Beacon Cloud

async fn verify_base(
    txn_hash: &str,
    expected_amount: f64,
    expected_address: &str,
) -> Result<bool> {
    let rpc_url = std::env::var("BASE_RPC_URL")
        .unwrap_or_else(|_| "https://mainnet.base.org".to_string());
    let provider = Provider::<Http>::try_from(rpc_url)?;
    let hash = H256::from_str(txn_hash)?;
    let receipt = provider.get_transaction_receipt(hash).await?
        .context("Transaction receipt not found")?;
    
    // Check transaction succeeded
    if receipt.status != Some(1.into()) {
        return Ok(false);
    }
    
    // Verify USDC transfer to correct address
    let usdc_addr = Address::from_str(BASE_USDC)?;
    let receiver_addr = Address::from_str(expected_address)?;
    let transfer_topic = H256::from_str(
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    )?; // Transfer(address,address,uint256)
    
    for log in receipt.logs {
        if log.address == usdc_addr && log.topics[0] == transfer_topic {
            let to = Address::from_slice(&log.topics[2][12..]);
            if to == receiver_addr {
                let value = U256::from_big_endian(&log.data);
                let amount_f64 = value.as_u128() as f64 / 1_000_000.0; // USDC has 6 decimals
                if (amount_f64 - expected_amount).abs() < 0.001 {
                    return Ok(true);
                }
            }
        }
    }
    Ok(false)
}

async fn verify_solana(
    txn_hash: &str,
    expected_amount: f64,
    expected_address: &str,
) -> Result<bool> {
    let rpc_url = std::env::var("SOLANA_RPC_URL")
        .unwrap_or_else(|_| "https://api.mainnet-beta.solana.com".to_string());
    let client = reqwest::Client::new();
    let resp = client.post(rpc_url)
        .json(&json!({
            "jsonrpc": "2.0",
            "id": 1,
            "method": "getTransaction",
            "params": [
                txn_hash,
                { "encoding": "json", "maxSupportedTransactionVersion": 0 }
            ]
        }))
        .send().await?.json::<Value>().await?;
    
    let meta = &resp["result"]["meta"];
    let pre = meta["preTokenBalances"].as_array()?;
    let post = meta["postTokenBalances"].as_array()?;
    
    // Find USDC balance change for recipient
    let mut pre_val = 0.0;
    for b in pre {
        if b["mint"] == SOLANA_USDC && b["owner"] == expected_address {
            pre_val = b["uiTokenAmount"]["uiAmount"].as_f64().unwrap_or(0.0);
        }
    }
    
    let mut post_val = 0.0;
    for b in post {
        if b["mint"] == SOLANA_USDC && b["owner"] == expected_address {
            post_val = b["uiTokenAmount"]["uiAmount"].as_f64().unwrap_or(0.0);
        }
    }
    
    if (post_val - pre_val - expected_amount).abs() < 0.001 {
        return Ok(true);
    }
    Ok(false)
}

# Generate with Beacon Cloud
beacon generate ./my-project --provider beacon-ai-cloud

# Follow interactive prompts:
# 1. Choose chain (base/solana)
# 2. Send USDC to provided address
# 3. Paste transaction hash
# 4. Wait for verification

if db::payment_already_used(txn).await.unwrap_or(false) {
    return Err(BeaconError::TransactionAlreadyUsed);
}

if (amount_f64 - expected_amount).abs() < 0.001 {
    return Ok(true);
}

if to == receiver_addr {
    // Payment verified
}

# Check transaction on block explorer
# Base: https://basescan.org/tx/<hash>
# Solana: https://solscan.io/tx/<hash>

# Verify:
# 1. Transaction succeeded (not failed/pending)
# 2. Sent exactly 0.09 USDC (not 0.09 ETH or SOL)
# 3. Recipient address matches provided address

Error: TransactionAlreadyUsed

# Set wallet addresses
export BEACON_WALLET_BASE="0xYourBaseAddress"
export BEACON_WALLET_SOLANA="YourSolanaAddress"
export PAYMENT_AMOUNT_USDC="0.09"

# Set RPC URLs
export BASE_RPC_URL="https://mainnet.base.org"
export SOLANA_RPC_URL="https://api.mainnet-beta.solana.com"

# Start server
beacon serve --port 8080