@vue-solana/vue 2.2.0 → 2.4.0

package/README.md

@@ -33,16 +33,17 @@ New to Solana? Start with the official docs and the project concepts guide:
 - Live data composables over Kit reactive stores (`useRequest`, `useSubscription`, `useTrackedData`) plus SWR cache adapters.
 - A generic async action state machine (`useAction`) built on `@vue-solana/core/action`.
 - Reactive Kit client signers (`usePayer`, `useIdentity`) and transaction planning (`usePlanTransaction`, `usePlanTransactions`) with fail-fast client capability assertions.
+- Client-sent transactions through the official Kit planner and RPC plan-sending executor installed by the default client.
 - Direct subpath exports for narrower imports.
 
 ## Compatibility
 
-| Requirement   | Supported                                       |
-| ------------- | ----------------------------------------------- |
-| Vue           | `^3.5.0`                                        |
-| TypeScript    | TypeScript 5.x recommended                      |
-| Solana client | Provided through `@vue-solana/core`             |
-| Clusters      | `mainnet-beta`, `devnet`, `testnet`, `localnet` |
+| Requirement   | Supported                                                         |
+| ------------- | ----------------------------------------------------------------- |
+| Vue           | `^3.5.0`                                                          |
+| TypeScript    | TypeScript 5.x recommended                                        |
+| Solana client | Provided through `@vue-solana/core`                               |
+| Clusters      | `mainnet` (alias `mainnet-beta`), `devnet`, `testnet`, `localnet` |
 
 ## Install
 
@@ -86,27 +87,31 @@ You can also pass a custom RPC endpoint:
 ```ts
 createApp(App).use(
   createSolanaPlugin({
-    cluster: "mainnet-beta",
+    cluster: "mainnet",
     endpoint: "https://your-rpc.example.com",
     commitment: "confirmed",
   }),
 );
 ```
 
-Supported clusters are `mainnet-beta`, `devnet`, `testnet`, and `localnet`. Use `mainnet-beta` for Solana mainnet; this is Solana's official cluster name.
+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.
 
 ### Plugin Options
 
-| Option         | Type                                                    | Default                              | Description                                                                                   |
-| -------------- | ------------------------------------------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------- |
-| `cluster`      | `"mainnet-beta" \| "devnet" \| "testnet" \| "localnet"` | `"devnet"`                           | Solana cluster used when `endpoint` is omitted.                                               |
-| `endpoint`     | `string`                                                | Public endpoint for `cluster`        | HTTP RPC endpoint. Use a dedicated RPC provider for production apps.                          |
-| `wsEndpoint`   | `string`                                                | Derived from `endpoint`              | WebSocket RPC endpoint.                                                                       |
-| `commitment`   | Solana commitment                                       | Solana client default                | Default commitment for created connections.                                                   |
-| `autoConnect`  | `boolean`                                               | `false`                              | Reconnects only a previously selected discovered wallet identity when it is discovered again. |
-| `wallet`       | `SolanaWallet`                                          | Disabled                             | Custom wallet adapter, useful for tests or custom integrations.                               |
-| `mobileWallet` | `MobileWalletOptions \| false`                          | Enabled on supported Android clients | Configures or disables Android Mobile Wallet Adapter registration.                            |
-| `iosWallet`    | `iOSWalletOptions \| false`                             | Enabled on iOS browsers              | Configures or disables iOS browser wallet universal links (Phantom, Solflare, Backpack).      |
+| Option           | Type                                                                 | Default                              | Description                                                                                   |
+| ---------------- | -------------------------------------------------------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------- |
+| `cluster`        | `"mainnet" \| "mainnet-beta" \| "devnet" \| "testnet" \| "localnet"` | `"devnet"`                           | Solana cluster used when `endpoint` is omitted.                                               |
+| `endpoint`       | `string`                                                             | Public endpoint for `cluster`        | HTTP RPC endpoint. Use a dedicated RPC provider for production apps.                          |
+| `wsEndpoint`     | `string`                                                             | Derived from `endpoint`              | WebSocket RPC endpoint.                                                                       |
+| `commitment`     | Solana commitment                                                    | Solana client default                | Default commitment for created connections.                                                   |
+| `autoConnect`    | `boolean`                                                            | `false`                              | Reconnects only a previously selected discovered wallet identity when it is discovered again. |
+| `payer`          | `TransactionSigner`                                                  | None                                 | Client fee payer and signer for client-sent transactions.                                     |
+| `payerSecretKey` | `string`                                                             | None                                 | Base64 64-byte Ed25519 keypair, secret key first, resolved at client creation.                |
+| `wallet`         | `SolanaWallet`                                                       | Disabled                             | Custom wallet adapter, useful for tests or custom integrations.                               |
+| `mobileWallet`   | `MobileWalletOptions \| false`                                       | Enabled on supported Android clients | Configures or disables Android Mobile Wallet Adapter registration.                            |
+| `iosWallet`      | `iOSWalletOptions \| false`                                          | Enabled on iOS browsers              | Configures or disables iOS browser wallet universal links (Phantom, Solflare, Backpack).      |
 
 The root export remains supported. For composables, prefer direct subpath imports in new code so bundlers can avoid evaluating unrelated package entry code:
 
