@earthworm/wallet-sdk 0.1.0

package/README.md

@@ -0,0 +1,37 @@
+# @earthworm/wallet-sdk
+
+Browser EVM wallet SDK for DApps (MetaMask, Coinbase, TronLink, EIP-6963, contract reads).
+
+## Install
+
+```bash
+pnpm add @earthworm/wallet-sdk ethers
+```
+
+## Usage
+
+```ts
+import { initWalletSdk, getWalletSdkConfig, walletEvents } from "@earthworm/wallet-sdk";
+
+initWalletSdk({
+  isMainnet: true,
+  contract: { address: "0x...", abi: [] },
+});
+
+walletEvents.on("accountsChanged", (accounts) => {
+  console.log(accounts);
+});
+```
+
+## Develop
+
+```bash
+pnpm install
+pnpm run build
+```
+
+## Publish
+
+```bash
+pnpm publish
+```

package/dist/index.d.ts

@@ -0,0 +1,328 @@
+import * as ethers from 'ethers';
+import { InterfaceAbi, Eip1193Provider, BrowserProvider, JsonRpcProvider, JsonRpcSigner } from 'ethers';
+
+/**
+ * 将 EVM 十六进制 chainId（如 0x61）转换为十进制 chainId（如 97）。
+ * 钱包 `chainChanged` / `eth_chainId` 返回的通常是 0x 前缀 hex 字符串。
+ */
+declare function toChainIdDecimal(chainId: string, fallback?: number): number;
+
+type EthereumEvent = "accountsChanged" | "chainChanged" | "connect" | "disconnect" | string;
+type EthereumListener = (...args: unknown[]) => void;
+type WalletEventProvider = Eip1193Provider & {
+    on(event: EthereumEvent, listener: EthereumListener): void;
+    removeListener(event: EthereumEvent, listener: EthereumListener): void;
+    removeAllListeners?(event?: EthereumEvent): void;
+};
+type InjectedEthereumProvider = WalletEventProvider & {
+    isMetaMask?: boolean;
+    isCoinbaseWallet?: boolean;
+    isTronLink?: boolean;
+    isTronLinkWallet?: boolean;
+    providers?: InjectedEthereumProvider[];
+    providerMap?: Map<string, InjectedEthereumProvider> | Record<string, InjectedEthereumProvider>;
+};
+type EvmReadProvider = BrowserProvider | JsonRpcProvider;
+type MutableRef<T> = {
+    value: T;
+};
+type EthereumRequestParams = unknown[] | Record<string, unknown>;
+type ChainConfig = {
+    chainId: string;
+    chainName: string;
+    nativeCurrencyName: string;
+    nativeCurrencySymbol: string;
+    nativeCurrencyDecimals: string | number;
+    rpcUrl: string;
+    blockExplorerUrl: string;
+};
+type Eip6963ProviderInfo = {
+    uuid: string;
+    name: string;
+    icon: string;
+    rdns: string;
+};
+type Eip6963ProviderDetail = {
+    info: Eip6963ProviderInfo;
+    provider: Eip1193Provider;
+};
+type ContractConfig = {
+    address: string;
+    abi: InterfaceAbi;
+};
+type WalletSdkInitOptions = {
+    /** `true` BSC 主网，`false` BSC 测试网 */
+    isMainnet: boolean;
+    contract: ContractConfig;
+};
+type WalletSdkConfig = {
+    isMainnet: boolean;
+    chainId: string;
+    chain: ChainConfig;
+    contract: ContractConfig;
+    usdt: {
+        address: string;
+        abi: InterfaceAbi;
+        symbol: string;
+        name: string;
+        decimals: number;
+    };
+};
+
+declare function discoverWalletProviders(timeoutMs?: number): Promise<Eip6963ProviderDetail[]>;
+declare function findDiscoveredProvider(match: (detail: Eip6963ProviderDetail) => boolean): ethers.Eip1193Provider | undefined;
+declare function findMetaMaskEip6963Provider(): ethers.Eip1193Provider | undefined;
+declare function findCoinbaseEip6963Provider(): ethers.Eip1193Provider | undefined;
+declare function hasMetaMaskEip6963Provider(): boolean;
+declare function hasCoinbaseEip6963Provider(): boolean;
+
+declare function getSharedBrowserProvider(ethereum: Eip1193Provider): BrowserProvider;
+
+declare function getInjectedEthereumProviders(): InjectedEthereumProvider[];
+declare function resolveMetaMaskInjectedProvider(): WalletEventProvider | undefined;
+declare function resolveCoinbaseInjectedProvider(): WalletEventProvider | undefined;
+declare function hasMetaMaskInjectedProvider(): boolean;
+declare function hasCoinbaseInjectedProvider(): boolean;
+declare function rememberAggregatorProvider(): void;
+declare function hasRecoverableAggregatorProvider(): boolean;
+declare function getAggregatedInjectedProvider(): WalletEventProvider | undefined;
+declare function hasAggregatedInjectedProvider(): boolean;
+
+declare const ERC20_DECIMALS_ABI: readonly ["function decimals() view returns (uint8)"];
+/** 检查地址在链上是否已部署合约（有 bytecode 才算合约地址） */
+declare function hasDeployedContract(readProvider: EvmReadProvider, address: string): Promise<boolean>;
+/** 读取 ERC20 代币 decimals；合约未部署直接报错，调用失败时返回 fallback */
+declare function readErc20Decimals(readProvider: EvmReadProvider, tokenAddress: string, erc20Abi?: InterfaceAbi, fallback?: 18): Promise<number>;
+
+type GetContractReadOptions = {
+    abi: InterfaceAbi;
+    method: string;
+};
+/** 设置钱包 BrowserProvider，链上读取优先走钱包 */
+declare function setWalletReadProvider(provider: BrowserProvider | null): void;
+declare function getConfiguredReadProvider(): EvmReadProvider;
+/** 检查合约是否已部署 */
+declare function isContractDeployed(contractAddress: string): Promise<boolean>;
+/** 读取合约 decimals */
+declare function getContractDecimals(contractAddress: string, options: GetContractReadOptions): Promise<number>;
+/** 读取合约价格 */
+declare function getContractPrice(contractAddress: string, options: GetContractReadOptions): Promise<string>;
+
+declare function buildEthereumChainParams(config: ChainConfig): {
+    chainId: string;
+    chainName: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls: string[];
+};
+/** 确保钱包切换到目标网络（不存在时自动 addEthereumChain） */
+declare function ensureTargetNetwork(options: {
+    targetChainId: string;
+    getCurrentChainId: () => Promise<string>;
+    switchChain: (chainId: string) => Promise<unknown>;
+    addChain: (chainParams: Record<string, unknown>) => Promise<unknown>;
+    chainParams: Record<string, unknown>;
+}): Promise<void>;
+
+declare function createJsonRpcReadProvider(rpcUrl: string, chainIdHex: string, cache?: {
+    current: JsonRpcProvider | null;
+}): JsonRpcProvider;
+/** 优先使用钱包 BrowserProvider，否则回退到 JsonRpcProvider */
+declare function getReadProviderWithFallback(walletProvider: BrowserProvider | null, rpcConfig: {
+    rpcUrl: string;
+    chainId: string;
+}, fallbackCache?: {
+    current: JsonRpcProvider | null;
+}): EvmReadProvider;
+
+declare function bindBrowserProvider(eip1193: WalletEventProvider, cache: MutableRef<BrowserProvider | null>): BrowserProvider;
+declare function requestWallet(eip1193: WalletEventProvider, method: string, params?: EthereumRequestParams): Promise<any>;
+declare function connectWalletAccount(requestAccounts: () => Promise<unknown>, getProvider: () => BrowserProvider, setSigner: (signer: JsonRpcSigner) => void, markConnected: () => void): Promise<{
+    address: string;
+    signer: JsonRpcSigner;
+}>;
+declare function syncWalletAccountAddress(getProvider: () => BrowserProvider, setSigner: (signer: JsonRpcSigner) => void, markConnected: () => void, nextAddress?: string): Promise<{
+    address: string;
+    signer: JsonRpcSigner;
+}>;
+declare function clearWalletRuntime(cache: {
+    provider: MutableRef<BrowserProvider | null>;
+    signer: MutableRef<JsonRpcSigner | null>;
+    selectedProvider?: MutableRef<WalletEventProvider | null>;
+}): void;
+
+type WalletProviderEventMap = {
+    accountsChanged: string[];
+    chainChanged: string;
+};
+type WalletProviderEventName = keyof WalletProviderEventMap;
+type WalletProviderEventListener<K extends WalletProviderEventName = WalletProviderEventName> = (payload: WalletProviderEventMap[K]) => void | Promise<void>;
+/** 设置当前钱包 EIP-1193 provider，供事件监听使用 */
+declare function setWalletEventProvider(provider: WalletEventProvider | null): void;
+declare function getWalletEventProvider(): WalletEventProvider;
+declare class WalletEventsEmitter {
+    on(event: "accountsChanged", listener: WalletProviderEventListener<"accountsChanged">): void;
+    on(event: "chainChanged", listener: WalletProviderEventListener<"chainChanged">): void;
+    on(event: WalletProviderEventName, listener: (...args: any[]) => void | Promise<void>): void;
+    off(event: "accountsChanged", listener: WalletProviderEventListener<"accountsChanged">): void;
+    off(event: "chainChanged", listener: WalletProviderEventListener<"chainChanged">): void;
+    off(event: WalletProviderEventName, listener?: (...args: any[]) => void | Promise<void>): void;
+    clear(): void;
+}
+type WalletEvents = WalletEventsEmitter;
+declare const walletEvents: WalletEventsEmitter;
+
+/** 是否在浏览器环境（模块加载时判定一次） */
+declare const isBrowser: boolean;
+/** 仅浏览器可用的操作入口；检测类 API 请用 isBrowser 后 return false */
+declare function assertBrowser(apiName: string): void;
+
+/** 是否检测到 MetaMask */
+declare function isEthereumProvider(): boolean;
+/** 是否检测到 Coinbase Wallet */
+declare function isCoinbaseProvider(): boolean;
+/** 是否检测到通用 Injected 钱包 */
+declare function isInjectedProvider(): boolean;
+/** 是否检测到 TronLink */
+declare function isTronLinkProvider(): boolean;
+
+/** 初始化并持久化配置，任意模块均可通过 getWalletSdkConfig 读取 */
+declare function initWalletSdk(options: WalletSdkInitOptions): WalletSdkConfig;
+declare function getWalletSdkConfig(): WalletSdkConfig;
+declare function isWalletSdkInitialized(): boolean;
+declare function resetWalletSdkConfig(): void;
+
+declare const BSC_NETWORK: {
+    chainId: string;
+    chainName: string;
+    nativeCurrencyName: string;
+    nativeCurrencySymbol: string;
+    nativeCurrencyDecimals: string;
+    rpcUrl: string;
+    blockExplorerUrl: string;
+};
+declare const BSC_TESTNET_NETWORK: {
+    chainId: string;
+    chainName: string;
+    nativeCurrencyName: string;
+    nativeCurrencySymbol: string;
+    nativeCurrencyDecimals: string;
+    rpcUrl: string;
+    blockExplorerUrl: string;
+};
+declare function getDefaultBscConfig(isProd?: boolean): {
+    chainId: string;
+    chainName: string;
+    nativeCurrencyName: string;
+    nativeCurrencySymbol: string;
+    nativeCurrencyDecimals: string;
+    rpcUrl: string;
+    blockExplorerUrl: string;
+};
+
+/** BSC USDT 合约地址 */
+declare const USDT_CONTRACT_ADDRESSES: {
+    readonly [BSC_NETWORK.chainId]: "0x55d398326f99059fF775485246999027B3197955";
+    readonly [BSC_TESTNET_NETWORK.chainId]: "0x66E972502A34A625828C544a1914E8D8cc2A9dE5";
+};
+declare function resolveUsdtContractAddress(chainId: string): "0x55d398326f99059fF775485246999027B3197955" | "0x66E972502A34A625828C544a1914E8D8cc2A9dE5";
+declare function resolveChainByMainnet(isMainnet: boolean): ChainConfig;
+declare function resolveUsdtByMainnet(isMainnet: boolean): "0x55d398326f99059fF775485246999027B3197955" | "0x66E972502A34A625828C544a1914E8D8cc2A9dE5";
+declare function resolveChainConfig(chainId: string): ChainConfig;
+
+declare const USDT_CONFIG: {
+    readonly symbol: "USDT";
+    readonly name: "Tether USD";
+    readonly decimals: 18;
+    readonly contractAbi: ({
+        constant: boolean;
+        inputs: {
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            name: string;
+            type: string;
+        }[];
+        payable: boolean;
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    } | {
+        inputs: {
+            name: string;
+            type: string;
+        }[];
+        payable: boolean;
+        stateMutability: string;
+        type: string;
+        constant?: undefined;
+        name?: undefined;
+        outputs?: undefined;
+        anonymous?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        constant?: undefined;
+        outputs?: undefined;
+        payable?: undefined;
+        stateMutability?: undefined;
+    })[];
+};
+/** BSC 上 ERC20 代币统一 decimals（如 USDT 为 18） */
+declare const ERC20_DECIMALS: 18;
+
+declare const ERC20_ABI: ({
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    constant?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+})[];
+
+export { BSC_NETWORK, BSC_TESTNET_NETWORK, type ChainConfig, type ContractConfig, ERC20_ABI, ERC20_DECIMALS, ERC20_DECIMALS_ABI, type Eip6963ProviderDetail, type Eip6963ProviderInfo, type EthereumRequestParams, type EvmReadProvider, type GetContractReadOptions, type InjectedEthereumProvider, type MutableRef, USDT_CONFIG, USDT_CONTRACT_ADDRESSES, type WalletEventProvider, type WalletEvents, type WalletProviderEventListener, type WalletProviderEventMap, type WalletProviderEventName, type WalletSdkConfig, type WalletSdkInitOptions, assertBrowser, bindBrowserProvider, buildEthereumChainParams, clearWalletRuntime, connectWalletAccount, createJsonRpcReadProvider, discoverWalletProviders, ensureTargetNetwork, findCoinbaseEip6963Provider, findDiscoveredProvider, findMetaMaskEip6963Provider, getAggregatedInjectedProvider, getConfiguredReadProvider, getContractDecimals, getContractPrice, getDefaultBscConfig, getInjectedEthereumProviders, getReadProviderWithFallback, getSharedBrowserProvider, getWalletEventProvider, getWalletSdkConfig, hasAggregatedInjectedProvider, hasCoinbaseEip6963Provider, hasCoinbaseInjectedProvider, hasDeployedContract, hasMetaMaskEip6963Provider, hasMetaMaskInjectedProvider, hasRecoverableAggregatorProvider, initWalletSdk, isBrowser, isCoinbaseProvider, isContractDeployed, isEthereumProvider, isInjectedProvider, isTronLinkProvider, isWalletSdkInitialized, readErc20Decimals, rememberAggregatorProvider, requestWallet, resetWalletSdkConfig, resolveChainByMainnet, resolveChainConfig, resolveCoinbaseInjectedProvider, resolveMetaMaskInjectedProvider, resolveUsdtByMainnet, resolveUsdtContractAddress, setWalletEventProvider, setWalletReadProvider, syncWalletAccountAddress, toChainIdDecimal, walletEvents };

