@payai/x402-evm 2.4.0 → 2.4.2

package/dist/esm/batch-settlement/server/index.mjs

@@ -0,0 +1,1645 @@
+import {
+  signClaimBatch,
+  signRefund,
+  validateChannelConfig
+} from "../../chunk-IN5YIT5C.mjs";
+import {
+  BATCH_SETTLEMENT_SCHEME,
+  ErrChannelBusy,
+  ErrChannelIdMismatch,
+  ErrChargeExceedsSignedCumulative,
+  ErrCumulativeAmountBelowClaimed,
+  ErrCumulativeAmountMismatch,
+  ErrCumulativeExceedsBalance,
+  ErrInvalidVoucherSignature,
+  ErrMissingChannel,
+  ErrRefundAmountInvalid,
+  ErrRefundNoBalance,
+  ErrRefundPayload,
+  MIN_WITHDRAW_DELAY,
+  computeChannelId,
+  getBatchSettlementEip712Domain,
+  voucherTypes
+} from "../../chunk-HYABYUBD.mjs";
+import {
+  getDefaultAsset
+} from "../../chunk-BTYNCDNS.mjs";
+import {
+  isBatchSettlementDepositPayload,
+  isBatchSettlementRefundPayload,
+  isBatchSettlementVoucherPayload
+} from "../../chunk-U4HCGTLU.mjs";
+import "../../chunk-VS3RYAYE.mjs";
+import {
+  createNonce,
+  getEvmChainId
+} from "../../chunk-TW7Z65AO.mjs";
+
+// src/batch-settlement/server/scheme.ts
+import { convertToTokenAmount, numberToDecimalString } from "@payai/x402/utils";
+import { getAddress as getAddress2 } from "viem";
+
+// 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/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
+import { getAddress, verifyTypedData } from "viem";
+
+// 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 verifyTypedData({
+      address: 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 || getAddress2(receiverAuthorizer) === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Payment requirements must include a non-zero extra.receiverAuthorizer");
+    }
+    return {
+      ...paymentRequirements,
+      extra: {
+        ...paymentRequirements.extra,
+        receiverAuthorizer: getAddress2(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 = convertToTokenAmount(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)));
+}
+export {
+  BatchSettlementChannelManager,
+  BatchSettlementEvmScheme,
+  InMemoryChannelStorage
+};
+//# sourceMappingURL=index.mjs.map