@@ -116,6 +121,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
@@ -166,7 +193,7 @@ const { balance, loading, error, refresh } = useBalance(address);
 
 ### Airdrop on Test Networks
 
-`useAirdrop()` sends SOL to an account on devnet, testnet, or a local validator. It requires an airdrop capability on the Kit client, installed with `createClient().use(solanaRpcConnection({ ... })).use(rpcAirdrop())` from `@solana/kit-plugin-rpc`.
+`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";
@@ -315,6 +342,108 @@ 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. The official executor waits for `confirmed` commitment before resolving.
+
+Configure a direct client with `payer` or `payerSecretKey`. `payerSecretKey` is a base64 64-byte Ed25519 keypair and must stay in a trusted server or development context. Never put it in Nuxt public runtime config or ship a funded key to an end-user browser.
+
+**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.
+
+**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`.
+
+```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:
@@ -457,43 +586,45 @@ Docs: [Vue Solana Agent Skill](https://vue-solana-docs.vercel.app/agent-skill)
 
 ## API
 
-| API                                                                                        | Description                                                                                                                |
-| ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
-| `createSolanaPlugin(options?)`                                                             | Installs the Vue Solana context.                                                                                           |
-| `VueSolana`                                                                                | Alias for `createSolanaPlugin`.                                                                                            |
-| `useSolana()`                                                                              | Returns the full injected Solana context.                                                                                  |
-| `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()`.                                                      |
-| `useWallet()`                                                                              | Returns wallet refs, computed connection state, and wallet actions.                                                        |
-| `useWallets()`                                                                             | Returns discovered browser extension wallets, Android MWA wallets, iOS browser wallet links, and wallet selection actions. |
-| `useSignMessage()`                                                                         | Signs arbitrary message bytes through the connected wallet when message signing is supported.                              |
-| `useBalance(address, commitment?)`                                                         | Loads lamport balance for an address string.                                                                               |
-| `useAirdrop()`                                                                             | Airdrops SOL on devnet/testnet/localnets; `data` is the `Signature`, or `undefined` when applied directly.                 |
-| `useAccountInfo(address, options?)`                                                        | Loads normalized account info (executable, lamports, owner, space, data bytes).                                            |
-| `useProgramAccounts(programId, config?)`                                                   | Loads accounts owned by a program with optional filters, commitment, and `dataSlice`.                                      |
-| `useTransaction(handler, options?)`                                                        | Generic async transaction state helper with optional timeout settings.                                                     |
-| `useTransactionConfirmation(options?)`                                                     | Confirms a submitted signature with reactive status and timeout/error state.                                               |
-| `useSignatureStatus(signature, options?)`                                                  | Reads a transaction signature status with optional polling.                                                                |
-| `useSignAndSendTransaction()`                                                              | Signs and sends a transaction through the configured wallet, with optional confirmation waiting.                           |
-| `useTokenAccounts(owner, options?)`                                                        | Reads SPL token accounts for an owner.                                                                                     |
-| `useTokenBalance(mint, owner, commitment?)`                                                | Reads the token balance for a mint/owner pair.                                                                             |
-| `useAction(handler, options?)`                                                             | Generic async action state machine; each dispatch aborts the prior in-flight call.                                         |
-| `useRequest(source, options?)`                                                             | One-shot Kit request that re-fires when its source changes, preserving the previous `data` while revalidating.             |
-| `useSubscription(source, options?)`                                                        | Live data over a Kit reactive stream store (e.g. RPC subscriptions), torn down on unmount.                                 |
-| `useTrackedData(source, options?)`                                                         | Slot-deduplicated fetch plus subscription over Kit's slot-tracking store.                                                  |
-| `useRequestSwr(key, ...)` / `useSubscriptionSwr(key, ...)` / `useTrackedDataSwr(key, ...)` | Cache-keyed SWR adapters seeding fresh mounts from the last-known result.                                                  |
-| `clearSwrCache()`                                                                          | Clears every cached SWR entry.                                                                                             |
-| `useSignIn(input?)`                                                                        | Sign In With Solana (SIWS) trigger returning `{ account, signedMessage, signature }` for server-side verification.         |
-| `useSelectedWalletAccount()`                                                               | App-wide selected wallet account context: `[selectedAccount, setSelectedAccount, filteredWallets]`.                        |
-| `SelectedWalletAccountProvider`                                                            | Component that provides the selected wallet account context to its subtree.                                                |
-| `useSignTransactions()`                                                                    | Batch-signs transactions through the wallet, preferring `signTransactions` and falling back to `signAllTransactions`.      |
-| `useSignAndSendTransactions()`                                                             | Signs and sends multiple transactions, returning one signature each, with a singular sequential fallback.                  |
-| `useClientCapability(capability, options?)`                                                | Fails fast with a clear error when the configured Solana client lacks a requested capability.                              |
-| `usePayer()`                                                                               | Reactive Kit client `payer` signer ref (requires a signer plugin on the client).                                           |
-| `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.                                                             |
+| API                                                                                        | Description                                                                                                                              |
+| ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `createSolanaPlugin(options?)`                                                             | Installs the Vue Solana context.                                                                                                         |
+| `VueSolana`                                                                                | Alias for `createSolanaPlugin`.                                                                                                          |
+| `useSolana()`                                                                              | Returns the full injected Solana context.                                                                                                |
+| `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()`.                                                                    |
+| `useWallet()`                                                                              | Returns wallet refs, computed connection state, and wallet actions.                                                                      |
+| `useWallets()`                                                                             | Returns discovered browser extension wallets, Android MWA wallets, iOS browser wallet links, and wallet selection actions.               |
+| `useSignMessage()`                                                                         | Signs arbitrary message bytes through the connected wallet when message signing is supported.                                            |
+| `useBalance(address, commitment?)`                                                         | Loads lamport balance for an address string.                                                                                             |
+| `useAirdrop()`                                                                             | Airdrops SOL on devnet/testnet/localnets; `data` is the `Signature`, or `undefined` when applied directly.                               |
+| `useAccountInfo(address, options?)`                                                        | Loads normalized account info (executable, lamports, owner, space, data bytes).                                                          |
+| `useProgramAccounts(programId, config?)`                                                   | Loads accounts owned by a program with optional filters, commitment, and `dataSlice`.                                                    |
+| `useTransaction(handler, options?)`                                                        | Generic async transaction state helper with optional timeout settings.                                                                   |
+| `useTransactionConfirmation(options?)`                                                     | Confirms a submitted signature with reactive status and timeout/error state.                                                             |
+| `useSignatureStatus(signature, options?)`                                                  | Reads a transaction signature status with optional polling.                                                                              |
+| `useSignAndSendTransaction()`                                                              | Signs and sends a transaction through the configured wallet, with optional confirmation waiting.                                         |
+| `useTokenAccounts(owner, options?)`                                                        | Reads SPL token accounts for an owner.                                                                                                   |
+| `useTokenBalance(mint, owner, commitment?)`                                                | Reads the token balance for a mint/owner pair.                                                                                           |
+| `useAction(handler, options?)`                                                             | Generic async action state machine; each dispatch aborts the prior in-flight call.                                                       |
+| `useRequest(source, options?)`                                                             | One-shot Kit request that re-fires when its source changes, preserving the previous `data` while revalidating.                           |
+| `useSubscription(source, options?)`                                                        | Live data over a Kit reactive stream store (e.g. RPC subscriptions), torn down on unmount.                                               |
+| `useTrackedData(source, options?)`                                                         | Slot-deduplicated fetch plus subscription over Kit's slot-tracking store.                                                                |
+| `useRequestSwr(key, ...)` / `useSubscriptionSwr(key, ...)` / `useTrackedDataSwr(key, ...)` | Cache-keyed SWR adapters seeding fresh mounts from the last-known result.                                                                |
+| `clearSwrCache()`                                                                          | Clears every cached SWR entry.                                                                                                           |
+| `useSignIn(input?)`                                                                        | Sign In With Solana (SIWS) trigger returning `{ account, signedMessage, signature }` for server-side verification.                       |
+| `useSelectedWalletAccount()`                                                               | App-wide selected wallet account context: `[selectedAccount, setSelectedAccount, filteredWallets]`.                                      |
+| `SelectedWalletAccountProvider`                                                            | Component that provides the selected wallet account context to its subtree.                                                              |
+| `useSignTransactions()`                                                                    | Batch-signs transactions through the wallet, preferring `signTransactions` and falling back to `signAllTransactions`.                    |
+| `useSignAndSendTransactions()`                                                             | Signs and sends multiple transactions, returning one signature each, with a singular sequential fallback.                                |
+| `useClientCapability(capability, options?)`                                                | Fails fast with a clear error when the configured Solana client lacks a requested capability.                                            |
+| `usePayer()`                                                                               | Reactive Kit client `payer` signer ref. The default client exposes a configured payer when supplied.                                     |
+| `useIdentity()`                                                                            | Reactive Kit client `identity` signer ref (requires an identity signer on a custom client).                                              |
+| `usePlanTransaction()`                                                                     | Plans a single transaction message from instruction inputs without signing or sending; the default client includes the official planner. |
+| `usePlanTransactions()`                                                                    | Plans a batch of transaction messages from instruction inputs.                                                                           |
+| `useSendTransaction()`                                                                     | Uses the official client transaction-sending capability to plan, sign, submit, and wait for `confirmed` commitment (no wallet).          |
+| `useSendTransactions()`                                                                    | Sends a batch through the same official capability, waiting for `confirmed` commitment.                                                  |
 
 Direct composable subpaths:
 
