@vue-solana/vue 2.6.1 → 3.0.0

package/README.md

@@ -55,6 +55,8 @@ pnpm add @vue-solana/vue
 npm install @vue-solana/vue
 ```
 
+Since v3.0.0 this package is ESM only. There is no `require` export condition and no top-level `main`, so `require("@vue-solana/vue")` fails with `No "exports" main defined`. Vite apps are unaffected; pin to `@vue-solana/vue@^2` if you must stay on CommonJS.
+
 ## Plugin Setup
 
 ```ts
@@ -196,7 +198,7 @@ const { balance, loading, error, refresh } = useBalance(address);
 `useAirdrop()` sends SOL to an account on devnet, testnet, or a local validator. The default Vue client includes the RPC and airdrop capabilities; a custom client can install them with `createClient().use(solanaRpc({ ... })).use(rpcAirdrop())` from `@solana/kit-plugin-rpc`.
 
 ```ts
-import { lamports } from "@solana/kit";
+import { lamports } from "@vue-solana/vue/kit";
 import { useAirdrop } from "@vue-solana/vue/useAirdrop";
 
 const { data, status, error, dispatch } = useAirdrop();
@@ -344,10 +346,10 @@ await confirmation.confirm(signature);
 
 ### Wallet Request Inputs and Returns
 
-Wallet signing flows accept transaction input as raw `Uint8Array` wire bytes that conform to the Solana transaction schema. Build them with `@solana/kit` (or decode them from a base64/base58 RPC response); base64 strings, transaction objects, and instruction lists are not accepted here.
+Wallet signing flows accept transaction input as raw `Uint8Array` wire bytes that conform to the Solana transaction schema. Build them with the Kit helpers from `@vue-solana/vue/kit` (or decode them from a base64/base58 RPC response); base64 strings, transaction objects, and instruction lists are not accepted here.
 
 ```ts
-import { compileTransaction, getTransactionEncoder } from "@solana/kit";
+import { compileTransaction, getTransactionEncoder } from "@vue-solana/vue/kit";
 
 const transaction: Uint8Array = getTransactionEncoder().encode(compileTransaction(message));
 await execute(transaction);
@@ -673,7 +675,7 @@ Other direct subpaths:
 - Public Solana RPC endpoints are useful for development, but production apps should use dedicated RPC infrastructure.
 - Broad `useProgramAccounts()` scans can be expensive or blocked on public RPC nodes. Prefer narrow filters and `dataSlice`.
 - Use `mainnet` for Solana mainnet. This is Solana's official mainnet cluster name; the legacy `mainnet-beta` spelling is still accepted and redirects to the same endpoint.
