@vue-solana/vue 2.2.0 → 2.3.0

package/README.md

@@ -116,6 +116,28 @@ import { useWallet } from "@vue-solana/vue/useWallet";
 import { useSignMessage } from "@vue-solana/vue/useSignMessage";
 ```
 
+### Client and Plugin Lifecycle
+
+`createSolanaPlugin()` builds the Kit client once, during `install()`. Create the plugin at module scope and reuse the instance:
+
+```ts
+// solana.ts
+import { createSolanaPlugin } from "@vue-solana/vue";
+
+export const solana = createSolanaPlugin({ cluster: "devnet" });
+```
+
+Calling `createSolanaPlugin()` again builds a new client and context, discarding the existing wallet selection and RPC state. If your config is reactive — a cluster toggle, for example — memoize on the config so a new plugin (and client) is built only when the value actually changes, not on every render:
+
+```ts
+import { computed, ref } from "vue";
+
+const cluster = ref<SolanaCluster>("devnet");
+const plugin = computed(() => createSolanaPlugin({ cluster: cluster.value }));
+```
+
+A Kit client runs its `createClient().use(...)` plugins during construction. When one of those plugins is async, the client — and any context built from it — only activates after that promise resolves. Defer real RPC and wallet work to client lifecycle hooks or user actions after hydration rather than running it during setup or SSR.
+
 For development, use `devnet` and request free test SOL from the official faucet:
 
 ```txt
@@ -315,6 +337,106 @@ await confirmation.confirm(signature);
 
 `useSignAndSendTransaction()` also clears `loading` if a wallet adapter never returns a result. In that stale case, `error` is set and the chain status may be unknown, so check the connected wallet or an explorer before retrying.
 
