@vue-solana/vue 3.0.1 → 4.0.0-rc.1

package/README.md

@@ -98,7 +98,7 @@ createApp(App).use(
 
 Supported clusters are `mainnet` (legacy alias `mainnet-beta`), `devnet`, `testnet`, and `localnet`. Use `mainnet` for Solana mainnet; this is Solana's official mainnet cluster name.
 
-`payer` and `payerSecretKey` are supported by direct Vue/core clients. A client-sent transaction requires a payer. Never put a raw secret or `payerSecretKey` in Nuxt public runtime config, and never ship a funded signing key to an end-user browser. The default `createSolanaPlugin()` client composes the official `solanaRpc()`, `rpcTransactionPlanner()`, and `rpcTransactionPlanSendingExecutor()` stack; the old custom fallback sender is not used.
+`payer` and `payerSecretKey` are supported by direct Vue/core clients. A client-sent transaction requires a payer. Never put a raw secret or `payerSecretKey` in Nuxt public runtime config, and never ship a funded signing key to an end-user browser. The default `createSolanaPlugin()` client composes `solanaRpc()` followed by `rpcAirdrop()`; `solanaRpc()` installs `rpcTransactionPlanner()`, `rpcTransactionPlanSigningExecutor()`, and `rpcTransactionPlanSendingExecutor()` itself, so the client exposes RPC reads and subscriptions plus `planTransaction(s)`, `signTransaction(s)`, and `sendTransaction(s)` with no extra plugin. The old custom fallback sender is not used.
 
 ### Plugin Options
 
@@ -276,6 +276,8 @@ const { publicKey, connected, connecting, canSignMessage, connect, disconnect }
 
 Browser extension wallets are discovered through the Solana Wallet Standard. Android Mobile Wallet Adapter wallets are registered through `@solana-mobile/wallet-standard-mobile` and exposed through the same `useWallets()` list on supported Android Chrome clients. iOS Phantom, Solflare, and Backpack entries are exposed through wallet-specific universal links on iOS browsers. `connect()` works after selecting a discovered wallet or configuring a custom `SolanaWallet`.
 
+Connecting a wallet also disconnects every other discovered wallet through its `standard:disconnect` feature, so only one wallet stays authorized for the app. An extension the user authorized in an earlier page session can otherwise keep answering signing requests, which is the usual cause of the wrong wallet prompting for a `signMessage` confirmation. A wallet that fails or never answers its disconnect is ignored after a 2 second timeout, and `connect()` resolves only after the sweep finishes.
+
 Selected discovered wallets are persisted under `localStorage["vue-solana:selected-wallet"]` as non-sensitive identity metadata: `name`, and `platform`/`source` when available. On reload, Vue Solana restores the selected wallet if the same wallet is discovered again. Pass `autoConnect: true` to opt into calling `connect()` for that restored wallet; arbitrary installed wallets are never auto-connected. Calling `selectWallet(null)` or `setWallet(customWallet)` clears the stored selection.
 
 Desktop native app wallet adapters are planned but not implemented yet.
@@ -312,7 +314,7 @@ async function signIn() {
 </template>
 ```
 
-Message signing proves wallet ownership for flows like authentication challenges. It does not sign, submit, or authorize Solana transactions. For authentication, issue a server-generated nonce, include domain and expiration details in the message, and verify the returned signature server-side.
+Message signing proves wallet ownership for flows like authentication challenges. It does not sign, submit, or authorize Solana transactions. For authentication, issue a server-generated nonce, include domain and expiration details in the message, and verify the returned signature server-side. The adapter also checks the signature against the account's public key before resolving, where Ed25519 (WebCrypto) is available — a best-effort client-side guard that rejects with `INVALID_SIGNATURE`, not a replacement for server-side verification.
 
 ## Transaction State
 
@@ -391,7 +393,7 @@ Configure a direct client with `payer` or `payerSecretKey`. `payerSecretKey` is
 
 Use the client flow for automated or server-backed signing (airdrop faucet, cron jobs, relayer fees paid by your keypair), and the wallet flow when the end user must own and approve each transaction.
 
-**Default client composition.** `createSolanaPlugin()` and `createSolanaClient()` install the official `solanaRpc()`, `rpcTransactionPlanner()`, and `rpcTransactionPlanSendingExecutor()` plugins by default. The old custom fallback sender is not used, so `useSendTransaction()` and `useSendTransactions()` do not need a second manual plugin installation. The official executor waits for `confirmed` commitment before `execute()` resolves and the composable reports `sent`. A custom client must still provide the planner and sending executor and a `payer`.
+**Default client composition.** `createSolanaPlugin()` and `createSolanaClient()` compose `solanaRpc()` followed by `rpcAirdrop()` by default; `solanaRpc()` installs `rpcTransactionPlanner()`, `rpcTransactionPlanSigningExecutor()`, and `rpcTransactionPlanSendingExecutor()` itself. The old custom fallback sender is not used, so `useSendTransaction()` and `useSendTransactions()` do not need a second manual plugin installation. The official executor waits for `confirmed` commitment before `execute()` resolves and the composable reports `sent`. A custom client must still provide the planner and sending executor and a `payer`.
 
 ```ts
 import { useSendTransaction } from "@vue-solana/vue/useSendTransaction";
@@ -488,6 +490,8 @@ import { useRequestSwr } from "@vue-solana/vue/swr";
 const balance = useRequestSwr(["balance", address], () => client.rpc.getBalance(address).send());
 ```
 
+The SWR cache is module-level and shared across the whole app, including across SSR requests. Namespace cache keys per request (for example by including a request or session id) or call `clearSwrCache()` at the start of each server request to avoid leaking one request's cached data into another. On the client the cache is intentionally shared for stale-while-revalidate seeding.
+
 ### Cancellation & Timeouts
 
 `useRequest()`, `useSubscription()`, and `useTrackedData()` accept a `getAbortSignal` option — a factory called once per attempt (request) or connection (subscription/tracked data). It is the natural place for a timeout:
@@ -592,7 +596,9 @@ Docs: [Vue Solana Agent Skill](https://vue-solana-docs.vercel.app/agent-skill)
 | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
 | `createSolanaPlugin(options?)`                                                             | Installs the Vue Solana context.                                                                                                         |
 | `VueSolana`                                                                                | Alias for `createSolanaPlugin`.                                                                                                          |
-| `useSolana()`                                                                              | Returns the full injected Solana context.                                                                                                |
+| `useSolana()`                                                                              | Returns the full injected Solana context; throws when no plugin context is available.                                                    |
+| `tryUseSolana()`                                                                           | Returns the injected Solana context or `null` when no plugin context is available (SSR-safe).                                            |
+| `MissingClientCapabilityError`                                                             | Thrown by `useClientCapability()` (and client-sent composables) when the configured client lacks a required capability.                  |
 | `useRpc()`                                                                                 | Returns cluster, endpoint, connection status, latest blockhash, the Kit `client`, and `checkConnection()`.                               |
 | `useSolanaClient()`                                                                        | Returns the injected Kit client as `{ client, rpc }`. The recommended RPC path.                                                          |
 | `useConnection()`                                                                          | Returns the Kit `client`. Deprecated in favor of `useSolanaClient()`.                                                                    |

package/dist/index.d.ts

@@ -56,6 +56,18 @@ interface VueSolanaPlugin {
      * context to consumers that run outside a component setup.
      */
     context: VueSolanaContext | null;
+    /**
+     * Stops the wallet discovery subscription and the deferred bootstrap started
+     * by `install`. Vue has no plugin unmount hook, so call this from an app
+     * teardown hook (`app.onUnmount` in Nuxt, after `app.unmount()` in Vue).
+     * Safe to call more than once and before `install`. Without it the Wallet
+     * Standard subscription outlives the app that created it. After `dispose()`,
+     * `refreshWallets()` is a no-op, so a late mobile-wallet import or manual
+     * call cannot resurrect the subscription. A connected wallet stays
+     * connected; `dispose()` does not disconnect it or abort an in-flight
+     * `connect()`.
+     */
+    dispose(): void;
 }
 declare function createSolanaPlugin(options?: VueSolanaPluginOptions): VueSolanaPlugin;
 declare const VueSolana: typeof createSolanaPlugin;

package/dist/index.mjs

@@ -1,39 +1,39 @@
-export { u as useAccountInfo } from './shared/vue.CvenSbZZ.mjs';
+export { u as useAccountInfo } from './shared/vue.DZhPXLZz.mjs';
 export { u as useAction } from './shared/vue.DYk0Xfr3.mjs';
-export { u as useAirdrop } from './shared/vue.DDQxNX5q.mjs';
-export { u as useBalance } from './shared/vue.BFSboXMB.mjs';
-export { M as MissingClientCapabilityError, u as useClientCapability } from './shared/vue.B9uRpSDJ.mjs';
-export { u as useConnection } from './shared/vue.CpkwC8Th.mjs';
-export { u as usePlanTransaction, a as usePlanTransactions } from './shared/vue.CsFY1mfz.mjs';
-export { u as useProgramAccounts } from './shared/vue.1Qwco2kv.mjs';
-export { u as useIdentity, a as usePayer } from './shared/vue.B-xtuLtD.mjs';
+export { u as useAirdrop } from './shared/vue.CELGI7de.mjs';
+export { u as useBalance } from './shared/vue.DbJKnSrl.mjs';
+export { M as MissingClientCapabilityError, u as useClientCapability } from './shared/vue.CAltY57B.mjs';
+export { u as useConnection } from './shared/vue.C6OkOK2W.mjs';
+export { u as usePlanTransaction, a as usePlanTransactions } from './shared/vue.BXNjyJ2c.mjs';
+export { u as useProgramAccounts } from './shared/vue.DcZ_R_RH.mjs';
+export { u as useIdentity, a as usePayer } from './shared/vue.D2J7_NpQ.mjs';
 export { u as useRequest } from './shared/vue.B8VvC8d2.mjs';
-export { u as useRpc } from './shared/vue.BsGwt78R.mjs';
+export { u as useRpc } from './shared/vue.D8zNWw2t.mjs';
 export { S as SelectedWalletAccountProvider, c as createSelectedWalletAccountContext, p as provideSelectedWalletAccount, s as selectedWalletAccountInjectionKey, u as useSelectedWalletAccount } from './shared/vue.BngCaeXJ.mjs';
-export { u as useSendTransaction, a as useSendTransactions } from './shared/vue.BxtOHzY_.mjs';
-export { u as useSignMessage } from './shared/vue.o98pAmDg.mjs';
-export { u as useSignAndSendTransaction } from './shared/vue.CjSw0Hh1.mjs';
-export { u as useSignTransactions } from './shared/vue.hG_FieA3.mjs';
-export { P as PartialSignAndSendError, u as useSignAndSendTransactions } from './shared/vue.C1JbUTpJ.mjs';
-export { u as useSignatureStatus } from './shared/vue.CXB4NEMA.mjs';
-export { u as useSignIn } from './shared/vue.C9OOmvkD.mjs';
-export { t as tryUseSolana, u as useSolana } from './shared/vue.CQh3AUE8.mjs';
-export { u as useSolanaClient } from './shared/vue.Mxc8w6Qk.mjs';
+export { u as useSendTransaction, a as useSendTransactions } from './shared/vue.CLAqNcLp.mjs';
+export { u as useSignMessage } from './shared/vue.Ddf_Cdjx.mjs';
+export { u as useSignAndSendTransaction } from './shared/vue.BTD4usyi.mjs';
+export { u as useSignTransactions } from './shared/vue.BHBifdbc.mjs';
+export { P as PartialSignAndSendError, u as useSignAndSendTransactions } from './shared/vue.C-7v1l8q.mjs';
+export { u as useSignatureStatus } from './shared/vue.Bu2cQ690.mjs';
+export { u as useSignIn } from './shared/vue.SeuJipQ8.mjs';
+export { t as tryUseSolana, u as useSolana } from './shared/vue.CcOZ9858.mjs';
+export { u as useSolanaClient } from './shared/vue.CZApWQAY.mjs';
 export { u as useSubscription } from './shared/vue.D5pqR5Fa.mjs';
-export { u as useTokenAccounts } from './shared/vue.DNKD6jqM.mjs';
-export { u as useTokenBalance } from './shared/vue.XlfH_nkc.mjs';
+export { u as useTokenAccounts } from './shared/vue.DTpvqDyY.mjs';
+export { u as useTokenBalance } from './shared/vue.FehFeE3w.mjs';
 export { u as useTrackedData } from './shared/vue.BNJTXSnQ.mjs';
 export { u as useTransaction } from './shared/vue.5euWd6-V.mjs';
-export { g as getConfirmedTransactionStatus, u as useTransactionConfirmation } from './shared/vue.CaAgH2Xt.mjs';
-export { u as useWallet } from './shared/vue.D218Ow7t.mjs';
-export { u as useWallets } from './shared/vue.C_4qJDiF.mjs';
+export { g as getConfirmedTransactionStatus, u as useTransactionConfirmation } from './shared/vue.DPwdqRO_.mjs';
+export { u as useWallet } from './shared/vue.Bc_Kbwr5.mjs';
+export { u as useWallets } from './shared/vue.DyLgoSbX.mjs';
 import { s as solanaInjectionKey } from './shared/vue.D_P5SqqD.mjs';
 import { createSolanaError, normalizeSolanaError } from '@vue-solana/core/errors';
 export { SolanaError, isSolanaError } from '@vue-solana/core/errors';
 import { isSolanaMobileWalletSupported } from '@vue-solana/core/mobile-wallet-support';
 import { createSolanaContext } from '@vue-solana/core/rpc';
 import { withTimeout } from '@vue-solana/core/timeout';
-import { getRegisteredSolanaWallets, getSolanaChain, adaptSolanaStandardWallet, subscribeSolanaWallets } from '@vue-solana/core/wallet-standard';
+import { getRegisteredSolanaWallets, getSolanaChain, adaptSolanaStandardWallet, disconnectSolanaStandardWallet, subscribeSolanaWallets } from '@vue-solana/core/wallet-standard';
 import { shallowRef, ref, triggerRef } from 'vue';
 import { handleSolanaIosWalletCallback, getSolanaIosWallets, isSolanaIosWalletInfo, adaptSolanaIosWallet } from '@vue-solana/core/ios-wallet';
 export * from '@vue-solana/core/types';
@@ -112,50 +112,65 @@ function getLocalStorage() {
   }
 }
 
+const DISCONNECT_TIMEOUT_MS = 2e3;
 function createSolanaWalletRegistry(options) {
   const adaptedWallets = /* @__PURE__ */ new WeakMap();
+  const adaptedPrimitiveWallets = /* @__PURE__ */ new Map();
+  const trackedAdapters = /* @__PURE__ */ new Set();
+  function trackAdapter(adapter) {
+    trackedAdapters.add(adapter);
+    return adapter;
+  }
   function getAdaptedWallet(walletInfo) {
     if (isSolanaIosWalletInfo(walletInfo)) {
-      return adaptSolanaIosWallet(walletInfo, {
-        chain: getSolanaChain(options.cluster),
-        cluster: options.cluster,
-        onChange: options.onWalletChange,
-        ...options.iosWallet || {}
-      });
+      const cachedIosWallet = adaptedWallets.get(walletInfo.wallet);
+      if (cachedIosWallet) {
+        return cachedIosWallet;
+      }
+      const iosAdapter = makeConnectExclusive(
+        adaptSolanaIosWallet(walletInfo, {
+          chain: getSolanaChain(options.cluster),
+          cluster: options.cluster,
+          onChange: options.onWalletChange,
+          ...options.iosWallet || {}
+        }),
+        walletInfo
+      );
+      adaptedWallets.set(walletInfo.wallet, iosAdapter);
+      return trackAdapter(iosAdapter);
     }
     if (!isObject(walletInfo.wallet)) {
-      return adaptSolanaStandardWallet(walletInfo, {
-        chain: getSolanaChain(options.cluster),
-        onChange: options.onWalletChange
-      });
+      const primitiveKey = getPrimitiveWalletKey(walletInfo);
+      const cachedPrimitiveWallet = adaptedPrimitiveWallets.get(primitiveKey);
+      if (cachedPrimitiveWallet) {
+        return cachedPrimitiveWallet;
+      }
+      const primitiveAdapter = makeConnectExclusive(
+        adaptSolanaStandardWallet(walletInfo, {
+          chain: getSolanaChain(options.cluster),
+          onChange: options.onWalletChange
+        }),
+        walletInfo
+      );
+      adaptedPrimitiveWallets.set(primitiveKey, primitiveAdapter);
+      return trackAdapter(primitiveAdapter);
     }
     const cachedWallet = adaptedWallets.get(walletInfo.wallet);
     if (cachedWallet) {
       return cachedWallet;
     }
-    const adaptedWallet = adaptSolanaStandardWallet(walletInfo, {
-      chain: getSolanaChain(options.cluster),
-      onChange: options.onWalletChange
-    });
-    const cachedAdapter = new Proxy(adaptedWallet, {
-      get(target, property) {
-        if (property === "connect") {
-          return connectAndDisconnectOthers;
-        }
-        const value = Reflect.get(target, property);
-        return typeof value === "function" ? value.bind(target) : value;
-      }
-    });
-    async function connectAndDisconnectOthers() {
-      await adaptedWallet.connect();
-      await Promise.all(
-        Array.from(getCachedWallets()).map(
-          (otherWallet) => otherWallet !== cachedAdapter && otherWallet.connected ? otherWallet.disconnect() : void 0
-        )
-      );
-    }
+    const cachedAdapter = makeConnectExclusive(
+      adaptSolanaStandardWallet(walletInfo, {
+        chain: getSolanaChain(options.cluster),
+        onChange: options.onWalletChange
+      }),
+      walletInfo
+    );
     adaptedWallets.set(walletInfo.wallet, cachedAdapter);
-    return cachedAdapter;
+    return trackAdapter(cachedAdapter);
+  }
+  function getCachedAdapter(walletInfo) {
+    return isObject(walletInfo.wallet) ? adaptedWallets.get(walletInfo.wallet) : adaptedPrimitiveWallets.get(getPrimitiveWalletKey(walletInfo));
   }
   function getDiscoveredWallets() {
     return [
@@ -171,31 +186,67 @@ function createSolanaWalletRegistry(options) {
     try {
       handleSolanaIosWalletCallback({ clearUrl: true });
     } catch (cause) {
-      console.error("[Vue Solana] iOS wallet callback failed", cause);
+      options.onError?.(cause);
     }
   }
-  function* getCachedWallets() {
-    for (const walletInfo of options.getWalletInfos()) {
-      if (isObject(walletInfo.wallet)) {
-        const cachedWallet = adaptedWallets.get(walletInfo.wallet);
-        if (cachedWallet) {
-          yield cachedWallet;
+  function makeConnectExclusive(adapter, walletInfo) {
+    const connect = adapter.connect.bind(adapter);
+    adapter.connect = async () => {
+      await connect();
+      await disconnectOtherWallets(walletInfo, adapter);
+    };
+    return adapter;
+  }
+  async function disconnectOtherWallets(currentWallet, currentAdapter) {
+    await Promise.all(
+      options.getWalletInfos().map(async (walletInfo) => {
+        const cachedWallet = getCachedAdapter(walletInfo);
+        if (cachedWallet === currentAdapter || isSameWalletInfo(walletInfo, currentWallet)) {
+          return;
         }
-      }
+        try {
+          await withTimeout(
+            disconnectWallet(walletInfo, cachedWallet),
+            DISCONNECT_TIMEOUT_MS,
+            () => new Error(`Solana wallet "${walletInfo.name}" did not disconnect within its timeout`)
+          );
+        } catch {
+        }
+      })
+    );
+  }
+  async function disconnectWallet(walletInfo, cachedWallet) {
+    if (cachedWallet) {
+      await cachedWallet.disconnect();
+      return;
+    }
+    await disconnectSolanaStandardWallet(walletInfo);
+  }
+  function disposeAllAdaptedWallets() {
+    for (const adapter of trackedAdapters) {
+      adapter.dispose?.();
     }
   }
   return {
     getAdaptedWallet,
     getDiscoveredWallets,
-    handleIosWalletCallback
+    handleIosWalletCallback,
+    disposeAllAdaptedWallets
   };
 }
 function isObject(value) {
   return typeof value === "object" && value !== null || typeof value === "function";
 }
+function getPrimitiveWalletKey(walletInfo) {
+  return `${walletInfo.name}::${String(walletInfo.wallet)}`;
+}
+function isSameWalletInfo(a, b) {
+  return a.wallet === b.wallet || a.name === b.name && a.source === b.source;
+}
 
 const RPC_CHECK_TIMEOUT_MS = 1e4;
 function createSolanaPlugin(options = {}) {
+  let teardown = null;
   const plugin = {
     context: null,
     install(app) {
@@ -210,21 +261,22 @@ function createSolanaPlugin(options = {}) {
         cluster: context.cluster,
         iosWallet: options.iosWallet,
         getWalletInfos: () => wallets.value,
-        onWalletChange: () => triggerRef(wallet)
+        onWalletChange: () => triggerRef(wallet),
+        onError: (cause) => {
+          error.value = normalizeSolanaError(cause, "WALLET_FAILURE");
+          logDevError("Failed to handle Solana iOS wallet callback", cause);
+        }
       });
       let unsubscribeWallets = null;
       let mobileWalletRegistrationPromise = null;
       let attemptedAutoConnectWallet = null;
       let rpcCheckId = 0;
+      let bootstrapId = 0;
+      let disposed = false;
       async function checkConnection() {
         const checkId = ++rpcCheckId;
         status.value = "checking";
         error.value = null;
-        console.info("[Vue Solana] Checking RPC connection", {
-          cluster: context.cluster,
-          endpoint: context.endpoint,
-          wsEndpoint: context.wsEndpoint
-        });
         try {
           const response = await withTimeout(
             context.client.rpc.getLatestBlockhash().send(),
@@ -239,22 +291,19 @@ function createSolanaPlugin(options = {}) {
           }
           latestBlockhash.value = blockhash.blockhash;
           status.value = "connected";
-          console.info("[Vue Solana] Connected", {
-            cluster: context.cluster,
-            endpoint: context.endpoint,
-            wsEndpoint: context.wsEndpoint,
-            blockhash
-          });
         } catch (cause) {
           if (checkId !== rpcCheckId) {
             return;
           }
           status.value = "error";
           error.value = normalizeSolanaError(cause, "RPC_FAILURE");
-          console.error("[Vue Solana] Connection failed", cause);
+          logDevError("Connection failed", cause);
         }
       }
       function refreshWallets() {
+        if (disposed) {
+          return;
+        }
         unsubscribeWallets ??= subscribeSolanaWallets(refreshWallets);
         walletRegistry.handleIosWalletCallback();
         wallets.value = walletRegistry.getDiscoveredWallets();
@@ -268,7 +317,7 @@ function createSolanaPlugin(options = {}) {
           const persistedWallet = readSelectedWallet();
           if (persistedWallet.error) {
             error.value = persistedWallet.error;
-            console.error("[Vue Solana] Selected wallet restoration failed", persistedWallet.error);
+            logDevError("Failed to read the persisted Solana wallet", persistedWallet.error);
           }
           restoredWallet = persistedWallet.wallet ? wallets.value.find(
             (nextWallet) => isSameWallet(nextWallet, persistedWallet.wallet)
@@ -286,14 +335,21 @@ function createSolanaPlugin(options = {}) {
         }
       }
       function registerMobileWallets() {
+        if (disposed) {
+          return;
+        }
         mobileWalletRegistrationPromise ??= import('@vue-solana/core/mobile-wallet').then(({ registerSolanaMobileWallet }) => {
+          if (disposed) {
+            return;
+          }
           registerSolanaMobileWallet({
             chains: [getSolanaChain(context.cluster)],
             ...options.mobileWallet || {}
           });
           refreshWallets();
         }).catch((cause) => {
-          console.error("[Vue Solana] Mobile wallet registration failed", cause);
+          error.value = normalizeSolanaError(cause, "WALLET_FAILURE");
+          logDevError("Failed to register Solana mobile wallet", cause);
         }).finally(() => {
           mobileWalletRegistrationPromise = null;
         });
@@ -304,7 +360,7 @@ function createSolanaPlugin(options = {}) {
         const storageError = writeSelectedWallet(nextWallet);
         if (storageError) {
           error.value = storageError;
-          console.error("[Vue Solana] Selected wallet persistence failed", storageError);
+          logDevError("Failed to persist the selected Solana wallet", storageError);
         }
       }
       function autoConnectWallet(walletInfo) {
@@ -318,7 +374,8 @@ function createSolanaPlugin(options = {}) {
         }
         attemptedAutoConnectWallet = storageValue;
         void activeWallet.connect().catch((cause) => {
-          console.error("[Vue Solana] Wallet auto-connect failed", cause);
+          error.value = normalizeSolanaError(cause, "WALLET_FAILURE");
+          logDevError("Failed to auto-connect Solana wallet", cause);
         }).finally(() => {
           triggerRef(wallet);
         });
@@ -340,22 +397,37 @@ function createSolanaPlugin(options = {}) {
           const storageError = writeSelectedWallet(null);
           if (storageError) {
             error.value = storageError;
-            console.error("[Vue Solana] Selected wallet persistence failed", storageError);
+            logDevError("Failed to clear the persisted Solana wallet", storageError);
           }
         }
       };
       app.provide(solanaInjectionKey, vueContext);
       plugin.context = vueContext;
+      teardown = () => {
+        disposed = true;
+        if (typeof window !== "undefined") {
+          window.clearTimeout(bootstrapId);
+        }
+        unsubscribeWallets?.();
+        unsubscribeWallets = null;
+        walletRegistry.disposeAllAdaptedWallets();
+        rpcCheckId += 1;
+        teardown = null;
+      };
       if (typeof window !== "undefined") {
-        window.setTimeout(() => {
+        bootstrapId = window.setTimeout(() => {
+          void checkConnection();
           try {
             refreshWallets();
           } catch (cause) {
-            console.error("[Vue Solana] Wallet refresh failed", cause);
+            error.value = normalizeSolanaError(cause, "WALLET_FAILURE");
+            logDevError("Failed to refresh Solana wallets", cause);
           }
-          void checkConnection();
         }, 0);
       }
+    },
+    dispose() {
+      teardown?.();
     }
   };
   return plugin;
@@ -363,6 +435,24 @@ function createSolanaPlugin(options = {}) {
 function isSameWallet(wallet, selectedWallet) {
   return wallet.name === selectedWallet?.name && wallet.source === selectedWallet.source && wallet.platform === selectedWallet.platform;
 }
+function isDevEnvironment() {
+  try {
+    if (import.meta.env?.DEV === true) {
+      return true;
+    }
+  } catch {
+  }
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const mode = process.env?.NODE_ENV;
+  return mode === "development" || mode === "test";
+}
+function logDevError(message, cause) {
+  if (isDevEnvironment()) {
+    console.error(`[Vue Solana] ${message}`, cause);
+  }
+}
 const VueSolana = createSolanaPlugin;
 
 export { VueSolana, createSolanaPlugin, solanaInjectionKey };

package/dist/shared/{vue.hG_FieA3.mjs → vue.BHBifdbc.mjs}

@@ -1,7 +1,7 @@
 import { createNoWalletSelectedError, assertWalletCanSignTransactions } from '@vue-solana/core/wallet';
 import { shallowRef } from 'vue';
-import { u as useExecution } from './vue.DlihC5GG.mjs';
-import { u as useWallet } from './vue.D218Ow7t.mjs';
+import { u as useExecution } from './vue.BiKE9Xuv.mjs';
+import { u as useWallet } from './vue.Bc_Kbwr5.mjs';
 
 function useSignTransactions() {
   const { wallet } = useWallet();

package/dist/shared/{vue.CjSw0Hh1.mjs → vue.BTD4usyi.mjs}

@@ -3,13 +3,13 @@ import { withSolanaTimeout } from '@vue-solana/core/timeout';
 import { signAndSendTransaction, confirmTransactionSignature } from '@vue-solana/core/transaction';
 import { createNoWalletSelectedError } from '@vue-solana/core/wallet';
 import { ref, computed } from 'vue';
-import { u as useConnection } from './vue.CpkwC8Th.mjs';
-import { u as useWallet } from './vue.D218Ow7t.mjs';
-import { g as getConfirmedTransactionStatus } from './vue.CaAgH2Xt.mjs';
+import { u as useSolanaClient } from './vue.CZApWQAY.mjs';
+import { u as useWallet } from './vue.Bc_Kbwr5.mjs';
+import { g as getConfirmedTransactionStatus } from './vue.DPwdqRO_.mjs';
 
 const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
 function useSignAndSendTransaction() {
-  const client = useConnection();
+  const client = useSolanaClient().client;
   const { wallet } = useWallet();
   const signature = ref(null);
   const confirmation = ref(null);

package/dist/shared/{vue.CsFY1mfz.mjs → vue.BXNjyJ2c.mjs}

@@ -1,4 +1,4 @@
-import { u as useClientAction } from './vue.CGv0ip3w.mjs';
+import { u as useClientAction } from './vue.CbmzveKF.mjs';
 
 const PLANNING_PROVIDER_HINT = "Install a planner plugin, e.g. `createClient().use(rpcTransactionPlanner())` from `@solana/kit-plugin-rpc`, and plan with a client that has a `payer` signer \u2014 Kit reads `client.payer` to set the fee payer.";
 const PLAN_STATUSES = {

package/dist/shared/{vue.D218Ow7t.mjs → vue.Bc_Kbwr5.mjs}

@@ -1,13 +1,19 @@
 import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { createNoWalletSelectedError, assertWalletConnected } from '@vue-solana/core/wallet';
 import { ref, computed, triggerRef } from 'vue';
-import { u as useSolana } from './vue.CQh3AUE8.mjs';
+import { u as useSolana } from './vue.CcOZ9858.mjs';
 
 function useWallet() {
   const solana = useSolana();
   const wallet = solana.wallet;
   const connecting = ref(false);
   const disconnecting = ref(false);
+  function clearWalletError() {
+    const current = solana.error.value;
+    if (current?.code === "WALLET_FAILURE" || current?.code === "USER_REJECTED") {
+      solana.error.value = null;
+    }
+  }
   async function connect() {
     if (connecting.value || wallet.value?.connecting) {
       return;
@@ -22,14 +28,11 @@ function useWallet() {
       triggerRef(wallet);
       await connection;
       assertWalletConnected(activeWallet);
+      clearWalletError();
       triggerRef(wallet);
-      console.info("[Vue Solana] Wallet connected", {
-        publicKey: activeWallet.publicKey ?? null
-      });
     } catch (error) {
-      const normalizedError = normalizeSolanaError(error, "RPC_FAILURE");
+      const normalizedError = normalizeSolanaError(error, "WALLET_FAILURE");
       triggerRef(wallet);
-      console.error("[Vue Solana] Wallet connection failed", normalizedError);
       throw normalizedError;
     } finally {
       connecting.value = false;
@@ -40,16 +43,14 @@ function useWallet() {
     if (!activeWallet) {
       return;
     }
-    const publicKey = activeWallet.publicKey ?? null;
     disconnecting.value = true;
     try {
       await activeWallet.disconnect();
+      clearWalletError();
       triggerRef(wallet);
-      console.info("[Vue Solana] Wallet disconnected", { publicKey });
     } catch (error) {
-      const normalizedError = normalizeSolanaError(error, "RPC_FAILURE");
+      const normalizedError = normalizeSolanaError(error, "WALLET_FAILURE");
       triggerRef(wallet);
-      console.error("[Vue Solana] Wallet disconnection failed", normalizedError);
       throw normalizedError;
     } finally {
       disconnecting.value = false;

package/dist/shared/{vue.DlihC5GG.mjs → vue.BiKE9Xuv.mjs}

@@ -1,8 +1,10 @@
 import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { shallowRef, onScopeDispose, computed } from 'vue';
 
-function useExecution(busy) {
-  const status = shallowRef("idle");
+function useExecution(busy, statuses = {}) {
+  const errorStatus = statuses.error ?? "error";
+  const idleStatus = statuses.idle ?? "idle";
+  const status = shallowRef(idleStatus);
   const error = shallowRef(null);
   let id = 0;
   async function execute(run, settled) {
@@ -19,14 +21,14 @@ function useExecution(busy) {
       const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
       if (currentId === id) {
         error.value = normalizedError;
-        status.value = "error";
+        status.value = errorStatus;
       }
       throw normalizedError;
     }
   }
   function reset() {
     id += 1;
-    status.value = "idle";
+    status.value = idleStatus;
     error.value = null;
   }
   onScopeDispose(() => {