-- v2.0.0 removed `@solana/web3-compat` and the `web3` subpaths. Build transaction messages with `@solana/kit` and pass raw `Uint8Array` wire bytes to wallet flows. See the [Kit Migration guide](https://vue-solana-docs.vercel.app/guides/kit-migration) for migrating from v1.
+- v2.0.0 removed `@solana/web3-compat` and the `web3` subpaths. Build transaction messages with `@vue-solana/vue/kit` and pass raw `Uint8Array` wire bytes to wallet flows. See the [Kit Migration guide](https://vue-solana-docs.vercel.app/guides/kit-migration) for migrating from v1.
 - Desktop native app wallets are planned but not implemented yet.
 
 ## Status

package/dist/index.d.mts

@@ -33,11 +33,13 @@ import { GetSolanaIosWalletsOptions } from '@vue-solana/core/ios-wallet';
 import { RegisterSolanaMobileWalletOptions } from '@vue-solana/core/mobile-wallet';
 import { SolanaConfig, SolanaWallet } from '@vue-solana/core/types';
 export * from '@vue-solana/core/types';
+export { TransactionStatus } from '@vue-solana/core/types';
 import { App } from 'vue';
+export { SolanaError, SolanaErrorCode, isSolanaError } from '@vue-solana/core/errors';
 export * from '@vue-solana/core/kit';
-import '@vue-solana/core/errors';
 import '@solana/kit-plugin-rpc';
 import '@solana/kit';
+import './shared/vue.BGGixph-.mjs';
 import '@vue-solana/core/token-accounts';
 
 interface VueSolanaPluginOptions extends SolanaConfig {

package/dist/index.d.ts

@@ -33,11 +33,13 @@ import { GetSolanaIosWalletsOptions } from '@vue-solana/core/ios-wallet';
 import { RegisterSolanaMobileWalletOptions } from '@vue-solana/core/mobile-wallet';
 import { SolanaConfig, SolanaWallet } from '@vue-solana/core/types';
 export * from '@vue-solana/core/types';
+export { TransactionStatus } from '@vue-solana/core/types';
 import { App } from 'vue';
+export { SolanaError, SolanaErrorCode, isSolanaError } from '@vue-solana/core/errors';
 export * from '@vue-solana/core/kit';
-import '@vue-solana/core/errors';
 import '@solana/kit-plugin-rpc';
 import '@solana/kit';
+import './shared/vue.BGGixph-.js';
 import '@vue-solana/core/token-accounts';
 
 interface VueSolanaPluginOptions extends SolanaConfig {

package/dist/index.mjs

@@ -1,34 +1,35 @@
-export { u as useAccountInfo } from './shared/vue.BQRpjwKl.mjs';
+export { u as useAccountInfo } from './shared/vue.CvenSbZZ.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.BINkrA8h.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.Co5rj-I6.mjs';
-export { u as useProgramAccounts } from './shared/vue.C13umiQi.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 useRequest } from './shared/vue.B8VvC8d2.mjs';
 export { u as useRpc } from './shared/vue.BsGwt78R.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.DAthhH4D.mjs';
-export { u as useSignMessage } from './shared/vue.JUWqu6kD.mjs';
-export { u as useSignAndSendTransaction } from './shared/vue.Dyi1OCI1.mjs';
-export { u as useSignTransactions } from './shared/vue.CMohL_Cz.mjs';
-export { P as PartialSignAndSendError, u as useSignAndSendTransactions } from './shared/vue.D5U1yLG3.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.ByxbBC3y.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 useSubscription } from './shared/vue.BDNOyiGZ.mjs';
-export { u as useTokenAccounts } from './shared/vue.BOpgWr43.mjs';
-export { u as useTokenBalance } from './shared/vue.BD6Gm1nl.mjs';
-export { u as useTrackedData } from './shared/vue.CbJFnho-.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 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.D3Y0PWbF.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';
 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 { createSolanaContext } from '@vue-solana/core/rpc';
 import { withTimeout } from '@vue-solana/core/timeout';
 import { getRegisteredSolanaWallets, getSolanaChain, adaptSolanaStandardWallet, subscribeSolanaWallets } from '@vue-solana/core/wallet-standard';
@@ -36,10 +37,13 @@ import { shallowRef, ref, triggerRef } from 'vue';
 import { handleSolanaIosWalletCallback, getSolanaIosWallets, isSolanaIosWalletInfo, adaptSolanaIosWallet } from '@vue-solana/core/ios-wallet';
 export * from '@vue-solana/core/types';
 export * from '@vue-solana/core/kit';
+import './shared/vue.BwBqla_n.mjs';
 import '@vue-solana/core/address';
 import './shared/vue.Bfu1dCKe.mjs';
 import '@vue-solana/core/action';
+import './shared/vue.CGv0ip3w.mjs';
 import '@vue-solana/core/wallet';
+import './shared/vue.DlihC5GG.mjs';
 import '@vue-solana/core/transaction';
 import 'bs58';
 import '@vue-solana/core/token-accounts';
@@ -142,38 +146,23 @@ function createSolanaWalletRegistry(options) {
       chain: getSolanaChain(options.cluster),
       onChange: options.onWalletChange
     });
-    const cachedAdapter = {
-      platform: walletInfo.platform,
-      source: walletInfo.source,
-      get publicKey() {
-        return adaptedWallet.publicKey;
-      },
-      get connected() {
-        return adaptedWallet.connected;
-      },
-      get connecting() {
-        return adaptedWallet.connecting;
-      },
-      get disconnecting() {
-        return adaptedWallet.disconnecting;
-      },
-      async connect() {
-        await adaptedWallet.connect();
-        await Promise.all(
-          Array.from(getCachedWallets()).map(
-            (otherWallet) => otherWallet !== cachedAdapter && otherWallet.connected ? otherWallet.disconnect() : void 0
-          )
-        );
-      },
-      disconnect: () => adaptedWallet.disconnect(),
-      signMessage: adaptedWallet.signMessage?.bind(adaptedWallet),
-      signTransaction: adaptedWallet.signTransaction?.bind(adaptedWallet),
-      signAllTransactions: adaptedWallet.signAllTransactions?.bind(adaptedWallet),
-      signAndSendTransaction: adaptedWallet.signAndSendTransaction?.bind(adaptedWallet),
-      signIn: adaptedWallet.signIn?.bind(adaptedWallet),
-      signTransactions: adaptedWallet.signTransactions?.bind(adaptedWallet),
-      signAndSendTransactions: adaptedWallet.signAndSendTransactions?.bind(adaptedWallet)
-    };
+    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
+        )
+      );
+    }
     adaptedWallets.set(walletInfo.wallet, cachedAdapter);
     return cachedAdapter;
   }