+### 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.
+
+```ts
+import { compileTransaction, getTransactionEncoder } from "@solana/kit";
+
+const transaction: Uint8Array = getTransactionEncoder().encode(compileTransaction(message));
+await execute(transaction);
+```
+
+`useSignMessage()` takes the raw message bytes to sign. Every wallet send request also accepts the Kit `SendTransactionOptions`:
+
+| Option                | Description                                                                                                   |
+| --------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `skipPreflight`       | Skip preflight simulation before sending.                                                                     |
+| `maxRetries`          | RPC node retry count (`bigint`).                                                                              |
+| `minContextSlot`      | Slot at which any blockhash or nonce in the transaction is known to exist; sending before it can be rejected. |
+| `preflightCommitment` | Commitment used for preflight simulation.                                                                     |
+
+Return shapes:
+
+- `useSignMessage().execute(bytes)` resolves to `{ signedMessage, signature }`, both `Uint8Array`.
+- `useSignTransactions().execute(transactions)` resolves to the signed `Uint8Array[]` (also exposed as `signedTransactions`); pass a single-element array for one transaction.
+- `useSignAndSendTransaction().execute(transaction)` resolves to the submitted `signature` string; with `confirm: true` it also fills `confirmation`.
+- `useSignAndSendTransactions().execute(transactions)` resolves to a `string[]` of signatures (also exposed as `signatures`).
+
+A wallet may modify the message or transaction before signing — for example to add its own instruction or change the fee payer — and the Wallet Standard explicitly allows it. Re-read the returned `signedMessage` or signed transaction bytes instead of assuming they match your input byte-for-byte.
+
+### Sending with the Client (no wallet popup)
+
+`useSendTransaction()` and `useSendTransactions()` send through the Kit client's transaction-sending capability (`ClientWithTransactionSending`) instead of the connected wallet. The client plans the transaction from your input, signs it with its own signers — typically the client identity or `payer` keypair, e.g. a relayer — submits it, and returns the result. There is no wallet extension and no approval popup.
+
+**Which to use:**
+
+| Flow                  | `useSendTransaction(s)` (client)                             | `useSignAndSendTransaction(s)` (wallet)   |
+| --------------------- | ------------------------------------------------------------ | ----------------------------------------- |
+| Who authorizes        | The client's fee payer / signer keypairs                     | The connected wallet (user approves)      |
+| Environment           | Server-side, relayer, or automated flows (no browser wallet) | Browser dapps where the user must approve |
+| Popup                 | None                                                         | Wallet approval popup / mobile handoff    |
+| Input                 | Instructions, instruction plans, transaction messages, plans | Raw transaction bytes (`Uint8Array`)      |
+| Multiple transactions | Yes, as a batch in one call                                  | Yes, one or more wallet requests          |
+
+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.
+
+**Prerequisite.** Your Kit client must install a transaction planner and a transaction-sending executor, e.g. `rpcTransactionPlanner()` and `rpcTransactionPlanSendingExecutor()` from `@solana/kit-plugin-rpc`. The default client built by `createSolanaPlugin()` installs only RPC and airdrop plugins, so without a capable client both composables fail fast at setup with a clear capability error naming what to install. Plan first with `usePlanTransaction()` / `usePlanTransactions()` when you need separate planning and sending steps.
+
+```ts
+import { useSendTransaction } from "@vue-solana/vue/useSendTransaction";
+import { useSendTransactions } from "@vue-solana/vue/useSendTransactions";
+
+const single = useSendTransaction();
+const batch = useSendTransactions();
+```
+
+`useSendTransaction().execute()` accepts flexible input and resolves to the successful transaction result:
+
+```ts
+const { data, status, error, execute } = useSendTransaction();
+
+// A raw list of instructions
+await execute(instructions);
+
+// A planned instruction plan or a single transaction plan
+await execute(plan);
+
+// A single transaction message
+await execute(transactionMessage);
+
+// data.context.signature is the submitted Signature
+```
+
+`useSendTransactions().execute()` plans, signs, and sends one or more messages at once — parallel where possible, sequential where dependencies require it — and resolves to the full plan result tree:
+
+```ts
+const { data, status, error, execute } = useSendTransactions();
+
+// A batch of transaction messages
+await execute([messageA, messageB]);
+
+// A message, a plan, or a nested batch of messages/plans
+await execute(nestedBatch);
+```
+
+Both composables surface `status` (`idle`, `sending`, `sent`, `error`), `loading`, `error`, and `data`. Starting a new `execute()` while one is in flight aborts the previous call; the stale attempt rejects and its state is discarded. Pass an `{ abortSignal }` to additionally cancel from outside (unmounting the owning component also aborts in-flight work).
+
+Because signing keypairs live on the client, reserve `useSendTransaction(s)` for trusted contexts (your relayer, automated flows). Do not register app-signing keypairs on a client exposed to end-user browsers, where a compromised page could spend funds.
+
+Superseded or aborted attempts reject with a wrapped error. To tell "superseded or cancelled" apart from a real failure, inspect the rejection's `cause`:
+
+```ts
+try {
+  await execute(instructions);
+} catch (cause) {
+  if (cause?.cause instanceof DOMException && cause.cause.name === "AbortError") {
+    // superseded by a newer call or cancelled via abortSignal / unmount
+  }
+}
+```
+
 ### Live Data
 
 `useRequest()` fetches once per change and revalidates stale data in the background. Pass a request function, a pending Kit RPC request, or a ref/computed of either:
