@earthworm/wallet-sdk 0.2.5 → 0.2.7

package/README.md

@@ -8,17 +8,17 @@ Browser EVM wallet SDK for DApps (MetaMask, Coinbase, TronLink, TokenPocket, con
 pnpm add @earthworm/wallet-sdk ethers
 ```
 
-## Usage
+## Quick start
 
 ```ts
 import {
   initWalletSdk,
-  getWalletSdkConfig,
+  connectWallet,
+  disconnectWallet,
+  isWalletConnected,
   walletEvents,
-  setWalletEventProvider,
-  switchToConfiguredNetwork,
-  requestWallet,
   resolveMetaMaskInjectedProvider,
+  switchToConfiguredNetwork,
   isEthereumProvider,
   isCoinbaseProvider,
   isTokenPocketProvider,
@@ -29,46 +29,141 @@ initWalletSdk({
   usdt: { address: "0x55d398326f99059fF775485246999027B3197955" },
 });
 
-// Optional: switch chain after connect
+const provider = resolveMetaMaskInjectedProvider();
+if (!provider) throw new Error("MetaMask not found");
+
 await connectWallet(provider, { chainId: "0x38" });
+console.log("Connected:", isWalletConnected());
 
-// Detect installed wallets
-if (isEthereumProvider()) {
-  console.log("MetaMask is available");
-}
+await disconnectWallet();
+```
 
-if (isCoinbaseProvider()) {
-  console.log("Coinbase Wallet is available");
-}
+`connectWallet()` binds the provider and registers event listeners internally. You do not need to call `setWalletEventProvider()` separately after connect.
 
-if (isTokenPocketProvider()) {
-  console.log("TokenPocket is available");
-}
+## Restore session on page load
+
+Some mobile wallets (e.g. TokenPocket App) **reload the page** when the user switches address. After reload, in-memory SDK state is lost even though the wallet still has an authorized session.
+
+Call `restoreWalletConnection()` during initialization. It uses `eth_accounts` (no authorization popup). If authorized accounts exist, it binds the provider, restores the signer, and optionally switches chain — same as `connectWallet()` but without `eth_requestAccounts`.
+
+```ts
+import {
+  initWalletSdk,
+  restoreWalletConnection,
+  isWalletConnected,
+  resolveTokenPocketInjectedProvider,
+} from "@earthworm/wallet-sdk";
 
-if (isTronLinkProvider()) {
-  console.log("TronLink is available");
+initWalletSdk({
+  usdt: { address: "0x55d398326f99059fF775485246999027B3197955" },
+});
+
+const provider = resolveTokenPocketInjectedProvider();
+if (provider) {
+  const session = await restoreWalletConnection(provider, { chainId: "0x38" });
+  if (session) {
+    console.log("Session restored:", session.address);
+  }
 }
 
-const provider = resolveMetaMaskInjectedProvider();
-setWalletEventProvider(provider ?? null);
+console.log("Connected:", isWalletConnected());
+```
+
+| API                         | RPC                   | Popup      | Use when                                        |
+| --------------------------- | --------------------- | ---------- | ----------------------------------------------- |
+| `connectWallet()`           | `eth_requestAccounts` | May prompt | User clicks Connect                             |
+| `restoreWalletConnection()` | `eth_accounts`        | No         | Page load / refresh with existing authorization |
+
+Returns `null` when no authorized accounts are found. Event listeners are registered the same way as `connectWallet()`.
+
+**Tip:** Persist which wallet the user selected (e.g. `localStorage`) so after reload you know which `resolve*InjectedProvider()` to pass in.
+
+## Wallet detection
+
+```ts
+if (isEthereumProvider()) console.log("MetaMask is available");
+if (isCoinbaseProvider()) console.log("Coinbase Wallet is available");
+if (isTokenPocketProvider()) console.log("TokenPocket is available");
+if (isTronLinkProvider()) console.log("TronLink is available");
+```
 
+## Events
+
+All `walletEvents.on(...)` listeners receive `(wallet, event)`:
+
+- `wallet`: `"metamask" | "coinbase" | "tokenpocket" | "tronlink" | "unknown"`
+- `event.name`: native wallet event name (e.g. `"accountsChanged"`, `"setAccount"`, `"disconnectWeb"`)
+- `event.payload`: normalized SDK payload for that event
+- `event.raw`: raw provider / postMessage arguments
+
+```ts
 walletEvents.on("accountsChanged", (wallet, event) => {
-  console.log(wallet, event.payload); // account addresses
+  console.log(wallet, event.name, event.payload); // string[] — current account address(es)
 });
 
 walletEvents.on("chainChanged", (wallet, event) => {
-  console.log("Network changed:", wallet, event.payload); // hex chainId, e.g. "0x38"
+  console.log(wallet, event.payload); // hex chainId, e.g. "0x38"
 });
 
 walletEvents.on("networkSwitched", (wallet, event) => {
   console.log(wallet, event.payload); // { chainId, previousChainId, switched }
 });
 
-async function switchWalletToBscMainnet() {
-  const provider = resolveMetaMaskInjectedProvider();
-  if (!provider) return;
+walletEvents.on("walletDisconnected", (wallet, event) => {
+  console.log(wallet, event.payload); // { source: "app" | "provider" }
+});
+```
 
-  setWalletEventProvider(provider);
-  await switchToConfiguredNetwork("0x38");
-}
+### Event summary
+
+| Event                | When it fires                                                                  |
+| -------------------- | ------------------------------------------------------------------------------ |
+| `accountsChanged`    | Active account updated (switch account, reconnect after TronLink revoke, etc.) |
+| `chainChanged`       | Wallet network changed                                                         |
+| `networkSwitched`    | SDK invoked `switchToConfiguredNetwork()`                                      |
+| `walletDisconnected` | Wallet or DApp disconnected                                                    |
+
+### `walletDisconnected`
+
+| Source               | Trigger                            |
+| -------------------- | ---------------------------------- |
+| `source: "app"`      | DApp called `disconnectWallet()`   |
+| `source: "provider"` | Wallet revoked the site connection |
+
+**MetaMask**
+
+- Site revoked in the extension → empty `accountsChanged` → `walletDisconnected`
+
+**TronLink / TokenPocket / Coinbase**
+
+On disconnect-like events (empty `accountsChanged`, `disconnect`, etc.), the SDK silently calls `eth_accounts`:
+
+- **Still has authorized addresses** → sync active account → `accountsChanged` (no disconnect)
+- **No authorized addresses** → clear connection state → `walletDisconnected`
+
+This supports:
+
+1. Single address connected, then revoked → `walletDisconnected`
+2. Multiple addresses, one revoked but others remain → `accountsChanged` with remaining address
+3. After revoke, switch to another already-connected address → `accountsChanged`
+
+When TronLink, TokenPocket, or Coinbase disconnects via provider, the SDK keeps the provider bound so a later account switch can still emit `accountsChanged`. Calling `disconnectWallet()` from the DApp performs a full disconnect.
+
+### App-initiated disconnect
+
+`disconnectWallet()` clears local state and, by default, calls `wallet_revokePermissions` so MetaMask / Coinbase remove the site from connected dApps. TronLink does not support DApp-side revoke; local state is cleared only.
+
+```ts
+const { revoked } = await disconnectWallet();
+console.log(revoked ? "Wallet permission revoked" : "Local disconnect only");
+```
+
+Pass `{ revokePermissions: false }` to skip the wallet revoke request.
+
+## Switch network
+
+```ts
+import { switchToConfiguredNetwork } from "@earthworm/wallet-sdk";
+
+await switchToConfiguredNetwork("0x38"); // BSC mainnet
 ```

package/dist/account-sync-IFXUYW65.js

@@ -0,0 +1,2 @@
+export { applyTronLinkAccountResolution, applyVerifiedAccountResolution, applyWalletAccountsChangedEffect, applyWalletDisconnectEffect } from './chunk-54NIXGDN.js';
+import './chunk-X6TWVXK3.js';

package/dist/chunk-54NIXGDN.js

@@ -0,0 +1,60 @@
+import { getSelectedWalletProvider, isWalletConnected, disconnectWallet, ensureWalletRuntimeProviderBound, syncConnectedWalletAccount, getWalletAccounts } from './chunk-X6TWVXK3.js';
+
+// src/wallet/account-sync.ts
+async function syncWalletAccount(address) {
+  if (!ensureWalletRuntimeProviderBound()) {
+    return { action: "ignored" };
+  }
+  try {
+    const result = await syncConnectedWalletAccount(address);
+    return { action: "synced", address: result.address };
+  } catch {
+    return { action: "ignored" };
+  }
+}
+async function fetchAuthorizedAccounts() {
+  if (!getSelectedWalletProvider()) {
+    return [];
+  }
+  try {
+    return await getWalletAccounts();
+  } catch {
+    return [];
+  }
+}
+async function applyVerifiedAccountResolution(accounts) {
+  if (!getSelectedWalletProvider()) {
+    return { action: "ignored" };
+  }
+  if (accounts.length > 0) {
+    const synced = await syncWalletAccount(accounts[0]);
+    if (synced.action === "synced") {
+      return synced;
+    }
+  }
+  const authorizedAccounts = await fetchAuthorizedAccounts();
+  if (authorizedAccounts.length > 0) {
+    return syncWalletAccount(authorizedAccounts[0]);
+  }
+  if (!isWalletConnected()) {
+    return { action: "ignored" };
+  }
+  await disconnectWallet({ silent: true, preserveProvider: true, revokePermissions: false });
+  return { action: "disconnected" };
+}
+async function applyWalletAccountsChangedEffect(wallet, accounts) {
+  if (!accounts.length) {
+    return { action: "ignored" };
+  }
+  return syncWalletAccount(accounts[0]);
+}
+async function applyWalletDisconnectEffect() {
+  if (!isWalletConnected()) {
+    return { action: "ignored" };
+  }
+  await disconnectWallet({ silent: true, revokePermissions: false });
+  return { action: "disconnected" };
+}
+var applyTronLinkAccountResolution = applyVerifiedAccountResolution;
+
+export { applyTronLinkAccountResolution, applyVerifiedAccountResolution, applyWalletAccountsChangedEffect, applyWalletDisconnectEffect };

package/dist/{chunk-XTONTXHH.js → chunk-5CET43HT.js}

@@ -1,4 +1,4 @@
-import { getWalletEventProvider, resolveChainConfig, requestWallet, syncWalletRuntimeProvider, emitWalletEvent, getActiveWalletKey } from './chunk-F7UNIZSN.js';
+import { getWalletEventProvider, resolveChainConfig, requestWallet, syncWalletRuntimeProvider, emitWalletEvent, getActiveWalletKey } from './chunk-X6TWVXK3.js';
 
 // src/core/network.ts
 async function ensureTargetNetwork(options) {

package/dist/{chunk-F7UNIZSN.js → chunk-X6TWVXK3.js}

@@ -1,33 +1,6 @@
-import { BrowserProvider, Contract, formatUnits, JsonRpcProvider } from 'ethers';
+import { Contract, formatUnits, JsonRpcProvider, BrowserProvider } 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/core/contract-read.ts
 
 // src/abi/erc20.ts
 var ERC20_ABI = [
@@ -428,6 +401,16 @@ async function readErc20Balance(readProvider, tokenAddress, accountAddress, erc2
     decimals
   };
 }
+
+// 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/core/read-provider.ts
 var jsonRpcReadProviderCache = { current: null };
 function clearJsonRpcReadProviderCache() {
   jsonRpcReadProviderCache.current = null;
@@ -504,6 +487,21 @@ function resetWalletSdkConfig() {
   delete globalState[INITIALIZED_KEY];
   clearJsonRpcReadProviderCache();
 }
+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/core/contract-read.ts
 var walletReadProvider = null;
 function setWalletReadProvider(provider) {
   walletReadProvider = provider;
@@ -598,6 +596,14 @@ function clearWalletRuntime(cache) {
   }
 }
 
+// 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`);
+  }
+}
+
 // src/wallet/resolve-wallet-key.ts
 function resolveWalletKey(provider) {
   if (!provider) {
@@ -671,6 +677,12 @@ function parseTronLinkChainChanged(args) {
     raw: args
   };
 }
+function normalizeTronLinkLegacyAccountData(data) {
+  if (data && typeof data === "object" && "address" in data) {
+    return normalizeAccountList(data.address);
+  }
+  return normalizeAccountList(data);
+}
 function parseTronLinkLegacyMessage(data) {
   const message = data?.message;
   if (!message?.action) {
@@ -684,16 +696,16 @@ function parseTronLinkLegacyMessage(data) {
     };
   }
   if (message.action === "accountsChanged") {
-    const payload = normalizeAccountList(message.data);
+    const payload = normalizeTronLinkLegacyAccountData(message.data);
     return {
       name: "accountsChanged",
       payload,
       raw: [data]
     };
   }
-  if (message.action === "disconnectWeb") {
+  if (message.action === "disconnectWeb" || message.action === "disconnect") {
     return {
-      name: "disconnectWeb",
+      name: message.action,
       payload: [],
       raw: [data]
     };
@@ -712,27 +724,37 @@ var walletEventAdapters = {
   metamask: {
     parseAccountsChanged: parseMetaMaskAccountsChanged,
     parseChainChanged: parseMetaMaskChainChanged,
+    emptyAccountsMeansDisconnect: true,
+    confirmEmptyAccountsWithRpc: false,
     ...DEFAULT_RETRY
   },
   coinbase: {
     parseAccountsChanged: parseMetaMaskAccountsChanged,
     parseChainChanged: parseMetaMaskChainChanged,
+    emptyAccountsMeansDisconnect: false,
+    confirmEmptyAccountsWithRpc: true,
     ...DEFAULT_RETRY
   },
   tokenpocket: {
     parseAccountsChanged: parseMetaMaskAccountsChanged,
     parseChainChanged: parseMetaMaskChainChanged,
+    emptyAccountsMeansDisconnect: false,
+    confirmEmptyAccountsWithRpc: true,
     ...DEFAULT_RETRY
   },
   tronlink: {
     parseAccountsChanged: parseTronLinkAccountsChanged,
     parseChainChanged: parseTronLinkChainChanged,
     parseLegacyMessage: parseTronLinkLegacyMessage,
+    emptyAccountsMeansDisconnect: false,
+    confirmEmptyAccountsWithRpc: true,
     ...TRONLINK_RETRY
   },
   unknown: {
     parseAccountsChanged: parseMetaMaskAccountsChanged,
     parseChainChanged: parseMetaMaskChainChanged,
+    emptyAccountsMeansDisconnect: true,
+    confirmEmptyAccountsWithRpc: false,
     emptyAccountsRetryAttempts: 2,
     emptyAccountsRetryIntervalMs: 100
   }
@@ -744,6 +766,7 @@ function getWalletEventAdapter(wallet) {
 // src/wallet/events.ts
 var eventHandlers = {};
 var providerBridges = /* @__PURE__ */ new WeakMap();
+var tronLinkAuxiliaryBindings = [];
 var walletEventProvider = null;
 var boundProvider = null;
 var activeWalletKey = "unknown";
@@ -755,6 +778,56 @@ function dispatch(sdkEvent, wallet, event) {
     void handler(wallet, event);
   }
 }
+function hasWalletEventListeners() {
+  return Boolean(eventHandlers.accountsChanged?.size || eventHandlers.walletDisconnected?.size);
+}
+function collectTronLinkEventProviders(primary) {
+  if (!isBrowser) {
+    return primary ? [primary] : [];
+  }
+  const providers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (provider) => {
+    if (!provider || seen.has(provider)) {
+      return;
+    }
+    seen.add(provider);
+    providers.push(provider);
+  };
+  add(primary);
+  add(window.tron ?? null);
+  add(window.tronLink ?? null);
+  const ethereum = window.ethereum;
+  if (ethereum && (ethereum.isTronLink || ethereum.isTronLinkWallet)) {
+    add(ethereum);
+  }
+  return providers;
+}
+async function ensureWalletEventBinding() {
+  const { getSelectedWalletProvider: getSelectedWalletProvider2 } = await import('./runtime-2TGIPXVJ.js');
+  const selected = getSelectedWalletProvider2();
+  if (selected && !walletEventProvider) {
+    setWalletEventProvider(selected);
+  }
+}
+async function handleVerifiedAccountEvent(wallet, nativeEvent) {
+  const { applyVerifiedAccountResolution } = await import('./account-sync-IFXUYW65.js');
+  const result = await applyVerifiedAccountResolution(nativeEvent.payload);
+  if (result.action === "synced" && result.address) {
+    await ensureWalletEventBinding();
+    dispatch("accountsChanged", wallet, {
+      ...nativeEvent,
+      payload: [result.address]
+    });
+    return;
+  }
+  if (result.action === "disconnected") {
+    dispatch("walletDisconnected", wallet, {
+      ...nativeEvent,
+      payload: { source: "provider" }
+    });
+  }
+}
 function emitWalletEvent(sdkEvent, wallet, event) {
   dispatch(sdkEvent, wallet, event);
 }
@@ -767,6 +840,9 @@ function unbindProvider(provider) {
   if (bridgeHandlers.chainChanged) {
     provider.removeListener("chainChanged", bridgeHandlers.chainChanged);
   }
+  if (bridgeHandlers.disconnect) {
+    provider.removeListener("disconnect", bridgeHandlers.disconnect);
+  }
   providerBridges.delete(provider);
 }
 function unbindTronLinkLegacyMessages() {
@@ -776,16 +852,38 @@ function unbindTronLinkLegacyMessages() {
   window.removeEventListener("message", tronLinkMessageListener);
   tronLinkMessageListener = null;
 }
+async function handleWalletDisconnect(wallet, nativeEvent) {
+  const { applyWalletDisconnectEffect } = await import('./account-sync-IFXUYW65.js');
+  const result = await applyWalletDisconnectEffect();
+  if (result.action === "disconnected") {
+    dispatch("walletDisconnected", wallet, nativeEvent);
+  }
+}
 async function handleAccountsChanged(wallet, nativeEvent) {
-  if (nativeEvent.name === "disconnectWeb") {
-    const { applyWalletDisconnectEffect } = await import('./account-sync-EPEP5KUV.js');
-    const result2 = applyWalletDisconnectEffect();
-    if (result2.action === "disconnected") {
-      dispatch("accountsChanged", wallet, nativeEvent);
+  const adapter = getWalletEventAdapter(wallet);
+  if (adapter.confirmEmptyAccountsWithRpc) {
+    void handleVerifiedAccountEvent(wallet, nativeEvent);
+    return;
+  }
+  if (nativeEvent.name === "disconnectWeb" || nativeEvent.name === "disconnect") {
+    void handleWalletDisconnect(wallet, {
+      ...nativeEvent,
+      payload: { source: "provider" }
+    });
+    return;
+  }
+  if (!nativeEvent.payload.length) {
+    if (adapter.emptyAccountsMeansDisconnect) {
+      void handleWalletDisconnect(wallet, {
+        ...nativeEvent,
+        name: "accountsChanged",
+        payload: { source: "provider" }
+      });
+      return;
     }
     return;
   }
-  const { applyWalletAccountsChangedEffect } = await import('./account-sync-EPEP5KUV.js');
+  const { applyWalletAccountsChangedEffect } = await import('./account-sync-IFXUYW65.js');
   const result = await applyWalletAccountsChangedEffect(wallet, nativeEvent.payload);
   if (result.action !== "synced" || !result.address) {
     return;
@@ -795,8 +893,36 @@ async function handleAccountsChanged(wallet, nativeEvent) {
     payload: [result.address]
   });
 }
+function unbindTronLinkAuxiliaryProviders() {
+  for (const binding of tronLinkAuxiliaryBindings) {
+    binding.provider.removeListener("accountsChanged", binding.handler);
+  }
+  tronLinkAuxiliaryBindings.length = 0;
+}
+function bindTronLinkAuxiliaryProviders(wallet, adapter) {
+  if (!hasWalletEventListeners() || wallet !== "tronlink") {
+    unbindTronLinkAuxiliaryProviders();
+    return;
+  }
+  unbindTronLinkAuxiliaryProviders();
+  for (const provider of collectTronLinkEventProviders(walletEventProvider)) {
+    if (provider === walletEventProvider) {
+      continue;
+    }
+    const handler = (...args) => {
+      const nativeEvent = adapter.parseAccountsChanged(args);
+      void handleAccountsChanged("tronlink", nativeEvent);
+    };
+    provider.removeListener("accountsChanged", handler);
+    provider.on("accountsChanged", handler);
+    tronLinkAuxiliaryBindings.push({ provider, handler });
+  }
+}
 function bindTronLinkLegacyMessages(wallet) {
-  if (!isBrowser || wallet !== "tronlink" || tronLinkMessageListener) {
+  if (!isBrowser || wallet !== "tronlink" || !hasWalletEventListeners()) {
+    return;
+  }
+  if (tronLinkMessageListener) {
     return;
   }
   const adapter = getWalletEventAdapter(wallet);
@@ -808,30 +934,49 @@ function bindTronLinkLegacyMessages(wallet) {
     if (!parsed) {
       return;
     }
-    if (parsed.name === "disconnectWeb") {
-      void handleAccountsChanged(wallet, parsed);
+    void handleAccountsChanged("tronlink", parsed);
+  };
+  window.addEventListener("message", tronLinkMessageListener);
+}
+function syncTronLinkExtras(adapter, wallet) {
+  if (!hasWalletEventListeners()) {
+    unbindTronLinkLegacyMessages();
+    unbindTronLinkAuxiliaryProviders();
+    return;
+  }
+  void import('./runtime-2TGIPXVJ.js').then(({ getSelectedWalletProvider: getSelectedWalletProvider2 }) => {
+    const selected = getSelectedWalletProvider2();
+    const selectedKey = selected ? resolveWalletKey(selected) : "unknown";
+    const eventKey = walletEventProvider ? resolveWalletKey(walletEventProvider) : "unknown";
+    const shouldListen = wallet === "tronlink" || activeWalletKey === "tronlink" || selectedKey === "tronlink" || eventKey === "tronlink";
+    if (!shouldListen) {
+      unbindTronLinkLegacyMessages();
+      unbindTronLinkAuxiliaryProviders();
       return;
     }
-    if (parsed.payload.length > 0 || parsed.name === "accountsChanged") {
-      void handleAccountsChanged(wallet, parsed);
+    bindTronLinkLegacyMessages("tronlink");
+    bindTronLinkAuxiliaryProviders("tronlink", adapter);
+  }).catch(() => {
+    if (wallet === "tronlink" || activeWalletKey === "tronlink") {
+      bindTronLinkLegacyMessages("tronlink");
+      bindTronLinkAuxiliaryProviders("tronlink", adapter);
     }
-  };
-  window.addEventListener("message", tronLinkMessageListener);
+  });
 }
 function syncProviderBinding() {
   if (boundProvider) {
     unbindProvider(boundProvider);
     boundProvider = null;
   }
-  unbindTronLinkLegacyMessages();
   if (!walletEventProvider) {
     activeWalletKey = "unknown";
+    syncTronLinkExtras(getWalletEventAdapter("tronlink"), "unknown");
     return;
   }
   activeWalletKey = resolveWalletKey(walletEventProvider);
   const adapter = getWalletEventAdapter(activeWalletKey);
   const bridgeHandlers = {};
-  if (eventHandlers.accountsChanged?.size) {
+  if (eventHandlers.accountsChanged?.size || eventHandlers.walletDisconnected?.size) {
     bridgeHandlers.accountsChanged = (...args) => {
       const nativeEvent = adapter.parseAccountsChanged(args);
       void handleAccountsChanged(activeWalletKey, nativeEvent);
@@ -846,6 +991,24 @@ function syncProviderBinding() {
       dispatch("chainChanged", activeWalletKey, nativeEvent);
     };
   }
+  if (eventHandlers.walletDisconnected?.size) {
+    bridgeHandlers.disconnect = () => {
+      const disconnectAdapter = getWalletEventAdapter(activeWalletKey);
+      if (disconnectAdapter.confirmEmptyAccountsWithRpc) {
+        void handleVerifiedAccountEvent(activeWalletKey, {
+          name: "disconnect",
+          payload: [],
+          raw: []
+        });
+        return;
+      }
+      void handleWalletDisconnect(activeWalletKey, {
+        name: "disconnect",
+        payload: { source: "provider" },
+        raw: []
+      });
+    };
+  }
   if (bridgeHandlers.accountsChanged) {
     walletEventProvider.removeListener("accountsChanged", bridgeHandlers.accountsChanged);
     walletEventProvider.on("accountsChanged", bridgeHandlers.accountsChanged);
@@ -854,9 +1017,13 @@ function syncProviderBinding() {
     walletEventProvider.removeListener("chainChanged", bridgeHandlers.chainChanged);
     walletEventProvider.on("chainChanged", bridgeHandlers.chainChanged);
   }
+  if (bridgeHandlers.disconnect) {
+    walletEventProvider.removeListener("disconnect", bridgeHandlers.disconnect);
+    walletEventProvider.on("disconnect", bridgeHandlers.disconnect);
+  }
   providerBridges.set(walletEventProvider, bridgeHandlers);
   boundProvider = walletEventProvider;
-  bindTronLinkLegacyMessages(activeWalletKey);
+  syncTronLinkExtras(adapter, activeWalletKey);
 }
 function setWalletEventProvider(provider) {
   walletEventProvider = provider;
@@ -988,7 +1155,39 @@ async function connectWallet(eip1193, options = {}) {
     }
   );
   if (options.chainId && isActiveConnectionSession(runtime, session)) {
-    const { switchToConfiguredNetwork } = await import('./network-BRDZGVT6.js');
+    const { switchToConfiguredNetwork } = await import('./network-5HQK32UU.js');
+    await switchToConfiguredNetwork(options.chainId);
+  }
+  return result;
+}
+async function restoreWalletConnection(eip1193, options = {}) {
+  const accounts = normalizeWalletAccounts(await requestWallet(eip1193, "eth_accounts"));
+  if (!accounts.length) {
+    return null;
+  }
+  bindWalletProvider(eip1193);
+  const runtime = getRuntimeStore();
+  const session = runtime.connectionSession;
+  const result = await syncWalletAccountAddress(
+    () => {
+      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;
+    },
+    accounts[0]
+  );
+  if (options.chainId && isActiveConnectionSession(runtime, session)) {
+    const { switchToConfiguredNetwork } = await import('./network-5HQK32UU.js');
     await switchToConfiguredNetwork(options.chainId);
   }
   return result;
@@ -1065,15 +1264,60 @@ async function switchWalletAccount(address) {
   }
   return syncConnectedWalletAccount(address);
 }
-function disconnectWallet() {
+async function tryRevokeAccountPermissions(provider) {
+  try {
+    await requestWallet(provider, "wallet_revokePermissions", [{ eth_accounts: {} }]);
+    return true;
+  } catch (err) {
+    const error = err;
+    if (error?.code === 4001) {
+      throw err;
+    }
+    return false;
+  }
+}
+function ensureWalletRuntimeProviderBound() {
+  const runtime = getRuntimeStore();
+  if (!runtime.selectedProvider) {
+    return false;
+  }
+  if (!runtime.provider) {
+    runtime.provider = getSharedBrowserProvider(runtime.selectedProvider);
+    setWalletReadProvider(runtime.provider);
+  }
+  return runtime.provider !== null;
+}
+async function disconnectWallet(options) {
   const runtime = getRuntimeStore();
+  const wasConnected = runtime.connected;
+  const walletKey = wasConnected ? getActiveWalletKey() : "unknown";
+  const preservedProvider = options?.preserveProvider ? runtime.selectedProvider : null;
+  const provider = runtime.selectedProvider;
+  const shouldRevoke = options?.revokePermissions !== false && !options?.preserveProvider && provider !== null;
+  let revoked = false;
+  if (shouldRevoke && provider) {
+    revoked = await tryRevokeAccountPermissions(provider);
+  }
   invalidateConnectionSession(runtime);
   runtime.provider = null;
   runtime.signer = null;
-  runtime.selectedProvider = null;
   runtime.connected = false;
-  setWalletEventProvider(null);
   setWalletReadProvider(null);
+  if (options?.preserveProvider && preservedProvider) {
+    runtime.selectedProvider = preservedProvider;
+    setWalletEventProvider(preservedProvider);
+  } else {
+    runtime.selectedProvider = null;
+    setWalletEventProvider(null);
+  }
+  if (wasConnected && !options?.silent) {
+    emitWalletEvent("walletDisconnected", walletKey, {
+      name: "disconnect",
+      payload: { source: "app" },
+      raw: []
+    });
+  }
+  return { revoked };
 }
 
-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 };
+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, ensureWalletRuntimeProviderBound, 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, restoreWalletConnection, setWalletEventProvider, setWalletReadProvider, switchWalletAccount, syncConnectedWalletAccount, syncWalletAccountAddress, syncWalletRuntimeProvider, toChainIdDecimal, walletEvents };

package/dist/index.d.ts

@@ -78,6 +78,10 @@ type NetworkSwitchResult = {
     /** @en `true` if switch was invoked; `false` if already on target chain. @zh `true` 已发起切链；`false` 已在目标链。 */
     switched: boolean;
 };
+type WalletDisconnectPayload = {
+    /** @en `app` when `disconnectWallet()` is called; `provider` when the wallet emits disconnect. @zh `app` 为调用 `disconnectWallet()`；`provider` 为钱包主动断开。 */
+    source: "app" | "provider";
+};
 type ConnectWalletOptions = {
     /** @en Switch wallet to this BSC chain after connect. @zh 连接后切换到指定 BSC 链。 */
     chainId?: SupportedBscChainId;
@@ -485,6 +489,15 @@ declare function connectWallet(eip1193: WalletEventProvider, options?: ConnectWa
     address: string;
     signer: JsonRpcSigner;
 }>;
+/**
+ * @en Restore wallet connection from an existing authorized session (`eth_accounts`, no auth prompt).
+ * @zh 从已有授权会话恢复钱包连接（`eth_accounts`，不弹授权窗）。
+ * @returns @en `{ address, signer }` when a session exists; `null` when no authorized accounts. @zh 有授权账户时返回 `{ address, signer }`，否则 `null`。
+ */
+declare function restoreWalletConnection(eip1193: WalletEventProvider, options?: ConnectWalletOptions): Promise<{
+    address: string;
+    signer: JsonRpcSigner;
+} | null>;
 /**
  * @en Sync the connected wallet signer.
  * @zh 同步已连接钱包的 signer。
@@ -518,10 +531,27 @@ declare function switchWalletAccount(address: string): Promise<{
     signer: JsonRpcSigner;
 }>;
 /**
- * @en Disconnect the wallet.
- * @zh 断开钱包连接。
+ * @en Re-bind BrowserProvider when `selectedProvider` exists but runtime provider was cleared.
+ * @zh 当 `selectedProvider` 仍在但 runtime provider 被清空时，重新绑定 BrowserProvider。
+ */
+declare function ensureWalletRuntimeProviderBound(): boolean;
+type DisconnectWalletOptions = {
+    /** @en When `true`, skip `walletDisconnected` event (internal provider-driven disconnect). @zh 为 `true` 时不触发 `walletDisconnected`（内部由 provider 断开时使用）。 */
+    silent?: boolean;
+    /** @en Keep `selectedProvider` and event listeners (TronLink account switch after revoke). @zh 保留 `selectedProvider` 与事件监听（TronLink 撤销后切账户）。 */
+    preserveProvider?: boolean;
+    /** @en Attempt `wallet_revokePermissions` before clearing local state (default `true`). @zh 清除本地状态前尝试 `wallet_revokePermissions`（默认 `true`）。 */
+    revokePermissions?: boolean;
+};
+type DisconnectWalletResult = {
+    /** @en Whether `eth_accounts` permission was revoked in the wallet. @zh 是否已在钱包侧撤销 `eth_accounts` 授权。 */
+    revoked: boolean;
+};
+/**
+ * @en Disconnect the wallet; optionally revoke site permissions in MetaMask / Coinbase.
+ * @zh 断开钱包；可选在 MetaMask / Coinbase 中撤销站点授权。
  */
-declare function disconnectWallet(): void;
+declare function disconnectWallet(options?: DisconnectWalletOptions): Promise<DisconnectWalletResult>;
 
 type SupportedWalletKey = "metamask" | "tronlink" | "coinbase" | "tokenpocket" | "unknown";
 /**
@@ -540,6 +570,7 @@ type WalletSdkEventMap = {
     accountsChanged: string[];
     chainChanged: string;
     networkSwitched: NetworkSwitchResult;
+    walletDisconnected: WalletDisconnectPayload;
 };
 type WalletSdkEventName = keyof WalletSdkEventMap;
 type WalletScopedEventListener<K extends WalletSdkEventName = WalletSdkEventName> = (wallet: SupportedWalletKey, event: WalletNativeEvent<WalletSdkEventMap[K]>) => void | Promise<void>;
@@ -572,8 +603,8 @@ type WalletAccountsSyncResult = {
     address?: string;
 };
 /**
- * @en Sync signer when payload includes an account address; ignore empty payloads.
- * @zh 仅当 payload 含账户地址时同步 signer；空 payload 忽略，不清空连接。
+ * @en Sync signer when payload includes an account address.
+ * @zh 仅当 payload 含账户地址时同步 signer。
  */
 declare function applyWalletAccountsChangedEffect(wallet: SupportedWalletKey, accounts: string[]): Promise<WalletAccountsSyncResult>;
 
@@ -770,4 +801,4 @@ declare const ERC20_ABI: ({
     stateMutability?: undefined;
 })[];
 
-export { BSC_NETWORK, BSC_TESTNET_NETWORK, type ChainConfig, type ChainNativeCurrency, type ConnectWalletOptions, ERC20_ABI, ERC20_DECIMALS, ERC20_DECIMALS_ABI, type Eip6963ProviderDetail, type Eip6963ProviderInfo, type Erc20BalanceResult, type EthereumRequestParams, type EvmReadProvider, type GetConfiguredReadProviderOptions, type GetContractReadOptions, type InjectedEthereumProvider, type MutableRef, type NetworkSwitchResult, SUPPORTED_BSC_CHAIN_IDS, type SupportedBscChainId, type SupportedWalletKey, USDT_CONFIG, type UsdtInitConfig, Wallet6963Name, Wallet6963Rdns, type WalletAccountsSyncResult, type WalletEventProvider, WalletEvents, type WalletNativeEvent, type WalletScopedEventListener, type WalletSdkConfig, type WalletSdkEventMap, type WalletSdkEventName, type WalletSdkInitOptions, applyWalletAccountsChangedEffect, assertBrowser, bindBrowserProvider, bindWalletProvider, clearJsonRpcReadProviderCache, clearWalletRuntime, connectWallet, connectWalletAccount, createJsonRpcReadProvider, disconnectWallet, discoverWalletProviders, emitWalletEvent, ensureTargetNetwork, findCoinbaseEip6963Provider, findDiscoveredProvider, findMetaMaskEip6963Provider, findTokenPocketEip6963Provider, findTronLinkEip6963Provider, getActiveWalletKey, getAggregatedInjectedProvider, getConfiguredReadProvider, getConnectedAddress, getContractDecimals, getContractPrice, getInjectedEthereumProviders, getReadProviderWithFallback, getSelectedWalletProvider, getSharedBrowserProvider, getWalletAccounts, getWalletBrowserProvider, getWalletEventProvider, getWalletSdkConfig, getWalletSigner, hasAggregatedInjectedProvider, hasCoinbaseEip6963Provider, hasCoinbaseInjectedProvider, hasDeployedContract, hasMetaMaskEip6963Provider, hasMetaMaskInjectedProvider, hasRecoverableAggregatorProvider, hasTokenPocketEip6963Provider, hasTokenPocketInjectedProvider, hasTronLinkEip6963Provider, hasTronLinkInjectedProvider, initWalletSdk, isBrowser, isCoinbaseProvider, isContractDeployed, isEthereumProvider, isInjectedProvider, isTokenPocketProvider, isTronLinkProvider, isWalletConnected, isWalletSdkInitialized, normalizeSupportedBscChainId, readConfiguredUsdtDecimals, readErc20Balance, readErc20Decimals, readUsdtBalance, refreshWalletAccounts, refreshWalletReadProvider, rememberAggregatorProvider, requestWallet, resetWalletSdkConfig, resolveChainConfig, resolveCoinbaseInjectedProvider, resolveMetaMaskInjectedProvider, resolveTokenPocketInjectedProvider, resolveTronLinkInjectedProvider, resolveWalletKey, setWalletEventProvider, setWalletReadProvider, switchToConfiguredNetwork, switchWalletAccount, syncConnectedWalletAccount, syncWalletAccountAddress, syncWalletRuntimeProvider, toChainIdDecimal, walletEvents };
+export { BSC_NETWORK, BSC_TESTNET_NETWORK, type ChainConfig, type ChainNativeCurrency, type ConnectWalletOptions, type DisconnectWalletOptions, type DisconnectWalletResult, ERC20_ABI, ERC20_DECIMALS, ERC20_DECIMALS_ABI, type Eip6963ProviderDetail, type Eip6963ProviderInfo, type Erc20BalanceResult, type EthereumRequestParams, type EvmReadProvider, type GetConfiguredReadProviderOptions, type GetContractReadOptions, type InjectedEthereumProvider, type MutableRef, type NetworkSwitchResult, SUPPORTED_BSC_CHAIN_IDS, type SupportedBscChainId, type SupportedWalletKey, USDT_CONFIG, type UsdtInitConfig, Wallet6963Name, Wallet6963Rdns, type WalletAccountsSyncResult, type WalletDisconnectPayload, type WalletEventProvider, WalletEvents, type WalletNativeEvent, type WalletScopedEventListener, type WalletSdkConfig, type WalletSdkEventMap, type WalletSdkEventName, type WalletSdkInitOptions, applyWalletAccountsChangedEffect, assertBrowser, bindBrowserProvider, bindWalletProvider, clearJsonRpcReadProviderCache, clearWalletRuntime, connectWallet, connectWalletAccount, createJsonRpcReadProvider, disconnectWallet, discoverWalletProviders, emitWalletEvent, ensureTargetNetwork, ensureWalletRuntimeProviderBound, findCoinbaseEip6963Provider, findDiscoveredProvider, findMetaMaskEip6963Provider, findTokenPocketEip6963Provider, findTronLinkEip6963Provider, getActiveWalletKey, getAggregatedInjectedProvider, getConfiguredReadProvider, getConnectedAddress, getContractDecimals, getContractPrice, getInjectedEthereumProviders, getReadProviderWithFallback, getSelectedWalletProvider, getSharedBrowserProvider, getWalletAccounts, getWalletBrowserProvider, getWalletEventProvider, getWalletSdkConfig, getWalletSigner, hasAggregatedInjectedProvider, hasCoinbaseEip6963Provider, hasCoinbaseInjectedProvider, hasDeployedContract, hasMetaMaskEip6963Provider, hasMetaMaskInjectedProvider, hasRecoverableAggregatorProvider, hasTokenPocketEip6963Provider, hasTokenPocketInjectedProvider, hasTronLinkEip6963Provider, hasTronLinkInjectedProvider, initWalletSdk, isBrowser, isCoinbaseProvider, isContractDeployed, isEthereumProvider, isInjectedProvider, isTokenPocketProvider, isTronLinkProvider, isWalletConnected, isWalletSdkInitialized, normalizeSupportedBscChainId, readConfiguredUsdtDecimals, readErc20Balance, readErc20Decimals, readUsdtBalance, refreshWalletAccounts, refreshWalletReadProvider, rememberAggregatorProvider, requestWallet, resetWalletSdkConfig, resolveChainConfig, resolveCoinbaseInjectedProvider, resolveMetaMaskInjectedProvider, resolveTokenPocketInjectedProvider, resolveTronLinkInjectedProvider, resolveWalletKey, restoreWalletConnection, setWalletEventProvider, setWalletReadProvider, switchToConfiguredNetwork, switchWalletAccount, syncConnectedWalletAccount, syncWalletAccountAddress, syncWalletRuntimeProvider, toChainIdDecimal, walletEvents };

package/dist/index.js

@@ -1,7 +1,7 @@
-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';
+export { applyWalletAccountsChangedEffect } from './chunk-54NIXGDN.js';
+export { ensureTargetNetwork, switchToConfiguredNetwork } from './chunk-5CET43HT.js';
+import { isBrowser } from './chunk-X6TWVXK3.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, ensureWalletRuntimeProviderBound, 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, restoreWalletConnection, setWalletEventProvider, setWalletReadProvider, switchWalletAccount, syncConnectedWalletAccount, syncWalletAccountAddress, syncWalletRuntimeProvider, toChainIdDecimal, walletEvents } from './chunk-X6TWVXK3.js';
 
 // src/wallet/eip6963.ts
 var EIP6963_ANNOUNCE = "eip6963:announceProvider";

package/dist/{network-BRDZGVT6.js → network-5HQK32UU.js}

@@ -1,2 +1,2 @@
-export { ensureTargetNetwork, switchToConfiguredNetwork } from './chunk-XTONTXHH.js';
-import './chunk-F7UNIZSN.js';
+export { ensureTargetNetwork, switchToConfiguredNetwork } from './chunk-5CET43HT.js';
+import './chunk-X6TWVXK3.js';

package/dist/runtime-2TGIPXVJ.js

@@ -0,0 +1 @@
+export { bindWalletProvider, connectWallet, disconnectWallet, ensureWalletRuntimeProviderBound, getConnectedAddress, getSelectedWalletProvider, getWalletAccounts, getWalletBrowserProvider, getWalletSigner, isWalletConnected, refreshWalletAccounts, restoreWalletConnection, switchWalletAccount, syncConnectedWalletAccount, syncWalletRuntimeProvider } from './chunk-X6TWVXK3.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@earthworm/wallet-sdk",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "EVM wallet utilities for browser DApps",
   "type": "module",
   "sideEffects": false,

package/dist/account-sync-EPEP5KUV.js

@@ -1,2 +0,0 @@
-export { applyWalletAccountsChangedEffect, applyWalletDisconnectEffect } from './chunk-HLZ3QZTH.js';
-import './chunk-F7UNIZSN.js';

package/dist/chunk-HLZ3QZTH.js

@@ -1,19 +0,0 @@
-import { syncConnectedWalletAccount, isWalletConnected, disconnectWallet } from './chunk-F7UNIZSN.js';
-
-// src/wallet/account-sync.ts
-async function applyWalletAccountsChangedEffect(wallet, accounts) {
-  if (!accounts.length) {
-    return { action: "ignored" };
-  }
-  const result = await syncConnectedWalletAccount(accounts[0]);
-  return { action: "synced", address: result.address };
-}
-function applyWalletDisconnectEffect() {
-  if (!isWalletConnected()) {
-    return { action: "ignored" };
-  }
-  disconnectWallet();
-  return { action: "disconnected" };
-}
-
-export { applyWalletAccountsChangedEffect, applyWalletDisconnectEffect };