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

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
 
@@ -312,7 +312,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 +391,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 +488,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 +594,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,32 +1,32 @@
-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.DbJG4-ku.mjs';
+export { u as useSignAndSendTransaction } from './shared/vue.4ne5EBD9.mjs';
+export { u as useSignTransactions } from './shared/vue.CW-1AuSO.mjs';
+export { P as PartialSignAndSendError, u as useSignAndSendTransactions } from './shared/vue.UrCjmf0T.mjs';
+export { u as useSignatureStatus } from './shared/vue.Bu2cQ690.mjs';
+export { u as useSignIn } from './shared/vue.BBN9aU6D.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.DY9VadLH.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';
@@ -114,20 +114,39 @@ function getLocalStorage() {
 
 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, {
+      const cachedIosWallet = adaptedWallets.get(walletInfo.wallet);
+      if (cachedIosWallet) {
+        return cachedIosWallet;
+      }
+      const iosAdapter = adaptSolanaIosWallet(walletInfo, {
         chain: getSolanaChain(options.cluster),
         cluster: options.cluster,
         onChange: options.onWalletChange,
         ...options.iosWallet || {}
       });
+      adaptedWallets.set(walletInfo.wallet, iosAdapter);
+      return trackAdapter(iosAdapter);
     }
     if (!isObject(walletInfo.wallet)) {
-      return adaptSolanaStandardWallet(walletInfo, {
+      const primitiveKey = `${walletInfo.name}::${String(walletInfo.wallet)}`;
+      const cachedPrimitiveWallet = adaptedPrimitiveWallets.get(primitiveKey);
+      if (cachedPrimitiveWallet) {
+        return cachedPrimitiveWallet;
+      }
+      const primitiveAdapter = adaptSolanaStandardWallet(walletInfo, {
         chain: getSolanaChain(options.cluster),
         onChange: options.onWalletChange
       });
+      adaptedPrimitiveWallets.set(primitiveKey, primitiveAdapter);
+      return trackAdapter(primitiveAdapter);
     }
     const cachedWallet = adaptedWallets.get(walletInfo.wallet);
     if (cachedWallet) {
@@ -155,7 +174,7 @@ function createSolanaWalletRegistry(options) {
       );
     }
     adaptedWallets.set(walletInfo.wallet, cachedAdapter);
-    return cachedAdapter;
+    return trackAdapter(cachedAdapter);
   }
   function getDiscoveredWallets() {
     return [
@@ -171,7 +190,6 @@ function createSolanaWalletRegistry(options) {
     try {
       handleSolanaIosWalletCallback({ clearUrl: true });
     } catch (cause) {
-      console.error("[Vue Solana] iOS wallet callback failed", cause);
     }
   }
   function* getCachedWallets() {
@@ -184,10 +202,16 @@ function createSolanaWalletRegistry(options) {
       }
     }
   }
+  function disposeAllAdaptedWallets() {
+    for (const adapter of trackedAdapters) {
+      adapter.dispose?.();
+    }
+  }
   return {
     getAdaptedWallet,
     getDiscoveredWallets,
-    handleIosWalletCallback
+    handleIosWalletCallback,
+    disposeAllAdaptedWallets
   };
 }
 function isObject(value) {
@@ -196,6 +220,7 @@ function isObject(value) {
 
 const RPC_CHECK_TIMEOUT_MS = 1e4;
 function createSolanaPlugin(options = {}) {
+  let teardown = null;
   const plugin = {
     context: null,
     install(app) {
@@ -216,15 +241,12 @@ function createSolanaPlugin(options = {}) {
       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 +261,18 @@ 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);
         }
       }
       function refreshWallets() {
+        if (disposed) {
+          return;
+        }
         unsubscribeWallets ??= subscribeSolanaWallets(refreshWallets);
         walletRegistry.handleIosWalletCallback();
         wallets.value = walletRegistry.getDiscoveredWallets();
@@ -268,7 +286,6 @@ function createSolanaPlugin(options = {}) {
           const persistedWallet = readSelectedWallet();
           if (persistedWallet.error) {
             error.value = persistedWallet.error;
-            console.error("[Vue Solana] Selected wallet restoration failed", persistedWallet.error);
           }
           restoredWallet = persistedWallet.wallet ? wallets.value.find(
             (nextWallet) => isSameWallet(nextWallet, persistedWallet.wallet)
@@ -286,14 +303,19 @@ 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);
         }).finally(() => {
           mobileWalletRegistrationPromise = null;
         });
@@ -304,7 +326,6 @@ function createSolanaPlugin(options = {}) {
         const storageError = writeSelectedWallet(nextWallet);
         if (storageError) {
           error.value = storageError;
-          console.error("[Vue Solana] Selected wallet persistence failed", storageError);
         }
       }
       function autoConnectWallet(walletInfo) {
@@ -318,7 +339,6 @@ function createSolanaPlugin(options = {}) {
         }
         attemptedAutoConnectWallet = storageValue;
         void activeWallet.connect().catch((cause) => {
-          console.error("[Vue Solana] Wallet auto-connect failed", cause);
         }).finally(() => {
           triggerRef(wallet);
         });
@@ -340,22 +360,34 @@ function createSolanaPlugin(options = {}) {
           const storageError = writeSelectedWallet(null);
           if (storageError) {
             error.value = storageError;
-            console.error("[Vue Solana] Selected wallet persistence failed", 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(() => {
           try {
             refreshWallets();
           } catch (cause) {
-            console.error("[Vue Solana] Wallet refresh failed", cause);
           }
           void checkConnection();
         }, 0);
       }
+    },
+    dispose() {
+      teardown?.();
     }
   };
   return plugin;

package/dist/shared/{vue.CjSw0Hh1.mjs → vue.4ne5EBD9.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.DY9VadLH.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.C9OOmvkD.mjs → vue.BBN9aU6D.mjs}

@@ -1,7 +1,7 @@
 import { createNoWalletSelectedError, assertWalletCanSignIn } 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.DY9VadLH.mjs';
 
 function useSignIn() {
   const { wallet } = useWallet();

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.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(() => {

package/dist/shared/{vue.CXB4NEMA.mjs → vue.Bu2cQ690.mjs}

@@ -1,19 +1,36 @@
-import { normalizeSolanaError, createSolanaError } from '@vue-solana/core/errors';
-import bs58 from 'bs58';
-import { shallowRef, onMounted, onUnmounted, watch, toValue } from 'vue';
-import { u as useConnection } from './vue.CpkwC8Th.mjs';
-import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
+import { getBase58Encoder } from '@vue-solana/core/kit';
+import { createSolanaError, normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, onMounted, onScopeDispose, watch, toValue } from 'vue';
+import { u as useSolanaClient } from './vue.CZApWQAY.mjs';
+import { t as tryUseSolana } from './vue.CcOZ9858.mjs';
 
 function useSignatureStatus(signature, options = {}) {
   const solana = tryUseSolana();
-  const client = solana?.client ?? useConnection();
+  const client = solana?.client ?? useSolanaClient().client;
   const status = shallowRef(null);
   const loading = shallowRef(false);
   const error = shallowRef(null);
   let refreshId = 0;
-  let pollId = null;
+  let pollTimer = null;
   let manuallyStoppedPolling = false;
+  let refreshInFlight = null;
   async function refresh() {
+    const value = toValue(signature);
+    const inFlight = refreshInFlight;
+    if (inFlight && inFlight.value === value) {
+      return inFlight.promise;
+    }
+    const promise = runRefresh();
+    refreshInFlight = { value, promise };
+    try {
+      return await promise;
+    } finally {
+      if (refreshInFlight?.promise === promise) {
+        refreshInFlight = null;
+      }
+    }
+  }
+  async function runRefresh() {
     const requestId = ++refreshId;
     const value = toValue(signature);
     if (!value || !solana) {
@@ -53,16 +70,22 @@ function useSignatureStatus(signature, options = {}) {
     stopCurrentPolling();
   }
   function stopCurrentPolling() {
-    if (pollId === null) {
+    if (pollTimer === null) {
       return;
     }
-    clearInterval(pollId);
-    pollId = null;
+    clearTimeout(pollTimer);
+    pollTimer = null;
   }
-  function startPolling() {
+  function schedulePoll() {
     stopCurrentPolling();
+    if (!options.pollIntervalMs || !solana) {
+      return;
+    }
+    if (manuallyStoppedPolling) {
+      return;
+    }
     const value = toValue(signature);
-    if (manuallyStoppedPolling || !options.pollIntervalMs || !value || !solana) {
+    if (!value) {
       return;
     }
     if (options.pollIntervalMs <= 0) {
@@ -75,15 +98,22 @@ function useSignatureStatus(signature, options = {}) {
       error.value = normalizeSolanaError(cause, "RPC_FAILURE");
       return;
     }
-    pollId = setInterval(() => {
-      void refresh().catch(() => void 0);
+    pollTimer = setTimeout(() => {
+      pollTimer = null;
+      void refresh().catch(() => void 0).finally(() => {
+        schedulePoll();
+      });
     }, options.pollIntervalMs);
   }
+  function startPolling() {
+    manuallyStoppedPolling = false;
+    schedulePoll();
+  }
   onMounted(() => {
     void refresh().catch(() => void 0);
-    startPolling();
+    schedulePoll();
   });
-  onUnmounted(() => {
+  onScopeDispose(() => {
     refreshId += 1;
     stopPolling();
   });
@@ -105,7 +135,7 @@ function useSignatureStatus(signature, options = {}) {
 function parseTransactionSignature(signature) {
   let decodedSignature;
   try {
-    decodedSignature = bs58.decode(signature);
+    decodedSignature = getBase58Encoder().encode(signature);
   } catch (cause) {
     throw new TypeError("Invalid Solana transaction signature", { cause });
   }

package/dist/shared/{vue.CpkwC8Th.mjs → vue.C6OkOK2W.mjs}

@@ -1,4 +1,4 @@
-import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+import { u as useSolanaClient } from './vue.CZApWQAY.mjs';
 
 function useConnection() {
   return useSolanaClient().client;

package/dist/shared/{vue.B9uRpSDJ.mjs → vue.CAltY57B.mjs}

@@ -1,6 +1,7 @@
-import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+import { SolanaError } from '@vue-solana/core/errors';
+import { u as useSolanaClient } from './vue.CZApWQAY.mjs';
 
-class MissingClientCapabilityError extends Error {
+class MissingClientCapabilityError extends SolanaError {
   /** Name of the hook that requested the capability, e.g. `usePayer`. */
   hookName;
   /** Human guidance for installing the capability on the client. */
@@ -9,7 +10,9 @@ class MissingClientCapabilityError extends Error {
   capabilities;
   constructor(hookName, capabilities, providerHint) {
     super(
-      `${hookName} requires the ${capabilities.map((capability) => `\`${capability}\``).join(" and ")} capabilit${capabilities.length === 1 ? "y" : "ies"} on the Solana client, but none ${capabilities.length === 1 ? "was" : "were"} found. ` + providerHint
+      "MISSING_CLIENT_CAPABILITY",
+      `${hookName} requires the ${capabilities.map((capability) => `\`${capability}\``).join(" and ")} capabilit${capabilities.length === 1 ? "y" : "ies"} on the Solana client, but none ${capabilities.length === 1 ? "was" : "were"} found. ` + providerHint,
+      {}
     );
     this.name = "MissingClientCapabilityError";
     this.hookName = hookName;

package/dist/shared/{vue.DDQxNX5q.mjs → vue.CELGI7de.mjs}

@@ -1,6 +1,7 @@
+import { createSolanaError } from '@vue-solana/core/errors';
 import { u as useAction } from './vue.DYk0Xfr3.mjs';
-import { u as useClientCapability } from './vue.B9uRpSDJ.mjs';
-import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+import { u as useClientCapability, M as MissingClientCapabilityError } from './vue.CAltY57B.mjs';
+import { u as useSolanaClient } from './vue.CZApWQAY.mjs';
 
 function toReadableAirdropError(error) {
   if (error instanceof Error) {
@@ -9,23 +10,22 @@ function toReadableAirdropError(error) {
     if (!isThrottled) {
       throw error;
     }
-    throw new Error(
+    throw createSolanaError(
+      "RPC_FAILURE",
       `${error.message} This likely means the network's airdrop faucet is rate-limited or out of test SOL. Retry later, use https://faucet.solana.com, or point the client at a local validator.`,
       { cause: error }
     );
   }
-  throw new Error(`Airdrop failed: ${String(error)}`);
+  throw createSolanaError("RPC_FAILURE", `Airdrop failed: ${String(error)}`, { cause: error });
 }
 function useAirdrop() {
-  useClientCapability("airdrop", {
-    hookName: "useAirdrop",
-    providerHint: "Install it by adding the airdrop capability with `createClient().use(solanaRpc({ ... })).use(rpcAirdrop())` from `@solana/kit-plugin-rpc`, on a client that has a `payer` signer to sign the request."
-  });
+  const providerHint = "Install it by adding the airdrop capability with `createClient().use(solanaRpc({ ... })).use(rpcAirdrop())` from `@solana/kit-plugin-rpc`, on a client that has a `payer` signer to sign the request.";
+  useClientCapability("airdrop", { hookName: "useAirdrop", providerHint });
   const { client } = useSolanaClient();
   return useAction((abortSignal, address, amount) => {
     const airdrop = client.airdrop;
     if (!airdrop) {
-      throw new Error("useAirdrop requires the `airdrop` capability on the Solana client.");
+      throw new MissingClientCapabilityError("useAirdrop", ["airdrop"], providerHint);
     }
     return airdrop(address, amount, abortSignal).catch(toReadableAirdropError);
   });

package/dist/shared/{vue.BxtOHzY_.mjs → vue.CLAqNcLp.mjs}

@@ -1,4 +1,4 @@
-import { u as useClientAction } from './vue.CGv0ip3w.mjs';
+import { u as useClientAction } from './vue.CbmzveKF.mjs';
 
 const SENDING_PROVIDER_HINT = "Use a client created by `createSolanaClient({ payer })` \u2014 or any client with a `payer` signer. Kit reads `client.payer` when it plans a transaction from an instruction plan.";
 const SEND_STATUSES = {

package/dist/shared/{vue.hG_FieA3.mjs → vue.CW-1AuSO.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.DY9VadLH.mjs';
 
 function useSignTransactions() {
   const { wallet } = useWallet();

package/dist/shared/{vue.Mxc8w6Qk.mjs → vue.CZApWQAY.mjs}

@@ -1,4 +1,4 @@
-import { u as useSolana } from './vue.CQh3AUE8.mjs';
+import { u as useSolana } from './vue.CcOZ9858.mjs';
 
 function useSolanaClient() {
   const { client } = useSolana();

package/dist/shared/vue.CbmzveKF.mjs

@@ -0,0 +1,44 @@
+import { shallowRef, onScopeDispose } from 'vue';
+import { u as useExecution } from './vue.BiKE9Xuv.mjs';
+import { u as useClientCapability, M as MissingClientCapabilityError } from './vue.CAltY57B.mjs';
+import { u as useSolanaClient } from './vue.CZApWQAY.mjs';
+
+function useClientAction(config) {
+  const { capability, hookName, providerHint, statuses } = config;
+  useClientCapability([capability, "payer"], { hookName, providerHint });
+  const { client } = useSolanaClient();
+  const data = shallowRef(null);
+  let abortController;
+  onScopeDispose(() => abortController?.abort());
+  const execution = useExecution(statuses.working, {
+    error: statuses.error,
+    idle: statuses.idle
+  });
+  async function execute(input, options = {}) {
+    const method = client?.[capability];
+    if (typeof method !== "function") {
+      throw new MissingClientCapabilityError(hookName, [capability], providerHint);
+    }
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    data.value = null;
+    const abortSignal = options.abortSignal ? AbortSignal.any([controller.signal, options.abortSignal]) : controller.signal;
+    return execution.execute(
+      () => method(input, { abortSignal }),
+      (result) => {
+        data.value = result;
+        return statuses.success;
+      }
+    );
+  }
+  return {
+    data,
+    status: execution.status,
+    loading: execution.loading,
+    error: execution.error,
+    execute
+  };
+}
+
+export { useClientAction as u };