@earthworm/wallet-sdk 0.2.2 → 0.2.5

package/dist/index.js

@@ -1,27 +1,84 @@
-import { BrowserProvider, Contract, JsonRpcProvider, formatUnits } from 'ethers';
-
-// src/utils/chain.ts
-function toChainIdDecimal(chainId, fallback) {
-  const decimal = Number.parseInt(chainId, 16);
-  if (Number.isFinite(decimal)) return decimal;
-  if (fallback !== void 0) return fallback;
-  return Number.NaN;
-}
-
-// src/utils/env.ts
-var isBrowser = typeof window !== "undefined";
-function assertBrowser(apiName) {
-  if (!isBrowser) {
-    throw new Error(`[wallet-sdk] ${apiName} is only available in the browser`);
-  }
-}
+export { applyWalletAccountsChangedEffect } from './chunk-HLZ3QZTH.js';
+export { ensureTargetNetwork, switchToConfiguredNetwork } from './chunk-XTONTXHH.js';
+import { isBrowser } from './chunk-F7UNIZSN.js';
+export { BSC_NETWORK, BSC_TESTNET_NETWORK, ERC20_ABI, ERC20_DECIMALS, ERC20_DECIMALS_ABI, SUPPORTED_BSC_CHAIN_IDS, USDT_CONFIG, WalletEvents, assertBrowser, bindBrowserProvider, bindWalletProvider, clearJsonRpcReadProviderCache, clearWalletRuntime, connectWallet, connectWalletAccount, createJsonRpcReadProvider, disconnectWallet, emitWalletEvent, getActiveWalletKey, getConfiguredReadProvider, getConnectedAddress, getContractDecimals, getContractPrice, getReadProviderWithFallback, getSelectedWalletProvider, getSharedBrowserProvider, getWalletAccounts, getWalletBrowserProvider, getWalletEventProvider, getWalletSdkConfig, getWalletSigner, hasDeployedContract, initWalletSdk, isBrowser, isContractDeployed, isWalletConnected, isWalletSdkInitialized, normalizeSupportedBscChainId, readConfiguredUsdtDecimals, readErc20Balance, readErc20Decimals, readUsdtBalance, refreshWalletAccounts, refreshWalletReadProvider, requestWallet, resetWalletSdkConfig, resolveChainConfig, resolveWalletKey, setWalletEventProvider, setWalletReadProvider, switchWalletAccount, syncConnectedWalletAccount, syncWalletAccountAddress, syncWalletRuntimeProvider, toChainIdDecimal, walletEvents } from './chunk-F7UNIZSN.js';
 
 // src/wallet/eip6963.ts
