across-pay-x402 1.0.0

package/.env.example

@@ -0,0 +1,7 @@
+CDP_API_KEY_ID=your_cdp_api_key_id
+CDP_API_KEY_SECRET=your_cdp_api_key_secret
+CDP_WALLET_SECRET=your_cdp_wallet_secret
+# Buyer wallet is now a CDP server wallet — no local private key needed.
+# The wallet is created/retrieved automatically via cdp.evm.getOrCreateAccount().
+MERCHANT_KEY=0xyour_merchant_private_key
+PORT=4021

package/HANDOVER.md

@@ -0,0 +1,56 @@
+# x402 Coinbase Buyer Demo Handover
+
+This workspace exists to prototype **x402 + Across on mainnet** alongside the MPP buyer demo.
+
+## Goal
+
+Mirror the current MPP demo flow with x402:
+
+1. Buyer requests a paid resource.
+2. If buyer lacks funds on the merchant's destination chain, Across bridges the shortfall to the buyer's own address.
+3. The standard x402 payment flow completes.
+4. The merchant sees a normal x402 payment.
+
+## Safety Rules
+
+- Keep protocol-specific logic in x402 packages where possible.
+- Keep Across responsible only for pre-funding and bridge orchestration.
+- Bridge to the buyer's own address, never directly to the merchant.
+
+## Intended Scope
+
+- Local Hono-based x402 seller on Base mainnet settings
+- x402 buyer using official x402 packages
+- Across pre-funding wrapper for the buyer flow
+  - `demo`: strict preferred-chain fast path for Base-funded demos
+  - `dynamic`: parallel funded-route discovery with quote-based tie-breaking
+- Reporting/proof output similar to the current MPP prototype
+
+## Deliverables
+
+- `src/dev/server.ts`: local x402 seller
+- `src/buyer/x402-with-across.ts`: buyer wrapper
+- `src/demo/run.ts`: end-to-end demo script
+- `src/dev/preflight.ts`: env/config validation
+- `src/buyer/across.ts`: Across helpers
+- `src/buyer/balance.ts`: ERC-20 balance helpers
+- `src/buyer/coinbase-wallet.ts`: Coinbase-shaped wallet adapter
+
+## Environment Expectations
+
+- `CDP_API_KEY_ID`
+- `CDP_API_KEY_SECRET`
+- `COINBASE_AGENT_WALLET_PRIVATE_KEY` (preferred)
+- `AGENT_PRIVATE_KEY` (legacy fallback)
+- `MERCHANT_KEY`
+- `PORT`
+- local secrets should live in `.env.local` only
+- optional `MODE=demo|dynamic`
+- optional origin-chain / RPC overrides
+
+## Recommended Build Order
+
+1. Prove plain x402 against the local seller.
+2. Add Across pre-funding to the buyer flow.
+3. Verify direct-payment and bridge-payment paths.
+4. Compare with the MPP buyer demo and only then extract shared funding logic.

package/README.md

@@ -0,0 +1,48 @@
+# x402 Coinbase Buyer Demo
+
+Coinbase-first x402 buyer demo with Across pre-funding.
+
+## What Lives Here
+
+- `src/buyer/` contains the x402 buyer flow and Across funding logic.
+- `src/demo/` contains the runnable buyer demo entrypoint.
+- `src/dev/` contains local-only helpers and the local x402 seller.
+
+## Wallet Surface
+
+The demo uses a **Coinbase CDP server wallet** via `@coinbase/cdp-sdk`. The buyer's private key never leaves Coinbase infrastructure — signing happens via the CDP API.
+
+The wallet is resolved through `src/buyer/coinbase-wallet.ts`, which calls `cdp.evm.getOrCreateAccount({ name: 'x402-buyer' })` to create or retrieve a persistent server-managed wallet.
+
+## Environment
+
+- `CDP_API_KEY_ID` — CDP API key ID
+- `CDP_API_KEY_SECRET` — CDP API key secret
+- `CDP_WALLET_SECRET` — CDP wallet secret (required for signing)
+- `MERCHANT_KEY` — merchant private key (local seller only)
+- `PORT`
+
+Create a local `.env.local` in this folder:
+
+```bash
+cp .env.example .env.local
+```
+
+## Commands
+
+```bash
+npm install
+npm run preflight
+npm run demo:local
+npm run demo:local:strict
+npm run demo:external
+npm run dev:server
+```
+
+## Notes
+
+- Mainnet target is Base (`eip155:8453`).
+- The x402 seller requires CDP credentials for verify and settlement.
+- The buyer does not reimplement x402; it funds first, then lets the x402 SDK create the payment payload and replay the request.
+- `demo:local` uses the local seller by default.
+- `demo:external` targets the CoinGecko x402 endpoint.

package/TEST-RESULTS.md

