@zubari/sdk 0.2.7 → 0.3.0

package/dist/wallet/index.js

@@ -1,14 +1,14 @@
 'use strict';
 
 var ethers = require('ethers');
-var viem = require('viem');
-var chains = require('viem/chains');
 var bip39 = require('@scure/bip39');
 var english = require('@scure/bip39/wordlists/english');
 var bip32 = require('@scure/bip32');
 var base = require('@scure/base');
 var sha256 = require('@noble/hashes/sha256');
 var ripemd160 = require('@noble/hashes/ripemd160');
+var viem = require('viem');
+var chains = require('viem/chains');
 
 // src/config/networks.ts
 var NETWORKS = {
@@ -140,9 +140,12 @@ function getNetworkConfig(network, isTestnet = false) {
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var ZUBARI_CONTRACTS = {
   testnet: {
-    // Ethereum Sepolia (11155111) - Deployed 2024-12-30
+    // Ethereum Sepolia (11155111) - Deployed 2024-12-31
     registry: "0xe5CE1Eb986f58BE42EEDFe5C18ee5956803b2BDC",
-    nft: "0xCb1AB134a75c4D504792233efC5dE949aDE3f29f",
+    nft: "0xc165b8C6843e8f0B1489525D0f853d23f22c677B",
+    // ZubariNFT ERC-721 with payment
+    nft1155: "0x5e618B5bEaE1dc41369E7aa235Cc3b9245905192",
+    // Zubari1155 ERC-1155 multi-edition
     marketplace: "0xfcEfDa6C73aC357b8695E5F8F8d17820750BF207",
     tips: "0x86a9A306C7fCC9e0B8cd6859f6f15498d0046BB7",
     subscriptions: "0xaB7F17A85F61d9ab9f96bCB4e73e910D019978F7",
@@ -160,6 +163,7 @@ var ZUBARI_CONTRACTS = {
     // Ethereum Mainnet (1)
     registry: ZERO_ADDRESS,
     nft: ZERO_ADDRESS,
+    nft1155: ZERO_ADDRESS,
     marketplace: ZERO_ADDRESS,
     tips: ZERO_ADDRESS,
     subscriptions: ZERO_ADDRESS,
@@ -176,1292 +180,1539 @@ function getContractAddresses(network) {
   return ZUBARI_CONTRACTS[network];
 }
 
-// src/wallet/ZubariWallet.ts
-var ZubariWallet = class {
-  seed;
+// src/services/WdkApiClient.ts
+var WdkApiClient = class {
   config;
-  accounts = /* @__PURE__ */ new Map();
-  initialized = false;
-  constructor(seed, config) {
-    this.seed = seed;
+  constructor(config) {
     this.config = {
-      network: config.network || "mainnet",
-      enabledNetworks: config.enabledNetworks || ["ethereum"],
-      gasless: config.gasless ?? false,
-      paymasterUrl: config.paymasterUrl,
-      bundlerUrl: config.bundlerUrl,
-      rpcUrls: config.rpcUrls
-    };
-  }
-  /**
-   * Initialize the wallet by deriving accounts for all enabled networks
-   */
-  async initialize() {
-    if (this.initialized) return;
-    for (const network of this.config.enabledNetworks) {
-      await this.deriveAccount(network);
-    }
-    this.initialized = true;
-  }
-  /**
-   * Derive account for a specific network using BIP-44
-   */
-  async deriveAccount(network, index = 0) {
-    getNetworkConfig(network, this.config.network === "testnet");
-    const basePath = DERIVATION_PATHS[network];
-    const derivationPath = `${basePath}/${index}`;
-    const account = {
-      network,
-      address: "",
-      // Will be derived using WDK
-      publicKey: "",
-      derivationPath
+      baseUrl: config.baseUrl,
+      timeout: config.timeout || 3e4
     };
-    this.accounts.set(network, account);
-    return account;
   }
   /**
-   * Get account for a specific network
+   * Generate a new BIP-39 seed phrase using Tether WDK
    */
-  async getAccount(network, index = 0) {
-    const existing = this.accounts.get(network);
-    if (existing && existing.derivationPath.endsWith(`/${index}`)) {
-      return existing;
+  async generateSeed() {
+    try {
+      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/generate-seed`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to generate seed"
+      };
     }
-    return this.deriveAccount(network, index);
-  }
-  /**
-   * Get address for a specific network
-   */
-  async getAddress(network) {
-    const account = await this.getAccount(network);
-    return account.address;
   }
   /**
-   * Get all addresses for enabled networks
+   * Validate a BIP-39 seed phrase
    */
-  async getAllAddresses() {
-    const addresses = {};
-    for (const network of this.config.enabledNetworks) {
-      addresses[network] = await this.getAddress(network);
+  async validateSeed(seed) {
+    try {
+      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/validate-seed`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ seed })
+      });
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to validate seed"
+      };
     }
-    return addresses;
-  }
-  /**
-   * Get balance for a specific network
-   */
-  async getBalance(network) {
-    const networkConfig = getNetworkConfig(network, this.config.network === "testnet");
-    return {
-      network,
-      native: {
-        symbol: networkConfig.nativeCurrency.symbol,
-        balance: BigInt(0),
-        balanceFormatted: "0",
-        balanceUsd: 0
-      },
-      tokens: []
-    };
   }
   /**
-   * Get balances for all enabled networks
+   * Derive address for a specific chain using Tether WDK
    */
-  async getAllBalances() {
-    const balances = [];
-    for (const network of this.config.enabledNetworks) {
-      balances.push(await this.getBalance(network));
+  async deriveAddress(seed, chain, network = "testnet") {
+    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 })
+      });
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to derive address"
+      };
     }
-    return balances;
   }
   /**
-   * Get total portfolio value in USD
+   * Derive addresses for all chains using Tether WDK
    */
-  async getTotalPortfolioUsd() {
-    const balances = await this.getAllBalances();
-    let total = 0;
-    for (const balance of balances) {
-      total += balance.native.balanceUsd;
-      for (const token of balance.tokens) {
-        total += token.balanceUsd;
-      }
+  async deriveAllAddresses(seed, network = "testnet") {
+    try {
+      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/derive-all`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ seed, network })
+      });
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to derive addresses"
+      };
     }
-    return total;
-  }
-  /**
-   * Send native currency on a specific network
-   */
-  async send(network, params) {
-    const { to, amount, gasless } = params;
-    gasless ?? (this.config.gasless && network === "ethereum");
-    return {
-      hash: "",
-      network,
-      status: "pending"
-    };
   }
   /**
-   * Send ERC-20 token on EVM networks
+   * Send a transaction on a specific chain using Tether WDK
    */
-  async sendToken(network, token, to, amount) {
-    const networkConfig = getNetworkConfig(network, this.config.network === "testnet");
-    if (!networkConfig.isEvm) {
-      throw new Error(`sendToken is only supported on EVM networks. ${network} is not an EVM chain.`);
+  async sendTransaction(seed, chain, to, amount, network = "testnet") {
+    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 })
+      });
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to send transaction"
+      };
     }
-    return {
-      hash: "",
-      network,
-      status: "pending"
-    };
   }
   /**
-   * Send Bitcoin on-chain using WalletManagerBtc
-   * @param to - Destination address (bc1q... for native segwit)
-   * @param amount - Amount in satoshis
+   * Get transaction history for an address on a specific chain
+   * Fetches from blockchain explorers (Etherscan, mempool.space, etc.)
    */
-  async sendBitcoin(to, amount) {
-    if (!this.isValidBitcoinAddress(to)) {
-      throw new Error("Invalid Bitcoin address. Expected bc1q... (native segwit) format.");
+  async getTransactionHistory(seed, chain, network = "testnet", 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 })
+      });
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get transaction history"
+      };
     }
-    return this.send("bitcoin", { to, amount });
   }
   /**
-   * Validate Bitcoin address format
+   * Get transaction status by hash
+   * Fetches from blockchain explorers to check confirmation status
    */
-  isValidBitcoinAddress(address) {
-    if (address.startsWith("bc1q") || address.startsWith("tb1q")) {
-      return address.length >= 42 && address.length <= 62;
-    }
-    if (address.startsWith("1") || address.startsWith("m") || address.startsWith("n")) {
-      return address.length >= 25 && address.length <= 34;
-    }
-    if (address.startsWith("3") || address.startsWith("2")) {
-      return address.length >= 25 && address.length <= 34;
+  async getTransactionStatus(txHash, chain, network = "testnet") {
+    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 })
+      });
+      return await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get transaction status"
+      };
     }
-    return false;
-  }
-  /**
-   * Get Bitcoin address (native segwit bc1q...)
-   */
-  async getBitcoinAddress() {
-    const account = await this.getAccount("bitcoin");
-    return account.address;
   }
-  /**
-   * Pay Lightning invoice via Spark network
-   * Uses WDK WalletManagerSpark (m/44'/998')
-   * @param invoice - Lightning invoice string (lnbc...)
-   */
-  async sendLightning(invoice) {
-    if (!this.isValidLightningInvoice(invoice)) {
-      throw new Error("Invalid Lightning invoice format. Expected lnbc... or lntb...");
-    }
-    const invoiceDetails = this.decodeLightningInvoice(invoice);
-    return {
-      hash: "",
-      // Will be payment hash from Spark
-      network: "spark",
-      status: "pending",
-      metadata: {
-        invoice,
-        amount: invoiceDetails.amount,
-        destination: invoiceDetails.destination
-      }
-    };
+};
+var DEFAULT_API_URL = process.env.NEXT_PUBLIC_API_URL || "https://ckgwifsxka.us-east-2.awsapprunner.com";
+var wdkApiClient = null;
+function getWdkApiClient(baseUrl) {
+  if (!wdkApiClient || baseUrl && wdkApiClient["config"].baseUrl !== baseUrl) {
+    wdkApiClient = new WdkApiClient({
+      baseUrl: baseUrl || DEFAULT_API_URL
+    });
   }
-  /**
-   * Create Lightning invoice via Spark
-   * @param amount - Amount in millisatoshis
-   * @param memo - Optional payment memo
-   * @returns Lightning invoice string (lnbc...)
-   */
-  async createLightningInvoice(amount, memo) {
-    if (amount <= 0) {
-      throw new Error("Invoice amount must be greater than 0");
+  return wdkApiClient;
+}
+var DERIVATION_PATHS2 = {
+  ethereum: "m/44'/60'/0'/0/0",
+  bitcoin_mainnet: "m/84'/0'/0'/0/0",
+  bitcoin_testnet: "m/84'/1'/0'/0/0",
+  ton: "m/44'/607'/0'/0'/0'",
+  tron: "m/44'/195'/0'/0/0",
+  solana: "m/44'/501'/0'/0'",
+  spark: "m/44'/998'/0'/0/0"
+};
+function deriveEthereumAddress(seed) {
+  const hdNode = ethers.HDNodeWallet.fromPhrase(seed, void 0, DERIVATION_PATHS2.ethereum);
+  return hdNode.address;
+}
+function deriveBitcoinAddress(seed, network = "testnet") {
+  try {
+    const seedBytes = bip39.mnemonicToSeedSync(seed);
+    const hdKey = bip32.HDKey.fromMasterSeed(seedBytes);
+    const path = network === "testnet" ? DERIVATION_PATHS2.bitcoin_testnet : DERIVATION_PATHS2.bitcoin_mainnet;
+    const child = hdKey.derive(path);
+    if (!child.publicKey) {
+      throw new Error("Failed to derive public key");
     }
-    const isTestnet = this.config.network === "testnet";
-    const prefix = isTestnet ? "lntb" : "lnbc";
-    return `${prefix}${amount}m1...`;
+    const pubKeyHash = ripemd160.ripemd160(sha256.sha256(child.publicKey));
+    const witnessVersion = 0;
+    const words = base.bech32.toWords(pubKeyHash);
+    words.unshift(witnessVersion);
+    const hrp = network === "testnet" ? "tb" : "bc";
+    const address = base.bech32.encode(hrp, words);
+    return address;
+  } catch (error) {
+    console.error("Bitcoin address derivation failed:", error);
+    throw error;
   }
-  /**
-   * Validate Lightning invoice format
-   */
-  isValidLightningInvoice(invoice) {
-    const lowerInvoice = invoice.toLowerCase();
-    return lowerInvoice.startsWith("lnbc") || // Mainnet
-    lowerInvoice.startsWith("lntb") || // Testnet
-    lowerInvoice.startsWith("lnbcrt");
+}
+async function deriveSolanaAddress(seed) {
+  try {
+    const [ed25519, nacl, bs58Module] = await Promise.all([
+      import('ed25519-hd-key'),
+      import('tweetnacl'),
+      import('bs58')
+    ]);
+    const bs58 = bs58Module.default || bs58Module;
+    const seedBytes = bip39.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);
+  } catch (error) {
+    console.error("Solana address derivation failed:", error);
+    throw error;
   }
-  /**
-   * Decode Lightning invoice (basic parsing)
-   */
-  decodeLightningInvoice(invoice) {
-    return {
-      amount: BigInt(0),
-      destination: "",
-      expiry: 3600
-    };
+}
+async function deriveTonAddress(seed) {
+  try {
+    const [ed25519, nacl] = await Promise.all([
+      import('ed25519-hd-key'),
+      import('tweetnacl')
+    ]);
+    const seedBytes = bip39.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 = sha256.sha256(publicKey);
+    const addressData = new Uint8Array(34);
+    addressData[0] = flags;
+    addressData[1] = workchain;
+    addressData.set(hash, 2);
+    const crc = crc16(addressData);
+    const fullAddress = new Uint8Array(36);
+    fullAddress.set(addressData);
+    fullAddress[34] = crc >> 8 & 255;
+    fullAddress[35] = crc & 255;
+    const base64 = btoa(String.fromCharCode(...fullAddress)).replace(/\+/g, "-").replace(/\//g, "_");
+    return base64;
+  } catch (error) {
+    console.error("TON address derivation failed:", error);
+    throw error;
   }
-  /**
-   * Get Lightning (Spark) balance
-   */
-  async getLightningBalance() {
-    return {
-      available: BigInt(0),
-      pending: BigInt(0)
-    };
+}
+function crc16(data) {
+  let crc = 0;
+  for (const byte of data) {
+    crc ^= byte << 8;
+    for (let i = 0; i < 8; i++) {
+      crc = crc & 32768 ? crc << 1 ^ 4129 : crc << 1;
+      crc &= 65535;
+    }
   }
-  /**
-   * Get configuration
-   */
-  getConfig() {
-    return { ...this.config };
+  return crc;
+}
+function deriveTronAddress(seed) {
+  try {
+    const hdNode = ethers.HDNodeWallet.fromPhrase(seed, void 0, DERIVATION_PATHS2.tron);
+    const ethAddressHex = hdNode.address.slice(2).toLowerCase();
+    const addressBytes = new Uint8Array(21);
+    addressBytes[0] = 65;
+    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);
+    return tronBase58check.encode(addressBytes);
+  } catch (error) {
+    console.error("TRON address derivation failed:", error);
+    throw error;
   }
-  /**
-   * Check if wallet is initialized
-   */
-  isInitialized() {
-    return this.initialized;
+}
+function deriveSparkAddress(seed, network = "testnet") {
+  try {
+    const seedBytes = bip39.mnemonicToSeedSync(seed);
+    const hdKey = bip32.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);
+    words.unshift(witnessVersion);
+    const hrp = network === "testnet" ? "tsp" : "sp";
+    const address = base.bech32.encode(hrp, words);
+    return address;
+  } catch (error) {
+    console.error("Spark address derivation failed:", error);
+    throw error;
   }
-  /**
-   * Get contract addresses for current network
-   */
-  getContractAddresses() {
-    return getContractAddresses(this.config.network);
+}
+async function deriveAllAddresses(seed, network = "testnet") {
+  const addresses = {
+    ethereum: null,
+    bitcoin: null,
+    ton: null,
+    tron: null,
+    solana: null,
+    spark: null
+  };
+  try {
+    addresses.ethereum = deriveEthereumAddress(seed);
+  } catch (e) {
+    console.error("ETH derivation failed:", e);
   }
-};
-
-// src/security/KeyManager.ts
-var KeyManager = class {
-  static ALGORITHM = "AES-GCM";
-  static KEY_LENGTH = 256;
-  static IV_LENGTH = 12;
-  static SALT_LENGTH = 16;
-  static PBKDF2_ITERATIONS = 1e5;
-  /**
-   * Encrypt a seed phrase with a password
-   */
-  static async encryptSeed(seed, password) {
-    const encoder = new TextEncoder();
-    const seedData = encoder.encode(seed);
-    const salt = crypto.getRandomValues(new Uint8Array(this.SALT_LENGTH));
-    const iv = crypto.getRandomValues(new Uint8Array(this.IV_LENGTH));
-    const key = await this.deriveKey(password, salt);
-    const encrypted = await crypto.subtle.encrypt(
-      { name: this.ALGORITHM, iv },
-      key,
-      seedData
-    );
-    const combined = new Uint8Array(salt.length + iv.length + encrypted.byteLength);
-    combined.set(salt, 0);
-    combined.set(iv, salt.length);
-    combined.set(new Uint8Array(encrypted), salt.length + iv.length);
-    return btoa(String.fromCharCode(...combined));
+  try {
+    addresses.bitcoin = deriveBitcoinAddress(seed, network);
+  } catch (e) {
+    console.error("BTC derivation failed:", e);
   }
-  /**
-   * Decrypt a seed phrase with a password
-   */
-  static async decryptSeed(encryptedData, password) {
-    const combined = new Uint8Array(
-      atob(encryptedData).split("").map((c) => c.charCodeAt(0))
-    );
-    const salt = combined.slice(0, this.SALT_LENGTH);
-    const iv = combined.slice(this.SALT_LENGTH, this.SALT_LENGTH + this.IV_LENGTH);
-    const encrypted = combined.slice(this.SALT_LENGTH + this.IV_LENGTH);
-    const key = await this.deriveKey(password, salt);
-    const decrypted = await crypto.subtle.decrypt(
-      { name: this.ALGORITHM, iv },
-      key,
-      encrypted
-    );
-    const decoder = new TextDecoder();
-    return decoder.decode(decrypted);
+  try {
+    addresses.spark = deriveSparkAddress(seed, network);
+  } catch (e) {
+    console.error("Spark derivation failed:", e);
   }
-  /**
-   * Derive encryption key from password using PBKDF2
-   */
-  static async deriveKey(password, salt) {
-    const encoder = new TextEncoder();
-    const passwordData = encoder.encode(password);
-    const keyMaterial = await crypto.subtle.importKey(
-      "raw",
-      passwordData,
-      "PBKDF2",
-      false,
-      ["deriveKey"]
-    );
-    return crypto.subtle.deriveKey(
-      {
-        name: "PBKDF2",
-        salt: salt.buffer.slice(salt.byteOffset, salt.byteOffset + salt.byteLength),
-        iterations: this.PBKDF2_ITERATIONS,
-        hash: "SHA-256"
-      },
-      keyMaterial,
-      { name: this.ALGORITHM, length: this.KEY_LENGTH },
-      false,
-      ["encrypt", "decrypt"]
-    );
+  try {
+    addresses.tron = deriveTronAddress(seed);
+  } catch (e) {
+    console.error("TRON derivation failed:", e);
   }
-  /**
-   * Validate a BIP-39 seed phrase (basic validation)
-   */
-  static validateSeedPhrase(seed) {
-    const words = seed.trim().split(/\s+/);
-    const validWordCounts = [12, 15, 18, 21, 24];
-    return validWordCounts.includes(words.length);
+  const [solResult, tonResult] = await Promise.allSettled([
+    deriveSolanaAddress(seed),
+    deriveTonAddress(seed)
+  ]);
+  if (solResult.status === "fulfilled") {
+    addresses.solana = solResult.value;
+  } else {
+    console.error("SOL derivation failed:", solResult.reason);
   }
-  /**
-   * Generate a random encryption key (for backup purposes)
-   */
-  static generateBackupKey() {
-    const bytes = crypto.getRandomValues(new Uint8Array(32));
-    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  if (tonResult.status === "fulfilled") {
+    addresses.ton = tonResult.value;
+  } else {
+    console.error("TON derivation failed:", tonResult.reason);
   }
-};
+  return addresses;
+}
+function isValidSeed(seed) {
+  return bip39.validateMnemonic(seed, english.wordlist);
+}
+function generateSeedPhrase() {
+  return bip39.generateMnemonic(english.wordlist);
+}
 
-// src/storage/SecureStorage.ts
-var KeychainStorageAdapter = class {
-  serviceName;
-  constructor(serviceName = "com.zubari.wallet") {
-    this.serviceName = serviceName;
+// src/services/ZubariWdkService.ts
+var DEFAULT_API_URL2 = "https://ckgwifsxka.us-east-2.awsapprunner.com";
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+var dynamicImport = new Function("specifier", "return import(specifier)");
+async function canUseNativeWdk() {
+  if (isBrowser()) {
+    return false;
   }
-  async setItem(key, value) {
-    if (typeof global !== "undefined" && global.KeychainModule) {
-      await global.KeychainModule.setItem(this.serviceName, key, value);
-    } else {
-      throw new Error("Keychain not available on this platform");
-    }
+  try {
+    await dynamicImport("@tetherto/wdk");
+    return true;
+  } catch {
+    return false;
   }
-  async getItem(key) {
-    if (typeof global !== "undefined" && global.KeychainModule) {
-      return global.KeychainModule.getItem(this.serviceName, key);
-    }
-    throw new Error("Keychain not available on this platform");
+}
+var ZubariWdkService = class {
+  config;
+  apiClient;
+  nativeWdkService = null;
+  initialized = false;
+  useNativeWdk = false;
+  constructor(config = {}) {
+    this.config = {
+      network: config.network || "testnet",
+      apiUrl: config.apiUrl || process.env.NEXT_PUBLIC_API_URL || DEFAULT_API_URL2,
+      forceApi: config.forceApi ?? false,
+      timeout: config.timeout || 3e4
+    };
+    this.apiClient = getWdkApiClient(this.config.apiUrl);
   }
-  async removeItem(key) {
-    if (typeof global !== "undefined" && global.KeychainModule) {
-      await global.KeychainModule.removeItem(this.serviceName, key);
-    } else {
-      throw new Error("Keychain not available on this platform");
+  /**
+   * Initialize the service and determine the best strategy
+   */
+  async initialize() {
+    if (this.initialized) return;
+    if (isBrowser() || this.config.forceApi) {
+      this.useNativeWdk = false;
+      this.initialized = true;
+      return;
     }
-  }
-  async hasItem(key) {
-    const value = await this.getItem(key);
-    return value !== null;
-  }
-  async clear() {
-    if (typeof global !== "undefined" && global.KeychainModule) {
-      await global.KeychainModule.clear(this.serviceName);
-    } else {
-      throw new Error("Keychain not available on this platform");
+    if (await canUseNativeWdk()) {
+      try {
+        const WdkServiceModule = await dynamicImport("./WdkService");
+        const WdkService = WdkServiceModule.WdkService || WdkServiceModule.default;
+        this.nativeWdkService = new WdkService({
+          network: this.config.network
+        });
+        this.useNativeWdk = true;
+      } catch (error) {
+        console.warn("Failed to initialize native WDK, falling back to API:", error);
+        this.useNativeWdk = false;
+      }
     }
+    this.initialized = true;
   }
-};
-var KeystoreStorageAdapter = class {
-  alias;
-  constructor(alias = "zubari_wallet_keys") {
-    this.alias = alias;
+  /**
+   * Get the current execution mode
+   */
+  getMode() {
+    if (this.useNativeWdk) return "native";
+    if (isBrowser()) return "api";
+    return "api";
   }
-  async setItem(key, value) {
-    if (typeof global !== "undefined" && global.KeystoreModule) {
-      await global.KeystoreModule.setItem(this.alias, key, value);
-    } else {
-      throw new Error("Keystore not available on this platform");
-    }
+  /**
+   * Check if running in browser
+   */
+  isBrowserEnvironment() {
+    return isBrowser();
   }
-  async getItem(key) {
-    if (typeof global !== "undefined" && global.KeystoreModule) {
-      return global.KeystoreModule.getItem(this.alias, key);
+  /**
+   * Generate a new BIP-39 seed phrase (12 words)
+   */
+  async generateSeed() {
+    await this.initialize();
+    try {
+      const response = await this.apiClient.generateSeed();
+      if (response.success && response.seed) {
+        return response.seed;
+      }
+    } catch (error) {
+      console.warn("API seed generation failed:", error);
+    }
+    if (this.useNativeWdk && this.nativeWdkService) {
+      try {
+        const wdk = this.nativeWdkService;
+        return await wdk.generateSeedPhrase();
+      } catch (error) {
+        console.warn("Native WDK seed generation failed:", error);
+      }
     }
-    throw new Error("Keystore not available on this platform");
+    return generateSeedPhrase();
   }
-  async removeItem(key) {
-    if (typeof global !== "undefined" && global.KeystoreModule) {
-      await global.KeystoreModule.removeItem(this.alias, key);
-    } else {
-      throw new Error("Keystore not available on this platform");
+  /**
+   * Validate a BIP-39 seed phrase
+   */
+  async validateSeed(seed) {
+    await this.initialize();
+    try {
+      const response = await this.apiClient.validateSeed(seed);
+      if (response.success) {
+        return response.isValid ?? false;
+      }
+    } catch (error) {
+      console.warn("API seed validation failed:", error);
     }
-  }
-  async hasItem(key) {
-    const value = await this.getItem(key);
-    return value !== null;
-  }
-  async clear() {
-    if (typeof global !== "undefined" && global.KeystoreModule) {
-      await global.KeystoreModule.clear(this.alias);
-    } else {
-      throw new Error("Keystore not available on this platform");
+    if (this.useNativeWdk && this.nativeWdkService) {
+      try {
+        const wdk = this.nativeWdkService;
+        return await wdk.isValidSeed(seed);
+      } catch (error) {
+        console.warn("Native WDK seed validation failed:", error);
+      }
     }
-  }
-};
-var WebEncryptedStorageAdapter = class {
-  encryptionKey = null;
-  storagePrefix;
-  constructor(storagePrefix = "zubari_") {
-    this.storagePrefix = storagePrefix;
+    return isValidSeed(seed);
   }
   /**
-   * Initialize with a password-derived key
+   * Derive address for a specific chain using WDK API
+   *
+   * For Ethereum, falls back to local derivation if API fails.
+   * For other chains, WDK API is required - no placeholder fallback.
    */
-  async initialize(password) {
-    const encoder = new TextEncoder();
-    const salt = this.getSalt();
-    const keyMaterial = await crypto.subtle.importKey(
-      "raw",
-      encoder.encode(password),
-      "PBKDF2",
-      false,
-      ["deriveKey"]
-    );
-    this.encryptionKey = await crypto.subtle.deriveKey(
-      {
-        name: "PBKDF2",
-        salt: salt.buffer,
-        iterations: 1e5,
-        hash: "SHA-256"
-      },
-      keyMaterial,
-      { name: "AES-GCM", length: 256 },
-      false,
-      ["encrypt", "decrypt"]
-    );
-  }
-  getSalt() {
-    const saltKey = `${this.storagePrefix}salt`;
-    let saltHex = localStorage.getItem(saltKey);
-    if (!saltHex) {
-      const salt = crypto.getRandomValues(new Uint8Array(16));
-      saltHex = Array.from(salt).map((b) => b.toString(16).padStart(2, "0")).join("");
-      localStorage.setItem(saltKey, saltHex);
+  async deriveAddress(seed, chain) {
+    await this.initialize();
+    const path = this.getDerivationPath(chain);
+    try {
+      const response = await this.apiClient.deriveAddress(seed, chain, this.config.network);
+      if (response.success && response.address) {
+        return {
+          chain,
+          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);
+      }
     }
-    return new Uint8Array(
-      saltHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
-    );
-  }
-  async setItem(key, value) {
-    if (!this.encryptionKey) {
-      throw new Error("Storage not initialized. Call initialize() first.");
+    if (this.useNativeWdk && this.nativeWdkService) {
+      try {
+        const wdk = this.nativeWdkService;
+        await wdk.initialize(seed);
+        return await wdk.deriveAddress(chain);
+      } catch (error) {
+        console.warn(`Native WDK address derivation failed for ${chain}:`, error);
+      }
     }
-    const encoder = new TextEncoder();
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const encrypted = await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv },
-      this.encryptionKey,
-      encoder.encode(value)
+    if (chain === "ethereum") {
+      return this.deriveBrowserAddress(seed, chain);
+    }
+    throw new Error(
+      `WDK API required for ${chain} address derivation. Ensure the backend is running.`
     );
-    const combined = new Uint8Array(iv.length + encrypted.byteLength);
-    combined.set(iv);
-    combined.set(new Uint8Array(encrypted), iv.length);
-    const base64 = btoa(String.fromCharCode(...combined));
-    localStorage.setItem(`${this.storagePrefix}${key}`, base64);
   }
-  async getItem(key) {
-    if (!this.encryptionKey) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-    const base64 = localStorage.getItem(`${this.storagePrefix}${key}`);
-    if (!base64) return null;
+  /**
+   * Derive addresses for all supported chains using WDK API
+   *
+   * Uses the backend WDK API for real cryptographically valid addresses.
+   * No placeholder fallback - WDK API is required for multi-chain addresses.
+   */
+  async deriveAllAddresses(seed) {
+    await this.initialize();
     try {
-      const combined = new Uint8Array(
-        atob(base64).split("").map((c) => c.charCodeAt(0))
-      );
-      const iv = combined.slice(0, 12);
-      const encrypted = combined.slice(12);
-      const decrypted = await crypto.subtle.decrypt(
-        { name: "AES-GCM", iv },
-        this.encryptionKey,
-        encrypted
-      );
-      const decoder = new TextDecoder();
-      return decoder.decode(decrypted);
-    } catch {
-      return null;
-    }
-  }
-  async removeItem(key) {
-    localStorage.removeItem(`${this.storagePrefix}${key}`);
-  }
-  async hasItem(key) {
-    return localStorage.getItem(`${this.storagePrefix}${key}`) !== null;
-  }
-  async clear() {
-    const keysToRemove = [];
-    for (let i = 0; i < localStorage.length; i++) {
-      const key = localStorage.key(i);
-      if (key?.startsWith(this.storagePrefix)) {
-        keysToRemove.push(key);
+      const response = await this.apiClient.deriveAllAddresses(seed, this.config.network);
+      if (response.success && response.addresses) {
+        const extractAddress = (value) => {
+          if (!value) return null;
+          if (typeof value === "string") return value;
+          if (typeof value === "object" && value !== null && "address" in value) {
+            return value.address;
+          }
+          return null;
+        };
+        return {
+          ethereum: extractAddress(response.addresses.ethereum),
+          bitcoin: extractAddress(response.addresses.bitcoin),
+          ton: extractAddress(response.addresses.ton),
+          tron: extractAddress(response.addresses.tron),
+          solana: extractAddress(response.addresses.solana),
+          spark: extractAddress(response.addresses.spark)
+        };
       }
+    } catch (error) {
+      console.warn("API address derivation failed:", error);
     }
-    keysToRemove.forEach((key) => localStorage.removeItem(key));
-  }
-};
-var MemoryStorageAdapter = class {
-  storage = /* @__PURE__ */ new Map();
-  async setItem(key, value) {
-    this.storage.set(key, value);
-  }
-  async getItem(key) {
-    return this.storage.get(key) || null;
-  }
-  async removeItem(key) {
-    this.storage.delete(key);
-  }
-  async hasItem(key) {
-    return this.storage.has(key);
-  }
-  async clear() {
-    this.storage.clear();
-  }
-};
-function createSecureStorage() {
-  if (typeof global !== "undefined" && global.nativeModuleProxy !== void 0) {
-    const Platform = global.Platform;
-    if (Platform?.OS === "ios") {
-      return new KeychainStorageAdapter();
-    } else if (Platform?.OS === "android") {
-      return new KeystoreStorageAdapter();
+    if (this.useNativeWdk && this.nativeWdkService) {
+      try {
+        const wdk = this.nativeWdkService;
+        await wdk.initialize(seed);
+        return await wdk.deriveAllAddresses();
+      } catch (error) {
+        console.warn("Native WDK multi-chain derivation failed:", error);
+      }
     }
+    throw new Error(
+      "Tether WDK API required for multi-chain address derivation. Service temporarily unavailable."
+    );
   }
-  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
-    return new WebEncryptedStorageAdapter();
-  }
-  return new MemoryStorageAdapter();
-}
-
-// src/services/WdkApiClient.ts
-var WdkApiClient = class {
-  config;
-  constructor(config) {
-    this.config = {
-      baseUrl: config.baseUrl,
-      timeout: config.timeout || 3e4
-    };
+  /**
+   * Get balances for all chains
+   */
+  async getAllBalances(seed) {
+    await this.initialize();
+    try {
+      const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/balances`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ seed, network: this.config.network })
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (data.success) {
+          return data.balances;
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to fetch balances:", error);
+    }
+    return {};
   }
   /**
-   * Generate a new BIP-39 seed phrase using Tether WDK
+   * Get fee rates for a chain
    */
-  async generateSeed() {
+  async getFeeRates(seed, chain) {
+    await this.initialize();
     try {
-      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/generate-seed`, {
+      const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/fee-rates`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        }
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ seed, chain, network: this.config.network })
       });
