@t402/evm 2.1.0 → 2.3.0

package/dist/cjs/index.js

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,7 +16,9 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var src_exports = {};
@@ -24,6 +27,7 @@ __export(src_exports, {
   BUNDLER_METHODS: () => BUNDLER_METHODS,
   BundlerClient: () => BundlerClient,
   BundlerError: () => BundlerError,
+  CrossChainPaymentRouter: () => CrossChainPaymentRouter,
   DEFAULT_GAS_LIMITS: () => DEFAULT_GAS_LIMITS,
   ENTRYPOINT_V06_ADDRESS: () => ENTRYPOINT_V06_ADDRESS,
   ENTRYPOINT_V07_ABI: () => ENTRYPOINT_V07_ABI,
@@ -35,49 +39,41 @@ __export(src_exports, {
   GaslessT402Client: () => GaslessT402Client,
   LAYERZERO_ENDPOINT_IDS: () => LAYERZERO_ENDPOINT_IDS,
   LAYERZERO_ENDPOINT_V2: () => LAYERZERO_ENDPOINT_V2,
+  LAYERZERO_SCAN_BASE_URL: () => LAYERZERO_SCAN_BASE_URL,
+  LayerZeroScanClient: () => LayerZeroScanClient,
   PaymasterClient: () => PaymasterClient,
   PaymasterType: () => PaymasterType,
-  TOKEN_PRIORITY: () => TOKEN_PRIORITY,
-  TOKEN_REGISTRY: () => TOKEN_REGISTRY,
-  USDC_ADDRESSES: () => USDC_ADDRESSES,
-  USDT0_ADDRESSES: () => USDT0_ADDRESSES,
   USDT0_OFT_ADDRESSES: () => USDT0_OFT_ADDRESSES,
-  USDT_LEGACY_ADDRESSES: () => USDT_LEGACY_ADDRESSES,
+  UptoEvmFacilitatorScheme: () => UptoEvmFacilitatorScheme,
+  UptoEvmScheme: () => UptoEvmScheme,
+  UptoEvmServerScheme: () => UptoEvmServerScheme,
   Usdt0Bridge: () => Usdt0Bridge,
   UserOpBuilder: () => UserOpBuilder,
   addressToBytes32: () => addressToBytes32,
-  authorizationTypes: () => authorizationTypes,
   bytes32ToAddress: () => bytes32ToAddress,
   createBundlerClient: () => createBundlerClient,
+  createCrossChainPaymentRouter: () => createCrossChainPaymentRouter,
   createGaslessT402Client: () => createGaslessT402Client,
+  createLayerZeroScanClient: () => createLayerZeroScanClient,
   createPaymasterClient: () => createPaymasterClient,
+  createUptoEvmFacilitatorScheme: () => createUptoEvmFacilitatorScheme,
+  createUptoEvmScheme: () => createUptoEvmScheme,
+  createUptoEvmServerScheme: () => createUptoEvmServerScheme,
   createUsdt0Bridge: () => createUsdt0Bridge,
   createUserOpBuilder: () => createUserOpBuilder,
   decodePaymasterAndData: () => decodePaymasterAndData,
-  eip3009ABI: () => eip3009ABI,
   encodePaymasterAndData: () => encodePaymasterAndData,
-  erc20LegacyABI: () => erc20LegacyABI,
   getBridgeableChains: () => getBridgeableChains,
-  getDefaultToken: () => getDefaultToken,
-  getEIP712Domain: () => getEIP712Domain,
   getEndpointId: () => getEndpointId,
-  getNetworkTokens: () => getNetworkTokens,
-  getNetworksForToken: () => getNetworksForToken,
-  getTokenByAddress: () => getTokenByAddress,
-  getTokenConfig: () => getTokenConfig,
-  getUsdt0Networks: () => getUsdt0Networks,
   getUsdt0OftAddress: () => getUsdt0OftAddress,
-  legacyAuthorizationTypes: () => legacyAuthorizationTypes,
   packAccountGasLimits: () => packAccountGasLimits,
   packGasFees: () => packGasFees,
   supportsBridging: () => supportsBridging,
-  supportsEIP3009: () => supportsEIP3009,
-  toClientEvmSigner: () => toClientEvmSigner,
-  toFacilitatorEvmSigner: () => toFacilitatorEvmSigner,
   unpackAccountGasLimits: () => unpackAccountGasLimits,
   unpackGasFees: () => unpackGasFees
 });
 module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("@t402/evm-core"), module.exports);
 
 // src/exact/client/scheme.ts
 var import_viem2 = require("viem");
@@ -104,54 +100,6 @@ var legacyAuthorizationTypes = {
     { name: "spender", type: "address" }
   ]
 };
