Automate payments with the x402 client library

npm install @x402/fetch @x402/evm @x402/core viem

// go get github.com/x402-foundation/x402/go/v2 github.com/ethereum/go-ethereum

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    x402 "github.com/x402-foundation/x402/go/v2"
    x402http "github.com/x402-foundation/x402/go/v2/http"
    batchedclient "github.com/x402-foundation/x402/go/v2/mechanisms/evm/batch-settlement/client"
    evmsigners "github.com/x402-foundation/x402/go/v2/signers/evm"

    "github.com/ethereum/go-ethereum/ethclient"
)

const (
    swapQuoteURL = "https://api.1inch.com/swap/v6.0/1/quote" +
        "?amount=1000000000000000000" +
        "&src=0xEeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" +
        "&dst=0xdAC17F958D2ee523a2206206994597C13D831ec7" // settlement is on Base
    depositMultiplier = 8334 // ceil($2.00 / $0.00024). SDK default (5) is rejected.
    maxDeposits       = 5    // 5 × $2 = $10 cap on auto top-ups
    paidCalls         = 10
)

func main() {
    // Base mainnet RPC. The signer reads chain state for the deposit.
    ethClient, err := ethclient.Dial("https://mainnet.base.org")
    if err != nil {
        log.Fatal(err)
    }

    // Sign with the wallet you linked to your application in the Business Portal.
    signer, err := evmsigners.NewClientSignerFromPrivateKeyWithClient(os.Getenv("EVM_PRIVATE_KEY"), ethClient)
    if err != nil {
        log.Fatal(err)
    }

    deposits := 0
    // The 1inch gateway accepts ONLY the batch-settlement scheme.
    batchScheme := batchedclient.NewBatchSettlementEvmScheme(signer, &batchedclient.BatchSettlementEvmSchemeOptions{
        DepositMultiplier: depositMultiplier,
        // Called before each on-chain deposit (open and auto top-up). Stop at $10.
        DepositStrategy: func(_ context.Context, _ batchedclient.DepositStrategyContext) (batchedclient.DepositStrategyResult, error) {
            if deposits >= maxDeposits {
                return batchedclient.DepositStrategyResult{}, fmt.Errorf("refusing deposit: would exceed $10")
            }
            return batchedclient.DepositStrategyResult{}, nil
        },
    })
    client := x402.Newx402Client().Register("eip155:*", batchScheme)
    // Count deposits so the $10 cap and the "wait for finalization" step know when one happened.
    client.OnAfterPaymentCreation(func(ctx x402.PaymentCreatedContext) error {
        if ctx.Payload != nil && ctx.Payload.GetPayload()["type"] == "deposit" {
            deposits++
        }
        return nil
    })

    // http.Client that runs 402 challenge -> deposit/voucher -> retry for you.
    httpClient := x402http.WrapHTTPClientWithPayment(
        http.DefaultClient,
        x402http.Newx402HTTPClient(client),
    )

    for call := 1; call <= paidCalls; call++ {
        before := deposits
        req, err := http.NewRequest(http.MethodGet, swapQuoteURL, nil)
        if err != nil {
            log.Fatal(err)
        }

        resp, err := httpClient.Do(req)
        if err != nil {
            log.Fatal(err)
        }
        resp.Body.Close()
        fmt.Println("call", call, "HTTP", resp.StatusCode)
        if deposits > before {
            // First call (and later top-ups) settle on-chain. Wait before the next voucher.
            time.Sleep(3 * time.Second)
        }
    }
}

depositMultiplier >= ceil(minDeposit / per-request price)