@x402r/evm 0.0.2 → 0.0.3

package/src/escrow/server/scheme.ts

@@ -0,0 +1,226 @@
+/**
+ * Escrow Scheme - Server
+ * Handles price parsing and requirement enhancement for resource servers.
+ *
+ * Implements x402's SchemeNetworkServer interface so it can be registered
+ * on an x402ResourceServer via server.register('eip155:84532', new EscrowServerScheme()).
+ */
+
+import type {
+  AssetAmount,
+  MoneyParser,
+  Network,
+  PaymentRequirements,
+  Price,
+  SchemeNetworkServer,
+} from '@x402/core/types'
+
+/**
+ * Asset info including EIP-712 domain parameters per network
+ */
+const ASSET_INFO: Record<
+  string,
+  { address: string; name: string; version: string; decimals: number }
+> = {
+  // Base Sepolia
+  'eip155:84532': {
+    address: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
+    name: 'USDC',
+    version: '2',
+    decimals: 6,
+  },
+  // Base mainnet
+  'eip155:8453': {
+    address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+    name: 'USD Coin',
+    version: '2',
+    decimals: 6,
+  },
+  // Ethereum Sepolia
+  'eip155:11155111': {
+    address: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238',
+    name: 'USDC',
+    version: '2',
+    decimals: 6,
+  },
+  // Ethereum mainnet
+  'eip155:1': {
+    address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    name: 'USD Coin',
+    version: '2',
+    decimals: 6,
+  },
+  // Polygon
+  'eip155:137': {
+    address: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+    name: 'USD Coin',
+    version: '2',
+    decimals: 6,
+  },
+  // Arbitrum
+  'eip155:42161': {
+    address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+    name: 'USD Coin',
+    version: '2',
+    decimals: 6,
+  },
+  // Celo
+  'eip155:42220': {
+    address: '0xcebA9300f2b948710d2653dD7B07f33A8B32118C',
+    name: 'USD Coin',
+    version: '2',
+    decimals: 6,
+  },
+  // Monad
+  'eip155:143': {
+    address: '0x754704Bc059F8C67012fEd69BC8A327a5aafb603',
+    name: 'USDC',
+    version: '2',
+    decimals: 6,
+  },
+  // Avalanche
+  'eip155:43114': {
+    address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
+    name: 'USD Coin',
+    version: '2',
+    decimals: 6,
+  },
+}
+
+/**
+ * Convert decimal amount to token units using string-based conversion
+ * (e.g., 0.10 -> 100000 for 6-decimal tokens)
+ * Avoids floating-point precision issues from BigInt(Math.round(...))
+ */
+function convertToTokenAmount(decimalAmount: string, decimals: number): string {
+  const amount = parseFloat(decimalAmount)
+  if (isNaN(amount)) {
+    throw new Error(`Invalid amount: ${decimalAmount}`)
+  }
+  const [intPart, decPart = ''] = String(amount).split('.')
+  const paddedDec = decPart.padEnd(decimals, '0').slice(0, decimals)
+  const tokenAmount = (intPart + paddedDec).replace(/^0+/, '') || '0'
+  return tokenAmount
+}
+
+/**
+ * Server scheme - handles price parsing and requirement enhancement.
+ * Implements x402's SchemeNetworkServer interface.
+ */
+export class EscrowServerScheme implements SchemeNetworkServer {
+  readonly scheme = 'escrow'
+  private moneyParsers: MoneyParser[] = []
+
+  /**
+   * Register a custom money parser in the parser chain.
+   * Multiple parsers can be registered — they will be tried in registration order.
+   * Each parser receives a decimal amount (e.g., 1.50 for $1.50).
+   * If a parser returns null, the next parser in the chain will be tried.
+   * The default parser (USDC) is always the final fallback.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount (or null to skip)
+   * @returns The server instance for chaining
+   */
+  registerMoneyParser(parser: MoneyParser): EscrowServerScheme {
+    this.moneyParsers.push(parser)
+    return this
+  }
+
+  /**
+   * Parse a price into an x402 AssetAmount.
+   *
+   * Accepts x402's Price type:
+   * - string: "$0.01", "0.01", "10000"
+   * - number: 0.01
+   * - AssetAmount: { asset: "0x...", amount: "10000" }
+   */
+  async parsePrice(price: Price, network: Network): Promise<AssetAmount> {
+    // If already an AssetAmount, pass through with validation
+    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 || {},
+      }
+    }
+
+    // Parse Money to decimal number
+    const numericAmount = this.parseMoneyToDecimal(price)
+
+    // Try each custom money parser in order
+    for (const parser of this.moneyParsers) {
+      const result = await parser(numericAmount, network)
+      if (result !== null) {
+        return result
+      }
+    }
+
+    // All custom parsers returned null (or none registered), use default conversion
+    return this.defaultMoneyConversion(numericAmount, network)
+  }
+
+  /**
+   * Parse Money (string | number) to a decimal number.
+   */
+  private parseMoneyToDecimal(money: string | number): number {
+    if (typeof money === 'number') {
+      return money
+    }
+    const cleaned = String(money).replace(/[$,]/g, '').trim()
+    const amount = parseFloat(cleaned)
+    if (isNaN(amount)) {
+      throw new Error(`Cannot parse price: ${money}`)
+    }
+    return amount
+  }
+
+  /**
+   * Default money conversion — converts decimal amount to the default stablecoin on the network.
+   */
+  private defaultMoneyConversion(amount: number, network: Network): AssetAmount {
+    const assetInfo = ASSET_INFO[network]
+    if (!assetInfo) {
+      throw new Error(`No USDC address configured for network: ${network}`)
+    }
+
+    const tokenAmount = convertToTokenAmount(String(amount), assetInfo.decimals)
+
+    return {
+      asset: assetInfo.address,
+      amount: tokenAmount,
+      extra: {
+        name: assetInfo.name,
+        version: assetInfo.version,
+      },
+    }
+  }
+
+  /**
+   * Enhance payment requirements with facilitator's extra fields.
+   *
+   * Merges supportedKind.extra (from facilitator's /supported endpoint) into
+   * the requirements, so escrow addresses flow from facilitator → merchant
+   * requirements automatically.
+   */
+  async enhancePaymentRequirements(
+    requirements: PaymentRequirements,
+    supportedKind: {
+      x402Version: number
+      scheme: string
+      network: Network
+      extra?: Record<string, unknown>
+    },
+    _facilitatorExtensions: string[],
+  ): Promise<PaymentRequirements> {
+    return {
+      ...requirements,
+      extra: {
+        ...supportedKind.extra,
+        ...requirements.extra,
+      },
+    }
+  }
+}

