@payai/x402-evm 2.4.0 → 2.4.2

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

@@ -0,0 +1,1960 @@
+"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/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  BatchSettlementChannelManager: () => BatchSettlementChannelManager,
+  BatchSettlementEvmScheme: () => BatchSettlementEvmScheme,
+  InMemoryChannelStorage: () => InMemoryChannelStorage
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/batch-settlement/server/scheme.ts
+var import_utils12 = require("@payai/x402/utils");
+var import_viem7 = require("viem");
+
+// src/batch-settlement/utils.ts
+var import_viem3 = require("viem");
+
+// src/batch-settlement/constants.ts
+var import_viem = require("viem");
+var BATCH_SETTLEMENT_SCHEME = "batch-settlement";
+var BATCH_SETTLEMENT_ADDRESS = "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003";
+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" }
+  ]
+};
+
+// 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)));
+}
+
+// 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/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/server/channelManager.ts
+var AUTO_JOB_PRIORITY = ["claim", "settle", "refund"];
+function formatFacilitatorFailure(operation, response) {
+  return `${operation} failed: ${response.errorReason ?? "unknown"} \u2014 ${response.errorMessage ?? ""}`;
+}
+function hasLivePendingRequest(channel, now = Date.now()) {
+  return channel.pendingRequest !== void 0 && channel.pendingRequest.expiresAt > now;
+}
+var BatchSettlementChannelManager = class {
+  /**
+   * Creates a new channel manager.
+   *
+   * @param config - Manager configuration: scheme, facilitator, receiver, token, network.
+   */
+  constructor(config) {
+    this.timers = {};
+    this.lastClaimTime = 0;
+    this.lastSettleTime = 0;
+    this.pendingSettle = false;
+    this.running = false;
+    this.pendingJobs = /* @__PURE__ */ new Set();
+    this.drainingJobs = false;
+    this.autoSettleConfig = {};
+    this.scheme = config.scheme;
+    this.facilitator = config.facilitator;
+    this.receiver = config.receiver;
+    this.token = config.token;
+    this.network = config.network;
+  }
+  /**
+   * Collects claimable vouchers and submits them in batches to the facilitator via `claim()`.
+   *
+   * @param opts - Optional claim execution and target selection options.
+   * @param opts.maxClaimsPerBatch - Max vouchers per facilitator `claim` batch.
+   * @param opts.idleSecs - When set, only include channels idle for at least this many seconds.
+   * @param opts.selectClaimChannels - Optional selector for choosing channels before claimability checks.
+   * @returns Array of claim results (one per batch).
+   */
+  async claim(opts) {
+    const channels = await this.selectClaimTargets(opts);
+    return this.claimFromChannels(channels, {
+      maxClaimsPerBatch: opts?.maxClaimsPerBatch ?? 100,
+      ...opts?.idleSecs !== void 0 ? { idleSecs: opts.idleSecs } : {}
+    });
+  }
+  /**
+   * Transfers claimed (but unsettled) funds to the receiver by calling `settle(receiver, token)`.
+   *
+   * @returns Settle result with the transaction hash.
+   */
+  async settle() {
+    const paymentPayload = this.buildSettlePaymentPayload();
+    const requirements = this.buildPaymentRequirements();
+    const response = await this.facilitator.settle(paymentPayload, requirements);
+    if (!response.success) {
+      throw new Error(formatFacilitatorFailure("Settle", response));
+    }
+    this.pendingSettle = false;
+    return { transaction: response.transaction };
+  }
+  /**
+   * Convenience: claims all eligible vouchers then settles in one call.
+   *
+   * @param opts - Optional claim execution and target selection options.
+   * @param opts.maxClaimsPerBatch - Max vouchers per claim batch before settling.
+   * @param opts.idleSecs - When set, only include channels idle for at least this many seconds.
+   * @param opts.selectClaimChannels - Optional selector for choosing channels before claimability checks.
+   * @returns Combined claim and settle results.
+   */
+  async claimAndSettle(opts) {
+    const claims = await this.claim(opts);
+    let settleResult;
+    if (claims.length > 0) {
+      settleResult = await this.settle();
+    }
+    return { claims, settle: settleResult };
+  }
+  /**
+   * Initiates cooperative refunds for one or more channels.
+   *
+   * @param channelIds - Specific channels to refund; defaults to all sessions.
+   * @returns One result per successfully refunded channel.
+   */
+  async refund(channelIds) {
+    const storage = this.scheme.getStorage();
+    const channels = await storage.list();
+    const now = Date.now();
+    const targets = (channelIds ? channels.filter(
+      (s) => channelIds.some((id) => id.toLowerCase() === s.channelId.toLowerCase())
+    ) : channels).filter((channel) => !hasLivePendingRequest(channel, now));
+    if (targets.length === 0) {
+      return [];
+    }
+    return this.refundChannels(targets);
+  }
+  /**
+   * Refunds idle channels with non-zero balances.
+   *
+   * @param opts - Idle refund options.
+   * @param opts.idleSecs - Minimum seconds since the last request.
+   * @returns One result per successfully refunded channel.
+   */
+  async refundIdleChannels(opts) {
+    const channels = await this.getIdleChannelsForRefund(opts.idleSecs);
+    return this.refundChannels(channels);
+  }
+  /**
+   * Collects vouchers that are eligible for onchain claiming.
+   *
+   * A voucher is claimable when its `chargedCumulativeAmount` exceeds what has already
+   * been claimed onchain.  An optional idle filter skips sessions that received a
+   * request within the last `idleSecs` seconds.
+   *
+   * @param opts - Optional filtering: `idleSecs` to only return idle channels.
+   * @param opts.idleSecs - Minimum seconds since last request for a channel to be included.
+   * @returns Array of {@link BatchSettlementVoucherClaim} entries for batch submission.
+   */
+  async getClaimableVouchers(opts) {
+    const channels = await this.scheme.getStorage().list();
+    return this.getClaimableVouchersFromChannels(channels, opts);
+  }
+  /**
+   * Returns channels that have a pending payer-initiated withdrawal.
+   *
+   * @returns All stored channel records with `withdrawRequestedAt` set.
+   */
+  async getWithdrawalPendingSessions() {
+    const channels = await this.scheme.getStorage().list();
+    return channels.filter((s) => s.withdrawRequestedAt > 0);
+  }
+  /**
+   * Starts auto-settlement jobs for configured claim, settle, and refund intervals.
+   *
+   * @param config - Auto-settlement policy configuration.
+   */
+  start(config = {}) {
+    if (this.running) {
+      return;
+    }
+    const now = Date.now();
+    this.lastClaimTime = now;
+    this.lastSettleTime = now;
+    this.running = true;
+    this.autoSettleConfig = config;
+    this.startAutoTimer("claim", config.claimIntervalSecs);
+    this.startAutoTimer("settle", config.settleIntervalSecs);
+    this.startAutoTimer("refund", config.refundIntervalSecs);
+  }
+  /**
+   * Stops the auto-settlement loop.
+   *
+   * @param opts - Stop options.
+   * @param opts.flush - When true, run `claimAndSettle` before stopping.
+   * @returns Resolves when the loop is stopped (and flush work completes, if requested).
+   */
+  async stop(opts) {
+    this.running = false;
+    for (const timer of Object.values(this.timers)) {
+      clearInterval(timer);
+    }
+    this.timers = {};
+    this.pendingJobs.clear();
+    if (opts?.flush) {
+      await this.claimAndSettle({
+        maxClaimsPerBatch: this.autoSettleConfig.maxClaimsPerBatch,
+        selectClaimChannels: this.autoSettleConfig.selectClaimChannels
+      });
+    }
+  }
+  /**
+   * Refunds a single channel and removes it from storage after success.
+   *
+   * @param target - Channel to refund.
+   * @returns Successful refund transaction.
+   */
+  async refundChannel(target) {
+    const authorizerSigner = this.scheme.getReceiverAuthorizerSigner();
+    const claims = this.buildRefundClaims(target);
+    const refundAmount = (BigInt(target.balance) - BigInt(target.chargedCumulativeAmount)).toString();
+    const nonce = String(target.refundNonce ?? 0);
+    const refundAuthorizerSignature = authorizerSigner ? await signRefund(
+      authorizerSigner,
+      target.channelId,
+      refundAmount,
+      nonce,
+      this.network
+    ) : void 0;
+    const claimAuthorizerSignature = authorizerSigner && claims.length > 0 ? await signClaimBatch(authorizerSigner, claims, this.network) : void 0;
+    const paymentPayload = {
+      x402Version: 2,
+      accepted: this.buildPaymentRequirements(),
+      payload: {
+        type: "refund",
+        channelConfig: target.channelConfig,
+        voucher: {
+          channelId: target.channelId,
+          maxClaimableAmount: target.signedMaxClaimable,
+          signature: target.signature
+        },
+        amount: refundAmount,
+        refundNonce: nonce,
+        claims,
+        ...refundAuthorizerSignature ? { refundAuthorizerSignature } : {},
+        ...claimAuthorizerSignature ? { claimAuthorizerSignature } : {}
+      }
+    };
+    const response = await this.facilitator.settle(paymentPayload, this.buildPaymentRequirements());
+    if (!response.success) {
+      throw new Error(formatFacilitatorFailure("Refund", response));
+    }
+    await this.scheme.getStorage().updateChannel(
+      target.channelId,
+      (current) => current && !hasLivePendingRequest(current) ? void 0 : current
+    );
+    return {
+      channel: target.channelId,
+      transaction: response.transaction
+    };
+  }
+  /**
+   * Starts a recurring timer for one auto job.
+   *
+   * @param job - Job to enqueue when the interval fires.
+   * @param intervalSecs - Timer interval in seconds.
+   */
+  startAutoTimer(job, intervalSecs) {
+    if (intervalSecs === void 0) {
+      return;
+    }
+    this.timers[job] = setInterval(() => {
+      this.enqueueJob(job);
+    }, intervalSecs * 1e3);
+  }
+  /**
+   * Adds an auto job to the coalescing queue.
+   *
+   * @param job - Job to run.
+   */
+  enqueueJob(job) {
+    if (!this.running) {
+      return;
+    }
+    this.pendingJobs.add(job);
+    if (!this.drainingJobs) {
+      void this.drainJobs();
+    }
+  }
+  /**
+   * Drains queued auto jobs in priority order.
+   */
+  async drainJobs() {
+    if (this.drainingJobs) {
+      return;
+    }
+    this.drainingJobs = true;
+    try {
+      while (this.running && this.pendingJobs.size > 0) {
+        const job = this.nextPendingJob();
+        if (!job) {
+          return;
+        }
+        this.pendingJobs.delete(job);
+        await this.runAutoJob(job);
+      }
+    } finally {
+      this.drainingJobs = false;
+    }
+  }
+  /**
+   * Returns the highest-priority queued auto job.
+   *
+   * @returns Next job to run.
+   */
+  nextPendingJob() {
+    return AUTO_JOB_PRIORITY.find((job) => this.pendingJobs.has(job));
+  }
+  /**
+   * Runs one auto job.
+   *
+   * @param job - Job to run.
+   */
+  async runAutoJob(job) {
+    switch (job) {
+      case "claim":
+        await this.runClaimJob();
+        return;
+      case "settle":
+        await this.runSettleJob();
+        return;
+      case "refund":
+        await this.runRefundJob();
+        return;
+    }
+  }
+  /**
+   * Runs the claim auto job.
+   */
+  async runClaimJob() {
+    const cfg = this.autoSettleConfig;
+    try {
+      const targets = await this.selectClaimTargets({
+        selectClaimChannels: cfg.selectClaimChannels
+      });
+      const results = await this.claimFromChannels(targets, {
+        maxClaimsPerBatch: cfg.maxClaimsPerBatch ?? 100
+      });
+      this.lastClaimTime = Date.now();
+      for (const result of results) {
+        cfg.onClaim?.(result);
+      }
+    } catch (err) {
+      cfg.onError?.(err);
+    }
+  }
+  /**
+   * Runs the settlement auto job.
+   */
+  async runSettleJob() {
+    const cfg = this.autoSettleConfig;
+    const context = this.buildAutoSettlementContext(Date.now());
+    if (!context.pendingSettle) {
+      return;
+    }
+    try {
+      if (cfg.shouldSettle && !await cfg.shouldSettle(context)) {
+        return;
+      }
+      const result = await this.settle();
+      this.lastSettleTime = Date.now();
+      cfg.onSettle?.(result);
+    } catch (err) {
+      cfg.onError?.(err);
+    }
+  }
+  /**
+   * Runs the refund auto job.
+   */
+  async runRefundJob() {
+    const cfg = this.autoSettleConfig;
+    if (!cfg.selectRefundChannels) {
+      return;
+    }
+    try {
+      const context = this.buildAutoSettlementContext(Date.now());
+      const channels = await this.scheme.getStorage().list();
+      const targets = await cfg.selectRefundChannels(channels, context);
+      for (const result of await this.refundChannels(targets)) {
+        cfg.onRefund?.(result);
+      }
+    } catch (err) {
+      cfg.onError?.(err);
+    }
+  }
+  /**
+   * Claims vouchers from a provided channel snapshot.
+   *
+   * @param channels - Channels to inspect for claimable vouchers.
+   * @param opts - Claim batching and filtering options.
+   * @param opts.maxClaimsPerBatch - Max vouchers per facilitator claim transaction.
+   * @param opts.idleSecs - Optional idle filter.
+   * @returns Claim results, one per submitted batch.
+   */
+  async claimFromChannels(channels, opts) {
+    const allClaims = this.getClaimableVouchersFromChannels(
+      channels,
+      opts.idleSecs !== void 0 ? { idleSecs: opts.idleSecs } : void 0
+    );
+    if (allClaims.length === 0) {
+      return [];
+    }
+    const results = [];
+    for (let i = 0; i < allClaims.length; i += opts.maxClaimsPerBatch) {
+      const batch = allClaims.slice(i, i + opts.maxClaimsPerBatch);
+      const result = await this.submitClaim(batch);
+      results.push(result);
+      await this.updateClaimedSessions(batch);
+    }
+    if (results.length > 0) {
+      this.pendingSettle = true;
+    }
+    return results;
+  }
+  /**
+   * Loads stored channels and applies the configured claim selector, if any.
+   *
+   * @param opts - Claim options containing an optional target selector.
+   * @returns The channel snapshot that should be inspected for claimable vouchers.
+   */
+  async selectClaimTargets(opts) {
+    const channels = await this.scheme.getStorage().list();
+    if (!opts?.selectClaimChannels) {
+      return channels;
+    }
+    const context = this.buildAutoSettlementContext(Date.now());
+    return opts.selectClaimChannels(channels, context);
+  }
+  /**
+   * Refunds each eligible channel independently.
+   *
+   * @param channels - Channels to refund.
+   * @returns Successful refund results.
+   */
+  async refundChannels(channels) {
+    const results = [];
+    for (const channel of channels) {
+      if (hasLivePendingRequest(channel)) {
+        continue;
+      }
+      results.push(await this.refundChannel(channel));
+    }
+    return results;
+  }
+  /**
+   * Builds an outstanding voucher claim for a refund payload.
+   *
+   * @param channel - Channel being refunded.
+   * @returns Claim payloads needed before refunding unclaimed balance.
+   */
+  buildRefundClaims(channel) {
+    if (BigInt(channel.chargedCumulativeAmount) <= BigInt(channel.totalClaimed)) {
+      return [];
+    }
+    return [
+      {
+        voucher: {
+          channel: channel.channelConfig,
+          maxClaimableAmount: channel.signedMaxClaimable
+        },
+        signature: channel.signature,
+        totalClaimed: channel.chargedCumulativeAmount
+      }
+    ];
+  }
+  /**
+   * Builds the policy context passed to interval hooks.
+   *
+   * @param now - Current wall-clock time in milliseconds.
+   * @returns Auto-settlement policy context.
+   */
+  buildAutoSettlementContext(now) {
+    return {
+      now,
+      lastClaimTime: this.lastClaimTime,
+      lastSettleTime: this.lastSettleTime,
+      pendingSettle: this.pendingSettle
+    };
+  }
+  /**
+   * Collects claimable vouchers from a provided channel snapshot.
+   *
+   * @param channels - Channels to inspect.
+   * @param opts - Optional idle filter.
+   * @param opts.idleSecs - Minimum seconds since last request.
+   * @returns Claimable voucher payloads.
+   */
+  getClaimableVouchersFromChannels(channels, opts) {
+    const now = Date.now();
+    const claims = [];
+    for (const c of channels) {
+      if (BigInt(c.chargedCumulativeAmount) <= BigInt(c.totalClaimed)) {
+        continue;
+      }
+      if (opts?.idleSecs !== void 0) {
+        const idleMs = now - c.lastRequestTimestamp;
+        if (idleMs < opts.idleSecs * 1e3) {
+          continue;
+        }
+      }
+      claims.push({
+        voucher: {
+          channel: c.channelConfig,
+          maxClaimableAmount: c.signedMaxClaimable
+        },
+        signature: c.signature,
+        totalClaimed: c.chargedCumulativeAmount
+      });
+    }
+    return claims;
+  }
+  /**
+   * Filters idle channels that can be cooperatively refunded.
+   *
+   * @param channels - Channels to inspect.
+   * @param idleSecs - Minimum seconds since the last request.
+   * @returns Idle refundable channels.
+   */
+  getIdleChannelsForRefundFromChannels(channels, idleSecs) {
+    const now = Date.now();
+    const idleMs = idleSecs * 1e3;
+    return channels.filter((c) => {
+      if (BigInt(c.balance) === 0n) return false;
+      if (hasLivePendingRequest(c, now)) return false;
+      return now - c.lastRequestTimestamp >= idleMs;
+    });
+  }
+  /**
+   * Returns channels that have been idle longer than `idleSecs` and still have
+   * a non-zero balance (candidates for cooperative refund).
+   *
+   * @param idleSecs - Minimum seconds since last request for a session to count as idle.
+   * @returns Channels meeting the idle and balance criteria.
+   */
+  async getIdleChannelsForRefund(idleSecs) {
+    const channels = await this.scheme.getStorage().list();
+    return this.getIdleChannelsForRefundFromChannels(channels, idleSecs);
+  }
+  /**
+   * Submits a batch of voucher claims to the facilitator.
+   *
+   * @param claims - Voucher claims to send in one `type: "claim"` payload.
+   * @returns Per-batch claim summary (count and transaction hash).
+   */
+  async submitClaim(claims) {
+    const authorizerSigner = this.scheme.getReceiverAuthorizerSigner();
+    const claimAuthorizerSignature = authorizerSigner ? await signClaimBatch(authorizerSigner, claims, this.network) : void 0;
+    const paymentPayload = {
+      x402Version: 2,
+      accepted: this.buildPaymentRequirements(),
+      payload: {
+        type: "claim",
+        claims,
+        ...claimAuthorizerSignature ? { claimAuthorizerSignature } : {}
+      }
+    };
+    const response = await this.facilitator.settle(
+      paymentPayload,
+      this.buildPaymentRequirements()
+    );
+    if (!response.success) {
+      throw new Error(formatFacilitatorFailure("Claim", response));
+    }
+    return { vouchers: claims.length, transaction: response.transaction };
+  }
+  /**
+   * Builds a settlement payment payload for `settle(receiver, token)`.
+   *
+   * @returns Payload with `type: "settle"` and receiver/token fields.
+   */
+  buildSettlePaymentPayload() {
+    return {
+      x402Version: 2,
+      accepted: this.buildPaymentRequirements(),
+      payload: {
+        type: "settle",
+        receiver: this.receiver,
+        token: this.token
+      }
+    };
+  }
+  /**
+   * Builds a minimal {@link PaymentRequirements} for channel manager operations.
+   *
+   * @returns Requirements describing batched operations for this manager.
+   */
+  buildPaymentRequirements() {
+    return {
+      scheme: BATCH_SETTLEMENT_SCHEME,
+      network: this.network,
+      asset: this.token,
+      amount: "0",
+      payTo: this.receiver,
+      maxTimeoutSeconds: 0,
+      extra: {}
+    };
+  }
+  /**
+   * Updates session records after a successful claim submission so that
+   * `getClaimableVouchers` no longer returns already-claimed vouchers.
+   *
+   * @param claims - Voucher claims that were included in the submitted settlement transaction.
+   */
+  async updateClaimedSessions(claims) {
+    const storage = this.scheme.getStorage();
+    for (const claim of claims) {
+      const channelId = computeChannelId(claim.voucher.channel, this.network);
+      const channel = await storage.get(channelId);
+      if (!channel) {
+        continue;
+      }
+      const claimedAmount = BigInt(claim.totalClaimed);
+      if (claimedAmount <= BigInt(channel.totalClaimed)) {
+        continue;
+      }
+      await storage.updateChannel(channelId, (current) => {
+        if (!current || claimedAmount <= BigInt(current.totalClaimed)) {
+          return current;
+        }
+        return {
+          ...current,
+          totalClaimed: claimedAmount.toString()
+        };
+      });
+    }
+  }
+};
+
+// src/shared/defaultAssets.ts
+var DEFAULT_STABLECOINS = {
+  "eip155:8453": {
+    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Base mainnet USDC
+  "eip155:84532": {
+    address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    name: "USDC",
+    version: "2",
+    decimals: 6
+  },
+  // Base Sepolia USDC
+  "eip155:4326": {
+    address: "0xFAfDdbb3FC7688494971a79cc65DCa3EF82079E7",
+    name: "MegaUSD",
+    version: "1",
+    decimals: 18,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // MegaETH mainnet MegaUSD (no EIP-3009, supports EIP-2612)
+  "eip155:143": {
+    address: "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Monad mainnet USDC
+  "eip155:988": {
+    address: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    name: "USDT0",
+    version: "1",
+    decimals: 6
+  },
+  // Stable mainnet USDT0
+  "eip155:2201": {
+    address: "0x78Cf24370174180738C5B8E352B6D14c83a6c9A9",
+    name: "USDT0",
+    version: "1",
+    decimals: 6
+  },
+  // Stable testnet USDT0
+  "eip155:137": {
+    address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Polygon mainnet USDC
+  "eip155:42161": {
+    address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Arbitrum One USDC
+  "eip155:421614": {
+    address: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    name: "USD Coin",
+    version: "2",
+    decimals: 6
+  },
+  // Arbitrum Sepolia USDC
+  "eip155:31611": {
+    address: "0x118917a40FAF1CD7a13dB0Ef56C86De7973Ac503",
+    name: "Mezo USD",
+    version: "1",
+    decimals: 18,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // Mezo Testnet mUSD (no EIP-3009, supports EIP-2612)
+  "eip155:723487": {
+    address: "0x33ad9e4BD16B69B5BFdED37D8B5D9fF9aba014Fb",
+    name: "Stable Coin",
+    version: "1",
+    decimals: 6,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // Radius Network SBC (no EIP-3009, supports EIP-2612)
+  "eip155:72344": {
+    address: "0x33ad9e4BD16B69B5BFdED37D8B5D9fF9aba014Fb",
+    name: "Stable Coin",
+    version: "1",
+    decimals: 6,
+    assetTransferMethod: "permit2",
+    supportsEip2612: true
+  },
+  // Radius Testnet SBC (no EIP-3009, supports EIP-2612)
+  "eip155:36900": {
+    address: "0x9cb8142aEBBcdc60AF7c97Af897A67A8f3CA71C2",
+    name: "USDC.e",
+    version: "2",
+    decimals: 6
+  },
+  // ADI Chain USDC.e (EIP-3009 supported)
+  "eip155:190415": {
+    address: "0x401eCb1D350407f13ba348573E5630B83638E30D",
+    name: "Bridged USDC",
+    version: "2",
+    decimals: 6
+  },
+  // HPP mainnet USDC.e
+  "eip155:181228": {
+    address: "0x401eCb1D350407f13ba348573E5630B83638E30D",
+    name: "Bridged USDC",
+    version: "2",
+    decimals: 6
+  }
+  // HPP Sepolia USDC.e
+};
+function getDefaultAsset(network) {
+  const info = DEFAULT_STABLECOINS[network];
+  if (!info) {
+    throw new Error(`No default asset configured for network ${network}`);
+  }
+  return info;
+}
+
+// src/batch-settlement/server/storage.ts
+var InMemoryChannelStorage = class {
+  constructor() {
+    this.channels = /* @__PURE__ */ new Map();
+    this.channelLocks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Returns the channel record for a channel, if present.
+   *
+   * @param channelId - The channel identifier.
+   * @returns The channel record or undefined when not found.
+   */
+  async get(channelId) {
+    return this.channels.get(channelId.toLowerCase());
+  }
+  /**
+   * Lists all stored channel records.
+   *
+   * @returns All channel records in storage.
+   */
+  async list() {
+    return [...this.channels.values()];
+  }
+  /**
+   * Atomically inspects and mutates a channel record while holding a per-channel lock.
+   *
+   * @param channelId - The channel identifier.
+   * @param update - Mutation callback. Return `undefined` to delete, or `current` to leave unchanged.
+   * @returns The final stored channel and whether storage updated, stayed unchanged, or deleted.
+   */
+  async updateChannel(channelId, update) {
+    const key = channelId.toLowerCase();
+    return this.withChannelLock(key, async () => {
+      const current = this.channels.get(key);
+      const next = update(current);
+      if (next === current) {
+        return { channel: current, status: "unchanged" };
+      }
+      if (!next) {
+        this.channels.delete(key);
+        return { channel: void 0, status: current ? "deleted" : "unchanged" };
+      }
+      this.channels.set(key, next);
+      return { channel: next, status: "updated" };
+    });
+  }
+  /**
+   * Runs `fn` after any prior locked work for the same channel key has finished.
+   *
+   * @param key - Lowercased channel id used as the lock key.
+   * @param fn - Async work to run while holding the logical per-channel lock.
+   * @returns The resolved result of `fn`.
+   */
+  async withChannelLock(key, fn) {
+    const previous = this.channelLocks.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const next = previous.catch(() => {
+    }).then(() => current);
+    this.channelLocks.set(key, next);
+    await previous.catch(() => {
+    });
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (this.channelLocks.get(key) === next) {
+        this.channelLocks.delete(key);
+      }
+    }
+  }
+};
+
+// src/batch-settlement/server/verify.ts
+var import_viem6 = require("viem");
+
+// 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);
+}
+
+// src/batch-settlement/facilitator/utils.ts
+var import_viem5 = require("viem");
+
+// src/multicall.ts
+var import_viem4 = require("viem");
+
+// src/batch-settlement/errors.ts
+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 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 ErrRefundPayload = "invalid_batch_settlement_evm_refund_payload";
+var ErrCumulativeAmountMismatch = "invalid_batch_settlement_evm_cumulative_amount_mismatch";
+var ErrChannelBusy = "invalid_batch_settlement_evm_channel_busy";
+var ErrChargeExceedsSignedCumulative = "invalid_batch_settlement_evm_charge_exceeds_signed_cumulative";
+var ErrMissingChannel = "invalid_batch_settlement_evm_missing_channel";
+var ErrRefundNoBalance = "invalid_batch_settlement_evm_refund_no_balance";
+var ErrRefundAmountInvalid = "invalid_batch_settlement_evm_refund_amount_invalid";
+
+// src/batch-settlement/facilitator/utils.ts
+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;
+}
+
+// src/batch-settlement/server/utils.ts
+function readChannelStateExtra(extra) {
+  const value = extra?.channelState;
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  return value;
+}
+function readExtraString(extra, key, fallback) {
+  const value = extra?.[key];
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  return fallback;
+}
+function readExtraNumber(extra, key, fallback) {
+  const value = extra?.[key];
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return parseInt(value, 10) || fallback;
+  return fallback;
+}
+function parseRefundSettlementSnapshot(extra) {
+  const channelState = readChannelStateExtra(extra);
+  return {
+    balance: parseUintStringExtra(channelState, "balance"),
+    totalClaimed: parseUintStringExtra(channelState, "totalClaimed"),
+    withdrawRequestedAt: parseUintNumberExtra(channelState, "withdrawRequestedAt"),
+    refundNonce: parseUintNumberExtra(channelState, "refundNonce")
+  };
+}
+function parseUintStringExtra(extra, key) {
+  const value = extra?.[key];
+  if (typeof value === "string" && /^\d+$/.test(value)) return value;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0) return String(value);
+  throw new Error(ErrRefundPayload);
+}
+function parseUintNumberExtra(extra, key) {
+  const value = extra?.[key];
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    const parsed = parseInt(value, 10);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  throw new Error(ErrRefundPayload);
+}
+
+// src/batch-settlement/server/verify.ts
+var MIN_PENDING_TTL_MS = 5e3;
+var MAX_PENDING_TTL_MS = 10 * 60 * 1e3;
+function pendingExpiresAt(maxTimeoutSeconds, now) {
+  const requestedMs = Math.max(0, maxTimeoutSeconds ?? 0) * 1e3;
+  const ttlMs = Math.min(MAX_PENDING_TTL_MS, Math.max(MIN_PENDING_TTL_MS, requestedMs));
+  return now + ttlMs;
+}
+function isPendingLive(pending, now) {
+  return pending !== void 0 && pending.expiresAt > now;
+}
+async function handleBeforeVerify(scheme, ctx) {
+  const { paymentPayload, requirements } = ctx;
+  const raw = paymentPayload.payload;
+  const isPaidPayload = isBatchSettlementVoucherPayload(raw) || isBatchSettlementDepositPayload(raw);
+  const isZeroChargePayload = isBatchSettlementRefundPayload(raw);
+  if (!isPaidPayload && !isZeroChargePayload) {
+    return;
+  }
+  const channelId = raw.voucher.channelId;
+  const now = Date.now();
+  const pendingId = createNonce();
+  let outcome;
+  await scheme.getStorage().updateChannel(channelId, (current) => {
+    if (isPendingLive(current?.pendingRequest, now)) {
+      outcome = { status: "busy" };
+      return current;
+    }
+    const chargedCumulativeAmount = current?.chargedCumulativeAmount ?? inferMissingLocalChargedAmount(
+      raw.voucher.maxClaimableAmount,
+      requirements.amount,
+      isPaidPayload
+    );
+    const expectedMaxClaimable = isZeroChargePayload ? BigInt(chargedCumulativeAmount) : BigInt(chargedCumulativeAmount) + BigInt(requirements.amount);
+    if (BigInt(raw.voucher.maxClaimableAmount) !== expectedMaxClaimable) {
+      if (current) {
+        outcome = { status: "mismatch", channel: current };
+      } else {
+        outcome = {
+          status: "mismatch",
+          channel: buildProvisionalChannel(raw, chargedCumulativeAmount)
+        };
+      }
+      return current;
+    }
+    const pendingRequest = {
+      pendingId,
+      signedMaxClaimable: raw.voucher.maxClaimableAmount,
+      expiresAt: pendingExpiresAt(requirements.maxTimeoutSeconds, now)
+    };
+    outcome = { status: "reserved", channelSnapshot: current };
+    return {
+      ...current ?? buildProvisionalChannel(raw, chargedCumulativeAmount),
+      pendingRequest,
+      lastRequestTimestamp: now
+    };
+  });
+  if (outcome?.status === "busy") {
+    return {
+      abort: true,
+      reason: ErrChannelBusy,
+      message: "Channel is already processing a request"
+    };
+  }
+  if (outcome?.status === "mismatch") {
+    scheme.rememberChannelSnapshot(paymentPayload, outcome.channel);
+    return {
+      abort: true,
+      reason: ErrCumulativeAmountMismatch,
+      message: "Client voucher base does not match server state"
+    };
+  }
+  if (outcome?.status === "reserved") {
+    scheme.mergeRequestContext(paymentPayload, {
+      channelId,
+      pendingId,
+      channelSnapshot: outcome.channelSnapshot
+    });
+    if (isBatchSettlementVoucherPayload(raw)) {
+      const localResult = await verifyVoucherLocally(
+        scheme,
+        raw,
+        requirements,
+        outcome.channelSnapshot,
+        now
+      );
+      if (localResult) {
+        scheme.mergeRequestContext(paymentPayload, { localVerify: true });
+        return { skip: true, result: localResult };
+      }
+    }
+  }
+}
+async function handleEnrichPaymentRequiredResponse(scheme, ctx) {
+  if (ctx.error !== ErrCumulativeAmountMismatch) {
+    return;
+  }
+  const { paymentPayload } = ctx;
+  if (!paymentPayload) {
+    return;
+  }
+  const raw = paymentPayload.payload;
+  if (!isBatchSettlementVoucherPayload(raw) && !isBatchSettlementDepositPayload(raw) && !isBatchSettlementRefundPayload(raw)) {
+    return;
+  }
+  const channel = scheme.takeChannelSnapshot(paymentPayload) ?? await scheme.getStorage().get(raw.voucher.channelId);
+  if (!channel) {
+    return;
+  }
+  const accept = ctx.requirements.find(
+    (req) => req.scheme === BATCH_SETTLEMENT_SCHEME && req.network === paymentPayload.accepted.network
+  );
+  if (!accept) {
+    return;
+  }
+  accept.extra = {
+    ...accept.extra,
+    channelState: {
+      channelId: channel.channelId,
+      balance: channel.balance,
+      totalClaimed: channel.totalClaimed,
+      withdrawRequestedAt: channel.withdrawRequestedAt,
+      refundNonce: String(channel.refundNonce),
+      chargedCumulativeAmount: channel.chargedCumulativeAmount
+    },
+    voucherState: {
+      signedMaxClaimable: channel.signedMaxClaimable,
+      signature: channel.signature
+    }
+  };
+}
+async function handleAfterVerify(scheme, ctx) {
+  const { paymentPayload, result } = ctx;
+  if (!result.isValid || !result.payer) {
+    await scheme.clearPendingRequest(paymentPayload);
+    return;
+  }
+  const raw = paymentPayload.payload;
+  let channelId;
+  let signedMaxClaimable;
+  let signature;
+  let channelConfig;
+  let isRefundVoucher = false;
+  if (isBatchSettlementDepositPayload(raw)) {
+    channelId = raw.voucher.channelId;
+    signedMaxClaimable = raw.voucher.maxClaimableAmount;
+    signature = raw.voucher.signature;
+    channelConfig = raw.channelConfig;
+  } else if (isBatchSettlementVoucherPayload(raw)) {
+    channelId = raw.voucher.channelId;
+    signedMaxClaimable = raw.voucher.maxClaimableAmount;
+    signature = raw.voucher.signature;
+    channelConfig = raw.channelConfig;
+  } else if (isBatchSettlementRefundPayload(raw)) {
+    channelId = raw.voucher.channelId;
+    signedMaxClaimable = raw.voucher.maxClaimableAmount;
+    signature = raw.voucher.signature;
+    channelConfig = raw.channelConfig;
+    isRefundVoucher = true;
+  } else {
+    return;
+  }
+  const ex = result.extra ?? {};
+  const balance = readExtraString(ex, "balance", "0");
+  const totalClaimed = readExtraString(ex, "totalClaimed", "0");
+  const withdrawRequestedAt = readExtraNumber(ex, "withdrawRequestedAt", 0);
+  const refundNonce = readExtraNumber(ex, "refundNonce", 0);
+  const now = Date.now();
+  const storage = scheme.getStorage();
+  const requestContext = scheme.readRequestContext(paymentPayload);
+  if (!requestContext?.pendingId) {
+    return;
+  }
+  if (requestContext.localVerify && isBatchSettlementVoucherPayload(raw)) {
+    return;
+  }
+  const updateResult = await storage.updateChannel(channelId, (current) => {
+    if (!current || current.pendingRequest?.pendingId !== requestContext.pendingId) {
+      return current;
+    }
+    const channel = {
+      channelId,
+      channelConfig,
+      chargedCumulativeAmount: current.chargedCumulativeAmount,
+      signedMaxClaimable,
+      signature,
+      balance,
+      totalClaimed,
+      withdrawRequestedAt,
+      refundNonce,
+      onchainSyncedAt: requestContext.localVerify ? current.onchainSyncedAt : now,
+      lastRequestTimestamp: now,
+      pendingRequest: current.pendingRequest
+    };
+    return channel;
+  });
+  if (updateResult.status === "updated" && updateResult.channel) {
+    scheme.rememberChannelSnapshot(paymentPayload, updateResult.channel);
+  }
+  if (isRefundVoucher && updateResult.status === "updated") {
+    return {
+      skipHandler: true,
+      response: {
+        contentType: "application/json",
+        body: { message: "Refund acknowledged", channelId }
+      }
+    };
+  }
+}
+async function handleVerifyFailure(scheme, ctx) {
+  await scheme.clearPendingRequest(ctx.paymentPayload);
+}
+async function handleVerifiedPaymentCanceled(scheme, ctx) {
+  if (ctx.reason !== "handler_threw" && ctx.reason !== "handler_failed") {
+    return;
+  }
+  await scheme.clearPendingRequest(ctx.paymentPayload);
+}
+async function verifyVoucherLocally(scheme, raw, requirements, channel, now) {
+  if (!channel || !isOnchainStateFresh(channel, scheme.getOnchainStateTtlMs(), now)) {
+    return;
+  }
+  if (raw.channelConfig.payerAuthorizer === "0x0000000000000000000000000000000000000000") {
+    return;
+  }
+  const payer = raw.channelConfig.payer;
+  const configErr = validateChannelConfig(
+    raw.channelConfig,
+    raw.voucher.channelId,
+    requirements
+  );
+  if (configErr) {
+    return invalidVerifyResponse(payer, configErr);
+  }
+  if (computeChannelId(raw.channelConfig, requirements.network).toLowerCase() !== channel.channelId.toLowerCase()) {
+    return invalidVerifyResponse(payer, ErrChannelIdMismatch);
+  }
+  const signatureOk = await verifyLocalVoucherSignature(raw, requirements.network);
+  if (!signatureOk) {
+    return invalidVerifyResponse(payer, ErrInvalidVoucherSignature);
+  }
+  const maxClaimableAmount = BigInt(raw.voucher.maxClaimableAmount);
+  if (maxClaimableAmount > BigInt(channel.balance)) {
+    return invalidVerifyResponse(payer, ErrCumulativeExceedsBalance);
+  }
+  if (maxClaimableAmount <= BigInt(channel.totalClaimed)) {
+    return invalidVerifyResponse(payer, ErrCumulativeAmountBelowClaimed);
+  }
+  return {
+    isValid: true,
+    payer,
+    extra: {
+      channelId: raw.voucher.channelId,
+      balance: channel.balance,
+      totalClaimed: channel.totalClaimed,
+      withdrawRequestedAt: channel.withdrawRequestedAt,
+      refundNonce: channel.refundNonce.toString()
+    }
+  };
+}
+function isOnchainStateFresh(channel, ttlMs, now) {
+  return channel.onchainSyncedAt !== void 0 && now - channel.onchainSyncedAt <= ttlMs;
+}
+async function verifyLocalVoucherSignature(raw, network) {
+  try {
+    return await (0, import_viem6.verifyTypedData)({
+      address: (0, import_viem6.getAddress)(raw.channelConfig.payerAuthorizer),
+      domain: getBatchSettlementEip712Domain(getEvmChainId(network)),
+      types: voucherTypes,
+      primaryType: "Voucher",
+      message: {
+        channelId: raw.voucher.channelId,
+        maxClaimableAmount: BigInt(raw.voucher.maxClaimableAmount)
+      },
+      signature: raw.voucher.signature
+    });
+  } catch {
+    return false;
+  }
+}
+function invalidVerifyResponse(payer, invalidReason) {
+  return { isValid: false, invalidReason, payer };
+}
+function buildProvisionalChannel(raw, chargedCumulativeAmount) {
+  return {
+    channelId: raw.voucher.channelId,
+    channelConfig: raw.channelConfig,
+    chargedCumulativeAmount,
+    signedMaxClaimable: raw.voucher.maxClaimableAmount,
+    signature: raw.voucher.signature,
+    balance: "0",
+    totalClaimed: "0",
+    withdrawRequestedAt: 0,
+    refundNonce: 0,
+    lastRequestTimestamp: Date.now()
+  };
+}
+function inferMissingLocalChargedAmount(signedMaxClaimable, price, isPaidPayload) {
+  if (!isPaidPayload) {
+    return signedMaxClaimable;
+  }
+  const signed = BigInt(signedMaxClaimable);
+  const amount = BigInt(price);
+  if (signed < amount) {
+    return "0";
+  }
+  return (signed - amount).toString();
+}
+
+// src/batch-settlement/server/settle.ts
+function channelStateExtra(channel, chargedCumulativeAmount) {
+  return {
+    channelId: channel.channelId,
+    balance: channel.balance,
+    totalClaimed: channel.totalClaimed,
+    withdrawRequestedAt: channel.withdrawRequestedAt,
+    refundNonce: String(channel.refundNonce),
+    ...chargedCumulativeAmount !== void 0 ? { chargedCumulativeAmount } : {}
+  };
+}
+async function handleBeforeSettle(scheme, ctx) {
+  const { paymentPayload, requirements } = ctx;
+  const raw = paymentPayload.payload;
+  const storage = scheme.getStorage();
+  if (!isBatchSettlementVoucherPayload(raw)) {
+    return;
+  }
+  const { voucher } = raw;
+  const channelId = voucher.channelId;
+  const pendingId = scheme.readRequestContext(paymentPayload)?.pendingId;
+  const increment = BigInt(requirements.amount);
+  const signedCap = BigInt(voucher.maxClaimableAmount);
+  let outcome;
+  const updateResult = await storage.updateChannel(channelId, (current) => {
+    if (!current) {
+      outcome = { status: "missing" };
+      return current;
+    }
+    if (!pendingId || current.pendingRequest?.pendingId !== pendingId) {
+      outcome = { status: "pending_mismatch" };
+      return current;
+    }
+    const newCharged = BigInt(current.chargedCumulativeAmount) + increment;
+    if (newCharged > signedCap) {
+      outcome = { status: "cap_exceeded", charged: newCharged.toString() };
+      return {
+        ...current,
+        pendingRequest: void 0
+      };
+    }
+    const updatedChannel = {
+      ...current,
+      chargedCumulativeAmount: newCharged.toString(),
+      signedMaxClaimable: voucher.maxClaimableAmount,
+      signature: voucher.signature,
+      lastRequestTimestamp: Date.now(),
+      pendingRequest: void 0
+    };
+    outcome = { status: "committed", previous: current, current: updatedChannel };
+    return updatedChannel;
+  });
+  if (outcome?.status === "missing") {
+    scheme.takeRequestContext(paymentPayload);
+    return {
+      abort: true,
+      reason: ErrMissingChannel,
+      message: "No channel record"
+    };
+  }
+  if (outcome?.status === "cap_exceeded") {
+    scheme.takeRequestContext(paymentPayload);
+    return {
+      abort: true,
+      reason: ErrChargeExceedsSignedCumulative,
+      message: `Charged ${outcome.charged} exceeds signed max ${signedCap.toString()}`
+    };
+  }
+  if (updateResult.status !== "updated" || outcome?.status !== "committed") {
+    scheme.takeRequestContext(paymentPayload);
+    return {
+      abort: true,
+      reason: ErrChannelBusy,
+      message: "Concurrent request modified channel state"
+    };
+  }
+  scheme.takeRequestContext(paymentPayload);
+  const skipExtra = {
+    channelState: channelStateExtra(outcome.previous, outcome.current.chargedCumulativeAmount),
+    chargedAmount: requirements.amount
+  };
+  return {
+    skip: true,
+    result: {
+      success: true,
+      payer: outcome.previous.channelConfig.payer.toLowerCase(),
+      transaction: "",
+      network: requirements.network,
+      amount: "",
+      extra: skipExtra
+    }
+  };
+}
+async function handleEnrichSettlementPayload(scheme, ctx) {
+  const { paymentPayload, requirements } = ctx;
+  const raw = paymentPayload.payload;
+  if (!isBatchSettlementRefundPayload(raw)) {
+    return;
+  }
+  const channelId = computeChannelId(raw.channelConfig, requirements.network);
+  if (raw.voucher.channelId !== channelId) {
+    throw new Error("refund channelId does not match channelConfig");
+  }
+  const channel = await scheme.getStorage().get(channelId);
+  if (!channel) {
+    throw new Error(ErrMissingChannel);
+  }
+  const pendingId = scheme.readRequestContext(paymentPayload)?.pendingId;
+  if (!pendingId || channel.pendingRequest?.pendingId !== pendingId) {
+    throw new Error(ErrChannelBusy);
+  }
+  if (BigInt(raw.voucher.maxClaimableAmount) !== BigInt(channel.chargedCumulativeAmount)) {
+    throw new Error(ErrCumulativeAmountMismatch);
+  }
+  if (raw.voucher.signature !== channel.signature) {
+    throw new Error(ErrInvalidVoucherSignature);
+  }
+  const config = raw.channelConfig;
+  const claimEntry = {
+    voucher: {
+      channel: config,
+      maxClaimableAmount: raw.voucher.maxClaimableAmount
+    },
+    signature: raw.voucher.signature,
+    totalClaimed: channel.chargedCumulativeAmount
+  };
+  const remainder = BigInt(channel.balance) - BigInt(channel.chargedCumulativeAmount);
+  if (remainder <= 0n) {
+    throw new Error(ErrRefundNoBalance);
+  }
+  let refundAmountBig = remainder;
+  if (raw.amount !== void 0) {
+    if (!/^\d+$/.test(raw.amount)) {
+      throw new Error(ErrRefundAmountInvalid);
+    }
+    const requested = BigInt(raw.amount);
+    if (requested <= 0n) {
+      throw new Error(ErrRefundAmountInvalid);
+    }
+    refundAmountBig = requested;
+  }
+  const refundAmount = refundAmountBig.toString();
+  const nonce = String(channel.refundNonce ?? 0);
+  const receiverAuthorizerSigner = scheme.getReceiverAuthorizerSigner();
+  const refundAuthorizerSignature = receiverAuthorizerSigner ? await signRefund(
+    receiverAuthorizerSigner,
+    channelId,
+    refundAmount,
+    nonce,
+    requirements.network
+  ) : void 0;
+  const claimAuthorizerSignature = receiverAuthorizerSigner ? await signClaimBatch(receiverAuthorizerSigner, [claimEntry], requirements.network) : void 0;
+  scheme.rememberChannelSnapshot(paymentPayload, channel);
+  return {
+    ...raw.amount === void 0 ? { amount: refundAmount } : {},
+    refundNonce: nonce,
+    claims: [claimEntry],
+    refundAuthorizerSignature,
+    claimAuthorizerSignature
+  };
+}
+async function handleAfterSettle(scheme, ctx) {
+  const { paymentPayload, requirements, result } = ctx;
+  if (!result.success) {
+    return;
+  }
+  const raw = paymentPayload.payload;
+  const storage = scheme.getStorage();
+  if (isBatchSettlementRefundPayload(raw)) {
+    const channelId = computeChannelId(raw.channelConfig, requirements.network);
+    const pendingId = scheme.readRequestContext(paymentPayload)?.pendingId;
+    const now = Date.now();
+    const snapshot = parseRefundSettlementSnapshot(result.extra);
+    const updateResult = await storage.updateChannel(channelId, (current) => {
+      if (!current) {
+        return current;
+      }
+      if (!pendingId || current.pendingRequest?.pendingId !== pendingId) {
+        return current;
+      }
+      if (BigInt(snapshot.balance) <= BigInt(current.chargedCumulativeAmount)) {
+        return void 0;
+      }
+      return {
+        ...current,
+        ...snapshot,
+        onchainSyncedAt: now,
+        lastRequestTimestamp: now,
+        pendingRequest: void 0
+      };
+    });
+    if (updateResult.status === "unchanged") {
+      throw new Error(ErrChannelBusy);
+    }
+    if (!updateResult.channel) {
+      return;
+    }
+    return;
+  }
+  if (isBatchSettlementVoucherPayload(raw)) {
+    return;
+  }
+  if (isBatchSettlementDepositPayload(raw)) {
+    const channelId = raw.voucher.channelId;
+    const pendingId = scheme.readRequestContext(paymentPayload)?.pendingId;
+    const ex = result.extra ?? {};
+    const channelState = readChannelStateExtra(ex);
+    const config = raw.channelConfig;
+    const signedMaxClaimable = raw.voucher.maxClaimableAmount;
+    const now = Date.now();
+    const updateResult = await storage.updateChannel(channelId, (current) => {
+      if (!current) {
+        return current;
+      }
+      if (!pendingId || current.pendingRequest?.pendingId !== pendingId) {
+        return current;
+      }
+      const chargedActual = (BigInt(current.chargedCumulativeAmount) + BigInt(requirements.amount)).toString();
+      return {
+        channelId,
+        channelConfig: config,
+        chargedCumulativeAmount: chargedActual,
+        signedMaxClaimable,
+        signature: raw.voucher.signature,
+        balance: readExtraString(channelState, "balance", current.balance),
+        totalClaimed: readExtraString(channelState, "totalClaimed", current.totalClaimed),
+        withdrawRequestedAt: readExtraNumber(
+          channelState,
+          "withdrawRequestedAt",
+          current.withdrawRequestedAt
+        ),
+        refundNonce: readExtraNumber(channelState, "refundNonce", current.refundNonce),
+        onchainSyncedAt: now,
+        lastRequestTimestamp: now
+      };
+    });
+    if (updateResult.status === "updated" && updateResult.channel) {
+      scheme.rememberChannelSnapshot(paymentPayload, updateResult.channel);
+      return;
+    }
+    scheme.takeRequestContext(paymentPayload);
+    throw new Error(ErrChannelBusy);
+  }
+}
+async function handleSettleFailure(scheme, ctx) {
+  await scheme.clearPendingRequest(ctx.paymentPayload);
+}
+async function handleEnrichSettlementResponse(scheme, ctx) {
+  const raw = ctx.paymentPayload.payload;
+  if (isBatchSettlementVoucherPayload(raw)) {
+    return;
+  }
+  const channel = scheme.takeChannelSnapshot(ctx.paymentPayload);
+  if (!channel) {
+    return;
+  }
+  if (isBatchSettlementRefundPayload(raw)) {
+    return {
+      channelState: {
+        chargedCumulativeAmount: channel.chargedCumulativeAmount
+      }
+    };
+  }
+  if (isBatchSettlementDepositPayload(raw)) {
+    return {
+      channelState: {
+        chargedCumulativeAmount: channel.chargedCumulativeAmount
+      },
+      chargedAmount: ctx.requirements.amount
+    };
+  }
+  return {
+    channelState: {
+      chargedCumulativeAmount: channel.chargedCumulativeAmount
+    }
+  };
+}
+
+// src/batch-settlement/server/scheme.ts
+var BatchSettlementEvmScheme = class {
+  /**
+   * Constructs a batched server scheme.
+   *
+   * @param receiverAddress - The server's receiver address (payTo).
+   * @param config - Optional configuration for storage, receiver-authorizer signer, and withdraw delay.
+   */
+  constructor(receiverAddress, config) {
+    this.scheme = BATCH_SETTLEMENT_SCHEME;
+    this.requestContexts = /* @__PURE__ */ new WeakMap();
+    this.moneyParsers = [];
+    /**
+     * Adds server-owned settlement fields before facilitator settlement.
+     *
+     * @param ctx - Settlement context for the current payment.
+     * @returns Additive payload fields, or nothing when no enrichment is needed.
+     */
+    this.enrichSettlementPayload = (ctx) => handleEnrichSettlementPayload(this, ctx);
+    /**
+     * Adds corrective channel state to payment-required responses when available.
+     *
+     * @param ctx - Payment-required response context for the current request.
+     * @returns Updated payment requirements, or nothing when no enrichment is needed.
+     */
+    this.enrichPaymentRequiredResponse = (ctx) => handleEnrichPaymentRequiredResponse(this, ctx);
+    /**
+     * Adds server-owned extra fields after facilitator settlement.
+     *
+     * @param ctx - Settlement result context for the current payment.
+     * @returns Additive response extra fields, or nothing when no enrichment is needed.
+     */
+    this.enrichSettlementResponse = (ctx) => handleEnrichSettlementResponse(this, ctx);
+    this.receiverAddress = receiverAddress;
+    this.storage = config?.storage ?? new InMemoryChannelStorage();
+    this.receiverAuthorizerSigner = config?.receiverAuthorizerSigner;
+    this.withdrawDelay = config?.withdrawDelay ?? MIN_WITHDRAW_DELAY;
+    this.onchainStateTtlMs = config?.onchainStateTtlMs ?? defaultOnchainStateTtlMs(this.withdrawDelay);
+    this.schemeHooks = {
+      onBeforeVerify: (ctx) => handleBeforeVerify(this, ctx),
+      onAfterVerify: (ctx) => handleAfterVerify(this, ctx),
+      onBeforeSettle: (ctx) => handleBeforeSettle(this, ctx),
+      onAfterSettle: (ctx) => handleAfterSettle(this, ctx),
+      onVerifyFailure: (ctx) => handleVerifyFailure(this, ctx),
+      onSettleFailure: (ctx) => handleSettleFailure(this, ctx),
+      onVerifiedPaymentCanceled: (ctx) => handleVerifiedPaymentCanceled(this, ctx)
+    };
+  }
+  /**
+   * Merges batch-settlement state into the current request context.
+   *
+   * @param payload - Request-scoped payment payload object.
+   * @param context - Partial context fields to merge.
+   */
+  mergeRequestContext(payload, context) {
+    this.requestContexts.set(payload, {
+      ...this.requestContexts.get(payload),
+      ...context
+    });
+  }
+  /**
+   * Reads batch-settlement state for the current request without clearing it.
+   *
+   * @param payload - Request-scoped payment payload object.
+   * @returns Request context, if one was recorded.
+   */
+  readRequestContext(payload) {
+    return this.requestContexts.get(payload);
+  }
+  /**
+   * Reads and clears batch-settlement state for the current request.
+   *
+   * @param payload - Request-scoped payment payload object.
+   * @returns Request context, if one was recorded.
+   */
+  takeRequestContext(payload) {
+    const context = this.requestContexts.get(payload);
+    this.requestContexts.delete(payload);
+    return context;
+  }
+  /**
+   * Stores a channel snapshot for the current settlement request.
+   *
+   * @param payload - Request-scoped payment payload object.
+   * @param channel - Channel state to use during response enrichment.
+   */
+  rememberChannelSnapshot(payload, channel) {
+    this.mergeRequestContext(payload, {
+      channelId: channel.channelId,
+      channelSnapshot: channel
+    });
+  }
+  /**
+   * Reads and clears a channel snapshot for the current settlement request.
+   *
+   * @param payload - Request-scoped payment payload object.
+   * @returns Stored channel state, if one was recorded.
+   */
+  takeChannelSnapshot(payload) {
+    return this.takeRequestContext(payload)?.channelSnapshot;
+  }
+  /**
+   * Clears this request's pending reservation without touching newer reservations.
+   *
+   * @param payload - Request-scoped payment payload object.
+   */
+  async clearPendingRequest(payload) {
+    const context = this.takeRequestContext(payload);
+    if (!context?.channelId || !context.pendingId) {
+      return;
+    }
+    await this.storage.updateChannel(context.channelId, (current) => {
+      if (!current || current.pendingRequest?.pendingId !== context.pendingId) {
+        return current;
+      }
+      if (!context.channelSnapshot) {
+        return void 0;
+      }
+      return {
+        ...current,
+        pendingRequest: void 0
+      };
+    });
+  }
+  /**
+   * Registers a custom money parser for converting price strings to token amounts.
+   *
+   * @param parser - A parser function to try before the default USD→token conversion.
+   * @returns `this` for chaining.
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Resolves a human-readable price (e.g. `"$0.01"`) into an onchain token amount.
+   *
+   * @param price - A price string, number, or explicit {@link AssetAmount}.
+   * @param network - CAIP-2 network identifier for looking up the default asset.
+   * @returns Token amount with asset address and metadata.
+   */
+  async parsePrice(price, network) {
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        throw new Error(`Asset address must be specified for AssetAmount on network ${network}`);
+      }
+      return {
+        amount: price.amount,
+        asset: price.asset,
+        extra: price.extra || {}
+      };
+    }
+    const amount = this.parseMoneyToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(amount, network);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return this.defaultMoneyConversion(amount, network);
+  }
+  /**
+   * Injects batched-specific fields into the payment requirements returned to
+   * the client (receiverAuthorizer, withdrawDelay, EIP-712 domain info).
+   *
+   * @param paymentRequirements - Base payment requirements from the middleware.
+   * @param supportedKind - Matched scheme/network kind (extra may contain overrides).
+   * @param supportedKind.x402Version - Protocol version from the matched kind.
+   * @param supportedKind.scheme - Scheme name from the matched kind.
+   * @param supportedKind.network - Network identifier from the matched kind.
+   * @param supportedKind.extra - Optional extra fields on the matched kind.
+   * @param _extensionKeys - Extension keys (unused).
+   * @returns Enhanced payment requirements with batched fields in `extra`.
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, _extensionKeys) {
+    void _extensionKeys;
+    const assetInfo = getDefaultAsset(paymentRequirements.network);
+    const receiverAuthorizer = this.receiverAuthorizerSigner?.address ?? (typeof supportedKind.extra?.receiverAuthorizer === "string" ? supportedKind.extra.receiverAuthorizer : void 0);
+    if (!receiverAuthorizer || (0, import_viem7.getAddress)(receiverAuthorizer) === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Payment requirements must include a non-zero extra.receiverAuthorizer");
+    }
+    return {
+      ...paymentRequirements,
+      extra: {
+        ...paymentRequirements.extra,
+        receiverAuthorizer: (0, import_viem7.getAddress)(receiverAuthorizer),
+        withdrawDelay: this.withdrawDelay,
+        name: assetInfo.name,
+        version: assetInfo.version,
+        assetTransferMethod: paymentRequirements.extra?.assetTransferMethod ?? assetInfo.assetTransferMethod
+      }
+    };
+  }
+  /**
+   * Returns the underlying channel storage instance.
+   *
+   * @returns The configured {@link ChannelStorage} backend.
+   */
+  getStorage() {
+    return this.storage;
+  }
+  /**
+   * Returns the server's receiver address.
+   *
+   * @returns Receiver wallet address for the payment channel.
+   */
+  getReceiverAddress() {
+    return this.receiverAddress;
+  }
+  /**
+   * Returns the configured withdraw delay (seconds).
+   *
+   * @returns Withdraw delay in seconds before uncooperative withdrawal is allowed.
+   */
+  getWithdrawDelay() {
+    return this.withdrawDelay;
+  }
+  /**
+   * Returns how long mirrored onchain channel state is trusted for local voucher verification.
+   *
+   * @returns Freshness window in milliseconds.
+   */
+  getOnchainStateTtlMs() {
+    return this.onchainStateTtlMs;
+  }
+  /**
+   * Returns the receiver-authorizer signer, if configured.
+   *
+   * @returns Receiver-authorizer signer, or `undefined` when not set.
+   */
+  getReceiverAuthorizerSigner() {
+    return this.receiverAuthorizerSigner;
+  }
+  /**
+   * Creates a {@link BatchSettlementChannelManager} pre-configured with this scheme's
+   * receiver, default token for the given network, and the provided facilitator.
+   *
+   * @param facilitator - Facilitator client for submitting onchain claims/settlements.
+   * @param network - CAIP-2 network identifier (e.g. `"eip155:84532"`).
+   * @returns A ready-to-use channel manager.
+   */
+  createChannelManager(facilitator, network) {
+    const token = getDefaultAsset(network).address;
+    return new BatchSettlementChannelManager({
+      scheme: this,
+      facilitator,
+      receiver: this.receiverAddress,
+      token,
+      network
+    });
+  }
+  /**
+   * Parses a human-readable money string (e.g. `"$1.50"`) into a decimal number.
+   *
+   * @param money - Money string (may include `$`) or numeric amount.
+   * @returns Parsed finite number.
+   */
+  parseMoneyToDecimal(money) {
+    if (typeof money === "number") {
+      return money;
+    }
+    const cleanMoney = money.replace(/^\$/, "").trim();
+    const amount = parseFloat(cleanMoney);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid money format: ${money}`);
+    }
+    return amount;
+  }
+  /**
+   * Converts a decimal dollar amount to the network's default token amount.
+   *
+   * @param amount - Decimal amount in display units.
+   * @param network - Target chain/network for default asset resolution.
+   * @returns {@link AssetAmount} with integer token amount, contract address, and metadata.
+   */
+  defaultMoneyConversion(amount, network) {
+    const assetInfo = getDefaultAsset(network);
+    const tokenAmount = (0, import_utils12.convertToTokenAmount)((0, import_utils12.numberToDecimalString)(amount), assetInfo.decimals);
+    return {
+      amount: tokenAmount,
+      asset: assetInfo.address,
+      extra: {
+        name: assetInfo.name,
+        version: assetInfo.version
+      }
+    };
+  }
+};
+function defaultOnchainStateTtlMs(withdrawDelaySeconds) {
+  const withdrawDelayMs = Math.max(0, withdrawDelaySeconds) * 1e3;
+  return Math.min(5 * 60 * 1e3, Math.max(30 * 1e3, Math.floor(withdrawDelayMs / 3)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchSettlementChannelManager,
+  BatchSettlementEvmScheme,
+  InMemoryChannelStorage
+});
+//# sourceMappingURL=index.js.map