-      return await response.json();
+      if (response.ok) {
+        const data = await response.json();
+        if (data.success && data.feeRates) {
+          return data.feeRates;
+        }
+      }
     } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to generate seed"
-      };
+      console.warn(`Failed to fetch fee rates for ${chain}:`, error);
     }
+    return { slow: "0", normal: "0", fast: "0" };
   }
   /**
-   * Validate a BIP-39 seed phrase
+   * Estimate transaction fee
    */
-  async validateSeed(seed) {
+  async estimateFee(seed, chain, to, amount) {
+    await this.initialize();
     try {
-      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/validate-seed`, {
+      const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/estimate-fee`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ seed })
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ seed, chain, to, amount, network: this.config.network })
       });
-      return await response.json();
+      if (response.ok) {
+        const data = await response.json();
+        if (data.success) {
+          return { fee: data.fee, symbol: data.symbol };
+        }
+      }
     } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to validate seed"
-      };
+      console.warn(`Failed to estimate fee for ${chain}:`, error);
     }
+    return { fee: "0", symbol: this.getChainSymbol(chain) };
   }
   /**
-   * Derive address for a specific chain using Tether WDK
+   * Send a transaction
    */
-  async deriveAddress(seed, chain, network = "testnet") {
+  async sendTransaction(seed, chain, to, amount) {
+    await this.initialize();
     try {
-      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/derive-address`, {
+      const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/send`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ seed, chain, network })
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ seed, chain, to, amount, network: this.config.network })
       });
