@zubari/sdk 0.5.6 → 0.5.8

package/dist/index.mjs

@@ -1,4 +1,10 @@
 import { HDNodeWallet, Wallet } from 'ethers';
+import { mnemonicToSeedSync, validateMnemonic, generateMnemonic } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+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, getAddress } from 'viem';
 import { mainnet, sepolia } from 'viem/chains';
 
@@ -604,37 +610,12 @@ var DERIVATION_PATHS2 = {
   solana: `${DERIVATION_PATHS.solana}/0'`,
   spark: `${DERIVATION_PATHS.spark}/0`
 };
-var _crypto = null;
-async function loadCrypto() {
-  if (_crypto) return _crypto;
-  const [bip39, bip39Words, bip32, scureBase, sha256Mod, ripemd160Mod] = await Promise.all([
-    import('@scure/bip39'),
-    import('@scure/bip39/wordlists/english'),
-    import('@scure/bip32'),
-    import('@scure/base'),
-    import('@noble/hashes/sha256'),
-    import('@noble/hashes/ripemd160')
-  ]);
-  _crypto = {
-    mnemonicToSeedSync: bip39.mnemonicToSeedSync,
-    validateMnemonic: bip39.validateMnemonic,
-    generateMnemonic: bip39.generateMnemonic,
-    wordlist: bip39Words.wordlist,
-    HDKey: bip32.HDKey,
-    bech32: scureBase.bech32,
-    base58check: scureBase.base58check,
-    sha256: sha256Mod.sha256,
-    ripemd160: ripemd160Mod.ripemd160
-  };
-  return _crypto;
-}
 function deriveEthereumAddress(seed) {
   const hdNode = HDNodeWallet.fromPhrase(seed, void 0, DERIVATION_PATHS2.ethereum);
   return hdNode.address;
 }