package/dist/shared/vue.1Qwco2kv.mjs

@@ -0,0 +1,33 @@
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { u as useAddressRead } from './vue.BwBqla_n.mjs';
+import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
+import { d as decodeBase64 } from './vue.Bfu1dCKe.mjs';
+
+function useProgramAccounts(programId, options = {}) {
+  const empty = [];
+  const solana = tryUseSolana();
+  const client = solana?.client ?? useConnection();
+  const { data: accounts, ...rest } = useAddressRead(
+    [programId],
+    async (key) => (await client.rpc.getProgramAccounts(key, {
+      encoding: "base64",
+      commitment: options.commitment,
+      dataSlice: options.dataSlice,
+      filters: options.filters
+    }).send()).value,
+    (response) => response.map(({ pubkey, account }) => ({
+      pubkey,
+      account: {
+        executable: account.executable,
+        lamports: Number(account.lamports),
+        owner: account.owner,
+        space: Number(account.space),
+        data: decodeBase64(account.data[0])
+      }
+    })),
+    empty
+  );
+  return { accounts, ...rest };
+}
+
+export { useProgramAccounts as u };

package/dist/shared/vue.BFSboXMB.mjs

@@ -0,0 +1,17 @@
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { u as useAddressRead } from './vue.BwBqla_n.mjs';
+import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
+
+function useBalance(address, commitment) {
+  const solana = tryUseSolana();
+  const client = solana?.client ?? useConnection();
+  const { data: balance, ...rest } = useAddressRead(
+    [address],
+    async (key) => (await client.rpc.getBalance(key, commitment ? { commitment } : void 0).send()).value,
+    Number,
+    null
+  );
+  return { balance, ...rest };
+}
+
+export { useBalance as u };

package/dist/shared/vue.BGGixph-.d.mts

@@ -0,0 +1,5 @@
+interface ClientActionConfig {
+    abortSignal?: AbortSignal;
+}
+
+export type { ClientActionConfig as C };

package/dist/shared/vue.BGGixph-.d.ts

@@ -0,0 +1,5 @@
+interface ClientActionConfig {
+    abortSignal?: AbortSignal;
+}
+
+export type { ClientActionConfig as C };

package/dist/shared/{vue.CbJFnho-.mjs → vue.BNJTXSnQ.mjs}