package/src/escrow/shared/constants.ts

@@ -0,0 +1,65 @@
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as const
+export const MAX_UINT48 = 281474976710655
+export const MAX_UINT32 = 4294967295
+
+// PaymentInfo struct for AuthCaptureEscrow (matches commerce-payments contract)
+export const PAYMENT_INFO_COMPONENTS = [
+  { name: 'operator', type: 'address' },
+  { name: 'payer', type: 'address' },
+  { name: 'receiver', type: 'address' },
+  { name: 'token', type: 'address' },
+  { name: 'maxAmount', type: 'uint120' },
+  { name: 'preApprovalExpiry', type: 'uint48' },
+  { name: 'authorizationExpiry', type: 'uint48' },
+  { name: 'refundExpiry', type: 'uint48' },
+  { name: 'minFeeBps', type: 'uint16' },
+  { name: 'maxFeeBps', type: 'uint16' },
+  { name: 'feeReceiver', type: 'address' },
+  { name: 'salt', type: 'uint256' },
+] as const
+
+export const OPERATOR_ABI = [
+  {
+    name: 'authorize',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      {
+        name: 'paymentInfo',
+        type: 'tuple',
+        components: PAYMENT_INFO_COMPONENTS,
+      },
+      { name: 'amount', type: 'uint256' },
+      { name: 'tokenCollector', type: 'address' },
+      { name: 'collectorData', type: 'bytes' },
+    ],
+    outputs: [],
+  },
+] as const
+
+// ERC-3009 TransferWithAuthorization type hash
+export const TRANSFER_WITH_AUTHORIZATION_TYPEHASH =
+  '0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267' as const
+
+// ERC-3009 ReceiveWithAuthorization EIP-712 types
+export const RECEIVE_AUTHORIZATION_TYPES = {
+  ReceiveWithAuthorization: [
+    { name: 'from', type: 'address' },
+    { name: 'to', type: 'address' },
+    { name: 'value', type: 'uint256' },
+    { name: 'validAfter', type: 'uint256' },
+    { name: 'validBefore', type: 'uint256' },
+    { name: 'nonce', type: 'bytes32' },
+  ],
+} as const
+
+// ERC-20 balanceOf ABI for balance checks
+export const ERC20_BALANCE_OF_ABI = [
+  {
+    name: 'balanceOf',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ name: 'balance', type: 'uint256' }],
+  },
+] as const