@@ -0,0 +1,74 @@
+# Test Results
+
+All x402 test runs and attempts.
+
+---
+
+### x402 Test Attempt (tooling startup failure)
+- **Time:** 2026-03-25 (exact time not captured)
+- **Target:** `https://pro-api.coingecko.com/api/v3/x402/simple/price?vs_currencies=usd&symbols=btc,eth,sol`
+- **Mode:** dynamic
+- **Force bridge:** no
+- **Configured origin chain:** 42161
+- **Buyer:** unknown
+- **Result:** ERROR
+- **Status:** N/A
+- **Start balances:** N/A
+- **End balances:** N/A
+- **Balance delta:** N/A
+- **Bridge info:** None
+- **Payment response:** None
+- **Explorer links:**
+- none
+- **Response body:** None
+- **Error:** `tsx/esbuild startup failure: Cannot start service: Host version "0.27.4" does not match binary version "0.25.0"`
+
+---
+
+### x402 Crosschain Test (CoinGecko)
+- **Time:** 2026-03-25 (exact time not captured)
+- **Target:** `https://pro-api.coingecko.com/api/v3/x402/simple/price?vs_currencies=usd&symbols=btc,eth,sol`
+- **Mode:** dynamic
+- **Force bridge:** no
+- **Configured origin chain:** 42161
+- **Buyer:** `0x6a568A616dAB0a8F092139Dd64663772c180170b`
+- **Result:** SUCCESS (via Across bridge)
+- **Status:** 200 OK
+- **Start balances:** Base ETH 0.010867872626366225, Base USDC 0
+- **End balances:** Base ETH 0.010867872626366225, Base USDC 0.01
+- **Balance delta:** Base ETH +0, Base USDC +0.01
+- **Bridge info:** `{"used":true,"forced":false,"originChainId":42161,"destinationChainId":8453,"inputToken":"0xaf88d065e77c8cC2239327C5EDb3A432268e5831","outputToken":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","inputAmount":"23100","destinationAmount":"10000","depositTxHash":"0xc6150f176cf7b764224e44f44686de0067446bb1a59a990260c6b488ef51bc47","fillTxHash":"0x86b0eae59f7994ce3a03e9dd0d2de47c595093656c9a514b26a3ddf7736596ad"}`
+- **Payment response:** `{"success":true,"transaction":"0x11ed6caece735d8b6b3f8706014eefee63d43d77460b29bffc30ec34f2c2ab6f","network":"eip155:8453","payer":"0x6a568A616dAB0a8F092139Dd64663772c180170b","errorReason":null}`
+- **Explorer links:**
+- buyerBase: https://basescan.org/address/0x6a568A616dAB0a8F092139Dd64663772c180170b
+- bridgeDeposit: https://arbiscan.io/tx/0xc6150f176cf7b764224e44f44686de0067446bb1a59a990260c6b488ef51bc47
+- acrossTransfer: https://app.across.to/transfer/0xc6150f176cf7b764224e44f44686de0067446bb1a59a990260c6b488ef51bc47
+- bridgeFill: https://basescan.org/tx/0x86b0eae59f7994ce3a03e9dd0d2de47c595093656c9a514b26a3ddf7736596ad
+- payment: https://basescan.org/tx/0x11ed6caece735d8b6b3f8706014eefee63d43d77460b29bffc30ec34f2c2ab6f
+- **Response body:** `{"btc":{"usd":70867},"eth":{"usd":2164.35},"sol":{"usd":91.9}}`
+- **Error:** None
+
+---
+
+### x402 Buyer Demo (CoinGecko)
+- **Time:** 2026-03-31T14:54:58.892Z
+- **Target:** https://pro-api.coingecko.com/api/v3/x402/simple/price?vs_currencies=usd&symbols=btc,eth,sol
+- **Mode:** dynamic
+- **Force bridge:** no
+- **Configured origin chain:** auto
+- **Buyer:** `0xE17725B0824E93Ab61706A506a4785A7312Cbe06`
+- **Result:** SUCCESS (via Across bridge)
+- **Status:** 200 OK
+- **Start balances:** Base ETH 0, Base USDC 0
+- **End balances:** Base ETH 0, Base USDC 0.02
+- **Balance delta:** Base ETH +0, Base USDC +0.02
+- **Bridge info:** `{"used":true,"forced":false,"originChainId":42161,"destinationChainId":8453,"inputToken":"0xaf88d065e77c8cC2239327C5EDb3A432268e5831","outputToken":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","inputAmount":"23604","destinationAmount":"10000","depositTxHash":"0xad1d552dd770efebf2e50a8fc9d70877daef2493c72829ad18218d05e0352006","fillTxHash":"0xeceac8278df0fef6444b29804ad6549b420b0bbf59a21f09cec0facc97bb1446"}`
+- **Payment response:** `{"success":true,"transaction":"0x68f2496cad62ce86a6c0574bfaa3fad72c3b9fd5d080dfb5818bb8dd6e89e2e2","network":"eip155:8453","payer":"0xE17725B0824E93Ab61706A506a4785A7312Cbe06","errorReason":null}`
+- **Explorer links:**
+- payment: https://basescan.org/tx/0x68f2496cad62ce86a6c0574bfaa3fad72c3b9fd5d080dfb5818bb8dd6e89e2e2
+- buyerBase: https://basescan.org/address/0xE17725B0824E93Ab61706A506a4785A7312Cbe06
+- bridgeDeposit: https://arbiscan.io/tx/0xad1d552dd770efebf2e50a8fc9d70877daef2493c72829ad18218d05e0352006
+- acrossTransfer: https://app.across.to/transfer/0xad1d552dd770efebf2e50a8fc9d70877daef2493c72829ad18218d05e0352006
+- bridgeFill: https://basescan.org/tx/0xeceac8278df0fef6444b29804ad6549b420b0bbf59a21f09cec0facc97bb1446
+- **Response body:** `{"btc":{"usd":66535},"eth":{"usd":2041.4},"sol":{"usd":80.95}}`
+- **Error:** None

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "across-pay-x402",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Crosschain x402 payments via Across Protocol. Bridge from any chain, pay on Base.",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "dev:server": "node --env-file-if-exists=.env.local --experimental-strip-types src/dev/server.ts",
+    "demo:local": "MODE=dynamic node --env-file-if-exists=.env.local --experimental-strip-types src/demo/run.ts",
+    "demo:local:strict": "MODE=demo node --env-file-if-exists=.env.local --experimental-strip-types src/demo/run.ts",
+    "demo:external": "MODE=dynamic TEST_URL='https://pro-api.coingecko.com/api/v3/x402/simple/price?vs_currencies=usd&symbols=btc,eth,sol' node --env-file-if-exists=.env.local --experimental-strip-types src/demo/run.ts",
+    "preflight": "node --env-file-if-exists=.env.local --experimental-strip-types src/dev/preflight.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@coinbase/x402": "^2.1.0",
+    "@hono/node-server": "^1.19.11",
+    "@types/node": "^25.5.0",
+    "@x402/core": "^2.8.0",
+    "@x402/evm": "^2.8.0",
+    "@x402/fetch": "^2.8.0",
+    "@x402/hono": "^2.8.0",
+    "esbuild": "^0.27.4",
+    "hono": "^4.12.9",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "viem": "^2.47.6"
+  }
+}

package/src/buyer/across.ts

