x402 integration

interface X402Config {
  asset: string;
  network: string;
  payTo: string;
  facilitatorUrl: string;
  amount: string;
  facilitatorApiKey?: string;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const config: X402Config = {
      asset: env.SBC_TOKEN_ADDRESS,
      network: env.X402_NETWORK,
      payTo: env.MERCHANT_ADDRESS,
      facilitatorUrl: env.FACILITATOR_URL,
      amount: env.PAYMENT_AMOUNT,
      facilitatorApiKey: env.FACILITATOR_API_KEY,
    };
 
    const paymentSig = request.headers.get('PAYMENT-SIGNATURE');
 
    if (!paymentSig) {
      const paymentRequired = {
        x402Version: 2,
        error: 'PAYMENT-SIGNATURE header is required',
        resource: {
          url: request.url,
          description: 'Access to protected resource',
          mimeType: 'application/json',
        },
        accepts: [
          {
            scheme: 'exact',
            network: config.network,
            amount: config.amount,
            payTo: config.payTo,
            asset: config.asset,
            maxTimeoutSeconds: 300,
            extra: {
              assetTransferMethod: 'erc2612',
              name: 'Stable Coin',
              version: '1',
            },
          },
        ],
      };
 
      return new Response('{}', {
        status: 402,
        headers: {
          'Content-Type': 'application/json',
          'PAYMENT-REQUIRED': btoa(JSON.stringify(paymentRequired)),
        },
      });
    }
 
    const paymentPayload = JSON.parse(atob(paymentSig));
    const paymentRequirements = {
      scheme: 'exact',
      network: config.network,
      amount: config.amount,
      asset: config.asset,
      payTo: config.payTo,
      maxTimeoutSeconds: 300,
      extra: { name: 'Stable Coin', version: '1' },
    };
 
    const verifyRes = await fetch(`${config.facilitatorUrl}/verify`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        ...(config.facilitatorApiKey ? { 'x-api-key': config.facilitatorApiKey } : {}),
      },
      body: JSON.stringify({ x402Version: 2, paymentPayload, paymentRequirements }),
    });
 
    if (!verifyRes.ok) {
      const err = await verifyRes.json<{ error: string }>();
      return new Response(JSON.stringify({ error: err.error ?? 'Verification failed' }), { status: 402, headers: { 'Content-Type': 'application/json' } });
    }
 
    const settleRes = await fetch(`${config.facilitatorUrl}/settle`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        ...(config.facilitatorApiKey ? { 'x-api-key': config.facilitatorApiKey } : {}),
      },
      body: JSON.stringify({ x402Version: 2, paymentPayload, paymentRequirements }),
    });
 
    if (!settleRes.ok) {
      const err = await settleRes.json<{ error: string }>();
      return new Response(JSON.stringify({ error: err.error ?? 'Settlement failed' }), { status: 402, headers: { 'Content-Type': 'application/json' } });
    }
 
    const result = await settleRes.json<{ success: boolean; transaction: string; payer: string; network: string }>();
 
    return new Response(JSON.stringify({ data: 'protected resource payload' }), {
      status: 200,
      headers: {
        'Content-Type': 'application/json',
        'PAYMENT-RESPONSE': btoa(JSON.stringify(result)),
      },
    });
  },
};

HTTP/1.1 402 Payment Required
Content-Type: application/json
PAYMENT-REQUIRED: eyJ4NDAyVmVyc2lvbiI6MiwiZXJyb3IiOi...(base64)
 
{}

{
  "x402Version": 2,
  "error": "PAYMENT-SIGNATURE header is required",
  "resource": {
    "url": "https://api.example.com/premium/report",
    "description": "Access to /premium/report",
    "mimeType": "application/json"
  },
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:723487",
      "amount": "100000",
      "payTo": "0x{{MERCHANT_ADDRESS}}",
      "asset": "0x33ad9e4bd16b69b5bfded37d8b5d9ff9aba014fb",
      "maxTimeoutSeconds": 300,
      "extra": {
        "assetTransferMethod": "erc2612",
        "name": "Stable Coin",
        "version": "1"
      }
    }
  ]
}

