Pay for one answer.
Keep the agent in bounds.

// voidpay-mainnet.mjs — Node.js 22+; real USDC on Base mainnet
import { pathToFileURL } from 'node:url';
import { CdpX402Client } from '@coinbase/cdp-sdk/x402';
import { wrapFetchWithPayment } from '@x402/fetch';

const RESOURCE = 'https://x402.voidly.ai/v1/verify-claim';
const BASE_USDC = process.env.BASE_MAINNET_USDC;
const PAY_TO = process.env.VOIDPAY_MAINNET_PAY_TO;
let attempted = false;

function newMainnetClient() {
  if (!BASE_USDC || !/^0x[0-9a-fA-F]{40}$/.test(BASE_USDC)) {
    throw new Error('Set BASE_MAINNET_USDC to the canonical Base mainnet USDC contract');
  }
  if (!PAY_TO || !/^0x[0-9a-fA-F]{40}$/.test(PAY_TO)) {
    throw new Error('Set VOIDPAY_MAINNET_PAY_TO from the reviewed 402 terms');
  }
  return new CdpX402Client({
    environment: 'production',
    spendControls: {
      maxAmountPerPayment: { atomic: 10_000n, asset: BASE_USDC },
      maxCumulativeSpend: { atomic: 10_000n, asset: BASE_USDC },
      maxCumulativeSpendWindow: '24h',
      allowedNetworks: ['eip155:8453'],
      allowedAssets: [BASE_USDC],
      allowedPayees: [PAY_TO],
    },
  });
}

export async function paymentTerms() {
  const response = await globalThis.fetch(RESOURCE, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ claim: 'A censorship claim to check' }),
  });
  if (response.status !== 402) throw new Error('Expected an unpaid 402 response');
  const encoded = response.headers.get('payment-required');
  if (!encoded) throw new Error('Missing PAYMENT-REQUIRED header');
  const challenge = JSON.parse(Buffer.from(encoded, 'base64').toString('utf8'));
  if (!Array.isArray(challenge.accepts)) throw new Error('Missing payment terms');
  return challenge.accepts.map(({ network, asset, amount, payTo }) => ({ network, asset, amount, payTo }));
}

export async function payingAddress() {
  const { evmAddress } = await newMainnetClient().getAddresses();
  return evmAddress;
}

export async function verifyClaim(claim) {
  const cleanClaim = String(claim).trim();
  if (!cleanClaim || [...cleanClaim].length > 500) {
    throw new Error('Claim must be 1–500 characters');
  }
  if (process.env.VOIDPAY_X402_AUTOPAY_ENABLED !== 'yes') {
    throw new Error('Operator must enable this example before an agent can pay');
  }
  if (attempted) throw new Error('This process already attempted one mainnet payment');
  const client = newMainnetClient();
  attempted = true; // Keep the latch even if the settlement outcome is unclear.
  const paidFetch = wrapFetchWithPayment(globalThis.fetch, client);
  const response = await paidFetch(RESOURCE, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ claim: cleanClaim }),
  });
  if (!response.ok) throw new Error('Gateway HTTP ' + response.status);
  return response.json();
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  if (process.argv[2] === '--terms') {
    console.log(JSON.stringify(await paymentTerms(), null, 2)); // Unpaid 402 only.
  } else if (process.argv[2] === '--address') {
    console.log(await payingAddress()); // May provision a CDP wallet; does not pay.
  } else {
    console.log(JSON.stringify(await verifyClaim(process.argv.slice(2).join(' ')), null, 2));
  }
}