@t402/wdk 2.4.0 → 2.6.0

package/dist/cjs/index.d.ts

@@ -1,934 +1,60 @@
+import { W as WDKSigner, E as EnrichedReceipt } from './index-DnEI5M6d.js';
+export { A as A2APaymentPayload, a as A2APaymentRequired, B as BackupMetadata, b as BalanceCache, c as BalanceCacheConfig, d as BalanceCacheStats, C as CacheConfig, e as CacheStats, D as DEFAULT_BALANCE_CACHE_CONFIG, f as DEFAULT_CACHE_CONFIG, g as EncryptedSeed, F as FacilitatorWdkSigner, h as FacilitatorWdkSignerOptions, I as InMemoryReceiptStore, M as MiddlewareFunction, i as MockWDKSigner, P as PaymentCostEstimate, j as PaymentReceiptStore, k as PricingProvider, l as PricingProviderConfig, R as ReceiptFilter, S as SIWxSigner, m as SUPPORTED_WDK_RANGE, n as SecretManager, T as T402EventEmitter, o as T402Events, p as T402WDK, q as TTLCache, r as WdkA2AOptions, s as WdkA2APaymentClient, t as compareSemver, u as createBackup, v as createFacilitatorSigners, w as createSIWxSigners, x as createWDKSigner, y as createWdkA2APaymentClient, z as createWdkMoneyParser, G as decryptSeed, H as encryptSeed, J as getPricingProvider, K as getSecretManager, L as isPricingProviderRegistered, N as parseSemver, O as registerPricingProvider, Q as registerSecretManager, U as resolveAssetForNetwork, V as rotateSeedPassword, X as satisfiesSemverRange, Y as toAtomicUnits, Z as toFacilitatorWdkSigner, _ as toSIWxSigner, $ as verifyBackup } from './index-DnEI5M6d.js';
+import { C as ChainFamily, N as NormalizedChainConfig, E as EvmChainConfig, B as BridgeResult, F as FiatOnRampProvider, e as FiatOnRampParams, f as FiatOnRampQuote, g as FiatOnRampResult } from './types-BwK8Xgvg.js';
+export { A as AggregatedBalance, h as BalanceError, i as BorrowParams, j as BorrowResult, k as BridgeError, l as BridgeParams, m as ChainBalance, n as ChainError, D as DEFAULT_RETRY_CONFIG, o as FailoverConfig, p as FailoverProvider, q as FromWDKOptions, G as GetAllSignersOptions, M as MetricCallback, r as MultiChainConfig, P as ProviderStatus, R as RPCError, s as RetryConfig, S as SignerEntry, t as SignerError, u as SigningError, v as SvmChainConfig, w as SwapParams, x as SwapQuote, y as SwapResult, T as T402BalanceCacheConfig, z as T402Logger, H as T402WDKConfig, I as T402WDKCreateConfig, J as T402WDKOptions, K as T402WDKSigner, L as TokenBalance, O as TonChainConfig, Q as TransactionError, U as TronChainConfig, V as TypedDataDomain, X as TypedDataTypes, c as WDKAccount, Y as WDKAutoDiscoveryResult, Z as WDKConstructor, _ as WDKError, $ as WDKErrorCode, a0 as WDKInitializationError, d as WDKInstance, a1 as WDKInstanceMultiChain, a2 as WDKModulesConfig, a3 as WDKProtocolModules, W as WDKSolanaAccount, a as WDKTonAccount, b as WDKTronAccount, a4 as WDKWalletModules, a5 as WdkAccount, a6 as createCorrelationId, a7 as createFailoverProvider, a8 as defaultLogger, a9 as hasErrorCode, aa as isWDKError, ab as noopLogger, ac as resolveRpcUrl, ad as withRetry, ae as withTimeout, af as wrapError } from './types-BwK8Xgvg.js';
+export { ClientTonSigner, JettonTransferResult, JettonTransferStatus, SignMessageParams as TonSignMessageParams, WDKTonSignerAdapter, WaitForJettonTransferParams, createWDKTonSigner, getJettonWalletAddress, waitForJettonTransfer } from './adapters/ton-adapter.js';
+export { ATAResolution, BuildVersionedTransactionParams, TransactionSigner as ClientSvmSigner, PriorityFeeEstimate, SerializedInstruction, SolanaAddress, TokenProgramType, TransferFeeInfo, TransferWithPriorityFeeParams, WDKSvmSignerAdapter, buildVersionedTransaction, createWDKSvmSigner, deriveATAAddress, getRecentPriorityFees, getTokenProgram, getTransferFee, resolveATA, transferWithPriorityFee } from './adapters/svm-adapter.js';
+export { ClientTronSigner, EnergyEstimate, EnergyProvider, BlockInfo as TronBlockInfo, SignTransactionParams as TronSignTransactionParams, WDKTronSignerAdapter, createWDKTronSigner } from './adapters/tron-adapter.js';
 import { Address } from 'viem';
-import { c as WDKInstance, d as WDKConstructor, e as WDKModulesConfig, f as WDKWalletModules, g as WDKProtocolModules, T as T402WDKCreateConfig, h as T402WDKConfig, F as FromWDKOptions, i as T402WDKOptions, G as GetAllSignersOptions, S as SignerEntry, N as NormalizedChainConfig, C as ChainFamily, j as ChainBalance, A as AggregatedBalance, B as BridgeParams, k as BridgeResult, l as SwapQuote, m as SwapParams, n as SwapResult, E as EvmChainConfig } from './types-V7c-qhn6.js';
-export { M as MultiChainConfig, v as SvmChainConfig, o as T402BalanceCacheConfig, s as T402WDKSigner, p as TokenBalance, w as TonChainConfig, x as TronChainConfig, q as TypedDataDomain, r as TypedDataTypes, t as WDKAccount, y as WDKInstanceMultiChain, W as WDKSolanaAccount, a as WDKTonAccount, b as WDKTronAccount, u as WdkAccount } from './types-V7c-qhn6.js';
-import { ClientTonSigner } from './adapters/ton-adapter.js';
-export { SignMessageParams as TonSignMessageParams, WDKTonSignerAdapter, createWDKTonSigner } from './adapters/ton-adapter.js';
-import { TransactionSigner } from './adapters/svm-adapter.js';
-export { SolanaAddress, WDKSvmSignerAdapter, createWDKSvmSigner } from './adapters/svm-adapter.js';
-import { ClientTronSigner } from './adapters/tron-adapter.js';
-export { BlockInfo as TronBlockInfo, SignTransactionParams as TronSignTransactionParams, WDKTronSignerAdapter, createWDKTronSigner } from './adapters/tron-adapter.js';
-import { ClientEvmSigner, Usdt0Bridge, BridgeSigner } from '@t402/evm';
+import { Usdt0Bridge, BridgeSigner } from '@t402/evm';
 export { BridgeQuote, BridgeSigner, LAYERZERO_ENDPOINT_IDS, USDT0_OFT_ADDRESSES, Usdt0Bridge, getBridgeableChains, supportsBridging } from '@t402/evm';