-async function deriveBitcoinAddress(seed, network = "mainnet") {
+function deriveBitcoinAddress(seed, network = "mainnet") {
   try {
-    const { mnemonicToSeedSync, HDKey, sha256, ripemd160, bech32 } = await loadCrypto();
     const seedBytes = mnemonicToSeedSync(seed);
     const hdKey = HDKey.fromMasterSeed(seedBytes);
     const path = network === "testnet" ? DERIVATION_PATHS2.bitcoin_testnet : DERIVATION_PATHS2.bitcoin_mainnet;
@@ -656,14 +637,13 @@ async function deriveBitcoinAddress(seed, network = "mainnet") {
 }
 async function deriveSolanaAddress(seed) {
   try {
-    const [crypto2, ed25519, nacl, bs58Module] = await Promise.all([
-      loadCrypto(),
+    const [ed25519, nacl, bs58Module] = await Promise.all([
       import('ed25519-hd-key'),
       import('tweetnacl'),
       import('bs58')
     ]);
     const bs58 = bs58Module.default || bs58Module;
-    const seedBytes = crypto2.mnemonicToSeedSync(seed);
+    const seedBytes = mnemonicToSeedSync(seed);
     const derived = ed25519.derivePath(DERIVATION_PATHS2.solana, Buffer.from(seedBytes).toString("hex"));
     const keypair = nacl.sign.keyPair.fromSeed(new Uint8Array(derived.key));
     return bs58.encode(keypair.publicKey);
@@ -674,18 +654,17 @@ async function deriveSolanaAddress(seed) {
 }
 async function deriveTonAddress(seed) {
   try {
-    const [crypto2, ed25519, nacl] = await Promise.all([
-      loadCrypto(),
+    const [ed25519, nacl] = await Promise.all([
       import('ed25519-hd-key'),
       import('tweetnacl')
     ]);
-    const seedBytes = crypto2.mnemonicToSeedSync(seed);
+    const seedBytes = mnemonicToSeedSync(seed);
     const derived = ed25519.derivePath(DERIVATION_PATHS2.ton, Buffer.from(seedBytes).toString("hex"));
     const keypair = nacl.sign.keyPair.fromSeed(new Uint8Array(derived.key));
     const publicKey = keypair.publicKey;
     const workchain = 0;
     const flags = 17;
-    const hash = crypto2.sha256(publicKey);
+    const hash = sha256(publicKey);
     const addressData = new Uint8Array(34);
     addressData[0] = flags;
     addressData[1] = workchain;
@@ -713,9 +692,8 @@ function crc16(data) {
   }
   return crc;
 }
-async function deriveTronAddress(seed) {
+function deriveTronAddress(seed) {
   try {
-    const { sha256, base58check } = await loadCrypto();
     const hdNode = HDNodeWallet.fromPhrase(seed, void 0, DERIVATION_PATHS2.tron);
     const ethAddressHex = hdNode.address.slice(2).toLowerCase();
     const addressBytes = new Uint8Array(21);
@@ -730,9 +708,8 @@ async function deriveTronAddress(seed) {
     throw error;
   }
 }
-async function deriveSparkAddress(seed, network = "mainnet") {
+function deriveSparkAddress(seed, network = "mainnet") {
   try {
-    const { mnemonicToSeedSync, HDKey, sha256, ripemd160, bech32 } = await loadCrypto();
     const seedBytes = mnemonicToSeedSync(seed);
     const hdKey = HDKey.fromMasterSeed(seedBytes);
     const child = hdKey.derive(DERIVATION_PATHS2.spark);
@@ -760,37 +737,46 @@ async function deriveAllAddresses(seed, network = "mainnet") {
     solana: null,
     spark: null
   };
-  await loadCrypto();
   try {
     addresses.ethereum = deriveEthereumAddress(seed);
   } catch (e) {
     console.error("ETH derivation failed:", e);
   }
-  const [btcResult, sparkResult, tronResult, solResult, tonResult] = await Promise.allSettled([
-    deriveBitcoinAddress(seed, network),
-    deriveSparkAddress(seed, network),
-    deriveTronAddress(seed),
+  try {
+    addresses.bitcoin = deriveBitcoinAddress(seed, network);
+  } catch (e) {
+    console.error("BTC derivation failed:", e);
+  }
+  try {
+    addresses.spark = deriveSparkAddress(seed, network);
+  } catch (e) {
+    console.error("Spark derivation failed:", e);
+  }
+  try {
+    addresses.tron = deriveTronAddress(seed);
+  } catch (e) {
+    console.error("TRON derivation failed:", e);
+  }
+  const [solResult, tonResult] = await Promise.allSettled([
     deriveSolanaAddress(seed),
     deriveTonAddress(seed)
   ]);
-  if (btcResult.status === "fulfilled") addresses.bitcoin = btcResult.value;
-  else console.error("BTC derivation failed:", btcResult.reason);
-  if (sparkResult.status === "fulfilled") addresses.spark = sparkResult.value;
-  else console.error("Spark derivation failed:", sparkResult.reason);
-  if (tronResult.status === "fulfilled") addresses.tron = tronResult.value;
-  else console.error("TRON derivation failed:", tronResult.reason);
-  if (solResult.status === "fulfilled") addresses.solana = solResult.value;
-  else console.error("SOL derivation failed:", solResult.reason);
-  if (tonResult.status === "fulfilled") addresses.ton = tonResult.value;
-  else console.error("TON derivation failed:", tonResult.reason);
+  if (solResult.status === "fulfilled") {
+    addresses.solana = solResult.value;
+  } else {
+    console.error("SOL derivation failed:", solResult.reason);
+  }
+  if (tonResult.status === "fulfilled") {
+    addresses.ton = tonResult.value;
+  } else {
+    console.error("TON derivation failed:", tonResult.reason);
+  }
   return addresses;
 }
-async function isValidSeed(seed) {
-  const { validateMnemonic, wordlist } = await loadCrypto();
+function isValidSeed(seed) {
   return validateMnemonic(seed, wordlist);
 }
-async function generateSeedPhrase() {
-  const { generateMnemonic, wordlist } = await loadCrypto();
+function generateSeedPhrase() {
   return generateMnemonic(wordlist);
 }
 
@@ -1034,7 +1020,7 @@ var ZubariWdkService = class {
         };
         if (!addresses.spark) {
           try {
-            addresses.spark = await deriveSparkAddress(seed, this.config.network);
+            addresses.spark = deriveSparkAddress(seed, this.config.network);
           } catch (e) {
             console.warn("Browser Spark derivation fallback failed:", e);
           }
@@ -1270,13 +1256,13 @@ var ZubariWdkService = class {
           address = deriveEthereumAddress(seed);
           break;
         case "bitcoin":
-          address = await deriveBitcoinAddress(seed, this.config.network);
+          address = deriveBitcoinAddress(seed, this.config.network);
           break;
         case "tron":
-          address = await deriveTronAddress(seed);
+          address = deriveTronAddress(seed);
           break;
         case "spark":
-          address = await deriveSparkAddress(seed, this.config.network);
+          address = deriveSparkAddress(seed, this.config.network);
           break;
         case "solana":
           address = await deriveSolanaAddress(seed);
@@ -2234,7 +2220,9 @@ var WalletManager = class _WalletManager {
       storage: config.storage || createSecureStorage(),
       enabledChains: config.enabledChains || SUPPORTED_CHAINS,
       apiUrl: config.apiUrl || process.env.NEXT_PUBLIC_API_URL || "https://ckgwifsxka.us-east-2.awsapprunner.com",
-      accessToken: config.accessToken
+      accessToken: config.accessToken,
+      chainRpcUrls: config.chainRpcUrls || {},
+      tronApiKey: config.tronApiKey
     };
     this.storage = this.config.storage;
     this.wdkService = getZubariWdkService({
@@ -2796,7 +2784,7 @@ var WalletManager = class _WalletManager {
         }
       }
     } else if (chain === "solana") {
-      const rpcUrl = this.config.network === "mainnet" ? "https://api.mainnet-beta.solana.com" : "https://api.devnet.solana.com";
+      const rpcUrl = this.config.chainRpcUrls.solana || (this.config.network === "mainnet" ? "https://api.mainnet-beta.solana.com" : "https://api.devnet.solana.com");
       try {
         const response = await fetch(rpcUrl, {
           method: "POST",
@@ -2853,8 +2841,12 @@ var WalletManager = class _WalletManager {
       const tronConfig = getNetworkConfig("tron", this.config.network !== "mainnet");
       const baseUrl = tronConfig.rpcUrl;
       try {
+        const tronHeaders = { "Accept": "application/json" };
+        if (this.config.tronApiKey) {
+          tronHeaders["TRON-PRO-API-KEY"] = this.config.tronApiKey;
+        }
         const response = await fetch(`${baseUrl}/v1/accounts/${address}`, {
-          headers: { "Accept": "application/json" }
+          headers: tronHeaders
         });
         if (response.ok) {
           const data = await response.json();
@@ -2980,7 +2972,7 @@ var WalletManager = class _WalletManager {
       if (result.status === "fulfilled") {
         return result.value;
       }
-      console.error(`Failed to fetch balance for ${chain}:`, result.reason);
+      console.warn(`Failed to fetch balance for ${chain}:`, result.reason);
       const networkConfig = this.getChainConfig(chain);
       return {
         chain,