@bankofai/x402-evm 1.0.0-beta.0

package/dist/esm/facilitator/agent-wallet.d.mts

@@ -0,0 +1,109 @@
+import { PublicClient } from 'viem';
+import { F as FacilitatorEvmSigner } from '../signer-BFelv8DL.mjs';
+
+/**
+ * BankofAI overlay — NOT from upstream @x402/evm.
+ *
+ * Adds a wallet-bridge factory for facilitators, symmetric to TRON's
+ * `createFacilitatorTronSigner`. Upstream only ships `toFacilitatorEvmSigner`,
+ * which requires the integrator to hand-wire every on-chain op
+ * (readContract / writeContract / sendTransaction / waitForTransactionReceipt /
+ * getCode / verifyTypedData). This module builds all of that from a viem
+ * public client + a key-custody wallet, so non-custodial signing is collected
+ * in one place.
+ *
+ * Upgrade safety: this file ONLY consumes upstream's public surface
+ * (`toFacilitatorEvmSigner` + the `FacilitatorEvmSigner` type). It never edits
+ * `signer.ts` or `index.ts`, so pulling a newer upstream is conflict-free as
+ * long as that public surface is unchanged. The agent-wallet dependency is kept
+ * out via the structural {@link FacilitatorEvmWallet} interface — any object of
+ * that shape works (agent-wallet's `EvmSigner`, a keystore, hardware, etc.).
+ */
+
+/**
+ * A wallet that signs EIP-1559 settlement transactions without ever exposing
+ * its private key to the SDK — structurally compatible with
+ * `@bankofai/agent-wallet`'s `EvmSigner`, but intentionally not coupled to it.
+ *
+ * `signTransaction` returns a serialized signed transaction hex. The `0x`
+ * prefix is optional: agent-wallet currently strips it (see SDK issue #2), so
+ * the broadcast path normalizes defensively.
+ */
+interface FacilitatorEvmWallet {
+    /** Facilitator EVM address (0x-prefixed, checksummed or lowercase). */
+    readonly address: `0x${string}`;
+    /**
+     * Sign a fully-specified EIP-1559 transaction and return the serialized
+     * signed tx hex (with or without the `0x` prefix).
+     */
+    signTransaction(tx: {
+        to: `0x${string}`;
+        data: `0x${string}`;
+        value: bigint;
+        nonce: number;
+        gas: bigint;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        chainId: number;
+    }): Promise<string>;
+}
+/**
+ * The viem public-client surface this factory needs. Defined as a `Pick` of
+ * viem's `PublicClient` so a real client is assignable WITHOUT a cast — using a
+ * hand-rolled structural interface with wider param types (e.g.
+ * `verifyTypedData`'s `types: Record<string, unknown>`) would fail under
+ * `strictFunctionTypes` and force every integrator to cast (see SDK issue #5).
+ *
+ * In tests, pass a mock via `as unknown as FacilitatorEvmPublicClient`.
+ */
+type FacilitatorEvmPublicClient = Pick<PublicClient, "getChainId" | "getTransactionCount" | "estimateFeesPerGas" | "estimateGas" | "sendRawTransaction" | "readContract" | "verifyTypedData" | "getCode" | "waitForTransactionReceipt">;
+/** Options for {@link createFacilitatorEvmSigner}. */
+interface FacilitatorEvmSignerOptions {
+    /**
+     * Gas limit to use when a per-call `gas` is not supplied. When unset, gas is
+     * estimated per transaction via `estimateGas`.
+     */
+    defaultGas?: bigint;
+}
+/**
+ * One transaction for {@link GasSponsoringFacilitatorEvmSigner.sendTransactions}:
+ * either a pre-signed serialized tx (broadcast as-is) or an unsigned call intent
+ * (signed by the facilitator wallet, then broadcast). Mirrors the
+ * `@bankofai/x402-extensions` `TransactionRequest` shape without importing it,
+ * so this overlay stays dependency-free.
+ */
+type EvmTransactionRequest = `0x${string}` | {
+    to: `0x${string}`;
+    data: `0x${string}`;
+    gas?: bigint;
+};
+/**
+ * {@link FacilitatorEvmSigner} plus `sendTransactions` — the shape the ERC-20
+ * approval gas-sponsoring extension expects (it broadcasts the client's
+ * pre-signed `approve` bundled with `settle`).
+ */
+type GasSponsoringFacilitatorEvmSigner = FacilitatorEvmSigner & {
+    sendTransactions(transactions: readonly EvmTransactionRequest[]): Promise<`0x${string}`[]>;
+};
+/**
+ * Creates a {@link FacilitatorEvmSigner} from a viem public client and a
+ * key-custody wallet — the EVM counterpart of `createFacilitatorTronSigner`.
+ *
+ * The transaction is built (nonce / EIP-1559 fees / gas), handed to the wallet
+ * to sign (the private key never enters the SDK), then broadcast — collecting
+ * all on-chain ops so each integrator no longer re-implements them.
+ *
+ * @param publicClient - viem public client used for reads, verification, and broadcast.
+ * @param wallet - The wallet that signs settlement transactions.
+ * @param options - Optional default gas limit.
+ * @returns A {@link FacilitatorEvmSigner} backed by the public client + wallet.
+ *
+ * @example
+ * ```typescript
+ * const publicClient = createPublicClient({ chain: base, transport: http() });
+ * const signer = createFacilitatorEvmSigner(publicClient, agentWallet);
+ * ```
+ */
+declare function createFacilitatorEvmSigner(publicClient: FacilitatorEvmPublicClient, wallet: FacilitatorEvmWallet, options?: FacilitatorEvmSignerOptions): GasSponsoringFacilitatorEvmSigner;
+
+export { type EvmTransactionRequest, type FacilitatorEvmPublicClient, type FacilitatorEvmSignerOptions, type FacilitatorEvmWallet, type GasSponsoringFacilitatorEvmSigner, createFacilitatorEvmSigner };

