@payai/x402-evm 2.4.1 → 2.4.3

package/dist/cjs/batch-settlement/client/index.js

@@ -0,0 +1,1565 @@
+"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/batch-settlement/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  BatchSettlementEvmScheme: () => BatchSettlementEvmScheme,
+  InMemoryClientChannelStorage: () => InMemoryClientChannelStorage,
+  buildChannelConfig: () => buildChannelConfig,
+  computeChannelId: () => computeChannelId,
+  createBatchSettlementClientHooks: () => createBatchSettlementClientHooks,
+  createBatchSettlementEIP3009DepositPayload: () => createBatchSettlementEIP3009DepositPayload,
+  depositAmountForRequest: () => depositAmountForRequest,
+  getChannel: () => getChannel,
+  handleBatchSettlementPaymentResponse: () => handleBatchSettlementPaymentResponse,
+  hasChannel: () => hasChannel,
+  isBatchSettlementEvmSchemeOptions: () => isBatchSettlementEvmSchemeOptions,
+  processCorrectivePaymentRequired: () => processCorrectivePaymentRequired,
+  processPaymentResponse: () => processPaymentResponse,
+  processSettleResponse: () => processSettleResponse,
+  readChannelBalanceAndTotalClaimed: () => readChannelBalanceAndTotalClaimed,
+  recoverChannel: () => recoverChannel,
+  recoverFromOnChainState: () => recoverFromOnChainState,
+  recoverFromSignature: () => recoverFromSignature,
+  refundChannel: () => refundChannel,
+  resolveClientOptions: () => resolveClientOptions,
+  signVoucher: () => signVoucher,
+  updateChannelAfterRefund: () => updateChannelAfterRefund,
+  validateDepositPolicy: () => validateDepositPolicy
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/batch-settlement/client/scheme.ts
+var import_viem13 = require("viem");
+
+// src/batch-settlement/constants.ts
+var import_viem = 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_viem.keccak256)(
+  (0, import_viem.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 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_viem3 = require("viem");
+
+// src/utils.ts
+var import_viem2 = 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_viem2.toHex)(getCrypto().getRandomValues(new Uint8Array(32)));
+}
+function createPermit2Nonce() {
+  const randomBytes = getCrypto().getRandomValues(new Uint8Array(32));
+  return BigInt((0, import_viem2.toHex)(randomBytes)).toString();
+}
+
+// src/batch-settlement/utils.ts
+function computeChannelId(config, networkOrChainId) {
+  const chainId = typeof networkOrChainId === "number" ? networkOrChainId : getEvmChainId(networkOrChainId);
+  return (0, import_viem3.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_viem3.getAddress)(BATCH_SETTLEMENT_ADDRESS)
+  };
+}
+
+// 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/extensions.ts
+var import_viem7 = require("viem");
+
+// src/constants.ts
+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";
+
+// src/exact/client/eip2612.ts
+var import_viem4 = require("viem");
+async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion, chainId, deadline, permittedAmount) {
+  const owner = signer.address;
+  const spender = (0, import_viem4.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_viem5 = require("viem");
+async function signErc20ApprovalTransaction(signer, tokenAddress, chainId) {
+  const from = signer.address;
+  const spender = (0, import_viem5.getAddress)(PERMIT2_ADDRESS);
+  const data = (0, import_viem5.encodeFunctionData)({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [spender, import_viem5.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_viem5.maxUint256.toString(),
+    signedTransaction,
+    version: ERC20_APPROVAL_GAS_SPONSORING_VERSION
+  };
+}
+
+// src/shared/rpc.ts
+var import_viem6 = 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_viem6.createPublicClient)({
+    transport: (0, import_viem6.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.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_viem7.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_viem7.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/batch-settlement/client/eip3009.ts
+var import_viem9 = 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_viem8 = require("viem");
+function buildErc3009DepositNonce(channelId, salt) {
+  return (0, import_viem8.keccak256)(
+    (0, import_viem8.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_viem9.getAddress)(paymentRequirements.asset)
+    },
+    types: receiveAuthorizationTypes,
+    primaryType: "ReceiveWithAuthorization",
+    message: {
+      from: (0, import_viem9.getAddress)(signer.address),
+      to: (0, import_viem9.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_viem10 = 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_viem10.getAddress)(paymentRequirements.asset),
+      amount: depositAmount
+    },
+    spender: (0, import_viem10.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_viem11 = 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_viem11.getAddress)(receiverAuthorizer) === "0x0000000000000000000000000000000000000000") {
+    throw new Error("Payment requirements must include a non-zero extra.receiverAuthorizer");
+  }
+  return {
+    payer: deps.signer.address,
+    payerAuthorizer: (0, import_viem11.getAddress)(
+      deps.payerAuthorizer ?? deps.voucherSigner?.address ?? deps.signer.address
+    ),
+    receiver: paymentRequirements.payTo,
+    receiverAuthorizer: (0, import_viem11.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 processPaymentResponse(storage, getHeader) {
+  const raw = getHeader("PAYMENT-RESPONSE");
+  if (!raw) return;
+  const settle = (0, import_http.decodePaymentResponseHeader)(raw);
+  await processSettleResponse(storage, settle);
+}
+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]
+  });
+}
+async function hasChannel(storage, channelId) {
+  const channel = await storage.get(channelId.toLowerCase());
+  return channel !== void 0;
+}
+async function getChannel(storage, channelId) {
+  return storage.get(channelId.toLowerCase());
+}
+
+// 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 isBatchSettlementRefundPayload(payload) {
+  return isObject(payload) && payload.type === "refund" && "channelConfig" in payload && isVoucherFields(payload.voucher);
+}
+
+// src/batch-settlement/client/recovery.ts
+var import_viem12 = 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_viem12.recoverTypedDataAddress)({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: voucherTypes,
+    primaryType: "Voucher",
+    message: {
+      channelId,
+      maxClaimableAmount: signed
+    },
+    signature: sig
+  });
+  const expectedSigner = (0, import_viem12.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_viem13.getAddress)(payerAuthorizer) !== (0, import_viem13.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
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchSettlementEvmScheme,
+  InMemoryClientChannelStorage,
+  buildChannelConfig,
+  computeChannelId,
+  createBatchSettlementClientHooks,
+  createBatchSettlementEIP3009DepositPayload,
+  depositAmountForRequest,
+  getChannel,
+  handleBatchSettlementPaymentResponse,
+  hasChannel,
+  isBatchSettlementEvmSchemeOptions,
+  processCorrectivePaymentRequired,
+  processPaymentResponse,
+  processSettleResponse,
+  readChannelBalanceAndTotalClaimed,
+  recoverChannel,
+  recoverFromOnChainState,
+  recoverFromSignature,
+  refundChannel,
+  resolveClientOptions,
+  signVoucher,
+  updateChannelAfterRefund,
+  validateDepositPolicy
+});
+//# sourceMappingURL=index.js.map