-var METAMASK_RDNS = "io.metamask";
-var COINBASE_RDNS = "com.coinbase.wallet";
-var TOKENPOCKET_RDNS = "com.tokenpocket";
+var EIP6963_ANNOUNCE = "eip6963:announceProvider";
+var EIP6963_REQUEST = "eip6963:requestProvider";
+var TIP6963_ANNOUNCE = "TIP6963:announceProvider";
+var TIP6963_REQUEST = "TIP6963:requestProvider";
+var Wallet6963Name = /* @__PURE__ */ ((Wallet6963Name2) => {
+  Wallet6963Name2["MetaMask"] = "metamask";
+  Wallet6963Name2["Coinbase"] = "coinbase";
+  Wallet6963Name2["TokenPocket"] = "tokenpocket";
+  Wallet6963Name2["TronLink"] = "tronlink";
+  return Wallet6963Name2;
+})(Wallet6963Name || {});
+var Wallet6963Rdns = /* @__PURE__ */ ((Wallet6963Rdns2) => {
+  Wallet6963Rdns2["MetaMask"] = "io.metamask";
+  Wallet6963Rdns2["Coinbase"] = "com.coinbase.wallet";
+  Wallet6963Rdns2["TokenPocket"] = "com.tokenpocket";
+  Wallet6963Rdns2["TronLink"] = "org.tronlink.www";
+  Wallet6963Rdns2["TronLinkAlt"] = "io.tronlink";
+  return Wallet6963Rdns2;
+})(Wallet6963Rdns || {});
+function normalizeWalletName(name) {
+  return name.toLowerCase();
+}
+function matchExactWalletName(name, walletName) {
+  return normalizeWalletName(name) === walletName;
+}
+function matchIncludesWalletName(name, walletName) {
+  return normalizeWalletName(name).includes(walletName);
+}
+var WALLET_6963_MATCHERS = {
+  metamask: {
+    rdns: ["io.metamask" /* MetaMask */],
+    matchName: (name) => matchExactWalletName(name, "metamask" /* MetaMask */)
+  },
+  coinbase: {
+    rdns: ["com.coinbase.wallet" /* Coinbase */],
+    matchName: (name) => matchIncludesWalletName(name, "coinbase" /* Coinbase */)
+  },
+  tokenpocket: {
+    rdns: ["com.tokenpocket" /* TokenPocket */],
+    matchName: (name) => matchIncludesWalletName(name, "tokenpocket" /* TokenPocket */)
+  },
+  tronlink: {
+    rdns: ["org.tronlink.www" /* TronLink */, "io.tronlink" /* TronLinkAlt */],
+    matchName: (name) => matchIncludesWalletName(name, "tronlink" /* TronLink */)
+  }
+};
 var discoveredProviders = [];
 var discoveryPromise = null;
