@bankofai/x402-evm 1.0.0-beta.0

package/dist/cjs/index.js

@@ -0,0 +1,2860 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AUTH_CAPTURE_ESCROW_ADDRESS: () => AUTH_CAPTURE_ESCROW_ADDRESS,
+  AUTH_CAPTURE_SCHEME: () => AUTH_CAPTURE_SCHEME,
+  AuthCaptureEvmScheme: () => AuthCaptureEvmScheme,
+  BATCH_SETTLEMENT_ADDRESS: () => BATCH_SETTLEMENT_ADDRESS,
+  BATCH_SETTLEMENT_DOMAIN: () => BATCH_SETTLEMENT_DOMAIN,
+  BATCH_SETTLEMENT_SCHEME: () => BATCH_SETTLEMENT_SCHEME,
+  BUILDER_CODE_KEY: () => BUILDER_CODE_KEY,
+  BatchSettlementEvmScheme: () => BatchSettlementEvmScheme,
+  DEFAULT_STABLECOINS: () => DEFAULT_STABLECOINS,
+  EIP3009_TOKEN_COLLECTOR_ADDRESS: () => EIP3009_TOKEN_COLLECTOR_ADDRESS,
+  ERC3009_DEPOSIT_COLLECTOR_ADDRESS: () => ERC3009_DEPOSIT_COLLECTOR_ADDRESS,
+  ExactEvmScheme: () => ExactEvmScheme,
+  PERMIT2_ADDRESS: () => PERMIT2_ADDRESS,
+  PERMIT2_TOKEN_COLLECTOR_ADDRESS: () => PERMIT2_TOKEN_COLLECTOR_ADDRESS,
+  UptoEvmScheme: () => UptoEvmScheme,
+  appendDataSuffix: () => appendDataSuffix,
+  authorizationTypes: () => authorizationTypes,
+  claimBatchTypes: () => claimBatchTypes,
+  createPermit2ApprovalTx: () => createPermit2ApprovalTx,
+  eip3009ABI: () => eip3009ABI,
+  erc20AllowanceAbi: () => erc20AllowanceAbi,
+  getDefaultAsset: () => getDefaultAsset,
+  getPermit2AllowanceReadParams: () => getPermit2AllowanceReadParams,
+  isAuthCaptureExtra: () => isAuthCaptureExtra,
+  isAuthCapturePayload: () => isAuthCapturePayload,
+  isBatchSettlementClaimPayload: () => isBatchSettlementClaimPayload,
+  isBatchSettlementDepositPayload: () => isBatchSettlementDepositPayload,
+  isBatchSettlementEnrichedRefundPayload: () => isBatchSettlementEnrichedRefundPayload,
+  isBatchSettlementRefundPayload: () => isBatchSettlementRefundPayload,
+  isBatchSettlementSettlePayload: () => isBatchSettlementSettlePayload,
+  isBatchSettlementVoucherPayload: () => isBatchSettlementVoucherPayload,
+  isEIP3009Payload: () => isEIP3009Payload,
+  isPermit2Payload: () => isPermit2Payload,
+  isUptoPermit2Payload: () => isUptoPermit2Payload,
+  permit2WitnessTypes: () => permit2WitnessTypes,
+  refundTypes: () => refundTypes,
+  resolveDataSuffix: () => resolveDataSuffix,
+  toClientEvmSigner: () => toClientEvmSigner,
+  toFacilitatorEvmSigner: () => toFacilitatorEvmSigner,
+  uptoPermit2WitnessTypes: () => uptoPermit2WitnessTypes,
+  voucherTypes: () => voucherTypes,
+  x402ExactPermit2ProxyABI: () => x402ExactPermit2ProxyABI,
+  x402ExactPermit2ProxyAddress: () => x402ExactPermit2ProxyAddress,
+  x402UptoPermit2ProxyABI: () => x402UptoPermit2ProxyABI,
+  x402UptoPermit2ProxyAddress: () => x402UptoPermit2ProxyAddress
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/exact/client/eip3009.ts
+var import_viem2 = require("viem");
+
+// src/constants.ts
+var authorizationTypes = {
+  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" }
+  ]
+};
+var permit2WitnessTypes = {
+  PermitWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Witness" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  Witness: [
+    { name: "to", type: "address" },
+    { name: "validAfter", type: "uint256" }
+  ]
+};
+var uptoPermit2WitnessTypes = {
+  PermitWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Witness" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  Witness: [
+    { name: "to", type: "address" },
+    { name: "facilitator", type: "address" },
+    { name: "validAfter", type: "uint256" }
+  ]
+};
+var eip3009ABI = [
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "signature", type: "bytes" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "version",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "authorizer", type: "address" },
+      { name: "nonce", type: "bytes32" }
+    ],
+    name: "authorizationState",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var eip2612PermitTypes = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var eip2612NoncesAbi = [
+  {
+    type: "function",
+    name: "nonces",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var erc20ApproveAbi = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+var erc20AllowanceAbi = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var ERC20_APPROVE_GAS_LIMIT = 70000n;
+var DEFAULT_MAX_FEE_PER_GAS = 1000000000n;
+var DEFAULT_MAX_PRIORITY_FEE_PER_GAS = 100000000n;
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var x402ExactPermit2ProxyAddress = "0x402085c248EeA27D92E8b30b2C58ed07f9E20001";
+var x402UptoPermit2ProxyAddress = "0x4020A4f3b7b90ccA423B9fabCc0CE57C6C240002";
+var permit2WitnessABIComponents = [
+  { name: "to", type: "address", internalType: "address" },
+  { name: "validAfter", type: "uint256", internalType: "uint256" }
+];
+var uptoPermit2WitnessABIComponents = [
+  { name: "to", type: "address", internalType: "address" },
+  { name: "facilitator", type: "address", internalType: "address" },
+  { name: "validAfter", type: "uint256", internalType: "uint256" }
+];
+var x402UptoPermit2ProxyABI = [
+  {
+    type: "function",
+    name: "PERMIT2",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "contract ISignatureTransfer" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WITNESS_TYPEHASH",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WITNESS_TYPE_STRING",
+    inputs: [],
+    outputs: [{ name: "", type: "string", internalType: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "settle",
+    inputs: [
+      {
+        name: "permit",
+        type: "tuple",
+        internalType: "struct ISignatureTransfer.PermitTransferFrom",
+        components: [
+          {
+            name: "permitted",
+            type: "tuple",
+            internalType: "struct ISignatureTransfer.TokenPermissions",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "nonce", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "amount", type: "uint256", internalType: "uint256" },
+      { name: "owner", type: "address", internalType: "address" },
+      {
+        name: "witness",
+        type: "tuple",
+        internalType: "struct x402UptoPermit2Proxy.Witness",
+        components: uptoPermit2WitnessABIComponents
+      },
+      { name: "signature", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "settleWithPermit",
+    inputs: [
+      {
+        name: "permit2612",
+        type: "tuple",
+        internalType: "struct x402UptoPermit2Proxy.EIP2612Permit",
+        components: [
+          { name: "value", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" },
+          { name: "r", type: "bytes32", internalType: "bytes32" },
+          { name: "s", type: "bytes32", internalType: "bytes32" },
+          { name: "v", type: "uint8", internalType: "uint8" }
+        ]
+      },
+      {
+        name: "permit",
+        type: "tuple",
+        internalType: "struct ISignatureTransfer.PermitTransferFrom",
+        components: [
+          {
+            name: "permitted",
+            type: "tuple",
+            internalType: "struct ISignatureTransfer.TokenPermissions",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "nonce", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "amount", type: "uint256", internalType: "uint256" },
+      { name: "owner", type: "address", internalType: "address" },
+      {
+        name: "witness",
+        type: "tuple",
+        internalType: "struct x402UptoPermit2Proxy.Witness",
+        components: uptoPermit2WitnessABIComponents
+      },
+      { name: "signature", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  { type: "event", name: "Settled", inputs: [], anonymous: false },
+  { type: "event", name: "SettledWithPermit", inputs: [], anonymous: false },
+  { type: "error", name: "AmountExceedsPermitted", inputs: [] },
+  { type: "error", name: "InvalidDestination", inputs: [] },
+  { type: "error", name: "InvalidOwner", inputs: [] },
+  { type: "error", name: "InvalidPermit2Address", inputs: [] },
+  { type: "error", name: "PaymentTooEarly", inputs: [] },
+  { type: "error", name: "Permit2612AmountMismatch", inputs: [] },
+  { type: "error", name: "ReentrancyGuardReentrantCall", inputs: [] },
+  { type: "error", name: "UnauthorizedFacilitator", inputs: [] }
+];
+var x402ExactPermit2ProxyABI = [
+  {
+    type: "function",
+    name: "PERMIT2",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "contract ISignatureTransfer" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WITNESS_TYPEHASH",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WITNESS_TYPE_STRING",
+    inputs: [],
+    outputs: [{ name: "", type: "string", internalType: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "settle",
+    inputs: [
+      {
+        name: "permit",
+        type: "tuple",
+        internalType: "struct ISignatureTransfer.PermitTransferFrom",
+        components: [
+          {
+            name: "permitted",
+            type: "tuple",
+            internalType: "struct ISignatureTransfer.TokenPermissions",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "nonce", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "owner", type: "address", internalType: "address" },
+      {
+        name: "witness",
+        type: "tuple",
+        internalType: "struct x402ExactPermit2Proxy.Witness",
+        components: permit2WitnessABIComponents
+      },
+      { name: "signature", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "settleWithPermit",
+    inputs: [
+      {
+        name: "permit2612",
+        type: "tuple",
+        internalType: "struct x402ExactPermit2Proxy.EIP2612Permit",
+        components: [
+          { name: "value", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" },
+          { name: "r", type: "bytes32", internalType: "bytes32" },
+          { name: "s", type: "bytes32", internalType: "bytes32" },
+          { name: "v", type: "uint8", internalType: "uint8" }
+        ]
+      },
+      {
+        name: "permit",
+        type: "tuple",
+        internalType: "struct ISignatureTransfer.PermitTransferFrom",
+        components: [
+          {
+            name: "permitted",
+            type: "tuple",
+            internalType: "struct ISignatureTransfer.TokenPermissions",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "nonce", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "owner", type: "address", internalType: "address" },
+      {
+        name: "witness",
+        type: "tuple",
+        internalType: "struct x402ExactPermit2Proxy.Witness",
+        components: permit2WitnessABIComponents
+      },
+      { name: "signature", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  { type: "event", name: "Settled", inputs: [], anonymous: false },
+  { type: "event", name: "SettledWithPermit", inputs: [], anonymous: false },
+  { type: "error", name: "InvalidAmount", inputs: [] },
+  { type: "error", name: "InvalidDestination", inputs: [] },
+  { type: "error", name: "InvalidOwner", inputs: [] },
+  { type: "error", name: "InvalidPermit2Address", inputs: [] },
+  { type: "error", name: "PaymentTooEarly", inputs: [] },
+  { type: "error", name: "Permit2612AmountMismatch", inputs: [] },
+  { type: "error", name: "ReentrancyGuardReentrantCall", inputs: [] }
+];
+
+// src/utils.ts
+var import_viem = require("viem");
+function getEvmChainId(network) {
+  if (network.startsWith("eip155:")) {
+    const idStr = network.split(":")[1];
+    const chainId = parseInt(idStr, 10);
+    if (isNaN(chainId)) {
+      throw new Error(`Invalid CAIP-2 chain ID: ${network}`);
+    }
+    return chainId;
+  }
+  throw new Error(`Unsupported network format: ${network} (expected eip155:CHAIN_ID)`);
+}
+function getCrypto() {
+  const cryptoObj = globalThis.crypto;
+  if (!cryptoObj) {
+    throw new Error("Crypto API not available");
+  }
+  return cryptoObj;
+}
+function createNonce() {
+  return (0, import_viem.toHex)(getCrypto().getRandomValues(new Uint8Array(32)));
+}
+function createPermit2Nonce() {
+  const randomBytes = getCrypto().getRandomValues(new Uint8Array(32));
+  return BigInt((0, import_viem.toHex)(randomBytes)).toString();
+}
+
+// src/exact/client/eip3009.ts
+async function createEIP3009Payload(signer, x402Version, paymentRequirements) {
+  const nonce = createNonce();
+  const now = Math.floor(Date.now() / 1e3);
+  const authorization = {
+    from: signer.address,
+    to: (0, import_viem2.getAddress)(paymentRequirements.payTo),
+    value: paymentRequirements.amount,
+    validAfter: "0",
+    validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
+    nonce
+  };
+  const signature = await signEIP3009Authorization(signer, authorization, paymentRequirements);
+  const payload = {
+    authorization,
+    signature
+  };
+  return {
+    x402Version,
+    payload
+  };
+}
+async function signEIP3009Authorization(signer, authorization, requirements) {
+  const chainId = getEvmChainId(requirements.network);
+  if (!requirements.extra?.name || !requirements.extra?.version) {
+    throw new Error(
+      `EIP-712 domain parameters (name, version) are required in payment requirements for asset ${requirements.asset}`
+    );
+  }
+  const { name, version } = requirements.extra;
+  const domain = {
+    name,
+    version,
+    chainId,
+    verifyingContract: (0, import_viem2.getAddress)(requirements.asset)
+  };
+  const message = {
+    from: (0, import_viem2.getAddress)(authorization.from),
+    to: (0, import_viem2.getAddress)(authorization.to),
+    value: BigInt(authorization.value),
+    validAfter: BigInt(authorization.validAfter),
+    validBefore: BigInt(authorization.validBefore),
+    nonce: authorization.nonce
+  };
+  return await signer.signTypedData({
+    domain,
+    types: authorizationTypes,
+    primaryType: "TransferWithAuthorization",
+    message
+  });
+}
+
+// src/exact/client/permit2.ts
+var import_viem6 = require("viem");
+
+// src/exact/extensions.ts
+var EIP2612_GAS_SPONSORING_KEY = "eip2612GasSponsoring";
+var ERC20_APPROVAL_GAS_SPONSORING_KEY = "erc20ApprovalGasSponsoring";
+var ERC20_APPROVAL_GAS_SPONSORING_VERSION = "1";
+
+// src/shared/permit2.ts
+var import_viem5 = require("viem");
+
+// src/multicall.ts
+var import_viem3 = require("viem");
+
+// src/shared/erc20approval.ts
+var import_viem4 = require("viem");
+
+// src/shared/permit2.ts
+async function createPermit2PayloadForProxy(proxyAddress, signer, x402Version, paymentRequirements) {
+  const now = Math.floor(Date.now() / 1e3);
+  const nonce = createPermit2Nonce();
+  const validAfter = "0";
+  const deadline = (now + paymentRequirements.maxTimeoutSeconds).toString();
+  const permit2Authorization = {
+    from: signer.address,
+    permitted: {
+      token: (0, import_viem5.getAddress)(paymentRequirements.asset),
+      amount: paymentRequirements.amount
+    },
+    spender: proxyAddress,
+    nonce,
+    deadline,
+    witness: {
+      to: (0, import_viem5.getAddress)(paymentRequirements.payTo),
+      validAfter
+    }
+  };
+  const signature = await signPermit2Authorization(
+    signer,
+    permit2Authorization,
+    paymentRequirements
+  );
+  return {
+    x402Version,
+    payload: { signature, permit2Authorization }
+  };
+}
+async function signPermit2Authorization(signer, permit2Authorization, requirements) {
+  const chainId = getEvmChainId(requirements.network);
+  return await signer.signTypedData({
+    domain: { name: "Permit2", chainId, verifyingContract: PERMIT2_ADDRESS },
+    types: permit2WitnessTypes,
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: (0, import_viem5.getAddress)(permit2Authorization.permitted.token),
+        amount: BigInt(permit2Authorization.permitted.amount)
+      },
+      spender: (0, import_viem5.getAddress)(permit2Authorization.spender),
+      nonce: BigInt(permit2Authorization.nonce),
+      deadline: BigInt(permit2Authorization.deadline),
+      witness: {
+        to: (0, import_viem5.getAddress)(permit2Authorization.witness.to),
+        validAfter: BigInt(permit2Authorization.witness.validAfter)
+      }
+    }
+  });
+}
+
+// src/exact/client/permit2.ts
+var MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+async function createPermit2Payload(signer, x402Version, paymentRequirements) {
+  return createPermit2PayloadForProxy(
+    x402ExactPermit2ProxyAddress,
+    signer,
+    x402Version,
+    paymentRequirements
+  );
+}
+function createPermit2ApprovalTx(tokenAddress) {
+  const data = (0, import_viem6.encodeFunctionData)({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [PERMIT2_ADDRESS, MAX_UINT256]
+  });
+  return {
+    to: (0, import_viem6.getAddress)(tokenAddress),
+    data
+  };
+}
+function getPermit2AllowanceReadParams(params) {
+  return {
+    address: (0, import_viem6.getAddress)(params.tokenAddress),
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [(0, import_viem6.getAddress)(params.ownerAddress), PERMIT2_ADDRESS]
+  };
+}
+
+// src/shared/extensions/gasSponsoring.ts
+var import_viem10 = require("viem");
+
+// src/exact/client/eip2612.ts
+var import_viem7 = require("viem");
+async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion, chainId, deadline, permittedAmount) {
+  const owner = signer.address;
+  const spender = (0, import_viem7.getAddress)(PERMIT2_ADDRESS);
+  const nonce = await signer.readContract({
+    address: tokenAddress,
+    abi: eip2612NoncesAbi,
+    functionName: "nonces",
+    args: [owner]
+  });
+  const domain = {
+    name: tokenName,
+    version: tokenVersion,
+    chainId,
+    verifyingContract: tokenAddress
+  };
+  const approvalAmount = BigInt(permittedAmount);
+  const message = {
+    owner,
+    spender,
+    value: approvalAmount,
+    nonce,
+    deadline: BigInt(deadline)
+  };
+  const signature = await signer.signTypedData({
+    domain,
+    types: eip2612PermitTypes,
+    primaryType: "Permit",
+    message
+  });
+  return {
+    from: owner,
+    asset: tokenAddress,
+    spender,
+    amount: approvalAmount.toString(),
+    nonce: nonce.toString(),
+    deadline,
+    signature,
+    version: "1"
+  };
+}
+
+// src/exact/client/erc20approval.ts
+var import_viem8 = require("viem");
+async function signErc20ApprovalTransaction(signer, tokenAddress, chainId) {
+  const from = signer.address;
+  const spender = (0, import_viem8.getAddress)(PERMIT2_ADDRESS);
+  const data = (0, import_viem8.encodeFunctionData)({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [spender, import_viem8.maxUint256]
+  });
+  const nonce = await signer.getTransactionCount({ address: from });
+  let maxFeePerGas;
+  let maxPriorityFeePerGas;
+  try {
+    const fees = await signer.estimateFeesPerGas?.();
+    if (!fees) {
+      throw new Error("no fee estimates available");
+    }
+    maxFeePerGas = fees.maxFeePerGas;
+    maxPriorityFeePerGas = fees.maxPriorityFeePerGas;
+  } catch {
+    maxFeePerGas = DEFAULT_MAX_FEE_PER_GAS;
+    maxPriorityFeePerGas = DEFAULT_MAX_PRIORITY_FEE_PER_GAS;
+  }
+  const signedTransaction = await signer.signTransaction({
+    to: tokenAddress,
+    data,
+    nonce,
+    gas: ERC20_APPROVE_GAS_LIMIT,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    chainId
+  });
+  return {
+    from,
+    asset: tokenAddress,
+    spender,
+    amount: import_viem8.maxUint256.toString(),
+    signedTransaction,
+    version: ERC20_APPROVAL_GAS_SPONSORING_VERSION
+  };
+}
+
+// src/shared/rpc.ts
+var import_viem9 = require("viem");
+var rpcClientCache = /* @__PURE__ */ new Map();
+function isConfigByChainId(options) {
+  const keys = Object.keys(options);
+  return keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
+}
+function getRpcClient(rpcUrl) {
+  const existing = rpcClientCache.get(rpcUrl);
+  if (existing) {
+    return existing;
+  }
+  const client = (0, import_viem9.createPublicClient)({
+    transport: (0, import_viem9.http)(rpcUrl)
+  });
+  rpcClientCache.set(rpcUrl, client);
+  return client;
+}
+function resolveRpcUrl(network, options) {
+  if (!options) {
+    return void 0;
+  }
+  if (isConfigByChainId(options)) {
+    const chainId = getEvmChainId(network);
+    const optionsByChainId = options;
+    return optionsByChainId[chainId]?.rpcUrl;
+  }
+  return options.rpcUrl;
+}
+function resolveExtensionRpcCapabilities(network, signer, options) {
+  const capabilities = {
+    signTransaction: signer.signTransaction,
+    readContract: signer.readContract,
+    getTransactionCount: signer.getTransactionCount,
+    estimateFeesPerGas: signer.estimateFeesPerGas
+  };
+  const needsRpcBackfill = !capabilities.readContract || !capabilities.getTransactionCount || !capabilities.estimateFeesPerGas;
+  if (!needsRpcBackfill) {
+    return capabilities;
+  }
+  const rpcUrl = resolveRpcUrl(network, options);
+  if (!rpcUrl) {
+    return capabilities;
+  }
+  const rpcClient = getRpcClient(rpcUrl);
+  if (!capabilities.readContract) {
+    capabilities.readContract = (args) => rpcClient.readContract(args);
+  }
+  if (!capabilities.getTransactionCount) {
+    capabilities.getTransactionCount = async (args) => rpcClient.getTransactionCount({ address: args.address });
+  }
+  if (!capabilities.estimateFeesPerGas) {
+    capabilities.estimateFeesPerGas = async () => rpcClient.estimateFeesPerGas();
+  }
+  return capabilities;
+}
+
+// src/shared/extensions/gasSponsoring.ts
+async function trySignEip2612PermitExtension(signer, options, requirements, result, context, approvalAmount) {
+  const capabilities = resolveExtensionRpcCapabilities(requirements.network, signer, options);
+  if (!capabilities.readContract) {
+    return void 0;
+  }
+  if (!context?.extensions?.[EIP2612_GAS_SPONSORING_KEY]) {
+    return void 0;
+  }
+  const tokenName = requirements.extra?.name;
+  const tokenVersion = requirements.extra?.version;
+  if (!tokenName || !tokenVersion) {
+    return void 0;
+  }
+  const chainId = getEvmChainId(requirements.network);
+  const tokenAddress = (0, import_viem10.getAddress)(requirements.asset);
+  const requiredAllowance = approvalAmount ?? requirements.amount;
+  try {
+    const allowance = await capabilities.readContract({
+      address: tokenAddress,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [signer.address, PERMIT2_ADDRESS]
+    });
+    if (allowance >= BigInt(requiredAllowance)) {
+      return void 0;
+    }
+  } catch {
+  }
+  const permit2Auth = result.payload?.permit2Authorization;
+  const deadline = permit2Auth?.deadline ?? Math.floor(Date.now() / 1e3 + requirements.maxTimeoutSeconds).toString();
+  const info = await signEip2612Permit(
+    {
+      address: signer.address,
+      signTypedData: (msg) => signer.signTypedData(msg),
+      readContract: capabilities.readContract
+    },
+    tokenAddress,
+    tokenName,
+    tokenVersion,
+    chainId,
+    deadline,
+    requiredAllowance
+  );
+  return {
+    [EIP2612_GAS_SPONSORING_KEY]: { info }
+  };
+}
+async function trySignErc20ApprovalExtension(signer, options, requirements, context, approvalAmount) {
+  const capabilities = resolveExtensionRpcCapabilities(requirements.network, signer, options);
+  if (!capabilities.readContract) {
+    return void 0;
+  }
+  if (!context?.extensions?.[ERC20_APPROVAL_GAS_SPONSORING_KEY]) {
+    return void 0;
+  }
+  if (!capabilities.signTransaction || !capabilities.getTransactionCount) {
+    return void 0;
+  }
+  const chainId = getEvmChainId(requirements.network);
+  const tokenAddress = (0, import_viem10.getAddress)(requirements.asset);
+  const requiredAllowance = approvalAmount ?? requirements.amount;
+  try {
+    const allowance = await capabilities.readContract({
+      address: tokenAddress,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [signer.address, PERMIT2_ADDRESS]
+    });
+    if (allowance >= BigInt(requiredAllowance)) {
+      return void 0;
+    }
+  } catch {
+  }
+  const info = await signErc20ApprovalTransaction(
+    {
+      address: signer.address,
+      signTransaction: capabilities.signTransaction,
+      getTransactionCount: capabilities.getTransactionCount,
+      estimateFeesPerGas: capabilities.estimateFeesPerGas
+    },
+    tokenAddress,
+    chainId
+  );
+  return {
+    [ERC20_APPROVAL_GAS_SPONSORING_KEY]: { info }
+  };
+}
+
+// src/shared/extensions/builderCode.ts
+var BUILDER_CODE_KEY = "builder-code";
+var BUILDER_CODE_RESOLVER = async (context, ctx) => {
+  const ext = context.getExtension(BUILDER_CODE_KEY);
+  if (!ext?.buildDataSuffix) {
+    return void 0;
+  }
+  return ext.buildDataSuffix(ctx);
+};
+var DATA_SUFFIX_RESOLVERS = [BUILDER_CODE_RESOLVER];
+async function resolveDataSuffix(context, ctx) {
+  if (!context) {
+    return void 0;
+  }
+  const parts = [];
+  for (const resolver of DATA_SUFFIX_RESOLVERS) {
+    const suffix = await resolver(context, ctx);
+    if (suffix && suffix !== "0x" && suffix.length > 2) {
+      parts.push(suffix);
+    }
+  }
+  if (parts.length === 0) {
+    return void 0;
+  }
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  return parts.reduce((acc, part, index) => {
+    if (index === 0) {
+      return part;
+    }
+    const stripped = part.startsWith("0x") ? part.slice(2) : part;
+    return `${acc}${stripped}`;
+  });
+}
+function appendDataSuffix(calldata, suffix) {
+  if (!suffix || suffix === "0x" || suffix.length <= 2) {
+    return calldata;
+  }
+  const suffixHex = suffix.startsWith("0x") ? suffix.slice(2) : suffix;
+  return `${calldata}${suffixHex}`;
+}
+
+// src/exact/client/scheme.ts
+var ExactEvmScheme = class {
+  /**
+   * Creates a new ExactEvmClient instance.
+   *
+   * @param signer - The EVM signer for client operations.
+   *   Base flow only requires `address` + `signTypedData`.
+   *   Extension enrichment (EIP-2612 / ERC-20 approval sponsoring) additionally
+   *   requires optional capabilities like `readContract` and tx signing helpers.
+   * @param options - Optional RPC configuration used to backfill extension capabilities.
+   */
+  constructor(signer, options) {
+    this.signer = signer;
+    this.options = options;
+    this.scheme = "exact";
+  }
+  /**
+   * Creates a payment payload for the Exact scheme.
+   * Routes to EIP-3009 or Permit2 based on requirements.extra.assetTransferMethod.
+   *
+   * For Permit2 flows, if the server advertises `eip2612GasSponsoring` and the
+   * signer supports `readContract`, automatically signs an EIP-2612 permit
+   * when Permit2 allowance is insufficient.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @param context - Optional context with server-declared extensions
+   * @returns Promise resolving to a payment payload result (with optional extensions)
+   */
+  async createPaymentPayload(x402Version, paymentRequirements, context) {
+    const assetTransferMethod = paymentRequirements.extra?.assetTransferMethod ?? "eip3009";
+    if (assetTransferMethod === "permit2") {
+      const result = await createPermit2Payload(this.signer, x402Version, paymentRequirements);
+      const eip2612Extensions = await trySignEip2612PermitExtension(
+        this.signer,
+        this.options,
+        paymentRequirements,
+        result,
+        context
+      );
+      if (eip2612Extensions) {
+        return {
+          ...result,
+          extensions: eip2612Extensions
+        };
+      }
+      const erc20Extensions = await trySignErc20ApprovalExtension(
+        this.signer,
+        this.options,
+        paymentRequirements,
+        context
+      );
+      if (erc20Extensions) {
+        return {
+          ...result,
+          extensions: erc20Extensions
+        };
+      }
+      return result;
+    }
+    return createEIP3009Payload(this.signer, x402Version, paymentRequirements);
+  }
+};
+
+// src/exact/v1/client/scheme.ts
+var import_viem13 = require("viem");
+
+// src/exact/v1/facilitator/scheme.ts
+var import_viem12 = require("viem");
+
+// src/exact/facilitator/eip3009-utils.ts
+var import_viem11 = require("viem");
+
+// src/v1/index.ts
+var EVM_NETWORK_CHAIN_ID_MAP = {
+  ethereum: 1,
+  sepolia: 11155111,
+  abstract: 2741,
+  "abstract-testnet": 11124,
+  "base-sepolia": 84532,
+  base: 8453,
+  "avalanche-fuji": 43113,
+  avalanche: 43114,
+  iotex: 4689,
+  sei: 1329,
+  "sei-testnet": 1328,
+  polygon: 137,
+  "polygon-amoy": 80002,
+  peaq: 3338,
+  story: 1514,
+  educhain: 41923,
+  "skale-base-sepolia": 324705682,
+  megaeth: 4326,
+  monad: 143,
+  stable: 988,
+  "stable-testnet": 2201
+};
+var NETWORKS = Object.keys(EVM_NETWORK_CHAIN_ID_MAP);
+
+// src/signer.ts
+function toClientEvmSigner(signer, publicClient) {
+  const readContract = signer.readContract ?? publicClient?.readContract.bind(publicClient);
+  const result = {
+    address: signer.address,
+    signTypedData: (msg) => signer.signTypedData(msg)
+  };
+  if (readContract) {
+    result.readContract = readContract;
+  }
+  const signTransaction = signer.signTransaction;
+  if (signTransaction) {
+    result.signTransaction = (args) => signTransaction(args);
+  }
+  const getTransactionCount = signer.getTransactionCount ?? publicClient?.getTransactionCount?.bind(publicClient);
+  if (getTransactionCount) {
+    result.getTransactionCount = (args) => getTransactionCount(args);
+  }
+  const estimateFeesPerGas = signer.estimateFeesPerGas ?? publicClient?.estimateFeesPerGas?.bind(publicClient);
+  if (estimateFeesPerGas) {
+    result.estimateFeesPerGas = () => estimateFeesPerGas();
+  }
+  return result;
+}
+function toFacilitatorEvmSigner(client) {
+  return {
+    ...client,
+    getAddresses: () => [client.address]
+  };
+}
+
+// src/batch-settlement/types.ts
+function isObject(payload) {
+  return typeof payload === "object" && payload !== null;
+}
+function isVoucherFields(payload) {
+  return isObject(payload) && "channelId" in payload && "maxClaimableAmount" in payload && "signature" in payload;
+}
+function isBatchSettlementDepositPayload(payload) {
+  return isObject(payload) && payload.type === "deposit" && "channelConfig" in payload && isVoucherFields(payload.voucher) && isObject(payload.deposit) && typeof payload.deposit.amount === "string" && isObject(payload.deposit.authorization);
+}
+function isBatchSettlementVoucherPayload(payload) {
+  return isObject(payload) && payload.type === "voucher" && "channelConfig" in payload && isVoucherFields(payload.voucher);
+}
+function isBatchSettlementRefundPayload(payload) {
+  return isObject(payload) && payload.type === "refund" && "channelConfig" in payload && isVoucherFields(payload.voucher);
+}
+function isBatchSettlementClaimPayload(payload) {
+  return isObject(payload) && payload.type === "claim" && "claims" in payload;
+}
+function isBatchSettlementSettlePayload(payload) {
+  return isObject(payload) && payload.type === "settle" && "receiver" in payload && "token" in payload;
+}
+function isBatchSettlementEnrichedRefundPayload(payload) {
+  return isBatchSettlementRefundPayload(payload) && "amount" in payload && "refundNonce" in payload && "claims" in payload;
+}
+
+// src/types.ts
+function isPermit2Payload(payload) {
+  return "permit2Authorization" in payload;
+}
+function isEIP3009Payload(payload) {
+  return "authorization" in payload;
+}
+function isUptoPermit2Payload(payload) {
+  if (typeof payload.signature !== "string") return false;
+  if (!("permit2Authorization" in payload)) return false;
+  const auth = payload.permit2Authorization;
+  if (typeof auth !== "object" || auth === null) return false;
+  const a = auth;
+  if (typeof a.from !== "string") return false;
+  if (typeof a.spender !== "string") return false;
+  if (typeof a.nonce !== "string") return false;
+  if (typeof a.deadline !== "string") return false;
+  const permitted = a.permitted;
+  if (typeof permitted !== "object" || permitted === null) return false;
+  const p = permitted;
+  if (typeof p.token !== "string") return false;
+  if (typeof p.amount !== "string") return false;
+  const witness = a.witness;
+  if (typeof witness !== "object" || witness === null) return false;
+  const w = witness;
+  return typeof w.facilitator === "string" && typeof w.to === "string" && typeof w.validAfter === "string";
+}
+
+// src/upto/client/permit2.ts
+var import_viem14 = require("viem");
+async function createUptoPermit2Payload(signer, x402Version, paymentRequirements) {
+  const facilitatorAddress = paymentRequirements.extra?.facilitatorAddress;
+  if (!facilitatorAddress) {
+    throw new Error(
+      "upto scheme requires facilitatorAddress in paymentRequirements.extra. Ensure the server is configured with an upto facilitator that provides getExtra()."
+    );
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  const nonce = createPermit2Nonce();
+  const validAfter = "0";
+  const deadline = (now + paymentRequirements.maxTimeoutSeconds).toString();
+  if (BigInt(deadline) <= BigInt(validAfter)) {
+    throw new Error(
+      `Invalid time window: deadline (${deadline}) must be after validAfter (${validAfter}). Check that maxTimeoutSeconds (${paymentRequirements.maxTimeoutSeconds}) is positive.`
+    );
+  }
+  const permit2Authorization = {
+    from: signer.address,
+    permitted: {
+      token: (0, import_viem14.getAddress)(paymentRequirements.asset),
+      amount: paymentRequirements.amount
+    },
+    spender: x402UptoPermit2ProxyAddress,
+    nonce,
+    deadline,
+    witness: {
+      to: (0, import_viem14.getAddress)(paymentRequirements.payTo),
+      facilitator: (0, import_viem14.getAddress)(facilitatorAddress),
+      validAfter
+    }
+  };
+  const chainId = getEvmChainId(paymentRequirements.network);
+  const signature = await signer.signTypedData({
+    domain: { name: "Permit2", chainId, verifyingContract: PERMIT2_ADDRESS },
+    types: uptoPermit2WitnessTypes,
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: (0, import_viem14.getAddress)(permit2Authorization.permitted.token),
+        amount: BigInt(permit2Authorization.permitted.amount)
+      },
+      spender: (0, import_viem14.getAddress)(permit2Authorization.spender),
+      nonce: BigInt(permit2Authorization.nonce),
+      deadline: BigInt(permit2Authorization.deadline),
+      witness: {
+        to: (0, import_viem14.getAddress)(permit2Authorization.witness.to),
+        facilitator: (0, import_viem14.getAddress)(permit2Authorization.witness.facilitator),
+        validAfter: BigInt(permit2Authorization.witness.validAfter)
+      }
+    }
+  });
+  return {
+    x402Version,
+    payload: { signature, permit2Authorization }
+  };
+}
+
+// src/upto/client/scheme.ts
+var UptoEvmScheme = class {
+  /**
+   * Creates a new UptoEvmScheme instance.
+   *
+   * @param signer - The EVM signer for client operations
+   * @param options - Optional RPC configuration
+   */
+  constructor(signer, options) {
+    this.signer = signer;
+    this.options = options;
+    this.scheme = "upto";
+  }
+  /**
+   * Creates a payment payload for the Upto scheme using Permit2.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @param context - Optional context with server-declared extensions
+   * @returns Promise resolving to a payment payload result
+   */
+  async createPaymentPayload(x402Version, paymentRequirements, context) {
+    const result = await createUptoPermit2Payload(this.signer, x402Version, paymentRequirements);
+    const eip2612Extensions = await trySignEip2612PermitExtension(
+      this.signer,
+      this.options,
+      paymentRequirements,
+      result,
+      context
+    );
+    if (eip2612Extensions) {
+      return { ...result, extensions: eip2612Extensions };
+    }
+    const erc20Extensions = await trySignErc20ApprovalExtension(
+      this.signer,
+      this.options,
+      paymentRequirements,
+      context
+    );
+    if (erc20Extensions) {
+      return { ...result, extensions: erc20Extensions };
+    }
+    return result;
+  }
+};
+
+// src/batch-settlement/client/scheme.ts
+var import_viem22 = require("viem");
+
+// src/batch-settlement/constants.ts
+var import_viem15 = require("viem");
+var BATCH_SETTLEMENT_SCHEME = "batch-settlement";
+var BATCH_SETTLEMENT_ADDRESS = "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003";
+var ERC3009_DEPOSIT_COLLECTOR_ADDRESS = "0x4020806089470a89826cB9fB1f4059150b550004";
+var PERMIT2_DEPOSIT_COLLECTOR_ADDRESS = "0x4020425FAf3B746C082C2f942b4E5159887B0005";
+var MIN_WITHDRAW_DELAY = 900;
+var BATCH_SETTLEMENT_DOMAIN = {
+  name: "x402 Batch Settlement",
+  version: "1"
+};
+var CHANNEL_CONFIG_TYPEHASH = (0, import_viem15.keccak256)(
+  (0, import_viem15.toBytes)(
+    "ChannelConfig(address payer,address payerAuthorizer,address receiver,address receiverAuthorizer,address token,uint40 withdrawDelay,bytes32 salt)"
+  )
+);
+var channelConfigTypes = {
+  ChannelConfig: [
+    { name: "payer", type: "address" },
+    { name: "payerAuthorizer", type: "address" },
+    { name: "receiver", type: "address" },
+    { name: "receiverAuthorizer", type: "address" },
+    { name: "token", type: "address" },
+    { name: "withdrawDelay", type: "uint40" },
+    { name: "salt", type: "bytes32" }
+  ]
+};
+var voucherTypes = {
+  Voucher: [
+    { name: "channelId", type: "bytes32" },
+    { name: "maxClaimableAmount", type: "uint128" }
+  ]
+};
+var refundTypes = {
+  Refund: [
+    { name: "channelId", type: "bytes32" },
+    { name: "nonce", type: "uint256" },
+    { name: "amount", type: "uint128" }
+  ]
+};
+var claimBatchTypes = {
+  ClaimBatch: [{ name: "claims", type: "ClaimEntry[]" }],
+  ClaimEntry: [
+    { name: "channelId", type: "bytes32" },
+    { name: "maxClaimableAmount", type: "uint128" },
+    { name: "totalClaimed", type: "uint128" }
+  ]
+};
+var receiveAuthorizationTypes = {
+  ReceiveWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var batchPermit2WitnessTypes = {
+  PermitWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "DepositWitness" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  DepositWitness: [{ name: "channelId", type: "bytes32" }]
+};
+
+// src/batch-settlement/utils.ts
+var import_viem16 = require("viem");
+function computeChannelId(config, networkOrChainId) {
+  const chainId = typeof networkOrChainId === "number" ? networkOrChainId : getEvmChainId(networkOrChainId);
+  return (0, import_viem16.hashTypedData)({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: channelConfigTypes,
+    primaryType: "ChannelConfig",
+    message: {
+      payer: config.payer,
+      payerAuthorizer: config.payerAuthorizer,
+      receiver: config.receiver,
+      receiverAuthorizer: config.receiverAuthorizer,
+      token: config.token,
+      withdrawDelay: config.withdrawDelay,
+      salt: config.salt
+    }
+  });
+}
+function getBatchSettlementEip712Domain(chainId) {
+  return {
+    ...BATCH_SETTLEMENT_DOMAIN,
+    chainId,
+    verifyingContract: (0, import_viem16.getAddress)(BATCH_SETTLEMENT_ADDRESS)
+  };
+}
+
+// src/batch-settlement/client/eip3009.ts
+var import_viem18 = require("viem");
+
+// src/batch-settlement/client/voucher.ts
+async function signVoucher(signer, channelId, maxClaimableAmount, network) {
+  const chainId = getEvmChainId(network);
+  const signature = await signer.signTypedData({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: voucherTypes,
+    primaryType: "Voucher",
+    message: {
+      channelId,
+      maxClaimableAmount: BigInt(maxClaimableAmount)
+    }
+  });
+  return {
+    channelId,
+    maxClaimableAmount,
+    signature
+  };
+}
+
+// src/batch-settlement/encoding.ts
+var import_viem17 = require("viem");
+function buildErc3009DepositNonce(channelId, salt) {
+  return (0, import_viem17.keccak256)(
+    (0, import_viem17.encodeAbiParameters)([{ type: "bytes32" }, { type: "uint256" }], [channelId, BigInt(salt)])
+  );
+}
+
+// src/batch-settlement/client/eip3009.ts
+async function createBatchSettlementEIP3009DepositPayload(signer, x402Version, paymentRequirements, channelConfig, depositAmount, maxClaimableAmount, voucherSigner) {
+  const salt = createNonce();
+  const now = Math.floor(Date.now() / 1e3);
+  const chainId = getEvmChainId(paymentRequirements.network);
+  if (!paymentRequirements.extra?.name || !paymentRequirements.extra?.version) {
+    throw new Error(
+      `EIP-712 domain parameters (name, version) are required in payment requirements for asset ${paymentRequirements.asset}`
+    );
+  }
+  const { name, version } = paymentRequirements.extra;
+  const channelId = computeChannelId(channelConfig, paymentRequirements.network);
+  const erc3009Nonce = buildErc3009DepositNonce(channelId, salt);
+  const signature = await signer.signTypedData({
+    domain: {
+      name,
+      version,
+      chainId,
+      verifyingContract: (0, import_viem18.getAddress)(paymentRequirements.asset)
+    },
+    types: receiveAuthorizationTypes,
+    primaryType: "ReceiveWithAuthorization",
+    message: {
+      from: (0, import_viem18.getAddress)(signer.address),
+      to: (0, import_viem18.getAddress)(ERC3009_DEPOSIT_COLLECTOR_ADDRESS),
+      value: BigInt(depositAmount),
+      validAfter: BigInt(0),
+      validBefore: BigInt(now + paymentRequirements.maxTimeoutSeconds),
+      nonce: erc3009Nonce
+    }
+  });
+  const vSigner = voucherSigner ?? signer;
+  const voucher = await signVoucher(
+    vSigner,
+    channelId,
+    maxClaimableAmount,
+    paymentRequirements.network
+  );
+  const payload = {
+    type: "deposit",
+    channelConfig,
+    voucher,
+    deposit: {
+      amount: depositAmount,
+      authorization: {
+        erc3009Authorization: {
+          validAfter: "0",
+          validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
+          salt,
+          signature
+        }
+      }
+    }
+  };
+  return {
+    x402Version,
+    payload
+  };
+}
+
+// src/batch-settlement/client/permit2.ts
+var import_viem19 = require("viem");
+async function createBatchSettlementPermit2DepositPayload(signer, x402Version, paymentRequirements, channelConfig, depositAmount, maxClaimableAmount, voucherSigner) {
+  const chainId = getEvmChainId(paymentRequirements.network);
+  const nonce = createPermit2Nonce();
+  const deadline = Math.floor(Date.now() / 1e3 + paymentRequirements.maxTimeoutSeconds).toString();
+  const channelId = computeChannelId(channelConfig, paymentRequirements.network);
+  const permit2Authorization = {
+    from: signer.address,
+    permitted: {
+      token: (0, import_viem19.getAddress)(paymentRequirements.asset),
+      amount: depositAmount
+    },
+    spender: (0, import_viem19.getAddress)(PERMIT2_DEPOSIT_COLLECTOR_ADDRESS),
+    nonce,
+    deadline,
+    witness: {
+      channelId
+    }
+  };
+  const signature = await signer.signTypedData({
+    domain: { name: "Permit2", chainId, verifyingContract: PERMIT2_ADDRESS },
+    types: batchPermit2WitnessTypes,
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: permit2Authorization.permitted.token,
+        amount: BigInt(permit2Authorization.permitted.amount)
+      },
+      spender: permit2Authorization.spender,
+      nonce: BigInt(permit2Authorization.nonce),
+      deadline: BigInt(permit2Authorization.deadline),
+      witness: {
+        channelId
+      }
+    }
+  });
+  const voucher = await signVoucher(
+    voucherSigner ?? signer,
+    channelId,
+    maxClaimableAmount,
+    paymentRequirements.network
+  );
+  const payload = {
+    type: "deposit",
+    channelConfig,
+    voucher,
+    deposit: {
+      amount: depositAmount,
+      authorization: {
+        permit2Authorization: {
+          ...permit2Authorization,
+          signature
+        }
+      }
+    }
+  };
+  return { x402Version, payload };
+}
+
+// src/batch-settlement/client/storage.ts
+var InMemoryClientChannelStorage = class {
+  constructor() {
+    this.channels = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Returns the channel record for `key` if present.
+   *
+   * @param key - Channel storage key (channelId).
+   * @returns Persisted context or undefined.
+   */
+  async get(key) {
+    return this.channels.get(key);
+  }
+  /**
+   * Stores or replaces the channel record for `key`.
+   *
+   * @param key - Channel storage key.
+   * @param context - Channel fields to persist.
+   * @returns Resolves when stored.
+   */
+  async set(key, context) {
+    this.channels.set(key, context);
+  }
+  /**
+   * Removes the channel record for `key` if it exists.
+   *
+   * @param key - Channel storage key.
+   * @returns Resolves when removed.
+   */
+  async delete(key) {
+    this.channels.delete(key);
+  }
+};
+
+// src/batch-settlement/client/config.ts
+var DEFAULT_SALT = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function isBatchSettlementEvmSchemeOptions(o) {
+  return o !== void 0 && typeof o === "object" && ("storage" in o || "depositPolicy" in o || "depositStrategy" in o || "salt" in o || "payerAuthorizer" in o || "rpcUrl" in o || "voucherSigner" in o);
+}
+function resolveClientOptions(second) {
+  if (second === void 0) {
+    return { storage: new InMemoryClientChannelStorage(), salt: DEFAULT_SALT };
+  }
+  if (isBatchSettlementEvmSchemeOptions(second)) {
+    return {
+      storage: second.storage ?? new InMemoryClientChannelStorage(),
+      depositPolicy: second.depositPolicy,
+      depositStrategy: second.depositStrategy,
+      salt: second.salt ?? DEFAULT_SALT,
+      payerAuthorizer: second.payerAuthorizer,
+      voucherSigner: second.voucherSigner,
+      extensionRpcOptions: second.rpcUrl ? { rpcUrl: second.rpcUrl } : void 0
+    };
+  }
+  return {
+    storage: new InMemoryClientChannelStorage(),
+    depositPolicy: second,
+    salt: DEFAULT_SALT
+  };
+}
+function validateDepositPolicy(policy) {
+  if (!policy) return;
+  const m = policy.depositMultiplier;
+  if (m !== void 0 && (!Number.isInteger(m) || m < 3)) {
+    throw new Error("depositMultiplier must be an integer >= 3");
+  }
+}
+function depositAmountForRequest(policy, requestAmount) {
+  const mult = BigInt(policy?.depositMultiplier ?? 5);
+  return (mult * requestAmount).toString();
+}
+
+// src/batch-settlement/client/refund.ts
+var import_http2 = require("@bankofai/x402-core/http");
+var import_client = require("@bankofai/x402-core/client");
+
+// src/batch-settlement/errors.ts
+var ErrCumulativeAmountBelowClaimed = "invalid_batch_settlement_evm_cumulative_below_claimed";
+var ErrCumulativeAmountMismatch = "invalid_batch_settlement_evm_cumulative_amount_mismatch";
+var ErrRefundNoBalance = "invalid_batch_settlement_evm_refund_no_balance";
+var ErrRefundAmountInvalid = "invalid_batch_settlement_evm_refund_amount_invalid";
+
+// src/batch-settlement/client/channel.ts
+var import_http = require("@bankofai/x402-core/http");
+var import_viem20 = require("viem");
+
+// src/batch-settlement/abi.ts
+var channelConfigComponents = [
+  { name: "payer", type: "address" },
+  { name: "payerAuthorizer", type: "address" },
+  { name: "receiver", type: "address" },
+  { name: "receiverAuthorizer", type: "address" },
+  { name: "token", type: "address" },
+  { name: "withdrawDelay", type: "uint40" },
+  { name: "salt", type: "bytes32" }
+];
+var voucherClaimComponents = [
+  {
+    name: "voucher",
+    type: "tuple",
+    components: [
+      {
+        name: "channel",
+        type: "tuple",
+        components: channelConfigComponents
+      },
+      { name: "maxClaimableAmount", type: "uint128" }
+    ]
+  },
+  { name: "signature", type: "bytes" },
+  { name: "totalClaimed", type: "uint128" }
+];
+var batchSettlementABI = [
+  {
+    type: "function",
+    name: "multicall",
+    inputs: [{ name: "data", type: "bytes[]" }],
+    outputs: [{ name: "results", type: "bytes[]" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "deposit",
+    inputs: [
+      { name: "config", type: "tuple", components: channelConfigComponents },
+      { name: "amount", type: "uint128" },
+      { name: "collector", type: "address" },
+      { name: "collectorData", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "claim",
+    inputs: [{ name: "voucherClaims", type: "tuple[]", components: voucherClaimComponents }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "claimWithSignature",
+    inputs: [
+      { name: "voucherClaims", type: "tuple[]", components: voucherClaimComponents },
+      { name: "authorizerSignature", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "settle",
+    inputs: [
+      { name: "receiver", type: "address" },
+      { name: "token", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "initiateWithdraw",
+    inputs: [
+      { name: "config", type: "tuple", components: channelConfigComponents },
+      { name: "amount", type: "uint128" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "finalizeWithdraw",
+    inputs: [{ name: "config", type: "tuple", components: channelConfigComponents }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "refund",
+    inputs: [
+      { name: "config", type: "tuple", components: channelConfigComponents },
+      { name: "amount", type: "uint128" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "refundWithSignature",
+    inputs: [
+      { name: "config", type: "tuple", components: channelConfigComponents },
+      { name: "amount", type: "uint128" },
+      { name: "nonce", type: "uint256" },
+      { name: "receiverAuthorizerSignature", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getChannelId",
+    inputs: [{ name: "config", type: "tuple", components: channelConfigComponents }],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "CHANNEL_CONFIG_TYPEHASH",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "channels",
+    inputs: [{ name: "channelId", type: "bytes32" }],
+    outputs: [
+      { name: "balance", type: "uint128" },
+      { name: "totalClaimed", type: "uint128" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingWithdrawals",
+    inputs: [{ name: "channelId", type: "bytes32" }],
+    outputs: [
+      { name: "amount", type: "uint128" },
+      { name: "initiatedAt", type: "uint40" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "receivers",
+    inputs: [
+      { name: "receiver", type: "address" },
+      { name: "token", type: "address" }
+    ],
+    outputs: [
+      { name: "totalClaimed", type: "uint128" },
+      { name: "totalSettled", type: "uint128" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getVoucherDigest",
+    inputs: [
+      { name: "channelId", type: "bytes32" },
+      { name: "maxClaimableAmount", type: "uint128" }
+    ],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getRefundDigest",
+    inputs: [
+      { name: "channelId", type: "bytes32" },
+      { name: "nonce", type: "uint256" },
+      { name: "amount", type: "uint128" }
+    ],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "refundNonce",
+    inputs: [{ name: "channelId", type: "bytes32" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getClaimBatchDigest",
+    inputs: [{ name: "voucherClaims", type: "tuple[]", components: voucherClaimComponents }],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "Settled",
+    inputs: [
+      { name: "receiver", type: "address", indexed: true },
+      { name: "token", type: "address", indexed: true },
+      { name: "sender", type: "address", indexed: true },
+      { name: "amount", type: "uint128", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+
+// src/batch-settlement/client/channel.ts
+function readResponseChannelState(extra) {
+  const channelState = extra.channelState;
+  if (typeof channelState !== "object" || channelState === null) {
+    return void 0;
+  }
+  return channelState;
+}
+function buildChannelConfig(deps, paymentRequirements) {
+  const extra = paymentRequirements.extra;
+  const receiverAuthorizer = extra?.receiverAuthorizer;
+  if (!receiverAuthorizer || (0, import_viem20.getAddress)(receiverAuthorizer) === "0x0000000000000000000000000000000000000000") {
+    throw new Error("Payment requirements must include a non-zero extra.receiverAuthorizer");
+  }
+  return {
+    payer: deps.signer.address,
+    payerAuthorizer: (0, import_viem20.getAddress)(
+      deps.payerAuthorizer ?? deps.voucherSigner?.address ?? deps.signer.address
+    ),
+    receiver: paymentRequirements.payTo,
+    receiverAuthorizer: (0, import_viem20.getAddress)(receiverAuthorizer),
+    token: paymentRequirements.asset,
+    withdrawDelay: typeof extra?.withdrawDelay === "number" ? extra.withdrawDelay : MIN_WITHDRAW_DELAY,
+    salt: deps.salt
+  };
+}
+async function processSettleResponse(storage, settle) {
+  const extra = settle.extra ?? {};
+  const channelState = readResponseChannelState(extra);
+  if (!channelState) return;
+  const channelId = channelState.channelId;
+  const key = channelId.toLowerCase();
+  const prev = await storage.get(key);
+  const next = { ...prev ?? {} };
+  if (channelState.chargedCumulativeAmount !== void 0) {
+    next.chargedCumulativeAmount = String(channelState.chargedCumulativeAmount);
+  }
+  if (channelState.balance !== void 0) {
+    next.balance = String(channelState.balance);
+  }
+  if (channelState.totalClaimed !== void 0) {
+    next.totalClaimed = String(channelState.totalClaimed);
+  }
+  await storage.set(key, next);
+}
+async function updateChannelAfterRefund(storage, channelKey, settleExtra) {
+  const channelState = readResponseChannelState(settleExtra);
+  if (!channelState) {
+    await storage.delete(channelKey);
+    return;
+  }
+  const balanceAfter = channelState.balance !== void 0 ? BigInt(String(channelState.balance)) : void 0;
+  if (balanceAfter === void 0 || balanceAfter <= 0n) {
+    await storage.delete(channelKey);
+    return;
+  }
+  const prev = await storage.get(channelKey);
+  const next = { ...prev ?? {} };
+  next.balance = balanceAfter.toString();
+  if (channelState.chargedCumulativeAmount !== void 0) {
+    next.chargedCumulativeAmount = String(channelState.chargedCumulativeAmount);
+  }
+  if (channelState.totalClaimed !== void 0) {
+    next.totalClaimed = String(channelState.totalClaimed);
+  }
+  await storage.set(channelKey, next);
+}
+async function recoverChannel(deps, paymentRequirements) {
+  if (!deps.signer.readContract) {
+    throw new Error("recoverChannel requires ClientEvmSigner.readContract");
+  }
+  const config = buildChannelConfig(deps, paymentRequirements);
+  const channelId = computeChannelId(config, paymentRequirements.network);
+  const [chBalance, chTotalClaimed] = await readChannelBalanceAndTotalClaimed(
+    deps.signer,
+    channelId
+  );
+  const ctx = {
+    chargedCumulativeAmount: chTotalClaimed.toString(),
+    balance: chBalance.toString(),
+    totalClaimed: chTotalClaimed.toString()
+  };
+  await deps.storage.set(channelId.toLowerCase(), ctx);
+  return ctx;
+}
+async function readChannelBalanceAndTotalClaimed(signer, channelId) {
+  if (!signer.readContract) {
+    throw new Error("readChannelBalanceAndTotalClaimed requires ClientEvmSigner.readContract");
+  }
+  return await signer.readContract({
+    address: BATCH_SETTLEMENT_ADDRESS,
+    abi: batchSettlementABI,
+    functionName: "channels",
+    args: [channelId]
+  });
+}
+
+// src/batch-settlement/client/recovery.ts
+var import_viem21 = require("viem");
+async function processCorrectivePaymentRequired(deps, paymentRequired) {
+  if (paymentRequired.error !== ErrCumulativeAmountMismatch && paymentRequired.error !== ErrCumulativeAmountBelowClaimed) {
+    return false;
+  }
+  const accept = paymentRequired.accepts.find((a) => a.scheme === BATCH_SETTLEMENT_SCHEME);
+  if (!accept) {
+    return false;
+  }
+  const channelState = accept.extra.channelState;
+  const voucherState = accept.extra.voucherState;
+  const hasSig = channelState?.chargedCumulativeAmount !== void 0 && voucherState?.signedMaxClaimable !== void 0 && voucherState.signature !== void 0;
+  if (!hasSig) {
+    return recoverFromOnChainState(deps, accept);
+  }
+  return recoverFromSignature(deps, accept, channelState, voucherState);
+}
+async function recoverFromSignature(deps, accept, channelState, voucherState) {
+  const chargedRaw = channelState.chargedCumulativeAmount;
+  const signedRaw = voucherState.signedMaxClaimable;
+  const sig = voucherState.signature;
+  const charged = BigInt(String(chargedRaw));
+  const signed = BigInt(String(signedRaw));
+  if (charged > signed) {
+    return false;
+  }
+  const config = buildChannelConfig(deps, accept);
+  const channelId = computeChannelId(config, accept.network);
+  if (!deps.signer.readContract) {
+    return false;
+  }
+  const [chBalance, chTotalClaimed] = await readChannelBalanceAndTotalClaimed(
+    deps.signer,
+    channelId
+  );
+  if (charged < chTotalClaimed) {
+    return false;
+  }
+  const chainId = getEvmChainId(accept.network);
+  const recovered = await (0, import_viem21.recoverTypedDataAddress)({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: voucherTypes,
+    primaryType: "Voucher",
+    message: {
+      channelId,
+      maxClaimableAmount: signed
+    },
+    signature: sig
+  });
+  const expectedSigner = (0, import_viem21.getAddress)(
+    deps.payerAuthorizer ?? deps.voucherSigner?.address ?? deps.signer.address
+  );
+  if (recovered.toLowerCase() !== expectedSigner.toLowerCase()) {
+    return false;
+  }
+  const ctx = {
+    chargedCumulativeAmount: charged.toString(),
+    signedMaxClaimable: signed.toString(),
+    signature: sig,
+    balance: chBalance.toString(),
+    totalClaimed: chTotalClaimed.toString()
+  };
+  await deps.storage.set(channelId.toLowerCase(), ctx);
+  return true;
+}
+async function recoverFromOnChainState(deps, accept) {
+  if (!deps.signer.readContract) {
+    return false;
+  }
+  const config = buildChannelConfig(deps, accept);
+  const channelId = computeChannelId(config, accept.network);
+  const [chBalance, chTotalClaimed] = await readChannelBalanceAndTotalClaimed(
+    deps.signer,
+    channelId
+  );
+  const ctx = {
+    chargedCumulativeAmount: chTotalClaimed.toString(),
+    balance: chBalance.toString(),
+    totalClaimed: chTotalClaimed.toString()
+  };
+  await deps.storage.set(channelId.toLowerCase(), ctx);
+  return true;
+}
+
+// src/batch-settlement/client/hooks.ts
+function createBatchSettlementClientHooks(deps) {
+  return {
+    onPaymentResponse: (ctx) => handleBatchSettlementPaymentResponse(deps, ctx)
+  };
+}
+async function handleBatchSettlementPaymentResponse(deps, ctx) {
+  if (ctx.settleResponse) {
+    if (isBatchSettlementRefundPayload(ctx.paymentPayload.payload)) {
+      const extra = ctx.settleResponse.extra ?? {};
+      const channelState = extra.channelState;
+      const channelId = typeof channelState === "object" && channelState !== null && "channelId" in channelState ? channelState.channelId : void 0;
+      if (typeof channelId === "string" && channelId) {
+        await updateChannelAfterRefund(deps.storage, channelId.toLowerCase(), extra);
+      }
+      return;
+    }
+    await processSettleResponse(deps.storage, ctx.settleResponse);
+    return;
+  }
+  if (ctx.paymentRequired) {
+    const recovered = await processCorrectivePaymentRequired(deps, ctx.paymentRequired);
+    return recovered ? { recovered: true } : void 0;
+  }
+}
+
+// src/batch-settlement/client/refund.ts
+var NON_RECOVERABLE_REFUND_ERRORS = /* @__PURE__ */ new Set([
+  ErrRefundNoBalance,
+  ErrRefundAmountInvalid
+]);
+async function refundChannel(ctx, url, options) {
+  const fetchImpl = options?.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("refund requires a fetch implementation (globalThis.fetch unavailable)");
+  }
+  const refundAmount = normalizeRefundAmount(options?.amount);
+  const probe = await probeRefundRequirements(url, fetchImpl);
+  return executeRefund(ctx, url, probe, refundAmount, fetchImpl);
+}
+async function probeRefundRequirements(url, fetchImpl) {
+  const probe = await fetchImpl(url, { method: "GET" });
+  if (probe.status !== 402) {
+    throw new Error(`Refund probe expected 402, got ${probe.status}`);
+  }
+  const header = probe.headers.get("PAYMENT-REQUIRED");
+  if (!header) {
+    throw new Error("Refund probe response missing PAYMENT-REQUIRED header");
+  }
+  const paymentRequired = (0, import_http2.decodePaymentRequiredHeader)(header);
+  const requirements = paymentRequired.accepts.find((a) => a.scheme === BATCH_SETTLEMENT_SCHEME);
+  if (!requirements) {
+    throw new Error(`No ${BATCH_SETTLEMENT_SCHEME} payment option at ${url}`);
+  }
+  const extra = requirements.extra;
+  if (!extra?.receiverAuthorizer) {
+    throw new Error("Refund requires a configured receiverAuthorizer on the receiver");
+  }
+  return { paymentRequired, requirements };
+}
+async function executeRefund(ctx, url, probe, refundAmount, fetchImpl) {
+  const maxAttempts = 2;
+  const { paymentRequired, requirements } = probe;
+  const httpClient = createRefundHttpClient(ctx, requirements);
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const paymentPayload = await buildRefundPaymentPayload(
+      ctx,
+      paymentRequired,
+      requirements,
+      refundAmount
+    );
+    const headers = httpClient.encodePaymentSignatureHeader(paymentPayload);
+    const response = await fetchImpl(url, { method: "GET", headers });
+    if (response.status === 402) {
+      const nonRecoverable = getNonRecoverableRefundFailure(response);
+      if (nonRecoverable) {
+        throw new Error(nonRecoverable);
+      }
+    }
+    const result = await httpClient.processPaymentResult(
+      paymentPayload,
+      (name) => response.headers.get(name),
+      response.status
+    );
+    if (response.status === 402) {
+      if (result.recovered && attempt < maxAttempts) {
+        continue;
+      }
+      if (result.recovered) {
+        throw new Error(`Refund failed: server returned 402 after ${attempt} attempt(s)`);
+      }
+      const corrective = getRefundPaymentRequired(response);
+      throw new Error(`Refund failed: ${corrective.error ?? "unknown"}`);
+    }
+    if (!result.settleResponse) {
+      throw new Error(
+        `Refund response missing PAYMENT-RESPONSE header (status ${response.status})`
+      );
+    }
+    return result.settleResponse;
+  }
+  throw new Error("Refund failed: retry budget exhausted");
+}
+async function buildRefundPaymentPayload(ctx, paymentRequired, requirements, refundAmount) {
+  const config = buildChannelConfig(ctx, requirements);
+  const channelId = computeChannelId(config, requirements.network);
+  const key = channelId.toLowerCase();
+  let channel = await ctx.storage.get(key);
+  if (channel === void 0 && ctx.signer.readContract) {
+    channel = await recoverChannel(ctx, requirements);
+  }
+  if (channel === void 0) {
+    throw new Error(
+      "Refund requires an existing channel record; deposit first or call from a context with an EVM RPC"
+    );
+  }
+  const charged = channel.chargedCumulativeAmount ?? "0";
+  if (channel.balance !== void 0 && BigInt(channel.balance) <= BigInt(charged)) {
+    throw new Error(
+      `Refund failed: channel has no remaining balance (balance=${channel.balance}, chargedCumulativeAmount=${charged})`
+    );
+  }
+  const voucherSigner = ctx.voucherSigner ?? ctx.signer;
+  const voucher = await signVoucher(voucherSigner, channelId, charged, requirements.network);
+  const payload = {
+    type: "refund",
+    channelConfig: config,
+    voucher,
+    ...refundAmount !== void 0 ? { amount: refundAmount } : {}
+  };
+  return {
+    x402Version: 2,
+    accepted: requirements,
+    payload,
+    ...paymentRequired.resource ? { resource: paymentRequired.resource } : {},
+    ...paymentRequired.extensions ? { extensions: paymentRequired.extensions } : {}
+  };
+}
+function createRefundHttpClient(ctx, requirements) {
+  const client = new import_client.x402Client().register(requirements.network, {
+    scheme: BATCH_SETTLEMENT_SCHEME,
+    schemeHooks: createBatchSettlementClientHooks(ctx),
+    createPaymentPayload: async () => {
+      throw new Error("Refund payloads are built by refundChannel");
+    }
+  });
+  return new import_client.x402HTTPClient(client);
+}
+function getNonRecoverableRefundFailure(response) {
+  const settleHeader = response.headers.get("PAYMENT-RESPONSE");
+  if (settleHeader) {
+    return formatRefundFailure((0, import_http2.decodePaymentResponseHeader)(settleHeader));
+  }
+  const paymentRequired = getRefundPaymentRequired(response);
+  const errorCode = paymentRequired.error;
+  if (errorCode && NON_RECOVERABLE_REFUND_ERRORS.has(errorCode)) {
+    return `Refund failed: ${errorCode}`;
+  }
+}
+function getRefundPaymentRequired(response) {
+  const requiredHeader = response.headers.get("PAYMENT-REQUIRED");
+  if (!requiredHeader) {
+    throw new Error("Refund 402 missing PAYMENT-REQUIRED header");
+  }
+  return (0, import_http2.decodePaymentRequiredHeader)(requiredHeader);
+}
+function formatRefundFailure(settle) {
+  const reason = settle.errorReason ?? "unknown_settlement_error";
+  const message = settle.errorMessage;
+  if (message && message !== reason) {
+    return `Refund failed: ${reason}: ${message}`;
+  }
+  return `Refund failed: ${reason}`;
+}
+function normalizeRefundAmount(amount) {
+  if (amount === void 0) return void 0;
+  if (!/^\d+$/.test(amount) || amount === "0") {
+    throw new Error(`Invalid refund amount "${amount}": must be a positive integer string`);
+  }
+  return amount;
+}
+
+// src/batch-settlement/client/scheme.ts
+var BatchSettlementEvmScheme = class {
+  /**
+   * Constructs a batched client scheme.
+   *
+   * @param signer - Client EVM wallet used for signing vouchers and ERC-3009 authorizations.
+   * @param optionsOrPolicy - Either a full options object or a bare deposit-policy.
+   */
+  constructor(signer, optionsOrPolicy) {
+    this.signer = signer;
+    this.scheme = BATCH_SETTLEMENT_SCHEME;
+    const {
+      storage,
+      depositPolicy,
+      depositStrategy,
+      salt,
+      payerAuthorizer,
+      voucherSigner,
+      extensionRpcOptions
+    } = resolveClientOptions(optionsOrPolicy);
+    this.storage = storage;
+    this.depositPolicy = depositPolicy;
+    this.depositStrategy = depositStrategy;
+    this.salt = salt;
+    this.payerAuthorizer = payerAuthorizer;
+    this.voucherSigner = voucherSigner;
+    this.extensionRpcOptions = extensionRpcOptions;
+    if (payerAuthorizer !== void 0 && voucherSigner !== void 0 && (0, import_viem22.getAddress)(payerAuthorizer) !== (0, import_viem22.getAddress)(voucherSigner.address)) {
+      throw new Error("payerAuthorizer address must match voucherSigner.address");
+    }
+    validateDepositPolicy(depositPolicy);
+    this.schemeHooks = createBatchSettlementClientHooks(this.deps());
+  }
+  /**
+   * Creates the payment payload for a batched request.
+   *
+   * If the channel has no onchain deposit (or needs a top-up), builds an
+   * ERC-3009 deposit payload bundled with a voucher. Otherwise, signs and
+   * returns a voucher-only payload.
+   *
+   * @param x402Version - Protocol version for the payload envelope.
+   * @param paymentRequirements - Server payment requirements (scheme, network, asset, amount).
+   * @param context - Optional payment payload context with extension hints.
+   * @returns A {@link PaymentPayloadResult} ready to be sent as the `X-PAYMENT` header.
+   */
+  async createPaymentPayload(x402Version, paymentRequirements, context) {
+    const deps = this.deps();
+    const config = buildChannelConfig(deps, paymentRequirements);
+    const channelId = computeChannelId(config, paymentRequirements.network);
+    const key = channelId.toLowerCase();
+    let batchedCtx = await this.storage.get(key);
+    if (batchedCtx === void 0 && this.signer.readContract) {
+      batchedCtx = await recoverChannel(deps, paymentRequirements);
+    }
+    batchedCtx = batchedCtx ?? {};
+    const needsInitialDeposit = !batchedCtx.balance || batchedCtx.balance === "0";
+    const baseCumulative = BigInt(batchedCtx.chargedCumulativeAmount ?? "0");
+    const requestAmount = BigInt(paymentRequirements.amount);
+    const maxClaimableAmount = (baseCumulative + requestAmount).toString();
+    const currentBalance = BigInt(batchedCtx.balance ?? "0");
+    const needsTopUp = !needsInitialDeposit && BigInt(maxClaimableAmount) > currentBalance;
+    if (needsInitialDeposit || needsTopUp) {
+      const computedDeposit = depositAmountForRequest(this.depositPolicy, requestAmount);
+      const minimumDepositAmount = BigInt(maxClaimableAmount) - currentBalance;
+      const depositAmount = await this.resolveDepositAmount({
+        paymentRequirements,
+        channelConfig: config,
+        channelId,
+        clientContext: batchedCtx,
+        requestAmount: requestAmount.toString(),
+        maxClaimableAmount,
+        currentBalance: currentBalance.toString(),
+        minimumDepositAmount: minimumDepositAmount.toString(),
+        depositAmount: computedDeposit
+      });
+      if (depositAmount === false) {
+        return this.createVoucherPayload(
+          x402Version,
+          channelId,
+          maxClaimableAmount,
+          paymentRequirements.network,
+          config
+        );
+      }
+      const assetTransferMethod = paymentRequirements.extra?.assetTransferMethod ?? "eip3009";
+      if (assetTransferMethod === "eip3009") {
+        return createBatchSettlementEIP3009DepositPayload(
+          this.signer,
+          x402Version,
+          paymentRequirements,
+          config,
+          depositAmount,
+          maxClaimableAmount,
+          this.voucherSigner
+        );
+      }
+      if (assetTransferMethod !== "permit2") {
+        throw new Error(`unsupported batch-settlement assetTransferMethod: ${assetTransferMethod}`);
+      }
+      const result = await createBatchSettlementPermit2DepositPayload(
+        this.signer,
+        x402Version,
+        paymentRequirements,
+        config,
+        depositAmount,
+        maxClaimableAmount,
+        this.voucherSigner
+      );
+      const eip2612Extensions = await trySignEip2612PermitExtension(
+        this.signer,
+        this.extensionRpcOptions,
+        paymentRequirements,
+        result,
+        context,
+        depositAmount
+      );
+      if (eip2612Extensions) {
+        return { ...result, extensions: eip2612Extensions };
+      }
+      const erc20Extensions = await trySignErc20ApprovalExtension(
+        this.signer,
+        this.extensionRpcOptions,
+        paymentRequirements,
+        context,
+        depositAmount
+      );
+      if (erc20Extensions) {
+        return { ...result, extensions: erc20Extensions };
+      }
+      return result;
+    }
+    return this.createVoucherPayload(
+      x402Version,
+      channelId,
+      maxClaimableAmount,
+      paymentRequirements.network,
+      config
+    );
+  }
+  /**
+   * Sends a cooperative refund request.
+   *
+   * @param url - The route URL backing the channel to refund.
+   * @param options - Optional `amount` (partial refund) and `fetch` override.
+   * @returns The settle response describing the refund outcome.
+   */
+  async refund(url, options) {
+    return refundChannel(this.deps(), url, options);
+  }
+  /**
+   * Updates local channel state from a settle response.
+   *
+   * @param settle - The parsed settle response from the server.
+   * @returns Resolves when local channel state has been updated.
+   */
+  async processSettleResponse(settle) {
+    return processSettleResponse(this.storage, settle);
+  }
+  /**
+   * Resyncs local channel state from a corrective 402 response.
+   *
+   * @param paymentRequired - The decoded 402 response body.
+   * @returns `true` if local state was successfully resynced and a retry is warranted.
+   */
+  async processCorrectivePaymentRequired(paymentRequired) {
+    return processCorrectivePaymentRequired(this.deps(), paymentRequired);
+  }
+  /**
+   * Builds the immutable {@link ChannelConfig} for a given set of payment
+   * requirements, using the scheme's own signer and salt.
+   *
+   * @param paymentRequirements - Server payment requirements for the channel.
+   * @returns The channel config that uniquely identifies the payment channel.
+   */
+  buildChannelConfig(paymentRequirements) {
+    return buildChannelConfig(this.deps(), paymentRequirements);
+  }
+  /**
+   * Resolves the deposit amount after applying the optional custom strategy.
+   *
+   * @param context - Deposit attempt context exposed to the strategy.
+   * @returns The deposit amount to sign, or `false` to skip this deposit attempt.
+   */
+  async resolveDepositAmount(context) {
+    const strategyResult = await this.depositStrategy?.(context);
+    if (strategyResult === false) return false;
+    if (strategyResult === void 0) return context.depositAmount;
+    const depositAmount = this.normalizeStrategyDepositAmount(strategyResult);
+    if (BigInt(depositAmount) < BigInt(context.minimumDepositAmount)) {
+      throw new Error(
+        `depositStrategy returned ${depositAmount}, below required top-up ${context.minimumDepositAmount}`
+      );
+    }
+    return depositAmount;
+  }
+  /**
+   * Normalizes and validates a strategy-provided base-unit deposit amount.
+   *
+   * @param value - Strategy-provided string or bigint amount.
+   * @returns Normalized decimal string.
+   */
+  normalizeStrategyDepositAmount(value) {
+    if (typeof value === "bigint") {
+      if (value <= 0n) {
+        throw new Error("depositStrategy must return a positive integer deposit amount");
+      }
+      return value.toString();
+    }
+    if (/^\d+$/.test(value) && BigInt(value) > 0n) {
+      return BigInt(value).toString();
+    }
+    throw new Error("depositStrategy must return a positive integer deposit amount");
+  }
+  /**
+   * Signs a voucher-only payment payload for the current channel.
+   *
+   * @param x402Version - Protocol version for the payload envelope.
+   * @param channelId - Channel identifier for the voucher.
+   * @param maxClaimableAmount - Cumulative ceiling for the voucher.
+   * @param network - CAIP-2 network identifier.
+   * @param config - Immutable channel configuration.
+   * @returns Voucher-only payment payload.
+   */
+  async createVoucherPayload(x402Version, channelId, maxClaimableAmount, network, config) {
+    const voucherSigner = this.voucherSigner ?? this.signer;
+    const voucher = await signVoucher(voucherSigner, channelId, maxClaimableAmount, network);
+    const payload = {
+      type: "voucher",
+      channelConfig: config,
+      voucher
+    };
+    return {
+      x402Version,
+      payload
+    };
+  }
+  /**
+   * Bundles the class state into the {@link BatchSettlementClientDeps} shape
+   * consumed by the `channel`, `recovery`, and `refund` modules.
+   *
+   * @returns Client deps wrapping the scheme's own signer and storage.
+   */
+  deps() {
+    return {
+      signer: this.signer,
+      storage: this.storage,
+      salt: this.salt,
+      payerAuthorizer: this.payerAuthorizer,
+      voucherSigner: this.voucherSigner
+    };
+  }
+};
+
+// src/shared/defaultAssets.ts
+var DEFAULT_STABLECOINS = {
+  "eip155:8453": {
+    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Base mainnet USDC
+  "eip155:84532": {
+    address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    name: "USDC",
+    version: "2",
+    decimals: 6
+  },
+  // Base Sepolia USDC
+  "eip155:4326": {
+    address: "0xFAfDdbb3FC7688494971a79cc65DCa3EF82079E7",
+    name: "MegaUSD",
+    version: "1",
+    decimals: 18,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // MegaETH mainnet MegaUSD (no EIP-3009, supports EIP-2612)
+  "eip155:143": {
+    address: "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Monad mainnet USDC
+  "eip155:988": {
+    address: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    name: "USDT0",
+    version: "1",
+    decimals: 6
+  },
+  // Stable mainnet USDT0
+  "eip155:2201": {
+    address: "0x78Cf24370174180738C5B8E352B6D14c83a6c9A9",
+    name: "USDT0",
+    version: "1",
+    decimals: 6
+  },
+  // Stable testnet USDT0
+  "eip155:137": {
+    address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Polygon mainnet USDC
+  "eip155:42161": {
+    address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Arbitrum One USDC
+  "eip155:421614": {
+    address: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Arbitrum Sepolia USDC
+  "eip155:31612": {
+    address: "0xdD468A1DDc392dcdbEf6db6e34E89AA338F9F186",
+    name: "Mezo USD",
+    version: "1",
+    decimals: 18,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // Mezo mainnet mUSD (no EIP-3009, supports EIP-2612)
+  "eip155:31611": {
+    address: "0x118917a40FAF1CD7a13dB0Ef56C86De7973Ac503",
+    name: "Mezo USD",
+    version: "1",
+    decimals: 18,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // Mezo Testnet mUSD (no EIP-3009, supports EIP-2612)
+  "eip155:723487": {
+    address: "0x33ad9e4BD16B69B5BFdED37D8B5D9fF9aba014Fb",
+    name: "Stable Coin",
+    version: "1",
+    decimals: 6,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // Radius Network SBC (no EIP-3009, supports EIP-2612)
+  "eip155:72344": {
+    address: "0x33ad9e4BD16B69B5BFdED37D8B5D9fF9aba014Fb",
+    name: "Stable Coin",
+    version: "1",
+    decimals: 6,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // Radius Testnet SBC (no EIP-3009, supports EIP-2612)
+  "eip155:36900": {
+    address: "0x9cb8142aEBBcdc60AF7c97Af897A67A8f3CA71C2",
+    name: "USDC.e",
+    version: "2",
+    decimals: 6
+  },
+  // ADI Chain USDC.e (EIP-3009 supported)
+  "eip155:190415": {
+    address: "0x401eCb1D350407f13ba348573E5630B83638E30D",
+    name: "Bridged USDC",
+    version: "2",
+    decimals: 6
+  },
+  // HPP mainnet USDC.e
+  "eip155:181228": {
+    address: "0x401eCb1D350407f13ba348573E5630B83638E30D",
+    name: "Bridged USDC",
+    version: "2",
+    decimals: 6
+  },
+  // HPP Sepolia USDC.e
+  "eip155:50": {
+    address: "0xfA2958CB79b0491CC627c1557F441eF849Ca8eb1",
+    name: "USDC",
+    version: "2",
+    decimals: 6
+  },
+  // XDC Network mainnet USDC (Bridged USDC Standard, EIP-3009 supported)
+  "eip155:51": {
+    address: "0xb5AB69F7bBada22B28e79C8FFAECe55eF1c771D4",
+    name: "USDC",
+    version: "2",
+    decimals: 6
+  }
+  // XDC Apothem testnet USDC (Bridged USDC Standard, EIP-3009 supported)
+};
+function getDefaultAsset(network) {
+  const info = DEFAULT_STABLECOINS[network];
+  if (!info) {
+    throw new Error(`No default asset configured for network ${network}`);
+  }
+  return info;
+}
+
+// src/auth-capture/client/scheme.ts
+var import_viem24 = require("viem");
+
+// src/auth-capture/constants.ts
+var AUTH_CAPTURE_SCHEME = "auth-capture";
+var AUTH_CAPTURE_ESCROW_ADDRESS = "0xBdEA0D1bcC5966192B070Fdf62aB4EF5b4420cff";
+var EIP3009_TOKEN_COLLECTOR_ADDRESS = "0x0E3dF9510de65469C4518D7843919c0b8C7A7757";
+var PERMIT2_TOKEN_COLLECTOR_ADDRESS = "0x992476B9Ee81d52a5BdA0622C333938D0Af0aB26";
+var RECEIVE_AUTHORIZATION_TYPES = {
+  ReceiveWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var PERMIT2_TRANSFER_FROM_TYPES = {
+  PermitTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+
+// src/auth-capture/nonce.ts
+var import_viem23 = require("viem");
+var PAYMENT_INFO_TYPEHASH = (0, import_viem23.keccak256)(
+  new TextEncoder().encode(
+    "PaymentInfo(address operator,address payer,address receiver,address token,uint120 maxAmount,uint48 preApprovalExpiry,uint48 authorizationExpiry,uint48 refundExpiry,uint16 minFeeBps,uint16 maxFeeBps,address feeReceiver,uint256 salt)"
+  )
+);
+function computePayerAgnosticPaymentInfoHash(chainId, paymentInfo) {
+  const paymentInfoEncoded = (0, import_viem23.encodeAbiParameters)(
+    [
+      { name: "typehash", type: "bytes32" },
+      { name: "operator", type: "address" },
+      { name: "payer", type: "address" },
+      { name: "receiver", type: "address" },
+      { name: "token", type: "address" },
+      { name: "maxAmount", type: "uint120" },
+      { name: "preApprovalExpiry", type: "uint48" },
+      { name: "authorizationExpiry", type: "uint48" },
+      { name: "refundExpiry", type: "uint48" },
+      { name: "minFeeBps", type: "uint16" },
+      { name: "maxFeeBps", type: "uint16" },
+      { name: "feeReceiver", type: "address" },
+      { name: "salt", type: "uint256" }
+    ],
+    [
+      PAYMENT_INFO_TYPEHASH,
+      paymentInfo.operator,
+      import_viem23.zeroAddress,
+      paymentInfo.receiver,
+      paymentInfo.token,
+      BigInt(paymentInfo.maxAmount),
+      paymentInfo.preApprovalExpiry,
+      paymentInfo.authorizationExpiry,
+      paymentInfo.refundExpiry,
+      paymentInfo.minFeeBps,
+      paymentInfo.maxFeeBps,
+      paymentInfo.feeReceiver,
+      BigInt(paymentInfo.salt)
+    ]
+  );
+  const paymentInfoHash = (0, import_viem23.keccak256)(paymentInfoEncoded);
+  const outerEncoded = (0, import_viem23.encodeAbiParameters)(
+    [
+      { name: "chainId", type: "uint256" },
+      { name: "escrow", type: "address" },
+      { name: "paymentInfoHash", type: "bytes32" }
+    ],
+    [BigInt(chainId), AUTH_CAPTURE_ESCROW_ADDRESS, paymentInfoHash]
+  );
+  return (0, import_viem23.keccak256)(outerEncoded);
+}
+async function signERC3009(signer, authorization, extra, tokenAddress, chainId) {
+  const domain = {
+    name: extra.name,
+    version: extra.version,
+    chainId,
+    verifyingContract: (0, import_viem23.getAddress)(tokenAddress)
+  };
+  const message = {
+    from: (0, import_viem23.getAddress)(authorization.from),
+    to: (0, import_viem23.getAddress)(authorization.to),
+    value: BigInt(authorization.value),
+    validAfter: BigInt(authorization.validAfter),
+    validBefore: BigInt(authorization.validBefore),
+    nonce: authorization.nonce
+  };
+  return signer.signTypedData({
+    domain,
+    types: RECEIVE_AUTHORIZATION_TYPES,
+    primaryType: "ReceiveWithAuthorization",
+    message
+  });
+}
+async function signPermit2(signer, permit, chainId) {
+  const domain = {
+    name: "Permit2",
+    chainId,
+    verifyingContract: PERMIT2_ADDRESS
+  };
+  const message = {
+    permitted: {
+      token: (0, import_viem23.getAddress)(permit.permitted.token),
+      amount: BigInt(permit.permitted.amount)
+    },
+    spender: (0, import_viem23.getAddress)(permit.spender),
+    nonce: BigInt(permit.nonce),
+    deadline: BigInt(permit.deadline)
+  };
+  return signer.signTypedData({
+    domain,
+    types: PERMIT2_TRANSFER_FROM_TYPES,
+    primaryType: "PermitTransferFrom",
+    message
+  });
+}
+function generateSalt() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return (0, import_viem23.toHex)(bytes);
+}
+
+// src/auth-capture/utils.ts
+function parseChainId(network) {
+  const parts = network.split(":");
+  if (parts.length !== 2 || parts[0] !== "eip155") {
+    throw new Error(`Invalid network format: ${network}. Expected 'eip155:<chainId>'`);
+  }
+  const chainId = parseInt(parts[1], 10);
+  if (isNaN(chainId)) {
+    throw new Error(`Invalid chainId in network: ${network}`);
+  }
+  return chainId;
+}
+
+// src/auth-capture/client/scheme.ts
+var AuthCaptureEvmScheme = class {
+  /**
+   * Construct a client-side auth-capture scheme bound to a specific signer.
+   *
+   * @param signer - Client-side signer that exposes `address` and `signTypedData`.
+   */
+  constructor(signer) {
+    this.signer = signer;
+    this.scheme = AUTH_CAPTURE_SCHEME;
+  }
+  /**
+   * Build and sign an auth-capture payment payload for the given requirements.
+   * Validates all spec-mandated `extra` fields and the asset-transfer method
+   * (default `eip3009`, alternative `permit2`), reconstructs the on-chain
+   * PaymentInfo struct, computes its payer-agnostic hash, and returns the
+   * signed wire payload.
+   *
+   * @param x402Version - Wire protocol version; only `2` is supported.
+   * @param requirements - Resource server's payment requirements (includes scheme `extra`).
+   * @param _ - Unused FacilitatorContext (interface compatibility).
+   * @returns The signed wire payload tagged with the x402 protocol version.
+   * @throws If `x402Version !== 2` or any required `extra` field is missing.
+   */
+  async createPaymentPayload(x402Version, requirements, _) {
+    if (x402Version !== 2) {
+      throw new Error(`Unsupported x402Version: ${x402Version}. Only version 2 is supported.`);
+    }
+    const extra = requirements.extra;
+    if (!extra.name) {
+      throw new Error(
+        `EIP-712 domain parameter 'name' is required in payment requirements for asset ${requirements.asset}`
+      );
+    }
+    if (!extra.version) {
+      throw new Error(
+        `EIP-712 domain parameter 'version' is required in payment requirements for asset ${requirements.asset}`
+      );
+    }
+    if (!extra.captureAuthorizer) {
+      throw new Error(`'captureAuthorizer' is required in payment requirements extra`);
+    }
+    if (!extra.feeRecipient) {
+      throw new Error(`'feeRecipient' is required in payment requirements extra`);
+    }
+    if (typeof extra.captureDeadline !== "number") {
+      throw new Error(`'captureDeadline' is required in payment requirements extra`);
+    }
+    if (typeof extra.refundDeadline !== "number") {
+      throw new Error(`'refundDeadline' is required in payment requirements extra`);
+    }
+    if (typeof extra.minFeeBps !== "number") {
+      throw new Error(`'minFeeBps' is required in payment requirements extra`);
+    }
+    if (typeof extra.maxFeeBps !== "number") {
+      throw new Error(`'maxFeeBps' is required in payment requirements extra`);
+    }
+    if (typeof requirements.maxTimeoutSeconds !== "number") {
+      throw new Error(
+        `'maxTimeoutSeconds' is required in PaymentRequirements (used to derive preApprovalExpiry)`
+      );
+    }
+    const chainId = parseChainId(requirements.network);
+    const maxAmount = requirements.amount;
+    const nowSeconds = Math.floor(Date.now() / 1e3);
+    const preApprovalExpiry = nowSeconds + requirements.maxTimeoutSeconds;
+    const salt = generateSalt();
+    const assetTransferMethod = extra.assetTransferMethod ?? "eip3009";
+    const paymentInfo = {
+      operator: extra.captureAuthorizer,
+      payer: this.signer.address,
+      receiver: requirements.payTo,
+      token: requirements.asset,
+      maxAmount,
+      preApprovalExpiry,
+      authorizationExpiry: extra.captureDeadline,
+      refundExpiry: extra.refundDeadline,
+      minFeeBps: extra.minFeeBps,
+      maxFeeBps: extra.maxFeeBps,
+      feeReceiver: extra.feeRecipient,
+      salt
+    };
+    const nonce = computePayerAgnosticPaymentInfoHash(chainId, paymentInfo);
+    if (assetTransferMethod === "permit2") {
+      const permit2Authorization = {
+        from: this.signer.address,
+        permitted: {
+          token: requirements.asset,
+          amount: maxAmount
+        },
+        spender: PERMIT2_TOKEN_COLLECTOR_ADDRESS,
+        nonce: (0, import_viem24.hexToBigInt)(nonce).toString(),
+        deadline: String(preApprovalExpiry)
+      };
+      const signature2 = await signPermit2(this.signer, permit2Authorization, chainId);
+      const payload2 = { permit2Authorization, signature: signature2, salt };
+      return { x402Version, payload: payload2 };
+    }
+    const authorization = {
+      from: this.signer.address,
+      to: EIP3009_TOKEN_COLLECTOR_ADDRESS,
+      value: maxAmount,
+      validAfter: "0",
+      validBefore: String(preApprovalExpiry),
+      nonce
+    };
+    const signature = await signERC3009(
+      this.signer,
+      authorization,
+      extra,
+      requirements.asset,
+      chainId
+    );
+    const payload = { authorization, signature, salt };
+    return { x402Version, payload };
+  }
+};
+
+// src/auth-capture/types.ts
+function isAuthCaptureExtra(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.captureAuthorizer === "string" && typeof v.captureDeadline === "number" && typeof v.refundDeadline === "number" && typeof v.feeRecipient === "string" && typeof v.minFeeBps === "number" && typeof v.maxFeeBps === "number" && typeof v.name === "string" && typeof v.version === "string";
+}
+function isEip3009Payload(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return "authorization" in v && typeof v.authorization === "object" && v.authorization !== null && typeof v.signature === "string" && typeof v.salt === "string";
+}
+function isPermit2Payload2(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.signature !== "string" || typeof v.salt !== "string") return false;
+  if (typeof v.permit2Authorization !== "object" || v.permit2Authorization === null) return false;
+  const a = v.permit2Authorization;
+  return typeof a.from === "string" && typeof a.spender === "string" && typeof a.nonce === "string" && typeof a.deadline === "string" && typeof a.permitted === "object" && a.permitted !== null;
+}
+function isAuthCapturePayload(value) {
+  return isEip3009Payload(value) || isPermit2Payload2(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTH_CAPTURE_ESCROW_ADDRESS,
+  AUTH_CAPTURE_SCHEME,
+  AuthCaptureEvmScheme,
+  BATCH_SETTLEMENT_ADDRESS,
+  BATCH_SETTLEMENT_DOMAIN,
+  BATCH_SETTLEMENT_SCHEME,
+  BUILDER_CODE_KEY,
+  BatchSettlementEvmScheme,
+  DEFAULT_STABLECOINS,
+  EIP3009_TOKEN_COLLECTOR_ADDRESS,
+  ERC3009_DEPOSIT_COLLECTOR_ADDRESS,
+  ExactEvmScheme,
+  PERMIT2_ADDRESS,
+  PERMIT2_TOKEN_COLLECTOR_ADDRESS,
+  UptoEvmScheme,
+  appendDataSuffix,
+  authorizationTypes,
+  claimBatchTypes,
+  createPermit2ApprovalTx,
+  eip3009ABI,
+  erc20AllowanceAbi,
+  getDefaultAsset,
+  getPermit2AllowanceReadParams,
+  isAuthCaptureExtra,
+  isAuthCapturePayload,
+  isBatchSettlementClaimPayload,
+  isBatchSettlementDepositPayload,
+  isBatchSettlementEnrichedRefundPayload,
+  isBatchSettlementRefundPayload,
+  isBatchSettlementSettlePayload,
+  isBatchSettlementVoucherPayload,
+  isEIP3009Payload,
+  isPermit2Payload,
+  isUptoPermit2Payload,
+  permit2WitnessTypes,
+  refundTypes,
+  resolveDataSuffix,
+  toClientEvmSigner,
+  toFacilitatorEvmSigner,
+  uptoPermit2WitnessTypes,
+  voucherTypes,
+  x402ExactPermit2ProxyABI,
+  x402ExactPermit2ProxyAddress,
+  x402UptoPermit2ProxyABI,
+  x402UptoPermit2ProxyAddress
+});
+//# sourceMappingURL=index.js.map