Buy scans as an agent

/** GeoCites x402 v1 example. Importing this module does not send requests or sign anything.
 * discoverScan() only asks for a quote. buyScan() authorizes a real USDC payment.
 * Supply your existing wallet signer; no private key is read, stored or printed here.
 */
const ORIGIN = "https://geo-cites.com";
const BASE_USDC = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
const types = { TransferWithAuthorization: [
  { name: "from", type: "address" }, { name: "to", type: "address" },
  { name: "value", type: "uint256" }, { name: "validAfter", type: "uint256" },
  { name: "validBefore", type: "uint256" }, { name: "nonce", type: "bytes32" },
] };

function post(path, input, fetchImpl, payment) {
  return fetchImpl(`${ORIGIN}${path}`, {
    method: "POST", redirect: "error",
    headers: { "Content-Type": "application/json", ...(payment ? { "X-Payment": payment } : {}) },
    body: JSON.stringify(input),
  });
}
async function challenge(path, input, fetchImpl) {
  const response = await post(path, input, fetchImpl);
  if (response.status !== 402) throw new Error(`Expected a 402 quote; received HTTP ${response.status}`);
  const body = await response.json();
  const requirement = body.accepts?.find((item) => item.scheme === "exact" && item.network === "base");
  if (!requirement) throw new Error("No supported Base exact-payment quote");
  return requirement;
}
export function discoverScan(input = { domain: "example.com", keyword: "crm software" }, fetchImpl = fetch) {
  return challenge("/api/a2a/scan", input, fetchImpl);
}
function atomicUsdc(amount) {
  if (typeof amount !== "string" || !/^\d+(\.\d{1,6})?$/.test(amount)) throw new Error("maxUsdc must be a decimal string with at most six decimal places");
  const [whole, fraction = ""] = amount.split(".");
  return BigInt(whole) * 1_000_000n + BigInt(fraction.padEnd(6, "0"));
}
async function authorize(requirement, signer, maxAtomic) {
  if (requirement.scheme !== "exact" || requirement.network !== "base" || requirement.asset?.toLowerCase() !== BASE_USDC
    || requirement.extra?.name !== "USD Coin" || requirement.extra?.version !== "2") {
    throw new Error("Unsupported token or signing domain; review the live AgentCard and challenge");
  }
  if (!/^0x[0-9a-fA-F]{40}$/.test(requirement.payTo) || /^0x0{40}$/i.test(requirement.payTo)) throw new Error("Invalid payment recipient");
  if (!/^\d+$/.test(requirement.maxAmountRequired)) throw new Error("Invalid quote amount");
  const amount = BigInt(requirement.maxAmountRequired);
  if (amount < 1n || amount > maxAtomic) throw new Error("Quote exceeds your explicit spending limit");
  const timeout = requirement.maxTimeoutSeconds;
  if (!Number.isSafeInteger(timeout) || timeout < 10 || timeout > 300) throw new Error("Unsupported authorization window");
  const now = Math.floor(Date.now() / 1000);
  const nonce = `0x${Array.from(crypto.getRandomValues(new Uint8Array(32)), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
  const authorization = { from: signer.address, to: requirement.payTo, value: requirement.maxAmountRequired,
    validAfter: String(now - 5), validBefore: String(now - 5 + timeout), nonce };
  const signature = await signer.signTypedData({
    domain: { name: requirement.extra.name, version: requirement.extra.version, chainId: 8453, verifyingContract: requirement.asset },
    types, primaryType: "TransferWithAuthorization",
    message: { ...authorization, value: amount, validAfter: BigInt(authorization.validAfter), validBefore: BigInt(authorization.validBefore) },
  });
  return { authorization, header: btoa(JSON.stringify({ x402Version: 1, scheme: "exact", network: "base", payload: { signature, authorization } })) };
}

/** This call signs and submits ONE paid scan. It never automatically retries a payment. */
export async function buyScan({ input, signer, maxUsdc, fetchImpl = fetch }) {
  const requirement = await discoverScan(input, fetchImpl);
  const signed = await authorize(requirement, signer, atomicUsdc(maxUsdc));
  const recovery = { payer: signer.address, nonce: signed.authorization.nonce, operation: "scan" };
  try {
    const response = await post("/api/a2a/scan", input, fetchImpl, signed.header);
    const scan = await response.json();
    recovery.scanId = scan.scanId ?? scan.id;
    const encoded = response.headers.get("X-Payment-Response") ?? response.headers.get("PAYMENT-RESPONSE");
    const payment = encoded ? JSON.parse(atob(encoded)) : null;
    if (!response.ok || payment?.success !== true || !payment.transaction) {
      throw new Error(`Payment/result not confirmed (HTTP ${response.status}); check your receipts before buying again`);
    }
    return { scan, payment, recovery };
  } catch (cause) {
    const error = new Error("Purchase outcome is uncertain. Keep recovery details and check receipts; do not automatically buy again", { cause });
    error.recovery = recovery;
    throw error;
  }
}

/** A fresh 1-micro-USDC proof, verified by GeoCites without settlement. A purchase signature is not a receipt-lookup proof. */
export async function readReceipts({ signer, fetchImpl = fetch }) {
  const path = "/api/a2a/my-receipts";
  const requirement = await challenge(path, {}, fetchImpl);
  const signed = await authorize(requirement, signer, 1n);
  const response = await post(path, {}, fetchImpl, signed.header);
  if (!response.ok) throw new Error(`Receipt lookup failed (HTTP ${response.status}); no purchase was retried`);
  return response.json();
}