@zubari/sdk 0.1.0

package/dist/react/index.mjs

@@ -0,0 +1,1570 @@
+import { useMemo, useState, useCallback, useEffect } from 'react';
+import { Wallet, HDNodeWallet } from 'ethers';
+import { createPublicClient, http, formatEther } from 'viem';
+import { mainnet, sepolia } from 'viem/chains';
+
+// src/react/useWalletManager.ts
+
+// src/config/networks.ts
+var NETWORKS = {
+  bitcoin: {
+    name: "Bitcoin",
+    chainId: 0,
+    coinType: 0,
+    // m/44'/0'
+    rpcUrl: "https://blockstream.info/api",
+    explorerUrl: "https://blockstream.info",
+    nativeCurrency: {
+      name: "Bitcoin",
+      symbol: "BTC",
+      decimals: 8
+    },
+    isEvm: false
+  },
+  ethereum: {
+    name: "Ethereum",
+    chainId: 1,
+    coinType: 60,
+    // m/44'/60'
+    rpcUrl: "https://eth.llamarpc.com",
+    explorerUrl: "https://etherscan.io",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    isEvm: true
+  },
+  ton: {
+    name: "TON",
+    chainId: -239,
+    coinType: 607,
+    // m/44'/607'
+    rpcUrl: "https://toncenter.com/api/v2",
+    explorerUrl: "https://tonscan.org",
+    nativeCurrency: {
+      name: "Toncoin",
+      symbol: "TON",
+      decimals: 9
+    },
+    isEvm: false
+  },
+  tron: {
+    name: "TRON",
+    chainId: 728126428,
+    coinType: 195,
+    // m/44'/195'
+    rpcUrl: "https://api.trongrid.io",
+    explorerUrl: "https://tronscan.org",
+    nativeCurrency: {
+      name: "TRON",
+      symbol: "TRX",
+      decimals: 6
+    },
+    isEvm: false
+  },
+  solana: {
+    name: "Solana",
+    chainId: 0,
+    coinType: 501,
+    // m/44'/501'
+    rpcUrl: "https://api.mainnet-beta.solana.com",
+    explorerUrl: "https://solscan.io",
+    nativeCurrency: {
+      name: "Solana",
+      symbol: "SOL",
+      decimals: 9
+    },
+    isEvm: false
+  },
+  spark: {
+    name: "Spark (Lightning)",
+    chainId: 0,
+    coinType: 998,
+    // m/44'/998'
+    rpcUrl: "",
+    explorerUrl: "",
+    nativeCurrency: {
+      name: "Bitcoin",
+      symbol: "BTC",
+      decimals: 8
+    },
+    isEvm: false
+  }
+};
+var TESTNET_NETWORKS = {
+  ethereum: {
+    name: "Sepolia",
+    chainId: 11155111,
+    // Using eth-sepolia.g.alchemy.com public endpoint (more reliable than rpc.sepolia.org)
+    // Fallback order: 1. Alchemy public, 2. Infura public, 3. BlockPi
+    rpcUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    explorerUrl: "https://sepolia.etherscan.io"
+  },
+  solana: {
+    name: "Solana Devnet",
+    rpcUrl: "https://api.devnet.solana.com",
+    explorerUrl: "https://solscan.io?cluster=devnet"
+  }
+};
+var DERIVATION_PATHS = {
+  ethereum: "m/44'/60'/0'/0"};
+function getNetworkConfig(network, isTestnet = false) {
+  const mainnetConfig = NETWORKS[network];
+  if (!isTestnet) return mainnetConfig;
+  const testnetOverrides = TESTNET_NETWORKS[network];
+  if (!testnetOverrides) return mainnetConfig;
+  return {
+    ...mainnetConfig,
+    ...testnetOverrides
+  };
+}
+
+// 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
+   */
+  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"]
+    );
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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("");
+  }
+};
+
+// 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");
+    }
+  }
+  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");
+  }
+  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");
+    }
+  }
+  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");
+    }
+  }
+};
+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");
+    }
+  }
+  async getItem(key) {
+    if (typeof global !== "undefined" && global.KeystoreModule) {
+      return global.KeystoreModule.getItem(this.alias, key);
+    }
+    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");
+    }
+  }
+};
+var WebEncryptedStorageAdapter = class {
+  encryptionKey = null;
+  storagePrefix;
+  constructor(storagePrefix = "zubari_") {
+    this.storagePrefix = storagePrefix;
+  }
+  /**
+   * Initialize with a password-derived key
+   */
+  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);
+    }
+    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.");
+    }
+    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);
+  }
+  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;
+    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);
+      }
+    }
+    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 (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
+    };
+  }
+  /**
+   * Generate a new BIP-39 seed phrase using Tether WDK
+   */
+  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"
+      };
+    }
+  }
+  /**
+   * Validate a BIP-39 seed phrase
+   */
+  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"
+      };
+    }
+  }
+  /**
+   * Derive address for a specific chain using Tether WDK
+   */
+  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"
+      };
+    }
+  }
+  /**
+   * Derive addresses for all chains using Tether WDK
+   */
+  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"
+      };
+    }
+  }
+};
+var DEFAULT_API_URL = process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001";
+var wdkApiClient = null;
+function getWdkApiClient(baseUrl) {
+  if (!wdkApiClient || baseUrl && wdkApiClient["config"].baseUrl !== baseUrl) {
+    wdkApiClient = new WdkApiClient({
+      baseUrl: baseUrl || DEFAULT_API_URL
+    });
+  }
+  return wdkApiClient;
+}
+
+// src/services/WdkService.ts
+var WdkManager;
+var WalletManagerBtc;
+var WalletManagerEvm;
+var WalletManagerSolana;
+var WalletManagerTon;
+var WalletManagerTron;
+var WalletManagerSpark;
+var wdkLoaded = false;
+var wdkLoadError = null;
+var dynamicImport = new Function("specifier", "return import(specifier)");
+async function loadWdkModules() {
+  if (wdkLoaded) return;
+  if (wdkLoadError) throw wdkLoadError;
+  try {
+    const [wdk, btc, evm, solana, ton, tron, spark] = await Promise.all([
+      dynamicImport("@tetherto/wdk"),
+      dynamicImport("@tetherto/wdk-wallet-btc"),
+      dynamicImport("@tetherto/wdk-wallet-evm"),
+      dynamicImport("@tetherto/wdk-wallet-solana"),
+      dynamicImport("@tetherto/wdk-wallet-ton"),
+      dynamicImport("@tetherto/wdk-wallet-tron"),
+      dynamicImport("@tetherto/wdk-wallet-spark")
+    ]);
+    WdkManager = wdk.default;
+    WalletManagerBtc = btc.default;
+    WalletManagerEvm = evm.default;
+    WalletManagerSolana = solana.default;
+    WalletManagerTon = ton.default;
+    WalletManagerTron = tron.default;
+    WalletManagerSpark = spark.default;
+    wdkLoaded = true;
+  } catch (error) {
+    wdkLoadError = error instanceof Error ? error : new Error("Failed to load WDK modules");
+    console.error("Failed to load WDK modules:", error);
+    throw wdkLoadError;
+  }
+}
+var DERIVATION_PATHS2 = {
+  bitcoin: "m/84'/0'/0'/0/0",
+  // BIP-84 for native SegWit
+  ethereum: "m/44'/60'/0'/0/0",
+  ton: "m/44'/607'/0'",
+  // Updated for v1.0.0-beta.6+
+  tron: "m/44'/195'/0'/0/0",
+  solana: "m/44'/501'/0'/0'",
+  // Updated for v1.0.0-beta.4+
+  spark: "m/44'/998'/0'/0/0"
+};
+var DEFAULT_RPC_URLS = {
+  mainnet: {
+    ethereum: "https://eth.llamarpc.com",
+    solana: "https://api.mainnet-beta.solana.com",
+    ton: "https://toncenter.com/api/v2/jsonRPC",
+    tron: "https://api.trongrid.io"
+  },
+  testnet: {
+    ethereum: "https://ethereum-sepolia-rpc.publicnode.com",
+    solana: "https://api.devnet.solana.com",
+    ton: "https://testnet.toncenter.com/api/v2/jsonRPC",
+    tron: "https://api.shasta.trongrid.io"
+  }
+};
+var WdkService = class {
+  seed = null;
+  config;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  wallets = {};
+  constructor(config = {}) {
+    this.config = {
+      network: config.network || "testnet",
+      rpcUrls: config.rpcUrls
+    };
+  }
+  /**
+   * Check if WDK modules are loaded
+   */
+  static isLoaded() {
+    return wdkLoaded;
+  }
+  /**
+   * Ensure WDK modules are loaded
+   */
+  async ensureLoaded() {
+    await loadWdkModules();
+  }
+  /**
+   * Load WDK modules (call this before using sync methods)
+   */
+  async loadModules() {
+    await loadWdkModules();
+  }
+  /**
+   * Generate a random BIP-39 seed phrase (12 words)
+   */
+  async generateSeedPhrase() {
+    await this.ensureLoaded();
+    return WdkManager.getRandomSeedPhrase();
+  }
+  /**
+   * Validate a BIP-39 seed phrase
+   */
+  async isValidSeed(seed) {
+    await this.ensureLoaded();
+    return WdkManager.isValidSeed(seed);
+  }
+  /**
+   * Validate seed phrase (sync version - basic check)
+   */
+  isValidSeedSync(seed) {
+    const words = seed.trim().split(/\s+/);
+    return words.length === 12 || words.length === 24;
+  }
+  /**
+   * Initialize the service with a seed phrase
+   */
+  async initialize(seed) {
+    await this.ensureLoaded();
+    if (!WdkManager.isValidSeed(seed)) {
+      throw new Error("Invalid seed phrase");
+    }
+    this.seed = seed;
+    this.wallets = {};
+  }
+  /**
+   * Get RPC URL for a chain
+   */
+  getRpcUrl(chain) {
+    const networkUrls = DEFAULT_RPC_URLS[this.config.network];
+    if (this.config.rpcUrls?.[chain]) {
+      return this.config.rpcUrls[chain];
+    }
+    return networkUrls[chain] || "";
+  }
+  /**
+   * Get or create wallet instance for a specific chain
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async getWallet(chain) {
+    if (!this.seed) {
+      throw new Error("WDK service not initialized. Call initialize() first.");
+    }
+    if (this.wallets[chain]) {
+      return this.wallets[chain];
+    }
+    const isTestnet = this.config.network === "testnet";
+    try {
+      switch (chain) {
+        case "ethereum": {
+          const rpcUrl = this.getRpcUrl("ethereum");
+          const wallet = new WalletManagerEvm(this.seed, { provider: rpcUrl });
+          this.wallets[chain] = wallet;
+          return wallet;
+        }
+        case "bitcoin": {
+          const wallet = new WalletManagerBtc(this.seed, {
+            network: isTestnet ? "testnet" : "bitcoin"
+          });
+          this.wallets[chain] = wallet;
+          return wallet;
+        }
+        case "solana": {
+          const rpcUrl = this.getRpcUrl("solana");
+          const wallet = new WalletManagerSolana(this.seed, {
+            rpcUrl
+          });
+          this.wallets[chain] = wallet;
+          return wallet;
+        }
+        case "ton": {
+          const url = this.getRpcUrl("ton");
+          const wallet = new WalletManagerTon(this.seed, {
+            tonClient: { url }
+          });
+          this.wallets[chain] = wallet;
+          return wallet;
+        }
+        case "tron": {
+          const fullHost = this.getRpcUrl("tron");
+          const wallet = new WalletManagerTron(this.seed, {
+            provider: fullHost
+          });
+          this.wallets[chain] = wallet;
+          return wallet;
+        }
+        case "spark": {
+          const wallet = new WalletManagerSpark(this.seed, {
+            network: isTestnet ? "TESTNET" : "MAINNET"
+          });
+          this.wallets[chain] = wallet;
+          return wallet;
+        }
+        default:
+          throw new Error(`Unsupported chain: ${chain}`);
+      }
+    } catch (error) {
+      console.error(`Failed to initialize ${chain} wallet:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Derive address for a specific chain
+   */
+  async deriveAddress(chain) {
+    const path = DERIVATION_PATHS2[chain];
+    try {
+      const wallet = await this.getWallet(chain);
+      const account = await wallet.getAccount(0);
+      const address = await account.getAddress();
+      return {
+        chain,
+        address,
+        path
+      };
+    } catch (error) {
+      console.error(`Error deriving ${chain} address:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Derive addresses for all supported chains
+   */
+  async deriveAllAddresses() {
+    const chains = ["ethereum", "bitcoin", "ton", "tron", "solana", "spark"];
+    const addresses = {
+      ethereum: null,
+      bitcoin: null,
+      ton: null,
+      tron: null,
+      solana: null,
+      spark: null
+    };
+    const results = await Promise.allSettled(
+      chains.map(async (chain) => {
+        const result = await this.deriveAddress(chain);
+        return { chain, address: result.address };
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        addresses[result.value.chain] = result.value.address;
+      } else {
+        console.error("Failed to derive address:", result.reason);
+      }
+    }
+    return addresses;
+  }
+  /**
+   * Derive addresses for specific chains only
+   */
+  async deriveAddressesForChains(chains) {
+    const addresses = {};
+    const results = await Promise.allSettled(
+      chains.map(async (chain) => {
+        const result = await this.deriveAddress(chain);
+        return { chain, address: result.address };
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        addresses[result.value.chain] = result.value.address;
+      }
+    }
+    return addresses;
+  }
+  /**
+   * Get fee rates for a specific chain
+   */
+  async getFeeRates(chain) {
+    if (!this.seed) {
+      throw new Error("WDK service not initialized. Call initialize() first.");
+    }
+    try {
+      const wallet = await this.getWallet(chain);
+      const feeRates = await wallet.getFeeRates();
+      return {
+        slow: (feeRates.slow || feeRates.low || "0").toString(),
+        medium: (feeRates.medium || feeRates.normal || feeRates.standard || "0").toString(),
+        fast: (feeRates.fast || feeRates.high || "0").toString()
+      };
+    } catch (error) {
+      console.error(`Error fetching fee rates for ${chain}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Get the current network configuration
+   */
+  getNetwork() {
+    return this.config.network;
+  }
+  /**
+   * Check if service is initialized
+   */
+  isInitialized() {
+    return this.seed !== null;
+  }
+  /**
+   * Clean up and dispose of wallet instances
+   */
+  dispose() {
+    for (const wallet of Object.values(this.wallets)) {
+      if (wallet && typeof wallet.dispose === "function") {
+        try {
+          wallet.dispose();
+        } catch {
+        }
+      }
+    }
+    this.wallets = {};
+    this.seed = null;
+  }
+};
+
+// src/wallet/WalletManager.ts
+var STORAGE_KEYS = {
+  ENCRYPTED_SEED: "encrypted_seed",
+  ACTIVE_WALLET: "active_wallet"
+};
+var SUPPORTED_CHAINS = ["ethereum", "bitcoin", "ton", "tron", "solana", "spark"];
+var WalletManager = class _WalletManager {
+  config;
+  storage;
+  currentSeed = null;
+  derivedAddress = null;
+  derivedAddresses = {};
+  selectedChain = "ethereum";
+  wdkService;
+  constructor(config = {}) {
+    const isTestnet = config.network !== "mainnet";
+    const ethereumConfig = getNetworkConfig("ethereum", isTestnet);
+    this.config = {
+      network: config.network || "testnet",
+      rpcUrl: config.rpcUrl || ethereumConfig.rpcUrl,
+      storage: config.storage || createSecureStorage(),
+      enabledChains: config.enabledChains || SUPPORTED_CHAINS,
+      apiUrl: config.apiUrl || process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001"
+    };
+    this.storage = this.config.storage;
+    this.wdkService = new WdkService({
+      network: this.config.network
+    });
+  }
+  /**
+   * Generate a new BIP-39 seed phrase (12 words) using ethers.js
+   * For native WDK generation, use generateSeedWithWdk() instead
+   */
+  static generateSeed() {
+    const wallet = Wallet.createRandom();
+    const mnemonic = wallet.mnemonic;
+    if (!mnemonic) {
+      throw new Error("Failed to generate mnemonic");
+    }
+    return mnemonic.phrase;
+  }
+  /**
+   * Generate a new BIP-39 seed phrase using native Tether WDK
+   * This is the recommended method for generating seed phrases
+   */
+  async generateSeedWithWdk() {
+    return await this.wdkService.generateSeedPhrase();
+  }
+  /**
+   * Validate seed phrase using native WDK (async, more accurate)
+   */
+  async validateSeedWithWdk(seed) {
+    return await this.wdkService.isValidSeed(seed);
+  }
+  /**
+   * Validate a BIP-39 seed phrase
+   */
+  static validateSeed(seed) {
+    return KeyManager.validateSeedPhrase(seed);
+  }
+  /**
+   * Derive Ethereum address from seed phrase using BIP-44 path
+   * Path: m/44'/60'/0'/0/0
+   */
+  static deriveAddress(seed) {
+    const hdNode = HDNodeWallet.fromPhrase(seed, void 0, "m/44'/60'/0'/0/0");
+    return hdNode.address;
+  }
+  /**
+   * Get the HDNodeWallet for signing transactions
+   */
+  static getWallet(seed) {
+    return HDNodeWallet.fromPhrase(seed, void 0, "m/44'/60'/0'/0/0");
+  }
+  /**
+   * Initialize storage with password (required for web platform)
+   */
+  async initializeStorage(password) {
+    if (this.storage instanceof WebEncryptedStorageAdapter) {
+      await this.storage.initialize(password);
+    }
+  }
+  /**
+   * Create a new wallet with generated seed
+   */
+  async createWallet(password) {
+    const seed = _WalletManager.generateSeed();
+    const address = _WalletManager.deriveAddress(seed);
+    const encrypted = await KeyManager.encryptSeed(seed, password);
+    await this.storage.setItem(STORAGE_KEYS.ENCRYPTED_SEED, encrypted);
+    this.currentSeed = seed;
+    this.derivedAddress = address;
+    return { seed, address };
+  }
+  /**
+   * Import an existing wallet from seed phrase
+   */
+  async importWallet(seed, password) {
+    if (!_WalletManager.validateSeed(seed)) {
+      throw new Error("Invalid seed phrase");
+    }
+    const address = _WalletManager.deriveAddress(seed);
+    const encrypted = await KeyManager.encryptSeed(seed, password);
+    await this.storage.setItem(STORAGE_KEYS.ENCRYPTED_SEED, encrypted);
+    this.currentSeed = seed;
+    this.derivedAddress = address;
+    return { address };
+  }
+  /**
+   * Unlock wallet with password
+   */
+  async unlock(password) {
+    const encrypted = await this.storage.getItem(STORAGE_KEYS.ENCRYPTED_SEED);
+    if (!encrypted) {
+      throw new Error("No wallet found");
+    }
+    try {
+      const seed = await KeyManager.decryptSeed(encrypted, password);
+      const address = _WalletManager.deriveAddress(seed);
+      this.currentSeed = seed;
+      this.derivedAddress = address;
+      return { address };
+    } catch {
+      throw new Error("Invalid password");
+    }
+  }
+  /**
+   * Lock wallet (clear seed from memory)
+   */
+  lock() {
+    this.currentSeed = null;
+    this.wdkService.dispose();
+  }
+  /**
+   * Check if wallet exists in storage
+   */
+  async hasWallet() {
+    return this.storage.hasItem(STORAGE_KEYS.ENCRYPTED_SEED);
+  }
+  /**
+   * Delete wallet from storage
+   */
+  async deleteWallet() {
+    await this.storage.removeItem(STORAGE_KEYS.ENCRYPTED_SEED);
+    this.currentSeed = null;
+    this.derivedAddress = null;
+    this.derivedAddresses = {};
+    this.wdkService.dispose();
+  }
+  /**
+   * Get current wallet state
+   */
+  getState() {
+    return {
+      isInitialized: this.derivedAddress !== null,
+      isLocked: this.currentSeed === null && this.derivedAddress !== null,
+      address: this.derivedAddress,
+      balance: null
+      // Use fetchBalance for current balance
+    };
+  }
+  /**
+   * Get current address (if unlocked)
+   */
+  getAddress() {
+    return this.derivedAddress;
+  }
+  /**
+   * Check if wallet is unlocked
+   */
+  isUnlocked() {
+    return this.currentSeed !== null;
+  }
+  /**
+   * Get the seed phrase (only if unlocked)
+   */
+  getSeed() {
+    return this.currentSeed;
+  }
+  /**
+   * Fetch balance for current address with timeout handling
+   */
+  async fetchBalance() {
+    if (!this.derivedAddress) {
+      throw new Error("Wallet not initialized");
+    }
+    const chain = this.config.network === "mainnet" ? mainnet : sepolia;
+    const client = createPublicClient({
+      chain,
+      transport: http(this.config.rpcUrl, {
+        timeout: 15e3,
+        // 15 second timeout
+        retryCount: 2,
+        retryDelay: 1e3
+      })
+    });
+    try {
+      const balance = await client.getBalance({
+        address: this.derivedAddress
+      });
+      return formatEther(balance);
+    } catch (error) {
+      console.warn("Failed to fetch balance:", error);
+      return "0";
+    }
+  }
+  /**
+   * Create viem public client for the current network
+   */
+  getPublicClient() {
+    const chain = this.config.network === "mainnet" ? mainnet : sepolia;
+    return createPublicClient({
+      chain,
+      transport: http(this.config.rpcUrl, {
+        timeout: 15e3,
+        // 15 second timeout
+        retryCount: 2,
+        retryDelay: 1e3
+      })
+    });
+  }
+  /**
+   * Get ethers wallet for signing (only if unlocked)
+   */
+  getEthersWallet() {
+    if (!this.currentSeed) return null;
+    return _WalletManager.getWallet(this.currentSeed);
+  }
+  /**
+   * Set active wallet preference
+   */
+  async setActiveWalletPreference(wallet) {
+    await this.storage.setItem(STORAGE_KEYS.ACTIVE_WALLET, wallet);
+  }
+  /**
+   * Get active wallet preference
+   */
+  async getActiveWalletPreference() {
+    const stored = await this.storage.getItem(STORAGE_KEYS.ACTIVE_WALLET);
+    return stored === "metamask" || stored === "wdk" ? stored : "metamask";
+  }
+  // ==========================================
+  // Multi-Chain Support Methods (Powered by Tether WDK)
+  // ==========================================
+  /**
+   * Derive address for a specific chain (async version)
+   *
+   * Calls the backend WDK API for proper derivation when available.
+   * Falls back to local ethers-based derivation if API is unavailable.
+   */
+  static async deriveAddressForChainAsync(seed, chain, network = "testnet", apiUrl) {
+    try {
+      const wdkApi = getWdkApiClient(apiUrl);
+      const response = await wdkApi.deriveAddress(seed, chain, network);
+      if (response.success && response.address) {
+        return response.address;
+      }
+      console.warn(`WDK API failed for ${chain}, using local derivation:`, response.error);
+    } catch (error) {
+      console.warn(`WDK API unavailable for ${chain}, using local derivation:`, error);
+    }
+    return _WalletManager.deriveAddressForChain(seed, chain);
+  }
+  /**
+   * Format address for non-WDK chains (fallback)
+   *
+   * Note: This fallback produces PLACEHOLDER addresses derived from the seed.
+   * For real blockchain interaction, use the WDK API via deriveAddressForChainAsync().
+   * These addresses should NOT be used for receiving funds without verification.
+   */
+  static formatAddressForChain(address, chain) {
+    if (chain === "ethereum") {
+      return address;
+    }
+    const addressBytes = address.toLowerCase().replace("0x", "");
+    switch (chain) {
+      case "bitcoin": {
+        const btcChars = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+        let btcAddr = "tb1q";
+        for (let i = 0; i < 38; i++) {
+          const idx = parseInt(addressBytes.charAt(i % 40) || "0", 16) % btcChars.length;
+          btcAddr += btcChars[idx];
+        }
+        return btcAddr;
+      }
+      case "ton": {
+        const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+        let tonAddr = "EQ";
+        for (let i = 0; i < 46; i++) {
+          const idx = parseInt(addressBytes.charAt(i % 40) || "0", 16) * 4 % base64Chars.length;
+          tonAddr += base64Chars[idx];
+        }
+        return tonAddr;
+      }
+      case "tron": {
+        const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+        let tronAddr = "T";
+        for (let i = 0; i < 33; i++) {
+          const idx = parseInt(addressBytes.charAt(i % 40) || "0", 16) * 3 % base58Chars.length;
+          tronAddr += base58Chars[idx];
+        }
+        return tronAddr;
+      }
+      case "solana": {
+        const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+        let solAddr = "";
+        for (let i = 0; i < 44; i++) {
+          const idx = parseInt(addressBytes.charAt(i % 40) || "0", 16) * 3 % base58Chars.length;
+          solAddr += base58Chars[idx];
+        }
+        return solAddr;
+      }
+      case "spark": {
+        const bech32Chars = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+        let sparkAddr = "sp1q";
+        for (let i = 0; i < 58; i++) {
+          const idx = parseInt(addressBytes.charAt(i % 40) || "0", 16) % bech32Chars.length;
+          sparkAddr += bech32Chars[idx];
+        }
+        return sparkAddr;
+      }
+      default:
+        return address;
+    }
+  }
+  /**
+   * Derive address for a specific chain (sync version for backwards compatibility)
+   * Uses ethers for basic derivation, use deriveAddressForChainAsync for WDK
+   *
+   * Note: For non-Ethereum chains, this produces placeholder addresses that are
+   * deterministic but not cryptographically valid. Use WDK API for real addresses.
+   */
+  static deriveAddressForChain(seed, chain) {
+    const ethPath = DERIVATION_PATHS["ethereum"];
+    const ethNode = HDNodeWallet.fromPhrase(seed, void 0, `${ethPath}/0`);
+    if (chain === "ethereum") {
+      return ethNode.address;
+    }
+    return _WalletManager.formatAddressForChain(ethNode.address, chain);
+  }
+  /**
+   * Derive addresses for all enabled chains (sync version)
+   */
+  deriveAllAddresses() {
+    if (!this.currentSeed) {
+      throw new Error("Wallet is locked");
+    }
+    const addresses = {};
+    for (const chain of this.config.enabledChains) {
+      addresses[chain] = _WalletManager.deriveAddressForChain(this.currentSeed, chain);
+    }
+    this.derivedAddresses = addresses;
+    return addresses;
+  }
+  /**
+   * Derive addresses for all enabled chains using native Tether WDK (recommended)
+   * This uses the WDK directly without needing a backend API.
+   * Returns REAL cryptographically valid addresses for all chains.
+   */
+  async deriveAllAddressesWithWdk() {
+    if (!this.currentSeed) {
+      throw new Error("Wallet is locked");
+    }
+    try {
+      await this.wdkService.initialize(this.currentSeed);
+      const enabledChainsSet = new Set(this.config.enabledChains);
+      const wdkAddresses = await this.wdkService.deriveAllAddresses();
+      const addresses = {};
+      for (const [chain, address] of Object.entries(wdkAddresses)) {
+        if (enabledChainsSet.has(chain) && address) {
+          addresses[chain] = address;
+        }
+      }
+      this.derivedAddresses = addresses;
+      return addresses;
+    } catch (error) {
+      console.error("Native WDK derivation failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Derive addresses for all enabled chains using Tether WDK
+   * Tries native WDK first, then falls back to API, then to placeholders
+   */
+  async deriveAllAddressesAsync() {
+    if (!this.currentSeed) {
+      throw new Error("Wallet is locked");
+    }
+    try {
+      return await this.deriveAllAddressesWithWdk();
+    } catch (wdkError) {
+      console.warn("Native WDK failed, trying API:", wdkError);
+    }
+    try {
+      const wdkApi = getWdkApiClient(this.config.apiUrl);
+      const response = await wdkApi.deriveAllAddresses(this.currentSeed, this.config.network);
+      if (response.success && response.addresses) {
+        const addresses = {};
+        for (const chain of this.config.enabledChains) {
+          const address = response.addresses[chain];
+          if (address) {
+            addresses[chain] = address;
+          }
+        }
+        this.derivedAddresses = addresses;
+        return addresses;
+      }
+      console.warn("WDK API call failed:", response.error);
+    } catch (apiError) {
+      console.warn("WDK API unavailable:", apiError);
+    }
+    console.warn("WARNING: Using placeholder addresses. These are NOT valid for receiving funds!");
+    return this.deriveAllAddresses();
+  }
+  /**
+   * Get address for a specific chain
+   */
+  getAddressForChain(chain) {
+    if (!this.currentSeed) {
+      return this.derivedAddresses[chain] || null;
+    }
+    if (!this.derivedAddresses[chain]) {
+      this.derivedAddresses[chain] = _WalletManager.deriveAddressForChain(this.currentSeed, chain);
+    }
+    return this.derivedAddresses[chain] || null;
+  }
+  /**
+   * Get all derived addresses
+   */
+  getAllAddresses() {
+    return { ...this.derivedAddresses };
+  }
+  /**
+   * Set the selected chain
+   */
+  setSelectedChain(chain) {
+    if (!this.config.enabledChains.includes(chain)) {
+      throw new Error(`Chain ${chain} is not enabled`);
+    }
+    this.selectedChain = chain;
+  }
+  /**
+   * Get the currently selected chain
+   */
+  getSelectedChain() {
+    return this.selectedChain;
+  }
+  /**
+   * Get enabled chains
+   */
+  getEnabledChains() {
+    return [...this.config.enabledChains];
+  }
+  /**
+   * Get chain configuration
+   */
+  getChainConfig(chain) {
+    return getNetworkConfig(chain, this.config.network === "testnet");
+  }
+  /**
+   * Fetch balance for a specific chain
+   * Note: Currently only Ethereum is implemented
+   */
+  async fetchBalanceForChain(chain) {
+    const address = this.getAddressForChain(chain);
+    if (!address) {
+      throw new Error(`No address for chain ${chain}`);
+    }
+    const networkConfig = this.getChainConfig(chain);
+    let balance = "0";
+    if (chain === "ethereum") {
+      const viemChain = this.config.network === "mainnet" ? mainnet : sepolia;
+      const client = createPublicClient({
+        chain: viemChain,
+        transport: http(this.config.rpcUrl, {
+          timeout: 15e3,
+          // 15 second timeout
+          retryCount: 2,
+          retryDelay: 1e3
+        })
+      });
+      try {
+        const rawBalance = await client.getBalance({
+          address
+        });
+        balance = formatEther(rawBalance);
+      } catch (error) {
+        console.warn(`Failed to fetch ${chain} balance:`, error);
+      }
+    }
+    return {
+      chain,
+      symbol: networkConfig.nativeCurrency.symbol,
+      balance,
+      balanceUsd: 0,
+      // TODO: Implement price fetching
+      address,
+      decimals: networkConfig.nativeCurrency.decimals
+    };
+  }
+  /**
+   * Fetch balances for all enabled chains
+   */
+  async fetchAllBalances() {
+    const balances = [];
+    for (const chain of this.config.enabledChains) {
+      try {
+        const balance = await this.fetchBalanceForChain(chain);
+        balances.push(balance);
+      } catch (error) {
+        console.error(`Failed to fetch balance for ${chain}:`, error);
+        const networkConfig = this.getChainConfig(chain);
+        balances.push({
+          chain,
+          symbol: networkConfig.nativeCurrency.symbol,
+          balance: "0",
+          balanceUsd: 0,
+          address: this.getAddressForChain(chain) || "",
+          decimals: networkConfig.nativeCurrency.decimals
+        });
+      }
+    }
+    return balances;
+  }
+  /**
+   * Get extended wallet state with multi-chain info
+   */
+  getExtendedState() {
+    return {
+      isInitialized: this.derivedAddress !== null,
+      isLocked: this.currentSeed === null && this.derivedAddress !== null,
+      address: this.derivedAddress,
+      balance: null,
+      addresses: this.derivedAddresses,
+      selectedChain: this.selectedChain
+    };
+  }
+};
+
+// src/react/useWalletManager.ts
+function useWalletManager(options = {}) {
+  const { autoCheckWallet = true, ...config } = options;
+  const manager = useMemo(() => new WalletManager(config), [
+    config.network,
+    config.rpcUrl
+  ]);
+  const [state, setState] = useState({
+    isInitialized: false,
+    isLocked: true,
+    address: null,
+    balance: null
+  });
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [selectedChain, setSelectedChainState] = useState("ethereum");
+  const [chainBalances, setChainBalances] = useState([]);
+  const updateState = useCallback(() => {
+    setState(manager.getExtendedState());
+  }, [manager]);
+  useEffect(() => {
+    if (autoCheckWallet) {
+      manager.hasWallet().then((exists) => {
+        if (exists) {
+          setState((prev) => ({
+            ...prev,
+            isInitialized: true,
+            isLocked: true
+          }));
+        }
+      });
+    }
+  }, [manager, autoCheckWallet]);
+  const createWallet = useCallback(
+    async (password) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await manager.initializeStorage(password);
+        const result = await manager.createWallet(password);
+        try {
+          await manager.deriveAllAddressesAsync();
+        } catch {
+          manager.deriveAllAddresses();
+        }
+        updateState();
+        return result;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create wallet";
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [manager, updateState]
+  );
+  const importWallet = useCallback(
+    async (seed, password) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await manager.initializeStorage(password);
+        await manager.importWallet(seed, password);
+        try {
+          await manager.deriveAllAddressesAsync();
+        } catch {
+          manager.deriveAllAddresses();
+        }
+        updateState();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to import wallet";
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [manager, updateState]
+  );
+  const unlock = useCallback(
+    async (password) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await manager.initializeStorage(password);
+        await manager.unlock(password);
+        try {
+          await manager.deriveAllAddressesAsync();
+        } catch {
+          manager.deriveAllAddresses();
+        }
+        updateState();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Invalid password";
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [manager, updateState]
+  );
+  const lock = useCallback(() => {
+    manager.lock();
+    setChainBalances([]);
+    updateState();
+  }, [manager, updateState]);
+  const deleteWallet = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      await manager.deleteWallet();
+      setChainBalances([]);
+      setState({
+        isInitialized: false,
+        isLocked: true,
+        address: null,
+        balance: null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to delete wallet";
+      setError(message);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [manager]);
+  const fetchBalance = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const balance = await manager.fetchBalance();
+      setState((prev) => ({ ...prev, balance }));
+      return balance;
+    } catch (err) {
+      console.warn("Failed to fetch balance:", err);
+      setState((prev) => ({ ...prev, balance: "0" }));
+      return "0";
+    } finally {
+      setIsLoading(false);
+    }
+  }, [manager]);
+  const fetchAllBalances = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const balances = await manager.fetchAllBalances();
+      setChainBalances(balances);
+      return balances;
+    } catch (err) {
+      console.warn("Failed to fetch all balances:", err);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [manager]);
+  const setSelectedChain = useCallback((chain) => {
+    manager.setSelectedChain(chain);
+    setSelectedChainState(chain);
+  }, [manager]);
+  const getAddressForChain = useCallback(
+    (chain) => manager.getAddressForChain(chain),
+    [manager]
+  );
+  const getAllAddresses = useCallback(
+    () => manager.getAllAddresses(),
+    [manager]
+  );
+  const hasWallet = useCallback(() => manager.hasWallet(), [manager]);
+  const getSeed = useCallback(() => manager.getSeed(), [manager]);
+  return {
+    state,
+    isLoading,
+    error,
+    createWallet,
+    importWallet,
+    unlock,
+    lock,
+    deleteWallet,
+    fetchBalance,
+    // Multi-chain
+    selectedChain,
+    setSelectedChain,
+    chainBalances,
+    fetchAllBalances,
+    getAddressForChain,
+    getAllAddresses,
+    supportedChains: SUPPORTED_CHAINS,
+    // Utilities
+    hasWallet,
+    getSeed,
+    manager
+  };
+}
+
+export { SUPPORTED_CHAINS, useWalletManager };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map