@t402/wdk 2.4.0 → 2.6.0

package/dist/cjs/index-DnEI5M6d.d.ts

@@ -0,0 +1,1798 @@
+import { Address } from 'viem';
+import { d as WDKInstance, Z as WDKConstructor, a4 as WDKWalletModules, a3 as WDKProtocolModules, F as FiatOnRampProvider, a2 as WDKModulesConfig, I as T402WDKCreateConfig, Y as WDKAutoDiscoveryResult, H as T402WDKConfig, q as FromWDKOptions, J as T402WDKOptions, G as GetAllSignersOptions, S as SignerEntry, N as NormalizedChainConfig, C as ChainFamily, m as ChainBalance, A as AggregatedBalance, l as BridgeParams, B as BridgeResult, x as SwapQuote, w as SwapParams, y as SwapResult, i as BorrowParams, j as BorrowResult, e as FiatOnRampParams, f as FiatOnRampQuote, g as FiatOnRampResult, P as ProviderStatus } from './types-BwK8Xgvg.js';
+import { ClientTonSigner } from './adapters/ton-adapter.js';
+import { TransactionSigner } from './adapters/svm-adapter.js';
+import { ClientTronSigner } from './adapters/tron-adapter.js';
+import { WDKSparkSignerAdapter, WDKBtcSignerAdapter } from './adapters/index.js';
+import { ClientEvmSigner } from '@t402/evm';
+import { MoneyParser, Network } from '@t402/core/types';
+
+/**
+ * WDK Secret Manager
+ *
+ * Encrypted seed phrase storage and retrieval using
+ * AES-256-GCM with PBKDF2 key derivation.
+ *
+ * Includes:
+ * - Key rotation with KDF iteration upgrades
+ * - Pluggable SecretManager interface
+ * - Backup/recovery with metadata and verification
+ */
+interface EncryptedSeed {
+    /** Encrypted seed data (base64) */
+    ciphertext: string;
+    /** Encryption algorithm identifier */
+    algorithm: string;
+    /** KDF parameters */
+    kdf: {
+        salt: string;
+        iterations: number;
+        keyLength: number;
+        hash: string;
+    };
+    /** Initialization vector (base64) */
+    iv: string;
+    /** Version for forward compatibility */
+    version: number;
+}
+/**
+ * Pluggable secret manager interface
+ *
+ * Allows custom encryption backends (e.g., HSM, cloud KMS).
+ * The default implementation uses Node.js crypto.
+ */
+interface SecretManager {
+    encrypt(data: string, password: string): Promise<EncryptedSeed>;
+    decrypt(encrypted: EncryptedSeed, password: string): Promise<string>;
+}
+/**
+ * Metadata included with seed backups
+ */
+interface BackupMetadata {
+    createdAt: string;
+    version: number;
+    supportedChains: string[];
+    /** Chain name -> first derived address hint for verification */
+    addressHints: Record<string, string>;
+}
+/**
+ * Encrypt a seed phrase using AES-256-GCM with PBKDF2 key derivation.
+ *
+ * When @tetherto/wdk-secret-manager is available, delegates to it.
+ * Falls back to Node.js crypto for standalone use.
+ *
+ * @param seedPhrase - The BIP-39 seed phrase to encrypt
+ * @param password - The password to derive the encryption key from
+ * @returns The encrypted seed data
+ */
+declare function encryptSeed(seedPhrase: string, password: string): Promise<EncryptedSeed>;
+/**
+ * Decrypt a seed phrase from encrypted storage.
+ *
+ * @param encrypted - The encrypted seed data
+ * @param password - The password to derive the decryption key from
+ * @returns The decrypted seed phrase
+ * @throws Error if password is wrong or data is corrupted
+ */
+declare function decryptSeed(encrypted: EncryptedSeed, password: string): Promise<string>;
+/**
+ * Rotate the password on an encrypted seed.
+ *
+ * Decrypts with the old password, then re-encrypts with the new password.
+ * Optionally upgrades KDF iterations (e.g., 100k -> 600k) and bumps version to 2.
+ *
+ * @param encrypted - The existing encrypted seed
+ * @param oldPassword - The current password
+ * @param newPassword - The new password to encrypt with
+ * @param options - Optional iteration upgrade
+ * @returns A new EncryptedSeed encrypted with the new password
+ */
+declare function rotateSeedPassword(encrypted: EncryptedSeed, oldPassword: string, newPassword: string, options?: {
+    iterations?: number;
+}): Promise<EncryptedSeed>;
+/**
+ * Register a custom secret manager
+ *
+ * @param manager - The secret manager implementation to use
+ */
+declare function registerSecretManager(manager: SecretManager): void;
+/**
+ * Get the current secret manager
+ *
+ * Returns the registered secret manager, or a default implementation
+ * that uses the built-in encryptSeed/decryptSeed functions.
+ */
+declare function getSecretManager(): SecretManager;
+/**
+ * Create a JSON backup of an encrypted seed with metadata
+ *
+ * @param seedPhrase - The BIP-39 seed phrase to backup
+ * @param password - The password to encrypt the backup with
+ * @param metadata - Backup metadata (chains, address hints, etc.)
+ * @returns JSON string containing the encrypted seed and metadata
+ */
+declare function createBackup(seedPhrase: string, password: string, metadata: BackupMetadata): Promise<string>;
+/**
+ * Verify a backup by attempting to decrypt and optionally checking address hints
+ *
+ * @param backup - The JSON backup string
+ * @param password - The password to decrypt with
+ * @param expectedAddresses - Optional map of chain -> expected address for verification
+ * @returns Object with `valid` (decryption succeeded) and `addressMatch` (addresses match if provided)
+ */
+declare function verifyBackup(backup: string, password: string, expectedAddresses?: Record<string, string>): Promise<{
+    valid: boolean;
+    addressMatch: boolean;
+    metadata?: BackupMetadata;
+}>;
+
+/**
+ * T402 Payment Event Emitter
+ *
+ * Provides typed event emission for tracking payment lifecycle,
+ * balance changes, bridge operations, and signer initialization.
+ */
+/** T402 event types */
+interface T402Events {
+    'payment:start': {
+        url: string;
+        network: string;
+        amount: string;
+    };
+    'payment:signed': {
+        url: string;
+        scheme: string;
+        network: string;
+    };
+    'payment:submitted': {
+        url: string;
+        statusCode: number;
+    };
+    'payment:complete': {
+        url: string;
+        success: boolean;
+        receipt?: unknown;
+    };
+    'payment:failed': {
+        url: string;
+        error: string;
+    };
+    'balance:changed': {
+        chain: string;
+        token: string;
+        previousBalance: bigint;
+        newBalance: bigint;
+    };
+    'bridge:start': {
+        fromChain: string;
+        toChain: string;
+        amount: bigint;
+    };
+    'bridge:confirmed': {
+        txHash: string;
+        fromChain: string;
+        toChain: string;
+    };
+    'bridge:delivered': {
+        txHash: string;
+        dstTxHash?: string;
+        status: string;
+    };
+    'signer:initialized': {
+        chain: string;
+        address: string;
+        family: string;
+    };
+}
+type EventHandler<T> = (data: T) => void;
+declare class T402EventEmitter {
+    private handlers;
+    on<K extends keyof T402Events>(event: K, handler: EventHandler<T402Events[K]>): this;
+    off<K extends keyof T402Events>(event: K, handler: EventHandler<T402Events[K]>): this;
+    once<K extends keyof T402Events>(event: K, handler: EventHandler<T402Events[K]>): this;
+    emit<K extends keyof T402Events>(event: K, data: T402Events[K]): boolean;
+    removeAllListeners(event?: keyof T402Events): this;
+    listenerCount(event: keyof T402Events): number;
+}
+
+/**
+ * Payment Receipt History
+ *
+ * Provides in-memory storage and querying of enriched payment receipts.
+ * Custom backends can be plugged in by implementing PaymentReceiptStore.
+ */
+interface EnrichedReceipt {
+    id: string;
+    timestamp: string;
+    url: string;
+    network: string;
+    scheme: string;
+    amount: string;
+    payTo: string;
+    success: boolean;
+    txHash?: string;
+    chainFamily: string;
+    error?: string;
+}
+interface ReceiptFilter {
+    network?: string;
+    chainFamily?: string;
+    success?: boolean;
+    fromDate?: string;
+    toDate?: string;
+    minAmount?: string;
+    maxAmount?: string;
+    limit?: number;
+    offset?: number;
+}
+interface PaymentReceiptStore {
+    save(receipt: EnrichedReceipt): Promise<void>;
+    getById(id: string): Promise<EnrichedReceipt | null>;
+    query(filter?: ReceiptFilter): Promise<EnrichedReceipt[]>;
+    getAll(): Promise<EnrichedReceipt[]>;
+    count(filter?: ReceiptFilter): Promise<number>;
+    clear(): Promise<void>;
+    exportJSON(): Promise<string>;
+}
+declare class InMemoryReceiptStore implements PaymentReceiptStore {
+    private receipts;
+    save(receipt: EnrichedReceipt): Promise<void>;
+    getById(id: string): Promise<EnrichedReceipt | null>;
+    query(filter?: ReceiptFilter): Promise<EnrichedReceipt[]>;
+    getAll(): Promise<EnrichedReceipt[]>;
+    count(filter?: ReceiptFilter): Promise<number>;
+    clear(): Promise<void>;
+    exportJSON(): Promise<string>;
+}
+
+/**
+ * TTL Cache implementation for balance caching
+ *
+ * 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.
+ */
+
+/**
+ * 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>;
+    /**
+     * Sign an EIP-2612 permit for gasless token approvals
+     *
+     * @param params - Permit parameters
+     * @returns The permit signature components (v, r, s)
+     * @throws {SigningError} If signing fails
+     */
+    signPermit(params: {
+        token: Address;
+        spender: Address;
+        value: bigint;
+        deadline: number;
+        nonce?: bigint;
+        tokenName?: string;
+        tokenVersion?: string;
+    }): Promise<{
+        v: number;
+        r: `0x${string}`;
+        s: `0x${string}`;
+    }>;
+    /**
+     * Send a transaction (for advanced use cases)
+     *
+     * @throws {TransactionError} If transaction fails
+     */
+    sendTransaction(params: {
+        to: Address;
+        value?: bigint;
+        data?: string;
+    }): Promise<{
+        hash: `0x${string}`;
+    }>;
+}
+/**
+ * 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
+ *
+ * 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}`>;
+}
+
+/**
+ * WDK Pricing Provider Integration
+ *
+ * Provides a MoneyParser that converts fiat/stablecoin amounts to
+ * on-chain AssetAmount values using WDK pricing data.
+ */
+
+/** External pricing provider interface */
+interface PricingProvider {
+    /** Get exchange rate from currency to token */
+    getRate(fromCurrency: string, toToken: string): Promise<number>;
+    /** Get list of supported currency pairs */
+    getSupportedPairs(): Array<{
+        from: string;
+        to: string;
+    }>;
+}
+declare function registerPricingProvider(provider: PricingProvider): void;
+declare function getPricingProvider(): PricingProvider | null;
+declare function isPricingProviderRegistered(): boolean;
+interface PricingProviderConfig {
+    /** Cache TTL in milliseconds (default: 60000 = 60s) */
+    cacheTTL?: number;
+    /** Supported fiat currencies (default: ['USD', 'EUR', 'GBP', 'JPY']) */
+    supportedFiat?: string[];
+}
+/**
+ * Creates a MoneyParser that uses WDK pricing provider for fiat-to-crypto conversion.
+ *
+ * For stablecoin-denominated amounts (USDT, USDC, etc.), returns 1:1 ratio (no API call).
+ * For fiat currencies (USD, EUR, etc.), fetches live rates from the pricing provider.
+ *
+ * The MoneyParser interface receives a numeric amount (e.g., 1.50) and a CAIP-2 network.
+ *
+ * @example
+ * ```typescript
+ * import { createWdkMoneyParser } from '@t402/wdk'
+ *
+ * const parser = createWdkMoneyParser({ cacheTTL: 30_000 })
+ * const amount = await parser(1.50, 'eip155:8453') // Returns USDT amount on Base
+ * ```
+ */
+declare function createWdkMoneyParser(config?: PricingProviderConfig): MoneyParser;
+/**
+ * Convert a decimal amount to atomic units string.
+ *
+ * @example
+ * toAtomicUnits(1.5, 6) => "1500000"
+ * toAtomicUnits(0.001, 6) => "1000"
+ */
+declare function toAtomicUnits(amount: number, decimals: number): string;
+/**
+ * Resolve the asset address for a token on a given network.
+ */
+declare function resolveAssetForNetwork(token: string, network: Network): string | null;
+
+/**
+ * T402WDK - Main class for T402 integration with Tether WDK
+ *
+ * Provides a high-level API for:
+ * - Multi-chain wallet management
+ * - T402-compatible signers
+ * - Balance aggregation
+ * - Cross-chain bridging (USDT0)
+ */
+
+/**
+ * Supported WDK semver range
+ */
+declare const SUPPORTED_WDK_RANGE = ">=1.0.0-beta.5 <2.0.0";
+/**
+ * Parse a semver version string into components.
+ * Handles pre-release tags like "1.0.0-beta.5".
+ */
+declare function parseSemver(version: string): {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string;
+} | null;
+/**
+ * Compare two semver versions. Returns -1, 0, or 1.
+ */
+declare function compareSemver(a: string, b: string): number;
+/**
+ * Check if a version satisfies a simple range like ">=1.0.0-beta.5 <2.0.0".
+ * Supports: >=, >, <=, <, = comparators (space-separated AND).
+ */
+declare function satisfiesSemverRange(version: string, range: string): boolean;
+/**
+ * Payment cost estimate for a chain
+ */
+interface PaymentCostEstimate {
+    paymentAmount: string;
+    estimatedGasCost: bigint;
+    nativeBalance: bigint;
+    canAffordGas: boolean;
+    chain: string;
+    network: string;
+}
+/** Middleware function type for chain account hooks */
+type MiddlewareFunction = (account: unknown) => Promise<void>;
+/**
+ * T402WDK - Tether WDK integration for T402 payments
+ *
+ * @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 }]
+ * });
+ * ```
+ */
+declare class T402WDK {
+    private _wdk;
+    private _normalizedChains;
+    private _seedPhrase;
+    private _signerCache;
+    private _balanceCache;
+    private _initializationError;
+    private _events;
+    private _receiptStore;
+    private _disposed;
+    private _wdkConstructor;
+    private _walletManagerEvm;
+    private _bridgeUsdt0Evm;
+    private _walletModules;
+    private _protocolModules;
+    private _fiatOnRampProvider;
+    private _middlewares;
+    private _retryConfig;
+    private _failoverProviders;
+    private static _defaultModules;
+    static get _WDK(): WDKConstructor | null;
+    static set _WDK(val: WDKConstructor | null);
+    static get _WalletManagerEvm(): unknown;
+    static set _WalletManagerEvm(val: unknown);
+    static get _BridgeUsdt0Evm(): unknown;
+    static set _BridgeUsdt0Evm(val: unknown);
+    static get _WalletModules(): WDKWalletModules;
+    static set _WalletModules(val: WDKWalletModules);
+    static get _ProtocolModules(): WDKProtocolModules;
+    static set _ProtocolModules(val: WDKProtocolModules);
+    static get _fiatOnRampProvider(): FiatOnRampProvider | null;
+    static set _fiatOnRampProvider(val: FiatOnRampProvider | null);
+    static get _middlewares(): Map<string, Array<(account: unknown) => Promise<void>>>;
+    static set _middlewares(val: Map<string, Array<(account: unknown) => Promise<void>>>);
+    private _pathSignerCache;
+    private _tonSignerCache;
+    private _svmSignerCache;
+    private _tronSignerCache;
+    private _sparkSignerCache;
+    private _btcSignerCache;
+    /**
+     * 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;
+    /**
+     * Check if Spark wallet manager is registered
+     */
+    static isSparkRegistered(): boolean;
+    /**
+     * Check if Bitcoin wallet manager is registered
+     */
+    static isBtcRegistered(): boolean;
+    /**
+     * Get all registered wallet modules
+     */
+    static getRegisteredWalletModules(): (keyof WDKWalletModules)[];
+    /**
+     * Get all registered protocol modules
+     */
+    static getRegisteredProtocolModules(): (keyof WDKProtocolModules)[];
+    /**
+     * Register a fiat on-ramp provider
+     *
+     * @param provider - A FiatOnRampProvider implementation (e.g., MoonpayOnRampProvider)
+     *
+     * @example
+     * ```typescript
+     * import { T402WDK, MoonpayOnRampProvider } from '@t402/wdk';
+     *
+     * T402WDK.registerFiatOnRamp(new MoonpayOnRampProvider({ apiKey: 'pk_test_...' }));
+     * ```
+     */
+    static registerFiatOnRamp(provider: FiatOnRampProvider): void;
+    /**
+     * Check if a fiat on-ramp provider is registered
+     */
+    static isFiatOnRampRegistered(): boolean;
+    /**
+     * Register a pricing provider for fiat-to-crypto rate conversion
+     */
+    static registerPricingProvider(provider: PricingProvider): void;
+    /**
+     * Check if a pricing provider is registered
+     */
+    static isPricingProviderRegistered(): boolean;
+    /**
+     * Register a middleware for a chain
+     */
+    static registerMiddleware(chain: string, fn: (account: unknown) => Promise<void>): void;
+    /**
+     * Get registered middlewares for a chain
+     */
+    static getMiddlewares(chain: string): Array<(account: unknown) => Promise<void>>;
+    /**
+     * Clear all middlewares
+     */
+    static clearMiddlewares(): void;
+    /**
+     * 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;
+    /**
+     * Auto-discover installed WDK packages using dynamic imports.
+     *
+     * Probes known `@tetherto/wdk-*` packages and returns the ones that
+     * are installed and importable.
+     *
+     * @returns Discovery result with available/unavailable packages and ready-to-use modules config
+     *
+     * @example
+     * ```typescript
+     * const result = await T402WDK.autoDiscover();
+     * console.log('Found:', result.available);
+     * console.log('Missing:', result.unavailable);
+     * ```
+     */
+    static autoDiscover(): Promise<WDKAutoDiscoveryResult>;
+    /**
+     * Auto-discover installed WDK modules, then create a fully configured T402WDK.
+     *
+     * Combines `autoDiscover()` + `create()` in one call. Any explicit
+     * modules you pass in `config.modules` take precedence over discovered ones.
+     *
+     * @param config - Same as `T402WDKCreateConfig` but `modules` is optional/partial
+     * @returns A ready-to-use T402WDK instance
+     *
+     * @example
+     * ```typescript
+     * const wdk = await T402WDK.autoCreate({
+     *   seedPhrase: 'your twelve word seed phrase ...',
+     *   chains: { arbitrum: 'https://arb1.arbitrum.io/rpc' },
+     * });
+     * ```
+     */
+    static autoCreate(config: Omit<T402WDKCreateConfig, 'modules'> & {
+        modules?: Partial<WDKModulesConfig>;
+    }): Promise<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;
+    /**
+     * Create a T402WDK instance from an encrypted seed.
+     *
+     * @example
+     * ```typescript
+     * const encrypted = JSON.parse(fs.readFileSync('seed.enc.json', 'utf8'))
+     * const wdk = await T402WDK.fromEncryptedSeed(encrypted, 'my-password', {
+     *   arbitrum: 'https://arb1.arbitrum.io/rpc',
+     * })
+     * ```
+     */
+    static fromEncryptedSeed(encrypted: EncryptedSeed, password: string, config?: T402WDKConfig, options?: T402WDKOptions): Promise<T402WDK>;
+    /**
+     * Encrypt the current seed phrase for secure storage.
+     *
+     * @param password - Password to encrypt with
+     * @returns Encrypted seed data suitable for JSON serialization
+     */
+    encryptSeed(password: string): Promise<EncryptedSeed>;
+    /**
+     * 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);
+    /**
+     * Guard: throw if this instance has been disposed (#194)
+     */
+    private assertNotDisposed;
+    /**
+     * Whether this instance has been disposed
+     */
+    get isDisposed(): boolean;
+    /**
+     * 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;
+    /**
+     * Subscribe to a T402 event
+     */
+    on<K extends keyof T402Events>(event: K, handler: (data: T402Events[K]) => void): this;
+    /**
+     * Unsubscribe from a T402 event
+     */
+    off<K extends keyof T402Events>(event: K, handler: (data: T402Events[K]) => void): this;
+    /**
+     * Subscribe to a T402 event (fires once then auto-unsubscribes)
+     */
+    once<K extends keyof T402Events>(event: K, handler: (data: T402Events[K]) => void): this;
+    /**
+     * Emit a T402 event
+     */
+    emit<K extends keyof T402Events>(event: K, data: T402Events[K]): boolean;
+    /**
+     * Get the payment receipt store
+     */
+    getReceiptStore(): PaymentReceiptStore;
+    /**
+     * Set a custom payment receipt store backend
+     */
+    setReceiptStore(store: PaymentReceiptStore): void;
+    /**
+     * 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 current fee rates for a chain
+     */
+    getFeeRates(chain: string): Promise<Record<string, bigint>>;
+    /**
+     * Estimate total cost of a payment on a chain
+     */
+    estimatePaymentCost(chain: string, amount: string): Promise<PaymentCostEstimate>;
+    /**
+     * Get a signer using a custom BIP-44 derivation path
+     */
+    getSignerByPath(chain: string, path: string): Promise<WDKSigner>;
+    /**
+     * 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 Spark (Bitcoin L2) signer for T402 payments
+     *
+     * @param accountIndex - HD wallet account index (default: 0)
+     * @throws {ChainError} If Spark wallet manager is not registered
+     * @returns An initialized WDKSparkSignerAdapter
+     *
+     * @example
+     * ```typescript
+     * const sparkSigner = await wallet.getSparkSigner();
+     *
+     * const client = createT402HTTPClient({
+     *   signers: [{ scheme: 'exact', network: 'spark:mainnet', signer: sparkSigner }]
+     * });
+     * ```
+     */
+    getSparkSigner(accountIndex?: number): Promise<WDKSparkSignerAdapter>;
+    /**
+     * Get a Bitcoin (BTC) on-chain signer for T402 payments
+     *
+     * @param accountIndex - HD wallet account index (default: 0)
+     * @throws {ChainError} If Bitcoin wallet manager is not registered
+     * @returns An initialized WDKBtcSignerAdapter
+     *
+     * @example
+     * ```typescript
+     * const btcSigner = await wallet.getBtcSigner();
+     *
+     * const client = createT402HTTPClient({
+     *   signers: [{ scheme: 'exact', network: 'bip122:000000000019d6689c085ae165831e93', signer: btcSigner }]
+     * });
+     * ```
+     */
+    getBtcSigner(accountIndex?: number): Promise<WDKBtcSignerAdapter>;
+    /**
+     * 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 | WDKSparkSignerAdapter | WDKBtcSignerAdapter>;
+    /**
+     * 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 the Aave lending protocol is registered and available
+     */
+    canBorrow(): boolean;
+    /**
+     * Borrow USDT0 against collateral and pay
+     *
+     * Uses the Aave protocol to deposit collateral, borrow USDT0, then the
+     * borrowed USDT0 is available for T402 payments.
+     *
+     * @param params - Borrow parameters
+     * @throws {WDKError} If lending protocol is not registered or borrow fails
+     *
+     * @example
+     * ```typescript
+     * // Borrow 100 USDT0 against 0.05 WETH on Arbitrum
+     * const result = await wallet.borrowAndPay({
+     *   chain: 'arbitrum',
+     *   collateralToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // WETH
+     *   collateralAmount: 50000000000000000n, // 0.05 WETH
+     *   borrowAmount: 100000000n, // 100 USDT0
+     * });
+     * ```
+     */
+    borrowAndPay(params: BorrowParams): Promise<BorrowResult>;
+    /**
+     * Get a fiat on-ramp quote
+     *
+     * @param params - Quote parameters (fiatAmount, fiatCurrency, network)
+     * @throws {WDKError} If no fiat on-ramp provider is registered
+     */
+    getFiatOnRampQuote(params: Pick<FiatOnRampParams, 'fiatAmount' | 'fiatCurrency' | 'network'>): Promise<FiatOnRampQuote>;
+    /**
+     * Generate a fiat on-ramp widget URL for the user
+     *
+     * Returns a widget URL that the application should open in a browser
+     * or webview so the user can complete the fiat purchase.
+     *
+     * @param params - On-ramp parameters
+     * @throws {WDKError} If no fiat on-ramp provider is registered
+     *
+     * @example
+     * ```typescript
+     * const result = await wallet.onRampAndPay({
+     *   fiatAmount: 100,
+     *   fiatCurrency: 'USD',
+     *   walletAddress: '0x...',
+     *   network: 'eip155:42161',
+     * });
+     * // Open result.widgetUrl in browser/webview
+     * ```
+     */
+    onRampAndPay(params: FiatOnRampParams): FiatOnRampResult;
+    /**
+     * 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 all resources held by this instance (#194).
+     *
+     * After disposal, any public method call will throw.
+     * Safe to call multiple times.
+     */
+    dispose(): void;
+    /**
+     * Symbol.dispose support for `using` declarations (TC39 Explicit Resource Management)
+     */
+    [Symbol.dispose](): void;
+    /**
+     * Get the FailoverProvider status for a chain, if one exists.
+     *
+     * @param chain - Chain name
+     * @returns Array of provider statuses, or null if no failover is configured for the chain
+     */
+    getProviderStatus(chain: string): ProviderStatus[] | null;
+    /**
+     * Simple online connectivity check.
+     * Returns true if at least one configured chain's RPC responds.
+     */
+    get isOnline(): Promise<boolean>;
+    private _checkOnline;
+    /**
+     * Wrap an async operation with the instance retry config (#202)
+     */
+    private _withRetry;
+}
+
+/**
+ * A2A + WDK Adapter
+ *
+ * Bridges T402WDK wallets with the A2A (Agent-to-Agent) payment transport,
+ * enabling AI agents to make payments using WDK-managed wallets.
+ */
+
+/**
+ * Payment requirements received from an A2A server (402 response).
+ * Matches the core PaymentRequired type shape.
+ */
+interface A2APaymentRequired {
+    t402Version: number;
+    resource: {
+        url: string;
+        description?: string;
+        mimeType?: string;
+    };
+    accepts: Array<{
+        scheme: string;
+        network: string;
+        asset: string;
+        amount: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }>;
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Payment payload to submit to an A2A server.
+ * Matches the core PaymentPayload type shape.
+ */
+interface A2APaymentPayload {
+    t402Version: number;
+    resource?: {
+        url: string;
+        description?: string;
+        mimeType?: string;
+    };
+    accepted: A2APaymentRequired['accepts'][0];
+    payload: Record<string, unknown>;
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Options for the WDK A2A payment client adapter.
+ */
+interface WdkA2AOptions {
+    /** Maximum spending limit per payment (in atomic units) */
+    spendingLimit?: bigint;
+    /** Callback when manual approval is required */
+    onApprovalRequired?: (payment: {
+        amount: bigint;
+        network: string;
+    }) => Promise<boolean>;
+    /** Auto-check balance before payment */
+    autoBalance?: boolean;
+    /** Auto-bridge if insufficient balance on target chain */
+    autoBridge?: boolean;
+    /** Preferred payment scheme (default: "exact") */
+    preferredScheme?: string;
+}
+/**
+ * Result of createWdkA2APaymentClient.
+ */
+interface WdkA2APaymentClient {
+    /** Signer entries from WDK for all configured chains */
+    signers: SignerEntry[];
+    /** Handle a 402 payment required response */
+    paymentHandler: (req: A2APaymentRequired) => Promise<A2APaymentPayload>;
+}
+/**
+ * Create a WDK-backed A2A payment client.
+ *
+ * Extracts all configured chain signers from WDK and wraps them for A2A use.
+ * The returned `paymentHandler` selects the best signer for the payment
+ * requirements, optionally checks balance, and creates a signed payment payload.
+ *
+ * @param wdk - An initialized T402WDK instance
+ * @param options - Configuration options
+ * @returns Object with signers and a paymentHandler function
+ *
+ * @example
+ * ```typescript
+ * const { signers, paymentHandler } = await createWdkA2APaymentClient(wdk, {
+ *   spendingLimit: 10_000_000n, // 10 USDT0
+ *   autoBalance: true,
+ * });
+ *
+ * // When the A2A agent receives a 402 response:
+ * const payload = await paymentHandler(paymentRequired);
+ * // Submit payload back to the A2A server
+ * ```
+ */
+declare function createWdkA2APaymentClient(wdk: T402WDK, options?: WdkA2AOptions): Promise<WdkA2APaymentClient>;
+
+/**
+ * Facilitator + WDK Adapter
+ *
+ * Wraps a T402WDK wallet as a facilitator-compatible signer, enabling WDK
+ * wallets to be used for on-chain settlement (verify + settle operations).
+ */
+
+/**
+ * Options for the facilitator WDK signer adapter.
+ */
+interface FacilitatorWdkSignerOptions {
+    /** Automatically settle payments after verification */
+    autoSettle?: boolean;
+    /** Auto-bridge received payments to this chain (CAIP-2 network or chain name) */
+    bridgeToMainChain?: string;
+}
+/**
+ * Facilitator-compatible signer backed by WDK.
+ */
+interface FacilitatorWdkSigner {
+    /** Wallet address on the target chain */
+    address: string;
+    /** Sign a transaction for on-chain settlement */
+    signTransaction: (tx: unknown) => Promise<string>;
+    /** Sign typed data (EIP-712) */
+    signTypedData: (data: {
+        domain: Record<string, unknown>;
+        types: Record<string, unknown>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }) => Promise<string>;
+    /** Send a signed transaction */
+    sendTransaction: (params: {
+        to: string;
+        value?: bigint;
+        data?: string;
+    }) => Promise<string>;
+}
+/**
+ * Convert a T402WDK instance into a facilitator-compatible signer for a given chain.
+ *
+ * The returned signer can be used with `toFacilitatorEvmSigner()` or directly
+ * with a `t402Facilitator` instance for on-chain payment verification and settlement.
+ *
+ * @param wdk - An initialized T402WDK instance
+ * @param chain - Chain name (e.g., "arbitrum", "base")
+ * @param options - Optional configuration
+ * @returns A facilitator-compatible signer object
+ *
+ * @example
+ * ```typescript
+ * const signer = await toFacilitatorWdkSigner(wdk, 'arbitrum', {
+ *   autoSettle: true,
+ *   bridgeToMainChain: 'arbitrum',
+ * });
+ *
+ * // Use the signer with the facilitator
+ * console.log('Facilitator address:', signer.address);
+ * ```
+ */
+declare function toFacilitatorWdkSigner(wdk: T402WDK, chain: string, options?: FacilitatorWdkSignerOptions): Promise<FacilitatorWdkSigner>;
+/**
+ * Create facilitator signers for all configured WDK chains.
+ *
+ * @param wdk - An initialized T402WDK instance
+ * @param options - Optional configuration applied to all signers
+ * @returns Map of chain name to facilitator signer
+ *
+ * @example
+ * ```typescript
+ * const signers = await createFacilitatorSigners(wdk, {
+ *   bridgeToMainChain: 'arbitrum',
+ * });
+ *
+ * for (const [chain, signer] of signers) {
+ *   console.log(`${chain}: ${signer.address}`);
+ * }
+ * ```
+ */
+declare function createFacilitatorSigners(wdk: T402WDK, options?: FacilitatorWdkSignerOptions): Promise<Map<string, FacilitatorWdkSigner>>;
+
+/**
+ * SIWx + WDK Adapter
+ *
+ * Wraps a T402WDK wallet as a SIWx (Sign-In-With-X) signer, enabling
+ * WDK wallets to sign CAIP-122 authentication messages.
+ */
+
+/**
+ * SIWx signer interface, compatible with the SIWxSigner from @t402/extensions.
+ */
+interface SIWxSigner {
+    /** Wallet address */
+    address: string;
+    /** Sign a personal message (EIP-191) */
+    signMessage(message: string): Promise<string>;
+    /** Sign EIP-712 typed data */
+    signTypedData(data: {
+        domain: unknown;
+        types: unknown;
+        primaryType: string;
+        message: unknown;
+    }): Promise<string>;
+}
+/**
+ * Convert a T402WDK instance into a SIWx-compatible signer for a given chain.
+ *
+ * The returned signer implements the `SIWxSigner` interface used by
+ * `@t402/extensions` for CAIP-122 Sign-In-With-X authentication flows.
+ *
+ * @param wdk - An initialized T402WDK instance
+ * @param chain - Chain name (e.g., "arbitrum", "base")
+ * @returns A SIWx-compatible signer
+ *
+ * @example
+ * ```typescript
+ * import { toSIWxSigner } from '@t402/wdk';
+ * import { createSIWxPayload, encodeSIWxHeader } from '@t402/extensions';
+ *
+ * const siwxSigner = await toSIWxSigner(wdk, 'arbitrum');
+ *
+ * // Create and sign SIWx payload
+ * const payload = await createSIWxPayload(serverExtension, siwxSigner);
+ * const header = encodeSIWxHeader(payload);
+ *
+ * // Include in request
+ * fetch(url, { headers: { 'X-T402-SIWx': header } });
+ * ```
+ */
+declare function toSIWxSigner(wdk: T402WDK, chain: string): Promise<SIWxSigner>;
+/**
+ * Create SIWx signers for all configured WDK chains.
+ *
+ * @param wdk - An initialized T402WDK instance
+ * @returns Map of chain name to SIWx signer
+ *
+ * @example
+ * ```typescript
+ * const signers = await createSIWxSigners(wdk);
+ * const arbSigner = signers.get('arbitrum');
+ * ```
+ */
+declare function createSIWxSigners(wdk: T402WDK): Promise<Map<string, SIWxSigner>>;
+
+export { verifyBackup as $, type A2APaymentPayload as A, type BackupMetadata as B, type CacheConfig as C, DEFAULT_BALANCE_CACHE_CONFIG as D, type EnrichedReceipt as E, type FacilitatorWdkSigner as F, decryptSeed as G, encryptSeed as H, InMemoryReceiptStore as I, getPricingProvider as J, getSecretManager as K, isPricingProviderRegistered as L, type MiddlewareFunction as M, parseSemver as N, registerPricingProvider as O, type PaymentCostEstimate as P, registerSecretManager as Q, type ReceiptFilter as R, type SIWxSigner as S, T402EventEmitter as T, resolveAssetForNetwork as U, rotateSeedPassword as V, WDKSigner as W, satisfiesSemverRange as X, toAtomicUnits as Y, toFacilitatorWdkSigner as Z, toSIWxSigner as _, type A2APaymentRequired as a, BalanceCache as b, type BalanceCacheConfig as c, type BalanceCacheStats as d, type CacheStats as e, DEFAULT_CACHE_CONFIG as f, type EncryptedSeed as g, type FacilitatorWdkSignerOptions as h, MockWDKSigner as i, type PaymentReceiptStore as j, type PricingProvider as k, type PricingProviderConfig as l, SUPPORTED_WDK_RANGE as m, type SecretManager as n, type T402Events as o, T402WDK as p, TTLCache as q, type WdkA2AOptions as r, type WdkA2APaymentClient as s, compareSemver as t, createBackup as u, createFacilitatorSigners as v, createSIWxSigners as w, createWDKSigner as x, createWdkA2APaymentClient as y, createWdkMoneyParser as z };