@@ -1,4 +1,4 @@
-import { createReactiveStoreWithInitialValueAndSlotTracking, getAbortablePromise } from '@vue-solana/core/kit';
+import { createReactiveActionStore, getAbortablePromise, createReactiveStoreWithInitialValueAndSlotTracking } from '@vue-solana/core/kit';
 import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { shallowRef, watch, unref, onMounted, getCurrentInstance, onScopeDispose, computed } from 'vue';
 
@@ -9,7 +9,7 @@ function useTrackedData(source, options = {}) {
   const data = shallowRef(void 0);
   const error = shallowRef(null);
   const status = shallowRef("loading");
-  const disposables = [];
+  let disposeActive;
   let connectionCount = 0;
   let disposed = false;
   let activeStore;
@@ -22,8 +22,8 @@ function useTrackedData(source, options = {}) {
       error.value = normalizeSolanaError(state.error, "RPC_FAILURE");
       status.value = "error";
       options.onError?.(state.error);
-    } else if (state.status === "loading") {
-      status.value = data.value === void 0 ? "loading" : status.value;
+    } else if (state.status === "loading" && data.value === void 0) {
+      status.value = "loading";
     } else if (state.status === "idle") {
       error.value = null;
     }
@@ -32,74 +32,25 @@ function useTrackedData(source, options = {}) {
     if (disposed) {
       return;
     }
+    disconnect();
     let rpcRequest = unref(source.rpcRequest);
     const rpcSubscriptionRequest = unref(source.rpcSubscriptionRequest);
     if (!rpcRequest || !rpcSubscriptionRequest) {
-      disconnect();
       data.value = void 0;
       error.value = null;
       status.value = "disabled";
       return;
     }
     if (!isActionSource(rpcRequest) && isSendSource(rpcRequest)) {
-      let runSend = function(abortSignal) {
-        controller?.abort();
-        controller = new AbortController();
-        const composed = abortSignal ? AbortSignal.any([controller.signal, abortSignal]) : controller.signal;
-        settle({ data: void 0, error: void 0, status: "running" });
-        const pending = Promise.resolve(sendSource.send({ abortSignal: composed }));
-        pending.then((response) => {
-          settle({ data: response, error: void 0, status: "success" });
-        }).catch((cause) => {
-          settle({ data: void 0, error: cause, status: "error" });
-        });
-        return getAbortablePromise(pending, composed);
-      };
       const sendSource = rpcRequest;
-      const listeners = /* @__PURE__ */ new Set();
-      let sendState = {
-        data: void 0,
-        error: void 0,
-        status: "idle"
-      };
-      let controller;
-      const emit = () => {
-        listeners.forEach((listener) => {
-          listener();
-        });
-      };
-      const settle = (next) => {
-        sendState = next;
-        emit();
-      };
       rpcRequest = {
-        reactiveStore: () => ({
-          dispatch() {
-            void runSend().catch(() => {
-            });
-          },
-          dispatchAsync: () => runSend(),
-          getState: () => sendState,
-          reset() {
-            controller?.abort();
-            settle({ data: void 0, error: void 0, status: "idle" });
-          },
-          subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-              listeners.delete(listener);
-            };
-          },
-          withSignal(signal) {
-            return {
-              dispatch: () => {
-                void runSend(signal).catch(() => {
-                });
-              },
-              dispatchAsync: () => runSend(signal)
-            };
-          }
-        })
+        reactiveStore: () => createReactiveActionStore(
+          (abortSignal) => (
+            // Race the send against the signal so a reconnection or teardown
+            // abort fails the attempt even if the source ignores it.
+            getAbortablePromise(sendSource.send({ abortSignal }), abortSignal)
+          )
+        )
       };
     }
     connectionCount += 1;
@@ -113,11 +64,9 @@ function useTrackedData(source, options = {}) {
     });
     activeStore = store;
     applyState(store.getState());
