@zubari/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2411 @@
+'use strict';
+
+var ethers = require('ethers');
+var viem = require('viem');
+var chains = require('viem/chains');
+var react = require('react');
+
+// 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 = {
+  bitcoin: "m/44'/0'/0'/0",
+  ethereum: "m/44'/60'/0'/0",
+  ton: "m/44'/607'/0'/0",
+  tron: "m/44'/195'/0'/0",
+  solana: "m/44'/501'/0'/0",
+  spark: "m/44'/998'/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/config/contracts.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZUBARI_CONTRACTS = {
+  testnet: {
+    // Ethereum Sepolia (11155111) - Deployed 2024-12-09
+    registry: "0xEdDf443D48832f23D4A0bED4C4c5eF200B38A7d3",
+    nft: "0xdc37e25650D685e4c38124aC314477Ea5f508a9e",
+    marketplace: ZERO_ADDRESS,
+    // Not yet deployed
+    tips: "0xFDc353edC63Cd3D4bba35bB43861369516a9Dc85",
+    subscriptions: "0x8C05F8aD2F295fB7f3596043a7c37C98A5F7fAB8",
+    payouts: "0x804Fe503936E8b8d3D5Dbb62AF4fB6Fe7265Fb2c",
+    entryPoint: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+    paymaster: ZERO_ADDRESS,
+    // Not yet deployed
+    accountFactory: ZERO_ADDRESS,
+    // Not yet deployed
+    usdt: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0",
+    // USDT on Sepolia
+    weth: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"
+  },
+  mainnet: {
+    // Ethereum Mainnet (1)
+    registry: ZERO_ADDRESS,
+    nft: ZERO_ADDRESS,
+    marketplace: ZERO_ADDRESS,
+    tips: ZERO_ADDRESS,
+    subscriptions: ZERO_ADDRESS,
+    payouts: ZERO_ADDRESS,
+    entryPoint: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+    paymaster: ZERO_ADDRESS,
+    accountFactory: ZERO_ADDRESS,
+    usdt: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    // USDT on Ethereum
+    weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+  }
+};
+var PLATFORM_CONFIG = {
+  // Platform fee in basis points (300 = 3%)
+  tipFeeBps: 300,
+  // Maximum royalty in basis points (1000 = 10%)
+  maxRoyaltyBps: 1e3,
+  // Default slippage tolerance for swaps (50 = 0.5%)
+  defaultSlippageBps: 50,
+  // Voucher validity in seconds (30 days)
+  voucherValiditySecs: 30 * 24 * 60 * 60,
+  // Swap deadline in seconds (30 minutes)
+  swapDeadlineSecs: 30 * 60
+};
+var NFT_VOUCHER_DOMAIN = {
+  name: "ZubariNFT",
+  version: "1"
+};
+var NFT_VOUCHER_TYPES = {
+  NFTVoucher: [
+    { name: "tokenId", type: "bytes32" },
+    { name: "uri", type: "string" },
+    { name: "creator", type: "address" },
+    { name: "royaltyBps", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+function getContractAddresses(network) {
+  return ZUBARI_CONTRACTS[network];
+}
+
+// src/wallet/ZubariWallet.ts
+var ZubariWallet = class {
+  seed;
+  config;
+  accounts = /* @__PURE__ */ new Map();
+  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
+    };
+  }
+  /**
+   * 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
+    };
+    this.accounts.set(network, account);
+    return account;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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
+   */
+  async getAllBalances() {
+    const balances = [];
+    for (const network of this.config.enabledNetworks) {
+      balances.push(await this.getBalance(network));
+    }
+    return balances;
+  }
+  /**
+   * 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;
+      }
+    }
+    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
+   */
+  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.`);
+    }
+    return {
+      hash: "",
+      network,
+      status: "pending"
+    };
+  }
+  /**
+   * 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 });
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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
+      }
+    };
+  }
+  /**
+   * 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");
+    }
+    const isTestnet = this.config.network === "testnet";
+    const prefix = isTestnet ? "lntb" : "lnbc";
+    return `${prefix}${amount}m1...`;
+  }
+  /**
+   * Validate Lightning invoice format
+   */
+  isValidLightningInvoice(invoice) {
+    const lowerInvoice = invoice.toLowerCase();
+    return lowerInvoice.startsWith("lnbc") || // Mainnet
+    lowerInvoice.startsWith("lntb") || // Testnet
+    lowerInvoice.startsWith("lnbcrt");
+  }
+  /**
+   * Decode Lightning invoice (basic parsing)
+   */
+  decodeLightningInvoice(invoice) {
+    return {
+      amount: BigInt(0),
+      destination: "",
+      expiry: 3600
+    };
+  }
+  /**
+   * Get Lightning (Spark) balance
+   */
+  async getLightningBalance() {
+    return {
+      available: BigInt(0),
+      pending: BigInt(0)
+    };
+  }
+  /**
+   * 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
+   */
+  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 = ethers.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 = ethers.HDNodeWallet.fromPhrase(seed, void 0, "m/44'/60'/0'/0/0");
+    return hdNode.address;
+  }
+  /**
+   * Get the HDNodeWallet for signing transactions
+   */
+  static getWallet(seed) {
+    return ethers.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" ? chains.mainnet : chains.sepolia;
+    const client = viem.createPublicClient({
+      chain,
+      transport: viem.http(this.config.rpcUrl, {
+        timeout: 15e3,
+        // 15 second timeout
+        retryCount: 2,
+        retryDelay: 1e3
+      })
+    });
+    try {
+      const balance = await client.getBalance({
+        address: this.derivedAddress
+      });
+      return viem.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" ? chains.mainnet : chains.sepolia;
+    return viem.createPublicClient({
+      chain,
+      transport: viem.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 = ethers.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" ? chains.mainnet : chains.sepolia;
+      const client = viem.createPublicClient({
+        chain: viemChain,
+        transport: viem.http(this.config.rpcUrl, {
+          timeout: 15e3,
+          // 15 second timeout
+          retryCount: 2,
+          retryDelay: 1e3
+        })
+      });
+      try {
+        const rawBalance = await client.getBalance({
+          address
+        });
+        balance = viem.formatEther(rawBalance);
+      } 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/protocols/NFTProtocol.ts
+var ZubariNFTProtocol = class {
+  contractAddress;
+  _marketplaceAddress;
+  chainId;
+  constructor(contractAddress, marketplaceAddress, chainId) {
+    this.contractAddress = contractAddress;
+    this._marketplaceAddress = marketplaceAddress;
+    this.chainId = chainId;
+  }
+  /**
+   * Create a lazy mint voucher for off-chain NFT creation
+   * The voucher can be redeemed on-chain when purchased
+   */
+  async createLazyMintVoucher(metadata, creatorAddress, signer) {
+    if (metadata.royaltyBps > PLATFORM_CONFIG.maxRoyaltyBps) {
+      throw new Error(`Royalty cannot exceed ${PLATFORM_CONFIG.maxRoyaltyBps / 100}%`);
+    }
+    const tokenId = this.generateTokenId();
+    const deadline = Math.floor(Date.now() / 1e3) + PLATFORM_CONFIG.voucherValiditySecs;
+    const voucherData = {
+      tokenId,
+      uri: metadata.image,
+      // Will be IPFS URI
+      creator: creatorAddress,
+      royaltyBps: metadata.royaltyBps,
+      deadline
+    };
+    const domain = {
+      ...NFT_VOUCHER_DOMAIN,
+      chainId: this.chainId,
+      verifyingContract: this.contractAddress
+    };
+    const signature = await signer.signTypedData(domain, NFT_VOUCHER_TYPES, voucherData);
+    return {
+      ...voucherData,
+      signature
+    };
+  }
+  /**
+   * Redeem a lazy mint voucher to mint the NFT on-chain
+   */
+  async redeemVoucher(voucher, _buyerAddress) {
+    if (voucher.deadline < Math.floor(Date.now() / 1e3)) {
+      throw new Error("Voucher has expired");
+    }
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * List an NFT for sale on the marketplace
+   */
+  async listForSale(_params) {
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Buy an NFT from the marketplace
+   */
+  async buyNFT(_listingId, _price) {
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Transfer an NFT to another address
+   */
+  async transfer(_tokenId, _to) {
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Get NFTs owned by an address
+   */
+  async getOwnedNFTs(_address) {
+    return [];
+  }
+  /**
+   * Generate a random tokenId (32 bytes hex)
+   */
+  generateTokenId() {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+};
+
+// src/protocols/TipsProtocol.ts
+var ZubariTipsProtocol = class {
+  contractAddress;
+  chainId;
+  gaslessEnabled;
+  constructor(contractAddress, chainId, gaslessEnabled = false) {
+    this.contractAddress = contractAddress;
+    this.chainId = chainId;
+    this.gaslessEnabled = gaslessEnabled;
+  }
+  /**
+   * Send a tip to a creator
+   */
+  async sendTip(tip) {
+    const { recipient, amount, token, message } = tip;
+    const platformFee = amount * BigInt(PLATFORM_CONFIG.tipFeeBps) / BigInt(1e4);
+    const creatorAmount = amount - platformFee;
+    if (amount <= 0n) {
+      throw new Error("Tip amount must be greater than 0");
+    }
+    const txResult = {
+      hash: ""};
+    return {
+      txHash: txResult.hash,
+      tipId: "",
+      // Will be returned from contract event
+      recipient,
+      amount: creatorAmount,
+      platformFee,
+      timestamp: Math.floor(Date.now() / 1e3)
+    };
+  }
+  /**
+   * Send tips to multiple creators in a single transaction
+   */
+  async sendBatchTips(tips) {
+    if (tips.length === 0) {
+      throw new Error("At least one tip is required");
+    }
+    tips.reduce((sum, tip) => sum + tip.amount, BigInt(0));
+    return tips.map((tip) => ({
+      txHash: "",
+      tipId: "",
+      recipient: tip.recipient,
+      amount: tip.amount - tip.amount * BigInt(PLATFORM_CONFIG.tipFeeBps) / BigInt(1e4),
+      platformFee: tip.amount * BigInt(PLATFORM_CONFIG.tipFeeBps) / BigInt(1e4),
+      timestamp: Math.floor(Date.now() / 1e3)
+    }));
+  }
+  /**
+   * Get tips received by an address
+   */
+  async getTipsReceived(address) {
+    return [];
+  }
+  /**
+   * Get tips sent by an address
+   */
+  async getTipsSent(address) {
+    return [];
+  }
+  /**
+   * Get tip statistics for a creator
+   */
+  async getCreatorTipStats(creator) {
+    return {
+      totalReceived: BigInt(0),
+      tipCount: 0,
+      uniqueTippers: 0
+    };
+  }
+  /**
+   * Get platform fee in basis points
+   */
+  getPlatformFeeBps() {
+    return PLATFORM_CONFIG.tipFeeBps;
+  }
+};
+
+// src/protocols/SubscriptionProtocol.ts
+var ZubariSubscriptionProtocol = class {
+  contractAddress;
+  chainId;
+  constructor(contractAddress, chainId) {
+    this.contractAddress = contractAddress;
+    this.chainId = chainId;
+  }
+  /**
+   * Create a new subscription plan
+   */
+  async createPlan(plan) {
+    if (!plan.name || plan.name.length === 0) {
+      throw new Error("Plan name is required");
+    }
+    if (plan.price <= 0n) {
+      throw new Error("Plan price must be greater than 0");
+    }
+    if (plan.duration <= 0) {
+      throw new Error("Plan duration must be greater than 0");
+    }
+    const planId = this.generatePlanId(plan.name);
+    return planId;
+  }
+  /**
+   * Update an existing subscription plan
+   */
+  async updatePlan(planId, updates) {
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Subscribe to a creator's plan
+   */
+  async subscribe(creator, planId, months = 1) {
+    if (months <= 0) {
+      throw new Error("Subscription duration must be at least 1 month");
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const durationSeconds = months * 30 * 24 * 60 * 60;
+    return {
+      subscriptionId: "",
+      planId,
+      creator,
+      subscriber: "",
+      // Current user address
+      startTime: now,
+      endTime: now + durationSeconds,
+      autoRenew: false,
+      status: "active"
+    };
+  }
+  /**
+   * Cancel an active subscription
+   */
+  async cancel(subscriptionId) {
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Check if an address is subscribed to a creator
+   */
+  async isSubscribed(creator, subscriber) {
+    return false;
+  }
+  /**
+   * Get active subscriptions for a subscriber
+   */
+  async getActiveSubscriptions(subscriber) {
+    return [];
+  }
+  /**
+   * Get all subscribers for a creator
+   */
+  async getSubscribers(creator) {
+    return [];
+  }
+  /**
+   * Get a specific plan by ID
+   */
+  async getPlan(planId) {
+    return null;
+  }
+  /**
+   * Get all plans for a creator
+   */
+  async getCreatorPlans(creator) {
+    return [];
+  }
+  /**
+   * Generate a unique plan ID
+   */
+  generatePlanId(name) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+};
+
+// src/protocols/PayoutsProtocol.ts
+var ZubariPayoutsProtocol = class {
+  contractAddress;
+  chainId;
+  constructor(contractAddress, chainId) {
+    this.contractAddress = contractAddress;
+    this.chainId = chainId;
+  }
+  /**
+   * Get pending earnings breakdown for the current user
+   */
+  async getPendingEarnings() {
+    return {
+      tips: BigInt(0),
+      subscriptions: BigInt(0),
+      nftSales: BigInt(0),
+      royalties: BigInt(0),
+      total: BigInt(0)
+    };
+  }
+  /**
+   * Get historical earnings for a time period
+   */
+  async getEarningsHistory(period = "all") {
+    return [];
+  }
+  /**
+   * Claim all pending earnings
+   */
+  async claimEarnings() {
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Claim specific amount of earnings
+   */
+  async claimPartialEarnings(amount) {
+    if (amount <= 0n) {
+      throw new Error("Amount must be greater than 0");
+    }
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Setup revenue split with collaborators
+   * Basis points must sum to 10000 (100%)
+   */
+  async setupRevenueSplit(splits) {
+    const totalBps = splits.reduce((sum, split) => sum + split.basisPoints, 0);
+    if (totalBps !== 1e4) {
+      throw new Error("Revenue splits must sum to 100% (10000 basis points)");
+    }
+    for (const split of splits) {
+      if (split.basisPoints <= 0) {
+        throw new Error("Each split must have positive basis points");
+      }
+      if (!split.recipient || split.recipient.length === 0) {
+        throw new Error("Each split must have a valid recipient address");
+      }
+    }
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Get current revenue split configuration
+   */
+  async getRevenueSplit() {
+    return [];
+  }
+  /**
+   * Remove revenue split (creator gets 100%)
+   */
+  async removeRevenueSplit() {
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Convert earnings to stablecoin (USDT)
+   */
+  async convertToStable(token, amount) {
+    if (amount <= 0n) {
+      throw new Error("Amount must be greater than 0");
+    }
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+};
+
+// src/services/SwapService.ts
+var SwapService = class {
+  _chainId;
+  isTestnet;
+  constructor(chainId, isTestnet = false) {
+    this._chainId = chainId;
+    this.isTestnet = isTestnet;
+  }
+  /**
+   * Get a swap quote
+   */
+  async getQuote(tokenIn, tokenOut, amountIn) {
+    if (amountIn <= 0n) {
+      throw new Error("Amount must be greater than 0");
+    }
+    return {
+      tokenIn,
+      tokenOut,
+      amountIn,
+      amountOut: BigInt(0),
+      priceImpact: 0,
+      route: [tokenIn, tokenOut],
+      estimatedGas: BigInt(0)
+    };
+  }
+  /**
+   * Execute a swap with slippage protection
+   */
+  async executeSwap(quote, slippageToleranceBps = PLATFORM_CONFIG.defaultSlippageBps) {
+    quote.amountOut - quote.amountOut * BigInt(slippageToleranceBps) / BigInt(1e4);
+    Math.floor(Date.now() / 1e3) + PLATFORM_CONFIG.swapDeadlineSecs;
+    if (quote.priceImpact > 5) {
+      console.warn(`High price impact: ${quote.priceImpact}%`);
+    }
+    return {
+      hash: "",
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Convert earnings to USDT, keeping some ETH for gas
+   */
+  async convertEarningsToStable(ethBalance, reserveForGas = BigInt("10000000000000000")) {
+    const amountToSwap = ethBalance - reserveForGas;
+    if (amountToSwap <= 0n) {
+      throw new Error("Insufficient balance after gas reserve");
+    }
+    const contracts = getContractAddresses(this.isTestnet ? "testnet" : "mainnet");
+    const quote = await this.getQuote(
+      "0x0000000000000000000000000000000000000000",
+      // ETH
+      contracts.usdt,
+      // USDT on Ethereum
+      amountToSwap
+    );
+    return this.executeSwap(quote);
+  }
+  /**
+   * Check if a swap route exists
+   */
+  async hasRoute(tokenIn, tokenOut) {
+    try {
+      const quote = await this.getQuote(tokenIn, tokenOut, BigInt(1));
+      return quote.amountOut > 0n;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get supported tokens for swapping
+   */
+  async getSupportedTokens() {
+    return [];
+  }
+};
+
+// src/types/index.ts
+var ZubariError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ZubariError";
+  }
+};
+function useWalletManager(options = {}) {
+  const { autoCheckWallet = true, ...config } = options;
+  const manager = react.useMemo(() => new WalletManager(config), [
+    config.network,
+    config.rpcUrl
+  ]);
+  const [state, setState] = react.useState({
+    isInitialized: false,
+    isLocked: true,
+    address: null,
+    balance: null
+  });
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [selectedChain, setSelectedChainState] = react.useState("ethereum");
+  const [chainBalances, setChainBalances] = react.useState([]);
+  const updateState = react.useCallback(() => {
+    setState(manager.getExtendedState());
+  }, [manager]);
+  react.useEffect(() => {
+    if (autoCheckWallet) {
+      manager.hasWallet().then((exists) => {
+        if (exists) {
+          setState((prev) => ({
+            ...prev,
+            isInitialized: true,
+            isLocked: true
+          }));
+        }
+      });
+    }
+  }, [manager, autoCheckWallet]);
+  const createWallet = react.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 = react.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 = react.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 = react.useCallback(() => {
+    manager.lock();
+    setChainBalances([]);
+    updateState();
+  }, [manager, updateState]);
+  const deleteWallet = react.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 = react.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 = react.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 = react.useCallback((chain) => {
+    manager.setSelectedChain(chain);
+    setSelectedChainState(chain);
+  }, [manager]);
+  const getAddressForChain = react.useCallback(
+    (chain) => manager.getAddressForChain(chain),
+    [manager]
+  );
+  const getAllAddresses = react.useCallback(
+    () => manager.getAllAddresses(),
+    [manager]
+  );
+  const hasWallet = react.useCallback(() => manager.hasWallet(), [manager]);
+  const getSeed = react.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
+  };
+}
+
+// src/utils/index.ts
+function formatAddress(address, chars = 4) {
+  if (!address || address.length < 10) return address;
+  return `${address.slice(0, chars + 2)}...${address.slice(-chars)}`;
+}
+function formatBalance(balance, decimals = 18, precision = 4) {
+  const divisor = BigInt(10 ** decimals);
+  const integerPart = balance / divisor;
+  const fractionalPart = balance % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0").slice(0, precision);
+  return `${integerPart}.${fractionalStr}`;
+}
+function isValidAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function normalizeAddress(address) {
+  if (!isValidAddress(address)) {
+    throw new Error("Invalid Ethereum address");
+  }
+  return address.toLowerCase();
+}
+
+exports.DERIVATION_PATHS = DERIVATION_PATHS;
+exports.KeyManager = KeyManager;
+exports.MemoryStorageAdapter = MemoryStorageAdapter;
+exports.NETWORKS = NETWORKS;
+exports.PLATFORM_CONFIG = PLATFORM_CONFIG;
+exports.SwapService = SwapService;
+exports.TESTNET_NETWORKS = TESTNET_NETWORKS;
+exports.WalletManager = WalletManager;
+exports.WebEncryptedStorageAdapter = WebEncryptedStorageAdapter;
+exports.ZUBARI_CONTRACTS = ZUBARI_CONTRACTS;
+exports.ZubariError = ZubariError;
+exports.ZubariNFTProtocol = ZubariNFTProtocol;
+exports.ZubariPayoutsProtocol = ZubariPayoutsProtocol;
+exports.ZubariSubscriptionProtocol = ZubariSubscriptionProtocol;
+exports.ZubariTipsProtocol = ZubariTipsProtocol;
+exports.ZubariWallet = ZubariWallet;
+exports.createSecureStorage = createSecureStorage;
+exports.formatAddress = formatAddress;
+exports.formatBalance = formatBalance;
+exports.getContractAddresses = getContractAddresses;
+exports.getNetworkConfig = getNetworkConfig;
+exports.isValidAddress = isValidAddress;
+exports.normalizeAddress = normalizeAddress;
+exports.useWalletManager = useWalletManager;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map