-      return await response.json();
+      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)`);
+        }
+        return {
+          success: data.success,
+          txHash,
+          from: data.from,
+          to: data.to,
+          amount: data.amount,
+          chain: data.chain,
+          network: data.network
+        };
+      }
+      const errorData = await response.json().catch(() => ({}));
+      return {
+        success: false,
+        error: errorData.error || `HTTP ${response.status}`
+      };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to derive address"
+        error: error instanceof Error ? error.message : "Transaction failed"
       };
     }
   }
   /**
-   * Derive addresses for all chains using Tether WDK
+   * Get the network configuration
    */
-  async deriveAllAddresses(seed, network = "testnet") {
+  getNetwork() {
+    return this.config.network;
+  }
+  /**
+   * Get API URL
+   */
+  getApiUrl() {
+    return this.config.apiUrl;
+  }
+  // ==========================================
+  // Private Helper Methods
+  // ==========================================
+  getDerivationPath(chain) {
+    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",
+      ton: "m/44'/607'/0'/0'/0'",
+      tron: "m/44'/195'/0'/0/0",
+      solana: "m/44'/501'/0'/0'",
+      spark: "m/44'/998'/0'/0/0"
+    };
+    return paths[chain];
+  }
+  getChainSymbol(chain) {
+    const symbols = {
+      ethereum: "ETH",
+      bitcoin: "BTC",
+      ton: "TON",
+      tron: "TRX",
+      solana: "SOL",
+      spark: "SAT"
+    };
+    return symbols[chain];
+  }
+  /**
+   * Derive address using browser-compatible libraries
+   */
+  async deriveBrowserAddress(seed, chain) {
+    const path = this.getDerivationPath(chain);
     try {
-      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/derive-all`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ seed, network })
-      });
-      return await response.json();
+      let address;
+      switch (chain) {
+        case "ethereum":
+          address = deriveEthereumAddress(seed);
+          break;
+        case "bitcoin":
+          address = deriveBitcoinAddress(seed, this.config.network);
+          break;
+        case "tron":
+          address = deriveTronAddress(seed);
+          break;
+        case "spark":
+          address = deriveSparkAddress(seed, this.config.network);
+          break;
+        case "solana":
+          address = await deriveSolanaAddress(seed);
+          break;
+        case "ton":
+          address = await deriveTonAddress(seed);
+          break;
+        default:
+          throw new Error(`Unsupported chain: ${chain}`);
+      }
+      return { chain, address, path };
     } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to derive addresses"
