@t402/evm 2.1.0 → 2.3.0

package/dist/cjs/index.d.ts

@@ -1,8 +1,10 @@
-export { E as ExactEvmScheme } from './scheme-OojTBKAz.js';
-export { a as ExactEvmSchemeConfig } from './scheme-yqGaK9rK.js';
+export * from '@t402/evm-core';
+export { E as ExactEvmScheme } from './scheme-CjijeY7y.js';
+export { a as ExactEvmSchemeConfig } from './scheme-B4rXSKCN.js';
 import { SchemeNetworkClient, PaymentRequirements, PaymentPayload, SchemeNetworkServer, MoneyParser, Price, Network, AssetAmount, SchemeNetworkFacilitator, VerifyResponse, SettleResponse } from '@t402/core/types';
-import { C as ClientEvmSigner, F as FacilitatorEvmSigner } from './signer-BkcAzwYi.js';
-export { t as toClientEvmSigner, a as toFacilitatorEvmSigner } from './signer-BkcAzwYi.js';
+import { C as ClientEvmSigner, F as FacilitatorEvmSigner } from './signer-DcavxxZt.js';
+export { UptoEvmScheme, createUptoEvmScheme } from './upto/client/index.js';
+export { b as UptoEvmFacilitatorScheme, e as UptoEvmFacilitatorSchemeConfig, U as UptoEvmServerScheme, a as UptoEvmServerSchemeConfig, d as createUptoEvmFacilitatorScheme, c as createUptoEvmServerScheme } from './scheme-CIar5W2B.js';
 import { Address, Hex, PublicClient } from 'viem';
 
 /**
@@ -59,18 +61,52 @@ declare class ExactLegacyEvmScheme$1 implements SchemeNetworkServer {
     readonly scheme = "exact-legacy";
     private moneyParsers;
     private config;
+    /**
+     * Creates a new ExactLegacyEvmScheme instance.
+     *
+     * @param config - Optional configuration options for the scheme
+     */
     constructor(config?: ExactLegacyEvmSchemeConfig$1);
+    /**
+     * Get all supported networks that have legacy tokens
+     *
+     * @returns Array of network identifiers with legacy token support
+     */
+    static getSupportedNetworks(): string[];
+    /**
+     * 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: string): boolean;
     /**
      * 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: MoneyParser): ExactLegacyEvmScheme$1;
     /**
      * 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
      */
     parsePrice(price: Price, network: Network): Promise<AssetAmount>;
     /**
      * 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: PaymentRequirements, supportedKind: {
         t402Version: number;
@@ -80,28 +116,34 @@ declare class ExactLegacyEvmScheme$1 implements SchemeNetworkServer {
     }, extensionKeys: string[]): Promise<PaymentRequirements>;
     /**
      * 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
      */
     private parseMoneyToDecimal;
     /**
      * 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
      */
     private defaultMoneyConversion;
     /**
      * 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
      */
     private convertToTokenAmount;
     /**
      * 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
      */
     private getDefaultAsset;
