x402 Payments

typescriptimport { createWalletClient, http, parseUnits } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const BASILISK_TREASURY = "YOUR_BASE_TREASURY_ADDRESS";
const API_URL = "https://basilisk-api.fly.dev";

async function payAndPost(endpoint: string, body: any) {
  // Step 1: Try the request — expect 402
  const firstTry = await fetch(`${API_URL}${endpoint}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "Bearer bsk_live_YOUR_KEY",
    },
    body: JSON.stringify(body),
  });

  if (firstTry.status !== 402) return firstTry.json();

  // Step 2: Parse payment requirements
  const { paymentRequirements } = await firstTry.json();
  const req = paymentRequirements.accepts.find(
    (a: any) => a.network === "base"
  );
  const amount = BigInt(req.maxAmountRequired);

  // Step 3: Sign USDC transfer
  const account = privateKeyToAccount(`0x${process.env.PRIVATE_KEY}`);
  const wallet = createWalletClient({
    account,
    chain: base,
    transport: http(),
  });

  const txHash = await wallet.writeContract({
    address: USDC_BASE as `0x${string}`,
    abi: [{
      name: "transfer",
      type: "function",
      inputs: [
        { name: "to", type: "address" },
        { name: "amount", type: "uint256" },
      ],
      outputs: [{ type: "bool" }],
    }],
    functionName: "transfer",
    args: [req.payTo as `0x${string}`, amount],
  });

  // Step 4: Retry with payment proof
  const payment = {
    x402Version: "0.1",
    scheme: "exact",
    network: "base",
    payload: {
      signature: txHash,
      amount: String(amount),
      asset: USDC_BASE,
      payTo: req.payTo,
      payer: account.address,
      nonce: crypto.randomUUID(),
      timestamp: Math.floor(Date.now() / 1000),
    },
  };

  const retry = await fetch(`${API_URL}${endpoint}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "Bearer bsk_live_YOUR_KEY",
      "X-Payment": JSON.stringify(payment),
    },
    body: JSON.stringify(body),
  });

  return retry.json();
}

typescriptimport {
  Connection, Keypair, PublicKey, Transaction,
} from "@solana/web3.js";
import {
  createTransferInstruction, getAssociatedTokenAddress,
} from "@solana/spl-token";

const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const TREASURY = new PublicKey("2pgTaqVHcDwhdzP1e4DR97iEXXxi4ufQPycvK7YS9h4w");

async function payViaSolana(endpoint: string, body: any, amountAtomic: number) {
  const connection = new Connection("https://api.mainnet-beta.solana.com");
  const payer = Keypair.fromSecretKey(/* your key */);

  const payerATA = await getAssociatedTokenAddress(USDC_MINT, payer.publicKey);
  const treasuryATA = await getAssociatedTokenAddress(USDC_MINT, TREASURY);

  const tx = new Transaction().add(
    createTransferInstruction(payerATA, treasuryATA, payer.publicKey, amountAtomic)
  );

  const sig = await connection.sendTransaction(tx, [payer]);
  await connection.confirmTransaction(sig, "confirmed");

  // Retry with payment proof
  const payment = {
    x402Version: "0.1",
    scheme: "exact",
    network: "solana",
    payload: {
      signature: sig,
      amount: String(amountAtomic),
      asset: USDC_MINT.toBase58(),
      payTo: TREASURY.toBase58(),
      payer: payer.publicKey.toBase58(),
      nonce: crypto.randomUUID(),
      timestamp: Math.floor(Date.now() / 1000),
    },
  };

  return fetch(`https://basilisk-api.fly.dev${endpoint}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "Bearer bsk_live_YOUR_KEY",
      "X-Payment": JSON.stringify(payment),
    },
    body: JSON.stringify(body),
  }).then(r => r.json());
}

typescript// Generic x402 payment wrapper for any agent
async function payableRequest(
  url: string,
  options: RequestInit,
  signer: (requirements: any) => Promise<string> // returns X-Payment JSON
): Promise<Response> {
  const res = await fetch(url, options);

  if (res.status !== 402) return res;

  // Parse payment requirements
  const body = await res.json();
  const requirements = body.paymentRequirements;

  // Sign payment using your wallet
  const paymentHeader = await signer(requirements);

  // Retry with payment
  return fetch(url, {
    ...options,
    headers: {
      ...Object.fromEntries(
        new Headers(options.headers).entries()
      ),
      "X-Payment": paymentHeader,
    },
  });
}