@relai-fi/x402 0.1.0

package/README.md

@@ -0,0 +1,314 @@
+<h1 align="center">@relai-fi/x402</h1>
+
+<p align="center">
+  <strong>Unified x402 payment SDK for Solana, Base, Avalanche, and SKALE Base.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@relai-fi/x402"><img src="https://img.shields.io/npm/v/@relai-fi/x402.svg" alt="npm"></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E=18-brightgreen.svg" alt="Node"></a>
+  <a href="https://relai.fi"><img src="https://img.shields.io/badge/Marketplace-relai.fi-blueviolet" alt="Marketplace"></a>
+</p>
+
+<p align="center">
+  <a href="https://relai.fi"><strong>Browse APIs →</strong></a>
+</p>
+
+---
+
+## What is x402?
+
+x402 is a protocol for HTTP-native micropayments. When a server returns HTTP `402 Payment Required`, it includes payment details in the response. The client signs a payment, retries the request, and the server settles the payment and returns the protected content.
+
+This SDK handles the entire flow automatically — call `fetch()` and payments happen transparently.
+
+---
+
+## Why This SDK?
+
+**Multi-chain.** Solana, Base, Avalanche, and SKALE Base with a single API. Connect your wallets and the SDK picks the right chain and signing method automatically.
+
+**Zero gas fees.** The RelAI facilitator sponsors gas — users only pay for content (USDC).
+
+**Auto-detects signing method.** EIP-3009 `transferWithAuthorization` for all EVM networks (Base, Avalanche, SKALE Base), native SPL transfer for Solana — all handled internally.
+
+**Works out of the box.** Uses the [RelAI facilitator](https://facilitator.x402.fi) by default.
+
+---
+
+## Quick Start
+
+### Install
+
+```bash
+npm install @relai-fi/x402
+```
+
+### Client (Browser / Node.js)
+
+```typescript
+import { createX402Client } from '@relai-fi/x402/client';
+
+const client = createX402Client({
+  wallets: {
+    solana: solanaWallet,  // @solana/wallet-adapter compatible
+    evm: evmWallet,        // wagmi/viem compatible
+  },
+});
+
+// 402 responses are handled automatically
+const response = await client.fetch('https://api.example.com/protected');
+const data = await response.json();
+```
+
+### React Hook
+
+Works with [`@solana/wallet-adapter-react`](https://github.com/anza-xyz/wallet-adapter) and [`wagmi`](https://wagmi.sh/):
+
+```tsx
+import { useRelaiPayment } from '@relai-fi/x402/react';
+import { useWallet } from '@solana/wallet-adapter-react';
+import { useAccount, useSignTypedData } from 'wagmi';
+
+function PayButton() {
+  const solanaWallet = useWallet();
+  const { address } = useAccount();
+  const { signTypedDataAsync } = useSignTypedData();
+
+  const {
+    fetch,
+    isLoading,
+    status,
+    transactionUrl,
+    transactionNetworkLabel,
+  } = useRelaiPayment({
+    wallets: {
+      solana: solanaWallet,
+      evm: address ? { address, signTypedData: signTypedDataAsync } : undefined,
+    },
+  });
+
+  return (
+    <div>
+      <button onClick={() => fetch('/api/protected')} disabled={isLoading}>
+        {isLoading ? 'Paying...' : 'Access API'}
+      </button>
+      {transactionUrl && (
+        <a href={transactionUrl} target="_blank">
+          View on {transactionNetworkLabel}
+        </a>
+      )}
+    </div>
+  );
+}
+```
+
+---
+
+## Supported Networks
+
+| Network | Identifier | CAIP-2 | Signing Method | USDC Contract |
+|---------|-----------|--------|----------------|---------------|
+| **Solana** | `solana` | `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` | SPL transfer + fee payer | `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` |
+| **Base** | `base` | `eip155:8453` | EIP-3009 transferWithAuthorization | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |
+| **Avalanche** | `avalanche` | `eip155:43114` | EIP-3009 transferWithAuthorization | `0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E` |
+| **SKALE Base** | `skale-base` | `eip155:1187947933` | EIP-3009 transferWithAuthorization | `0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20` |
+
+All networks use **USDC** with 6 decimals. Gas fees are sponsored by the RelAI facilitator.
+
+---
+
+## Package Exports
+
+```typescript
+// Client — browser & Node.js fetch wrapper with automatic 402 handling
+import { createX402Client } from '@relai-fi/x402/client';
+
+// React hook — state management + wallet integration
+import { useRelaiPayment } from '@relai-fi/x402/react';
+
+// Server — Express middleware for protecting endpoints
+import Relai from '@relai-fi/x402/server';
+
+// Utilities — payload conversion, unit helpers
+import {
+  convertV1ToV2,
+  convertV2ToV1,
+  networkV1ToV2,
+  networkV2ToV1,
+  toAtomicUnits,
+  fromAtomicUnits,
+} from '@relai-fi/x402/utils';
+
+// Types & constants
+import {
+  RELAI_NETWORKS,
+  CHAIN_IDS,
+  USDC_ADDRESSES,
+  NETWORK_CAIP2,
+  EXPLORER_TX_URL,
+  type RelaiNetwork,
+  type SolanaWallet,
+  type EvmWallet,
+  type WalletSet,
+} from '@relai-fi/x402';
+```
+
+---
+
+## API Reference
+
+### `createX402Client(config)`
+
+Creates a fetch wrapper that automatically handles 402 Payment Required responses.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `wallets` | `{ solana?, evm? }` | `{}` | Wallet adapters for each chain |
+| `facilitatorUrl` | `string` | RelAI facilitator | Custom facilitator endpoint |
+| `preferredNetwork` | `RelaiNetwork` | — | Prefer this network when multiple `accepts` |
+| `solanaRpcUrl` | `string` | `https://api.mainnet-beta.solana.com` | Solana RPC (use Helius/Quicknode for production) |
+| `evmRpcUrls` | `Record<string, string>` | Built-in defaults | RPC URLs per network name |
+| `maxAmountAtomic` | `string` | — | Safety cap on payment amount |
+| `verbose` | `boolean` | `false` | Log payment flow to console |
+
+**Wallet interfaces:**
+
+```typescript
+// Solana — compatible with @solana/wallet-adapter-react useWallet()
+interface SolanaWallet {
+  publicKey: { toString(): string } | null;
+  signTransaction: ((tx: unknown) => Promise<unknown>) | null;
+}
+
+// EVM — pass address + signTypedData from wagmi
+interface EvmWallet {
+  address: string;
+  signTypedData: (params: {
+    domain: Record<string, unknown>;
+    types: Record<string, unknown[]>;
+    message: Record<string, unknown>;
+    primaryType: string;
+  }) => Promise<string>;
+}
+```
+
+---
+
+### `useRelaiPayment(config)`
+
+React hook wrapping `createX402Client` with state management.
+
+**Config** — same as `createX402Client` (see above).
+
+**Returns:**
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `fetch` | `(input, init?) => Promise<Response>` | Payment-aware fetch |
+| `isLoading` | `boolean` | Payment in progress |
+| `status` | `'idle' \| 'pending' \| 'success' \| 'error'` | Current state |
+| `error` | `Error \| null` | Error details on failure |
+| `transactionId` | `string \| null` | Tx hash/signature on success |
+| `transactionNetwork` | `RelaiNetwork \| null` | Network used for payment |
+| `transactionNetworkLabel` | `string \| null` | Human-readable label (e.g. "Base") |
+| `transactionUrl` | `string \| null` | Block explorer link |
+| `connectedChains` | `{ solana: boolean, evm: boolean }` | Which wallets are connected |
+| `isConnected` | `boolean` | Any wallet connected |
+| `reset` | `() => void` | Reset state to idle |
+
+---
+
+### Server SDK (Express)
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+
+const relai = new Relai({
+  apiKey: process.env.RELAI_API_KEY,
+  network: 'solana', // or 'base', 'avalanche', 'skale-base'
+});
+
+// Protect any Express route with micropayments
+app.get('/api/data', relai.protect({
+  payTo: 'YourWalletAddress',
+  price: 0.01,  // $0.01 USDC
+  description: 'Premium data access',
+}), (req, res) => {
+  res.json({ data: 'Protected content', payment: req.payment });
+});
+```
+
+---
+
+## Utilities
+
+```typescript
+import { toAtomicUnits, fromAtomicUnits } from '@relai-fi/x402/utils';
+
+toAtomicUnits(0.05, 6);       // '50000'   ($0.05 USDC)
+toAtomicUnits(1.50, 6);       // '1500000' ($1.50 USDC)
+
+fromAtomicUnits('50000', 6);  // 0.05
+fromAtomicUnits('1500000', 6); // 1.5
+```
+
+### Payload Conversion (v1 ↔ v2)
+
+```typescript
+import { convertV1ToV2, convertV2ToV1, networkV1ToV2 } from '@relai-fi/x402/utils';
+
+networkV1ToV2('solana');     // 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+networkV1ToV2('base');       // 'eip155:8453'
+networkV1ToV2('avalanche');  // 'eip155:43114'
+networkV1ToV2('skale-base'); // 'eip155:1187947933'
+
+const v2Payload = convertV1ToV2(v1Payload);
+const v1Payload = convertV2ToV1(v2Payload);
+```
+
+---
+
+## How It Works
+
+```
+Client                        Server                     Facilitator
+  |                             |                             |
+  |── GET /api/data ──────────>|                             |
+  |<── 402 Payment Required ───|                             |
+  |   (accepts: network, amount, asset)                      |
+  |                             |                             |
+  | SDK signs payment           |                             |
+  | (EIP-3009/SPL)              |                             |
+  |                             |                             |
+  |── GET /api/data ──────────>|                             |
+  |   X-PAYMENT: <signed>      |── settle ─────────────────>|
+  |                             |<── tx hash ────────────────|
+  |<── 200 OK + data ─────────|                             |
+  |   PAYMENT-RESPONSE: <tx>   |                             |
+```
+
+---
+
+## Development
+
+```bash
+npm run build        # Build ESM + CJS bundles
+npm run dev          # Watch mode
+npm run type-check   # TypeScript checks
+npm test             # Run tests
+```
+
+---
+
+## License
+
+MIT
+
+---
+
+<p align="center">
+  <a href="https://facilitator.x402.fi">RelAI Facilitator</a> · 
+  <a href="https://relai.fi">Marketplace</a> ·
+  <a href="https://github.com/web3luka/relai-sdk">GitHub</a>
+</p>

package/dist/client.cjs

@@ -0,0 +1,393 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  createX402Client: () => createX402Client,
+  default: () => client_default
+});
+module.exports = __toCommonJS(client_exports);
+var import_web3 = require("@solana/web3.js");
+var import_spl_token = require("@solana/spl-token");
+
+// src/types.ts
+var RELAI_FACILITATOR_URL = "https://facilitator.x402.fi";
+var NETWORK_CAIP2 = {
+  "solana": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "base": "eip155:8453",
+  "avalanche": "eip155:43114",
+  "skale-base": "eip155:1187947933"
+};
+var CAIP2_TO_NETWORK = Object.fromEntries(
+  Object.entries(NETWORK_CAIP2).map(([k, v]) => [v, k])
+);
+var CHAIN_IDS = {
+  "base": 8453,
+  "avalanche": 43114,
+  "skale-base": 1187947933
+};
+var USDC_ADDRESSES = {
+  "solana": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+  "base": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "avalanche": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  "skale-base": "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20"
+};
+var SOLANA_MAINNET_NETWORK = NETWORK_CAIP2["solana"];
+var BASE_MAINNET_NETWORK = NETWORK_CAIP2["base"];
+var USDC_SOLANA = USDC_ADDRESSES["solana"];
+var USDC_BASE = USDC_ADDRESSES["base"];
+var RELAI_NETWORKS = ["solana", "base", "avalanche", "skale-base"];
+function isSolana(network) {
+  return network === "solana" || network.startsWith("solana:");
+}
+function isEvm(network) {
+  return ["base", "avalanche", "skale-base"].includes(network) || network.startsWith("eip155:");
+}
+function normalizeNetwork(network) {
+  if (RELAI_NETWORKS.includes(network)) return network;
+  const fromCaip2 = CAIP2_TO_NETWORK[network];
+  if (fromCaip2) return fromCaip2;
+  if (network.startsWith("solana:")) return "solana";
+  if (network.startsWith("eip155:")) {
+    const chainId = parseInt(network.split(":")[1]);
+    const entry = Object.entries(CHAIN_IDS).find(([, id]) => id === chainId);
+    if (entry) return entry[0];
+  }
+  return null;
+}
+
+// src/client.ts
+var PERMIT_NETWORKS = /* @__PURE__ */ new Set([]);
+var DEFAULT_EVM_RPC_URLS = {
+  "skale-base": "https://skale-base.skalenodes.com/v1/base",
+  "base": "https://mainnet.base.org",
+  "avalanche": "https://api.avax.network/ext/bc/C/rpc"
+};
+function createX402Client(config) {
+  const {
+    wallets = {},
+    wallet: legacyWallet,
+    facilitatorUrl = RELAI_FACILITATOR_URL,
+    preferredNetwork,
+    solanaRpcUrl = "https://api.mainnet-beta.solana.com",
+    evmRpcUrls = {},
+    maxAmountAtomic,
+    verbose = false
+  } = config;
+  const log = verbose ? console.log.bind(console, "[relai-x402]") : () => {
+  };
+  const effectiveWallets = { ...wallets };
+  if (legacyWallet && !effectiveWallets.solana) {
+    effectiveWallets.solana = legacyWallet;
+  }
+  const hasSolanaWallet = Boolean(
+    effectiveWallets.solana?.publicKey && effectiveWallets.solana?.signTransaction
+  );
+  if (hasSolanaWallet) log("Solana wallet ready");
+  function selectAccept(accepts) {
+    if (preferredNetwork) {
+      const caip2 = NETWORK_CAIP2[preferredNetwork];
+      for (const a of accepts) {
+        const net = a.network || "";
+        if (net === preferredNetwork || net === caip2) {
+          const chain = isSolana(net) ? "solana" : "evm";
+          if (chain === "solana" && hasSolanaWallet || chain === "evm" && effectiveWallets.evm) {
+            return { accept: a, chain };
+          }
+        }
+      }
+    }
+    for (const a of accepts) {
+      const net = a.network || "";
+      if (isSolana(net) && hasSolanaWallet) return { accept: a, chain: "solana" };
+      if (isEvm(net) && effectiveWallets.evm) return { accept: a, chain: "evm" };
+    }
+    return null;
+  }
+  async function evmRpcCall(rpcUrl, to, data) {
+    const res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to, data }, "latest"],
+        id: 1
+      })
+    });
+    const json = await res.json();
+    if (json.error) throw new Error(`RPC error: ${json.error.message}`);
+    return json.result;
+  }
+  function getEvmRpcUrl(network) {
+    return evmRpcUrls[network] || DEFAULT_EVM_RPC_URLS[network] || "";
+  }
+  async function buildEvmPermitPayment(accept, requirements, url) {
+    const evmWallet = effectiveWallets.evm;
+    const extra = accept.extra || {};
+    const rawNetwork = accept.network || "";
+    const network = normalizeNetwork(rawNetwork);
+    const chainId = network ? CHAIN_IDS[network] : parseInt(rawNetwork.split(":")[1] || "8453");
+    const paymentAmount = accept.amount || accept.maxAmountRequired;
+    const spender = extra.feePayer || accept.payTo;
+    const usdcAddress = accept.asset;
+    const rpcUrl = getEvmRpcUrl(network || rawNetwork);
+    if (!rpcUrl) throw new Error(`[relai-x402] No EVM RPC URL for network ${network || rawNetwork}`);
+    log("Building EIP-2612 permit on chain", chainId);
+    const paddedAddress = evmWallet.address.toLowerCase().replace("0x", "").padStart(64, "0");
+    const nonceHex = await evmRpcCall(rpcUrl, usdcAddress, "0x7ecebe00" + paddedAddress);
+    const nonce = nonceHex ? parseInt(nonceHex, 16) : 0;
+    if (isNaN(nonce)) throw new Error(`[relai-x402] Failed to read permit nonce from ${usdcAddress} on ${rpcUrl}`);
+    log("  Permit nonce:", nonce);
+    const nameHex = await evmRpcCall(rpcUrl, usdcAddress, "0x06fdde03");
+    let tokenName = "USD Coin";
+    try {
+      const offset = parseInt(nameHex.slice(2, 66), 16) * 2;
+      const length = parseInt(nameHex.slice(2 + offset, 2 + offset + 64), 16);
+      const hex = nameHex.slice(2 + offset + 64, 2 + offset + 64 + length * 2);
+      tokenName = decodeURIComponent(hex.replace(/[0-9a-f]{2}/g, "%$&"));
+    } catch {
+      tokenName = extra.name || "USD Coin";
+    }
+    log("  Token name:", tokenName);
+    const deadline = Math.floor(Date.now() / 1e3) + 600;
+    const domain = {
+      name: tokenName,
+      version: extra.version || "2",
+      chainId,
+      verifyingContract: usdcAddress
+    };
+    const types = {
+      Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ]
+    };
+    const message = {
+      owner: evmWallet.address,
+      spender,
+      value: paymentAmount,
+      nonce: String(nonce),
+      deadline: String(deadline)
+    };
+    log("Signing EIP-2612 permit:", message);
+    const signature = await evmWallet.signTypedData({
+      domain,
+      types,
+      message,
+      primaryType: "Permit"
+    });
+    const sigHex = signature.replace("0x", "");
+    const r = "0x" + sigHex.slice(0, 64);
+    const s = "0x" + sigHex.slice(64, 128);
+    const v = parseInt(sigHex.slice(128, 130), 16);
+    log("  Permit signed: v=%d r=%s s=%s", v, r, s);
+    const paymentPayload = {
+      x402Version: 2,
+      scheme: "exact",
+      network: network || rawNetwork,
+      payload: {
+        userAddress: evmWallet.address,
+        permit: { deadline: String(deadline), v, r, s },
+        amount: paymentAmount
+      }
+    };
+    return btoa(JSON.stringify(paymentPayload));
+  }
+  async function buildEvmPayment(accept, requirements, url) {
+    const evmWallet = effectiveWallets.evm;
+    const extra = accept.extra || {};
+    const rawNetwork = accept.network || "";
+    const network = normalizeNetwork(rawNetwork);
+    const chainId = network ? CHAIN_IDS[network] : parseInt(rawNetwork.split(":")[1] || "8453");
+    const paymentAmount = accept.amount || accept.maxAmountRequired;
+    const domain = {
+      name: extra.name || "USD Coin",
+      version: extra.version || "2",
+      chainId,
+      verifyingContract: accept.asset
+    };
+    const validAfter = 0;
+    const validBefore = Math.floor(Date.now() / 1e3) + 3600;
+    const nonce = "0x" + [...crypto.getRandomValues(new Uint8Array(32))].map((b) => b.toString(16).padStart(2, "0")).join("");
+    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" }
+      ]
+    };
+    const spender = extra.feePayer || accept.payTo;
+    const message = {
+      from: evmWallet.address,
+      to: spender,
+      value: paymentAmount,
+      validAfter: String(validAfter),
+      validBefore: String(validBefore),
+      nonce
+    };
+    log("Signing EIP-3009 transferWithAuthorization on chain", chainId);
+    const signature = await evmWallet.signTypedData({
+      domain,
+      types,
+      message,
+      primaryType: "TransferWithAuthorization"
+    });
+    const paymentPayload = {
+      x402Version: 2,
+      resource: requirements.resource || { url },
+      accepted: accept,
+      payload: {
+        authorization: message,
+        signature
+      },
+      facilitatorUrl
+    };
+    return btoa(JSON.stringify(paymentPayload));
+  }
+  async function buildSolanaPayment(accept, requirements, url) {
+    const solWallet = effectiveWallets.solana;
+    const extra = accept.extra || {};
+    if (!extra.feePayer) {
+      throw new Error("[relai-x402] Missing feePayer in Solana payment requirements");
+    }
+    const connection = new import_web3.Connection(solanaRpcUrl, "confirmed");
+    const userPubkey = new import_web3.PublicKey(solWallet.publicKey.toString());
+    const merchantPubkey = new import_web3.PublicKey(accept.payTo);
+    const feePayerPubkey = new import_web3.PublicKey(extra.feePayer);
+    const mintPubkey = new import_web3.PublicKey(accept.asset);
+    const paymentAmount = BigInt(accept.amount || accept.maxAmountRequired);
+    log("Building Solana SPL transfer");
+    log("  User:", userPubkey.toBase58());
+    log("  Merchant:", merchantPubkey.toBase58());
+    log("  FeePayer:", feePayerPubkey.toBase58());
+    log("  Mint:", mintPubkey.toBase58());
+    log("  Amount:", paymentAmount.toString());
+    const mintInfo = await (0, import_spl_token.getMint)(connection, mintPubkey);
+    const programId = mintInfo.address.equals(mintPubkey) ? mintInfo.owner?.toBase58?.() === import_spl_token.TOKEN_2022_PROGRAM_ID.toBase58() ? import_spl_token.TOKEN_2022_PROGRAM_ID : import_spl_token.TOKEN_PROGRAM_ID : import_spl_token.TOKEN_PROGRAM_ID;
+    const sourceAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+      mintPubkey,
+      userPubkey,
+      false,
+      programId
+    );
+    const destinationAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+      mintPubkey,
+      merchantPubkey,
+      true,
+      programId
+    );
+    log("  Source ATA:", sourceAta.toBase58());
+    log("  Dest ATA:", destinationAta.toBase58());
+    const transferIx = (0, import_spl_token.createTransferCheckedInstruction)(
+      sourceAta,
+      mintPubkey,
+      destinationAta,
+      userPubkey,
+      paymentAmount,
+      mintInfo.decimals,
+      [],
+      programId
+    );
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    const message = new import_web3.TransactionMessage({
+      payerKey: feePayerPubkey,
+      recentBlockhash: blockhash,
+      instructions: [transferIx]
+    }).compileToV0Message();
+    const transaction = new import_web3.VersionedTransaction(message);
+    const signedTx = await solWallet.signTransaction(transaction);
+    log("Transaction signed by user");
+    const serializedTx = Buffer.from(signedTx.serialize()).toString("base64");
+    const paymentPayload = {
+      x402Version: 2,
+      resource: requirements.resource || { url },
+      accepted: accept,
+      payload: {
+        transaction: serializedTx
+      }
+    };
+    return btoa(JSON.stringify(paymentPayload));
+  }
+  async function x402Fetch(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    log("Request:", url);
+    const response = await fetch(input, init);
+    if (response.status !== 402) return response;
+    log("Got 402 Payment Required");
+    let requirements;
+    try {
+      requirements = await response.clone().json();
+    } catch {
+      throw new Error("[relai-x402] Failed to parse 402 response body");
+    }
+    const accepts = requirements.accepts || [];
+    if (!accepts.length) throw new Error("[relai-x402] No payment options in 402 response");
+    const selected = selectAccept(accepts);
+    if (!selected) {
+      const networks = accepts.map((a) => a.network).join(", ");
+      throw new Error(`[relai-x402] No wallet available for networks: ${networks}`);
+    }
+    const { accept, chain } = selected;
+    const amount = accept.amount || accept.maxAmountRequired;
+    log(`Selected: ${chain} / ${accept.network} / amount=${amount}`);
+    if (maxAmountAtomic && BigInt(amount) > BigInt(maxAmountAtomic)) {
+      throw new Error(`[relai-x402] Amount ${amount} exceeds max ${maxAmountAtomic}`);
+    }
+    if (chain === "solana" && hasSolanaWallet) {
+      const paymentHeader = await buildSolanaPayment(accept, requirements, url);
+      log("Retrying with X-PAYMENT header (Solana)");
+      return fetch(input, {
+        ...init,
+        headers: {
+          ...init?.headers || {},
+          "X-PAYMENT": paymentHeader
+        }
+      });
+    }
+    if (chain === "evm") {
+      const evmNetwork = normalizeNetwork(accept.network || "");
+      const usePermit = evmNetwork && PERMIT_NETWORKS.has(evmNetwork);
+      const paymentHeader = usePermit ? await buildEvmPermitPayment(accept, requirements, url) : await buildEvmPayment(accept, requirements, url);
+      log("Retrying with X-PAYMENT header");
+      return fetch(input, {
+        ...init,
+        headers: {
+          ...init?.headers || {},
+          "X-PAYMENT": paymentHeader
+        }
+      });
+    }
+    throw new Error("[relai-x402] Unexpected state \u2014 no payment handler matched");
+  }
+  return { fetch: x402Fetch };
+}
+var client_default = createX402Client;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createX402Client
+});
+//# sourceMappingURL=client.cjs.map