@t402/evm 2.0.0

package/dist/cjs/index.d.ts

@@ -0,0 +1,1537 @@
+export { E as ExactEvmScheme } from './scheme-OojTBKAz.js';
+export { a as ExactEvmSchemeConfig } from './scheme-yqGaK9rK.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 { Address, Hex, PublicClient } from 'viem';
+
+/**
+ * EVM client implementation for the exact-legacy payment scheme.
+ * Used for legacy tokens (like USDT) that don't support EIP-3009.
+ *
+ * This scheme uses the approve + transferFrom pattern:
+ * 1. Client must first approve the facilitator to spend tokens
+ * 2. Client signs an authorization message
+ * 3. Facilitator verifies the signature and calls transferFrom
+ *
+ * Note: The client must have already approved the facilitator (spender)
+ * for at least the payment amount before creating a payment payload.
+ */
+declare class ExactLegacyEvmScheme$2 implements SchemeNetworkClient {
+    private readonly signer;
+    readonly scheme = "exact-legacy";
+    /**
+     * Creates a new ExactLegacyEvmScheme instance.
+     *
+     * @param signer - The EVM signer for client operations
+     */
+    constructor(signer: ClientEvmSigner);
+    /**
+     * Creates a payment payload for the exact-legacy scheme.
+     *
+     * @param t402Version - The t402 protocol version
+     * @param paymentRequirements - The payment requirements
+     * @returns Promise resolving to a payment payload
+     */
+    createPaymentPayload(t402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "t402Version" | "payload">>;
+    /**
+     * Sign the legacy transfer authorization using EIP-712
+     *
+     * @param authorization - The authorization to sign
+     * @param requirements - The payment requirements
+     * @returns Promise resolving to the signature
+     */
+    private signAuthorization;
+}
+
+/**
+ * Configuration options for ExactLegacyEvmScheme
+ */
+interface ExactLegacyEvmSchemeConfig$1 {
+    /** Preferred token symbol. Defaults to "USDT" (legacy USDT) */
+    preferredToken?: string;
+}
+/**
+ * EVM server implementation for the exact-legacy payment scheme.
+ * Supports legacy tokens that use approve + transferFrom pattern.
+ */
+declare class ExactLegacyEvmScheme$1 implements SchemeNetworkServer {
+    readonly scheme = "exact-legacy";
+    private moneyParsers;
+    private config;
+    constructor(config?: ExactLegacyEvmSchemeConfig$1);
+    /**
+     * Register a custom money parser in the parser chain.
+     */
+    registerMoneyParser(parser: MoneyParser): ExactLegacyEvmScheme$1;
+    /**
+     * Parses a price into an asset amount for legacy tokens.
+     */
+    parsePrice(price: Price, network: Network): Promise<AssetAmount>;
+    /**
+     * Build payment requirements for this scheme/network combination.
+     * Adds the spender (facilitator) address to the extra field.
+     */
+    enhancePaymentRequirements(paymentRequirements: PaymentRequirements, supportedKind: {
+        t402Version: number;
+        scheme: string;
+        network: Network;
+        extra?: Record<string, unknown>;
+    }, extensionKeys: string[]): Promise<PaymentRequirements>;
+    /**
+     * Parse Money (string | number) to a decimal number.
+     */
+    private parseMoneyToDecimal;
+    /**
+     * Default money conversion implementation for legacy tokens.
+     */
+    private defaultMoneyConversion;
+    /**
+     * Convert decimal amount to token units
+     */
+    private convertToTokenAmount;
+    /**
+     * Get the default legacy token for a network.
+     */
+    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 {
+    /**
+     * Minimum allowance ratio required (0.0 to 1.0)
+     * If the allowance is less than this ratio of the payment amount,
+     * verification will fail.
+     *
+     * @default 1.0 (exact allowance required)
+     */
+    minAllowanceRatio?: number;
+}
+/**
+ * EVM facilitator implementation for the exact-legacy payment scheme.
+ * Uses the approve + transferFrom pattern for legacy tokens.
+ */
+declare class ExactLegacyEvmScheme implements SchemeNetworkFacilitator {
+    private readonly signer;
+    readonly scheme = "exact-legacy";
+    readonly caipFamily = "eip155:*";
+    private readonly config;
+    /**
+     * Creates a new ExactLegacyEvmScheme instance.
+     *
+     * @param signer - The EVM signer for facilitator operations
+     * @param config - Optional configuration
+     */
+    constructor(signer: FacilitatorEvmSigner, config?: ExactLegacyEvmSchemeConfig);
+    /**
+     * Get mechanism-specific extra data for the supported kinds endpoint.
+     * For exact-legacy, returns the spender (facilitator) addresses.
+     *
+     * @param network - The network identifier
+     * @returns Extra data including spender addresses
+     */
+    getExtra(network: string): Record<string, unknown> | undefined;
+    /**
+     * Get signer addresses used by this facilitator.
+     */
+    getSigners(network: string): string[];
+    /**
+     * Verifies a payment payload.
+     */
+    verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Settles a payment by executing transferFrom.
+     */
+    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
+ */
+
+/**
+ * Parameters for quoting a bridge transaction
+ */
+interface BridgeQuoteParams {
+    /** Source chain name (e.g., "ethereum", "arbitrum") */
+    fromChain: string;
+    /** Destination chain name */
+    toChain: string;
+    /** Amount to bridge in token units (6 decimals for USDT0) */
+    amount: bigint;
+    /** Recipient address on destination chain */
+    recipient: Address;
+}
+/**
+ * Quote result for a bridge transaction
+ */
+interface BridgeQuote {
+    /** Native token fee required (in wei) */
+    nativeFee: bigint;
+    /** Amount that will be sent */
+    amountToSend: bigint;
+    /** Minimum amount to receive (after fees/slippage) */
+    minAmountToReceive: bigint;
+    /** Estimated time for bridge completion in seconds */
+    estimatedTime: number;
+    /** Source chain */
+    fromChain: string;
+    /** Destination chain */
+    toChain: string;
+}
+/**
+ * Parameters for executing a bridge transaction
+ */
+interface BridgeExecuteParams extends BridgeQuoteParams {
+    /** Slippage tolerance as percentage (e.g., 0.5 for 0.5%) */
+    slippageTolerance?: number;
+    /** Custom gas limit for the destination chain execution */
+    dstGasLimit?: bigint;
+    /** Refund address for excess fees (defaults to sender) */
+    refundAddress?: Address;
+}
+/**
+ * Result of a bridge transaction
+ */
+interface BridgeResult {
+    /** Transaction hash on source chain */
+    txHash: `0x${string}`;
+    /** LayerZero message GUID */
+    messageGuid: `0x${string}`;
+    /** Amount sent */
+    amountSent: bigint;
+    /** Amount to be received on destination */
+    amountToReceive: bigint;
+    /** Source chain */
+    fromChain: string;
+    /** Destination chain */
+    toChain: string;
+    /** Estimated completion time in seconds */
+    estimatedTime: number;
+}
+/**
+ * Bridge status for tracking cross-chain transfers
+ */
+type BridgeStatus = "pending" | "inflight" | "delivered" | "completed" | "failed";
+/**
+ * Bridge transaction tracking info
+ */
+interface BridgeTransaction {
+    /** Source chain transaction hash */
+    srcTxHash: `0x${string}`;
+    /** LayerZero message GUID */
+    messageGuid: `0x${string}`;
+    /** Current status */
+    status: BridgeStatus;
+    /** Source chain */
+    fromChain: string;
+    /** Destination chain */
+    toChain: string;
+    /** Amount sent */
+    amount: bigint;
+    /** Recipient address */
+    recipient: Address;
+    /** Timestamp when bridge was initiated */
+    timestamp: number;
+    /** Destination chain transaction hash (when completed) */
+    dstTxHash?: `0x${string}`;
+}
+/**
+ * Signer interface for bridge operations
+ */
+interface BridgeSigner {
+    /** Wallet address */
+    readonly address: Address;
+    /** Read contract state */
+    readContract(args: {
+        address: Address;
+        abi: readonly unknown[];
+        functionName: string;
+        args?: readonly unknown[];
+    }): Promise<unknown>;
+    /** Write to contract */
+    writeContract(args: {
+        address: Address;
+        abi: readonly unknown[];
+        functionName: string;
+        args: readonly unknown[];
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /** Wait for transaction receipt */
+    waitForTransactionReceipt(args: {
+        hash: `0x${string}`;
+    }): Promise<{
+        status: string;
+    }>;
+}
+
+/**
+ * USDT0 Bridge Client
+ *
+ * Provides cross-chain USDT0 transfers using LayerZero OFT standard.
+ *
+ * @example
+ * ```typescript
+ * import { Usdt0Bridge } from '@t402/evm';
+ * import { createWalletClient, http } from 'viem';
+ * import { arbitrum } from 'viem/chains';
+ *
+ * const walletClient = createWalletClient({
+ *   chain: arbitrum,
+ *   transport: http(),
+ *   account: privateKeyToAccount(privateKey),
+ * });
+ *
+ * const bridge = new Usdt0Bridge(walletClient, 'arbitrum');
+ *
+ * // Get quote
+ * const quote = await bridge.quote({
+ *   fromChain: 'arbitrum',
+ *   toChain: 'ethereum',
+ *   amount: 100_000000n, // 100 USDT0
+ *   recipient: '0x...',
+ * });
+ *
+ * // Execute bridge
+ * const result = await bridge.send({
+ *   fromChain: 'arbitrum',
+ *   toChain: 'ethereum',
+ *   amount: 100_000000n,
+ *   recipient: '0x...',
+ * });
+ * ```
+ */
+
+/**
+ * USDT0 Bridge Client for LayerZero OFT transfers
+ */
+declare class Usdt0Bridge {
+    private readonly signer;
+    private readonly chain;
+    /**
+     * Create a new bridge client
+     *
+     * @param signer - Wallet signer with read/write capabilities
+     * @param chain - Source chain name (e.g., "arbitrum", "ethereum")
+     */
+    constructor(signer: BridgeSigner, chain: string);
+    /**
+     * Get a quote for bridging USDT0
+     *
+     * @param params - Bridge parameters
+     * @returns Quote with fee and amount information
+     */
+    quote(params: BridgeQuoteParams): Promise<BridgeQuote>;
+    /**
+     * Execute a bridge transaction
+     *
+     * @param params - Bridge execution parameters
+     * @returns Bridge result with transaction hash
+     */
+    send(params: BridgeExecuteParams): Promise<BridgeResult>;
+    /**
+     * Ensure sufficient token allowance for the OFT contract
+     */
+    private ensureAllowance;
+    /**
+     * Build SendParam struct for LayerZero
+     */
+    private buildSendParam;
+    /**
+     * Validate bridge parameters
+     */
+    private validateBridgeParams;
+    /**
+     * Get all supported destination chains from current chain
+     */
+    getSupportedDestinations(): string[];
+    /**
+     * Check if a destination chain is supported
+     */
+    supportsDestination(toChain: string): boolean;
+}
+/**
+ * Create a bridge client for a specific chain
+ */
+declare function createUsdt0Bridge(signer: BridgeSigner, chain: string): Usdt0Bridge;
+
+/**
+ * LayerZero OFT Bridge Constants for USDT0
+ *
+ * USDT0 uses LayerZero's OFT (Omnichain Fungible Token) standard
+ * for cross-chain transfers.
+ *
+ * @see https://docs.layerzero.network/v2/developers/evm/oft/quickstart
+ */
+
+/**
+ * LayerZero V2 Endpoint IDs (EIDs) for supported chains
+ * These are unique identifiers used by LayerZero to route messages
+ *
+ * @see https://docs.layerzero.network/v2/deployments/deployed-contracts
+ */
+declare const LAYERZERO_ENDPOINT_IDS: Record<string, number>;
+/**
+ * USDT0 OFT Adapter contract addresses by chain
+ * These are the contracts that handle cross-chain transfers
+ */
+declare const USDT0_OFT_ADDRESSES: Record<string, Address>;
+/**
+ * LayerZero V2 Endpoint contract addresses
+ * Same address on all EVM chains
+ */
+declare const LAYERZERO_ENDPOINT_V2: Address;
+/**
+ * Get LayerZero endpoint ID for a chain
+ */
+declare function getEndpointId(chain: string): number | undefined;
+/**
+ * Get USDT0 OFT contract address for a chain
+ */
+declare function getUsdt0OftAddress(chain: string): Address | undefined;
+/**
+ * Check if a chain supports USDT0 bridging
+ */
+declare function supportsBridging(chain: string): boolean;
+/**
+ * Get all chains that support USDT0 bridging
+ */
+declare function getBridgeableChains(): string[];
+/**
+ * Convert address to bytes32 format for LayerZero
+ * Pads address with leading zeros to 32 bytes
+ */
+declare function addressToBytes32(address: Address): `0x${string}`;
+/**
+ * Convert bytes32 to address
+ */
+declare function bytes32ToAddress(bytes32: `0x${string}`): Address;
+
+/**
+ * ERC-4337 Account Abstraction Types
+ *
+ * Type definitions for ERC-4337 v0.7 implementation.
+ */
+
+/**
+ * UserOperation for off-chain representation
+ * This is the format used before packing for on-chain submission
+ */
+interface UserOperation {
+    /** Smart account address */
+    sender: Address;
+    /** Anti-replay nonce */
+    nonce: bigint;
+    /** Factory address + init data (for account deployment) or empty */
+    initCode: Hex;
+    /** Encoded call data for the account's execute function */
+    callData: Hex;
+    /** Gas limit for account validation */
+    verificationGasLimit: bigint;
+    /** Gas limit for call execution */
+    callGasLimit: bigint;
+    /** Gas to pay bundler for overhead */
+    preVerificationGas: bigint;
+    /** Max priority fee per gas (tip) */
+    maxPriorityFeePerGas: bigint;
+    /** Max fee per gas */
+    maxFeePerGas: bigint;
+    /** Paymaster address + data, or empty for self-pay */
+    paymasterAndData: Hex;
+    /** Signature over the UserOperation hash */
+    signature: Hex;
+}
+/**
+ * PackedUserOperation for on-chain submission (v0.7)
+ * Gas fields are packed into bytes32 for efficiency
+ */
+interface PackedUserOperation {
+    /** Smart account address */
+    sender: Address;
+    /** Anti-replay nonce */
+    nonce: bigint;
+    /** Factory address + init data, or empty */
+    initCode: Hex;
+    /** Encoded call data */
+    callData: Hex;
+    /** Packed: verificationGasLimit (16 bytes) + callGasLimit (16 bytes) */
+    accountGasLimits: Hex;
+    /** Gas for bundler overhead */
+    preVerificationGas: bigint;
+    /** Packed: maxPriorityFeePerGas (16 bytes) + maxFeePerGas (16 bytes) */
+    gasFees: Hex;
+    /** Paymaster address + verification gas + postOp gas + data */
+    paymasterAndData: Hex;
+    /** Authorization signature */
+    signature: Hex;
+}
+/**
+ * Paymaster data for gas sponsorship
+ */
+interface PaymasterData {
+    /** Paymaster contract address */
+    paymaster: Address;
+    /** Gas limit for paymaster validation */
+    paymasterVerificationGasLimit: bigint;
+    /** Gas limit for paymaster post-operation */
+    paymasterPostOpGasLimit: bigint;
+    /** Additional paymaster-specific data */
+    paymasterData: Hex;
+}
+/**
+ * Gas estimation result from bundler
+ */
+interface GasEstimate {
+    /** Gas for account validation */
+    verificationGasLimit: bigint;
+    /** Gas for call execution */
+    callGasLimit: bigint;
+    /** Gas for bundler overhead */
+    preVerificationGas: bigint;
+    /** Gas for paymaster validation (if applicable) */
+    paymasterVerificationGasLimit?: bigint;
+    /** Gas for paymaster post-op (if applicable) */
+    paymasterPostOpGasLimit?: bigint;
+}
+/**
+ * UserOperation receipt from bundler
+ */
+interface UserOperationReceipt {
+    /** UserOperation hash */
+    userOpHash: Hex;
+    /** Smart account address */
+    sender: Address;
+    /** Nonce used */
+    nonce: bigint;
+    /** Paymaster address (if used) */
+    paymaster?: Address;
+    /** Actual gas cost */
+    actualGasCost: bigint;
+    /** Actual gas used */
+    actualGasUsed: bigint;
+    /** Success status */
+    success: boolean;
+    /** Revert reason (if failed) */
+    reason?: string;
+    /** Transaction receipt */
+    receipt: {
+        transactionHash: Hex;
+        blockNumber: bigint;
+        blockHash: Hex;
+    };
+}
+/**
+ * Bundler client configuration
+ */
+interface BundlerConfig {
+    /** Bundler RPC endpoint URL */
+    bundlerUrl: string;
+    /** EntryPoint contract address */
+    entryPoint?: Address;
+    /** Chain ID */
+    chainId: number;
+}
+/**
+ * Paymaster configuration
+ */
+interface PaymasterConfig {
+    /** Paymaster contract address */
+    address: Address;
+    /** Paymaster service URL (for verifying paymasters) */
+    url?: string;
+    /** Paymaster type */
+    type: "verifying" | "token" | "sponsoring";
+    /** Additional configuration */
+    options?: Record<string, unknown>;
+}
+/**
+ * Smart account signer interface
+ */
+interface SmartAccountSigner {
+    /** Get the smart account address */
+    getAddress(): Promise<Address>;
+    /** Sign a UserOperation hash */
+    signUserOpHash(userOpHash: Hex): Promise<Hex>;
+    /** Get the account's init code (for deployment) */
+    getInitCode(): Promise<Hex>;
+    /** Check if the account is deployed */
+    isDeployed(): Promise<boolean>;
+    /** Encode a call to the account's execute function */
+    encodeExecute(target: Address, value: bigint, data: Hex): Hex;
+    /** Encode a batch call to the account's executeBatch function */
+    encodeExecuteBatch(targets: Address[], values: bigint[], datas: Hex[]): Hex;
+}
+/**
+ * UserOperation builder configuration
+ */
+interface UserOpBuilderConfig {
+    /** Smart account signer */
+    signer: SmartAccountSigner;
+    /** Bundler configuration */
+    bundler: BundlerConfig;
+    /** Optional paymaster configuration */
+    paymaster?: PaymasterConfig;
+}
+/**
+ * Transaction intent for building UserOperations
+ */
+interface TransactionIntent {
+    /** Target contract address */
+    to: Address;
+    /** Value to send (in wei) */
+    value?: bigint;
+    /** Call data */
+    data?: Hex;
+}
+/**
+ * Result of submitting a UserOperation
+ */
+interface UserOperationResult {
+    /** UserOperation hash */
+    userOpHash: Hex;
+    /** Wait for the operation to be included */
+    wait(): Promise<UserOperationReceipt>;
+}
+
+/**
+ * ERC-4337 Account Abstraction Constants
+ *
+ * Provides constants for ERC-4337 v0.7 implementation including:
+ * - EntryPoint contract addresses
+ * - Default gas limits
+ * - ABI definitions
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-4337
+ */
+
+/**
+ * EntryPoint v0.7 contract address (canonical deployment)
+ * Deployed on all major EVM chains at the same address
+ */
+declare const ENTRYPOINT_V07_ADDRESS: Address;
+/**
+ * EntryPoint v0.6 contract address (legacy)
+ */
+declare const ENTRYPOINT_V06_ADDRESS: Address;
+/**
+ * Default gas limits for UserOperations
+ */
+declare const DEFAULT_GAS_LIMITS: {
+    /** Gas for account validation */
+    readonly verificationGasLimit: 150000n;
+    /** Gas for callData execution */
+    readonly callGasLimit: 100000n;
+    /** Gas paid to bundler for overhead */
+    readonly preVerificationGas: 50000n;
+    /** Gas for paymaster validation */
+    readonly paymasterVerificationGasLimit: 50000n;
+    /** Gas for paymaster post-op */
+    readonly paymasterPostOpGasLimit: 50000n;
+};
+/**
+ * EntryPoint v0.7 ABI (essential functions)
+ */
+declare const ENTRYPOINT_V07_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "initCode";
+            readonly type: "bytes";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+        }, {
+            readonly name: "accountGasLimits";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "preVerificationGas";
+            readonly type: "uint256";
+        }, {
+            readonly name: "gasFees";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "paymasterAndData";
+            readonly type: "bytes";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+        }];
+        readonly name: "ops";
+        readonly type: "tuple[]";
+    }, {
+        readonly name: "beneficiary";
+        readonly type: "address";
+    }];
+    readonly name: "handleOps";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly type: "address";
+    }];
+    readonly name: "getNonce";
+    readonly outputs: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly name: "key";
+        readonly type: "uint192";
+    }];
+    readonly name: "getNonce";
+    readonly outputs: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "initCode";
+            readonly type: "bytes";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+        }, {
+            readonly name: "accountGasLimits";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "preVerificationGas";
+            readonly type: "uint256";
+        }, {
+            readonly name: "gasFees";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "paymasterAndData";
+            readonly type: "bytes";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+        }];
+        readonly name: "userOp";
+        readonly type: "tuple";
+    }];
+    readonly name: "getUserOpHash";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+/**
+ * IAccount interface ABI (smart wallet validation)
+ */
+declare const ACCOUNT_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "initCode";
+            readonly type: "bytes";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+        }, {
+            readonly name: "accountGasLimits";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "preVerificationGas";
+            readonly type: "uint256";
+        }, {
+            readonly name: "gasFees";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "paymasterAndData";
+            readonly type: "bytes";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+        }];
+        readonly name: "userOp";
+        readonly type: "tuple";
+    }, {
+        readonly name: "userOpHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "missingAccountFunds";
+        readonly type: "uint256";
+    }];
+    readonly name: "validateUserOp";
+    readonly outputs: readonly [{
+        readonly name: "validationData";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dest";
+        readonly type: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "func";
+        readonly type: "bytes";
+    }];
+    readonly name: "execute";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dest";
+        readonly type: "address[]";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256[]";
+    }, {
+        readonly name: "func";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "executeBatch";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+/**
+ * Bundler JSON-RPC method names
+ */
+declare const BUNDLER_METHODS: {
+    readonly sendUserOperation: "eth_sendUserOperation";
+    readonly estimateUserOperationGas: "eth_estimateUserOperationGas";
+    readonly getUserOperationByHash: "eth_getUserOperationByHash";
+    readonly getUserOperationReceipt: "eth_getUserOperationReceipt";
+    readonly supportedEntryPoints: "eth_supportedEntryPoints";
+    readonly chainId: "eth_chainId";
+};
+/**
+ * Common paymaster types
+ */
+declare enum PaymasterType {
+    /** No paymaster - user pays gas */
+    None = "none",
+    /** Verifying paymaster with off-chain signature */
+    Verifying = "verifying",
+    /** Token paymaster - pay gas with ERC20 */
+    Token = "token",
+    /** Sponsoring paymaster - third party pays */
+    Sponsoring = "sponsoring"
+}
+/**
+ * Pack verification and call gas limits into bytes32
+ */
+declare function packAccountGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): `0x${string}`;
+/**
+ * Unpack account gas limits from bytes32
+ */
+declare function unpackAccountGasLimits(packed: `0x${string}`): {
+    verificationGasLimit: bigint;
+    callGasLimit: bigint;
+};
+/**
+ * Pack max priority fee and max fee per gas into bytes32
+ */
+declare function packGasFees(maxPriorityFeePerGas: bigint, maxFeePerGas: bigint): `0x${string}`;
+/**
+ * Unpack gas fees from bytes32
+ */
+declare function unpackGasFees(packed: `0x${string}`): {
+    maxPriorityFeePerGas: bigint;
+    maxFeePerGas: bigint;
+};
+
+/**
+ * ERC-4337 UserOperation Builder
+ *
+ * Builds UserOperations from transaction intents for ERC-4337 v0.7.
+ * Handles gas estimation, nonce management, and operation packing.
+ */
+
+/**
+ * Builder configuration
+ */
+interface UserOpBuilderOptions {
+    /** EntryPoint address (defaults to v0.7) */
+    entryPoint?: Address;
+    /** Default gas multiplier for safety margin */
+    gasMultiplier?: number;
+}
+/**
+ * UserOperation Builder for creating and packing operations
+ */
+declare class UserOpBuilder {
+    private readonly entryPoint;
+    private readonly gasMultiplier;
+    constructor(options?: UserOpBuilderOptions);
+    /**
+     * Build a UserOperation from a transaction intent
+     */
+    buildUserOp(signer: SmartAccountSigner, intent: TransactionIntent, client: PublicClient, gasEstimate?: GasEstimate, paymaster?: PaymasterData): Promise<UserOperation>;
+    /**
+     * Build a batch UserOperation from multiple transaction intents
+     */
+    buildBatchUserOp(signer: SmartAccountSigner, intents: TransactionIntent[], client: PublicClient, gasEstimate?: GasEstimate, paymaster?: PaymasterData): Promise<UserOperation>;
+    /**
+     * Pack a UserOperation for on-chain submission (v0.7 format)
+     */
+    packUserOp(userOp: UserOperation): PackedUserOperation;
+    /**
+     * Compute the UserOperation hash for signing
+     */
+    getUserOpHash(userOp: UserOperation, client: PublicClient, chainId: number): Promise<Hex>;
+    /**
+     * Sign a UserOperation
+     */
+    signUserOp(userOp: UserOperation, signer: SmartAccountSigner, client: PublicClient, chainId: number): Promise<UserOperation>;
+    /**
+     * Get the nonce for an account from EntryPoint
+     */
+    private getNonce;
+    /**
+     * Get current gas prices from the chain
+     */
+    private getGasPrices;
+    /**
+     * Apply gas multiplier for safety margin
+     */
+    private applyMultiplier;
+    /**
+     * Encode paymaster data for the UserOperation
+     */
+    private encodePaymasterData;
+}
+/**
+ * Create a UserOpBuilder instance
+ */
+declare function createUserOpBuilder(options?: UserOpBuilderOptions): UserOpBuilder;
+
+/**
+ * ERC-4337 Bundler Client
+ *
+ * Client for interacting with ERC-4337 bundlers via JSON-RPC.
+ * Handles UserOperation submission, gas estimation, and receipt polling.
+ */
+
+/**
+ * Bundler error class
+ */
+declare class BundlerError extends Error {
+    code?: number | undefined;
+    data?: unknown | undefined;
+    constructor(message: string, code?: number | undefined, data?: unknown | undefined);
+}
+/**
+ * Bundler client for submitting UserOperations
+ */
+declare class BundlerClient {
+    private readonly bundlerUrl;
+    private readonly entryPoint;
+    private readonly chainId;
+    private requestId;
+    constructor(config: BundlerConfig);
+    /**
+     * Send a UserOperation to the bundler
+     */
+    sendUserOperation(userOp: UserOperation): Promise<UserOperationResult>;
+    /**
+     * Estimate gas for a UserOperation
+     */
+    estimateUserOperationGas(userOp: Partial<UserOperation> & {
+        sender: Address;
+        callData: Hex;
+    }): Promise<GasEstimate>;
+    /**
+     * Get UserOperation by hash
+     */
+    getUserOperationByHash(userOpHash: Hex): Promise<{
+        userOperation: PackedUserOperation;
+        entryPoint: Address;
+    } | null>;
+    /**
+     * Get UserOperation receipt
+     */
+    getUserOperationReceipt(userOpHash: Hex): Promise<UserOperationReceipt | null>;
+    /**
+     * Get supported EntryPoints
+     */
+    getSupportedEntryPoints(): Promise<Address[]>;
+    /**
+     * Get chain ID from bundler
+     */
+    getChainId(): Promise<number>;
+    /**
+     * Wait for UserOperation receipt with polling
+     */
+    waitForReceipt(userOpHash: Hex, options?: {
+        timeout?: number;
+        pollingInterval?: number;
+    }): Promise<UserOperationReceipt>;
+    /**
+     * Pack UserOperation for RPC (convert bigints to hex strings)
+     */
+    private packForRpc;
+    /**
+     * Convert bigint to hex string
+     */
+    private toHex;
+    /**
+     * Make a JSON-RPC call to the bundler
+     */
+    private rpcCall;
+}
+/**
+ * Create a BundlerClient instance
+ */
+declare function createBundlerClient(config: BundlerConfig): BundlerClient;
+
+/**
+ * ERC-4337 Paymaster Client
+ *
+ * Handles paymaster interactions for gas sponsorship.
+ * Supports verifying paymasters (off-chain signature) and
+ * sponsoring paymasters (third-party gas payment).
+ */
+
+/**
+ * Paymaster service response
+ */
+interface PaymasterResponse {
+    /** Paymaster address */
+    paymaster: Address;
+    /** Paymaster data to include in UserOp */
+    paymasterData: Hex;
+    /** Gas limits for paymaster operations */
+    paymasterVerificationGasLimit: bigint;
+    paymasterPostOpGasLimit: bigint;
+}
+/**
+ * Paymaster sponsor request
+ */
+interface SponsorRequest {
+    /** UserOperation to sponsor (without paymaster data) */
+    userOp: Partial<UserOperation>;
+    /** Chain ID */
+    chainId: number;
+    /** EntryPoint address */
+    entryPoint: Address;
+    /** Optional context for the paymaster */
+    context?: Record<string, unknown>;
+}
+/**
+ * Paymaster client for gas sponsorship
+ */
+declare class PaymasterClient {
+    private readonly config;
+    constructor(config: PaymasterConfig);
+    /**
+     * Get paymaster data for a UserOperation
+     */
+    getPaymasterData(userOp: Partial<UserOperation>, chainId: number, entryPoint: Address, context?: Record<string, unknown>): Promise<PaymasterData>;
+    /**
+     * Get gas estimates including paymaster gas
+     */
+    estimatePaymasterGas(userOp: Partial<UserOperation>, _chainId: number): Promise<GasEstimate>;
+    /**
+     * Check if the paymaster will sponsor this operation
+     */
+    willSponsor(userOp: Partial<UserOperation>, chainId: number, entryPoint: Address, context?: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Get verifying paymaster data (off-chain signature)
+     */
+    private getVerifyingPaymasterData;
+    /**
+     * Get sponsoring paymaster data (third-party pays)
+     */
+    private getSponsoringPaymasterData;
+    /**
+     * Get token paymaster data (pay gas with ERC20)
+     */
+    private getTokenPaymasterData;
+    /**
+     * Call paymaster service API
+     */
+    private callPaymasterService;
+    /**
+     * Serialize UserOperation for API calls
+     */
+    private serializeUserOp;
+}
+/**
+ * Create a PaymasterClient instance
+ */
+declare function createPaymasterClient(config: PaymasterConfig): PaymasterClient;
+/**
+ * Encode paymaster data for inclusion in UserOperation
+ */
+declare function encodePaymasterAndData(data: PaymasterData): Hex;
+/**
+ * Decode paymaster and data from UserOperation
+ */
+declare function decodePaymasterAndData(paymasterAndData: Hex): PaymasterData | null;
+
+/**
+ * ERC-4337 T402 Integration
+ *
+ * Integrates ERC-4337 Account Abstraction with T402 payment protocol.
+ * Enables gasless payment execution via smart accounts and paymasters.
+ */
+
+/**
+ * T402 payment parameters for ERC-4337
+ */
+interface GaslessPaymentParams {
+    /** Token contract address */
+    tokenAddress: Address;
+    /** Recipient address (resource server/facilitator) */
+    to: Address;
+    /** Amount to transfer */
+    amount: bigint;
+    /** Optional: Pre-signed authorization (for EIP-3009 tokens) */
+    authorization?: {
+        validAfter: bigint;
+        validBefore: bigint;
+        nonce: Hex;
+        signature: Hex;
+    };
+}
+/**
+ * Gasless T402 client configuration
+ */
+interface GaslessClientConfig {
+    /** Smart account signer */
+    signer: SmartAccountSigner;
+    /** Bundler configuration */
+    bundler: BundlerConfig;
+    /** Optional paymaster for gas sponsorship */
+    paymaster?: PaymasterConfig;
+    /** Chain ID */
+    chainId: number;
+    /** Public client for chain interactions */
+    publicClient: PublicClient;
+}
+/**
+ * Gasless T402 client for executing payments via ERC-4337
+ */
+declare class GaslessT402Client {
+    private readonly signer;
+    private readonly builder;
+    private readonly bundler;
+    private readonly paymaster?;
+    private readonly chainId;
+    private readonly publicClient;
+    constructor(config: GaslessClientConfig);
+    /**
+     * Execute a T402 payment via ERC-4337
+     *
+     * This submits the payment as a UserOperation which can be:
+     * - Sponsored by a paymaster (truly gasless)
+     * - Paid from the smart account's balance
+     */
+    executePayment(params: GaslessPaymentParams): Promise<UserOperationResult>;
+    /**
+     * Execute multiple T402 payments in a single UserOperation
+     */
+    executeBatchPayments(payments: GaslessPaymentParams[]): Promise<UserOperationResult>;
+    /**
+     * Check if a payment can be sponsored (gasless)
+     */
+    canSponsor(params: GaslessPaymentParams): Promise<boolean>;
+    /**
+     * Get the smart account address
+     */
+    getAccountAddress(): Promise<Address>;
+    /**
+     * Check if the smart account is deployed
+     */
+    isAccountDeployed(): Promise<boolean>;
+    /**
+     * Build call data for a simple ERC20 transfer
+     */
+    private buildTransferCallData;
+    /**
+     * Build call data for an authorized transfer (EIP-3009)
+     */
+    private buildAuthorizedTransferCallData;
+    /**
+     * Estimate gas for a single transaction
+     */
+    private estimateGas;
+    /**
+     * Estimate gas for a batch transaction
+     */
+    private estimateBatchGas;
+    /**
+     * Get paymaster data if configured
+     */
+    private getPaymasterData;
+}
+/**
+ * Create a 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 };