-var eip3009ABI = [
-  {
-    inputs: [
-      { name: "from", type: "address" },
-      { name: "to", type: "address" },
-      { name: "value", type: "uint256" },
-      { name: "validAfter", type: "uint256" },
-      { name: "validBefore", type: "uint256" },
-      { name: "nonce", type: "bytes32" },
-      { name: "v", type: "uint8" },
-      { name: "r", type: "bytes32" },
-      { name: "s", type: "bytes32" }
-    ],
-    name: "transferWithAuthorization",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "from", type: "address" },
-      { name: "to", type: "address" },
-      { name: "value", type: "uint256" },
-      { name: "validAfter", type: "uint256" },
-      { name: "validBefore", type: "uint256" },
-      { name: "nonce", type: "bytes32" },
-      { name: "signature", type: "bytes" }
-    ],
-    name: "transferWithAuthorization",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ name: "account", type: "address" }],
-    name: "balanceOf",
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "version",
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view",
-    type: "function"
-  }
-];
 var erc20LegacyABI = [
   {
     inputs: [{ name: "account", type: "address" }],
@@ -212,7 +160,7 @@ var ExactEvmScheme = class {
    */
   constructor(signer) {
     this.signer = signer;
-    this.scheme = "exact";
+    __publicField(this, "scheme", "exact");
   }
   /**
    * Creates a payment payload for the Exact scheme.
@@ -291,7 +239,7 @@ var ExactLegacyEvmScheme = class {
    */
   constructor(signer) {
     this.signer = signer;
-    this.scheme = "exact-legacy";
+    __publicField(this, "scheme", "exact-legacy");
   }
   /**
    * Creates a payment payload for the exact-legacy scheme.
@@ -366,6 +314,7 @@ var ExactLegacyEvmScheme = class {
 
 // src/tokens.ts
 var USDT0_ADDRESSES = {
+  // === Existing Networks ===
   // Ethereum Mainnet - OFT Adapter (bridge endpoint)
   "eip155:1": "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
   // Arbitrum One - Native USDT0
@@ -374,8 +323,38 @@ var USDT0_ADDRESSES = {
   "eip155:57073": "0x0200C29006150606B650577BBE7B6248F58470c1",
   // Berachain Mainnet
   "eip155:80094": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
-  // Unichain Mainnet
-  "eip155:130": "0x588ce4F028D8e7B53B687865d6A67b3A54C75518"
+  // Unichain Mainnet (updated address)
+  "eip155:130": "0x9151434b16b9763660705744891fA906F660EcC5",
+  // === Phase 1: High Priority Networks ===
+  // Polygon PoS
+  "eip155:137": "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+  // Mantle
+  "eip155:5000": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  // Optimism
+  "eip155:10": "0x01bFF41798a0BcF287b996046Ca68b395DbC1071",
+  // Plasma
+  "eip155:9745": "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+  // Sei
+  "eip155:1329": "0x9151434b16b9763660705744891fA906F660EcC5",
+  // Conflux eSpace
+  "eip155:1030": "0xaf37E8B6C9ED7f6318979f56Fc287d76c30847ff",
+  // Monad
+  "eip155:143": "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+  // === Phase 2: Medium Priority Networks ===
+  // Rootstock (Bitcoin sidechain)
+  "eip155:30": "0x779dED0C9e1022225F8e0630b35A9B54Be713736",
+  // XLayer (OKX L2)
+  "eip155:196": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  // Flare
+  "eip155:14": "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+  // Corn
+  "eip155:21000000": "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+  // HyperEVM
+  "eip155:999": "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+  // MegaETH
+  "eip155:4326": "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
+  // Stable
+  "eip155:988": "0x779Ded0c9e1022225f8E0630b35a9b54bE713736"
 };
 var USDC_ADDRESSES = {
   // Ethereum Mainnet
@@ -394,8 +373,18 @@ var USDC_ADDRESSES = {
 var USDT_LEGACY_ADDRESSES = {
   // Ethereum Mainnet
   "eip155:1": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
-  // Polygon Mainnet
-  "eip155:137": "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
+  // Polygon Mainnet (native USDT, not USDT0)
+  "eip155:137": "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+  // BNB Chain (BSC) - BEP-20 USDT
+  "eip155:56": "0x55d398326f99059fF775485246999027B3197955",
+  // Avalanche C-Chain
+  "eip155:43114": "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+  // Fantom
+  "eip155:250": "0x049d68029688eabf473097a2fc38ef61633a3c7a",
+  // Celo
+  "eip155:42220": "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e",
+  // Kaia (formerly Klaytn)
+  "eip155:8217": "0xcee8faf64bb97a73bb51e115aa89c17ffa8dd167"
 };
 var TOKEN_REGISTRY = {
   // Ethereum Mainnet
@@ -524,6 +513,15 @@ var TOKEN_REGISTRY = {
   },
   // Polygon Mainnet
   "eip155:137": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:137"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    },
     USDC: {
       address: USDC_ADDRESSES["eip155:137"],
       symbol: "USDC",
@@ -542,18 +540,228 @@ var TOKEN_REGISTRY = {
       tokenType: "legacy",
       priority: 10
     }
+  },
+  // === Phase 1: High Priority USDT0 Networks ===
+  // Optimism Mainnet
+  "eip155:10": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:10"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Mantle Mainnet
+  "eip155:5000": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:5000"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Plasma Mainnet
+  "eip155:9745": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:9745"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Sei Mainnet
+  "eip155:1329": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:1329"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Conflux eSpace Mainnet
+  "eip155:1030": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:1030"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Monad Mainnet
+  "eip155:143": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:143"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // === Phase 2: Medium Priority USDT0 Networks ===
+  // Flare Mainnet
+  "eip155:14": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:14"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Rootstock Mainnet (Bitcoin sidechain)
+  "eip155:30": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:30"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // XLayer Mainnet (OKX L2)
+  "eip155:196": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:196"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Stable Mainnet
+  "eip155:988": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:988"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // HyperEVM Mainnet
+  "eip155:999": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:999"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // MegaETH Mainnet
+  "eip155:4326": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:4326"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // Corn Mainnet
+  "eip155:21000000": {
+    USDT0: {
+      address: USDT0_ADDRESSES["eip155:21000000"],
+      symbol: "USDT0",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "eip3009",
+      priority: 1
+    }
+  },
+  // === Legacy USDT Networks (no EIP-3009 support) ===
+  // BNB Chain (BSC) - BEP-20 USDT
+  "eip155:56": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:56"],
+      symbol: "USDT",
+      name: "Tether USD",
+      version: "1",
+      decimals: 18,
+      // BSC USDT uses 18 decimals
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Avalanche C-Chain
+  "eip155:43114": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:43114"],
+      symbol: "USDT",
+      name: "TetherToken",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Fantom
+  "eip155:250": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:250"],
+      symbol: "USDT",
+      name: "Frapped USDT",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Celo
+  "eip155:42220": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:42220"],
+      symbol: "USDT",
+      name: "Tether USD",
+      version: "1",
+      decimals: 18,
+      tokenType: "legacy",
+      priority: 10
+    }
+  },
+  // Kaia (formerly Klaytn)
+  "eip155:8217": {
+    USDT: {
+      address: USDT_LEGACY_ADDRESSES["eip155:8217"],
+      symbol: "USDT",
+      name: "Tether USD",
+      version: "1",
+      decimals: 6,
+      tokenType: "legacy",
+      priority: 10
+    }
   }
 };
-var TOKEN_PRIORITY = {
-  USDT0: 1,
-  // Highest priority - gasless, cross-chain
-  USDC: 2,
-  // Second - wide support, EIP-3009
-  USDT: 10,
-  // Lower - requires approval transaction
-  DAI: 5
-  // Medium - good support
-};
 function getTokenConfig(network, symbol) {
   return TOKEN_REGISTRY[network]?.[symbol.toUpperCase()];
 }
@@ -572,42 +780,42 @@ function getTokenByAddress(network, address) {
   const lowerAddress = address.toLowerCase();
   return Object.values(tokens).find((t) => t.address.toLowerCase() === lowerAddress);
 }
-function supportsEIP3009(network, symbol) {
-  const config = getTokenConfig(network, symbol);
-  return config?.tokenType === "eip3009";
-}
-function getNetworksForToken(symbol) {
-  const networks = [];
-  for (const [network, tokens] of Object.entries(TOKEN_REGISTRY)) {
-    if (tokens[symbol.toUpperCase()]) {
-      networks.push(network);
-    }
-  }
-  return networks;
-}
-function getUsdt0Networks() {
-  return getNetworksForToken("USDT0");
-}
-function getEIP712Domain(network, tokenAddress, chainId) {
-  const token = getTokenByAddress(network, tokenAddress);
-  if (!token) return void 0;
-  return {
-    name: token.name,
-    version: token.version,
-    chainId,
-    verifyingContract: token.address
-  };
-}
 
 // src/exact-legacy/server/scheme.ts
 var ExactLegacyEvmScheme2 = class {
+  /**
+   * Creates a new ExactLegacyEvmScheme instance.
+   *
+   * @param config - Optional configuration options for the scheme
+   */
   constructor(config = {}) {
-    this.scheme = "exact-legacy";
-    this.moneyParsers = [];
+    __publicField(this, "scheme", "exact-legacy");
+    __publicField(this, "moneyParsers", []);
+    __publicField(this, "config");
     this.config = config;
   }
+  /**
+   * Get all supported networks that have legacy tokens
+   *
+   * @returns Array of network identifiers with legacy token support
+   */
+  static getSupportedNetworks() {
+    return Object.keys(USDT_LEGACY_ADDRESSES);
+  }
+  /**
+   * Check if a network has legacy token support
+   *
+   * @param network - The network identifier to check
+   * @returns True if the network has legacy token support
+   */
+  static isNetworkSupported(network) {
+    return network in USDT_LEGACY_ADDRESSES;
+  }
   /**
    * Register a custom money parser in the parser chain.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount
+   * @returns The scheme instance for method chaining
    */
   registerMoneyParser(parser) {
     this.moneyParsers.push(parser);
@@ -615,6 +823,10 @@ var ExactLegacyEvmScheme2 = class {
   }
   /**
    * Parses a price into an asset amount for legacy tokens.
+   *
+   * @param price - The price to parse (Money or AssetAmount)
+   * @param network - The network identifier in CAIP-2 format
+   * @returns Promise resolving to the parsed asset amount
    */
   async parsePrice(price, network) {
     if (typeof price === "object" && price !== null && "amount" in price) {
@@ -642,6 +854,15 @@ var ExactLegacyEvmScheme2 = class {
   /**
    * Build payment requirements for this scheme/network combination.
    * Adds the spender (facilitator) address to the extra field.
+   *
+   * @param paymentRequirements - The base payment requirements to enhance
+   * @param supportedKind - The supported kind from facilitator
+   * @param supportedKind.t402Version - The t402 protocol version
+   * @param supportedKind.scheme - The logical payment scheme identifier
+   * @param supportedKind.network - The network identifier in CAIP-2 format
+   * @param supportedKind.extra - Optional extra metadata with spender address
+   * @param extensionKeys - Extension keys supported by the facilitator (unused)
+   * @returns Promise resolving to enhanced payment requirements
    */
   enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
     void extensionKeys;
@@ -657,6 +878,9 @@ var ExactLegacyEvmScheme2 = class {
   }
   /**
    * Parse Money (string | number) to a decimal number.
+   *
+   * @param money - The money value to parse (e.g., "$1.50" or 1.50)
+   * @returns The decimal number representation
    */
   parseMoneyToDecimal(money) {
     if (typeof money === "number") {
@@ -671,6 +895,10 @@ var ExactLegacyEvmScheme2 = class {
   }
   /**
    * Default money conversion implementation for legacy tokens.
+   *
+   * @param amount - The decimal amount to convert (e.g., 1.50)
+   * @param network - The network identifier in CAIP-2 format
+   * @returns The asset amount in token units
    */
   defaultMoneyConversion(amount, network) {
     const token = this.getDefaultAsset(network);
@@ -688,6 +916,10 @@ var ExactLegacyEvmScheme2 = class {
   }
   /**
    * Convert decimal amount to token units
+   *
+   * @param decimalAmount - The decimal amount as a string (e.g., "1.50")
+   * @param decimals - The number of decimal places for the token
+   * @returns The token amount as a string in smallest units
    */
   convertToTokenAmount(decimalAmount, decimals) {
     const amount = parseFloat(decimalAmount);
@@ -699,6 +931,9 @@ var ExactLegacyEvmScheme2 = class {
   }
   /**
    * Get the default legacy token for a network.
+   *
+   * @param network - The network identifier in CAIP-2 format
+   * @returns The token configuration for the default legacy token
    */
   getDefaultAsset(network) {
     if (this.config.preferredToken) {
@@ -718,18 +953,6 @@ var ExactLegacyEvmScheme2 = class {
     }
     throw new Error(`No legacy tokens configured for network ${network}`);
   }
-  /**
-   * Get all supported networks that have legacy tokens
-   */
-  static getSupportedNetworks() {
-    return Object.keys(USDT_LEGACY_ADDRESSES);
-  }
-  /**
-   * Check if a network has legacy token support
-   */
-  static isNetworkSupported(network) {
-    return network in USDT_LEGACY_ADDRESSES;
-  }
 };
 
 // src/exact-legacy/facilitator/scheme.ts
@@ -743,8 +966,9 @@ var ExactLegacyEvmScheme3 = class {
    */
   constructor(signer, config) {
     this.signer = signer;
-    this.scheme = "exact-legacy";
-    this.caipFamily = "eip155:*";
+    __publicField(this, "scheme", "exact-legacy");
+    __publicField(this, "caipFamily", "eip155:*");
+    __publicField(this, "config");
     this.config = {
       minAllowanceRatio: config?.minAllowanceRatio ?? 1
     };
@@ -769,6 +993,9 @@ var ExactLegacyEvmScheme3 = class {
   }
   /**
    * Get signer addresses used by this facilitator.
+   *
+   * @param network - The network identifier (unused, returns same addresses for all networks)
+   * @returns Array of signer addresses
    */
   getSigners(network) {
     void network;
@@ -776,6 +1003,10 @@ var ExactLegacyEvmScheme3 = class {
   }
   /**
    * Verifies a payment payload.
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements to verify against
+   * @returns Promise resolving to verification response with validity status
    */
   async verify(payload, requirements) {
     const legacyPayload = payload.payload;
@@ -922,70 +1153,569 @@ var ExactLegacyEvmScheme3 = class {
   }
   /**
    * Settles a payment by executing transferFrom.
+   *
+   * @param payload - The payment payload containing transfer authorization
+   * @param requirements - The payment requirements specifying amount and recipient
+   * @returns Promise resolving to settlement response with transaction hash
+   */
+  async settle(payload, requirements) {
+    const legacyPayload = payload.payload;
+    const valid = await this.verify(payload, requirements);
+    if (!valid.isValid) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: valid.invalidReason ?? "invalid_payment",
+        payer: legacyPayload.authorization.from
+      };
+    }
+    try {
+      const tx = await this.signer.writeContract({
+        address: (0, import_viem4.getAddress)(requirements.asset),
+        abi: erc20LegacyABI,
+        functionName: "transferFrom",
+        args: [
+          (0, import_viem4.getAddress)(legacyPayload.authorization.from),
+          (0, import_viem4.getAddress)(legacyPayload.authorization.to),
+          BigInt(legacyPayload.authorization.value)
+        ]
+      });
+      const receipt = await this.signer.waitForTransactionReceipt({ hash: tx });
+      if (receipt.status !== "success") {
+        return {
+          success: false,
+          errorReason: "transaction_failed",
+          transaction: tx,
+          network: payload.accepted.network,
+          payer: legacyPayload.authorization.from
+        };
+      }
+      return {
+        success: true,
+        transaction: tx,
+        network: payload.accepted.network,
+        payer: legacyPayload.authorization.from
+      };
+    } catch (error) {
+      console.error("Failed to settle legacy transaction:", error);
+      return {
+        success: false,
+        errorReason: "settlement_failed",
+        transaction: "",
+        network: payload.accepted.network,
+        payer: legacyPayload.authorization.from
+      };
+    }
+  }
+};
+
+// src/upto/client/scheme.ts
+var import_viem5 = require("viem");
+
+// src/types.ts
+var permitTypes = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+function isUptoEIP2612Payload(payload) {
+  if (typeof payload !== "object" || payload === null) return false;
+  const p = payload;
+  return "signature" in p && "authorization" in p && "paymentNonce" in p && typeof p.authorization === "object" && p.authorization !== null && "owner" in p.authorization && "spender" in p.authorization && "value" in p.authorization && "deadline" in p.authorization && "nonce" in p.authorization;
+}
+
+// src/upto/client/scheme.ts
+var UptoEvmScheme = class {
+  /**
+   * Creates a new UptoEvmScheme instance.
+   *
+   * @param signer - The EVM signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    __publicField(this, "scheme", "upto");
+  }
+  /**
+   * Creates a payment payload for the Up-To scheme.
+   *
+   * The payload contains an EIP-2612 permit signature authorizing
+   * the router contract (or facilitator) to transfer up to the
+   * specified maximum amount.
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements (must include maxAmount)
+   * @returns Promise resolving to a payment payload
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    if (paymentRequirements.scheme !== "upto") {
+      throw new Error(`Expected upto scheme, got ${paymentRequirements.scheme}`);
+    }
+    const extra = paymentRequirements.extra;
+    if (!extra?.name || !extra?.version) {
+      throw new Error("EIP-712 domain parameters (name, version) are required for upto scheme");
+    }
+    const maxAmount = paymentRequirements.maxAmount;
+    if (!maxAmount) {
+      throw new Error("maxAmount is required for upto scheme");
+    }
+    const spender = extra.routerAddress ? (0, import_viem5.getAddress)(extra.routerAddress) : (0, import_viem5.getAddress)(paymentRequirements.payTo);
+    const now = Math.floor(Date.now() / 1e3);
+    const deadline = now + paymentRequirements.maxTimeoutSeconds;
+    const permitNonce = extra.permitNonce ?? 0;
+    const authorization = {
+      owner: this.signer.address,
+      spender,
+      value: maxAmount,
+      deadline: deadline.toString(),
+      nonce: permitNonce
+    };
+    const signature = await this.signPermit(authorization, paymentRequirements);
+    const paymentNonce = createNonce();
+    const payload = {
+      signature,
+      authorization,
+      paymentNonce
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+  /**
+   * Sign the EIP-2612 permit using EIP-712
+   *
+   * @param authorization - The permit authorization to sign
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to the signature components
+   */
+  async signPermit(authorization, requirements) {
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const extra = requirements.extra;
+    const domain = {
+      name: extra.name,
+      version: extra.version,
+      chainId,
+      verifyingContract: (0, import_viem5.getAddress)(requirements.asset)
+    };
+    const message = {
+      owner: (0, import_viem5.getAddress)(authorization.owner),
+      spender: (0, import_viem5.getAddress)(authorization.spender),
+      value: BigInt(authorization.value),
+      nonce: BigInt(authorization.nonce),
+      deadline: BigInt(authorization.deadline)
+    };
+    const signature = await this.signer.signTypedData({
+      domain,
+      types: permitTypes,
+      primaryType: "Permit",
+      message
+    });
+    const r = `0x${signature.slice(2, 66)}`;
+    const s = `0x${signature.slice(66, 130)}`;
+    const v = parseInt(signature.slice(130, 132), 16);
+    return { v, r, s };
+  }
+};
+function createUptoEvmScheme(signer) {
+  return new UptoEvmScheme(signer);
+}
+
+// src/upto/server/scheme.ts
+var import_types2 = require("@t402/core/types");
+var UptoEvmServerScheme = class {
+  /**
+   * Creates a new UptoEvmServerScheme instance.
+   *
+   * @param config - Optional configuration options for the scheme
+   */
+  constructor(config = {}) {
+    __publicField(this, "scheme", "upto");
+    __publicField(this, "moneyParsers", []);
+    __publicField(this, "config");
+    this.config = config;
+  }
+  /**
+   * Get all supported networks
+   *
+   * @returns Array of network identifiers in CAIP-2 format
+   */
+  static getSupportedNetworks() {
+    return Object.keys(TOKEN_REGISTRY);
+  }
+  /**
+   * Check if a network is supported
+   *
+   * @param network - The network identifier to check
+   * @returns True if the network is supported
+   */
+  static isNetworkSupported(network) {
+    return network in TOKEN_REGISTRY;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount
+   * @returns The server instance for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parses a price into an asset amount for maxAmount.
+   *
+   * @param price - The price to parse (represents maxAmount)
+   * @param network - The network to use
+   * @returns Promise resolving to the parsed asset amount
+   */
+  async parsePrice(price, network) {
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        const token2 = this.getPreferredToken(network);
+        return { amount: price.amount, asset: token2.address };
+      }
+      return price;
+    }
+    const decimalAmount = this.parseToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(decimalAmount, network);
+      if (result !== null) {
+        return result;
+      }
+    }
+    const token = this.getPreferredToken(network);
+    const amount = Math.floor(decimalAmount * 10 ** token.decimals).toString();
+    return {
+      amount,
+      asset: token.address
+    };
+  }
+  /**
+   * Enhance payment requirements for the upto scheme.
+   *
+   * @param paymentRequirements - Base payment requirements
+   * @param supportedKind - The supported kind from facilitator
+   * @param supportedKind.t402Version - T402 protocol version
+   * @param supportedKind.scheme - Payment scheme
+   * @param supportedKind.network - Network identifier
+   * @param supportedKind.extra - Extra configuration
+   * @param facilitatorExtensions - Extensions supported by the facilitator
+   * @returns Enhanced payment requirements for upto scheme
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, facilitatorExtensions) {
+    void facilitatorExtensions;
+    const network = supportedKind.network;
+    const token = getTokenByAddress(network, paymentRequirements.asset);
+    if (!token) {
+      throw new Error(`Unknown token ${paymentRequirements.asset} on ${network}`);
+    }
+    const extra = {
+      // EIP-712 domain (required for permit signing)
+      name: token.name,
+      version: token.version,
+      // Router address (optional - if set, permits go to router)
+      ...this.config.routerAddress && { routerAddress: this.config.routerAddress },
+      // Billing unit info (optional)
+      ...this.config.defaultUnit && { unit: this.config.defaultUnit },
+      ...this.config.defaultUnitPrice && { unitPrice: this.config.defaultUnitPrice },
+      // Upto-specific fields
+      maxAmount: paymentRequirements.amount,
+      minAmount: import_types2.UPTO_DEFAULTS.MIN_AMOUNT,
+      // Merge any facilitator extra
+      ...supportedKind.extra
+    };
+    return {
+      ...paymentRequirements,
+      scheme: "upto",
+      extra
+    };
+  }
+  /**
+   * Get the preferred token for a network.
+   *
+   * @param network - The network identifier
+   * @returns Token configuration
+   * @throws Error if no token is found for the network
+   */
+  getPreferredToken(network) {
+    if (this.config.preferredToken) {
+      const token = getTokenConfig(network, this.config.preferredToken);
+      if (token) return token;
+    }
+    const defaultToken = getDefaultToken(network);
+    if (!defaultToken) {
+      throw new Error(`No token configured for network ${network}`);
+    }
+    return defaultToken;
+  }
+  /**
+   * Parse price to decimal value.
+   *
+   * @param price - Price string or number
+   * @returns Decimal amount
+   */
+  parseToDecimal(price) {
+    if (typeof price === "number") {
+      return price;
+    }
+    const cleaned = price.replace(/[$,]/g, "").trim();
+    const parsed = parseFloat(cleaned);
+    if (isNaN(parsed)) {
+      throw new Error(`Invalid price format: ${price}`);
+    }
+    return parsed;
+  }
+};
+function createUptoEvmServerScheme(config) {
+  return new UptoEvmServerScheme(config);
+}
+
+// src/upto/facilitator/scheme.ts
+var import_viem6 = require("viem");
+var T402_UPTO_ROUTER_ABI = (0, import_viem6.parseAbi)([
+  "function executeUptoTransfer(address token, address from, address to, uint256 maxAmount, uint256 settleAmount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external",
+  "function isFacilitator(address facilitator) external view returns (bool)",
+  "function checkPermitValidity(address token, address from, uint256 maxAmount) external view returns (bool valid, uint256 balance)"
+]);
+var UptoEvmFacilitatorScheme = class {
+  /**
+   * Creates a new UptoEvmFacilitatorScheme instance.
+   *
+   * @param signer - The EVM signer for facilitator operations
+   * @param config - Optional configuration
+   */
+  constructor(signer, config) {
+    this.signer = signer;
+    __publicField(this, "scheme", "upto");
+    __publicField(this, "caipFamily", "eip155:*");
+    __publicField(this, "config");
+    this.config = config ?? {};
+  }
+  /**
+   * Get mechanism-specific extra data for the supported kinds endpoint.
+   *
+   * @param network - The network identifier
+   * @returns Extra data including router address if configured
+   */
+  getExtra(network) {
+    const routerAddress = this.config.routerAddresses?.[network];
+    if (routerAddress) {
+      return { routerAddress };
+    }
+    return void 0;
+  }
+  /**
+   * Get signer addresses used by this facilitator.
+   *
+   * @param _ - The network identifier (unused for EVM)
+   * @returns Array of facilitator wallet addresses
+   */
+  getSigners(_) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies an upto payment payload.
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to verification response
+   */
+  async verify(payload, requirements) {
+    const uptoPayload = payload.payload;
+    if (!uptoPayload || !isUptoEIP2612Payload(uptoPayload)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_payload_structure",
+        payer: void 0
+      };
+    }
+    if (payload.accepted.scheme !== "upto" || requirements.scheme !== "upto") {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (!requirements.extra?.name || !requirements.extra?.version) {
+      return {
+        isValid: false,
+        invalidReason: "missing_eip712_domain",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const maxAmount = requirements.extra?.maxAmount;
+    if (!maxAmount) {
+      return {
+        isValid: false,
+        invalidReason: "missing_maxAmount",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (payload.accepted.network !== requirements.network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const deadline = parseInt(uptoPayload.authorization.deadline);
+    const now = Math.floor(Date.now() / 1e3);
+    if (deadline <= now) {
+      return {
+        isValid: false,
+        invalidReason: "permit_expired",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (uptoPayload.authorization.value !== maxAmount) {
+      return {
+        isValid: false,
+        invalidReason: "amount_mismatch",
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const permitTypedData = {
+      types: permitTypes,
+      primaryType: "Permit",
+      domain: {
+        name: requirements.extra.name,
+        version: requirements.extra.version,
+        chainId,
+        verifyingContract: (0, import_viem6.getAddress)(requirements.asset)
+      },
+      message: {
+        owner: (0, import_viem6.getAddress)(uptoPayload.authorization.owner),
+        spender: (0, import_viem6.getAddress)(uptoPayload.authorization.spender),
+        value: BigInt(uptoPayload.authorization.value),
+        nonce: BigInt(uptoPayload.authorization.nonce),
+        deadline: BigInt(uptoPayload.authorization.deadline)
+      }
+    };
+    const signature = `0x${uptoPayload.signature.r.slice(2)}${uptoPayload.signature.s.slice(2)}${uptoPayload.signature.v.toString(16).padStart(2, "0")}`;
+    try {
+      const isValid = await this.signer.verifyTypedData({
+        address: uptoPayload.authorization.owner,
+        ...permitTypedData,
+        signature
+      });
+      if (!isValid) {
+        return {
+          isValid: false,
+          invalidReason: "invalid_signature",
+          payer: uptoPayload.authorization.owner
+        };
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        invalidReason: `signature_verification_failed: ${error instanceof Error ? error.message : "unknown"}`,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    return {
+      isValid: true,
+      payer: uptoPayload.authorization.owner
+    };
+  }
+  /**
+   * Settles an upto payment by calling the T402UptoRouter contract.
+   *
+   * @param payload - The verified payment payload
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to settlement response
    */
   async settle(payload, requirements) {
-    const legacyPayload = payload.payload;
-    const valid = await this.verify(payload, requirements);
-    if (!valid.isValid) {
+    const uptoPayload = payload.payload;
+    const maxAmount = requirements.extra?.maxAmount;
+    const minAmount = requirements.extra?.minAmount;
+    const routerAddress = requirements.extra?.routerAddress;
+    if (!maxAmount) {
       return {
         success: false,
-        network: payload.accepted.network,
+        errorReason: "maxAmount not found in payment requirements",
         transaction: "",
-        errorReason: valid.invalidReason ?? "invalid_payment",
-        payer: legacyPayload.authorization.from
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    const settleAmount = maxAmount;
+    if (minAmount && BigInt(settleAmount) < BigInt(minAmount)) {
+      return {
+        success: false,
+        errorReason: `Settle amount ${settleAmount} below minimum ${minAmount}`,
+        transaction: "",
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
+      };
+    }
+    if (!routerAddress) {
+      return {
+        success: false,
+        errorReason: "Router address not configured",
+        transaction: "",
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
       };
     }
     try {
-      const tx = await this.signer.writeContract({
-        address: (0, import_viem4.getAddress)(requirements.asset),
-        abi: erc20LegacyABI,
-        functionName: "transferFrom",
-        args: [
-          (0, import_viem4.getAddress)(legacyPayload.authorization.from),
-          (0, import_viem4.getAddress)(legacyPayload.authorization.to),
-          BigInt(legacyPayload.authorization.value)
-        ]
+      const txHash = await this.signer.sendTransaction({
+        to: (0, import_viem6.getAddress)(routerAddress),
+        data: (0, import_viem6.encodeFunctionData)({
+          abi: T402_UPTO_ROUTER_ABI,
+          functionName: "executeUptoTransfer",
+          args: [
+            (0, import_viem6.getAddress)(requirements.asset),
+            (0, import_viem6.getAddress)(uptoPayload.authorization.owner),
+            (0, import_viem6.getAddress)(requirements.payTo),
+            BigInt(maxAmount),
+            BigInt(settleAmount),
+            BigInt(uptoPayload.authorization.deadline),
+            uptoPayload.signature.v,
+            uptoPayload.signature.r,
+            uptoPayload.signature.s
+          ]
+        })
       });
-      const receipt = await this.signer.waitForTransactionReceipt({ hash: tx });
+      const receipt = await this.signer.waitForTransactionReceipt({ hash: txHash });
       if (receipt.status !== "success") {
         return {
           success: false,
-          errorReason: "transaction_failed",
-          transaction: tx,
-          network: payload.accepted.network,
-          payer: legacyPayload.authorization.from
+          errorReason: "transaction_reverted",
+          transaction: txHash,
+          network: requirements.network,
+          payer: uptoPayload.authorization.owner
         };
       }
       return {
         success: true,
-        transaction: tx,
-        network: payload.accepted.network,
-        payer: legacyPayload.authorization.from
+        transaction: txHash,
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
       };
     } catch (error) {
-      console.error("Failed to settle legacy transaction:", error);
       return {
         success: false,
-        errorReason: "settlement_failed",
+        errorReason: `Settlement failed: ${error instanceof Error ? error.message : "unknown"}`,
         transaction: "",
-        network: payload.accepted.network,
-        payer: legacyPayload.authorization.from
+        network: requirements.network,
+        payer: uptoPayload.authorization.owner
       };
     }
   }
 };
-
-// src/signer.ts
-function toClientEvmSigner(signer) {
-  return signer;
-}
-function toFacilitatorEvmSigner(client) {
-  return {
-    ...client,
-    getAddresses: () => [client.address]
-  };
+function createUptoEvmFacilitatorScheme(signer, config) {
+  return new UptoEvmFacilitatorScheme(signer, config);
 }
 
+// src/bridge/client.ts
+var import_viem7 = require("viem");
+
 // src/bridge/constants.ts
 var LAYERZERO_ENDPOINT_IDS = {
   // Mainnets
@@ -1158,9 +1888,7 @@ function supportsBridging(chain) {
   return chain in USDT0_OFT_ADDRESSES && chain in LAYERZERO_ENDPOINT_IDS;
 }
 function getBridgeableChains() {
-  return Object.keys(USDT0_OFT_ADDRESSES).filter(
-    (chain) => chain in LAYERZERO_ENDPOINT_IDS
-  );
+  return Object.keys(USDT0_OFT_ADDRESSES).filter((chain) => chain in LAYERZERO_ENDPOINT_IDS);
 }
 function addressToBytes32(address) {
   const cleanAddress = address.slice(2).toLowerCase();
@@ -1171,6 +1899,7 @@ function bytes32ToAddress(bytes32) {
 }
 
 // src/bridge/client.ts
+var OFT_SENT_EVENT_TOPIC = (0, import_viem7.keccak256)((0, import_viem7.toBytes)("OFTSent(bytes32,uint32,address,uint256,uint256)"));
 var DEFAULT_SLIPPAGE = 0.5;
 var ESTIMATED_BRIDGE_TIME = 300;
 var Usdt0Bridge = class {
@@ -1181,6 +1910,8 @@ var Usdt0Bridge = class {
    * @param chain - Source chain name (e.g., "arbitrum", "ethereum")
    */
   constructor(signer, chain) {
+    __publicField(this, "signer");
+    __publicField(this, "chain");
     if (!supportsBridging(chain)) {
       throw new Error(
         `Chain "${chain}" does not support USDT0 bridging. Supported chains: ${getBridgeableChains().join(", ")}`
@@ -1243,10 +1974,10 @@ var Usdt0Bridge = class {
     if (receipt.status !== "success") {
       throw new Error(`Bridge transaction failed: ${txHash}`);
     }
+    const messageGuid = this.extractMessageGuid(receipt);
     return {
       txHash,
-      messageGuid: "0x" + "0".repeat(64),
-      // Would be extracted from event logs
+      messageGuid,
       amountSent: params.amount,
       amountToReceive: sendParam.minAmountLD,
       fromChain: params.fromChain,
@@ -1254,8 +1985,44 @@ var Usdt0Bridge = class {
       estimatedTime: ESTIMATED_BRIDGE_TIME
     };
   }
+  /**
+   * Get all supported destination chains from current chain
+   *
+   * @returns Array of supported destination chain names
+   */
+  getSupportedDestinations() {
+    return getBridgeableChains().filter((chain) => chain !== this.chain);
+  }
+  /**
+   * Check if a destination chain is supported
+   *
+   * @param toChain - The destination chain to check
+   * @returns True if the destination chain is supported
+   */
+  supportsDestination(toChain) {
+    return toChain !== this.chain && supportsBridging(toChain);
+  }
+  /**
+   * Extract LayerZero message GUID from OFTSent event logs
+   *
+   * @param receipt - Transaction receipt with logs
+   * @returns Message GUID as hex string
+   */
+  extractMessageGuid(receipt) {
+    for (const log of receipt.logs) {
+      if (log.topics[0] === OFT_SENT_EVENT_TOPIC && log.topics[1]) {
+        return log.topics[1];
+      }
+    }
+    throw new Error(
+      "Failed to extract message GUID from transaction logs. The OFTSent event was not found in the transaction receipt."
+    );
+  }
   /**
    * Ensure sufficient token allowance for the OFT contract
+   *
+   * @param oftAddress - The OFT contract address
+   * @param amount - The amount to approve
    */
   async ensureAllowance(oftAddress, amount) {
     const allowance = await this.signer.readContract({
@@ -1276,6 +2043,9 @@ var Usdt0Bridge = class {
   }
   /**
    * Build SendParam struct for LayerZero
+   *
+   * @param params - Bridge parameters
+   * @returns SendParam struct for the OFT contract
    */
   buildSendParam(params) {
     const dstEid = getEndpointId(params.toChain);
@@ -1296,6 +2066,8 @@ var Usdt0Bridge = class {
   }
   /**
    * Validate bridge parameters
+   *
+   * @param params - Bridge parameters to validate
    */
   validateBridgeParams(params) {
     if (params.fromChain !== this.chain) {
@@ -1316,21 +2088,301 @@ var Usdt0Bridge = class {
       throw new Error("Amount must be greater than 0");
     }
   }
+};
+function createUsdt0Bridge(signer, chain) {
+  return new Usdt0Bridge(signer, chain);
+}
+
+// src/bridge/scan.ts
+var LAYERZERO_SCAN_BASE_URL = "https://scan.layerzero-api.com/v1";
+var DEFAULT_TIMEOUT = 6e5;
+var DEFAULT_POLL_INTERVAL = 1e4;
+var LayerZeroScanClient = class {
   /**
-   * Get all supported destination chains from current chain
+   * Create a new LayerZero Scan client
+   *
+   * @param baseUrl - API base URL (default: production endpoint)
+   */
+  constructor(baseUrl = LAYERZERO_SCAN_BASE_URL) {
+    __publicField(this, "baseUrl");
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Get message by GUID
+   *
+   * @param guid - LayerZero message GUID
+   * @returns Message details including status
+   * @throws Error if message not found or API error
+   */
+  async getMessage(guid) {
+    const url = `${this.baseUrl}/messages/guid/${guid}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Message not found: ${guid}`);
+      }
+      throw new Error(`LayerZero Scan API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return this.mapApiResponse(data);
+  }
+  /**
+   * Get messages by wallet address
+   *
+   * @param address - Wallet address that initiated messages
+   * @param limit - Maximum number of messages to return (default: 20)
+   * @returns Array of messages
+   */
+  async getMessagesByWallet(address, limit = 20) {
+    const url = `${this.baseUrl}/messages/wallet/${address}?limit=${limit}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`LayerZero Scan API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const messages = data.messages ?? data.data ?? [];
+    return messages.map((msg) => this.mapApiResponse(msg));
+  }
+  /**
+   * Poll message status until delivered or failed
+   *
+   * @param guid - LayerZero message GUID
+   * @param options - Wait configuration options
+   * @returns Final message state (DELIVERED)
+   * @throws Error if message fails, is blocked, or times out
+   */
+  async waitForDelivery(guid, options = {}) {
+    const {
+      timeout = DEFAULT_TIMEOUT,
+      pollInterval = DEFAULT_POLL_INTERVAL,
+      onStatusChange
+    } = options;
+    const startTime = Date.now();
+    let lastStatus = null;
+    while (Date.now() - startTime < timeout) {
+      try {
+        const message = await this.getMessage(guid);
+        if (lastStatus !== message.status) {
+          lastStatus = message.status;
+          onStatusChange?.(message.status);
+        }
+        if (message.status === "DELIVERED") {
+          return message;
+        }
+        if (message.status === "FAILED") {
+          throw new Error(`Bridge message failed: ${guid}`);
+        }
+        if (message.status === "BLOCKED") {
+          throw new Error(`Bridge message blocked by DVN: ${guid}`);
+        }
+        await this.sleep(pollInterval);
+      } catch (error) {
+        if (error.message.includes("not found")) {
+          await this.sleep(pollInterval);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error(`Timeout waiting for message delivery: ${guid}`);
+  }
+  /**
+   * Check if a message has been delivered
+   *
+   * @param guid - LayerZero message GUID
+   * @returns True if delivered, false otherwise
+   */
+  async isDelivered(guid) {
+    try {
+      const message = await this.getMessage(guid);
+      return message.status === "DELIVERED";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Map API response to our interface
+   *
+   * @param data - The raw API response data
+   * @returns The mapped LayerZeroMessage object
+   */
+  mapApiResponse(data) {
+    const msg = data;
+    return {
+      guid: msg.guid ?? msg.messageGuid ?? "",
+      srcEid: msg.srcEid ?? msg.srcChainId ?? 0,
+      dstEid: msg.dstEid ?? msg.dstChainId ?? 0,
+      srcUaAddress: msg.srcUaAddress ?? msg.srcAddress ?? "",
+      dstUaAddress: msg.dstUaAddress ?? msg.dstAddress ?? "",
+      srcTxHash: msg.srcTxHash ?? "",
+      dstTxHash: msg.dstTxHash ?? void 0,
+      status: msg.status ?? "INFLIGHT",
+      srcBlockNumber: msg.srcBlockNumber ?? 0,
+      dstBlockNumber: msg.dstBlockNumber ?? void 0,
+      created: msg.created ?? msg.createdAt ?? "",
+      updated: msg.updated ?? msg.updatedAt ?? ""
+    };
+  }
+  /**
+   * Sleep helper
+   *
+   * @param ms - The number of milliseconds to sleep
+   * @returns A promise that resolves after the specified delay
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createLayerZeroScanClient(baseUrl) {
+  return new LayerZeroScanClient(baseUrl);
+}
+
+// src/bridge/router.ts
+var CrossChainPaymentRouter = class {
+  /**
+   * Create a cross-chain payment router
+   *
+   * @param signer - Wallet signer for bridge operations
+   * @param sourceChain - Chain where user's funds are located
+   */
+  constructor(signer, sourceChain) {
+    __publicField(this, "bridge");
+    __publicField(this, "scanClient");
+    __publicField(this, "sourceChain");
+    this.bridge = new Usdt0Bridge(signer, sourceChain);
+    this.scanClient = new LayerZeroScanClient();
+    this.sourceChain = sourceChain;
+  }
+  /**
+   * Get all bridgeable chains
+   *
+   * @returns Array of all chain names that support USDT0 bridging
+   */
+  static getBridgeableChains() {
+    return getBridgeableChains();
+  }
+  /**
+   * Route payment across chains
+   *
+   * This method:
+   * 1. Bridges USDT0 from source chain to destination chain
+   * 2. Sends funds to the payer's address on destination chain
+   * 3. Returns tracking info for monitoring delivery
+   *
+   * After delivery, the payer can use the bridged funds to pay on the destination chain.
+   *
+   * @param params - Payment routing parameters
+   * @returns Result with transaction hash and tracking info
+   */
+  async routePayment(params) {
+    this.validateParams(params);
+    const result = await this.bridge.send({
+      fromChain: params.sourceChain,
+      toChain: params.destinationChain,
+      amount: params.amount,
+      recipient: params.payer,
+      slippageTolerance: params.slippageTolerance
+    });
+    return {
+      bridgeTxHash: result.txHash,
+      messageGuid: result.messageGuid,
+      amountBridged: result.amountSent,
+      estimatedReceiveAmount: result.amountToReceive,
+      sourceChain: params.sourceChain,
+      destinationChain: params.destinationChain,
+      estimatedDeliveryTime: result.estimatedTime
+    };
+  }
+  /**
+   * Get estimated fees for routing a payment
+   *
+   * @param params - Payment parameters
+   * @returns Quote with native fee and estimated receive amount
+   */
+  async estimateFees(params) {
+    const quote = await this.bridge.quote({
+      fromChain: params.sourceChain,
+      toChain: params.destinationChain,
+      amount: params.amount,
+      recipient: params.payer
+    });
+    return {
+      nativeFee: quote.nativeFee,
+      estimatedReceiveAmount: quote.minAmountToReceive,
+      estimatedTime: quote.estimatedTime
+    };
+  }
+  /**
+   * Track message delivery status
+   *
+   * @param messageGuid - LayerZero message GUID from routePayment result
+   * @returns Current message status
+   */
+  async trackMessage(messageGuid) {
+    return this.scanClient.getMessage(messageGuid);
+  }
+  /**
+   * Wait for payment to be delivered on destination chain
+   *
+   * @param messageGuid - LayerZero message GUID from routePayment result
+   * @param options - Wait options (timeout, poll interval, callbacks)
+   * @returns Final message state when delivered
+   */
+  async waitForDelivery(messageGuid, options) {
+    return this.scanClient.waitForDelivery(messageGuid, options);
+  }
+  /**
+   * Check if routing between two chains is supported
+   *
+   * @param sourceChain - Source chain name
+   * @param destinationChain - Destination chain name
+   * @returns True if routing is supported
+   */
+  canRoute(sourceChain, destinationChain) {
+    return sourceChain !== destinationChain && supportsBridging(sourceChain) && supportsBridging(destinationChain);
+  }
+  /**
+   * Get all supported destination chains from source chain
+   *
+   * @returns Array of chain names that can receive bridged funds
    */
   getSupportedDestinations() {
-    return getBridgeableChains().filter((chain) => chain !== this.chain);
+    return this.bridge.getSupportedDestinations();
   }
   /**
-   * Check if a destination chain is supported
+   * Validate routing parameters
+   *
+   * @param params - The cross-chain payment parameters to validate
+   * @throws Error if parameters are invalid or routing is not supported
    */
-  supportsDestination(toChain) {
-    return toChain !== this.chain && supportsBridging(toChain);
+  validateParams(params) {
+    if (params.sourceChain !== this.sourceChain) {
+      throw new Error(
+        `Source chain mismatch: router initialized for "${this.sourceChain}" but got "${params.sourceChain}"`
+      );
+    }
+    if (!this.canRoute(params.sourceChain, params.destinationChain)) {
+      throw new Error(
+        `Cannot route payment from "${params.sourceChain}" to "${params.destinationChain}". Supported chains: ${getBridgeableChains().join(", ")}`
+      );
+    }
+    if (params.amount <= 0n) {
+      throw new Error("Amount must be greater than 0");
+    }
   }
 };
-function createUsdt0Bridge(signer, chain) {
-  return new Usdt0Bridge(signer, chain);
+function createCrossChainPaymentRouter(signer, sourceChain) {
+  return new CrossChainPaymentRouter(signer, sourceChain);
 }
 
 // src/erc4337/constants.ts
@@ -1508,25 +2560,35 @@ function unpackGasFees(packed) {
 }
 
 // src/erc4337/builder.ts
-var import_viem5 = require("viem");
+var import_viem8 = require("viem");
 var UserOpBuilder = class {
+  /**
+   * Create a new UserOpBuilder instance
+   *
+   * @param options - Optional configuration for the builder
+   */
   constructor(options = {}) {
+    __publicField(this, "entryPoint");
+    __publicField(this, "gasMultiplier");
     this.entryPoint = options.entryPoint ?? ENTRYPOINT_V07_ADDRESS;
     this.gasMultiplier = options.gasMultiplier ?? 1.2;
   }
   /**
    * Build a UserOperation from a transaction intent
+   *
+   * @param signer - The smart account signer
+   * @param intent - The transaction intent to execute
+   * @param client - The public client for chain interaction
+   * @param gasEstimate - Optional gas estimates (uses defaults if not provided)
+   * @param paymaster - Optional paymaster data for sponsored transactions
+   * @returns A UserOperation ready for signing
    */
   async buildUserOp(signer, intent, client, gasEstimate, paymaster) {
     const sender = await signer.getAddress();
     const nonce = await this.getNonce(client, sender);
     const isDeployed = await signer.isDeployed();
     const initCode = isDeployed ? "0x" : await signer.getInitCode();
-    const callData = signer.encodeExecute(
-      intent.to,
-      intent.value ?? 0n,
-      intent.data ?? "0x"
-    );
+    const callData = signer.encodeExecute(intent.to, intent.value ?? 0n, intent.data ?? "0x");
     const { maxFeePerGas, maxPriorityFeePerGas } = await this.getGasPrices(client);
     const gas = gasEstimate ?? DEFAULT_GAS_LIMITS;
     const verificationGasLimit = this.applyMultiplier(gas.verificationGasLimit);
@@ -1550,6 +2612,13 @@ var UserOpBuilder = class {
   }
   /**
    * Build a batch UserOperation from multiple transaction intents
+   *
+   * @param signer - The smart account signer
+   * @param intents - Array of transaction intents to execute
+   * @param client - The public client for chain interaction
+   * @param gasEstimate - Optional gas estimates (uses defaults if not provided)
+   * @param paymaster - Optional paymaster data for sponsored transactions
+   * @returns A UserOperation ready for signing
    */
   async buildBatchUserOp(signer, intents, client, gasEstimate, paymaster) {
     const sender = await signer.getAddress();
@@ -1586,6 +2655,9 @@ var UserOpBuilder = class {
   }
   /**
    * Pack a UserOperation for on-chain submission (v0.7 format)
+   *
+   * @param userOp - The UserOperation to pack
+   * @returns The packed UserOperation for on-chain submission
    */
   packUserOp(userOp) {
     return {
@@ -1593,10 +2665,7 @@ var UserOpBuilder = class {
       nonce: userOp.nonce,
       initCode: userOp.initCode,
       callData: userOp.callData,
-      accountGasLimits: packAccountGasLimits(
-        userOp.verificationGasLimit,
-        userOp.callGasLimit
-      ),
+      accountGasLimits: packAccountGasLimits(userOp.verificationGasLimit, userOp.callGasLimit),
       preVerificationGas: userOp.preVerificationGas,
       gasFees: packGasFees(userOp.maxPriorityFeePerGas, userOp.maxFeePerGas),
       paymasterAndData: userOp.paymasterAndData,
@@ -1605,8 +2674,13 @@ var UserOpBuilder = class {
   }
   /**
    * Compute the UserOperation hash for signing
+   *
+   * @param userOp - The UserOperation to hash
+   * @param client - The public client for chain interaction
+   * @param _ - The chain ID (reserved for future use)
+   * @returns The UserOperation hash
    */
-  async getUserOpHash(userOp, client, chainId) {
+  async getUserOpHash(userOp, client, _) {
     const packed = this.packUserOp(userOp);
     const userOpTuple = {
       sender: packed.sender,
@@ -1629,6 +2703,12 @@ var UserOpBuilder = class {
   }
   /**
    * Sign a UserOperation
+   *
+   * @param userOp - The UserOperation to sign
+   * @param signer - The smart account signer
+   * @param client - The public client for chain interaction
+   * @param chainId - The chain ID for the signature
+   * @returns The UserOperation with signature attached
    */
   async signUserOp(userOp, signer, client, chainId) {
     const userOpHash = await this.getUserOpHash(userOp, client, chainId);
@@ -1640,6 +2720,10 @@ var UserOpBuilder = class {
   }
   /**
    * Get the nonce for an account from EntryPoint
+   *
+   * @param client - The public client for chain interaction
+   * @param sender - The smart account address
+   * @returns The current nonce for the account
    */
   async getNonce(client, sender) {
     try {
@@ -1657,6 +2741,9 @@ var UserOpBuilder = class {
   }
   /**
    * Get current gas prices from the chain
+   *
+   * @param client - The public client for chain interaction
+   * @returns The current gas prices for EIP-1559 transactions
    */
   async getGasPrices(client) {
     const block = await client.getBlock({ blockTag: "latest" });
@@ -1667,25 +2754,26 @@ var UserOpBuilder = class {
   }
   /**
    * Apply gas multiplier for safety margin
+   *
+   * @param gas - The gas amount to multiply
+   * @returns The gas amount with safety margin applied
    */
   applyMultiplier(gas) {
     return BigInt(Math.ceil(Number(gas) * this.gasMultiplier));
   }
   /**
    * Encode paymaster data for the UserOperation
+   *
+   * @param paymaster - The paymaster configuration
+   * @returns The encoded paymaster data
    */
   encodePaymasterData(paymaster) {
     const paymasterAddress = paymaster.paymaster;
-    const verificationGas = (0, import_viem5.pad)((0, import_viem5.toHex)(paymaster.paymasterVerificationGasLimit), {
+    const verificationGas = (0, import_viem8.pad)((0, import_viem8.toHex)(paymaster.paymasterVerificationGasLimit), {
       size: 16
     });
-    const postOpGas = (0, import_viem5.pad)((0, import_viem5.toHex)(paymaster.paymasterPostOpGasLimit), { size: 16 });
-    return (0, import_viem5.concat)([
-      paymasterAddress,
-      verificationGas,
-      postOpGas,
-      paymaster.paymasterData
-    ]);
+    const postOpGas = (0, import_viem8.pad)((0, import_viem8.toHex)(paymaster.paymasterPostOpGasLimit), { size: 16 });
+    return (0, import_viem8.concat)([paymasterAddress, verificationGas, postOpGas, paymaster.paymasterData]);
   }
 };
 function createUserOpBuilder(options) {
@@ -1694,6 +2782,13 @@ function createUserOpBuilder(options) {
 
 // src/erc4337/bundler.ts
 var BundlerError = class extends Error {
+  /**
+   * Create a new BundlerError
+   *
+   * @param message - The error message
+   * @param code - Optional JSON-RPC error code
+   * @param data - Optional additional error data
+   */
   constructor(message, code, data) {
     super(message);
     this.code = code;
@@ -1702,21 +2797,31 @@ var BundlerError = class extends Error {
   }
 };
 var BundlerClient = class {
+  /**
+   * Create a new BundlerClient instance
+   *
+   * @param config - Configuration for the bundler client
+   */
   constructor(config) {
-    this.requestId = 0;
+    __publicField(this, "bundlerUrl");
+    __publicField(this, "entryPoint");
+    __publicField(this, "requestId", 0);
     this.bundlerUrl = config.bundlerUrl;
     this.entryPoint = config.entryPoint ?? ENTRYPOINT_V07_ADDRESS;
-    this.chainId = config.chainId;
+    void config.chainId;
   }
   /**
    * Send a UserOperation to the bundler
+   *
+   * @param userOp - The UserOperation to send
+   * @returns The result containing the userOpHash and a wait function
    */
   async sendUserOperation(userOp) {
     const packed = this.packForRpc(userOp);
-    const userOpHash = await this.rpcCall(
-      BUNDLER_METHODS.sendUserOperation,
-      [packed, this.entryPoint]
-    );
+    const userOpHash = await this.rpcCall(BUNDLER_METHODS.sendUserOperation, [
+      packed,
+      this.entryPoint
+    ]);
     return {
       userOpHash,
       wait: () => this.waitForReceipt(userOpHash)
@@ -1724,6 +2829,9 @@ var BundlerClient = class {
   }
   /**
    * Estimate gas for a UserOperation
+   *
+   * @param userOp - Partial UserOperation with required sender and callData
+   * @returns Gas estimates for the UserOperation
    */
   async estimateUserOperationGas(userOp) {
     const estimationOp = {
@@ -1752,6 +2860,9 @@ var BundlerClient = class {
   }
   /**
    * Get UserOperation by hash
+   *
+   * @param userOpHash - The hash of the UserOperation to retrieve
+   * @returns The UserOperation and EntryPoint, or null if not found
    */
   async getUserOperationByHash(userOpHash) {
     const result = await this.rpcCall(BUNDLER_METHODS.getUserOperationByHash, [userOpHash]);
@@ -1759,6 +2870,9 @@ var BundlerClient = class {
   }
   /**
    * Get UserOperation receipt
+   *
+   * @param userOpHash - The hash of the UserOperation
+   * @returns The receipt, or null if not yet included
    */
   async getUserOperationReceipt(userOpHash) {
     const result = await this.rpcCall(BUNDLER_METHODS.getUserOperationReceipt, [userOpHash]);
@@ -1781,12 +2895,16 @@ var BundlerClient = class {
   }
   /**
    * Get supported EntryPoints
+   *
+   * @returns Array of supported EntryPoint addresses
    */
   async getSupportedEntryPoints() {
     return this.rpcCall(BUNDLER_METHODS.supportedEntryPoints, []);
   }
   /**
    * Get chain ID from bundler
+   *
+   * @returns The chain ID
    */
   async getChainId() {
     const result = await this.rpcCall(BUNDLER_METHODS.chainId, []);
@@ -1794,6 +2912,12 @@ var BundlerClient = class {
   }
   /**
    * Wait for UserOperation receipt with polling
+   *
+   * @param userOpHash - The hash of the UserOperation to wait for
+   * @param options - Polling options
+   * @param options.timeout - Maximum time to wait in milliseconds (default: 60000)
+   * @param options.pollingInterval - Interval between polls in milliseconds (default: 2000)
+   * @returns The UserOperation receipt
    */
   async waitForReceipt(userOpHash, options = {}) {
     const timeout = options.timeout ?? 6e4;
@@ -1806,12 +2930,13 @@ var BundlerClient = class {
       }
       await new Promise((resolve) => setTimeout(resolve, pollingInterval));
     }
-    throw new BundlerError(
-      `Timeout waiting for UserOperation receipt: ${userOpHash}`
-    );
+    throw new BundlerError(`Timeout waiting for UserOperation receipt: ${userOpHash}`);
   }
   /**
    * Pack UserOperation for RPC (convert bigints to hex strings)
+   *
+   * @param userOp - The UserOperation to pack
+   * @returns The packed UserOperation for RPC transmission
    */
   packForRpc(userOp) {
     return {
@@ -1819,10 +2944,7 @@ var BundlerClient = class {
       nonce: this.toHex(userOp.nonce),
       initCode: userOp.initCode,
       callData: userOp.callData,
-      accountGasLimits: packAccountGasLimits(
-        userOp.verificationGasLimit,
-        userOp.callGasLimit
-      ),
+      accountGasLimits: packAccountGasLimits(userOp.verificationGasLimit, userOp.callGasLimit),
       preVerificationGas: this.toHex(userOp.preVerificationGas),
       gasFees: packGasFees(userOp.maxPriorityFeePerGas, userOp.maxFeePerGas),
       paymasterAndData: userOp.paymasterAndData,
@@ -1831,12 +2953,19 @@ var BundlerClient = class {
   }
   /**
    * Convert bigint to hex string
+   *
+   * @param value - The bigint value to convert
+   * @returns The hex string representation
    */
   toHex(value) {
     return `0x${value.toString(16)}`;
   }
   /**
    * Make a JSON-RPC call to the bundler
+   *
+   * @param method - The JSON-RPC method name
+   * @param params - The method parameters
+   * @returns The result from the bundler
    */
   async rpcCall(method, params) {
     const request = {
@@ -1853,9 +2982,7 @@ var BundlerClient = class {
       body: JSON.stringify(request)
     });
     if (!response.ok) {
-      throw new BundlerError(
-        `HTTP error: ${response.status} ${response.statusText}`
-      );
+      throw new BundlerError(`HTTP error: ${response.status} ${response.statusText}`);
     }
     const json = await response.json();
     if (json.error) {
@@ -1869,25 +2996,32 @@ function createBundlerClient(config) {
 }
 
 // src/erc4337/paymaster.ts
-var import_viem6 = require("viem");
+var import_viem9 = require("viem");
 var PaymasterClient = class {
+  /**
+   * Creates a new PaymasterClient instance
+   *
+   * @param config - Paymaster configuration including type, address, and optional URL
+   */
   constructor(config) {
+    __publicField(this, "config");
     this.config = config;
   }
   /**
    * Get paymaster data for a UserOperation
+   *
+   * @param userOp - Partial UserOperation to get paymaster data for
+   * @param chainId - The chain ID for the operation
+   * @param entryPoint - The EntryPoint contract address
+   * @param context - Optional context data for the paymaster
+   * @returns Paymaster data including address and gas limits
    */
   async getPaymasterData(userOp, chainId, entryPoint, context) {
     switch (this.config.type) {
       case "verifying":
         return this.getVerifyingPaymasterData(userOp, chainId, entryPoint);
       case "sponsoring":
-        return this.getSponsoringPaymasterData(
-          userOp,
-          chainId,
-          entryPoint,
-          context
-        );
+        return this.getSponsoringPaymasterData(userOp, chainId, entryPoint, context);
       case "token":
         return this.getTokenPaymasterData(userOp, chainId, entryPoint);
       default:
@@ -1896,8 +3030,12 @@ var PaymasterClient = class {
   }
   /**
    * Get gas estimates including paymaster gas
+   *
+   * @param _userOp - Partial UserOperation to estimate gas for (reserved for future use)
+   * @param _chainId - The chain ID for the operation (reserved for future use)
+   * @returns Gas estimates including paymaster verification and postOp gas
    */
-  async estimatePaymasterGas(userOp, _chainId) {
+  async estimatePaymasterGas(_userOp, _chainId) {
     return {
       verificationGasLimit: DEFAULT_GAS_LIMITS.verificationGasLimit,
       callGasLimit: DEFAULT_GAS_LIMITS.callGasLimit,
@@ -1908,6 +3046,12 @@ var PaymasterClient = class {
   }
   /**
    * Check if the paymaster will sponsor this operation
+   *
+   * @param userOp - Partial UserOperation to check sponsorship for
+   * @param chainId - The chain ID for the operation
+   * @param entryPoint - The EntryPoint contract address
+   * @param context - Optional context data for policy validation
+   * @returns True if the paymaster will sponsor the operation
    */
   async willSponsor(userOp, chainId, entryPoint, context) {
     if (!this.config.url) {
@@ -1933,6 +3077,11 @@ var PaymasterClient = class {
   }
   /**
    * Get verifying paymaster data (off-chain signature)
+   *
+   * @param userOp - Partial UserOperation to get paymaster data for
+   * @param chainId - The chain ID for the operation
+   * @param entryPoint - The EntryPoint contract address
+   * @returns Paymaster data with verification signature
    */
   async getVerifyingPaymasterData(userOp, chainId, entryPoint) {
     if (this.config.url) {
@@ -1947,6 +3096,12 @@ var PaymasterClient = class {
   }
   /**
    * Get sponsoring paymaster data (third-party pays)
+   *
+   * @param userOp - Partial UserOperation to get sponsorship for
+   * @param chainId - The chain ID for the operation
+   * @param entryPoint - The EntryPoint contract address
+   * @param context - Optional context data for sponsorship validation
+   * @returns Paymaster data for sponsored operation
    */
   async getSponsoringPaymasterData(userOp, chainId, entryPoint, context) {
     if (!this.config.url) {
@@ -1976,6 +3131,11 @@ var PaymasterClient = class {
   }
   /**
    * Get token paymaster data (pay gas with ERC20)
+   *
+   * @param userOp - Partial UserOperation to get token paymaster data for
+   * @param chainId - The chain ID for the operation
+   * @param entryPoint - The EntryPoint contract address
+   * @returns Paymaster data for ERC20 token payment
    */
   async getTokenPaymasterData(userOp, chainId, entryPoint) {
     const tokenAddress = this.config.options?.tokenAddress;
@@ -1997,6 +3157,12 @@ var PaymasterClient = class {
   }
   /**
    * Call paymaster service API
+   *
+   * @param userOp - Partial UserOperation to send to the service
+   * @param chainId - The chain ID for the operation
+   * @param entryPoint - The EntryPoint contract address
+   * @param context - Optional context data for the service
+   * @returns Paymaster data from the service response
    */
   async callPaymasterService(userOp, chainId, entryPoint, context) {
     if (!this.config.url) {
@@ -2026,12 +3192,14 @@ var PaymasterClient = class {
   }
   /**
    * Serialize UserOperation for API calls
+   *
+   * @param userOp - Partial UserOperation to serialize
+   * @returns Serialized UserOperation with hex-encoded values
    */
   serializeUserOp(userOp) {
     const result = {};
     if (userOp.sender) result.sender = userOp.sender;
-    if (userOp.nonce !== void 0)
-      result.nonce = `0x${userOp.nonce.toString(16)}`;
+    if (userOp.nonce !== void 0) result.nonce = `0x${userOp.nonce.toString(16)}`;
     if (userOp.initCode) result.initCode = userOp.initCode;
     if (userOp.callData) result.callData = userOp.callData;
     if (userOp.verificationGasLimit !== void 0)
@@ -2053,10 +3221,10 @@ function createPaymasterClient(config) {
   return new PaymasterClient(config);
 }
 function encodePaymasterAndData(data) {
-  return (0, import_viem6.concat)([
+  return (0, import_viem9.concat)([
     data.paymaster,
-    (0, import_viem6.pad)((0, import_viem6.toHex)(data.paymasterVerificationGasLimit), { size: 16 }),
-    (0, import_viem6.pad)((0, import_viem6.toHex)(data.paymasterPostOpGasLimit), { size: 16 }),
+    (0, import_viem9.pad)((0, import_viem9.toHex)(data.paymasterVerificationGasLimit), { size: 16 }),
+    (0, import_viem9.pad)((0, import_viem9.toHex)(data.paymasterPostOpGasLimit), { size: 16 }),
     data.paymasterData
   ]);
 }
@@ -2065,9 +3233,7 @@ function decodePaymasterAndData(paymasterAndData) {
     return null;
   }
   const paymaster = `0x${paymasterAndData.slice(2, 42)}`;
-  const paymasterVerificationGasLimit = BigInt(
-    `0x${paymasterAndData.slice(42, 74)}`
-  );
+  const paymasterVerificationGasLimit = BigInt(`0x${paymasterAndData.slice(42, 74)}`);
   const paymasterPostOpGasLimit = BigInt(`0x${paymasterAndData.slice(74, 106)}`);
   const paymasterData = `0x${paymasterAndData.slice(106)}`;
   return {
@@ -2079,13 +3245,13 @@ function decodePaymasterAndData(paymasterAndData) {
 }
 
 // src/erc4337/paymasters/pimlico.ts
-var import_viem7 = require("viem");
+var import_viem10 = require("viem");
 
 // src/erc4337/accounts/safe.ts
-var import_viem8 = require("viem");
+var import_viem11 = require("viem");
 
 // src/erc4337/t402.ts
-var import_viem9 = require("viem");
+var import_viem12 = require("viem");
 var ERC20_TRANSFER_ABI = [
   {
     inputs: [
@@ -2118,7 +3284,18 @@ var EIP3009_TRANSFER_ABI = [
   }
 ];
 var GaslessT402Client = class {
+  /**
+   * Creates a new GaslessT402Client instance
+   *
+   * @param config - Configuration including signer, bundler, paymaster, and chain settings
+   */
   constructor(config) {
+    __publicField(this, "signer");
+    __publicField(this, "builder");
+    __publicField(this, "bundler");
+    __publicField(this, "paymaster");
+    __publicField(this, "chainId");
+    __publicField(this, "publicClient");
     this.signer = config.signer;
     this.builder = new UserOpBuilder();
     this.bundler = new BundlerClient(config.bundler);
@@ -2132,6 +3309,9 @@ var GaslessT402Client = class {
    * This submits the payment as a UserOperation which can be:
    * - Sponsored by a paymaster (truly gasless)
    * - Paid from the smart account's balance
+   *
+   * @param params - Payment parameters including token, recipient, and amount
+   * @returns Result containing the user operation hash and wait function
    */
   async executePayment(params) {
     const callData = params.authorization ? this.buildAuthorizedTransferCallData(params) : this.buildTransferCallData(params);
@@ -2159,6 +3339,9 @@ var GaslessT402Client = class {
   }
   /**
    * Execute multiple T402 payments in a single UserOperation
+   *
+   * @param payments - Array of payment parameters to batch together
+   * @returns Result containing the user operation hash and wait function
    */
   async executeBatchPayments(payments) {
     const intents = payments.map((params) => ({
@@ -2185,6 +3368,9 @@ var GaslessT402Client = class {
   }
   /**
    * Check if a payment can be sponsored (gasless)
+   *
+   * @param params - Payment parameters to check for sponsorship eligibility
+   * @returns True if the payment can be sponsored by the paymaster
    */
   async canSponsor(params) {
     if (!this.paymaster) return false;
@@ -2202,21 +3388,28 @@ var GaslessT402Client = class {
   }
   /**
    * Get the smart account address
+   *
+   * @returns The address of the smart account
    */
   async getAccountAddress() {
     return this.signer.getAddress();
   }
   /**
    * Check if the smart account is deployed
+   *
+   * @returns True if the smart account contract is deployed on-chain
    */
   async isAccountDeployed() {
     return this.signer.isDeployed();
   }
   /**
    * Build call data for a simple ERC20 transfer
+   *
+   * @param params - Payment parameters including recipient and amount
+   * @returns Encoded call data for ERC20 transfer function
    */
   buildTransferCallData(params) {
-    return (0, import_viem9.encodeFunctionData)({
+    return (0, import_viem12.encodeFunctionData)({
       abi: ERC20_TRANSFER_ABI,
       functionName: "transfer",
       args: [params.to, params.amount]
@@ -2224,6 +3417,9 @@ var GaslessT402Client = class {
   }
   /**
    * Build call data for an authorized transfer (EIP-3009)
+   *
+   * @param params - Payment parameters including authorization signature
+   * @returns Encoded call data for transferWithAuthorization function
    */
   buildAuthorizedTransferCallData(params) {
     if (!params.authorization) {
@@ -2233,7 +3429,7 @@ var GaslessT402Client = class {
     const r = `0x${sig.slice(2, 66)}`;
     const s = `0x${sig.slice(66, 130)}`;
     const v = parseInt(sig.slice(130, 132), 16);
-    return (0, import_viem9.encodeFunctionData)({
+    return (0, import_viem12.encodeFunctionData)({
       abi: EIP3009_TRANSFER_ABI,
       functionName: "transferWithAuthorization",
       args: [
@@ -2252,14 +3448,13 @@ var GaslessT402Client = class {
   }
   /**
    * Estimate gas for a single transaction
+   *
+   * @param intent - Transaction intent with target, value, and data
+   * @returns Gas estimates for the UserOperation
    */
   async estimateGas(intent) {
     const sender = await this.signer.getAddress();
-    const callData = this.signer.encodeExecute(
-      intent.to,
-      intent.value ?? 0n,
-      intent.data ?? "0x"
-    );
+    const callData = this.signer.encodeExecute(intent.to, intent.value ?? 0n, intent.data ?? "0x");
     try {
       return await this.bundler.estimateUserOperationGas({
         sender,
@@ -2275,6 +3470,9 @@ var GaslessT402Client = class {
   }
   /**
    * Estimate gas for a batch transaction
+   *
+   * @param intents - Array of transaction intents to batch
+   * @returns Gas estimates for the batched UserOperation
    */
   async estimateBatchGas(intents) {
     const sender = await this.signer.getAddress();
@@ -2298,15 +3496,14 @@ var GaslessT402Client = class {
   }
   /**
    * Get paymaster data if configured
+   *
+   * @param _ - Gas estimates (unused but kept for potential future use)
+   * @returns Paymaster data or undefined if no paymaster configured
    */
-  async getPaymasterData(_gasEstimate) {
+  async getPaymasterData(_) {
     if (!this.paymaster) return void 0;
     const sender = await this.signer.getAddress();
-    return this.paymaster.getPaymasterData(
-      { sender },
-      this.chainId,
-      ENTRYPOINT_V07_ADDRESS
-    );
+    return this.paymaster.getPaymasterData({ sender }, this.chainId, ENTRYPOINT_V07_ADDRESS);
   }
 };
 function createGaslessT402Client(config) {
@@ -2318,6 +3515,7 @@ function createGaslessT402Client(config) {
   BUNDLER_METHODS,
   BundlerClient,
   BundlerError,
+  CrossChainPaymentRouter,
   DEFAULT_GAS_LIMITS,
   ENTRYPOINT_V06_ADDRESS,
   ENTRYPOINT_V07_ABI,
@@ -2329,46 +3527,38 @@ function createGaslessT402Client(config) {
   GaslessT402Client,
   LAYERZERO_ENDPOINT_IDS,
   LAYERZERO_ENDPOINT_V2,
+  LAYERZERO_SCAN_BASE_URL,
+  LayerZeroScanClient,
   PaymasterClient,
   PaymasterType,
-  TOKEN_PRIORITY,
-  TOKEN_REGISTRY,
-  USDC_ADDRESSES,
-  USDT0_ADDRESSES,
   USDT0_OFT_ADDRESSES,
-  USDT_LEGACY_ADDRESSES,
+  UptoEvmFacilitatorScheme,
+  UptoEvmScheme,
+  UptoEvmServerScheme,
   Usdt0Bridge,
   UserOpBuilder,
   addressToBytes32,
-  authorizationTypes,
   bytes32ToAddress,
   createBundlerClient,
+  createCrossChainPaymentRouter,
   createGaslessT402Client,
+  createLayerZeroScanClient,
   createPaymasterClient,
+  createUptoEvmFacilitatorScheme,
+  createUptoEvmScheme,
+  createUptoEvmServerScheme,
   createUsdt0Bridge,
   createUserOpBuilder,
   decodePaymasterAndData,
-  eip3009ABI,
   encodePaymasterAndData,
-  erc20LegacyABI,
   getBridgeableChains,
-  getDefaultToken,
-  getEIP712Domain,
   getEndpointId,
-  getNetworkTokens,
-  getNetworksForToken,
-  getTokenByAddress,
-  getTokenConfig,
-  getUsdt0Networks,
   getUsdt0OftAddress,
-  legacyAuthorizationTypes,
   packAccountGasLimits,
   packGasFees,
   supportsBridging,
-  supportsEIP3009,
-  toClientEvmSigner,
-  toFacilitatorEvmSigner,
   unpackAccountGasLimits,
-  unpackGasFees
+  unpackGasFees,
+  ...require("@t402/evm-core")
 });
 //# sourceMappingURL=index.js.map