@@ -0,0 +1,154 @@
+/**
+ * Across Protocol API helpers for dynamic EVM destination chains.
+ */
+
+const ACROSS_API = 'https://app.across.to/api'
+
+export const DEFAULT_RPCS: Record<number, string> = {
+  1: 'https://eth.llamarpc.com',
+  10: 'https://mainnet.optimism.io',
+  56: 'https://bsc-dataseed.binance.org',
+  137: 'https://polygon-rpc.com',
+  324: 'https://mainnet.era.zksync.io',
+  8453: 'https://mainnet.base.org',
+  42161: 'https://arb1.arbitrum.io/rpc',
+  59144: 'https://rpc.linea.build',
+  534352: 'https://rpc.scroll.io',
+}
+
+export const DEFAULT_ORIGIN_CHAINS = [42161, 10, 137, 1, 8453]
+
+export interface AcrossRoute {
+  originChainId: number
+  originToken: string
+  originTokenSymbol: string
+  destinationChainId: number
+  destinationToken: string
+  destinationTokenSymbol: string
+}
+
+export interface AcrossQuote {
+  inputAmount: string
+  expectedOutputAmount: string
+  minOutputAmount: string
+  expectedFillTime: number
+  approvalTxns: Array<{ chainId: number; to: string; data: string }>
+  swapTx: {
+    chainId: number
+    to: string
+    data: string
+    gas: string
+    simulationSuccess: boolean
+  }
+  fees: {
+    total: { amount: string; amountUsd: string }
+  }
+  id: string
+}
+
+export interface DepositStatus {
+  status: 'pending' | 'filled' | 'expired'
+  fillTx?: string
+  destinationChainId?: number
+  outputAmount?: string
+}
+
+export function parseEip155ChainId(network: string): number {
+  const match = network.match(/^eip155:(\d+)$/)
+  if (!match) {
+    throw new Error(`Unsupported network format: ${network}. Expected eip155:<chainId>`)
+  }
+
+  return Number(match[1])
+}
+
+export async function findRoutes(
+  destinationChainId: number,
+  outputToken: string,
+  fetchImpl: typeof globalThis.fetch = globalThis.fetch,
+): Promise<AcrossRoute[]> {
+  const url = new URL(`${ACROSS_API}/available-routes`)
+  url.searchParams.set('destinationChainId', destinationChainId.toString())
+
+  const response = await fetchImpl(url.toString())
+  if (!response.ok) {
+    return []
+  }
+
+  const routes = (await response.json()) as AcrossRoute[]
+  return routes.filter(
+    (route) => route.destinationToken.toLowerCase() === outputToken.toLowerCase(),
+  )
+}
+
+export async function findRoute(
+  originChainId: number,
+  destinationChainId: number,
+  outputToken: string,
+  fetchImpl: typeof globalThis.fetch = globalThis.fetch,
+): Promise<AcrossRoute | null> {
+  const routes = await findRoutes(destinationChainId, outputToken, fetchImpl)
+  return routes.find((route) => route.originChainId === originChainId) ?? null
+}
+
+export async function getQuote(
+  params: {
+    originChainId: number
+    destinationChainId: number
+    inputToken: string
+    outputToken: string
+    amount: string
+    depositor: string
+    recipient: string
+  },
+  fetchImpl: typeof globalThis.fetch = globalThis.fetch,
+): Promise<AcrossQuote> {
+  const url = new URL(`${ACROSS_API}/swap/approval`)
+
+  url.searchParams.set('originChainId', params.originChainId.toString())
+  url.searchParams.set('destinationChainId', params.destinationChainId.toString())
+  url.searchParams.set('inputToken', params.inputToken)
+  url.searchParams.set('outputToken', params.outputToken)
+  url.searchParams.set('amount', params.amount)
+  url.searchParams.set('depositor', params.depositor)
+  url.searchParams.set('recipient', params.recipient)
+  url.searchParams.set('tradeType', 'exactOutput')
+
+  const response = await fetchImpl(url.toString())
+  if (!response.ok) {
+    throw new Error(`Across quote failed (${response.status}): ${await response.text()}`)
+  }
+
+  return (await response.json()) as AcrossQuote
+}
+
+export async function waitForFill(
+  depositTxHash: string,
+  originChainId: number,
+  fetchImpl: typeof globalThis.fetch = globalThis.fetch,
+  timeoutMs = 120_000,
+  pollIntervalMs = 2_000,
+): Promise<DepositStatus> {
+  const start = Date.now()
+
+  while (Date.now() - start < timeoutMs) {
+    const url = new URL(`${ACROSS_API}/deposit/status`)
+    url.searchParams.set('originChainId', originChainId.toString())
+    url.searchParams.set('depositTxHash', depositTxHash)
+
+    const response = await fetchImpl(url.toString())
+    if (response.ok) {
+      const status = (await response.json()) as DepositStatus
+      if (status.status === 'filled') {
+        return status
+      }
+      if (status.status === 'expired') {
+        throw new Error('Across deposit expired without fill')
+      }
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs))
+  }
+
+  throw new Error(`Across fill timed out after ${timeoutMs / 1000}s`)
+}

package/src/buyer/balance.ts

@@ -0,0 +1,57 @@
+/**
+ * Generic ERC-20 balance helpers for x402 EVM flows.
+ */
+import { createPublicClient, erc20Abi, http, type Address } from 'viem'
+import { DEFAULT_RPCS, type AcrossRoute } from './across.ts'
+
+function publicRpc(chainId: number): string {
+  return DEFAULT_RPCS[chainId] ?? `https://lb.drpc.org/ogrpc?network=${chainId}`
+}
+
+export function getRpc(chainId: number, rpcs: Record<number, string> = {}): string {
+  return rpcs[chainId] ?? publicRpc(chainId)
+}
+
+export async function getErc20Balance(
+  address: string,
+  token: string,
+  rpcUrl: string,
+): Promise<bigint> {
+  try {
+    const client = createPublicClient({ transport: http(rpcUrl) })
+    return await client.readContract({
+      address: token as Address,
+      abi: erc20Abi,
+      functionName: 'balanceOf',
+      args: [address as Address],
+    })
+  } catch (error) {
+    console.warn(`[balance] Failed to read balance for token ${token}: ${String(error)}`)
+    return 0n
+  }
+}
+
+export interface FundedRouteBalance {
+  route: AcrossRoute
+  balance: bigint
+}
+
+export async function getFundedRouteBalances(
+  address: string,
+  routes: AcrossRoute[],
+  rpcs: Record<number, string> = {},
+): Promise<FundedRouteBalance[]> {
+  const results = await Promise.allSettled(
+    routes.map(async (route) => ({
+      route,
+      balance: await getErc20Balance(address, route.originToken, getRpc(route.originChainId, rpcs)),
+    })),
+  )
+
+  return results
+    .filter(
+      (result): result is PromiseFulfilledResult<FundedRouteBalance> =>
+        result.status === 'fulfilled' && result.value.balance > 0n,
+    )
+    .map((result) => result.value)
+}

package/src/buyer/coinbase-wallet.ts