+import './adapters/index.js';
+import '@t402/core/types';
 
 /**
- * TTL Cache implementation for balance caching
+ * Multi-chain address validation for T402 WDK
  *
- * Provides a generic cache with configurable TTL (Time To Live) for
- * reducing RPC calls and improving performance.
- */
-/**
- * Cache configuration options
- */
-interface CacheConfig {
-    /** Default TTL in milliseconds (default: 30000 = 30 seconds) */
-    defaultTTL: number;
-    /** Maximum number of entries (default: 1000) */
-    maxSize: number;
-    /** Whether to refresh TTL on access (default: false) */
-    refreshOnAccess: boolean;
-}
-/**
- * Default cache configuration
- */
-declare const DEFAULT_CACHE_CONFIG: CacheConfig;
-/**
- * Generic TTL cache implementation
- *
- * @example
- * ```typescript
- * const cache = new TTLCache<bigint>({ defaultTTL: 60000 });
- *
- * // Set with default TTL
- * cache.set('balance:arbitrum:0x123', 1000000n);
- *
- * // Set with custom TTL
- * cache.set('balance:ethereum:0x456', 2000000n, 120000);
- *
- * // Get value (returns undefined if expired)
- * const balance = cache.get('balance:arbitrum:0x123');
- *
- * // Check if key exists and is not expired
- * if (cache.has('balance:arbitrum:0x123')) {
- *   // Use cached value
- * }
- * ```
- */
-declare class TTLCache<T> {
-    private _cache;
-    private _config;
-    private _cleanupInterval;
-    constructor(config?: Partial<CacheConfig>);
-    /**
-     * Get a value from the cache
-     *
-     * @param key - Cache key
-     * @returns The cached value or undefined if not found/expired
-     */
-    get(key: string): T | undefined;
-    /**
-     * Set a value in the cache
-     *
-     * @param key - Cache key
-     * @param value - Value to cache
-     * @param ttl - TTL in milliseconds (optional, uses default if not provided)
-     */
-    set(key: string, value: T, ttl?: number): void;
-    /**
-     * Check if a key exists and is not expired
-     *
-     * @param key - Cache key
-     * @returns true if key exists and is not expired
-     */
-    has(key: string): boolean;
-    /**
-     * Delete a key from the cache
-     *
-     * @param key - Cache key
-     * @returns true if key was deleted
-     */
-    delete(key: string): boolean;
-    /**
-     * Delete all keys matching a prefix
-     *
-     * @param prefix - Key prefix to match
-     * @returns Number of keys deleted
-     */
-    deleteByPrefix(prefix: string): number;
-    /**
-     * Clear all entries from the cache
-     */
-    clear(): void;
-    /**
-     * Get the number of entries in the cache (including expired)
-     */
-    get size(): number;
-    /**
-     * Get the number of valid (non-expired) entries
-     */
-    get validSize(): number;
-    /**
-     * Get all valid keys
-     */
-    keys(): string[];
-    /**
-     * Get remaining TTL for a key in milliseconds
-     *
-     * @param key - Cache key
-     * @returns Remaining TTL in ms, or -1 if not found/expired
-     */
-    getTTL(key: string): number;
-    /**
-     * Update TTL for an existing key
-     *
-     * @param key - Cache key
-     * @param ttl - New TTL in milliseconds
-     * @returns true if key exists and TTL was updated
-     */
-    touch(key: string, ttl?: number): boolean;
-    /**
-     * Get or set a value using a factory function
-     *
-     * @param key - Cache key
-     * @param factory - Function to create value if not cached
-     * @param ttl - TTL in milliseconds (optional)
-     * @returns The cached or newly created value
-     */
-    getOrSet(key: string, factory: () => Promise<T>, ttl?: number): Promise<T>;
-    /**
-     * Get cache statistics
-     */
-    getStats(): CacheStats;
-    /**
-     * Stop the cleanup interval
-     */
-    dispose(): void;
-    /**
-     * Start periodic cleanup of expired entries
-     */
-    private _startCleanup;
-    /**
-     * Remove all expired entries
-     */
-    private _removeExpired;
-    /**
-     * Evict oldest entries to make room
-     */
-    private _evictOldest;
-}
-/**
- * Cache statistics
- */
-interface CacheStats {
-    /** Total entries including expired */
-    totalSize: number;
-    /** Valid (non-expired) entries */
-    validSize: number;
-    /** Expired entries pending cleanup */
-    expiredSize: number;
-    /** Maximum cache size */
-    maxSize: number;
-    /** Default TTL in milliseconds */
-    defaultTTL: number;
-    /** Time until oldest entry expires (ms) */
-    oldestExpiryMs: number;
-    /** Time until newest entry expires (ms) */
-    newestExpiryMs: number;
-}
-/**
- * Balance cache configuration
- */
-interface BalanceCacheConfig {
-    /** 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;
-}
-/**
- * Default balance cache configuration
- */
-declare const DEFAULT_BALANCE_CACHE_CONFIG: BalanceCacheConfig;
-/**
- * Specialized balance cache for WDK
- *
- * Provides separate TTL settings for different balance types
- * and convenient methods for balance-specific caching.
- *
- * @example
- * ```typescript
- * const cache = new BalanceCache({
- *   tokenBalanceTTL: 60000, // 1 minute for token balances
- * });
- *
- * // Cache token balance
- * cache.setTokenBalance('arbitrum', '0xUSDT', '0xWallet', 1000000n);
- *
- * // Get cached balance (returns undefined if expired)
- * const balance = cache.getTokenBalance('arbitrum', '0xUSDT', '0xWallet');
- *
- * // Or use getOrFetch pattern
- * const balance = await cache.getOrFetchTokenBalance(
- *   'arbitrum',
- *   '0xUSDT',
- *   '0xWallet',
- *   async () => await signer.getTokenBalance('0xUSDT')
- * );
- * ```
- */
-declare class BalanceCache {
-    private _cache;
-    private _aggregatedCache;
-    private _config;
-    constructor(config?: Partial<BalanceCacheConfig>);
-    /**
-     * Check if caching is enabled
-     */
-    get enabled(): boolean;
-    /**
-     * Get cache configuration
-     */
-    get config(): BalanceCacheConfig;
-    /**
-     * Get cached native balance
-     */
-    getNativeBalance(chain: string, address: string): bigint | undefined;
-    /**
-     * Set native balance in cache
-     */
-    setNativeBalance(chain: string, address: string, balance: bigint): void;
-    /**
-     * Get or fetch native balance
-     */
-    getOrFetchNativeBalance(chain: string, address: string, fetcher: () => Promise<bigint>): Promise<bigint>;
-    /**
-     * Get cached token balance
-     */
-    getTokenBalance(chain: string, token: string, address: string): bigint | undefined;
-    /**
-     * Set token balance in cache
-     */
-    setTokenBalance(chain: string, token: string, address: string, balance: bigint): void;
-    /**
-     * Get or fetch token balance
-     */
-    getOrFetchTokenBalance(chain: string, token: string, address: string, fetcher: () => Promise<bigint>): Promise<bigint>;
-    /**
-     * Get cached aggregated balance
-     */
-    getAggregatedBalance<T>(key: string): T | undefined;
-    /**
-     * Set aggregated balance in cache
-     */
-    setAggregatedBalance<T>(key: string, value: T): void;
-    /**
-     * Get or fetch aggregated balance
-     */
-    getOrFetchAggregatedBalance<T>(key: string, fetcher: () => Promise<T>): Promise<T>;
-    /**
-     * Invalidate all balances for a chain
-     */
-    invalidateChain(chain: string): number;
-    /**
-     * Invalidate all balances for an address
-     */
-    invalidateAddress(address: string): number;
-    /**
-     * Invalidate specific token balance
-     */
-    invalidateTokenBalance(chain: string, token: string, address: string): boolean;
-    /**
-     * Clear all caches
-     */
-    clear(): void;
-    /**
-     * Get cache statistics
-     */
-    getStats(): BalanceCacheStats;
-    /**
-     * Dispose of cache resources
-     */
-    dispose(): void;
-    private _nativeKey;
-    private _tokenKey;
-    private _aggregatedKey;
-}
-/**
- * Balance cache statistics
- */
-interface BalanceCacheStats {
-    balanceCache: CacheStats;
-    aggregatedCache: CacheStats;
-    config: BalanceCacheConfig;
-}
-
-/**
- * WDK Signer implementation for T402 payments
- *
- * This signer wraps the Tether WDK account to provide a T402-compatible
- * signing interface for EVM chains.
+ * Provides address validation and normalization across supported chain families.
+ * Includes cross-chain mismatch detection to help users avoid sending to wrong chains.
  */
 
 /**
- * WDK Signer for T402 EVM payments
- *
- * Implements the ClientEvmSigner interface from @t402/evm,
- * wrapping a Tether WDK account for signing operations.
- *
- * @example
- * ```typescript
- * import { T402WDK } from '@t402/wdk';
- *
- * const wdk = new T402WDK(seedPhrase, { arbitrum: 'https://arb1.arbitrum.io/rpc' });
- * const signer = await wdk.getSigner('arbitrum');
- *
- * // Use with T402 client
- * const client = createT402HTTPClient({
- *   signers: [{ scheme: 'exact', signer }]
- * });
- * ```
- */
-declare class WDKSigner implements ClientEvmSigner {
-    private _wdk;
-    private _chain;
-    private _accountIndex;
-    private _account;
-    private _address;
-    private _timeoutMs;
-    /**
-     * Create a new WDK signer
-     *
-     * @param wdk - The WDK instance
-     * @param chain - Chain name (e.g., "arbitrum", "ethereum")
-     * @param accountIndex - HD wallet account index (default: 0)
-     * @param timeoutMs - Timeout for operations in milliseconds (default: 30000)
-     */
-    constructor(wdk: WDKInstance, chain: string, accountIndex?: number, timeoutMs?: number);
-    /**
-     * Get the wallet address
-     * Throws if signer is not initialized
-     */
-    get address(): Address;
-    /**
-     * Check if the signer is initialized
-     */
-    get isInitialized(): boolean;
-    /**
-     * Initialize the signer by fetching the account
-     * Must be called before using the signer
-     *
-     * @throws {SignerError} If account fetch fails
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get the underlying WDK account
-     * Initializes if not already done
-     *
-     * @throws {SignerError} If initialization fails
-     */
-    private getAccount;
-    /**
-     * Sign EIP-712 typed data for T402 payments
-     *
-     * This is the primary signing method used by T402 for EIP-3009
-     * transferWithAuthorization payments.
-     *
-     * @throws {SigningError} If signing fails
-     */
-    signTypedData(message: {
-        domain: Record<string, unknown>;
-        types: Record<string, unknown>;
-        primaryType: string;
-        message: Record<string, unknown>;
-    }): Promise<`0x${string}`>;
-    /**
-     * Sign a personal message
-     *
-     * @throws {SigningError} If signing fails
-     */
-    signMessage(message: string | Uint8Array): Promise<`0x${string}`>;
-    /**
-     * Get the chain name
-     */
-    getChain(): string;
-    /**
-     * Get the chain ID
-     */
-    getChainId(): number;
-    /**
-     * Get the account index
-     */
-    getAccountIndex(): number;
-    /**
-     * Get native token balance (ETH, etc.)
-     *
-     * @throws {BalanceError} If balance fetch fails
-     */
-    getBalance(): Promise<bigint>;
-    /**
-     * Get ERC20 token balance
-     *
-     * @throws {BalanceError} If balance fetch fails
-     */
-    getTokenBalance(tokenAddress: Address): Promise<bigint>;
-    /**
-     * Estimate gas for a transaction
-     *
-     * @throws {TransactionError} If gas estimation fails
-     */
-    estimateGas(params: {
-        to: Address;
-        value?: bigint;
-        data?: string;
-    }): Promise<bigint>;
-    /**
-     * Send a transaction (for advanced use cases)
-     *
-     * @throws {TransactionError} If transaction fails
-     */
-    sendTransaction(params: {
-        to: Address;
-        value?: bigint;
-        data?: string;
-    }): Promise<{
-        hash: `0x${string}`;
-    }>;
+ * Result of validating a payment address
+ */
+interface AddressValidationResult {
+    /** Whether the address is valid for the specified chain family */
+    valid: boolean;
+    /** Normalized form of the address (e.g., checksummed, lowercased) */
+    normalized?: string;
+    /** Error message if validation failed */
+    error?: string;
+    /** Detected chain family if the address appears to belong to a different chain */
+    detectedFamily?: ChainFamily;
 }
 /**
- * Create an initialized WDK signer
- *
- * This async factory function creates and initializes a WDK signer,
- * ensuring the address is available immediately.
- *
- * @throws {SignerError} If initialization fails
- *
- * @example
- * ```typescript
- * const signer = await createWDKSigner(wdkInstance, 'arbitrum');
- * console.log('Address:', signer.address); // Works immediately
- * ```
- */
-declare function createWDKSigner(wdk: WDKInstance, chain: string, accountIndex?: number, timeoutMs?: number): Promise<WDKSigner>;
-/**
- * Mock WDK signer for testing purposes
+ * Validate a payment address for a given chain family.
  *
- * Implements the same interface but uses a fixed private key
- * for deterministic testing.
- */
-declare class MockWDKSigner implements ClientEvmSigner {
-    readonly address: Address;
-    constructor(address: Address, _privateKey: `0x${string}`);
-    signTypedData(_message: {
-        domain: Record<string, unknown>;
-        types: Record<string, unknown>;
-        primaryType: string;
-        message: Record<string, unknown>;
-    }): Promise<`0x${string}`>;
-    signMessage(_message: string | Uint8Array): Promise<`0x${string}`>;
-}
-
-/**
- * T402WDK - Main class for T402 integration with Tether WDK
+ * Supports EVM, TON, TRON, Solana (SVM), Bitcoin (BTC/Spark), and Cosmos.
+ * Returns validation result with optional normalization and cross-chain mismatch detection.
  *
- * Provides a high-level API for:
- * - Multi-chain wallet management
- * - T402-compatible signers
- * - Balance aggregation
- * - Cross-chain bridging (USDT0)
- */
-
-/**
- * T402WDK - Tether WDK integration for T402 payments
+ * @param address - The address to validate
+ * @param family - The target chain family
+ * @returns Validation result
  *
  * @example
  * ```typescript
- * import { T402WDK } from '@t402/wdk';
- *
- * // Initialize with seed phrase
- * const seedPhrase = T402WDK.generateSeedPhrase();
- * const wdk = new T402WDK(seedPhrase, {
- *   arbitrum: 'https://arb1.arbitrum.io/rpc',
- *   base: 'https://mainnet.base.org'
- * });
- *
- * // Get signer for T402 payments
- * const signer = await wdk.getSigner('arbitrum');
- *
- * // Use with T402 client
- * const client = createT402HTTPClient({
- *   signers: [{ scheme: 'exact', signer }]
- * });
+ * const result = validatePaymentAddress('0x1234...', 'evm');
+ * if (result.valid) {
+ *   console.log('Normalized:', result.normalized);
+ * } else {
+ *   console.error(result.error);
+ *   if (result.detectedFamily) {
+ *     console.error(`Did you mean to use ${result.detectedFamily}?`);
+ *   }
+ * }
  * ```
  */
-declare class T402WDK {
-    private _wdk;
-    private _normalizedChains;
-    private _seedPhrase;
-    private _signerCache;
-    private _balanceCache;
-    private _initializationError;
-    private static _WDK;
-    private static _WalletManagerEvm;
-    private static _BridgeUsdt0Evm;
-    private static _WalletModules;
-    private static _ProtocolModules;
-    private _tonSignerCache;
-    private _svmSignerCache;
-    private _tronSignerCache;
-    /**
-     * Register the Tether WDK modules
-     *
-     * This must be called before creating T402WDK instances if you want
-     * to use the actual WDK. Otherwise, a mock implementation is used.
-     *
-     * Supports two registration patterns:
-     *
-     * 1. Legacy (EVM-only):
-     *    ```typescript
-     *    T402WDK.registerWDK(WDK, WalletManagerEvm, BridgeUsdt0Evm);
-     *    ```
-     *
-     * 2. Unified (multi-chain):
-     *    ```typescript
-     *    T402WDK.registerWDK(WDK, {
-     *      wallets: {
-     *        evm: WalletManagerEvm,
-     *        ton: WalletManagerTon,
-     *        solana: WalletManagerSolana,
-     *        tron: WalletManagerTron,
-     *      },
-     *      protocols: {
-     *        bridgeUsdt0Evm: BridgeUsdt0Evm,
-     *        bridgeUsdt0Ton: BridgeUsdt0Ton,
-     *      }
-     *    });
-     *    ```
-     *
-     * @throws {WDKInitializationError} If registration fails
-     */
-    static registerWDK(WDK: WDKConstructor, modulesOrWalletManager?: WDKModulesConfig | unknown, BridgeUsdt0Evm?: unknown): void;
-    /**
-     * Check if WDK is registered
-     */
-    static isWDKRegistered(): boolean;
-    /**
-     * Check if wallet manager is registered
-     */
-    static isWalletManagerRegistered(): boolean;
-    /**
-     * Check if bridge protocol is registered
-     */
-    static isBridgeRegistered(): boolean;
-    /**
-     * Check if TON wallet manager is registered
-     */
-    static isTonRegistered(): boolean;
-    /**
-     * Check if Solana wallet manager is registered
-     */
-    static isSolanaRegistered(): boolean;
-    /**
-     * Check if TRON wallet manager is registered
-     */
-    static isTronRegistered(): boolean;
-    /**
-     * Get all registered wallet modules
-     */
-    static getRegisteredWalletModules(): (keyof WDKWalletModules)[];
-    /**
-     * Get all registered protocol modules
-     */
-    static getRegisteredProtocolModules(): (keyof WDKProtocolModules)[];
-    /**
-     * Generate a new random seed phrase
-     *
-     * @throws {WDKInitializationError} If WDK is not registered
-     * @returns A new BIP-39 mnemonic seed phrase
-     */
-    static generateSeedPhrase(): string;
-    /**
-     * Quick setup: seed phrase + chains + modules → ready-to-use T402WDK.
-     *
-     * Registers all provided wallet/protocol modules and creates a fully
-     * configured instance in a single call.
-     *
-     * @example
-     * ```typescript
-     * import WDK from '@tetherto/wdk';
-     * import WalletManagerEvm from '@tetherto/wdk-wallet-evm';
-     * import BridgeUsdt0Evm from '@tetherto/wdk-protocol-bridge-usdt0-evm';
-     *
-     * const wallet = T402WDK.create({
-     *   seedPhrase: 'your twelve word seed phrase ...',
-     *   chains: {
-     *     arbitrum: 'https://arb1.arbitrum.io/rpc',
-     *     base: 'https://mainnet.base.org',
-     *   },
-     *   modules: {
-     *     wallets: { evm: WalletManagerEvm },
-     *     protocols: { bridgeUsdt0Evm: BridgeUsdt0Evm },
-     *   },
-     * });
-     * ```
-     */
-    static create(WDK: WDKConstructor, config: T402WDKCreateConfig): T402WDK;
-    /**
-     * Create a T402WDK from a pre-configured @tetherto/wdk instance.
-     *
-     * Wraps an existing WDK instance (already has wallets/protocols registered)
-     * into a T402WDK without re-registering modules.
-     *
-     * @param wdkInstance - A pre-configured WDK instance
-     * @param config - EVM chain configuration (RPC endpoints)
-     * @param options - Additional options
-     */
-    static fromWDK(wdkInstance: WDKInstance, config?: T402WDKConfig, options?: FromWDKOptions & T402WDKOptions): T402WDK;
-    /**
-     * Get all signers as an array ready for T402 HTTP clients.
-     *
-     * Returns signer entries for all configured EVM chains, plus any
-     * registered non-EVM chains (TON, Solana, TRON).
-     *
-     * @example
-     * ```typescript
-     * const signers = await wallet.getAllSigners();
-     * const client = createT402HTTPClient({ signers });
-     * ```
-     */
-    getAllSigners(options?: GetAllSignersOptions): Promise<SignerEntry[]>;
-    /**
-     * Create a new T402WDK instance
-     *
-     * @param seedPhrase - BIP-39 mnemonic seed phrase
-     * @param config - Chain configuration (RPC endpoints)
-     * @param options - Additional options (cache configuration, etc.)
-     * @throws {WDKInitializationError} If seed phrase is invalid
-     */
-    constructor(seedPhrase: string, config?: T402WDKConfig, options?: T402WDKOptions);
-    /**
-     * Add default chain configurations for common chains
-     */
-    private _addDefaultChainsIfNeeded;
-    /**
-     * Initialize the underlying WDK instance
-     */
-    private _initializeWDK;
-    /**
-     * Get the underlying WDK instance
-     *
-     * @throws {WDKInitializationError} If WDK is not initialized
-     */
-    get wdk(): WDKInstance;
-    /**
-     * Check if WDK is properly initialized
-     */
-    get isInitialized(): boolean;
-    /**
-     * Get initialization error if any
-     */
-    get initializationError(): Error | null;
-    /**
-     * Get all configured chains
-     */
-    getConfiguredChains(): string[];
-    /**
-     * Get chain configuration
-     */
-    getChainConfig(chain: string): NormalizedChainConfig | undefined;
-    /**
-     * Check if a chain is configured
-     */
-    isChainConfigured(chain: string): boolean;
-    /**
-     * Get a T402-compatible signer for a chain
-     *
-     * @param chain - Chain name (e.g., "arbitrum", "ethereum")
-     * @param accountIndex - HD wallet account index (default: 0)
-     * @throws {ChainError} If chain is not configured
-     * @throws {SignerError} If signer creation fails
-     * @returns An initialized WDKSigner
-     */
-    getSigner(chain: string, accountIndex?: number): Promise<WDKSigner>;
-    /**
-     * Clear the signer cache
-     * Useful for forcing re-initialization of signers
-     */
-    clearSignerCache(): void;
-    /**
-     * Get a TON signer for T402 payments
-     *
-     * @param accountIndex - HD wallet account index (default: 0)
-     * @throws {ChainError} If TON wallet manager is not registered
-     * @returns An initialized ClientTonSigner
-     *
-     * @example
-     * ```typescript
-     * const tonSigner = await wallet.getTonSigner();
-     *
-     * const client = createT402HTTPClient({
-     *   signers: [{ scheme: 'exact', network: 'ton:mainnet', signer: tonSigner }]
-     * });
-     * ```
-     */
-    getTonSigner(accountIndex?: number): Promise<ClientTonSigner>;
-    /**
-     * Get a Solana (SVM) signer for T402 payments
-     *
-     * @param accountIndex - HD wallet account index (default: 0)
-     * @throws {ChainError} If Solana wallet manager is not registered
-     * @returns An initialized TransactionSigner (ClientSvmSigner)
-     *
-     * @example
-     * ```typescript
-     * const svmSigner = await wallet.getSvmSigner();
-     *
-     * const client = createT402HTTPClient({
-     *   signers: [{ scheme: 'exact', network: 'solana:mainnet', signer: svmSigner }]
-     * });
-     * ```
-     */
-    getSvmSigner(accountIndex?: number): Promise<TransactionSigner>;
-    /**
-     * Get a TRON signer for T402 payments
-     *
-     * @param accountIndex - HD wallet account index (default: 0)
-     * @param rpcUrl - Optional custom RPC URL (default: https://api.trongrid.io)
-     * @throws {ChainError} If TRON wallet manager is not registered
-     * @returns An initialized ClientTronSigner
-     *
-     * @example
-     * ```typescript
-     * const tronSigner = await wallet.getTronSigner();
-     *
-     * const client = createT402HTTPClient({
-     *   signers: [{ scheme: 'exact', network: 'tron:mainnet', signer: tronSigner }]
-     * });
-     * ```
-     */
-    getTronSigner(accountIndex?: number, rpcUrl?: string): Promise<ClientTronSigner>;
-    /**
-     * Get a signer for a specific chain family
-     *
-     * @param family - Chain family (evm, svm, ton, tron)
-     * @param chainOrIndex - Chain name for EVM, or account index for others
-     * @param accountIndex - Account index (only used for EVM)
-     * @throws {ChainError} If chain family is not supported or not configured
-     * @returns An appropriate signer for the chain family
-     *
-     * @example
-     * ```typescript
-     * // Get EVM signer for Arbitrum
-     * const evmSigner = await wallet.getSignerByFamily('evm', 'arbitrum');
-     *
-     * // Get TON signer
-     * const tonSigner = await wallet.getSignerByFamily('ton');
-     *
-     * // Get Solana signer with account index 1
-     * const svmSigner = await wallet.getSignerByFamily('svm', 1);
-     * ```
-     */
-    getSignerByFamily(family: ChainFamily, chainOrIndex?: string | number, accountIndex?: number): Promise<WDKSigner | ClientTonSigner | TransactionSigner | ClientTronSigner>;
-    /**
-     * Get wallet address for a chain
-     *
-     * @param chain - Chain name
-     * @param accountIndex - HD wallet account index (default: 0)
-     * @throws {ChainError} If chain is not configured
-     * @throws {SignerError} If address fetch fails
-     */
-    getAddress(chain: string, accountIndex?: number): Promise<Address>;
-    /**
-     * Get USDT0 balance for a chain
-     *
-     * Uses cache if enabled to reduce RPC calls.
-     *
-     * @throws {BalanceError} If balance fetch fails
-     */
-    getUsdt0Balance(chain: string, accountIndex?: number): Promise<bigint>;
-    /**
-     * Get USDC balance for a chain
-     *
-     * Uses cache if enabled to reduce RPC calls.
-     *
-     * @throws {BalanceError} If balance fetch fails
-     */
-    getUsdcBalance(chain: string, accountIndex?: number): Promise<bigint>;
-    /**
-     * Get all token balances for a chain
-     *
-     * Uses cache if enabled to reduce RPC calls.
-     *
-     * @throws {ChainError} If chain is not configured
-     * @throws {BalanceError} If balance fetch fails
-     */
-    getChainBalances(chain: string, accountIndex?: number): Promise<ChainBalance>;
-    /**
-     * Get aggregated balances across all configured chains
-     *
-     * @param accountIndex - HD wallet account index (default: 0)
-     * @param options - Options for balance aggregation
-     */
-    getAggregatedBalances(accountIndex?: number, options?: {
-        continueOnError?: boolean;
-    }): Promise<AggregatedBalance>;
-    /**
-     * Find the best chain for a payment
-     *
-     * Looks for the chain with sufficient balance, prioritizing USDT0.
-     *
-     * @param amount - Required amount in smallest units
-     * @param preferredToken - Preferred token ("USDT0" | "USDC")
-     * @throws {BalanceError} If balance aggregation fails
-     */
-    findBestChainForPayment(amount: bigint, preferredToken?: 'USDT0' | 'USDC'): Promise<{
-        chain: string;
-        token: string;
-        balance: bigint;
-    } | null>;
-    /**
-     * Bridge USDT0 between chains
-     *
-     * Uses LayerZero OFT for cross-chain transfers.
-     *
-     * @param params - Bridge parameters
-     * @throws {BridgeError} If bridge is not available or fails
-     * @returns Bridge result with transaction hash
-     */
-    bridgeUsdt0(params: BridgeParams): Promise<BridgeResult>;
-    /**
-     * Get chains that support USDT0
-     */
-    getUsdt0Chains(): string[];
-    /**
-     * Get chains that support USDT0 bridging
-     *
-     * Returns configured chains that have LayerZero OFT bridge support.
-     */
-    getBridgeableChains(): string[];
-    /**
-     * Check if bridging is supported between two chains
-     */
-    canBridge(fromChain: string, toChain: string): boolean;
-    /**
-     * Get all possible bridge destinations from a chain
-     */
-    getBridgeDestinations(fromChain: string): string[];
-    /**
-     * Check if the Velora swap protocol is registered and available
-     */
-    canSwap(): boolean;
-    /**
-     * Get a swap quote for converting a token to USDT0
-     *
-     * @param chain - Chain name (e.g., "ethereum", "arbitrum")
-     * @param fromToken - Input token address
-     * @param amount - Amount to swap in smallest units
-     * @throws {WDKError} If swap protocol is not registered or quote fails
-     */
-    getSwapQuote(chain: string, fromToken: string, amount: bigint): Promise<SwapQuote>;
-    /**
-     * Swap any token to USDT0 for payment
-     *
-     * Uses the Velora protocol to execute a token swap on the specified chain.
-     *
-     * @param params - Swap parameters
-     * @throws {WDKError} If swap protocol is not registered or swap fails
-     *
-     * @example
-     * ```typescript
-     * // Swap 0.1 WETH to USDT0 on Arbitrum
-     * const result = await wallet.swapAndPay({
-     *   chain: 'arbitrum',
-     *   fromToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // WETH
-     *   amount: 100000000000000000n, // 0.1 WETH
-     *   maxSlippage: 0.005,
-     * });
-     * ```
-     */
-    swapAndPay(params: SwapParams): Promise<SwapResult>;
-    /**
-     * Check if balance caching is enabled
-     */
-    get isCacheEnabled(): boolean;
-    /**
-     * Get cache configuration
-     */
-    getCacheConfig(): BalanceCacheConfig;
-    /**
-     * Get cache statistics
-     */
-    getCacheStats(): BalanceCacheStats;
-    /**
-     * Invalidate all cached balances
-     *
-     * Call this after sending transactions to ensure fresh balance data.
-     */
-    invalidateBalanceCache(): void;
-    /**
-     * Invalidate cached balances for a specific chain
-     *
-     * @param chain - Chain name to invalidate
-     * @returns Number of cache entries invalidated
-     */
-    invalidateChainCache(chain: string): number;
-    /**
-     * Invalidate cached balances for a specific address
-     *
-     * @param address - Address to invalidate (case-insensitive)
-     * @returns Number of cache entries invalidated
-     */
-    invalidateAddressCache(address: string): number;
-    /**
-     * Dispose of cache resources
-     *
-     * Call this when the T402WDK instance is no longer needed.
-     */
-    dispose(): void;
-}
+declare function validatePaymentAddress(address: string, family: ChainFamily | 'cosmos'): AddressValidationResult;
 
 /**
  * Chain configuration and token addresses for T402 WDK
@@ -968,230 +94,106 @@ interface TokenInfo {
 }
 declare const CHAIN_TOKENS: Record<string, TokenInfo[]>;
 /**
- * Normalize chain configuration from string or object
- */
-declare function normalizeChainConfig(chainName: string, config: string | EvmChainConfig): NormalizedChainConfig;
-/**
- * Get CAIP-2 network ID from chain name
+ * Token entry in the chain registry (address is string to support non-EVM)
  */
-declare function getNetworkFromChain(chain: string): string;
-/**
- * Get chain name from CAIP-2 network ID
- */
-declare function getChainFromNetwork(network: string): string | undefined;
-/**
- * Get chain ID from chain name
- */
-declare function getChainId(chain: string): number;
-/**
- * Get all chains that support USDT0
- */
-declare function getUsdt0Chains(): string[];
-/**
- * Get preferred token for a chain (USDT0 > USDC > USDT)
- */
-declare function getPreferredToken(chain: string): TokenInfo | undefined;
-
-/**
- * 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>;
-    });
+interface RegistryToken {
+    address: string;
+    symbol: string;
+    decimals: number;
 }
 /**
- * Error thrown for signing operations
+ * Unified chain registry entry
  */
-declare class SigningError extends WDKError {
-    readonly operation: 'signTypedData' | 'signMessage';
-    constructor(code: WDKErrorCode, message: string, options: {
-        operation: 'signTypedData' | 'signMessage';
-        cause?: Error;
-        context?: Record<string, unknown>;
-    });
+interface ChainRegistryEntry {
+    family: ChainFamily;
+    chainId?: number;
+    caip2: string;
+    rpcEndpoints: string[];
+    tokens: RegistryToken[];
 }
 /**
- * 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
+ * Unified chain registry mapping chain names to metadata.
+ *
+ * Includes EVM chains (derived from existing data), plus TON, TRON, Solana.
+ * Existing exports (DEFAULT_CHAINS, USDT0_ADDRESSES, etc.) remain the
+ * canonical source for EVM data; the registry provides a single lookup
+ * for cross-chain code paths.
  */
-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>;
-    });
-}
+declare const CHAIN_REGISTRY: Record<string, ChainRegistryEntry>;
 /**
- * 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>;
-    });
-}
+ * Look up a chain registry entry by CAIP-2 identifier.
+ */
+declare function getRegistryByCaip2(caip2: string): ChainRegistryEntry | undefined;
 /**
- * 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>;
-    });
-}
+ * Get all chain names for a given chain family.
+ */
+declare function getChainsByFamily(family: ChainFamily): string[];
 /**
- * Wrap an unknown error into a WDKError
+ * Normalize chain configuration from string or object
  */
