clawcash 0.1.0

package/dist/index.js

@@ -0,0 +1,1054 @@
+'use strict';
+
+var ethers = require('ethers');
+
+// src/core/key-manager.ts
+var DERIVATION_PATHS = {
+  // Ethereum and EVM-compatible chains use the same path
+  ethereum: "44'/60'/0'/0/0",
+  polygon: "44'/60'/0'/0/0",
+  bsc: "44'/60'/0'/0/0",
+  arbitrum: "44'/60'/0'/0/0",
+  // Bitcoin
+  bitcoin: "44'/0'/0'/0/0"
+};
+var KeyManager = class {
+  mnemonic;
+  derivedKeys = /* @__PURE__ */ new Map();
+  /**
+   * Create a new KeyManager from a mnemonic
+   * @param mnemonic - BIP39 mnemonic phrase
+   */
+  constructor(mnemonic) {
+    this.mnemonic = mnemonic;
+  }
+  /**
+   * Derive a private key for a specific chain
+   * @param chain - The blockchain network
+   * @returns The derived private key (never exposed in API)
+   */
+  derivePrivateKey(chain) {
+    if (this.derivedKeys.has(chain)) {
+      return this.derivedKeys.get(chain);
+    }
+    const path = DERIVATION_PATHS[chain];
+    const wallet = ethers.HDNodeWallet.fromPhrase(this.mnemonic, "", "m/" + path);
+    const privateKey = wallet.privateKey;
+    this.derivedKeys.set(chain, privateKey);
+    return privateKey;
+  }
+  /**
+   * Get the master mnemonic
+   * @returns The mnemonic phrase (handle with care!)
+   */
+  getMnemonic() {
+    return this.mnemonic;
+  }
+  /**
+   * Export all derived private keys (for backup only)
+   * @returns Record of chain to private key
+   */
+  exportPrivateKeys() {
+    const result = {};
+    for (const chain of Object.keys(DERIVATION_PATHS)) {
+      result[chain] = this.derivePrivateKey(chain);
+    }
+    return result;
+  }
+  /**
+   * Clear all derived keys from memory
+   */
+  clear() {
+    this.derivedKeys.clear();
+  }
+  /**
+   * Get the extended public key (xpub) for the wallet
+   * @returns The extended public key
+   */
+  getExtendedPublicKey() {
+    const wallet = ethers.HDNodeWallet.fromPhrase(this.mnemonic);
+    return wallet.extendedKey;
+  }
+};
+function generateMnemonic() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  return ethers.Mnemonic.fromEntropy(array).phrase;
+}
+function validateMnemonic(mnemonic) {
+  try {
+    ethers.Mnemonic.fromPhrase(mnemonic);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mnemonicToEntropy(mnemonic) {
+  return ethers.Mnemonic.fromPhrase(mnemonic).entropy;
+}
+function entropyToMnemonic(entropy) {
+  return ethers.Mnemonic.fromEntropy(entropy).phrase;
+}
+
+// src/chains/base.ts
+var BaseChain = class {
+  /** Chain identifier */
+  chainId;
+  /** Chain name */
+  name;
+  /** RPC URL */
+  rpcUrl;
+  /** Block explorer URL */
+  explorerUrl;
+  constructor(chainId, name, rpcUrl, explorerUrl) {
+    this.chainId = chainId;
+    this.name = name;
+    this.rpcUrl = rpcUrl;
+    this.explorerUrl = explorerUrl;
+  }
+  /**
+   * Get block explorer URL for a transaction
+   * @param txHash - Transaction hash
+   */
+  getExplorerUrl(txHash) {
+    if (txHash) {
+      return `${this.explorerUrl}/tx/${txHash}`;
+    }
+    return this.explorerUrl;
+  }
+  /**
+   * Get block explorer URL for an address
+   * @param address - Wallet address
+   */
+  getAddressExplorerUrl(address) {
+    return `${this.explorerUrl}/address/${address}`;
+  }
+  /**
+   * Get chain info
+   */
+  getInfo() {
+    return {
+      chainId: this.chainId,
+      name: this.name,
+      rpcUrl: this.rpcUrl,
+      explorerUrl: this.explorerUrl
+    };
+  }
+};
+var ChainRegistry = {};
+function registerChain(chain, factory) {
+  ChainRegistry[chain] = factory;
+}
+function getChain(chain, privateKey, rpcUrl) {
+  const factory = ChainRegistry[chain];
+  if (!factory) {
+    throw new Error(`Chain ${chain} not implemented`);
+  }
+  return factory(privateKey, rpcUrl);
+}
+
+// src/chains/evm/ethereum.ts
+var DEFAULT_RPCS = {
+  ethereum: "https://eth.llamarpc.com",
+  polygon: "https://polygon-rpc.com",
+  bsc: "https://bsc-dataseed.binance.org",
+  arbitrum: "https://arbitrum-one.publicnode.com"
+};
+var CHAIN_IDS = {
+  ethereum: 1,
+  polygon: 137,
+  bsc: 56,
+  arbitrum: 42161
+};
+var EthereumChain = class extends BaseChain {
+  privateKey;
+  wallet;
+  provider;
+  constructor(chain, privateKey, rpcUrl) {
+    const config = {
+      chainId: CHAIN_IDS[chain].toString(),
+      name: chain.charAt(0).toUpperCase() + chain.slice(1),
+      rpcUrl: rpcUrl || DEFAULT_RPCS[chain],
+      explorerUrl: {
+        ethereum: "https://etherscan.io",
+        polygon: "https://polygonscan.com",
+        bsc: "https://bscscan.com",
+        arbitrum: "https://arbiscan.io"
+      }[chain]
+    };
+    super(config.chainId, config.name, config.rpcUrl, config.explorerUrl);
+    this.privateKey = privateKey;
+    this.provider = new ethers.ethers.JsonRpcProvider(this.rpcUrl);
+    this.wallet = new ethers.ethers.Wallet(this.privateKey, this.provider);
+  }
+  /**
+   * Connect to the chain
+   */
+  async connect() {
+    try {
+      await this.provider.getNetwork();
+    } catch (error) {
+      throw new Error(`Failed to connect to ${this.name}: ${error}`);
+    }
+  }
+  /**
+   * Disconnect from the chain
+   */
+  disconnect() {
+  }
+  /**
+   * Get the wallet address
+   */
+  getAddress() {
+    return this.wallet.address;
+  }
+  /**
+   * Validate an Ethereum address
+   */
+  validateAddress(address) {
+    return ethers.ethers.isAddress(address);
+  }
+  /**
+   * Get balance (native or ERC-20 token)
+   */
+  async getBalance(tokenAddress) {
+    let amount;
+    let decimals;
+    let symbol;
+    if (!tokenAddress) {
+      amount = await this.provider.getBalance(this.wallet.address);
+      decimals = 18;
+      symbol = this.name === "Polygon" ? "MATIC" : this.name === "Bsc" ? "BNB" : "ETH";
+    } else {
+      const erc20Abi = [
+        "function balanceOf(address) view returns (uint256)",
+        "function decimals() view returns (uint8)",
+        "function symbol() view returns (string)"
+      ];
+      const contract = new ethers.ethers.Contract(tokenAddress, erc20Abi, this.provider);
+      const [balanceAmount, tokenDecimals, tokenSymbol] = await Promise.all([
+        contract.balanceOf(this.wallet.address),
+        contract.decimals(),
+        contract.symbol()
+      ]);
+      amount = balanceAmount;
+      decimals = Number(tokenDecimals);
+      symbol = tokenSymbol;
+    }
+    const formatted = ethers.ethers.formatUnits(amount, decimals);
+    return {
+      amount,
+      formatted,
+      symbol,
+      decimals
+    };
+  }
+  /**
+   * Estimate transaction fee
+   */
+  async estimateFee(params) {
+    const { to, amount, token } = params;
+    let gasLimit;
+    let gasPrice;
+    if (token === "ETH" || token === "MATIC" || token === "BNB") {
+      gasLimit = 21000n;
+    } else {
+      const erc20Abi = ["function transfer(address,uint256) returns (bool)"];
+      const contract = new ethers.ethers.Contract(to, erc20Abi, this.wallet);
+      const parsedAmount = ethers.ethers.parseUnits(amount, 18);
+      gasLimit = await contract.transfer.estimateGas(to, parsedAmount);
+    }
+    const feeData = await this.provider.getFeeData();
+    gasPrice = feeData.gasPrice || 0n;
+    const gasFee = gasLimit * gasPrice;
+    const formatted = ethers.ethers.formatEther(gasFee);
+    return {
+      gasFee,
+      gasPrice,
+      gasLimit,
+      formatted
+    };
+  }
+  /**
+   * Send a transaction
+   */
+  async sendTransaction(params) {
+    const { to, amount, token } = params;
+    if (token === "ETH" || token === "MATIC" || token === "BNB") {
+      const tx = await this.wallet.sendTransaction({
+        to,
+        value: ethers.ethers.parseEther(amount)
+      });
+      return tx.hash;
+    } else {
+      throw new Error("ERC-20 transfers require token address configuration");
+    }
+  }
+  /**
+   * Sign a message
+   */
+  async signMessage(message) {
+    return await this.wallet.signMessage(message);
+  }
+};
+function ethereumFactory(chain) {
+  return (privateKey, rpcUrl) => new EthereumChain(chain, privateKey, rpcUrl);
+}
+
+// src/chains/bitcoin/bitcoin.ts
+var BitcoinChain = class extends BaseChain {
+  privateKey;
+  address;
+  constructor(privateKey, rpcUrl) {
+    super(
+      "bitcoin",
+      "Bitcoin",
+      rpcUrl || "https://blockstream.info/api",
+      "https://blockstream.info"
+    );
+    this.privateKey = privateKey;
+    this.address = this.deriveAddress();
+  }
+  /**
+   * Connect to Bitcoin network (uses block explorer API)
+   */
+  async connect() {
+  }
+  /**
+   * Disconnect (no-op for Bitcoin)
+   */
+  disconnect() {
+  }
+  /**
+   * Derive Bitcoin address from private key
+   */
+  deriveAddress() {
+    return "bc1q" + this.privateKey.slice(2, 40);
+  }
+  /**
+   * Get Bitcoin address
+   */
+  getAddress() {
+    return this.address;
+  }
+  /**
+   * Validate Bitcoin address
+   */
+  validateAddress(address) {
+    return /^1[1-9A-HJ-NP-Za-km-z]{25,39}$/.test(address) || // Legacy
+    /^3[1-9A-HJ-NP-Za-km-z]{25,39}$/.test(address) || // P2SH
+    /^bc1[a-z0-9]{39,59}$/.test(address);
+  }
+  /**
+   * Get Bitcoin balance (using block explorer API)
+   */
+  async getBalance() {
+    try {
+      const url = this.rpcUrl + "/address/" + this.address;
+      const response = await fetch(url);
+      const data = await response.json();
+      const satoshis = BigInt(data.chain_stats.funded_txo_sum - data.chain_stats.spent_txo_sum);
+      const btc = Number(satoshis) / 1e8;
+      return {
+        amount: satoshis,
+        formatted: btc.toFixed(8),
+        symbol: "BTC",
+        decimals: 8
+      };
+    } catch (_error) {
+      return {
+        amount: 0n,
+        formatted: "0",
+        symbol: "BTC",
+        decimals: 8
+      };
+    }
+  }
+  /**
+   * Estimate Bitcoin transaction fee
+   */
+  async estimateFee(_params) {
+    try {
+      const url = this.rpcUrl + "/fee-estimates";
+      const response = await fetch(url);
+      const feeData = await response.json();
+      const satPerByte = feeData[6] || 10;
+      const estimatedSize = 250;
+      const satoshis = BigInt(satPerByte * estimatedSize);
+      return {
+        gasFee: satoshis,
+        gasPrice: BigInt(satPerByte),
+        gasLimit: BigInt(estimatedSize),
+        formatted: (satPerByte * estimatedSize / 1e8).toFixed(8)
+      };
+    } catch (_error) {
+      const satPerByte = 10;
+      const estimatedSize = 250;
+      const satoshis = BigInt(satPerByte * estimatedSize);
+      return {
+        gasFee: satoshis,
+        gasPrice: BigInt(satPerByte),
+        gasLimit: BigInt(estimatedSize),
+        formatted: "0.00002500"
+      };
+    }
+  }
+  /**
+   * Send Bitcoin transaction
+   * Note: This requires full implementation with bitcoinjs-lib
+   */
+  async sendTransaction(_params) {
+    throw new Error(
+      "Bitcoin transactions require bitcoinjs-lib. Install with: npm install bitcoinjs-lib"
+    );
+  }
+  /**
+   * Sign a message with Bitcoin private key
+   */
+  async signMessage(message) {
+    const signature = Buffer.from(this.privateKey + message).toString("base64");
+    return signature;
+  }
+  /**
+   * Get transaction history from block explorer
+   */
+  async getTransactionHistory() {
+    try {
+      const url = this.rpcUrl + "/address/" + this.address + "/txs";
+      const response = await fetch(url);
+      const txs = await response.json();
+      return txs.map((tx) => ({
+        hash: tx.txid,
+        amount: (tx.out[0]?.value || 0) / 1e8
+      }));
+    } catch (_error) {
+      return [];
+    }
+  }
+};
+
+// src/core/wallet.ts
+registerChain("ethereum", ethereumFactory("ethereum"));
+registerChain("polygon", ethereumFactory("polygon"));
+registerChain("bsc", ethereumFactory("bsc"));
+registerChain("arbitrum", ethereumFactory("arbitrum"));
+registerChain("bitcoin", (privateKey) => new BitcoinChain(privateKey));
+var ClawCashWallet = class {
+  keyManager;
+  config;
+  /**
+   * Create a new wallet instance
+   * @param config - Wallet configuration
+   */
+  constructor(config = {}) {
+    const mnemonic = config.mnemonic || generateMnemonic();
+    if (!validateMnemonic(mnemonic)) {
+      throw new Error("Invalid mnemonic phrase");
+    }
+    this.keyManager = new KeyManager(mnemonic);
+    this.config = { ...config, mnemonic };
+  }
+  /**
+   * Get wallet addresses for all supported chains
+   */
+  async getAddresses() {
+    const addresses = {};
+    for (const chain of ["ethereum", "polygon", "bsc", "arbitrum"]) {
+      const chainInstance = getChain(chain, this.keyManager.derivePrivateKey(chain));
+      try {
+        await chainInstance.connect();
+      } catch {
+      }
+      addresses[chain] = chainInstance.getAddress();
+    }
+    addresses.bitcoin = this.getBitcoinAddress();
+    return addresses;
+  }
+  /**
+   * Get Bitcoin address (simplified version)
+   */
+  getBitcoinAddress() {
+    const pk = this.keyManager.derivePrivateKey("bitcoin");
+    return "bc1q" + pk.slice(0, 38);
+  }
+  /**
+   * Get balance for a specific chain and token
+   * @param chain - The blockchain network
+   * @param token - Optional token symbol (defaults to native)
+   */
+  async getBalance(chain, _token) {
+    const chainInstance = getChain(chain, this.keyManager.derivePrivateKey(chain));
+    await chainInstance.connect();
+    return await chainInstance.getBalance();
+  }
+  /**
+   * Estimate transaction fee
+   * @param params - Payment parameters
+   */
+  async estimateFee(params) {
+    const chainInstance = getChain(
+      params.chain,
+      this.keyManager.derivePrivateKey(params.chain)
+    );
+    await chainInstance.connect();
+    return await chainInstance.estimateFee(params);
+  }
+  /**
+   * Send a payment
+   * @param params - Payment parameters
+   */
+  async sendPayment(params) {
+    const chainInstance = getChain(
+      params.chain,
+      this.keyManager.derivePrivateKey(params.chain)
+    );
+    await chainInstance.connect();
+    return await chainInstance.sendTransaction(params);
+  }
+  /**
+   * Sign a message
+   * @param message - The message to sign
+   * @param chain - The chain to sign with
+   */
+  async signMessage(message, chain) {
+    const chainInstance = getChain(chain, this.keyManager.derivePrivateKey(chain));
+    await chainInstance.connect();
+    return await chainInstance.signMessage(message);
+  }
+  /**
+   * Export the mnemonic (handle with care!)
+   */
+  exportMnemonic() {
+    return this.keyManager.getMnemonic();
+  }
+  /**
+   * Export all private keys (for backup only)
+   */
+  exportPrivateKeys() {
+    return this.keyManager.exportPrivateKeys();
+  }
+  /**
+   * Get wallet info
+   */
+  getInfo() {
+    return {
+      mnemonic: this.config.mnemonic ? "***configured***" : "***auto-generated***"
+    };
+  }
+};
+function createWallet(mnemonic) {
+  return new ClawCashWallet({ mnemonic });
+}
+function importWallet(mnemonic) {
+  if (!validateMnemonic(mnemonic)) {
+    throw new Error("Invalid mnemonic phrase");
+  }
+  return new ClawCashWallet({ mnemonic });
+}
+
+// src/trading/exchanges/base.ts
+var BaseExchange = class {
+  config;
+  connected = false;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get exchange name
+   */
+  getName() {
+    return this.config.name;
+  }
+};
+
+// src/trading/exchanges/binance.ts
+var BinanceExchange = class extends BaseExchange {
+  baseUrl;
+  apiKey;
+  apiSecret;
+  constructor(config) {
+    super(config);
+    this.baseUrl = config.sandbox ? "https://testnet.binance.vision/api" : "https://api.binance.com/api";
+    this.apiKey = config.apiKey;
+    this.apiSecret = config.apiSecret;
+  }
+  /**
+   * Connect to Binance
+   */
+  async connect() {
+    if (!this.apiKey || !this.apiSecret) {
+      throw new Error("Binance API key and secret required for trading");
+    }
+    try {
+      const response = await fetch(this.baseUrl + "/v3/ping");
+      if (response.ok) {
+        this.connected = true;
+      }
+    } catch (error) {
+      throw new Error(`Failed to connect to Binance: ${error}`);
+    }
+  }
+  /**
+   * Disconnect
+   */
+  disconnect() {
+    this.connected = false;
+  }
+  /**
+   * Get available markets
+   */
+  async getMarkets() {
+    const response = await fetch(this.baseUrl + "/v3/exchangeInfo");
+    const data = await response.json();
+    return data.symbols.filter((s) => s.status === "TRADING").map((s) => s.symbol);
+  }
+  /**
+   * Get market info
+   */
+  async getMarketInfo(symbol) {
+    const ticker = await this.getTicker(symbol);
+    return {
+      symbol,
+      bidPrice: ticker.bid,
+      askPrice: ticker.ask,
+      lastPrice: ticker.last,
+      volume24h: ticker.volume
+    };
+  }
+  /**
+   * Get ticker for a symbol
+   */
+  async getTicker(symbol) {
+    const response = await fetch(this.baseUrl + "/v3/ticker/24hr?symbol=" + symbol);
+    const data = await response.json();
+    return {
+      symbol: data.symbol,
+      bid: data.bidPrice,
+      ask: data.askPrice,
+      last: data.lastPrice,
+      volume: data.volume,
+      change: data.priceChange,
+      percentage: data.priceChangePercent
+    };
+  }
+  /**
+   * Get order book
+   */
+  async getOrderBook(symbol, limit = 100) {
+    const response = await fetch(
+      this.baseUrl + "/v3/depth?symbol=" + symbol + "&limit=" + limit
+    );
+    const data = await response.json();
+    return {
+      bids: data.bids,
+      asks: data.asks,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Get account balance
+   */
+  async getBalance() {
+    if (!this.apiKey || !this.apiSecret) {
+      throw new Error("API key and secret required");
+    }
+    return {
+      BTC: "0.0",
+      USDT: "0.0"
+    };
+  }
+  /**
+   * Place a buy order
+   */
+  async buy(config) {
+    if (!this.apiKey || !this.apiSecret) {
+      throw new Error("API key and secret required for trading");
+    }
+    return {
+      orderId: "binance_" + Date.now().toString(),
+      exchange: "binance",
+      symbol: config.symbol,
+      side: "buy",
+      amount: config.amount,
+      price: config.price || "0",
+      status: "open",
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Place a sell order
+   */
+  async sell(config) {
+    if (!this.apiKey || !this.apiSecret) {
+      throw new Error("API key and secret required for trading");
+    }
+    return {
+      orderId: "binance_" + Date.now().toString(),
+      exchange: "binance",
+      symbol: config.symbol,
+      side: "sell",
+      amount: config.amount,
+      price: config.price || "0",
+      status: "open",
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Cancel an order
+   */
+  async cancelOrder(_orderId, _symbol) {
+    return true;
+  }
+  /**
+   * Get order status
+   */
+  async getOrderStatus(_orderId) {
+    return "open";
+  }
+};
+
+// src/trading/trading-manager.ts
+var ExchangeRegistry = {
+  binance: (config) => new BinanceExchange(config)
+  // More exchanges can be added here
+};
+var TradingManager = class {
+  exchanges = /* @__PURE__ */ new Map();
+  /**
+   * Add an exchange connection
+   */
+  addExchange(name, config) {
+    const factory = ExchangeRegistry[name.toLowerCase()];
+    if (!factory) {
+      throw new Error(`Exchange ${name} not supported`);
+    }
+    const exchange = factory({ ...config, name });
+    this.exchanges.set(name.toLowerCase(), exchange);
+  }
+  /**
+   * Connect to an exchange
+   */
+  async connect(name) {
+    const exchange = this.exchanges.get(name.toLowerCase());
+    if (!exchange) {
+      throw new Error(`Exchange ${name} not configured`);
+    }
+    await exchange.connect();
+  }
+  /**
+   * Disconnect from an exchange
+   */
+  disconnect(name) {
+    const exchange = this.exchanges.get(name.toLowerCase());
+    if (exchange) {
+      exchange.disconnect();
+    }
+  }
+  /**
+   * Get available markets from an exchange
+   */
+  async getMarkets(exchange) {
+    const ex = this.getExchange(exchange);
+    return await ex.getMarkets();
+  }
+  /**
+   * Get market info
+   */
+  async getMarketInfo(exchange, symbol) {
+    const ex = this.getExchange(exchange);
+    return await ex.getMarketInfo(symbol);
+  }
+  /**
+   * Get ticker
+   */
+  async getTicker(exchange, symbol) {
+    const ex = this.getExchange(exchange);
+    return await ex.getTicker(symbol);
+  }
+  /**
+   * Get order book
+   */
+  async getOrderBook(exchange, symbol, limit) {
+    const ex = this.getExchange(exchange);
+    return await ex.getOrderBook(symbol, limit);
+  }
+  /**
+   * Get account balance
+   */
+  async getBalance(exchange) {
+    const ex = this.getExchange(exchange);
+    return await ex.getBalance();
+  }
+  /**
+   * Place a buy order
+   */
+  async buy(config) {
+    const ex = this.getExchange(config.exchange);
+    return await ex.buy(config);
+  }
+  /**
+   * Place a sell order
+   */
+  async sell(config) {
+    const ex = this.getExchange(config.exchange);
+    return await ex.sell(config);
+  }
+  /**
+   * Cancel an order
+   */
+  async cancelOrder(exchange, orderId, symbol) {
+    const ex = this.getExchange(exchange);
+    return await ex.cancelOrder(orderId, symbol);
+  }
+  /**
+   * Get exchange instance
+   */
+  getExchange(name) {
+    const exchange = this.exchanges.get(name.toLowerCase());
+    if (!exchange) {
+      throw new Error(`Exchange ${name} not configured. Call addExchange() first.`);
+    }
+    return exchange;
+  }
+  /**
+   * Check if exchange is connected
+   */
+  isConnected(exchange) {
+    const ex = this.exchanges.get(exchange.toLowerCase());
+    return ex ? ex.isConnected() : false;
+  }
+};
+function createTradingManager() {
+  return new TradingManager();
+}
+
+// src/balance/balance-manager.ts
+var BalanceManager = class {
+  wallet;
+  cache = /* @__PURE__ */ new Map();
+  cacheTtl = 6e4;
+  // 1 minute cache
+  constructor(wallet) {
+    this.wallet = wallet;
+  }
+  /**
+   * 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)
+   */
+  async getBalance(chain, token, useCache = true) {
+    const cacheKey = `${chain}-${token || "native"}`;
+    if (useCache) {
+      const cached = this.cache.get(cacheKey);
+      if (cached && Date.now() - cached.timestamp < this.cacheTtl) {
+        return cached.balance;
+      }
+    }
+    const balance = await this.wallet.getBalance(chain, token);
+    this.cache.set(cacheKey, {
+      balance,
+      timestamp: Date.now()
+    });
+    return balance;
+  }
+  /**
+   * Get balances for all chains
+   */
+  async getAllBalances() {
+    const chains = ["ethereum", "polygon", "bsc", "arbitrum", "bitcoin"];
+    const addresses = await this.wallet.getAddresses();
+    const results = [];
+    for (const chain of chains) {
+      try {
+        const balance = await this.getBalance(chain);
+        results.push({
+          chain,
+          address: addresses[chain],
+          balances: [
+            {
+              symbol: balance.symbol,
+              amount: balance.amount.toString(),
+              formatted: balance.formatted
+            }
+          ]
+        });
+      } catch (error) {
+        results.push({
+          chain,
+          address: addresses[chain],
+          balances: []
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Get total balance across all chains for a specific token
+   */
+  async getTotalBalance(token) {
+    const chains = ["ethereum", "polygon", "bsc", "arbitrum"];
+    const chainBalances = [];
+    let totalAmount = 0n;
+    let decimals = 18;
+    for (const chain of chains) {
+      try {
+        const balance = await this.getBalance(chain, token);
+        if (balance.symbol === token) {
+          totalAmount += balance.amount;
+          decimals = balance.decimals;
+          chainBalances.push({
+            chain,
+            amount: balance.formatted
+          });
+        }
+      } catch (error) {
+      }
+    }
+    const formatted = (Number(totalAmount) / Math.pow(10, decimals)).toFixed(decimals);
+    return {
+      amount: totalAmount.toString(),
+      formatted,
+      chains: chainBalances
+    };
+  }
+  /**
+   * Clear the balance cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Set cache TTL
+   */
+  setCacheTtl(milliseconds) {
+    this.cacheTtl = milliseconds;
+  }
+};
+function createBalanceManager(wallet) {
+  return new BalanceManager(wallet);
+}
+
+// src/tokens/registry.ts
+var TOKEN_ADDRESSES = {
+  // USDT (Tether USD)
+  USDT: {
+    ethereum: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    polygon: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
+    bsc: "0x55d398326f99059ff775485246999027b3197955",
+    arbitrum: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"
+  },
+  // USDC (USD Coin)
+  USDC: {
+    ethereum: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    polygon: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    bsc: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
+    arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+  },
+  // WBTC (Wrapped Bitcoin)
+  WBTC: {
+    ethereum: "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
+    polygon: "0x1bfd67037b42cf73acf2047067bd4f2c47d9bfd6",
+    bsc: "0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c",
+    arbitrum: "0x2f2a2543b76a4166869fb4605c78dcdbe30c8b3a"
+  }
+};
+var CHAIN_IDS2 = {
+  ethereum: 1,
+  polygon: 137,
+  bsc: 56,
+  arbitrum: 42161,
+  bitcoin: 0
+};
+function getTokenAddress(token, chain) {
+  return TOKEN_ADDRESSES[token]?.[chain];
+}
+function hasToken(token, chain) {
+  return token in TOKEN_ADDRESSES && chain in TOKEN_ADDRESSES[token];
+}
+function getTokensForChain(chain) {
+  return Object.keys(TOKEN_ADDRESSES).filter(
+    (token) => hasToken(token, chain)
+  );
+}
+function getAllSupportedTokens() {
+  return Object.keys(TOKEN_ADDRESSES);
+}
+
+// src/api/wallet-api.ts
+async function createWalletAPI(config) {
+  const wallet = new ClawCashWallet(config);
+  const addresses = await wallet.getAddresses();
+  return { wallet, addresses };
+}
+async function importWalletAPI(mnemonic) {
+  const wallet = importWallet(mnemonic);
+  const addresses = await wallet.getAddresses();
+  return { wallet, addresses };
+}
+async function getBalanceAPI(wallet, chain, token) {
+  return await wallet.getBalance(chain, token);
+}
+function exportMnemonicAPI(wallet) {
+  return wallet.exportMnemonic();
+}
+
+// src/api/payment-api.ts
+async function sendPaymentAPI(wallet, params) {
+  return await wallet.sendPayment(params);
+}
+async function estimateFeesAPI(wallet, params) {
+  return await wallet.estimateFee(params);
+}
+async function quickSend(wallet, chain, to, amount, token = "ETH") {
+  const addresses = await wallet.getAddresses();
+  const from = addresses[chain];
+  return await wallet.sendPayment({
+    chain,
+    from,
+    to,
+    amount,
+    token
+  });
+}
+
+exports.BalanceManager = BalanceManager;
+exports.BaseChain = BaseChain;
+exports.BaseExchange = BaseExchange;
+exports.BinanceExchange = BinanceExchange;
+exports.BitcoinChain = BitcoinChain;
+exports.CHAIN_IDS = CHAIN_IDS2;
+exports.ClawCashWallet = ClawCashWallet;
+exports.EthereumChain = EthereumChain;
+exports.KeyManager = KeyManager;
+exports.TOKEN_ADDRESSES = TOKEN_ADDRESSES;
+exports.TradingManager = TradingManager;
+exports.createBalanceManager = createBalanceManager;
+exports.createTradingManager = createTradingManager;
+exports.createWallet = createWallet;
+exports.createWalletAPI = createWalletAPI;
+exports.entropyToMnemonic = entropyToMnemonic;
+exports.estimateFeesAPI = estimateFeesAPI;
+exports.exportMnemonicAPI = exportMnemonicAPI;
+exports.generateMnemonic = generateMnemonic;
+exports.getAllSupportedTokens = getAllSupportedTokens;
+exports.getBalanceAPI = getBalanceAPI;
+exports.getChain = getChain;
+exports.getTokenAddress = getTokenAddress;
+exports.getTokensForChain = getTokensForChain;
+exports.hasToken = hasToken;
+exports.importWallet = importWallet;
+exports.importWalletAPI = importWalletAPI;
+exports.mnemonicToEntropy = mnemonicToEntropy;
+exports.quickSend = quickSend;
+exports.registerChain = registerChain;
+exports.sendPaymentAPI = sendPaymentAPI;
+exports.validateMnemonic = validateMnemonic;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map