package/dist/esm/facilitator/agent-wallet.mjs

@@ -0,0 +1,74 @@
+import {
+  toFacilitatorEvmSigner
+} from "../chunk-3WZF6722.mjs";
+
+// src/facilitator/agent-wallet.ts
+import { encodeFunctionData } from "viem";
+function appendDataSuffix(data, suffix) {
+  if (!suffix || suffix === "0x") {
+    return data;
+  }
+  return `${data}${suffix.slice(2)}`;
+}
+function createFacilitatorEvmSigner(publicClient, wallet, options = {}) {
+  const client = publicClient;
+  async function buildSignBroadcast(to, data, gasOverride) {
+    const value = 0n;
+    const [chainId, nonce, fees] = await Promise.all([
+      client.getChainId(),
+      client.getTransactionCount({ address: wallet.address }),
+      client.estimateFeesPerGas()
+    ]);
+    const gas = gasOverride ?? options.defaultGas ?? await client.estimateGas({ account: wallet.address, to, data, value });
+    const signed = await wallet.signTransaction({
+      to,
+      data,
+      value,
+      nonce,
+      gas,
+      maxFeePerGas: fees.maxFeePerGas,
+      maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
+      chainId
+    });
+    const serializedTransaction = `0x${signed.replace(/^0x/, "")}`;
+    return client.sendRawTransaction({ serializedTransaction });
+  }
+  const base = toFacilitatorEvmSigner({
+    address: wallet.address,
+    readContract: (args) => client.readContract(args),
+    verifyTypedData: (args) => client.verifyTypedData(args),
+    getCode: (args) => client.getCode(args),
+    waitForTransactionReceipt: (args) => client.waitForTransactionReceipt(args),
+    writeContract: (args) => {
+      const data = appendDataSuffix(
+        encodeFunctionData({
+          abi: args.abi,
+          functionName: args.functionName,
+          args: args.args
+        }),
+        args.dataSuffix
+      );
+      return buildSignBroadcast(args.address, data, args.gas);
+    },
+    sendTransaction: (args) => buildSignBroadcast(args.to, args.data)
+  });
+  return {
+    ...base,
+    async sendTransactions(transactions) {
+      const hashes = [];
+      for (const tx of transactions) {
+        if (typeof tx === "string") {
+          const serializedTransaction = `0x${tx.replace(/^0x/, "")}`;
+          hashes.push(await client.sendRawTransaction({ serializedTransaction }));
+        } else {
+          hashes.push(await buildSignBroadcast(tx.to, tx.data, tx.gas));
+        }
+      }
+      return hashes;
+    }
+  };
+}
+export {
+  createFacilitatorEvmSigner
+};
+//# sourceMappingURL=agent-wallet.mjs.map

