@payai/x402-evm 2.4.1 → 2.4.3

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

@@ -0,0 +1,2032 @@
+"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/facilitator/index.ts
+var facilitator_exports = {};
+__export(facilitator_exports, {
+  BatchSettlementEvmScheme: () => BatchSettlementEvmScheme
+});
+module.exports = __toCommonJS(facilitator_exports);
+
+// 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 MAX_WITHDRAW_DELAY = 2592e3;
+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 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/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/batch-settlement/facilitator/deposit.ts
+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
+  }
+];
+var erc20BalanceOfABI = [
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+
+// 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)`);
+}
+
+// src/multicall.ts
+var import_viem3 = require("viem");
+var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var multicall3ABI = [
+  {
+    inputs: [
+      { name: "requireSuccess", type: "bool" },
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "callData", type: "bytes" }
+        ]
+      }
+    ],
+    name: "tryAggregate",
+    outputs: [
+      {
+        name: "returnData",
+        type: "tuple[]",
+        components: [
+          { name: "success", type: "bool" },
+          { name: "returnData", type: "bytes" }
+        ]
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+async function multicall(readContract, calls) {
+  const aggregateCalls = calls.map((call) => {
+    if ("callData" in call) {
+      return { target: call.address, callData: call.callData };
+    }
+    const callData = (0, import_viem3.encodeFunctionData)({
+      abi: call.abi,
+      functionName: call.functionName,
+      args: call.args
+    });
+    return { target: call.address, callData };
+  });
+  const rawResults = await readContract({
+    address: MULTICALL3_ADDRESS,
+    abi: multicall3ABI,
+    functionName: "tryAggregate",
+    args: [false, aggregateCalls]
+  });
+  return rawResults.map((raw, i) => {
+    if (!raw.success) {
+      return {
+        status: "failure",
+        error: new Error(`multicall: call reverted (returnData: ${raw.returnData})`)
+      };
+    }
+    const call = calls[i];
+    if ("callData" in call) {
+      return { status: "success", result: void 0 };
+    }
+    try {
+      const decoded = (0, import_viem3.decodeFunctionResult)({
+        abi: call.abi,
+        functionName: call.functionName,
+        data: raw.returnData
+      });
+      return { status: "success", result: decoded };
+    } catch (err) {
+      return {
+        status: "failure",
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  });
+}
+
+// src/batch-settlement/errors.ts
+var ErrChannelNotFound = "invalid_batch_settlement_evm_channel_not_found";
+var ErrTokenMismatch = "invalid_batch_settlement_evm_token_mismatch";
+var ErrInvalidVoucherSignature = "invalid_batch_settlement_evm_voucher_signature";
+var ErrCumulativeExceedsBalance = "invalid_batch_settlement_evm_cumulative_exceeds_balance";
+var ErrCumulativeAmountBelowClaimed = "invalid_batch_settlement_evm_cumulative_below_claimed";
+var ErrInsufficientBalance = "invalid_batch_settlement_evm_insufficient_balance";
+var ErrDepositTransactionFailed = "invalid_batch_settlement_evm_deposit_transaction_failed";
+var ErrClaimTransactionFailed = "invalid_batch_settlement_evm_claim_transaction_failed";
+var ErrSettleTransactionFailed = "invalid_batch_settlement_evm_settle_transaction_failed";
+var ErrInvalidScheme = "invalid_batch_settlement_evm_scheme";
+var ErrNetworkMismatch = "invalid_batch_settlement_evm_network_mismatch";
+var ErrMissingEip712Domain = "invalid_batch_settlement_evm_missing_eip712_domain";
+var ErrValidBeforeExpired = "invalid_batch_settlement_evm_payload_authorization_valid_before";
+var ErrValidAfterInFuture = "invalid_batch_settlement_evm_payload_authorization_valid_after";
+var ErrInvalidReceiveAuthorizationSignature = "invalid_batch_settlement_evm_receive_authorization_signature";
+var ErrErc3009AuthorizationRequired = "invalid_batch_settlement_evm_erc3009_authorization_required";
+var ErrRefundTransactionFailed = "invalid_batch_settlement_evm_refund_transaction_failed";
+var ErrInvalidPayloadType = "invalid_batch_settlement_evm_payload_type";
+var ErrWithdrawDelayOutOfRange = "invalid_batch_settlement_evm_withdraw_delay_out_of_range";
+var ErrChannelIdMismatch = "invalid_batch_settlement_evm_channel_id_mismatch";
+var ErrReceiverMismatch = "invalid_batch_settlement_evm_receiver_mismatch";
+var ErrReceiverAuthorizerMismatch = "invalid_batch_settlement_evm_receiver_authorizer_mismatch";
+var ErrWithdrawDelayMismatch = "invalid_batch_settlement_evm_withdraw_delay_mismatch";
+var ErrAuthorizerAddressMismatch = "invalid_batch_settlement_evm_authorizer_address_mismatch";
+var ErrDepositSimulationFailed = "invalid_batch_settlement_evm_deposit_simulation_failed";
+var ErrClaimSimulationFailed = "invalid_batch_settlement_evm_claim_simulation_failed";
+var ErrSettleSimulationFailed = "invalid_batch_settlement_evm_settle_simulation_failed";
+var ErrNothingToSettle = "invalid_batch_settlement_evm_nothing_to_settle";
+var ErrRefundSimulationFailed = "invalid_batch_settlement_evm_refund_simulation_failed";
+var ErrRpcReadFailed = "invalid_batch_settlement_evm_rpc_read_failed";
+var ErrPermit2AuthorizationRequired = "invalid_batch_settlement_evm_permit2_authorization_required";
+var ErrPermit2InvalidSpender = "invalid_batch_settlement_evm_permit2_invalid_spender";
+var ErrPermit2AmountMismatch = "invalid_batch_settlement_evm_permit2_amount_mismatch";
+var ErrPermit2DeadlineExpired = "invalid_batch_settlement_evm_permit2_deadline_expired";
+var ErrPermit2InvalidSignature = "invalid_batch_settlement_evm_permit2_invalid_signature";
+var ErrPermit2AllowanceRequired = "invalid_batch_settlement_evm_permit2_allowance_required";
+var ErrEip2612AmountMismatch = "invalid_batch_settlement_evm_eip2612_amount_mismatch";
+var ErrErc20ApprovalUnavailable = "invalid_batch_settlement_evm_erc20_approval_unavailable";
+var ErrRefundNoBalance = "invalid_batch_settlement_evm_refund_no_balance";
+
+// src/batch-settlement/facilitator/utils.ts
+var import_viem5 = require("viem");
+
+// src/batch-settlement/utils.ts
+var import_viem4 = require("viem");
+function computeChannelId(config, networkOrChainId) {
+  const chainId = typeof networkOrChainId === "number" ? networkOrChainId : getEvmChainId(networkOrChainId);
+  return (0, import_viem4.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_viem4.getAddress)(BATCH_SETTLEMENT_ADDRESS)
+  };
+}
+
+// src/batch-settlement/facilitator/utils.ts
+function toContractChannelConfig(config) {
+  return {
+    payer: (0, import_viem5.getAddress)(config.payer),
+    payerAuthorizer: (0, import_viem5.getAddress)(config.payerAuthorizer),
+    receiver: (0, import_viem5.getAddress)(config.receiver),
+    receiverAuthorizer: (0, import_viem5.getAddress)(config.receiverAuthorizer),
+    token: (0, import_viem5.getAddress)(config.token),
+    withdrawDelay: config.withdrawDelay,
+    salt: config.salt
+  };
+}
+function erc3009AuthorizationTimeInvalidReason(validAfter, validBefore) {
+  const now = Math.floor(Date.now() / 1e3);
+  if (validBefore < BigInt(now + 6)) return ErrValidBeforeExpired;
+  if (validAfter > BigInt(now)) return ErrValidAfterInFuture;
+  return void 0;
+}
+async function verifyBatchSettlementVoucherTypedData(signer, params, chainId) {
+  const domain = getBatchSettlementEip712Domain(chainId);
+  const message = {
+    channelId: params.channelId,
+    maxClaimableAmount: BigInt(params.maxClaimableAmount)
+  };
+  const zeroAddress = "0x0000000000000000000000000000000000000000";
+  if (params.payerAuthorizer !== zeroAddress) {
+    return (0, import_viem5.verifyTypedData)({
+      address: (0, import_viem5.getAddress)(params.payerAuthorizer),
+      domain,
+      types: voucherTypes,
+      primaryType: "Voucher",
+      message,
+      signature: params.signature
+    });
+  }
+  return signer.verifyTypedData({
+    address: (0, import_viem5.getAddress)(params.payer),
+    domain,
+    types: voucherTypes,
+    primaryType: "Voucher",
+    message,
+    signature: params.signature
+  });
+}
+function validateChannelConfig(config, channelId, requirements) {
+  const computedId = computeChannelId(config, requirements.network);
+  if (computedId.toLowerCase() !== channelId.toLowerCase()) {
+    return ErrChannelIdMismatch;
+  }
+  if ((0, import_viem5.getAddress)(config.receiver) !== (0, import_viem5.getAddress)(requirements.payTo)) {
+    return ErrReceiverMismatch;
+  }
+  const extra = requirements.extra;
+  const requiredReceiverAuthorizer = extra?.receiverAuthorizer;
+  if (!requiredReceiverAuthorizer || (0, import_viem5.getAddress)(requiredReceiverAuthorizer) === "0x0000000000000000000000000000000000000000" || (0, import_viem5.getAddress)(config.receiverAuthorizer) !== (0, import_viem5.getAddress)(requiredReceiverAuthorizer)) {
+    return ErrReceiverAuthorizerMismatch;
+  }
+  if ((0, import_viem5.getAddress)(config.token) !== (0, import_viem5.getAddress)(requirements.asset)) {
+    return ErrTokenMismatch;
+  }
+  if (extra?.withdrawDelay !== void 0 && config.withdrawDelay !== Number(extra.withdrawDelay)) {
+    return ErrWithdrawDelayMismatch;
+  }
+  if (config.withdrawDelay < MIN_WITHDRAW_DELAY || config.withdrawDelay > MAX_WITHDRAW_DELAY) {
+    return ErrWithdrawDelayOutOfRange;
+  }
+  return void 0;
+}
+async function readChannelState(signer, channelId) {
+  const target = (0, import_viem5.getAddress)(BATCH_SETTLEMENT_ADDRESS);
+  const mcResults = await multicall(signer.readContract.bind(signer), [
+    { address: target, abi: batchSettlementABI, functionName: "channels", args: [channelId] },
+    {
+      address: target,
+      abi: batchSettlementABI,
+      functionName: "pendingWithdrawals",
+      args: [channelId]
+    },
+    { address: target, abi: batchSettlementABI, functionName: "refundNonce", args: [channelId] }
+  ]);
+  const [chRes, wdRes, rnRes] = mcResults;
+  if (chRes.status === "failure" || wdRes.status === "failure" || rnRes.status === "failure") {
+    throw new Error(`${ErrRpcReadFailed}: multicall returned failure for ${channelId}`);
+  }
+  const [balance, totalClaimed] = chRes.result;
+  const [, wdInitiatedAt] = wdRes.result;
+  const refundNonce = rnRes.result;
+  return { balance, totalClaimed, withdrawRequestedAt: Number(wdInitiatedAt), refundNonce };
+}
+
+// src/batch-settlement/facilitator/deposit-eip3009.ts
+var import_viem7 = require("viem");
+
+// src/batch-settlement/encoding.ts
+var import_viem6 = require("viem");
+function buildErc3009DepositNonce(channelId, salt) {
+  return (0, import_viem6.keccak256)(
+    (0, import_viem6.encodeAbiParameters)([{ type: "bytes32" }, { type: "uint256" }], [channelId, BigInt(salt)])
+  );
+}
+function buildErc3009CollectorData(validAfter, validBefore, salt, signature) {
+  return (0, import_viem6.encodeAbiParameters)(
+    [{ type: "uint256" }, { type: "uint256" }, { type: "uint256" }, { type: "bytes" }],
+    [BigInt(validAfter), BigInt(validBefore), BigInt(salt), signature]
+  );
+}
+function buildEip2612PermitData(params) {
+  return (0, import_viem6.encodeAbiParameters)(
+    [
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "uint8" },
+      { type: "bytes32" },
+      { type: "bytes32" }
+    ],
+    [BigInt(params.value), BigInt(params.deadline), params.v, params.r, params.s]
+  );
+}
+function buildPermit2CollectorData(nonce, deadline, permit2Signature, eip2612PermitData = "0x") {
+  return (0, import_viem6.encodeAbiParameters)(
+    [{ type: "uint256" }, { type: "uint256" }, { type: "bytes" }, { type: "bytes" }],
+    [BigInt(nonce), BigInt(deadline), permit2Signature, eip2612PermitData]
+  );
+}
+
+// src/batch-settlement/facilitator/deposit-eip3009.ts
+function getEip3009DepositCollectorAddress() {
+  return (0, import_viem7.getAddress)(ERC3009_DEPOSIT_COLLECTOR_ADDRESS);
+}
+function buildEip3009DepositCollectorData(payload) {
+  const auth = payload.deposit.authorization.erc3009Authorization;
+  if (!auth) {
+    throw new Error(ErrErc3009AuthorizationRequired);
+  }
+  const { signature } = (0, import_viem7.parseErc6492Signature)(auth.signature);
+  return buildErc3009CollectorData(auth.validAfter, auth.validBefore, auth.salt, signature);
+}
+async function verifyEip3009DepositAuthorization(signer, payload, requirements, chainId) {
+  const { deposit, voucher } = payload;
+  const payer = payload.channelConfig.payer;
+  const auth = deposit.authorization.erc3009Authorization;
+  if (!auth) {
+    return { isValid: false, invalidReason: ErrErc3009AuthorizationRequired, payer };
+  }
+  const extra = requirements.extra;
+  if (!extra?.name || !extra?.version) {
+    return { isValid: false, invalidReason: ErrMissingEip712Domain, payer };
+  }
+  const validAfter = BigInt(auth.validAfter);
+  const validBefore = BigInt(auth.validBefore);
+  const timeInvalid = erc3009AuthorizationTimeInvalidReason(validAfter, validBefore);
+  if (timeInvalid) {
+    return { isValid: false, invalidReason: timeInvalid, payer };
+  }
+  const erc3009Nonce = buildErc3009DepositNonce(voucher.channelId, auth.salt);
+  const receiveAuthOk = await verifyReceiveAuth(signer, {
+    payer,
+    asset: requirements.asset,
+    name: extra.name,
+    version: extra.version,
+    chainId,
+    amount: deposit.amount,
+    validAfter,
+    validBefore,
+    nonce: erc3009Nonce,
+    signature: auth.signature
+  });
+  if (!receiveAuthOk) {
+    return { isValid: false, invalidReason: ErrInvalidReceiveAuthorizationSignature, payer };
+  }
+  return null;
+}
+async function verifyReceiveAuth(signer, params) {
+  try {
+    return await signer.verifyTypedData({
+      address: (0, import_viem7.getAddress)(params.payer),
+      domain: {
+        name: params.name,
+        version: params.version,
+        chainId: params.chainId,
+        verifyingContract: (0, import_viem7.getAddress)(params.asset)
+      },
+      types: receiveAuthorizationTypes,
+      primaryType: "ReceiveWithAuthorization",
+      message: {
+        from: (0, import_viem7.getAddress)(params.payer),
+        to: (0, import_viem7.getAddress)(ERC3009_DEPOSIT_COLLECTOR_ADDRESS),
+        value: BigInt(params.amount),
+        validAfter: params.validAfter,
+        validBefore: params.validBefore,
+        nonce: params.nonce
+      },
+      signature: params.signature
+    });
+  } catch {
+    return false;
+  }
+}
+
+// src/batch-settlement/facilitator/deposit-permit2.ts
+var import_viem10 = require("viem");
+
+// src/exact/extensions.ts
+var EIP2612_GAS_SPONSORING_KEY = "eip2612GasSponsoring";
+var ERC20_APPROVAL_GAS_SPONSORING_KEY = "erc20ApprovalGasSponsoring";
+function _extractInfo(payload, extensionKey) {
+  const extensions = payload.extensions;
+  if (!extensions) return null;
+  const extension = extensions[extensionKey];
+  if (!extension?.info) return null;
+  return extension.info;
+}
+function extractEip2612GasSponsoringInfo(payload) {
+  const info = _extractInfo(payload, EIP2612_GAS_SPONSORING_KEY);
+  if (!info) return null;
+  if (!info.from || !info.asset || !info.spender || !info.amount || !info.nonce || !info.deadline || !info.signature || !info.version) {
+    return null;
+  }
+  return info;
+}
+function validateEip2612GasSponsoringInfo(info) {
+  const addressPattern = /^0x[a-fA-F0-9]{40}$/;
+  const numericPattern = /^[0-9]+$/;
+  const hexPattern = /^0x[a-fA-F0-9]+$/;
+  const versionPattern = /^[0-9]+(\.[0-9]+)*$/;
+  return addressPattern.test(info.from) && addressPattern.test(info.asset) && addressPattern.test(info.spender) && numericPattern.test(info.amount) && numericPattern.test(info.nonce) && numericPattern.test(info.deadline) && hexPattern.test(info.signature) && versionPattern.test(info.version);
+}
+function extractErc20ApprovalGasSponsoringInfo(payload) {
+  const info = _extractInfo(payload, ERC20_APPROVAL_GAS_SPONSORING_KEY);
+  if (!info) return null;
+  if (!info.from || !info.asset || !info.spender || !info.amount || !info.signedTransaction || !info.version) {
+    return null;
+  }
+  return info;
+}
+function validateErc20ApprovalGasSponsoringInfo(info) {
+  const addressPattern = /^0x[a-fA-F0-9]{40}$/;
+  const numericPattern = /^[0-9]+$/;
+  const hexPattern = /^0x[a-fA-F0-9]+$/;
+  const versionPattern = /^[0-9]+(\.[0-9]+)*$/;
+  return addressPattern.test(info.from) && addressPattern.test(info.asset) && addressPattern.test(info.spender) && numericPattern.test(info.amount) && hexPattern.test(info.signedTransaction) && versionPattern.test(info.version);
+}
+function resolveErc20ApprovalExtensionSigner(extension, network) {
+  if (!extension) return void 0;
+  return extension.signerForNetwork?.(network) ?? extension.signer;
+}
+
+// src/shared/erc20approval.ts
+var import_viem8 = require("viem");
+
+// src/constants.ts
+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 PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+
+// src/exact/facilitator/errors.ts
+var ErrErc20ApprovalInvalidFormat = "invalid_erc20_approval_extension_format";
+var ErrErc20ApprovalFromMismatch = "erc20_approval_from_mismatch";
+var ErrErc20ApprovalAssetMismatch = "erc20_approval_asset_mismatch";
+var ErrErc20ApprovalSpenderNotPermit2 = "erc20_approval_spender_not_permit2";
+var ErrErc20ApprovalTxWrongTarget = "erc20_approval_tx_wrong_target";
+var ErrErc20ApprovalTxWrongSelector = "erc20_approval_tx_wrong_selector";
+var ErrErc20ApprovalTxWrongSpender = "erc20_approval_tx_wrong_spender";
+var ErrErc20ApprovalTxInvalidCalldata = "erc20_approval_tx_invalid_calldata";
+var ErrErc20ApprovalTxSignerMismatch = "erc20_approval_tx_signer_mismatch";
+var ErrErc20ApprovalTxInvalidSignature = "erc20_approval_tx_invalid_signature";
+var ErrErc20ApprovalTxParseFailed = "erc20_approval_tx_parse_failed";
+var ErrInvalidEip2612ExtensionFormat = "invalid_eip2612_extension_format";
+var ErrEip2612FromMismatch = "eip2612_from_mismatch";
+var ErrEip2612AssetMismatch = "eip2612_asset_mismatch";
+var ErrEip2612SpenderNotPermit2 = "eip2612_spender_not_permit2";
+var ErrEip2612DeadlineExpired = "eip2612_deadline_expired";
+
+// src/shared/erc20approval.ts
+var APPROVE_SELECTOR = "0x095ea7b3";
+async function validateErc20ApprovalForPayment(info, payer, tokenAddress) {
+  if (!validateErc20ApprovalGasSponsoringInfo(info)) {
+    return {
+      isValid: false,
+      invalidReason: ErrErc20ApprovalInvalidFormat,
+      invalidMessage: "ERC-20 approval extension info failed schema validation"
+    };
+  }
+  if ((0, import_viem8.getAddress)(info.from) !== (0, import_viem8.getAddress)(payer)) {
+    return {
+      isValid: false,
+      invalidReason: ErrErc20ApprovalFromMismatch,
+      invalidMessage: `Expected from=${payer}, got ${info.from}`
+    };
+  }
+  if ((0, import_viem8.getAddress)(info.asset) !== tokenAddress) {
+    return {
+      isValid: false,
+      invalidReason: ErrErc20ApprovalAssetMismatch,
+      invalidMessage: `Expected asset=${tokenAddress}, got ${info.asset}`
+    };
+  }
+  if ((0, import_viem8.getAddress)(info.spender) !== (0, import_viem8.getAddress)(PERMIT2_ADDRESS)) {
+    return {
+      isValid: false,
+      invalidReason: ErrErc20ApprovalSpenderNotPermit2,
+      invalidMessage: `Expected spender=${PERMIT2_ADDRESS}, got ${info.spender}`
+    };
+  }
+  try {
+    const serializedTx = info.signedTransaction;
+    const tx = (0, import_viem8.parseTransaction)(serializedTx);
+    if (!tx.to || (0, import_viem8.getAddress)(tx.to) !== tokenAddress) {
+      return {
+        isValid: false,
+        invalidReason: ErrErc20ApprovalTxWrongTarget,
+        invalidMessage: `Transaction targets ${tx.to ?? "null"}, expected ${tokenAddress}`
+      };
+    }
+    const data = tx.data ?? "0x";
+    if (!data.startsWith(APPROVE_SELECTOR)) {
+      return {
+        isValid: false,
+        invalidReason: ErrErc20ApprovalTxWrongSelector,
+        invalidMessage: `Transaction calldata does not start with approve() selector ${APPROVE_SELECTOR}`
+      };
+    }
+    try {
+      const decoded = (0, import_viem8.decodeFunctionData)({
+        abi: erc20ApproveAbi,
+        data
+      });
+      const calldataSpender = (0, import_viem8.getAddress)(decoded.args[0]);
+      if (calldataSpender !== (0, import_viem8.getAddress)(PERMIT2_ADDRESS)) {
+        return {
+          isValid: false,
+          invalidReason: ErrErc20ApprovalTxWrongSpender,
+          invalidMessage: `approve() spender is ${calldataSpender}, expected Permit2 ${PERMIT2_ADDRESS}`
+        };
+      }
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: ErrErc20ApprovalTxInvalidCalldata,
+        invalidMessage: "Failed to decode approve() calldata from the signed transaction"
+      };
+    }
+    try {
+      const recoveredAddress = await (0, import_viem8.recoverTransactionAddress)({
+        serializedTransaction: serializedTx
+      });
+      if ((0, import_viem8.getAddress)(recoveredAddress) !== (0, import_viem8.getAddress)(payer)) {
+        return {
+          isValid: false,
+          invalidReason: ErrErc20ApprovalTxSignerMismatch,
+          invalidMessage: `Transaction signed by ${recoveredAddress}, expected payer ${payer}`
+        };
+      }
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: ErrErc20ApprovalTxInvalidSignature,
+        invalidMessage: "Failed to recover signer from the signed transaction"
+      };
+    }
+  } catch {
+    return {
+      isValid: false,
+      invalidReason: ErrErc20ApprovalTxParseFailed,
+      invalidMessage: "Failed to parse the signed transaction"
+    };
+  }
+  return { isValid: true };
+}
+
+// src/shared/permit2.ts
+var import_viem9 = require("viem");
+function validateEip2612PermitForPayment(info, payer, tokenAddress) {
+  if (!validateEip2612GasSponsoringInfo(info)) {
+    return { isValid: false, invalidReason: ErrInvalidEip2612ExtensionFormat };
+  }
+  if ((0, import_viem9.getAddress)(info.from) !== (0, import_viem9.getAddress)(payer)) {
+    return { isValid: false, invalidReason: ErrEip2612FromMismatch };
+  }
+  if ((0, import_viem9.getAddress)(info.asset) !== tokenAddress) {
+    return { isValid: false, invalidReason: ErrEip2612AssetMismatch };
+  }
+  if ((0, import_viem9.getAddress)(info.spender) !== (0, import_viem9.getAddress)(PERMIT2_ADDRESS)) {
+    return { isValid: false, invalidReason: ErrEip2612SpenderNotPermit2 };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (BigInt(info.deadline) < BigInt(now + 6)) {
+    return { isValid: false, invalidReason: ErrEip2612DeadlineExpired };
+  }
+  return { isValid: true };
+}
+function splitEip2612Signature(signature) {
+  const sig = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (sig.length !== 130) {
+    throw new Error(
+      `invalid EIP-2612 signature length: expected 65 bytes (130 hex chars), got ${sig.length / 2} bytes`
+    );
+  }
+  const r = `0x${sig.slice(0, 64)}`;
+  const s = `0x${sig.slice(64, 128)}`;
+  const v = parseInt(sig.slice(128, 130), 16);
+  return { v, r, s };
+}
+
+// src/batch-settlement/facilitator/deposit-permit2.ts
+function getPermit2DepositCollectorAddress() {
+  return (0, import_viem10.getAddress)(PERMIT2_DEPOSIT_COLLECTOR_ADDRESS);
+}
+function buildPermit2DepositCollectorData(payload, eip2612PermitData = "0x") {
+  const auth = payload.deposit.authorization.permit2Authorization;
+  if (!auth) {
+    throw new Error(ErrPermit2AuthorizationRequired);
+  }
+  const { signature } = (0, import_viem10.parseErc6492Signature)(auth.signature);
+  return buildPermit2CollectorData(auth.nonce, auth.deadline, signature, eip2612PermitData);
+}
+async function verifyPermit2DepositAuthorization(signer, payment, payload, requirements, chainId, context) {
+  const authResult = await verifyPermit2TypedData(signer, payload, requirements, chainId);
+  if (authResult) {
+    return authResult;
+  }
+  const branchResult = await resolvePermit2DepositBranch(
+    signer,
+    payment,
+    payload,
+    requirements,
+    context
+  );
+  if ("isValid" in branchResult) {
+    return branchResult;
+  }
+  if (branchResult.kind !== "erc20Approval" || !branchResult.extensionSigner.simulateTransactions) {
+    return null;
+  }
+  const ok = await branchResult.extensionSigner.simulateTransactions([
+    branchResult.signedTransaction,
+    buildDepositTransaction(payload, branchResult.collectorData)
+  ]);
+  if (!ok) {
+    return {
+      isValid: false,
+      invalidReason: ErrDepositSimulationFailed,
+      payer: payload.channelConfig.payer
+    };
+  }
+  return null;
+}
+async function resolvePermit2DepositBranch(signer, payment, payload, requirements, context) {
+  const payer = payload.channelConfig.payer;
+  const tokenAddress = (0, import_viem10.getAddress)(requirements.asset);
+  const eip2612Info = extractEip2612GasSponsoringInfo(payment);
+  if (eip2612Info) {
+    const result = validateBatchEip2612Permit(
+      eip2612Info,
+      payer,
+      tokenAddress,
+      payload.deposit.amount
+    );
+    if (!result.isValid) {
+      return { isValid: false, invalidReason: result.invalidReason, payer };
+    }
+    const { v, r, s } = splitEip2612Signature(eip2612Info.signature);
+    return {
+      kind: "eip2612",
+      collectorData: buildPermit2DepositCollectorData(
+        payload,
+        buildEip2612PermitData({
+          value: eip2612Info.amount,
+          deadline: eip2612Info.deadline,
+          v,
+          r,
+          s
+        })
+      )
+    };
+  }
+  const erc20Info = extractErc20ApprovalGasSponsoringInfo(payment);
+  if (erc20Info) {
+    const extensionSigner = resolveErc20ApprovalExtensionSigner(
+      context?.getExtension(
+        ERC20_APPROVAL_GAS_SPONSORING_KEY
+      ),
+      requirements.network
+    );
+    if (!extensionSigner) {
+      return { isValid: false, invalidReason: ErrErc20ApprovalUnavailable, payer };
+    }
+    const result = await validateErc20ApprovalForPayment(erc20Info, payer, tokenAddress);
+    if (!result.isValid) {
+      return {
+        isValid: false,
+        invalidReason: result.invalidReason,
+        invalidMessage: result.invalidMessage,
+        payer
+      };
+    }
+    return {
+      kind: "erc20Approval",
+      collectorData: buildPermit2DepositCollectorData(payload),
+      signedTransaction: erc20Info.signedTransaction,
+      extensionSigner
+    };
+  }
+  try {
+    const allowance = await signer.readContract({
+      address: tokenAddress,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [payer, PERMIT2_ADDRESS]
+    });
+    if (allowance < BigInt(payload.deposit.amount)) {
+      return { isValid: false, invalidReason: ErrPermit2AllowanceRequired, payer };
+    }
+  } catch {
+    return { isValid: false, invalidReason: ErrPermit2AllowanceRequired, payer };
+  }
+  return {
+    kind: "standard",
+    collectorData: buildPermit2DepositCollectorData(payload)
+  };
+}
+function buildDepositTransaction(payload, collectorData) {
+  return {
+    to: (0, import_viem10.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+    data: (0, import_viem10.encodeFunctionData)({
+      abi: batchSettlementABI,
+      functionName: "deposit",
+      args: [
+        toContractChannelConfig(payload.channelConfig),
+        BigInt(payload.deposit.amount),
+        getPermit2DepositCollectorAddress(),
+        collectorData
+      ]
+    }),
+    gas: 300000n
+  };
+}
+async function verifyPermit2TypedData(signer, payload, requirements, chainId) {
+  const auth = payload.deposit.authorization.permit2Authorization;
+  const payer = payload.channelConfig.payer;
+  if (!auth) {
+    return { isValid: false, invalidReason: ErrPermit2AuthorizationRequired, payer };
+  }
+  if ((0, import_viem10.getAddress)(auth.from) !== (0, import_viem10.getAddress)(payer)) {
+    return { isValid: false, invalidReason: ErrPermit2InvalidSignature, payer };
+  }
+  if ((0, import_viem10.getAddress)(auth.spender) !== getPermit2DepositCollectorAddress()) {
+    return { isValid: false, invalidReason: ErrPermit2InvalidSpender, payer };
+  }
+  if ((0, import_viem10.getAddress)(auth.permitted.token) !== (0, import_viem10.getAddress)(requirements.asset)) {
+    return { isValid: false, invalidReason: ErrTokenMismatch, payer };
+  }
+  if (BigInt(auth.permitted.amount) !== BigInt(payload.deposit.amount)) {
+    return { isValid: false, invalidReason: ErrPermit2AmountMismatch, payer };
+  }
+  if (auth.witness.channelId !== payload.voucher.channelId) {
+    return { isValid: false, invalidReason: ErrChannelIdMismatch, payer };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (BigInt(auth.deadline) < BigInt(now + 6)) {
+    return { isValid: false, invalidReason: ErrPermit2DeadlineExpired, payer };
+  }
+  try {
+    const ok = await signer.verifyTypedData({
+      address: (0, import_viem10.getAddress)(auth.from),
+      domain: { name: "Permit2", chainId, verifyingContract: PERMIT2_ADDRESS },
+      types: batchPermit2WitnessTypes,
+      primaryType: "PermitWitnessTransferFrom",
+      message: {
+        permitted: {
+          token: (0, import_viem10.getAddress)(auth.permitted.token),
+          amount: BigInt(auth.permitted.amount)
+        },
+        spender: (0, import_viem10.getAddress)(auth.spender),
+        nonce: BigInt(auth.nonce),
+        deadline: BigInt(auth.deadline),
+        witness: {
+          channelId: auth.witness.channelId
+        }
+      },
+      signature: auth.signature
+    });
+    if (!ok) {
+      return { isValid: false, invalidReason: ErrPermit2InvalidSignature, payer };
+    }
+  } catch {
+    return { isValid: false, invalidReason: ErrPermit2InvalidSignature, payer };
+  }
+  return null;
+}
+function validateBatchEip2612Permit(info, payer, tokenAddress, depositAmount) {
+  const baseline = validateEip2612PermitForPayment(info, payer, tokenAddress);
+  if (!baseline.isValid) {
+    return {
+      isValid: false,
+      invalidReason: baseline.invalidReason ?? ErrInvalidPayloadType
+    };
+  }
+  if (BigInt(info.amount) !== BigInt(depositAmount)) {
+    return { isValid: false, invalidReason: ErrEip2612AmountMismatch };
+  }
+  return { isValid: true };
+}
+
+// src/batch-settlement/facilitator/deposit.ts
+async function verifyDeposit(signer, payment, payload, requirements, context) {
+  const payer = payload.channelConfig.payer;
+  const chainId = getEvmChainId(requirements.network);
+  const configErr = validateChannelConfig(
+    payload.channelConfig,
+    payload.voucher.channelId,
+    requirements
+  );
+  if (configErr) {
+    return { isValid: false, invalidReason: configErr, payer };
+  }
+  const transferMethod = resolveDepositTransferMethod(payload, requirements);
+  if (transferMethod === "permit2" && !payload.deposit.authorization.permit2Authorization) {
+    return { isValid: false, invalidReason: ErrInvalidPayloadType, payer };
+  }
+  const methodErr = transferMethod === "permit2" ? await verifyPermit2DepositAuthorization(
+    signer,
+    payment,
+    payload,
+    requirements,
+    chainId,
+    context
+  ) : await verifyEip3009DepositAuthorization(signer, payload, requirements, chainId);
+  if (methodErr) {
+    return methodErr;
+  }
+  const shared = await verifySharedDepositState(signer, payload, requirements);
+  if (!shared.ok) {
+    return shared.response;
+  }
+  const { depositAmount, chBalance, chTotalClaimed, wdInitiatedAt, refundNonceVal } = shared;
+  const execution = await resolveDepositExecution(signer, payment, payload, requirements, context);
+  if ("isValid" in execution) {
+    return execution;
+  }
+  if (!execution.skipDirectSimulation) {
+    try {
+      await signer.readContract({
+        address: (0, import_viem11.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+        abi: batchSettlementABI,
+        functionName: "deposit",
+        args: [
+          toContractChannelConfig(payload.channelConfig),
+          depositAmount,
+          execution.collector,
+          execution.collectorData
+        ]
+      });
+    } catch (e) {
+      return {
+        isValid: false,
+        invalidReason: ErrDepositSimulationFailed,
+        invalidMessage: e instanceof Error ? e.message : String(e),
+        payer
+      };
+    }
+  }
+  return {
+    isValid: true,
+    payer,
+    extra: {
+      channelId: payload.voucher.channelId,
+      balance: chBalance.toString(),
+      totalClaimed: chTotalClaimed.toString(),
+      withdrawRequestedAt: Number(wdInitiatedAt),
+      refundNonce: refundNonceVal.toString()
+    }
+  };
+}
+async function verifySharedDepositState(signer, payload, requirements) {
+  const { deposit, voucher } = payload;
+  const config = payload.channelConfig;
+  const payer = config.payer;
+  const chainId = getEvmChainId(requirements.network);
+  const configErr = validateChannelConfig(config, voucher.channelId, requirements);
+  if (configErr) {
+    return { ok: false, response: { isValid: false, invalidReason: configErr, payer } };
+  }
+  const voucherOk = await verifyBatchSettlementVoucherTypedData(
+    signer,
+    {
+      channelId: voucher.channelId,
+      maxClaimableAmount: voucher.maxClaimableAmount,
+      payerAuthorizer: config.payerAuthorizer,
+      payer: config.payer,
+      signature: voucher.signature
+    },
+    chainId
+  );
+  if (!voucherOk) {
+    return {
+      ok: false,
+      response: { isValid: false, invalidReason: ErrInvalidVoucherSignature, payer }
+    };
+  }
+  const mcResults = await multicall(signer.readContract.bind(signer), [
+    {
+      address: (0, import_viem11.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+      abi: batchSettlementABI,
+      functionName: "channels",
+      args: [voucher.channelId]
+    },
+    {
+      address: (0, import_viem11.getAddress)(requirements.asset),
+      abi: erc20BalanceOfABI,
+      functionName: "balanceOf",
+      args: [(0, import_viem11.getAddress)(payer)]
+    },
+    {
+      address: (0, import_viem11.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+      abi: batchSettlementABI,
+      functionName: "pendingWithdrawals",
+      args: [voucher.channelId]
+    },
+    {
+      address: (0, import_viem11.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+      abi: batchSettlementABI,
+      functionName: "refundNonce",
+      args: [voucher.channelId]
+    }
+  ]);
+  const [chRes, balRes, wdRes, rnRes] = mcResults;
+  if (chRes.status === "failure" || balRes.status === "failure" || wdRes.status === "failure" || rnRes.status === "failure") {
+    return {
+      ok: false,
+      response: { isValid: false, invalidReason: ErrRpcReadFailed, payer }
+    };
+  }
+  const [chBalance, chTotalClaimed] = chRes.result;
+  const payerBalance = balRes.result;
+  const [, wdInitiatedAt] = wdRes.result;
+  const refundNonceVal = rnRes.result;
+  const depositAmount = BigInt(deposit.amount);
+  if (payerBalance < depositAmount) {
+    return {
+      ok: false,
+      response: { isValid: false, invalidReason: ErrInsufficientBalance, payer }
+    };
+  }
+  const effectiveBalance = chBalance + depositAmount;
+  const maxClaimableAmount = BigInt(voucher.maxClaimableAmount);
+  if (maxClaimableAmount > effectiveBalance) {
+    return {
+      ok: false,
+      response: { isValid: false, invalidReason: ErrCumulativeExceedsBalance, payer }
+    };
+  }
+  if (maxClaimableAmount <= chTotalClaimed) {
+    return {
+      ok: false,
+      response: { isValid: false, invalidReason: ErrCumulativeAmountBelowClaimed, payer }
+    };
+  }
+  return {
+    ok: true,
+    chainId,
+    depositAmount,
+    payer,
+    chBalance,
+    chTotalClaimed,
+    wdInitiatedAt,
+    refundNonceVal
+  };
+}
+async function settleDeposit(signer, payment, payload, requirements, context) {
+  const { deposit, voucher } = payload;
+  const config = payload.channelConfig;
+  const payer = config.payer;
+  const verified = await verifyDeposit(signer, payment, payload, requirements, context);
+  if (!verified.isValid) {
+    const reason = verified.invalidReason ?? ErrInvalidPayloadType;
+    return {
+      success: false,
+      errorReason: reason,
+      errorMessage: verified.invalidMessage ?? reason,
+      transaction: "",
+      network: requirements.network,
+      payer: verified.payer
+    };
+  }
+  try {
+    const execution = await resolveDepositExecution(
+      signer,
+      payment,
+      payload,
+      requirements,
+      context
+    );
+    if ("isValid" in execution) {
+      const reason = execution.invalidReason ?? ErrInvalidPayloadType;
+      return {
+        success: false,
+        errorReason: reason,
+        errorMessage: execution.invalidMessage ?? reason,
+        transaction: "",
+        network: requirements.network,
+        payer: execution.payer
+      };
+    }
+    const depositTx = buildDepositTransaction(payload, execution.collectorData);
+    const tx = execution.kind === "erc20Approval" ? (await execution.extensionSigner.sendTransactions([
+      execution.signedTransaction,
+      depositTx
+    ]))[1] : await signer.writeContract({
+      address: (0, import_viem11.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+      abi: batchSettlementABI,
+      functionName: "deposit",
+      args: [
+        toContractChannelConfig(config),
+        BigInt(deposit.amount),
+        execution.collector,
+        execution.collectorData
+      ]
+    });
+    const receipt = await signer.waitForTransactionReceipt({ hash: tx });
+    if (receipt.status !== "success") {
+      return {
+        success: false,
+        errorReason: ErrDepositTransactionFailed,
+        errorMessage: `transaction reverted (receipt status ${receipt.status})`,
+        transaction: tx,
+        network: requirements.network,
+        payer
+      };
+    }
+    const optimisticExtra = {
+      channelState: {
+        channelId: voucher.channelId,
+        balance: (BigInt(String(verified.extra?.balance ?? "0")) + BigInt(deposit.amount)).toString(),
+        totalClaimed: String(verified.extra?.totalClaimed ?? "0"),
+        withdrawRequestedAt: Number(verified.extra?.withdrawRequestedAt ?? 0),
+        refundNonce: String(verified.extra?.refundNonce ?? "0")
+      }
+    };
+    const expectedMinBalance = BigInt(optimisticExtra.channelState.balance);
+    const rpcDeadline = Date.now() + 2e3;
+    let postState = await readChannelState(signer, voucher.channelId);
+    while (postState.balance < expectedMinBalance && Date.now() < rpcDeadline) {
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      postState = await readChannelState(signer, voucher.channelId);
+    }
+    const rpcCaughtUp = postState.balance >= expectedMinBalance;
+    return {
+      success: true,
+      transaction: tx,
+      network: requirements.network,
+      payer,
+      amount: deposit.amount,
+      extra: rpcCaughtUp ? {
+        ...optimisticExtra,
+        channelState: {
+          channelId: voucher.channelId,
+          balance: postState.balance.toString(),
+          totalClaimed: postState.totalClaimed.toString(),
+          withdrawRequestedAt: postState.withdrawRequestedAt,
+          refundNonce: postState.refundNonce.toString()
+        }
+      } : optimisticExtra
+    };
+  } catch (e) {
+    return {
+      success: false,
+      errorReason: ErrDepositTransactionFailed,
+      errorMessage: e instanceof Error ? e.message : String(e),
+      transaction: "",
+      network: requirements.network,
+      payer
+    };
+  }
+}
+async function resolveDepositExecution(signer, payment, payload, requirements, context) {
+  const transferMethod = resolveDepositTransferMethod(payload, requirements);
+  if (transferMethod === "eip3009") {
+    return {
+      kind: "direct",
+      collector: getEip3009DepositCollectorAddress(),
+      collectorData: buildEip3009DepositCollectorData(payload)
+    };
+  }
+  const branch = await resolvePermit2DepositBranch(signer, payment, payload, requirements, context);
+  if ("isValid" in branch) {
+    return branch;
+  }
+  if (branch.kind === "erc20Approval") {
+    return {
+      kind: "erc20Approval",
+      collector: getPermit2DepositCollectorAddress(),
+      collectorData: branch.collectorData,
+      signedTransaction: branch.signedTransaction,
+      extensionSigner: branch.extensionSigner,
+      skipDirectSimulation: true
+    };
+  }
+  return {
+    kind: "direct",
+    collector: getPermit2DepositCollectorAddress(),
+    collectorData: branch.collectorData
+  };
+}
+function resolveDepositTransferMethod(payload, requirements) {
+  const hinted = requirements.extra?.assetTransferMethod;
+  if (hinted) {
+    return hinted;
+  }
+  return payload.deposit.authorization.permit2Authorization ? "permit2" : "eip3009";
+}
+
+// src/batch-settlement/facilitator/voucher.ts
+async function verifyVoucher(signer, payload, requirements, channelConfig) {
+  const { voucher } = payload;
+  const channelId = voucher.channelId;
+  const chainId = getEvmChainId(requirements.network);
+  const configErr = validateChannelConfig(channelConfig, channelId, requirements);
+  if (configErr) {
+    return { isValid: false, invalidReason: configErr, payer: channelConfig.payer };
+  }
+  const voucherOk = await verifyBatchSettlementVoucherTypedData(
+    signer,
+    {
+      channelId,
+      maxClaimableAmount: voucher.maxClaimableAmount,
+      payerAuthorizer: channelConfig.payerAuthorizer,
+      payer: channelConfig.payer,
+      signature: voucher.signature
+    },
+    chainId
+  );
+  if (!voucherOk) {
+    return {
+      isValid: false,
+      invalidReason: ErrInvalidVoucherSignature,
+      payer: channelConfig.payer
+    };
+  }
+  const state = await readChannelState(signer, channelId);
+  if (state.balance === 0n) {
+    return { isValid: false, invalidReason: ErrChannelNotFound, payer: channelConfig.payer };
+  }
+  const maxClaimableAmount = BigInt(voucher.maxClaimableAmount);
+  if (maxClaimableAmount > state.balance) {
+    return {
+      isValid: false,
+      invalidReason: ErrCumulativeExceedsBalance,
+      payer: channelConfig.payer
+    };
+  }
+  const belowClaimed = payload.type === "refund" ? maxClaimableAmount < state.totalClaimed : maxClaimableAmount <= state.totalClaimed;
+  if (belowClaimed) {
+    return {
+      isValid: false,
+      invalidReason: ErrCumulativeAmountBelowClaimed,
+      payer: channelConfig.payer
+    };
+  }
+  return {
+    isValid: true,
+    payer: channelConfig.payer,
+    extra: {
+      channelId,
+      balance: state.balance.toString(),
+      totalClaimed: state.totalClaimed.toString(),
+      withdrawRequestedAt: state.withdrawRequestedAt,
+      refundNonce: state.refundNonce.toString()
+    }
+  };
+}
+
+// src/batch-settlement/facilitator/claim.ts
+var import_viem12 = require("viem");
+
+// src/batch-settlement/authorizerSigner.ts
+async function signClaimBatch(signer, claims, network) {
+  const chainId = getEvmChainId(network);
+  const claimEntries = claims.map((c) => ({
+    channelId: computeChannelId(c.voucher.channel, chainId),
+    maxClaimableAmount: BigInt(c.voucher.maxClaimableAmount),
+    totalClaimed: BigInt(c.totalClaimed)
+  }));
+  return signer.signTypedData({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: claimBatchTypes,
+    primaryType: "ClaimBatch",
+    message: {
+      claims: claimEntries
+    }
+  });
+}
+async function signRefund(signer, channelId, amount, nonce, network) {
+  const chainId = getEvmChainId(network);
+  return signer.signTypedData({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: refundTypes,
+    primaryType: "Refund",
+    message: {
+      channelId,
+      nonce: BigInt(nonce),
+      amount: BigInt(amount)
+    }
+  });
+}
+
+// src/batch-settlement/facilitator/claim.ts
+function buildVoucherClaimArgs(claims) {
+  return claims.map((c) => ({
+    voucher: {
+      channel: toContractChannelConfig(c.voucher.channel),
+      maxClaimableAmount: BigInt(c.voucher.maxClaimableAmount)
+    },
+    signature: c.signature,
+    totalClaimed: BigInt(c.totalClaimed)
+  }));
+}
+async function executeClaimWithSignature(signer, payload, requirements, authorizerSigner) {
+  const network = requirements.network;
+  const claimArgs = buildVoucherClaimArgs(payload.claims);
+  let sig = payload.claimAuthorizerSignature;
+  if (!sig) {
+    for (const claim of payload.claims) {
+      if ((0, import_viem12.getAddress)(claim.voucher.channel.receiverAuthorizer) !== (0, import_viem12.getAddress)(authorizerSigner.address)) {
+        return {
+          success: false,
+          errorReason: ErrAuthorizerAddressMismatch,
+          transaction: "",
+          network
+        };
+      }
+    }
+    sig = await signClaimBatch(authorizerSigner, payload.claims, network);
+  }
+  try {
+    await signer.readContract({
+      address: (0, import_viem12.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+      abi: batchSettlementABI,
+      functionName: "claimWithSignature",
+      args: [claimArgs, sig]
+    });
+  } catch (e) {
+    return {
+      success: false,
+      errorReason: ErrClaimSimulationFailed,
+      errorMessage: e instanceof Error ? e.message : String(e),
+      transaction: "",
+      network
+    };
+  }
+  try {
+    const tx = await signer.writeContract({
+      address: (0, import_viem12.getAddress)(BATCH_SETTLEMENT_ADDRESS),
+      abi: batchSettlementABI,
+      functionName: "claimWithSignature",
+      args: [claimArgs, sig]
+    });
+    const receipt = await signer.waitForTransactionReceipt({ hash: tx });
+    if (receipt.status !== "success") {
+      return {
+        success: false,
+        errorReason: ErrClaimTransactionFailed,
+        errorMessage: `transaction reverted (receipt status ${receipt.status})`,
+        transaction: tx,
+        network
+      };
+    }
+    return {
+      success: true,
+      transaction: tx,
+      network,
+      amount: ""
+    };
+  } catch (e) {
+    return {
+      success: false,
+      errorReason: ErrClaimTransactionFailed,
+      errorMessage: e instanceof Error ? e.message : String(e),
+      transaction: "",
+      network
+    };
+  }
+}
+
+// src/batch-settlement/facilitator/settle.ts
+var import_viem13 = require("viem");
+async function executeSettle(signer, payload, requirements) {
+  const network = requirements.network;
+  const contractAddr = (0, import_viem13.getAddress)(BATCH_SETTLEMENT_ADDRESS);
+  const receiver = (0, import_viem13.getAddress)(payload.receiver);
+  const token = (0, import_viem13.getAddress)(payload.token);
+  try {
+    const [totalClaimed, totalSettled] = await signer.readContract({
+      address: contractAddr,
+      abi: batchSettlementABI,
+      functionName: "receivers",
+      args: [receiver, token]
+    });
+    if (totalClaimed <= totalSettled) {
+      return {
+        success: false,
+        errorReason: ErrNothingToSettle,
+        errorMessage: "nothing to settle for receiver and token",
+        transaction: "",
+        network
+      };
+    }
+  } catch (e) {
+    return {
+      success: false,
+      errorReason: ErrRpcReadFailed,
+      errorMessage: e instanceof Error ? e.message : String(e),
+      transaction: "",
+      network
+    };
+  }
+  try {
+    await signer.readContract({
+      address: contractAddr,
+      abi: batchSettlementABI,
+      functionName: "settle",
+      args: [receiver, token]
+    });
+  } catch (e) {
+    return {
+      success: false,
+      errorReason: ErrSettleSimulationFailed,
+      errorMessage: e instanceof Error ? e.message : String(e),
+      transaction: "",
+      network
+    };
+  }
+  try {
+    const tx = await signer.writeContract({
+      address: contractAddr,
+      abi: batchSettlementABI,
+      functionName: "settle",
+      args: [receiver, token]
+    });
+    const receipt = await signer.waitForTransactionReceipt({ hash: tx });
+    if (receipt.status !== "success") {
+      return {
+        success: false,
+        errorReason: ErrSettleTransactionFailed,
+        errorMessage: `transaction reverted (receipt status ${receipt.status})`,
+        transaction: tx,
+        network
+      };
+    }
+    let amount = "";
+    if (receipt.logs) {
+      const logs = (0, import_viem13.parseEventLogs)({
+        abi: batchSettlementABI,
+        eventName: "Settled",
+        logs: receipt.logs.filter((log) => (0, import_viem13.isAddressEqual)(log.address, contractAddr))
+      });
+      const settledLog = logs.find(
+        (log) => (0, import_viem13.isAddressEqual)(log.args.receiver, receiver) && (0, import_viem13.isAddressEqual)(log.args.token, token)
+      );
+      amount = settledLog?.args.amount.toString() ?? "0";
+    }
+    return {
+      success: true,
+      transaction: tx,
+      network,
+      amount
+    };
+  } catch (e) {
+    return {
+      success: false,
+      errorReason: ErrSettleTransactionFailed,
+      errorMessage: e instanceof Error ? e.message : String(e),
+      transaction: "",
+      network
+    };
+  }
+}
+
+// src/batch-settlement/facilitator/refund.ts
+var import_viem14 = require("viem");
+var REFUND_STATE_POLL_MS = 2e3;
+var REFUND_STATE_POLL_INTERVAL_MS = 150;
+function getRefundableAmount(payload, preState, channelId, network) {
+  const postClaimTotalClaimed = payload.claims.reduce((max, claim) => {
+    const claimChannelId = computeChannelId(claim.voucher.channel, network);
+    if (claimChannelId.toLowerCase() !== channelId.toLowerCase()) {
+      return max;
+    }
+    const totalClaimed = BigInt(claim.totalClaimed);
+    return totalClaimed > max ? totalClaimed : max;
+  }, preState.totalClaimed);
+  if (postClaimTotalClaimed > preState.balance) {
+    return null;
+  }
+  const requestedAmount = BigInt(payload.amount);
+  if (requestedAmount === 0n) {
+    return null;
+  }
+  const available = preState.balance - postClaimTotalClaimed;
+  return requestedAmount > available ? available : requestedAmount;
+}
+function buildRefundExtra(payload, channelId, preState) {
+  const preTotalClaimed = preState?.totalClaimed ?? 0n;
+  const preBalance = preState?.balance ?? 0n;
+  const lastClaimTotal = payload.claims.length > 0 ? BigInt(payload.claims[payload.claims.length - 1].totalClaimed) : preTotalClaimed;
+  const postClaimTotalClaimed = lastClaimTotal > preTotalClaimed ? lastClaimTotal : preTotalClaimed;
+  const available = preBalance - postClaimTotalClaimed;
+  const requestedAmount = BigInt(payload.amount);
+  const actualRefund = requestedAmount > available ? available : requestedAmount;
+  return {
+    amount: actualRefund.toString(),
+    extra: {
+      channelState: {
+        channelId,
+        balance: (preBalance - actualRefund).toString(),
+        totalClaimed: postClaimTotalClaimed.toString(),
+        withdrawRequestedAt: 0,
+        refundNonce: String((preState?.refundNonce ?? 0n) + 1n)
+      }
+    }
+  };
+}
+async function readPostRefundState(signer, channelId, submittedNonce) {
+  const expectedNonce = BigInt(submittedNonce) + 1n;
+  const deadline = Date.now() + REFUND_STATE_POLL_MS;
+  do {
+    let state;
+    try {
+      state = await readChannelState(signer, channelId);
+    } catch {
+      return null;
+    }
+    if (state.refundNonce >= expectedNonce) {
+      return state;
+    }
+    await new Promise((resolve) => setTimeout(resolve, REFUND_STATE_POLL_INTERVAL_MS));
+  } while (Date.now() < deadline);
+  return null;
+}
+function buildRefundExtraFromPostState(channelId, preState, postState) {
+  const actualRefund = preState.balance > postState.balance ? preState.balance - postState.balance : 0n;
+  return {
+    amount: actualRefund.toString(),
+    extra: {
+      channelState: {
+        channelId,
+        balance: postState.balance.toString(),
+        totalClaimed: postState.totalClaimed.toString(),
+        withdrawRequestedAt: postState.withdrawRequestedAt,
+        refundNonce: postState.refundNonce.toString()
+      }
+    }
+  };
+}
+async function executeRefundWithSignature(signer, payload, requirements, authorizerSigner) {
+  const network = requirements.network;
+  try {
+    const channelId = computeChannelId(payload.channelConfig, network);
+    const preState = await readChannelState(signer, channelId);
+    const contractAddr = (0, import_viem14.getAddress)(BATCH_SETTLEMENT_ADDRESS);
+    const refundableAmount = getRefundableAmount(payload, preState, channelId, network);
+    if (refundableAmount === 0n) {
+      return {
+        success: false,
+        errorReason: ErrRefundNoBalance,
+        errorMessage: "Nothing to refund",
+        transaction: "",
+        network
+      };
+    }
+    const hasClientSig = payload.refundAuthorizerSignature !== void 0;
+    const authorizerMismatch = (0, import_viem14.getAddress)(payload.channelConfig.receiverAuthorizer) !== (0, import_viem14.getAddress)(authorizerSigner.address);
+    if (!hasClientSig && authorizerMismatch) {
+      return {
+        success: false,
+        errorReason: ErrAuthorizerAddressMismatch,
+        transaction: "",
+        network
+      };
+    }
+    const refundSig = payload.refundAuthorizerSignature ?? await signRefund(authorizerSigner, channelId, payload.amount, payload.refundNonce, network);
+    const refundCalldata = (0, import_viem14.encodeFunctionData)({
+      abi: batchSettlementABI,
+      functionName: "refundWithSignature",
+      args: [
+        toContractChannelConfig(payload.channelConfig),
+        BigInt(payload.amount),
+        BigInt(payload.refundNonce),
+        refundSig
+      ]
+    });
+    let tx;
+    if (payload.claims.length > 0) {
+      let claimSig = payload.claimAuthorizerSignature;
+      if (!claimSig) {
+        claimSig = await signClaimBatch(authorizerSigner, payload.claims, network);
+      }
+      const claimCalldata = (0, import_viem14.encodeFunctionData)({
+        abi: batchSettlementABI,
+        functionName: "claimWithSignature",
+        args: [buildVoucherClaimArgs(payload.claims), claimSig]
+      });
+      try {
+        await signer.readContract({
+          address: contractAddr,
+          abi: batchSettlementABI,
+          functionName: "multicall",
+          args: [[claimCalldata, refundCalldata]]
+        });
+      } catch (e) {
+        return {
+          success: false,
+          errorReason: ErrRefundSimulationFailed,
+          errorMessage: e instanceof Error ? e.message : String(e),
+          transaction: "",
+          network
+        };
+      }
+      tx = await signer.writeContract({
+        address: contractAddr,
+        abi: batchSettlementABI,
+        functionName: "multicall",
+        args: [[claimCalldata, refundCalldata]]
+      });
+    } else {
+      try {
+        await signer.readContract({
+          address: contractAddr,
+          abi: batchSettlementABI,
+          functionName: "refundWithSignature",
+          args: [
+            toContractChannelConfig(payload.channelConfig),
+            BigInt(payload.amount),
+            BigInt(payload.refundNonce),
+            refundSig
+          ]
+        });
+      } catch (e) {
+        return {
+          success: false,
+          errorReason: ErrRefundSimulationFailed,
+          errorMessage: e instanceof Error ? e.message : String(e),
+          transaction: "",
+          network
+        };
+      }
+      tx = await signer.writeContract({
+        address: contractAddr,
+        abi: batchSettlementABI,
+        functionName: "refundWithSignature",
+        args: [
+          toContractChannelConfig(payload.channelConfig),
+          BigInt(payload.amount),
+          BigInt(payload.refundNonce),
+          refundSig
+        ]
+      });
+    }
+    const receipt = await signer.waitForTransactionReceipt({ hash: tx });
+    if (receipt.status !== "success") {
+      return {
+        success: false,
+        errorReason: ErrRefundTransactionFailed,
+        errorMessage: `transaction reverted (receipt status ${receipt.status})`,
+        transaction: tx,
+        network
+      };
+    }
+    const postState = preState && preState.withdrawRequestedAt !== 0 ? await readPostRefundState(signer, channelId, payload.refundNonce) : null;
+    const refundDetails = preState && postState ? buildRefundExtraFromPostState(channelId, preState, postState) : buildRefundExtra(payload, channelId, preState);
+    return {
+      success: true,
+      transaction: tx,
+      network,
+      payer: payload.channelConfig.payer,
+      amount: refundDetails.amount,
+      extra: refundDetails.extra
+    };
+  } catch (e) {
+    return {
+      success: false,
+      errorReason: ErrRefundTransactionFailed,
+      errorMessage: e instanceof Error ? e.message : String(e),
+      transaction: "",
+      network
+    };
+  }
+}
+
+// src/batch-settlement/facilitator/scheme.ts
+var BatchSettlementEvmScheme = class {
+  /**
+   * Creates a facilitator scheme for verifying and settling batch-settlement payments.
+   *
+   * @param signer - Facilitator EVM signer(s) used for tx submission and onchain reads.
+   * @param authorizerSigner - Dedicated key that provides EIP-712 signatures for
+   *   `claimWithSignature` / `refundWithSignature`.  The facilitator will sign missing
+   *   authorizer signatures using this key when the server omits them.
+   */
+  constructor(signer, authorizerSigner) {
+    this.signer = signer;
+    this.authorizerSigner = authorizerSigner;
+    this.scheme = BATCH_SETTLEMENT_SCHEME;
+    this.caipFamily = "eip155:*";
+  }
+  /**
+   * Returns facilitator-specific extra fields to be merged into payment requirements.
+   *
+   * Exposes the configured `receiverAuthorizer` address so the server and client can
+   * embed it in `ChannelConfig`.
+   *
+   * @param _ - Network identifier (unused).
+   * @returns Extra fields containing `receiverAuthorizer`.
+   */
+  getExtra(_) {
+    return { receiverAuthorizer: this.authorizerSigner.address };
+  }
+  /**
+   * Returns all facilitator signer addresses available for the given network.
+   *
+   * @param _ - Network identifier (unused).
+   * @returns Array of hex addresses.
+   */
+  getSigners(_) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies a payment payload (deposit or voucher) without executing settlement.
+   *
+   * @param payload - The x402 payment payload envelope.
+   * @param requirements - Server payment requirements (scheme, network, asset, amount).
+   * @param context - Optional facilitator extension context.
+   * @returns A {@link VerifyResponse} indicating validity with payer and channel state in `extra`.
+   */
+  async verify(payload, requirements, context) {
+    const rawPayload = payload.payload;
+    if (payload.accepted.scheme !== BATCH_SETTLEMENT_SCHEME || requirements.scheme !== BATCH_SETTLEMENT_SCHEME) {
+      return { isValid: false, invalidReason: ErrInvalidScheme };
+    }
+    if (payload.accepted.network !== requirements.network) {
+      return { isValid: false, invalidReason: ErrNetworkMismatch };
+    }
+    if (isBatchSettlementDepositPayload(rawPayload)) {
+      return verifyDeposit(this.signer, payload, rawPayload, requirements, context);
+    }
+    if (isBatchSettlementVoucherPayload(rawPayload)) {
+      return verifyVoucher(this.signer, rawPayload, requirements, rawPayload.channelConfig);
+    }
+    if (isBatchSettlementRefundPayload(rawPayload)) {
+      return verifyVoucher(this.signer, rawPayload, requirements, rawPayload.channelConfig);
+    }
+    return { isValid: false, invalidReason: ErrInvalidPayloadType };
+  }
+  /**
+   * Executes settlement for a payment payload.
+   *
+   * Dispatches to the correct handler based on payload settle action:
+   * - `deposit` → onchain `deposit(config, amount, collector, collectorData)`
+   * - `claim` → onchain `claimWithSignature(VoucherClaim[], bytes)`
+   * - `settle` → onchain `settle(receiver, token)`
+   * - `refund` → optional claim + onchain `refundWithSignature(config, amount, nonce, sig)`
+   *
+   * @param payload - The x402 payment payload envelope.
+   * @param requirements - Server payment requirements.
+   * @param context - Optional facilitator extension context.
+   * @returns A {@link SettleResponse} with the transaction hash on success.
+   */
+  async settle(payload, requirements, context) {
+    const rawPayload = payload.payload;
+    if (isBatchSettlementDepositPayload(rawPayload)) {
+      return settleDeposit(this.signer, payload, rawPayload, requirements, context);
+    }
+    if (isBatchSettlementClaimPayload(rawPayload)) {
+      return executeClaimWithSignature(
+        this.signer,
+        rawPayload,
+        requirements,
+        this.authorizerSigner
+      );
+    }
+    if (isBatchSettlementEnrichedRefundPayload(rawPayload)) {
+      return executeRefundWithSignature(
+        this.signer,
+        rawPayload,
+        requirements,
+        this.authorizerSigner
+      );
+    }
+    if (isBatchSettlementSettlePayload(rawPayload)) {
+      return executeSettle(this.signer, rawPayload, requirements);
+    }
+    return {
+      success: false,
+      errorReason: ErrInvalidPayloadType,
+      transaction: "",
+      network: requirements.network
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchSettlementEvmScheme
+});
+//# sourceMappingURL=index.js.map