-declare function wrapError(error: unknown, defaultCode?: WDKErrorCode, defaultMessage?: string, context?: Record<string, unknown>): WDKError;
+declare function normalizeChainConfig(chainName: string, config: string | EvmChainConfig): NormalizedChainConfig;
 /**
- * Type guard to check if an error is a WDKError
+ * Get CAIP-2 network ID from chain name
  */
-declare function isWDKError(error: unknown): error is WDKError;
+declare function getNetworkFromChain(chain: string): string;
 /**
- * Type guard to check if an error has a specific code
+ * Get chain name from CAIP-2 network ID
  */
-declare function hasErrorCode(error: unknown, code: WDKErrorCode): boolean;
+declare function getChainFromNetwork(network: string): string | undefined;
 /**
- * Retry configuration
+ * Get chain ID from chain name
  */
-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;
-}
+declare function getChainId(chain: string): number;
 /**
- * Default retry configuration
+ * Get all chains that support USDT0
  */
-declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+declare function getUsdt0Chains(): string[];
 /**
- * Execute an async function with retry logic
+ * Get preferred token for a chain (USDT0 > USDC > USDT)
  */
-declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>): Promise<T>;
+declare function getPreferredToken(chain: string): TokenInfo | undefined;
+
 /**
- * Timeout wrapper for async operations
+ * Bridge Delivery Tracking
+ *
+ * Tracks LayerZero cross-chain bridge message delivery status
+ * by polling the LayerZero Scan API.
  */
-declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, operation?: string): Promise<T>;
+/** Bridge delivery status (mirrors @t402/wdk-bridge BridgeDeliveryStatus) */
+type BridgeDeliveryStatus = 'INFLIGHT' | 'CONFIRMING' | 'DELIVERED' | 'FAILED' | 'BLOCKED';
+/** Options for waiting for delivery */
+interface WaitOptions {
+    timeout?: number;
+    pollInterval?: number;
+    onStatusChange?: (status: BridgeDeliveryStatus) => void;
+}
+/** Result of delivery confirmation */
+interface DeliveryResult {
+    success: boolean;
+    status: BridgeDeliveryStatus;
+    dstTxHash?: `0x${string}`;
+    srcTxHash: `0x${string}`;
+    messageGuid: `0x${string}`;
+    error?: string;
+}
+interface BridgeTrackerConfig {
+    apiBaseUrl?: string;
+}
+declare class BridgeTracker {
+    private apiBaseUrl;
+    constructor(config?: BridgeTrackerConfig);
+    /** Get current status of a bridge message */
+    getStatus(txHash: string): Promise<{
+        status: BridgeDeliveryStatus;
+        dstTxHash?: string;
+    }>;
+    /** Wait for delivery with polling */
+    waitForDelivery(txHash: string, options?: WaitOptions): Promise<DeliveryResult>;
+}
+declare function mapLayerZeroStatus(data: unknown): {
+    status: BridgeDeliveryStatus;
+    dstTxHash?: string;
+};
 
 /**
  * USDT0 Bridge integration for T402 WDK
@@ -1222,14 +224,23 @@ interface BridgeQuoteResult extends BridgeResult {
  */
 declare class WdkBridge {
     private bridges;
+    readonly tracker: BridgeTracker;
+    constructor(trackerConfig?: BridgeTrackerConfig);
     /**
-     * Create bridge signer adapter from WDK signer
+     * Create bridge signer adapter from WDK signer.
+     *
+     * Uses JSON-RPC calls for readContract / waitForTransactionReceipt,
+     * and delegates writeContract to the WDK signer's sendTransaction.
      */
     private createBridgeSigner;
     /**
      * Get or create a bridge instance for a chain
+     *
+     * @param chain - Chain name (e.g., "arbitrum", "ethereum")
+     * @param signer - WDK signer for the chain
+     * @param rpcUrl - JSON-RPC endpoint URL for the chain
      */
-    getBridge(chain: string, signer: WDKSigner): Usdt0Bridge;
+    getBridge(chain: string, signer: WDKSigner, rpcUrl: string): Usdt0Bridge;
     /**
      * Check if a chain supports USDT0 bridging
      */
@@ -1354,6 +365,486 @@ declare function checkWalletEvmCompatibility(version: string): CompatibilityResu
  */
 declare function getWalletModuleMinVersion(module: keyof typeof WDK_COMPATIBILITY.walletModuleVersions): string | undefined;
 
+/**
+ * Idempotent Payment Protection
+ *
+ * Prevents duplicate payments through idempotency key tracking
+ * and nonce management for EVM permits and other chain-specific operations.
+ */
+
+/**
+ * Idempotency manager interface for preventing duplicate payments
+ */
+interface IdempotencyManager {
+    /** Check if a payment with this key has already been processed */
+    checkDuplicate(key: string): Promise<boolean>;
+    /** Record a completed payment */
+    recordPayment(key: string, receipt: EnrichedReceipt): Promise<void>;
+    /** Get the current nonce for an address on a chain */
+    getNonce(address: string, chain: string): Promise<bigint>;
+    /** Increment and return the next nonce for an address on a chain */
+    incrementNonce(address: string, chain: string): Promise<bigint>;
+}
+/**
+ * In-memory idempotency manager
+ *
+ * Tracks payment keys and nonces in memory. Suitable for single-process
+ * applications. For distributed systems, implement IdempotencyManager
+ * with a shared store (Redis, database, etc.).
+ */
+declare class InMemoryIdempotencyManager implements IdempotencyManager {
+    private _payments;
+    private _nonces;
+    private _recentTxHashes;
+    private _maxRecentTxHashes;
+    /**
+     * @param maxRecentTxHashes - Maximum number of recent tx hashes to track for dedup (default: 1000)
+     */
+    constructor(maxRecentTxHashes?: number);
+    checkDuplicate(key: string): Promise<boolean>;
+    recordPayment(key: string, receipt: EnrichedReceipt): Promise<void>;
+    getNonce(address: string, chain: string): Promise<bigint>;
+    incrementNonce(address: string, chain: string): Promise<bigint>;
+    /**
+     * Check if a transaction hash has been seen recently
+     */
+    hasTxHash(txHash: string): boolean;
+    /**
+     * Get a recorded payment by its idempotency key
+     */
+    getPayment(key: string): EnrichedReceipt | undefined;
+    /**
+     * Get the number of recorded payments
+     */
+    get size(): number;
+    /**
+     * Clear all recorded payments and nonces
+     */
+    clear(): void;
+    private _nonceKey;
+    private _addTxHash;
+}
+/**
+ * Nonce manager for EVM permit signatures
+ *
+ * Caches on-chain nonces locally and increments after each use.
+ * Supports querying the on-chain nonce to resync.
+ */
+declare class NonceManager {
+    private _nonces;
+    /**
+     * Get the current nonce for an address on a chain.
+     * If no cached value exists, uses the provided fetcher to query on-chain.
+     *
+     * @param address - Wallet address
+     * @param chain - Chain identifier
+     * @param fetchOnChainNonce - Optional function to query the on-chain nonce
+     */
+    getNonce(address: string, chain: string, fetchOnChainNonce?: () => Promise<bigint>): Promise<bigint>;
+    /**
+     * Increment the nonce after a successful signature/transaction
+     */
+    increment(address: string, chain: string): bigint;
+    /**
+     * Set the nonce to a specific value (e.g., after querying on-chain)
+     */
+    set(address: string, chain: string, nonce: bigint): void;
+    /**
+     * Reset the nonce for an address on a chain (forces re-fetch on next use)
+     */
+    reset(address: string, chain: string): void;
+    /**
+     * Clear all cached nonces
+     */
+    clear(): void;
+    private _key;
+}
+/**
+ * Generate an idempotency key from payment parameters
+ *
+ * Creates a deterministic key based on the payment details to
+ * prevent the same logical payment from being processed twice.
+ */
+declare function generateIdempotencyKey(params: {
+    url: string;
+    network: string;
+    amount: string;
+    payTo: string;
+    from: string;
+}): string;
+
+/**
+ * Transaction Screening / Compliance
+ *
+ * Provides a pluggable compliance framework for screening transactions
+ * before execution. Supports multiple providers and maintains an audit trail.
+ */
+/**
+ * Parameters for a compliance check
+ */
+interface ComplianceCheckParams {
+    from: string;
+    to: string;
+    chain: string;
+    amount: bigint;
+    asset: string;
+}
+/**
+ * Result of a compliance check
+ */
+interface ComplianceResult {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * A provider that performs compliance checks
+ */
+interface ComplianceProvider {
+    check(params: ComplianceCheckParams): Promise<ComplianceResult>;
+}
+/**
+ * An audit trail entry for a compliance check
+ */
+interface ComplianceEvent {
+    timestamp: number;
+    action: 'payment' | 'bridge' | 'swap';
+    params: ComplianceCheckParams;
+    result: ComplianceResult;
+}
+/**
+ * Manages compliance checks across multiple providers
+ *
+ * All registered providers are checked in order. If any provider
+ * returns `allowed: false`, the transaction is blocked.
+ *
+ * @example
+ * ```typescript
+ * const manager = new ComplianceManager();
+ * manager.registerProvider(new BlacklistProvider(new Set(['0xbad...'])));
+ *
+ * const result = await manager.check({
+ *   from: '0xsender...',
+ *   to: '0xreceiver...',
+ *   chain: 'eip155:42161',
+ *   amount: 1000000n,
+ *   asset: 'USDT0',
+ * });
+ *
+ * if (!result.allowed) {
+ *   console.log('Blocked:', result.reason);
+ * }
+ * ```
+ */
+declare class ComplianceManager {
+    private _providers;
+    private _auditTrail;
+    /**
+     * Register a compliance provider
+     */
+    registerProvider(provider: ComplianceProvider): void;
+    /**
+     * Run all registered providers against the given parameters.
+     * Returns the first rejection, or `{ allowed: true }` if all pass.
+     *
+     * @param params - The transaction parameters to check
+     * @param action - The type of action being performed (default: 'payment')
+     */
+    check(params: ComplianceCheckParams, action?: 'payment' | 'bridge' | 'swap'): Promise<ComplianceResult>;
+    /**
+     * Get the full audit trail of compliance checks
+     */
+    getAuditTrail(): ComplianceEvent[];
+    /**
+     * Clear the audit trail
+     */
+    clearAuditTrail(): void;
+    /**
+     * Get the number of registered providers
+     */
+    get providerCount(): number;
+    private _recordEvent;
+}
+/**
+ * Built-in blacklist compliance provider
+ *
+ * Blocks transactions involving addresses in the blacklist.
+ * Checks both `from` and `to` addresses.
+ */
+declare class BlacklistProvider implements ComplianceProvider {
+    private _addresses;
+    constructor(addresses?: Set<string>);
+    check(params: ComplianceCheckParams): Promise<ComplianceResult>;
+    /**
+     * Add an address to the blacklist
+     */
+    addAddress(address: string): void;
+    /**
+     * Remove an address from the blacklist
+     */
+    removeAddress(address: string): void;
+    /**
+     * Check if an address is blacklisted
+     */
+    hasAddress(address: string): boolean;
+    /**
+     * Get the number of blacklisted addresses
+     */
+    get size(): number;
+}
+/**
+ * Amount limit compliance provider
+ *
+ * Blocks transactions that exceed a configurable per-transaction or
+ * cumulative amount limit.
+ */
+declare class AmountLimitProvider implements ComplianceProvider {
+    private _maxPerTransaction;
+    private _cumulativeAmounts;
+    private _maxCumulative;
+    /**
+     * @param maxPerTransaction - Maximum amount per single transaction
+     * @param maxCumulative - Optional maximum cumulative amount per address
+     */
+    constructor(maxPerTransaction: bigint, maxCumulative?: bigint);
+    check(params: ComplianceCheckParams): Promise<ComplianceResult>;
+    /**
+     * Reset cumulative tracking for an address
+     */
+    resetCumulative(address: string): void;
+    /**
+     * Reset all cumulative tracking
+     */
+    resetAllCumulative(): void;
+}
+
+/**
+ * Webhook Notifications
+ *
+ * Sends payment event notifications to configured webhook endpoints
+ * with HMAC-SHA256 signature verification and retry support.
+ */
+/**
+ * Configuration for a webhook endpoint
+ */
+interface WebhookConfig {
+    /** The URL to send webhook payloads to */
+    url: string;
+    /** Secret key for HMAC-SHA256 signing */
+    secret: string;
+    /** Event types to subscribe to (default: all events) */
+    events?: string[];
+    /** Number of retry attempts on failure (default: 3) */
+    retries?: number;
+}
+/**
+ * Webhook payload for payment events
+ */
+interface PaymentWebhookPayload {
+    event: 'payment.completed' | 'payment.failed';
+    timestamp: string;
+    payment: {
+        network: string;
+        txHash?: string;
+        amount: string;
+        asset: string;
+        payer: string;
+        resource: string;
+    };
+    signature: string;
+}
+/**
+ * Result of a webhook delivery attempt
+ */
+interface WebhookDeliveryResult {
+    url: string;
+    success: boolean;
+    statusCode?: number;
+    error?: string;
+    attempts: number;
+}
+/**
+ * Manages webhook notifications for payment events
+ *
+ * @example
+ * ```typescript
+ * const webhooks = new WebhookManager([{
+ *   url: 'https://example.com/webhooks',
+ *   secret: 'whsec_...',
+ *   events: ['payment.completed'],
+ * }]);
+ *
+ * await webhooks.send('payment.completed', {
+ *   network: 'eip155:42161',
+ *   amount: '1000000',
+ *   asset: 'USDT0',
+ *   payer: '0x...',
+ *   resource: '/api/premium',
+ * });
+ * ```
+ */
+declare class WebhookManager {
+    private _configs;
+    private _deliveryResults;
+    private _maxDeliveryHistory;
+    /**
+     * @param configs - Array of webhook endpoint configurations
+     * @param maxDeliveryHistory - Maximum number of delivery results to retain (default: 100)
+     */
+    constructor(configs: WebhookConfig[], maxDeliveryHistory?: number);
+    /**
+     * Send a webhook event to all subscribed endpoints
+     *
+     * @param event - Event type (e.g., 'payment.completed')
+     * @param payload - Event payload data
+     * @returns Array of delivery results for each endpoint
+     */
+    send(event: string, payload: unknown): Promise<WebhookDeliveryResult[]>;
+    /**
+     * Sign a payload with HMAC-SHA256
+     *
+     * @param payload - The payload to sign (will be JSON.stringify'd if not a string)
+     * @param secret - The secret key
+     * @returns Hex-encoded HMAC-SHA256 signature
+     */
+    signPayload(payload: unknown, secret: string): string;
+    /**
+     * Verify an HMAC-SHA256 signature on a payload
+     *
+     * @param payload - The raw payload string
+     * @param signature - The signature to verify
+     * @param secret - The secret key
+     * @returns True if the signature is valid
+     */
+    verifySignature(payload: string, signature: string, secret: string): boolean;
+    /**
+     * Get recent delivery results
+     */
+    getDeliveryResults(): WebhookDeliveryResult[];
+    /**
+     * Clear delivery history
+     */
+    clearDeliveryResults(): void;
+    /**
+     * Get the number of configured webhook endpoints
+     */
+    get endpointCount(): number;
+    private _deliver;
+    private _recordResult;
+    private _sleep;
+}
+
+/**
+ * WDK Indexer Verifier - Unified cross-chain transaction verification.
+ *
+ * Uses wdk-indexer-http for querying transactions across EVM, TON, TRON, Solana.
+ * Falls back to chain-specific RPC verification if indexer is unavailable.
+ */
+/**
+ * Configuration for the WDK indexer verifier
+ */
+interface WdkIndexerConfig {
+    /** Indexer HTTP endpoint */
+    endpoint: string;
+    /** API key (optional) */
+    apiKey?: string;
+    /** Request timeout in ms (default: 10000) */
+    timeout?: number;
+}
+/**
+ * Query parameters for a transaction
+ */
+interface TransactionQuery {
+    /** Transaction hash */
+    txHash: string;
+    /** Network identifier (CAIP-2 or chain name) */
+    network: string;
+    /** Expected recipient address */
+    expectedTo?: string;
+    /** Expected amount in smallest units */
+    expectedAmount?: string;
+}
+/**
+ * Result of a transaction query
+ */
+interface TransactionResult {
+    /** Whether the transaction was found */
+    found: boolean;
+    /** Whether the transaction is confirmed */
+    confirmed: boolean;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Transfer amount in smallest units */
+    amount: string;
+    /** Token contract address or symbol */
+    token: string;
+    /** Block number (if confirmed) */
+    blockNumber?: number;
+    /** Block timestamp (if confirmed) */
+    timestamp?: number;
+}
+/**
+ * Verification result
+ */
+interface PaymentVerification {
+    /** Whether the payment is verified */
+    verified: boolean;
+    /** Reason for failure (if not verified) */
+    reason?: string;
+}
+/**
+ * WDK Indexer Verifier
+ *
+ * Provides unified cross-chain transaction verification by querying
+ * a wdk-indexer-http endpoint. This enables the facilitator to verify
+ * payments across all supported chains through a single API.
+ *
+ * @example
+ * ```typescript
+ * import { WdkIndexerVerifier } from '@t402/wdk';
+ *
+ * const verifier = new WdkIndexerVerifier({
+ *   endpoint: 'https://indexer.example.com',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * // Verify a payment
+ * const result = await verifier.verifyPayment({
+ *   txHash: '0xabc...',
+ *   network: 'eip155:42161',
+ *   expectedTo: '0xpayee...',
+ *   expectedAmount: '1000000',
+ * });
+ *
+ * if (result.verified) {
+ *   console.log('Payment verified');
+ * }
+ * ```
+ */
+declare class WdkIndexerVerifier {
+    private endpoint;
+    private apiKey?;
+    private timeout;
+    constructor(config: WdkIndexerConfig);
+    /**
+     * Query a transaction across any supported chain
+     */
+    queryTransaction(query: TransactionQuery): Promise<TransactionResult>;
+    /**
+     * Verify a transaction matches expected payment parameters
+     */
+    verifyPayment(query: TransactionQuery): Promise<PaymentVerification>;
+    /**
+     * Check indexer health
+     */
+    healthCheck(): Promise<boolean>;
+}
+/**
+ * Create a WDK indexer verifier
+ */
+declare function createIndexerVerifier(config: WdkIndexerConfig): WdkIndexerVerifier;
+
 /**
  * Hardware wallet type definitions for T402 WDK
  */
@@ -1730,4 +1221,97 @@ declare function detectHardwareWalletSupport(): {
  */
 declare function isHardwareWalletSupported(): boolean;
 
-export { AggregatedBalance, BalanceCache, type BalanceCacheConfig, type BalanceCacheStats, BalanceError, BridgeError, BridgeParams, type BridgeQuoteResult, BridgeResult, CHAIN_TOKENS, type CacheConfig, type CacheStats, ChainBalance, ChainError, ChainFamily, TransactionSigner as ClientSvmSigner, ClientTonSigner, ClientTronSigner, type CompatibilityResult, DEFAULT_BALANCE_CACHE_CONFIG, DEFAULT_CACHE_CONFIG, DEFAULT_CHAINS, DEFAULT_RETRY_CONFIG, DEFAULT_RPC_ENDPOINTS, type DeviceStatus, EvmChainConfig, FromWDKOptions, GetAllSignersOptions, type HardwareWalletConnectionOptions, type HardwareWalletDeviceInfo, HardwareWalletError, HardwareWalletErrorCode, type HardwareWalletSigner, type HardwareWalletType, type LedgerOptions, LedgerSigner, MockWDKSigner, NormalizedChainConfig, RPCError, type RetryConfig, SignerEntry, SignerError, SigningError, SwapParams, SwapQuote, SwapResult, T402WDK, T402WDKConfig, T402WDKCreateConfig, T402WDKOptions, TTLCache, type TokenInfo, TransactionError, type TrezorOptions, TrezorSigner, USDC_ADDRESSES, USDT0_ADDRESSES, USDT_LEGACY_ADDRESSES, WDKConstructor, WDKError, WDKErrorCode, WDKInitializationError, WDKInstance, WDKModulesConfig, WDKProtocolModules, WDKSigner, WDKWalletModules, WDK_COMPATIBILITY, WdkBridge, checkWalletEvmCompatibility, checkWdkCompatibility, createDirectBridge, createLedgerSigner, createTrezorSigner, createWDKSigner, detectHardwareWalletSupport, getChainFromNetwork, getChainId, getNetworkFromChain, getPreferredToken, getUsdt0Chains, getWalletModuleMinVersion, hasErrorCode, isHardwareWalletSupported, isWDKError, normalizeChainConfig, withRetry, withTimeout, wrapError };
+/**
+ * Moonpay fiat on-ramp provider for T402 WDK
+ *
+ * Enables zero-crypto users to purchase USDT/USDT0 directly
+ * via Moonpay's widget and fund their wallet for T402 payments.
+ */
+
+/**
+ * Moonpay provider configuration
+ */
+interface MoonpayConfig {
+    /** Moonpay API key */
+    apiKey: string;
+    /** Environment (default: 'production') */
+    environment?: 'sandbox' | 'production';
+}
+/**
+ * MoonpayOnRampProvider - Fiat on-ramp via Moonpay
+ *
+ * @example
+ * ```typescript
+ * import { MoonpayOnRampProvider } from '@t402/wdk';
+ *
+ * const moonpay = new MoonpayOnRampProvider({
+ *   apiKey: 'pk_test_...',
+ *   environment: 'sandbox',
+ * });
+ *
+ * // Get a quote
+ * const quote = await moonpay.getQuote({
+ *   fiatAmount: 100,
+ *   fiatCurrency: 'USD',
+ *   network: 'eip155:42161',
+ * });
+ *
+ * // Create widget URL for the user
+ * const result = moonpay.createWidget({
+ *   fiatAmount: 100,
+ *   fiatCurrency: 'USD',
+ *   walletAddress: '0x...',
+ *   network: 'eip155:42161',
+ * });
+ *
+ * // Open result.widgetUrl in browser/webview
+ * ```
+ */
+declare class MoonpayOnRampProvider implements FiatOnRampProvider {
+    readonly name = "moonpay";
+    private _apiKey;
+    private _environment;
+    constructor(config: MoonpayConfig);
+    /**
+     * Get the base widget URL for the current environment
+     */
+    get baseUrl(): string;
+    /**
+     * Get the API base URL for the current environment
+     */
+    get apiUrl(): string;
+    /**
+     * Get a quote for fiat-to-crypto conversion
+     *
+     * This method fetches a real-time quote from Moonpay.
+     * Override `_fetchQuote` for testing.
+     */
+    getQuote(params: Pick<FiatOnRampParams, 'fiatAmount' | 'fiatCurrency' | 'network'>): Promise<FiatOnRampQuote>;
+    /**
+     * Fetch quote from Moonpay API (override in tests)
+     */
+    _fetchQuote(url: string): Promise<Record<string, unknown>>;
+    /**
+     * Create a Moonpay widget URL for the user
+     */
+    createWidget(params: FiatOnRampParams): FiatOnRampResult;
+    /**
+     * Get supported fiat currencies
+     */
+    getSupportedCurrencies(): string[];
+    /**
+     * Get supported CAIP-2 networks
+     */
+    getSupportedNetworks(): string[];
+    /**
+     * Map CAIP-2 network to Moonpay currency code
+     */
+    private _getCurrencyCode;
+}
+/**
+ * Get the Moonpay currency code for a CAIP-2 network
+ * Exported for testing
+ */
+declare function getMoonpayCurrencyCode(network: string): string | undefined;
+
+export { type AddressValidationResult, AmountLimitProvider, BlacklistProvider, type BridgeDeliveryStatus, type BridgeQuoteResult, BridgeResult, BridgeTracker, type BridgeTrackerConfig, CHAIN_REGISTRY, CHAIN_TOKENS, ChainFamily, type ChainRegistryEntry, type CompatibilityResult, type ComplianceCheckParams, type ComplianceEvent, ComplianceManager, type ComplianceProvider, type ComplianceResult, DEFAULT_CHAINS, DEFAULT_RPC_ENDPOINTS, type DeliveryResult, type DeviceStatus, EnrichedReceipt, EvmChainConfig, FiatOnRampParams, FiatOnRampProvider, FiatOnRampQuote, FiatOnRampResult, type HardwareWalletConnectionOptions, type HardwareWalletDeviceInfo, HardwareWalletError, HardwareWalletErrorCode, type HardwareWalletSigner, type HardwareWalletType, type IdempotencyManager, InMemoryIdempotencyManager, type LedgerOptions, LedgerSigner, type MoonpayConfig, MoonpayOnRampProvider, NonceManager, NormalizedChainConfig, type PaymentVerification, type PaymentWebhookPayload, type RegistryToken, type TokenInfo, type TransactionQuery, type TransactionResult, type TrezorOptions, TrezorSigner, USDC_ADDRESSES, USDT0_ADDRESSES, USDT_LEGACY_ADDRESSES, WDKSigner, WDK_COMPATIBILITY, type WaitOptions, WdkBridge, type WdkIndexerConfig, WdkIndexerVerifier, type WebhookConfig, type WebhookDeliveryResult, WebhookManager, checkWalletEvmCompatibility, checkWdkCompatibility, createDirectBridge, createIndexerVerifier, createLedgerSigner, createTrezorSigner, detectHardwareWalletSupport, generateIdempotencyKey, getChainFromNetwork, getChainId, getChainsByFamily, getMoonpayCurrencyCode, getNetworkFromChain, getPreferredToken, getRegistryByCaip2, getUsdt0Chains, getWalletModuleMinVersion, isHardwareWalletSupported, mapLayerZeroStatus, normalizeChainConfig, validatePaymentAddress };