+      console.error(`Browser derivation failed for ${chain}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Derive all addresses using browser-compatible libraries
+   */
+  async deriveAllBrowserAddresses(seed) {
+    return deriveAllAddresses(seed, this.config.network);
+  }
+};
+var defaultService = null;
+function getZubariWdkService(config) {
+  if (!defaultService || config && config.network !== defaultService.getNetwork()) {
+    defaultService = new ZubariWdkService(config);
+  }
+  return defaultService;
+}
+
+// src/wallet/ZubariWallet.ts
+var ZubariWallet = class {
+  seed;
+  config;
+  accounts = /* @__PURE__ */ new Map();
+  wdkService;
+  initialized = false;
+  constructor(seed, config) {
+    this.seed = seed;
+    this.config = {
+      network: config.network || "mainnet",
+      enabledNetworks: config.enabledNetworks || ["ethereum"],
+      gasless: config.gasless ?? false,
+      paymasterUrl: config.paymasterUrl,
+      bundlerUrl: config.bundlerUrl,
+      rpcUrls: config.rpcUrls
+    };
+    this.wdkService = getZubariWdkService({
+      network: this.config.network === "testnet" ? "testnet" : "mainnet",
+      forceApi: true
+      // Use backend API for all operations
+    });
+  }
+  /**
+   * Initialize the wallet by deriving accounts for all enabled networks
+   */
+  async initialize() {
+    if (this.initialized) return;
+    for (const network of this.config.enabledNetworks) {
+      await this.deriveAccount(network);
+    }
+    this.initialized = true;
+  }
+  /**
+   * Derive account for a specific network using BIP-44 via WDK API
+   */
+  async deriveAccount(network, index = 0) {
+    const basePath = DERIVATION_PATHS[network];
+    const derivationPath = `${basePath}/${index}`;
+    const chainMap = {
+      ethereum: "ethereum",
+      bitcoin: "bitcoin",
+      ton: "ton",
+      tron: "tron",
+      solana: "solana",
+      spark: "spark"
+    };
+    const chain = chainMap[network];
+    if (!chain) {
+      throw new Error(`Unsupported network: ${network}`);
+    }
+    try {
+      const result = await this.wdkService.deriveAddress(this.seed, chain);
+      const account = {
+        network,
+        address: result.address,
+        publicKey: "",
+        // WDK doesn't expose public key directly
+        derivationPath: result.path || derivationPath
       };
+      this.accounts.set(network, account);
+      return account;
+    } catch (error) {
+      console.error(`Failed to derive account for ${network}:`, error);
+      throw new Error(`Failed to derive ${network} address: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get account for a specific network
+   */
+  async getAccount(network, index = 0) {
+    const existing = this.accounts.get(network);
+    if (existing && existing.derivationPath.endsWith(`/${index}`)) {
+      return existing;
+    }
+    return this.deriveAccount(network, index);
+  }
+  /**
+   * Get address for a specific network
+   */
+  async getAddress(network) {
+    const account = await this.getAccount(network);
+    return account.address;
+  }
+  /**
+   * Get all addresses for enabled networks
+   */
+  async getAllAddresses() {
+    const addresses = {};
+    for (const network of this.config.enabledNetworks) {
+      addresses[network] = await this.getAddress(network);
     }
+    return addresses;
   }
   /**
-   * Send a transaction on a specific chain using Tether WDK
+   * Get balance for a specific network via WDK API
    */
-  async sendTransaction(seed, chain, to, amount, network = "testnet") {
+  async getBalance(network) {
+    const networkConfig = getNetworkConfig(network, this.config.network === "testnet");
+    const chainMap = {
+      ethereum: "ethereum",
+      bitcoin: "bitcoin",
+      ton: "ton",
+      tron: "tron",
+      solana: "solana",
+      spark: "spark"
+    };
+    const chain = chainMap[network];
+    if (!chain) {
+      throw new Error(`Unsupported network: ${network}`);
+    }
     try {
-      const response = await fetch(`${this.config.baseUrl}/api/wallets/wdk/send`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
+      const balances = await this.wdkService.getAllBalances(this.seed);
+      const chainBalance = balances[chain];
+      if (chainBalance) {
+        const balanceValue = BigInt(chainBalance.balance || "0");
+        const decimals = networkConfig.nativeCurrency.decimals;
+        const balanceFormatted = this.formatBalance(balanceValue, decimals);
+        return {
+          network,
+          native: {
+            symbol: chainBalance.symbol || networkConfig.nativeCurrency.symbol,
+            balance: balanceValue,
+            balanceFormatted,
+            balanceUsd: 0
+            // TODO: Integrate price feed
+          },
+          tokens: []
+        };
+      }
+      return {
+        network,
+        native: {
+          symbol: networkConfig.nativeCurrency.symbol,
+          balance: BigInt(0),
+          balanceFormatted: "0",
+          balanceUsd: 0
         },
-        body: JSON.stringify({ seed, chain, to, amount, network })
-      });
-      return await response.json();
+        tokens: []
+      };
     } catch (error) {
+      console.error(`Failed to get balance for ${network}:`, error);
       return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to send transaction"
+        network,
+        native: {
+          symbol: networkConfig.nativeCurrency.symbol,
+          balance: BigInt(0),
+          balanceFormatted: "0",
+          balanceUsd: 0
+        },
+        tokens: []
       };
     }
   }
   /**
-   * Get transaction history for an address on a specific chain
-   * Fetches from blockchain explorers (Etherscan, mempool.space, etc.)
+   * Format balance from wei/satoshi to human-readable string
    */
