@vue-solana/vue 2.0.0 → 2.1.0

package/dist/useRpc.mjs

@@ -1,3 +1,4 @@
-export { u as useRpc } from './shared/vue.3VLZmw05.mjs';
+export { u as useRpc } from './shared/vue.BsGwt78R.mjs';
 import 'vue';
-import './shared/vue.CnUlZSe8.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useSelectedWalletAccount.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const SelectedWalletAccountProvider = require('./shared/vue.DDbVk0Zh.cjs');
+require('vue');
+require('./shared/vue.DEHxNvUX.cjs');
+
+
+
+exports.SelectedWalletAccountProvider = SelectedWalletAccountProvider.SelectedWalletAccountProvider;
+exports.createSelectedWalletAccountContext = SelectedWalletAccountProvider.createSelectedWalletAccountContext;
+exports.provideSelectedWalletAccount = SelectedWalletAccountProvider.provideSelectedWalletAccount;
+exports.selectedWalletAccountInjectionKey = SelectedWalletAccountProvider.selectedWalletAccountInjectionKey;
+exports.useSelectedWalletAccount = SelectedWalletAccountProvider.useSelectedWalletAccount;

package/dist/useSelectedWalletAccount.d.cts

@@ -0,0 +1,117 @@
+import { SolanaWalletInfo } from '@vue-solana/core/types';
+import * as vue from 'vue';
+import { Ref, ComputedRef, InjectionKey, PropType } from 'vue';
+
+/**
+ * Storage adapter used by `SelectedWalletAccountProvider`'s `stateSync`
+ * option. The persisted value is the selected wallet's
+ * `${walletName}:${accountAddress}` key.
+ */
+interface SelectedWalletAccountStorage {
+    storeSelectedWallet(key: string): void | Promise<void>;
+    getSelectedWallet(): string | null | Promise<string | null>;
+    deleteSelectedWallet(): void | Promise<void>;
+}
+
+type SelectedWalletAccount = SolanaWalletInfo["accounts"][number] & {
+    /** The wallet that owns this account. */
+    walletName: string;
+};
+type WalletAccountFilter = (walletName: string, account: SolanaWalletInfo["accounts"][number]) => boolean;
+interface SelectedWalletAccountContext {
+    selectedWalletAccount: Ref<SelectedWalletAccount | null>;
+    setSelectedWalletAccount: (account: SelectedWalletAccount | null) => void;
+    filteredWallets: ComputedRef<SolanaWalletInfo[]>;
+}
+declare const selectedWalletAccountInjectionKey: InjectionKey<SelectedWalletAccountContext>;
+interface SelectedWalletAccountOptions {
+    /**
+     * Restricts the wallets exposed through `filteredWallets` and the accounts
+     * that can be selected. Receives the wallet name and each of its accounts;
+     * return `false` to hide the account (a wallet with no remaining accounts
+     * is hidden entirely).
+     */
+    filterWallet?: WalletAccountFilter;
+    /**
+     * Persists the selection as `${walletName}:${accountAddress}`. Defaults to
+     * `localStorage`; pass `null` to disable persistence.
+     */
+    stateSync?: SelectedWalletAccountStorage | null;
+}
+/**
+ * App-wide selected wallet account state, mirroring `@solana/react`'s
+ * `SelectedWalletAccountContextProvider`.
+ *
+ * Call once near the root of your app, then read state anywhere with
+ * {@link useSelectedWalletAccount}. The selection persists as
+ * `${walletName}:${accountAddress}` through `stateSync` and is restored on
+ * the next mount when the wallet and account are available again.
+ */
+declare function provideSelectedWalletAccount(options?: SelectedWalletAccountOptions): SelectedWalletAccountContext;
+/**
+ * Build the selected wallet account context without providing it. Used by
+ * the Nuxt runtime plugin, which installs the context app-wide via
+ * `app.provide` rather than inside a component setup.
+ *
+ * When called outside a component setup (as the Nuxt plugin does), `inject`
+ * cannot resolve the Solana context, so pass it explicitly through
+ * {@link solanaContextOverride}.
+ */
+declare function createSelectedWalletAccountContext(options?: SelectedWalletAccountOptions, solanaContextOverride?: SolanaContextLike | null): SelectedWalletAccountContext;
+/**
+ * Read the app-wide selected wallet account provided by
+ * {@link provideSelectedWalletAccount}.
+ *
+ * Returns `[selectedAccount, setSelectedAccount, filteredWallets]`. The
+ * setter accepts `null` to clear the selection. Throws when called outside a
+ * provider — mount `SelectedWalletAccountProvider` (or call
+ * `provideSelectedWalletAccount`) first.
+ */
+declare function useSelectedWalletAccount(): [
+    Ref<SelectedWalletAccount | null>,
+    (account: SelectedWalletAccount | null) => void,
+    ComputedRef<SolanaWalletInfo[]>
+];
+/**
+ * The minimal Solana context surface this composable reads. Structural so the
+ * full `VueSolanaContext` (or the raw RPC context) satisfies it without an
+ * import cycle from the plugin to its composables.
+ */
+interface SolanaContextLike {
+    wallets: Ref<SolanaWalletInfo[]>;
+}
+
+/**
+ * App-wide selected wallet account provider, mirroring `@solana/react`'s
+ * `SelectedWalletAccountContextProvider`.
+ *
+ * Wraps `provideSelectedWalletAccount`; children read state via
+ * `useSelectedWalletAccount()`.
+ */
+declare const SelectedWalletAccountProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    filterWallet: {
+        type: PropType<SelectedWalletAccountOptions["filterWallet"]>;
+        default: undefined;
+    };
+    stateSync: {
+        type: PropType<SelectedWalletAccountOptions["stateSync"]>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    filterWallet: {
+        type: PropType<SelectedWalletAccountOptions["filterWallet"]>;
+        default: undefined;
+    };
+    stateSync: {
+        type: PropType<SelectedWalletAccountOptions["stateSync"]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    filterWallet: WalletAccountFilter | undefined;
+    stateSync: SelectedWalletAccountStorage | null | undefined;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { SelectedWalletAccountProvider, createSelectedWalletAccountContext, provideSelectedWalletAccount, selectedWalletAccountInjectionKey, useSelectedWalletAccount };
+export type { SelectedWalletAccount, SelectedWalletAccountContext, SelectedWalletAccountOptions, WalletAccountFilter };

package/dist/useSelectedWalletAccount.d.mts

@@ -0,0 +1,117 @@
+import { SolanaWalletInfo } from '@vue-solana/core/types';
+import * as vue from 'vue';
+import { Ref, ComputedRef, InjectionKey, PropType } from 'vue';
+
+/**
+ * Storage adapter used by `SelectedWalletAccountProvider`'s `stateSync`
+ * option. The persisted value is the selected wallet's
+ * `${walletName}:${accountAddress}` key.
+ */
+interface SelectedWalletAccountStorage {
+    storeSelectedWallet(key: string): void | Promise<void>;
+    getSelectedWallet(): string | null | Promise<string | null>;
+    deleteSelectedWallet(): void | Promise<void>;
+}
+
+type SelectedWalletAccount = SolanaWalletInfo["accounts"][number] & {
+    /** The wallet that owns this account. */
+    walletName: string;
+};
+type WalletAccountFilter = (walletName: string, account: SolanaWalletInfo["accounts"][number]) => boolean;
+interface SelectedWalletAccountContext {
+    selectedWalletAccount: Ref<SelectedWalletAccount | null>;
+    setSelectedWalletAccount: (account: SelectedWalletAccount | null) => void;
+    filteredWallets: ComputedRef<SolanaWalletInfo[]>;
+}
+declare const selectedWalletAccountInjectionKey: InjectionKey<SelectedWalletAccountContext>;
+interface SelectedWalletAccountOptions {
+    /**
+     * Restricts the wallets exposed through `filteredWallets` and the accounts
+     * that can be selected. Receives the wallet name and each of its accounts;
+     * return `false` to hide the account (a wallet with no remaining accounts
+     * is hidden entirely).
+     */
+    filterWallet?: WalletAccountFilter;
+    /**
+     * Persists the selection as `${walletName}:${accountAddress}`. Defaults to
+     * `localStorage`; pass `null` to disable persistence.
+     */
+    stateSync?: SelectedWalletAccountStorage | null;
+}
+/**
+ * App-wide selected wallet account state, mirroring `@solana/react`'s
+ * `SelectedWalletAccountContextProvider`.
+ *
+ * Call once near the root of your app, then read state anywhere with
+ * {@link useSelectedWalletAccount}. The selection persists as
+ * `${walletName}:${accountAddress}` through `stateSync` and is restored on
+ * the next mount when the wallet and account are available again.
+ */
+declare function provideSelectedWalletAccount(options?: SelectedWalletAccountOptions): SelectedWalletAccountContext;
+/**
+ * Build the selected wallet account context without providing it. Used by
+ * the Nuxt runtime plugin, which installs the context app-wide via
+ * `app.provide` rather than inside a component setup.
+ *
+ * When called outside a component setup (as the Nuxt plugin does), `inject`
+ * cannot resolve the Solana context, so pass it explicitly through
+ * {@link solanaContextOverride}.
+ */
+declare function createSelectedWalletAccountContext(options?: SelectedWalletAccountOptions, solanaContextOverride?: SolanaContextLike | null): SelectedWalletAccountContext;
+/**
+ * Read the app-wide selected wallet account provided by
+ * {@link provideSelectedWalletAccount}.
+ *
+ * Returns `[selectedAccount, setSelectedAccount, filteredWallets]`. The
+ * setter accepts `null` to clear the selection. Throws when called outside a
+ * provider — mount `SelectedWalletAccountProvider` (or call
+ * `provideSelectedWalletAccount`) first.
+ */
+declare function useSelectedWalletAccount(): [
+    Ref<SelectedWalletAccount | null>,
+    (account: SelectedWalletAccount | null) => void,
+    ComputedRef<SolanaWalletInfo[]>
+];
+/**
+ * The minimal Solana context surface this composable reads. Structural so the
+ * full `VueSolanaContext` (or the raw RPC context) satisfies it without an
+ * import cycle from the plugin to its composables.
+ */
+interface SolanaContextLike {
+    wallets: Ref<SolanaWalletInfo[]>;
+}
+
+/**
+ * App-wide selected wallet account provider, mirroring `@solana/react`'s
+ * `SelectedWalletAccountContextProvider`.
+ *
+ * Wraps `provideSelectedWalletAccount`; children read state via
+ * `useSelectedWalletAccount()`.
+ */
+declare const SelectedWalletAccountProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    filterWallet: {
+        type: PropType<SelectedWalletAccountOptions["filterWallet"]>;
+        default: undefined;
+    };
+    stateSync: {
+        type: PropType<SelectedWalletAccountOptions["stateSync"]>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    filterWallet: {
+        type: PropType<SelectedWalletAccountOptions["filterWallet"]>;
+        default: undefined;
+    };
+    stateSync: {
+        type: PropType<SelectedWalletAccountOptions["stateSync"]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    filterWallet: WalletAccountFilter | undefined;
+    stateSync: SelectedWalletAccountStorage | null | undefined;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { SelectedWalletAccountProvider, createSelectedWalletAccountContext, provideSelectedWalletAccount, selectedWalletAccountInjectionKey, useSelectedWalletAccount };
+export type { SelectedWalletAccount, SelectedWalletAccountContext, SelectedWalletAccountOptions, WalletAccountFilter };

package/dist/useSelectedWalletAccount.d.ts

@@ -0,0 +1,117 @@
+import { SolanaWalletInfo } from '@vue-solana/core/types';
+import * as vue from 'vue';
+import { Ref, ComputedRef, InjectionKey, PropType } from 'vue';
+
+/**
+ * Storage adapter used by `SelectedWalletAccountProvider`'s `stateSync`
+ * option. The persisted value is the selected wallet's
+ * `${walletName}:${accountAddress}` key.
+ */
+interface SelectedWalletAccountStorage {
+    storeSelectedWallet(key: string): void | Promise<void>;
+    getSelectedWallet(): string | null | Promise<string | null>;
+    deleteSelectedWallet(): void | Promise<void>;
+}
+
+type SelectedWalletAccount = SolanaWalletInfo["accounts"][number] & {
+    /** The wallet that owns this account. */
+    walletName: string;
+};
+type WalletAccountFilter = (walletName: string, account: SolanaWalletInfo["accounts"][number]) => boolean;
+interface SelectedWalletAccountContext {
+    selectedWalletAccount: Ref<SelectedWalletAccount | null>;
+    setSelectedWalletAccount: (account: SelectedWalletAccount | null) => void;
+    filteredWallets: ComputedRef<SolanaWalletInfo[]>;
+}
+declare const selectedWalletAccountInjectionKey: InjectionKey<SelectedWalletAccountContext>;
+interface SelectedWalletAccountOptions {
+    /**
+     * Restricts the wallets exposed through `filteredWallets` and the accounts
+     * that can be selected. Receives the wallet name and each of its accounts;
+     * return `false` to hide the account (a wallet with no remaining accounts
+     * is hidden entirely).
+     */
+    filterWallet?: WalletAccountFilter;
+    /**
+     * Persists the selection as `${walletName}:${accountAddress}`. Defaults to
+     * `localStorage`; pass `null` to disable persistence.
+     */
+    stateSync?: SelectedWalletAccountStorage | null;
+}
+/**
+ * App-wide selected wallet account state, mirroring `@solana/react`'s
+ * `SelectedWalletAccountContextProvider`.
+ *
+ * Call once near the root of your app, then read state anywhere with
+ * {@link useSelectedWalletAccount}. The selection persists as
+ * `${walletName}:${accountAddress}` through `stateSync` and is restored on
+ * the next mount when the wallet and account are available again.
+ */
+declare function provideSelectedWalletAccount(options?: SelectedWalletAccountOptions): SelectedWalletAccountContext;
+/**
+ * Build the selected wallet account context without providing it. Used by
+ * the Nuxt runtime plugin, which installs the context app-wide via
+ * `app.provide` rather than inside a component setup.
+ *
+ * When called outside a component setup (as the Nuxt plugin does), `inject`
+ * cannot resolve the Solana context, so pass it explicitly through
+ * {@link solanaContextOverride}.
+ */
+declare function createSelectedWalletAccountContext(options?: SelectedWalletAccountOptions, solanaContextOverride?: SolanaContextLike | null): SelectedWalletAccountContext;
+/**
+ * Read the app-wide selected wallet account provided by
+ * {@link provideSelectedWalletAccount}.
+ *
+ * Returns `[selectedAccount, setSelectedAccount, filteredWallets]`. The
+ * setter accepts `null` to clear the selection. Throws when called outside a
+ * provider — mount `SelectedWalletAccountProvider` (or call
+ * `provideSelectedWalletAccount`) first.
+ */
+declare function useSelectedWalletAccount(): [
+    Ref<SelectedWalletAccount | null>,
+    (account: SelectedWalletAccount | null) => void,
+    ComputedRef<SolanaWalletInfo[]>
+];
+/**
+ * The minimal Solana context surface this composable reads. Structural so the
+ * full `VueSolanaContext` (or the raw RPC context) satisfies it without an
+ * import cycle from the plugin to its composables.
+ */
+interface SolanaContextLike {
+    wallets: Ref<SolanaWalletInfo[]>;
+}
+
+/**
+ * App-wide selected wallet account provider, mirroring `@solana/react`'s
+ * `SelectedWalletAccountContextProvider`.
+ *
+ * Wraps `provideSelectedWalletAccount`; children read state via
+ * `useSelectedWalletAccount()`.
+ */
+declare const SelectedWalletAccountProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    filterWallet: {
+        type: PropType<SelectedWalletAccountOptions["filterWallet"]>;
+        default: undefined;
+    };
+    stateSync: {
+        type: PropType<SelectedWalletAccountOptions["stateSync"]>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    filterWallet: {
+        type: PropType<SelectedWalletAccountOptions["filterWallet"]>;
+        default: undefined;
+    };
+    stateSync: {
+        type: PropType<SelectedWalletAccountOptions["stateSync"]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    filterWallet: WalletAccountFilter | undefined;
+    stateSync: SelectedWalletAccountStorage | null | undefined;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { SelectedWalletAccountProvider, createSelectedWalletAccountContext, provideSelectedWalletAccount, selectedWalletAccountInjectionKey, useSelectedWalletAccount };
+export type { SelectedWalletAccount, SelectedWalletAccountContext, SelectedWalletAccountOptions, WalletAccountFilter };

package/dist/useSelectedWalletAccount.mjs

@@ -0,0 +1,3 @@
+export { S as SelectedWalletAccountProvider, c as createSelectedWalletAccountContext, p as provideSelectedWalletAccount, s as selectedWalletAccountInjectionKey, u as useSelectedWalletAccount } from './shared/vue.DXQVIRZA.mjs';
+import 'vue';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useSignAndSendTransaction.cjs

@@ -1,16 +1,17 @@
 'use strict';
 
-const useSignAndSendTransaction = require('./shared/vue.CSJSK0Nq.cjs');
+const useSignAndSendTransaction = require('./shared/vue.CWZSMVnB.cjs');
 require('@vue-solana/core/errors');
 require('@vue-solana/core/timeout');
 require('@vue-solana/core/transaction');
 require('@vue-solana/core/wallet');
 require('vue');
-require('./shared/vue.CZwftA0L.cjs');
-require('./shared/vue.k9Q6aN-0.cjs');
-require('./shared/vue.BaR1VPhl.cjs');
-require('./shared/vue.BAlo-tIh.cjs');
-require('./shared/vue.C32ozdA1.cjs');
+require('./shared/vue.BVaMoz9y.cjs');
+require('./shared/vue.BIxphCAq.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
+require('./shared/vue.BGxz4dru.cjs');
+require('./shared/vue.Sbbm9JSu.cjs');
 
 
 

package/dist/useSignAndSendTransaction.mjs

@@ -1,11 +1,12 @@
-export { u as useSignAndSendTransaction } from './shared/vue.WugzPOca.mjs';
+export { u as useSignAndSendTransaction } from './shared/vue.Dyi1OCI1.mjs';
 import '@vue-solana/core/errors';
 import '@vue-solana/core/timeout';
 import '@vue-solana/core/transaction';
 import '@vue-solana/core/wallet';
 import 'vue';
-import './shared/vue.ChujsB0B.mjs';
-import './shared/vue.BaFrF2PF.mjs';
-import './shared/vue.CnUlZSe8.mjs';
-import './shared/vue.PJjEncbP.mjs';
-import './shared/vue.B2sFJ1xI.mjs';
+import './shared/vue.CpkwC8Th.mjs';
+import './shared/vue.Mxc8w6Qk.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';
+import './shared/vue.D218Ow7t.mjs';
+import './shared/vue.D3Y0PWbF.mjs';

package/dist/useSignAndSendTransactions.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const useSignAndSendTransactions = require('./shared/vue.CrkK_T15.cjs');
+require('@vue-solana/core/errors');
+require('@vue-solana/core/timeout');
+require('@vue-solana/core/wallet');
+require('vue');
+require('./shared/vue.BGxz4dru.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
+
+
+
+exports.PartialSignAndSendError = useSignAndSendTransactions.PartialSignAndSendError;
+exports.useSignAndSendTransactions = useSignAndSendTransactions.useSignAndSendTransactions;

package/dist/useSignAndSendTransactions.d.cts

@@ -0,0 +1,35 @@
+import * as vue from 'vue';
+import { Signature } from '@vue-solana/core/kit';
+import { SolanaTransaction, SendTransactionOptions } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignAndSendTransactionsStatus = "idle" | "sending" | "sent" | "error";
+/**
+ * Thrown when the singular fallback path fails partway through: the earlier
+ * transactions in the batch have already been sent, and their signatures are
+ * exposed here so callers can avoid resubmitting them.
+ */
+declare class PartialSignAndSendError extends SolanaError {
+    readonly signatures: Signature[];
+    constructor(cause: SolanaError, signatures: Signature[]);
+}
+/**
+ * Sign and send multiple serialized transactions in a single wallet request,
+ * returning one signature per transaction.
+ *
+ * Prefers the wallet's batch `signAndSendTransactions` capability and falls
+ * back to sending the singular `signAndSendTransaction` requests in sequence.
+ * When that fallback fails partway through, it rejects with a
+ * {@link PartialSignAndSendError} carrying the signatures already sent, so a
+ * retry can skip them (the wallet has no batch rollback).
+ */
+declare function useSignAndSendTransactions(): {
+    signatures: vue.ShallowRef<Signature[] | null, Signature[] | null>;
+    status: vue.Ref<SignAndSendTransactionsStatus, SignAndSendTransactionsStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (transactions: SolanaTransaction[], options?: SendTransactionOptions) => Promise<Signature[]>;
+};
+
+export { PartialSignAndSendError, useSignAndSendTransactions };
+export type { SignAndSendTransactionsStatus };

package/dist/useSignAndSendTransactions.d.mts

@@ -0,0 +1,35 @@
+import * as vue from 'vue';
+import { Signature } from '@vue-solana/core/kit';
+import { SolanaTransaction, SendTransactionOptions } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignAndSendTransactionsStatus = "idle" | "sending" | "sent" | "error";
+/**
+ * Thrown when the singular fallback path fails partway through: the earlier
+ * transactions in the batch have already been sent, and their signatures are
+ * exposed here so callers can avoid resubmitting them.
+ */
+declare class PartialSignAndSendError extends SolanaError {
+    readonly signatures: Signature[];
+    constructor(cause: SolanaError, signatures: Signature[]);
+}
+/**
+ * Sign and send multiple serialized transactions in a single wallet request,
+ * returning one signature per transaction.
+ *
+ * Prefers the wallet's batch `signAndSendTransactions` capability and falls
+ * back to sending the singular `signAndSendTransaction` requests in sequence.
+ * When that fallback fails partway through, it rejects with a
+ * {@link PartialSignAndSendError} carrying the signatures already sent, so a
+ * retry can skip them (the wallet has no batch rollback).
+ */
+declare function useSignAndSendTransactions(): {
+    signatures: vue.ShallowRef<Signature[] | null, Signature[] | null>;
+    status: vue.Ref<SignAndSendTransactionsStatus, SignAndSendTransactionsStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (transactions: SolanaTransaction[], options?: SendTransactionOptions) => Promise<Signature[]>;
+};
+
+export { PartialSignAndSendError, useSignAndSendTransactions };
+export type { SignAndSendTransactionsStatus };

package/dist/useSignAndSendTransactions.d.ts

@@ -0,0 +1,35 @@
+import * as vue from 'vue';
+import { Signature } from '@vue-solana/core/kit';
+import { SolanaTransaction, SendTransactionOptions } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignAndSendTransactionsStatus = "idle" | "sending" | "sent" | "error";
+/**
+ * Thrown when the singular fallback path fails partway through: the earlier
+ * transactions in the batch have already been sent, and their signatures are
+ * exposed here so callers can avoid resubmitting them.
+ */
+declare class PartialSignAndSendError extends SolanaError {
+    readonly signatures: Signature[];
+    constructor(cause: SolanaError, signatures: Signature[]);
+}
+/**
+ * Sign and send multiple serialized transactions in a single wallet request,
+ * returning one signature per transaction.
+ *
+ * Prefers the wallet's batch `signAndSendTransactions` capability and falls
+ * back to sending the singular `signAndSendTransaction` requests in sequence.
+ * When that fallback fails partway through, it rejects with a
+ * {@link PartialSignAndSendError} carrying the signatures already sent, so a
+ * retry can skip them (the wallet has no batch rollback).
+ */
+declare function useSignAndSendTransactions(): {
+    signatures: vue.ShallowRef<Signature[] | null, Signature[] | null>;
+    status: vue.Ref<SignAndSendTransactionsStatus, SignAndSendTransactionsStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (transactions: SolanaTransaction[], options?: SendTransactionOptions) => Promise<Signature[]>;
+};
+
+export { PartialSignAndSendError, useSignAndSendTransactions };
+export type { SignAndSendTransactionsStatus };

package/dist/useSignAndSendTransactions.mjs

@@ -0,0 +1,8 @@
+export { P as PartialSignAndSendError, u as useSignAndSendTransactions } from './shared/vue.D5U1yLG3.mjs';
+import '@vue-solana/core/errors';
+import '@vue-solana/core/timeout';
+import '@vue-solana/core/wallet';
+import 'vue';
+import './shared/vue.D218Ow7t.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useSignIn.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const useSignIn = require('./shared/vue.9TPxZPMf.cjs');
+require('@vue-solana/core/errors');
+require('@vue-solana/core/wallet');
+require('vue');
+require('./shared/vue.BGxz4dru.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
+
+
+
+exports.useSignIn = useSignIn.useSignIn;

package/dist/useSignIn.d.cts

@@ -0,0 +1,23 @@
+import * as vue from 'vue';
+import { SolanaSignInResult, SolanaSignInInput } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignInStatus = "idle" | "signing-in" | "signed-in" | "error";
+/**
+ * Trigger a wallet's Sign In With Solana (SIWS) feature.
+ *
+ * Resolves `{ account, signedMessage, signature }` for **server-side
+ * verification** — the signature is over `signedMessage` and must be verified
+ * against `account.publicKey` on your backend before trusting the identity
+ * (see the message-signing guide). The wallet UI drives domain/nonce consent.
+ */
+declare function useSignIn(): {
+    signInResult: vue.ShallowRef<SolanaSignInResult | null, SolanaSignInResult | null>;
+    status: vue.Ref<SignInStatus, SignInStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    signIn: (input?: SolanaSignInInput) => Promise<SolanaSignInResult>;
+};
+
+export { useSignIn };
+export type { SignInStatus };

package/dist/useSignIn.d.mts

@@ -0,0 +1,23 @@
+import * as vue from 'vue';
+import { SolanaSignInResult, SolanaSignInInput } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignInStatus = "idle" | "signing-in" | "signed-in" | "error";
+/**
+ * Trigger a wallet's Sign In With Solana (SIWS) feature.
+ *
+ * Resolves `{ account, signedMessage, signature }` for **server-side
+ * verification** — the signature is over `signedMessage` and must be verified
+ * against `account.publicKey` on your backend before trusting the identity
+ * (see the message-signing guide). The wallet UI drives domain/nonce consent.
+ */
+declare function useSignIn(): {
+    signInResult: vue.ShallowRef<SolanaSignInResult | null, SolanaSignInResult | null>;
+    status: vue.Ref<SignInStatus, SignInStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    signIn: (input?: SolanaSignInInput) => Promise<SolanaSignInResult>;
+};
+
+export { useSignIn };
+export type { SignInStatus };

package/dist/useSignIn.d.ts

@@ -0,0 +1,23 @@
+import * as vue from 'vue';
+import { SolanaSignInResult, SolanaSignInInput } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignInStatus = "idle" | "signing-in" | "signed-in" | "error";
+/**
+ * Trigger a wallet's Sign In With Solana (SIWS) feature.
+ *
+ * Resolves `{ account, signedMessage, signature }` for **server-side
+ * verification** — the signature is over `signedMessage` and must be verified
+ * against `account.publicKey` on your backend before trusting the identity
+ * (see the message-signing guide). The wallet UI drives domain/nonce consent.
+ */
+declare function useSignIn(): {
+    signInResult: vue.ShallowRef<SolanaSignInResult | null, SolanaSignInResult | null>;
+    status: vue.Ref<SignInStatus, SignInStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    signIn: (input?: SolanaSignInInput) => Promise<SolanaSignInResult>;
+};
+
+export { useSignIn };
+export type { SignInStatus };

package/dist/useSignIn.mjs

@@ -0,0 +1,7 @@
+export { u as useSignIn } from './shared/vue.ByxbBC3y.mjs';
+import '@vue-solana/core/errors';
+import '@vue-solana/core/wallet';
+import 'vue';
+import './shared/vue.D218Ow7t.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';