@payai/x402-evm 2.4.1 → 2.4.3

package/dist/esm/chunk-NKYVYGRA.mjs

@@ -0,0 +1,911 @@
+import {
+  buildErc3009DepositNonce
+} from "./chunk-W6ON4LG2.mjs";
+import {
+  BATCH_SETTLEMENT_ADDRESS,
+  BATCH_SETTLEMENT_SCHEME,
+  ERC3009_DEPOSIT_COLLECTOR_ADDRESS,
+  ErrCumulativeAmountBelowClaimed,
+  ErrCumulativeAmountMismatch,
+  ErrRefundAmountInvalid,
+  ErrRefundNoBalance,
+  MIN_WITHDRAW_DELAY,
+  PERMIT2_DEPOSIT_COLLECTOR_ADDRESS,
+  batchPermit2WitnessTypes,
+  batchSettlementABI,
+  computeChannelId,
+  getBatchSettlementEip712Domain,
+  receiveAuthorizationTypes,
+  voucherTypes
+} from "./chunk-HYABYUBD.mjs";
+import {
+  isBatchSettlementRefundPayload
+} from "./chunk-U4HCGTLU.mjs";
+import {
+  trySignEip2612PermitExtension,
+  trySignErc20ApprovalExtension
+} from "./chunk-YMQCTKDU.mjs";
+import {
+  PERMIT2_ADDRESS
+} from "./chunk-MACPBXCT.mjs";
+import {
+  createNonce,
+  createPermit2Nonce,
+  getEvmChainId
+} from "./chunk-TW7Z65AO.mjs";
+
+// src/batch-settlement/client/voucher.ts
+async function signVoucher(signer, channelId, maxClaimableAmount, network) {
+  const chainId = getEvmChainId(network);
+  const signature = await signer.signTypedData({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: voucherTypes,
+    primaryType: "Voucher",
+    message: {
+      channelId,
+      maxClaimableAmount: BigInt(maxClaimableAmount)
+    }
+  });
+  return {
+    channelId,
+    maxClaimableAmount,
+    signature
+  };
+}
+
+// src/batch-settlement/client/eip3009.ts
+import { getAddress } from "viem";
+async function createBatchSettlementEIP3009DepositPayload(signer, x402Version, paymentRequirements, channelConfig, depositAmount, maxClaimableAmount, voucherSigner) {
+  const salt = createNonce();
+  const now = Math.floor(Date.now() / 1e3);
+  const chainId = getEvmChainId(paymentRequirements.network);
+  if (!paymentRequirements.extra?.name || !paymentRequirements.extra?.version) {
+    throw new Error(
+      `EIP-712 domain parameters (name, version) are required in payment requirements for asset ${paymentRequirements.asset}`
+    );
+  }
+  const { name, version } = paymentRequirements.extra;
+  const channelId = computeChannelId(channelConfig, paymentRequirements.network);
+  const erc3009Nonce = buildErc3009DepositNonce(channelId, salt);
+  const signature = await signer.signTypedData({
+    domain: {
+      name,
+      version,
+      chainId,
+      verifyingContract: getAddress(paymentRequirements.asset)
+    },
+    types: receiveAuthorizationTypes,
+    primaryType: "ReceiveWithAuthorization",
+    message: {
+      from: getAddress(signer.address),
+      to: getAddress(ERC3009_DEPOSIT_COLLECTOR_ADDRESS),
+      value: BigInt(depositAmount),
+      validAfter: BigInt(now - 600),
+      validBefore: BigInt(now + paymentRequirements.maxTimeoutSeconds),
+      nonce: erc3009Nonce
+    }
+  });
+  const vSigner = voucherSigner ?? signer;
+  const voucher = await signVoucher(
+    vSigner,
+    channelId,
+    maxClaimableAmount,
+    paymentRequirements.network
+  );
+  const payload = {
+    type: "deposit",
+    channelConfig,
+    voucher,
+    deposit: {
+      amount: depositAmount,
+      authorization: {
+        erc3009Authorization: {
+          validAfter: (now - 600).toString(),
+          validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
+          salt,
+          signature
+        }
+      }
+    }
+  };
+  return {
+    x402Version,
+    payload
+  };
+}
+
+// src/batch-settlement/client/storage.ts
+var InMemoryClientChannelStorage = class {
+  constructor() {
+    this.channels = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Returns the channel record for `key` if present.
+   *
+   * @param key - Channel storage key (channelId).
+   * @returns Persisted context or undefined.
+   */
+  async get(key) {
+    return this.channels.get(key);
+  }
+  /**
+   * Stores or replaces the channel record for `key`.
+   *
+   * @param key - Channel storage key.
+   * @param context - Channel fields to persist.
+   * @returns Resolves when stored.
+   */
+  async set(key, context) {
+    this.channels.set(key, context);
+  }
+  /**
+   * Removes the channel record for `key` if it exists.
+   *
+   * @param key - Channel storage key.
+   * @returns Resolves when removed.
+   */
+  async delete(key) {
+    this.channels.delete(key);
+  }
+};
+
+// src/batch-settlement/client/config.ts
+var DEFAULT_SALT = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function isBatchSettlementEvmSchemeOptions(o) {
+  return o !== void 0 && typeof o === "object" && ("storage" in o || "depositPolicy" in o || "depositStrategy" in o || "salt" in o || "payerAuthorizer" in o || "rpcUrl" in o || "voucherSigner" in o);
+}
+function resolveClientOptions(second) {
+  if (second === void 0) {
+    return { storage: new InMemoryClientChannelStorage(), salt: DEFAULT_SALT };
+  }
+  if (isBatchSettlementEvmSchemeOptions(second)) {
+    return {
+      storage: second.storage ?? new InMemoryClientChannelStorage(),
+      depositPolicy: second.depositPolicy,
+      depositStrategy: second.depositStrategy,
+      salt: second.salt ?? DEFAULT_SALT,
+      payerAuthorizer: second.payerAuthorizer,
+      voucherSigner: second.voucherSigner,
+      extensionRpcOptions: second.rpcUrl ? { rpcUrl: second.rpcUrl } : void 0
+    };
+  }
+  return {
+    storage: new InMemoryClientChannelStorage(),
+    depositPolicy: second,
+    salt: DEFAULT_SALT
+  };
+}
+function validateDepositPolicy(policy) {
+  if (!policy) return;
+  const m = policy.depositMultiplier;
+  if (m !== void 0 && (!Number.isInteger(m) || m < 3)) {
+    throw new Error("depositMultiplier must be an integer >= 3");
+  }
+}
+function depositAmountForRequest(policy, requestAmount) {
+  const mult = BigInt(policy?.depositMultiplier ?? 5);
+  return (mult * requestAmount).toString();
+}
+
+// src/batch-settlement/client/channel.ts
+import { decodePaymentResponseHeader } from "@payai/x402/http";
+import { getAddress as getAddress2 } from "viem";
+function readResponseChannelState(extra) {
+  const channelState = extra.channelState;
+  if (typeof channelState !== "object" || channelState === null) {
+    return void 0;
+  }
+  return channelState;
+}
+function buildChannelConfig(deps, paymentRequirements) {
+  const extra = paymentRequirements.extra;
+  const receiverAuthorizer = extra?.receiverAuthorizer;
+  if (!receiverAuthorizer || getAddress2(receiverAuthorizer) === "0x0000000000000000000000000000000000000000") {
+    throw new Error("Payment requirements must include a non-zero extra.receiverAuthorizer");
+  }
+  return {
+    payer: deps.signer.address,
+    payerAuthorizer: getAddress2(
+      deps.payerAuthorizer ?? deps.voucherSigner?.address ?? deps.signer.address
+    ),
+    receiver: paymentRequirements.payTo,
+    receiverAuthorizer: getAddress2(receiverAuthorizer),
+    token: paymentRequirements.asset,
+    withdrawDelay: typeof extra?.withdrawDelay === "number" ? extra.withdrawDelay : MIN_WITHDRAW_DELAY,
+    salt: deps.salt
+  };
+}
+async function processSettleResponse(storage, settle) {
+  const extra = settle.extra ?? {};
+  const channelState = readResponseChannelState(extra);
+  if (!channelState) return;
+  const channelId = channelState.channelId;
+  const key = channelId.toLowerCase();
+  const prev = await storage.get(key);
+  const next = { ...prev ?? {} };
+  if (channelState.chargedCumulativeAmount !== void 0) {
+    next.chargedCumulativeAmount = String(channelState.chargedCumulativeAmount);
+  }
+  if (channelState.balance !== void 0) {
+    next.balance = String(channelState.balance);
+  }
+  if (channelState.totalClaimed !== void 0) {
+    next.totalClaimed = String(channelState.totalClaimed);
+  }
+  await storage.set(key, next);
+}
+async function updateChannelAfterRefund(storage, channelKey, settleExtra) {
+  const channelState = readResponseChannelState(settleExtra);
+  if (!channelState) {
+    await storage.delete(channelKey);
+    return;
+  }
+  const balanceAfter = channelState.balance !== void 0 ? BigInt(String(channelState.balance)) : void 0;
+  if (balanceAfter === void 0 || balanceAfter <= 0n) {
+    await storage.delete(channelKey);
+    return;
+  }
+  const prev = await storage.get(channelKey);
+  const next = { ...prev ?? {} };
+  next.balance = balanceAfter.toString();
+  if (channelState.chargedCumulativeAmount !== void 0) {
+    next.chargedCumulativeAmount = String(channelState.chargedCumulativeAmount);
+  }
+  if (channelState.totalClaimed !== void 0) {
+    next.totalClaimed = String(channelState.totalClaimed);
+  }
+  await storage.set(channelKey, next);
+}
+async function processPaymentResponse(storage, getHeader) {
+  const raw = getHeader("PAYMENT-RESPONSE");
+  if (!raw) return;
+  const settle = decodePaymentResponseHeader(raw);
+  await processSettleResponse(storage, settle);
+}
+async function recoverChannel(deps, paymentRequirements) {
+  if (!deps.signer.readContract) {
+    throw new Error("recoverChannel requires ClientEvmSigner.readContract");
+  }
+  const config = buildChannelConfig(deps, paymentRequirements);
+  const channelId = computeChannelId(config, paymentRequirements.network);
+  const [chBalance, chTotalClaimed] = await readChannelBalanceAndTotalClaimed(
+    deps.signer,
+    channelId
+  );
+  const ctx = {
+    chargedCumulativeAmount: chTotalClaimed.toString(),
+    balance: chBalance.toString(),
+    totalClaimed: chTotalClaimed.toString()
+  };
+  await deps.storage.set(channelId.toLowerCase(), ctx);
+  return ctx;
+}
+async function readChannelBalanceAndTotalClaimed(signer, channelId) {
+  if (!signer.readContract) {
+    throw new Error("readChannelBalanceAndTotalClaimed requires ClientEvmSigner.readContract");
+  }
+  return await signer.readContract({
+    address: BATCH_SETTLEMENT_ADDRESS,
+    abi: batchSettlementABI,
+    functionName: "channels",
+    args: [channelId]
+  });
+}
+async function hasChannel(storage, channelId) {
+  const channel = await storage.get(channelId.toLowerCase());
+  return channel !== void 0;
+}
+async function getChannel(storage, channelId) {
+  return storage.get(channelId.toLowerCase());
+}
+
+// src/batch-settlement/client/recovery.ts
+import { getAddress as getAddress3, recoverTypedDataAddress } from "viem";
+async function processCorrectivePaymentRequired(deps, paymentRequired) {
+  if (paymentRequired.error !== ErrCumulativeAmountMismatch && paymentRequired.error !== ErrCumulativeAmountBelowClaimed) {
+    return false;
+  }
+  const accept = paymentRequired.accepts.find((a) => a.scheme === BATCH_SETTLEMENT_SCHEME);
+  if (!accept) {
+    return false;
+  }
+  const channelState = accept.extra.channelState;
+  const voucherState = accept.extra.voucherState;
+  const hasSig = channelState?.chargedCumulativeAmount !== void 0 && voucherState?.signedMaxClaimable !== void 0 && voucherState.signature !== void 0;
+  if (!hasSig) {
+    return recoverFromOnChainState(deps, accept);
+  }
+  return recoverFromSignature(deps, accept, channelState, voucherState);
+}
+async function recoverFromSignature(deps, accept, channelState, voucherState) {
+  const chargedRaw = channelState.chargedCumulativeAmount;
+  const signedRaw = voucherState.signedMaxClaimable;
+  const sig = voucherState.signature;
+  const charged = BigInt(String(chargedRaw));
+  const signed = BigInt(String(signedRaw));
+  if (charged > signed) {
+    return false;
+  }
+  const config = buildChannelConfig(deps, accept);
+  const channelId = computeChannelId(config, accept.network);
+  if (!deps.signer.readContract) {
+    return false;
+  }
+  const [chBalance, chTotalClaimed] = await readChannelBalanceAndTotalClaimed(
+    deps.signer,
+    channelId
+  );
+  if (charged < chTotalClaimed) {
+    return false;
+  }
+  const chainId = getEvmChainId(accept.network);
+  const recovered = await recoverTypedDataAddress({
+    domain: getBatchSettlementEip712Domain(chainId),
+    types: voucherTypes,
+    primaryType: "Voucher",
+    message: {
+      channelId,
+      maxClaimableAmount: signed
+    },
+    signature: sig
+  });
+  const expectedSigner = getAddress3(
+    deps.payerAuthorizer ?? deps.voucherSigner?.address ?? deps.signer.address
+  );
+  if (recovered.toLowerCase() !== expectedSigner.toLowerCase()) {
+    return false;
+  }
+  const ctx = {
+    chargedCumulativeAmount: charged.toString(),
+    signedMaxClaimable: signed.toString(),
+    signature: sig,
+    balance: chBalance.toString(),
+    totalClaimed: chTotalClaimed.toString()
+  };
+  await deps.storage.set(channelId.toLowerCase(), ctx);
+  return true;
+}
+async function recoverFromOnChainState(deps, accept) {
+  if (!deps.signer.readContract) {
+    return false;
+  }
+  const config = buildChannelConfig(deps, accept);
+  const channelId = computeChannelId(config, accept.network);
+  const [chBalance, chTotalClaimed] = await readChannelBalanceAndTotalClaimed(
+    deps.signer,
+    channelId
+  );
+  const ctx = {
+    chargedCumulativeAmount: chTotalClaimed.toString(),
+    balance: chBalance.toString(),
+    totalClaimed: chTotalClaimed.toString()
+  };
+  await deps.storage.set(channelId.toLowerCase(), ctx);
+  return true;
+}
+
+// src/batch-settlement/client/hooks.ts
+function createBatchSettlementClientHooks(deps) {
+  return {
+    onPaymentResponse: (ctx) => handleBatchSettlementPaymentResponse(deps, ctx)
+  };
+}
+async function handleBatchSettlementPaymentResponse(deps, ctx) {
+  if (ctx.settleResponse) {
+    if (isBatchSettlementRefundPayload(ctx.paymentPayload.payload)) {
+      const extra = ctx.settleResponse.extra ?? {};
+      const channelState = extra.channelState;
+      const channelId = typeof channelState === "object" && channelState !== null && "channelId" in channelState ? channelState.channelId : void 0;
+      if (typeof channelId === "string" && channelId) {
+        await updateChannelAfterRefund(deps.storage, channelId.toLowerCase(), extra);
+      }
+      return;
+    }
+    await processSettleResponse(deps.storage, ctx.settleResponse);
+    return;
+  }
+  if (ctx.paymentRequired) {
+    const recovered = await processCorrectivePaymentRequired(deps, ctx.paymentRequired);
+    return recovered ? { recovered: true } : void 0;
+  }
+}
+
+// src/batch-settlement/client/refund.ts
+import { decodePaymentRequiredHeader, decodePaymentResponseHeader as decodePaymentResponseHeader2 } from "@payai/x402/http";
+import { x402Client, x402HTTPClient } from "@payai/x402/client";
+var NON_RECOVERABLE_REFUND_ERRORS = /* @__PURE__ */ new Set([
+  ErrRefundNoBalance,
+  ErrRefundAmountInvalid
+]);
+async function refundChannel(ctx, url, options) {
+  const fetchImpl = options?.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("refund requires a fetch implementation (globalThis.fetch unavailable)");
+  }
+  const refundAmount = normalizeRefundAmount(options?.amount);
+  const probe = await probeRefundRequirements(url, fetchImpl);
+  return executeRefund(ctx, url, probe, refundAmount, fetchImpl);
+}
+async function probeRefundRequirements(url, fetchImpl) {
+  const probe = await fetchImpl(url, { method: "GET" });
+  if (probe.status !== 402) {
+    throw new Error(`Refund probe expected 402, got ${probe.status}`);
+  }
+  const header = probe.headers.get("PAYMENT-REQUIRED");
+  if (!header) {
+    throw new Error("Refund probe response missing PAYMENT-REQUIRED header");
+  }
+  const paymentRequired = decodePaymentRequiredHeader(header);
+  const requirements = paymentRequired.accepts.find((a) => a.scheme === BATCH_SETTLEMENT_SCHEME);
+  if (!requirements) {
+    throw new Error(`No ${BATCH_SETTLEMENT_SCHEME} payment option at ${url}`);
+  }
+  const extra = requirements.extra;
+  if (!extra?.receiverAuthorizer) {
+    throw new Error("Refund requires a configured receiverAuthorizer on the receiver");
+  }
+  return { paymentRequired, requirements };
+}
+async function executeRefund(ctx, url, probe, refundAmount, fetchImpl) {
+  const maxAttempts = 2;
+  const { paymentRequired, requirements } = probe;
+  const httpClient = createRefundHttpClient(ctx, requirements);
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const paymentPayload = await buildRefundPaymentPayload(
+      ctx,
+      paymentRequired,
+      requirements,
+      refundAmount
+    );
+    const headers = httpClient.encodePaymentSignatureHeader(paymentPayload);
+    const response = await fetchImpl(url, { method: "GET", headers });
+    if (response.status === 402) {
+      const nonRecoverable = getNonRecoverableRefundFailure(response);
+      if (nonRecoverable) {
+        throw new Error(nonRecoverable);
+      }
+    }
+    const result = await httpClient.processPaymentResult(
+      paymentPayload,
+      (name) => response.headers.get(name),
+      response.status
+    );
+    if (response.status === 402) {
+      if (result.recovered && attempt < maxAttempts) {
+        continue;
+      }
+      if (result.recovered) {
+        throw new Error(`Refund failed: server returned 402 after ${attempt} attempt(s)`);
+      }
+      const corrective = getRefundPaymentRequired(response);
+      throw new Error(`Refund failed: ${corrective.error ?? "unknown"}`);
+    }
+    if (!result.settleResponse) {
+      throw new Error(
+        `Refund response missing PAYMENT-RESPONSE header (status ${response.status})`
+      );
+    }
+    return result.settleResponse;
+  }
+  throw new Error("Refund failed: retry budget exhausted");
+}
+async function buildRefundPaymentPayload(ctx, paymentRequired, requirements, refundAmount) {
+  const config = buildChannelConfig(ctx, requirements);
+  const channelId = computeChannelId(config, requirements.network);
+  const key = channelId.toLowerCase();
+  let channel = await ctx.storage.get(key);
+  if (channel === void 0 && ctx.signer.readContract) {
+    channel = await recoverChannel(ctx, requirements);
+  }
+  if (channel === void 0) {
+    throw new Error(
+      "Refund requires an existing channel record; deposit first or call from a context with an EVM RPC"
+    );
+  }
+  const charged = channel.chargedCumulativeAmount ?? "0";
+  if (channel.balance !== void 0 && BigInt(channel.balance) <= BigInt(charged)) {
+    throw new Error(
+      `Refund failed: channel has no remaining balance (balance=${channel.balance}, chargedCumulativeAmount=${charged})`
+    );
+  }
+  const voucherSigner = ctx.voucherSigner ?? ctx.signer;
+  const voucher = await signVoucher(voucherSigner, channelId, charged, requirements.network);
+  const payload = {
+    type: "refund",
+    channelConfig: config,
+    voucher,
+    ...refundAmount !== void 0 ? { amount: refundAmount } : {}
+  };
+  return {
+    x402Version: 2,
+    accepted: requirements,
+    payload,
+    ...paymentRequired.resource ? { resource: paymentRequired.resource } : {},
+    ...paymentRequired.extensions ? { extensions: paymentRequired.extensions } : {}
+  };
+}
+function createRefundHttpClient(ctx, requirements) {
+  const client = new x402Client().register(requirements.network, {
+    scheme: BATCH_SETTLEMENT_SCHEME,
+    schemeHooks: createBatchSettlementClientHooks(ctx),
+    createPaymentPayload: async () => {
+      throw new Error("Refund payloads are built by refundChannel");
+    }
+  });
+  return new x402HTTPClient(client);
+}
+function getNonRecoverableRefundFailure(response) {
+  const settleHeader = response.headers.get("PAYMENT-RESPONSE");
+  if (settleHeader) {
+    return formatRefundFailure(decodePaymentResponseHeader2(settleHeader));
+  }
+  const paymentRequired = getRefundPaymentRequired(response);
+  const errorCode = paymentRequired.error;
+  if (errorCode && NON_RECOVERABLE_REFUND_ERRORS.has(errorCode)) {
+    return `Refund failed: ${errorCode}`;
+  }
+}
+function getRefundPaymentRequired(response) {
+  const requiredHeader = response.headers.get("PAYMENT-REQUIRED");
+  if (!requiredHeader) {
+    throw new Error("Refund 402 missing PAYMENT-REQUIRED header");
+  }
+  return decodePaymentRequiredHeader(requiredHeader);
+}
+function formatRefundFailure(settle) {
+  const reason = settle.errorReason ?? "unknown_settlement_error";
+  const message = settle.errorMessage;
+  if (message && message !== reason) {
+    return `Refund failed: ${reason}: ${message}`;
+  }
+  return `Refund failed: ${reason}`;
+}
+function normalizeRefundAmount(amount) {
+  if (amount === void 0) return void 0;
+  if (!/^\d+$/.test(amount) || amount === "0") {
+    throw new Error(`Invalid refund amount "${amount}": must be a positive integer string`);
+  }
+  return amount;
+}
+
+// src/batch-settlement/client/scheme.ts
+import { getAddress as getAddress5 } from "viem";
+
+// src/batch-settlement/client/permit2.ts
+import { getAddress as getAddress4 } from "viem";
+async function createBatchSettlementPermit2DepositPayload(signer, x402Version, paymentRequirements, channelConfig, depositAmount, maxClaimableAmount, voucherSigner) {
+  const chainId = getEvmChainId(paymentRequirements.network);
+  const nonce = createPermit2Nonce();
+  const deadline = Math.floor(Date.now() / 1e3 + paymentRequirements.maxTimeoutSeconds).toString();
+  const channelId = computeChannelId(channelConfig, paymentRequirements.network);
+  const permit2Authorization = {
+    from: signer.address,
+    permitted: {
+      token: getAddress4(paymentRequirements.asset),
+      amount: depositAmount
+    },
+    spender: getAddress4(PERMIT2_DEPOSIT_COLLECTOR_ADDRESS),
+    nonce,
+    deadline,
+    witness: {
+      channelId
+    }
+  };
+  const signature = await signer.signTypedData({
+    domain: { name: "Permit2", chainId, verifyingContract: PERMIT2_ADDRESS },
+    types: batchPermit2WitnessTypes,
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: permit2Authorization.permitted.token,
+        amount: BigInt(permit2Authorization.permitted.amount)
+      },
+      spender: permit2Authorization.spender,
+      nonce: BigInt(permit2Authorization.nonce),
+      deadline: BigInt(permit2Authorization.deadline),
+      witness: {
+        channelId
+      }
+    }
+  });
+  const voucher = await signVoucher(
+    voucherSigner ?? signer,
+    channelId,
+    maxClaimableAmount,
+    paymentRequirements.network
+  );
+  const payload = {
+    type: "deposit",
+    channelConfig,
+    voucher,
+    deposit: {
+      amount: depositAmount,
+      authorization: {
+        permit2Authorization: {
+          ...permit2Authorization,
+          signature
+        }
+      }
+    }
+  };
+  return { x402Version, payload };
+}
+
+// src/batch-settlement/client/scheme.ts
+var BatchSettlementEvmScheme = class {
+  /**
+   * Constructs a batched client scheme.
+   *
+   * @param signer - Client EVM wallet used for signing vouchers and ERC-3009 authorizations.
+   * @param optionsOrPolicy - Either a full options object or a bare deposit-policy.
+   */
+  constructor(signer, optionsOrPolicy) {
+    this.signer = signer;
+    this.scheme = BATCH_SETTLEMENT_SCHEME;
+    const {
+      storage,
+      depositPolicy,
+      depositStrategy,
+      salt,
+      payerAuthorizer,
+      voucherSigner,
+      extensionRpcOptions
+    } = resolveClientOptions(optionsOrPolicy);
+    this.storage = storage;
+    this.depositPolicy = depositPolicy;
+    this.depositStrategy = depositStrategy;
+    this.salt = salt;
+    this.payerAuthorizer = payerAuthorizer;
+    this.voucherSigner = voucherSigner;
+    this.extensionRpcOptions = extensionRpcOptions;
+    if (payerAuthorizer !== void 0 && voucherSigner !== void 0 && getAddress5(payerAuthorizer) !== getAddress5(voucherSigner.address)) {
+      throw new Error("payerAuthorizer address must match voucherSigner.address");
+    }
+    validateDepositPolicy(depositPolicy);
+    this.schemeHooks = createBatchSettlementClientHooks(this.deps());
+  }
+  /**
+   * Creates the payment payload for a batched request.
+   *
+   * If the channel has no onchain deposit (or needs a top-up), builds an
+   * ERC-3009 deposit payload bundled with a voucher. Otherwise, signs and
+   * returns a voucher-only payload.
+   *
+   * @param x402Version - Protocol version for the payload envelope.
+   * @param paymentRequirements - Server payment requirements (scheme, network, asset, amount).
+   * @param context - Optional payment payload context with extension hints.
+   * @returns A {@link PaymentPayloadResult} ready to be sent as the `X-PAYMENT` header.
+   */
+  async createPaymentPayload(x402Version, paymentRequirements, context) {
+    const deps = this.deps();
+    const config = buildChannelConfig(deps, paymentRequirements);
+    const channelId = computeChannelId(config, paymentRequirements.network);
+    const key = channelId.toLowerCase();
+    let batchedCtx = await this.storage.get(key);
+    if (batchedCtx === void 0 && this.signer.readContract) {
+      batchedCtx = await recoverChannel(deps, paymentRequirements);
+    }
+    batchedCtx = batchedCtx ?? {};
+    const needsInitialDeposit = !batchedCtx.balance || batchedCtx.balance === "0";
+    const baseCumulative = BigInt(batchedCtx.chargedCumulativeAmount ?? "0");
+    const requestAmount = BigInt(paymentRequirements.amount);
+    const maxClaimableAmount = (baseCumulative + requestAmount).toString();
+    const currentBalance = BigInt(batchedCtx.balance ?? "0");
+    const needsTopUp = !needsInitialDeposit && BigInt(maxClaimableAmount) > currentBalance;
+    if (needsInitialDeposit || needsTopUp) {
+      const computedDeposit = depositAmountForRequest(this.depositPolicy, requestAmount);
+      const minimumDepositAmount = BigInt(maxClaimableAmount) - currentBalance;
+      const depositAmount = await this.resolveDepositAmount({
+        paymentRequirements,
+        channelConfig: config,
+        channelId,
+        clientContext: batchedCtx,
+        requestAmount: requestAmount.toString(),
+        maxClaimableAmount,
+        currentBalance: currentBalance.toString(),
+        minimumDepositAmount: minimumDepositAmount.toString(),
+        depositAmount: computedDeposit
+      });
+      if (depositAmount === false) {
+        return this.createVoucherPayload(
+          x402Version,
+          channelId,
+          maxClaimableAmount,
+          paymentRequirements.network,
+          config
+        );
+      }
+      const assetTransferMethod = paymentRequirements.extra?.assetTransferMethod ?? "eip3009";
+      if (assetTransferMethod === "eip3009") {
+        return createBatchSettlementEIP3009DepositPayload(
+          this.signer,
+          x402Version,
+          paymentRequirements,
+          config,
+          depositAmount,
+          maxClaimableAmount,
+          this.voucherSigner
+        );
+      }
+      if (assetTransferMethod !== "permit2") {
+        throw new Error(`unsupported batch-settlement assetTransferMethod: ${assetTransferMethod}`);
+      }
+      const result = await createBatchSettlementPermit2DepositPayload(
+        this.signer,
+        x402Version,
+        paymentRequirements,
+        config,
+        depositAmount,
+        maxClaimableAmount,
+        this.voucherSigner
+      );
+      const eip2612Extensions = await trySignEip2612PermitExtension(
+        this.signer,
+        this.extensionRpcOptions,
+        paymentRequirements,
+        result,
+        context,
+        depositAmount
+      );
+      if (eip2612Extensions) {
+        return { ...result, extensions: eip2612Extensions };
+      }
+      const erc20Extensions = await trySignErc20ApprovalExtension(
+        this.signer,
+        this.extensionRpcOptions,
+        paymentRequirements,
+        context,
+        depositAmount
+      );
+      if (erc20Extensions) {
+        return { ...result, extensions: erc20Extensions };
+      }
+      return result;
+    }
+    return this.createVoucherPayload(
+      x402Version,
+      channelId,
+      maxClaimableAmount,
+      paymentRequirements.network,
+      config
+    );
+  }
+  /**
+   * Sends a cooperative refund request.
+   *
+   * @param url - The route URL backing the channel to refund.
+   * @param options - Optional `amount` (partial refund) and `fetch` override.
+   * @returns The settle response describing the refund outcome.
+   */
+  async refund(url, options) {
+    return refundChannel(this.deps(), url, options);
+  }
+  /**
+   * Updates local channel state from a settle response.
+   *
+   * @param settle - The parsed settle response from the server.
+   * @returns Resolves when local channel state has been updated.
+   */
+  async processSettleResponse(settle) {
+    return processSettleResponse(this.storage, settle);
+  }
+  /**
+   * Resyncs local channel state from a corrective 402 response.
+   *
+   * @param paymentRequired - The decoded 402 response body.
+   * @returns `true` if local state was successfully resynced and a retry is warranted.
+   */
+  async processCorrectivePaymentRequired(paymentRequired) {
+    return processCorrectivePaymentRequired(this.deps(), paymentRequired);
+  }
+  /**
+   * Builds the immutable {@link ChannelConfig} for a given set of payment
+   * requirements, using the scheme's own signer and salt.
+   *
+   * @param paymentRequirements - Server payment requirements for the channel.
+   * @returns The channel config that uniquely identifies the payment channel.
+   */
+  buildChannelConfig(paymentRequirements) {
+    return buildChannelConfig(this.deps(), paymentRequirements);
+  }
+  /**
+   * Resolves the deposit amount after applying the optional custom strategy.
+   *
+   * @param context - Deposit attempt context exposed to the strategy.
+   * @returns The deposit amount to sign, or `false` to skip this deposit attempt.
+   */
+  async resolveDepositAmount(context) {
+    const strategyResult = await this.depositStrategy?.(context);
+    if (strategyResult === false) return false;
+    if (strategyResult === void 0) return context.depositAmount;
+    const depositAmount = this.normalizeStrategyDepositAmount(strategyResult);
+    if (BigInt(depositAmount) < BigInt(context.minimumDepositAmount)) {
+      throw new Error(
+        `depositStrategy returned ${depositAmount}, below required top-up ${context.minimumDepositAmount}`
+      );
+    }
+    return depositAmount;
+  }
+  /**
+   * Normalizes and validates a strategy-provided base-unit deposit amount.
+   *
+   * @param value - Strategy-provided string or bigint amount.
+   * @returns Normalized decimal string.
+   */
+  normalizeStrategyDepositAmount(value) {
+    if (typeof value === "bigint") {
+      if (value <= 0n) {
+        throw new Error("depositStrategy must return a positive integer deposit amount");
+      }
+      return value.toString();
+    }
+    if (/^\d+$/.test(value) && BigInt(value) > 0n) {
+      return BigInt(value).toString();
+    }
+    throw new Error("depositStrategy must return a positive integer deposit amount");
+  }
+  /**
+   * Signs a voucher-only payment payload for the current channel.
+   *
+   * @param x402Version - Protocol version for the payload envelope.
+   * @param channelId - Channel identifier for the voucher.
+   * @param maxClaimableAmount - Cumulative ceiling for the voucher.
+   * @param network - CAIP-2 network identifier.
+   * @param config - Immutable channel configuration.
+   * @returns Voucher-only payment payload.
+   */
+  async createVoucherPayload(x402Version, channelId, maxClaimableAmount, network, config) {
+    const voucherSigner = this.voucherSigner ?? this.signer;
+    const voucher = await signVoucher(voucherSigner, channelId, maxClaimableAmount, network);
+    const payload = {
+      type: "voucher",
+      channelConfig: config,
+      voucher
+    };
+    return {
+      x402Version,
+      payload
+    };
+  }
+  /**
+   * Bundles the class state into the {@link BatchSettlementClientDeps} shape
+   * consumed by the `channel`, `recovery`, and `refund` modules.
+   *
+   * @returns Client deps wrapping the scheme's own signer and storage.
+   */
+  deps() {
+    return {
+      signer: this.signer,
+      storage: this.storage,
+      salt: this.salt,
+      payerAuthorizer: this.payerAuthorizer,
+      voucherSigner: this.voucherSigner
+    };
+  }
+};
+
+export {
+  signVoucher,
+  createBatchSettlementEIP3009DepositPayload,
+  InMemoryClientChannelStorage,
+  isBatchSettlementEvmSchemeOptions,
+  resolveClientOptions,
+  validateDepositPolicy,
+  depositAmountForRequest,
+  buildChannelConfig,
+  processSettleResponse,
+  updateChannelAfterRefund,
+  processPaymentResponse,
+  recoverChannel,
+  readChannelBalanceAndTotalClaimed,
+  hasChannel,
+  getChannel,
+  processCorrectivePaymentRequired,
+  recoverFromSignature,
+  recoverFromOnChainState,
+  createBatchSettlementClientHooks,
+  handleBatchSettlementPaymentResponse,
+  refundChannel,
+  BatchSettlementEvmScheme
+};
+//# sourceMappingURL=chunk-NKYVYGRA.mjs.map