{
  "x402Version": 2,
  "resource": {
    "url": "https://api.example.com/premium/report",
    "description": "Access to /premium/report",
    "mimeType": "application/json"
  },
  "accepted": {
    "scheme": "exact",
    "network": "eip155:723487",
    "amount": "100",
    "asset": "0x33ad9e4bd16b69b5bfded37d8b5d9ff9aba014fb",
    "payTo": "0x{{MERCHANT_ADDRESS}}",
    "maxTimeoutSeconds": 300,
    "extra": {
      "assetTransferMethod": "erc2612",
      "name": "Stable Coin",
      "version": "1"
    }
  },
  "payload": {
    "signature": "0x...",
    "authorization": {
      "from": "0x{{PAYER_ADDRESS}}",
      "to": "0x{{MERCHANT_ADDRESS}}",
      "value": "100",
      "validAfter": "0",
      "validBefore": "115792089237316195423570985008687907853269984665640564039457584007913129639935",
      "nonce": "0x..."
    }
  }
}

{
  "x402Version": 2,
  "paymentPayload": {
    "x402Version": 2,
    "resource": {
      "url": "https://api.example.com/premium/report",
      "description": "Access to /premium/report",
      "mimeType": "application/json"
    },
    "accepted": {
      "scheme": "exact",
      "network": "eip155:723487",
      "amount": "100",
      "asset": "0x33ad9e4bd16b69b5bfded37d8b5d9ff9aba014fb",
      "payTo": "0x{{MERCHANT_ADDRESS}}",
      "maxTimeoutSeconds": 300,
      "extra": {
        "assetTransferMethod": "erc2612",
        "name": "Stable Coin",
        "version": "1"
      }
    },
    "payload": {
      "signature": "0x...",
      "authorization": {
        "from": "0x{{PAYER_ADDRESS}}",
        "to": "0x{{MERCHANT_ADDRESS}}",
        "value": "100",
        "validAfter": "0",
        "validBefore": "115792089237316195423570985008687907853269984665640564039457584007913129639935",
        "nonce": "0x..."
      }
    }
  },
  "paymentRequirements": {
    "scheme": "exact",
    "network": "eip155:723487",
    "amount": "100",
    "asset": "0x33ad9e4bd16b69b5bfded37d8b5d9ff9aba014fb",
    "payTo": "0x{{MERCHANT_ADDRESS}}",
    "maxTimeoutSeconds": 300,
    "extra": { "name": "Stable Coin", "version": "1" }
  }
}