package/dist/esm/facilitator/agent-wallet.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/facilitator/agent-wallet.ts"],"sourcesContent":["/**\n * BankofAI overlay — NOT from upstream @x402/evm.\n *\n * Adds a wallet-bridge factory for facilitators, symmetric to TRON's\n * `createFacilitatorTronSigner`. Upstream only ships `toFacilitatorEvmSigner`,\n * which requires the integrator to hand-wire every on-chain op\n * (readContract / writeContract / sendTransaction / waitForTransactionReceipt /\n * getCode / verifyTypedData). This module builds all of that from a viem\n * public client + a key-custody wallet, so non-custodial signing is collected\n * in one place.\n *\n * Upgrade safety: this file ONLY consumes upstream's public surface\n * (`toFacilitatorEvmSigner` + the `FacilitatorEvmSigner` type). It never edits\n * `signer.ts` or `index.ts`, so pulling a newer upstream is conflict-free as\n * long as that public surface is unchanged. The agent-wallet dependency is kept\n * out via the structural {@link FacilitatorEvmWallet} interface — any object of\n * that shape works (agent-wallet's `EvmSigner`, a keystore, hardware, etc.).\n */\nimport { encodeFunctionData, type Abi, type Log, type PublicClient } from \"viem\";\n\nimport { toFacilitatorEvmSigner, type FacilitatorEvmSigner } from \"../signer\";\n\n/**\n * A wallet that signs EIP-1559 settlement transactions without ever exposing\n * its private key to the SDK — structurally compatible with\n * `@bankofai/agent-wallet`'s `EvmSigner`, but intentionally not coupled to it.\n *\n * `signTransaction` returns a serialized signed transaction hex. The `0x`\n * prefix is optional: agent-wallet currently strips it (see SDK issue #2), so\n * the broadcast path normalizes defensively.\n */\nexport interface FacilitatorEvmWallet {\n  /** Facilitator EVM address (0x-prefixed, checksummed or lowercase). */\n  readonly address: `0x${string}`;\n  /**\n   * Sign a fully-specified EIP-1559 transaction and return the serialized\n   * signed tx hex (with or without the `0x` prefix).\n   */\n  signTransaction(tx: {\n    to: `0x${string}`;\n    data: `0x${string}`;\n    value: bigint;\n    nonce: number;\n    gas: bigint;\n    maxFeePerGas: bigint;\n    maxPriorityFeePerGas: bigint;\n    chainId: number;\n  }): Promise<string>;\n}\n\n/**\n * The viem public-client surface this factory needs. Defined as a `Pick` of\n * viem's `PublicClient` so a real client is assignable WITHOUT a cast — using a\n * hand-rolled structural interface with wider param types (e.g.\n * `verifyTypedData`'s `types: Record<string, unknown>`) would fail under\n * `strictFunctionTypes` and force every integrator to cast (see SDK issue #5).\n *\n * In tests, pass a mock via `as unknown as FacilitatorEvmPublicClient`.\n */\nexport type FacilitatorEvmPublicClient = Pick<\n  PublicClient,\n  | \"getChainId\"\n  | \"getTransactionCount\"\n  | \"estimateFeesPerGas\"\n  | \"estimateGas\"\n  | \"sendRawTransaction\"\n  | \"readContract\"\n  | \"verifyTypedData\"\n  | \"getCode\"\n  | \"waitForTransactionReceipt\"\n>;\n\n/**\n * Loose view of the public client for internal forwarding. viem's read/verify\n * methods are generic and strict, while upstream's `FacilitatorEvmSigner` shape\n * is loose; we narrow once here (the runtime client provides all these methods)\n * so the loose/strict impedance is resolved inside the SDK, not by integrators.\n */\ntype LooseEvmPublicClient = {\n  getChainId(): Promise<number>;\n  getTransactionCount(args: { address: `0x${string}` }): Promise<number>;\n  estimateFeesPerGas(): Promise<{ maxFeePerGas: bigint; maxPriorityFeePerGas: bigint }>;\n  estimateGas(args: {\n    account: `0x${string}`;\n    to: `0x${string}`;\n    data: `0x${string}`;\n    value?: bigint;\n  }): Promise<bigint>;\n  sendRawTransaction(args: { serializedTransaction: `0x${string}` }): Promise<`0x${string}`>;\n  readContract(args: {\n    address: `0x${string}`;\n    abi: readonly unknown[];\n    functionName: string;\n    args?: readonly unknown[];\n  }): Promise<unknown>;\n  verifyTypedData(args: {\n    address: `0x${string}`;\n    domain: Record<string, unknown>;\n    types: Record<string, unknown>;\n    primaryType: string;\n    message: Record<string, unknown>;\n    signature: `0x${string}`;\n  }): Promise<boolean>;\n  getCode(args: { address: `0x${string}` }): Promise<`0x${string}` | undefined>;\n  waitForTransactionReceipt(args: {\n    hash: `0x${string}`;\n  }): Promise<{ status: string; logs?: readonly Log[] }>;\n};\n\n/** Options for {@link createFacilitatorEvmSigner}. */\nexport interface FacilitatorEvmSignerOptions {\n  /**\n   * Gas limit to use when a per-call `gas` is not supplied. When unset, gas is\n   * estimated per transaction via `estimateGas`.\n   */\n  defaultGas?: bigint;\n}\n\n/**\n * One transaction for {@link GasSponsoringFacilitatorEvmSigner.sendTransactions}:\n * either a pre-signed serialized tx (broadcast as-is) or an unsigned call intent\n * (signed by the facilitator wallet, then broadcast). Mirrors the\n * `@bankofai/x402-extensions` `TransactionRequest` shape without importing it,\n * so this overlay stays dependency-free.\n */\nexport type EvmTransactionRequest =\n  | `0x${string}`\n  | { to: `0x${string}`; data: `0x${string}`; gas?: bigint };\n\n/**\n * {@link FacilitatorEvmSigner} plus `sendTransactions` — the shape the ERC-20\n * approval gas-sponsoring extension expects (it broadcasts the client's\n * pre-signed `approve` bundled with `settle`).\n */\nexport type GasSponsoringFacilitatorEvmSigner = FacilitatorEvmSigner & {\n  sendTransactions(transactions: readonly EvmTransactionRequest[]): Promise<`0x${string}`[]>;\n};\n\n/**\n * Appends an extension data suffix (e.g. a builder code) to encoded calldata.\n *\n * @param data - The encoded function calldata.\n * @param suffix - Optional `0x`-prefixed suffix to append.\n * @returns The calldata with the suffix appended, or `data` unchanged.\n */\nfunction appendDataSuffix(data: `0x${string}`, suffix?: `0x${string}`): `0x${string}` {\n  if (!suffix || suffix === \"0x\") {\n    return data;\n  }\n  return `${data}${suffix.slice(2)}` as `0x${string}`;\n}\n\n/**\n * Creates a {@link FacilitatorEvmSigner} from a viem public client and a\n * key-custody wallet — the EVM counterpart of `createFacilitatorTronSigner`.\n *\n * The transaction is built (nonce / EIP-1559 fees / gas), handed to the wallet\n * to sign (the private key never enters the SDK), then broadcast — collecting\n * all on-chain ops so each integrator no longer re-implements them.\n *\n * @param publicClient - viem public client used for reads, verification, and broadcast.\n * @param wallet - The wallet that signs settlement transactions.\n * @param options - Optional default gas limit.\n * @returns A {@link FacilitatorEvmSigner} backed by the public client + wallet.\n *\n * @example\n * ```typescript\n * const publicClient = createPublicClient({ chain: base, transport: http() });\n * const signer = createFacilitatorEvmSigner(publicClient, agentWallet);\n * ```\n */\nexport function createFacilitatorEvmSigner(\n  publicClient: FacilitatorEvmPublicClient,\n  wallet: FacilitatorEvmWallet,\n  options: FacilitatorEvmSignerOptions = {},\n): GasSponsoringFacilitatorEvmSigner {\n  // Narrow once: viem's strict generic methods → the loose shape we forward to\n  // upstream's FacilitatorEvmSigner. Keeps the cast inside the SDK (issue #5).\n  const client = publicClient as unknown as LooseEvmPublicClient;\n\n  // Build → wallet-sign → broadcast. Shared by writeContract and sendTransaction.\n  async function buildSignBroadcast(\n    to: `0x${string}`,\n    data: `0x${string}`,\n    gasOverride?: bigint,\n  ): Promise<`0x${string}`> {\n    const value = 0n; // x402 settlement never transfers native value.\n    const [chainId, nonce, fees] = await Promise.all([\n      client.getChainId(),\n      client.getTransactionCount({ address: wallet.address }),\n      client.estimateFeesPerGas(),\n    ]);\n    const gas =\n      gasOverride ??\n      options.defaultGas ??\n      (await client.estimateGas({ account: wallet.address, to, data, value }));\n\n    const signed = await wallet.signTransaction({\n      to,\n      data,\n      value,\n      nonce,\n      gas,\n      maxFeePerGas: fees.maxFeePerGas,\n      maxPriorityFeePerGas: fees.maxPriorityFeePerGas,\n      chainId,\n    });\n\n    // agent-wallet strips the `0x` prefix (SDK issue #2); strip-then-prefix is\n    // robust whether or not the prefix is present, so it survives an upstream\n    // fix that restores it. Carried over from the v1 facilitator signer.\n    const serializedTransaction = `0x${signed.replace(/^0x/, \"\")}` as `0x${string}`;\n    return client.sendRawTransaction({ serializedTransaction });\n  }\n\n  const base = toFacilitatorEvmSigner({\n    address: wallet.address,\n    readContract: args => client.readContract(args),\n    verifyTypedData: args => client.verifyTypedData(args),\n    getCode: args => client.getCode(args),\n    waitForTransactionReceipt: args => client.waitForTransactionReceipt(args),\n    writeContract: args => {\n      const data = appendDataSuffix(\n        encodeFunctionData({\n          abi: args.abi as Abi,\n          functionName: args.functionName,\n          args: args.args,\n        }),\n        args.dataSuffix,\n      );\n      return buildSignBroadcast(args.address, data, args.gas);\n    },\n    sendTransaction: args => buildSignBroadcast(args.to, args.data),\n  });\n\n  // Batch broadcast for the ERC-20 approval gas-sponsoring extension: the\n  // client's pre-signed `approve` (a serialized tx) is broadcast as-is; the\n  // `settle` call intent is signed by the facilitator wallet and broadcast.\n  // Executed sequentially; hashes returned in order (settle is last).\n  return {\n    ...base,\n    async sendTransactions(transactions) {\n      const hashes: `0x${string}`[] = [];\n      for (const tx of transactions) {\n        if (typeof tx === \"string\") {\n          const serializedTransaction = `0x${tx.replace(/^0x/, \"\")}` as `0x${string}`;\n          hashes.push(await client.sendRawTransaction({ serializedTransaction }));\n        } else {\n          hashes.push(await buildSignBroadcast(tx.to, tx.data, tx.gas));\n        }\n      }\n      return hashes;\n    },\n  };\n}\n"],"mappings":";;;;;AAkBA,SAAS,0BAAiE;AA+H1E,SAAS,iBAAiB,MAAqB,QAAuC;AACpF,MAAI,CAAC,UAAU,WAAW,MAAM;AAC9B,WAAO;AAAA,EACT;AACA,SAAO,GAAG,IAAI,GAAG,OAAO,MAAM,CAAC,CAAC;AAClC;AAqBO,SAAS,2BACd,cACA,QACA,UAAuC,CAAC,GACL;AAGnC,QAAM,SAAS;AAGf,iBAAe,mBACb,IACA,MACA,aACwB;AACxB,UAAM,QAAQ;AACd,UAAM,CAAC,SAAS,OAAO,IAAI,IAAI,MAAM,QAAQ,IAAI;AAAA,MAC/C,OAAO,WAAW;AAAA,MAClB,OAAO,oBAAoB,EAAE,SAAS,OAAO,QAAQ,CAAC;AAAA,MACtD,OAAO,mBAAmB;AAAA,IAC5B,CAAC;AACD,UAAM,MACJ,eACA,QAAQ,cACP,MAAM,OAAO,YAAY,EAAE,SAAS,OAAO,SAAS,IAAI,MAAM,MAAM,CAAC;AAExE,UAAM,SAAS,MAAM,OAAO,gBAAgB;AAAA,MAC1C;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,cAAc,KAAK;AAAA,MACnB,sBAAsB,KAAK;AAAA,MAC3B;AAAA,IACF,CAAC;AAKD,UAAM,wBAAwB,KAAK,OAAO,QAAQ,OAAO,EAAE,CAAC;AAC5D,WAAO,OAAO,mBAAmB,EAAE,sBAAsB,CAAC;AAAA,EAC5D;AAEA,QAAM,OAAO,uBAAuB;AAAA,IAClC,SAAS,OAAO;AAAA,IAChB,cAAc,UAAQ,OAAO,aAAa,IAAI;AAAA,IAC9C,iBAAiB,UAAQ,OAAO,gBAAgB,IAAI;AAAA,IACpD,SAAS,UAAQ,OAAO,QAAQ,IAAI;AAAA,IACpC,2BAA2B,UAAQ,OAAO,0BAA0B,IAAI;AAAA,IACxE,eAAe,UAAQ;AACrB,YAAM,OAAO;AAAA,QACX,mBAAmB;AAAA,UACjB,KAAK,KAAK;AAAA,UACV,cAAc,KAAK;AAAA,UACnB,MAAM,KAAK;AAAA,QACb,CAAC;AAAA,QACD,KAAK;AAAA,MACP;AACA,aAAO,mBAAmB,KAAK,SAAS,MAAM,KAAK,GAAG;AAAA,IACxD;AAAA,IACA,iBAAiB,UAAQ,mBAAmB,KAAK,IAAI,KAAK,IAAI;AAAA,EAChE,CAAC;AAMD,SAAO;AAAA,IACL,GAAG;AAAA,IACH,MAAM,iBAAiB,cAAc;AACnC,YAAM,SAA0B,CAAC;AACjC,iBAAW,MAAM,cAAc;AAC7B,YAAI,OAAO,OAAO,UAAU;AAC1B,gBAAM,wBAAwB,KAAK,GAAG,QAAQ,OAAO,EAAE,CAAC;AACxD,iBAAO,KAAK,MAAM,OAAO,mBAAmB,EAAE,sBAAsB,CAAC,CAAC;AAAA,QACxE,OAAO;AACL,iBAAO,KAAK,MAAM,mBAAmB,GAAG,IAAI,GAAG,MAAM,GAAG,GAAG,CAAC;AAAA,QAC9D;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

