@zubari/sdk 0.4.5 → 0.5.1

package/dist/index.mjs

@@ -5,7 +5,7 @@ import { HDKey } from '@scure/bip32';
 import { bech32, base58check } from '@scure/base';
 import { sha256 } from '@noble/hashes/sha256';
 import { ripemd160 } from '@noble/hashes/ripemd160';
-import { createPublicClient, http, formatEther } from 'viem';
+import { createPublicClient, http, formatEther, getAddress } from 'viem';
 import { mainnet, sepolia } from 'viem/chains';
 
 var __defProp = Object.defineProperty;
@@ -119,6 +119,38 @@ var TESTNET_NETWORKS = {
     name: "Solana Devnet",
     rpcUrl: "https://api.devnet.solana.com",
     explorerUrl: "https://solscan.io?cluster=devnet"
+  },
+  tron: {
+    name: "TRON Nile Testnet",
+    chainId: 3448148188,
+    rpcUrl: "https://nile.trongrid.io",
+    explorerUrl: "https://nile.tronscan.org"
+  },
+  ton: {
+    name: "TON Testnet",
+    rpcUrl: "https://testnet.toncenter.com/api/v2",
+    explorerUrl: "https://testnet.tonscan.org"
+  }
+};
+var USDT_ADDRESSES = {
+  ethereum: {
+    mainnet: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    testnet: "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06"
+    // Sepolia (Test Tether USD)
+  },
+  tron: {
+    mainnet: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+    testnet: "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf"
+    // Nile testnet
+  },
+  solana: {
+    mainnet: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    testnet: ""
+    // No official USDT on devnet
+  },
+  ton: {
+    mainnet: "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",
+    testnet: "kQD0GKBM8ZbryVk2aESmzfU6b9b_8era_IkvBSELujFZPsyy"
   }
 };
 var DERIVATION_PATHS = {
@@ -282,8 +314,8 @@ var NFT_VOUCHER_TYPES = {
 var CURRENCY_ADDRESSES = {
   testnet: {
     ETH: ZERO_ADDRESS,
-    USDT: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0"
-    // USDT on Sepolia
+    USDT: "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06"
+    // USDT on Sepolia (Test Tether USD)
   },
   mainnet: {
     ETH: ZERO_ADDRESS,
@@ -742,6 +774,60 @@ function generateSeedPhrase() {
 
 // src/services/ZubariWdkService.ts
 var DEFAULT_API_URL2 = "https://ckgwifsxka.us-east-2.awsapprunner.com";
+var CHAIN_ERROR_MESSAGES = {
+  ethereum: {
+    "insufficient funds": "INSUFFICIENT_FUNDS",
+    "nonce too low": "NONCE_TOO_LOW",
+    "gas too low": "GAS_TOO_LOW",
+    "replacement transaction underpriced": "GAS_TOO_LOW",
+    "transaction underpriced": "GAS_TOO_LOW",
+    "invalid address": "INVALID_ADDRESS"
+  },
+  bitcoin: {
+    "insufficient funds": "INSUFFICIENT_FUNDS",
+    "dust": "DUST_AMOUNT",
+    "mempool": "MEMPOOL_FULL",
+    "invalid address": "INVALID_ADDRESS"
+  },
+  solana: {
+    "insufficient funds": "INSUFFICIENT_FUNDS",
+    "invalid account": "INVALID_ADDRESS",
+    "blockhash not found": "NETWORK_ERROR"
+  },
+  ton: {
+    "insufficient funds": "INSUFFICIENT_FUNDS",
+    "invalid address": "INVALID_ADDRESS"
+  },
+  tron: {
+    "insufficient funds": "INSUFFICIENT_FUNDS",
+    "invalid address": "INVALID_ADDRESS",
+    "bandwidth": "GAS_TOO_LOW"
+  },
+  spark: {
+    "insufficient funds": "INSUFFICIENT_FUNDS",
+    "invoice expired": "TIMEOUT",
+    "no route": "NETWORK_ERROR"
+  }
+};
+function parseChainError(chain, errorMessage) {
+  const errorLower = errorMessage.toLowerCase();
+  const chainErrors = CHAIN_ERROR_MESSAGES[chain];
+  for (const [pattern, code] of Object.entries(chainErrors)) {
+    if (errorLower.includes(pattern)) {
+      return code;
+    }
+  }
+  if (errorLower.includes("timeout") || errorLower.includes("timed out")) {
+    return "TIMEOUT";
+  }
+  if (errorLower.includes("network") || errorLower.includes("connection")) {
+    return "NETWORK_ERROR";
+  }
+  if (errorLower.includes("rejected") || errorLower.includes("denied")) {
+    return "REJECTED";
+  }
+  return "UNKNOWN";
+}
 function isBrowser() {
   return typeof window !== "undefined" && typeof window.document !== "undefined";
 }
@@ -1016,47 +1102,117 @@ var ZubariWdkService = class {
     return { fee: "0", symbol: this.getChainSymbol(chain) };
   }
   /**
-   * Send a transaction
+   * Send a transaction on any supported chain
+   *
+   * @param seed - BIP-39 seed phrase
+   * @param chain - Target blockchain (ethereum, bitcoin, solana, ton, tron, spark)
+   * @param to - Recipient address
+   * @param amount - Amount to send (in native units: ETH, BTC, SOL, etc.)
+   * @returns Transaction result with hash on success, or error details on failure
    */
   async sendTransaction(seed, chain, to, amount) {
     await this.initialize();
+    const startTime = Date.now();
+    console.log(`[ZubariWdkService] Sending ${chain} transaction`, {
+      to: `${to.slice(0, 10)}...${to.slice(-6)}`,
+      amount,
+      network: this.config.network
+    });
     try {
       const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/send`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ seed, chain, to, amount, network: this.config.network })
       });
+      const elapsed = Date.now() - startTime;
       if (response.ok) {
         const data = await response.json();
         let txHash = data.txHash || data.transactionHash || data.hash;
         if (txHash && typeof txHash === "object" && "hash" in txHash) {
           txHash = txHash.hash;
         }
-        if (chain === "ethereum" && txHash && (typeof txHash !== "string" || !txHash.startsWith("0x") || txHash.length !== 66)) {
-          console.warn(`Invalid Ethereum tx hash format: ${txHash} (length: ${txHash?.length}, expected: 66)`);
+        if (txHash) {
+          const isValid = this.validateTxHash(chain, txHash);
+          if (!isValid) {
+            console.warn(`[ZubariWdkService] Invalid ${chain} tx hash format:`, txHash);
+          }
+        }
+        console.log(`[ZubariWdkService] ${chain} transaction ${data.success ? "SUCCESS" : "FAILED"}`, {
+          txHash: txHash ? `${txHash.slice(0, 16)}...` : "N/A",
+          elapsed: `${elapsed}ms`
+        });
+        if (!data.success) {
+          const errorCode2 = parseChainError(chain, data.error || "");
+          return {
+            success: false,
+            error: data.error,
+            errorCode: errorCode2,
+            chain
+          };
         }
         return {
-          success: data.success,
+          success: true,
           txHash,
           from: data.from,
           to: data.to,
           amount: data.amount,
-          chain: data.chain,
-          network: data.network
+          chain: data.chain || chain,
+          network: data.network || this.config.network
         };
       }
       const errorData = await response.json().catch(() => ({}));
+      const errorMessage = errorData.error || `HTTP ${response.status}`;
+      const errorCode = parseChainError(chain, errorMessage);
+      console.error(`[ZubariWdkService] ${chain} transaction FAILED`, {
+        status: response.status,
+        error: errorMessage,
+        errorCode,
+        elapsed: `${elapsed}ms`
+      });
       return {
         success: false,
-        error: errorData.error || `HTTP ${response.status}`
+        error: errorMessage,
+        errorCode,
+        chain
       };
     } catch (error) {
+      const elapsed = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "Transaction failed";
+      const errorCode = parseChainError(chain, errorMessage);
+      console.error(`[ZubariWdkService] ${chain} transaction ERROR`, {
+        error: errorMessage,
+        errorCode,
+        elapsed: `${elapsed}ms`
+      });
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Transaction failed"
+        error: errorMessage,
+        errorCode,
+        chain
       };
     }
   }
+  /**
+   * Validate transaction hash format for a specific chain
+   */
+  validateTxHash(chain, txHash) {
+    switch (chain) {
+      case "ethereum":
+        return /^0x[a-fA-F0-9]{64}$/.test(txHash);
+      case "bitcoin":
+        return /^[a-fA-F0-9]{64}$/.test(txHash);
+      case "solana":
+        return /^[1-9A-HJ-NP-Za-km-z]{80,90}$/.test(txHash);
+      case "ton":
+        return txHash.length >= 40;
+      case "tron":
+        return /^[a-fA-F0-9]{64}$/.test(txHash);
+      case "spark":
+        return txHash.length >= 32;
+      default:
+        return true;
+    }
+  }
   /**
    * Get the network configuration
    */
@@ -2046,6 +2202,19 @@ async function getPriceForChain(chain) {
   const prices = await fetchPrices();
   return prices[chain] || 0;
 }
+function tonFriendlyToRaw(addr) {
+  if (addr.includes(":")) return addr;
+  try {
+    const b64 = addr.replace(/-/g, "+").replace(/_/g, "/");
+    const bytes = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+    if (bytes.length !== 36) return addr;
+    const workchain = bytes[1] === 255 ? -1 : bytes[1];
+    const hash = Array.from(bytes.slice(2, 34)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${workchain}:${hash}`;
+  } catch {
+    return addr;
+  }
+}
 var STORAGE_KEYS = {
   ENCRYPTED_SEED: "encrypted_seed",
   ACTIVE_WALLET: "active_wallet",
@@ -2550,26 +2719,53 @@ var WalletManager = class _WalletManager {
     }
     const networkConfig = this.getChainConfig(chain);
     let balance = "0";
+    const tokenBalances = {};
     if (chain === "ethereum") {
       const viemChain = this.config.network === "mainnet" ? mainnet : sepolia;
-      console.log(`[WalletManager] Fetching ${chain} balance for ${address} using RPC: ${this.config.rpcUrl}`);
+      const isTestnet2 = this.config.network !== "mainnet";
       const client = createPublicClient({
         chain: viemChain,
         transport: http(this.config.rpcUrl, {
           timeout: 15e3,
-          // 15 second timeout
           retryCount: 2,
           retryDelay: 1e3
         })
       });
-      try {
-        const rawBalance = await client.getBalance({
-          address
-        });
-        balance = formatEther(rawBalance);
-        console.log(`[WalletManager] ${chain} balance fetched: ${balance} (raw: ${rawBalance})`);
-      } catch (error) {
-        console.error(`[WalletManager] Failed to fetch ${chain} balance from ${this.config.rpcUrl}:`, error);
+      const usdtAddr = USDT_ADDRESSES.ethereum?.[isTestnet2 ? "testnet" : "mainnet"];
+      const erc20BalanceOfAbi = [{
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }]
+      }];
+      const checksumAddr = getAddress(address);
+      const [ethResult, usdtResult] = await Promise.allSettled([
+        client.getBalance({ address: checksumAddr }),
+        usdtAddr ? client.readContract({
+          address: getAddress(usdtAddr),
+          abi: erc20BalanceOfAbi,
+          functionName: "balanceOf",
+          args: [checksumAddr]
+        }) : Promise.resolve(null)
+      ]);
+      if (ethResult.status === "fulfilled") {
+        balance = formatEther(ethResult.value);
+      } else {
+        console.error(`[WalletManager] Failed to fetch ETH balance:`, ethResult.reason);
+      }
+      if (usdtResult.status === "fulfilled" && usdtResult.value != null) {
+        try {
+          const rawUsdt = BigInt(usdtResult.value);
+          const usdtAmount = Number(rawUsdt) / 1e6;
+          if (usdtAmount > 0) {
+            tokenBalances.USDT = { balance: usdtAmount.toFixed(6), balanceUsd: usdtAmount };
+          }
+        } catch (err) {
+          console.warn("[WalletManager] Failed to parse ETH USDT balance:", err);
+        }
+      } else if (usdtResult.status === "rejected") {
+        console.warn("[WalletManager] Failed to fetch ETH USDT balance:", usdtResult.reason);
       }
     } else if (chain === "bitcoin") {
       const isMainnet2 = this.config.network === "mainnet" || address.startsWith("bc1") || address.startsWith("1") || address.startsWith("3");
@@ -2625,8 +2821,41 @@ var WalletManager = class _WalletManager {
       } catch (error) {
         console.warn(`Failed to fetch ${chain} balance:`, error);
       }
+      const isTestnet2 = this.config.network !== "mainnet";
+      const usdtMint = USDT_ADDRESSES.solana?.[isTestnet2 ? "testnet" : "mainnet"];
+      if (usdtMint) {
+        try {
+          const tokenResponse = await fetch(rpcUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 2,
+              method: "getTokenAccountsByOwner",
+              params: [
+                address,
+                { mint: usdtMint },
+                { encoding: "jsonParsed" }
+              ]
+            })
+          });
+          if (tokenResponse.ok) {
+            const tokenData = await tokenResponse.json();
+            const accounts = tokenData.result?.value;
+            if (accounts && accounts.length > 0) {
+              const uiAmount = accounts[0].account?.data?.parsed?.info?.tokenAmount?.uiAmount;
+              if (uiAmount && uiAmount > 0) {
+                tokenBalances.USDT = { balance: uiAmount.toFixed(6), balanceUsd: uiAmount };
+              }
+            }
+          }
+        } catch (error) {
+          console.warn("Failed to fetch Solana USDT balance:", error);
+        }
+      }
     } else if (chain === "tron") {
-      const baseUrl = this.config.network === "mainnet" ? "https://api.trongrid.io" : "https://api.shasta.trongrid.io";
+      const tronConfig = getNetworkConfig("tron", this.config.network !== "mainnet");
+      const baseUrl = tronConfig.rpcUrl;
       try {
         const response = await fetch(`${baseUrl}/v1/accounts/${address}`, {
           headers: { "Accept": "application/json" }
@@ -2636,12 +2865,28 @@ var WalletManager = class _WalletManager {
           if (data.data?.[0]?.balance !== void 0) {
             balance = (data.data[0].balance / 1e6).toFixed(6);
           }
+          const isTestnet2 = this.config.network !== "mainnet";
+          const usdtAddr = USDT_ADDRESSES.tron?.[isTestnet2 ? "testnet" : "mainnet"];
+          if (usdtAddr && data.data?.[0]?.trc20) {
+            const trc20List = data.data[0].trc20;
+            for (const tokenObj of trc20List) {
+              if (tokenObj[usdtAddr]) {
+                const rawUsdtBalance = BigInt(tokenObj[usdtAddr]);
+                const usdtAmount = Number(rawUsdtBalance) / 1e6;
+                if (usdtAmount > 0) {
+                  tokenBalances.USDT = { balance: usdtAmount.toFixed(6), balanceUsd: usdtAmount };
+                }
+                break;
+              }
+            }
+          }
         }
       } catch (error) {
         console.warn(`Failed to fetch ${chain} balance:`, error);
       }
     } else if (chain === "ton") {
-      const baseUrl = this.config.network === "mainnet" ? "https://toncenter.com/api/v2" : "https://testnet.toncenter.com/api/v2";
+      const isTestnet2 = this.config.network !== "mainnet";
+      const baseUrl = isTestnet2 ? "https://testnet.toncenter.com/api/v2" : "https://toncenter.com/api/v2";
       try {
         const response = await fetch(`${baseUrl}/getAddressBalance?address=${address}`, {
           headers: { "Accept": "application/json" }
@@ -2657,6 +2902,42 @@ var WalletManager = class _WalletManager {
       } catch (error) {
         console.warn(`Failed to fetch ${chain} balance:`, error);
       }
+      const usdtJetton = USDT_ADDRESSES.ton?.[isTestnet2 ? "testnet" : "mainnet"];
+      if (usdtJetton) {
+        const tonapiBaseUrl = isTestnet2 ? "https://testnet.tonapi.io/v2" : "https://tonapi.io/v2";
+        try {
+          const rawAddr = tonFriendlyToRaw(address);
+          const jettonResponse = await fetch(
+            `${tonapiBaseUrl}/accounts/${encodeURIComponent(rawAddr)}/jettons?currencies=usd`,
+            { headers: { "Accept": "application/json" } }
+          );
+          if (jettonResponse.ok) {
+            const jettonData = await jettonResponse.json();
+            const balances = jettonData.balances;
+            if (balances && balances.length > 0) {
+              for (const jb of balances) {
+                const jettonAddr = jb.jetton?.address;
+                if (jettonAddr) {
+                  const usdtRaw = tonFriendlyToRaw(usdtJetton);
+                  if (jettonAddr.toLowerCase() === usdtRaw.toLowerCase()) {
+                    const rawBalance = jb.balance;
+                    if (rawBalance) {
+                      const decimals = jb.jetton?.decimals || 6;
+                      const usdtAmount = Number(BigInt(rawBalance)) / Math.pow(10, decimals);
+                      if (usdtAmount > 0) {
+                        tokenBalances.USDT = { balance: usdtAmount.toFixed(6), balanceUsd: usdtAmount };
+                      }
+                    }
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.warn("Failed to fetch TON USDT jetton balance:", error);
+        }
+      }
     } else if (chain === "spark") {
       try {
         const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/balance`, {
@@ -2688,7 +2969,8 @@ var WalletManager = class _WalletManager {
       balance,
       balanceUsd,
       address,
-      decimals: networkConfig.nativeCurrency.decimals
+      decimals: networkConfig.nativeCurrency.decimals,
+      ...Object.keys(tokenBalances).length > 0 ? { tokenBalances } : {}
     };
   }
   /**