clawcash 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,918 @@
+/**
+ * Core type definitions for ClawCash wallet
+ */
+/**
+ * Supported blockchain networks
+ */
+type Chain = 'ethereum' | 'polygon' | 'bsc' | 'arbitrum' | 'bitcoin';
+/**
+ * Supported token symbols
+ */
+type TokenSymbol = 'ETH' | 'BTC' | 'MATIC' | 'BNB' | 'USDT' | 'USDC';
+/**
+ * Wallet configuration options
+ */
+interface WalletConfig {
+    /** BIP39 mnemonic phrase (if not provided, a new one will be generated) */
+    mnemonic?: string;
+    /** Password for encrypting private keys */
+    password?: string;
+    /** Custom RPC endpoints for each chain */
+    rpcUrls?: Partial<Record<Chain, string>>;
+}
+/**
+ * Wallet addresses for all supported chains
+ */
+interface WalletAddresses {
+    ethereum: string;
+    polygon: string;
+    bsc: string;
+    arbitrum: string;
+    bitcoin: string;
+}
+/**
+ * Token configuration
+ */
+interface TokenConfig {
+    symbol: TokenSymbol;
+    decimals: number;
+    address?: string;
+    chainId: number;
+}
+/**
+ * Chain configuration
+ */
+interface ChainConfig {
+    chainId: number;
+    name: string;
+    rpcUrl: string;
+    explorerUrl: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+}
+/**
+ * Balance information
+ */
+interface Balance {
+    amount: bigint;
+    formatted: string;
+    symbol: TokenSymbol;
+    decimals: number;
+}
+/**
+ * Payment/transfer parameters
+ */
+interface PaymentParams {
+    /** Source chain */
+    chain: Chain;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Amount to send (as decimal string) */
+    amount: string;
+    /** Token symbol (e.g., 'ETH', 'USDT') */
+    token: TokenSymbol;
+    /** Optional gas price for EVM chains */
+    gasPrice?: string;
+    /** Optional gas limit for EVM chains */
+    gasLimit?: string;
+}
+/**
+ * Transaction result
+ */
+interface TransactionResult {
+    /** Transaction hash */
+    hash: string;
+    /** Block number (if confirmed) */
+    blockNumber?: number;
+    /** Transaction status */
+    status: 'pending' | 'confirmed' | 'failed';
+    /** Explorer URL */
+    explorerUrl?: string;
+}
+/**
+ * Fee estimate for a transaction
+ */
+interface FeeEstimate {
+    /** Estimated gas fee in wei */
+    gasFee: bigint;
+    /** Estimated gas price */
+    gasPrice: bigint;
+    /** Estimated gas limit */
+    gasLimit: bigint;
+    /** Total fee formatted */
+    formatted: string;
+}
+/**
+ * Transaction history entry
+ */
+interface Transaction {
+    hash: string;
+    from: string;
+    to: string;
+    amount: bigint;
+    formatted: string;
+    symbol: TokenSymbol;
+    timestamp: number;
+    blockNumber?: number;
+    status: 'pending' | 'confirmed' | 'failed';
+}
+/**
+ * Trade configuration (for exchange trading)
+ */
+interface TradeConfig {
+    /** Exchange name (e.g., 'binance', 'coinbase') */
+    exchange: string;
+    /** Trading pair (e.g., 'BTC/USDT') */
+    symbol: string;
+    /** Amount to trade */
+    amount: string;
+    /** Limit price (undefined for market order) */
+    price?: string;
+    /** Order type */
+    type?: 'market' | 'limit';
+}
+/**
+ * Trade result
+ */
+interface TradeResult {
+    /** Order ID */
+    orderId: string;
+    /** Exchange name */
+    exchange: string;
+    /** Trading pair */
+    symbol: string;
+    /** Side (buy/sell) */
+    side: 'buy' | 'sell';
+    /** Amount traded */
+    amount: string;
+    /** Price */
+    price: string;
+    /** Order status */
+    status: 'open' | 'filled' | 'canceled';
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Market information
+ */
+interface MarketInfo {
+    symbol: string;
+    bidPrice: string;
+    askPrice: string;
+    lastPrice: string;
+    volume24h: string;
+}
+/**
+ * Agent-friendly error class
+ */
+declare class AgentError extends Error {
+    code: string;
+    suggestion?: string | undefined;
+    constructor(message: string, code: string, suggestion?: string | undefined);
+}
+/**
+ * Result wrapper for agent operations
+ */
+interface AgentResult<T = void> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    code?: string;
+}
+
+/**
+ * Main ClawCash Wallet class
+ * Orchestrates all wallet functionality across multiple chains
+ */
+
+/**
+ * Main ClawCash wallet class
+ */
+declare class ClawCashWallet {
+    private keyManager;
+    private config;
+    /**
+     * Create a new wallet instance
+     * @param config - Wallet configuration
+     */
+    constructor(config?: WalletConfig);
+    /**
+     * Get wallet addresses for all supported chains
+     */
+    getAddresses(): Promise<WalletAddresses>;
+    /**
+     * Get Bitcoin address (simplified version)
+     */
+    private getBitcoinAddress;
+    /**
+     * Get balance for a specific chain and token
+     * @param chain - The blockchain network
+     * @param token - Optional token symbol (defaults to native)
+     */
+    getBalance(chain: Chain, _token?: TokenSymbol): Promise<Balance>;
+    /**
+     * Estimate transaction fee
+     * @param params - Payment parameters
+     */
+    estimateFee(params: PaymentParams): Promise<FeeEstimate>;
+    /**
+     * Send a payment
+     * @param params - Payment parameters
+     */
+    sendPayment(params: PaymentParams): Promise<string>;
+    /**
+     * Sign a message
+     * @param message - The message to sign
+     * @param chain - The chain to sign with
+     */
+    signMessage(message: string, chain: Chain): Promise<string>;
+    /**
+     * Export the mnemonic (handle with care!)
+     */
+    exportMnemonic(): string;
+    /**
+     * Export all private keys (for backup only)
+     */
+    exportPrivateKeys(): Record<Chain, string>;
+    /**
+     * Get wallet info
+     */
+    getInfo(): {
+        mnemonic: string;
+    };
+}
+/**
+ * Create a new wallet
+ * @param mnemonic - Optional mnemonic phrase
+ */
+declare function createWallet(mnemonic?: string): ClawCashWallet;
+/**
+ * Import a wallet from mnemonic
+ * @param mnemonic - BIP39 mnemonic phrase
+ */
+declare function importWallet(mnemonic: string): ClawCashWallet;
+
+/**
+ * Key management for ClawCash wallet
+ * Handles BIP-32/BIP-44 key derivation for multiple chains
+ */
+
+/**
+ * Key manager for handling private key derivation
+ */
+declare class KeyManager {
+    private mnemonic;
+    private derivedKeys;
+    /**
+     * Create a new KeyManager from a mnemonic
+     * @param mnemonic - BIP39 mnemonic phrase
+     */
+    constructor(mnemonic: string);
+    /**
+     * Derive a private key for a specific chain
+     * @param chain - The blockchain network
+     * @returns The derived private key (never exposed in API)
+     */
+    derivePrivateKey(chain: Chain): string;
+    /**
+     * Get the master mnemonic
+     * @returns The mnemonic phrase (handle with care!)
+     */
+    getMnemonic(): string;
+    /**
+     * Export all derived private keys (for backup only)
+     * @returns Record of chain to private key
+     */
+    exportPrivateKeys(): Record<Chain, string>;
+    /**
+     * Clear all derived keys from memory
+     */
+    clear(): void;
+    /**
+     * Get the extended public key (xpub) for the wallet
+     * @returns The extended public key
+     */
+    getExtendedPublicKey(): string;
+}
+
+/**
+ * BIP39 Mnemonic generation and validation
+ * Uses ethers.js which has built-in BIP39 support
+ */
+/**
+ * Generate a new BIP39 mnemonic phrase
+ * @returns 12 word mnemonic phrase
+ */
+declare function generateMnemonic(): string;
+/**
+ * Validate a mnemonic phrase
+ * @param mnemonic - The mnemonic phrase to validate
+ * @returns True if valid
+ */
+declare function validateMnemonic(mnemonic: string): boolean;
+/**
+ * Get the entropy from a mnemonic (for backup/encryption)
+ * @param mnemonic - The mnemonic phrase
+ * @returns The entropy as a hex string
+ */
+declare function mnemonicToEntropy(mnemonic: string): string;
+/**
+ * Create mnemonic from entropy
+ * @param entropy - The entropy hex string
+ * @returns The mnemonic phrase
+ */
+declare function entropyToMnemonic(entropy: string): string;
+
+/**
+ * Base chain interface for all blockchain implementations
+ */
+
+/**
+ * Abstract base class for all chain implementations
+ */
+declare abstract class BaseChain {
+    /** Chain identifier */
+    readonly chainId: string;
+    /** Chain name */
+    readonly name: string;
+    /** RPC URL */
+    protected rpcUrl: string;
+    /** Block explorer URL */
+    protected explorerUrl: string;
+    constructor(chainId: string, name: string, rpcUrl: string, explorerUrl: string);
+    /**
+     * Connect to the chain (establish provider connection)
+     */
+    abstract connect(): Promise<void>;
+    /**
+     * Disconnect from the chain
+     */
+    abstract disconnect(): void;
+    /**
+     * Get the wallet address for this chain
+     */
+    abstract getAddress(): string;
+    /**
+     * Validate an address format for this chain
+     * @param address - The address to validate
+     */
+    abstract validateAddress(address: string): boolean;
+    /**
+     * Get balance for native or token
+     * @param tokenAddress - Optional token address (undefined for native)
+     */
+    abstract getBalance(tokenAddress?: string): Promise<Balance>;
+    /**
+     * Estimate transaction fee
+     * @param params - Payment parameters
+     */
+    abstract estimateFee(params: PaymentParams): Promise<FeeEstimate>;
+    /**
+     * Send a transaction
+     * @param params - Payment parameters
+     */
+    abstract sendTransaction(params: PaymentParams): Promise<string>;
+    /**
+     * Sign a message
+     * @param message - The message to sign
+     */
+    abstract signMessage(message: string): Promise<string>;
+    /**
+     * Get block explorer URL for a transaction
+     * @param txHash - Transaction hash
+     */
+    getExplorerUrl(txHash?: string): string;
+    /**
+     * Get block explorer URL for an address
+     * @param address - Wallet address
+     */
+    getAddressExplorerUrl(address: string): string;
+    /**
+     * Get chain info
+     */
+    getInfo(): {
+        chainId: string;
+        name: string;
+        rpcUrl: string;
+        explorerUrl: string;
+    };
+}
+/**
+ * Chain factory type
+ */
+type ChainFactory = (privateKey: string, rpcUrl?: string) => BaseChain;
+/**
+ * Register a chain implementation
+ */
+declare function registerChain(chain: Chain, factory: ChainFactory): void;
+/**
+ * Get a chain instance
+ */
+declare function getChain(chain: Chain, privateKey: string, rpcUrl?: string): BaseChain;
+
+/**
+ * Ethereum chain implementation using ethers.js v6
+ */
+
+/**
+ * Ethereum chain implementation
+ */
+declare class EthereumChain extends BaseChain {
+    private privateKey;
+    private wallet;
+    private provider;
+    constructor(chain: 'ethereum' | 'polygon' | 'bsc' | 'arbitrum', privateKey: string, rpcUrl?: string);
+    /**
+     * Connect to the chain
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the chain
+     */
+    disconnect(): void;
+    /**
+     * Get the wallet address
+     */
+    getAddress(): string;
+    /**
+     * Validate an Ethereum address
+     */
+    validateAddress(address: string): boolean;
+    /**
+     * Get balance (native or ERC-20 token)
+     */
+    getBalance(tokenAddress?: string): Promise<Balance>;
+    /**
+     * Estimate transaction fee
+     */
+    estimateFee(params: PaymentParams): Promise<FeeEstimate>;
+    /**
+     * Send a transaction
+     */
+    sendTransaction(params: PaymentParams): Promise<string>;
+    /**
+     * Sign a message
+     */
+    signMessage(message: string): Promise<string>;
+}
+
+/**
+ * Bitcoin chain implementation
+ * Note: This is a simplified implementation. For production, use bitcoinjs-lib
+ */
+
+/**
+ * Bitcoin chain implementation
+ */
+declare class BitcoinChain extends BaseChain {
+    private privateKey;
+    private address;
+    constructor(privateKey: string, rpcUrl?: string);
+    /**
+     * Connect to Bitcoin network (uses block explorer API)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect (no-op for Bitcoin)
+     */
+    disconnect(): void;
+    /**
+     * Derive Bitcoin address from private key
+     */
+    private deriveAddress;
+    /**
+     * Get Bitcoin address
+     */
+    getAddress(): string;
+    /**
+     * Validate Bitcoin address
+     */
+    validateAddress(address: string): boolean;
+    /**
+     * Get Bitcoin balance (using block explorer API)
+     */
+    getBalance(): Promise<Balance>;
+    /**
+     * Estimate Bitcoin transaction fee
+     */
+    estimateFee(_params: PaymentParams): Promise<FeeEstimate>;
+    /**
+     * Send Bitcoin transaction
+     * Note: This requires full implementation with bitcoinjs-lib
+     */
+    sendTransaction(_params: PaymentParams): Promise<string>;
+    /**
+     * Sign a message with Bitcoin private key
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Get transaction history from block explorer
+     */
+    getTransactionHistory(): Promise<Array<{
+        hash: string;
+        amount: number;
+    }>>;
+}
+
+/**
+ * Trading module types
+ */
+
+/**
+ * Exchange configuration
+ */
+interface ExchangeConfig {
+    name: string;
+    apiKey?: string;
+    apiSecret?: string;
+    passphrase?: string;
+    sandbox?: boolean;
+}
+/**
+ * Order book data
+ */
+interface OrderBook {
+    bids: [string, string][];
+    asks: [string, string][];
+    timestamp: number;
+}
+/**
+ * Ticker data
+ */
+interface Ticker {
+    symbol: string;
+    bid: string;
+    ask: string;
+    last: string;
+    volume: string;
+    change: string;
+    percentage: string;
+}
+/**
+ * Order status
+ */
+type OrderStatus = 'open' | 'closed' | 'canceled' | 'rejected';
+
+/**
+ * Base exchange adapter interface
+ */
+
+/**
+ * Abstract base class for exchange adapters
+ */
+declare abstract class BaseExchange {
+    protected config: ExchangeConfig;
+    protected connected: boolean;
+    constructor(config: ExchangeConfig);
+    /**
+     * Connect to the exchange
+     */
+    abstract connect(): Promise<void>;
+    /**
+     * Disconnect from the exchange
+     */
+    abstract disconnect(): void;
+    /**
+     * Get available markets/trading pairs
+     */
+    abstract getMarkets(): Promise<string[]>;
+    /**
+     * Get market info for a symbol
+     */
+    abstract getMarketInfo(symbol: string): Promise<MarketInfo>;
+    /**
+     * Get ticker for a symbol
+     */
+    abstract getTicker(symbol: string): Promise<Ticker>;
+    /**
+     * Get order book for a symbol
+     */
+    abstract getOrderBook(symbol: string, limit?: number): Promise<OrderBook>;
+    /**
+     * Get account balance
+     */
+    abstract getBalance(): Promise<Record<string, string>>;
+    /**
+     * Place a buy order
+     */
+    abstract buy(config: TradeConfig): Promise<TradeResult>;
+    /**
+     * Place a sell order
+     */
+    abstract sell(config: TradeConfig): Promise<TradeResult>;
+    /**
+     * Cancel an order
+     */
+    abstract cancelOrder(orderId: string, symbol?: string): Promise<boolean>;
+    /**
+     * Get order status
+     */
+    abstract getOrderStatus(orderId: string): Promise<OrderStatus>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get exchange name
+     */
+    getName(): string;
+}
+
+/**
+ * Trading manager for handling exchange operations
+ */
+
+/**
+ * Trading manager class
+ */
+declare class TradingManager {
+    private exchanges;
+    /**
+     * Add an exchange connection
+     */
+    addExchange(name: string, config: ExchangeConfig): void;
+    /**
+     * Connect to an exchange
+     */
+    connect(name: string): Promise<void>;
+    /**
+     * Disconnect from an exchange
+     */
+    disconnect(name: string): void;
+    /**
+     * Get available markets from an exchange
+     */
+    getMarkets(exchange: string): Promise<string[]>;
+    /**
+     * Get market info
+     */
+    getMarketInfo(exchange: string, symbol: string): Promise<MarketInfo>;
+    /**
+     * Get ticker
+     */
+    getTicker(exchange: string, symbol: string): Promise<Ticker>;
+    /**
+     * Get order book
+     */
+    getOrderBook(exchange: string, symbol: string, limit?: number): Promise<OrderBook>;
+    /**
+     * Get account balance
+     */
+    getBalance(exchange: string): Promise<Record<string, string>>;
+    /**
+     * Place a buy order
+     */
+    buy(config: TradeConfig): Promise<TradeResult>;
+    /**
+     * Place a sell order
+     */
+    sell(config: TradeConfig): Promise<TradeResult>;
+    /**
+     * Cancel an order
+     */
+    cancelOrder(exchange: string, orderId: string, symbol?: string): Promise<boolean>;
+    /**
+     * Get exchange instance
+     */
+    private getExchange;
+    /**
+     * Check if exchange is connected
+     */
+    isConnected(exchange: string): boolean;
+}
+/**
+ * Create a new trading manager
+ */
+declare function createTradingManager(): TradingManager;
+
+/**
+ * Binance exchange adapter
+ * Note: This is a simplified implementation using public APIs
+ * For full trading functionality, integrate with CCXT library
+ */
+
+/**
+ * Binance exchange adapter
+ */
+declare class BinanceExchange extends BaseExchange {
+    private baseUrl;
+    private apiKey?;
+    private apiSecret?;
+    constructor(config: ExchangeConfig);
+    /**
+     * Connect to Binance
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect
+     */
+    disconnect(): void;
+    /**
+     * Get available markets
+     */
+    getMarkets(): Promise<string[]>;
+    /**
+     * Get market info
+     */
+    getMarketInfo(symbol: string): Promise<MarketInfo>;
+    /**
+     * Get ticker for a symbol
+     */
+    getTicker(symbol: string): Promise<Ticker>;
+    /**
+     * Get order book
+     */
+    getOrderBook(symbol: string, limit?: number): Promise<OrderBook>;
+    /**
+     * Get account balance
+     */
+    getBalance(): Promise<Record<string, string>>;
+    /**
+     * Place a buy order
+     */
+    buy(config: TradeConfig): Promise<TradeResult>;
+    /**
+     * Place a sell order
+     */
+    sell(config: TradeConfig): Promise<TradeResult>;
+    /**
+     * Cancel an order
+     */
+    cancelOrder(_orderId: string, _symbol?: string): Promise<boolean>;
+    /**
+     * Get order status
+     */
+    getOrderStatus(_orderId: string): Promise<OrderStatus>;
+}
+
+/**
+ * Balance manager for tracking balances across chains
+ */
+
+/**
+ * Balance summary across all chains
+ */
+interface BalanceSummary {
+    chain: Chain;
+    address: string;
+    balances: Array<{
+        symbol: TokenSymbol;
+        amount: string;
+        formatted: string;
+    }>;
+    totalValueUsd?: string;
+}
+/**
+ * Balance manager class
+ */
+declare class BalanceManager {
+    private wallet;
+    private cache;
+    private cacheTtl;
+    constructor(wallet: ClawCashWallet);
+    /**
+     * Get balance for a specific chain
+     * @param chain - The blockchain network
+     * @param token - Optional token symbol
+     * @param useCache - Whether to use cached balance (default: true)
+     */
+    getBalance(chain: Chain, token?: TokenSymbol, useCache?: boolean): Promise<Balance>;
+    /**
+     * Get balances for all chains
+     */
+    getAllBalances(): Promise<BalanceSummary[]>;
+    /**
+     * Get total balance across all chains for a specific token
+     */
+    getTotalBalance(token: TokenSymbol): Promise<{
+        amount: string;
+        formatted: string;
+        chains: Array<{
+            chain: Chain;
+            amount: string;
+        }>;
+    }>;
+    /**
+     * Clear the balance cache
+     */
+    clearCache(): void;
+    /**
+     * Set cache TTL
+     */
+    setCacheTtl(milliseconds: number): void;
+}
+/**
+ * Create a balance manager
+ */
+declare function createBalanceManager(wallet: ClawCashWallet): BalanceManager;
+
+/**
+ * Token address registry for multi-chain tokens
+ */
+
+/**
+ * Token configuration
+ */
+interface TokenInfo {
+    symbol: TokenSymbol;
+    name: string;
+    decimals: number;
+    address: string;
+    chainId: number;
+}
+/**
+ * Token addresses across chains
+ */
+declare const TOKEN_ADDRESSES: Record<string, Partial<Record<Chain, string>>>;
+/**
+ * Chain IDs
+ */
+declare const CHAIN_IDS: Record<Chain, number>;
+/**
+ * Get token address for a chain
+ */
+declare function getTokenAddress(token: string, chain: Chain): string | undefined;
+/**
+ * Check if token exists on chain
+ */
+declare function hasToken(token: string, chain: Chain): boolean;
+/**
+ * Get all tokens for a chain
+ */
+declare function getTokensForChain(chain: Chain): string[];
+/**
+ * Get all supported tokens
+ */
+declare function getAllSupportedTokens(): string[];
+
+/**
+ * Public Wallet API
+ * Simple, agent-friendly functions for wallet operations
+ */
+
+/**
+ * Create a new wallet
+ * @param config - Optional wallet configuration
+ * @returns Wallet addresses for all supported chains
+ */
+declare function createWalletAPI(config?: WalletConfig): Promise<{
+    wallet: ClawCashWallet;
+    addresses: WalletAddresses;
+}>;
+/**
+ * Import a wallet from mnemonic
+ * @param mnemonic - BIP39 mnemonic phrase
+ * @returns Wallet addresses for all supported chains
+ */
+declare function importWalletAPI(mnemonic: string): Promise<{
+    wallet: ClawCashWallet;
+    addresses: WalletAddresses;
+}>;
+/**
+ * Get wallet balance
+ * @param wallet - The wallet instance
+ * @param chain - The blockchain network
+ * @param token - Optional token symbol
+ */
+declare function getBalanceAPI(wallet: ClawCashWallet, chain: Chain, token?: TokenSymbol): Promise<Balance>;
+/**
+ * Export wallet mnemonic (use carefully!)
+ * @param wallet - The wallet instance
+ */
+declare function exportMnemonicAPI(wallet: ClawCashWallet): string;
+
+/**
+ * Public Payment API
+ * Simple, agent-friendly functions for payments
+ */
+
+/**
+ * Send a payment
+ * @param wallet - The wallet instance
+ * @param params - Payment parameters
+ * @returns Transaction hash
+ */
+declare function sendPaymentAPI(wallet: ClawCashWallet, params: PaymentParams): Promise<string>;
+/**
+ * Estimate transaction fee
+ * @param wallet - The wallet instance
+ * @param params - Payment parameters
+ * @returns Fee estimate
+ */
+declare function estimateFeesAPI(wallet: ClawCashWallet, params: PaymentParams): Promise<FeeEstimate>;
+/**
+ * Quick payment - simplified interface
+ * @param wallet - The wallet instance
+ * @param chain - The blockchain network
+ * @param to - Recipient address
+ * @param amount - Amount to send (as decimal string)
+ * @param token - Token symbol (defaults to native)
+ */
+declare function quickSend(wallet: ClawCashWallet, chain: 'ethereum' | 'polygon' | 'bsc' | 'arbitrum', to: string, amount: string, token?: 'ETH' | 'MATIC' | 'BNB'): Promise<string>;
+
+export { AgentError, type AgentResult, type Balance, BalanceManager, type BalanceSummary, BaseChain, BaseExchange, BinanceExchange, BitcoinChain, CHAIN_IDS, type Chain, type ChainConfig, ClawCashWallet, EthereumChain, type ExchangeConfig, type FeeEstimate, KeyManager, type MarketInfo, type OrderBook, type OrderStatus, type PaymentParams, TOKEN_ADDRESSES, type Ticker, type TokenConfig, type TokenInfo, type TokenSymbol, type TradeConfig, type TradeResult, TradingManager, type Transaction, type TransactionResult, type WalletAddresses, type WalletConfig, createBalanceManager, createTradingManager, createWallet, createWalletAPI, entropyToMnemonic, estimateFeesAPI, exportMnemonicAPI, generateMnemonic, getAllSupportedTokens, getBalanceAPI, getChain, getTokenAddress, getTokensForChain, hasToken, importWallet, importWalletAPI, mnemonicToEntropy, quickSend, registerChain, sendPaymentAPI, validateMnemonic };