@zubari/sdk 0.5.0 → 0.5.2

package/dist/wallet/index.js

@@ -3,8 +3,11 @@
 var ethers = require('ethers');
 var bip39 = require('@scure/bip39');
 var english = require('@scure/bip39/wordlists/english');
-var bip32 = require('@scure/bip32');
-var base = require('@scure/base');
+var secp256k1_js = require('@noble/curves/secp256k1.js');
+var hmac_js = require('@noble/hashes/hmac.js');
+var legacy_js = require('@noble/hashes/legacy.js');
+var sha2_js = require('@noble/hashes/sha2.js');
+var utils_js = require('@noble/hashes/utils.js');
 var sha256 = require('@noble/hashes/sha256');
 var ripemd160 = require('@noble/hashes/ripemd160');
 var viem = require('viem');
@@ -31,7 +34,7 @@ var NETWORKS = {
     chainId: 1,
     coinType: 60,
     // m/44'/60'
-    rpcUrl: "https://eth.llamarpc.com",
+    rpcUrl: "https://ethereum-rpc.publicnode.com",
     explorerUrl: "https://etherscan.io",
     nativeCurrency: {
       name: "Ether",
@@ -115,6 +118,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: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0"
+    // Sepolia
+  },
+  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 = {
@@ -140,37 +175,48 @@ function getNetworkConfig(network, isTestnet = false) {
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var ZUBARI_CONTRACTS = {
   testnet: {
-    // Ethereum Sepolia (11155111) - Deployed 2024-12-31
-    registry: "0xe5CE1Eb986f58BE42EEDFe5C18ee5956803b2BDC",
-    nft: "0xc165b8C6843e8f0B1489525D0f853d23f22c677B",
+    // Ethereum Sepolia (11155111) - Updated 2025-01-18
+    // Treasury: 0xAC2e22B5a99F0123319644A9bF0DF4FD72c9b001
+    // Platform Fee: 10% (1000 bps)
+    registry: "0xcEd503aeD6E2F6884A7eAB4226D15477d863B084",
+    nft: "0xc61497530E08897CCf518cbF9DA1A327983192E1",
     // ZubariNFT ERC-721 with payment
     nft1155: "0x5e618B5bEaE1dc41369E7aa235Cc3b9245905192",
     // Zubari1155 ERC-1155 multi-edition
-    marketplace: "0xfcEfDa6C73aC357b8695E5F8F8d17820750BF207",
-    tips: "0x86a9A306C7fCC9e0B8cd6859f6f15498d0046BB7",
-    subscriptions: "0xaB7F17A85F61d9ab9f96bCB4e73e910D019978F7",
+    marketplace: "0x64B8fC45bB669a1bD672bD5ab76f82B7EE3B2e0f",
+    tips: "0xFDc353edC63Cd3D4bba35bB43861369516a9Dc85",
+    // ZubariTips - 10% fee
+    subscriptions: "0x8C05F8aD2F295fB7f3596043a7c37C98A5F7fAB8",
+    // ZubariSubscription - 10% fee
     subscriptionsV2: ZERO_ADDRESS,
-    // Deploy with: npx hardhat run deploy/deploy.ts --network ethereum-sepolia
-    payouts: "0x8aaB23Fb2a83A259E965Aae8Ee0938b1400B7E6b",
+    subscriptionsSimple: "0x944f306e7d2e4f224dd660442EB65e4021b5eC24",
+    // Deployed 2025-01-26
+    creatorRegistry: ZERO_ADDRESS,
+    payouts: "0x804Fe503936E8b8d3D5Dbb62AF4fB6Fe7265Fb2c",
+    // ZubariPayouts
     entryPoint: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
     paymaster: ZERO_ADDRESS,
     // Deploy with: npx hardhat run deploy/deploy.ts --network ethereum-sepolia
     accountFactory: ZERO_ADDRESS,
     // Not yet deployed
-    usdt: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0",
-    // USDT on Sepolia
+    usdt: "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06",
+    // USDT on Sepolia (mintable test token)
     weth: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"
   },
   mainnet: {
-    // Ethereum Mainnet (1)
-    registry: ZERO_ADDRESS,
-    nft: ZERO_ADDRESS,
-    nft1155: ZERO_ADDRESS,
-    marketplace: ZERO_ADDRESS,
-    tips: ZERO_ADDRESS,
-    subscriptions: ZERO_ADDRESS,
-    subscriptionsV2: ZERO_ADDRESS,
-    payouts: ZERO_ADDRESS,
+    // Ethereum Mainnet (1) - Deployed 2025-01-22
+    // Owner/Treasury: Safe 0x436fE1eff6056aCc8c34d8ADe0C54B8AcF90DCAa
+    // Platform Fee: 10% (1000 bps)
+    registry: "0x1DA6880bc730e96cFA24d614D12012f9f81C3239",
+    nft: "0x19842D60a81bd65Bd9352A380C3b37dc2E0a5731",
+    nft1155: "0xDA824094c3ADdaC49e2480a699E2B21ca234BeD6",
+    marketplace: "0x8B0B3383644D0d374F4E047fC37e11F00f716b3A",
+    tips: "0x38D7Fc0592bCF094e1880c19a34f98c6A36b68D8",
+    subscriptions: "0xDA774d657B04Ab8744bfF09D18EeAce27E3F3DEa",
+    subscriptionsV2: "0x7abbaFe67941036bBF7dB7006855C55014d6012A",
+    subscriptionsSimple: "0xd0C07722a29D8aC7d137e59dCA114b031B4411E8",
+    creatorRegistry: "0xe5CE1Eb986f58BE42EEDFe5C18ee5956803b2BDC",
+    payouts: "0x74fc8cC0B5A92c90ae35caEB0E388Ea30424cc79",
     entryPoint: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
     paymaster: ZERO_ADDRESS,
     accountFactory: ZERO_ADDRESS,
@@ -234,14 +280,14 @@ var WdkApiClient = class {
   /**
    * Derive address for a specific chain using Tether WDK
    */
-  async deriveAddress(seed, chain, network = "testnet") {
+  async deriveAddress(seed, chain2, network = "mainnet") {
     try {
       const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/derive-address`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ seed, chain, network })
+        body: JSON.stringify({ seed, chain: chain2, network })
       });
       return await response.json();
     } catch (error) {
@@ -254,7 +300,7 @@ var WdkApiClient = class {
   /**
    * Derive addresses for all chains using Tether WDK
    */
-  async deriveAllAddresses(seed, network = "testnet") {
+  async deriveAllAddresses(seed, network = "mainnet") {
     try {
       const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/derive-all`, {
         method: "POST",
@@ -274,14 +320,14 @@ var WdkApiClient = class {
   /**
    * Send a transaction on a specific chain using Tether WDK
    */
-  async sendTransaction(seed, chain, to, amount, network = "testnet") {
+  async sendTransaction(seed, chain2, to, amount, network = "mainnet") {
     try {
       const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/send`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ seed, chain, to, amount, network })
+        body: JSON.stringify({ seed, chain: chain2, to, amount, network })
       });
       return await response.json();
     } catch (error) {
@@ -295,14 +341,14 @@ var WdkApiClient = class {
    * Get transaction history for an address on a specific chain
    * Fetches from blockchain explorers (Etherscan, mempool.space, etc.)
    */
-  async getTransactionHistory(seed, chain, network = "testnet", limit = 10) {
+  async getTransactionHistory(seed, chain2, network = "mainnet", limit = 10) {
     try {
       const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/history`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ seed, chain, network, limit })
+        body: JSON.stringify({ seed, chain: chain2, network, limit })
       });
       return await response.json();
     } catch (error) {
@@ -316,14 +362,14 @@ var WdkApiClient = class {
    * Get transaction status by hash
    * Fetches from blockchain explorers to check confirmation status
    */
-  async getTransactionStatus(txHash, chain, network = "testnet") {
+  async getTransactionStatus(txHash, chain2, network = "mainnet") {
     try {
       const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/tx-status`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ txHash, chain, network })
+        body: JSON.stringify({ txHash, chain: chain2, network })
       });
       return await response.json();
     } catch (error) {
@@ -344,6 +390,589 @@ function getWdkApiClient(baseUrl) {
   }
   return wdkApiClient;
 }
+
+// node_modules/@scure/base/index.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos; i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0; i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === void 0)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+// @__NO_SIDE_EFFECTS__
+function radix(num) {
+  anumber(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function radix2(bits, revPadding = false) {
+  anumber(bits);
+  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e) {
+    }
+  };
+}
+function checksum(len, fn) {
+  anumber(len);
+  afn(fn);
+  return {
+    encode(data) {
+      if (!isBytes(data))
+        throw new Error("checksum.encode: input should be Uint8Array");
+      const sum = fn(data).slice(0, len);
+      const res = new Uint8Array(data.length + len);
+      res.set(data);
+      res.set(sum, data.length);
+      return res;
+    },
+    decode(data) {
+      if (!isBytes(data))
+        throw new Error("checksum.decode: input should be Uint8Array");
+      const payload = data.slice(0, -len);
+      const oldChecksum = data.slice(-len);
+      const newChecksum = fn(payload).slice(0, len);
+      for (let i = 0; i < len; i++)
+        if (newChecksum[i] !== oldChecksum[i])
+          throw new Error("Invalid checksum");
+      return payload;
+    }
+  };
+}
+var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
+var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+var createBase58check = (sha2563) => /* @__PURE__ */ chain(checksum(4, (data) => sha2563(sha2563(data))), base58);
+var base58check = createBase58check;
+var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join(""));
+var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function bech32Polymod(pre) {
+  const b = pre >> 25;
+  let chk = (pre & 33554431) << 5;
+  for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
+    if ((b >> i & 1) === 1)
+      chk ^= POLYMOD_GENERATORS[i];
+  }
+  return chk;
+}
+function bechChecksum(prefix, words, encodingConst = 1) {
+  const len = prefix.length;
+  let chk = 1;
+  for (let i = 0; i < len; i++) {
+    const c = prefix.charCodeAt(i);
+    if (c < 33 || c > 126)
+      throw new Error(`Invalid prefix (${prefix})`);
+    chk = bech32Polymod(chk) ^ c >> 5;
+  }
+  chk = bech32Polymod(chk);
+  for (let i = 0; i < len; i++)
+    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
+  for (let v of words)
+    chk = bech32Polymod(chk) ^ v;
+  for (let i = 0; i < 6; i++)
+    chk = bech32Polymod(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+// @__NO_SIDE_EFFECTS__
+function genBech32(encoding) {
+  const ENCODING_CONST = 1 ;
+  const _words = /* @__PURE__ */ radix2(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper(fromWords);
+  function encode(prefix, words, limit = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit !== false && actualLength > limit)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  }
+  function decode(str, limit = 90) {
+    astr("bech32.decode input", str);
+    const slen = str.length;
+    if (slen < 8 || limit !== false && slen > limit)
+      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+    const lowered = str.toLowerCase();
+    if (str !== lowered && str !== str.toUpperCase())
+      throw new Error(`String must be lowercase or uppercase`);
+    const sepIndex = lowered.lastIndexOf("1");
+    if (sepIndex === 0 || sepIndex === -1)
+      throw new Error(`Letter "1" must be present between prefix and data only`);
+    const prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET.decode(data).slice(0, -6);
+    const sum = bechChecksum(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper(decode);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes) {
+    return encode(prefix, toWords(bytes));
+  }
+  return {
+    encode,
+    decode,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech32 = /* @__PURE__ */ genBech32();
+
+// node_modules/@scure/bip32/index.js
+var Point = secp256k1_js.secp256k1.Point;
+var { Fn } = Point;
+var base58check2 = createBase58check(sha2_js.sha256);
+var MASTER_SECRET = Uint8Array.from("Bitcoin seed".split(""), (char) => char.charCodeAt(0));
+var BITCOIN_VERSIONS = { private: 76066276, public: 76067358 };
+var HARDENED_OFFSET = 2147483648;
+var hash160 = (data) => legacy_js.ripemd160(sha2_js.sha256(data));
+var fromU32 = (data) => utils_js.createView(data).getUint32(0, false);
+var toU32 = (n) => {
+  if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) {
+    throw new Error("invalid number, should be from 0 to 2**32-1, got " + n);
+  }
+  const buf = new Uint8Array(4);
+  utils_js.createView(buf).setUint32(0, n, false);
+  return buf;
+};
+var HDKey = class _HDKey {
+  get fingerprint() {
+    if (!this.pubHash) {
+      throw new Error("No publicKey set!");
+    }
+    return fromU32(this.pubHash);
+  }
+  get identifier() {
+    return this.pubHash;
+  }
+  get pubKeyHash() {
+    return this.pubHash;
+  }
+  get privateKey() {
+    return this._privateKey || null;
+  }
+  get publicKey() {
+    return this._publicKey || null;
+  }
+  get privateExtendedKey() {
+    const priv = this._privateKey;
+    if (!priv) {
+      throw new Error("No private key");
+    }
+    return base58check2.encode(this.serialize(this.versions.private, utils_js.concatBytes(Uint8Array.of(0), priv)));
+  }
+  get publicExtendedKey() {
+    if (!this._publicKey) {
+      throw new Error("No public key");
+    }
+    return base58check2.encode(this.serialize(this.versions.public, this._publicKey));
+  }
+  static fromMasterSeed(seed, versions = BITCOIN_VERSIONS) {
+    utils_js.abytes(seed);
+    if (8 * seed.length < 128 || 8 * seed.length > 512) {
+      throw new Error("HDKey: seed length must be between 128 and 512 bits; 256 bits is advised, got " + seed.length);
+    }
+    const I = hmac_js.hmac(sha2_js.sha512, MASTER_SECRET, seed);
+    const privateKey = I.slice(0, 32);
+    const chainCode = I.slice(32);
+    return new _HDKey({ versions, chainCode, privateKey });
+  }
+  static fromExtendedKey(base58key, versions = BITCOIN_VERSIONS) {
+    const keyBuffer = base58check2.decode(base58key);
+    const keyView = utils_js.createView(keyBuffer);
+    const version = keyView.getUint32(0, false);
+    const opt = {
+      versions,
+      depth: keyBuffer[4],
+      parentFingerprint: keyView.getUint32(5, false),
+      index: keyView.getUint32(9, false),
+      chainCode: keyBuffer.slice(13, 45)
+    };
+    const key = keyBuffer.slice(45);
+    const isPriv = key[0] === 0;
+    if (version !== versions[isPriv ? "private" : "public"]) {
+      throw new Error("Version mismatch");
+    }
+    if (isPriv) {
+      return new _HDKey({ ...opt, privateKey: key.slice(1) });
+    } else {
+      return new _HDKey({ ...opt, publicKey: key });
+    }
+  }
+  static fromJSON(json) {
+    return _HDKey.fromExtendedKey(json.xpriv);
+  }
+  versions;
+  depth = 0;
+  index = 0;
+  chainCode = null;
+  parentFingerprint = 0;
+  _privateKey;
+  _publicKey;
+  pubHash;
+  constructor(opt) {
+    if (!opt || typeof opt !== "object") {
+      throw new Error("HDKey.constructor must not be called directly");
+    }
+    this.versions = opt.versions || BITCOIN_VERSIONS;
+    this.depth = opt.depth || 0;
+    this.chainCode = opt.chainCode || null;
+    this.index = opt.index || 0;
+    this.parentFingerprint = opt.parentFingerprint || 0;
+    if (!this.depth) {
+      if (this.parentFingerprint || this.index) {
+        throw new Error("HDKey: zero depth with non-zero index/parent fingerprint");
+      }
+    }
+    if (this.depth > 255) {
+      throw new Error("HDKey: depth exceeds the serializable value 255");
+    }
+    if (opt.publicKey && opt.privateKey) {
+      throw new Error("HDKey: publicKey and privateKey at same time.");
+    }
+    if (opt.privateKey) {
+      if (!secp256k1_js.secp256k1.utils.isValidSecretKey(opt.privateKey))
+        throw new Error("Invalid private key");
+      this._privateKey = opt.privateKey;
+      this._publicKey = secp256k1_js.secp256k1.getPublicKey(opt.privateKey, true);
+    } else if (opt.publicKey) {
+      this._publicKey = Point.fromBytes(opt.publicKey).toBytes(true);
+    } else {
+      throw new Error("HDKey: no public or private key provided");
+    }
+    this.pubHash = hash160(this._publicKey);
+  }
+  derive(path) {
+    if (!/^[mM]'?/.test(path)) {
+      throw new Error('Path must start with "m" or "M"');
+    }
+    if (/^[mM]'?$/.test(path)) {
+      return this;
+    }
+    const parts = path.replace(/^[mM]'?\//, "").split("/");
+    let child = this;
+    for (const c of parts) {
+      const m = /^(\d+)('?)$/.exec(c);
+      const m1 = m && m[1];
+      if (!m || m.length !== 3 || typeof m1 !== "string")
+        throw new Error("invalid child index: " + c);
+      let idx = +m1;
+      if (!Number.isSafeInteger(idx) || idx >= HARDENED_OFFSET) {
+        throw new Error("Invalid index");
+      }
+      if (m[2] === "'") {
+        idx += HARDENED_OFFSET;
+      }
+      child = child.deriveChild(idx);
+    }
+    return child;
+  }
+  deriveChild(index) {
+    if (!this._publicKey || !this.chainCode) {
+      throw new Error("No publicKey or chainCode set");
+    }
+    let data = toU32(index);
+    if (index >= HARDENED_OFFSET) {
+      const priv = this._privateKey;
+      if (!priv) {
+        throw new Error("Could not derive hardened child key");
+      }
+      data = utils_js.concatBytes(Uint8Array.of(0), priv, data);
+    } else {
+      data = utils_js.concatBytes(this._publicKey, data);
+    }
+    const I = hmac_js.hmac(sha2_js.sha512, this.chainCode, data);
+    const childTweak = I.slice(0, 32);
+    const chainCode = I.slice(32);
+    if (!secp256k1_js.secp256k1.utils.isValidSecretKey(childTweak)) {
+      throw new Error("Tweak bigger than curve order");
+    }
+    const opt = {
+      versions: this.versions,
+      chainCode,
+      depth: this.depth + 1,
+      parentFingerprint: this.fingerprint,
+      index
+    };
+    const ctweak = Fn.fromBytes(childTweak);
+    try {
+      if (this._privateKey) {
+        const added = Fn.create(Fn.fromBytes(this._privateKey) + ctweak);
+        if (!Fn.isValidNot0(added)) {
+          throw new Error("The tweak was out of range or the resulted private key is invalid");
+        }
+        opt.privateKey = Fn.toBytes(added);
+      } else {
+        const added = Point.fromBytes(this._publicKey).add(Point.BASE.multiply(ctweak));
+        if (added.equals(Point.ZERO)) {
+          throw new Error("The tweak was equal to negative P, which made the result key invalid");
+        }
+        opt.publicKey = added.toBytes(true);
+      }
+      return new _HDKey(opt);
+    } catch (err) {
+      return this.deriveChild(index + 1);
+    }
+  }
+  sign(hash) {
+    if (!this._privateKey) {
+      throw new Error("No privateKey set!");
+    }
+    utils_js.abytes(hash, 32);
+    return secp256k1_js.secp256k1.sign(hash, this._privateKey, { prehash: false });
+  }
+  verify(hash, signature) {
+    utils_js.abytes(hash, 32);
+    utils_js.abytes(signature, 64);
+    if (!this._publicKey) {
+      throw new Error("No publicKey set!");
+    }
+    return secp256k1_js.secp256k1.verify(signature, hash, this._publicKey, { prehash: false });
+  }
+  wipePrivateData() {
+    if (this._privateKey) {
+      this._privateKey.fill(0);
+      this._privateKey = void 0;
+    }
+    return this;
+  }
+  toJSON() {
+    return {
+      xpriv: this.privateExtendedKey,
+      xpub: this.publicExtendedKey
+    };
+  }
+  serialize(version, key) {
+    if (!this.chainCode) {
+      throw new Error("No chainCode set");
+    }
+    utils_js.abytes(key, 33);
+    return utils_js.concatBytes(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
+  }
+};
 var DERIVATION_PATHS2 = {
   ethereum: "m/44'/60'/0'/0/0",
   bitcoin_mainnet: "m/84'/0'/0'/0/0",
@@ -357,10 +986,10 @@ function deriveEthereumAddress(seed) {
   const hdNode = ethers.HDNodeWallet.fromPhrase(seed, void 0, DERIVATION_PATHS2.ethereum);
   return hdNode.address;
 }
-function deriveBitcoinAddress(seed, network = "testnet") {
+function deriveBitcoinAddress(seed, network = "mainnet") {
   try {
     const seedBytes = bip39.mnemonicToSeedSync(seed);
-    const hdKey = bip32.HDKey.fromMasterSeed(seedBytes);
+    const hdKey = HDKey.fromMasterSeed(seedBytes);
     const path = network === "testnet" ? DERIVATION_PATHS2.bitcoin_testnet : DERIVATION_PATHS2.bitcoin_mainnet;
     const child = hdKey.derive(path);
     if (!child.publicKey) {
@@ -368,10 +997,10 @@ function deriveBitcoinAddress(seed, network = "testnet") {
     }
     const pubKeyHash = ripemd160.ripemd160(sha256.sha256(child.publicKey));
     const witnessVersion = 0;
-    const words = base.bech32.toWords(pubKeyHash);
+    const words = bech32.toWords(pubKeyHash);
     words.unshift(witnessVersion);
     const hrp = network === "testnet" ? "tb" : "bc";
-    const address = base.bech32.encode(hrp, words);
+    const address = bech32.encode(hrp, words);
     return address;
   } catch (error) {
     console.error("Bitcoin address derivation failed:", error);
@@ -444,34 +1073,34 @@ function deriveTronAddress(seed) {
     for (let i = 0; i < 20; i++) {
       addressBytes[i + 1] = parseInt(ethAddressHex.slice(i * 2, i * 2 + 2), 16);
     }
-    const tronBase58check = base.base58check(sha256.sha256);
+    const tronBase58check = base58check(sha256.sha256);
     return tronBase58check.encode(addressBytes);
   } catch (error) {
     console.error("TRON address derivation failed:", error);
     throw error;
   }
 }
-function deriveSparkAddress(seed, network = "testnet") {
+function deriveSparkAddress(seed, network = "mainnet") {
   try {
     const seedBytes = bip39.mnemonicToSeedSync(seed);
-    const hdKey = bip32.HDKey.fromMasterSeed(seedBytes);
+    const hdKey = HDKey.fromMasterSeed(seedBytes);
     const child = hdKey.derive(DERIVATION_PATHS2.spark);
     if (!child.publicKey) {
       throw new Error("Failed to derive public key");
     }
     const pubKeyHash = ripemd160.ripemd160(sha256.sha256(child.publicKey));
     const witnessVersion = 0;
-    const words = base.bech32.toWords(pubKeyHash);
+    const words = bech32.toWords(pubKeyHash);
     words.unshift(witnessVersion);
     const hrp = network === "testnet" ? "tsp" : "sp";
-    const address = base.bech32.encode(hrp, words);
+    const address = bech32.encode(hrp, words);
     return address;
   } catch (error) {
     console.error("Spark address derivation failed:", error);
     throw error;
   }
 }
-async function deriveAllAddresses(seed, network = "testnet") {
+async function deriveAllAddresses(seed, network = "mainnet") {
   const addresses = {
     ethereum: null,
     bitcoin: null,
@@ -525,6 +1154,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(chain2, errorMessage) {
+  const errorLower = errorMessage.toLowerCase();
+  const chainErrors = CHAIN_ERROR_MESSAGES[chain2];
+  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";
 }
@@ -548,7 +1231,7 @@ var ZubariWdkService = class {
   useNativeWdk = false;
   constructor(config = {}) {
     this.config = {
-      network: config.network || "testnet",
+      network: config.network || "mainnet",
       apiUrl: config.apiUrl || process.env.NEXT_PUBLIC_API_URL || DEFAULT_API_URL2,
       forceApi: config.forceApi ?? false,
       timeout: config.timeout || 3e4
@@ -646,38 +1329,38 @@ var ZubariWdkService = class {
    * For Ethereum, falls back to local derivation if API fails.
    * For other chains, WDK API is required - no placeholder fallback.
    */
-  async deriveAddress(seed, chain) {
+  async deriveAddress(seed, chain2) {
     await this.initialize();
-    const path = this.getDerivationPath(chain);
+    const path = this.getDerivationPath(chain2);
     try {
-      const response = await this.apiClient.deriveAddress(seed, chain, this.config.network);
+      const response = await this.apiClient.deriveAddress(seed, chain2, this.config.network);
       if (response.success && response.address) {
         return {
-          chain,
+          chain: chain2,
           address: response.address,
           path: response.path || path
         };
       }
     } catch (error) {
-      console.warn(`API address derivation failed for ${chain}:`, error);
-      if (chain === "ethereum") {
-        return this.deriveBrowserAddress(seed, chain);
+      console.warn(`API address derivation failed for ${chain2}:`, error);
+      if (chain2 === "ethereum") {
+        return this.deriveBrowserAddress(seed, chain2);
       }
     }
     if (this.useNativeWdk && this.nativeWdkService) {
       try {
         const wdk = this.nativeWdkService;
         await wdk.initialize(seed);
-        return await wdk.deriveAddress(chain);
+        return await wdk.deriveAddress(chain2);
       } catch (error) {
-        console.warn(`Native WDK address derivation failed for ${chain}:`, error);
+        console.warn(`Native WDK address derivation failed for ${chain2}:`, error);
       }
     }
-    if (chain === "ethereum") {
-      return this.deriveBrowserAddress(seed, chain);
+    if (chain2 === "ethereum") {
+      return this.deriveBrowserAddress(seed, chain2);
     }
     throw new Error(
-      `WDK API required for ${chain} address derivation. Ensure the backend is running.`
+      `WDK API required for ${chain2} address derivation. Ensure the backend is running.`
     );
   }
   /**
@@ -699,7 +1382,7 @@ var ZubariWdkService = class {
           }
           return null;
         };
-        return {
+        const addresses = {
           ethereum: extractAddress(response.addresses.ethereum),
           bitcoin: extractAddress(response.addresses.bitcoin),
           ton: extractAddress(response.addresses.ton),
@@ -707,6 +1390,14 @@ var ZubariWdkService = class {
           solana: extractAddress(response.addresses.solana),
           spark: extractAddress(response.addresses.spark)
         };
+        if (!addresses.spark) {
+          try {
+            addresses.spark = deriveSparkAddress(seed, this.config.network);
+          } catch (e) {
+            console.warn("Browser Spark derivation fallback failed:", e);
+          }
+        }
+        return addresses;
       }
     } catch (error) {
       console.warn("API address derivation failed:", error);
@@ -749,13 +1440,13 @@ var ZubariWdkService = class {
   /**
    * Get fee rates for a chain
    */
-  async getFeeRates(seed, chain) {
+  async getFeeRates(seed, chain2) {
     await this.initialize();
     try {
       const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/fee-rates`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ seed, chain, network: this.config.network })
+        body: JSON.stringify({ seed, chain: chain2, network: this.config.network })
       });
       if (response.ok) {
         const data = await response.json();
@@ -764,20 +1455,20 @@ var ZubariWdkService = class {
         }
       }
     } catch (error) {
-      console.warn(`Failed to fetch fee rates for ${chain}:`, error);
+      console.warn(`Failed to fetch fee rates for ${chain2}:`, error);
     }
     return { slow: "0", normal: "0", fast: "0" };
   }
   /**
    * Estimate transaction fee
    */
-  async estimateFee(seed, chain, to, amount) {
+  async estimateFee(seed, chain2, to, amount) {
     await this.initialize();
     try {
       const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/estimate-fee`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ seed, chain, to, amount, network: this.config.network })
+        body: JSON.stringify({ seed, chain: chain2, to, amount, network: this.config.network })
       });
       if (response.ok) {
         const data = await response.json();
@@ -786,52 +1477,122 @@ var ZubariWdkService = class {
         }
       }
     } catch (error) {
-      console.warn(`Failed to estimate fee for ${chain}:`, error);
+      console.warn(`Failed to estimate fee for ${chain2}:`, error);
     }
-    return { fee: "0", symbol: this.getChainSymbol(chain) };
+    return { fee: "0", symbol: this.getChainSymbol(chain2) };
   }
   /**
-   * 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) {
+  async sendTransaction(seed, chain2, to, amount) {
     await this.initialize();
+    const startTime = Date.now();
+    console.log(`[ZubariWdkService] Sending ${chain2} 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 })
+        body: JSON.stringify({ seed, chain: chain2, 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(chain2, txHash);
+          if (!isValid) {
+            console.warn(`[ZubariWdkService] Invalid ${chain2} tx hash format:`, txHash);
+          }
+        }
+        console.log(`[ZubariWdkService] ${chain2} transaction ${data.success ? "SUCCESS" : "FAILED"}`, {
+          txHash: txHash ? `${txHash.slice(0, 16)}...` : "N/A",
+          elapsed: `${elapsed}ms`
+        });
+        if (!data.success) {
+          const errorCode2 = parseChainError(chain2, data.error || "");
+          return {
+            success: false,
+            error: data.error,
+            errorCode: errorCode2,
+            chain: chain2
+          };
         }
         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 || chain2,
+          network: data.network || this.config.network
         };
       }
       const errorData = await response.json().catch(() => ({}));
+      const errorMessage = errorData.error || `HTTP ${response.status}`;
+      const errorCode = parseChainError(chain2, errorMessage);
+      console.error(`[ZubariWdkService] ${chain2} transaction FAILED`, {
+        status: response.status,
+        error: errorMessage,
+        errorCode,
+        elapsed: `${elapsed}ms`
+      });
       return {
         success: false,
-        error: errorData.error || `HTTP ${response.status}`
+        error: errorMessage,
+        errorCode,
+        chain: chain2
       };
     } catch (error) {
+      const elapsed = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "Transaction failed";
+      const errorCode = parseChainError(chain2, errorMessage);
+      console.error(`[ZubariWdkService] ${chain2} transaction ERROR`, {
+        error: errorMessage,
+        errorCode,
+        elapsed: `${elapsed}ms`
+      });
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Transaction failed"
+        error: errorMessage,
+        errorCode,
+        chain: chain2
       };
     }
   }
+  /**
+   * Validate transaction hash format for a specific chain
+   */
+  validateTxHash(chain2, txHash) {
+    switch (chain2) {
+      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
    */
@@ -847,7 +1608,7 @@ var ZubariWdkService = class {
   // ==========================================
   // Private Helper Methods
   // ==========================================
-  getDerivationPath(chain) {
+  getDerivationPath(chain2) {
     const paths = {
       bitcoin: this.config.network === "testnet" ? "m/84'/1'/0'/0/0" : "m/84'/0'/0'/0/0",
       ethereum: "m/44'/60'/0'/0/0",
@@ -856,9 +1617,9 @@ var ZubariWdkService = class {
       solana: "m/44'/501'/0'/0'",
       spark: "m/44'/998'/0'/0/0"
     };
-    return paths[chain];
+    return paths[chain2];
   }
-  getChainSymbol(chain) {
+  getChainSymbol(chain2) {
     const symbols = {
       ethereum: "ETH",
       bitcoin: "BTC",
@@ -867,16 +1628,16 @@ var ZubariWdkService = class {
       solana: "SOL",
       spark: "SAT"
     };
-    return symbols[chain];
+    return symbols[chain2];
   }
   /**
    * Derive address using browser-compatible libraries
    */
-  async deriveBrowserAddress(seed, chain) {
-    const path = this.getDerivationPath(chain);
+  async deriveBrowserAddress(seed, chain2) {
+    const path = this.getDerivationPath(chain2);
     try {
       let address;
-      switch (chain) {
+      switch (chain2) {
         case "ethereum":
           address = deriveEthereumAddress(seed);
           break;
@@ -896,11 +1657,11 @@ var ZubariWdkService = class {
           address = await deriveTonAddress(seed);
           break;
         default:
-          throw new Error(`Unsupported chain: ${chain}`);
+          throw new Error(`Unsupported chain: ${chain2}`);
       }
-      return { chain, address, path };
+      return { chain: chain2, address, path };
     } catch (error) {
-      console.error(`Browser derivation failed for ${chain}:`, error);
+      console.error(`Browser derivation failed for ${chain2}:`, error);
       throw error;
     }
   }
@@ -966,12 +1727,12 @@ var ZubariWallet = class {
       solana: "solana",
       spark: "spark"
     };
-    const chain = chainMap[network];
-    if (!chain) {
+    const chain2 = chainMap[network];
+    if (!chain2) {
       throw new Error(`Unsupported network: ${network}`);
     }
     try {
-      const result = await this.wdkService.deriveAddress(this.seed, chain);
+      const result = await this.wdkService.deriveAddress(this.seed, chain2);
       const account = {
         network,
         address: result.address,
@@ -1026,13 +1787,13 @@ var ZubariWallet = class {
       solana: "solana",
       spark: "spark"
     };
-    const chain = chainMap[network];
-    if (!chain) {
+    const chain2 = chainMap[network];
+    if (!chain2) {
       throw new Error(`Unsupported network: ${network}`);
     }
     try {
       const balances = await this.wdkService.getAllBalances(this.seed);
-      const chainBalance = balances[chain];
+      const chainBalance = balances[chain2];
       if (chainBalance) {
         const balanceValue = BigInt(chainBalance.balance || "0");
         const decimals = networkConfig.nativeCurrency.decimals;
@@ -1121,14 +1882,14 @@ var ZubariWallet = class {
       solana: "solana",
       spark: "spark"
     };
-    const chain = chainMap[network];
-    if (!chain) {
+    const chain2 = chainMap[network];
+    if (!chain2) {
       throw new Error(`Unsupported network: ${network}`);
     }
     try {
       const result = await this.wdkService.sendTransaction(
         this.seed,
-        chain,
+        chain2,
         to,
         amount.toString()
       );
@@ -1803,8 +2564,8 @@ async function fetchPrices() {
     if (response.ok) {
       const data = await response.json();
       const prices = {};
-      for (const [chain, geckoId] of Object.entries(COINGECKO_IDS)) {
-        prices[chain] = data[geckoId]?.usd || 0;
+      for (const [chain2, geckoId] of Object.entries(COINGECKO_IDS)) {
+        prices[chain2] = data[geckoId]?.usd || 0;
       }
       priceCache = { prices, timestamp: Date.now() };
       return prices;
@@ -1814,9 +2575,9 @@ async function fetchPrices() {
   }
   return priceCache?.prices || {};
 }
-async function getPriceForChain(chain) {
+async function getPriceForChain(chain2) {
   const prices = await fetchPrices();
-  return prices[chain] || 0;
+  return prices[chain2] || 0;
 }
 var STORAGE_KEYS = {
   ENCRYPTED_SEED: "encrypted_seed",
@@ -1836,7 +2597,7 @@ var WalletManager = class _WalletManager {
     const isTestnet = config.network !== "mainnet";
     const ethereumConfig = getNetworkConfig("ethereum", isTestnet);
     this.config = {
-      network: config.network || "testnet",
+      network: config.network || "mainnet",
       rpcUrl: config.rpcUrl || ethereumConfig.rpcUrl,
       storage: config.storage || createSecureStorage(),
       enabledChains: config.enabledChains || SUPPORTED_CHAINS,
@@ -2022,9 +2783,9 @@ var WalletManager = class _WalletManager {
     if (!this.derivedAddress) {
       throw new Error("Wallet not initialized");
     }
-    const chain = this.config.network === "mainnet" ? chains.mainnet : chains.sepolia;
+    const chain2 = this.config.network === "mainnet" ? chains.mainnet : chains.sepolia;
     const client = viem.createPublicClient({
-      chain,
+      chain: chain2,
       transport: viem.http(this.config.rpcUrl, {
         timeout: 15e3,
         // 15 second timeout
@@ -2046,9 +2807,9 @@ var WalletManager = class _WalletManager {
    * Create viem public client for the current network
    */
   getPublicClient() {
-    const chain = this.config.network === "mainnet" ? chains.mainnet : chains.sepolia;
+    const chain2 = this.config.network === "mainnet" ? chains.mainnet : chains.sepolia;
     return viem.createPublicClient({
-      chain,
+      chain: chain2,
       transport: viem.http(this.config.rpcUrl, {
         timeout: 15e3,
         // 15 second timeout
@@ -2102,11 +2863,11 @@ var WalletManager = class _WalletManager {
    *
    * No fallback to placeholder addresses - WDK API is required for real addresses.
    */
-  static async deriveAddressForChainAsync(seed, chain, network = "testnet", apiUrl) {
-    if (chain === "ethereum") {
+  static async deriveAddressForChainAsync(seed, chain2, network = "mainnet", apiUrl) {
+    if (chain2 === "ethereum") {
       try {
         const wdkService2 = getZubariWdkService({ network, apiUrl });
-        const result2 = await wdkService2.deriveAddress(seed, chain);
+        const result2 = await wdkService2.deriveAddress(seed, chain2);
         return result2.address;
       } catch (error) {
         console.warn("WDK service failed for Ethereum, using local derivation:", error);
@@ -2114,7 +2875,7 @@ var WalletManager = class _WalletManager {
       }
     }
     const wdkService = getZubariWdkService({ network, apiUrl });
-    const result = await wdkService.deriveAddress(seed, chain);
+    const result = await wdkService.deriveAddress(seed, chain2);
     return result.address;
   }
   /**
@@ -2123,14 +2884,14 @@ var WalletManager = class _WalletManager {
    *
    * @throws Error for non-Ethereum chains - use WDK API instead
    */
-  static deriveAddressForChain(seed, chain) {
-    if (chain === "ethereum") {
+  static deriveAddressForChain(seed, chain2) {
+    if (chain2 === "ethereum") {
       const ethPath = DERIVATION_PATHS["ethereum"];
       const ethNode = ethers.HDNodeWallet.fromPhrase(seed, void 0, `${ethPath}/0`);
       return ethNode.address;
     }
     throw new Error(
-      `Sync derivation not supported for ${chain}. Use deriveAddressForChainAsync() with WDK API.`
+      `Sync derivation not supported for ${chain2}. Use deriveAddressForChainAsync() with WDK API.`
     );
   }
   /**
@@ -2162,9 +2923,9 @@ var WalletManager = class _WalletManager {
       const wdkAddresses = await this.wdkService.deriveAllAddresses(this.currentSeed);
       const enabledChainsSet = new Set(this.config.enabledChains);
       const addresses = {};
-      for (const [chain, address] of Object.entries(wdkAddresses)) {
-        if (enabledChainsSet.has(chain) && address) {
-          addresses[chain] = address;
+      for (const [chain2, address] of Object.entries(wdkAddresses)) {
+        if (enabledChainsSet.has(chain2) && address) {
+          addresses[chain2] = address;
         }
       }
       this.derivedAddresses = addresses;
@@ -2205,10 +2966,10 @@ var WalletManager = class _WalletManager {
    */
   normalizeAddresses(addresses) {
     const normalized = {};
-    for (const [chain, value] of Object.entries(addresses)) {
+    for (const [chain2, value] of Object.entries(addresses)) {
       const addr = this.normalizeAddress(value);
       if (addr) {
-        normalized[chain] = addr;
+        normalized[chain2] = addr;
       }
     }
     return normalized;
@@ -2261,20 +3022,20 @@ var WalletManager = class _WalletManager {
    * Get address for a specific chain
    * Returns cached address or null - use deriveAllAddressesAsync to derive addresses
    */
-  getAddressForChain(chain) {
-    const cachedValue = this.derivedAddresses[chain];
+  getAddressForChain(chain2) {
+    const cachedValue = this.derivedAddresses[chain2];
     if (cachedValue) {
-      console.log(`[WalletManager] getAddressForChain(${chain}) cached value:`, cachedValue, "type:", typeof cachedValue);
+      console.log(`[WalletManager] getAddressForChain(${chain2}) cached value:`, cachedValue, "type:", typeof cachedValue);
       const addr = this.normalizeAddress(cachedValue);
-      console.log(`[WalletManager] getAddressForChain(${chain}) normalized:`, addr);
+      console.log(`[WalletManager] getAddressForChain(${chain2}) normalized:`, addr);
       if (addr) {
-        this.derivedAddresses[chain] = addr;
+        this.derivedAddresses[chain2] = addr;
         return addr;
       }
     }
-    if (chain === "ethereum" && this.currentSeed) {
-      this.derivedAddresses[chain] = _WalletManager.deriveAddressForChain(this.currentSeed, chain);
-      return this.derivedAddresses[chain];
+    if (chain2 === "ethereum" && this.currentSeed) {
+      this.derivedAddresses[chain2] = _WalletManager.deriveAddressForChain(this.currentSeed, chain2);
+      return this.derivedAddresses[chain2];
     }
     return null;
   }
@@ -2287,11 +3048,11 @@ var WalletManager = class _WalletManager {
   /**
    * Set the selected chain
    */
-  setSelectedChain(chain) {
-    if (!this.config.enabledChains.includes(chain)) {
-      throw new Error(`Chain ${chain} is not enabled`);
+  setSelectedChain(chain2) {
+    if (!this.config.enabledChains.includes(chain2)) {
+      throw new Error(`Chain ${chain2} is not enabled`);
     }
-    this.selectedChain = chain;
+    this.selectedChain = chain2;
   }
   /**
    * Get the currently selected chain
@@ -2308,42 +3069,69 @@ var WalletManager = class _WalletManager {
   /**
    * Get chain configuration
    */
-  getChainConfig(chain) {
-    return getNetworkConfig(chain, this.config.network === "testnet");
+  getChainConfig(chain2) {
+    return getNetworkConfig(chain2, this.config.network === "testnet");
   }
   /**
    * Fetch balance for a specific chain
    * Note: Currently only Ethereum is implemented
    */
-  async fetchBalanceForChain(chain) {
-    const address = this.getAddressForChain(chain);
+  async fetchBalanceForChain(chain2) {
+    const address = this.getAddressForChain(chain2);
     if (!address) {
-      throw new Error(`No address for chain ${chain}`);
+      throw new Error(`No address for chain ${chain2}`);
     }
-    const networkConfig = this.getChainConfig(chain);
+    const networkConfig = this.getChainConfig(chain2);
     let balance = "0";
-    if (chain === "ethereum") {
+    const tokenBalances = {};
+    if (chain2 === "ethereum") {
       const viemChain = this.config.network === "mainnet" ? chains.mainnet : chains.sepolia;
-      console.log(`[WalletManager] Fetching ${chain} balance for ${address} using RPC: ${this.config.rpcUrl}`);
+      const isTestnet = this.config.network !== "mainnet";
       const client = viem.createPublicClient({
         chain: viemChain,
         transport: viem.http(this.config.rpcUrl, {
           timeout: 15e3,
-          // 15 second timeout
           retryCount: 2,
           retryDelay: 1e3
         })
       });
-      try {
-        const rawBalance = await client.getBalance({
-          address
-        });
-        balance = viem.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?.[isTestnet ? "testnet" : "mainnet"];
+      const erc20BalanceOfAbi = [{
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }]
+      }];
+      const checksumAddr = viem.getAddress(address);
+      const [ethResult, usdtResult] = await Promise.allSettled([
+        client.getBalance({ address: checksumAddr }),
+        usdtAddr ? client.readContract({
+          address: viem.getAddress(usdtAddr),
+          abi: erc20BalanceOfAbi,
+          functionName: "balanceOf",
+          args: [checksumAddr]
+        }) : Promise.resolve(null)
+      ]);
+      if (ethResult.status === "fulfilled") {
+        balance = viem.formatEther(ethResult.value);
+      } else {
+        console.error(`[WalletManager] Failed to fetch ETH balance:`, ethResult.reason);
       }
-    } else if (chain === "bitcoin") {
+      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 (chain2 === "bitcoin") {
       const isMainnet = this.config.network === "mainnet" || address.startsWith("bc1") || address.startsWith("1") || address.startsWith("3");
       const apisToTry = isMainnet ? ["https://mempool.space/api"] : [
         "https://mempool.space/testnet/api",
@@ -2375,7 +3163,7 @@ var WalletManager = class _WalletManager {
           console.warn(`Failed to fetch from ${apiUrl}:`, error);
         }
       }
-    } else if (chain === "solana") {
+    } else if (chain2 === "solana") {
       const rpcUrl = this.config.network === "mainnet" ? "https://api.mainnet-beta.solana.com" : "https://api.devnet.solana.com";
       try {
         const response = await fetch(rpcUrl, {
@@ -2395,10 +3183,43 @@ var WalletManager = class _WalletManager {
           }
         }
       } catch (error) {
-        console.warn(`Failed to fetch ${chain} balance:`, error);
+        console.warn(`Failed to fetch ${chain2} balance:`, error);
+      }
+      const isTestnet = this.config.network !== "mainnet";
+      const usdtMint = USDT_ADDRESSES.solana?.[isTestnet ? "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";
+    } else if (chain2 === "tron") {
+      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" }
@@ -2408,12 +3229,28 @@ var WalletManager = class _WalletManager {
           if (data.data?.[0]?.balance !== void 0) {
             balance = (data.data[0].balance / 1e6).toFixed(6);
           }
+          const isTestnet = this.config.network !== "mainnet";
+          const usdtAddr = USDT_ADDRESSES.tron?.[isTestnet ? "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);
+        console.warn(`Failed to fetch ${chain2} balance:`, error);
       }
-    } else if (chain === "ton") {
-      const baseUrl = this.config.network === "mainnet" ? "https://toncenter.com/api/v2" : "https://testnet.toncenter.com/api/v2";
+    } else if (chain2 === "ton") {
+      const isTestnet = this.config.network !== "mainnet";
+      const baseUrl = isTestnet ? "https://testnet.toncenter.com/api/v2" : "https://toncenter.com/api/v2";
       try {
         const response = await fetch(`${baseUrl}/getAddressBalance?address=${address}`, {
           headers: { "Accept": "application/json" }
@@ -2427,9 +3264,34 @@ var WalletManager = class _WalletManager {
           }
         }
       } catch (error) {
-        console.warn(`Failed to fetch ${chain} balance:`, error);
+        console.warn(`Failed to fetch ${chain2} balance:`, error);
+      }
+      const usdtJetton = USDT_ADDRESSES.ton?.[isTestnet ? "testnet" : "mainnet"];
+      if (usdtJetton) {
+        const v3BaseUrl = isTestnet ? "https://testnet.toncenter.com/api/v3" : "https://toncenter.com/api/v3";
+        try {
+          const jettonResponse = await fetch(
+            `${v3BaseUrl}/jetton/wallets?owner_address=${address}&jetton_address=${usdtJetton}&limit=1`,
+            { headers: { "Accept": "application/json" } }
+          );
+          if (jettonResponse.ok) {
+            const jettonData = await jettonResponse.json();
+            const wallets = jettonData.jetton_wallets;
+            if (wallets && wallets.length > 0) {
+              const rawBalance = wallets[0].balance;
+              if (rawBalance) {
+                const usdtAmount = Number(BigInt(rawBalance)) / 1e6;
+                if (usdtAmount > 0) {
+                  tokenBalances.USDT = { balance: usdtAmount.toFixed(6), balanceUsd: usdtAmount };
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.warn("Failed to fetch TON USDT jetton balance:", error);
+        }
       }
-    } else if (chain === "spark") {
+    } else if (chain2 === "spark") {
       try {
         const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/balance`, {
           method: "POST",
@@ -2448,19 +3310,20 @@ var WalletManager = class _WalletManager {
           }
         }
       } catch (error) {
-        console.warn(`Failed to fetch ${chain} balance:`, error);
+        console.warn(`Failed to fetch ${chain2} balance:`, error);
       }
     }
-    const priceUsd = await getPriceForChain(chain);
+    const priceUsd = await getPriceForChain(chain2);
     const balanceNum = parseFloat(balance) || 0;
     const balanceUsd = balanceNum * priceUsd;
     return {
-      chain,
+      chain: chain2,
       symbol: networkConfig.nativeCurrency.symbol,
       balance,
       balanceUsd,
       address,
-      decimals: networkConfig.nativeCurrency.decimals
+      decimals: networkConfig.nativeCurrency.decimals,
+      ...Object.keys(tokenBalances).length > 0 ? { tokenBalances } : {}
     };
   }
   /**
@@ -2468,19 +3331,19 @@ var WalletManager = class _WalletManager {
    */
   async fetchAllBalances() {
     const balances = [];
-    for (const chain of this.config.enabledChains) {
+    for (const chain2 of this.config.enabledChains) {
       try {
-        const balance = await this.fetchBalanceForChain(chain);
+        const balance = await this.fetchBalanceForChain(chain2);
         balances.push(balance);
       } catch (error) {
-        console.error(`Failed to fetch balance for ${chain}:`, error);
-        const networkConfig = this.getChainConfig(chain);
+        console.error(`Failed to fetch balance for ${chain2}:`, error);
+        const networkConfig = this.getChainConfig(chain2);
         balances.push({
-          chain,
+          chain: chain2,
           symbol: networkConfig.nativeCurrency.symbol,
           balance: "0",
           balanceUsd: 0,
-          address: this.getAddressForChain(chain) || "",
+          address: this.getAddressForChain(chain2) || "",
           decimals: networkConfig.nativeCurrency.decimals
         });
       }
@@ -2510,13 +3373,13 @@ var WalletManager = class _WalletManager {
    * @param token - Optional token symbol (e.g., 'USDT' for stablecoins)
    * @returns Transaction result with hash and status
    */
-  async sendTransaction(chain, to, amount, token) {
+  async sendTransaction(chain2, to, amount, token) {
     if (!this.currentSeed) {
       return { success: false, error: "Wallet is locked" };
     }
-    const fromAddress = this.getAddressForChain(chain);
+    const fromAddress = this.getAddressForChain(chain2);
     if (!fromAddress) {
-      return { success: false, error: `No address for chain ${chain}` };
+      return { success: false, error: `No address for chain ${chain2}` };
     }
     try {
       const headers = {
@@ -2530,7 +3393,7 @@ var WalletManager = class _WalletManager {
         headers,
         body: JSON.stringify({
           seed: this.currentSeed,
-          chain,
+          chain: chain2,
           to,
           amount,
           token,
@@ -2539,12 +3402,12 @@ var WalletManager = class _WalletManager {
       });
       if (response.ok) {
         const data = await response.json();
-        console.log(`Transaction sent on ${chain}:`, data);
+        console.log(`Transaction sent on ${chain2}:`, data);
         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)) {
+        if (chain2 === "ethereum" && txHash && (typeof txHash !== "string" || !txHash.startsWith("0x") || txHash.length !== 66)) {
           console.warn(`Invalid Ethereum tx hash format: ${txHash} (length: ${txHash?.length}, expected: 66)`);
         }
         return {
@@ -2553,7 +3416,7 @@ var WalletManager = class _WalletManager {
           from: fromAddress,
           to,
           amount,
-          chain
+          chain: chain2
         };
       }
       const errorData = await response.json().catch(() => ({}));
@@ -2562,7 +3425,7 @@ var WalletManager = class _WalletManager {
         error: errorData.error || `HTTP ${response.status}`
       };
     } catch (error) {
-      console.error(`Transaction failed on ${chain}:`, error);
+      console.error(`Transaction failed on ${chain2}:`, error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Transaction failed"
@@ -2572,7 +3435,7 @@ var WalletManager = class _WalletManager {
   /**
    * Estimate transaction fee using Tether WDK
    */
-  async estimateFee(chain, to, amount, token) {
+  async estimateFee(chain2, to, amount, token) {
     try {
       const headers = {
         "Content-Type": "application/json"
@@ -2584,7 +3447,7 @@ var WalletManager = class _WalletManager {
         method: "POST",
         headers,
         body: JSON.stringify({
-          chain,
+          chain: chain2,
           to,
           amount,
           token,
@@ -2608,6 +3471,14 @@ var WalletManager = class _WalletManager {
     }
   }
 };
+/*! Bundled license information:
+
+@scure/base/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@scure/bip32/index.js:
+  (*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
+*/
 
 exports.SUPPORTED_CHAINS = SUPPORTED_CHAINS;
 exports.WalletManager = WalletManager;