package/src/escrow/shared/nonce.ts

@@ -0,0 +1,175 @@
+/**
+ * Nonce computation and ERC-3009 signing utilities
+ * Adapted from @agentokratia/x402-escrow (MIT)
+ */
+
+import { encodeAbiParameters, getAddress, keccak256, toHex } from 'viem'
+import type { ClientEvmSigner } from '@x402/evm'
+import { ZERO_ADDRESS, RECEIVE_AUTHORIZATION_TYPES } from './constants'
+import type { EscrowExtra, EscrowPayload } from './types'
+
+/**
+ * PaymentInfo typehash - must match AuthCaptureEscrow.PAYMENT_INFO_TYPEHASH
+ */
+const PAYMENT_INFO_TYPEHASH = keccak256(
+  new TextEncoder().encode(
+    'PaymentInfo(address operator,address payer,address receiver,address token,uint120 maxAmount,uint48 preApprovalExpiry,uint48 authorizationExpiry,uint48 refundExpiry,uint16 minFeeBps,uint16 maxFeeBps,address feeReceiver,uint256 salt)',
+  ),
+)
+
+/**
+ * Compute escrow nonce for ERC-3009 authorization
+ * Must match AuthCaptureEscrow.getHash() with payer=address(0)
+ */
+export function computeEscrowNonce(
+  chainId: number,
+  escrowAddress: `0x${string}`,
+  paymentInfo: EscrowPayload['paymentInfo'],
+): `0x${string}` {
+  // Step 1: Encode paymentInfo with payer=0 (payer-agnostic)
+  const paymentInfoEncoded = encodeAbiParameters(
+    [
+      { name: 'typehash', type: 'bytes32' },
+      { name: 'operator', type: 'address' },
+      { name: 'payer', type: 'address' },
+      { name: 'receiver', type: 'address' },
+      { name: 'token', type: 'address' },
+      { name: 'maxAmount', type: 'uint120' },
+      { name: 'preApprovalExpiry', type: 'uint48' },
+      { name: 'authorizationExpiry', type: 'uint48' },
+      { name: 'refundExpiry', type: 'uint48' },
+      { name: 'minFeeBps', type: 'uint16' },
+      { name: 'maxFeeBps', type: 'uint16' },
+      { name: 'feeReceiver', type: 'address' },
+      { name: 'salt', type: 'uint256' },
+    ],
+    [
+      PAYMENT_INFO_TYPEHASH,
+      paymentInfo.operator,
+      ZERO_ADDRESS, // payer-agnostic
+      paymentInfo.receiver,
+      paymentInfo.token,
+      BigInt(paymentInfo.maxAmount),
+      paymentInfo.preApprovalExpiry,
+      paymentInfo.authorizationExpiry,
+      paymentInfo.refundExpiry,
+      paymentInfo.minFeeBps,
+      paymentInfo.maxFeeBps,
+      paymentInfo.feeReceiver,
+      BigInt(paymentInfo.salt),
+    ],
+  )
+  const paymentInfoHash = keccak256(paymentInfoEncoded)
+
+  // Step 2: Encode (chainId, escrow, paymentInfoHash) and hash
+  const outerEncoded = encodeAbiParameters(
+    [
+      { name: 'chainId', type: 'uint256' },
+      { name: 'escrow', type: 'address' },
+      { name: 'paymentInfoHash', type: 'bytes32' },
+    ],
+    [BigInt(chainId), escrowAddress, paymentInfoHash],
+  )
+
+  return keccak256(outerEncoded)
+}
+
+/**
+ * Sign ERC-3009 ReceiveWithAuthorization
+ * Note: receiveWithAuthorization uses a different primary type than transferWithAuthorization
+ */
+export async function signERC3009(
+  signer: ClientEvmSigner,
+  authorization: EscrowPayload['authorization'],
+  extra: EscrowExtra,
+  tokenAddress: `0x${string}`,
+  chainId: number,
+): Promise<`0x${string}`> {
+  // EIP-712 domain - name must match the token's EIP-712 domain
+  // (e.g., "USDC" for Base USDC, not "USD Coin")
+  const domain = {
+    name: extra.name,
+    version: extra.version,
+    chainId,
+    verifyingContract: getAddress(tokenAddress),
+  }
+
+  const message = {
+    from: getAddress(authorization.from),
+    to: getAddress(authorization.to),
+    value: BigInt(authorization.value),
+    validAfter: BigInt(authorization.validAfter),
+    validBefore: BigInt(authorization.validBefore),
+    nonce: authorization.nonce,
+  }
+
+  return signer.signTypedData({
+    domain,
+    types: RECEIVE_AUTHORIZATION_TYPES,
+    primaryType: 'ReceiveWithAuthorization',
+    message,
+  })
+}
+
+/**
+ * Verify ERC-3009 signature (facilitator-side)
+ * @param signer - The signer with verifyTypedData method
+ * @param authorization - ERC-3009 authorization data
+ * @param signature - The signature to verify
+ * @param extra - Extra configuration including chainId
+ * @param tokenAddress - The token contract address (verifyingContract for EIP-712)
+ */
+export async function verifyERC3009Signature(
+  signer: {
+    verifyTypedData: (_args: {
+      address: `0x${string}`
+      domain: Record<string, unknown>
+      types: Record<string, unknown>
+      primaryType: string
+      message: Record<string, unknown>
+      signature: `0x${string}`
+    }) => Promise<boolean>
+  },
+  authorization: EscrowPayload['authorization'],
+  signature: `0x${string}`,
+  extra: EscrowExtra & { chainId: number },
+  tokenAddress: `0x${string}`,
+): Promise<boolean> {
+  const domain = {
+    name: extra.name,
+    version: extra.version,
+    chainId: extra.chainId,
+    verifyingContract: getAddress(tokenAddress),
+  }
+
+  const message = {
+    from: getAddress(authorization.from),
+    to: getAddress(authorization.to),
+    value: BigInt(authorization.value),
+    validAfter: BigInt(authorization.validAfter),
+    validBefore: BigInt(authorization.validBefore),
+    nonce: authorization.nonce,
+  }
+
+  try {
+    return await signer.verifyTypedData({
+      address: getAddress(authorization.from),
+      domain,
+      types: RECEIVE_AUTHORIZATION_TYPES,
+      primaryType: 'ReceiveWithAuthorization',
+      message,
+      signature,
+    })
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Generate random salt for paymentInfo
+ */
+export function generateSalt(): `0x${string}` {
+  const bytes = new Uint8Array(32)
+  crypto.getRandomValues(bytes)
+  return toHex(bytes)
+}

package/src/escrow/shared/types.ts

@@ -0,0 +1,69 @@
+/**
+ * Type guard for EscrowPayload
+ */
+export function isEscrowPayload(value: unknown): value is EscrowPayload {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'authorization' in value &&
+    'signature' in value &&
+    'paymentInfo' in value
+  )
+}
+
+/**
+ * Type guard for EscrowExtra
+ */
+export function isEscrowExtra(value: unknown): value is EscrowExtra {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'escrowAddress' in value &&
+    'operatorAddress' in value &&
+    'tokenCollector' in value
+  )
+}
+
+// EscrowExtra - fields in PaymentRequirements.extra
+export interface EscrowExtra {
+  escrowAddress: `0x${string}`
+  operatorAddress: `0x${string}`
+  tokenCollector: `0x${string}`
+  authorizeAddress?: `0x${string}`
+  minDeposit?: string
+  maxDeposit?: string
+  preApprovalExpirySeconds?: number
+  authorizationExpirySeconds?: number
+  refundExpirySeconds?: number
+  minFeeBps?: number
+  maxFeeBps?: number
+  feeReceiver?: `0x${string}`
+  name: string // EIP-712 domain name (e.g., "USDC" for Base USDC)
+  version: string // EIP-712 domain version (e.g., "2" for USDC)
+}
+
+// EscrowPayload - the payload field in PaymentPayload
+export interface EscrowPayload {
+  authorization: {
+    from: `0x${string}`
+    to: `0x${string}`
+    value: string
+    validAfter: string
+    validBefore: string
+    nonce: `0x${string}`
+  }
+  signature: `0x${string}`
+  paymentInfo: {
+    operator: `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}`
+  }
+}

