@payai/x402-evm 2.4.0 → 2.4.2

package/dist/cjs/index.js

@@ -20,21 +20,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BATCH_SETTLEMENT_ADDRESS: () => BATCH_SETTLEMENT_ADDRESS,
+  BATCH_SETTLEMENT_DOMAIN: () => BATCH_SETTLEMENT_DOMAIN,
+  BATCH_SETTLEMENT_SCHEME: () => BATCH_SETTLEMENT_SCHEME,
+  BatchSettlementEvmScheme: () => BatchSettlementEvmScheme,
+  DEFAULT_STABLECOINS: () => DEFAULT_STABLECOINS,
+  ERC3009_DEPOSIT_COLLECTOR_ADDRESS: () => ERC3009_DEPOSIT_COLLECTOR_ADDRESS,
   ExactEvmScheme: () => ExactEvmScheme,
   PERMIT2_ADDRESS: () => PERMIT2_ADDRESS,
   UptoEvmScheme: () => UptoEvmScheme,
   authorizationTypes: () => authorizationTypes,
+  claimBatchTypes: () => claimBatchTypes,
   createPermit2ApprovalTx: () => createPermit2ApprovalTx,
   eip3009ABI: () => eip3009ABI,
   erc20AllowanceAbi: () => erc20AllowanceAbi,
+  getDefaultAsset: () => getDefaultAsset,
   getPermit2AllowanceReadParams: () => getPermit2AllowanceReadParams,
+  isBatchSettlementClaimPayload: () => isBatchSettlementClaimPayload,
+  isBatchSettlementDepositPayload: () => isBatchSettlementDepositPayload,
+  isBatchSettlementEnrichedRefundPayload: () => isBatchSettlementEnrichedRefundPayload,
+  isBatchSettlementRefundPayload: () => isBatchSettlementRefundPayload,
+  isBatchSettlementSettlePayload: () => isBatchSettlementSettlePayload,
+  isBatchSettlementVoucherPayload: () => isBatchSettlementVoucherPayload,
   isEIP3009Payload: () => isEIP3009Payload,
   isPermit2Payload: () => isPermit2Payload,
   isUptoPermit2Payload: () => isUptoPermit2Payload,
   permit2WitnessTypes: () => permit2WitnessTypes,
+  refundTypes: () => refundTypes,
   toClientEvmSigner: () => toClientEvmSigner,
   toFacilitatorEvmSigner: () => toFacilitatorEvmSigner,
   uptoPermit2WitnessTypes: () => uptoPermit2WitnessTypes,
+  voucherTypes: () => voucherTypes,
   x402ExactPermit2ProxyABI: () => x402ExactPermit2ProxyABI,
   x402ExactPermit2ProxyAddress: () => x402ExactPermit2ProxyAddress,
   x402UptoPermit2ProxyABI: () => x402UptoPermit2ProxyABI,
@@ -767,7 +783,7 @@ function resolveExtensionRpcCapabilities(network, signer, options) {
 }
 
 // src/shared/extensions.ts
-async function trySignEip2612PermitExtension(signer, options, requirements, result, context) {
+async function trySignEip2612PermitExtension(signer, options, requirements, result, context, approvalAmount) {
   const capabilities = resolveExtensionRpcCapabilities(requirements.network, signer, options);
   if (!capabilities.readContract) {
     return void 0;
@@ -782,6 +798,7 @@ async function trySignEip2612PermitExtension(signer, options, requirements, resu
   }
   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,
@@ -789,7 +806,7 @@ async function trySignEip2612PermitExtension(signer, options, requirements, resu
       functionName: "allowance",
       args: [signer.address, PERMIT2_ADDRESS]
     });
-    if (allowance >= BigInt(requirements.amount)) {
+    if (allowance >= BigInt(requiredAllowance)) {
       return void 0;
     }
   } catch {
@@ -807,13 +824,13 @@ async function trySignEip2612PermitExtension(signer, options, requirements, resu
     tokenVersion,
     chainId,
     deadline,
-    requirements.amount
+    requiredAllowance
   );
   return {
     [EIP2612_GAS_SPONSORING_KEY]: { info }
   };
 }
-async function trySignErc20ApprovalExtension(signer, options, requirements, context) {
+async function trySignErc20ApprovalExtension(signer, options, requirements, context, approvalAmount) {
   const capabilities = resolveExtensionRpcCapabilities(requirements.network, signer, options);
   if (!capabilities.readContract) {
     return void 0;
@@ -826,6 +843,7 @@ async function trySignErc20ApprovalExtension(signer, options, requirements, cont
   }
   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,
@@ -833,7 +851,7 @@ async function trySignErc20ApprovalExtension(signer, options, requirements, cont
       functionName: "allowance",
       args: [signer.address, PERMIT2_ADDRESS]
     });
-    if (allowance >= BigInt(requirements.amount)) {
+    if (allowance >= BigInt(requiredAllowance)) {
       return void 0;
     }
   } catch {
@@ -985,6 +1003,32 @@ function toFacilitatorEvmSigner(client) {
   };
 }
 
+// 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;
@@ -1117,23 +1161,1327 @@ var UptoEvmScheme = class {
     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(now - 600),
+      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: (now - 600).toString(),
+          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("@payai/x402/http");
+var import_client = require("@payai/x402/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("@payai/x402/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: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
+};
+function getDefaultAsset(network) {
+  const info = DEFAULT_STABLECOINS[network];
+  if (!info) {
+    throw new Error(`No default asset configured for network ${network}`);
+  }
+  return info;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BATCH_SETTLEMENT_ADDRESS,
+  BATCH_SETTLEMENT_DOMAIN,
+  BATCH_SETTLEMENT_SCHEME,
+  BatchSettlementEvmScheme,
+  DEFAULT_STABLECOINS,
+  ERC3009_DEPOSIT_COLLECTOR_ADDRESS,
   ExactEvmScheme,
   PERMIT2_ADDRESS,
   UptoEvmScheme,
   authorizationTypes,
+  claimBatchTypes,
   createPermit2ApprovalTx,
   eip3009ABI,
   erc20AllowanceAbi,
+  getDefaultAsset,
   getPermit2AllowanceReadParams,
+  isBatchSettlementClaimPayload,
+  isBatchSettlementDepositPayload,
+  isBatchSettlementEnrichedRefundPayload,
+  isBatchSettlementRefundPayload,
+  isBatchSettlementSettlePayload,
+  isBatchSettlementVoucherPayload,
   isEIP3009Payload,
   isPermit2Payload,
   isUptoPermit2Payload,
   permit2WitnessTypes,
+  refundTypes,
   toClientEvmSigner,
   toFacilitatorEvmSigner,
   uptoPermit2WitnessTypes,
+  voucherTypes,
   x402ExactPermit2ProxyABI,
   x402ExactPermit2ProxyAddress,
   x402UptoPermit2ProxyABI,