-    /**
-     * Get all supported networks that have legacy tokens
-     */
-    static getSupportedNetworks(): string[];
-    /**
-     * Check if a network has legacy token support
-     */
-    static isNetworkSupported(network: string): boolean;
 }
 
 interface ExactLegacyEvmSchemeConfig {
@@ -140,349 +182,29 @@ declare class ExactLegacyEvmScheme implements SchemeNetworkFacilitator {
     getExtra(network: string): Record<string, unknown> | undefined;
     /**
      * 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: string): string[];
     /**
      * 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
      */
     verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
     /**
      * 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
      */
     settle(payload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
 }
 
-/**
- * Token configuration for T402 EVM payments
- *
- * This module provides comprehensive token definitions including:
- * - USDT0 (Tether's new omnichain token with EIP-3009 support)
- * - USDC (USD Coin with EIP-3009 support)
- * - Legacy tokens configuration
- */
-
-/**
- * Token type classification for payment scheme selection
- */
-type TokenType = "eip3009" | "legacy";
-/**
- * Token configuration with EIP-712 domain parameters
- */
-interface TokenConfig {
-    /** Token contract address */
-    address: Address;
-    /** Token symbol (e.g., "USDT0", "USDC") */
-    symbol: string;
-    /** EIP-712 domain name for signing */
-    name: string;
-    /** EIP-712 domain version for signing */
-    version: string;
-    /** Number of decimal places */
-    decimals: number;
-    /** Token type for scheme selection */
-    tokenType: TokenType;
-    /** Payment priority (lower = higher priority) */
-    priority: number;
-}
-/**
- * Network token registry mapping network -> symbol -> config
- */
-type NetworkTokenRegistry = Record<string, Record<string, TokenConfig>>;
-/**
- * USDT0 Contract Addresses by Network
- * Source: https://docs.tether.io/usdt0/integration-guide/deployed-contracts
- *
- * USDT0 is Tether's new omnichain token using LayerZero OFT standard.
- * Key features:
- * - Supports EIP-3009 transferWithAuthorization (gasless transfers)
- * - Supports EIP-2612 permit
- * - Native cross-chain via LayerZero
- */
-declare const USDT0_ADDRESSES: Record<string, Address>;
-/**
- * USDC Contract Addresses by Network
- * Native USDC with EIP-3009 support
- */
-declare const USDC_ADDRESSES: Record<string, Address>;
-/**
- * Traditional USDT Addresses (Legacy - no EIP-3009 support)
- * These require the approve + transferFrom pattern
- */
-declare const USDT_LEGACY_ADDRESSES: Record<string, Address>;
-/**
- * Complete token registry with all supported tokens per network
- */
-declare const TOKEN_REGISTRY: NetworkTokenRegistry;
-/**
- * Token priority for payment method selection
- * Lower number = higher priority
- */
-declare const TOKEN_PRIORITY: Record<string, number>;
-/**
- * Get token configuration for a specific token on a network
- */
-declare function getTokenConfig(network: string, symbol: string): TokenConfig | undefined;
-/**
- * Get all tokens available on a network
- */
-declare function getNetworkTokens(network: string): TokenConfig[];
-/**
- * Get the default/preferred token for a network
- * Prefers USDT0 > USDC > others based on priority
- */
-declare function getDefaultToken(network: string): TokenConfig | undefined;
-/**
- * Get token by contract address on a network
- */
-declare function getTokenByAddress(network: string, address: Address): TokenConfig | undefined;
-/**
- * Check if a token supports EIP-3009 (gasless transfers)
- */
-declare function supportsEIP3009(network: string, symbol: string): boolean;
-/**
- * Get all networks that support a specific token
- */
-declare function getNetworksForToken(symbol: string): string[];
-/**
- * Get USDT0 networks (primary T402 token)
- */
-declare function getUsdt0Networks(): string[];
-/**
- * EIP-712 domain configuration for a token
- */
-declare function getEIP712Domain(network: string, tokenAddress: Address, chainId: number): {
-    name: string;
-    version: string;
-    chainId: number;
-    verifyingContract: Address;
-} | undefined;
-
-type ExactEIP3009Payload = {
-    signature?: `0x${string}`;
-    authorization: {
-        from: `0x${string}`;
-        to: `0x${string}`;
-        value: string;
-        validAfter: string;
-        validBefore: string;
-        nonce: `0x${string}`;
-    };
-};
-type ExactEvmPayloadV1 = ExactEIP3009Payload;
-type ExactEvmPayloadV2 = ExactEIP3009Payload;
-/**
- * Payload for exact-legacy scheme (approve + transferFrom pattern)
- * Used for legacy USDT and other tokens without EIP-3009 support
- */
-type ExactLegacyPayload = {
-    signature?: `0x${string}`;
-    authorization: {
-        /** Payer address */
-        from: `0x${string}`;
-        /** Recipient address */
-        to: `0x${string}`;
-        /** Payment amount in token units */
-        value: string;
-        /** Unix timestamp after which the authorization is valid */
-        validAfter: string;
-        /** Unix timestamp before which the authorization is valid */
-        validBefore: string;
-        /** Unique nonce to prevent replay attacks */
-        nonce: `0x${string}`;
-        /** Facilitator address that will call transferFrom */
-        spender: `0x${string}`;
-    };
-};
-
-declare const authorizationTypes: {
-    readonly TransferWithAuthorization: readonly [{
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly name: "value";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validAfter";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validBefore";
-        readonly type: "uint256";
-    }, {
-        readonly name: "nonce";
-        readonly type: "bytes32";
-    }];
-};
-declare const legacyAuthorizationTypes: {
-    readonly LegacyTransferAuthorization: readonly [{
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly name: "value";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validAfter";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validBefore";
-        readonly type: "uint256";
-    }, {
-        readonly name: "nonce";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "spender";
-        readonly type: "address";
-    }];
-};
-declare const eip3009ABI: readonly [{
-    readonly inputs: readonly [{
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly name: "value";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validAfter";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validBefore";
-        readonly type: "uint256";
-    }, {
-        readonly name: "nonce";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "v";
-        readonly type: "uint8";
-    }, {
-        readonly name: "r";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "s";
-        readonly type: "bytes32";
-    }];
-    readonly name: "transferWithAuthorization";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly name: "value";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validAfter";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validBefore";
-        readonly type: "uint256";
-    }, {
-        readonly name: "nonce";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "signature";
-        readonly type: "bytes";
-    }];
-    readonly name: "transferWithAuthorization";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly name: "account";
-        readonly type: "address";
-    }];
-    readonly name: "balanceOf";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "version";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}];
-declare const erc20LegacyABI: readonly [{
-    readonly inputs: readonly [{
-        readonly name: "account";
-        readonly type: "address";
-    }];
-    readonly name: "balanceOf";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly name: "spender";
-        readonly type: "address";
-    }];
-    readonly name: "allowance";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly name: "spender";
-        readonly type: "address";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-    }];
-    readonly name: "approve";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-    }];
-    readonly name: "transferFrom";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}];
-
 /**
  * Type definitions for USDT0 cross-chain bridging
  */