package/dist/esm/index.d.mts

@@ -0,0 +1,338 @@
+export { E as ExactEvmScheme } from './scheme-D8ZbykGV.mjs';
+export { C as ClientEvmSigner, F as FacilitatorEvmSigner, t as toClientEvmSigner, a as toFacilitatorEvmSigner } from './signer-BFelv8DL.mjs';
+export { a as PERMIT2_ADDRESS, P as Permit2AllowanceParams, d as authorizationTypes, c as createPermit2ApprovalTx, f as eip3009ABI, e as erc20AllowanceAbi, g as getPermit2AllowanceReadParams, p as permit2WitnessTypes, u as uptoPermit2WitnessTypes, h as x402ExactPermit2ProxyABI, x as x402ExactPermit2ProxyAddress, i as x402UptoPermit2ProxyABI, b as x402UptoPermit2ProxyAddress } from './permit2-DhJRUcgY.mjs';
+export { UptoEvmScheme } from './upto/client/index.mjs';
+export { a as BatchSettlementEvmScheme } from './scheme-CkNhpXrG.mjs';
+export { A as AuthorizerSigner, i as BatchSettlementClaimPayload, e as BatchSettlementDepositPayload, j as BatchSettlementEnrichedRefundPayload, h as BatchSettlementErc3009Authorization, m as BatchSettlementFacilitatorSettlePayload, k as BatchSettlementPayload, n as BatchSettlementPaymentRequirementsExtra, o as BatchSettlementPaymentResponseExtra, g as BatchSettlementRefundPayload, l as BatchSettlementSettlePayload, B as BatchSettlementVoucherClaim, a as BatchSettlementVoucherFields, f as BatchSettlementVoucherPayload, C as ChannelConfig, d as ChannelState, s as isBatchSettlementClaimPayload, p as isBatchSettlementDepositPayload, u as isBatchSettlementEnrichedRefundPayload, r as isBatchSettlementRefundPayload, t as isBatchSettlementSettlePayload, q as isBatchSettlementVoucherPayload } from './types-DIt9uAUy.mjs';
+import { Network, FacilitatorContext, PaymentPayload, PaymentRequirements, FacilitatorExtension } from '@bankofai/x402-core/types';
+import { Hex } from 'viem';
+export { AuthCaptureEvmScheme } from './auth-capture/client/index.mjs';
+import './rpc-DULZzRne.mjs';
+import './storage-6W5MO46W.mjs';
+
+/**
+ * Asset transfer methods for the exact EVM scheme.
+ * - eip3009: Uses transferWithAuthorization (USDC, etc.) - recommended for compatible tokens
+ * - permit2: Uses Permit2 + x402Permit2Proxy - universal fallback for any ERC-20
+ */
+type AssetTransferMethod = "eip3009" | "permit2";
+/**
+ * EIP-3009 payload for tokens with native transferWithAuthorization support.
+ */
+type ExactEIP3009Payload = {
+    signature?: `0x${string}`;
+    authorization: {
+        from: `0x${string}`;
+        to: `0x${string}`;
+        value: string;
+        validAfter: string;
+        validBefore: string;
+        nonce: `0x${string}`;
+    };
+};
+/**
+ * Permit2 witness data structure.
+ * Matches the Witness struct in x402Permit2Proxy contract.
+ * Note: Upper time bound is enforced by Permit2's `deadline` field, not a witness field.
+ */
+type Permit2Witness = {
+    to: `0x${string}`;
+    validAfter: string;
+};
+/**
+ * Permit2 authorization parameters.
+ * Used to reconstruct the signed message for verification.
+ */
+type Permit2Authorization = {
+    permitted: {
+        token: `0x${string}`;
+        amount: string;
+    };
+    spender: `0x${string}`;
+    nonce: string;
+    deadline: string;
+    witness: Permit2Witness;
+};
+/**
+ * Permit2 payload for tokens using the Permit2 + x402Permit2Proxy flow.
+ */
+type ExactPermit2Payload = {
+    signature: `0x${string}`;
+    permit2Authorization: Permit2Authorization & {
+        from: `0x${string}`;
+    };
+};
+type ExactEvmPayloadV1 = ExactEIP3009Payload;
+type ExactEvmPayloadV2 = ExactEIP3009Payload | ExactPermit2Payload;
+/**
+ * Type guard to check if a payload is a Permit2 payload.
+ * Permit2 payloads have a `permit2Authorization` field.
+ *
+ * @param payload - The payload to check.
+ * @returns True if the payload is a Permit2 payload, false otherwise.
+ */
+declare function isPermit2Payload(payload: ExactEvmPayloadV2): payload is ExactPermit2Payload;
+/**
+ * Type guard to check if a payload is an EIP-3009 payload.
+ * EIP-3009 payloads have an `authorization` field.
+ *
+ * @param payload - The payload to check.
+ * @returns True if the payload is an EIP-3009 payload, false otherwise.
+ */
+declare function isEIP3009Payload(payload: ExactEvmPayloadV2): payload is ExactEIP3009Payload;
+/**
+ * Upto Permit2 witness — includes `facilitator` field absent from exact witness.
+ * Only the address matching `witness.facilitator` can call settle() on-chain.
+ */
+type UptoPermit2Witness = {
+    to: `0x${string}`;
+    facilitator: `0x${string}`;
+    validAfter: string;
+};
+type UptoPermit2Authorization = {
+    permitted: {
+        token: `0x${string}`;
+        amount: string;
+    };
+    spender: `0x${string}`;
+    nonce: string;
+    deadline: string;
+    witness: UptoPermit2Witness;
+};
+type UptoPermit2Payload = {
+    signature: `0x${string}`;
+    permit2Authorization: UptoPermit2Authorization & {
+        from: `0x${string}`;
+    };
+};
+
+/**
+ * Type guard to check if a payload is an upto Permit2 payload.
+ * Validates structural presence of all required fields: signature, permit2Authorization
+ * (with from, permitted, spender, nonce, deadline), and a witness containing facilitator.
+ *
+ * @param payload - The payload to check.
+ * @returns True if the payload is an upto Permit2 payload, false otherwise.
+ */
+declare function isUptoPermit2Payload(payload: Record<string, unknown>): payload is UptoPermit2Payload;
+
+/** Scheme identifier for the batch-settlement payment scheme. */
+declare const BATCH_SETTLEMENT_SCHEME: "batch-settlement";
+/** Deployed address of the x402BatchSettlement contract. */
+declare const BATCH_SETTLEMENT_ADDRESS: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003";
+/** Deployed address of the ERC3009DepositCollector contract. */
+declare const ERC3009_DEPOSIT_COLLECTOR_ADDRESS: "0x4020806089470a89826cB9fB1f4059150b550004";
+/** EIP-712 domain fields shared across all batch-settlement typed-data signatures. */
+declare const BATCH_SETTLEMENT_DOMAIN: {
+    readonly name: "x402 Batch Settlement";
+    readonly version: "1";
+};
+/** EIP-712 type definition for a cumulative voucher: `Voucher(bytes32 channelId, uint128 maxClaimableAmount)`. */
+declare const voucherTypes: {
+    readonly Voucher: readonly [{
+        readonly name: "channelId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "maxClaimableAmount";
+        readonly type: "uint128";
+    }];
+};
+/** EIP-712 type definition for cooperative refund: `Refund(bytes32 channelId, uint256 nonce, uint128 amount)`. */
+declare const refundTypes: {
+    readonly Refund: readonly [{
+        readonly name: "channelId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint128";
+    }];
+};
+/** EIP-712 type definitions for a receiver-authorizer claim batch (nested ClaimEntry). */
+declare const claimBatchTypes: {
+    readonly ClaimBatch: readonly [{
+        readonly name: "claims";
+        readonly type: "ClaimEntry[]";
+    }];
+    readonly ClaimEntry: readonly [{
+        readonly name: "channelId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "maxClaimableAmount";
+        readonly type: "uint128";
+    }, {
+        readonly name: "totalClaimed";
+        readonly type: "uint128";
+    }];
+};
+
+/**
+ * Base stablecoin asset configuration shared across all EVM payment schemes.
+ * Contains the core fields needed to identify and convert tokens.
+ */
+type DefaultAssetInfo = {
+    /** Token contract address */
+    address: string;
+    /** EIP-712 domain name (must match the token's domain separator) */
+    name: string;
+    /** EIP-712 domain version (must match the token's domain separator) */
+    version: string;
+    /** Token decimal places (typically 6 for USDC) */
+    decimals: number;
+};
+/**
+ * Extended asset configuration for the exact scheme.
+ * Includes transfer method hints that control client-side behaviour.
+ */
+type ExactDefaultAssetInfo = DefaultAssetInfo & {
+    /**
+     * Transfer method override: `"permit2"` for tokens that don't support EIP-3009.
+     * Omit for EIP-3009 tokens (default behaviour).
+     */
+    assetTransferMethod?: string;
+    /**
+     * Set to `true` for permit2 tokens that implement EIP-2612 `permit()`.
+     * Controls whether name/version are included in `extra` so the client can
+     * sign a gasless EIP-2612 permit for Permit2 approval.
+     */
+    supportsEip2612?: boolean;
+};
+/**
+ * Default stablecoins indexed by CAIP-2 network identifier.
+ *
+ * Each network has the right to determine its own default stablecoin that can
+ * be expressed as a USD string by calling servers. See DEFAULT_ASSET.md in
+ * exact/server/ for how to add new chains.
+ */
+declare const DEFAULT_STABLECOINS: Record<string, ExactDefaultAssetInfo>;
+/**
+ * Look up the default stablecoin for a network.
+ *
+ * @param network - CAIP-2 network identifier (e.g. "eip155:8453")
+ * @returns The default asset info
+ * @throws If no default asset is configured for the network
+ */
+declare function getDefaultAsset(network: Network): ExactDefaultAssetInfo;
+
+declare const BUILDER_CODE_KEY: "builder-code";
+interface DataSuffixContext {
+    paymentPayload: PaymentPayload;
+    paymentRequirements: PaymentRequirements;
+}
+interface BuilderCodeFacilitatorExtension extends FacilitatorExtension {
+    key: typeof BUILDER_CODE_KEY;
+    buildDataSuffix?(ctx: DataSuffixContext): Hex | undefined | Promise<Hex | undefined>;
+}
+/**
+ * Resolves and concatenates data suffixes from registered extensions.
+ *
+ * @param context - Facilitator context with registered extensions
+ * @param ctx - Data suffix context passed to extension resolvers
+ * @returns Hex-encoded suffix to append to settlement calldata, or undefined if none
+ */
+declare function resolveDataSuffix(context: FacilitatorContext | undefined, ctx: DataSuffixContext): Promise<Hex | undefined>;
+/**
+ * Appends a hex data suffix to encoded contract calldata.
+ *
+ * @param calldata - Base encoded function calldata
+ * @param suffix - Optional hex suffix (with or without 0x prefix)
+ * @returns Calldata with suffix appended, or the original calldata when suffix is empty
+ */
+declare function appendDataSuffix(calldata: Hex, suffix?: Hex): Hex;
+
+/**
+ * auth-capture wire-format types.
+ *
+ * Spec-level field names (captureAuthorizer, captureDeadline, refundDeadline,
+ * feeRecipient) live here at the extra/wire layer. The on-chain PaymentInfo
+ * struct keeps the canonical Solidity field names (operator, authorizationExpiry,
+ * refundExpiry, feeReceiver) so the EIP-712 typehash stays byte-identical with
+ * the AuthCaptureEscrow contract.
+ *
+ * Salt is NOT in extra. It is generated client-side per signing call and rides
+ * on the payload alongside the signature.
+ */
+
+interface AuthCaptureExtra {
+    captureAuthorizer: `0x${string}`;
+    captureDeadline: number;
+    refundDeadline: number;
+    feeRecipient: `0x${string}`;
+    minFeeBps: number;
+    maxFeeBps: number;
+    name: string;
+    version: string;
+    autoCapture?: boolean;
+    assetTransferMethod?: AssetTransferMethod;
+}
+/**
+ * Type guard for AuthCaptureExtra. Checks the structural shape an auth-capture
+ * scheme requires inside `PaymentRequirements.extra`: every spec-mandated
+ * required field present with the right primitive type.
+ *
+ * @param value - Candidate object from `requirements.extra`.
+ * @returns True if `value` has every required AuthCaptureExtra field.
+ */
+declare function isAuthCaptureExtra(value: unknown): value is AuthCaptureExtra;
+interface Eip3009Payload {
+    authorization: {
+        from: `0x${string}`;
+        to: `0x${string}`;
+        value: string;
+        validAfter: string;
+        validBefore: string;
+        nonce: `0x${string}`;
+    };
+    signature: `0x${string}`;
+    salt: `0x${string}`;
+}
+interface Permit2Payload {
+    permit2Authorization: {
+        from: `0x${string}`;
+        permitted: {
+            token: `0x${string}`;
+            amount: string;
+        };
+        spender: `0x${string}`;
+        nonce: string;
+        deadline: string;
+    };
+    signature: `0x${string}`;
+    salt: `0x${string}`;
+}
+type AuthCapturePayload = Eip3009Payload | Permit2Payload;
+/**
+ * Type guard for any auth-capture payload. Returns true if `value` matches
+ * either the EIP-3009 envelope or the Permit2 envelope.
+ *
+ * @param value - Candidate payment payload from the wire.
+ * @returns True if `value` is a valid auth-capture envelope of either shape.
+ */
+declare function isAuthCapturePayload(value: unknown): value is AuthCapturePayload;
+/**
+ * On-chain PaymentInfo struct (canonical Solidity names — DO NOT RENAME).
+ * Reconstructed by the facilitator from extra + payload.salt + payer + receiver/asset/amount.
+ */
+interface PaymentInfoStruct {
+    operator: `0x${string}`;
+    payer: `0x${string}`;
+    receiver: `0x${string}`;
+    token: `0x${string}`;
+    maxAmount: string;
+    preApprovalExpiry: number;
+    authorizationExpiry: number;
+    refundExpiry: number;
+    minFeeBps: number;
+    maxFeeBps: number;
+    feeReceiver: `0x${string}`;
+    salt: `0x${string}`;
+}
+
+declare const AUTH_CAPTURE_SCHEME: "auth-capture";
+declare const AUTH_CAPTURE_ESCROW_ADDRESS: "0xBdEA0D1bcC5966192B070Fdf62aB4EF5b4420cff";
+declare const EIP3009_TOKEN_COLLECTOR_ADDRESS: "0x0E3dF9510de65469C4518D7843919c0b8C7A7757";
+declare const PERMIT2_TOKEN_COLLECTOR_ADDRESS: "0x992476B9Ee81d52a5BdA0622C333938D0Af0aB26";
+
+export { AUTH_CAPTURE_ESCROW_ADDRESS, AUTH_CAPTURE_SCHEME, type AssetTransferMethod, type Eip3009Payload as AuthCaptureEip3009Payload, type AuthCaptureExtra, type AuthCapturePayload, type PaymentInfoStruct as AuthCapturePaymentInfo, type Permit2Payload as AuthCapturePermit2Payload, BATCH_SETTLEMENT_ADDRESS, BATCH_SETTLEMENT_DOMAIN, BATCH_SETTLEMENT_SCHEME, BUILDER_CODE_KEY, type BuilderCodeFacilitatorExtension, DEFAULT_STABLECOINS, type DataSuffixContext, type DefaultAssetInfo, EIP3009_TOKEN_COLLECTOR_ADDRESS, ERC3009_DEPOSIT_COLLECTOR_ADDRESS, type ExactDefaultAssetInfo, type ExactEIP3009Payload, type ExactEvmPayloadV1, type ExactEvmPayloadV2, type ExactPermit2Payload, PERMIT2_TOKEN_COLLECTOR_ADDRESS, type Permit2Authorization, type Permit2Witness, type UptoPermit2Authorization, type UptoPermit2Payload, type UptoPermit2Witness, appendDataSuffix, claimBatchTypes, getDefaultAsset, isAuthCaptureExtra, isAuthCapturePayload, isEIP3009Payload, isPermit2Payload, isUptoPermit2Payload, refundTypes, resolveDataSuffix, voucherTypes };