export { S as SwapService } from '../SwapService-DZD0OJI_.js';
import { N as NetworkType } from '../index-BLuxEdLp.js';

/**
 * WDK API Client
 *
 * Client for calling the backend WDK endpoints to derive addresses
 * using Tether WDK (which runs server-side in Node.js).
 */

interface WdkApiConfig {
    baseUrl: string;
    timeout?: number;
}
interface DeriveAddressResponse {
    success: boolean;
    address?: string;
    chain?: string;
    path?: string;
    network?: string;
    error?: string;
}
interface DeriveAllAddressesResponse {
    success: boolean;
    addresses?: {
        ethereum: string | null;
        bitcoin: string | null;
        ton: string | null;
        tron: string | null;
        solana: string | null;
        spark: string | null;
    };
    network?: string;
    error?: string;
}
interface ValidateSeedResponse {
    success: boolean;
    isValid?: boolean;
    wordCount?: number;
    error?: string;
}
interface GenerateSeedResponse {
    success: boolean;
    seed?: string;
    wordCount?: number;
    error?: string;
}
/**
 * WDK API Client for server-side Tether WDK integration
 */
declare class WdkApiClient {
    private config;
    constructor(config: WdkApiConfig);
    /**
     * Generate a new BIP-39 seed phrase using Tether WDK
     */
    generateSeed(): Promise<GenerateSeedResponse>;
    /**
     * Validate a BIP-39 seed phrase
     */
    validateSeed(seed: string): Promise<ValidateSeedResponse>;
    /**
     * Derive address for a specific chain using Tether WDK
     */
    deriveAddress(seed: string, chain: NetworkType, network?: 'mainnet' | 'testnet'): Promise<DeriveAddressResponse>;
    /**
     * Derive addresses for all chains using Tether WDK
     */
    deriveAllAddresses(seed: string, network?: 'mainnet' | 'testnet'): Promise<DeriveAllAddressesResponse>;
}
/**
 * Get or create the WDK API client instance
 */
declare function getWdkApiClient(baseUrl?: string): WdkApiClient;

/**
 * WDK Service for SDK
 *
 * Native integration with Tether WDK for multi-chain address derivation.
 * Uses individual wallet modules for each chain to derive cryptographically
 * valid addresses from a BIP-39 seed phrase.
 *
 * Supported chains: Ethereum, Bitcoin, TON, TRON, Solana, Spark (Lightning)
 *
 * @see https://docs.wallet.tether.io/
 */
type SupportedChain = 'ethereum' | 'bitcoin' | 'ton' | 'tron' | 'solana' | 'spark';
interface ChainAddress {
    chain: SupportedChain;
    address: string;
    path: string;
}
interface MultiChainAddresses {
    ethereum: string | null;
    bitcoin: string | null;
    ton: string | null;
    tron: string | null;
    solana: string | null;
    spark: string | null;
}
interface WdkServiceConfig {
    network: 'mainnet' | 'testnet';
    rpcUrls?: {
        ethereum?: string;
        bitcoin?: string;
        solana?: string;
        ton?: string;
        tron?: string;
    };
}
/**
 * WDK Service for native multi-chain address derivation
 * Uses Tether WDK wallet modules directly without needing a backend API
 */
declare class WdkService {
    private seed;
    private config;
    private wallets;
    constructor(config?: Partial<WdkServiceConfig>);
    /**
     * Check if WDK modules are loaded
     */
    static isLoaded(): boolean;
    /**
     * Ensure WDK modules are loaded
     */
    private ensureLoaded;
    /**
     * Load WDK modules (call this before using sync methods)
     */
    loadModules(): Promise<void>;
    /**
     * Generate a random BIP-39 seed phrase (12 words)
     */
    generateSeedPhrase(): Promise<string>;
    /**
     * Validate a BIP-39 seed phrase
     */
    isValidSeed(seed: string): Promise<boolean>;
    /**
     * Validate seed phrase (sync version - basic check)
     */
    isValidSeedSync(seed: string): boolean;
    /**
     * Initialize the service with a seed phrase
     */
    initialize(seed: string): Promise<void>;
    /**
     * Get RPC URL for a chain
     */
    private getRpcUrl;
    /**
     * Get or create wallet instance for a specific chain
     */
    private getWallet;
    /**
     * Derive address for a specific chain
     */
    deriveAddress(chain: SupportedChain): Promise<ChainAddress>;
    /**
     * Derive addresses for all supported chains
     */
    deriveAllAddresses(): Promise<MultiChainAddresses>;
    /**
     * Derive addresses for specific chains only
     */
    deriveAddressesForChains(chains: SupportedChain[]): Promise<Partial<MultiChainAddresses>>;
    /**
     * Get fee rates for a specific chain
     */
    getFeeRates(chain: SupportedChain): Promise<{
        slow: string;
        medium: string;
        fast: string;
    }>;
    /**
     * Get the current network configuration
     */
    getNetwork(): 'mainnet' | 'testnet';
    /**
     * Check if service is initialized
     */
    isInitialized(): boolean;
    /**
     * Clean up and dispose of wallet instances
     */
    dispose(): void;
}
/**
 * Get or create the WDK service singleton
 */
declare function getWdkService(config?: Partial<WdkServiceConfig>): WdkService;
/**
 * Create a new WDK service instance (non-singleton)
 */
declare function createWdkService(config?: Partial<WdkServiceConfig>): WdkService;

export { type ChainAddress, type DeriveAddressResponse, type DeriveAllAddressesResponse, type GenerateSeedResponse, type MultiChainAddresses, type SupportedChain, type ValidateSeedResponse, WdkApiClient, type WdkApiConfig, WdkService, type WdkServiceConfig, createWdkService, getWdkApiClient, getWdkService };