@@ -574,6 +296,28 @@ interface BridgeTransaction {
     /** Destination chain transaction hash (when completed) */
     dstTxHash?: `0x${string}`;
 }
+/**
+ * Transaction log entry
+ */
+interface TransactionLog {
+    /** Contract address that emitted the log */
+    address: Address;
+    /** Indexed event parameters */
+    topics: readonly `0x${string}`[];
+    /** Non-indexed event data */
+    data: `0x${string}`;
+}
+/**
+ * Transaction receipt with logs
+ */
+interface TransactionReceipt {
+    /** Transaction status ("success" or "reverted") */
+    status: string;
+    /** Transaction hash */
+    transactionHash: `0x${string}`;
+    /** Event logs emitted during transaction */
+    logs: readonly TransactionLog[];
+}
 /**
  * Signer interface for bridge operations
  */
@@ -598,9 +342,87 @@ interface BridgeSigner {
     /** Wait for transaction receipt */
     waitForTransactionReceipt(args: {
         hash: `0x${string}`;
-    }): Promise<{
-        status: string;
-    }>;
+    }): Promise<TransactionReceipt>;
+}
+/**
+ * LayerZero message status from Scan API
+ */
+type LayerZeroMessageStatus = "INFLIGHT" | "CONFIRMING" | "DELIVERED" | "FAILED" | "BLOCKED";
+/**
+ * LayerZero message from Scan API
+ */
+interface LayerZeroMessage {
+    /** Unique message identifier */
+    guid: string;
+    /** Source chain LayerZero endpoint ID */
+    srcEid: number;
+    /** Destination chain LayerZero endpoint ID */
+    dstEid: number;
+    /** Source chain OApp address */
+    srcUaAddress: string;
+    /** Destination chain OApp address */
+    dstUaAddress: string;
+    /** Source chain transaction hash */
+    srcTxHash: string;
+    /** Destination chain transaction hash (when delivered) */
+    dstTxHash?: string;
+    /** Current message status */
+    status: LayerZeroMessageStatus;
+    /** Source chain block number */
+    srcBlockNumber: number;
+    /** Destination chain block number (when delivered) */
+    dstBlockNumber?: number;
+    /** Timestamp when message was created */
+    created: string;
+    /** Timestamp when message was last updated */
+    updated: string;
+}
+/**
+ * Options for waiting for message delivery
+ */
+interface WaitForDeliveryOptions {
+    /** Maximum time to wait in milliseconds (default: 600000 = 10 minutes) */
+    timeout?: number;
+    /** Polling interval in milliseconds (default: 10000 = 10 seconds) */
+    pollInterval?: number;
+    /** Callback when status changes */
+    onStatusChange?: (status: LayerZeroMessageStatus) => void;
+}
+/**
+ * Parameters for cross-chain payment routing
+ */
+interface CrossChainPaymentParams {
+    /** Source chain where user has funds */
+    sourceChain: string;
+    /** Destination chain where payment is needed */
+    destinationChain: string;
+    /** Amount to transfer (in token units, 6 decimals for USDT0) */
+    amount: bigint;
+    /** Payment recipient on destination chain */
+    payTo: Address;
+    /** Payer address (receives bridged funds on destination) */
+    payer: Address;
+    /** Slippage tolerance percentage (default: 0.5) */
+    slippageTolerance?: number;
+}
+/**
+ * Result of cross-chain payment routing
+ */
+interface CrossChainPaymentResult {
+    /** Bridge transaction hash on source chain */
+    bridgeTxHash: `0x${string}`;
+    /** LayerZero message GUID for tracking */
+    messageGuid: `0x${string}`;
+    /** Amount bridged from source chain */
+    amountBridged: bigint;
+    /** Estimated amount to receive on destination */
+    estimatedReceiveAmount: bigint;
+    /** Source chain name */
+    sourceChain: string;
+    /** Destination chain name */
+    destinationChain: string;
+    /** Estimated delivery time in seconds */
+    estimatedDeliveryTime: number;
 }
 
 /**
@@ -667,31 +489,272 @@ declare class Usdt0Bridge {
      * @returns Bridge result with transaction hash
      */
     send(params: BridgeExecuteParams): Promise<BridgeResult>;
+    /**
+     * Get all supported destination chains from current chain
+     *
+     * @returns Array of supported destination chain names
+     */
+    getSupportedDestinations(): string[];
+    /**
+     * Check if a destination chain is supported
+     *
+     * @param toChain - The destination chain to check
+     * @returns True if the destination chain is supported
+     */
+    supportsDestination(toChain: string): boolean;
+    /**
+     * Extract LayerZero message GUID from OFTSent event logs
+     *
+     * @param receipt - Transaction receipt with logs
+     * @returns Message GUID as hex string
+     */
+    private extractMessageGuid;
     /**
      * Ensure sufficient token allowance for the OFT contract
+     *
+     * @param oftAddress - The OFT contract address
+     * @param amount - The amount to approve
      */
     private ensureAllowance;
     /**
      * Build SendParam struct for LayerZero
+     *
+     * @param params - Bridge parameters
+     * @returns SendParam struct for the OFT contract
      */
     private buildSendParam;
     /**
      * Validate bridge parameters
+     *
+     * @param params - Bridge parameters to validate
      */
     private validateBridgeParams;