@@ -527,6 +658,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:
 
@@ -539,7 +672,7 @@ Other direct subpaths:
 - Wallet and RPC operations require the plugin-provided client context. Composables are SSR-safe, but real wallet work should run after hydration or in user actions.
 - 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-beta` for Solana mainnet. `mainnet` is intentionally not accepted as a cluster alias.
+- 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.
 - Desktop native app wallets are planned but not implemented yet.
 

package/dist/index.cjs

@@ -2,16 +2,17 @@
 
 const useAccountInfo = require('./shared/vue.D-qi8PSL.cjs');
 const useAction = require('./shared/vue.CoaIWGPT.cjs');
-const useAirdrop = require('./shared/vue.CTqPbvz3.cjs');
+const useAirdrop = require('./shared/vue.B4eMoJT2.cjs');
 const useBalance = require('./shared/vue.E_npPFoV.cjs');
-const useClientCapability = require('./shared/vue.BY0qpgYr.cjs');
+const useClientCapability = require('./shared/vue.4C5kX4fE.cjs');
 const useConnection = require('./shared/vue.BVaMoz9y.cjs');
-const usePlanTransaction = require('./shared/vue.B4-LEdSE.cjs');
+const usePlanTransaction = require('./shared/vue.Dn3KLJZH.cjs');
 const useProgramAccounts = require('./shared/vue.Di7yjJ-R.cjs');
-const usePayer = require('./shared/vue.g8fnm_ca.cjs');
+const usePayer = require('./shared/vue.ldvmk9NM.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.DKoM8jIV.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';
@@ -34,6 +35,7 @@ import { RegisterSolanaMobileWalletOptions } from '@vue-solana/core/mobile-walle
 import { SolanaConfig, SolanaWallet } from '@vue-solana/core/types';
 import { App } from 'vue';
 import '@vue-solana/core/errors';
+import '@solana/kit-plugin-rpc';
 import '@solana/kit';
 import '@vue-solana/core/token-accounts';
 

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';
@@ -34,6 +35,7 @@ import { RegisterSolanaMobileWalletOptions } from '@vue-solana/core/mobile-walle
 import { SolanaConfig, SolanaWallet } from '@vue-solana/core/types';
 import { App } from 'vue';
 import '@vue-solana/core/errors';
+import '@solana/kit-plugin-rpc';
 import '@solana/kit';
 import '@vue-solana/core/token-accounts';
 

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';
@@ -34,6 +35,7 @@ import { RegisterSolanaMobileWalletOptions } from '@vue-solana/core/mobile-walle
 import { SolanaConfig, SolanaWallet } from '@vue-solana/core/types';
 import { App } from 'vue';
 import '@vue-solana/core/errors';
+import '@solana/kit-plugin-rpc';
 import '@solana/kit';
 import '@vue-solana/core/token-accounts';
 

package/dist/index.mjs

@@ -1,15 +1,16 @@
 export { u as useAccountInfo } from './shared/vue.BQRpjwKl.mjs';
 export { u as useAction } from './shared/vue.DYk0Xfr3.mjs';
-export { u as useAirdrop } from './shared/vue.BSfiHqwj.mjs';
+export { u as useAirdrop } from './shared/vue.DDQxNX5q.mjs';
 export { u as useBalance } from './shared/vue.BINkrA8h.mjs';
-export { M as MissingClientCapabilityError, u as useClientCapability } from './shared/vue.B8LptjZP.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.C5FVoEZT.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 useIdentity, a as usePayer } from './shared/vue.CATOh_9G.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.DXQVIRZA.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';

package/dist/shared/{vue.BY0qpgYr.cjs → vue.4C5kX4fE.cjs}

@@ -25,7 +25,8 @@ function useClientCapability(capability, options = {}) {
   const providerHint = options.providerHint ?? "Install it by adding the corresponding @solana/kit plugin with `createClient().use(...)`.";
   const { client } = useSolanaClient.useSolanaClient();
   for (const name of capabilities) {
-    if (typeof client[name] === "undefined") {
+    const value = client[name];
+    if (value === null || typeof value !== "function" && typeof value !== "object") {
       throw new MissingClientCapabilityError(hookName, [name], providerHint);
     }
   }

package/dist/shared/{vue.CATOh_9G.mjs → vue.B-xtuLtD.mjs}

@@ -1,5 +1,5 @@
 import { shallowRef, onScopeDispose } from 'vue';
-import { u as useClientCapability } from './vue.B8LptjZP.mjs';
+import { u as useClientCapability } from './vue.B9uRpSDJ.mjs';
 import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
 
 function useIdentity() {

package/dist/shared/{vue.CTqPbvz3.cjs → vue.B4eMoJT2.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const useAction = require('./vue.CoaIWGPT.cjs');
-const useClientCapability = require('./vue.BY0qpgYr.cjs');
+const useClientCapability = require('./vue.4C5kX4fE.cjs');
 const useSolanaClient = require('./vue.BIxphCAq.cjs');
 
 function toReadableAirdropError(error) {
@@ -21,7 +21,7 @@ function toReadableAirdropError(error) {
 function useAirdrop() {
   useClientCapability.useClientCapability("airdrop", {
     hookName: "useAirdrop",
-    providerHint: "Install it by adding the airdrop capability with `createClient().use(solanaRpcConnection({ ... })).use(rpcAirdrop())` from `@solana/kit-plugin-rpc`."
+    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 { client } = useSolanaClient.useSolanaClient();
   return useAction.useAction((abortSignal, address, amount) => {

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

@@ -23,7 +23,8 @@ function useClientCapability(capability, options = {}) {
   const providerHint = options.providerHint ?? "Install it by adding the corresponding @solana/kit plugin with `createClient().use(...)`.";
   const { client } = useSolanaClient();
   for (const name of capabilities) {
-    if (typeof client[name] === "undefined") {
+    const value = client[name];
+    if (value === null || typeof value !== "function" && typeof value !== "object") {
       throw new MissingClientCapabilityError(hookName, [name], providerHint);
     }
   }

package/dist/shared/{vue.C5FVoEZT.mjs → vue.Co5rj-I6.mjs}

@@ -1,12 +1,13 @@
 import { normalizeSolanaError } from '@vue-solana/core/errors';
-import { shallowRef, ref } from 'vue';
-import { u as useClientCapability } from './vue.B8LptjZP.mjs';
+import { shallowRef, ref, onScopeDispose } from 'vue';
+import { u as useClientCapability } from './vue.B9uRpSDJ.mjs';
 import { u as useSolanaClient } from './vue.Mxc8w6Qk.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.";
 function usePlanTransaction() {
-  useClientCapability(["planTransaction"], {
+  useClientCapability(["planTransaction", "payer"], {
     hookName: "usePlanTransaction",
-    providerHint: "Install a planner plugin, e.g. `createClient().use(rpcTransactionPlanner())` from `@solana/kit-plugin-rpc`."
+    providerHint: PLANNING_PROVIDER_HINT
   });
   const { client } = useSolanaClient();
   const transactionMessage = shallowRef(null);
@@ -14,7 +15,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 +31,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";
@@ -50,9 +60,9 @@ function usePlanTransaction() {
   };
 }
 function usePlanTransactions() {
-  useClientCapability(["planTransactions"], {
+  useClientCapability(["planTransactions", "payer"], {
     hookName: "usePlanTransactions",
-    providerHint: "Install a planner plugin, e.g. `createClient().use(rpcTransactionPlanner())` from `@solana/kit-plugin-rpc`."
+    providerHint: PLANNING_PROVIDER_HINT
   });
   const { client } = useSolanaClient();
   const transactionPlan = shallowRef(null);
@@ -60,7 +70,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 +86,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";