-  async getTransactionHistory(seed, chain, network = "testnet", 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 })
-      });
-      return await response.json();
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to get transaction history"
-      };
-    }
+  formatBalance(balance, decimals) {
+    if (balance === BigInt(0)) return "0";
+    const divisor = BigInt(10 ** decimals);
+    const integerPart = balance / divisor;
+    const fractionalPart = balance % divisor;
+    const fractionalStr = fractionalPart.toString().padStart(decimals, "0").slice(0, 6);
+    return `${integerPart}.${fractionalStr}`.replace(/\.?0+$/, "") || "0";
   }
   /**
-   * Get transaction status by hash
-   * Fetches from blockchain explorers to check confirmation status
+   * Get balances for all enabled networks
    */
-  async getTransactionStatus(txHash, chain, network = "testnet") {
-    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 })
-      });
-      return await response.json();
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to get transaction status"
-      };
+  async getAllBalances() {
+    const balances = [];
+    for (const network of this.config.enabledNetworks) {
+      balances.push(await this.getBalance(network));
     }
+    return balances;
   }
-};
-var DEFAULT_API_URL = process.env.NEXT_PUBLIC_API_URL || "https://ckgwifsxka.us-east-2.awsapprunner.com";
-var wdkApiClient = null;
-function getWdkApiClient(baseUrl) {
-  if (!wdkApiClient || baseUrl && wdkApiClient["config"].baseUrl !== baseUrl) {
-    wdkApiClient = new WdkApiClient({
-      baseUrl: baseUrl || DEFAULT_API_URL
-    });
-  }
-  return wdkApiClient;
-}
-var DERIVATION_PATHS2 = {
-  ethereum: "m/44'/60'/0'/0/0",
-  bitcoin_mainnet: "m/84'/0'/0'/0/0",
-  bitcoin_testnet: "m/84'/1'/0'/0/0",
-  ton: "m/44'/607'/0'/0'/0'",
-  tron: "m/44'/195'/0'/0/0",
-  solana: "m/44'/501'/0'/0'",
-  spark: "m/44'/998'/0'/0/0"
-};
-function deriveEthereumAddress(seed) {
-  const hdNode = ethers.HDNodeWallet.fromPhrase(seed, void 0, DERIVATION_PATHS2.ethereum);
-  return hdNode.address;
-}
-function deriveBitcoinAddress(seed, network = "testnet") {
-  try {
-    const seedBytes = bip39.mnemonicToSeedSync(seed);
-    const hdKey = bip32.HDKey.fromMasterSeed(seedBytes);
-    const path = network === "testnet" ? DERIVATION_PATHS2.bitcoin_testnet : DERIVATION_PATHS2.bitcoin_mainnet;
-    const child = hdKey.derive(path);
-    if (!child.publicKey) {
-      throw new Error("Failed to derive public key");
+  /**
+   * Get total portfolio value in USD
+   */
+  async getTotalPortfolioUsd() {
+    const balances = await this.getAllBalances();
+    let total = 0;
+    for (const balance of balances) {
+      total += balance.native.balanceUsd;
+      for (const token of balance.tokens) {
+        total += token.balanceUsd;
+      }
     }
-    const pubKeyHash = ripemd160.ripemd160(sha256.sha256(child.publicKey));
-    const witnessVersion = 0;
-    const words = base.bech32.toWords(pubKeyHash);
-    words.unshift(witnessVersion);
-    const hrp = network === "testnet" ? "tb" : "bc";
-    const address = base.bech32.encode(hrp, words);
-    return address;
-  } catch (error) {
-    console.error("Bitcoin address derivation failed:", error);
-    throw error;
-  }
-}
-async function deriveSolanaAddress(seed) {
-  try {
-    const [ed25519, nacl, bs58Module] = await Promise.all([
-      import('ed25519-hd-key'),
-      import('tweetnacl'),
-      import('bs58')
-    ]);
-    const bs58 = bs58Module.default || bs58Module;
-    const seedBytes = bip39.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);
-  } catch (error) {
-    console.error("Solana address derivation failed:", error);
-    throw error;
-  }
-}
-async function deriveTonAddress(seed) {
-  try {
-    const [ed25519, nacl] = await Promise.all([
-      import('ed25519-hd-key'),
-      import('tweetnacl')
-    ]);
-    const seedBytes = bip39.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 = sha256.sha256(publicKey);
-    const addressData = new Uint8Array(34);
-    addressData[0] = flags;
-    addressData[1] = workchain;
-    addressData.set(hash, 2);
-    const crc = crc16(addressData);
-    const fullAddress = new Uint8Array(36);
-    fullAddress.set(addressData);
-    fullAddress[34] = crc >> 8 & 255;
-    fullAddress[35] = crc & 255;
-    const base64 = btoa(String.fromCharCode(...fullAddress)).replace(/\+/g, "-").replace(/\//g, "_");
-    return base64;
-  } catch (error) {
-    console.error("TON address derivation failed:", error);
-    throw error;
+    return total;
   }
-}
-function crc16(data) {
-  let crc = 0;
-  for (const byte of data) {
-    crc ^= byte << 8;
-    for (let i = 0; i < 8; i++) {
-      crc = crc & 32768 ? crc << 1 ^ 4129 : crc << 1;
-      crc &= 65535;
+  /**
+   * Send native currency on a specific network via WDK API
+   */
+  async send(network, params) {
+    const { to, amount } = params;
+    const chainMap = {
+      ethereum: "ethereum",
+      bitcoin: "bitcoin",
+      ton: "ton",
+      tron: "tron",
+      solana: "solana",
+      spark: "spark"
+    };
+    const chain = chainMap[network];
+    if (!chain) {
+      throw new Error(`Unsupported network: ${network}`);
     }
-  }
-  return crc;
-}
-function deriveTronAddress(seed) {
-  try {
-    const hdNode = ethers.HDNodeWallet.fromPhrase(seed, void 0, DERIVATION_PATHS2.tron);
-    const ethAddressHex = hdNode.address.slice(2).toLowerCase();
-    const addressBytes = new Uint8Array(21);
-    addressBytes[0] = 65;
-    for (let i = 0; i < 20; i++) {
-      addressBytes[i + 1] = parseInt(ethAddressHex.slice(i * 2, i * 2 + 2), 16);
+    try {
+      const result = await this.wdkService.sendTransaction(
+        this.seed,
+        chain,
+        to,
+        amount.toString()
+      );
+      if (result.success && result.txHash) {
+        return {
+          hash: result.txHash,
+          network,
+          status: "pending",
+          metadata: {
+            from: result.from,
+            to: result.to,
+            amount: result.amount
+          }
+        };
+      }
+      throw new Error(result.error || "Transaction failed");
+    } catch (error) {
+      console.error(`Failed to send on ${network}:`, error);
+      throw new Error(`Transaction failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
-    const tronBase58check = base.base58check(sha256.sha256);
-    return tronBase58check.encode(addressBytes);
-  } catch (error) {
-    console.error("TRON address derivation failed:", error);
-    throw error;
   }
-}
-function deriveSparkAddress(seed, network = "testnet") {
-  try {
-    const seedBytes = bip39.mnemonicToSeedSync(seed);
-    const hdKey = bip32.HDKey.fromMasterSeed(seedBytes);
-    const child = hdKey.derive(DERIVATION_PATHS2.spark);
-    if (!child.publicKey) {
-      throw new Error("Failed to derive public key");
+  /**
+   * Send ERC-20 token on EVM networks via WDK API
+   */
+  async sendToken(network, token, to, amount) {
+    const networkConfig = getNetworkConfig(network, this.config.network === "testnet");
+    if (!networkConfig.isEvm) {
+      throw new Error(`sendToken is only supported on EVM networks. ${network} is not an EVM chain.`);
+    }
+    try {
+      const apiUrl = this.wdkService.getApiUrl();
+      const response = await fetch(`${apiUrl}/api/wallets/wdk/send-token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          seed: this.seed,
+          chain: "ethereum",
+          token,
+          to,
+          amount: amount.toString(),
+          network: this.config.network
+        })
+      });
+      const result = await response.json();
+      if (result.success && result.txHash) {
+        return {
+          hash: result.txHash,
+          network,
+          status: "pending",
+          metadata: {
+            token,
+            from: result.from,
+            to: result.to,
+            amount: result.amount
+          }
+        };
+      }
+      throw new Error(result.error || "Token transfer failed");
+    } catch (error) {
+      console.error(`Failed to send token on ${network}:`, error);
+      throw new Error(`Token transfer failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
-    const pubKeyHash = ripemd160.ripemd160(sha256.sha256(child.publicKey));
-    const witnessVersion = 0;
-    const words = base.bech32.toWords(pubKeyHash);
-    words.unshift(witnessVersion);
-    const hrp = network === "testnet" ? "tsp" : "sp";
-    const address = base.bech32.encode(hrp, words);
-    return address;
-  } catch (error) {
-    console.error("Spark address derivation failed:", error);
-    throw error;
-  }
-}
-async function deriveAllAddresses(seed, network = "testnet") {
-  const addresses = {
-    ethereum: null,
-    bitcoin: null,
-    ton: null,
-    tron: null,
-    solana: null,
-    spark: null
-  };
-  try {
-    addresses.ethereum = deriveEthereumAddress(seed);
-  } catch (e) {
-    console.error("ETH derivation failed:", e);
   }
-  try {
-    addresses.bitcoin = deriveBitcoinAddress(seed, network);
-  } catch (e) {
-    console.error("BTC derivation failed:", e);
+  /**
+   * Send Bitcoin on-chain using WalletManagerBtc
+   * @param to - Destination address (bc1q... for native segwit)
+   * @param amount - Amount in satoshis
+   */
+  async sendBitcoin(to, amount) {
+    if (!this.isValidBitcoinAddress(to)) {
+      throw new Error("Invalid Bitcoin address. Expected bc1q... (native segwit) format.");
+    }
+    return this.send("bitcoin", { to, amount });
   }
-  try {
-    addresses.spark = deriveSparkAddress(seed, network);
-  } catch (e) {
-    console.error("Spark derivation failed:", e);
+  /**
+   * Validate Bitcoin address format
+   */
+  isValidBitcoinAddress(address) {
+    if (address.startsWith("bc1q") || address.startsWith("tb1q")) {
+      return address.length >= 42 && address.length <= 62;
+    }
+    if (address.startsWith("1") || address.startsWith("m") || address.startsWith("n")) {
+      return address.length >= 25 && address.length <= 34;
+    }
+    if (address.startsWith("3") || address.startsWith("2")) {
+      return address.length >= 25 && address.length <= 34;
+    }
+    return false;
   }
-  try {
-    addresses.tron = deriveTronAddress(seed);
-  } catch (e) {
-    console.error("TRON derivation failed:", e);
+  /**
+   * Get Bitcoin address (native segwit bc1q...)
+   */
+  async getBitcoinAddress() {
+    const account = await this.getAccount("bitcoin");
+    return account.address;
   }
-  const [solResult, tonResult] = await Promise.allSettled([
-    deriveSolanaAddress(seed),
-    deriveTonAddress(seed)
-  ]);
-  if (solResult.status === "fulfilled") {
-    addresses.solana = solResult.value;
-  } else {
-    console.error("SOL derivation failed:", solResult.reason);
+  /**
+   * Pay Lightning invoice via Spark network using WDK API
+   * Uses WDK WalletManagerSpark (m/44'/998')
+   * @param invoice - Lightning invoice string (lnbc...)
+   */
+  async sendLightning(invoice) {
+    if (!this.isValidLightningInvoice(invoice)) {
+      throw new Error("Invalid Lightning invoice format. Expected lnbc... or lntb...");
+    }
+    const invoiceDetails = await this.decodeLightningInvoice(invoice);
+    try {
+      const apiUrl = this.wdkService.getApiUrl();
+      const response = await fetch(`${apiUrl}/api/wallets/wdk/lightning/pay`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          seed: this.seed,
+          invoice,
+          network: this.config.network
+        })
+      });
+      const result = await response.json();
+      if (result.success && result.paymentHash) {
+        return {
+          hash: result.paymentHash,
+          network: "spark",
+          status: "pending",
+          metadata: {
+            invoice,
+            amount: invoiceDetails.amount,
+            destination: invoiceDetails.destination,
+            preimage: result.preimage
+          }
+        };
+      }
+      throw new Error(result.error || "Lightning payment failed");
+    } catch (error) {
+      console.error("Failed to send Lightning payment:", error);
+      throw new Error(`Lightning payment failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
-  if (tonResult.status === "fulfilled") {
-    addresses.ton = tonResult.value;
-  } else {
-    console.error("TON derivation failed:", tonResult.reason);
+  /**
+   * Create Lightning invoice via Spark using WDK API
+   * @param amount - Amount in millisatoshis
+   * @param memo - Optional payment memo
+   * @returns Lightning invoice string (lnbc...)
+   */
+  async createLightningInvoice(amount, memo) {
+    if (amount <= BigInt(0)) {
+      throw new Error("Invoice amount must be greater than 0");
+    }
+    try {
+      const apiUrl = this.wdkService.getApiUrl();
+      const response = await fetch(`${apiUrl}/api/wallets/wdk/lightning/invoice`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          seed: this.seed,
+          amount: amount.toString(),
+          memo: memo || "",
+          network: this.config.network
+        })
+      });
+      const result = await response.json();
+      if (result.success && result.invoice) {
+        return result.invoice;
+      }
+      throw new Error(result.error || "Failed to create invoice");
+    } catch (error) {
+      console.error("Failed to create Lightning invoice:", error);
+      throw new Error(`Failed to create invoice: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
-  return addresses;
-}
-function isValidSeed(seed) {
-  return bip39.validateMnemonic(seed, english.wordlist);
-}
-function generateSeedPhrase() {
-  return bip39.generateMnemonic(english.wordlist);
-}
-
-// src/services/ZubariWdkService.ts
-var DEFAULT_API_URL2 = "https://ckgwifsxka.us-east-2.awsapprunner.com";
-function isBrowser() {
-  return typeof window !== "undefined" && typeof window.document !== "undefined";
-}
-var dynamicImport = new Function("specifier", "return import(specifier)");
-async function canUseNativeWdk() {
-  if (isBrowser()) {
-    return false;
+  /**
+   * Validate Lightning invoice format
+   */
+  isValidLightningInvoice(invoice) {
+    const lowerInvoice = invoice.toLowerCase();
+    return lowerInvoice.startsWith("lnbc") || // Mainnet
+    lowerInvoice.startsWith("lntb") || // Testnet
+    lowerInvoice.startsWith("lnbcrt");
   }
-  try {
-    await dynamicImport("@tetherto/wdk");
-    return true;
-  } catch {
-    return false;
+  /**
+   * Decode Lightning invoice using backend API
+   * Parses BOLT11 invoice to extract payment details
+   */
+  async decodeLightningInvoice(invoice) {
+    try {
+      const apiUrl = this.wdkService.getApiUrl();
+      const response = await fetch(`${apiUrl}/api/wallets/wdk/lightning/decode`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ invoice })
+      });
+      const result = await response.json();
+      if (result.success) {
+        return {
+          amount: BigInt(result.amount || 0),
+          destination: result.destination || "",
+          expiry: result.expiry || 3600,
+          description: result.description
+        };
+      }
+      return this.parseInvoiceBasic(invoice);
+    } catch (error) {
+      console.warn("Failed to decode invoice via API, using basic parsing:", error);
+      return this.parseInvoiceBasic(invoice);
+    }
   }
-}
-var ZubariWdkService = class {
-  config;
-  apiClient;
-  nativeWdkService = null;
-  initialized = false;
-  useNativeWdk = false;
-  constructor(config = {}) {
-    this.config = {
-      network: config.network || "testnet",
-      apiUrl: config.apiUrl || process.env.NEXT_PUBLIC_API_URL || DEFAULT_API_URL2,
-      forceApi: config.forceApi ?? false,
-      timeout: config.timeout || 3e4
+  /**
+   * Basic Lightning invoice parsing (fallback)
+   * Extracts amount from invoice prefix when API is unavailable
+   */
+  parseInvoiceBasic(invoice) {
+    const lowerInvoice = invoice.toLowerCase();
+    const amountMatch = lowerInvoice.match(/^ln(?:bc|tb|bcrt)(\d+)([munp])?/);
+    let amount = BigInt(0);
+    if (amountMatch && amountMatch[1]) {
+      const value = BigInt(amountMatch[1]);
+      const multiplier = amountMatch[2];
+      switch (multiplier) {
+        case "m":
+          amount = value * BigInt(1e8);
+          break;
+        // milli-BTC
+        case "u":
+          amount = value * BigInt(1e5);
+          break;
+        // micro-BTC
+        case "n":
+          amount = value * BigInt(100);
+          break;
+        // nano-BTC
+        case "p":
+          amount = value / BigInt(10);
+          break;
+        // pico-BTC
+        default:
+          amount = value * BigInt(1e11);
+          break;
+      }
+    }
+    return {
+      amount,
+      destination: "",
+      expiry: 3600
     };
-    this.apiClient = getWdkApiClient(this.config.apiUrl);
   }
   /**
-   * Initialize the service and determine the best strategy
+   * Get Lightning (Spark) balance via WDK API
    */
-  async initialize() {
-    if (this.initialized) return;
-    if (isBrowser() || this.config.forceApi) {
-      this.useNativeWdk = false;
-      this.initialized = true;
-      return;
-    }
-    if (await canUseNativeWdk()) {
-      try {
-        const WdkServiceModule = await dynamicImport("./WdkService");
-        const WdkService = WdkServiceModule.WdkService || WdkServiceModule.default;
-        this.nativeWdkService = new WdkService({
+  async getLightningBalance() {
+    try {
+      const apiUrl = this.wdkService.getApiUrl();
+      const response = await fetch(`${apiUrl}/api/wallets/wdk/lightning/balance`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          seed: this.seed,
           network: this.config.network
-        });
-        this.useNativeWdk = true;
-      } catch (error) {
-        console.warn("Failed to initialize native WDK, falling back to API:", error);
-        this.useNativeWdk = false;
+        })
+      });
+      const result = await response.json();
+      if (result.success) {
+        return {
+          available: BigInt(result.available || 0),
+          pending: BigInt(result.pending || 0)
+        };
       }
+      return { available: BigInt(0), pending: BigInt(0) };
+    } catch (error) {
+      console.error("Failed to get Lightning balance:", error);
+      return { available: BigInt(0), pending: BigInt(0) };
     }
-    this.initialized = true;
   }
   /**
-   * Get the current execution mode
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Check if wallet is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get contract addresses for current network
+   */
+  getContractAddresses() {
+    return getContractAddresses(this.config.network);
+  }
+};
+
+// src/security/KeyManager.ts
+var KeyManager = class {
+  static ALGORITHM = "AES-GCM";
+  static KEY_LENGTH = 256;
+  static IV_LENGTH = 12;
+  static SALT_LENGTH = 16;
+  static PBKDF2_ITERATIONS = 1e5;
+  /**
+   * Encrypt a seed phrase with a password
+   */
+  static async encryptSeed(seed, password) {
+    const encoder = new TextEncoder();
+    const seedData = encoder.encode(seed);
+    const salt = crypto.getRandomValues(new Uint8Array(this.SALT_LENGTH));
+    const iv = crypto.getRandomValues(new Uint8Array(this.IV_LENGTH));
+    const key = await this.deriveKey(password, salt);
+    const encrypted = await crypto.subtle.encrypt(
+      { name: this.ALGORITHM, iv },
+      key,
+      seedData
+    );
+    const combined = new Uint8Array(salt.length + iv.length + encrypted.byteLength);
+    combined.set(salt, 0);
+    combined.set(iv, salt.length);
+    combined.set(new Uint8Array(encrypted), salt.length + iv.length);
+    return btoa(String.fromCharCode(...combined));
+  }
+  /**
+   * Decrypt a seed phrase with a password
+   */
+  static async decryptSeed(encryptedData, password) {
+    const combined = new Uint8Array(
+      atob(encryptedData).split("").map((c) => c.charCodeAt(0))
+    );
+    const salt = combined.slice(0, this.SALT_LENGTH);
+    const iv = combined.slice(this.SALT_LENGTH, this.SALT_LENGTH + this.IV_LENGTH);
+    const encrypted = combined.slice(this.SALT_LENGTH + this.IV_LENGTH);
+    const key = await this.deriveKey(password, salt);
+    const decrypted = await crypto.subtle.decrypt(
+      { name: this.ALGORITHM, iv },
+      key,
+      encrypted
+    );
+    const decoder = new TextDecoder();
+    return decoder.decode(decrypted);
+  }
+  /**
+   * Derive encryption key from password using PBKDF2
    */
-  getMode() {
-    if (this.useNativeWdk) return "native";
-    if (isBrowser()) return "api";
-    return "api";
+  static async deriveKey(password, salt) {
+    const encoder = new TextEncoder();
+    const passwordData = encoder.encode(password);
+    const keyMaterial = await crypto.subtle.importKey(
+      "raw",
+      passwordData,
+      "PBKDF2",
+      false,
+      ["deriveKey"]
+    );
+    return crypto.subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        salt: salt.buffer.slice(salt.byteOffset, salt.byteOffset + salt.byteLength),
+        iterations: this.PBKDF2_ITERATIONS,
+        hash: "SHA-256"
+      },
+      keyMaterial,
+      { name: this.ALGORITHM, length: this.KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
   }
   /**
-   * Check if running in browser
+   * Validate a BIP-39 seed phrase (basic validation)
    */
-  isBrowserEnvironment() {
-    return isBrowser();
+  static validateSeedPhrase(seed) {
+    const words = seed.trim().split(/\s+/);
+    const validWordCounts = [12, 15, 18, 21, 24];
+    return validWordCounts.includes(words.length);
   }
   /**
-   * Generate a new BIP-39 seed phrase (12 words)
+   * Generate a random encryption key (for backup purposes)
    */
-  async generateSeed() {
-    await this.initialize();
-    try {
-      const response = await this.apiClient.generateSeed();
-      if (response.success && response.seed) {
-        return response.seed;
-      }
-    } catch (error) {
-      console.warn("API seed generation failed:", error);
+  static generateBackupKey() {
+    const bytes = crypto.getRandomValues(new Uint8Array(32));
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+};
+
+// src/storage/SecureStorage.ts
+var KeychainStorageAdapter = class {
+  serviceName;
+  constructor(serviceName = "com.zubari.wallet") {
+    this.serviceName = serviceName;
+  }
+  async setItem(key, value) {
+    if (typeof global !== "undefined" && global.KeychainModule) {
+      await global.KeychainModule.setItem(this.serviceName, key, value);
+    } else {
+      throw new Error("Keychain not available on this platform");
     }
-    if (this.useNativeWdk && this.nativeWdkService) {
-      try {
-        const wdk = this.nativeWdkService;
-        return await wdk.generateSeedPhrase();
-      } catch (error) {
-        console.warn("Native WDK seed generation failed:", error);
-      }
+  }
+  async getItem(key) {
+    if (typeof global !== "undefined" && global.KeychainModule) {
+      return global.KeychainModule.getItem(this.serviceName, key);
     }
-    return generateSeedPhrase();
+    throw new Error("Keychain not available on this platform");
   }
-  /**
-   * Validate a BIP-39 seed phrase
-   */
-  async validateSeed(seed) {
-    await this.initialize();
-    try {
-      const response = await this.apiClient.validateSeed(seed);
-      if (response.success) {
-        return response.isValid ?? false;
-      }
-    } catch (error) {
-      console.warn("API seed validation failed:", error);
+  async removeItem(key) {
+    if (typeof global !== "undefined" && global.KeychainModule) {
+      await global.KeychainModule.removeItem(this.serviceName, key);
+    } else {
+      throw new Error("Keychain not available on this platform");
     }
-    if (this.useNativeWdk && this.nativeWdkService) {
-      try {
-        const wdk = this.nativeWdkService;
-        return await wdk.isValidSeed(seed);
-      } catch (error) {
-        console.warn("Native WDK seed validation failed:", error);
-      }
+  }
+  async hasItem(key) {
+    const value = await this.getItem(key);
+    return value !== null;
+  }
+  async clear() {
+    if (typeof global !== "undefined" && global.KeychainModule) {
+      await global.KeychainModule.clear(this.serviceName);
+    } else {
+      throw new Error("Keychain not available on this platform");
     }
-    return isValidSeed(seed);
   }
-  /**
-   * Derive address for a specific chain using WDK API
-   *
-   * For Ethereum, falls back to local derivation if API fails.
-   * For other chains, WDK API is required - no placeholder fallback.
-   */
-  async deriveAddress(seed, chain) {
-    await this.initialize();
-    const path = this.getDerivationPath(chain);
-    try {
-      const response = await this.apiClient.deriveAddress(seed, chain, this.config.network);
-      if (response.success && response.address) {
-        return {
-          chain,
-          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);
-      }
+};
+var KeystoreStorageAdapter = class {
+  alias;
+  constructor(alias = "zubari_wallet_keys") {
+    this.alias = alias;
+  }
+  async setItem(key, value) {
+    if (typeof global !== "undefined" && global.KeystoreModule) {
+      await global.KeystoreModule.setItem(this.alias, key, value);
+    } else {
+      throw new Error("Keystore not available on this platform");
     }
-    if (this.useNativeWdk && this.nativeWdkService) {
-      try {
-        const wdk = this.nativeWdkService;
-        await wdk.initialize(seed);
-        return await wdk.deriveAddress(chain);
-      } catch (error) {
-        console.warn(`Native WDK address derivation failed for ${chain}:`, error);
-      }
+  }
+  async getItem(key) {
+    if (typeof global !== "undefined" && global.KeystoreModule) {
+      return global.KeystoreModule.getItem(this.alias, key);
     }
-    if (chain === "ethereum") {
-      return this.deriveBrowserAddress(seed, chain);
+    throw new Error("Keystore not available on this platform");
+  }
+  async removeItem(key) {
+    if (typeof global !== "undefined" && global.KeystoreModule) {
+      await global.KeystoreModule.removeItem(this.alias, key);
+    } else {
+      throw new Error("Keystore not available on this platform");
+    }
+  }
+  async hasItem(key) {
+    const value = await this.getItem(key);
+    return value !== null;
+  }
+  async clear() {
+    if (typeof global !== "undefined" && global.KeystoreModule) {
+      await global.KeystoreModule.clear(this.alias);
+    } else {
+      throw new Error("Keystore not available on this platform");
     }
-    throw new Error(
-      `WDK API required for ${chain} address derivation. Ensure the backend is running.`
-    );
+  }
+};
+var WebEncryptedStorageAdapter = class {
+  encryptionKey = null;
+  storagePrefix;
+  constructor(storagePrefix = "zubari_") {
+    this.storagePrefix = storagePrefix;
   }
   /**
-   * Derive addresses for all supported chains using WDK API
-   *
-   * Uses the backend WDK API for real cryptographically valid addresses.
-   * No placeholder fallback - WDK API is required for multi-chain addresses.
+   * Initialize with a password-derived key
    */
-  async deriveAllAddresses(seed) {
-    await this.initialize();
-    try {
-      const response = await this.apiClient.deriveAllAddresses(seed, this.config.network);
-      if (response.success && response.addresses) {
-        const extractAddress = (value) => {
-          if (!value) return null;
-          if (typeof value === "string") return value;
-          if (typeof value === "object" && value !== null && "address" in value) {
-            return value.address;
-          }
-          return null;
-        };
-        return {
-          ethereum: extractAddress(response.addresses.ethereum),
-          bitcoin: extractAddress(response.addresses.bitcoin),
-          ton: extractAddress(response.addresses.ton),
-          tron: extractAddress(response.addresses.tron),
-          solana: extractAddress(response.addresses.solana),
-          spark: extractAddress(response.addresses.spark)
-        };
-      }
-    } catch (error) {
-      console.warn("API address derivation failed:", error);
-    }
-    if (this.useNativeWdk && this.nativeWdkService) {
-      try {
-        const wdk = this.nativeWdkService;
-        await wdk.initialize(seed);
-        return await wdk.deriveAllAddresses();
-      } catch (error) {
-        console.warn("Native WDK multi-chain derivation failed:", error);
-      }
+  async initialize(password) {
+    const encoder = new TextEncoder();
+    const salt = this.getSalt();
+    const keyMaterial = await crypto.subtle.importKey(
+      "raw",
+      encoder.encode(password),
+      "PBKDF2",
+      false,
+      ["deriveKey"]
+    );
+    this.encryptionKey = await crypto.subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        salt: salt.buffer,
+        iterations: 1e5,
+        hash: "SHA-256"
+      },
+      keyMaterial,
+      { name: "AES-GCM", length: 256 },
+      false,
+      ["encrypt", "decrypt"]
+    );
+  }
+  getSalt() {
+    const saltKey = `${this.storagePrefix}salt`;
+    let saltHex = localStorage.getItem(saltKey);
+    if (!saltHex) {
+      const salt = crypto.getRandomValues(new Uint8Array(16));
+      saltHex = Array.from(salt).map((b) => b.toString(16).padStart(2, "0")).join("");
+      localStorage.setItem(saltKey, saltHex);
     }
-    throw new Error(
-      "Tether WDK API required for multi-chain address derivation. Service temporarily unavailable."
+    return new Uint8Array(
+      saltHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
     );
   }
-  /**
-   * Get balances for all chains
-   */
-  async getAllBalances(seed) {
-    await this.initialize();
-    try {
-      const response = await fetch(`${this.config.apiUrl}/api/wallets/wdk/balances`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ seed, network: this.config.network })
-      });
-      if (response.ok) {
-        const data = await response.json();
-        if (data.success) {
-          return data.balances;
-        }
-      }
-    } catch (error) {
-      console.warn("Failed to fetch balances:", error);
+  async setItem(key, value) {
+    if (!this.encryptionKey) {
+      throw new Error("Storage not initialized. Call initialize() first.");
     }
-    return {};
+    const encoder = new TextEncoder();
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const encrypted = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      this.encryptionKey,
+      encoder.encode(value)
+    );
+    const combined = new Uint8Array(iv.length + encrypted.byteLength);
+    combined.set(iv);
+    combined.set(new Uint8Array(encrypted), iv.length);
+    const base64 = btoa(String.fromCharCode(...combined));
+    localStorage.setItem(`${this.storagePrefix}${key}`, base64);
   }
-  /**
-   * Get fee rates for a chain
-   */
-  async getFeeRates(seed, chain) {
-    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 })
-      });
-      if (response.ok) {
-        const data = await response.json();
-        if (data.success && data.feeRates) {
-          return data.feeRates;
-        }
-      }
-    } catch (error) {
-      console.warn(`Failed to fetch fee rates for ${chain}:`, error);
+  async getItem(key) {
+    if (!this.encryptionKey) {
+      throw new Error("Storage not initialized. Call initialize() first.");
     }
-    return { slow: "0", normal: "0", fast: "0" };
-  }
-  /**
-   * Estimate transaction fee
-   */
-  async estimateFee(seed, chain, to, amount) {
-    await this.initialize();
+    const base64 = localStorage.getItem(`${this.storagePrefix}${key}`);
+    if (!base64) return null;
     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 })
-      });
-      if (response.ok) {
-        const data = await response.json();
-        if (data.success) {
-          return { fee: data.fee, symbol: data.symbol };
-        }
-      }
-    } catch (error) {
-      console.warn(`Failed to estimate fee for ${chain}:`, error);
+      const combined = new Uint8Array(
+        atob(base64).split("").map((c) => c.charCodeAt(0))
+      );
+      const iv = combined.slice(0, 12);
+      const encrypted = combined.slice(12);
+      const decrypted = await crypto.subtle.decrypt(
+        { name: "AES-GCM", iv },
+        this.encryptionKey,
+        encrypted
+      );
+      const decoder = new TextDecoder();
+      return decoder.decode(decrypted);
+    } catch {
+      return null;
     }
-    return { fee: "0", symbol: this.getChainSymbol(chain) };
   }
-  /**
-   * Send a transaction
-   */
-  async sendTransaction(seed, chain, to, amount) {
-    await this.initialize();
-    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 })
-      });
-      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)`);
-        }
-        return {
-          success: data.success,
-          txHash,
-          from: data.from,
-          to: data.to,
-          amount: data.amount,
-          chain: data.chain,
-          network: data.network
-        };
+  async removeItem(key) {
+    localStorage.removeItem(`${this.storagePrefix}${key}`);
+  }
+  async hasItem(key) {
+    return localStorage.getItem(`${this.storagePrefix}${key}`) !== null;
+  }
+  async clear() {
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.storagePrefix)) {
+        keysToRemove.push(key);
       }
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        success: false,
-        error: errorData.error || `HTTP ${response.status}`
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Transaction failed"
-      };
     }
+    keysToRemove.forEach((key) => localStorage.removeItem(key));
   }
-  /**
-   * Get the network configuration
-   */
-  getNetwork() {
-    return this.config.network;
-  }
-  /**
-   * Get API URL
-   */
-  getApiUrl() {
-    return this.config.apiUrl;
+};
+var MemoryStorageAdapter = class {
+  storage = /* @__PURE__ */ new Map();
+  async setItem(key, value) {
+    this.storage.set(key, value);
   }
-  // ==========================================
-  // Private Helper Methods
-  // ==========================================
-  getDerivationPath(chain) {
-    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",
-      ton: "m/44'/607'/0'/0'/0'",
-      tron: "m/44'/195'/0'/0/0",
-      solana: "m/44'/501'/0'/0'",
-      spark: "m/44'/998'/0'/0/0"
-    };
-    return paths[chain];
+  async getItem(key) {
+    return this.storage.get(key) || null;
   }
-  getChainSymbol(chain) {
-    const symbols = {
-      ethereum: "ETH",
-      bitcoin: "BTC",
-      ton: "TON",
-      tron: "TRX",
-      solana: "SOL",
-      spark: "SAT"
-    };
-    return symbols[chain];
+  async removeItem(key) {
+    this.storage.delete(key);
   }
-  /**
-   * Derive address using browser-compatible libraries
-   */
-  async deriveBrowserAddress(seed, chain) {
-    const path = this.getDerivationPath(chain);
-    try {
-      let address;
-      switch (chain) {
-        case "ethereum":
-          address = deriveEthereumAddress(seed);
-          break;
-        case "bitcoin":
-          address = deriveBitcoinAddress(seed, this.config.network);
-          break;
-        case "tron":
-          address = deriveTronAddress(seed);
-          break;
-        case "spark":
-          address = deriveSparkAddress(seed, this.config.network);
-          break;
-        case "solana":
-          address = await deriveSolanaAddress(seed);
-          break;
-        case "ton":
-          address = await deriveTonAddress(seed);
-          break;
-        default:
-          throw new Error(`Unsupported chain: ${chain}`);
-      }
-      return { chain, address, path };
-    } catch (error) {
-      console.error(`Browser derivation failed for ${chain}:`, error);
-      throw error;
-    }
+  async hasItem(key) {
+    return this.storage.has(key);
   }
-  /**
-   * Derive all addresses using browser-compatible libraries
-   */
-  async deriveAllBrowserAddresses(seed) {
-    return deriveAllAddresses(seed, this.config.network);
+  async clear() {
+    this.storage.clear();
   }
 };
-var defaultService = null;
-function getZubariWdkService(config) {
-  if (!defaultService || config && config.network !== defaultService.getNetwork()) {
-    defaultService = new ZubariWdkService(config);
+function createSecureStorage() {
+  if (typeof global !== "undefined" && global.nativeModuleProxy !== void 0) {
+    const Platform = global.Platform;
+    if (Platform?.OS === "ios") {
+      return new KeychainStorageAdapter();
+    } else if (Platform?.OS === "android") {
+      return new KeystoreStorageAdapter();
+    }
   }
-  return defaultService;
+  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+    return new WebEncryptedStorageAdapter();
+  }
+  return new MemoryStorageAdapter();
 }
 
 // src/wallet/WalletManager.ts