+}
+/**
+ * Create a bridge client for a specific chain
+ *
+ * @param signer - Wallet signer with read/write capabilities
+ * @param chain - Source chain name
+ * @returns New Usdt0Bridge instance
+ */
+declare function createUsdt0Bridge(signer: BridgeSigner, chain: string): Usdt0Bridge;
+
+/**
+ * LayerZero Scan API Client
+ *
+ * Provides tracking for cross-chain messages via LayerZero Scan.
+ *
+ * @see https://docs.layerzero.network/v2/tools/api/scan/mainnet
+ *
+ * @example
+ * ```typescript
+ * import { LayerZeroScanClient } from '@t402/evm';
+ *
+ * const scanClient = new LayerZeroScanClient();
+ *
+ * // Get message status
+ * const message = await scanClient.getMessage(messageGuid);
+ * console.log(`Status: ${message.status}`);
+ *
+ * // Wait for delivery
+ * const delivered = await scanClient.waitForDelivery(messageGuid, {
+ *   onStatusChange: (status) => console.log(`Status changed: ${status}`),
+ * });
+ * console.log(`Delivered! Destination TX: ${delivered.dstTxHash}`);
+ * ```
+ */
+
+/**
+ * LayerZero Scan API base URL
+ */
+declare const LAYERZERO_SCAN_BASE_URL = "https://scan.layerzero-api.com/v1";
+/**
+ * LayerZero Scan API Client
+ *
+ * Use this client to track the status of cross-chain messages sent via LayerZero.
+ */
+declare class LayerZeroScanClient {
+    private readonly baseUrl;
     /**
-     * Get all supported destination chains from current chain
+     * Create a new LayerZero Scan client
+     *
+     * @param baseUrl - API base URL (default: production endpoint)
+     */
+    constructor(baseUrl?: string);
+    /**
+     * Get message by GUID
+     *
+     * @param guid - LayerZero message GUID
+     * @returns Message details including status
+     * @throws Error if message not found or API error
+     */
+    getMessage(guid: string): Promise<LayerZeroMessage>;
+    /**
+     * 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
+     */
+    getMessagesByWallet(address: string, limit?: number): Promise<LayerZeroMessage[]>;
+    /**
+     * 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
+     */
+    waitForDelivery(guid: string, options?: WaitForDeliveryOptions): Promise<LayerZeroMessage>;
+    /**
+     * Check if a message has been delivered
+     *
+     * @param guid - LayerZero message GUID
+     * @returns True if delivered, false otherwise
+     */
+    isDelivered(guid: string): Promise<boolean>;
+    /**
+     * Map API response to our interface
+     *
+     * @param data - The raw API response data
+     * @returns The mapped LayerZeroMessage object
+     */
+    private mapApiResponse;
+    /**
+     * Sleep helper
+     *
+     * @param ms - The number of milliseconds to sleep
+     * @returns A promise that resolves after the specified delay
+     */
+    private sleep;
+}
+/**
+ * Create a LayerZero Scan client
+ *
+ * @param baseUrl - Optional custom API base URL
+ * @returns A new LayerZeroScanClient instance
+ */
+declare function createLayerZeroScanClient(baseUrl?: string): LayerZeroScanClient;
+
+/**
+ * Cross-Chain Payment Router
+ *
+ * Enables payments on a destination chain using funds from a source chain.
+ * Uses USDT0 bridge via LayerZero for cross-chain transfers.
+ *
+ * @example
+ * ```typescript
+ * import { CrossChainPaymentRouter } from '@t402/evm';
+ *
+ * const router = new CrossChainPaymentRouter(signer, 'arbitrum');
+ *
+ * // Route payment from Arbitrum to Ethereum
+ * const result = await router.routePayment({
+ *   sourceChain: 'arbitrum',
+ *   destinationChain: 'ethereum',
+ *   amount: 100_000000n, // 100 USDT0
+ *   payTo: recipientAddress,
+ *   payer: userAddress,
+ * });
+ *
+ * // Track delivery
+ * const message = await router.trackMessage(result.messageGuid);
+ * ```
+ */
+
+/**
+ * Cross-Chain Payment Router
+ *
+ * Routes payments across chains using USDT0 bridge.
+ * Handles fee estimation, bridge execution, and delivery tracking.
+ */
+declare class CrossChainPaymentRouter {
+    private readonly bridge;
+    private readonly scanClient;
+    private readonly sourceChain;
+    /**
+     * Create a cross-chain payment router
+     *
+     * @param signer - Wallet signer for bridge operations
+     * @param sourceChain - Chain where user's funds are located
+     */
+    constructor(signer: BridgeSigner, sourceChain: string);
+    /**
+     * Get all bridgeable chains
+     *
+     * @returns Array of all chain names that support USDT0 bridging
+     */
+    static getBridgeableChains(): string[];
+    /**
+     * 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
+     */
+    routePayment(params: CrossChainPaymentParams): Promise<CrossChainPaymentResult>;
+    /**
+     * Get estimated fees for routing a payment
+     *
+     * @param params - Payment parameters
+     * @returns Quote with native fee and estimated receive amount
+     */
+    estimateFees(params: CrossChainPaymentParams): Promise<{
+        nativeFee: bigint;
+        estimatedReceiveAmount: bigint;
+        estimatedTime: number;
+    }>;
+    /**
+     * Track message delivery status
+     *
+     * @param messageGuid - LayerZero message GUID from routePayment result
+     * @returns Current message status
+     */
+    trackMessage(messageGuid: string): Promise<LayerZeroMessage>;
+    /**
+     * 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
+     */
+    waitForDelivery(messageGuid: string, options?: WaitForDeliveryOptions): Promise<LayerZeroMessage>;
+    /**
+     * 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: string, destinationChain: string): boolean;
+    /**
+     * Get all supported destination chains from source chain
+     *
+     * @returns Array of chain names that can receive bridged funds
      */
     getSupportedDestinations(): string[];
     /**
-     * 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: string): boolean;
+    private validateParams;
 }
 /**
- * Create a bridge client for a specific chain
+ * Create a cross-chain payment router
+ *
+ * @param signer - Wallet signer for bridge operations
+ * @param sourceChain - Chain where funds are located
+ * @returns A new CrossChainPaymentRouter instance
  */
-declare function createUsdt0Bridge(signer: BridgeSigner, chain: string): Usdt0Bridge;
+declare function createCrossChainPaymentRouter(signer: BridgeSigner, sourceChain: string): CrossChainPaymentRouter;
 
 /**
  * LayerZero OFT Bridge Constants for USDT0
@@ -721,27 +784,44 @@ declare const USDT0_OFT_ADDRESSES: Record<string, Address>;
 declare const LAYERZERO_ENDPOINT_V2: Address;
 /**
  * Get LayerZero endpoint ID for a chain
+ *
+ * @param chain - The chain name (e.g., 'ethereum', 'arbitrum')
+ * @returns The LayerZero endpoint ID, or undefined if chain not supported
  */
 declare function getEndpointId(chain: string): number | undefined;
 /**
  * Get USDT0 OFT contract address for a chain
+ *
+ * @param chain - The chain name (e.g., 'ethereum', 'arbitrum')
+ * @returns The USDT0 OFT contract address, or undefined if chain not supported
  */
 declare function getUsdt0OftAddress(chain: string): Address | undefined;
 /**
  * Check if a chain supports USDT0 bridging
+ *
+ * @param chain - The chain name to check (e.g., 'ethereum', 'arbitrum')
+ * @returns True if the chain supports USDT0 bridging, false otherwise
  */
 declare function supportsBridging(chain: string): boolean;
 /**
  * Get all chains that support USDT0 bridging
+ *
+ * @returns Array of chain names that support USDT0 bridging
  */
 declare function getBridgeableChains(): string[];
 /**
  * Convert address to bytes32 format for LayerZero
  * Pads address with leading zeros to 32 bytes
+ *
+ * @param address - The EVM address to convert
+ * @returns The address as a bytes32 hex string with leading zeros
  */
 declare function addressToBytes32(address: Address): `0x${string}`;
 /**
  * Convert bytes32 to address
+ *
+ * @param bytes32 - The bytes32 hex string to convert
+ * @returns The extracted EVM address from the last 20 bytes
  */
 declare function bytes32ToAddress(bytes32: `0x${string}`): Address;
 
@@ -1183,10 +1263,17 @@ declare enum PaymasterType {
 }
 /**
  * Pack verification and call gas limits into bytes32
+ *
+ * @param verificationGasLimit - The verification gas limit
+ * @param callGasLimit - The call gas limit
+ * @returns Packed bytes32 with gas limits
  */
 declare function packAccountGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): `0x${string}`;
 /**
  * Unpack account gas limits from bytes32
+ *
+ * @param packed - The packed bytes32 containing gas limits
+ * @returns Object containing verificationGasLimit and callGasLimit
  */
 declare function unpackAccountGasLimits(packed: `0x${string}`): {
     verificationGasLimit: bigint;
@@ -1194,10 +1281,17 @@ declare function unpackAccountGasLimits(packed: `0x${string}`): {
 };
 /**
  * Pack max priority fee and max fee per gas into bytes32
+ *
+ * @param maxPriorityFeePerGas - The max priority fee per gas (tip)
+ * @param maxFeePerGas - The max fee per gas
+ * @returns Packed bytes32 with gas fees
  */
 declare function packGasFees(maxPriorityFeePerGas: bigint, maxFeePerGas: bigint): `0x${string}`;
 /**
  * Unpack gas fees from bytes32
+ *
+ * @param packed - The packed bytes32 containing gas fees
+ * @returns Object containing maxPriorityFeePerGas and maxFeePerGas
  */
 declare function unpackGasFees(packed: `0x${string}`): {
     maxPriorityFeePerGas: bigint;
@@ -1226,46 +1320,95 @@ interface UserOpBuilderOptions {
 declare class UserOpBuilder {
     private readonly entryPoint;
     private readonly gasMultiplier;
+    /**
+     * Create a new UserOpBuilder instance
+     *
+     * @param options - Optional configuration for the builder
+     */
     constructor(options?: UserOpBuilderOptions);
     /**
      * 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
      */
     buildUserOp(signer: SmartAccountSigner, intent: TransactionIntent, client: PublicClient, gasEstimate?: GasEstimate, paymaster?: PaymasterData): Promise<UserOperation>;
     /**
      * 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
      */
     buildBatchUserOp(signer: SmartAccountSigner, intents: TransactionIntent[], client: PublicClient, gasEstimate?: GasEstimate, paymaster?: PaymasterData): Promise<UserOperation>;
     /**
      * 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: UserOperation): PackedUserOperation;
     /**
      * 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
      */
-    getUserOpHash(userOp: UserOperation, client: PublicClient, chainId: number): Promise<Hex>;
+    getUserOpHash(userOp: UserOperation, client: PublicClient, _: number): Promise<Hex>;
     /**
      * 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
      */
     signUserOp(userOp: UserOperation, signer: SmartAccountSigner, client: PublicClient, chainId: number): Promise<UserOperation>;
     /**
      * 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
      */
     private getNonce;
     /**
      * Get current gas prices from the chain
+     *
+     * @param client - The public client for chain interaction
+     * @returns The current gas prices for EIP-1559 transactions
      */
     private getGasPrices;
     /**
      * Apply gas multiplier for safety margin
+     *
+     * @param gas - The gas amount to multiply
+     * @returns The gas amount with safety margin applied
      */
     private applyMultiplier;
     /**
      * Encode paymaster data for the UserOperation
+     *
+     * @param paymaster - The paymaster configuration
+     * @returns The encoded paymaster data
      */
     private encodePaymasterData;
 }
 /**
  * Create a UserOpBuilder instance
+ *
+ * @param options - Optional configuration for the builder
+ * @returns A new UserOpBuilder instance
  */
 declare function createUserOpBuilder(options?: UserOpBuilderOptions): UserOpBuilder;
 
@@ -1282,6 +1425,13 @@ declare function createUserOpBuilder(options?: UserOpBuilderOptions): UserOpBuil
 declare class BundlerError extends Error {
     code?: number | undefined;
     data?: unknown | undefined;
+    /**
+     * Create a new BundlerError
+     *
+     * @param message - The error message
+     * @param code - Optional JSON-RPC error code
+     * @param data - Optional additional error data
+     */
     constructor(message: string, code?: number | undefined, data?: unknown | undefined);
 }
 /**
@@ -1290,15 +1440,25 @@ declare class BundlerError extends Error {
 declare class BundlerClient {
     private readonly bundlerUrl;
     private readonly entryPoint;
-    private readonly chainId;
     private requestId;
+    /**
+     * Create a new BundlerClient instance
+     *
+     * @param config - Configuration for the bundler client
+     */
     constructor(config: BundlerConfig);
     /**
      * Send a UserOperation to the bundler
+     *
+     * @param userOp - The UserOperation to send
+     * @returns The result containing the userOpHash and a wait function
      */
     sendUserOperation(userOp: UserOperation): Promise<UserOperationResult>;
     /**
      * Estimate gas for a UserOperation
+     *
+     * @param userOp - Partial UserOperation with required sender and callData
+     * @returns Gas estimates for the UserOperation
      */
     estimateUserOperationGas(userOp: Partial<UserOperation> & {
         sender: Address;
@@ -1306,6 +1466,9 @@ declare class BundlerClient {
     }): Promise<GasEstimate>;
     /**
      * Get UserOperation by hash
+     *
+     * @param userOpHash - The hash of the UserOperation to retrieve
+     * @returns The UserOperation and EntryPoint, or null if not found
      */
     getUserOperationByHash(userOpHash: Hex): Promise<{
         userOperation: PackedUserOperation;
@@ -1313,18 +1476,31 @@ declare class BundlerClient {
     } | null>;
     /**
      * Get UserOperation receipt
+     *
+     * @param userOpHash - The hash of the UserOperation
+     * @returns The receipt, or null if not yet included
      */
     getUserOperationReceipt(userOpHash: Hex): Promise<UserOperationReceipt | null>;
     /**
      * Get supported EntryPoints
+     *
+     * @returns Array of supported EntryPoint addresses
      */
     getSupportedEntryPoints(): Promise<Address[]>;
     /**
      * Get chain ID from bundler
+     *
+     * @returns The chain ID
      */
     getChainId(): Promise<number>;
     /**
      * 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
      */
     waitForReceipt(userOpHash: Hex, options?: {
         timeout?: number;
@@ -1332,19 +1508,32 @@ declare class BundlerClient {
     }): Promise<UserOperationReceipt>;
     /**
      * Pack UserOperation for RPC (convert bigints to hex strings)
+     *
+     * @param userOp - The UserOperation to pack
+     * @returns The packed UserOperation for RPC transmission
      */
     private packForRpc;
     /**
      * Convert bigint to hex string
+     *
+     * @param value - The bigint value to convert
+     * @returns The hex string representation
      */
     private toHex;
     /**
      * 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
      */
     private rpcCall;
 }
 /**
  * Create a BundlerClient instance
+ *
+ * @param config - Configuration for the bundler client
+ * @returns A new BundlerClient instance
  */
 declare function createBundlerClient(config: BundlerConfig): BundlerClient;
 
@@ -1386,50 +1575,106 @@ interface SponsorRequest {
  */
 declare class PaymasterClient {
     private readonly config;
+    /**
+     * Creates a new PaymasterClient instance
+     *
+     * @param config - Paymaster configuration including type, address, and optional URL
+     */
     constructor(config: PaymasterConfig);
     /**
      * 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
      */
     getPaymasterData(userOp: Partial<UserOperation>, chainId: number, entryPoint: Address, context?: Record<string, unknown>): Promise<PaymasterData>;
     /**
      * 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
      */
-    estimatePaymasterGas(userOp: Partial<UserOperation>, _chainId: number): Promise<GasEstimate>;
+    estimatePaymasterGas(_userOp: Partial<UserOperation>, // eslint-disable-line @typescript-eslint/no-unused-vars
+    _chainId: number): Promise<GasEstimate>;
     /**
      * 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
      */
     willSponsor(userOp: Partial<UserOperation>, chainId: number, entryPoint: Address, context?: Record<string, unknown>): Promise<boolean>;
     /**
      * 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
      */
     private getVerifyingPaymasterData;
     /**
      * 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
      */
     private getSponsoringPaymasterData;
     /**
      * 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
      */
     private getTokenPaymasterData;
     /**
      * 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
      */
     private callPaymasterService;
     /**
      * Serialize UserOperation for API calls
+     *
+     * @param userOp - Partial UserOperation to serialize
+     * @returns Serialized UserOperation with hex-encoded values
      */
     private serializeUserOp;
 }
 /**
  * Create a PaymasterClient instance
+ *
+ * @param config - Paymaster configuration including type, address, and optional URL
+ * @returns A new PaymasterClient instance
  */
 declare function createPaymasterClient(config: PaymasterConfig): PaymasterClient;
 /**
  * Encode paymaster data for inclusion in UserOperation
+ *
+ * @param data - Paymaster data to encode
+ * @returns Encoded paymasterAndData hex string
  */
 declare function encodePaymasterAndData(data: PaymasterData): Hex;
 /**
  * Decode paymaster and data from UserOperation
+ *
+ * @param paymasterAndData - Encoded paymasterAndData hex string
+ * @returns Decoded PaymasterData or null if invalid/empty
  */
 declare function decodePaymasterAndData(paymasterAndData: Hex): PaymasterData | null;
 
@@ -1483,6 +1728,11 @@ declare class GaslessT402Client {
     private readonly paymaster?;
     private readonly chainId;
     private readonly publicClient;
+    /**
+     * Creates a new GaslessT402Client instance
+     *
+     * @param config - Configuration including signer, bundler, paymaster, and chain settings
+     */
     constructor(config: GaslessClientConfig);
     /**
      * Execute a T402 payment via ERC-4337
@@ -1490,48 +1740,79 @@ declare class GaslessT402Client {
      * 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
      */
     executePayment(params: GaslessPaymentParams): Promise<UserOperationResult>;
     /**
      * 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
      */
     executeBatchPayments(payments: GaslessPaymentParams[]): Promise<UserOperationResult>;
     /**
      * 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
      */
     canSponsor(params: GaslessPaymentParams): Promise<boolean>;
     /**
      * Get the smart account address
+     *
+     * @returns The address of the smart account
      */
     getAccountAddress(): Promise<Address>;
     /**
      * Check if the smart account is deployed
+     *
+     * @returns True if the smart account contract is deployed on-chain
      */
     isAccountDeployed(): Promise<boolean>;
     /**
      * Build call data for a simple ERC20 transfer
+     *
+     * @param params - Payment parameters including recipient and amount
+     * @returns Encoded call data for ERC20 transfer function
      */
     private buildTransferCallData;
     /**
      * Build call data for an authorized transfer (EIP-3009)
+     *
+     * @param params - Payment parameters including authorization signature
+     * @returns Encoded call data for transferWithAuthorization function
      */
     private buildAuthorizedTransferCallData;
     /**
      * Estimate gas for a single transaction
+     *
+     * @param intent - Transaction intent with target, value, and data
+     * @returns Gas estimates for the UserOperation
      */
     private estimateGas;
     /**
      * Estimate gas for a batch transaction
+     *
+     * @param intents - Array of transaction intents to batch
+     * @returns Gas estimates for the batched UserOperation
      */
     private estimateBatchGas;
     /**
      * Get paymaster data if configured
+     *
+     * @param _ - Gas estimates (unused but kept for potential future use)
+     * @returns Paymaster data or undefined if no paymaster configured
      */
     private getPaymasterData;
 }
 /**
  * Create a GaslessT402Client instance
+ *
+ * @param config - Configuration including signer, bundler, paymaster, and chain settings
+ * @returns A new GaslessT402Client instance
  */
 declare function createGaslessT402Client(config: GaslessClientConfig): GaslessT402Client;
 
-export { ACCOUNT_ABI, BUNDLER_METHODS, type BridgeExecuteParams, type BridgeQuote, type BridgeQuoteParams, type BridgeResult, type BridgeSigner, type BridgeStatus, type BridgeTransaction, BundlerClient, type BundlerConfig, BundlerError, ClientEvmSigner, DEFAULT_GAS_LIMITS, ENTRYPOINT_V06_ADDRESS, ENTRYPOINT_V07_ABI, ENTRYPOINT_V07_ADDRESS, type ExactEvmPayloadV1, type ExactEvmPayloadV2, ExactLegacyEvmScheme$2 as ExactLegacyEvmClientScheme, ExactLegacyEvmScheme as ExactLegacyEvmFacilitatorScheme, type ExactLegacyEvmSchemeConfig as ExactLegacyEvmFacilitatorSchemeConfig, ExactLegacyEvmScheme$1 as ExactLegacyEvmServerScheme, type ExactLegacyEvmSchemeConfig$1 as ExactLegacyEvmServerSchemeConfig, type ExactLegacyPayload, FacilitatorEvmSigner, type GasEstimate, type GaslessClientConfig, type GaslessPaymentParams, GaslessT402Client, LAYERZERO_ENDPOINT_IDS, LAYERZERO_ENDPOINT_V2, type NetworkTokenRegistry, type PackedUserOperation, PaymasterClient, type PaymasterConfig, type PaymasterData, type PaymasterResponse, PaymasterType, type SmartAccountSigner, type SponsorRequest, TOKEN_PRIORITY, TOKEN_REGISTRY, type TokenConfig, type TokenType, type TransactionIntent, USDC_ADDRESSES, USDT0_ADDRESSES, USDT0_OFT_ADDRESSES, USDT_LEGACY_ADDRESSES, Usdt0Bridge, UserOpBuilder, type UserOpBuilderConfig, type UserOpBuilderOptions, type UserOperation, type UserOperationReceipt, type UserOperationResult, addressToBytes32, authorizationTypes, bytes32ToAddress, createBundlerClient, createGaslessT402Client, createPaymasterClient, createUsdt0Bridge, createUserOpBuilder, decodePaymasterAndData, eip3009ABI, encodePaymasterAndData, erc20LegacyABI, getBridgeableChains, getDefaultToken, getEIP712Domain, getEndpointId, getNetworkTokens, getNetworksForToken, getTokenByAddress, getTokenConfig, getUsdt0Networks, getUsdt0OftAddress, legacyAuthorizationTypes, packAccountGasLimits, packGasFees, supportsBridging, supportsEIP3009, unpackAccountGasLimits, unpackGasFees };
+export { ACCOUNT_ABI, BUNDLER_METHODS, type BridgeExecuteParams, type BridgeQuote, type BridgeQuoteParams, type BridgeResult, type BridgeSigner, type BridgeStatus, type BridgeTransaction, BundlerClient, type BundlerConfig, BundlerError, type CrossChainPaymentParams, type CrossChainPaymentResult, CrossChainPaymentRouter, DEFAULT_GAS_LIMITS, ENTRYPOINT_V06_ADDRESS, ENTRYPOINT_V07_ABI, ENTRYPOINT_V07_ADDRESS, ExactLegacyEvmScheme$2 as ExactLegacyEvmClientScheme, ExactLegacyEvmScheme as ExactLegacyEvmFacilitatorScheme, type ExactLegacyEvmSchemeConfig as ExactLegacyEvmFacilitatorSchemeConfig, ExactLegacyEvmScheme$1 as ExactLegacyEvmServerScheme, type ExactLegacyEvmSchemeConfig$1 as ExactLegacyEvmServerSchemeConfig, type GasEstimate, type GaslessClientConfig, type GaslessPaymentParams, GaslessT402Client, LAYERZERO_ENDPOINT_IDS, LAYERZERO_ENDPOINT_V2, LAYERZERO_SCAN_BASE_URL, type LayerZeroMessage, type LayerZeroMessageStatus, LayerZeroScanClient, type PackedUserOperation, PaymasterClient, type PaymasterConfig, type PaymasterData, type PaymasterResponse, PaymasterType, type SmartAccountSigner, type SponsorRequest, type TransactionIntent, type TransactionLog, type TransactionReceipt, USDT0_OFT_ADDRESSES, Usdt0Bridge, UserOpBuilder, type UserOpBuilderConfig, type UserOpBuilderOptions, type UserOperation, type UserOperationReceipt, type UserOperationResult, type WaitForDeliveryOptions, addressToBytes32, bytes32ToAddress, createBundlerClient, createCrossChainPaymentRouter, createGaslessT402Client, createLayerZeroScanClient, createPaymasterClient, createUsdt0Bridge, createUserOpBuilder, decodePaymasterAndData, encodePaymasterAndData, getBridgeableChains, getEndpointId, getUsdt0OftAddress, packAccountGasLimits, packGasFees, supportsBridging, unpackAccountGasLimits, unpackGasFees };