@vue-solana/vue 2.1.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
@@ -164,6 +186,22 @@ const { balance, loading, error, refresh } = useBalance(address);
 </template>
 ```
 
+### 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`.
+
+```ts
+import { lamports } from "@solana/kit";
+import { useAirdrop } from "@vue-solana/vue/useAirdrop";
+
+const { data, status, error, dispatch } = useAirdrop();
+await dispatch(address, lamports(1_000_000_000)); // 1 SOL
+```
+
+Each `dispatch(address, amount)` runs a fresh airdrop and aborts the previous in-flight call. `data` resolves to the transaction `Signature`, or to `undefined` when the network applies the airdrop without a transaction (some local validators, e.g. LiteSVM).
+
+Airdrops to a single address are rate-limited (public devnets commonly return HTTP 429, and 1 SOL requires enough devnet balance); wait before dispatching again or use a fresh address. Errors surface through `error` / the `error` state.
+
 ## Read Account Data
 
 ```ts
@@ -299,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:
@@ -341,6 +479,39 @@ import { useRequestSwr } from "@vue-solana/vue/swr";
 const balance = useRequestSwr(["balance", address], () => client.rpc.getBalance(address).send());
 ```
 
+### Cancellation & Timeouts
+
+`useRequest()`, `useSubscription()`, and `useTrackedData()` accept a `getAbortSignal` option — a factory called once per attempt (request) or connection (subscription/tracked data). It is the natural place for a timeout:
+
+```ts
+const { data, refresh } = useRequest(source, {
+  getAbortSignal: (attempt) => AbortSignal.timeout(10_000),
+});
+
+await refresh({ abortSignal: AbortSignal.timeout(2_000) });
+```
+
+The factory is read fresh from the latest render on every attempt, so inline closures work without `useCallback`-style wrapping. Each manual refresh or reconnect can instead pass a single `{ abortSignal }` override that replaces the factory for that attempt; pass `AbortSignal` explicitly as `undefined` to skip caller cancellation entirely. Aborting the composed signal fails only that attempt — previous `data` is kept and `status` drops back to `error`.
+
+To kill the data hook entirely, set its source to `null` (status becomes `disabled` and in-flight work is cancelled) or unmount the component that owns it.
+
+### Actions with `useAction`
+
+`useAction()` and its derivatives (`useAirdrop()`, `useSignAndSendTransaction()` themes) manage one async action at a time:
+
+```ts
+const { data, status, error, dispatch } = useAction(async (signal, input) => {
+  /* ... */
+});
+
+dispatch(inputA); // runs
+await dispatch(inputB); // aborts dispatch(inputA) before starting
+```
+
+- `useAction` keeps the handler in a ref — every `dispatch` runs the latest closure, so there is no deps array to keep in sync. In-flight calls keep running with the closure they started with.
+- `dispatch` returns a `Promise<TResult>`. If a newer dispatch supersedes it, the older promise rejects with an abort error; awaiters should treat that as "superseded", not a failure, and fresh awaits win.
+- Calling `dispatch` again aborts the prior in-flight call with a fresh `AbortSignal`, and resets state to `idle` before the new run starts.
+
 ### Sign In With Solana
 
 `useSignIn()` triggers the SIWS flow when the connected wallet supports the `solana:signIn` feature:
@@ -420,6 +591,7 @@ Docs: [Vue Solana Agent Skill](https://vue-solana-docs.vercel.app/agent-skill)
 | `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.                                                     |
@@ -444,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:
 
@@ -452,6 +626,7 @@ Direct composable subpaths:
 - `@vue-solana/vue/useRpc`
 - `@vue-solana/vue/useConnection`
 - `@vue-solana/vue/useAccountInfo`
+- `@vue-solana/vue/useAirdrop`
 - `@vue-solana/vue/useBalance`
 - `@vue-solana/vue/useProgramAccounts`
 - `@vue-solana/vue/useWallet`
@@ -476,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

@@ -2,15 +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 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.B8pLQ8P4.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');
@@ -19,10 +21,10 @@ const useSignatureStatus = require('./shared/vue.CIs8QhCw.cjs');
 const useSignIn = require('./shared/vue.9TPxZPMf.cjs');
 const useSolana = require('./shared/vue.DE3emjSF.cjs');
 const useSolanaClient = require('./shared/vue.BIxphCAq.cjs');
-const useSubscription = require('./shared/vue.BVj9lWBK.cjs');
+const useSubscription = require('./shared/vue.l3UCdN7z.cjs');
 const useTokenAccounts = require('./shared/vue.Bwd1sGAM.cjs');
 const useTokenBalance = require('./shared/vue.DAg5wC1G.cjs');
-const useTrackedData = require('./shared/vue.DtCbCcPd.cjs');
+const useTrackedData = require('./shared/vue.DxM45azl.cjs');
 const useTransaction = require('./shared/vue.Bk5xjlUx.cjs');
 const useTransactionConfirmation = require('./shared/vue.Sbbm9JSu.cjs');
 const useWallet = require('./shared/vue.BGxz4dru.cjs');
@@ -386,6 +388,7 @@ const VueSolana = createSolanaPlugin;
 
 exports.useAccountInfo = useAccountInfo.useAccountInfo;
 exports.useAction = useAction.useAction;
+exports.useAirdrop = useAirdrop.useAirdrop;
 exports.useBalance = useBalance.useBalance;
 exports.MissingClientCapabilityError = useClientCapability.MissingClientCapabilityError;
 exports.useClientCapability = useClientCapability.useClientCapability;
@@ -402,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

@@ -1,14 +1,16 @@
 export { AccountInfo, UseAccountInfoOptions, useAccountInfo } from './useAccountInfo.cjs';
 export { UseActionOptions, UseActionReturn, UseActionStatus, useAction } from './useAction.cjs';
+export { useAirdrop } from './useAirdrop.cjs';
 export { BalanceInput, useBalance } from './useBalance.cjs';
 export { MissingClientCapabilityError, UseClientCapabilityOptions, useClientCapability } from './useClientCapability.cjs';
 export { useConnection } from './useConnection.cjs';
 export { PlanTransactionConfig, PlanTransactionStatus, usePlanTransaction, usePlanTransactions } from './usePlanTransaction.cjs';
 export { ProgramAccount, ProgramAccountDataSizeFilter, ProgramAccountDataSlice, ProgramAccountFilter, ProgramAccountMemcmpEncoding, ProgramAccountMemcmpFilter, UseProgramAccountsOptions, useProgramAccounts } from './useProgramAccounts.cjs';
 export { useIdentity, usePayer } from './usePayer.cjs';
-export { UseRequestOptions, UseRequestReturn, UseRequestSource, UseRequestStatus, useRequest } from './useRequest.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';
@@ -17,10 +19,10 @@ export { SignatureStatus, UseSignatureStatusOptions, useSignatureStatus } from '
 export { SignInStatus, useSignIn } from './useSignIn.cjs';
 export { tryUseSolana, useSolana } from './useSolana.cjs';
 export { useSolanaClient } from './useSolanaClient.cjs';
-export { UseSubscriptionOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus, useSubscription } from './useSubscription.cjs';
+export { UseSubscriptionOptions, UseSubscriptionReconnectOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus, useSubscription } from './useSubscription.cjs';
 export { UseTokenAccountsOptions, useTokenAccounts } from './useTokenAccounts.cjs';
 export { useTokenBalance } from './useTokenBalance.cjs';
-export { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource, useTrackedData } from './useTrackedData.cjs';
+export { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataRefresherOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource, useTrackedData } from './useTrackedData.cjs';
 export { UseTransactionOptions, useTransaction } from './useTransaction.cjs';
 export { TransactionConfirmationStatus, getConfirmedTransactionStatus, useTransactionConfirmation } from './useTransactionConfirmation.cjs';
 export { useWallet } from './useWallet.cjs';

package/dist/index.d.mts

@@ -1,14 +1,16 @@
 export { AccountInfo, UseAccountInfoOptions, useAccountInfo } from './useAccountInfo.mjs';
 export { UseActionOptions, UseActionReturn, UseActionStatus, useAction } from './useAction.mjs';
+export { useAirdrop } from './useAirdrop.mjs';
 export { BalanceInput, useBalance } from './useBalance.mjs';
 export { MissingClientCapabilityError, UseClientCapabilityOptions, useClientCapability } from './useClientCapability.mjs';
 export { useConnection } from './useConnection.mjs';
 export { PlanTransactionConfig, PlanTransactionStatus, usePlanTransaction, usePlanTransactions } from './usePlanTransaction.mjs';
 export { ProgramAccount, ProgramAccountDataSizeFilter, ProgramAccountDataSlice, ProgramAccountFilter, ProgramAccountMemcmpEncoding, ProgramAccountMemcmpFilter, UseProgramAccountsOptions, useProgramAccounts } from './useProgramAccounts.mjs';
 export { useIdentity, usePayer } from './usePayer.mjs';
-export { UseRequestOptions, UseRequestReturn, UseRequestSource, UseRequestStatus, useRequest } from './useRequest.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';
@@ -17,10 +19,10 @@ export { SignatureStatus, UseSignatureStatusOptions, useSignatureStatus } from '
 export { SignInStatus, useSignIn } from './useSignIn.mjs';
 export { tryUseSolana, useSolana } from './useSolana.mjs';
 export { useSolanaClient } from './useSolanaClient.mjs';
-export { UseSubscriptionOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus, useSubscription } from './useSubscription.mjs';
+export { UseSubscriptionOptions, UseSubscriptionReconnectOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus, useSubscription } from './useSubscription.mjs';
 export { UseTokenAccountsOptions, useTokenAccounts } from './useTokenAccounts.mjs';
 export { useTokenBalance } from './useTokenBalance.mjs';
-export { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource, useTrackedData } from './useTrackedData.mjs';
+export { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataRefresherOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource, useTrackedData } from './useTrackedData.mjs';
 export { UseTransactionOptions, useTransaction } from './useTransaction.mjs';
 export { TransactionConfirmationStatus, getConfirmedTransactionStatus, useTransactionConfirmation } from './useTransactionConfirmation.mjs';
 export { useWallet } from './useWallet.mjs';

package/dist/index.d.ts

@@ -1,14 +1,16 @@
 export { AccountInfo, UseAccountInfoOptions, useAccountInfo } from './useAccountInfo.js';
 export { UseActionOptions, UseActionReturn, UseActionStatus, useAction } from './useAction.js';
+export { useAirdrop } from './useAirdrop.js';
 export { BalanceInput, useBalance } from './useBalance.js';
 export { MissingClientCapabilityError, UseClientCapabilityOptions, useClientCapability } from './useClientCapability.js';
 export { useConnection } from './useConnection.js';
 export { PlanTransactionConfig, PlanTransactionStatus, usePlanTransaction, usePlanTransactions } from './usePlanTransaction.js';
 export { ProgramAccount, ProgramAccountDataSizeFilter, ProgramAccountDataSlice, ProgramAccountFilter, ProgramAccountMemcmpEncoding, ProgramAccountMemcmpFilter, UseProgramAccountsOptions, useProgramAccounts } from './useProgramAccounts.js';
 export { useIdentity, usePayer } from './usePayer.js';
-export { UseRequestOptions, UseRequestReturn, UseRequestSource, UseRequestStatus, useRequest } from './useRequest.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';
@@ -17,10 +19,10 @@ export { SignatureStatus, UseSignatureStatusOptions, useSignatureStatus } from '
 export { SignInStatus, useSignIn } from './useSignIn.js';
 export { tryUseSolana, useSolana } from './useSolana.js';
 export { useSolanaClient } from './useSolanaClient.js';
-export { UseSubscriptionOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus, useSubscription } from './useSubscription.js';
+export { UseSubscriptionOptions, UseSubscriptionReconnectOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus, useSubscription } from './useSubscription.js';
 export { UseTokenAccountsOptions, useTokenAccounts } from './useTokenAccounts.js';
 export { useTokenBalance } from './useTokenBalance.js';
-export { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource, useTrackedData } from './useTrackedData.js';
+export { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataRefresherOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource, useTrackedData } from './useTrackedData.js';
 export { UseTransactionOptions, useTransaction } from './useTransaction.js';
 export { TransactionConfirmationStatus, getConfirmedTransactionStatus, useTransactionConfirmation } from './useTransactionConfirmation.js';
 export { useWallet } from './useWallet.js';

package/dist/index.mjs

@@ -1,14 +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 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.DImwKTwJ.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';
@@ -17,10 +19,10 @@ export { u as useSignatureStatus } from './shared/vue.CXB4NEMA.mjs';
 export { u as useSignIn } from './shared/vue.ByxbBC3y.mjs';
 export { t as tryUseSolana, u as useSolana } from './shared/vue.CQh3AUE8.mjs';
 export { u as useSolanaClient } from './shared/vue.Mxc8w6Qk.mjs';
-export { u as useSubscription } from './shared/vue.B8ub540p.mjs';
+export { u as useSubscription } from './shared/vue.BDNOyiGZ.mjs';
 export { u as useTokenAccounts } from './shared/vue.BOpgWr43.mjs';
 export { u as useTokenBalance } from './shared/vue.BD6Gm1nl.mjs';
-export { u as useTrackedData } from './shared/vue.CogzzQXM.mjs';
+export { u as useTrackedData } from './shared/vue.CbJFnho-.mjs';
 export { u as useTransaction } from './shared/vue.5euWd6-V.mjs';
 export { g as getConfirmedTransactionStatus, u as useTransactionConfirmation } from './shared/vue.D3Y0PWbF.mjs';
 export { u as useWallet } from './shared/vue.D218Ow7t.mjs';

package/dist/shared/{vue.DImwKTwJ.mjs → vue.B8VvC8d2.mjs}

@@ -9,24 +9,22 @@ function useRequest(source, options = {}) {
   const status = shallowRef("fetching");
   let disposed = false;
   let attempt = 0;
-  const store = createSolanaActionStore(
-    async (signal, resolved) => {
-      attempt += 1;
-      const callerSignal = options.getAbortSignal?.(attempt);
-      const composedSignal = callerSignal ? AbortSignal.any([signal, callerSignal]) : signal;
-      let pending;
-      if (isSendSource(resolved)) {
-        pending = Promise.resolve(resolved.send({ abortSignal: composedSignal }));
-      } else if (typeof resolved === "function") {
-        pending = Promise.resolve(resolved(composedSignal)).then(
-          (result) => isSendSource(result) ? result.send({ abortSignal: composedSignal }) : result
-        );
-      } else {
-        throw new Error("useRequest source did not resolve to a request function");
-      }
-      return getAbortablePromise(pending, composedSignal);
+  const store = createSolanaActionStore(async (signal, resolved, override) => {
+    attempt += 1;
+    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(attempt);
+    const composedSignal = callerSignal ? AbortSignal.any([signal, callerSignal]) : signal;
+    let pending;
+    if (isSendSource(resolved)) {
+      pending = Promise.resolve(resolved.send({ abortSignal: composedSignal }));
+    } else if (typeof resolved === "function") {
+      pending = Promise.resolve(resolved(composedSignal)).then(
+        (result) => isSendSource(result) ? result.send({ abortSignal: composedSignal }) : result
+      );
+    } else {
+      throw new Error("useRequest source did not resolve to a request function");
     }
-  );
+    return getAbortablePromise(pending, composedSignal);
+  });
   const unsubscribe = store.subscribe(() => {
     const next = store.getState();
     if (next.status === "success") {
@@ -51,7 +49,7 @@ function useRequest(source, options = {}) {
     }
     return source;
   }
-  async function run() {
+  async function run(override) {
     if (disposed) {
       return void 0;
     }
@@ -65,7 +63,7 @@ function useRequest(source, options = {}) {
     }
     status.value = "fetching";
     try {
-      return await store.dispatchAsync(resolved);
+      return await store.dispatchAsync(resolved, override);
     } catch (cause) {
       if (store.getState().status !== "error") {
         return void 0;
@@ -73,7 +71,7 @@ function useRequest(source, options = {}) {
       throw normalizeSolanaError(cause, "RPC_FAILURE");
     }
   }
-  const refresh = () => run();
+  const refresh = (options2) => run(options2);
   watch(
     () => isRef(source) ? source.value : source,
     () => {

package/dist/shared/{vue.B8ub540p.mjs → vue.BDNOyiGZ.mjs}

@@ -27,11 +27,11 @@ function useSubscription(source, options = {}) {
       status.value = "loading";
     }
   }
-  function openConnection(store) {
+  function openConnection(store, override) {
     activeStore = store;
     connectionCount += 1;
     const connection = connectionCount;
-    const callerSignal = options.getAbortSignal?.(connection);
+    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(connection);
     applyState(store.getState());
     disposables.push(
       store.subscribe(() => {
@@ -59,7 +59,7 @@ function useSubscription(source, options = {}) {
     }
     activeSource = void 0;
   }
-  function connectCurrent() {
+  function connectCurrent(override) {
     if (disposed) {
       return;
     }
@@ -72,12 +72,12 @@ function useSubscription(source, options = {}) {
       return;
     }
     if (activeSource === resolved && activeStore) {
-      openConnection(activeStore);
+      openConnection(activeStore, override);
       return;
     }
     disconnect();
     activeSource = resolved;
-    openConnection(resolved.reactiveStore());
+    openConnection(resolved.reactiveStore(), override);
   }
   watch(
     () => isRef(source) ? source.value : source,
@@ -99,8 +99,8 @@ function useSubscription(source, options = {}) {
   return {
     data: computed(() => data.value),
     error: computed(() => error.value),
-    reconnect: () => {
-      connectCurrent();
+    reconnect: (options2) => {
+      connectCurrent(options2);
     },
     status: computed(() => status.value)
   };