@@ -0,0 +1,26 @@
+import { CdpClient } from '@coinbase/cdp-sdk'
+import { toAccount } from 'viem/accounts'
+
+export interface CoinbaseDemoWallet {
+  provider: 'coinbase-cdp'
+  source: 'CDP server wallet'
+  account: ReturnType<typeof toAccount>
+}
+
+/**
+ * Creates or retrieves a CDP server-managed wallet for the x402 buyer demo.
+ *
+ * The private key never leaves Coinbase infrastructure. Signing happens via
+ * the CDP API using CDP_API_KEY_ID, CDP_API_KEY_SECRET, and CDP_WALLET_SECRET.
+ */
+export async function resolveCoinbaseDemoWallet(): Promise<CoinbaseDemoWallet> {
+  const cdp = new CdpClient()
+  const cdpAccount = await cdp.evm.getOrCreateAccount({ name: 'x402-buyer' })
+  const account = toAccount(cdpAccount)
+
+  return {
+    provider: 'coinbase-cdp',
+    source: 'CDP server wallet',
+    account,
+  }
+}

package/src/buyer/x402-with-across.ts

@@ -0,0 +1,351 @@
+/**
+ * Wraps the x402 buyer flow with Across pre-funding on the selected EVM network.
+ *
+ * The x402 SDK remains responsible for protocol parsing, payload creation, retry,
+ * verification, and settlement. Across only ensures the buyer has funds on the
+ * destination chain before the x402 payment payload is created.
+ */
+import { x402Client, x402HTTPClient } from '@x402/core/client'
+import { ExactEvmScheme, toClientEvmSigner } from '@x402/evm'
+import { wrapFetchWithPayment } from '@x402/fetch'
+import type { Account } from 'viem'
+import { createPublicClient, createWalletClient, http } from 'viem'
+
+import {
+  DEFAULT_ORIGIN_CHAINS,
+  DEFAULT_RPCS,
+  findRoutes,
+  getQuote,
+  parseEip155ChainId,
+  type AcrossQuote,
+  type AcrossRoute,
+  waitForFill,
+} from './across.ts'
+import {
+  getErc20Balance,
+  getFundedRouteBalances,
+  getRpc,
+  type FundedRouteBalance,
+} from './balance.ts'
+
+function toSchemeRpcConfig(rpcs: Record<number, string>) {
+  return Object.fromEntries(
+    Object.entries(rpcs).map(([chainId, rpcUrl]) => [Number(chainId), { rpcUrl }]),
+  )
+}
+
+function compareFundedBalances(a: FundedRouteBalance, b: FundedRouteBalance): number {
+  if (a.balance === b.balance) return a.route.originChainId - b.route.originChainId
+  return a.balance > b.balance ? -1 : 1
+}
+
+interface QuotedFundedRoute extends FundedRouteBalance {
+  quote: AcrossQuote
+  feeUsd: number
+}
+
+function compareQuotedRoutes(a: QuotedFundedRoute, b: QuotedFundedRoute): number {
+  if (a.balance !== b.balance) return a.balance > b.balance ? -1 : 1
+  if (a.feeUsd !== b.feeUsd) return a.feeUsd - b.feeUsd
+  return a.route.originChainId - b.route.originChainId
+}
+
+function isQuotedCandidate(
+  result: PromiseSettledResult<QuotedFundedRoute | null>,
+): result is PromiseFulfilledResult<QuotedFundedRoute> {
+  return result.status === 'fulfilled' && result.value !== null
+}
+
+function feeUsd(amountUsd: string): number {
+  const parsed = Number(amountUsd)
+  return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY
+}
+
+export interface BridgeInfo {
+  used: boolean
+  forced?: boolean
+  originChainId?: number
+  destinationChainId?: number
+  inputToken?: string
+  outputToken?: string
+  inputAmount?: string
+  destinationAmount?: string
+  depositTxHash?: `0x${string}`
+  fillTxHash?: string
+}
+
+export interface AcrossConfig {
+  preferredOriginChainId?: number
+  preferredOriginChainOnly?: boolean
+  originChainIds?: number[]
+  gasBuffer?: bigint
+  forceBridge?: boolean
+  rpcs?: Record<number, string>
+}
+
+export function createX402WithAcross(config: {
+  account: Account
+  across?: AcrossConfig
+  polyfill?: boolean
+}) {
+  const rawFetch = globalThis.fetch
+  const account = config.account
+  const signer = toClientEvmSigner(account as Parameters<typeof toClientEvmSigner>[0])
+  const rpcs = { ...DEFAULT_RPCS, ...config.across?.rpcs }
+  const originChainIds = config.across?.originChainIds ?? DEFAULT_ORIGIN_CHAINS
+  const preferredOriginChain = config.across?.preferredOriginChainId
+  const preferredOriginChainOnly = config.across?.preferredOriginChainOnly ?? false
+  const gasBuffer = config.across?.gasBuffer ?? 0n
+  const forceBridge = config.across?.forceBridge ?? false
+
+  console.log(`[x402+across] Buyer: ${account.address}`)
+  if (preferredOriginChain) {
+    const mode = preferredOriginChainOnly
+      ? 'strict preferred-chain mode'
+      : 'preferred-chain fast path with dynamic fallback'
+    console.log(`[x402+across] Origin selection: chain ${preferredOriginChain} (${mode})`)
+  } else {
+    console.log('[x402+across] Dynamic chain discovery enabled')
+  }
+  if (forceBridge) {
+    console.log('[x402+across] Force-bridge mode enabled for crosschain testing')
+  }
+
+  const bridgeInfo: BridgeInfo = { used: false }
+
+  const client = new x402Client()
+    .register('eip155:*', new ExactEvmScheme(signer, toSchemeRpcConfig(rpcs)))
+    .onBeforePaymentCreation(async ({ selectedRequirements }) => {
+      if (!selectedRequirements.network.startsWith('eip155:')) {
+        return
+      }
+
+      const destinationChainId = parseEip155ChainId(selectedRequirements.network)
+      const destinationToken = selectedRequirements.asset
+      const destinationAmount = BigInt(selectedRequirements.amount)
+      const destinationRpc = getRpc(destinationChainId, rpcs)
+
+      console.log(`\n[x402+across] Payment requirements:`)
+      console.log(`  Network: ${selectedRequirements.network}`)
+      console.log(`  Asset: ${destinationToken}`)
+      console.log(`  Amount: ${selectedRequirements.amount}`)
+
+      const destinationBalance = await getErc20Balance(
+        account.address,
+        destinationToken,
+        destinationRpc,
+      )
+
+      bridgeInfo.used = false
+      bridgeInfo.forced = forceBridge
+      bridgeInfo.originChainId = undefined
+      bridgeInfo.destinationChainId = destinationChainId
+      bridgeInfo.inputToken = undefined
+      bridgeInfo.outputToken = destinationToken
+      bridgeInfo.inputAmount = undefined
+      bridgeInfo.destinationAmount = selectedRequirements.amount
+      bridgeInfo.depositTxHash = undefined
+      bridgeInfo.fillTxHash = undefined
+
+      console.log(`  Destination balance: ${destinationBalance}`)
+
+      if (!forceBridge && destinationBalance >= destinationAmount) {
+        console.log('  [skip bridge] Sufficient balance on destination chain')
+        return
+      }
+
+      const shortfall = forceBridge
+        ? destinationAmount + gasBuffer
+        : destinationAmount - destinationBalance + gasBuffer
+      const reason = forceBridge ? 'forced bridge for test flow' : 'includes gas buffer'
+      console.log(`  [bridge needed] Shortfall: ${shortfall} (${reason})`)
+
+      const routes = await findRoutes(destinationChainId, destinationToken, rawFetch)
+      const candidateRoutes = routes.filter(
+        (route) =>
+          route.originChainId !== destinationChainId &&
+          originChainIds.includes(route.originChainId),
+      )
+      const originChains = [...new Set(candidateRoutes.map((route) => route.originChainId))]
+
+      console.log(
+        `  [route discovery] Found ${candidateRoutes.length} route(s) from ${
+          originChains.length > 0 ? originChains.join(', ') : 'none'
+        }`,
+      )
+
+      let bestRoute: AcrossRoute | null = null
+      let bestOrigin = 0
+      let originBalance = 0n
+      let bestQuote: AcrossQuote | null = null
+
+      if (preferredOriginChain) {
+        const preferredRoute =
+          candidateRoutes.find((route) => route.originChainId === preferredOriginChain) ?? null
+
+        if (preferredRoute) {
+          const balance = await getErc20Balance(
+            account.address,
+            preferredRoute.originToken,
+            getRpc(preferredOriginChain, rpcs),
+          )
+
+          console.log(`  [fast path] Chain ${preferredOriginChain}: ${balance}`)
+
+          if (balance > 0n) {
+            bestRoute = preferredRoute
+            bestOrigin = preferredOriginChain
+            originBalance = balance
+            console.log(`  [fast path hit] Using preferred chain ${preferredOriginChain}`)
+          } else if (preferredOriginChainOnly) {
+            throw new Error(`Preferred origin chain ${preferredOriginChain} has no funded route`)
+          } else {
+            console.log('  [fast path miss] No funds on preferred chain, scanning others')
+          }
+        } else if (preferredOriginChainOnly) {
+          throw new Error(
+            `No Across route from preferred chain ${preferredOriginChain} to chain ${destinationChainId}`,
+          )
+        } else {
+          console.log('  [fast path miss] No route on preferred chain, scanning others')
+        }
+      }
+
+      if (!bestRoute) {
+        const scanStart = Date.now()
+        const funded = (
+          await getFundedRouteBalances(account.address, candidateRoutes, rpcs)
+        ).sort(compareFundedBalances)
+
+        console.log(
+          `  [parallel scan] Done in ${Date.now() - scanStart}ms with ${funded.length} funded chain(s)`,
+        )
+
+        if (funded.length === 1) {
+          bestRoute = funded[0].route
+          bestOrigin = funded[0].route.originChainId
+          originBalance = funded[0].balance
+          console.log(`  [route selection] Using only funded candidate on chain ${bestOrigin}`)
+        } else if (funded.length > 1) {
+          const quoteStart = Date.now()
+          const quotedCandidates = (
+            await Promise.allSettled(
+              funded.map(async (candidate): Promise<QuotedFundedRoute | null> => {
+                const quote = await getQuote(
+                  {
+                    originChainId: candidate.route.originChainId,
+                    destinationChainId,
+                    inputToken: candidate.route.originToken,
+                    outputToken: destinationToken,
+                    amount: shortfall.toString(),
+                    depositor: account.address,
+                    recipient: account.address,
+                  },
+                  rawFetch,
+                )
+
+                return BigInt(quote.inputAmount) <= candidate.balance
+                  ? { ...candidate, quote, feeUsd: feeUsd(quote.fees.total.amountUsd) }
+                  : null
+              }),
+            )
+          )
+            .filter(isQuotedCandidate)
+            .map((result) => result.value)
+            .sort(compareQuotedRoutes)
+
+          console.log(
+            `  [route selection] Quoted ${quotedCandidates.length}/${funded.length} candidate(s) in ${Date.now() - quoteStart}ms`,
+          )
+
+          if (quotedCandidates.length > 0) {
+            bestRoute = quotedCandidates[0].route
+            bestOrigin = quotedCandidates[0].route.originChainId
+            originBalance = quotedCandidates[0].balance
+            bestQuote = quotedCandidates[0].quote
+          }
+        }
+      }
+
+      if (!bestRoute) {
+        throw new Error(
+          `No Across origin route with sufficient funds found for ${selectedRequirements.network} ${destinationToken}`,
+        )
+      }
+
+      const quote =
+        bestQuote ??
+        (await getQuote(
+          {
+            originChainId: bestOrigin,
+            destinationChainId,
+            inputToken: bestRoute.originToken,
+            outputToken: destinationToken,
+            amount: shortfall.toString(),
+            depositor: account.address,
+            recipient: account.address,
+          },
+          rawFetch,
+        ))
+
+      const inputNeeded = BigInt(quote.inputAmount)
+      if (originBalance < inputNeeded) {
+        throw new Error(
+          `Insufficient origin balance. Need ${inputNeeded} on chain ${bestOrigin}, have ${originBalance}`,
+        )
+      }
+
+      const originRpc = getRpc(bestOrigin, rpcs)
+      const originWallet = createWalletClient({
+        account,
+        transport: http(originRpc),
+      })
+      const originPublic = createPublicClient({
+        transport: http(originRpc),
+      })
+
+      for (const approval of quote.approvalTxns ?? []) {
+        console.log('[across] Sending approval tx...')
+        const approvalHash = await originWallet.sendTransaction({
+          chain: undefined,
+          to: approval.to as `0x${string}`,
+          data: approval.data as `0x${string}`,
+        })
+        await originPublic.waitForTransactionReceipt({ hash: approvalHash })
+      }
+
+      console.log(`[across] Bridging from chain ${bestOrigin} to chain ${destinationChainId}`)
+      const depositTxHash = await originWallet.sendTransaction({
+        chain: undefined,
+        to: quote.swapTx.to as `0x${string}`,
+        data: quote.swapTx.data as `0x${string}`,
+      })
+      await originPublic.waitForTransactionReceipt({ hash: depositTxHash })
+
+      const fill = await waitForFill(depositTxHash, bestOrigin, rawFetch)
+
+      bridgeInfo.used = true
+      bridgeInfo.originChainId = bestOrigin
+      bridgeInfo.inputToken = bestRoute.originToken
+      bridgeInfo.inputAmount = quote.inputAmount
+      bridgeInfo.depositTxHash = depositTxHash
+      bridgeInfo.fillTxHash = fill.fillTx
+    })
+
+  const httpClient = new x402HTTPClient(client)
+  const paidFetch = wrapFetchWithPayment(rawFetch, httpClient)
+
+  if (config.polyfill ?? true) {
+    globalThis.fetch = paidFetch
+  }
+
+  return {
+    account,
+    bridgeInfo,
+    client,
+    httpClient,
+    fetch: paidFetch,
+    rawFetch,
+    rpcs,
+  }
+}

