@earthworm/wallet-sdk 0.2.1 → 0.2.3

package/dist/chunk-Z2EMFRMV.js

@@ -0,0 +1,1065 @@
+import { BrowserProvider, Contract, formatUnits, JsonRpcProvider } 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`);
+  }
+}
+var providerCache = /* @__PURE__ */ new WeakMap();
+function resetSharedBrowserProvider(ethereum) {
+  providerCache.delete(ethereum);
+}
+function getSharedBrowserProvider(ethereum) {
+  const cached = providerCache.get(ethereum);
+  if (cached) {
+    return cached;
+  }
+  const provider = new BrowserProvider(ethereum);
+  providerCache.set(ethereum, provider);
+  return provider;
+}
+
+// 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 SUPPORTED_BSC_CHAIN_IDS = [
+  BSC_NETWORK.chainId,
+  BSC_TESTNET_NETWORK.chainId
+];
+function normalizeChainIdInput(chainId) {
+  if (typeof chainId === "number") {
+    return `0x${Number(chainId).toString(16)}`;
+  }
+  const trimmed = chainId.trim();
+  if (trimmed.startsWith("0x") || trimmed.startsWith("0X")) {
+    return `0x${trimmed.slice(2).toLowerCase()}`;
+  }
+  const decimal = Number.parseInt(trimmed, 10);
+  if (Number.isFinite(decimal)) {
+    return `0x${decimal.toString(16)}`;
+  }
+  return trimmed.toLowerCase();
+}
+function normalizeSupportedBscChainId(chainId) {
+  const normalized = normalizeChainIdInput(chainId);
+  if (normalized === BSC_NETWORK.chainId) {
+    return BSC_NETWORK.chainId;
+  }
+  if (normalized === BSC_TESTNET_NETWORK.chainId) {
+    return BSC_TESTNET_NETWORK.chainId;
+  }
+  throw new Error(
+    `[wallet-sdk] Unsupported chainId: ${chainId}. Only BSC mainnet (${BSC_NETWORK.chainId}) and testnet (${BSC_TESTNET_NETWORK.chainId}) are supported.`
+  );
+}
+function resolveChainConfig(chainId) {
+  return chainId === BSC_NETWORK.chainId ? BSC_NETWORK : BSC_TESTNET_NETWORK;
+}
+
+// src/config/usdt.ts
+var USDT_CONFIG = {
+  symbol: "USDT",
+  name: "Tether USD",
+  decimals: 18,
+  contractAbi: ERC20_ABI
+};
+var ERC20_DECIMALS = USDT_CONFIG.decimals;
+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;
+  }
+}
+async function readErc20Balance(readProvider, tokenAddress, accountAddress, erc20Abi = ERC20_ABI) {
+  if (!await hasDeployedContract(readProvider, tokenAddress)) {
+    throw new Error(`[wallet-sdk] Token contract not deployed: ${tokenAddress}`);
+  }
+  const tokenContract = new Contract(tokenAddress, erc20Abi, readProvider);
+  const [balance, decimals] = await Promise.all([
+    tokenContract.getFunction("balanceOf").staticCall(accountAddress),
+    readErc20Decimals(readProvider, tokenAddress, erc20Abi)
+  ]);
+  return {
+    accountAddress,
+    balance: formatUnits(balance, decimals),
+    decimals
+  };
+}
+var jsonRpcReadProviderCache = { current: null };
+function clearJsonRpcReadProviderCache() {
+  jsonRpcReadProviderCache.current = null;
+}
+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/init.ts
+var CONFIG_KEY = "__WALLET_SDK_CONFIG__";
+var INITIALIZED_KEY = "__WALLET_SDK_INITIALIZED__";
+function getStoredConfig() {
+  return globalThis[CONFIG_KEY] ?? null;
+}
+function isStoredInitialized() {
+  return Boolean(globalThis[INITIALIZED_KEY]);
+}
+function storeConfig(config) {
+  const globalState = globalThis;
+  globalState[CONFIG_KEY] = config;
+  globalState[INITIALIZED_KEY] = true;
+}
+function buildConfig(options) {
+  return {
+    usdt: {
+      address: options.usdt.address,
+      abi: USDT_CONFIG.contractAbi,
+      symbol: USDT_CONFIG.symbol,
+      name: USDT_CONFIG.name,
+      decimals: USDT_CONFIG.decimals
+    }
+  };
+}
+function isSameInitOptions(existing, options) {
+  return existing.usdt.address === options.usdt.address;
+}
+function initWalletSdk(options) {
+  const existing = getStoredConfig();
+  if (existing && isSameInitOptions(existing, options)) {
+    return existing;
+  }
+  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 isStoredInitialized() && getStoredConfig() !== null;
+}
+function resetWalletSdkConfig() {
+  const globalState = globalThis;
+  delete globalState[CONFIG_KEY];
+  delete globalState[INITIALIZED_KEY];
+  clearJsonRpcReadProviderCache();
+}
+var walletReadProvider = null;
+function setWalletReadProvider(provider) {
+  walletReadProvider = provider;
+}
+function refreshWalletReadProvider(eip1193) {
+  if (!walletReadProvider) return;
+  resetSharedBrowserProvider(eip1193);
+  walletReadProvider = getSharedBrowserProvider(eip1193);
+}
+function getConfiguredReadProvider(options = {}) {
+  if (walletReadProvider) {
+    return walletReadProvider;
+  }
+  if (!options.chainId) {
+    throw new Error(
+      "[wallet-sdk] Wallet read provider is not available. Connect wallet first or pass chainId for RPC read."
+    );
+  }
+  const chain = resolveChainConfig(options.chainId);
+  return getReadProviderWithFallback(null, chain, jsonRpcReadProviderCache);
+}
+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);
+}
+async function readConfiguredUsdtDecimals(chainId) {
+  const { usdt } = getWalletSdkConfig();
+  return readErc20Decimals(getConfiguredReadProvider({ chainId }), usdt.address, usdt.abi);
+}
+async function readUsdtBalance(accountAddress, chainId) {
+  const { usdt } = getWalletSdkConfig();
+  return readErc20Balance(getConfiguredReadProvider({ chainId }), usdt.address, accountAddress, usdt.abi);
+}
+
+// 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/resolve-wallet-key.ts
+function resolveWalletKey(provider) {
+  if (!provider) {
+    return "unknown";
+  }
+  const injected = provider;
+  if (injected.isTronLink || injected.isTronLinkWallet) {
+    return "tronlink";
+  }
+  if (injected.isCoinbaseWallet) {
+    return "coinbase";
+  }
+  if (injected.isTokenPocket) {
+    return "tokenpocket";
+  }
+  if (injected.isMetaMask) {
+    return "metamask";
+  }
+  if (typeof window !== "undefined") {
+    if (provider === window.tronLink || provider === window.tron) {
+      return "tronlink";
+    }
+  }
+  return "unknown";
+}
+
+// src/wallet/wallet-event-adapters.ts
+function normalizeAccountList(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter((item) => typeof item === "string" && item.length > 0);
+  }
+  if (typeof raw === "string" && raw.length > 0) {
+    return [raw];
+  }
+  return [];
+}
+function parseChainId(raw) {
+  if (typeof raw === "string") {
+    return raw;
+  }
+  if (raw && typeof raw === "object" && "chainId" in raw) {
+    return String(raw.chainId ?? "");
+  }
+  return String(raw ?? "");
+}
+function parseMetaMaskAccountsChanged(args) {
+  return {
+    name: "accountsChanged",
+    payload: normalizeAccountList(args[0]),
+    raw: args
+  };
+}
+function parseMetaMaskChainChanged(args) {
+  return {
+    name: "chainChanged",
+    payload: parseChainId(args[0]),
+    raw: args
+  };
+}
+function parseTronLinkAccountsChanged(args) {
+  return {
+    name: "accountsChanged",
+    payload: normalizeAccountList(args[0]),
+    raw: args
+  };
+}
+function parseTronLinkChainChanged(args) {
+  return {
+    name: "chainChanged",
+    payload: parseChainId(args[0]),
+    raw: args
+  };
+}
+function parseTronLinkLegacyMessage(data) {
+  const message = data?.message;
+  if (!message?.action) {
+    return null;
+  }
+  if (message.action === "setAccount" && message.data?.address) {
+    return {
+      name: "setAccount",
+      payload: [message.data.address],
+      raw: [data]
+    };
+  }
+  if (message.action === "accountsChanged") {
+    const payload = normalizeAccountList(message.data);
+    return {
+      name: "accountsChanged",
+      payload,
+      raw: [data]
+    };
+  }
+  if (message.action === "disconnectWeb") {
+    return {
+      name: "disconnectWeb",
+      payload: [],
+      raw: [data]
+    };
+  }
+  return null;
+}
+var DEFAULT_RETRY = {
+  emptyAccountsRetryAttempts: 0,
+  emptyAccountsRetryIntervalMs: 0
+};
+var TRONLINK_RETRY = {
+  emptyAccountsRetryAttempts: 5,
+  emptyAccountsRetryIntervalMs: 120
+};
+var walletEventAdapters = {
+  metamask: {
+    parseAccountsChanged: parseMetaMaskAccountsChanged,
+    parseChainChanged: parseMetaMaskChainChanged,
+    ...DEFAULT_RETRY
+  },
+  coinbase: {
+    parseAccountsChanged: parseMetaMaskAccountsChanged,
+    parseChainChanged: parseMetaMaskChainChanged,
+    ...DEFAULT_RETRY
+  },
+  tokenpocket: {
+    parseAccountsChanged: parseMetaMaskAccountsChanged,
+    parseChainChanged: parseMetaMaskChainChanged,
+    ...DEFAULT_RETRY
+  },
+  tronlink: {
+    parseAccountsChanged: parseTronLinkAccountsChanged,
+    parseChainChanged: parseTronLinkChainChanged,
+    parseLegacyMessage: parseTronLinkLegacyMessage,
+    ...TRONLINK_RETRY
+  },
+  unknown: {
+    parseAccountsChanged: parseMetaMaskAccountsChanged,
+    parseChainChanged: parseMetaMaskChainChanged,
+    emptyAccountsRetryAttempts: 2,
+    emptyAccountsRetryIntervalMs: 100
+  }
+};
+function getWalletEventAdapter(wallet) {
+  return walletEventAdapters[wallet];
+}
+
+// src/wallet/events.ts
+var eventHandlers = {};
+var providerBridges = /* @__PURE__ */ new WeakMap();
+var walletEventProvider = null;
+var boundProvider = null;
+var activeWalletKey = "unknown";
+var tronLinkMessageListener = null;
+function dispatch(sdkEvent, wallet, event) {
+  const handlers = eventHandlers[sdkEvent];
+  if (!handlers) return;
+  for (const handler of handlers) {
+    void handler(wallet, event);
+  }
+}
+function emitWalletEvent(sdkEvent, wallet, event) {
+  dispatch(sdkEvent, wallet, event);
+}
+function unbindProvider(provider) {
+  const bridgeHandlers = providerBridges.get(provider);
+  if (!bridgeHandlers) return;
+  if (bridgeHandlers.accountsChanged) {
+    provider.removeListener("accountsChanged", bridgeHandlers.accountsChanged);
+  }
+  if (bridgeHandlers.chainChanged) {
+    provider.removeListener("chainChanged", bridgeHandlers.chainChanged);
+  }
+  providerBridges.delete(provider);
+}
+function unbindTronLinkLegacyMessages() {
+  if (!isBrowser || !tronLinkMessageListener) {
+    return;
+  }
+  window.removeEventListener("message", tronLinkMessageListener);
+  tronLinkMessageListener = null;
+}
+async function handleAccountsChanged(wallet, nativeEvent) {
+  const { applyWalletAccountsChangedEffect } = await import('./account-sync-77HMBIWC.js');
+  await applyWalletAccountsChangedEffect(wallet, nativeEvent.payload);
+  dispatch("accountsChanged", wallet, nativeEvent);
+}
+function bindTronLinkLegacyMessages(wallet) {
+  if (!isBrowser || wallet !== "tronlink" || tronLinkMessageListener) {
+    return;
+  }
+  const adapter = getWalletEventAdapter(wallet);
+  tronLinkMessageListener = (messageEvent) => {
+    if (!adapter.parseLegacyMessage) {
+      return;
+    }
+    const parsed = adapter.parseLegacyMessage(messageEvent.data);
+    if (!parsed) {
+      return;
+    }
+    if (parsed.name === "disconnectWeb") {
+      void handleAccountsChanged(wallet, parsed);
+      return;
+    }
+    if (parsed.payload.length > 0 || parsed.name === "accountsChanged") {
+      void handleAccountsChanged(wallet, parsed);
+    }
+  };
+  window.addEventListener("message", tronLinkMessageListener);
+}
+function syncProviderBinding() {
+  if (boundProvider) {
+    unbindProvider(boundProvider);
+    boundProvider = null;
+  }
+  unbindTronLinkLegacyMessages();
+  if (!walletEventProvider) {
+    activeWalletKey = "unknown";
+    return;
+  }
+  activeWalletKey = resolveWalletKey(walletEventProvider);
+  const adapter = getWalletEventAdapter(activeWalletKey);
+  const bridgeHandlers = {};
+  if (eventHandlers.accountsChanged?.size) {
+    bridgeHandlers.accountsChanged = (...args) => {
+      const nativeEvent = adapter.parseAccountsChanged(args);
+      void handleAccountsChanged(activeWalletKey, nativeEvent);
+    };
+  }
+  if (eventHandlers.chainChanged?.size) {
+    bridgeHandlers.chainChanged = (...args) => {
+      if (walletEventProvider) {
+        refreshWalletReadProvider(walletEventProvider);
+      }
+      const nativeEvent = adapter.parseChainChanged(args);
+      dispatch("chainChanged", activeWalletKey, nativeEvent);
+    };
+  }
+  if (bridgeHandlers.accountsChanged) {
+    walletEventProvider.removeListener("accountsChanged", bridgeHandlers.accountsChanged);
+    walletEventProvider.on("accountsChanged", bridgeHandlers.accountsChanged);
+  }
+  if (bridgeHandlers.chainChanged) {
+    walletEventProvider.removeListener("chainChanged", bridgeHandlers.chainChanged);
+    walletEventProvider.on("chainChanged", bridgeHandlers.chainChanged);
+  }
+  providerBridges.set(walletEventProvider, bridgeHandlers);
+  boundProvider = walletEventProvider;
+  bindTronLinkLegacyMessages(activeWalletKey);
+}
+function setWalletEventProvider(provider) {
+  walletEventProvider = provider;
+  syncProviderBinding();
+}
+function getWalletEventProvider() {
+  if (!walletEventProvider) {
+    throw new Error("[wallet-sdk] Wallet event provider is not set");
+  }
+  return walletEventProvider;
+}
+function getActiveWalletKey() {
+  return activeWalletKey;
+}
+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 WalletEvents = class {
+  on(event, listener) {
+    registerEvent(event, listener);
+  }
+  off(event, listener) {
+    unregisterEvent(event, listener);
+  }
+  clear() {
+    clearEvents();
+  }
+};
+var walletEvents = new WalletEvents();
+
+// src/wallet/runtime.ts
+var RUNTIME_KEY = "__WALLET_SDK_RUNTIME__";
+function getRuntimeStore() {
+  const globalState = globalThis;
+  if (!globalState[RUNTIME_KEY]) {
+    globalState[RUNTIME_KEY] = {
+      provider: null,
+      signer: null,
+      selectedProvider: null,
+      connected: false,
+      connectionSession: 0
+    };
+  }
+  return globalState[RUNTIME_KEY];
+}
+function invalidateConnectionSession(runtime) {
+  runtime.connectionSession += 1;
+}
+function isActiveConnectionSession(runtime, session) {
+  return runtime.connectionSession === session && runtime.selectedProvider !== null;
+}
+function isWalletConnected() {
+  const runtime = getRuntimeStore();
+  return runtime.connected && runtime.signer !== null && runtime.selectedProvider !== null;
+}
+function getWalletSigner() {
+  const signer = getRuntimeStore().signer;
+  if (!signer) {
+    throw new Error("[wallet-sdk] Wallet is not connected");
+  }
+  return signer;
+}
+async function getConnectedAddress() {
+  return getWalletSigner().getAddress();
+}
+function getSelectedWalletProvider() {
+  return getRuntimeStore().selectedProvider;
+}
+function getWalletBrowserProvider() {
+  return getRuntimeStore().provider;
+}
+function bindWalletProvider(eip1193) {
+  const runtime = getRuntimeStore();
+  invalidateConnectionSession(runtime);
+  runtime.selectedProvider = eip1193;
+  setWalletEventProvider(eip1193);
+  const browserProvider = getSharedBrowserProvider(eip1193);
+  runtime.provider = browserProvider;
+  setWalletReadProvider(browserProvider);
+  return browserProvider;
+}
+function syncWalletRuntimeProvider() {
+  const runtime = getRuntimeStore();
+  if (!runtime.selectedProvider) return;
+  refreshWalletReadProvider(runtime.selectedProvider);
+  runtime.provider = getSharedBrowserProvider(runtime.selectedProvider);
+}
+async function connectWallet(eip1193, options = {}) {
+  bindWalletProvider(eip1193);
+  const runtime = getRuntimeStore();
+  const session = runtime.connectionSession;
+  const result = await connectWalletAccount(
+    () => requestWallet(eip1193, "eth_requestAccounts"),
+    () => {
+      const provider = getRuntimeStore().provider;
+      if (!provider) {
+        throw new Error("[wallet-sdk] Wallet provider is not bound");
+      }
+      return provider;
+    },
+    (signer) => {
+      if (!isActiveConnectionSession(runtime, session)) return;
+      runtime.signer = signer;
+    },
+    () => {
+      if (!isActiveConnectionSession(runtime, session)) return;
+      runtime.connected = true;
+    }
+  );
+  if (options.chainId && isActiveConnectionSession(runtime, session)) {
+    const { switchToConfiguredNetwork } = await import('./network-WJN3S7KB.js');
+    await switchToConfiguredNetwork(options.chainId);
+  }
+  return result;
+}
+async function syncConnectedWalletAccount(nextAddress) {
+  const runtime = getRuntimeStore();
+  const session = runtime.connectionSession;
+  if (!runtime.provider) {
+    throw new Error("[wallet-sdk] Wallet provider is not bound");
+  }
+  return syncWalletAccountAddress(
+    () => {
+      if (!isActiveConnectionSession(runtime, session) || !runtime.provider) {
+        throw new Error("[wallet-sdk] Wallet disconnected during account sync");
+      }
+      return runtime.provider;
+    },
+    (signer) => {
+      if (!isActiveConnectionSession(runtime, session)) return;
+      runtime.signer = signer;
+    },
+    () => {
+      if (!isActiveConnectionSession(runtime, session)) return;
+      runtime.connected = true;
+    },
+    nextAddress
+  );
+}
+function normalizeWalletAccounts(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((item) => typeof item === "string" && item.length > 0);
+}
+async function getWalletAccounts() {
+  const provider = getSelectedWalletProvider();
+  if (!provider) {
+    throw new Error("[wallet-sdk] Wallet is not connected");
+  }
+  return normalizeWalletAccounts(await requestWallet(provider, "eth_accounts"));
+}
+async function tryRequestAccountPermissions(provider) {
+  try {
+    await requestWallet(provider, "wallet_requestPermissions", [{ eth_accounts: {} }]);
+    return true;
+  } catch (err) {
+    const error = err;
+    if (error?.code === 4001) {
+      throw err;
+    }
+    if (error?.code === 4200) {
+      return false;
+    }
+    return false;
+  }
+}
+async function refreshWalletAccounts() {
+  const provider = getSelectedWalletProvider();
+  if (!provider) {
+    throw new Error("[wallet-sdk] Wallet is not connected");
+  }
+  const permissionRequested = await tryRequestAccountPermissions(provider);
+  if (permissionRequested) {
+    return normalizeWalletAccounts(await requestWallet(provider, "eth_accounts"));
+  }
+  return normalizeWalletAccounts(await requestWallet(provider, "eth_requestAccounts"));
+}
+async function switchWalletAccount(address) {
+  if (!isWalletConnected()) {
+    throw new Error("[wallet-sdk] Wallet is not connected");
+  }
+  const accounts = await getWalletAccounts();
+  const target = address.toLowerCase();
+  if (!accounts.some((item) => item.toLowerCase() === target)) {
+    throw new Error(`[wallet-sdk] Address not available in connected wallet: ${address}`);
+  }
+  return syncConnectedWalletAccount(address);
+}
+function disconnectWallet() {
+  const runtime = getRuntimeStore();
+  invalidateConnectionSession(runtime);
+  runtime.provider = null;
+  runtime.signer = null;
+  runtime.selectedProvider = null;
+  runtime.connected = false;
+  setWalletEventProvider(null);
+  setWalletReadProvider(null);
+}
+
+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, getWalletEventAdapter, 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 };