-    disposables.push(
-      store.subscribe(() => {
-        applyState(store.getState());
-      })
-    );
+    disposeActive = store.subscribe(() => {
+      applyState(store.getState());
+    });
     if (callerSignal?.aborted) {
       applyState({ data: store.getState().data, error: callerSignal.reason, status: "error" });
       return;
@@ -129,10 +78,8 @@ function useTrackedData(source, options = {}) {
     }
   }
   function disconnect() {
-    disposables.forEach((dispose) => {
-      dispose();
-    });
-    disposables.length = 0;
+    disposeActive?.();
+    disposeActive = void 0;
     if (activeStore) {
       activeStore.reset();
       activeStore = void 0;

package/dist/shared/{vue.BINkrA8h.mjs → vue.BwBqla_n.mjs}

@@ -1,21 +1,17 @@
 import { parseAddress } from '@vue-solana/core/address';
 import { normalizeSolanaError } from '@vue-solana/core/errors';
-import { shallowRef, onMounted, watch, toValue } from 'vue';
-import { u as useConnection } from './vue.CpkwC8Th.mjs';
-import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
+import { shallowRef, onMounted, onScopeDispose, watch, toValue } from 'vue';
 
-function useBalance(address, commitment) {
-  const solana = tryUseSolana();
-  const client = solana?.client ?? useConnection();
-  const balance = shallowRef(null);
+function useAddressRead(addresses, read, select, empty) {
+  const data = shallowRef(empty);
   const loading = shallowRef(false);
   const error = shallowRef(null);
   let refreshId = 0;
   async function refresh() {
     const requestId = ++refreshId;
-    const value = toValue(address);
-    if (!value || !solana) {
-      balance.value = null;
+    const values = addresses.map((address) => toValue(address));
+    if (values.some((value) => !value)) {
+      data.value = empty;
       loading.value = false;
       error.value = null;
       return null;
@@ -23,19 +19,15 @@ function useBalance(address, commitment) {
     loading.value = true;
     error.value = null;
     try {
-      const parsedAddress = parseAddress(value);
-      if (!parsedAddress) {
-        balance.value = null;
-        return null;
-      }
-      const { value: lamports } = await client.rpc.getBalance(parsedAddress, commitment ? { commitment } : void 0).send();
+      const next = select(await read(...values.map((value) => parseAddress(value))));
       if (requestId === refreshId) {
-        balance.value = Number(lamports);
+        data.value = next;
       }
-      return Number(lamports);
+      return next;
     } catch (cause) {
       const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
       if (requestId === refreshId) {
+        data.value = empty;
         error.value = normalizedError;
       }
       throw normalizedError;
@@ -48,18 +40,16 @@ function useBalance(address, commitment) {
   onMounted(() => {
     void refresh().catch(() => void 0);
   });
+  onScopeDispose(() => {
+    refreshId += 1;
+  });
   watch(
-    () => toValue(address),
+    () => addresses.map((address) => toValue(address)),
     () => {
       void refresh().catch(() => void 0);
     }
   );
-  return {
-    balance,
-    loading,
-    error,
-    refresh
-  };
+  return { data, loading, error, refresh };
 }
 
-export { useBalance as u };
+export { useAddressRead as u };

package/dist/shared/vue.BxtOHzY_.mjs

@@ -0,0 +1,27 @@
+import { u as useClientAction } from './vue.CGv0ip3w.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 = {
+  error: "error",
+  idle: "idle",
+  success: "sent",
+  working: "sending"
+};
+function useSendTransaction() {
+  return useClientAction({
+    capability: "sendTransaction",
+    hookName: "useSendTransaction",
+    providerHint: SENDING_PROVIDER_HINT,
+    statuses: SEND_STATUSES
+  });
+}
+function useSendTransactions() {
+  return useClientAction({
+    capability: "sendTransactions",
+    hookName: "useSendTransactions",
+    providerHint: SENDING_PROVIDER_HINT,
+    statuses: SEND_STATUSES
+  });
+}
+
+export { useSendTransactions as a, useSendTransaction as u };

package/dist/shared/vue.C1JbUTpJ.mjs

@@ -0,0 +1,66 @@
+import { SolanaError, normalizeSolanaError } from '@vue-solana/core/errors';
+import { withSolanaTimeout } from '@vue-solana/core/timeout';
+import { createNoWalletSelectedError, assertWalletCanSignAndSendTransactions } 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';
+
+const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
+class PartialSignAndSendError extends SolanaError {
+  constructor(cause, signatures) {
+    super(cause.code, cause.message, { cause: cause.cause, feature: cause.feature });
+    this.signatures = signatures;
+    this.name = "PartialSignAndSendError";
+  }
+}
+function useSignAndSendTransactions() {
+  const { wallet } = useWallet();
+  const signatures = shallowRef(null);
+  const { status, loading, error, execute } = useExecution("sending");
+  function send(transactions, options) {
+    signatures.value = null;
+    return execute(
+      async () => {
+        const activeWallet = wallet.value;
+        if (!activeWallet) {
+          throw createNoWalletSelectedError();
+        }
+        assertWalletCanSignAndSendTransactions(activeWallet);
+        const sendSingularSequentially = async () => {
+          const collected = [];
+          for (const transaction of transactions) {
+            try {
+              const result = await activeWallet.signAndSendTransaction(transaction, options);
+              collected.push(result.signature);
+            } catch (cause) {
+              throw new PartialSignAndSendError(
+                normalizeSolanaError(cause, "RPC_FAILURE"),
+                collected
+              );
+            }
+          }
+          return collected;
+        };
+        const send2 = withSolanaTimeout(
+          activeWallet.signAndSendTransactions ? activeWallet.signAndSendTransactions(transactions, options) : sendSingularSequentially(),
+          SIGN_AND_SEND_TIMEOUT_MS,
+          "Wallet transaction did not return a result. Check your wallet or explorer for the final status."
+        );
+        return await send2;
+      },
+      (result) => {
+        signatures.value = result;
+        return "sent";
+      }
+    );
+  }
+  return {
+    signatures,
+    status,
+    loading,
+    error,
+    execute: send
+  };
+}
+
+export { PartialSignAndSendError as P, useSignAndSendTransactions as u };

package/dist/shared/vue.C9OOmvkD.mjs

@@ -0,0 +1,36 @@
+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';
+
+function useSignIn() {
+  const { wallet } = useWallet();
+  const signInResult = shallowRef(null);
+  const { status, loading, error, execute } = useExecution("signing-in");
+  function signIn(input) {
+    signInResult.value = null;
+    return execute(
+      async () => {
+        const activeWallet = wallet.value;
+        if (!activeWallet) {
+          throw createNoWalletSelectedError();
+        }
+        assertWalletCanSignIn(activeWallet);
+        return activeWallet.signIn(input);
+      },
+      (result) => {
+        signInResult.value = result;
+        return "signed-in";
+      }
+    );
+  }
+  return {
+    signInResult,
+    status,
+    loading,
+    error,
+    signIn
+  };
+}
+
+export { useSignIn as u };

package/dist/shared/vue.CGv0ip3w.mjs

@@ -0,0 +1,52 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, computed, ref, onScopeDispose } from 'vue';
+import { u as useClientCapability, M as MissingClientCapabilityError } from './vue.B9uRpSDJ.mjs';
+import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+
+function useClientAction(config) {
+  const { capability, hookName, providerHint, statuses } = config;
+  useClientCapability([capability, "payer"], { hookName, providerHint });
+  const { client } = useSolanaClient();
+  const data = shallowRef(null);
+  const status = shallowRef(statuses.idle);
+  const loading = computed(() => status.value === statuses.working);
+  const error = ref(null);
+  let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  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;
+    const currentExecutionId = ++executionId;
+    status.value = statuses.working;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = options.abortSignal ? AbortSignal.any([controller.signal, options.abortSignal]) : controller.signal;
+      const result = await method(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = statuses.success;
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = statuses.error;
+      }
+      throw normalizedError;
+    }
+  }
+  return { data, status, loading, error, execute };
+}
+
+export { useClientAction as u };