@piprail/sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1681 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkWQWNPAYQcjs = require('./chunk-WQWNPAYQ.cjs');
+
+// src/drivers/registry.ts
+var byFamily = /* @__PURE__ */ new Map();
+function registerDriver(driver) {
+  byFamily.set(driver.family, driver);
+}
+function isRegistered(family) {
+  return byFamily.has(family);
+}
+function familyForChain(chain) {
+  if (typeof chain === "string") {
+    if (chain.startsWith("solana")) return "solana";
+    if (chain.startsWith("ton")) return "ton";
+    if (chain.startsWith("stellar")) return "stellar";
+    if (chain.startsWith("xrpl")) return "xrpl";
+    if (chain.startsWith("tron")) return "tron";
+    if (chain.startsWith("sui")) return "sui";
+    if (chain.startsWith("near")) return "near";
+    return "evm";
+  }
+  return "evm";
+}
+function resolveNetwork(opts) {
+  const family = familyForChain(opts.chain);
+  const driver = byFamily.get(family);
+  if (!driver) {
+    throw new (0, _chunkWQWNPAYQcjs.UnsupportedNetworkError)(
+      `No driver registered for the "${family}" family \u2014 it may not be mounted yet (use the async resolveNetwork()).`
+    );
+  }
+  const net = driver.resolve(opts);
+  if (!net) {
+    throw new (0, _chunkWQWNPAYQcjs.UnsupportedNetworkError)(
+      `The ${family} driver didn't recognise this chain input.`
+    );
+  }
+  return net;
+}
+
+// src/drivers/evm/index.ts
+var _viem = require('viem');
+
+// src/drivers/evm/chains.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chains = require('viem/chains');
+var CHAINS = {
+  ethereum: {
+    chain: _chains.mainnet,
+    // viem's bundled default (eth.merkle.io) is flaky; pin a reliable public RPC.
+    defaultRpc: "https://ethereum-rpc.publicnode.com",
+    tokens: {
+      USDC: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", decimals: 6, symbol: "USDT" }
+    }
+  },
+  base: {
+    chain: _chains.base,
+    tokens: {
+      USDC: { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6, symbol: "USDC" }
+    }
+  },
+  arbitrum: {
+    chain: _chains.arbitrum,
+    tokens: {
+      USDC: { address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", decimals: 6, symbol: "USDT" }
+    }
+  },
+  optimism: {
+    chain: _chains.optimism,
+    tokens: {
+      USDC: { address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58", decimals: 6, symbol: "USDT" }
+    }
+  },
+  polygon: {
+    chain: _chains.polygon,
+    tokens: {
+      USDC: { address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F", decimals: 6, symbol: "USDT" }
+    }
+  },
+  bnb: {
+    chain: _chains.bsc,
+    tokens: {
+      // Binance-Peg tokens on BNB Chain are 18 decimals (not the usual 6).
+      USDC: { address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d", decimals: 18, symbol: "USDC" },
+      USDT: { address: "0x55d398326f99059fF775485246999027B3197955", decimals: 18, symbol: "USDT" }
+    }
+  },
+  avalanche: {
+    chain: _chains.avalanche,
+    tokens: {
+      USDC: { address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7", decimals: 6, symbol: "USDT" }
+    }
+  },
+  // ── More popular EVM mainnets. Every address below was verified on-chain
+  //    (symbol + decimals read via RPC) before being committed here. ──
+  mantle: {
+    chain: _chains.mantle,
+    tokens: {
+      USDC: { address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE", decimals: 6, symbol: "USDT" }
+    }
+  },
+  sonic: {
+    chain: _chains.sonic,
+    tokens: {
+      USDC: { address: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x6047828dc181963ba44974801FF68e538dA5eaF9", decimals: 6, symbol: "USDT" }
+    }
+  },
+  linea: {
+    chain: _chains.linea,
+    tokens: {
+      USDC: { address: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0xA219439258ca9da29E9Cc4cE5596924745e12B93", decimals: 6, symbol: "USDT" }
+    }
+  },
+  scroll: {
+    chain: _chains.scroll,
+    tokens: {
+      USDC: { address: "0x06eFdBFf2a14a7c8E15944D1F4A48F9F95F663A4", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0xf55BEC9cafDbE8730f096Aa55dad6D22d44099Df", decimals: 6, symbol: "USDT" }
+    }
+  },
+  celo: {
+    chain: _chains.celo,
+    tokens: {
+      USDC: { address: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e", decimals: 6, symbol: "USDT" }
+    }
+  },
+  zksync: {
+    chain: _chains.zksync,
+    tokens: {
+      USDC: { address: "0x1d17CBcF0D6D143135aE902365D2E5e2A16538D4", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x493257fD37EDB34451f62EDf8D2a0C418852bA4C", decimals: 6, symbol: "USDT" }
+    }
+  },
+  unichain: {
+    chain: _chains.unichain,
+    tokens: {
+      USDC: { address: "0x078D782b760474a361dDA0AF3839290b0EF57AD6", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x9151434b16b9763660705744891fA906F660EcC5", decimals: 6, symbol: "USDT" }
+    }
+  },
+  worldchain: {
+    chain: _chains.worldchain,
+    tokens: {
+      USDC: { address: "0x79A02482A880bCE3F13e09Da970dC34db4CD24d1", decimals: 6, symbol: "USDC" }
+    }
+  },
+  // Sei EVM (pacific-1, chainId 1329) — native Circle USDC. Sei's "USDT" is
+  // USDT0 (LayerZero/omnichain), not Circle/Tether-native, so it's intentionally
+  // omitted; pass it as a custom { address, decimals } if you need it.
+  sei: {
+    chain: _chains.sei,
+    tokens: {
+      USDC: { address: "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392", decimals: 6, symbol: "USDC" }
+    }
+  },
+  // Injective native EVM (chainId 1776) — native Circle USDC + USDT via the
+  // MultiVM Token Standard (one address across EVM + Wasm, not bridged).
+  injective: {
+    chain: _chains.injective,
+    tokens: {
+      USDC: { address: "0xa00C59fF5a080D2b954d0c75e46E22a0c371235a", decimals: 6, symbol: "USDC" },
+      USDT: { address: "0x88f7F2b685F9692caf8c478f5BADF09eE9B1Cc13", decimals: 6, symbol: "USDT" }
+    }
+  }
+};
+function isViemChain(input) {
+  return typeof input === "object" && "rpcUrls" in input;
+}
+function knownTokensForId(chainId) {
+  for (const preset of Object.values(CHAINS)) {
+    if (preset.chain.id === chainId) return preset.tokens;
+  }
+  return {};
+}
+function resolveChain(input, rpcUrlOverride) {
+  if (typeof input === "string") {
+    const preset = CHAINS[input];
+    if (!preset) {
+      const names = Object.keys(CHAINS).join(", ");
+      throw new Error(
+        `resolveChain: unknown chain "${input}". Built-in names: ${names}. Or pass a viem Chain or { id, rpcUrl } for any other EVM chain.`
+      );
+    }
+    const rpcUrl2 = _nullishCoalesce(_nullishCoalesce(rpcUrlOverride, () => ( preset.defaultRpc)), () => ( preset.chain.rpcUrls.default.http[0]));
+    if (!rpcUrl2) {
+      throw new Error(`resolveChain: "${input}" has no default RPC URL \u2014 pass rpcUrl.`);
+    }
+    return { chain: preset.chain, chainId: preset.chain.id, rpcUrl: rpcUrl2, tokens: preset.tokens };
+  }
+  if (isViemChain(input)) {
+    const rpcUrl2 = _nullishCoalesce(rpcUrlOverride, () => ( input.rpcUrls.default.http[0]));
+    if (!rpcUrl2) {
+      throw new Error(
+        `resolveChain: viem chain ${input.id} has no default RPC URL \u2014 pass rpcUrl explicitly.`
+      );
+    }
+    return { chain: input, chainId: input.id, rpcUrl: rpcUrl2, tokens: knownTokensForId(input.id) };
+  }
+  const rpcUrl = _nullishCoalesce(rpcUrlOverride, () => ( input.rpcUrl));
+  if (!rpcUrl) {
+    throw new Error(`resolveChain: chain ${input.id} needs an rpcUrl.`);
+  }
+  const chain = _viem.defineChain.call(void 0, {
+    id: input.id,
+    name: _nullishCoalesce(input.name, () => ( `EVM ${input.id}`)),
+    nativeCurrency: _nullishCoalesce(input.nativeCurrency, () => ( { name: "Ether", symbol: "ETH", decimals: 18 })),
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return { chain, chainId: input.id, rpcUrl, tokens: knownTokensForId(input.id) };
+}
+
+// src/drivers/evm/wallet.ts
+
+
+
+
+var _accounts = require('viem/accounts');
+function createWalletAdapter(config, resolved) {
+  if ("privateKey" in config) {
+    const account = _accounts.privateKeyToAccount.call(void 0, config.privateKey);
+    const transport = _viem.http.call(void 0, resolved.rpcUrl);
+    const walletClient = _viem.createWalletClient.call(void 0, { account, chain: resolved.chain, transport });
+    return { account, walletClient };
+  }
+  const wc = config.walletClient;
+  if (!wc.account) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      "chain is EVM; the provided walletClient has no attached account. Use `createWalletClient({ account, chain, transport })`, or pass { privateKey }."
+    );
+  }
+  if (wc.chain && wc.chain.id !== resolved.chainId) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongChainError)(
+      `PipRailClient: walletClient is on chain ${wc.chain.id} but the SDK was configured with chain ${resolved.chainId}. They must match.`
+    );
+  }
+  return { account: wc.account, walletClient: wc };
+}
+
+// src/drivers/evm/pay.ts
+
+
+
+async function payEvm(input) {
+  const { walletClient, account, chain, accept } = input;
+  const amount = BigInt(accept.amount);
+  const payTo = accept.payTo;
+  if (accept.asset === "native") {
+    return walletClient.sendTransaction({
+      account,
+      chain,
+      to: payTo,
+      value: amount
+    });
+  }
+  return walletClient.writeContract({
+    account,
+    chain,
+    address: accept.asset,
+    abi: _viem.erc20Abi,
+    functionName: "transfer",
+    args: [payTo, amount]
+  });
+}
+
+// src/drivers/evm/verify.ts
+
+
+
+
+
+var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+async function verifyEvm(params) {
+  const { publicClient, txHash, accept, minConfirmations } = params;
+  const requiredAmount = BigInt(accept.amount);
+  const payTo = _viem.getAddress.call(void 0, accept.payTo);
+  let receipt;
+  try {
+    receipt = await publicClient.getTransactionReceipt({ hash: txHash });
+  } catch (e2) {
+    return {
+      ok: false,
+      error: "tx_not_found",
+      detail: `Transaction ${txHash} not found or not yet mined.`
+    };
+  }
+  if (receipt.status !== "success") {
+    return {
+      ok: false,
+      error: "tx_reverted",
+      detail: `Transaction ${txHash} reverted on-chain.`
+    };
+  }
+  let latestBlock;
+  let block;
+  try {
+    latestBlock = await publicClient.getBlockNumber();
+    block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
+  } catch (e3) {
+    return {
+      ok: false,
+      error: "tx_not_found",
+      detail: `Could not read chain state for ${txHash} (transient RPC failure) \u2014 retry.`
+    };
+  }
+  const confirmations = latestBlock >= receipt.blockNumber ? latestBlock - receipt.blockNumber + 1n : 0n;
+  if (confirmations < BigInt(minConfirmations)) {
+    return {
+      ok: false,
+      error: "insufficient_confirmations",
+      detail: `Need ${minConfirmations} confirmation(s), have ${confirmations}.`
+    };
+  }
+  const ageSeconds = Math.floor(Date.now() / 1e3) - Number(block.timestamp);
+  if (ageSeconds > accept.maxTimeoutSeconds) {
+    return {
+      ok: false,
+      error: "payment_expired",
+      detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+    };
+  }
+  let payer;
+  if (accept.asset === "native") {
+    let tx;
+    try {
+      tx = await publicClient.getTransaction({ hash: txHash });
+    } catch (e4) {
+      return {
+        ok: false,
+        error: "tx_not_found",
+        detail: `Could not read ${txHash} (transient RPC failure) \u2014 retry.`
+      };
+    }
+    if (!tx.to || _viem.getAddress.call(void 0, tx.to) !== payTo) {
+      return {
+        ok: false,
+        error: "wrong_recipient",
+        detail: `Native payment in ${txHash} was not sent to ${payTo}.`
+      };
+    }
+    if (tx.value < requiredAmount) {
+      return {
+        ok: false,
+        error: "amount_too_low",
+        detail: `Sent ${tx.value}, required ${requiredAmount}.`
+      };
+    }
+    payer = _viem.getAddress.call(void 0, tx.from);
+  } else {
+    const asset = _viem.getAddress.call(void 0, accept.asset);
+    const transferred = sumTransfersTo(receipt.logs, asset, payTo);
+    if (transferred.total < requiredAmount) {
+      return {
+        ok: false,
+        error: "transfer_not_found",
+        detail: `No ERC-20 Transfer of >= ${requiredAmount} (token ${asset}) to ${payTo} in ${txHash}.`
+      };
+    }
+    payer = _nullishCoalesce(transferred.from, () => ( ZERO_ADDRESS));
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: txHash,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function sumTransfersTo(logs, asset, payTo) {
+  let total = 0n;
+  let from = null;
+  for (const log of logs) {
+    if (_viem.getAddress.call(void 0, log.address) !== asset) continue;
+    if (log.topics[0] !== TRANSFER_TOPIC) continue;
+    try {
+      const decoded = _viem.decodeEventLog.call(void 0, {
+        abi: _viem.erc20Abi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName !== "Transfer") continue;
+      const args = decoded.args;
+      if (_viem.getAddress.call(void 0, args.to) !== payTo) continue;
+      total += args.value;
+      from = _viem.getAddress.call(void 0, args.from);
+    } catch (e5) {
+    }
+  }
+  return { total, from };
+}
+
+// src/x402.ts
+var HEADER_REQUIRED = "payment-required";
+var HEADER_SIGNATURE = "payment-signature";
+var HEADER_RESPONSE = "payment-response";
+function decodeBase64(b64) {
+  if (typeof atob === "function") return atob(b64);
+  if (typeof Buffer !== "undefined") return Buffer.from(b64, "base64").toString("utf8");
+  throw new Error("No base64 decoder available in this runtime.");
+}
+function encodeBase64(str) {
+  if (typeof btoa === "function") return btoa(str);
+  if (typeof Buffer !== "undefined") return Buffer.from(str, "utf8").toString("base64");
+  throw new Error("No base64 encoder available in this runtime.");
+}
+function fromBase64Json(b64) {
+  try {
+    return JSON.parse(decodeBase64(b64));
+  } catch (e6) {
+    return null;
+  }
+}
+function toBase64Json(value) {
+  return encodeBase64(JSON.stringify(value));
+}
+function networkForChain(chainId) {
+  return `eip155:${chainId}`;
+}
+function chainIdFromNetwork(network) {
+  const match = /^eip155:(\d+)$/.exec(network);
+  if (!match || !match[1]) return null;
+  const n = Number(match[1]);
+  return Number.isSafeInteger(n) ? n : null;
+}
+function buildChallengeHeader(challenge) {
+  return toBase64Json(challenge);
+}
+function buildReceiptHeader(receipt) {
+  return toBase64Json(receipt);
+}
+function buildSignatureHeader(signature) {
+  return toBase64Json(signature);
+}
+async function parseChallenge(response) {
+  const headerValue = response.headers.get(HEADER_REQUIRED);
+  if (headerValue) {
+    const parsed = fromBase64Json(headerValue);
+    if (isValidChallenge(parsed)) return parsed;
+  }
+  try {
+    const body = await response.clone().json();
+    if (isValidChallenge(body)) return body;
+  } catch (e7) {
+  }
+  return null;
+}
+function parseReceipt(response) {
+  const headerValue = response.headers.get(HEADER_RESPONSE);
+  if (!headerValue) return null;
+  const parsed = fromBase64Json(headerValue);
+  return isValidReceipt(parsed) ? parsed : null;
+}
+function parseSignatureHeader(value) {
+  const parsed = fromBase64Json(value);
+  if (!parsed || typeof parsed !== "object") return null;
+  const v = parsed;
+  const accepted = v.accepted;
+  const scheme = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _ => _.scheme]), () => ( v.scheme));
+  if (scheme !== "onchain-proof") return null;
+  const payload = v.payload;
+  if (!payload || typeof payload.txHash !== "string" || typeof payload.nonce !== "string") {
+    return null;
+  }
+  return parsed;
+}
+function isValidChallenge(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.x402Version !== 2) return false;
+  if (!Array.isArray(v.accepts) || v.accepts.length === 0) return false;
+  if (!v.resource || typeof v.resource !== "object") return false;
+  return true;
+}
+function isValidReceipt(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.scheme !== "onchain-proof") return false;
+  if (typeof v.transaction !== "string" && typeof v.txHash !== "string") return false;
+  if (typeof v.payer !== "string") return false;
+  return true;
+}
+function pickAccept(challenge, matches) {
+  for (const accept of challenge.accepts) {
+    if (accept.scheme === "onchain-proof" && matches(accept.network)) return accept;
+  }
+  return null;
+}
+
+// src/drivers/evm/index.ts
+var evmDriver = {
+  family: "evm",
+  resolve(opts) {
+    if (typeof opts.chain === "string" && /^(solana|ton|stellar)/.test(opts.chain)) return null;
+    if (typeof opts.chain === "string") {
+      return makeEvmNetwork(resolveChain(opts.chain, opts.rpcUrl));
+    }
+    let resolved;
+    try {
+      resolved = resolveChain(opts.chain, opts.rpcUrl);
+    } catch (e8) {
+      return null;
+    }
+    return makeEvmNetwork(resolved);
+  }
+};
+function makeEvmNetwork(resolved) {
+  const network = networkForChain(resolved.chainId);
+  const publicClient = _viem.createPublicClient.call(void 0, {
+    chain: resolved.chain,
+    transport: _viem.http.call(void 0, resolved.rpcUrl)
+  });
+  return {
+    family: "evm",
+    network,
+    supports: (n) => chainIdFromNetwork(n) === resolved.chainId,
+    resolveToken(token) {
+      if (token === "native") {
+        return {
+          asset: "native",
+          decimals: resolved.chain.nativeCurrency.decimals,
+          symbol: resolved.chain.nativeCurrency.symbol
+        };
+      }
+      if (typeof token === "string") {
+        const info = resolved.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(resolved.tokens).join(", ") || "(none built in)";
+          throw new (0, _chunkWQWNPAYQcjs.UnknownTokenError)(
+            `token "${token}" isn't built in for ${resolved.chain.name} (known: ${known}). Pass { address, decimals } instead, or use 'native'.`
+          );
+        }
+        return { asset: info.address, decimals: info.decimals, symbol: info.symbol };
+      }
+      _chunkWQWNPAYQcjs.rejectForeignToken.call(void 0, token, "evm", network);
+      if (!("address" in token)) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is EVM; a custom token must be { address, decimals }.`
+        );
+      }
+      return {
+        asset: token.address,
+        decimals: token.decimals,
+        ...token.symbol ? { symbol: token.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") {
+        return {
+          symbol: resolved.chain.nativeCurrency.symbol,
+          decimals: resolved.chain.nativeCurrency.decimals
+        };
+      }
+      let normalized;
+      try {
+        normalized = _viem.getAddress.call(void 0, asset);
+      } catch (e9) {
+        return null;
+      }
+      for (const info of Object.values(resolved.tokens)) {
+        if (_viem.getAddress.call(void 0, info.address) === normalized) {
+          return { symbol: info.symbol, decimals: info.decimals };
+        }
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (!_viem.isAddress.call(void 0, payTo)) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is EVM, but payTo "${payTo}" is not a valid 0x address.`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      if (typeof wallet !== "object" || wallet === null || !("privateKey" in wallet) && !("walletClient" in wallet)) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is EVM; wallet must be { privateKey } or { walletClient }.`
+        );
+      }
+      return { _native: createWalletAdapter(wallet, resolved) };
+    },
+    async send(wallet, accept) {
+      const a = wallet._native;
+      try {
+        return await payEvm({
+          walletClient: a.walletClient,
+          account: a.account,
+          chain: resolved.chain,
+          accept
+        });
+      } catch (err) {
+        if (isViemInsufficientFunds(err)) {
+          throw new (0, _chunkWQWNPAYQcjs.InsufficientFundsError)(
+            err instanceof Error ? err.message : "Insufficient funds for payment.",
+            { cause: err }
+          );
+        }
+        throw _nullishCoalesce(_chunkWQWNPAYQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+      }
+    },
+    async confirm(ref, minConfirmations) {
+      try {
+        const receipt = await publicClient.waitForTransactionReceipt({
+          hash: ref,
+          confirmations: minConfirmations
+        });
+        return { height: receipt.blockNumber.toString() };
+      } catch (err) {
+        throw new (0, _chunkWQWNPAYQcjs.ConfirmationTimeoutError)(
+          `EVM tx ${ref} did not reach ${minConfirmations} confirmation(s) in time.`,
+          { cause: err }
+        );
+      }
+    },
+    async estimateCost(accept) {
+      const { decimals, symbol } = resolved.chain.nativeCurrency;
+      const gasLimit = accept.asset === "native" ? 21000n : 65000n;
+      try {
+        const gasPrice = await publicClient.getGasPrice();
+        return _chunkWQWNPAYQcjs.nativeCost.call(void 0, {
+          symbol,
+          decimals,
+          fee: gasPrice * gasLimit,
+          basis: "estimated",
+          detail: `~${gasLimit} gas @ ${gasPrice} wei/gas`
+        });
+      } catch (e10) {
+        const gasPrice = 5000000000n;
+        return _chunkWQWNPAYQcjs.nativeCost.call(void 0, {
+          symbol,
+          decimals,
+          fee: gasPrice * gasLimit,
+          basis: "heuristic",
+          detail: `~${gasLimit} gas @ assumed 5 gwei (live gas price unavailable)`
+        });
+      }
+    },
+    async verify(ref, accept) {
+      return verifyEvm({
+        publicClient,
+        txHash: ref,
+        accept,
+        minConfirmations: accept.extra.minConfirmations
+      });
+    }
+  };
+}
+function isViemInsufficientFunds(err) {
+  if (err instanceof _viem.BaseError) {
+    return Boolean(err.walk((e) => e instanceof Error && e.name === "InsufficientFundsError"));
+  }
+  return err instanceof Error && err.name === "InsufficientFundsError";
+}
+
+// src/drivers/index.ts
+registerDriver(evmDriver);
+var loaders = {
+  solana: async () => {
+    let mod;
+    try {
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./solana-F7H4YDW5.cjs")));
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.MissingDriverError)(
+        `Solana selected, but its packages aren't installed. Run: npm install @solana/web3.js @solana/spl-token bs58`,
+        { cause }
+      );
+    }
+    registerDriver(mod.solanaDriver);
+  },
+  ton: async () => {
+    let mod;
+    try {
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./ton-E5RLUPD2.cjs")));
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.MissingDriverError)(
+        `TON selected, but its packages aren't installed. Run: npm install @ton/ton @ton/core @ton/crypto`,
+        { cause }
+      );
+    }
+    registerDriver(mod.tonDriver);
+  },
+  stellar: async () => {
+    let mod;
+    try {
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./stellar-BPPQTLNI.cjs")));
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.MissingDriverError)(
+        `Stellar selected, but its package isn't installed. Run: npm install @stellar/stellar-sdk`,
+        { cause }
+      );
+    }
+    registerDriver(mod.stellarDriver);
+  },
+  xrpl: async () => {
+    let mod;
+    try {
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./xrpl-6NRFT5CA.cjs")));
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.MissingDriverError)(
+        `XRPL selected, but its package isn't installed. Run: npm install xrpl`,
+        { cause }
+      );
+    }
+    registerDriver(mod.xrplDriver);
+  },
+  tron: async () => {
+    let mod;
+    try {
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./tron-3UDH7KGF.cjs")));
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.MissingDriverError)(
+        `Tron selected, but its package isn't installed. Run: npm install tronweb`,
+        { cause }
+      );
+    }
+    registerDriver(mod.tronDriver);
+  },
+  sui: async () => {
+    let mod;
+    try {
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./sui-XV4YYSGV.cjs")));
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.MissingDriverError)(
+        `Sui selected, but its package isn't installed. Run: npm install @mysten/sui`,
+        { cause }
+      );
+    }
+    registerDriver(mod.suiDriver);
+  },
+  near: async () => {
+    let mod;
+    try {
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./near-4P5XNMMB.cjs")));
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.MissingDriverError)(
+        `NEAR selected, but its package isn't installed. Run: npm install near-api-js`,
+        { cause }
+      );
+    }
+    registerDriver(mod.nearDriver);
+  }
+};
+var inFlight = /* @__PURE__ */ new Map();
+async function ensureDriver(family) {
+  if (isRegistered(family)) return;
+  const load = loaders[family];
+  if (!load) return;
+  let pending = inFlight.get(family);
+  if (!pending) {
+    pending = load();
+    inFlight.set(family, pending);
+  }
+  try {
+    await pending;
+  } catch (err) {
+    inFlight.delete(family);
+    throw err;
+  }
+}
+async function resolveNetwork2(opts) {
+  await ensureDriver(familyForChain(opts.chain));
+  return resolveNetwork(opts);
+}
+
+// src/policy.ts
+var ALLOW = { allowed: true };
+var deny = (reason) => ({ allowed: false, reason });
+function hostMatches(host, pattern) {
+  if (pattern.startsWith("*.")) {
+    const suffix = pattern.slice(1);
+    return host === pattern.slice(2) || host.endsWith(suffix);
+  }
+  return host === pattern;
+}
+function chainMatches(intent, allowed) {
+  if (typeof allowed === "string") {
+    if (typeof intent.chain === "string" && intent.chain === allowed) return true;
+    return false;
+  }
+  const id = "id" in allowed ? allowed.id : void 0;
+  return id !== void 0 && intent.network === `eip155:${id}`;
+}
+function evaluatePolicy(intent, policy, spentForAssetBase) {
+  if (!policy) return ALLOW;
+  if (policy.chains && !policy.chains.some((c) => chainMatches(intent, c))) {
+    return deny(
+      `chain ${intent.network} is not in the allowed set (policy.chains).`
+    );
+  }
+  if (policy.hosts && !policy.hosts.some((h) => hostMatches(intent.host, h))) {
+    return deny(`host ${intent.host} is not in the allowed set (policy.hosts).`);
+  }
+  if (!intent.recognized && !policy.allowUnknownTokens) {
+    return deny(
+      `asset ${intent.asset} on ${intent.network} isn't a token the SDK can price; refusing to pay it on trust. Set policy.allowUnknownTokens to override.`
+    );
+  }
+  if (policy.tokens) {
+    const sym = intent.recognized ? intent.symbol : void 0;
+    if (!sym || !policy.tokens.some((t) => t.toUpperCase() === sym.toUpperCase())) {
+      return deny(
+        `token ${_nullishCoalesce(intent.symbol, () => ( intent.asset))} is not in the allowed set (policy.tokens).`
+      );
+    }
+  }
+  if (policy.maxAmount !== void 0) {
+    const cap = _chunkWQWNPAYQcjs.floorUnits.call(void 0, policy.maxAmount, intent.decimals);
+    if (intent.amountBase > cap) {
+      return deny(
+        `payment of ${intent.amountBase} base units exceeds policy.maxAmount ` + `(${policy.maxAmount} ${_nullishCoalesce(intent.symbol, () => ( ""))}).`.trimEnd()
+      );
+    }
+  }
+  if (policy.maxTotal !== void 0) {
+    const cap = _chunkWQWNPAYQcjs.floorUnits.call(void 0, policy.maxTotal, intent.decimals);
+    if (spentForAssetBase + intent.amountBase > cap) {
+      return deny(
+        `this payment would push spend on ${_nullishCoalesce(intent.symbol, () => ( intent.asset))} past policy.maxTotal (${policy.maxTotal}); already spent ${spentForAssetBase} base units.`
+      );
+    }
+  }
+  return ALLOW;
+}
+
+// src/ledger.ts
+var keyFor = (network, asset) => `${network}|${asset}`;
+var SpendLedger = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this.records = []}
+  __init2() {this.buckets = /* @__PURE__ */ new Map()}
+  /** Record a settled payment. `decimals` is the TRUE token decimals (for the
+   *  per-asset running total used by maxTotal + the formatted summary). */
+  record(r, decimals) {
+    this.records.push(r);
+    const key = keyFor(r.network, r.asset);
+    const bucket = this.buckets.get(key);
+    if (bucket) {
+      bucket.total += BigInt(r.amountBase);
+      bucket.count += 1;
+      if (!bucket.symbol && r.symbol) bucket.symbol = r.symbol;
+    } else {
+      this.buckets.set(key, {
+        network: r.network,
+        asset: r.asset,
+        symbol: r.symbol,
+        decimals,
+        total: BigInt(r.amountBase),
+        count: 1
+      });
+    }
+  }
+  /** Running total (base units) already spent on this (network, asset). */
+  totalFor(network, asset) {
+    return _nullishCoalesce(_optionalChain([this, 'access', _2 => _2.buckets, 'access', _3 => _3.get, 'call', _4 => _4(keyFor(network, asset)), 'optionalAccess', _5 => _5.total]), () => ( 0n));
+  }
+  /** An immutable snapshot of all spend so far. */
+  summary() {
+    return {
+      count: this.records.length,
+      byAsset: [...this.buckets.values()].map((b) => ({
+        network: b.network,
+        asset: b.asset,
+        symbol: b.symbol,
+        decimals: b.decimals,
+        totalBase: b.total.toString(),
+        totalFormatted: _chunkWQWNPAYQcjs.formatUnits.call(void 0, b.total, b.decimals),
+        count: b.count
+      })),
+      records: [...this.records]
+    };
+  }
+}, _class);
+
+// src/client.ts
+var PipRailClient = (_class2 = class {
+  
+  
+  
+  
+  // Per-asset tally of everything this client has paid (powers spent() and the
+  // policy's maxTotal cap).
+  __init3() {this.ledger = new SpendLedger()}
+  // Resolved lazily on first request — this is what lets Solana (and future
+  // families) auto-mount with no setup call.
+  
+  constructor(opts) {;_class2.prototype.__init3.call(this);
+    this.opts = opts;
+    this.maxRetries = Math.max(1, _nullishCoalesce(opts.maxPaymentRetries, () => ( 3)));
+    this.retryTimeoutMs = _nullishCoalesce(opts.retryTimeoutMs, () => ( 3e4));
+    this.onEvent = _nullishCoalesce(opts.onEvent, () => ( (() => void 0)));
+  }
+  /** Emit an observability event, never letting a throwing handler break the
+   * payment flow (mirrors the server gate's `onPaid` isolation). */
+  safeEmit(event) {
+    try {
+      this.onEvent(event);
+    } catch (e11) {
+    }
+  }
+  /** Auto-mount the chain's driver, resolve the network, and bind the wallet — once. */
+  ensure() {
+    return this.bound ??= (async () => {
+      const net = await resolveNetwork2({
+        chain: this.opts.chain,
+        rpcUrl: this.opts.rpcUrl
+      });
+      const wallet = net.bindWallet(this.opts.wallet);
+      return { net, wallet };
+    })();
+  }
+  /** GET that auto-handles 402. Pass a full URL to any x402-gated endpoint. */
+  get(url, init) {
+    return this.fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: "GET" });
+  }
+  /**
+   * POST that auto-handles 402.
+   *
+   * `body` can be a string/FormData/URLSearchParams/ArrayBuffer/Blob (sent
+   * as-is) or a plain object (serialised as JSON).
+   */
+  post(url, body, init) {
+    const headers = new Headers(_optionalChain([init, 'optionalAccess', _6 => _6.headers]));
+    let payload;
+    if (body === void 0 || body === null) {
+      payload = void 0;
+    } else if (isReplayableBodyInit(body)) {
+      payload = body;
+    } else if (typeof body === "object") {
+      payload = JSON.stringify(body);
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+      }
+    } else {
+      payload = String(body);
+    }
+    return this.fetch(url, {
+      ..._nullishCoalesce(init, () => ( {})),
+      method: "POST",
+      headers,
+      body: payload
+    });
+  }
+  /**
+   * Price a gated URL WITHOUT paying. Does the initial request, and if it's a
+   * 402, returns a {@link PipRailQuote} — the amount (in the token's TRUE
+   * decimals), token, chain, recipient, and whether the configured `policy`
+   * would allow it. Returns `null` when the URL isn't payment-gated (no 402).
+   *
+   * This is what lets an agent (or its planner) decide *before* spending —
+   * "0.05 USDC on Base, within budget → pay it." No funds move.
+   */
+  async quote(url, init) {
+    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _7 => _7.method]), () => ( "GET")) });
+    if (res.status !== 402) return null;
+    const { quote } = await this.resolveChallenge(url, res);
+    return quote;
+  }
+  /**
+   * Estimate the network fee (gas) to pay a gated URL — WITHOUT paying. Returns
+   * the {@link PipRailQuote} (what the payment is) plus a {@link CostEstimate}
+   * (the gas it will burn, in the chain's NATIVE coin), so an agent can budget
+   * the *total* — payment + gas — before any funds move. Returns `null` when the
+   * URL isn't payment-gated (no 402).
+   *
+   * The estimate is best-effort and labelled (`cost.basis`): live-RPC ('estimated')
+   * where cheap (EVM gas price, XRPL fee), a typical-cost constant ('heuristic')
+   * otherwise. It never throws for a transient RPC issue. Gas is in the native
+   * coin (ETH/SOL/TON/XLM/XRP/TRX), distinct from the payment token — most useful
+   * on Tron, where a USD₮ transfer can cost real TRX.
+   */
+  async estimateCost(url, init) {
+    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _8 => _8.method]), () => ( "GET")) });
+    if (res.status !== 402) return null;
+    const { net, accept, quote } = await this.resolveChallenge(url, res);
+    const cost = await net.estimateCost(accept);
+    return { quote, cost };
+  }
+  /** Aggregated snapshot of every payment this client has settled — total
+   *  count, cumulative spend per token, and the individual records. */
+  spent() {
+    return this.ledger.summary();
+  }
+  /**
+   * Lower-level: drive any HTTP method through the 402 flow.
+   *
+   * `init.body` (if any) must be replayable — the SDK may send the request
+   * twice (once to fetch the 402, once with the proof attached). One-shot
+   * streams throw `NonReplayableBodyError`.
+   */
+  async fetch(url, init) {
+    const body = _optionalChain([init, 'optionalAccess', _9 => _9.body]);
+    if (body !== void 0 && body !== null && !isReplayableBodyInit(body)) {
+      throw new (0, _chunkWQWNPAYQcjs.NonReplayableBodyError)(
+        "fetch(): init.body is not replayable. Pass a string, FormData, URLSearchParams, ArrayBuffer, or Blob \u2014 not a ReadableStream."
+      );
+    }
+    const firstResponse = await fetch(url, init);
+    if (firstResponse.status !== 402) return firstResponse;
+    const { net, wallet, accept, challenge, quote } = await this.resolveChallenge(
+      url,
+      firstResponse
+    );
+    this.safeEmit({ kind: "payment-required", challenge, accept });
+    await this.authorize(quote);
+    const ref = await this.payAndConfirm(net, wallet, accept);
+    const response = await this.retryWithProof(url, init, accept, ref);
+    this.recordSpend(quote, ref);
+    return response;
+  }
+  /* ------------------------- internals ------------------------- */
+  /**
+   * From a confirmed-402 response: parse the challenge, mount + bind the
+   * network, pick the accept the client can pay, and build its quote. Shared by
+   * `quote()` (read-only) and `fetch()` (which then authorises + pays).
+   */
+  async resolveChallenge(url, response) {
+    const challenge = await parseChallenge(response);
+    if (!challenge) {
+      throw new (0, _chunkWQWNPAYQcjs.InvalidEnvelopeError)(
+        "402 response did not include a parseable x402 challenge."
+      );
+    }
+    const { net, wallet } = await this.ensure();
+    const candidates = challenge.accepts.filter(
+      (a) => a.scheme === "onchain-proof" && net.supports(a.network)
+    );
+    if (candidates.length === 0) {
+      const networks = challenge.accepts.map((a) => a.network).join(", ");
+      throw new (0, _chunkWQWNPAYQcjs.NoCompatibleAcceptError)(
+        `No accepts[] entry for ${net.network} (challenge offered: ${networks || "none"}).`
+      );
+    }
+    const priced = candidates.map((accept) => ({
+      accept,
+      quote: this.buildQuote(net, accept, url, challenge.resource.description)
+    }));
+    const chosen = _nullishCoalesce(priced.find((p) => p.quote.withinPolicy), () => ( priced[0]));
+    return { net, wallet, accept: chosen.accept, challenge, quote: chosen.quote };
+  }
+  /** Build the agent-facing quote for an accept: TRUE decimals/symbol (via the
+   *  driver's describeAsset) + the policy verdict + a symbol-mismatch flag. */
+  buildQuote(net, accept, url, description) {
+    if (!/^\d+$/.test(accept.amount)) {
+      throw new (0, _chunkWQWNPAYQcjs.InvalidEnvelopeError)(
+        `challenge amount "${accept.amount}" is not a base-unit integer.`
+      );
+    }
+    const amountBase = BigInt(accept.amount);
+    const described = net.describeAsset(accept.asset);
+    const decimals = _nullishCoalesce(_optionalChain([described, 'optionalAccess', _10 => _10.decimals]), () => ( accept.extra.decimals));
+    const symbol = _nullishCoalesce(_optionalChain([described, 'optionalAccess', _11 => _11.symbol]), () => ( accept.extra.symbol));
+    const amountFormatted = _chunkWQWNPAYQcjs.formatUnits.call(void 0, amountBase, decimals);
+    const intent = {
+      host: hostOf(url),
+      chain: this.opts.chain,
+      network: accept.network,
+      asset: accept.asset,
+      amountBase,
+      decimals,
+      symbol,
+      recognized: described != null
+    };
+    const decision = evaluatePolicy(
+      intent,
+      this.opts.policy,
+      this.ledger.totalFor(accept.network, accept.asset)
+    );
+    const serverSymbol = accept.extra.symbol;
+    const symbolMismatch = intent.recognized && !!serverSymbol && !!symbol && serverSymbol.toUpperCase() !== symbol.toUpperCase();
+    return {
+      url,
+      chain: this.opts.chain,
+      network: accept.network,
+      asset: accept.asset,
+      amount: accept.amount,
+      amountFormatted,
+      decimals,
+      symbol,
+      payTo: accept.payTo,
+      ...description ? { description } : {},
+      maxTimeoutSeconds: accept.maxTimeoutSeconds,
+      recognized: intent.recognized,
+      symbolMismatch,
+      withinPolicy: decision.allowed,
+      ...decision.reason ? { policyReason: decision.reason } : {}
+    };
+  }
+  /** Enforce the spend policy and the onBeforePay hook — both refuse by
+   *  throwing PaymentDeclinedError, before any funds move. */
+  async authorize(quote) {
+    if (!quote.withinPolicy) {
+      throw new (0, _chunkWQWNPAYQcjs.PaymentDeclinedError)(
+        `Payment refused by policy: ${_nullishCoalesce(quote.policyReason, () => ( "not allowed"))}`
+      );
+    }
+    const hook = this.opts.onBeforePay;
+    if (!hook) return;
+    let approved;
+    try {
+      approved = await hook(quote);
+    } catch (err) {
+      throw new (0, _chunkWQWNPAYQcjs.PaymentDeclinedError)("onBeforePay threw \u2014 refusing to pay.", {
+        cause: err
+      });
+    }
+    if (!approved) {
+      throw new (0, _chunkWQWNPAYQcjs.PaymentDeclinedError)(
+        `onBeforePay declined ${quote.amountFormatted} ${_nullishCoalesce(quote.symbol, () => ( ""))}`.trimEnd() + ` on ${quote.network}.`
+      );
+    }
+  }
+  /** Record a settled payment in the ledger (true decimals for the running total). */
+  recordSpend(quote, ref) {
+    this.ledger.record(
+      {
+        url: quote.url,
+        host: hostOf(quote.url),
+        network: quote.network,
+        asset: quote.asset,
+        amountBase: quote.amount,
+        amountFormatted: quote.amountFormatted,
+        ...quote.symbol ? { symbol: quote.symbol } : {},
+        ref,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      quote.decimals
+    );
+  }
+  async payAndConfirm(net, wallet, accept) {
+    if (!net.supports(accept.network)) {
+      throw new (0, _chunkWQWNPAYQcjs.WrongChainError)(
+        `Challenge expects ${accept.network} but client is on ${net.network}.`
+      );
+    }
+    const ref = await net.send(wallet, accept);
+    this.safeEmit({ kind: "payment-broadcast", ref });
+    const { height } = await net.confirm(ref, _nullishCoalesce(accept.extra.minConfirmations, () => ( 1)));
+    this.safeEmit({
+      kind: "payment-confirmed",
+      ref,
+      blockNumber: BigInt(height)
+    });
+    return ref;
+  }
+  async retryWithProof(url, originalInit, accept, ref) {
+    const signature = {
+      x402Version: 2,
+      accepted: accept,
+      payload: { nonce: accept.extra.nonce, txHash: ref }
+    };
+    const headers = new Headers(_optionalChain([originalInit, 'optionalAccess', _12 => _12.headers]));
+    headers.set(HEADER_SIGNATURE, buildSignatureHeader(signature));
+    let lastResponse = null;
+    let lastReason = null;
+    for (let attempt = 0; attempt < this.maxRetries; attempt += 1) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, Math.min(2e3, 400 * 2 ** (attempt - 1))));
+      }
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(
+        () => timeoutController.abort(),
+        this.retryTimeoutMs
+      );
+      const signal = _optionalChain([originalInit, 'optionalAccess', _13 => _13.signal]) && typeof AbortSignal.any === "function" ? AbortSignal.any([timeoutController.signal, originalInit.signal]) : timeoutController.signal;
+      try {
+        lastResponse = await fetch(url, {
+          ..._nullishCoalesce(originalInit, () => ( {})),
+          headers,
+          signal
+        });
+      } catch (err) {
+        if (timeoutController.signal.aborted) {
+          throw new (0, _chunkWQWNPAYQcjs.PaymentTimeoutError)(
+            `Server did not respond within ${this.retryTimeoutMs}ms after on-chain payment ${ref} confirmed.`,
+            { cause: err }
+          );
+        }
+        throw err;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      if (lastResponse.status !== 402) {
+        const receipt = parseReceipt(lastResponse);
+        this.safeEmit({ kind: "payment-settled", receipt });
+        return lastResponse;
+      }
+      lastReason = await _asyncNullishCoalesce(await readInvalidReason(lastResponse), async () => ( lastReason));
+    }
+    const why = lastReason ? `${lastReason.error}${lastReason.detail ? ` \u2014 ${lastReason.detail}` : ""}` : "server gave no reason";
+    this.safeEmit({
+      kind: "payment-failed",
+      reason: `server returned 402 after on-chain payment ${ref} confirmed (${why})`
+    });
+    throw new (0, _chunkWQWNPAYQcjs.MaxRetriesExceededError)(
+      `Server still returned 402 after ${this.maxRetries} retry attempt(s) with on-chain proof ref=${ref}. Last server rejection: ${why}.`
+    );
+  }
+}, _class2);
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch (e12) {
+    return url;
+  }
+}
+function isReplayableBodyInit(value) {
+  if (typeof value === "string") return true;
+  if (value instanceof ArrayBuffer) return true;
+  if (ArrayBuffer.isView(value)) return true;
+  if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams)
+    return true;
+  if (typeof FormData !== "undefined" && value instanceof FormData) return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  return false;
+}
+async function readInvalidReason(response) {
+  try {
+    const body = await response.clone().json();
+    if (body && (body.status === "invalid" || typeof body.error === "string")) {
+      return {
+        error: typeof body.error === "string" ? body.error : "no error code",
+        detail: typeof body.detail === "string" ? body.detail : ""
+      };
+    }
+  } catch (e13) {
+  }
+  return null;
+}
+
+// src/agent.ts
+async function readBody(res) {
+  const text = await res.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch (e14) {
+    return text;
+  }
+}
+function paymentTools(client) {
+  return [
+    {
+      name: "piprail_quote_payment",
+      description: "Get the price of an x402 payment-gated URL WITHOUT paying. Returns the amount, token, chain, recipient, and whether it is within the spend policy. Returns { gated: false } when the URL needs no payment. Call this first to decide whether a resource is worth buying.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "Full URL of the gated resource." }
+        },
+        required: ["url"],
+        additionalProperties: false
+      },
+      invoke: async (args) => {
+        const quote = await client.quote(String(args.url));
+        return quote ? { gated: true, ...quote } : { gated: false, url: String(args.url) };
+      }
+    },
+    {
+      name: "piprail_pay_request",
+      description: "Fetch an x402 payment-gated URL, automatically paying the required on-chain payment if needed (subject to the spend policy + approval hook). Returns the HTTP status, the response body, and a payment receipt if one settled. If the payment is refused by policy or the approval hook, returns { declined: true, reason } \u2014 no funds moved.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "Full URL to fetch." },
+          method: { type: "string", description: "HTTP method, default 'GET'." },
+          body: {
+            type: ["object", "string"],
+            description: "Optional request body for POST/PUT (a JSON object or a string)."
+          }
+        },
+        required: ["url"],
+        additionalProperties: false
+      },
+      invoke: async (args) => {
+        const url = String(args.url);
+        const method = (args.method ? String(args.method) : "GET").toUpperCase();
+        try {
+          let res;
+          if (method === "GET") {
+            res = await client.get(url);
+          } else {
+            const headers = {};
+            let body;
+            if (args.body !== void 0 && args.body !== null) {
+              if (typeof args.body === "string") {
+                body = args.body;
+              } else {
+                body = JSON.stringify(args.body);
+                headers["content-type"] = "application/json";
+              }
+            }
+            res = await client.fetch(url, { method, headers, body });
+          }
+          return {
+            status: res.status,
+            ok: res.ok,
+            body: await readBody(res),
+            receipt: parseReceipt(res)
+          };
+        } catch (err) {
+          if (err instanceof _chunkWQWNPAYQcjs.PaymentDeclinedError) {
+            return { declined: true, reason: err.message };
+          }
+          throw err;
+        }
+      }
+    }
+  ];
+}
+
+// src/server.ts
+function toInvalidBody(result) {
+  return { x402Version: 2, status: "invalid", error: result.error, detail: result.detail };
+}
+function normaliseAccepts(options) {
+  if (options.accept && options.accept.length > 0) {
+    if (options.chain !== void 0 || options.token !== void 0 || options.amount !== void 0) {
+      throw new Error(
+        "requirePayment: pass EITHER `accept: [...]` (multi-chain) OR `chain`/`token`/`amount` (single) \u2014 not both."
+      );
+    }
+    return options.accept;
+  }
+  if (options.chain !== void 0 && options.token !== void 0 && options.amount !== void 0) {
+    return [{ chain: options.chain, token: options.token, amount: options.amount }];
+  }
+  throw new Error(
+    "requirePayment: provide either { chain, token, amount } or a non-empty `accept: [{ chain, token, amount }, \u2026]`."
+  );
+}
+function createPaymentGate(options) {
+  const minConfirmations = _nullishCoalesce(options.minConfirmations, () => ( 1));
+  const maxTimeoutSeconds = _nullishCoalesce(options.maxTimeoutSeconds, () => ( 600));
+  const genNonce = _nullishCoalesce(options.generateNonce, () => ( (() => globalThis.crypto.randomUUID())));
+  let resolved;
+  function ready() {
+    return resolved ??= (async () => {
+      const accepts = normaliseAccepts(options);
+      return Promise.all(
+        accepts.map(async (a) => {
+          const net = await resolveNetwork2({ chain: a.chain, rpcUrl: _nullishCoalesce(a.rpcUrl, () => ( options.rpcUrl)) });
+          const payTo = _nullishCoalesce(a.payTo, () => ( options.payTo));
+          if (!payTo) {
+            throw new Error(
+              `requirePayment: no payTo for chain ${net.network}. Set it on the accept entry or pass a top-level payTo.`
+            );
+          }
+          net.assertValidPayTo(payTo);
+          const { asset, decimals, symbol } = net.resolveToken(a.token);
+          const amountBase = _chunkWQWNPAYQcjs.parseUnits.call(void 0, a.amount, decimals);
+          return { net, asset, decimals, symbol, amountBase, amountFormatted: a.amount, payTo };
+        })
+      );
+    })();
+  }
+  const hasCustomStore = Boolean(options.isUsed || options.markUsed);
+  const localUsed = /* @__PURE__ */ new Set();
+  async function claimTx(ref) {
+    if (hasCustomStore) {
+      return options.isUsed ? Boolean(await options.isUsed(ref)) : false;
+    }
+    const key = ref.toLowerCase();
+    if (localUsed.has(key)) return true;
+    localUsed.add(key);
+    return false;
+  }
+  async function settleTx(ref, ok) {
+    if (hasCustomStore) {
+      if (ok && options.markUsed) await options.markUsed(ref);
+      return;
+    }
+    if (!ok) localUsed.delete(ref.toLowerCase());
+  }
+  function buildAccept(s, nonce) {
+    return {
+      scheme: "onchain-proof",
+      network: s.net.network,
+      amount: s.amountBase.toString(),
+      asset: s.asset,
+      payTo: s.payTo,
+      maxTimeoutSeconds,
+      extra: {
+        nonce,
+        decimals: s.decimals,
+        minConfirmations,
+        amountFormatted: s.amountFormatted,
+        ...s.symbol ? { symbol: s.symbol } : {}
+      }
+    };
+  }
+  async function challenge(resourceUrl = "") {
+    const specs = await ready();
+    const nonce = genNonce();
+    const challenge2 = {
+      x402Version: 2,
+      error: null,
+      resource: {
+        url: resourceUrl,
+        ...options.description ? { description: options.description } : {}
+      },
+      accepts: specs.map((s) => buildAccept(s, nonce))
+    };
+    return { challenge: challenge2, requiredHeader: buildChallengeHeader(challenge2) };
+  }
+  async function asChallenge() {
+    const { challenge: c, requiredHeader } = await challenge();
+    return { kind: "challenge", challenge: c, requiredHeader, statusCode: 402 };
+  }
+  async function verify(paymentSignature) {
+    const raw = normaliseHeader(paymentSignature);
+    if (!raw) return asChallenge();
+    const sig = parseSignatureHeader(raw);
+    if (!sig || !sig.accepted || typeof sig.accepted.network !== "string" || typeof sig.accepted.asset !== "string") {
+      return asChallenge();
+    }
+    const specs = await ready();
+    const spec = specs.find(
+      (s) => s.net.network === sig.accepted.network && s.asset === sig.accepted.asset
+    );
+    if (!spec) {
+      return {
+        kind: "invalid",
+        error: "transfer_not_found",
+        detail: `Proof claims ${sig.accepted.asset} on ${sig.accepted.network}, which this resource doesn't accept (offered: ${specs.map((s) => `${s.asset}@${s.net.network}`).join(", ")}).`,
+        statusCode: 402
+      };
+    }
+    const ref = sig.payload.txHash;
+    if (await claimTx(ref)) {
+      return {
+        kind: "invalid",
+        error: "tx_already_used",
+        detail: `Proof ${ref} was already redeemed.`,
+        statusCode: 402
+      };
+    }
+    const result = await spec.net.verify(ref, buildAccept(spec, sig.payload.nonce));
+    if (!result.ok) {
+      await settleTx(ref, false);
+      return {
+        kind: "invalid",
+        error: result.error,
+        detail: result.detail,
+        statusCode: 402
+      };
+    }
+    await settleTx(ref, true);
+    if (options.onPaid) {
+      try {
+        options.onPaid(result.receipt);
+      } catch (e15) {
+      }
+    }
+    return {
+      kind: "paid",
+      receipt: result.receipt,
+      receiptHeader: buildReceiptHeader(result.receipt)
+    };
+  }
+  return { challenge, verify };
+}
+function requirePayment(options) {
+  const gate = createPaymentGate(options);
+  return async (req, res, next) => {
+    let result;
+    try {
+      result = await gate.verify(req.headers[HEADER_SIGNATURE]);
+    } catch (err) {
+      next(err);
+      return;
+    }
+    switch (result.kind) {
+      case "paid":
+        res.setHeader(HEADER_RESPONSE, result.receiptHeader);
+        return next();
+      case "challenge":
+        res.setHeader(HEADER_REQUIRED, result.requiredHeader);
+        res.status(result.statusCode);
+        res.json(result.challenge);
+        return;
+      case "invalid":
+        res.status(result.statusCode);
+        res.json(toInvalidBody(result));
+        return;
+    }
+  };
+}
+function normaliseHeader(value) {
+  if (Array.isArray(value)) return value[0];
+  return value;
+}
+
+// src/drivers/evm/exact.ts
+var EXACT_NETWORK_SLUGS = {
+  ethereum: 1,
+  base: 8453,
+  "base-sepolia": 84532,
+  arbitrum: 42161,
+  optimism: 10,
+  polygon: 137,
+  avalanche: 43114
+};
+function chainIdForExactNetwork(slug) {
+  return _nullishCoalesce(EXACT_NETWORK_SLUGS[slug], () => ( null));
+}
+var EIP3009_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 parseExactRequirements(body) {
+  if (!body || typeof body !== "object") return null;
+  const accepts = body.accepts;
+  if (!Array.isArray(accepts)) return null;
+  const out = [];
+  for (const raw of accepts) {
+    if (!raw || typeof raw !== "object") continue;
+    const a = raw;
+    if (a.scheme !== "exact") continue;
+    const amount = _nullishCoalesce(a.maxAmountRequired, () => ( a.amount));
+    if (typeof a.network !== "string" || typeof amount !== "string" || typeof a.asset !== "string" || typeof a.payTo !== "string") {
+      continue;
+    }
+    out.push({
+      scheme: "exact",
+      network: a.network,
+      maxAmountRequired: amount,
+      asset: a.asset,
+      payTo: a.payTo,
+      maxTimeoutSeconds: typeof a.maxTimeoutSeconds === "number" ? a.maxTimeoutSeconds : 600,
+      ...a.extra && typeof a.extra === "object" ? { extra: a.extra } : {},
+      ...typeof a.description === "string" ? { description: a.description } : {},
+      ...typeof a.resource === "string" ? { resource: a.resource } : {}
+    });
+  }
+  return out;
+}
+async function buildExactAuthorization(params) {
+  const { account, accept, chainId, now, nonce } = params;
+  if (!account.signTypedData) {
+    throw new Error("buildExactAuthorization: the account cannot sign EIP-712 typed data.");
+  }
+  const authorization = {
+    from: account.address,
+    to: accept.payTo,
+    value: accept.maxAmountRequired,
+    validAfter: "0",
+    validBefore: String(now + accept.maxTimeoutSeconds),
+    nonce
+  };
+  const signature = await account.signTypedData({
+    domain: {
+      name: _nullishCoalesce(_optionalChain([accept, 'access', _14 => _14.extra, 'optionalAccess', _15 => _15.name]), () => ( "USD Coin")),
+      version: _nullishCoalesce(_optionalChain([accept, 'access', _16 => _16.extra, 'optionalAccess', _17 => _17.version]), () => ( "2")),
+      chainId,
+      verifyingContract: accept.asset
+    },
+    types: EIP3009_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: authorization.from,
+      to: authorization.to,
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      nonce: authorization.nonce
+    }
+  });
+  return { authorization, signature };
+}
+function base64(str) {
+  if (typeof btoa === "function") return btoa(str);
+  if (typeof Buffer !== "undefined") return Buffer.from(str, "utf8").toString("base64");
+  throw new Error("No base64 encoder available in this runtime.");
+}
+function encodeXPaymentHeader(input) {
+  const payload = {
+    x402Version: _nullishCoalesce(input.x402Version, () => ( 1)),
+    scheme: "exact",
+    network: input.network,
+    payload: { signature: input.signature, authorization: input.authorization }
+  };
+  return base64(JSON.stringify(payload));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CHAINS = CHAINS; exports.ConfirmationTimeoutError = _chunkWQWNPAYQcjs.ConfirmationTimeoutError; exports.EIP3009_TYPES = EIP3009_TYPES; exports.EXACT_NETWORK_SLUGS = EXACT_NETWORK_SLUGS; exports.InsufficientFundsError = _chunkWQWNPAYQcjs.InsufficientFundsError; exports.InvalidEnvelopeError = _chunkWQWNPAYQcjs.InvalidEnvelopeError; exports.MaxRetriesExceededError = _chunkWQWNPAYQcjs.MaxRetriesExceededError; exports.MissingDriverError = _chunkWQWNPAYQcjs.MissingDriverError; exports.NoCompatibleAcceptError = _chunkWQWNPAYQcjs.NoCompatibleAcceptError; exports.NonReplayableBodyError = _chunkWQWNPAYQcjs.NonReplayableBodyError; exports.PaymentDeclinedError = _chunkWQWNPAYQcjs.PaymentDeclinedError; exports.PaymentTimeoutError = _chunkWQWNPAYQcjs.PaymentTimeoutError; exports.PipRailClient = PipRailClient; exports.PipRailError = _chunkWQWNPAYQcjs.PipRailError; exports.UnknownTokenError = _chunkWQWNPAYQcjs.UnknownTokenError; exports.UnsupportedNetworkError = _chunkWQWNPAYQcjs.UnsupportedNetworkError; exports.WrongChainError = _chunkWQWNPAYQcjs.WrongChainError; exports.WrongFamilyError = _chunkWQWNPAYQcjs.WrongFamilyError; exports.buildChallengeHeader = buildChallengeHeader; exports.buildExactAuthorization = buildExactAuthorization; exports.buildReceiptHeader = buildReceiptHeader; exports.buildSignatureHeader = buildSignatureHeader; exports.chainIdForExactNetwork = chainIdForExactNetwork; exports.createPaymentGate = createPaymentGate; exports.encodeXPaymentHeader = encodeXPaymentHeader; exports.evaluatePolicy = evaluatePolicy; exports.parseChallenge = parseChallenge; exports.parseExactRequirements = parseExactRequirements; exports.parseReceipt = parseReceipt; exports.parseSignatureHeader = parseSignatureHeader; exports.paymentTools = paymentTools; exports.pickAccept = pickAccept; exports.registerDriver = registerDriver; exports.requirePayment = requirePayment; exports.resolveChain = resolveChain; exports.toInsufficientFundsError = _chunkWQWNPAYQcjs.toInsufficientFundsError; exports.toInvalidBody = toInvalidBody;