package/dist/index.js

@@ -0,0 +1,887 @@
+import { BrowserProvider, Contract, JsonRpcProvider, formatUnits } from 'ethers';
+
+// src/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/env.ts
+var isBrowser = typeof window !== "undefined";
+function assertBrowser(apiName) {
+  if (!isBrowser) {
+    throw new Error(`[wallet-sdk] ${apiName} is only available in the browser`);
+  }
+}
+
+// src/eip6963.ts
+var METAMASK_RDNS = "io.metamask";
+var COINBASE_RDNS = "com.coinbase.wallet";
+var discoveredProviders = [];
+var discoveryPromise = null;
+function discoverWalletProviders(timeoutMs = 500) {
+  if (!isBrowser) {
+    return Promise.resolve([]);
+  }
+  if (discoveryPromise) {
+    return discoveryPromise;
+  }
+  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);
+    };
+    window.addEventListener("eip6963:announceProvider", onAnnounce);
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+    window.setTimeout(() => {
+      window.removeEventListener("eip6963:announceProvider", onAnnounce);
+      discoveredProviders = providers;
+      resolve(providers);
+    }, timeoutMs);
+  });
+  return discoveryPromise;
+}
+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 hasMetaMaskEip6963Provider() {
+  return Boolean(findMetaMaskEip6963Provider());
+}
+function hasCoinbaseEip6963Provider() {
+  return Boolean(findCoinbaseEip6963Provider());
+}
+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;
+}
+
+// src/injected-providers.ts
+var isRequestableProvider = (provider) => {
+  return Boolean(provider && typeof provider.request === "function");
+};
+function getInjectedEthereumProviders() {
+  const ethereum = window.ethereum;
+  if (!ethereum) return [];
+  if (Array.isArray(ethereum.providers) && ethereum.providers.length > 0) {
+    return ethereum.providers.filter(isRequestableProvider);
+  }
+  return isRequestableProvider(ethereum) ? [ethereum] : [];
+}
+var isMetaMaskLikeProvider = (provider) => {
+  return Boolean(
+    provider.isMetaMask && !provider.isCoinbaseWallet && !provider.isTronLink && !provider.isTronLinkWallet
+  );
+};
+var isCoinbaseLikeProvider = (provider) => {
+  return Boolean(provider.isCoinbaseWallet && !provider.isTronLink && !provider.isTronLinkWallet);
+};
+var isTronLinkLikeProvider = (provider) => {
+  return Boolean(provider.isTronLink || provider.isTronLinkWallet);
+};
+function getMetaMaskFromProviderMap(ethereum) {
+  const providerMap = ethereum.providerMap;
+  if (!providerMap) return void 0;
+  if (providerMap instanceof Map) {
+    const metamask2 = providerMap.get("MetaMask") || providerMap.get("metamask");
+    return metamask2 && isMetaMaskLikeProvider(metamask2) ? metamask2 : void 0;
+  }
+  const metamask = providerMap.MetaMask || providerMap.metamask;
+  return metamask && isMetaMaskLikeProvider(metamask) ? metamask : void 0;
+}
+function getCoinbaseFromProviderMap(ethereum) {
+  const providerMap = ethereum.providerMap;
+  if (!providerMap) return void 0;
+  if (providerMap instanceof Map) {
+    const coinbase2 = providerMap.get("Coinbase Wallet") || providerMap.get("CoinbaseWallet");
+    return coinbase2 && isCoinbaseLikeProvider(coinbase2) ? coinbase2 : void 0;
+  }
+  const coinbase = providerMap["Coinbase Wallet"] || providerMap.CoinbaseWallet;
+  return coinbase && isCoinbaseLikeProvider(coinbase) ? coinbase : void 0;
+}
+function resolveMetaMaskInjectedProvider() {
+  const fromEip6963 = findMetaMaskEip6963Provider();
+  if (fromEip6963 && isRequestableProvider(fromEip6963)) {
+    return fromEip6963;
+  }
+  const ethereum = window.ethereum;
+  const fromMap = ethereum ? getMetaMaskFromProviderMap(ethereum) : void 0;
+  if (fromMap) {
+    return fromMap;
+  }
+  const fromProviders = getInjectedEthereumProviders().find(isMetaMaskLikeProvider);
+  if (fromProviders) {
+    return fromProviders;
+  }
+  if (ethereum && isMetaMaskLikeProvider(ethereum)) {
+    return ethereum;
+  }
+  return void 0;
+}
+function resolveCoinbaseInjectedProvider() {
+  if (isRequestableProvider(window.coinbaseWalletExtension)) {
+    return window.coinbaseWalletExtension;
+  }
+  if (isRequestableProvider(window.coinbaseWalletRequestProvider)) {
+    return window.coinbaseWalletRequestProvider;
+  }
+  const fromEip6963 = findCoinbaseEip6963Provider();
+  if (fromEip6963 && isRequestableProvider(fromEip6963)) {
+    return fromEip6963;
+  }
+  const ethereum = window.ethereum;
+  const fromMap = ethereum ? getCoinbaseFromProviderMap(ethereum) : void 0;
+  if (fromMap) {
+    return fromMap;
+  }
+  const fromProviders = getInjectedEthereumProviders().find(isCoinbaseLikeProvider);
+  if (fromProviders) {
+    return fromProviders;
+  }
+  if (ethereum && isCoinbaseLikeProvider(ethereum)) {
+    return ethereum;
+  }
+  return void 0;
+}
+function hasMetaMaskInjectedProvider() {
+  return Boolean(resolveMetaMaskInjectedProvider());
+}
+function hasCoinbaseInjectedProvider() {
+  return Boolean(
+    window.coinbaseWalletExtension || window.coinbaseWalletRequestProvider || window.coinbaseSolana || resolveCoinbaseInjectedProvider()
+  );
+}
+var cachedAggregatorProvider;
+var cachedAggregatorProviderCount = 0;
+var isMultiWalletAggregator = (provider) => {
+  return Array.isArray(provider.providers) && provider.providers.length > 1;
+};
+var collectAggregatorCandidates = () => {
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  const add = (provider) => {
+    if (!provider || seen.has(provider) || !isRequestableProvider(provider)) return;
+    seen.add(provider);
+    candidates.push(provider);
+  };
+  add(window.ethereum);
+  add(window.coinbaseWalletExtension);
+  add(window.coinbaseWalletRequestProvider);
+  add(cachedAggregatorProvider);
+  return candidates;
+};
+var findLiveMultiWalletRoot = () => {
+  return collectAggregatorCandidates().find(isMultiWalletAggregator);
+};
+function rememberAggregatorProvider() {
+  if (!isBrowser) return;
+  const live = findLiveMultiWalletRoot();
+  if (!live) return;
+  const count = live.providers?.length ?? 0;
+  if (!cachedAggregatorProvider || count >= cachedAggregatorProviderCount) {
+    cachedAggregatorProvider = live;
+    cachedAggregatorProviderCount = count;
+  }
+}
+function hasRecoverableAggregatorProvider() {
+  return Boolean(findLiveMultiWalletRoot() || cachedAggregatorProviderCount > 1);
+}
+function getAggregatedInjectedProvider() {
+  const live = findLiveMultiWalletRoot();
+  if (live) {
+    rememberAggregatorProvider();
+    return live;
+  }
+  if (cachedAggregatorProvider && cachedAggregatorProviderCount > 1) {
+    return cachedAggregatorProvider;
+  }
+  const ethereum = window.ethereum;
+  if (ethereum && isTronLinkLikeProvider(ethereum) && !isMultiWalletAggregator(ethereum)) {
+    const coinbaseRequest = window.coinbaseWalletRequestProvider ?? window.coinbaseWalletExtension;
+    if (isRequestableProvider(coinbaseRequest)) {
+      return coinbaseRequest;
+    }
+    return cachedAggregatorProvider ?? ethereum;
+  }
+  return ethereum;
+}
+function hasAggregatedInjectedProvider() {
+  if (!isBrowser) return false;
+  if (getAggregatedInjectedProvider()) return true;
+  if (hasRecoverableAggregatorProvider()) return true;
+  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",
+  nativeCurrencyName: "BNB",
+  nativeCurrencySymbol: "BNB",
+  nativeCurrencyDecimals: "18",
+  rpcUrl: "https://bsc-dataseed.binance.org/",
+  blockExplorerUrl: "https://bscscan.com"
+};
+var BSC_TESTNET_NETWORK = {
+  chainId: "0x61",
+  chainName: "BNB Smart Chain Testnet",
+  nativeCurrencyName: "tBNB",
+  nativeCurrencySymbol: "tBNB",
+  nativeCurrencyDecimals: "18",
+  rpcUrl: "https://data-seed-prebsc-1-s1.bnbchain.org:8545/",
+  blockExplorerUrl: "https://testnet.bscscan.com"
+};
+function getDefaultBscConfig(isProd = typeof process !== "undefined" && process.env.NODE_ENV === "production") {
+  return isProd ? BSC_NETWORK : BSC_TESTNET_NETWORK;
+}
+
+// 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/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/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;
+  if (!rpcConfig.rpcUrl || !rpcConfig.chainId) {
+    throw new Error("RPC config is missing");
+  }
+  return createJsonRpcReadProvider(rpcConfig.rpcUrl, rpcConfig.chainId, fallbackCache);
+}
+
+// src/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/network.ts
+function buildEthereumChainParams(config) {
+  return {
+    chainId: config.chainId,
+    chainName: config.chainName,
+    nativeCurrency: {
+      name: config.nativeCurrencyName,
+      symbol: config.nativeCurrencySymbol,
+      decimals: Number(config.nativeCurrencyDecimals) || 18
+    },
+    rpcUrls: [config.rpcUrl],
+    blockExplorerUrls: [config.blockExplorerUrl]
+  };
+}
+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;
+  return hasMetaMaskInjectedProvider() || hasMetaMaskEip6963Provider();
+}
+function isCoinbaseProvider() {
+  if (!isBrowser) return false;
+  return hasCoinbaseInjectedProvider();
+}
+function isInjectedProvider() {
+  if (!isBrowser) return false;
+  return hasAggregatedInjectedProvider();
+}
+function isTronLinkProvider() {
+  if (!isBrowser) return false;
+  return Boolean(window.tron?.request || window.tronLink);
+}
+
+export { BSC_NETWORK, BSC_TESTNET_NETWORK, ERC20_ABI, ERC20_DECIMALS, ERC20_DECIMALS_ABI, USDT_CONFIG, USDT_CONTRACT_ADDRESSES, assertBrowser, bindBrowserProvider, buildEthereumChainParams, clearWalletRuntime, connectWalletAccount, createJsonRpcReadProvider, discoverWalletProviders, ensureTargetNetwork, findCoinbaseEip6963Provider, findDiscoveredProvider, findMetaMaskEip6963Provider, getAggregatedInjectedProvider, getConfiguredReadProvider, getContractDecimals, getContractPrice, getDefaultBscConfig, getInjectedEthereumProviders, getReadProviderWithFallback, getSharedBrowserProvider, getWalletEventProvider, getWalletSdkConfig, hasAggregatedInjectedProvider, hasCoinbaseEip6963Provider, hasCoinbaseInjectedProvider, hasDeployedContract, hasMetaMaskEip6963Provider, hasMetaMaskInjectedProvider, hasRecoverableAggregatorProvider, initWalletSdk, isBrowser, isCoinbaseProvider, isContractDeployed, isEthereumProvider, isInjectedProvider, isTronLinkProvider, isWalletSdkInitialized, readErc20Decimals, rememberAggregatorProvider, requestWallet, resetWalletSdkConfig, resolveChainByMainnet, resolveChainConfig, resolveCoinbaseInjectedProvider, resolveMetaMaskInjectedProvider, resolveUsdtByMainnet, resolveUsdtContractAddress, setWalletEventProvider, setWalletReadProvider, syncWalletAccountAddress, toChainIdDecimal, walletEvents };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@earthworm/wallet-sdk",
+  "version": "0.1.0",
+  "description": "EVM wallet utilities for browser DApps",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "ethereum",
+    "wallet",
+    "eip6963",
+    "ethers",
+    "dapp"
+  ],
+  "license": "MIT",
+  "author": "Alex",
+  "peerDependencies": {
+    "ethers": "^6.0.0"
+  },
+  "devDependencies": {
+    "ethers": "^6.17.0",
+    "tsup": "^8.4.0",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}