@@ -494,6 +616,8 @@ Docs: [Vue Solana Agent Skill](https://vue-solana-docs.vercel.app/agent-skill)
 | `useIdentity()`                                                                            | Reactive Kit client `identity` signer ref (requires a signer plugin on the client).                                        |
 | `usePlanTransaction()`                                                                     | Plans a single transaction message from instruction inputs without signing or sending.                                     |
 | `usePlanTransactions()`                                                                    | Plans a batch of transaction messages from instruction inputs.                                                             |
+| `useSendTransaction()`                                                                     | Plans, signs, submits, and confirms one transaction through the client's transaction-sending capability (no wallet).       |
+| `useSendTransactions()`                                                                    | Sends a batch of transactions (parallel or sequential) through the client's transaction-sending capability.                |
 
 Direct composable subpaths:
 
@@ -527,6 +651,8 @@ Direct composable subpaths:
 - `@vue-solana/vue/useIdentity`
 - `@vue-solana/vue/usePlanTransaction`
 - `@vue-solana/vue/usePlanTransactions`
+- `@vue-solana/vue/useSendTransaction`
+- `@vue-solana/vue/useSendTransactions`
 
 Other direct subpaths:
 

package/dist/index.cjs

@@ -6,12 +6,13 @@ const useAirdrop = require('./shared/vue.CTqPbvz3.cjs');
 const useBalance = require('./shared/vue.E_npPFoV.cjs');
 const useClientCapability = require('./shared/vue.BY0qpgYr.cjs');
 const useConnection = require('./shared/vue.BVaMoz9y.cjs');
-const usePlanTransaction = require('./shared/vue.B4-LEdSE.cjs');
+const usePlanTransaction = require('./shared/vue.BfGt94sg.cjs');
 const useProgramAccounts = require('./shared/vue.Di7yjJ-R.cjs');
 const usePayer = require('./shared/vue.g8fnm_ca.cjs');
 const useRequest = require('./shared/vue.ZuUCEEab.cjs');
 const useRpc = require('./shared/vue.FiMmnMHr.cjs');
 const SelectedWalletAccountProvider = require('./shared/vue.DDbVk0Zh.cjs');
+const useSendTransaction = require('./shared/vue.BFbIDI66.cjs');
 const useSignMessage = require('./shared/vue.B6ainw2G.cjs');
 const useSignAndSendTransaction = require('./shared/vue.CWZSMVnB.cjs');
 const useSignTransactions = require('./shared/vue.DFaMJLAQ.cjs');
@@ -404,6 +405,8 @@ exports.createSelectedWalletAccountContext = SelectedWalletAccountProvider.creat
 exports.provideSelectedWalletAccount = SelectedWalletAccountProvider.provideSelectedWalletAccount;
 exports.selectedWalletAccountInjectionKey = SelectedWalletAccountProvider.selectedWalletAccountInjectionKey;
 exports.useSelectedWalletAccount = SelectedWalletAccountProvider.useSelectedWalletAccount;
+exports.useSendTransaction = useSendTransaction.useSendTransaction;
+exports.useSendTransactions = useSendTransaction.useSendTransactions;
 exports.useSignMessage = useSignMessage.useSignMessage;
 exports.useSignAndSendTransaction = useSignAndSendTransaction.useSignAndSendTransaction;
 exports.useSignTransactions = useSignTransactions.useSignTransactions;

package/dist/index.d.cts

@@ -10,6 +10,7 @@ export { useIdentity, usePayer } from './usePayer.cjs';
 export { UseRequestOptions, UseRequestRefresherOptions, UseRequestReturn, UseRequestSource, UseRequestStatus, useRequest } from './useRequest.cjs';
 export { useRpc } from './useRpc.cjs';
 export { SelectedWalletAccount, SelectedWalletAccountContext, SelectedWalletAccountOptions, SelectedWalletAccountProvider, WalletAccountFilter, createSelectedWalletAccountContext, provideSelectedWalletAccount, selectedWalletAccountInjectionKey, useSelectedWalletAccount } from './useSelectedWalletAccount.cjs';
+export { SendTransactionConfig, SendTransactionInput, SendTransactionStatus, SendTransactionsInput, useSendTransaction, useSendTransactions } from './useSendTransaction.cjs';
 export { SignMessageStatus, useSignMessage } from './useSignMessage.cjs';
 export { SignAndSendTransactionOptions, SignAndSendTransactionStatus, useSignAndSendTransaction } from './useSignAndSendTransaction.cjs';
 export { SignTransactionsStatus, useSignTransactions } from './useSignTransactions.cjs';

package/dist/index.d.mts

@@ -10,6 +10,7 @@ export { useIdentity, usePayer } from './usePayer.mjs';
 export { UseRequestOptions, UseRequestRefresherOptions, UseRequestReturn, UseRequestSource, UseRequestStatus, useRequest } from './useRequest.mjs';
 export { useRpc } from './useRpc.mjs';
 export { SelectedWalletAccount, SelectedWalletAccountContext, SelectedWalletAccountOptions, SelectedWalletAccountProvider, WalletAccountFilter, createSelectedWalletAccountContext, provideSelectedWalletAccount, selectedWalletAccountInjectionKey, useSelectedWalletAccount } from './useSelectedWalletAccount.mjs';
+export { SendTransactionConfig, SendTransactionInput, SendTransactionStatus, SendTransactionsInput, useSendTransaction, useSendTransactions } from './useSendTransaction.mjs';
 export { SignMessageStatus, useSignMessage } from './useSignMessage.mjs';
 export { SignAndSendTransactionOptions, SignAndSendTransactionStatus, useSignAndSendTransaction } from './useSignAndSendTransaction.mjs';
 export { SignTransactionsStatus, useSignTransactions } from './useSignTransactions.mjs';

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export { useIdentity, usePayer } from './usePayer.js';
 export { UseRequestOptions, UseRequestRefresherOptions, UseRequestReturn, UseRequestSource, UseRequestStatus, useRequest } from './useRequest.js';
 export { useRpc } from './useRpc.js';
 export { SelectedWalletAccount, SelectedWalletAccountContext, SelectedWalletAccountOptions, SelectedWalletAccountProvider, WalletAccountFilter, createSelectedWalletAccountContext, provideSelectedWalletAccount, selectedWalletAccountInjectionKey, useSelectedWalletAccount } from './useSelectedWalletAccount.js';
+export { SendTransactionConfig, SendTransactionInput, SendTransactionStatus, SendTransactionsInput, useSendTransaction, useSendTransactions } from './useSendTransaction.js';
 export { SignMessageStatus, useSignMessage } from './useSignMessage.js';
 export { SignAndSendTransactionOptions, SignAndSendTransactionStatus, useSignAndSendTransaction } from './useSignAndSendTransaction.js';
 export { SignTransactionsStatus, useSignTransactions } from './useSignTransactions.js';

package/dist/index.mjs

@@ -4,12 +4,13 @@ export { u as useAirdrop } from './shared/vue.BSfiHqwj.mjs';
 export { u as useBalance } from './shared/vue.BINkrA8h.mjs';
 export { M as MissingClientCapabilityError, u as useClientCapability } from './shared/vue.B8LptjZP.mjs';
 export { u as useConnection } from './shared/vue.CpkwC8Th.mjs';
-export { u as usePlanTransaction, a as usePlanTransactions } from './shared/vue.C5FVoEZT.mjs';
+export { u as usePlanTransaction, a as usePlanTransactions } from './shared/vue.C4hGlFC8.mjs';
 export { u as useProgramAccounts } from './shared/vue.C13umiQi.mjs';
 export { u as useIdentity, a as usePayer } from './shared/vue.CATOh_9G.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.DXQVIRZA.mjs';
+export { u as useSendTransaction, a as useSendTransactions } from './shared/vue.DT4vCUa6.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';

package/dist/shared/vue.BFbIDI66.cjs

@@ -0,0 +1,121 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const vue = require('vue');
+const useClientCapability = require('./vue.BY0qpgYr.cjs');
+const useSolanaClient = require('./vue.BIxphCAq.cjs');
+
+const SENDING_PROVIDER_HINT = "Install a transaction planner and a transaction-sending executor plugin, e.g. `createClient().use(rpcTransactionPlanner()).use(rpcTransactionPlanSendingExecutor())` from `@solana/kit-plugin-rpc`.";
+function useSendTransaction() {
+  useClientCapability.useClientCapability(["sendTransaction"], {
+    hookName: "useSendTransaction",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient.useSolanaClient();
+  const data = vue.shallowRef(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransaction(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+function useSendTransactions() {
+  useClientCapability.useClientCapability(["sendTransactions"], {
+    hookName: "useSendTransactions",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient.useSolanaClient();
+  const data = vue.shallowRef(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransactions(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+exports.useSendTransaction = useSendTransaction;
+exports.useSendTransactions = useSendTransactions;

package/dist/shared/{vue.B4-LEdSE.cjs → vue.BfGt94sg.cjs}

@@ -16,7 +16,15 @@ function usePlanTransaction() {
   const loading = vue.ref(false);
   const error = vue.ref(null);
   let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -24,7 +32,8 @@ function usePlanTransaction() {
     error.value = null;
     transactionMessage.value = null;
     try {
-      const message = await planner.planTransaction(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const message = await planner.planTransaction(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionMessage.value = message;
         status.value = "planned";
@@ -62,7 +71,15 @@ function usePlanTransactions() {
   const loading = vue.ref(false);
   const error = vue.ref(null);
   let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -70,7 +87,8 @@ function usePlanTransactions() {
     error.value = null;
     transactionPlan.value = null;
     try {
-      const plan = await planner.planTransactions(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const plan = await planner.planTransactions(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionPlan.value = plan;
         status.value = "planned";

package/dist/shared/{vue.C5FVoEZT.mjs → vue.C4hGlFC8.mjs}

@@ -1,5 +1,5 @@
 import { normalizeSolanaError } from '@vue-solana/core/errors';
-import { shallowRef, ref } from 'vue';
+import { shallowRef, ref, onScopeDispose } from 'vue';
 import { u as useClientCapability } from './vue.B8LptjZP.mjs';
 import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
 
@@ -14,7 +14,15 @@ function usePlanTransaction() {
   const loading = ref(false);
   const error = ref(null);
   let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -22,7 +30,8 @@ function usePlanTransaction() {
     error.value = null;
     transactionMessage.value = null;
     try {
-      const message = await planner.planTransaction(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const message = await planner.planTransaction(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionMessage.value = message;
         status.value = "planned";
@@ -60,7 +69,15 @@ function usePlanTransactions() {
   const loading = ref(false);
   const error = ref(null);
   let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -68,7 +85,8 @@ function usePlanTransactions() {
     error.value = null;
     transactionPlan.value = null;
     try {
-      const plan = await planner.planTransactions(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const plan = await planner.planTransactions(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionPlan.value = plan;
         status.value = "planned";

package/dist/shared/vue.DT4vCUa6.mjs

@@ -0,0 +1,118 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, ref, onScopeDispose } from 'vue';
+import { u as useClientCapability } from './vue.B8LptjZP.mjs';
+import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+
+const SENDING_PROVIDER_HINT = "Install a transaction planner and a transaction-sending executor plugin, e.g. `createClient().use(rpcTransactionPlanner()).use(rpcTransactionPlanSendingExecutor())` from `@solana/kit-plugin-rpc`.";
+function useSendTransaction() {
+  useClientCapability(["sendTransaction"], {
+    hookName: "useSendTransaction",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient();
+  const data = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransaction(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+function useSendTransactions() {
+  useClientCapability(["sendTransactions"], {
+    hookName: "useSendTransactions",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient();
+  const data = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransactions(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+export { useSendTransactions as a, useSendTransaction as u };

package/dist/usePlanTransaction.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const usePlanTransaction = require('./shared/vue.B4-LEdSE.cjs');
+const usePlanTransaction = require('./shared/vue.BfGt94sg.cjs');
 require('@vue-solana/core/errors');
 require('vue');
 require('./shared/vue.BY0qpgYr.cjs');

package/dist/usePlanTransaction.d.cts

@@ -12,6 +12,10 @@ interface PlanTransactionConfig {
  * (e.g. `rpcTransactionPlanner` from `@solana/kit-plugin-rpc`).
  *
  * Rejects with a clear capability error when the client does not plan.
+ *
+ * Calling `execute` while a prior execution is in flight aborts the prior call;
+ * the superseded attempt rejects, so check its `error.cause` to tell it apart
+ * from a real failure.
  */
 declare function usePlanTransaction(): {
     transactionMessage: vue.ShallowRef<TransactionMessage | null, TransactionMessage | null>;

package/dist/usePlanTransaction.d.mts

@@ -12,6 +12,10 @@ interface PlanTransactionConfig {
  * (e.g. `rpcTransactionPlanner` from `@solana/kit-plugin-rpc`).
  *
  * Rejects with a clear capability error when the client does not plan.
+ *
+ * Calling `execute` while a prior execution is in flight aborts the prior call;
+ * the superseded attempt rejects, so check its `error.cause` to tell it apart
+ * from a real failure.
  */
 declare function usePlanTransaction(): {
     transactionMessage: vue.ShallowRef<TransactionMessage | null, TransactionMessage | null>;

package/dist/usePlanTransaction.d.ts

@@ -12,6 +12,10 @@ interface PlanTransactionConfig {
  * (e.g. `rpcTransactionPlanner` from `@solana/kit-plugin-rpc`).
  *
  * Rejects with a clear capability error when the client does not plan.
+ *
+ * Calling `execute` while a prior execution is in flight aborts the prior call;
+ * the superseded attempt rejects, so check its `error.cause` to tell it apart
+ * from a real failure.
  */
 declare function usePlanTransaction(): {
     transactionMessage: vue.ShallowRef<TransactionMessage | null, TransactionMessage | null>;

package/dist/usePlanTransaction.mjs

@@ -1,4 +1,4 @@
-export { u as usePlanTransaction, a as usePlanTransactions } from './shared/vue.C5FVoEZT.mjs';
+export { u as usePlanTransaction, a as usePlanTransactions } from './shared/vue.C4hGlFC8.mjs';
 import '@vue-solana/core/errors';
 import 'vue';
 import './shared/vue.B8LptjZP.mjs';

package/dist/usePlanTransactions.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const usePlanTransaction = require('./shared/vue.B4-LEdSE.cjs');
+const usePlanTransaction = require('./shared/vue.BfGt94sg.cjs');
 require('@vue-solana/core/errors');
 require('vue');
 require('./shared/vue.BY0qpgYr.cjs');

package/dist/usePlanTransactions.mjs

@@ -1,4 +1,4 @@
-export { a as usePlanTransactions } from './shared/vue.C5FVoEZT.mjs';
+export { a as usePlanTransactions } from './shared/vue.C4hGlFC8.mjs';
 import '@vue-solana/core/errors';
 import 'vue';
 import './shared/vue.B8LptjZP.mjs';

package/dist/useSendTransaction.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const useSendTransaction = require('./shared/vue.BFbIDI66.cjs');
+require('@vue-solana/core/errors');
+require('vue');
+require('./shared/vue.BY0qpgYr.cjs');
+require('./shared/vue.BIxphCAq.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
+
+
+
+exports.useSendTransaction = useSendTransaction.useSendTransaction;
+exports.useSendTransactions = useSendTransaction.useSendTransactions;

package/dist/useSendTransaction.d.cts

@@ -0,0 +1,46 @@
+import * as vue from 'vue';
+import { InstructionPlanInput, SingleTransactionPlan, TransactionPlanInput, SuccessfulSingleTransactionPlanResult, TransactionPlanResult } from '@vue-solana/core/kit';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SendTransactionStatus = "idle" | "sending" | "sent" | "error";
+interface SendTransactionConfig {
+    abortSignal?: AbortSignal;
+}
+type SendTransactionInput = InstructionPlanInput | SingleTransactionPlan | SingleTransactionPlan["message"];
+type SendTransactionsInput = InstructionPlanInput | TransactionPlanInput;
+/**
+ * Plan, sign with the client's signers (payer/identity), submit, and confirm
+ * a single transaction — all through the client's transaction-sending
+ * capability (`ClientWithTransactionSending`), with no wallet popup.
+ *
+ * Accepts flexible input: instructions, an instruction plan, a transaction
+ * message, or a single transaction plan.
+ *
+ * Rejects with a clear capability error when the client cannot send.
+ *
+ * Calling `execute` while a prior execution is in flight aborts the prior call;
+ * the superseded attempt rejects, so check its `error.cause` to tell it apart
+ * from a real failure.
+ */
+declare function useSendTransaction(): {
+    data: vue.ShallowRef<SuccessfulSingleTransactionPlanResult | null, SuccessfulSingleTransactionPlanResult | null>;
+    status: vue.Ref<SendTransactionStatus, SendTransactionStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (input: SendTransactionInput, config?: SendTransactionConfig) => Promise<SuccessfulSingleTransactionPlanResult>;
+};
+/**
+ * Plan, sign, submit, and confirm one or more transactions — possibly a batch
+ * of messages, executed in parallel or sequentially as the plan dictates —
+ * through the client's transaction-sending capability.
+ */
+declare function useSendTransactions(): {
+    data: vue.ShallowRef<TransactionPlanResult | null, TransactionPlanResult | null>;
+    status: vue.Ref<SendTransactionStatus, SendTransactionStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (input: SendTransactionsInput, config?: SendTransactionConfig) => Promise<TransactionPlanResult>;
+};
+
+export { useSendTransaction, useSendTransactions };
+export type { SendTransactionConfig, SendTransactionInput, SendTransactionStatus, SendTransactionsInput };

package/dist/useSendTransaction.d.mts

@@ -0,0 +1,46 @@
+import * as vue from 'vue';
+import { InstructionPlanInput, SingleTransactionPlan, TransactionPlanInput, SuccessfulSingleTransactionPlanResult, TransactionPlanResult } from '@vue-solana/core/kit';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SendTransactionStatus = "idle" | "sending" | "sent" | "error";
+interface SendTransactionConfig {
+    abortSignal?: AbortSignal;
+}
+type SendTransactionInput = InstructionPlanInput | SingleTransactionPlan | SingleTransactionPlan["message"];
+type SendTransactionsInput = InstructionPlanInput | TransactionPlanInput;
+/**
+ * Plan, sign with the client's signers (payer/identity), submit, and confirm
+ * a single transaction — all through the client's transaction-sending
+ * capability (`ClientWithTransactionSending`), with no wallet popup.
+ *
+ * Accepts flexible input: instructions, an instruction plan, a transaction
+ * message, or a single transaction plan.
+ *
+ * Rejects with a clear capability error when the client cannot send.
+ *
+ * Calling `execute` while a prior execution is in flight aborts the prior call;
+ * the superseded attempt rejects, so check its `error.cause` to tell it apart
+ * from a real failure.
+ */
+declare function useSendTransaction(): {
+    data: vue.ShallowRef<SuccessfulSingleTransactionPlanResult | null, SuccessfulSingleTransactionPlanResult | null>;
+    status: vue.Ref<SendTransactionStatus, SendTransactionStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (input: SendTransactionInput, config?: SendTransactionConfig) => Promise<SuccessfulSingleTransactionPlanResult>;
+};
+/**
+ * Plan, sign, submit, and confirm one or more transactions — possibly a batch
+ * of messages, executed in parallel or sequentially as the plan dictates —
+ * through the client's transaction-sending capability.
+ */
+declare function useSendTransactions(): {
+    data: vue.ShallowRef<TransactionPlanResult | null, TransactionPlanResult | null>;
+    status: vue.Ref<SendTransactionStatus, SendTransactionStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (input: SendTransactionsInput, config?: SendTransactionConfig) => Promise<TransactionPlanResult>;
+};
+
+export { useSendTransaction, useSendTransactions };
+export type { SendTransactionConfig, SendTransactionInput, SendTransactionStatus, SendTransactionsInput };

package/dist/useSendTransaction.d.ts

@@ -0,0 +1,46 @@
+import * as vue from 'vue';
+import { InstructionPlanInput, SingleTransactionPlan, TransactionPlanInput, SuccessfulSingleTransactionPlanResult, TransactionPlanResult } from '@vue-solana/core/kit';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SendTransactionStatus = "idle" | "sending" | "sent" | "error";
+interface SendTransactionConfig {
+    abortSignal?: AbortSignal;
+}
+type SendTransactionInput = InstructionPlanInput | SingleTransactionPlan | SingleTransactionPlan["message"];
+type SendTransactionsInput = InstructionPlanInput | TransactionPlanInput;
+/**
+ * Plan, sign with the client's signers (payer/identity), submit, and confirm
+ * a single transaction — all through the client's transaction-sending
+ * capability (`ClientWithTransactionSending`), with no wallet popup.
+ *
+ * Accepts flexible input: instructions, an instruction plan, a transaction
+ * message, or a single transaction plan.
+ *
+ * Rejects with a clear capability error when the client cannot send.
+ *
+ * Calling `execute` while a prior execution is in flight aborts the prior call;
+ * the superseded attempt rejects, so check its `error.cause` to tell it apart
+ * from a real failure.
+ */
+declare function useSendTransaction(): {
+    data: vue.ShallowRef<SuccessfulSingleTransactionPlanResult | null, SuccessfulSingleTransactionPlanResult | null>;
+    status: vue.Ref<SendTransactionStatus, SendTransactionStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (input: SendTransactionInput, config?: SendTransactionConfig) => Promise<SuccessfulSingleTransactionPlanResult>;
+};
+/**
+ * Plan, sign, submit, and confirm one or more transactions — possibly a batch
+ * of messages, executed in parallel or sequentially as the plan dictates —
+ * through the client's transaction-sending capability.
+ */
+declare function useSendTransactions(): {
+    data: vue.ShallowRef<TransactionPlanResult | null, TransactionPlanResult | null>;
+    status: vue.Ref<SendTransactionStatus, SendTransactionStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (input: SendTransactionsInput, config?: SendTransactionConfig) => Promise<TransactionPlanResult>;
+};
+
+export { useSendTransaction, useSendTransactions };
+export type { SendTransactionConfig, SendTransactionInput, SendTransactionStatus, SendTransactionsInput };

package/dist/useSendTransaction.mjs

@@ -0,0 +1,7 @@
+export { u as useSendTransaction, a as useSendTransactions } from './shared/vue.DT4vCUa6.mjs';
+import '@vue-solana/core/errors';
+import 'vue';
+import './shared/vue.B8LptjZP.mjs';
+import './shared/vue.Mxc8w6Qk.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useSendTransactions.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const useSendTransaction = require('./shared/vue.BFbIDI66.cjs');
+require('@vue-solana/core/errors');
+require('vue');
+require('./shared/vue.BY0qpgYr.cjs');
+require('./shared/vue.BIxphCAq.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
+
+
+
+exports.useSendTransactions = useSendTransaction.useSendTransactions;

package/dist/useSendTransactions.d.cts

@@ -0,0 +1,4 @@
+export { useSendTransactions } from './useSendTransaction.cjs';
+import 'vue';
+import '@vue-solana/core/kit';
+import '@vue-solana/core/errors';

package/dist/useSendTransactions.d.mts

@@ -0,0 +1,4 @@
+export { useSendTransactions } from './useSendTransaction.mjs';
+import 'vue';
+import '@vue-solana/core/kit';
+import '@vue-solana/core/errors';

package/dist/useSendTransactions.d.ts

@@ -0,0 +1,4 @@
+export { useSendTransactions } from './useSendTransaction.js';
+import 'vue';
+import '@vue-solana/core/kit';
+import '@vue-solana/core/errors';

package/dist/useSendTransactions.mjs

@@ -0,0 +1,7 @@
+export { a as useSendTransactions } from './shared/vue.DT4vCUa6.mjs';
+import '@vue-solana/core/errors';
+import 'vue';
+import './shared/vue.B8LptjZP.mjs';
+import './shared/vue.Mxc8w6Qk.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue-solana/vue",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Vue plugin and composables for Solana applications.",
   "license": "MIT",
   "keywords": [
@@ -105,6 +105,16 @@
       "import": "./dist/usePlanTransactions.mjs",
       "require": "./dist/usePlanTransactions.cjs"
     },
+    "./useSendTransaction": {
+      "types": "./dist/useSendTransaction.d.ts",
+      "import": "./dist/useSendTransaction.mjs",
+      "require": "./dist/useSendTransaction.cjs"
+    },
+    "./useSendTransactions": {
+      "types": "./dist/useSendTransactions.d.ts",
+      "import": "./dist/useSendTransactions.mjs",
+      "require": "./dist/useSendTransactions.cjs"
+    },
     "./swr": {
       "types": "./dist/swr.d.ts",
       "import": "./dist/swr.mjs",
@@ -204,7 +214,7 @@
   },
   "dependencies": {
     "bs58": "^6.0.0",
-    "@vue-solana/core": "2.2.0"
+    "@vue-solana/core": "2.3.0"
   },
   "peerDependencies": {
     "vue": "^3.5.0"