+function getProviderDedupKey(detail) {
+  const rdns = detail.info.rdns?.trim().toLowerCase();
+  if (rdns) {
+    return `rdns:${rdns}`;
+  }
+  return `name:${normalizeWalletName(detail.info.name)}`;
+}
+function collectProviderDetail(providers, detail) {
+  if (!detail?.provider) return;
+  if (providers.some((item) => item.info.uuid === detail.info.uuid)) return;
+  const dedupKey = getProviderDedupKey(detail);
+  if (providers.some((item) => getProviderDedupKey(item) === dedupKey)) return;
+  providers.push(detail);
+}
+function matchesWallet6963(detail, matcher) {
+  const rdns = detail.info.rdns.toLowerCase();
+  return matcher.rdns.includes(rdns) || matcher.matchName(detail.info.name);
+}
+function defineWallet6963Provider(matcher) {
+  const find = () => findDiscoveredProvider((detail) => matchesWallet6963(detail, matcher));
+  const has = () => Boolean(find());
+  return { find, has };
+}
+var metamask6963 = defineWallet6963Provider(WALLET_6963_MATCHERS.metamask);
+var coinbase6963 = defineWallet6963Provider(WALLET_6963_MATCHERS.coinbase);
+var tokenPocket6963 = defineWallet6963Provider(WALLET_6963_MATCHERS.tokenpocket);
+var tronLink6963 = defineWallet6963Provider(WALLET_6963_MATCHERS.tronlink);
 function discoverWalletProviders(timeoutMs = 500) {
   if (!isBrowser) {
     return Promise.resolve([]);
@@ -32,58 +89,35 @@ function discoverWalletProviders(timeoutMs = 500) {
   discoveryPromise = new Promise((resolve) => {
     const providers = [];
     const onAnnounce = (event) => {
-      const detail = event.detail;
-      if (!detail?.provider) return;
-      if (providers.some((item) => item.info.uuid === detail.info.uuid)) return;
-      providers.push(detail);
+      collectProviderDetail(providers, event.detail);
     };
-    window.addEventListener("eip6963:announceProvider", onAnnounce);
-    window.dispatchEvent(new Event("eip6963:requestProvider"));
+    window.addEventListener(EIP6963_ANNOUNCE, onAnnounce);
+    window.addEventListener(TIP6963_ANNOUNCE, onAnnounce);
+    window.dispatchEvent(new Event(EIP6963_REQUEST));
+    window.dispatchEvent(new Event(TIP6963_REQUEST));
     window.setTimeout(() => {
-      window.removeEventListener("eip6963:announceProvider", onAnnounce);
+      window.removeEventListener(EIP6963_ANNOUNCE, onAnnounce);
+      window.removeEventListener(TIP6963_ANNOUNCE, onAnnounce);
       discoveredProviders = providers;
       resolve(providers);
     }, timeoutMs);
   });
   return discoveryPromise;
 }
+if (isBrowser) {
+  void discoverWalletProviders();
+}
 function findDiscoveredProvider(match) {
   return discoveredProviders.find(match)?.provider;
 }
-function findMetaMaskEip6963Provider() {
-  return findDiscoveredProvider(
-    (detail) => detail.info.rdns === METAMASK_RDNS || detail.info.name.toLowerCase() === "metamask"
-  );
-}
-function findCoinbaseEip6963Provider() {
-  return findDiscoveredProvider(
-    (detail) => detail.info.rdns === COINBASE_RDNS || detail.info.name.toLowerCase().includes("coinbase")
-  );
-}
-function findTokenPocketEip6963Provider() {
-  return findDiscoveredProvider(
-    (detail) => detail.info.rdns === TOKENPOCKET_RDNS || detail.info.name.toLowerCase().includes("tokenpocket")
-  );
-}
-function hasMetaMaskEip6963Provider() {
-  return Boolean(findMetaMaskEip6963Provider());
-}
-function hasCoinbaseEip6963Provider() {
-  return Boolean(findCoinbaseEip6963Provider());
-}
-function hasTokenPocketEip6963Provider() {
-  return Boolean(findTokenPocketEip6963Provider());
-}
-var providerCache = /* @__PURE__ */ new WeakMap();
-function getSharedBrowserProvider(ethereum) {
-  const cached = providerCache.get(ethereum);
-  if (cached) {
-    return cached;
-  }
-  const provider = new BrowserProvider(ethereum);
-  providerCache.set(ethereum, provider);
-  return provider;
-}
+var findMetaMaskEip6963Provider = metamask6963.find;
+var findCoinbaseEip6963Provider = coinbase6963.find;
+var findTokenPocketEip6963Provider = tokenPocket6963.find;
+var findTronLinkEip6963Provider = tronLink6963.find;
+var hasMetaMaskEip6963Provider = metamask6963.has;
+var hasCoinbaseEip6963Provider = coinbase6963.has;
+var hasTokenPocketEip6963Provider = tokenPocket6963.has;
+var hasTronLinkEip6963Provider = tronLink6963.has;
 
 // src/wallet/injected-providers.ts
 var isRequestableProvider = (provider) => {
@@ -99,7 +133,7 @@ function getInjectedEthereumProviders() {
 }
 var isMetaMaskLikeProvider = (provider) => {
   return Boolean(
-    provider.isMetaMask && !provider.isCoinbaseWallet && !provider.isTronLink && !provider.isTronLinkWallet
+    provider.isMetaMask && !provider.isCoinbaseWallet && !provider.isTokenPocket && !provider.isTronLink && !provider.isTronLinkWallet
   );
 };
 var isCoinbaseLikeProvider = (provider) => {
@@ -193,6 +227,27 @@ function resolveTokenPocketInjectedProvider() {
   }
   return void 0;
 }
+function resolveTronLinkInjectedProvider() {
+  const fromEip6963 = findTronLinkEip6963Provider();
+  if (fromEip6963 && isRequestableProvider(fromEip6963)) {
+    return fromEip6963;
+  }
+  const ethereum = window.ethereum;
+  const fromProviders = getInjectedEthereumProviders().find(isTronLinkLikeProvider);
+  if (fromProviders) {
+    return fromProviders;
+  }
+  if (ethereum && isTronLinkLikeProvider(ethereum)) {
+    return ethereum;
+  }
+  if (isRequestableProvider(window.tronLink)) {
+    return window.tronLink;
+  }
+  if (isRequestableProvider(window.tron)) {
+    return window.tron;
+  }
+  return void 0;
+}
 function hasMetaMaskInjectedProvider() {
   return Boolean(resolveMetaMaskInjectedProvider());
 }
@@ -204,6 +259,9 @@ function hasCoinbaseInjectedProvider() {
 function hasTokenPocketInjectedProvider() {
   return Boolean(resolveTokenPocketInjectedProvider());
 }
+function hasTronLinkInjectedProvider() {
+  return Boolean(resolveTronLinkInjectedProvider());
+}
 var cachedAggregatorProvider;
 var cachedAggregatorProviderCount = 0;
 var isMultiWalletAggregator = (provider) => {
@@ -265,637 +323,6 @@ function hasAggregatedInjectedProvider() {
   return isRequestableProvider(window.ethereum);
 }
 
-// src/abi/erc20.ts
-var ERC20_ABI = [
-  {
-    constant: true,
-    inputs: [],
-    name: "name",
-    outputs: [
-      {
-        name: "",
-        type: "string"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        name: "_spender",
-        type: "address"
-      },
-      {
-        name: "_value",
-        type: "uint256"
-      }
-    ],
-    name: "approve",
-    outputs: [
-      {
-        name: "success",
-        type: "bool"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "totalSupply",
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        name: "_from",
-        type: "address"
-      },
-      {
-        name: "_to",
-        type: "address"
-      },
-      {
-        name: "_value",
-        type: "uint256"
-      }
-    ],
-    name: "transferFrom",
-    outputs: [
-      {
-        name: "success",
-        type: "bool"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "decimals",
-    outputs: [
-      {
-        name: "",
-        type: "uint8"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        name: "_value",
-        type: "uint256"
-      }
-    ],
-    name: "burn",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [
-      {
-        name: "_owner",
-        type: "address"
-      }
-    ],
-    name: "balanceOf",
-    outputs: [
-      {
-        name: "balance",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        name: "_from",
-        type: "address"
-      },
-      {
-        name: "_value",
-        type: "uint256"
-      }
-    ],
-    name: "burnFrom",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        name: "_to",
-        type: "address[]"
-      },
-      {
-        name: "_value",
-        type: "uint256[]"
-      }
-    ],
-    name: "transferArray",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "symbol",
-    outputs: [
-      {
-        name: "",
-        type: "string"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        name: "_to",
-        type: "address"
-      },
-      {
-        name: "_value",
-        type: "uint256"
-      }
-    ],
-    name: "transfer",
-    outputs: [
-      {
-        name: "success",
-        type: "bool"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [
-      {
-        name: "_owner",
-        type: "address"
-      },
-      {
-        name: "_spender",
-        type: "address"
-      }
-    ],
-    name: "allowance",
-    outputs: [
-      {
-        name: "remaining",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        name: "_tokenName",
-        type: "string"
-      },
-      {
-        name: "_tokenSymbol",
-        type: "string"
-      },
-      {
-        name: "_decimalUnits",
-        type: "uint8"
-      },
-      {
-        name: "_initialAmount",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        name: "from",
-        type: "address"
-      },
-      {
-        indexed: true,
-        name: "to",
-        type: "address"
-      },
-      {
-        indexed: false,
-        name: "value",
-        type: "uint256"
-      }
-    ],
-    name: "Transfer",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        name: "owner",
-        type: "address"
-      },
-      {
-        indexed: true,
-        name: "spender",
-        type: "address"
-      },
-      {
-        indexed: false,
-        name: "value",
-        type: "uint256"
-      }
-    ],
-    name: "Approval",
-    type: "event"
-  }
-];
-
-// src/config/networks.ts
-var BSC_NETWORK = {
-  chainId: "0x38",
-  chainName: "BNB Smart Chain",
-  nativeCurrency: {
-    name: "BNB",
-    symbol: "BNB",
-    decimals: 18
-  },
-  rpcUrls: [
-    "https://bsc-dataseed.binance.org/",
-    "https://bsc-dataseed1.binance.org/",
-    "https://bsc-dataseed2.binance.org/"
-  ],
-  blockExplorerUrls: ["https://bscscan.com"]
-};
-var BSC_TESTNET_NETWORK = {
-  chainId: "0x61",
-  chainName: "BNB Smart Chain Testnet",
-  nativeCurrency: {
-    name: "tBNB",
-    symbol: "tBNB",
-    decimals: 18
-  },
-  rpcUrls: [
-    "https://data-seed-prebsc-1-s1.bnbchain.org:8545/",
-    "https://data-seed-prebsc-2-s1.bnbchain.org:8545/",
-    "https://data-seed-prebsc-1-s2.bnbchain.org:8545/"
-  ],
-  blockExplorerUrls: ["https://testnet.bscscan.com"]
-};
-
-// src/config/resolve-chain.ts
-var USDT_CONTRACT_ADDRESSES = {
-  [BSC_NETWORK.chainId]: "0x55d398326f99059fF775485246999027B3197955",
-  [BSC_TESTNET_NETWORK.chainId]: "0x66E972502A34A625828C544a1914E8D8cc2A9dE5"
-};
-function resolveUsdtContractAddress(chainId) {
-  const address = USDT_CONTRACT_ADDRESSES[chainId];
-  if (!address) {
-    throw new Error(`[wallet-sdk] Unsupported chainId for USDT: ${chainId}`);
-  }
-  return address;
-}
-function resolveChainByMainnet(isMainnet) {
-  return isMainnet ? BSC_NETWORK : BSC_TESTNET_NETWORK;
-}
-function resolveUsdtByMainnet(isMainnet) {
-  return resolveUsdtContractAddress(resolveChainByMainnet(isMainnet).chainId);
-}
-function resolveChainConfig(chainId) {
-  if (chainId === BSC_NETWORK.chainId) {
-    return BSC_NETWORK;
-  }
-  if (chainId === BSC_TESTNET_NETWORK.chainId) {
-    return BSC_TESTNET_NETWORK;
-  }
-  throw new Error(`[wallet-sdk] Unsupported chainId: ${chainId}`);
-}
-
-// src/config/usdt.ts
-var USDT_CONFIG = {
-  symbol: "USDT",
-  name: "Tether USD",
-  decimals: 18,
-  contractAbi: ERC20_ABI
-};
-var ERC20_DECIMALS = USDT_CONFIG.decimals;
-
-// src/core/contract.ts
-var ERC20_DECIMALS_ABI = ["function decimals() view returns (uint8)"];
-async function hasDeployedContract(readProvider, address) {
-  const code = await readProvider.getCode(address);
-  return Boolean(code && code !== "0x");
-}
-async function readErc20Decimals(readProvider, tokenAddress, erc20Abi = ERC20_DECIMALS_ABI, fallback = ERC20_DECIMALS) {
-  if (!await hasDeployedContract(readProvider, tokenAddress)) {
-    throw new Error(`[wallet-sdk] Token contract not deployed: ${tokenAddress}`);
-  }
-  try {
-    const tokenContract = new Contract(tokenAddress, erc20Abi, readProvider);
-    const decimals = Number(await tokenContract.getFunction("decimals").staticCall());
-    return Number.isFinite(decimals) && decimals >= 0 ? decimals : fallback;
-  } catch {
-    return fallback;
-  }
-}
-
-// src/core/init.ts
-var CONFIG_KEY = "__WALLET_SDK_CONFIG__";
-function getStoredConfig() {
-  return globalThis[CONFIG_KEY] ?? null;
-}
-function storeConfig(config) {
-  globalThis[CONFIG_KEY] = config;
-}
-function buildConfig(options) {
-  const chain = resolveChainByMainnet(options.isMainnet);
-  return {
-    isMainnet: options.isMainnet,
-    chainId: chain.chainId,
-    chain,
-    contract: {
-      address: options.contract.address,
-      abi: options.contract.abi
-    },
-    usdt: {
-      address: resolveUsdtByMainnet(options.isMainnet),
-      abi: USDT_CONFIG.contractAbi,
-      symbol: USDT_CONFIG.symbol,
-      name: USDT_CONFIG.name,
-      decimals: USDT_CONFIG.decimals
-    }
-  };
-}
-function initWalletSdk(options) {
-  const config = buildConfig(options);
-  storeConfig(config);
-  return config;
-}
-function getWalletSdkConfig() {
-  const config = getStoredConfig();
-  if (!config) {
-    throw new Error("[wallet-sdk] initWalletSdk() must be called before using the library");
-  }
-  return config;
-}
-function isWalletSdkInitialized() {
-  return getStoredConfig() !== null;
-}
-function resetWalletSdkConfig() {
-  delete globalThis[CONFIG_KEY];
-}
-function createJsonRpcReadProvider(rpcUrl, chainIdHex, cache) {
-  if (cache?.current) return cache.current;
-  const provider = new JsonRpcProvider(rpcUrl, toChainIdDecimal(chainIdHex), {
-    staticNetwork: true
-  });
-  if (cache) {
-    cache.current = provider;
-  }
-  return provider;
-}
-function getReadProviderWithFallback(walletProvider, rpcConfig, fallbackCache) {
-  if (walletProvider) return walletProvider;
-  const rpcUrl = rpcConfig.rpcUrls[0];
-  if (!rpcUrl || !rpcConfig.chainId) {
-    throw new Error("RPC config is missing");
-  }
-  return createJsonRpcReadProvider(rpcUrl, rpcConfig.chainId, fallbackCache);
-}
-
-// src/core/contract-read.ts
-var readProviderCache = { current: null };
-var walletReadProvider = null;
-function setWalletReadProvider(provider) {
-  walletReadProvider = provider;
-}
-function getConfiguredReadProvider() {
-  const { chain } = getWalletSdkConfig();
-  return getReadProviderWithFallback(walletReadProvider, chain, readProviderCache);
-}
-async function isContractDeployed(contractAddress) {
-  return hasDeployedContract(getConfiguredReadProvider(), contractAddress);
-}
-async function getContractDecimals(contractAddress, options) {
-  const readProvider = getConfiguredReadProvider();
-  if (!await hasDeployedContract(readProvider, contractAddress)) {
-    throw new Error(`[wallet-sdk] Contract not deployed: ${contractAddress}`);
-  }
-  const tokenContract = new Contract(contractAddress, options.abi, readProvider);
-  const decimals = await tokenContract.getFunction(options.method).staticCall();
-  return Number(decimals);
-}
-async function getContractPrice(contractAddress, options) {
-  const readProvider = getConfiguredReadProvider();
-  if (!await hasDeployedContract(readProvider, contractAddress)) {
-    throw new Error(`[wallet-sdk] Contract not deployed: ${contractAddress}`);
-  }
-  const tokenContract = new Contract(contractAddress, options.abi, readProvider);
-  const price = await tokenContract.getFunction(options.method).staticCall();
-  const decimals = await getContractDecimals(contractAddress, { abi: options.abi, method: "decimals" });
-  return formatUnits(price, decimals);
-}
-
-// src/core/network.ts
-async function ensureTargetNetwork(options) {
-  const currentChainId = await options.getCurrentChainId();
-  if (currentChainId.toLowerCase() === options.targetChainId.toLowerCase()) return;
-  try {
-    await options.switchChain(options.targetChainId);
-  } catch (err) {
-    const error = err;
-    if (error?.code !== 4902 && error?.info?.error?.code !== 4902) {
-      throw err;
-    }
-    await options.addChain(options.chainParams);
-    await options.switchChain(options.targetChainId);
-  }
-}
-
-// src/wallet/common.ts
-function bindBrowserProvider(eip1193, cache) {
-  const nextProvider = getSharedBrowserProvider(eip1193);
-  if (cache.value !== nextProvider) {
-    cache.value = nextProvider;
-  }
-  return nextProvider;
-}
-async function requestWallet(eip1193, method, params) {
-  return eip1193.request({
-    method,
-    ...params === void 0 ? {} : { params }
-  });
-}
-async function connectWalletAccount(requestAccounts, getProvider, setSigner, markConnected) {
-  const accounts = await requestAccounts() || [];
-  if (!accounts.length) {
-    throw new Error("No accounts returned");
-  }
-  const sourceProvider = getProvider();
-  const nextSigner = await sourceProvider.getSigner();
-  const address = await nextSigner.getAddress();
-  setSigner(nextSigner);
-  markConnected();
-  return { address, signer: nextSigner };
-}
-async function syncWalletAccountAddress(getProvider, setSigner, markConnected, nextAddress) {
-  const sourceProvider = getProvider();
-  const nextSigner = nextAddress ? await sourceProvider.getSigner(nextAddress) : await sourceProvider.getSigner();
-  const address = nextAddress || await nextSigner.getAddress();
-  setSigner(nextSigner);
-  markConnected();
-  return { address, signer: nextSigner };
-}
-function clearWalletRuntime(cache) {
-  cache.provider.value = null;
-  cache.signer.value = null;
-  if (cache.selectedProvider) {
-    cache.selectedProvider.value = null;
-  }
-}
-
-// src/wallet/events.ts
-var eventHandlers = {};
-var providerBridges = /* @__PURE__ */ new WeakMap();
-var walletEventProvider = null;
-var boundProvider = null;
-function hasRegisteredHandlers() {
-  return Object.values(eventHandlers).some((handlers) => handlers && handlers.size > 0);
-}
-function dispatch(event, payload) {
-  const handlers = eventHandlers[event];
-  if (!handlers) return;
-  for (const handler of handlers) {
-    void handler(payload);
-  }
-}
-function unbindProvider(provider) {
-  const bridgeHandlers = providerBridges.get(provider);
-  if (!bridgeHandlers) return;
-  for (const [event, handler] of Object.entries(bridgeHandlers)) {
-    provider.removeListener(event, handler);
-  }
-  providerBridges.delete(provider);
-}
-function syncProviderBinding() {
-  if (boundProvider) {
-    unbindProvider(boundProvider);
-    boundProvider = null;
-  }
-  if (!walletEventProvider || !hasRegisteredHandlers()) {
-    return;
-  }
-  const bridgeHandlers = {};
-  if (eventHandlers.accountsChanged?.size) {
-    bridgeHandlers.accountsChanged = (...args) => {
-      dispatch("accountsChanged", args[0] ?? []);
-    };
-  }
-  if (eventHandlers.chainChanged?.size) {
-    bridgeHandlers.chainChanged = (...args) => {
-      dispatch("chainChanged", String(args[0] ?? ""));
-    };
-  }
-  for (const [event, handler] of Object.entries(bridgeHandlers)) {
-    walletEventProvider.removeListener(event, handler);
-    walletEventProvider.on(event, handler);
-  }
-  providerBridges.set(walletEventProvider, bridgeHandlers);
-  boundProvider = walletEventProvider;
-}
-function setWalletEventProvider(provider) {
-  walletEventProvider = provider;
-  syncProviderBinding();
-}
-function getWalletEventProvider() {
-  if (!walletEventProvider) {
-    throw new Error("[wallet-sdk] Wallet event provider is not set");
-  }
-  return walletEventProvider;
-}
-function registerEvent(event, listener) {
-  assertBrowser("walletEvents.on");
-  if (!eventHandlers[event]) {
-    eventHandlers[event] = /* @__PURE__ */ new Set();
-  }
-  eventHandlers[event].add(listener);
-  syncProviderBinding();
-}
-function unregisterEvent(event, listener) {
-  if (!isBrowser) return;
-  if (listener) {
-    eventHandlers[event]?.delete(listener);
-  } else {
-    eventHandlers[event]?.clear();
-  }
-  syncProviderBinding();
-}
-function clearEvents() {
-  if (!isBrowser) return;
-  for (const event of Object.keys(eventHandlers)) {
-    eventHandlers[event]?.clear();
-  }
-  syncProviderBinding();
-}
-var WalletEventsEmitter = class {
-  on(event, listener) {
-    registerEvent(event, listener);
-  }
-  off(event, listener) {
-    unregisterEvent(event, listener);
-  }
-  clear() {
-    clearEvents();
-  }
-};
-var walletEvents = new WalletEventsEmitter();
-
 // src/wallet/detection.ts
 function isEthereumProvider() {
   if (!isBrowser) return false;
@@ -915,7 +342,7 @@ function isInjectedProvider() {
 }
 function isTronLinkProvider() {
   if (!isBrowser) return false;
-  return Boolean(window.tron?.request || window.tronLink);
+  return hasTronLinkInjectedProvider() || hasTronLinkEip6963Provider();
 }
 
-export { BSC_NETWORK, BSC_TESTNET_NETWORK, ERC20_ABI, ERC20_DECIMALS, ERC20_DECIMALS_ABI, USDT_CONFIG, USDT_CONTRACT_ADDRESSES, assertBrowser, bindBrowserProvider, clearWalletRuntime, connectWalletAccount, createJsonRpcReadProvider, discoverWalletProviders, ensureTargetNetwork, findCoinbaseEip6963Provider, findDiscoveredProvider, findMetaMaskEip6963Provider, findTokenPocketEip6963Provider, getAggregatedInjectedProvider, getConfiguredReadProvider, getContractDecimals, getContractPrice, getInjectedEthereumProviders, getReadProviderWithFallback, getSharedBrowserProvider, getWalletEventProvider, getWalletSdkConfig, hasAggregatedInjectedProvider, hasCoinbaseEip6963Provider, hasCoinbaseInjectedProvider, hasDeployedContract, hasMetaMaskEip6963Provider, hasMetaMaskInjectedProvider, hasRecoverableAggregatorProvider, hasTokenPocketEip6963Provider, hasTokenPocketInjectedProvider, initWalletSdk, isBrowser, isCoinbaseProvider, isContractDeployed, isEthereumProvider, isInjectedProvider, isTokenPocketProvider, isTronLinkProvider, isWalletSdkInitialized, readErc20Decimals, rememberAggregatorProvider, requestWallet, resetWalletSdkConfig, resolveChainByMainnet, resolveChainConfig, resolveCoinbaseInjectedProvider, resolveMetaMaskInjectedProvider, resolveTokenPocketInjectedProvider, resolveUsdtByMainnet, resolveUsdtContractAddress, setWalletEventProvider, setWalletReadProvider, syncWalletAccountAddress, toChainIdDecimal, walletEvents };
+export { Wallet6963Name, Wallet6963Rdns, discoverWalletProviders, findCoinbaseEip6963Provider, findDiscoveredProvider, findMetaMaskEip6963Provider, findTokenPocketEip6963Provider, findTronLinkEip6963Provider, getAggregatedInjectedProvider, getInjectedEthereumProviders, hasAggregatedInjectedProvider, hasCoinbaseEip6963Provider, hasCoinbaseInjectedProvider, hasMetaMaskEip6963Provider, hasMetaMaskInjectedProvider, hasRecoverableAggregatorProvider, hasTokenPocketEip6963Provider, hasTokenPocketInjectedProvider, hasTronLinkEip6963Provider, hasTronLinkInjectedProvider, isCoinbaseProvider, isEthereumProvider, isInjectedProvider, isTokenPocketProvider, isTronLinkProvider, rememberAggregatorProvider, resolveCoinbaseInjectedProvider, resolveMetaMaskInjectedProvider, resolveTokenPocketInjectedProvider, resolveTronLinkInjectedProvider };