@t402/wdk 2.4.0 → 2.6.0

package/dist/cjs/types-BwK8Xgvg.d.ts

@@ -0,0 +1,967 @@
+import { Address } from 'viem';
+
+/**
+ * Structured logging for @t402/wdk
+ *
+ * Provides a pluggable logger interface with console and noop implementations.
+ */
+/**
+ * Logger interface for T402 WDK operations.
+ *
+ * Accepts an optional context object for structured metadata.
+ */
+interface T402Logger {
+    debug(msg: string, ctx?: Record<string, unknown>): void;
+    info(msg: string, ctx?: Record<string, unknown>): void;
+    warn(msg: string, ctx?: Record<string, unknown>): void;
+    error(msg: string, ctx?: Record<string, unknown>): void;
+}
+/**
+ * Console-based logger that outputs structured JSON context.
+ */
+declare const defaultLogger: T402Logger;
+/**
+ * Silent logger that discards all messages.
+ */
+declare const noopLogger: T402Logger;
+/**
+ * Create a correlation ID for tracing operations across calls.
+ *
+ * Returns a compact random hex string suitable for log correlation.
+ */
+declare function createCorrelationId(): string;
+/**
+ * Metric callback signature for observability hooks.
+ */
+type MetricCallback = (name: string, value: number, tags?: Record<string, string>) => void;
+
+/**
+ * Error classes for T402 WDK integration
+ *
+ * Provides structured error handling with error codes for
+ * programmatic error handling and debugging.
+ */
+/**
+ * Error codes for WDK operations
+ */
+declare enum WDKErrorCode {
+    WDK_NOT_REGISTERED = 1001,
+    WDK_NOT_INITIALIZED = 1002,
+    INVALID_SEED_PHRASE = 1003,
+    WALLET_MANAGER_NOT_REGISTERED = 1004,
+    CHAIN_NOT_CONFIGURED = 2001,
+    CHAIN_NOT_SUPPORTED = 2002,
+    INVALID_CHAIN_CONFIG = 2003,
+    UNKNOWN_CHAIN_ID = 2004,
+    SIGNER_NOT_INITIALIZED = 3001,
+    ACCOUNT_FETCH_FAILED = 3002,
+    ADDRESS_FETCH_FAILED = 3003,
+    SIGN_TYPED_DATA_FAILED = 4001,
+    SIGN_MESSAGE_FAILED = 4002,
+    INVALID_TYPED_DATA = 4003,
+    INVALID_MESSAGE = 4004,
+    USER_REJECTED_SIGNATURE = 4005,
+    BALANCE_FETCH_FAILED = 5001,
+    TOKEN_BALANCE_FETCH_FAILED = 5002,
+    INVALID_TOKEN_ADDRESS = 5003,
+    TRANSACTION_FAILED = 6001,
+    GAS_ESTIMATION_FAILED = 6002,
+    INSUFFICIENT_BALANCE = 6003,
+    TRANSACTION_REVERTED = 6004,
+    TRANSACTION_TIMEOUT = 6005,
+    BRIDGE_NOT_AVAILABLE = 7001,
+    BRIDGE_NOT_SUPPORTED = 7002,
+    BRIDGE_FAILED = 7003,
+    INSUFFICIENT_BRIDGE_FEE = 7004,
+    RPC_ERROR = 8001,
+    RPC_TIMEOUT = 8002,
+    RPC_RATE_LIMITED = 8003,
+    RPC_CONNECTION_FAILED = 8004,
+    PROTOCOL_NOT_REGISTERED = 8101,
+    PROTOCOL_EXECUTION_FAILED = 8102,
+    INVALID_PARAMETER = 8103,
+    UNKNOWN_ERROR = 9999
+}
+/**
+ * Base error class for WDK operations
+ */
+declare class WDKError extends Error {
+    readonly code: WDKErrorCode;
+    readonly cause?: Error;
+    readonly context?: Record<string, unknown>;
+    constructor(code: WDKErrorCode, message: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+    /**
+     * Create a JSON-serializable representation
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Check if error is retryable
+     */
+    isRetryable(): boolean;
+}
+/**
+ * Error thrown when WDK is not properly initialized
+ */
+declare class WDKInitializationError extends WDKError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Error thrown for chain-related issues
+ */
+declare class ChainError extends WDKError {
+    readonly chain?: string;
+    constructor(code: WDKErrorCode, message: string, options?: {
+        chain?: string;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Error thrown for signer-related issues
+ */
+declare class SignerError extends WDKError {
+    readonly chain?: string;
+    readonly address?: string;
+    constructor(code: WDKErrorCode, message: string, options?: {
+        chain?: string;
+        address?: string;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Error thrown for signing operations
+ */
+declare class SigningError extends WDKError {
+    readonly operation: 'signTypedData' | 'signMessage';
+    constructor(code: WDKErrorCode, message: string, options: {
+        operation: 'signTypedData' | 'signMessage';
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Error thrown for balance operations
+ */
+declare class BalanceError extends WDKError {
+    readonly chain?: string;
+    readonly token?: string;
+    constructor(code: WDKErrorCode, message: string, options?: {
+        chain?: string;
+        token?: string;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Error thrown for transaction operations
+ */
+declare class TransactionError extends WDKError {
+    readonly chain?: string;
+    readonly txHash?: string;
+    constructor(code: WDKErrorCode, message: string, options?: {
+        chain?: string;
+        txHash?: string;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Error thrown for bridge operations
+ */
+declare class BridgeError extends WDKError {
+    readonly fromChain?: string;
+    readonly toChain?: string;
+    constructor(code: WDKErrorCode, message: string, options?: {
+        fromChain?: string;
+        toChain?: string;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Error thrown for RPC-related issues
+ */
+declare class RPCError extends WDKError {
+    readonly endpoint?: string;
+    readonly rpcCode?: number;
+    constructor(code: WDKErrorCode, message: string, options?: {
+        endpoint?: string;
+        rpcCode?: number;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Wrap an unknown error into a WDKError
+ */
+declare function wrapError(error: unknown, defaultCode?: WDKErrorCode, defaultMessage?: string, context?: Record<string, unknown>): WDKError;
+/**
+ * Type guard to check if an error is a WDKError
+ */
+declare function isWDKError(error: unknown): error is WDKError;
+/**
+ * Type guard to check if an error has a specific code
+ */
+declare function hasErrorCode(error: unknown, code: WDKErrorCode): boolean;
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    /** Maximum number of retries */
+    maxRetries: number;
+    /** Base delay in milliseconds */
+    baseDelay: number;
+    /** Maximum delay in milliseconds */
+    maxDelay: number;
+    /** Whether to use exponential backoff */
+    exponentialBackoff: boolean;
+}
+/**
+ * Default retry configuration
+ */
+declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+/**
+ * Execute an async function with retry logic
+ */
+declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>): Promise<T>;
+/**
+ * Timeout wrapper for async operations
+ */
+declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, operation?: string): Promise<T>;
+
+/**
+ * WDK Failover Provider
+ *
+ * Automatic RPC failover support with health checking and
+ * configurable failure thresholds.
+ */
+interface FailoverConfig {
+    /** RPC URLs in priority order */
+    urls: string[];
+    /** Health check interval in ms (default: 30000) */
+    healthCheckInterval?: number;
+    /** Request timeout in ms (default: 5000) */
+    requestTimeout?: number;
+    /** Max consecutive failures before marking unhealthy (default: 3) */
+    maxFailures?: number;
+}
+interface ProviderStatus {
+    url: string;
+    healthy: boolean;
+    lastChecked: number;
+    consecutiveFailures: number;
+}
+/**
+ * RPC failover provider with automatic health checking and failover.
+ *
+ * Manages a list of RPC URLs in priority order, automatically switching
+ * to the next healthy provider when failures exceed the threshold.
+ *
+ * @example
+ * ```typescript
+ * const provider = new FailoverProvider({
+ *   urls: ['https://arb1.arbitrum.io/rpc', 'https://arb-fallback.example.com'],
+ *   maxFailures: 3,
+ * })
+ *
+ * const url = provider.getCurrentUrl()
+ * try {
+ *   await fetch(url)
+ *   provider.reportSuccess()
+ * } catch {
+ *   provider.reportFailure()
+ * }
+ * ```
+ */
+declare class FailoverProvider {
+    private providers;
+    private currentIndex;
+    private healthCheckTimer?;
+    private readonly maxFailures;
+    private readonly requestTimeout;
+    constructor(config: FailoverConfig);
+    /**
+     * Get current active RPC URL
+     */
+    getCurrentUrl(): string;
+    /**
+     * Report a failure on the current URL.
+     * Auto-switches to next healthy provider if failure threshold is reached.
+     *
+     * @returns The new URL if switched, or null if no switch occurred
+     */
+    reportFailure(): string | null;
+    /**
+     * Report success on the current URL, reset failure counter.
+     */
+    reportSuccess(): void;
+    /**
+     * Get all provider statuses
+     */
+    getStatus(): ProviderStatus[];
+    /**
+     * Force switch to next healthy provider.
+     *
+     * @returns The new URL, or null if no healthy providers available
+     */
+    switchToNext(): string | null;
+    /**
+     * Get the request timeout in milliseconds
+     */
+    getRequestTimeout(): number;
+    /**
+     * Stop health checks and clean up resources
+     */
+    dispose(): void;
+    private startHealthChecks;
+    private checkHealth;
+}
+/**
+ * Normalize chain config that may contain failover arrays.
+ * Backward compatible: single string URL still works.
+ *
+ * @example
+ * ```typescript
+ * // Single URL (backward compatible)
+ * const provider = createFailoverProvider('https://arb1.arbitrum.io/rpc')
+ * // Returns null — no failover needed
+ *
+ * // Multiple URLs with failover
+ * const provider = createFailoverProvider(['https://arb1.arbitrum.io/rpc', 'https://fallback.example.com'])
+ * // Returns FailoverProvider
+ *
+ * // Full config
+ * const provider = createFailoverProvider({
+ *   urls: ['https://arb1.arbitrum.io/rpc', 'https://fallback.example.com'],
+ *   healthCheckInterval: 15000,
+ * })
+ * ```
+ */
+declare function createFailoverProvider(config: string | string[] | FailoverConfig): FailoverProvider | null;
+/**
+ * Resolve the primary RPC URL from a config that may be a string, array, or FailoverConfig.
+ */
+declare function resolveRpcUrl(config: string | string[] | FailoverConfig): string;
+
+/**
+ * EVM chain configuration
+ */
+interface EvmChainConfig {
+    /** RPC endpoint URL or array of URLs for failover */
+    provider: string | string[];
+    /** Chain ID */
+    chainId?: number;
+    /** CAIP-2 network identifier */
+    network?: string;
+    /** Failover configuration (only used when provider is an array) */
+    failover?: Partial<FailoverConfig>;
+}
+/**
+ * T402 WDK configuration options
+ */
+interface T402WDKConfig {
+    /** Ethereum mainnet configuration */
+    ethereum?: EvmChainConfig | string;
+    /** Arbitrum One configuration */
+    arbitrum?: EvmChainConfig | string;
+    /** Base mainnet configuration */
+    base?: EvmChainConfig | string;
+    /** Ink mainnet configuration */
+    ink?: EvmChainConfig | string;
+    /** Berachain mainnet configuration */
+    berachain?: EvmChainConfig | string;
+    /** Unichain mainnet configuration */
+    unichain?: EvmChainConfig | string;
+    /** Polygon mainnet configuration */
+    polygon?: EvmChainConfig | string;
+    /** Custom chains */
+    [key: string]: EvmChainConfig | string | undefined;
+}
+/**
+ * Normalized chain configuration
+ */
+interface NormalizedChainConfig {
+    provider: string;
+    chainId: number;
+    network: string;
+    name: string;
+}
+/**
+ * Token balance information
+ */
+interface TokenBalance {
+    /** Token contract address */
+    token: Address;
+    /** Token symbol */
+    symbol: string;
+    /** Balance in smallest units */
+    balance: bigint;
+    /** Formatted balance (human-readable) */
+    formatted: string;
+    /** Decimals */
+    decimals: number;
+}
+/**
+ * Chain balance information
+ */
+interface ChainBalance {
+    /** Chain name (e.g., "arbitrum") */
+    chain: string;
+    /** CAIP-2 network identifier */
+    network: string;
+    /** Native token balance */
+    native: bigint;
+    /** Token balances */
+    tokens: TokenBalance[];
+}
+/**
+ * Aggregated balance across all chains
+ */
+interface AggregatedBalance {
+    /** Total USDT0 balance across all chains */
+    totalUsdt0: bigint;
+    /** Total USDC balance across all chains */
+    totalUsdc: bigint;
+    /** Per-chain balances */
+    chains: ChainBalance[];
+}
+/**
+ * Bridge parameters for cross-chain transfers
+ */
+interface BridgeParams {
+    /** Source chain name */
+    fromChain: string;
+    /** Destination chain name */
+    toChain: string;
+    /** Amount to bridge in smallest units */
+    amount: bigint;
+    /** Recipient address (optional, defaults to same wallet on target chain) */
+    recipient?: Address;
+}
+/**
+ * Bridge result
+ */
+interface BridgeResult {
+    /** Transaction hash on source chain */
+    txHash: string;
+    /** Estimated time for bridge completion in seconds */
+    estimatedTime: number;
+}
+/**
+ * EIP-712 typed data domain
+ */
+interface TypedDataDomain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: Address;
+}
+/**
+ * EIP-712 typed data types
+ */
+type TypedDataTypes = Record<string, Array<{
+    name: string;
+    type: string;
+}>>;
+/**
+ * T402 Signer interface for WDK
+ * Compatible with @t402/core signer requirements
+ */
+interface T402WDKSigner {
+    /** Get wallet address */
+    readonly address: Address;
+    /** Sign EIP-712 typed data */
+    signTypedData(params: {
+        domain: TypedDataDomain;
+        types: TypedDataTypes;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<`0x${string}`>;
+    /** Sign a message */
+    signMessage?(message: string | Uint8Array): Promise<`0x${string}`>;
+    /** Get token balance */
+    getTokenBalance?(tokenAddress: Address): Promise<bigint>;
+}
+/**
+ * WDK Account interface (matches @tetherto/wdk account structure)
+ *
+ * This is the canonical definition used across all @t402/wdk-* packages.
+ * Implementors (Tether WDK) provide these methods; T402 code consumes them.
+ */
+interface WDKAccount {
+    /** Get the account's address */
+    getAddress(): Promise<string>;
+    /** Get the account's native balance */
+    getBalance(): Promise<bigint>;
+    /** Get the account's token balance */
+    getTokenBalance(tokenAddress: string): Promise<bigint>;
+    /** Sign a message */
+    signMessage(message: string): Promise<string>;
+    /** Sign typed data (EIP-712) */
+    signTypedData(params: {
+        domain: Record<string, unknown>;
+        types: Record<string, unknown>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<string>;
+    /** Send a transaction */
+    sendTransaction(params: {
+        to: string;
+        value?: bigint;
+        data?: string;
+    }): Promise<string>;
+    /** Estimate gas for a transaction (optional — not all implementations support this) */
+    estimateGas?(params: {
+        to: string;
+        value?: bigint;
+        data?: string;
+    }): Promise<bigint>;
+}
+/**
+ * Alias for WDKAccount — preferred naming for use in @t402/wdk-* packages.
+ */
+type WdkAccount = WDKAccount;
+/**
+ * WDK instance interface (matches @tetherto/wdk structure)
+ */
+interface WDKInstance {
+    registerWallet<T>(name: string, manager: T, config: Record<string, unknown>): WDKInstance;
+    registerProtocol<T>(name: string, protocol: T): WDKInstance;
+    getAccount(chain: string, index: number): Promise<WDKAccount>;
+    executeProtocol(name: string, params: Record<string, unknown>): Promise<{
+        txHash: string;
+    }>;
+}
+/**
+ * WDK constructor type
+ */
+interface WDKConstructor {
+    new (seedPhrase: string): WDKInstance;
+    getRandomSeedPhrase(): string;
+}
+/**
+ * Balance cache configuration for T402WDK
+ */
+interface T402BalanceCacheConfig {
+    /** Whether caching is enabled (default: true) */
+    enabled?: boolean;
+    /** TTL for native balance in milliseconds (default: 15000 = 15 seconds) */
+    nativeBalanceTTL?: number;
+    /** TTL for token balance in milliseconds (default: 30000 = 30 seconds) */
+    tokenBalanceTTL?: number;
+    /** TTL for aggregated balances in milliseconds (default: 60000 = 60 seconds) */
+    aggregatedBalanceTTL?: number;
+    /** Maximum cache entries (default: 500) */
+    maxSize?: number;
+}
+/**
+ * Extended T402 WDK configuration with cache options
+ */
+interface T402WDKOptions {
+    /** Balance cache configuration */
+    cache?: T402BalanceCacheConfig;
+    /** Retry configuration for RPC-calling methods */
+    retry?: Partial<RetryConfig>;
+    /** WDK constructor (instance-level override) */
+    wdk?: WDKConstructor;
+    /** Wallet modules (instance-level override) */
+    wallets?: WDKWalletModules;
+    /** Protocol modules (instance-level override) */
+    protocols?: WDKProtocolModules;
+    /** Middleware hooks (instance-level override) */
+    middlewares?: Map<string, Array<(account: unknown) => Promise<void>>>;
+    /** Fiat on-ramp provider (instance-level override) */
+    fiatOnRampProvider?: FiatOnRampProvider;
+    /** Structured logger (default: noopLogger) */
+    logger?: T402Logger;
+    /** Metric callback for observability */
+    onMetric?: (name: string, value: number, tags?: Record<string, string>) => void;
+}
+/**
+ * Supported blockchain families
+ */
+type ChainFamily = 'evm' | 'svm' | 'ton' | 'tron' | 'spark' | 'btc';
+/**
+ * Solana chain configuration
+ */
+interface SvmChainConfig {
+    /** RPC endpoint URL */
+    rpcUrl: string;
+    /** Commitment level */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    /** Network type */
+    network?: 'mainnet' | 'testnet' | 'devnet';
+}
+/**
+ * TON chain configuration
+ */
+interface TonChainConfig {
+    /** API endpoint URL */
+    endpoint: string;
+    /** Network type */
+    network?: 'mainnet' | 'testnet';
+    /** API key for TON Center */
+    apiKey?: string;
+}
+/**
+ * TRON chain configuration
+ */
+interface TronChainConfig {
+    /** Full host URL (e.g., https://api.trongrid.io) */
+    fullHost: string;
+    /** Network type */
+    network?: 'mainnet' | 'shasta' | 'nile';
+    /** API key for TronGrid */
+    apiKey?: string;
+}
+/**
+ * Multi-chain configuration
+ */
+interface MultiChainConfig {
+    /** EVM chains configuration */
+    evm?: Record<string, EvmChainConfig | string>;
+    /** Solana configuration */
+    svm?: SvmChainConfig;
+    /** TON configuration */
+    ton?: TonChainConfig;
+    /** TRON configuration */
+    tron?: TronChainConfig;
+}
+/**
+ * WDK wallet modules registry
+ * All modules are optional - only register what you need
+ */
+interface WDKWalletModules {
+    /** EVM wallet manager (@tetherto/wdk-wallet-evm) */
+    evm?: unknown;
+    /** EVM ERC-4337 wallet manager (@tetherto/wdk-wallet-evm-erc4337) */
+    evmErc4337?: unknown;
+    /** Solana wallet manager (@tetherto/wdk-wallet-solana) */
+    solana?: unknown;
+    /** TON wallet manager (@tetherto/wdk-wallet-ton) */
+    ton?: unknown;
+    /** TON gasless wallet manager (@tetherto/wdk-wallet-ton-gasless) */
+    tonGasless?: unknown;
+    /** TRON wallet manager (@tetherto/wdk-wallet-tron) */
+    tron?: unknown;
+    /** TRON gas-free wallet manager (@tetherto/wdk-wallet-tron-gasfree) */
+    tronGasfree?: unknown;
+    /** Bitcoin wallet manager (@tetherto/wdk-wallet-btc) */
+    btc?: unknown;
+    /** Spark (Bitcoin L2) wallet manager (@buildonspark/spark-sdk) */
+    spark?: unknown;
+}
+/**
+ * WDK protocol modules registry
+ * All modules are optional - only register what you need
+ */
+interface WDKProtocolModules {
+    /** USDT0 bridge for EVM (@tetherto/wdk-protocol-bridge-usdt0-evm) */
+    bridgeUsdt0Evm?: unknown;
+    /** USDT0 bridge for TON (@tetherto/wdk-protocol-bridge-usdt0-ton) */
+    bridgeUsdt0Ton?: unknown;
+    /** Velora swap for EVM (@tetherto/wdk-protocol-swap-velora-evm) */
+    swapVeloraEvm?: unknown;
+    /** Aave lending for EVM (@tetherto/wdk-protocol-lending-aave-evm) */
+    lendingAaveEvm?: unknown;
+}
+/**
+ * Unified WDK modules registration
+ */
+interface WDKModulesConfig {
+    /** Wallet modules */
+    wallets?: WDKWalletModules;
+    /** Protocol modules */
+    protocols?: WDKProtocolModules;
+}
+/**
+ * WDK TON account interface (compatible with @tetherto/wdk-wallet-ton)
+ */
+interface WDKTonAccount {
+    /** Get wallet address */
+    getAddress(): Promise<string>;
+    /** Get TON balance */
+    getBalance(): Promise<bigint>;
+    /** Get Jetton balance */
+    getJettonBalance(jettonMaster: string): Promise<bigint>;
+    /** Sign a message */
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    /** Send TON transaction */
+    sendTransaction(params: {
+        to: string;
+        value: bigint;
+        body?: string;
+        bounce?: boolean;
+    }): Promise<string>;
+    /** Get current sequence number */
+    getSeqno(): Promise<number>;
+    /** Transfer Jettons */
+    transferJetton?(params: {
+        jettonMaster: string;
+        to: string;
+        amount: bigint;
+        forwardPayload?: string;
+    }): Promise<string>;
+}
+/**
+ * WDK Solana account interface (compatible with @tetherto/wdk-wallet-solana)
+ */
+interface WDKSolanaAccount {
+    /** Get wallet address (base58) */
+    getAddress(): Promise<string>;
+    /** Get SOL balance */
+    getBalance(): Promise<bigint>;
+    /** Get SPL token balance */
+    getTokenBalance(mint: string): Promise<bigint>;
+    /** Sign a message */
+    sign(message: Uint8Array): Promise<Uint8Array>;
+    /** Sign a transaction */
+    signTransaction(transaction: Uint8Array): Promise<Uint8Array>;
+    /** Send SOL */
+    sendTransaction(params: {
+        recipient: string;
+        value: bigint;
+    }): Promise<string>;
+    /** Transfer SPL token */
+    transfer(params: {
+        token: string;
+        recipient: string;
+        amount: bigint;
+    }): Promise<string>;
+    /** Get token program for a mint (Token or Token-2022) — optional Token-2022 support */
+    getTokenProgram?(mint: string): Promise<'Token' | 'Token-2022'>;
+    /** Get transfer fee for a Token-2022 mint — optional Token-2022 support */
+    getTransferFee?(mint: string, amount: bigint): Promise<{
+        fee: bigint;
+        netAmount: bigint;
+    }>;
+}
+/**
+ * WDK TRON account interface (compatible with @tetherto/wdk-wallet-tron)
+ */
+interface WDKTronAccount {
+    /** Get wallet address (base58) */
+    getAddress(): Promise<string>;
+    /** Get TRX balance */
+    getBalance(): Promise<bigint>;
+    /** Get TRC20 token balance */
+    getTrc20Balance(contractAddress: string): Promise<bigint>;
+    /** Sign a transaction */
+    signTransaction(transaction: unknown): Promise<unknown>;
+    /** Send signed transaction */
+    sendTransaction(signedTx: unknown): Promise<string>;
+    /** Transfer TRC20 token */
+    transferTrc20?(params: {
+        contractAddress: string;
+        to: string;
+        amount: bigint;
+    }): Promise<string>;
+}
+/**
+ * Extended WDK instance interface with multi-chain support
+ */
+interface WDKInstanceMultiChain extends WDKInstance {
+    /** Get TON account */
+    getTonAccount?(index: number): Promise<WDKTonAccount>;
+    /** Get Solana account */
+    getSolanaAccount?(index: number): Promise<WDKSolanaAccount>;
+    /** Get TRON account */
+    getTronAccount?(index: number): Promise<WDKTronAccount>;
+}
+/**
+ * Result of WDK module auto-discovery
+ */
+interface WDKAutoDiscoveryResult {
+    /** Discovered modules ready for registration */
+    discovered: WDKModulesConfig;
+    /** Package names that were found and loaded */
+    available: string[];
+    /** Package names that were not installed */
+    unavailable: string[];
+}
+/**
+ * Configuration for T402WDK.create() factory method
+ */
+interface T402WDKCreateConfig {
+    /** BIP-39 mnemonic seed phrase */
+    seedPhrase: string;
+    /** Chain name → RPC URL mapping for EVM chains */
+    chains: Record<string, string>;
+    /** WDK modules to register */
+    modules: WDKModulesConfig;
+    /** Additional options */
+    options?: T402WDKOptions;
+}
+/**
+ * A signer entry for use with T402 HTTP clients
+ */
+interface SignerEntry {
+    /** Payment scheme (e.g., "exact") */
+    scheme: string;
+    /** CAIP-2 network identifier (e.g., "eip155:42161") */
+    network: string;
+    /** The signer instance */
+    signer: unknown;
+    /** Chain family (evm, ton, svm, tron) */
+    family: ChainFamily;
+}
+/**
+ * Options for getAllSigners()
+ */
+interface GetAllSignersOptions {
+    /** HD wallet account index (default: 0) */
+    accountIndex?: number;
+    /** Filter by payment schemes (default: ["exact"]) */
+    schemes?: string[];
+    /** Include non-EVM chain signers (default: true) */
+    includeNonEvm?: boolean;
+}
+/**
+ * Options for T402WDK.fromWDK()
+ */
+interface FromWDKOptions {
+    /** HD wallet account index for auto-discovery (default: 0) */
+    defaultAccountIndex?: number;
+}
+/**
+ * Swap quote result
+ */
+interface SwapQuote {
+    /** Input token address */
+    inputToken: string;
+    /** Output token address */
+    outputToken: string;
+    /** Input amount in smallest units */
+    inputAmount: bigint;
+    /** Expected output amount in smallest units */
+    outputAmount: bigint;
+    /** Price impact percentage */
+    priceImpact: number;
+    /** Swap route (token addresses) */
+    route: string[];
+}
+/**
+ * Swap execution result
+ */
+interface SwapResult {
+    /** Transaction hash */
+    txHash: string;
+    /** Actual input amount */
+    inputAmount: bigint;
+    /** Actual output amount */
+    outputAmount: bigint;
+}
+/**
+ * Parameters for swap operations
+ */
+interface SwapParams {
+    /** Chain name (e.g., "ethereum", "arbitrum") */
+    chain: string;
+    /** Input token address */
+    fromToken: string;
+    /** Amount to swap in smallest units */
+    amount: bigint;
+    /** Maximum slippage tolerance (0-1, default: 0.005 = 0.5%) */
+    maxSlippage?: number;
+}
+/**
+ * Parameters for borrow-and-pay operations
+ */
+interface BorrowParams {
+    /** Chain name (e.g., "ethereum", "arbitrum") */
+    chain: string;
+    /** Collateral token address */
+    collateralToken: string;
+    /** Collateral amount in smallest units */
+    collateralAmount: bigint;
+    /** USDT0 amount to borrow in smallest units */
+    borrowAmount: bigint;
+    /** Interest rate mode: 1 = stable, 2 = variable (default: 2) */
+    interestRateMode?: number;
+}
+/**
+ * Result of a borrow-and-pay operation
+ */
+interface BorrowResult {
+    /** Supply (deposit collateral) transaction hash */
+    supplyTxHash: string;
+    /** Borrow transaction hash */
+    borrowTxHash: string;
+    /** Actual borrowed amount in smallest units */
+    borrowedAmount: bigint;
+}
+/**
+ * Fiat on-ramp quote
+ */
+interface FiatOnRampQuote {
+    /** Fiat amount to spend */
+    fiatAmount: number;
+    /** Fiat currency code (e.g., "USD", "EUR") */
+    fiatCurrency: string;
+    /** Crypto amount to receive */
+    cryptoAmount: string;
+    /** Crypto currency code (e.g., "USDT") */
+    cryptoCurrency: string;
+    /** Exchange rate (fiat per crypto) */
+    exchangeRate: number;
+    /** Fee breakdown */
+    fees: {
+        network: string;
+        service: string;
+        total: string;
+    };
+    /** Estimated time to complete in seconds */
+    estimatedTime: number;
+}
+/**
+ * Fiat on-ramp parameters
+ */
+interface FiatOnRampParams {
+    /** Fiat amount to spend */
+    fiatAmount: number;
+    /** Fiat currency code (e.g., "USD") */
+    fiatCurrency: string;
+    /** Crypto currency to buy (default: "USDT") */
+    cryptoCurrency?: string;
+    /** Wallet address to receive funds */
+    walletAddress: string;
+    /** CAIP-2 network identifier */
+    network: string;
+    /** URL to redirect after purchase */
+    redirectUrl?: string;
+}
+/**
+ * Fiat on-ramp result
+ */
+interface FiatOnRampResult {
+    /** Widget URL to open for the user */
+    widgetUrl: string;
+    /** Order ID for tracking */
+    orderId: string;
+    /** When the widget URL expires */
+    expiresAt: string;
+}
+/**
+ * Fiat on-ramp provider interface
+ */
+interface FiatOnRampProvider {
+    /** Provider name */
+    name: string;
+    /** Get a quote for fiat-to-crypto conversion */
+    getQuote(params: Pick<FiatOnRampParams, 'fiatAmount' | 'fiatCurrency' | 'network'>): Promise<FiatOnRampQuote>;
+    /** Create a widget URL for the user to complete the purchase */
+    createWidget(params: FiatOnRampParams): FiatOnRampResult;
+    /** Get supported fiat currencies */
+    getSupportedCurrencies(): string[];
+    /** Get supported CAIP-2 network identifiers */
+    getSupportedNetworks(): string[];
+}
+
+export { WDKErrorCode as $, type AggregatedBalance as A, type BridgeResult as B, type ChainFamily as C, DEFAULT_RETRY_CONFIG as D, type EvmChainConfig as E, type FiatOnRampProvider as F, type GetAllSignersOptions as G, type T402WDKConfig as H, type T402WDKCreateConfig as I, type T402WDKOptions as J, type T402WDKSigner as K, type TokenBalance as L, type MetricCallback as M, type NormalizedChainConfig as N, type TonChainConfig as O, type ProviderStatus as P, TransactionError as Q, RPCError as R, type SignerEntry as S, type T402BalanceCacheConfig as T, type TronChainConfig as U, type TypedDataDomain as V, type WDKSolanaAccount as W, type TypedDataTypes as X, type WDKAutoDiscoveryResult as Y, type WDKConstructor as Z, WDKError as _, type WDKTonAccount as a, WDKInitializationError as a0, type WDKInstanceMultiChain as a1, type WDKModulesConfig as a2, type WDKProtocolModules as a3, type WDKWalletModules as a4, type WdkAccount as a5, createCorrelationId as a6, createFailoverProvider as a7, defaultLogger as a8, hasErrorCode as a9, isWDKError as aa, noopLogger as ab, resolveRpcUrl as ac, withRetry as ad, withTimeout as ae, wrapError as af, type WDKTronAccount as b, type WDKAccount as c, type WDKInstance as d, type FiatOnRampParams as e, type FiatOnRampQuote as f, type FiatOnRampResult as g, BalanceError as h, type BorrowParams as i, type BorrowResult as j, BridgeError as k, type BridgeParams as l, type ChainBalance as m, ChainError as n, type FailoverConfig as o, FailoverProvider as p, type FromWDKOptions as q, type MultiChainConfig as r, type RetryConfig as s, SignerError as t, SigningError as u, type SvmChainConfig as v, type SwapParams as w, type SwapQuote as x, type SwapResult as y, type T402Logger as z };