@vue-solana/vue 1.2.0 → 2.1.0

package/dist/useSignAndSendTransaction.d.cts

@@ -1,8 +1,8 @@
-import * as _solana_web3_compat from '@solana/web3-compat';
+import * as _solana_kit from '@solana/kit';
 import * as vue from 'vue';
+import { Signature } from '@vue-solana/core/kit';
 import { SolanaError } from '@vue-solana/core/errors';
 import { SendTransactionOptions, ConfirmTransactionOptions, TransactionConfirmation, SolanaTransaction } from '@vue-solana/core/types';
-import { TransactionSignature } from '@vue-solana/core/web3';
 
 type SignAndSendTransactionStatus = "idle" | "sending" | "sent" | "confirming" | "processed" | "confirmed" | "finalized" | "error";
 interface SignAndSendTransactionOptions extends SendTransactionOptions {
@@ -10,36 +10,30 @@ interface SignAndSendTransactionOptions extends SendTransactionOptions {
     confirmation?: ConfirmTransactionOptions;
 }
 declare function useSignAndSendTransaction(): {
-    signature: vue.Ref<string | null, string | null>;
+    signature: vue.Ref<Signature | null, Signature | null>;
     confirmation: vue.Ref<{
-        signature: TransactionSignature;
-        commitment: _solana_web3_compat.Commitment;
-        result: {
-            context: {
-                slot: number;
-                apiVersion?: string | undefined;
-            };
-            value: {
-                err: unknown | null;
-            };
+        signature: Signature;
+        commitment: _solana_kit.Commitment;
+        status: {
+            slot: _solana_kit.Slot;
+            confirmations: bigint | null;
+            err: unknown | null;
+            confirmationStatus: _solana_kit.Commitment | null;
         };
     } | null, TransactionConfirmation | {
-        signature: TransactionSignature;
-        commitment: _solana_web3_compat.Commitment;
-        result: {
-            context: {
-                slot: number;
-                apiVersion?: string | undefined;
-            };
-            value: {
-                err: unknown | null;
-            };
+        signature: Signature;
+        commitment: _solana_kit.Commitment;
+        status: {
+            slot: _solana_kit.Slot;
+            confirmations: bigint | null;
+            err: unknown | null;
+            confirmationStatus: _solana_kit.Commitment | null;
         };
     } | null>;
     status: vue.Ref<SignAndSendTransactionStatus, SignAndSendTransactionStatus>;
     loading: vue.Ref<boolean, boolean>;
     error: vue.Ref<SolanaError | null, SolanaError | null>;
-    execute: (transaction: SolanaTransaction, options?: SignAndSendTransactionOptions) => Promise<string>;
+    execute: (transaction: SolanaTransaction, options?: SignAndSendTransactionOptions) => Promise<Signature>;
 };
 
 export { useSignAndSendTransaction };

package/dist/useSignAndSendTransaction.d.mts

@@ -1,8 +1,8 @@
-import * as _solana_web3_compat from '@solana/web3-compat';
+import * as _solana_kit from '@solana/kit';
 import * as vue from 'vue';
+import { Signature } from '@vue-solana/core/kit';
 import { SolanaError } from '@vue-solana/core/errors';
 import { SendTransactionOptions, ConfirmTransactionOptions, TransactionConfirmation, SolanaTransaction } from '@vue-solana/core/types';
-import { TransactionSignature } from '@vue-solana/core/web3';
 
 type SignAndSendTransactionStatus = "idle" | "sending" | "sent" | "confirming" | "processed" | "confirmed" | "finalized" | "error";
 interface SignAndSendTransactionOptions extends SendTransactionOptions {
@@ -10,36 +10,30 @@ interface SignAndSendTransactionOptions extends SendTransactionOptions {
     confirmation?: ConfirmTransactionOptions;
 }
 declare function useSignAndSendTransaction(): {
-    signature: vue.Ref<string | null, string | null>;
+    signature: vue.Ref<Signature | null, Signature | null>;
     confirmation: vue.Ref<{
-        signature: TransactionSignature;
-        commitment: _solana_web3_compat.Commitment;
-        result: {
-            context: {
-                slot: number;
-                apiVersion?: string | undefined;
-            };
-            value: {
-                err: unknown | null;
-            };
+        signature: Signature;
+        commitment: _solana_kit.Commitment;
+        status: {
+            slot: _solana_kit.Slot;
+            confirmations: bigint | null;
+            err: unknown | null;
+            confirmationStatus: _solana_kit.Commitment | null;
         };
     } | null, TransactionConfirmation | {
-        signature: TransactionSignature;
-        commitment: _solana_web3_compat.Commitment;
-        result: {
-            context: {
-                slot: number;
-                apiVersion?: string | undefined;
-            };
-            value: {
-                err: unknown | null;
-            };
+        signature: Signature;
+        commitment: _solana_kit.Commitment;
+        status: {
+            slot: _solana_kit.Slot;
+            confirmations: bigint | null;
+            err: unknown | null;
+            confirmationStatus: _solana_kit.Commitment | null;
         };
     } | null>;
     status: vue.Ref<SignAndSendTransactionStatus, SignAndSendTransactionStatus>;
     loading: vue.Ref<boolean, boolean>;
     error: vue.Ref<SolanaError | null, SolanaError | null>;
-    execute: (transaction: SolanaTransaction, options?: SignAndSendTransactionOptions) => Promise<string>;
+    execute: (transaction: SolanaTransaction, options?: SignAndSendTransactionOptions) => Promise<Signature>;
 };
 
 export { useSignAndSendTransaction };

package/dist/useSignAndSendTransaction.d.ts

@@ -1,8 +1,8 @@
-import * as _solana_web3_compat from '@solana/web3-compat';
+import * as _solana_kit from '@solana/kit';
 import * as vue from 'vue';
+import { Signature } from '@vue-solana/core/kit';
 import { SolanaError } from '@vue-solana/core/errors';
 import { SendTransactionOptions, ConfirmTransactionOptions, TransactionConfirmation, SolanaTransaction } from '@vue-solana/core/types';
-import { TransactionSignature } from '@vue-solana/core/web3';
 
 type SignAndSendTransactionStatus = "idle" | "sending" | "sent" | "confirming" | "processed" | "confirmed" | "finalized" | "error";
 interface SignAndSendTransactionOptions extends SendTransactionOptions {
@@ -10,36 +10,30 @@ interface SignAndSendTransactionOptions extends SendTransactionOptions {
     confirmation?: ConfirmTransactionOptions;
 }
 declare function useSignAndSendTransaction(): {
-    signature: vue.Ref<string | null, string | null>;
+    signature: vue.Ref<Signature | null, Signature | null>;
     confirmation: vue.Ref<{
-        signature: TransactionSignature;
-        commitment: _solana_web3_compat.Commitment;
-        result: {
-            context: {
-                slot: number;
-                apiVersion?: string | undefined;
-            };
-            value: {
-                err: unknown | null;
-            };
+        signature: Signature;
+        commitment: _solana_kit.Commitment;
+        status: {
+            slot: _solana_kit.Slot;
+            confirmations: bigint | null;
+            err: unknown | null;
+            confirmationStatus: _solana_kit.Commitment | null;
         };
     } | null, TransactionConfirmation | {
-        signature: TransactionSignature;
-        commitment: _solana_web3_compat.Commitment;
-        result: {
-            context: {
-                slot: number;
-                apiVersion?: string | undefined;
-            };
-            value: {
-                err: unknown | null;
-            };
+        signature: Signature;
+        commitment: _solana_kit.Commitment;
+        status: {
+            slot: _solana_kit.Slot;
+            confirmations: bigint | null;
+            err: unknown | null;
+            confirmationStatus: _solana_kit.Commitment | null;
         };
     } | null>;
     status: vue.Ref<SignAndSendTransactionStatus, SignAndSendTransactionStatus>;
     loading: vue.Ref<boolean, boolean>;
     error: vue.Ref<SolanaError | null, SolanaError | null>;
-    execute: (transaction: SolanaTransaction, options?: SignAndSendTransactionOptions) => Promise<string>;
+    execute: (transaction: SolanaTransaction, options?: SignAndSendTransactionOptions) => Promise<Signature>;
 };
 
 export { useSignAndSendTransaction };

package/dist/useSignAndSendTransaction.mjs

@@ -1,11 +1,12 @@
-export { u as useSignAndSendTransaction } from './shared/vue.CM_uqVc0.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.DiNn3XHm.mjs';
-import './shared/vue.BtUKvuQw.mjs';
-import './shared/vue.CYKT65tB.mjs';
-import './shared/vue.B2AQR2bE.mjs';
-import './shared/vue.QHAHFnw8.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';

package/dist/useSignMessage.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
-const useSignMessage = require('./shared/vue.C0uCLjJ6.cjs');
+const useSignMessage = require('./shared/vue.B6ainw2G.cjs');
 require('@vue-solana/core/errors');
 require('@vue-solana/core/wallet');
 require('vue');
-require('./shared/vue.BEesxsrA.cjs');
-require('./shared/vue.BE4KHksm.cjs');
+require('./shared/vue.BGxz4dru.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
 
 
 

package/dist/useSignMessage.mjs

@@ -1,6 +1,7 @@
-export { u as useSignMessage } from './shared/vue.CSzg70vB.mjs';
+export { u as useSignMessage } from './shared/vue.JUWqu6kD.mjs';
 import '@vue-solana/core/errors';
 import '@vue-solana/core/wallet';
 import 'vue';
-import './shared/vue.B2AQR2bE.mjs';
-import './shared/vue.CYKT65tB.mjs';
+import './shared/vue.D218Ow7t.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useSignTransactions.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const useSignTransactions = require('./shared/vue.DFaMJLAQ.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.useSignTransactions = useSignTransactions.useSignTransactions;

package/dist/useSignTransactions.d.cts

@@ -0,0 +1,24 @@
+import * as vue from 'vue';
+import { SolanaTransaction } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignTransactionsStatus = "idle" | "signing" | "signed" | "error";
+/**
+ * Sign multiple serialized transactions in a single wallet request.
+ *
+ * Prefers the wallet's batch `signTransactions` capability and falls back to
+ * `signAllTransactions` (the legacy naming) when only that is present.
+ * Partial rejection is not a thing in the Wallet Standard: either every
+ * transaction is signed or the request rejects, so a failure clears the
+ * previous result.
+ */
+declare function useSignTransactions(): {
+    signedTransactions: vue.ShallowRef<SolanaTransaction[] | null, SolanaTransaction[] | null>;
+    status: vue.Ref<SignTransactionsStatus, SignTransactionsStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (transactions: SolanaTransaction[]) => Promise<SolanaTransaction[]>;
+};
+
+export { useSignTransactions };
+export type { SignTransactionsStatus };

package/dist/useSignTransactions.d.mts

@@ -0,0 +1,24 @@
+import * as vue from 'vue';
+import { SolanaTransaction } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignTransactionsStatus = "idle" | "signing" | "signed" | "error";
+/**
+ * Sign multiple serialized transactions in a single wallet request.
+ *
+ * Prefers the wallet's batch `signTransactions` capability and falls back to
+ * `signAllTransactions` (the legacy naming) when only that is present.
+ * Partial rejection is not a thing in the Wallet Standard: either every
+ * transaction is signed or the request rejects, so a failure clears the
+ * previous result.
+ */
+declare function useSignTransactions(): {
+    signedTransactions: vue.ShallowRef<SolanaTransaction[] | null, SolanaTransaction[] | null>;
+    status: vue.Ref<SignTransactionsStatus, SignTransactionsStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (transactions: SolanaTransaction[]) => Promise<SolanaTransaction[]>;
+};
+
+export { useSignTransactions };
+export type { SignTransactionsStatus };

package/dist/useSignTransactions.d.ts

@@ -0,0 +1,24 @@
+import * as vue from 'vue';
+import { SolanaTransaction } from '@vue-solana/core/types';
+import { SolanaError } from '@vue-solana/core/errors';
+
+type SignTransactionsStatus = "idle" | "signing" | "signed" | "error";
+/**
+ * Sign multiple serialized transactions in a single wallet request.
+ *
+ * Prefers the wallet's batch `signTransactions` capability and falls back to
+ * `signAllTransactions` (the legacy naming) when only that is present.
+ * Partial rejection is not a thing in the Wallet Standard: either every
+ * transaction is signed or the request rejects, so a failure clears the
+ * previous result.
+ */
+declare function useSignTransactions(): {
+    signedTransactions: vue.ShallowRef<SolanaTransaction[] | null, SolanaTransaction[] | null>;
+    status: vue.Ref<SignTransactionsStatus, SignTransactionsStatus>;
+    loading: vue.Ref<boolean, boolean>;
+    error: vue.Ref<SolanaError | null, SolanaError | null>;
+    execute: (transactions: SolanaTransaction[]) => Promise<SolanaTransaction[]>;
+};
+
+export { useSignTransactions };
+export type { SignTransactionsStatus };

package/dist/useSignTransactions.mjs

@@ -0,0 +1,7 @@
+export { u as useSignTransactions } from './shared/vue.CMohL_Cz.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';

package/dist/useSignatureStatus.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
-const useSignatureStatus = require('./shared/vue.Bhdhmz8d.cjs');
+const useSignatureStatus = require('./shared/vue.CIs8QhCw.cjs');
 require('@vue-solana/core/errors');
 require('bs58');
 require('vue');
-require('./shared/vue.DCgByzxg.cjs');
-require('./shared/vue.LNhX07HB.cjs');
-require('./shared/vue.BE4KHksm.cjs');
+require('./shared/vue.BVaMoz9y.cjs');
+require('./shared/vue.BIxphCAq.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
 
 
 

package/dist/useSignatureStatus.d.cts

@@ -1,22 +1,26 @@
 import * as vue from 'vue';
 import { MaybeRefOrGetter } from 'vue';
-import { Commitment, TransactionSignature, SignatureStatus } from '@vue-solana/core/web3';
+import { Commitment } from '@vue-solana/core/kit';
 import { SolanaError } from '@vue-solana/core/errors';
 
 interface UseSignatureStatusOptions {
     commitment?: Commitment;
     pollIntervalMs?: number;
     searchTransactionHistory?: boolean;
-    subscribe?: boolean;
 }
-declare function useSignatureStatus(signature: MaybeRefOrGetter<TransactionSignature | null | undefined>, options?: UseSignatureStatusOptions): {
+interface SignatureStatus {
+    slot: number;
+    confirmations: number | null;
+    err: unknown | null;
+    confirmationStatus: Commitment | null;
+}
+declare function useSignatureStatus(signature: MaybeRefOrGetter<string | null | undefined>, options?: UseSignatureStatusOptions): {
     status: vue.ShallowRef<SignatureStatus | null, SignatureStatus | null>;
     loading: vue.ShallowRef<boolean, boolean>;
     error: vue.ShallowRef<SolanaError | null, SolanaError | null>;
     refresh: () => Promise<SignatureStatus | null>;
     stopPolling: () => void;
-    stopSubscription: () => Promise<void>;
 };
 
 export { useSignatureStatus };
-export type { UseSignatureStatusOptions };
+export type { SignatureStatus, UseSignatureStatusOptions };