package/src/escrow/shared/utils.ts

@@ -0,0 +1,16 @@
+/**
+ * Parse chainId from CAIP-2 network identifier
+ * @param network - CAIP-2 network identifier (e.g., 'eip155:84532')
+ * @returns The chain ID as a number
+ */
+export function parseChainId(network: string): number {
+  const parts = network.split(':')
+  if (parts.length !== 2 || parts[0] !== 'eip155') {
+    throw new Error(`Invalid network format: ${network}. Expected 'eip155:<chainId>'`)
+  }
+  const chainId = parseInt(parts[1], 10)
+  if (isNaN(chainId)) {
+    throw new Error(`Invalid chainId in network: ${network}`)
+  }
+  return chainId
+}

package/dist/escrow/client/index.d.ts

@@ -1,40 +0,0 @@
-/**
- * Escrow Scheme - Client
- * Creates payment payloads for escrow payments.
- *
- * Implements x402's SchemeNetworkClient interface so it can be registered
- * on an x402Client via client.register('eip155:84532', new EscrowEvmScheme(signer)).
- */
-import type { Network, PaymentPayload, PaymentRequirements, SchemeNetworkClient } from "@x402/core/types";
-import type { ClientEvmSigner } from "@x402/evm";
-import { x402Client } from "@x402/core/client";
-/**
- * Escrow Client Scheme - implements x402's SchemeNetworkClient
- */
-export declare class EscrowEvmScheme implements SchemeNetworkClient {
-    private readonly signer;
-    readonly scheme = "escrow";
-    constructor(signer: ClientEvmSigner);
-    createPaymentPayload(x402Version: number, requirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
-}
-/**
- * Register escrow client scheme with x402Client
- *
- * @example
- * ```typescript
- * const client = new x402Client();
- * registerEscrowScheme(client, { signer, networks: "eip155:84532" });
- * ```
- */
-export declare function registerEscrowScheme(client: x402Client, config: {
-    signer: ClientEvmSigner;
-    networks: Network | Network[];
-}): x402Client;
-/**
- * @deprecated Use `new EscrowEvmScheme(signer)` directly
- */
-export declare const EscrowScheme: {
-    scheme: "escrow";
-};
-export type { EscrowExtra, EscrowPayload } from "../../shared/types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/escrow/client/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/escrow/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA0B/C;;GAEG;AACH,qBAAa,eAAgB,YAAW,mBAAmB;IAG7C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,QAAQ,CAAC,MAAM,YAAY;gBAEE,MAAM,EAAE,eAAe;IAE9C,oBAAoB,CACxB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,mBAAmB,GAChC,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,aAAa,GAAG,SAAS,CAAC,CAAC;CA4E5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,EAAE,CAAA;CAAE,GACjE,UAAU,CASZ;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/escrow/client/index.js

@@ -1,104 +0,0 @@
-/**
- * Escrow Scheme - Client
- * Creates payment payloads for escrow payments.
- *
- * Implements x402's SchemeNetworkClient interface so it can be registered
- * on an x402Client via client.register('eip155:84532', new EscrowEvmScheme(signer)).
- */
-import { computeEscrowNonce, signERC3009, generateSalt, } from "../../shared/nonce.js";
-import { MAX_UINT48 } from "../../shared/constants.js";
-/**
- * Parse chainId from CAIP-2 network identifier
- */
-function parseChainId(network) {
-    const parts = network.split(":");
-    if (parts.length !== 2 || parts[0] !== "eip155") {
-        throw new Error(`Invalid network format: ${network}. Expected 'eip155:<chainId>'`);
-    }
-    const chainId = parseInt(parts[1], 10);
-    if (isNaN(chainId)) {
-        throw new Error(`Invalid chainId in network: ${network}`);
-    }
-    return chainId;
-}
-/**
- * Escrow Client Scheme - implements x402's SchemeNetworkClient
- */
-export class EscrowEvmScheme {
-    signer;
-    scheme = "escrow";
-    constructor(signer) {
-        this.signer = signer;
-    }
-    async createPaymentPayload(x402Version, requirements) {
-        if (x402Version !== 2) {
-            throw new Error(`Unsupported x402Version: ${x402Version}. Only version 2 is supported.`);
-        }
-        const extra = requirements.extra;
-        // Validate required EIP-712 domain parameters (M3, M10)
-        if (!extra.name) {
-            throw new Error(`EIP-712 domain parameter 'name' is required in payment requirements for asset ${requirements.asset}`);
-        }
-        if (!extra.version) {
-            throw new Error(`EIP-712 domain parameter 'version' is required in payment requirements for asset ${requirements.asset}`);
-        }
-        const { escrowAddress, operatorAddress, tokenCollector, minFeeBps = 0, maxFeeBps = 0, feeReceiver, preApprovalExpirySeconds, refundExpirySeconds, authorizationExpirySeconds, } = extra;
-        const chainId = parseChainId(requirements.network);
-        const maxAmount = requirements.amount;
-        const paymentInfo = {
-            operator: operatorAddress,
-            receiver: requirements.payTo,
-            token: requirements.asset,
-            maxAmount,
-            preApprovalExpiry: preApprovalExpirySeconds ?? MAX_UINT48,
-            authorizationExpiry: authorizationExpirySeconds ?? MAX_UINT48,
-            refundExpiry: refundExpirySeconds ?? MAX_UINT48,
-            minFeeBps,
-            maxFeeBps,
-            feeReceiver: feeReceiver ?? operatorAddress,
-            salt: generateSalt(),
-        };
-        const nonce = computeEscrowNonce(chainId, escrowAddress, paymentInfo);
-        // ERC-3009 authorization - validBefore MUST match what contract passes to receiveWithAuthorization
-        // The contract uses paymentInfo.preApprovalExpiry as validBefore
-        const authorization = {
-            from: this.signer.address,
-            to: tokenCollector,
-            value: maxAmount,
-            validAfter: "0",
-            validBefore: String(paymentInfo.preApprovalExpiry),
-            nonce,
-        };
-        const signature = await signERC3009(this.signer, authorization, extra, requirements.asset, chainId);
-        return {
-            x402Version,
-            payload: { authorization, signature, paymentInfo },
-        };
-    }
-}
-/**
- * Register escrow client scheme with x402Client
- *
- * @example
- * ```typescript
- * const client = new x402Client();
- * registerEscrowScheme(client, { signer, networks: "eip155:84532" });
- * ```
- */
-export function registerEscrowScheme(client, config) {
-    const scheme = new EscrowEvmScheme(config.signer);
-    const networks = Array.isArray(config.networks)
-        ? config.networks
-        : [config.networks];
-    for (const network of networks) {
-        client.register(network, scheme);
-    }
-    return client;
-}
-/**
- * @deprecated Use `new EscrowEvmScheme(signer)` directly
- */
-export const EscrowScheme = {
-    scheme: "escrow",
-};
-//# sourceMappingURL=index.js.map