@talken/talkenkit 2.4.29 → 2.5.0

package/dist/chunk-RAWLCGOW.js

@@ -1,5058 +0,0 @@
-"use client";
-import {
-  ABC_WALLET_METADATA,
-  DEFAULT_TALKEN_API_CONFIG,
-  PIN_CONFIG,
-  STORAGE_PREFIX,
-  TALKEN_API_ENDPOINTS,
-  TOKEN_EXPIRY,
-  getCredentialManager
-} from "./chunk-XIDK5P36.js";
-
-// src/wallets/walletConnectors/abcWallet/abcWallet.ts
-import { setTalkenApiClient as setTalkenApiClient2 } from "@talken/talkenkit";
-
-// src/wallets/walletConnectors/abcWallet/abcConnector.ts
-import { getTalkenApiClient as getTalkenApiClient3 } from "@talken/talkenkit";
-import { createConnector } from "wagmi";
-
-// src/wallets/walletConnectors/abcWallet/abcProvider.ts
-import { getTalkenApiClient } from "@talken/talkenkit";
-import { parseGwei } from "viem";
-
-// src/config/networks.ts
-var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
-  NetworkType2["EVM"] = "EVM";
-  NetworkType2["NON_EVM"] = "Non-EVM";
-  NetworkType2["BITCOIN"] = "Bitcoin";
-  NetworkType2["TRON"] = "TRX";
-  NetworkType2["ICP"] = "ICP";
-  NetworkType2["SOLANA"] = "Solana";
-  return NetworkType2;
-})(NetworkType || {});
-var NETWORK_CONFIGS = {
-  // Ethereum Mainnet
-  1: {
-    chainId: 1,
-    network: "ethereum",
-    name: "Ethereum",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://etherscan.io",
-    website: "https://ethereum.org",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Ethereum Sepolia Testnet
-  11155111: {
-    chainId: 11155111,
-    network: "ethereum_sepolia",
-    name: "Ethereum Sepolia",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://sepolia.etherscan.io",
-    website: "https://ethereum.org",
-    nativeCurrency: {
-      name: "Sepolia Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Ethereum Holesky Testnet
-  17e3: {
-    chainId: 17e3,
-    network: "ethereum_holesky",
-    name: "Ethereum Holesky",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://holesky.etherscan.io",
-    website: "https://ethereum.org",
-    nativeCurrency: {
-      name: "Holesky Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Kaia Mainnet (formerly Klaytn)
-  8217: {
-    chainId: 8217,
-    network: "kaia",
-    name: "Kaia Mainnet",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://kaiascan.io",
-    website: "https://kaia.io",
-    nativeCurrency: {
-      name: "Kaia",
-      symbol: "KAIA",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Kaia Kairos Testnet
-  1001: {
-    chainId: 1001,
-    network: "kaia_kairos",
-    name: "Kaia Kairos Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://kairos.kaiascan.io",
-    website: "https://kaia.io",
-    nativeCurrency: {
-      name: "Kaia",
-      symbol: "KAIA",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Polygon Mainnet
-  137: {
-    chainId: 137,
-    network: "polygon",
-    name: "Polygon",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://polygonscan.com",
-    website: "https://polygon.technology",
-    nativeCurrency: {
-      name: "MATIC",
-      symbol: "MATIC",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Polygon Amoy Testnet
-  80001: {
-    chainId: 80001,
-    network: "polygon_amoy",
-    name: "Polygon Amoy Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://amoy.polygonscan.com",
-    website: "https://polygon.technology",
-    nativeCurrency: {
-      name: "MATIC",
-      symbol: "MATIC",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Binance Smart Chain Mainnet
-  56: {
-    chainId: 56,
-    network: "binance",
-    name: "Binance Smart Chain Mainnet",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://bscscan.com",
-    website: "https://www.bnbchain.org/en/bnb-smart-chain",
-    nativeCurrency: {
-      name: "BNB",
-      symbol: "BNB",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Binance Smart Chain Testnet
-  97: {
-    chainId: 97,
-    network: "binance_testnet",
-    name: "Binance Smart Chain Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://testnet.bscscan.com",
-    website: "https://www.bnbchain.org/en/bnb-smart-chain",
-    nativeCurrency: {
-      name: "BNB",
-      symbol: "BNB",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Arbitrum One
-  42161: {
-    chainId: 42161,
-    network: "arbitrum",
-    name: "Arbitrum One",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://arbiscan.io",
-    website: "https://arbitrum.io",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Arbitrum Sepolia
-  421614: {
-    chainId: 421614,
-    network: "arbitrum_sepolia",
-    name: "Arbitrum Sepolia",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://sepolia.arbiscan.io",
-    website: "https://arbitrum.io",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Optimism Mainnet
-  10: {
-    chainId: 10,
-    network: "optimism",
-    name: "Optimism",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://optimistic.etherscan.io",
-    website: "https://optimism.io",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Optimism Sepolia
-  420: {
-    chainId: 420,
-    network: "optimism_sepolia",
-    name: "Optimism Sepolia",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://sepolia-optimism.etherscan.io",
-    website: "https://optimism.io",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Avalanche C-Chain
-  43114: {
-    chainId: 43114,
-    network: "avalanche",
-    name: "Avalanche C-Chain",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://avascan.info/blockchain/c/home",
-    website: "https://avax.network",
-    nativeCurrency: {
-      name: "Avalanche",
-      symbol: "AVAX",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Avalanche Fuji Testnet
-  43113: {
-    chainId: 43113,
-    network: "avalanche_fuji",
-    name: "Avalanche Fuji Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://testnet.avascan.info",
-    website: "https://avax.network",
-    nativeCurrency: {
-      name: "Avalanche",
-      symbol: "AVAX",
-      decimals: 18
-    },
-    apiSupport: { tokens: false, nft: false, transactions: false },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Mantle Mainnet
-  5e3: {
-    chainId: 5e3,
-    network: "mantle",
-    name: "Mantle Mainnet",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://explorer.mantle.xyz",
-    website: "https://www.mantle.xyz",
-    nativeCurrency: {
-      name: "Mantle",
-      symbol: "MNT",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Mantle Testnet
-  5001: {
-    chainId: 5001,
-    network: "mantle_testnet",
-    name: "Mantle Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://sepolia.mantlescan.xyz",
-    website: "https://www.mantle.xyz",
-    nativeCurrency: {
-      name: "Mantle",
-      symbol: "MNT",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Moonbeam
-  1284: {
-    chainId: 1284,
-    network: "moonbeam",
-    name: "Moonbeam",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://moonbeam.moonscan.io",
-    website: "https://moonbeam.network",
-    nativeCurrency: {
-      name: "Glimmer",
-      symbol: "GLMR",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Moonriver
-  1285: {
-    chainId: 1285,
-    network: "moonriver",
-    name: "Moonriver",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://moonriver.moonscan.io",
-    website: "https://moonbeam.network/networks/moonriver",
-    nativeCurrency: {
-      name: "Moonriver",
-      symbol: "MOVR",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Scroll Mainnet
-  534352: {
-    chainId: 534352,
-    network: "scroll",
-    name: "Scroll",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://scrollscan.co",
-    website: "https://scroll.io",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Scroll Testnet
-  534351: {
-    chainId: 534351,
-    network: "scroll_testnet",
-    name: "Scroll Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://sepolia.scrollscan.com",
-    website: "https://scroll.io",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Silicon Mainnet
-  2355: {
-    chainId: 2355,
-    network: "silicon",
-    name: "Silicon",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://scope.silicon.network",
-    website: "https://silicon.network",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Silicon Sepolia
-  1722641160: {
-    chainId: 1722641160,
-    network: "silicon_sepolia",
-    name: "Silicon Sepolia",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://scope-sepolia.silicon.network",
-    website: "https://silicon.network",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Six Protocol
-  98: {
-    chainId: 98,
-    network: "six_evm",
-    name: "Six Protocol",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://v2.sixscan.io",
-    website: "https://www.six.network",
-    nativeCurrency: {
-      name: "SIX",
-      symbol: "SIX",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: false, transactions: true },
-    signSupport: { legacy: true, eip1559: false }
-  },
-  // Six Protocol Testnet
-  150: {
-    chainId: 150,
-    network: "six_evm_testnet",
-    name: "Six Protocol Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://v2.fivenet.sixscan.io",
-    website: "https://www.six.network",
-    nativeCurrency: {
-      name: "SIX",
-      symbol: "SIX",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: false, transactions: true },
-    signSupport: { legacy: true, eip1559: false }
-  },
-  // Wemix Mainnet
-  1111: {
-    chainId: 1111,
-    network: "wemix",
-    name: "Wemix3.0 Mainnet",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://explorer.wemix.com",
-    website: "https://wemix.com",
-    nativeCurrency: {
-      name: "WEMIX",
-      symbol: "WEMIX",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Wemix Testnet
-  1112: {
-    chainId: 1112,
-    network: "wemix_testnet",
-    name: "Wemix3.0 Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://explorer.test.wemix.com",
-    website: "https://wemix.com",
-    nativeCurrency: {
-      name: "WEMIX",
-      symbol: "WEMIX",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Taiko Mainnet
-  167e3: {
-    chainId: 167e3,
-    network: "taiko",
-    name: "Taiko Mainnet",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://taikoscan.io",
-    website: "https://taiko.xyz",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Taiko Hekla Testnet
-  167009: {
-    chainId: 167009,
-    network: "taiko_hekla",
-    name: "Taiko Hekla Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://hekla.taikoscan.io",
-    website: "https://taiko.xyz",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Base Mainnet
-  8453: {
-    chainId: 8453,
-    network: "base",
-    name: "Base",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://basescan.org",
-    website: "https://base.org",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Base Sepolia Testnet
-  84532: {
-    chainId: 84532,
-    network: "base_sepolia",
-    name: "Base Sepolia",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://sepolia.basescan.org",
-    website: "https://base.org",
-    nativeCurrency: {
-      name: "Ether",
-      symbol: "ETH",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // ChainBounty Mainnet
-  51828: {
-    chainId: 51828,
-    network: "chainbounty",
-    name: "ChainBounty Mainnet",
-    type: "EVM" /* EVM */,
-    isTestnet: false,
-    explorer: "https://scan.chainbounty.io",
-    website: "https://chainbounty.io",
-    nativeCurrency: {
-      name: "ChainBounty",
-      symbol: "CBY",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // ChainBounty Testnet
-  56580: {
-    chainId: 56580,
-    network: "chainbounty_testnet",
-    name: "ChainBounty Testnet",
-    type: "EVM" /* EVM */,
-    isTestnet: true,
-    explorer: "https://test.scan.chainbounty.io",
-    website: "https://chainbounty.io",
-    nativeCurrency: {
-      name: "ChainBounty",
-      symbol: "CBY",
-      decimals: 18
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Aptos Mainnet (Non-EVM)
-  aptos: {
-    chainId: null,
-    network: "aptos",
-    name: "Aptos",
-    type: "Non-EVM" /* NON_EVM */,
-    isTestnet: false,
-    explorer: "https://explorer.aptoslabs.com/?network=mainnet",
-    website: "https://aptos.dev",
-    nativeCurrency: {
-      name: "Aptos",
-      symbol: "APT",
-      decimals: 8
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: false }
-  },
-  // Aptos Testnet (Non-EVM)
-  aptos_testnet: {
-    chainId: null,
-    network: "aptos_testnet",
-    name: "Aptos Testnet",
-    type: "Non-EVM" /* NON_EVM */,
-    isTestnet: true,
-    explorer: "https://explorer.aptoslabs.com/?network=testnet",
-    website: "https://aptos.dev",
-    nativeCurrency: {
-      name: "Aptos",
-      symbol: "APT",
-      decimals: 8
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: false }
-  },
-  // Bitcoin Mainnet
-  bitcoin: {
-    chainId: null,
-    network: "bitcoin",
-    name: "Bitcoin Mainnet",
-    type: "Bitcoin" /* BITCOIN */,
-    isTestnet: false,
-    explorer: "https://blockstream.info",
-    website: "https://bitcoin.org",
-    nativeCurrency: {
-      name: "Bitcoin",
-      symbol: "BTC",
-      decimals: 8
-    },
-    apiSupport: { tokens: true, nft: false, transactions: true },
-    signSupport: { legacy: true, eip1559: false }
-  },
-  // Bitcoin Testnet
-  bitcoin_testnet: {
-    chainId: null,
-    network: "bitcoin_testnet",
-    name: "Bitcoin Testnet",
-    type: "Bitcoin" /* BITCOIN */,
-    isTestnet: true,
-    explorer: "https://blockstream.info/testnet",
-    website: "https://bitcoin.org",
-    nativeCurrency: {
-      name: "Bitcoin",
-      symbol: "BTC",
-      decimals: 8
-    },
-    apiSupport: { tokens: true, nft: false, transactions: true },
-    signSupport: { legacy: true, eip1559: false }
-  },
-  // Tron Mainnet
-  tron: {
-    chainId: null,
-    network: "tron",
-    name: "Tron Mainnet",
-    type: "TRX" /* TRON */,
-    isTestnet: false,
-    explorer: "https://tronscan.org",
-    website: "https://tron.network",
-    nativeCurrency: {
-      name: "Tronix",
-      symbol: "TRX",
-      decimals: 6
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // Tron Nile Testnet
-  tron_nile: {
-    chainId: null,
-    network: "tron_nile",
-    name: "Tron Nile Testnet",
-    type: "TRX" /* TRON */,
-    isTestnet: true,
-    explorer: "https://nile.tronscan.org",
-    website: "https://tron.network",
-    nativeCurrency: {
-      name: "Tronix",
-      symbol: "TRX",
-      decimals: 6
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  },
-  // ICP Mainnet
-  icp: {
-    chainId: null,
-    network: "icp",
-    name: "Internet Computer",
-    type: "ICP" /* ICP */,
-    isTestnet: false,
-    explorer: "https://dashboard.internetcomputer.org",
-    website: "https://internetcomputer.org",
-    nativeCurrency: {
-      name: "ICP",
-      symbol: "ICP",
-      decimals: 8
-    },
-    apiSupport: { tokens: true, nft: true, transactions: true },
-    signSupport: { legacy: true, eip1559: true }
-  }
-};
-var NETWORK_BY_PARAM = Object.values(
-  NETWORK_CONFIGS
-).reduce(
-  (acc, config) => {
-    acc[config.network] = config;
-    return acc;
-  },
-  {}
-);
-function getNetworkByChainId(chainId) {
-  return NETWORK_CONFIGS[chainId];
-}
-function getNetworkByParam(network) {
-  return NETWORK_BY_PARAM[network];
-}
-function chainIdToNetwork(chainId) {
-  return NETWORK_CONFIGS[chainId]?.network;
-}
-function getNetworkName(chainId, fallback = "ethereum") {
-  return NETWORK_CONFIGS[chainId]?.network ?? fallback;
-}
-var CHAIN_ID_TO_KEY = {
-  // Mainnet
-  1: "ethereum",
-  42161: "arbitrum",
-  8217: "kaia",
-  56: "bsc",
-  8453: "base",
-  137: "polygon",
-  // Testnet
-  11155111: "sepolia",
-  421614: "arbitrumSepolia",
-  1001: "kaiaKairos",
-  97: "bscTestnet",
-  84532: "baseSepolia",
-  80002: "polygonAmoy",
-  998: "hyperevmTestnet"
-};
-function getChainKey(chainId) {
-  const key = CHAIN_ID_TO_KEY[chainId];
-  if (!key) {
-    throw new Error(`Unsupported chainId for tx endpoint: ${chainId}`);
-  }
-  return key;
-}
-function networkNameToChainKey(network) {
-  const chainId = NETWORK_BY_PARAM[network]?.chainId;
-  if (chainId == null)
-    return network;
-  return CHAIN_ID_TO_KEY[chainId] ?? network;
-}
-function networkToChainId(network) {
-  return NETWORK_BY_PARAM[network]?.chainId;
-}
-function getExplorerTxUrl(chainIdOrNetwork, txHash) {
-  const config = typeof chainIdOrNetwork === "number" ? getNetworkByChainId(chainIdOrNetwork) : getNetworkByParam(chainIdOrNetwork);
-  if (!config) {
-    throw new Error(`Unknown network: ${chainIdOrNetwork}`);
-  }
-  return `${config.explorer}/tx/${txHash}`;
-}
-function getExplorerAddressUrl(chainIdOrNetwork, address) {
-  const config = typeof chainIdOrNetwork === "number" ? getNetworkByChainId(chainIdOrNetwork) : getNetworkByParam(chainIdOrNetwork);
-  if (!config) {
-    throw new Error(`Unknown network: ${chainIdOrNetwork}`);
-  }
-  return `${config.explorer}/address/${address}`;
-}
-function isEvmNetwork(chainIdOrNetwork) {
-  const config = typeof chainIdOrNetwork === "number" ? getNetworkByChainId(chainIdOrNetwork) : getNetworkByParam(chainIdOrNetwork);
-  return config?.type === "EVM" /* EVM */;
-}
-function isTestnet(chainIdOrNetwork) {
-  const config = typeof chainIdOrNetwork === "number" ? getNetworkByChainId(chainIdOrNetwork) : getNetworkByParam(chainIdOrNetwork);
-  return config?.isTestnet ?? false;
-}
-function getSupportedChainIds(includeTestnets = true) {
-  return Object.values(NETWORK_CONFIGS).filter(
-    (config) => config.chainId !== null && (includeTestnets || !config.isTestnet)
-  ).map((config) => config.chainId);
-}
-function getSupportedNetworks(includeTestnets = true) {
-  return Object.values(NETWORK_CONFIGS).filter((config) => includeTestnets || !config.isTestnet).map((config) => config.network);
-}
-
-// src/wallets/walletConnectors/abcWallet/types.ts
-var AbcStorageKey = /* @__PURE__ */ ((AbcStorageKey2) => {
-  AbcStorageKey2["USER"] = "user";
-  AbcStorageKey2["WALLET"] = "wallet";
-  AbcStorageKey2["SOLANA_WALLET"] = "solana_wallet";
-  AbcStorageKey2["BITCOIN_WALLET"] = "bitcoin_wallet";
-  AbcStorageKey2["TRON_WALLET"] = "tron_wallet";
-  AbcStorageKey2["ACCESS_TOKEN"] = "access_token";
-  AbcStorageKey2["REFRESH_TOKEN"] = "refresh_token";
-  AbcStorageKey2["EXPIRES_AT"] = "expires_at";
-  AbcStorageKey2["AUTH_STATE"] = "auth_state";
-  return AbcStorageKey2;
-})(AbcStorageKey || {});
-var AbcErrorCode = /* @__PURE__ */ ((AbcErrorCode3) => {
-  AbcErrorCode3["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
-  AbcErrorCode3["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
-  AbcErrorCode3["WALLET_NOT_FOUND"] = "WALLET_NOT_FOUND";
-  AbcErrorCode3["INVALID_PIN"] = "INVALID_PIN";
-  AbcErrorCode3["NETWORK_ERROR"] = "NETWORK_ERROR";
-  AbcErrorCode3["SIGNATURE_FAILED"] = "SIGNATURE_FAILED";
-  AbcErrorCode3["USER_CANCELLED"] = "USER_CANCELLED";
-  AbcErrorCode3["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-  return AbcErrorCode3;
-})(AbcErrorCode || {});
-var AbcError = class extends Error {
-  constructor(code, message, details, statusCode) {
-    super(message);
-    this.name = "AbcError";
-    this.code = code;
-    this.details = details;
-    this.statusCode = statusCode;
-  }
-};
-var TalkenApiError = class extends Error {
-  constructor(code, message, statusCode, details) {
-    super(message);
-    this.name = "TalkenApiError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/utils.ts
-async function hashPin(pin) {
-  if (typeof window === "undefined" || !window.crypto?.subtle) {
-    return btoa(pin);
-  }
-  const encoder = new TextEncoder();
-  const data = encoder.encode(pin);
-  const hashBuffer = await window.crypto.subtle.digest("SHA-256", data);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return hashHex;
-}
-function validatePin(pin) {
-  if (!pin || typeof pin !== "string") {
-    return false;
-  }
-  const pinLength = pin.length;
-  if (pinLength < PIN_CONFIG.MIN_LENGTH || pinLength > PIN_CONFIG.MAX_LENGTH) {
-    return false;
-  }
-  return /^\d+$/.test(pin);
-}
-function validateEmail(email) {
-  if (!email || typeof email !== "string") {
-    return false;
-  }
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(email);
-}
-function getStorageKey(key) {
-  return `${STORAGE_PREFIX}${key}`;
-}
-function saveToStorage(key, value) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    const storageKey = getStorageKey(key);
-    const serialized = JSON.stringify(value);
-    localStorage.setItem(storageKey, serialized);
-  } catch (error) {
-    console.error("Failed to save to storage:", error);
-  }
-}
-function loadFromStorage(key) {
-  if (typeof window === "undefined")
-    return null;
-  try {
-    const storageKey = getStorageKey(key);
-    const serialized = localStorage.getItem(storageKey);
-    if (!serialized)
-      return null;
-    try {
-      return JSON.parse(serialized);
-    } catch {
-      return serialized;
-    }
-  } catch (error) {
-    console.error("Failed to load from storage:", error);
-    return null;
-  }
-}
-function removeFromStorage(key) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    const storageKey = getStorageKey(key);
-    localStorage.removeItem(storageKey);
-  } catch (error) {
-    console.error("Failed to remove from storage:", error);
-  }
-}
-function clearStorage() {
-  if (typeof window === "undefined")
-    return;
-  const keysToRemove = [];
-  for (let i = 0; i < localStorage.length; i++) {
-    const key = localStorage.key(i);
-    if (key?.startsWith(STORAGE_PREFIX)) {
-      keysToRemove.push(key);
-    }
-  }
-  for (const key of keysToRemove) {
-    localStorage.removeItem(key);
-  }
-}
-function isTokenExpired(expiresAt) {
-  if (!expiresAt)
-    return true;
-  return Date.now() >= expiresAt - TOKEN_EXPIRY.REFRESH_BUFFER;
-}
-function calculateExpiryTimestamp(expiresIn) {
-  return Date.now() + expiresIn * 1e3;
-}
-function saveAuthState(state) {
-  saveToStorage("auth_state" /* AUTH_STATE */, state);
-  if (state.user) {
-    saveToStorage("user" /* USER */, state.user);
-  }
-  if (state.wallet) {
-    saveToStorage("wallet" /* WALLET */, state.wallet);
-  }
-  if (state.solanaWallet) {
-    saveToStorage("solana_wallet" /* SOLANA_WALLET */, state.solanaWallet);
-  }
-  if (state.bitcoinWallet) {
-    saveToStorage("bitcoin_wallet" /* BITCOIN_WALLET */, state.bitcoinWallet);
-  }
-  if (state.tronWallet) {
-    saveToStorage("tron_wallet" /* TRON_WALLET */, state.tronWallet);
-  }
-  if (state.accessToken) {
-    saveToStorage("access_token" /* ACCESS_TOKEN */, state.accessToken);
-  }
-  if (state.refreshToken) {
-    saveToStorage("refresh_token" /* REFRESH_TOKEN */, state.refreshToken);
-  }
-  if (state.expiresAt) {
-    saveToStorage("expires_at" /* EXPIRES_AT */, state.expiresAt);
-  }
-}
-function hydrateAuthStateFromIndividualStorage(state) {
-  const user = loadFromStorage("user" /* USER */);
-  const wallet = loadFromStorage("wallet" /* WALLET */);
-  const solanaWallet = loadFromStorage("solana_wallet" /* SOLANA_WALLET */);
-  const bitcoinWallet = loadFromStorage("bitcoin_wallet" /* BITCOIN_WALLET */);
-  const tronWallet = loadFromStorage("tron_wallet" /* TRON_WALLET */);
-  const accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
-  const refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
-  const expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
-  const nextState = {
-    ...state,
-    user: state.user || user || null,
-    wallet: state.wallet || wallet || null,
-    solanaWallet: state.solanaWallet || solanaWallet || null,
-    bitcoinWallet: state.bitcoinWallet || bitcoinWallet || null,
-    tronWallet: state.tronWallet || tronWallet || null,
-    accessToken: state.accessToken || accessToken || null,
-    refreshToken: state.refreshToken || refreshToken || null,
-    expiresAt: state.expiresAt || expiresAt || null
-  };
-  const wasHydrated = nextState.user !== state.user || nextState.wallet !== state.wallet || nextState.solanaWallet !== state.solanaWallet || nextState.bitcoinWallet !== state.bitcoinWallet || nextState.tronWallet !== state.tronWallet || nextState.accessToken !== state.accessToken || nextState.refreshToken !== state.refreshToken || nextState.expiresAt !== state.expiresAt;
-  if (wasHydrated) {
-    saveToStorage("auth_state" /* AUTH_STATE */, nextState);
-  }
-  return nextState;
-}
-function loadAuthState() {
-  const state = loadFromStorage("auth_state" /* AUTH_STATE */);
-  if (state) {
-    if (state.accessToken && isTokenExpired(state.expiresAt)) {
-      clearStorage();
-      return null;
-    }
-    return hydrateAuthStateFromIndividualStorage(state);
-  }
-  const user = loadFromStorage("user" /* USER */);
-  const wallet = loadFromStorage("wallet" /* WALLET */);
-  const solanaWallet = loadFromStorage("solana_wallet" /* SOLANA_WALLET */);
-  const accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
-  const refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
-  const expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
-  if (!user || !accessToken) {
-    return null;
-  }
-  const bitcoinWallet = loadFromStorage("bitcoin_wallet" /* BITCOIN_WALLET */);
-  const tronWallet = loadFromStorage("tron_wallet" /* TRON_WALLET */);
-  return {
-    isAuthenticated: true,
-    user,
-    wallet,
-    solanaWallet,
-    bitcoinWallet,
-    tronWallet,
-    accessToken,
-    refreshToken,
-    expiresAt
-  };
-}
-function clearAuthState() {
-  clearStorage();
-}
-function createAbcError(code, message, details, statusCode) {
-  return new AbcError(code, message, details, statusCode);
-}
-function hexToNumber(hex) {
-  return Number.parseInt(hex, 16);
-}
-function numberToHex(num) {
-  return `0x${num.toString(16)}`;
-}
-
-// src/wallets/walletConnectors/abcWallet/abcProvider.ts
-var EventEmitter = class {
-  constructor() {
-    this.events = /* @__PURE__ */ new Map();
-  }
-  on(event, listener) {
-    if (!this.events.has(event)) {
-      this.events.set(event, []);
-    }
-    this.events.get(event).push(listener);
-    return this;
-  }
-  off(event, listener) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
-      }
-    }
-    return this;
-  }
-  removeListener(event, listener) {
-    return this.off(event, listener);
-  }
-  emit(event, ...args) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        listener(...args);
-      }
-      return true;
-    }
-    return false;
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this.events.delete(event);
-    } else {
-      this.events.clear();
-    }
-    return this;
-  }
-};
-var ProviderRpcError = class extends Error {
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "ProviderRpcError";
-  }
-};
-var ErrorCode = {
-  USER_REJECTED: 4001,
-  UNAUTHORIZED: 4100,
-  UNSUPPORTED_METHOD: 4200,
-  DISCONNECTED: 4900,
-  CHAIN_DISCONNECTED: 4901,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603
-};
-var AbcEvmProvider = class extends EventEmitter {
-  constructor(talkenApi) {
-    super();
-    this.wallet = null;
-    this.chainId = 1;
-    // Default to Ethereum mainnet
-    this.connected = false;
-    this.talkenApi = talkenApi;
-  }
-  getRecoveryEmail() {
-    const walletEmail = this.wallet?.email?.trim();
-    if (walletEmail) {
-      return walletEmail;
-    }
-    return getCredentialManager().getEmail() || void 0;
-  }
-  /**
-   * Set wallet information
-   */
-  setWallet(wallet) {
-    const previousAddress = this.wallet?.address;
-    const previousChainId = this.chainId;
-    this.wallet = wallet;
-    this.chainId = wallet.chainId;
-    this.connected = true;
-    if (previousAddress !== wallet.address) {
-      this.emit("accountsChanged", [wallet.address]);
-    }
-    if (previousChainId !== wallet.chainId) {
-      this.emit("chainChanged", numberToHex(wallet.chainId));
-    }
-    this.emit("connect", { chainId: numberToHex(wallet.chainId) });
-  }
-  /**
-   * Clear wallet (disconnect)
-   */
-  clearWallet() {
-    this.wallet = null;
-    this.connected = false;
-    this.emit("disconnect", {
-      code: ErrorCode.DISCONNECTED,
-      message: "User disconnected"
-    });
-    this.emit("accountsChanged", []);
-  }
-  /**
-   * Set request interceptor for sign confirmation
-   * The interceptor is called before signing operations to show confirmation UI
-   */
-  setRequestInterceptor(interceptor) {
-    this.requestInterceptor = interceptor;
-  }
-  /**
-   * Set TalkenApiClient for backend-proxied transaction flow
-   * When set, transaction methods will use a single API call instead of multi-step WaaS
-   */
-  setTalkenApi(talkenApi) {
-    this.talkenApi = talkenApi;
-  }
-  getTalkenApiClientOrThrow() {
-    const api = this.talkenApi || getTalkenApiClient();
-    if (!api) {
-      throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
-        "TalkenApiClient not initialized"
-      );
-    }
-    return api;
-  }
-  /**
-   * Check if an error is a "Missing required wallet fields" 502 from the server.
-   * When the server's in-memory signing credential cache is cold, it needs
-   * a wallet.generate() call (idempotent create/recover) to repopulate.
-   */
-  isSigningCredentialError(error) {
-    return error instanceof TalkenApiError && error.statusCode === 502 && error.message.includes("Missing required wallet fields");
-  }
-  /**
-   * Refresh server-side signing credentials by calling wallet.generate().
-   * This is idempotent — it recovers existing wallets, not creates new ones.
-   */
-  async refreshSigningCredentials() {
-    const pinHash = getCredentialManager().getPinHash();
-    const email = this.getRecoveryEmail();
-    if (!pinHash || !email) {
-      console.warn(
-        "[AbcProvider] Cannot refresh signing credentials \u2014 PIN hash or email missing"
-      );
-      return;
-    }
-    const api = this.getTalkenApiClientOrThrow();
-    console.log("[AbcProvider] Refreshing server-side signing credentials...");
-    await api.wallet.generate(pinHash, email);
-    console.log("[AbcProvider] Signing credentials refreshed");
-  }
-  /**
-   * Wrap a signing operation with auto-retry on "Missing required wallet fields" error.
-   * On first failure, refreshes the server's signing credential cache and retries once.
-   */
-  async withSigningCredentialRetry(operation) {
-    try {
-      return await operation();
-    } catch (error) {
-      if (this.isSigningCredentialError(error)) {
-        console.log(
-          "[AbcProvider] Signing credentials missing on server \u2014 attempting refresh and retry"
-        );
-        await this.refreshSigningCredentials();
-        return await operation();
-      }
-      throw error;
-    }
-  }
-  /**
-   * Call request interceptor if configured
-   * Called by specific signing/transaction methods that need user confirmation
-   * @returns Resolved transaction with user modifications if changed in confirmation modal
-   */
-  async callInterceptor(method, params) {
-    if (!this.requestInterceptor) {
-      return void 0;
-    }
-    const request = {
-      method,
-      params,
-      chainId: this.chainId,
-      address: this.wallet?.address || ""
-    };
-    return this.requestInterceptor(request);
-  }
-  /**
-   * EIP-1193 request method
-   */
-  async request(args) {
-    const { method, params } = args;
-    switch (method) {
-      case "eth_requestAccounts":
-        return this.eth_requestAccounts();
-      case "eth_accounts":
-        return this.eth_accounts();
-      case "eth_chainId":
-        return this.eth_chainId();
-      case "eth_sendTransaction":
-      case "wallet_sendTransaction":
-        return this.eth_sendTransaction(params);
-      case "eth_signTransaction":
-        return this.eth_signTransaction(params);
-      case "personal_sign":
-        return this.personal_sign(params);
-      case "eth_sign":
-        return this.eth_sign(params);
-      case "eth_signTypedData":
-      case "eth_signTypedData_v3":
-      case "eth_signTypedData_v4":
-        return this.eth_signTypedData(params);
-      case "wallet_getCapabilities":
-        return this.wallet_getCapabilities();
-      case "eth_signAuthorization":
-        return this.eth_signAuthorization(params);
-      case "wallet_switchEthereumChain":
-        return this.wallet_switchEthereumChain(params);
-      case "wallet_addEthereumChain":
-        return this.wallet_addEthereumChain(params);
-      case "eth_estimateGas":
-        return this.eth_estimateGas(params);
-      case "eth_getTransactionCount":
-        return this.eth_getTransactionCount(
-          Array.isArray(params) ? params : []
-        );
-      case "eth_blockNumber":
-      case "eth_call":
-      case "eth_gasPrice":
-      case "eth_getBalance":
-      case "eth_getBlockByHash":
-      case "eth_getBlockByNumber":
-      case "eth_getCode":
-      case "eth_getStorageAt":
-      case "eth_getTransactionByHash":
-      case "eth_getTransactionReceipt":
-        throw new ProviderRpcError(
-          ErrorCode.UNSUPPORTED_METHOD,
-          `Method ${method} should be handled by RPC provider`
-        );
-      default:
-        throw new ProviderRpcError(
-          ErrorCode.UNSUPPORTED_METHOD,
-          `Method ${method} not supported`
-        );
-    }
-  }
-  /**
-   * Request accounts (EIP-1193)
-   */
-  async eth_requestAccounts() {
-    if (!this.wallet) {
-      throw new ProviderRpcError(
-        ErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    return [this.wallet.address];
-  }
-  /**
-   * Get accounts
-   */
-  async eth_accounts() {
-    if (!this.wallet) {
-      return [];
-    }
-    return [this.wallet.address];
-  }
-  /**
-   * Get chain ID
-   */
-  async eth_chainId() {
-    return numberToHex(this.chainId);
-  }
-  /**
-   * Send transaction
-   */
-  async eth_sendTransaction(params) {
-    if (!this.wallet) {
-      throw new ProviderRpcError(
-        ErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    if (!Array.isArray(params) || params.length === 0) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid transaction params"
-      );
-    }
-    const resolved = await this.callInterceptor("eth_sendTransaction", params);
-    const tx = params[0];
-    console.log("[AbcProvider] eth_sendTransaction incoming gas params:", {
-      gas: tx.gas ?? tx.gasLimit,
-      gasPrice: tx.gasPrice,
-      maxFeePerGas: tx.maxFeePerGas,
-      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
-    });
-    if (resolved) {
-      if (resolved.data) {
-        tx.data = resolved.data;
-      }
-      if (resolved.gasFee?.maxFeePerGas) {
-        try {
-          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
-          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
-        } catch (error) {
-          console.error(
-            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
-            error
-          );
-        }
-      }
-      if (resolved.gasFee?.maxPriorityFeePerGas) {
-        try {
-          const priorityFeeWei = parseGwei(
-            resolved.gasFee.maxPriorityFeePerGas
-          );
-          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
-        } catch (error) {
-          console.error(
-            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
-            error
-          );
-        }
-      }
-    }
-    console.log("[AbcProvider] eth_sendTransaction final gas params:", {
-      gas: tx.gas ?? tx.gasLimit,
-      gasPrice: tx.gasPrice,
-      maxFeePerGas: tx.maxFeePerGas,
-      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
-    });
-    const isContractDeployment = !tx.to || tx.to === "0x" || tx.to === "0x0" || tx.to === "0x0000000000000000000000000000000000000000";
-    if (isContractDeployment) {
-      tx.to = "0x";
-    } else if (!tx.to) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        'Transaction must have "to" field'
-      );
-    }
-    const pinHash = getCredentialManager().getPinHash();
-    if (!pinHash) {
-      throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
-        "PIN hash not found. Please login again."
-      );
-    }
-    const hexValue = tx.value || "0x0";
-    const amountWei = BigInt(hexValue).toString();
-    const email = this.getRecoveryEmail();
-    const api = this.getTalkenApiClientOrThrow();
-    const result = await this.withSigningCredentialRetry(
-      () => api.evm.sendTransaction({
-        chainKey: getChainKey(this.chainId),
-        to: tx.to,
-        amountWei,
-        pin: pinHash,
-        data: tx.data || "0x",
-        gasLimit: tx.gas || tx.gasLimit,
-        maxFeePerGas: tx.maxFeePerGas,
-        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-        ...email && { email }
-      })
-    );
-    return result.txHash;
-  }
-  /**
-   * Sign transaction (without sending)
-   */
-  async eth_signTransaction(params) {
-    if (!this.wallet) {
-      throw new ProviderRpcError(
-        ErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    if (!Array.isArray(params) || params.length === 0) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid transaction params"
-      );
-    }
-    const resolved = await this.callInterceptor("eth_signTransaction", params);
-    const tx = params[0];
-    if (resolved) {
-      if (resolved.data) {
-        tx.data = resolved.data;
-      }
-      if (resolved.gasFee?.maxFeePerGas) {
-        try {
-          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
-          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
-        } catch (error) {
-          console.error(
-            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
-            error
-          );
-        }
-      }
-      if (resolved.gasFee?.maxPriorityFeePerGas) {
-        try {
-          const priorityFeeWei = parseGwei(
-            resolved.gasFee.maxPriorityFeePerGas
-          );
-          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
-        } catch (error) {
-          console.error(
-            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
-            error
-          );
-        }
-      }
-    }
-    const api = this.getTalkenApiClientOrThrow();
-    const pinHash = getCredentialManager().getPinHash() || void 0;
-    const email = this.getRecoveryEmail();
-    const result = await this.withSigningCredentialRetry(
-      () => api.evm.signTransaction({
-        network: getNetworkName(this.chainId),
-        to: tx.to,
-        value: tx.value || "0x0",
-        data: tx.data || "0x",
-        gasLimit: tx.gas || tx.gasLimit,
-        maxFeePerGas: tx.maxFeePerGas,
-        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-        nonce: tx.nonce ? String(Number.parseInt(tx.nonce, 16)) : void 0,
-        ...pinHash && { pin: pinHash },
-        ...email && { email }
-      })
-    );
-    return result.signature;
-  }
-  /**
-   * Personal sign (EIP-191)
-   */
-  async personal_sign(params) {
-    if (!this.wallet) {
-      console.error("[AbcProvider] \u274C Wallet not connected");
-      throw new ProviderRpcError(
-        ErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    if (!Array.isArray(params) || params.length < 2) {
-      console.error("[AbcProvider] \u274C Invalid params:", params);
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid personal_sign params"
-      );
-    }
-    await this.callInterceptor("personal_sign", params);
-    const [message, address] = params;
-    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
-      console.error("[AbcProvider] \u274C Address mismatch");
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Address does not match connected wallet"
-      );
-    }
-    const api = this.getTalkenApiClientOrThrow();
-    const network = getNetworkName(this.chainId);
-    const pinHash = getCredentialManager().getPinHash() || void 0;
-    const email = this.getRecoveryEmail();
-    const result = await this.withSigningCredentialRetry(
-      () => api.evm.signPersonal({
-        network,
-        message,
-        address,
-        pin: pinHash,
-        ...email && { email }
-      })
-    );
-    return result.signature;
-  }
-  /**
-   * Eth sign
-   */
-  async eth_sign(params) {
-    if (!Array.isArray(params) || params.length < 2) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid eth_sign params"
-      );
-    }
-    const [address, message] = params;
-    return this.personal_sign([message, address]);
-  }
-  /**
-   * Sign typed data (EIP-712)
-   */
-  async eth_signTypedData(params) {
-    if (!this.wallet) {
-      throw new ProviderRpcError(
-        ErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    if (!Array.isArray(params) || params.length < 2) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid signTypedData params"
-      );
-    }
-    await this.callInterceptor("eth_signTypedData_v4", params);
-    const [address, typedData] = params;
-    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Address does not match connected wallet"
-      );
-    }
-    const api = this.getTalkenApiClientOrThrow();
-    const network = getNetworkName(this.chainId);
-    const pinHash = getCredentialManager().getPinHash() || void 0;
-    const email = this.getRecoveryEmail();
-    const result = await this.withSigningCredentialRetry(
-      () => api.evm.signTypedData({
-        network,
-        typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
-        pin: pinHash,
-        ...email && { email }
-      })
-    );
-    return result.signature;
-  }
-  /**
-   * Return normalized wallet capabilities for ABC embedded wallets.
-   * ABC supports EIP-7702 authorization signing via talken-api.
-   */
-  async wallet_getCapabilities() {
-    return {
-      supportsTypedDataV4: true,
-      supports7702Authorization: true,
-      supports5792Batch: false,
-      supportsPaymasterService: false,
-      supportsPermit2RelayHints: true,
-      walletType: "abc-embedded"
-    };
-  }
-  /**
-   * Sign EIP-7702 authorization via Talken API.
-   */
-  async eth_signAuthorization(params) {
-    if (!this.wallet) {
-      throw new ProviderRpcError(
-        ErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    if (!Array.isArray(params) || params.length < 2) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid signAuthorization params"
-      );
-    }
-    const [address, authorization] = params;
-    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Address does not match connected wallet"
-      );
-    }
-    if (!authorization?.address || authorization.chainId == null || authorization.nonce == null) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Authorization payload is incomplete"
-      );
-    }
-    await this.callInterceptor("eth_signAuthorization", params);
-    const api = this.getTalkenApiClientOrThrow();
-    const network = getNetworkName(this.chainId);
-    const pinHash = getCredentialManager().getPinHash() || void 0;
-    const email = this.getRecoveryEmail();
-    const chainIdValue = typeof authorization.chainId === "string" ? Number(BigInt(authorization.chainId)) : Number(authorization.chainId);
-    const nonceValue = typeof authorization.nonce === "string" ? BigInt(authorization.nonce).toString() : String(authorization.nonce);
-    const result = await this.withSigningCredentialRetry(
-      () => api.evm.signAuthorization({
-        network,
-        authorization: {
-          chainId: chainIdValue,
-          address: authorization.address,
-          nonce: nonceValue
-        },
-        pin: pinHash,
-        ...email && { email }
-      })
-    );
-    return result.authorization;
-  }
-  /**
-   * Switch Ethereum chain
-   */
-  async wallet_switchEthereumChain(params) {
-    if (!Array.isArray(params) || params.length === 0) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid switchEthereumChain params"
-      );
-    }
-    const { chainId } = params[0];
-    const newChainId = hexToNumber(chainId);
-    if (this.chainId === newChainId) {
-      return null;
-    }
-    const _previousChainId = this.chainId;
-    this.chainId = newChainId;
-    if (this.wallet) {
-      this.wallet.chainId = newChainId;
-    }
-    this.emit("chainChanged", numberToHex(newChainId));
-    return null;
-  }
-  /**
-   * Add Ethereum chain
-   */
-  async wallet_addEthereumChain(params) {
-    return this.wallet_switchEthereumChain(params);
-  }
-  /**
-   * Get transaction count (nonce) using ABC WaaS API
-   */
-  async eth_getTransactionCount(params) {
-    const address = params[0]?.toLowerCase();
-    if (!address) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Missing address parameter"
-      );
-    }
-    const currentChainId = this.chainId;
-    try {
-      const api = this.getTalkenApiClientOrThrow();
-      const response = await api.evm.getNonce(
-        getNetworkName(currentChainId),
-        address
-      );
-      const nonce = response.result !== void 0 ? typeof response.result === "number" ? `0x${response.result.toString(16)}` : response.result : void 0;
-      if (!nonce) {
-        throw new Error("No result in nonce response");
-      }
-      return nonce;
-    } catch (error) {
-      console.error(
-        "[AbcEvmProvider] \u274C Failed to get transaction count from ABC WaaS:",
-        error
-      );
-      throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
-        `Failed to get transaction count: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  /**
-   * Estimate gas for transaction
-   * Uses ABC WaaS gas estimation API with fallback
-   */
-  async eth_estimateGas(params) {
-    if (!Array.isArray(params) || params.length === 0) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        "Invalid estimateGas params"
-      );
-    }
-    const tx = params[0];
-    if (!tx.to) {
-      throw new ProviderRpcError(
-        ErrorCode.INVALID_PARAMS,
-        'Transaction must have "to" field'
-      );
-    }
-    try {
-      const response = await this.getTalkenApiClientOrThrow().evm.estimateGas({
-        network: getNetworkName(this.chainId),
-        from: tx.from || this.wallet?.address || "",
-        to: tx.to,
-        value: tx.value,
-        data: tx.data
-      });
-      if (!response.result) {
-        throw new Error("No result in gas estimate response");
-      }
-      return response.result;
-    } catch (error) {
-      console.warn(
-        "[AbcEvmProvider] Gas estimation failed, using fallback:",
-        error
-      );
-      if (tx.data && tx.data !== "0x") {
-        return "0x493e0";
-      }
-      return "0x5208";
-    }
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.connected;
-  }
-  /**
-   * Get current wallet
-   */
-  getWallet() {
-    return this.wallet;
-  }
-  /**
-   * Get current chain ID
-   */
-  getChainId() {
-    return this.chainId;
-  }
-};
-function createAbcEvmProvider(talkenApi) {
-  return new AbcEvmProvider(talkenApi);
-}
-var createAbcProvider = createAbcEvmProvider;
-
-// src/wallets/walletConnectors/abcWallet/api/TalkenApiClient.ts
-var STORAGE_KEY_PREFIX = "talken_api_";
-function loadToken(key) {
-  if (typeof window === "undefined")
-    return null;
-  try {
-    return localStorage.getItem(`${STORAGE_KEY_PREFIX}${key}`);
-  } catch {
-    return null;
-  }
-}
-function saveToken(key, value) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    localStorage.setItem(`${STORAGE_KEY_PREFIX}${key}`, value);
-  } catch {
-  }
-}
-function removeToken(key) {
-  if (typeof window === "undefined")
-    return;
-  try {
-    localStorage.removeItem(`${STORAGE_KEY_PREFIX}${key}`);
-  } catch {
-  }
-}
-function normalizeAuthResponse(raw) {
-  const d = raw.data || raw;
-  const loginData = d.login || d;
-  return {
-    accessToken: loginData.access_token || loginData.accessToken || "",
-    refreshToken: loginData.refresh_token || loginData.refreshToken || "",
-    expiresIn: loginData.expires_in || loginData.expire_in || loginData.expiresIn || 3600,
-    uid: d.uid || loginData.uid || "",
-    email: d.email || loginData.email || "",
-    isNewUser: d.isNewUser
-  };
-}
-var TalkenAuthModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Login with email and password
-   * POST /wallet/auth { action: 'login', method: 'password', email, password }
-   */
-  async loginWithPassword(email, password) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "login", method: "password", email, password },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Send OTP code to email
-   * POST /wallet/auth { action: 'otp.send', email }
-   */
-  async sendOtp(email) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "otp.send", email },
-      { skipAuth: true }
-    );
-    return raw.data || raw;
-  }
-  /**
-   * Verify OTP code
-   * POST /wallet/auth { action: 'otp.verify', email, otpCode }
-   */
-  async verifyOtp(email, otpCode) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "otp.verify", email, otpCode },
-      { skipAuth: true }
-    );
-    return raw.data || raw;
-  }
-  /**
-   * Check if email is already registered
-   * POST /wallet/auth { action: 'email.check', email }
-   * Returns code 606 if email exists
-   */
-  async checkEmail(email) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "email.check", email },
-      { skipAuth: true }
-    );
-    const d = raw.data || raw;
-    return {
-      code: d.code,
-      message: d.message,
-      exists: d.code === 606
-    };
-  }
-  /**
-   * Register a new user (creates account + auto-login)
-   * POST /wallet/auth { action: 'register', email, otpCode, password, name? }
-   */
-  async register(params) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "register", ...params },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Reset password for existing user
-   * POST /wallet/auth { action: 'password.reset', email, newPassword, emailCode }
-   */
-  async resetPassword(email, newPassword, emailCode) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "password.reset", email, newPassword, emailCode },
-      { skipAuth: true }
-    );
-    return raw.data || raw;
-  }
-  /**
-   * Login with social provider (Google, Apple, Kakao, etc.)
-   * POST /wallet/auth { action: 'login', method: 'sns', token, service, audience? }
-   */
-  async loginWithSns(params) {
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      {
-        action: "login",
-        method: "sns",
-        token: params.token,
-        service: params.service,
-        ...params.audience && { audience: params.audience }
-      },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Refresh access token
-   * POST /wallet/auth { action: 'token.refresh', refreshToken }
-   */
-  async refresh() {
-    const refreshToken = this.client.getRefreshToken();
-    if (!refreshToken) {
-      throw new TalkenApiError(
-        "TOKEN_EXPIRED",
-        "No refresh token available",
-        401
-      );
-    }
-    const raw = await this.client.post(
-      TALKEN_API_ENDPOINTS.AUTH,
-      { action: "token.refresh", refreshToken },
-      { skipAuth: true }
-    );
-    const res = normalizeAuthResponse(raw);
-    this.client.handleAuthResponse(res);
-    return res;
-  }
-  /**
-   * Logout (clear local session only — no server endpoint)
-   */
-  logout() {
-    this.client.clearSession();
-  }
-};
-var TalkenWalletModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Generate/recover MPC wallets (create = idempotent generate/recover)
-   * POST /wallet/mpc { action: 'create', email?, pin }
-   *
-   * @param pin - SHA-256 hashed PIN
-   * @param email - User email (optional; server resolves from bearer token if omitted)
-   */
-  async generate(pin, email) {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_MPC, {
-      action: "create",
-      ...email && { email },
-      pin
-    });
-  }
-  /**
-   * Recover is the same as generate (create is idempotent)
-   */
-  async recover(pin, email) {
-    return this.generate(pin, email);
-  }
-  /**
-   * Get wallet info
-   * POST /wallet/mpc { action: 'info' }
-   */
-  async getInfo() {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_MPC, {
-      action: "info"
-    });
-  }
-  /**
-   * Get addresses for all chains
-   * POST /wallet/address { chain: 'all' }
-   */
-  async getAddresses() {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_ADDRESS, {
-      chain: "all"
-    });
-  }
-  /**
-   * Get addresses for a specific chain
-   * POST /wallet/address { chain, publicKey?, pin? }
-   */
-  async getAddressForChain(chain, publicKey, pin) {
-    return this.client.post(TALKEN_API_ENDPOINTS.WALLET_ADDRESS, {
-      chain,
-      ...publicKey && { publicKey },
-      ...pin && { pin }
-    });
-  }
-};
-var TalkenEvmModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Sign EVM transaction (sign only, no broadcast)
-   * POST /wallet/sign/evm { network, to, from?, value?, data?, ... }
-   * Server handles SecureChannel internally
-   */
-  async signTransaction(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_EVM,
-      params
-    );
-  }
-  /**
-   * Sign EIP-712 typed data
-   * POST /wallet/sign/evm/typed { network, typedData }
-   */
-  async signTypedData(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_TYPED,
-      params
-    );
-  }
-  /**
-   * Sign personal message (EIP-191)
-   * POST /wallet/sign/evm/personal { network, message, address? }
-   */
-  async signPersonal(params) {
-    const res = await this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_PERSONAL,
-      params
-    );
-    return {
-      signature: res?.signature ?? res?.serializedTx ?? "",
-      txHash: res?.txHash ?? res?.rawTx
-    };
-  }
-  /**
-   * Sign EIP-7702 authorization payload
-   * POST /wallet/sign/authorization { network, authorization, pin? }
-   */
-  async signAuthorization(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_AUTHORIZATION,
-      params
-    );
-  }
-  /**
-   * Broadcast signed transaction
-   * POST /wallet/tx/raw { network, signedSerializeTx }
-   */
-  async sendRawTransaction(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_RAW,
-      params
-    );
-  }
-  /**
-   * Integrated EVM transfer (sign + broadcast)
-   * POST /wallet/tx/evm { chainKey, to, amountWei, pin, ... }
-   */
-  async sendTransaction(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_EVM,
-      params
-    );
-  }
-  /**
-   * Get gas price
-   * GET /wallet/gas/price?network=
-   */
-  async getGasPrice(network) {
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.GAS_PRICE}?network=${encodeURIComponent(network)}`
-    );
-  }
-  /**
-   * Get suggested gas fees (EIP-1559)
-   * GET /wallet/gas/suggested?network=
-   */
-  async getGasSuggested(network) {
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.GAS_SUGGESTED}?network=${encodeURIComponent(network)}`
-    );
-  }
-  /**
-   * Estimate gas
-   * POST /wallet/gas/estimate { network, from, to, value?, data? }
-   */
-  async estimateGas(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.GAS_ESTIMATE,
-      params
-    );
-  }
-  /**
-   * Get nonce for address
-   * GET /wallet/nonce?network=&address=
-   */
-  async getNonce(network, address) {
-    const qs = new URLSearchParams({ network, address }).toString();
-    return this.client.get(`${TALKEN_API_ENDPOINTS.NONCE}?${qs}`);
-  }
-};
-var TalkenSolanaModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Transfer SOL or SPL token (integrated sign + broadcast)
-   * POST /wallet/tx/sol
-   * - kind='native': { toAddress, amountLamports, pin }
-   * - kind='spl':    { toAddress, mintAddress, amount, decimals, network, pin }
-   */
-  async transfer(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_SOL,
-      params
-    );
-  }
-  /**
-   * Sign Solana transaction or message (sign-only, no broadcast)
-   * POST /wallet/sign/sol
-   *
-   * Two modes:
-   * - PIN mode: { message, pin } — server resolves signing material
-   * - Share mode: { message, keyId, encryptedShare } — no PIN required (for signMessage)
-   *
-   * @returns Ed25519 signature (hex) and optionally public key
-   */
-  async sign(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_SVM,
-      params
-    );
-  }
-};
-var TalkenBitcoinModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * BTC fee rate lookup
-   * GET /wallet/btc?mode=fee&network=&blocks=
-   */
-  async getFeeRate(network, blocks) {
-    const qs = new URLSearchParams({
-      mode: "fee",
-      network,
-      ...typeof blocks === "number" ? { blocks: String(blocks) } : {}
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * BTC tx status by hash
-   * GET /wallet/btc?mode=txHash&network=&txHash=
-   */
-  async getTxByHash(txHash, network) {
-    const qs = new URLSearchParams({
-      mode: "txHash",
-      network,
-      txHash
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * BTC UTXO list
-   * GET /wallet/btc?mode=utxos&network=&address=
-   */
-  async getUtxos(network, address) {
-    const qs = new URLSearchParams({
-      mode: "utxos",
-      network,
-      ...address ? { address } : {}
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * BTC address validation
-   * GET /wallet/btc?mode=validateAddress&network=&address=
-   */
-  async validateAddress(address, network) {
-    const qs = new URLSearchParams({
-      mode: "validateAddress",
-      network,
-      address
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_BTC}?${qs}`
-    );
-  }
-  /**
-   * Send BTC (integrated sign + broadcast, action=transfer)
-   * POST /wallet/tx/btc
-   */
-  async sendTransaction(params) {
-    const payload = { action: "transfer", ...params };
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_BTC,
-      payload
-    );
-  }
-  /**
-   * Execute BTC action endpoint (transfer|generate|signHash|finalize)
-   * POST /wallet/tx/btc
-   */
-  async execute(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_BTC,
-      params
-    );
-  }
-  /**
-   * Sign raw hash via secp256k1 MPC (universal: EVM/BTC/TVM)
-   * POST /wallet/sign/hash { hash, pin, network? }
-   */
-  async signHash(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.SIGN_HASH,
-      params
-    );
-  }
-  /**
-   * Broadcast raw BTC transaction
-   * POST /wallet/tx/raw { network, signedSerializeTx }
-   */
-  async broadcastRawTransaction(params) {
-    return this.client.post(TALKEN_API_ENDPOINTS.TX_RAW, {
-      network: params.network,
-      signedSerializeTx: params.rawTransaction
-    });
-  }
-};
-var TalkenTronModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Execute TVM(TRON) transfer/call (integrated sign + broadcast)
-   * POST /wallet/tx/tvm
-   * - kind=native: TRX transfer (amountSun)
-   * - kind=trc20: TRC-20 transfer (contractAddress + amount)
-   * - kind=contract: arbitrary contract call (contractAddress + data)
-   */
-  async transferTrx(params) {
-    return this.client.post(
-      TALKEN_API_ENDPOINTS.TX_TVM,
-      params
-    );
-  }
-};
-var TalkenWalletscanModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Get token metadata by contract address
-   * GET /wallet/scan?type=tokens&chainKeys=...&contractAddress=...
-   */
-  async getToken(params) {
-    const qs = new URLSearchParams({
-      type: "tokens",
-      chainKeys: params.chainKeys,
-      contractAddress: params.contractAddress
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_SCAN}?${qs}`
-    );
-  }
-  /**
-   * Get native coin balances
-   * GET /wallet/scan?type=natives&chainKeys=...&walletAddress=...
-   */
-  async getNativeTokens(params) {
-    const qs = new URLSearchParams({
-      type: "natives",
-      chainKeys: params.chainKeys,
-      walletAddress: params.walletAddress
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_SCAN}?${qs}`
-    );
-  }
-  /**
-   * Get NFT metadata
-   * GET /wallet/scan?type=nfts&chainKeys=...&walletAddress=...
-   */
-  async getNfts(params) {
-    const qs = new URLSearchParams({
-      type: "nfts",
-      chainKeys: params.chainKeys,
-      walletAddress: params.walletAddress
-    }).toString();
-    return this.client.get(
-      `${TALKEN_API_ENDPOINTS.WALLET_SCAN}?${qs}`
-    );
-  }
-};
-var TalkenApiClient = class {
-  constructor(config) {
-    this.accessToken = null;
-    this.refreshToken_ = null;
-    this.expiresAt = null;
-    this.isRefreshing = false;
-    this.refreshPromise = null;
-    this.config = {
-      baseUrl: config?.baseUrl || DEFAULT_TALKEN_API_CONFIG.baseUrl || "",
-      timeout: config?.timeout || DEFAULT_TALKEN_API_CONFIG.timeout,
-      environment: config?.environment || "development",
-      defaultChainId: config?.defaultChainId,
-      debug: config?.debug || false
-    };
-    this.auth = new TalkenAuthModule(this);
-    this.wallet = new TalkenWalletModule(this);
-    this.evm = new TalkenEvmModule(this);
-    this.solana = new TalkenSolanaModule(this);
-    this.bitcoin = new TalkenBitcoinModule(this);
-    this.tron = new TalkenTronModule(this);
-    this.walletscan = new TalkenWalletscanModule(this);
-    this.restoreSession();
-  }
-  // ── Session Management ──────────────────────────────────────────────
-  restoreSession() {
-    this.accessToken = loadToken("access_token");
-    this.refreshToken_ = loadToken("refresh_token");
-    const expiresAtStr = loadToken("expires_at");
-    this.expiresAt = expiresAtStr ? Number(expiresAtStr) : null;
-  }
-  /** @internal Called by auth module after successful login/register */
-  handleAuthResponse(response) {
-    this.accessToken = response.accessToken;
-    this.refreshToken_ = response.refreshToken;
-    this.expiresAt = Date.now() + response.expiresIn * 1e3;
-    saveToken("access_token", response.accessToken);
-    saveToken("refresh_token", response.refreshToken);
-    saveToken("expires_at", String(this.expiresAt));
-  }
-  /** @internal Clear all session data */
-  clearSession() {
-    this.accessToken = null;
-    this.refreshToken_ = null;
-    this.expiresAt = null;
-    removeToken("access_token");
-    removeToken("refresh_token");
-    removeToken("expires_at");
-  }
-  /**
-   * Check if user is authenticated (has valid access token)
-   */
-  isAuthenticated() {
-    return !!this.accessToken && !this.isTokenExpired();
-  }
-  /**
-   * Check if current access token is expired
-   */
-  isTokenExpired() {
-    if (!this.expiresAt)
-      return true;
-    return Date.now() >= this.expiresAt - TOKEN_EXPIRY.REFRESH_BUFFER;
-  }
-  /**
-   * Get current access token
-   */
-  getAccessToken() {
-    return this.accessToken;
-  }
-  /**
-   * Get current refresh token
-   * @internal Used by auth module for token refresh
-   */
-  getRefreshToken() {
-    return this.refreshToken_;
-  }
-  /**
-   * Get client configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Set tokens externally (useful for SSR or state management integration)
-   */
-  setTokens(accessToken, refreshToken, expiresAt) {
-    this.accessToken = accessToken;
-    this.refreshToken_ = refreshToken;
-    this.expiresAt = expiresAt;
-    saveToken("access_token", accessToken);
-    saveToken("refresh_token", refreshToken);
-    saveToken("expires_at", String(expiresAt));
-  }
-  // ── HTTP Methods (Internal) ─────────────────────────────────────────
-  /** @internal Make a GET request */
-  async get(endpoint, options) {
-    return this.request(endpoint, { method: "GET", ...options });
-  }
-  /** @internal Make a POST request */
-  async post(endpoint, body, options) {
-    return this.request(endpoint, { method: "POST", body, ...options });
-  }
-  /**
-   * Core HTTP request handler with automatic token refresh
-   * @internal
-   */
-  async request(endpoint, options) {
-    const { method, body, skipAuth = false } = options;
-    if (!skipAuth && this.isTokenExpired() && this.refreshToken_) {
-      await this.ensureTokenRefreshed();
-    }
-    const url = `${this.config.baseUrl}${endpoint}`;
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    };
-    if (!skipAuth && this.accessToken) {
-      headers.Authorization = `Bearer ${this.accessToken}`;
-    }
-    if (this.config.debug) {
-      console.log(`[TalkenApiClient] ${method} ${url}`);
-    }
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(
-        () => controller.abort(),
-        this.config.timeout || 3e4
-      );
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal,
-        credentials: "include"
-      });
-      clearTimeout(timeoutId);
-      const text = await response.text();
-      let data;
-      if (text) {
-        try {
-          data = JSON.parse(text);
-        } catch {
-          throw new TalkenApiError(
-            "PARSE_ERROR",
-            "Invalid JSON response from server",
-            response.status,
-            { text: text.substring(0, 200) }
-          );
-        }
-      } else {
-        data = { success: true };
-      }
-      if (response.status === 401 && !skipAuth && this.refreshToken_) {
-        try {
-          await this.forceTokenRefresh();
-          return this.request(endpoint, { ...options, skipAuth: true });
-        } catch {
-          this.clearSession();
-          throw new TalkenApiError(
-            "TOKEN_EXPIRED",
-            "Session expired. Please login again.",
-            401
-          );
-        }
-      }
-      if (!response.ok) {
-        const errCode = data.error?.code || "UNKNOWN_ERROR";
-        const errMsg = data.error?.message || `Request failed with status ${response.status}`;
-        if (this.config.debug) {
-          console.error(`[TalkenApiClient] Error: ${errCode} - ${errMsg}`);
-        }
-        throw new TalkenApiError(
-          errCode,
-          errMsg,
-          response.status,
-          data.error?.details || data.details
-        );
-      }
-      return data.data ?? data;
-    } catch (error) {
-      if (error instanceof TalkenApiError) {
-        throw error;
-      }
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new TalkenApiError("TIMEOUT", "Request timed out", 408);
-      }
-      const errorMessage = error instanceof Error ? error.message : "Network request failed";
-      throw new TalkenApiError("NETWORK_ERROR", errorMessage, 0);
-    }
-  }
-  /**
-   * Ensure token is refreshed (handles concurrent requests)
-   */
-  async ensureTokenRefreshed() {
-    if (this.isRefreshing && this.refreshPromise) {
-      await this.refreshPromise;
-      return;
-    }
-    await this.forceTokenRefresh();
-  }
-  /**
-   * Force a token refresh
-   */
-  async forceTokenRefresh() {
-    if (this.isRefreshing && this.refreshPromise) {
-      await this.refreshPromise;
-      return;
-    }
-    this.isRefreshing = true;
-    this.refreshPromise = (async () => {
-      try {
-        await this.auth.refresh();
-      } finally {
-        this.isRefreshing = false;
-        this.refreshPromise = null;
-      }
-    })();
-    await this.refreshPromise;
-  }
-};
-function createTalkenApiClient(config) {
-  return new TalkenApiClient(config);
-}
-
-// src/wallets/walletConnectors/abcWallet/api/TalkenApiSingleton.ts
-var _instance;
-function setTalkenApiClient(client) {
-  _instance = client;
-}
-function getTalkenApiClient2() {
-  return _instance;
-}
-
-// src/wallets/walletConnectors/abcWallet/networkConfig.ts
-var SolanaNetwork = /* @__PURE__ */ ((SolanaNetwork2) => {
-  SolanaNetwork2["Mainnet"] = "solana";
-  SolanaNetwork2["Devnet"] = "solana_devnet";
-  SolanaNetwork2["Testnet"] = "solana_testnet";
-  return SolanaNetwork2;
-})(SolanaNetwork || {});
-var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
-  BitcoinNetwork2["Mainnet"] = "bitcoin";
-  BitcoinNetwork2["Testnet"] = "bitcoin_testnet";
-  return BitcoinNetwork2;
-})(BitcoinNetwork || {});
-var TronNetwork = /* @__PURE__ */ ((TronNetwork2) => {
-  TronNetwork2["Mainnet"] = "tron";
-  TronNetwork2["Nile"] = "tron_nile";
-  return TronNetwork2;
-})(TronNetwork || {});
-var DEFAULT_NETWORK_CONFIG = {
-  evm: {
-    mainnet: 1,
-    // Ethereum Mainnet
-    testnet: 11155111
-    // Sepolia Testnet
-  },
-  solana: {
-    mainnet: "solana" /* Mainnet */,
-    devnet: "solana_devnet" /* Devnet */
-  },
-  bitcoin: {
-    mainnet: "bitcoin" /* Mainnet */,
-    testnet: "bitcoin_testnet" /* Testnet */
-  },
-  tron: {
-    mainnet: "tron" /* Mainnet */,
-    testnet: "tron_nile" /* Nile */
-  }
-};
-var globalDefaultChainId;
-var globalDefaultSolanaNetwork;
-var globalDefaultBitcoinNetwork;
-var globalDefaultTronNetwork;
-function setGlobalDefaultChainId(chainId) {
-  globalDefaultChainId = chainId;
-}
-function setGlobalDefaultSolanaNetwork(network) {
-  globalDefaultSolanaNetwork = network;
-}
-function setGlobalDefaultBitcoinNetwork(network) {
-  globalDefaultBitcoinNetwork = network;
-}
-function getEvmNetwork(customChainId) {
-  if (customChainId !== void 0) {
-    return customChainId;
-  }
-  if (globalDefaultChainId !== void 0) {
-    return globalDefaultChainId;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  const fallbackChainId = isProduction ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
-  return fallbackChainId;
-}
-function getSolanaNetwork() {
-  if (globalDefaultSolanaNetwork !== void 0) {
-    return globalDefaultSolanaNetwork;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  return isProduction ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
-}
-function getBitcoinNetwork() {
-  if (globalDefaultBitcoinNetwork !== void 0) {
-    return globalDefaultBitcoinNetwork;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  return isProduction ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
-}
-function getTronNetwork() {
-  if (globalDefaultTronNetwork !== void 0) {
-    return globalDefaultTronNetwork;
-  }
-  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
-  return isProduction ? DEFAULT_NETWORK_CONFIG.tron.mainnet : DEFAULT_NETWORK_CONFIG.tron.testnet;
-}
-
-// src/wallets/walletConnectors/abcWallet/resolveTalkenApiUrl.ts
-function resolveTalkenApiUrl(explicitUrl) {
-  const talkenApiUrl = explicitUrl || process.env.NEXT_PUBLIC_TALKEN_API_URL;
-  if (!talkenApiUrl) {
-    throw new Error(
-      "Talken API URL is required. Pass talkenApiUrl explicitly or set NEXT_PUBLIC_TALKEN_API_URL."
-    );
-  }
-  return talkenApiUrl;
-}
-
-// src/wallets/walletConnectors/abcWallet/abcConnector.ts
-function abcConnector(options) {
-  const { config } = options;
-  if (config.defaultChainId) {
-    setGlobalDefaultChainId(config.defaultChainId);
-  }
-  if (config.defaultSolanaNetwork) {
-    setGlobalDefaultSolanaNetwork(config.defaultSolanaNetwork);
-  }
-  if (config.defaultBitcoinNetwork) {
-    setGlobalDefaultBitcoinNetwork(config.defaultBitcoinNetwork);
-  }
-  return createConnector((wagmiConfig) => {
-    const talkenApi = getTalkenApiClient3() || createTalkenApiClient({
-      baseUrl: resolveTalkenApiUrl(config.talkenApiUrl),
-      environment: config.environment,
-      debug: config.environment === "development",
-      defaultChainId: config.defaultChainId
-    });
-    setTalkenApiClient(talkenApi);
-    const provider = createAbcEvmProvider(talkenApi);
-    let accountsChangedHandler;
-    let chainChangedHandler;
-    let disconnectHandler;
-    return {
-      id: "abc",
-      name: "ABC Wallet",
-      type: "abc",
-      /**
-       * Connect wallet
-       */
-      async connect() {
-        try {
-          const authState = loadAuthState();
-          if (!authState || !authState.isAuthenticated || !authState.wallet) {
-            throw new Error("ABC_LOGIN_REQUIRED");
-          }
-          provider.setWallet(authState.wallet);
-          if (authState.accessToken && authState.refreshToken && authState.expiresAt) {
-            talkenApi.setTokens(
-              authState.accessToken,
-              authState.refreshToken,
-              authState.expiresAt
-            );
-          }
-          const accounts = await provider.request({
-            method: "eth_requestAccounts"
-          });
-          let currentChainId = await provider.request({
-            method: "eth_chainId"
-          });
-          const currentChainIdNumber = Number(currentChainId);
-          const isChainSupported = wagmiConfig.chains.some(
-            (c) => c.id === currentChainIdNumber
-          );
-          if (!isChainSupported && wagmiConfig.chains.length > 0) {
-            const fallbackChainId = wagmiConfig.chains[0].id;
-            await provider.request({
-              method: "wallet_switchEthereumChain",
-              params: [{ chainId: `0x${fallbackChainId.toString(16)}` }]
-            });
-            currentChainId = `0x${fallbackChainId.toString(16)}`;
-            if (authState.wallet) {
-              authState.wallet.chainId = fallbackChainId;
-              saveAuthState(authState);
-            }
-          }
-          if (accountsChangedHandler) {
-            provider.removeListener("accountsChanged", accountsChangedHandler);
-          }
-          accountsChangedHandler = (accounts2) => {
-            wagmiConfig.emitter.emit("change", {
-              accounts: accounts2
-            });
-          };
-          provider.on("accountsChanged", accountsChangedHandler);
-          if (chainChangedHandler) {
-            provider.removeListener("chainChanged", chainChangedHandler);
-          }
-          chainChangedHandler = (chainId) => {
-            wagmiConfig.emitter.emit("change", {
-              chainId: Number(chainId)
-            });
-          };
-          provider.on("chainChanged", chainChangedHandler);
-          if (disconnectHandler) {
-            provider.removeListener("disconnect", disconnectHandler);
-          }
-          disconnectHandler = () => {
-            wagmiConfig.emitter.emit("disconnect");
-            this.onDisconnect();
-          };
-          provider.on("disconnect", disconnectHandler);
-          wagmiConfig.emitter.emit("connect", {
-            accounts,
-            chainId: Number(currentChainId)
-          });
-          return {
-            accounts,
-            chainId: Number(currentChainId)
-          };
-        } catch (error) {
-          console.error("\u274C ABC Connector connect() failed:", {
-            message: error.message,
-            code: error.code,
-            error
-          });
-          if (error.message === "ABC_LOGIN_REQUIRED") {
-            throw error;
-          }
-          throw error;
-        }
-      },
-      /**
-       * Disconnect wallet
-       */
-      async disconnect() {
-        if (accountsChangedHandler) {
-          provider.removeListener("accountsChanged", accountsChangedHandler);
-          accountsChangedHandler = void 0;
-        }
-        if (chainChangedHandler) {
-          provider.removeListener("chainChanged", chainChangedHandler);
-          chainChangedHandler = void 0;
-        }
-        if (disconnectHandler) {
-          provider.removeListener("disconnect", disconnectHandler);
-          disconnectHandler = void 0;
-        }
-        provider.clearWallet();
-        talkenApi.auth.logout();
-        clearAuthState();
-        getCredentialManager().clear();
-      },
-      /**
-       * Get accounts
-       */
-      async getAccounts() {
-        const accounts = await provider.request({
-          method: "eth_accounts"
-        });
-        return accounts.map((account) => account);
-      },
-      /**
-       * Get chain ID
-       */
-      async getChainId() {
-        const chainId = await provider.request({
-          method: "eth_chainId"
-        });
-        return Number(chainId);
-      },
-      /**
-       * Get provider
-       */
-      async getProvider() {
-        return provider;
-      },
-      /**
-       * Check if authorized (has valid session)
-       * Auto-refreshes access token if expired but refresh token is valid
-       */
-      async isAuthorized() {
-        try {
-          const authState = loadAuthState();
-          if (!authState || !authState.isAuthenticated) {
-            return false;
-          }
-          if (!authState.wallet) {
-            return false;
-          }
-          if (talkenApi.isAuthenticated()) {
-            return true;
-          }
-          const refreshToken = loadFromStorage(
-            "refresh_token" /* REFRESH_TOKEN */
-          );
-          if (!refreshToken) {
-            clearStorage();
-            return false;
-          }
-          try {
-            const api = getTalkenApiClient3();
-            if (!api) {
-              clearStorage();
-              return false;
-            }
-            const res = await api.auth.refresh();
-            talkenApi.setTokens(
-              res.accessToken,
-              res.refreshToken,
-              Date.now() + res.expiresIn * 1e3
-            );
-            const updatedState = loadAuthState();
-            return updatedState?.isAuthenticated ?? false;
-          } catch (error) {
-            console.error("[AbcConnector] Token refresh failed:", error);
-            clearStorage();
-            return false;
-          }
-        } catch (error) {
-          console.error(
-            "[AbcConnector] Unexpected error in isAuthorized:",
-            error
-          );
-          return false;
-        }
-      },
-      /**
-       * Switch chain
-       */
-      async switchChain({ chainId }) {
-        await provider.request({
-          method: "wallet_switchEthereumChain",
-          params: [{ chainId: `0x${chainId.toString(16)}` }]
-        });
-        const newChainId = await this.getChainId();
-        const authState = loadAuthState();
-        if (authState?.wallet) {
-          authState.wallet.chainId = newChainId;
-          saveAuthState(authState);
-        }
-        return wagmiConfig.chains.find((x) => x.id === chainId) ?? {
-          id: chainId,
-          name: `Chain ${chainId}`,
-          nativeCurrency: {
-            name: "Ether",
-            decimals: 18,
-            symbol: "ETH"
-          },
-          rpcUrls: {
-            default: { http: [""] }
-          }
-        };
-      },
-      /**
-       * Handle accounts changed
-       */
-      onAccountsChanged(accounts) {
-        if (accounts.length === 0) {
-          this.onDisconnect();
-        } else {
-          wagmiConfig.emitter.emit("change", {
-            accounts
-          });
-        }
-      },
-      /**
-       * Handle chain changed
-       */
-      onChainChanged(chain) {
-        const chainId = Number(chain);
-        wagmiConfig.emitter.emit("change", { chainId });
-      },
-      /**
-       * Handle disconnect
-       */
-      onDisconnect(_error) {
-        provider.clearWallet();
-        clearAuthState();
-        wagmiConfig.emitter.emit("disconnect");
-      }
-    };
-  });
-}
-
-// src/wallets/walletConnectors/abcWallet/abcWallet.ts
-var abcWallet = (specificOptions) => ({ projectId }) => {
-  const talkenApiUrl = resolveTalkenApiUrl(specificOptions?.talkenApiUrl);
-  const talkenApi = createTalkenApiClient({
-    baseUrl: talkenApiUrl,
-    debug: specificOptions?.environment === "development"
-  });
-  setTalkenApiClient2(talkenApi);
-  const config = {
-    talkenApiUrl,
-    apiKey: specificOptions?.apiKey,
-    plain: specificOptions?.plain || "",
-    // Deprecated - not used (secure.ts uses random generation)
-    environment: specificOptions?.environment || "development",
-    defaultChainId: specificOptions?.defaultChainId,
-    defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
-    defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
-    projectId
-  };
-  return {
-    id: ABC_WALLET_METADATA.id,
-    name: ABC_WALLET_METADATA.name,
-    rdns: ABC_WALLET_METADATA.rdns,
-    iconUrl: async () => (await import("./abcWallet-AYWSIGAG.js")).default,
-    iconBackground: ABC_WALLET_METADATA.iconBackground,
-    // Embedded wallet - no installation required
-    installed: void 0,
-    // No download URLs for embedded wallet
-    downloadUrls: void 0,
-    // Create connector - wrapper function required by Wallet type
-    createConnector: (_walletDetails) => abcConnector({ config }),
-    // Embedded wallet always available
-    hidden: () => false
-  };
-};
-
-// src/wallets/walletConnectors/abcWallet/api/WalletscanApi.ts
-import { getTalkenApiClient as getTalkenApiClient4, networkNameToChainKey as networkNameToChainKey2 } from "@talken/talkenkit";
-var WalletscanApi = class {
-  /**
-   * Get token metadata via TalkenApiClient walletscan endpoint
-   *
-   * @param params - Contract address and networks
-   * @returns Token metadata or null if not found/failed
-   */
-  async getContractToken(params) {
-    const api = getTalkenApiClient4();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    try {
-      const tokens = await api.walletscan.getToken({
-        contractAddress: params.contractAddress,
-        chainKeys: networkNameToChainKey2(params.networks)
-      });
-      return tokens.length > 0 ? tokens[0] : null;
-    } catch (error) {
-      console.warn(
-        "[WalletscanApi] TalkenApi getToken failed:",
-        params.contractAddress,
-        error
-      );
-      return null;
-    }
-  }
-  /**
-   * Get token metadata with timeout
-   *
-   * @param params - Contract address and networks
-   * @param timeoutMs - Timeout in milliseconds (default: 3000)
-   * @returns Token metadata or null if timeout/failed
-   */
-  async getContractTokenWithTimeout(params, timeoutMs = 3e3) {
-    try {
-      const result = await Promise.race([
-        this.getContractToken(params),
-        new Promise(
-          (resolve) => setTimeout(() => resolve(null), timeoutMs)
-        )
-      ]);
-      return result;
-    } catch (_error) {
-      console.warn(
-        "[WalletscanApi] Token metadata request timed out:",
-        params.contractAddress
-      );
-      return null;
-    }
-  }
-  /**
-   * Get native coin info via TalkenApiClient walletscan endpoint
-   *
-   * @param params - Wallet address and networks
-   * @returns Array of native coins or empty array if failed
-   */
-  async getNativeToken(params) {
-    const api = getTalkenApiClient4();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    try {
-      return await api.walletscan.getNativeTokens({
-        walletAddress: params.walletAddress,
-        chainKeys: networkNameToChainKey2(params.networks)
-      });
-    } catch (error) {
-      console.warn("[WalletscanApi] TalkenApi getNativeTokens failed:", error);
-      return [];
-    }
-  }
-  /**
-   * Get native coin info with timeout
-   *
-   * @param params - Wallet address and networks
-   * @param timeoutMs - Timeout in milliseconds (default: 3000)
-   * @returns First native coin or null if timeout/failed
-   */
-  async getNativeTokenWithTimeout(params, timeoutMs = 3e3) {
-    try {
-      const natives = await Promise.race([
-        this.getNativeToken(params),
-        new Promise(
-          (resolve) => setTimeout(() => resolve([]), timeoutMs)
-        )
-      ]);
-      return natives.length > 0 ? natives[0] : null;
-    } catch (_error) {
-      console.warn("[WalletscanApi] Native coin request timed out");
-      return null;
-    }
-  }
-  /**
-   * Get NFT metadata via TalkenApiClient walletscan endpoint
-   *
-   * @param params - Contract address, wallet address, and networks
-   * @returns Array of NFT metadata or empty array if failed
-   */
-  async getNFT(params) {
-    const api = getTalkenApiClient4();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    try {
-      return await api.walletscan.getNfts({
-        chainKeys: networkNameToChainKey2(params.networks),
-        walletAddress: params.walletAddress
-      });
-    } catch (error) {
-      console.warn(
-        "[WalletscanApi] TalkenApi getNfts failed:",
-        params.contractAddress,
-        error
-      );
-      return [];
-    }
-  }
-  /**
-   * Get NFT metadata with timeout
-   *
-   * @param params - Contract address, wallet address, and networks
-   * @param timeoutMs - Timeout in milliseconds (default: 3000)
-   * @returns First NFT or null if timeout/failed/empty
-   */
-  async getNFTWithTimeout(params, timeoutMs = 3e3) {
-    try {
-      const nfts = await Promise.race([
-        this.getNFT(params),
-        new Promise(
-          (resolve) => setTimeout(() => resolve([]), timeoutMs)
-        )
-      ]);
-      return nfts.length > 0 ? nfts[0] : null;
-    } catch (_error) {
-      console.warn(
-        "[WalletscanApi] NFT metadata request timed out:",
-        params.contractAddress
-      );
-      return null;
-    }
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/api/GasApi.ts
-import { getTalkenApiClient as getTalkenApiClient5 } from "@talken/talkenkit";
-var GasApi = class {
-  parseGasFees(data) {
-    return {
-      ...data,
-      networkCongestion: data.networkCongestion != null ? Number(data.networkCongestion) : void 0
-    };
-  }
-  /**
-   * Get suggested gas fees for EIP-1559 transactions via TalkenApiClient
-   *
-   * @param network - Network name (ethereum, polygon, klaytn, etc.)
-   * @returns Suggested gas fees or null if failed
-   */
-  async getSuggestedGasFees(network) {
-    const api = getTalkenApiClient5();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    try {
-      const gasFees = await api.evm.getGasSuggested(network);
-      return this.parseGasFees(gasFees);
-    } catch (error) {
-      console.warn(
-        "[GasApi] TalkenApi getGasSuggested failed:",
-        network,
-        error
-      );
-      return null;
-    }
-  }
-  /**
-   * Estimate gas limit for EIP-1559 transaction via TalkenApiClient
-   *
-   * @param params - Transaction parameters
-   * @returns Gas limit (hex string) or null if failed
-   */
-  async estimateGas(params) {
-    const api = getTalkenApiClient5();
-    if (!api)
-      throw new Error("TalkenApiClient not initialized");
-    try {
-      const response = await api.evm.estimateGas({
-        network: params.network,
-        from: params.from || "",
-        to: params.to,
-        value: params.value || "0x0",
-        data: params.data || "0x"
-      });
-      return response.result ?? null;
-    } catch (error) {
-      console.warn("[GasApi] TalkenApi estimateGas failed:", error);
-      return null;
-    }
-  }
-  /**
-   * Get suggested gas fees with timeout
-   *
-   * @param network - Network name
-   * @param timeoutMs - Timeout in milliseconds (default: 5000)
-   * @returns Suggested gas fees or null if timeout/failed
-   */
-  async getSuggestedGasFeesWithTimeout(network, timeoutMs = 5e3) {
-    try {
-      const result = await Promise.race([
-        this.getSuggestedGasFees(network),
-        new Promise(
-          (resolve) => setTimeout(() => resolve(null), timeoutMs)
-        )
-      ]);
-      return result;
-    } catch (_error) {
-      console.warn("[GasApi] Gas fees request timed out:", network);
-      return null;
-    }
-  }
-  /**
-   * Estimate gas with timeout
-   *
-   * @param params - Transaction parameters
-   * @param timeoutMs - Timeout in milliseconds (default: 5000)
-   * @returns Gas limit (hex string) or null if timeout/failed
-   */
-  async estimateGasWithTimeout(params, timeoutMs = 5e3) {
-    try {
-      const result = await Promise.race([
-        this.estimateGas(params),
-        new Promise(
-          (resolve) => setTimeout(() => resolve(null), timeoutMs)
-        )
-      ]);
-      return result;
-    } catch (_error) {
-      console.warn("[GasApi] Gas estimate request timed out");
-      return null;
-    }
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/sessionUtils.ts
-import { getTalkenApiClient as getTalkenApiClient6 } from "@talken/talkenkit";
-var SessionExpiredError = class extends Error {
-  constructor(message = "Session expired. Please reconnect your wallet.") {
-    super(message);
-    this.name = "SessionExpiredError";
-  }
-};
-function dispatchSessionExpired() {
-  if (typeof window !== "undefined") {
-    console.warn("[SessionUtils] \u{1F6A8} dispatchSessionExpired called from:");
-    console.trace();
-    window.dispatchEvent(new CustomEvent("talkenkit:session_expired"));
-  }
-}
-function handleUnauthorizedResponse(response) {
-  if (response.status === 401) {
-    dispatchSessionExpired();
-    throw new SessionExpiredError(
-      "Session expired. Please reconnect your wallet."
-    );
-  }
-}
-async function fetchWithSessionCheck(url, options) {
-  const response = await fetch(url, options);
-  if (!response.ok && response.status === 401) {
-    const errorText = await response.text();
-    console.error("[ABC WaaS] \u274C Unauthorized (401):", errorText);
-    dispatchSessionExpired();
-    throw new SessionExpiredError(
-      "Session expired. Please reconnect your wallet."
-    );
-  }
-  return response;
-}
-async function refreshAccessToken(pinCallback) {
-  if (pinCallback) {
-    await pinCallback();
-  }
-  const refreshToken = localStorage.getItem(`${STORAGE_PREFIX}refresh_token`);
-  if (!refreshToken) {
-    console.warn("[SessionUtils] No refresh token - opening connect modal");
-    dispatchSessionExpired();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    throw new SessionExpiredError(
-      "Session expired. Please reconnect your wallet."
-    );
-  }
-  try {
-    const api = getTalkenApiClient6();
-    if (!api) {
-      throw new Error("TalkenApiClient not initialized");
-    }
-    api.setTokens(
-      localStorage.getItem(`${STORAGE_PREFIX}access_token`) || "",
-      refreshToken,
-      Number(localStorage.getItem(`${STORAGE_PREFIX}expires_at`) || "0")
-    );
-    const res = await api.auth.refresh();
-    const expiresAt = Date.now() + res.expiresIn * 1e3;
-    localStorage.setItem(`${STORAGE_PREFIX}access_token`, res.accessToken);
-    if (res.refreshToken) {
-      localStorage.setItem(`${STORAGE_PREFIX}refresh_token`, res.refreshToken);
-    }
-    localStorage.setItem(`${STORAGE_PREFIX}expires_at`, String(expiresAt));
-    console.log(
-      "[SessionUtils] \u2705 Token refreshed - expires in:",
-      (res.expiresIn / 60 / 60).toFixed(2),
-      "hours"
-    );
-    return res.accessToken;
-  } catch (error) {
-    console.error("[SessionUtils] Token refresh failed:", error);
-    dispatchSessionExpired();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    throw new SessionExpiredError(
-      "Session expired. Please reconnect your wallet."
-    );
-  }
-}
-
-// src/wallets/walletConnectors/abcWallet/abcBitcoinProvider.ts
-import { getTalkenApiClient as getTalkenApiClient7 } from "@talken/talkenkit";
-function isTalkenApiClient(client) {
-  return typeof client?.bitcoin?.getUtxos === "function";
-}
-var EventEmitter2 = class {
-  constructor() {
-    this.events = /* @__PURE__ */ new Map();
-  }
-  on(event, listener) {
-    if (!this.events.has(event)) {
-      this.events.set(event, []);
-    }
-    this.events.get(event).push(listener);
-    return this;
-  }
-  off(event, listener) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
-      }
-    }
-    return this;
-  }
-  removeListener(event, listener) {
-    return this.off(event, listener);
-  }
-  emit(event, ...args) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        listener(...args);
-      }
-      return true;
-    }
-    return false;
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this.events.delete(event);
-    } else {
-      this.events.clear();
-    }
-    return this;
-  }
-};
-var BitcoinErrorCode = {
-  USER_REJECTED: 4001,
-  UNAUTHORIZED: 4100,
-  UNSUPPORTED_METHOD: 4200,
-  DISCONNECTED: 4900,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603,
-  INSUFFICIENT_FUNDS: 5001,
-  UTXO_NOT_FOUND: 5002
-};
-var BitcoinProviderError = class extends Error {
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "BitcoinProviderError";
-  }
-};
-var BITCOIN_NETWORKS = {
-  mainnet: {
-    name: "Bitcoin Mainnet",
-    type: "bitcoin",
-    explorer: "https://blockstream.info"
-  },
-  testnet: {
-    name: "Bitcoin Testnet",
-    type: "bitcoin_testnet",
-    explorer: "https://blockstream.info/testnet"
-  }
-};
-var AbcBitcoinProvider = class extends EventEmitter2 {
-  constructor(client) {
-    super();
-    this.wallet = null;
-    this.network = BITCOIN_NETWORKS.testnet;
-    this.connected = false;
-    this.utxoCache = /* @__PURE__ */ new Map();
-    this.cacheExpiry = /* @__PURE__ */ new Map();
-    this.CACHE_TTL = 6e4;
-    if (isTalkenApiClient(client)) {
-      this.talkenApi = client;
-    }
-  }
-  extractHashSignature(result) {
-    const data = result;
-    return data?.signatureHex || data?.signstr || data?.result?.signstr || data?.data?.signatureHex || data?.data?.signstr || data?.data?.result?.signstr || "";
-  }
-  getRecoveryEmail() {
-    return getCredentialManager().getEmail() || void 0;
-  }
-  /**
-   * Set request interceptor for sign/transfer confirmation modals
-   */
-  setRequestInterceptor(interceptor) {
-    this.requestInterceptor = interceptor;
-  }
-  /**
-   * Call request interceptor if set (throws on user cancel)
-   */
-  async callInterceptor(request) {
-    if (this.requestInterceptor) {
-      await this.requestInterceptor(request);
-    }
-  }
-  /**
-   * Set wallet information
-   */
-  setWallet(wallet) {
-    const previousAddress = this.wallet?.address;
-    this.wallet = wallet;
-    this.connected = true;
-    if (wallet.network === "bitcoin") {
-      this.network = BITCOIN_NETWORKS.mainnet;
-    } else {
-      this.network = BITCOIN_NETWORKS.testnet;
-    }
-    if (previousAddress !== wallet.address) {
-      this.emit("accountsChanged", [wallet.address]);
-      this.clearUtxoCache();
-    }
-    this.emit("connect", {
-      address: wallet.address,
-      network: this.network.type
-    });
-    console.log(
-      "[BitcoinProvider] \u2705 Wallet connected:",
-      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 6)}`
-    );
-  }
-  /**
-   * Clear wallet (disconnect)
-   */
-  clearWallet() {
-    this.wallet = null;
-    this.connected = false;
-    this.clearUtxoCache();
-    this.emit("disconnect");
-    this.emit("accountsChanged", []);
-    console.log("[BitcoinProvider] \u{1F50C} Wallet disconnected");
-  }
-  /**
-   * Set TalkenApiClient for backend-proxied transaction flow
-   * When set, sendTransaction will use a single API call instead of multi-step WaaS
-   */
-  setTalkenApi(talkenApi) {
-    this.talkenApi = talkenApi;
-  }
-  /**
-   * Set network
-   */
-  setNetwork(networkKey) {
-    const newNetwork = BITCOIN_NETWORKS[networkKey];
-    if (!newNetwork) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.INVALID_PARAMS,
-        `Unknown network: ${networkKey}`
-      );
-    }
-    const previousType = this.network.type;
-    this.network = newNetwork;
-    if (previousType !== newNetwork.type) {
-      this.emit("networkChanged", newNetwork.type);
-      this.clearUtxoCache();
-    }
-  }
-  /**
-   * Get current network
-   */
-  getNetwork() {
-    return this.network;
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.connected && this.wallet !== null;
-  }
-  /**
-   * Get Bitcoin address
-   */
-  async getAddress() {
-    if (!this.wallet) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    return this.wallet.address;
-  }
-  /**
-   * Get compressed public key (33 bytes)
-   */
-  async getPublicKey() {
-    if (!this.wallet) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    return this.wallet.publicKey;
-  }
-  /**
-   * Get address type (bech32, p2pkh, etc.)
-   */
-  getAddressType() {
-    if (!this.wallet) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    return this.wallet.addressType;
-  }
-  /**
-   * Clear UTXO cache
-   */
-  clearUtxoCache() {
-    this.utxoCache.clear();
-    this.cacheExpiry.clear();
-  }
-  /**
-   * Check if cache is valid
-   */
-  isCacheValid(address) {
-    const expiry = this.cacheExpiry.get(address);
-    if (!expiry)
-      return false;
-    return Date.now() < expiry;
-  }
-  normalizeUtxos(rawUtxos) {
-    return rawUtxos.map((u) => ({
-      txid: String(u?.txid ?? u?.tx_hash ?? ""),
-      vout: Number(u?.vout ?? u?.output_index ?? 0),
-      value: Number(u?.value ?? u?.satoshis ?? 0),
-      scriptPubKey: String(
-        u?.scriptPubKey ?? u?.script_pub_key ?? u?.script ?? ""
-      ),
-      confirmations: Number(u?.confirmations ?? 0)
-    })).filter(
-      (u) => Boolean(u.txid) && Number.isFinite(u.vout) && Number.isFinite(u.value) && Number.isFinite(u.confirmations)
-    );
-  }
-  /**
-   * Get UTXOs for address (with caching)
-   */
-  async getUtxos(forceRefresh = false) {
-    if (!this.wallet) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    const address = this.wallet.address;
-    if (!forceRefresh && this.isCacheValid(address)) {
-      const cached = this.utxoCache.get(address);
-      if (cached) {
-        console.log(
-          `[BitcoinProvider] \u{1F4E6} Using cached UTXOs (${cached.length} items)`
-        );
-        return cached;
-      }
-    }
-    try {
-      console.log("[BitcoinProvider] \u{1F50D} Fetching UTXOs from network...");
-      const api = this.talkenApi || getTalkenApiClient7();
-      const result = await api.bitcoin.getUtxos(this.network.type, address);
-      const utxos = this.normalizeUtxos(result.utxos || []);
-      this.utxoCache.set(address, utxos);
-      this.cacheExpiry.set(address, Date.now() + this.CACHE_TTL);
-      console.log(`[BitcoinProvider] \u2705 Fetched ${utxos.length} UTXOs`);
-      return utxos;
-    } catch (error) {
-      console.error(
-        "[BitcoinProvider] \u274C Failed to fetch UTXOs:",
-        error.message
-      );
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.INTERNAL_ERROR,
-        "Failed to fetch UTXOs",
-        error
-      );
-    }
-  }
-  /**
-   * Get total balance (sum of all UTXOs)
-   * Returns balance in satoshis
-   */
-  async getBalance(forceRefresh = false) {
-    const utxos = await this.getUtxos(forceRefresh);
-    const balance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
-    console.log(
-      `[BitcoinProvider] \u{1F4B0} Balance: ${balance} satoshis (${balance / 1e8} BTC)`
-    );
-    return balance;
-  }
-  /**
-   * Estimate transaction fee
-   * Returns fee rate in satoshis per byte
-   */
-  async estimateFee(targetBlocks = 6) {
-    try {
-      const api = this.talkenApi || getTalkenApiClient7();
-      const result = await api.bitcoin.getFeeRate(
-        this.network.type,
-        targetBlocks
-      );
-      const feeRate = Number(result.feeRate);
-      if (!Number.isFinite(feeRate) || feeRate <= 0) {
-        throw new Error("Invalid fee rate");
-      }
-      console.log(`[BitcoinProvider] \u26FD Fee rate: ${feeRate} sat/byte`);
-      return feeRate;
-    } catch (_error) {
-      console.error("[BitcoinProvider] \u26A0\uFE0F Fee estimation failed, using default");
-      return 1;
-    }
-  }
-  /**
-   * Sign Bitcoin message (Bitcoin Signed Message format)
-   * Uses secp256k1 sign/hash endpoint with double-SHA256 of prefixed message.
-   *
-   * Format: SHA256(SHA256("\x18Bitcoin Signed Message:\n" + varint(len) + message))
-   *
-   * @param message - Message to sign (string)
-   * @returns Signature in hex format (compact: r + s + v)
-   */
-  async signMessage(message) {
-    if (!this.wallet) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    await this.callInterceptor({
-      chain: "bitcoin",
-      method: "signMessage",
-      address: this.wallet.address,
-      network: this.network.type,
-      message
-    });
-    console.log("[BitcoinProvider] \u{1F4DD} Signing Bitcoin message...");
-    const prefix = "Bitcoin Signed Message:\n";
-    const msgBytes = new TextEncoder().encode(message);
-    const varint = this.encodeVarint(msgBytes.length);
-    const prefixBytes = new TextEncoder().encode(prefix);
-    const preimage = new Uint8Array(
-      prefixBytes.length + varint.length + msgBytes.length
-    );
-    preimage.set(prefixBytes, 0);
-    preimage.set(varint, prefixBytes.length);
-    preimage.set(msgBytes, prefixBytes.length + varint.length);
-    const hash1 = await crypto.subtle.digest("SHA-256", preimage);
-    const hash2 = await crypto.subtle.digest("SHA-256", hash1);
-    const hashHex = Array.from(new Uint8Array(hash2)).map((b) => b.toString(16).padStart(2, "0")).join("");
-    const api = getTalkenApiClient7();
-    if (!api) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.INTERNAL_ERROR,
-        "TalkenApiClient not initialized"
-      );
-    }
-    const pinHash = getCredentialManager().getPinHash() || "";
-    const email = this.getRecoveryEmail();
-    let signstr = "";
-    try {
-      const result = await api.bitcoin.execute({
-        action: "signHash",
-        hash: hashHex,
-        pin: pinHash,
-        network: this.network.type,
-        ...email && { email }
-      });
-      signstr = this.extractHashSignature(result);
-    } catch (error) {
-      console.warn(
-        "[BitcoinProvider] BTC signHash endpoint failed, falling back to generic sign/hash:",
-        error
-      );
-    }
-    if (!signstr) {
-      signstr = this.extractHashSignature(
-        await api.bitcoin.signHash({
-          hash: hashHex,
-          pin: pinHash,
-          network: this.network.type,
-          ...email && { email }
-        })
-      );
-    }
-    if (!signstr) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.INTERNAL_ERROR,
-        "Empty signature from sign/hash"
-      );
-    }
-    console.log("[BitcoinProvider] \u2705 Message signed successfully");
-    return signstr;
-  }
-  /** Encode integer as Bitcoin varint */
-  encodeVarint(n) {
-    if (n < 253)
-      return new Uint8Array([n]);
-    if (n <= 65535) {
-      const buf2 = new Uint8Array(3);
-      buf2[0] = 253;
-      buf2[1] = n & 255;
-      buf2[2] = n >> 8 & 255;
-      return buf2;
-    }
-    const buf = new Uint8Array(5);
-    buf[0] = 254;
-    buf[1] = n & 255;
-    buf[2] = n >> 8 & 255;
-    buf[3] = n >> 16 & 255;
-    buf[4] = n >> 24 & 255;
-    return buf;
-  }
-  /**
-   * High-level transaction sending (like Solana pattern)
-   * Creates, signs, and broadcasts transaction
-   *
-   * @param params - Transaction parameters
-   * @param params.toAddress - Recipient Bitcoin address
-   * @param params.amount - Amount in BTC (will be converted to satoshis)
-   * @returns Transaction hash
-   */
-  async sendTransaction(params) {
-    if (!this.wallet) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    try {
-      await this.callInterceptor({
-        chain: "bitcoin",
-        method: "sendTransaction",
-        fromAddress: this.wallet.address,
-        toAddress: params.toAddress,
-        amount: String(params.amount),
-        symbol: "BTC",
-        network: this.network.type,
-        isNativeToken: true,
-        feeSymbol: "BTC"
-      });
-      console.log("[BitcoinProvider] \u{1F4B8} Starting high-level transaction...");
-      const pinHash = getCredentialManager().getPinHash();
-      if (!pinHash) {
-        throw new BitcoinProviderError(
-          BitcoinErrorCode.INTERNAL_ERROR,
-          "PIN hash not found. Please login again."
-        );
-      }
-      const email = this.getRecoveryEmail();
-      const satoshis = Math.floor(params.amount * 1e8);
-      const api = this.talkenApi || getTalkenApiClient7();
-      const result = await api.bitcoin.sendTransaction({
-        toAddress: params.toAddress,
-        amountSats: satoshis.toString(),
-        pin: pinHash,
-        ...email && { email }
-      });
-      console.log(
-        "[BitcoinProvider] \u2705 BTC transaction complete via TalkenApiClient:",
-        result.txHash
-      );
-      this.emit("transactionBroadcasted", {
-        txHash: result.txHash,
-        explorerUrl: `${this.network.explorer}/tx/${result.txHash}`
-      });
-      this.clearUtxoCache();
-      return result.txHash;
-    } catch (error) {
-      if (error.message?.includes("cancelled") || error.message?.includes("rejected")) {
-        console.log("[BitcoinProvider] \u2139\uFE0F User cancelled transaction");
-        throw new BitcoinProviderError(
-          BitcoinErrorCode.USER_REJECTED,
-          "User rejected transaction",
-          error
-        );
-      }
-      console.error("[BitcoinProvider] \u274C Transaction failed:", error.message);
-      if (error.message?.includes("insufficient")) {
-        throw new BitcoinProviderError(
-          BitcoinErrorCode.INSUFFICIENT_FUNDS,
-          "Insufficient BTC balance",
-          error
-        );
-      }
-      this.emit("error", error);
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.INTERNAL_ERROR,
-        "Failed to send transaction",
-        error
-      );
-    }
-  }
-  /**
-   * Broadcast signed transaction to network
-   *
-   * @param rawTransaction - Raw transaction in hex format
-   * @param psbt - Optional finalized PSBT
-   * @returns Transaction hash
-   */
-  async broadcastTransaction(rawTransaction, psbt) {
-    if (!this.wallet) {
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    try {
-      console.log("[BitcoinProvider] \u{1F4E1} Broadcasting transaction...");
-      if (psbt) {
-        console.log(
-          "[BitcoinProvider] \u2139\uFE0F PSBT argument provided; raw tx broadcast uses rawTransaction only via talken-api"
-        );
-      }
-      const api = this.talkenApi || getTalkenApiClient7();
-      const result = await api.bitcoin.broadcastRawTransaction({
-        network: this.network.type,
-        rawTransaction
-      });
-      console.log(
-        "[BitcoinProvider] \u2705 Transaction broadcasted:",
-        result.txHash
-      );
-      this.emit("transactionBroadcasted", {
-        txHash: result.txHash,
-        explorerUrl: `${this.network.explorer}/tx/${result.txHash}`
-      });
-      this.clearUtxoCache();
-      return result.txHash;
-    } catch (error) {
-      console.error(
-        "[BitcoinProvider] \u274C Transaction broadcast failed:",
-        error.message
-      );
-      this.emit("error", error);
-      throw new BitcoinProviderError(
-        BitcoinErrorCode.INTERNAL_ERROR,
-        "Failed to broadcast transaction",
-        error
-      );
-    }
-  }
-  /**
-   * Get wallet info
-   */
-  getWalletInfo() {
-    if (!this.wallet)
-      return null;
-    return {
-      address: this.wallet.address,
-      publicKey: this.wallet.publicKey,
-      addressType: this.wallet.addressType,
-      network: this.network.type
-    };
-  }
-  /**
-   * Refresh UTXO cache
-   */
-  async refreshUtxos() {
-    return this.getUtxos(true);
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
-import { getTalkenApiClient as getTalkenApiClient8 } from "@talken/talkenkit";
-var AbcBitcoinConnector = class {
-  constructor(config) {
-    this.wallet = null;
-    this.connected = false;
-    // Event listeners
-    this.connectListeners = /* @__PURE__ */ new Set();
-    this.disconnectListeners = /* @__PURE__ */ new Set();
-    this.accountsChangedListeners = /* @__PURE__ */ new Set();
-    this.networkChangedListeners = /* @__PURE__ */ new Set();
-    this.provider = config.provider;
-    this.setupProviderListeners();
-  }
-  /**
-   * Setup provider event listeners
-   */
-  setupProviderListeners() {
-    this.provider.on("connect", () => {
-      this.connected = true;
-      if (this.wallet) {
-        for (const listener of this.connectListeners) {
-          listener(this.wallet);
-        }
-      }
-    });
-    this.provider.on("disconnect", () => {
-      this.connected = false;
-      this.wallet = null;
-      for (const listener of this.disconnectListeners) {
-        listener();
-      }
-    });
-    this.provider.on("accountsChanged", (accounts) => {
-      for (const listener of this.accountsChangedListeners) {
-        listener(accounts);
-      }
-    });
-    this.provider.on("networkChanged", (network) => {
-      for (const listener of this.networkChangedListeners) {
-        listener(network);
-      }
-    });
-  }
-  /**
-   * Connect Bitcoin wallet
-   */
-  async connect() {
-    try {
-      const authState = loadAuthState();
-      console.log("[BitcoinConnector] \u{1F527} connect() called:", {
-        hasAuthState: !!authState,
-        isAuthenticated: authState?.isAuthenticated,
-        hasBitcoinWallet: !!authState?.bitcoinWallet,
-        bitcoinAddress: authState?.bitcoinWallet?.address
-      });
-      if (!authState || !authState.isAuthenticated || !authState.bitcoinWallet) {
-        throw new Error("BITCOIN_LOGIN_REQUIRED");
-      }
-      this.wallet = authState.bitcoinWallet;
-      this.provider.setWallet(authState.bitcoinWallet);
-      console.log("[BitcoinConnector] \u2705 Wallet set:", {
-        address: authState.bitcoinWallet.address,
-        publicKey: authState.bitcoinWallet.publicKey,
-        addressType: authState.bitcoinWallet.addressType,
-        network: authState.bitcoinWallet.network
-      });
-      this.connected = true;
-      return {
-        address: authState.bitcoinWallet.address,
-        publicKey: authState.bitcoinWallet.publicKey,
-        network: authState.bitcoinWallet.network
-      };
-    } catch (error) {
-      if (error.message === "BITCOIN_LOGIN_REQUIRED") {
-        throw error;
-      }
-      console.error("[BitcoinConnector] \u274C connect error:", error);
-      throw error;
-    }
-  }
-  /**
-   * Disconnect Bitcoin wallet
-   */
-  async disconnect() {
-    try {
-      this.provider.clearWallet();
-      this.wallet = null;
-      this.connected = false;
-      console.log("[BitcoinConnector] \u2705 Wallet disconnected");
-    } catch (error) {
-      console.error("[BitcoinConnector] \u274C disconnect error:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get Bitcoin address
-   */
-  async getAddress() {
-    return this.provider.getAddress();
-  }
-  /**
-   * Get compressed public key (33 bytes)
-   */
-  async getPublicKey() {
-    return this.provider.getPublicKey();
-  }
-  /**
-   * Get address type (bech32, p2pkh, etc.)
-   */
-  getAddressType() {
-    return this.provider.getAddressType();
-  }
-  /**
-   * Get UTXOs
-   */
-  async getUtxos(forceRefresh = false) {
-    return this.provider.getUtxos(forceRefresh);
-  }
-  /**
-   * Get balance (in satoshis)
-   */
-  async getBalance(forceRefresh = false) {
-    return this.provider.getBalance(forceRefresh);
-  }
-  /**
-   * Estimate transaction fee
-   */
-  async estimateFee(targetBlocks = 6) {
-    return this.provider.estimateFee(targetBlocks);
-  }
-  /**
-   * Sign Bitcoin message (BIP-322)
-   * NOTE: Currently not supported - Bitcoin uses v2 API which doesn't have message signing endpoint
-   */
-  async signMessage(message) {
-    return this.provider.signMessage(message);
-  }
-  /**
-   * Send Bitcoin transaction (high-level API)
-   * Creates, signs, and broadcasts transaction
-   */
-  async sendTransaction(params) {
-    return this.provider.sendTransaction(params);
-  }
-  /**
-   * Broadcast signed transaction to network (low-level API)
-   */
-  async broadcastTransaction(rawTransaction, psbt) {
-    return this.provider.broadcastTransaction(rawTransaction, psbt);
-  }
-  /**
-   * Check if authorized (has valid session)
-   */
-  async isAuthorized() {
-    try {
-      const authState = loadAuthState();
-      if (!authState || !authState.isAuthenticated) {
-        return false;
-      }
-      if (!authState.bitcoinWallet) {
-        return false;
-      }
-      const api = getTalkenApiClient8();
-      return !!api && !api.isTokenExpired();
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.connected && this.provider.isConnected();
-  }
-  /**
-   * Get current wallet
-   */
-  getWallet() {
-    return this.wallet;
-  }
-  /**
-   * Get provider
-   */
-  getProvider() {
-    return this.provider;
-  }
-  /**
-   * Get wallet info
-   */
-  getWalletInfo() {
-    return this.provider.getWalletInfo();
-  }
-  /**
-   * Switch network
-   */
-  async switchNetwork(network) {
-    this.provider.setNetwork(network);
-    const authState = loadAuthState();
-    if (authState?.bitcoinWallet) {
-      authState.bitcoinWallet.network = network === "mainnet" ? "bitcoin" /* Mainnet */ : "bitcoin_testnet" /* Testnet */;
-      saveAuthState(authState);
-    }
-    console.log("[BitcoinConnector] \u{1F504} Network switched to:", network);
-  }
-  /**
-   * Get current network
-   */
-  getNetwork() {
-    return this.provider.getNetwork().type;
-  }
-  /**
-   * Refresh UTXO cache
-   */
-  async refreshUtxos() {
-    return this.provider.refreshUtxos();
-  }
-  on(event, listener) {
-    switch (event) {
-      case "connect":
-        this.connectListeners.add(listener);
-        break;
-      case "disconnect":
-        this.disconnectListeners.add(listener);
-        break;
-      case "accountsChanged":
-        this.accountsChangedListeners.add(listener);
-        break;
-      case "networkChanged":
-        this.networkChangedListeners.add(listener);
-        break;
-    }
-  }
-  off(event, listener) {
-    switch (event) {
-      case "connect":
-        this.connectListeners.delete(listener);
-        break;
-      case "disconnect":
-        this.disconnectListeners.delete(listener);
-        break;
-      case "accountsChanged":
-        this.accountsChangedListeners.delete(listener);
-        break;
-      case "networkChanged":
-        this.networkChangedListeners.delete(listener);
-        break;
-    }
-  }
-  /**
-   * Remove all listeners
-   */
-  removeAllListeners() {
-    this.connectListeners.clear();
-    this.disconnectListeners.clear();
-    this.accountsChangedListeners.clear();
-    this.networkChangedListeners.clear();
-  }
-};
-function createAbcBitcoinConnector(config) {
-  return new AbcBitcoinConnector(config);
-}
-
-// src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
-import { getTalkenApiClient as getTalkenApiClient9 } from "@talken/talkenkit";
-var EventEmitter3 = class {
-  constructor() {
-    this.events = /* @__PURE__ */ new Map();
-  }
-  on(event, listener) {
-    if (!this.events.has(event)) {
-      this.events.set(event, []);
-    }
-    this.events.get(event).push(listener);
-    return this;
-  }
-  off(event, listener) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
-      }
-    }
-    return this;
-  }
-  removeListener(event, listener) {
-    return this.off(event, listener);
-  }
-  emit(event, ...args) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        listener(...args);
-      }
-      return true;
-    }
-    return false;
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this.events.delete(event);
-    } else {
-      this.events.clear();
-    }
-    return this;
-  }
-};
-var SolanaErrorCode = {
-  USER_REJECTED: 4001,
-  UNAUTHORIZED: 4100,
-  UNSUPPORTED_METHOD: 4200,
-  DISCONNECTED: 4900,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603
-};
-var SolanaProviderError = class extends Error {
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "SolanaProviderError";
-  }
-};
-var AbcSolanaProvider = class extends EventEmitter3 {
-  constructor(talkenApi) {
-    super();
-    this.wallet = null;
-    this.connected = false;
-    this.talkenApi = talkenApi;
-  }
-  /**
-   * Set request interceptor for sign/transfer confirmation modals
-   */
-  setRequestInterceptor(interceptor) {
-    this.requestInterceptor = interceptor;
-  }
-  /**
-   * Call request interceptor if set (throws on user cancel)
-   */
-  async callInterceptor(request) {
-    if (this.requestInterceptor) {
-      await this.requestInterceptor(request);
-    }
-  }
-  /**
-   * Set wallet information
-   */
-  setWallet(wallet) {
-    const previousAddress = this.wallet?.address;
-    this.wallet = wallet;
-    this.connected = true;
-    if (previousAddress !== wallet.address) {
-      this.emit("accountsChanged", [wallet.address]);
-    }
-    this.emit("connect", {
-      address: wallet.address,
-      network: wallet.network
-    });
-  }
-  /**
-   * Clear wallet (disconnect)
-   */
-  clearWallet() {
-    this.wallet = null;
-    this.connected = false;
-    this.emit("disconnect");
-    this.emit("accountsChanged", []);
-  }
-  /**
-   * Set TalkenApiClient for backend-proxied transaction flow
-   * When set, native SOL transfers will use a single API call instead of multi-step WaaS
-   */
-  setTalkenApi(talkenApi) {
-    this.talkenApi = talkenApi;
-  }
-  getTalkenApiClientOrThrow() {
-    const api = this.talkenApi || getTalkenApiClient9();
-    if (!api) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "TalkenApiClient not initialized"
-      );
-    }
-    return api;
-  }
-  getSigningNetwork() {
-    return this.wallet?.network === "solana" ? "solana" : "solana_devnet";
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.connected && this.wallet !== null;
-  }
-  /**
-   * Get Solana address
-   */
-  async getAddress() {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    return this.wallet.address;
-  }
-  /**
-   * Get public key
-   */
-  async getPublicKey() {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    return this.wallet.publicKey;
-  }
-  /**
-   * Sign Solana message (no PIN required)
-   * Uses encrypted_share which doesn't require PIN
-   */
-  async signMessage(encodedMessage, _display) {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    try {
-      const decodedText = new TextDecoder().decode(encodedMessage);
-      await this.callInterceptor({
-        chain: "solana",
-        method: "signMessage",
-        address: this.wallet.address,
-        network: this.wallet.network,
-        message: decodedText
-      });
-      const messageHex = `0x${Array.from(encodedMessage).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
-      const result = await this.getTalkenApiClientOrThrow().solana.sign({
-        message: messageHex,
-        encryptedShare: this.wallet.encryptedShare,
-        keyId: this.wallet.keyId,
-        secretStore: this.wallet.secretStore || "",
-        network: this.getSigningNetwork()
-      });
-      const signatureHex = result.signature.startsWith("0x") ? result.signature.slice(2) : result.signature;
-      const signatureBytes = new Uint8Array(
-        signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
-      );
-      return { signature: signatureBytes };
-    } catch (error) {
-      this.emit("error", error);
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "Failed to sign message",
-        error
-      );
-    }
-  }
-  /**
-   * Sign arbitrary Solana transaction (requires PIN)
-   * Supports both Legacy Transaction and VersionedTransaction
-   * Used for custom transactions, dApp interactions, and protocol integrations
-   */
-  async signTransaction(transaction) {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    try {
-      let txMessage = "";
-      try {
-        txMessage = JSON.stringify(transaction, null, 2);
-      } catch {
-        txMessage = String(transaction);
-      }
-      await this.callInterceptor({
-        chain: "solana",
-        method: "signTransaction",
-        address: this.wallet.address,
-        network: this.wallet.network,
-        message: txMessage,
-        isTransaction: true
-      });
-      const { VersionedTransaction, PublicKey } = await import("@solana/web3.js");
-      const isVersioned = transaction instanceof VersionedTransaction;
-      let serialized;
-      if (isVersioned) {
-        serialized = transaction.message.serialize();
-      } else {
-        serialized = transaction.serializeMessage();
-      }
-      const messageHex = Buffer.from(serialized).toString("hex");
-      const signatureResponse = await this.getTalkenApiClientOrThrow().solana.sign({
-        keyId: this.wallet.keyId,
-        encryptedShare: this.wallet.encryptedShare,
-        secretStore: this.wallet.secretStore || "",
-        message: messageHex,
-        network: this.getSigningNetwork()
-      });
-      const signatureHex = signatureResponse.signature.startsWith("0x") ? signatureResponse.signature.slice(2) : signatureResponse.signature;
-      const signatureBytes = Buffer.from(signatureHex, "hex");
-      const publicKey = new PublicKey(this.wallet.address);
-      if (isVersioned) {
-        transaction.addSignature(publicKey, signatureBytes);
-      } else {
-        transaction.addSignature(publicKey, signatureBytes);
-      }
-      return transaction;
-    } catch (error) {
-      if (error.code === 4001 || error.cancelled) {
-        throw error;
-      }
-      this.emit("error", error);
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "Failed to sign transaction",
-        error
-      );
-    }
-  }
-  /**
-   * Sign multiple transactions (batch signing)
-   */
-  async signAllTransactions(transactions) {
-    const signedTransactions = [];
-    for (const transaction of transactions) {
-      const signed = await this.signTransaction(transaction);
-      signedTransactions.push(signed);
-    }
-    return signedTransactions;
-  }
-  /**
-   * Unified transfer: SOL, SPL token, or NFT
-   * - No mintAddress → native SOL transfer (kind='native')
-   * - With mintAddress → SPL/NFT transfer (kind='spl')
-   * - NFT = transfer({ mintAddress, toAddress, amount: 1 })
-   */
-  async transfer(params) {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    try {
-      const symbol = params.mintAddress ? "SPL" : "SOL";
-      await this.callInterceptor({
-        chain: "solana",
-        method: "transfer",
-        fromAddress: this.wallet.address,
-        toAddress: params.toAddress,
-        amount: String(params.amount),
-        symbol,
-        network: this.wallet.network,
-        tokenAddress: params.mintAddress,
-        isNativeToken: !params.mintAddress,
-        feeSymbol: "SOL"
-      });
-      const pinHash = getCredentialManager().getPinHash();
-      if (!pinHash) {
-        throw new SolanaProviderError(
-          SolanaErrorCode.INTERNAL_ERROR,
-          "PIN hash not found. Please login again."
-        );
-      }
-      console.log("[AbcSolanaProvider] transfer START", {
-        kind: params.mintAddress ? "spl" : "native",
-        toAddress: params.toAddress,
-        amount: params.amount,
-        mintAddress: params.mintAddress || null,
-        network: this.wallet.network,
-        hasPinHash: !!pinHash
-      });
-      const api = this.getTalkenApiClientOrThrow();
-      if (params.mintAddress) {
-        const apiNetwork = this.wallet.network === "solana" ? "solana_mainnet" : this.wallet.network;
-        const { PublicKey, Connection } = await import("@solana/web3.js");
-        const connection = new Connection(this.getRpcUrl(), "confirmed");
-        const mintPubkey = new PublicKey(params.mintAddress);
-        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
-        const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
-        const rawAmount = Math.floor(params.amount * 10 ** decimals);
-        const result2 = await api.solana.transfer({
-          kind: "spl",
-          toAddress: params.toAddress,
-          mintAddress: params.mintAddress,
-          amount: String(rawAmount),
-          decimals,
-          network: apiNetwork,
-          pin: pinHash
-        });
-        console.log("[AbcSolanaProvider] SPL transfer result:", result2);
-        return { signature: result2.txHash };
-      }
-      const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
-      const amountLamports = params.amount * LAMPORTS_PER_SOL;
-      console.log("[AbcSolanaProvider] native transfer request:", {
-        toAddress: params.toAddress,
-        amountLamports: String(amountLamports),
-        amountSOL: params.amount
-      });
-      const result = await api.solana.transfer({
-        kind: "native",
-        toAddress: params.toAddress,
-        amountLamports: String(amountLamports),
-        pin: pinHash
-      });
-      console.log("[AbcSolanaProvider] native transfer result:", result);
-      return { signature: result.txHash };
-    } catch (error) {
-      console.error("[AbcSolanaProvider] transfer FAILED:", {
-        message: error.message,
-        code: error.code,
-        status: error.status,
-        details: error.details || error.data
-      });
-      if (error.code === 4001 || error.cancelled) {
-        throw error;
-      }
-      this.emit("error", error);
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "Failed to transfer",
-        error
-      );
-    }
-  }
-  /**
-   * Get wallet info
-   */
-  getWalletInfo() {
-    if (!this.wallet)
-      return null;
-    return {
-      address: this.wallet.address,
-      publicKey: this.wallet.publicKey,
-      network: this.wallet.network
-    };
-  }
-  /**
-   * Get SPL token balance
-   *
-   * @param mintAddress - Token mint address
-   * @returns Token balance information
-   */
-  async getTokenBalance(mintAddress) {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    try {
-      const { PublicKey, Connection } = await import("@solana/web3.js");
-      const { getAssociatedTokenAddress, TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
-      const connection = new Connection(this.getRpcUrl(), "confirmed");
-      const mintPubkey = new PublicKey(mintAddress);
-      const ownerPubkey = new PublicKey(this.wallet.address);
-      const tokenAccount = await getAssociatedTokenAddress(
-        mintPubkey,
-        ownerPubkey,
-        false,
-        TOKEN_PROGRAM_ID
-      );
-      const balance = await connection.getTokenAccountBalance(tokenAccount);
-      return {
-        amount: balance.value.amount,
-        decimals: balance.value.decimals,
-        uiAmount: balance.value.uiAmount || 0
-      };
-    } catch (error) {
-      this.emit("error", error);
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "Failed to get token balance",
-        error
-      );
-    }
-  }
-  /**
-   * Get RPC URL based on network
-   */
-  getRpcUrl() {
-    const isMainnet = this.wallet?.network === "solana";
-    return isMainnet ? process.env.NEXT_PUBLIC_SOLANA_RPC_MAINNET || "https://api.mainnet-beta.solana.com" : process.env.NEXT_PUBLIC_SOLANA_RPC_DEVNET || "https://api.devnet.solana.com";
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/abcTronProvider.ts
-import { getTalkenApiClient as getTalkenApiClient10 } from "@talken/talkenkit";
-function isTalkenApiClient2(client) {
-  return typeof client?.tron?.transferTrx === "function";
-}
-var TronErrorCode = {
-  USER_REJECTED: 4001,
-  UNAUTHORIZED: 4100,
-  UNSUPPORTED_METHOD: 4200,
-  DISCONNECTED: 4900,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603,
-  INSUFFICIENT_FUNDS: 5001
-};
-var TronProviderError = class extends Error {
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "TronProviderError";
-  }
-};
-var TRON_NETWORKS = {
-  mainnet: {
-    name: "TRON Mainnet",
-    type: "tron",
-    explorer: "https://tronscan.org"
-  },
-  nile: {
-    name: "TRON Nile Testnet",
-    type: "tron_nile",
-    explorer: "https://nile.tronscan.org"
-  }
-};
-var EventEmitter4 = class {
-  constructor() {
-    this.events = /* @__PURE__ */ new Map();
-  }
-  on(event, listener) {
-    if (!this.events.has(event)) {
-      this.events.set(event, []);
-    }
-    this.events.get(event).push(listener);
-    return this;
-  }
-  off(event, listener) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
-      }
-    }
-    return this;
-  }
-  emit(event, ...args) {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        listener(...args);
-      }
-      return true;
-    }
-    return false;
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this.events.delete(event);
-    } else {
-      this.events.clear();
-    }
-    return this;
-  }
-};
-var AbcTronProvider = class extends EventEmitter4 {
-  constructor(client) {
-    super();
-    this.wallet = null;
-    this.network = TRON_NETWORKS.mainnet;
-    this.connected = false;
-    this.tokenMetadataCache = /* @__PURE__ */ new Map();
-    if (isTalkenApiClient2(client)) {
-      this.talkenApi = client;
-    }
-  }
-  /**
-   * Set request interceptor for transfer confirmation modals
-   */
-  setRequestInterceptor(interceptor) {
-    this.requestInterceptor = interceptor;
-  }
-  /**
-   * Call request interceptor if set (throws on user cancel)
-   */
-  async callInterceptor(request) {
-    if (this.requestInterceptor) {
-      await this.requestInterceptor(request);
-    }
-  }
-  /**
-   * Set wallet information
-   */
-  setWallet(wallet) {
-    const previousAddress = this.wallet?.address;
-    this.wallet = wallet;
-    this.connected = true;
-    if (wallet.network === "tron") {
-      this.network = TRON_NETWORKS.mainnet;
-    } else {
-      this.network = TRON_NETWORKS.nile;
-    }
-    if (previousAddress !== wallet.address) {
-      this.emit("accountsChanged", [wallet.address]);
-    }
-    this.emit("connect", {
-      address: wallet.address,
-      network: this.network.type
-    });
-    console.log(
-      "[TronProvider] \u2705 Wallet connected:",
-      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 6)}`
-    );
-  }
-  /**
-   * Clear wallet (disconnect)
-   */
-  clearWallet() {
-    this.wallet = null;
-    this.connected = false;
-    this.emit("disconnect");
-    this.emit("accountsChanged", []);
-    console.log("[TronProvider] \u{1F50C} Wallet disconnected");
-  }
-  /**
-   * Set TalkenApiClient for backend-proxied transaction flow
-   * When set, sendTransaction will use a single API call instead of multi-step WaaS
-   */
-  setTalkenApi(talkenApi) {
-    this.talkenApi = talkenApi;
-  }
-  /**
-   * Fetch token metadata (symbol, logo) from walletscan API with caching.
-   * Falls back to 'TRX'/'TRC20' on failure.
-   */
-  async fetchTokenMetadata(contractAddress) {
-    const cacheKey = contractAddress || "__native__";
-    const cached = this.tokenMetadataCache.get(cacheKey);
-    if (cached)
-      return cached;
-    try {
-      const api = this.talkenApi || getTalkenApiClient10();
-      const chainKeys = this.network.type === "tron_nile" ? "tronNile" : "tron";
-      let tokens;
-      if (contractAddress) {
-        tokens = await api.walletscan.getToken({ chainKeys, contractAddress });
-      } else {
-        tokens = await api.walletscan.getNativeTokens({
-          chainKeys,
-          walletAddress: this.wallet.address
-        });
-      }
-      if (tokens.length > 0) {
-        const info = { symbol: tokens[0].symbol, logo: tokens[0].logo };
-        this.tokenMetadataCache.set(cacheKey, info);
-        return info;
-      }
-    } catch {
-    }
-    return { symbol: contractAddress ? "TRC20" : "TRX" };
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.connected && this.wallet !== null;
-  }
-  /**
-   * Get TRON address
-   */
-  async getAddress() {
-    if (!this.wallet) {
-      throw new TronProviderError(
-        TronErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    return this.wallet.address;
-  }
-  /**
-   * Get public key
-   */
-  async getPublicKey() {
-    if (!this.wallet) {
-      throw new TronProviderError(
-        TronErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    return this.wallet.publicKey;
-  }
-  /**
-   * Get current network
-   */
-  getNetwork() {
-    return this.network;
-  }
-  /**
-   * Sign TRON message (not supported)
-   */
-  async signMessage(_message) {
-    throw new TronProviderError(
-      TronErrorCode.UNSUPPORTED_METHOD,
-      "TRON message signing is not supported. Use sendTransaction() instead."
-    );
-  }
-  /**
-   * Send TRON transaction (TRX native or TRC20)
-   * Complete flow: create unsigned tx -> request PIN -> sign -> broadcast
-   *
-   * @param params - Transaction parameters
-   * @returns Transaction hash
-   */
-  async sendTransaction(params) {
-    if (!this.wallet) {
-      throw new TronProviderError(
-        TronErrorCode.DISCONNECTED,
-        "Wallet not connected"
-      );
-    }
-    try {
-      const tokenMetadata = await this.fetchTokenMetadata(
-        params.contractAddress
-      );
-      await this.callInterceptor({
-        chain: "tron",
-        method: "sendTransaction",
-        fromAddress: this.wallet.address,
-        toAddress: params.toAddress,
-        amount: params.amount,
-        symbol: tokenMetadata.symbol,
-        network: this.network.type,
-        tokenAddress: params.contractAddress,
-        isNativeToken: !params.contractAddress,
-        feeSymbol: "TRX",
-        tokenLogo: tokenMetadata.logo
-      });
-      console.log("[TronProvider] \u{1F4B8} Starting TRON transaction...");
-      const pinHash = getCredentialManager().getPinHash();
-      if (!pinHash) {
-        throw new TronProviderError(
-          TronErrorCode.INTERNAL_ERROR,
-          "PIN hash not found. Please login again."
-        );
-      }
-      const txType = params.contractAddress ? "TRC20" : "NATIVE";
-      let amountRaw;
-      if (txType === "NATIVE") {
-        amountRaw = Math.floor(
-          Number.parseFloat(params.amount) * 1e6
-        ).toString();
-        console.log(
-          `[TronProvider] Converting ${params.amount} TRX -> ${amountRaw} SUN`
-        );
-      } else {
-        const decimals = params.decimals ?? 6;
-        amountRaw = Math.floor(
-          Number.parseFloat(params.amount) * 10 ** decimals
-        ).toString();
-        console.log(
-          `[TronProvider] Converting ${params.amount} -> ${amountRaw} (decimals: ${decimals})`
-        );
-      }
-      const email = getCredentialManager().getEmail() || void 0;
-      const api = this.talkenApi || getTalkenApiClient10();
-      const request = txType === "NATIVE" ? {
-        kind: "native",
-        network: this.network.type,
-        toAddress: params.toAddress,
-        amountSun: amountRaw,
-        pin: pinHash,
-        ...email && { email }
-      } : {
-        kind: "trc20",
-        network: this.network.type,
-        toAddress: params.toAddress,
-        contractAddress: params.contractAddress,
-        amount: amountRaw,
-        feeLimit: params.feeLimit,
-        pin: pinHash,
-        ...email && { email }
-      };
-      const result = await api.tron.transferTrx(request);
-      const txHash = result.txHash;
-      console.log(
-        `[TronProvider] \u2705 ${txType === "NATIVE" ? "TRX" : "TRC-20"} transaction complete via TalkenApiClient:`,
-        txHash
-      );
-      this.emit("transactionBroadcasted", {
-        txHash,
-        explorerUrl: `${this.network.explorer}/#/transaction/${txHash}`
-      });
-      return txHash;
-    } catch (error) {
-      if (error.message?.includes("cancelled") || error.message?.includes("rejected")) {
-        console.log("[TronProvider] \u2139\uFE0F User cancelled transaction");
-        throw new TronProviderError(
-          TronErrorCode.USER_REJECTED,
-          "User rejected transaction",
-          error
-        );
-      }
-      console.error("[TronProvider] \u274C Transaction failed:", error.message);
-      if (error.message?.includes("insufficient")) {
-        throw new TronProviderError(
-          TronErrorCode.INSUFFICIENT_FUNDS,
-          "Insufficient TRX balance",
-          error
-        );
-      }
-      this.emit("error", error);
-      throw new TronProviderError(
-        TronErrorCode.INTERNAL_ERROR,
-        error.message || "Failed to send TRON transaction",
-        error
-      );
-    }
-  }
-  /**
-   * Get wallet info
-   */
-  getWalletInfo() {
-    if (!this.wallet)
-      return null;
-    return {
-      address: this.wallet.address,
-      publicKey: this.wallet.publicKey,
-      network: this.network.type
-    };
-  }
-};
-
-// src/wallets/walletConnectors/abcWallet/walletGeneration.ts
-import { getTalkenApiClient as getTalkenApiClient11 } from "@talken/talkenkit";
-function mapApiResponseToWallets(genResponse, infoResponse, email) {
-  const accounts = infoResponse?.accounts || [];
-  const evmAccount = accounts[0] || infoResponse || {};
-  const uid = String(genResponse.uid || evmAccount.uid || "");
-  const wid = String(genResponse.wid || evmAccount.wid || "");
-  const sid = String(evmAccount.sid || evmAccount.ethAddress || genResponse.evmAddress || "");
-  const pubkey = String(evmAccount.pubkey || genResponse.pubkey || "");
-  const solMaterial = genResponse.solana || {};
-  const evmWallet = {
-    uid,
-    sessionId: sid,
-    keyId: wid,
-    encryptedShare: String(evmAccount.pvencstr || ""),
-    secretStore: String(evmAccount.encryptDevicePassword || ""),
-    address: genResponse.evmAddress || sid,
-    chainId: getEvmNetwork(),
-    sid,
-    type: "evm",
-    email,
-    pubkey
-  };
-  const solanaWallet = {
-    uid,
-    sessionId: String(solMaterial.shareId || ""),
-    keyId: String(solMaterial.keyId || ""),
-    encryptedShare: String(solMaterial.encryptedShare || ""),
-    secretStore: String(solMaterial.secretStore || ""),
-    shareId: String(solMaterial.shareId || ""),
-    publicKey: String(solMaterial.publicKey || ""),
-    address: genResponse.solAddress || solMaterial.address || "",
-    network: getSolanaNetwork()
-  };
-  const bitcoinWallet = {
-    uid,
-    sessionId: sid,
-    keyId: wid,
-    encryptedShare: String(evmAccount.pvencstr || ""),
-    shareId: sid,
-    publicKey: pubkey,
-    address: genResponse.btcAddress || "",
-    addressType: "bech32",
-    network: getBitcoinNetwork()
-  };
-  const tronWallet = {
-    uid,
-    sessionId: sid,
-    keyId: wid,
-    encryptedShare: String(evmAccount.pvencstr || ""),
-    shareId: sid,
-    publicKey: pubkey,
-    address: genResponse.trxAddress || "",
-    network: getTronNetwork()
-  };
-  return { evmWallet, solanaWallet, bitcoinWallet, tronWallet };
-}
-async function generateMpcWallets(hashedPin, email) {
-  const api = getTalkenApiClient11();
-  if (!api) {
-    throw new AbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      "TalkenApiClient not initialized"
-    );
-  }
-  try {
-    const genResponse = await api.wallet.generate(hashedPin, email);
-    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
-    return mapApiResponseToWallets(genResponse, infoResponse, email || "");
-  } catch (error) {
-    throw new AbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      `Failed to generate MPC wallets: ${error.message}`,
-      { originalError: error }
-    );
-  }
-}
-async function recoverMpcWallets(hashedPin, email) {
-  const api = getTalkenApiClient11();
-  if (!api) {
-    throw new AbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      "TalkenApiClient not initialized"
-    );
-  }
-  try {
-    const genResponse = await api.wallet.recover(hashedPin, email);
-    const infoResponse = await api.wallet.getInfo().catch(() => ({}));
-    return mapApiResponseToWallets(genResponse, infoResponse, email || "");
-  } catch (error) {
-    throw new AbcError(
-      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-      `Failed to recover MPC wallets: ${error.message}`,
-      { originalError: error }
-    );
-  }
-}
-function validateMpcWallets(result) {
-  const errors = [];
-  if (!result.evmWallet) {
-    errors.push("EVM wallet is missing");
-  } else {
-    if (!result.evmWallet.address || !result.evmWallet.address.startsWith("0x")) {
-      errors.push("Invalid EVM wallet address");
-    }
-  }
-  if (!result.solanaWallet) {
-    errors.push("Solana wallet is missing");
-  } else {
-    if (!result.solanaWallet.address) {
-      errors.push("Invalid Solana wallet address");
-    }
-  }
-  if (!result.bitcoinWallet) {
-    errors.push("Bitcoin wallet is missing");
-  } else {
-    if (!result.bitcoinWallet.address) {
-      errors.push("Invalid Bitcoin wallet address");
-    }
-  }
-  if (!result.tronWallet) {
-    errors.push("TRON wallet is missing");
-  } else {
-    if (!result.tronWallet.address) {
-      errors.push("Invalid TRON wallet address");
-    } else if (!result.tronWallet.address.startsWith("T")) {
-      errors.push("Invalid TRON address format (expected T prefix)");
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-
-export {
-  AbcStorageKey,
-  AbcErrorCode,
-  AbcError,
-  hashPin,
-  validatePin,
-  validateEmail,
-  getStorageKey,
-  saveToStorage,
-  loadFromStorage,
-  removeFromStorage,
-  clearStorage,
-  isTokenExpired,
-  calculateExpiryTimestamp,
-  saveAuthState,
-  loadAuthState,
-  clearAuthState,
-  createAbcError,
-  hexToNumber,
-  numberToHex,
-  NetworkType,
-  NETWORK_CONFIGS,
-  NETWORK_BY_PARAM,
-  getNetworkByChainId,
-  getNetworkByParam,
-  chainIdToNetwork,
-  getNetworkName,
-  networkNameToChainKey,
-  networkToChainId,
-  getExplorerTxUrl,
-  getExplorerAddressUrl,
-  isEvmNetwork,
-  isTestnet,
-  getSupportedChainIds,
-  getSupportedNetworks,
-  AbcEvmProvider,
-  createAbcEvmProvider,
-  createAbcProvider,
-  TalkenApiClient,
-  createTalkenApiClient,
-  setTalkenApiClient,
-  getTalkenApiClient2 as getTalkenApiClient,
-  SolanaNetwork,
-  BitcoinNetwork,
-  TronNetwork,
-  getEvmNetwork,
-  getSolanaNetwork,
-  getBitcoinNetwork,
-  getTronNetwork,
-  resolveTalkenApiUrl,
-  abcConnector,
-  abcWallet,
-  WalletscanApi,
-  GasApi,
-  SessionExpiredError,
-  dispatchSessionExpired,
-  handleUnauthorizedResponse,
-  fetchWithSessionCheck,
-  refreshAccessToken,
-  BitcoinProviderError,
-  BITCOIN_NETWORKS,
-  AbcBitcoinProvider,
-  AbcBitcoinConnector,
-  createAbcBitcoinConnector,
-  SolanaProviderError,
-  AbcSolanaProvider,
-  TronProviderError,
-  TRON_NETWORKS,
-  AbcTronProvider,
-  generateMpcWallets,
-  recoverMpcWallets,
-  validateMpcWallets
-};