import { createWalletClient, createPublicClient, http, type Address, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
 
/** The decoded client payload from the PAYMENT-SIGNATURE header. */
interface X402ClientPayload {
  payload: {
    authorization: {
      from: Address;
      to: Address;
      value: string;
      validAfter: string;
      validBefore: string;
      nonce: string;
    };
    signature: Hex;
  };
}
 
/** Input to the custom on-chain settlement function (for self-hosted facilitators, not the hosted facilitator request format). */
interface X402FacilitatorRequest {
  payload: {
    scheme: string;
    from: Address;
    to: Address;
    value: string;
    validAfter: string;
    validBefore: string;
    nonce: string;
  };
  requirements: {
    tokenAddress: Address;
    amount: string;
    recipient: Address;
    network: string;
  };
  signature: Hex;
}
 
/** Split a 65-byte hex signature into v, r, s for EVM permit calls. */
function splitSignature(sig: Hex): { v: number; r: Hex; s: Hex } {
  const raw = sig.startsWith('0x') ? sig.slice(2) : sig;
  return {
    r: `0x${raw.slice(0, 64)}` as Hex,
    s: `0x${raw.slice(64, 128)}` as Hex,
    v: parseInt(raw.slice(128, 130), 16),
  };
}
 
const SBC_ABI = [
  {
    name: 'permit',
    type: 'function',
    inputs: [
      { name: 'owner', type: 'address' },
      { name: 'spender', type: 'address' },
      { name: 'value', type: 'uint256' },
      { name: 'deadline', type: 'uint256' },
      { name: 'v', type: 'uint8' },
      { name: 'r', type: 'bytes32' },
      { name: 's', type: 'bytes32' },
    ],
    outputs: [],
    stateMutability: 'nonpayable',
  },
  {
    name: 'transferFrom',
    type: 'function',
    inputs: [
      { name: 'from', type: 'address' },
      { name: 'to', type: 'address' },
      { name: 'value', type: 'uint256' },
    ],
    outputs: [{ name: '', type: 'bool' }],
    stateMutability: 'nonpayable',
  },
] as const;
 
async function settlePayment(request: X402FacilitatorRequest, asset: Address, settlementKey: Hex, rpcUrl: string): Promise<{ payer: Address; txHash: Hex }> {
  const publicClient = createPublicClient({ transport: http(rpcUrl) });
  const account = privateKeyToAccount(settlementKey);
  const walletClient = createWalletClient({
    transport: http(rpcUrl),
    account,
  });
 
  const { from, to, value, validBefore } = request.payload;
  const deadline = BigInt(validBefore);
  const amount = BigInt(value);
  const now = BigInt(Math.floor(Date.now() / 1000));
 
  if (deadline < now) {
    throw new Error('Permit deadline has expired');
  }
 
  if (amount <= 0n) {
    throw new Error('Payment value must be greater than zero');
  }
 
  // Split the single hex signature into v, r, s for the permit() call
  const { v, r, s } = splitSignature(request.signature);
 
  const permitHash = await walletClient.writeContract({
    address: asset,
    abi: SBC_ABI,
    functionName: 'permit',
    args: [from, to, amount, deadline, v, r, s],
  });
 
  await publicClient.waitForTransactionReceipt({ hash: permitHash });
 
  const transferHash = await walletClient.writeContract({
    address: asset,
    abi: SBC_ABI,
    functionName: 'transferFrom',
    args: [from, to, amount],
  });
 
  const receipt = await publicClient.waitForTransactionReceipt({
    hash: transferHash,
  });
 
  if (receipt.status !== 'success') {
    throw new Error(`Settlement transaction reverted: ${transferHash}`);
  }
 
  return { payer: from, txHash: transferHash };
}

import { createPublicClient, createWalletClient, http, type Address, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
 
interface Env {
  MERCHANT_ADDRESS: string;
  SETTLEMENT_KEY: string; // Private key of the wallet that submits permit + transferFrom
}
 
const SBC_TOKEN: Address = '0x33ad9e4bd16b69b5bfded37d8b5d9ff9aba014fb';
const RADIUS_RPC = 'https://rpc.radiustech.xyz';
const NETWORK = 'eip155:723487';
const PRICE = '100'; // 0.0001 SBC per request
 
const SBC_ABI = [
  {
    name: 'permit',
    type: 'function',
    inputs: [
      { name: 'owner', type: 'address' },
      { name: 'spender', type: 'address' },
      { name: 'value', type: 'uint256' },
      { name: 'deadline', type: 'uint256' },
      { name: 'v', type: 'uint8' },
      { name: 'r', type: 'bytes32' },
      { name: 's', type: 'bytes32' },
    ],
    outputs: [],
    stateMutability: 'nonpayable',
  },
  {
    name: 'transferFrom',
    type: 'function',
    inputs: [
      { name: 'from', type: 'address' },
      { name: 'to', type: 'address' },
      { name: 'value', type: 'uint256' },
    ],
    outputs: [{ name: '', type: 'bool' }],
    stateMutability: 'nonpayable',
  },
] as const;
 
function splitSignature(sig: Hex): { v: number; r: Hex; s: Hex } {
  const raw = sig.startsWith('0x') ? sig.slice(2) : sig;
  return {
    r: `0x${raw.slice(0, 64)}` as Hex,
    s: `0x${raw.slice(64, 128)}` as Hex,
    v: parseInt(raw.slice(128, 130), 16),
  };
}
 
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const paymentHeader = request.headers.get('PAYMENT-SIGNATURE');
 
    // No payment — return 402 with requirements
    if (!paymentHeader) {
      const paymentRequired = {
        x402Version: 2,
        error: 'PAYMENT-SIGNATURE header is required',
        resource: {
          url: request.url,
          description: 'Access to paid endpoint',
          mimeType: 'application/json',
        },
        accepts: [
          {
            scheme: 'exact',
            network: NETWORK,
            amount: PRICE,
            payTo: env.MERCHANT_ADDRESS,
            maxTimeoutSeconds: 300,
            asset: SBC_TOKEN,
            extra: {
              assetTransferMethod: 'erc2612',
              name: 'Stable Coin',
              version: '1',
            },
          },
        ],
      };
 
      return new Response('{}', {
        status: 402,
        headers: {
          'Content-Type': 'application/json',
          'PAYMENT-REQUIRED': btoa(JSON.stringify(paymentRequired)),
        },
      });
    }
 
    // Decode the client payload (nested authorization + signature)
    let clientPayload: any;
    try {
      clientPayload = JSON.parse(atob(paymentHeader));
    } catch {
      return Response.json({ error: 'Invalid payment header' }, { status: 400 });
    }
 
    const auth = clientPayload?.payload?.authorization;
    const signature = clientPayload?.payload?.signature as Hex;
    if (!auth || !signature) {
      return Response.json({ error: 'Missing authorization or signature' }, { status: 400 });
    }
 
    // Validate fields
    const deadline = BigInt(auth.validBefore);
    const amount = BigInt(auth.value);
    const now = BigInt(Math.floor(Date.now() / 1000));
 
    if (deadline < now) {
      return Response.json({ error: 'Permit expired' }, { status: 402 });
    }
    if (amount < BigInt(PRICE)) {
      return Response.json({ error: 'Insufficient payment amount' }, { status: 402 });
    }
 
    // Settle directly on Radius — no external facilitator
    const publicClient = createPublicClient({ transport: http(RADIUS_RPC) });
    const account = privateKeyToAccount(env.SETTLEMENT_KEY as Hex);
    const walletClient = createWalletClient({
      transport: http(RADIUS_RPC),
      account,
    });
 
    const { v, r, s } = splitSignature(signature);
 
    try {
      // Step 1: permit() — grant allowance from payer to settlement wallet
      const permitHash = await walletClient.writeContract({
        address: SBC_TOKEN,
        abi: SBC_ABI,
        functionName: 'permit',
        args: [
          auth.from as Address, // owner (authorization.from)
          auth.to as Address, // spender (authorization.to)
          amount, // value
          deadline, // deadline (authorization.validBefore)
          v,
          r,
          s,
        ],
      });
      await publicClient.waitForTransactionReceipt({ hash: permitHash });
 
      // Step 2: transferFrom() — move tokens from payer to merchant
      const transferHash = await walletClient.writeContract({
        address: SBC_TOKEN,
        abi: SBC_ABI,
        functionName: 'transferFrom',
        args: [auth.from as Address, env.MERCHANT_ADDRESS as Address, amount],
      });
      const receipt = await publicClient.waitForTransactionReceipt({ hash: transferHash });
 
      if (receipt.status !== 'success') {
        return Response.json({ error: 'Settlement reverted' }, { status: 502 });
      }
 
      // Payment settled — serve the resource
      const paymentResponse = {
        success: true,
        transaction: transferHash,
        network: NETWORK,
        payer: auth.from,
      };
 
      return Response.json(
        { data: 'paid content' },
        {
          status: 200,
          headers: {
            'PAYMENT-RESPONSE': btoa(JSON.stringify(paymentResponse)),
          },
        },
      );
    } catch (e: any) {
      return Response.json({ error: 'Settlement failed', detail: e.message }, { status: 502 });
    }
  },
};