package/src/demo/run.ts

@@ -0,0 +1,255 @@
+/**
+ * x402 buyer demo against a local seller or a public x402 merchant.
+ *
+ * Usage:
+ *   npm run demo:local
+ *   npm run demo:local:strict
+ *   npm run demo:external
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+
+import { decodePaymentResponseHeader } from '@x402/core/http'
+import { createPublicClient, erc20Abi, formatUnits, http } from 'viem'
+import { base } from 'viem/chains'
+
+import { createX402WithAcross } from '../buyer/x402-with-across.ts'
+import { resolveCoinbaseDemoWallet } from '../buyer/coinbase-wallet.ts'
+
+const BASE_CHAIN_ID = 8453
+const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
+const REPORT_FILE = 'TEST-RESULTS.md'
+const EXPLORERS: Record<number, string> = {
+  1: 'https://etherscan.io',
+  10: 'https://optimistic.etherscan.io',
+  137: 'https://polygonscan.com',
+  8453: 'https://basescan.org',
+  42161: 'https://arbiscan.io',
+}
+
+function resolveMode(): 'demo' | 'dynamic' {
+  if (process.env.MODE === 'demo' || process.env.DEMO === '1') {
+    return 'demo'
+  }
+
+  return 'dynamic'
+}
+
+function readOriginChain(mode: 'demo' | 'dynamic'): number | undefined {
+  const raw = process.env.ORIGIN_CHAIN
+  if (raw) {
+    const parsed = Number(raw)
+    if (!Number.isFinite(parsed)) {
+      throw new Error(`Invalid ORIGIN_CHAIN: ${raw}`)
+    }
+    return parsed
+  }
+
+  return mode === 'demo' ? BASE_CHAIN_ID : undefined
+}
+
+function absBigInt(value: bigint): bigint {
+  return value < 0n ? -value : value
+}
+
+function formatSignedUnits(value: bigint, decimals: number): string {
+  const sign = value >= 0n ? '+' : '-'
+  return `${sign}${formatUnits(absBigInt(value), decimals)}`
+}
+
+function appendReport(entry: string) {
+  const header = '# Test Results\n\nAll x402 test runs and attempts.\n\n'
+  const existing = existsSync(REPORT_FILE) ? readFileSync(REPORT_FILE, 'utf-8') : ''
+  const separator = existing.length > 0 ? '\n---\n\n' : ''
+  writeFileSync(REPORT_FILE, (existing || header) + separator + entry)
+}
+
+async function main() {
+  const wallet = await resolveCoinbaseDemoWallet()
+  const testUrl = process.env.TEST_URL ?? 'http://localhost:4021/api/ping'
+  const mode = resolveMode()
+  const forceBridge = process.env.FORCE_BRIDGE === '1'
+  const preferredOriginChainId = readOriginChain(mode)
+  const startTime = new Date()
+
+  const testName =
+    mode === 'demo'
+      ? 'x402 Buyer Demo (strict local mode)'
+      : testUrl.includes('coingecko.com')
+        ? 'x402 Buyer Demo (CoinGecko)'
+        : 'x402 Buyer Demo (dynamic local mode)'
+
+  const report: Record<string, any> = {
+    test: testName,
+    timestamp: startTime.toISOString(),
+    target: testUrl,
+    mode,
+    forceBridge,
+    configuredOriginChainId: preferredOriginChainId ?? null,
+    buyer: null,
+    status: null,
+    statusText: null,
+    result: 'ERROR',
+    error: null,
+    responseBody: null,
+    paymentResponse: null,
+    bridgeInfo: null,
+    txLinks: {} as Record<string, string>,
+  }
+
+  const baseClient = createPublicClient({ chain: base, transport: http('https://mainnet.base.org') })
+  const { account, bridgeInfo, fetch } = createX402WithAcross({
+    account: wallet.account,
+    polyfill: false,
+    across:
+      mode === 'demo' || forceBridge || preferredOriginChainId !== undefined
+        ? {
+            preferredOriginChainId,
+            preferredOriginChainOnly: mode === 'demo',
+            forceBridge,
+          }
+        : undefined,
+  })
+
+  report.buyer = account.address
+  report.walletSource = wallet.source
+
+  const startEth = await baseClient.getBalance({ address: account.address })
+  const startUsdc = await baseClient.readContract({
+    address: BASE_USDC,
+    abi: erc20Abi,
+    functionName: 'balanceOf',
+    args: [account.address],
+  })
+
+  console.log('\n=== x402 Buyer Demo ===')
+  console.log(`Wallet source: ${wallet.source}`)
+  console.log(`Target: ${testUrl}`)
+  console.log(`Mode:   ${mode === 'demo' ? 'demo (strict Base fast path)' : 'dynamic (parallel discovery)'}`)
+  console.log(`Force:  ${forceBridge ? 'bridge enabled' : 'normal direct-if-funded flow'}`)
+  console.log(`Origin: ${preferredOriginChainId ?? 'auto'}`)
+  console.log(`Buyer:  ${account.address}`)
+  console.log(`Base ETH:  ${formatUnits(startEth, 18)}`)
+  console.log(`Base USDC: ${formatUnits(startUsdc, 6)}`)
+
+  report.startBalances = {
+    baseEth: formatUnits(startEth, 18),
+    baseUsdc: formatUnits(startUsdc, 6),
+  }
+
+  try {
+    const response = await fetch(testUrl)
+    const body = await response.text()
+    const endEth = await baseClient.getBalance({ address: account.address })
+    const endUsdc = await baseClient.readContract({
+      address: BASE_USDC,
+      abi: erc20Abi,
+      functionName: 'balanceOf',
+      args: [account.address],
+    })
+
+    const ethDelta = endEth - startEth
+    const usdcDelta = endUsdc - startUsdc
+
+    report.status = response.status
+    report.statusText = response.statusText
+    report.responseBody = body.length > 2000 ? `${body.slice(0, 2000)}...` : body
+    report.endBalances = {
+      baseEth: formatUnits(endEth, 18),
+      baseUsdc: formatUnits(endUsdc, 6),
+    }
+    report.balanceDelta = {
+      baseEth: formatSignedUnits(ethDelta, 18),
+      baseUsdc: formatSignedUnits(usdcDelta, 6),
+    }
+
+    console.log(`\nStatus: ${response.status} ${response.statusText}`)
+
+    const paymentResponseHeader = response.headers.get('PAYMENT-RESPONSE')
+    if (paymentResponseHeader) {
+      const paymentResponse = decodePaymentResponseHeader(paymentResponseHeader)
+      report.paymentResponse = paymentResponse
+      console.log('\nPayment Response:')
+      console.log(JSON.stringify(paymentResponse, null, 2))
+
+      if (paymentResponse.transaction) {
+        report.txLinks.payment = `${EXPLORERS[BASE_CHAIN_ID]}/tx/${paymentResponse.transaction}`
+      }
+    }
+
+    report.bridgeInfo = bridgeInfo
+
+    console.log('\nBridge Info:')
+    console.log(JSON.stringify(bridgeInfo, null, 2))
+
+    console.log('\nBalances:')
+    console.log(`  End Base ETH:  ${formatUnits(endEth, 18)} (delta ${formatSignedUnits(ethDelta, 18)})`)
+    console.log(`  End Base USDC: ${formatUnits(endUsdc, 6)} (delta ${formatSignedUnits(usdcDelta, 6)})`)
+
+    console.log('\nExplorer Links:')
+    report.txLinks.buyerBase = `${EXPLORERS[BASE_CHAIN_ID]}/address/${account.address}`
+    console.log(`  Buyer: ${report.txLinks.buyerBase}`)
+
+    if (bridgeInfo.depositTxHash) {
+      const originChainId = bridgeInfo.originChainId ?? preferredOriginChainId ?? null
+      const originExplorer = originChainId ? EXPLORERS[originChainId] : null
+      if (originExplorer) {
+        report.txLinks.bridgeDeposit = `${originExplorer}/tx/${bridgeInfo.depositTxHash}`
+        console.log(`  Bridge deposit: ${report.txLinks.bridgeDeposit}`)
+      }
+      report.txLinks.acrossTransfer = `https://app.across.to/transfer/${bridgeInfo.depositTxHash}`
+      console.log(`  Across transfer: ${report.txLinks.acrossTransfer}`)
+    }
+
+    if (bridgeInfo.fillTxHash) {
+      report.txLinks.bridgeFill = `${EXPLORERS[BASE_CHAIN_ID]}/tx/${bridgeInfo.fillTxHash}`
+      console.log(`  Bridge fill: ${report.txLinks.bridgeFill}`)
+    }
+
+    console.log('\nResponse Body:')
+    console.log(body)
+
+    report.result = response.ok
+      ? bridgeInfo.used
+        ? 'SUCCESS (via Across bridge)'
+        : 'SUCCESS (direct x402 payment)'
+      : 'FAILED'
+  } catch (error) {
+    report.error = error instanceof Error ? error.stack ?? error.message : String(error)
+    throw error
+  } finally {
+    const txLinksSection =
+      Object.keys(report.txLinks).length > 0
+        ? Object.entries(report.txLinks)
+            .map(([key, value]) => `- ${key}: ${value}`)
+            .join('\n')
+        : '- none'
+
+    const entry = `### ${report.test}
+- **Time:** ${report.timestamp}
+- **Target:** ${report.target}
+- **Mode:** ${report.mode}
+- **Force bridge:** ${report.forceBridge ? 'yes' : 'no'}
+- **Configured origin chain:** ${report.configuredOriginChainId ?? 'auto'}
+- **Buyer:** \`${report.buyer ?? 'unknown'}\`
+- **Result:** ${report.result}
+- **Status:** ${report.status ?? 'N/A'} ${report.statusText ?? ''}
+- **Start balances:** Base ETH ${report.startBalances?.baseEth ?? 'N/A'}, Base USDC ${report.startBalances?.baseUsdc ?? 'N/A'}
+- **End balances:** Base ETH ${report.endBalances?.baseEth ?? 'N/A'}, Base USDC ${report.endBalances?.baseUsdc ?? 'N/A'}
+- **Balance delta:** Base ETH ${report.balanceDelta?.baseEth ?? 'N/A'}, Base USDC ${report.balanceDelta?.baseUsdc ?? 'N/A'}
+- **Bridge info:** ${report.bridgeInfo ? `\`${JSON.stringify(report.bridgeInfo)}\`` : 'None'}
+- **Payment response:** ${report.paymentResponse ? `\`${JSON.stringify(report.paymentResponse)}\`` : 'None'}
+- **Explorer links:**
+${txLinksSection}
+- **Response body:** ${report.responseBody ? `\`${report.responseBody.replaceAll('`', "'")}\`` : 'None'}
+- **Error:** ${report.error ? `\`${String(report.error).replaceAll('`', "'")}\`` : 'None'}
+`
+
+    appendReport(entry)
+    console.log(`\nResults appended to ${REPORT_FILE}`)
+  }
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/src/dev/preflight.ts

@@ -0,0 +1,78 @@
+/**
+ * Mainnet readiness checks for the x402 + Across prototype.
+ */
+import { HTTPFacilitatorClient } from '@x402/core/server'
+import { createFacilitatorConfig } from '@coinbase/x402'
+import { createPublicClient, erc20Abi, formatUnits, http } from 'viem'
+import { base } from 'viem/chains'
+import { resolveCoinbaseDemoWallet } from '../buyer/coinbase-wallet.ts'
+
+const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
+
+function log(name: string, status: 'OK' | 'WARN' | 'FAIL', detail: string) {
+  console.log(`${status.padEnd(4)} ${name.padEnd(18)} ${detail}`)
+}
+
+async function main() {
+  const cdpApiKeyId = process.env.CDP_API_KEY_ID
+  const cdpApiKeySecret = process.env.CDP_API_KEY_SECRET
+  const cdpWalletSecret = process.env.CDP_WALLET_SECRET
+
+  if (cdpApiKeyId && cdpApiKeySecret) {
+    log('CDP creds', 'OK', 'CDP_API_KEY_ID / CDP_API_KEY_SECRET present')
+  } else {
+    log('CDP creds', 'FAIL', 'Missing CDP_API_KEY_ID or CDP_API_KEY_SECRET')
+  }
+
+  if (cdpWalletSecret) {
+    log('CDP wallet', 'OK', 'CDP_WALLET_SECRET present')
+  } else {
+    log('CDP wallet', 'FAIL', 'Missing CDP_WALLET_SECRET (required for signing)')
+  }
+
+  const wallet = await resolveCoinbaseDemoWallet()
+  const { account } = wallet
+  log('Agent address', 'OK', account.address)
+  log('Wallet source', 'OK', wallet.source)
+
+  const facilitatorClient = new HTTPFacilitatorClient(
+    createFacilitatorConfig(cdpApiKeyId, cdpApiKeySecret),
+  )
+
+  try {
+    const supported = await facilitatorClient.getSupported()
+    log(
+      'Facilitator',
+      'OK',
+      `supported kinds=${supported.kinds.length}, extensions=${supported.extensions.length}`,
+    )
+  } catch (error) {
+    log('Facilitator', 'FAIL', String(error))
+  }
+
+  const baseClient = createPublicClient({ chain: base, transport: http('https://mainnet.base.org') })
+
+  try {
+    const eth = await baseClient.getBalance({ address: account.address })
+    log('Base ETH', 'OK', formatUnits(eth, 18))
+  } catch (error) {
+    log('Base ETH', 'FAIL', String(error))
+  }
+
+  try {
+    const usdc = await baseClient.readContract({
+      address: BASE_USDC,
+      abi: erc20Abi,
+      functionName: 'balanceOf',
+      args: [account.address],
+    })
+    log('Base USDC', 'OK', formatUnits(usdc, 6))
+  } catch (error) {
+    log('Base USDC', 'FAIL', String(error))
+  }
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/src/dev/server.ts

@@ -0,0 +1,106 @@
+/**
+ * Local x402 seller on Base mainnet using Coinbase's hosted facilitator.
+ *
+ * This is the local dev seller for the x402 buyer demo.
+ */
+import { serve } from '@hono/node-server'
+import { paymentMiddleware, x402ResourceServer } from '@x402/hono'
+import { HTTPFacilitatorClient } from '@x402/core/server'
+import { ExactEvmScheme } from '@x402/evm/exact/server'
+import { createFacilitatorConfig } from '@coinbase/x402'
+import { Hono } from 'hono'
+import { privateKeyToAccount } from 'viem/accounts'
+
+async function main() {
+  const merchantKey =
+    process.env.MERCHANT_KEY ??
+    '0x9593f890cb5779da1817bd921712d8446e7468f84b887a342fe5bf8795ce2f8b'
+  const cdpApiKeyId = process.env.CDP_API_KEY_ID
+  const cdpApiKeySecret = process.env.CDP_API_KEY_SECRET
+  const port = Number(process.env.PORT ?? 4021)
+
+  if (!cdpApiKeyId || !cdpApiKeySecret) {
+    throw new Error('Set CDP_API_KEY_ID and CDP_API_KEY_SECRET for x402 mainnet settlement')
+  }
+
+  const merchant = privateKeyToAccount(merchantKey as `0x${string}`)
+  const facilitatorClient = new HTTPFacilitatorClient(
+    createFacilitatorConfig(cdpApiKeyId, cdpApiKeySecret),
+  )
+  const resourceServer = new x402ResourceServer(facilitatorClient).register(
+    'eip155:8453',
+    new ExactEvmScheme(),
+  )
+
+  await resourceServer.initialize()
+
+  const app = new Hono()
+
+  const routes = {
+    'GET /api/premium': {
+      accepts: {
+        scheme: 'exact',
+        price: '$0.01',
+        network: 'eip155:8453',
+        payTo: merchant.address,
+        maxTimeoutSeconds: 300,
+      },
+      description: 'Premium x402 resource access',
+      mimeType: 'application/json',
+    },
+    'GET /api/ping': {
+      accepts: {
+        scheme: 'exact',
+        price: '$0.15',
+        network: 'eip155:8453',
+        payTo: merchant.address,
+        maxTimeoutSeconds: 300,
+      },
+      description: 'Ping test',
+      mimeType: 'application/json',
+    },
+  } as const
+
+  app.use(paymentMiddleware(routes, resourceServer))
+
+  app.get('/', (c) =>
+    c.json({
+      status: 'ok',
+      service: 'across-x402-demo',
+      network: 'eip155:8453',
+      merchant: merchant.address,
+    }),
+  )
+
+  app.get('/api/premium', (c) =>
+    c.json({
+      message: 'Welcome to the premium x402 resource!',
+      paid: true,
+      timestamp: new Date().toISOString(),
+    }),
+  )
+
+  app.get('/api/ping', (c) =>
+    c.json({
+      pong: true,
+      timestamp: new Date().toISOString(),
+    }),
+  )
+
+  serve({ fetch: app.fetch, port }, () => {
+    console.log('\n=== Across x402 Demo Server ===')
+    console.log(`Merchant: ${merchant.address}`)
+    console.log('Network:  eip155:8453 (Base mainnet)')
+    console.log('Protocol: x402 exact')
+    console.log('Price:    $0.01 premium / $0.15 ping')
+    console.log(`\nListening on http://localhost:${port}`)
+    console.log('  GET /              — health check (free)')
+    console.log('  GET /api/premium   — $0.01 x402 exact on Base mainnet')
+    console.log('  GET /api/ping      — $0.15 x402 exact on Base mainnet')
+  })
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createX402WithAcross, type AcrossConfig, type BridgeInfo } from './buyer/x402-with-across.ts'
+export { resolveCoinbaseDemoWallet, type CoinbaseDemoWallet } from './buyer/coinbase-wallet.ts'

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}