@vue-solana/core 3.0.1 → 4.0.0-rc.1

package/dist/kit.mjs

@@ -1,25 +1,38 @@
-import { getBase64Encoder, getBase58Decoder, signBytes, createClient, extendClient, createKeyPairFromBytes, isSolanaError, SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY } from '@solana/kit';
+import { getBase64Encoder, getBase58Decoder, signBytes, createClient, extendClient, createRpc, createDefaultRpcTransport, createSolanaRpcApi, DEFAULT_RPC_CONFIG, createSubscriptionRpc, createDefaultRpcSubscriptionsTransport, createDefaultSolanaRpcSubscriptionsChannelCreator, createSolanaRpcSubscriptionsApi, DEFAULT_RPC_SUBSCRIPTIONS_CONFIG, createKeyPairFromBytes, isSolanaError, SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY } from '@solana/kit';
 export * from '@solana/kit';
-import { solanaRpc, rpcAirdrop } from '@solana/kit-plugin-rpc';
+import { solanaRpc, rpcAirdrop, rpcGetMinimumBalance, rpcTransactionPlanner, rpcTransactionPlanSigningExecutor, rpcTransactionPlanSendingExecutor } from '@solana/kit-plugin-rpc';
 import { DEFAULT_CLUSTER, getClusterEndpoint, getWebSocketEndpoint, getClusterWebSocketEndpoint } from './clusters.mjs';
 
-function buildSolanaClient(endpoint, wsEndpoint, payer) {
+function buildSolanaClient(endpoint, wsEndpoint, payer, commitment) {
   const client = createClient().use(
     (current) => extendClient(current, payer ? { payer } : {})
   );
-  return client.use(
-    solanaRpc({
-      rpcUrl: endpoint,
-      rpcSubscriptionsUrl: wsEndpoint
+  const rpc = commitment ? createRpc({
+    api: createSolanaRpcApi({ ...DEFAULT_RPC_CONFIG, defaultCommitment: commitment }),
+    transport: createDefaultRpcTransport({ url: endpoint })
+  }) : void 0;
+  const rpcSubscriptions = commitment ? createSubscriptionRpc({
+    api: createSolanaRpcSubscriptionsApi({
+      ...DEFAULT_RPC_SUBSCRIPTIONS_CONFIG,
+      defaultCommitment: commitment
+    }),
+    transport: createDefaultRpcSubscriptionsTransport({
+      createChannel: createDefaultSolanaRpcSubscriptionsChannelCreator({
+        url: wsEndpoint
+      })
     })
-  ).use(rpcAirdrop());
+  }) : void 0;
+  if (!rpc || !rpcSubscriptions) {
+    return client.use(solanaRpc({ rpcUrl: endpoint, rpcSubscriptionsUrl: wsEndpoint })).use(rpcAirdrop());
+  }
+  return client.use((current) => extendClient(current, { rpc, rpcSubscriptions })).use(rpcGetMinimumBalance()).use(rpcTransactionPlanner()).use(rpcTransactionPlanSigningExecutor()).use(rpcTransactionPlanSendingExecutor()).use(rpcAirdrop());
 }
 function createSolanaClient(config = {}) {
   const cluster = config.cluster ?? DEFAULT_CLUSTER;
   const endpoint = config.endpoint ?? getClusterEndpoint(cluster);
   const wsEndpoint = config.wsEndpoint ?? (config.endpoint ? getWebSocketEndpoint(endpoint) : getClusterWebSocketEndpoint(cluster));
   const payer = config.payer ?? resolvePayerFromSecretKey(config.payerSecretKey);
-  return buildSolanaClient(endpoint, wsEndpoint, payer);
+  return buildSolanaClient(endpoint, wsEndpoint, payer, config.commitment);
 }
 function resolvePayerFromSecretKey(payerSecretKey) {
   if (!payerSecretKey) {

package/dist/mobile-wallet.d.ts

@@ -1,5 +1,5 @@
 export { isSolanaMobileWalletSupported } from './mobile-wallet-support.js';
-import { a as SolanaChain } from './shared/core.C9vxHRXl.js';
+import { a as SolanaChain } from './shared/core.BhF1J_tt.js';
 import '@solana/kit-plugin-rpc';
 import '@solana/kit';
 
@@ -14,7 +14,17 @@ interface RegisterSolanaMobileWalletOptions {
     remoteHostAuthority?: string;
 }
 declare function registerSolanaMobileWallet(options?: RegisterSolanaMobileWalletOptions): boolean;
+/**
+ * Clears this package's local record of which Mobile Wallet Adapter
+ * registration keys have been applied. This only affects the deduplication guard
+ * inside `registerSolanaMobileWallet()`; it does not (and cannot) unregister an
+ * MWA wallet already installed into the host's Wallet Standard registry, because
+ * `@solana-mobile/wallet-standard-mobile` provides no unregister API. Calling
+ * `registerSolanaMobileWallet()` after this may therefore install a duplicate
+ * host-side registration. Intended for test/HMR reset only.
+ */
+declare function unregisterSolanaMobileWallet(): void;
 declare function getDefaultMobileWalletAppIdentity(): SolanaMobileWalletAppIdentity;
 
-export { getDefaultMobileWalletAppIdentity, registerSolanaMobileWallet };
+export { getDefaultMobileWalletAppIdentity, registerSolanaMobileWallet, unregisterSolanaMobileWallet };
 export type { RegisterSolanaMobileWalletOptions, SolanaMobileWalletAppIdentity };

package/dist/mobile-wallet.mjs

@@ -28,6 +28,9 @@ function registerSolanaMobileWallet(options = {}) {
   registeredMobileWalletKeys.add(registrationKey);
   return true;
 }
+function unregisterSolanaMobileWallet() {
+  registeredMobileWalletKeys.clear();
+}
 function getDefaultMobileWalletAppIdentity() {
   if (typeof window === "undefined") {
     return {
@@ -54,4 +57,4 @@ function getDocumentIconPath() {
   return icon.href;
 }
 
-export { getDefaultMobileWalletAppIdentity, isSolanaMobileWalletSupported, registerSolanaMobileWallet };
+export { getDefaultMobileWalletAppIdentity, isSolanaMobileWalletSupported, registerSolanaMobileWallet, unregisterSolanaMobileWallet };

package/dist/rpc.d.ts

@@ -1,4 +1,4 @@
-import { d as SolanaConfig, e as SolanaContext } from './shared/core.C9vxHRXl.js';
+import { d as SolanaConfig, e as SolanaContext } from './shared/core.BhF1J_tt.js';
 import '@solana/kit-plugin-rpc';
 import '@solana/kit';
 

package/dist/shared/{core.DaUlAmcN.mjs → core.A4I__4IR.mjs}

@@ -1,8 +1,42 @@
 import { StandardEvents, StandardDisconnect, StandardConnect } from '@wallet-standard/features';
 import { SolanaSignTransaction, SolanaSignIn, SolanaSignAndSendTransaction, SolanaSignMessage } from '@solana/wallet-standard-features';
-import bs58 from 'bs58';
+import { isSignatureBytes, verifySignature, getBase58Decoder } from '@solana/kit';
+import { createSolanaError } from '../errors.mjs';
 import { getWallets } from '@wallet-standard/app';
 
+async function assertWalletSignature(publicKey, signedMessage, signature, label) {
+  if (!isSignatureBytes(signature)) {
+    throw createSolanaError(
+      "INVALID_SIGNATURE",
+      `The wallet returned a malformed ${label} signature.`
+    );
+  }
+  let key;
+  try {
+    key = await globalThis.crypto.subtle.importKey(
+      "raw",
+      publicKey,
+      "Ed25519",
+      true,
+      ["verify"]
+    );
+  } catch {
+    return;
+  }
+  let valid;
+  try {
+    valid = await verifySignature(key, signature, signedMessage);
+  } catch {
+    return;
+  }
+  if (!valid) {
+    throw createSolanaError(
+      "INVALID_SIGNATURE",
+      `The wallet returned an invalid ${label} signature.`
+    );
+  }
+}
+
 const SOLANA_CHAINS = [
   "solana:mainnet",
   "solana:testnet",
@@ -42,16 +76,20 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
   let disconnecting = false;
   let manuallyDisconnected = false;
   const eventsFeature = wallet.features[StandardEvents];
-  eventsFeature?.on("change", (properties) => {
+  const unsubscribeChange = eventsFeature?.on("change", (properties) => {
     if (properties.accounts) {
       accounts = properties.accounts;
       account = allowAccountUpdates && !manuallyDisconnected ? getSolanaAccount(accounts, options.chain) : void 0;
       options.onChange?.();
     }
   });
+  function dispose() {
+    unsubscribeChange?.();
+  }
   return {
     platform: walletInfo.platform,
     source: walletInfo.source,
+    dispose,
     get publicKey() {
       return account ? account.address : null;
     },
@@ -110,7 +148,30 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       if (!result) {
         throw new Error("Solana wallet did not return a sign-in result");
       }
-      return toSolanaSignInResult(result);
+      const signInResult = toSolanaSignInResult(result);
+      const requestedAddress = input?.address ?? account?.address;
+      const signInAccount = accounts.find(
+        (candidate) => candidate.address === signInResult.account.address
+      );
+      if (!signInAccount) {
+        throw createSolanaError(
+          "INVALID_SIGNATURE",
+          "The wallet returned a sign-in account it does not expose."
+        );
+      }
+      if (requestedAddress !== void 0 && requestedAddress !== signInAccount.address) {
+        throw createSolanaError(
+          "INVALID_SIGNATURE",
+          `The wallet signed in as ${signInResult.account.address} instead of the requested ${requestedAddress}.`
+        );
+      }
+      await assertWalletSignature(
+        signInAccount.publicKey,
+        signInResult.signedMessage,
+        signInResult.signature,
+        "sign-in"
+      );
+      return signInResult;
     } : void 0,
     signMessage: hasSignMessage(wallet) ? async (message) => {
       const activeAccount = getActiveAccount(account);
@@ -121,6 +182,12 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       if (!result) {
         throw new Error("Solana wallet did not return a message signature");
       }
+      await assertWalletSignature(
+        activeAccount.publicKey,
+        result.signedMessage,
+        result.signature,
+        "message"
+      );
       return result;
     } : void 0,
     signTransaction: hasSignTransaction(wallet) ? async (transaction) => {
@@ -158,7 +225,7 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       if (!result) {
         throw new Error("Solana wallet did not return a transaction signature");
       }
-      return { signature: bs58.encode(result.signature) };
+      return { signature: getBase58Decoder().decode(result.signature) };
     } : void 0,
     signAndSendTransactions: hasSignAndSendTransaction(wallet) ? async (transactions, sendOptions) => {
       const activeAccount = getActiveAccount(account);
@@ -179,11 +246,24 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
         if (!result) {
           throw new Error("Solana wallet did not return a transaction signature");
         }
-        return bs58.encode(result.signature);
+        return getBase58Decoder().decode(result.signature);
       });
     } : void 0
   };
 }
+async function disconnectSolanaStandardWallet(walletInfo) {
+  const wallet = walletInfo.wallet;
+  if (typeof wallet !== "object" && typeof wallet !== "function") {
+    return false;
+  }
+  const features = wallet?.features;
+  const feature = features?.[StandardDisconnect];
+  if (typeof feature?.disconnect !== "function") {
+    return false;
+  }
+  await feature.disconnect();
+  return true;
+}
 async function signAllThroughFeature(wallet, getAccount, transactions, chain) {
   const activeAccount = getAccount();
   const results = await wallet.features[SolanaSignTransaction].signTransaction(
@@ -301,4 +381,4 @@ function getWalletUrl(wallet) {
   return "url" in wallet && typeof wallet.url === "string" ? wallet.url : void 0;
 }
 
-export { SOLANA_CHAINS as S, SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME as a, adaptSolanaStandardWallet as b, getSolanaChain as c, getRegisteredSolanaWallets as g, isSolanaStandardWallet as i, subscribeSolanaWallets as s };
+export { SOLANA_CHAINS as S, SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME as a, adaptSolanaStandardWallet as b, getSolanaChain as c, disconnectSolanaStandardWallet as d, getRegisteredSolanaWallets as g, isSolanaStandardWallet as i, subscribeSolanaWallets as s };

package/dist/shared/{core.C9vxHRXl.d.mts → core.BhF1J_tt.d.ts}

@@ -1,6 +1,6 @@
 import * as _solana_kit_plugin_rpc from '@solana/kit-plugin-rpc';
 import * as _solana_kit from '@solana/kit';
-import { Commitment, Slot, TransactionSigner, Address, ReadonlyUint8Array, Signature } from '@solana/kit';
+import { Address, ReadonlyUint8Array, Slot, Commitment, TransactionSigner, Signature } from '@solana/kit';
 
 /**
  * Solana cluster names. `mainnet` is Solana's official mainnet cluster name.
@@ -82,9 +82,21 @@ interface SolanaWallet {
     source?: SolanaWalletInfo["source"];
     connect: () => Promise<void>;
     disconnect: () => Promise<void>;
+    /**
+     * Releases wallet-event subscriptions captured at adapt time (e.g. the
+     * Wallet Standard `change` listener). The wallet stays connected; only
+     * event delivery stops. Idempotent. Present on adapted wallets; plain
+     * caller-supplied wallets typically omit it.
+     */
+    dispose?: () => void;
     signMessage?: (message: Uint8Array) => Promise<SolanaSignMessageResult>;
     signIn?: (input?: SolanaSignInInput) => Promise<SolanaSignInResult>;
     signTransaction?: (transaction: SolanaTransaction) => Promise<SolanaTransaction>;
+    /**
+     * @deprecated Prefer `signTransactions` (identical signature). `signTransactions`
+     * is tried first in `useSignTransactions()`; `signAllTransactions` remains as
+     * the legacy Wallet Standard naming.
+     */
     signAllTransactions?: (transactions: SolanaTransaction[]) => Promise<SolanaTransaction[]>;
     signTransactions?: (transactions: SolanaTransaction[]) => Promise<SolanaTransaction[]>;
     signAndSendTransaction?: (transaction: SolanaTransaction, options?: SendTransactionOptions) => Promise<{
@@ -128,6 +140,26 @@ interface SendTransactionOptions {
 interface ConfirmTransactionOptions {
     commitment?: Commitment;
     timeoutMs?: number;
+    /**
+     * Milliseconds between `getSignatureStatuses` polls. Defaults to 1500.
+     * Must be greater than 0: with no delay between polls an absent signature
+     * would hammer the RPC until the timeout expires.
+     */
+    pollIntervalMs?: number;
+    /**
+     * Rejects without further polling when the caller's own `AbortSignal`
+     * fires. An aborted confirmation rejects with the signal's reason (an
+     * `AbortError` by default) rather than a timeout error.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Pass `true` to search transaction history when the signature may have
+     * left the recent status cache. Defaults to `false`: an older signature
+     * never appears in `getSignatureStatuses` results, so confirming one
+     * without this flag resolves to `TRANSACTION_NOT_FOUND` after the timeout
+     * rather than confirming.
+     */
+    searchTransactionHistory?: boolean;
 }
 interface TransactionStatus {
     slot: Slot;
@@ -141,9 +173,10 @@ interface TransactionConfirmation {
     status: TransactionStatus;
 }
 
-declare function buildSolanaClient(endpoint: string, wsEndpoint: string, payer: TransactionSigner | undefined): _solana_kit.Client<{
+declare function buildSolanaClient(endpoint: string, wsEndpoint: string, payer: TransactionSigner | undefined, commitment: Commitment | undefined): _solana_kit.Client<{
     signTransactions: (input: _solana_kit.InstructionPlanInput | _solana_kit.TransactionPlanInput, config?: {
         abortSignal?: AbortSignal;
+        maxInstructionsPerTransaction?: number;
     }) => Promise<_solana_kit.TransactionPlanResult<_solana_kit_plugin_rpc.RpcSignContext>>;
     payer: TransactionSigner;
     rpc: _solana_kit.Rpc<_solana_kit.RequestAirdropApi & _solana_kit.GetAccountInfoApi & _solana_kit.GetAgGenesisCertApi & _solana_kit.GetBalanceApi & _solana_kit.GetBlockApi & _solana_kit.GetBlockCommitmentApi & _solana_kit.GetBlockHeightApi & _solana_kit.GetBlockProductionApi & _solana_kit.GetBlocksApi & _solana_kit.GetBlocksWithLimitApi & _solana_kit.GetBlockTimeApi & _solana_kit.GetClusterNodesApi & _solana_kit.GetEpochInfoApi & _solana_kit.GetEpochScheduleApi & _solana_kit.GetFeeForMessageApi & _solana_kit.GetFirstAvailableBlockApi & _solana_kit.GetGenesisHashApi & _solana_kit.GetHealthApi & _solana_kit.GetHighestSnapshotSlotApi & _solana_kit.GetIdentityApi & _solana_kit.GetInflationGovernorApi & _solana_kit.GetInflationRateApi & _solana_kit.GetInflationRewardApi & _solana_kit.GetLargestAccountsApi & _solana_kit.GetLatestBlockhashApi & _solana_kit.GetLeaderScheduleApi & _solana_kit.GetMaxRetransmitSlotApi & _solana_kit.GetMaxShredInsertSlotApi & _solana_kit.GetMinimumBalanceForRentExemptionApi & _solana_kit.GetMultipleAccountsApi & _solana_kit.GetProgramAccountsApi & _solana_kit.GetRecentPerformanceSamplesApi & _solana_kit.GetRecentPrioritizationFeesApi & _solana_kit.GetSignaturesForAddressApi & _solana_kit.GetSignatureStatusesApi & _solana_kit.GetSlotApi & _solana_kit.GetSlotLeaderApi & _solana_kit.GetSlotLeadersApi & _solana_kit.GetStakeMinimumDelegationApi & _solana_kit.GetSupplyApi & _solana_kit.GetTokenAccountBalanceApi & _solana_kit.GetTokenAccountsByDelegateApi & _solana_kit.GetTokenAccountsByOwnerApi & _solana_kit.GetTokenLargestAccountsApi & _solana_kit.GetTokenSupplyApi & _solana_kit.GetTransactionApi & _solana_kit.GetTransactionCountApi & _solana_kit.GetTransactionsForAddressApi & _solana_kit.GetVersionApi & _solana_kit.GetVoteAccountsApi & _solana_kit.IsBlockhashValidApi & _solana_kit.MinimumLedgerSlotApi & _solana_kit.SendTransactionApi & _solana_kit.SimulateTransactionApi>;
@@ -152,9 +185,11 @@ declare function buildSolanaClient(endpoint: string, wsEndpoint: string, payer:
     transactionPlanner: _solana_kit.TransactionPlanner;
     planTransaction: (input: _solana_kit.InstructionPlanInput, config?: {
         abortSignal?: AbortSignal;
+        maxInstructionsPerTransaction?: number;
     }) => Promise<_solana_kit.SingleTransactionPlan["message"]>;
     planTransactions: (input: _solana_kit.InstructionPlanInput, config?: {
         abortSignal?: AbortSignal;
+        maxInstructionsPerTransaction?: number;
     }) => Promise<_solana_kit.TransactionPlan>;
     signTransaction: (input: _solana_kit.InstructionPlanInput | (_solana_kit.TransactionMessage & _solana_kit.TransactionMessageWithFeePayer<string>) | Readonly<{
         kind: "single";
@@ -162,6 +197,7 @@ declare function buildSolanaClient(endpoint: string, wsEndpoint: string, payer:
         planType: "transactionPlan";
     }>, config?: {
         abortSignal?: AbortSignal;
+        maxInstructionsPerTransaction?: number;
     }) => Promise<_solana_kit.SuccessfulSingleTransactionPlanResult<_solana_kit_plugin_rpc.RpcSignContext>>;
     transactionPlanExecutor: _solana_kit.TransactionPlanExecutor<_solana_kit_plugin_rpc.RpcSendContext>;
     sendTransaction: (input: _solana_kit.InstructionPlanInput | (_solana_kit.TransactionMessage & _solana_kit.TransactionMessageWithFeePayer<string>) | Readonly<{
@@ -170,9 +206,11 @@ declare function buildSolanaClient(endpoint: string, wsEndpoint: string, payer:
         planType: "transactionPlan";
     }>, config?: {
         abortSignal?: AbortSignal;
+        maxInstructionsPerTransaction?: number;
     }) => Promise<_solana_kit.SuccessfulSingleTransactionPlanResult<_solana_kit_plugin_rpc.RpcSendContext>>;
     sendTransactions: (input: _solana_kit.InstructionPlanInput | _solana_kit.TransactionPlanInput, config?: {
         abortSignal?: AbortSignal;
+        maxInstructionsPerTransaction?: number;
     }) => Promise<_solana_kit.TransactionPlanResult<_solana_kit_plugin_rpc.RpcSendContext>>;
     airdrop: (address: Address, amount: _solana_kit.Lamports, abortSignal?: AbortSignal) => Promise<_solana_kit.Signature | undefined>;
 }>;

package/dist/timeout.d.ts

@@ -1,4 +1,25 @@
-declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, createError: () => unknown): Promise<T>;
+import { SolanaErrorCode } from './errors.js';
+
+interface WithTimeoutOptions {
+    /**
+     * Rejects without racing when the caller's own `AbortSignal` fires first.
+     * An aborted wait rejects with the signal's reason (an `AbortError` by
+     * default) rather than the timeout error.
+     */
+    signal?: AbortSignal;
+    /**
+     * Error code for the timeout rejection when `createError` is not given.
+     * Defaults to `"TRANSACTION_TIMEOUT"`.
+     */
+    code?: SolanaErrorCode;
+    /**
+     * Message for the timeout rejection when `createError` is not given.
+     */
+    message?: string;
+}
+declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, createError?: () => unknown, options?: WithTimeoutOptions): Promise<T>;
+declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, options?: WithTimeoutOptions): Promise<T>;
 declare function withSolanaTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, message: string): Promise<T>;
 
 export { withSolanaTimeout, withTimeout };
+export type { WithTimeoutOptions };

package/dist/timeout.mjs

@@ -1,28 +1,64 @@
 import { createSolanaError } from './errors.mjs';
 
-function withTimeout(promise, timeoutMs, createError) {
+function withTimeout(promise, timeoutMs, createErrorOrOptions, maybeOptions) {
+  const createError = typeof createErrorOrOptions === "function" ? createErrorOrOptions : void 0;
+  const {
+    signal,
+    code = "TRANSACTION_TIMEOUT",
+    message
+  } = (typeof createErrorOrOptions === "function" ? maybeOptions : createErrorOrOptions) ?? {};
   if (timeoutMs === void 0) {
-    return promise;
+    return signal ? raceWithSignal(promise, signal) : promise;
   }
+  if (typeof timeoutMs !== "number" || Number.isNaN(timeoutMs) || timeoutMs < 0) {
+    throw createSolanaError(
+      "INVALID_INPUT",
+      `Invalid timeout: expected a non-negative number of milliseconds, received ${String(timeoutMs)}`
+    );
+  }
+  signal?.throwIfAborted();
   let timeoutId;
-  return Promise.race([
-    promise,
-    // ponytail: the try/catch looks redundant but is not. `createError()` runs
-    // in the `setTimeout` callback, not the executor body, so a throwing
-    // factory would be an uncaught exception rather than a rejection.
-    new Promise((_, reject) => {
-      timeoutId = setTimeout(() => {
-        try {
-          reject(createError());
-        } catch (error) {
-          reject(error);
-        }
-      }, timeoutMs);
-    })
-  ]).finally(() => {
+  let onAbort;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      try {
+        reject(createError?.() ?? createSolanaError(code, message ?? "Operation timed out"));
+      } catch (error) {
+        reject(error);
+      }
+    }, timeoutMs);
+    if (signal) {
+      onAbort = () => reject(signal.reason);
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+  const raced = signal ? raceWithSignal(promise, signal) : promise;
+  return Promise.race([raced, timeoutPromise]).finally(() => {
     if (timeoutId) {
       clearTimeout(timeoutId);
     }
+    if (signal && onAbort) {
+      signal.removeEventListener("abort", onAbort);
+    }
+  });
+}
+function raceWithSignal(promise, signal) {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (cause) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(cause);
+      }
+    );
   });
 }
 function withSolanaTimeout(promise, timeoutMs, message) {

package/dist/token-accounts.d.ts

@@ -1,5 +1,5 @@
 import { Address, Commitment } from '@solana/kit';
-import { b as SolanaClient } from './shared/core.C9vxHRXl.js';
+import { b as SolanaClient } from './shared/core.BhF1J_tt.js';
 import '@solana/kit-plugin-rpc';
 
 interface TokenAccountInfo {

package/dist/token-accounts.mjs

@@ -1,5 +1,5 @@
-import { address } from '@solana/kit';
-import { normalizeSolanaError } from './errors.mjs';
+import { address, isAddress } from '@solana/kit';
+import { normalizeSolanaError, createSolanaError } from './errors.mjs';
 
 const TOKEN_PROGRAM_ADDRESS = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const TOKEN_2022_PROGRAM_ADDRESS = address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
@@ -54,6 +54,13 @@ function tokenAccountInfoFromParsed(address2, data) {
   if (!parsed) {
     throw new Error(`Token account ${address2} has no parsed data`);
   }
+  const mismatches = validateParsedTokenAccount(parsed);
+  if (mismatches.length > 0) {
+    throw createSolanaError(
+      "RPC_FAILURE",
+      `Token account ${address2} returned malformed data (${mismatches.join(", ")})`
+    );
+  }
   return {
     address: address2,
     mint: parsed.mint,
@@ -64,5 +71,27 @@ function tokenAccountInfoFromParsed(address2, data) {
     isNative: parsed.isNative
   };
 }
+function validateParsedTokenAccount(parsed) {
+  const mismatches = [];
+  if (typeof parsed.mint !== "string" || !isAddress(parsed.mint)) {
+    mismatches.push("mint");
+  }
+  if (typeof parsed.owner !== "string" || !isAddress(parsed.owner)) {
+    mismatches.push("owner");
+  }
+  if (typeof parsed.tokenAmount?.amount !== "string" || !/^\d+$/.test(parsed.tokenAmount.amount)) {
+    mismatches.push("tokenAmount.amount");
+  }
+  if (typeof parsed.tokenAmount?.decimals !== "number" || !Number.isInteger(parsed.tokenAmount.decimals) || parsed.tokenAmount.decimals < 0) {
+    mismatches.push("tokenAmount.decimals");
+  }
+  if (parsed.state !== "frozen" && parsed.state !== "initialized" && parsed.state !== "uninitialized") {
+    mismatches.push("state");
+  }
+  if (typeof parsed.isNative !== "boolean") {
+    mismatches.push("isNative");
+  }
+  return mismatches;
+}
 
 export { getTokenAccount, getTokenAccountsByOwner, getTokenBalance };

package/dist/transaction.d.ts

@@ -1,5 +1,5 @@
 import { Signature } from '@solana/kit';
-import { b as SolanaClient, C as ConfirmTransactionOptions, T as TransactionConfirmation, k as SolanaWallet, j as SolanaTransaction, S as SendTransactionOptions } from './shared/core.C9vxHRXl.js';
+import { b as SolanaClient, C as ConfirmTransactionOptions, T as TransactionConfirmation, k as SolanaWallet, j as SolanaTransaction, S as SendTransactionOptions } from './shared/core.BhF1J_tt.js';
 import '@solana/kit-plugin-rpc';
 
 /**
@@ -12,6 +12,14 @@ declare function signAndSendTransaction(client: SolanaClient, wallet: SolanaWall
 /**
  * Confirm a transaction signature against the kit RPC until it reaches the
  * requested commitment.
+ *
+ * Kit's `sendAndConfirmTransaction` cannot back this: it needs the whole
+ * transaction plus a `rpcSubscriptions` websocket and sends the transaction
+ * itself, whereas this confirms a signature a wallet already submitted.
+ *
+ * Kit's `getSignatureStatuses` takes no commitment parameter — the commitment
+ * check below is client-side. A missing status means the signature is unknown
+ * (not found), distinct from a failed transaction or an expired wait.
  */
 declare function confirmTransactionSignature(client: SolanaClient, signature: Signature, options?: ConfirmTransactionOptions): Promise<TransactionConfirmation>;
 

package/dist/transaction.mjs

@@ -31,17 +31,36 @@ async function signAndSendTransaction(client, wallet, transaction, options) {
 async function confirmTransactionSignature(client, signature, options = {}) {
   const commitment = options.commitment ?? DEFAULT_CONFIRMATION_COMMITMENT;
   const timeoutMs = options.timeoutMs ?? DEFAULT_CONFIRMATION_TIMEOUT_MS;
-  let elapsedMs = 0;
+  const pollIntervalMs = options.pollIntervalMs ?? SIGNATURE_STATUS_POLL_INTERVAL_MS;
+  const { abortSignal, searchTransactionHistory = false } = options;
+  if (typeof timeoutMs !== "number" || Number.isNaN(timeoutMs) || timeoutMs < 0) {
+    throw createSolanaError(
+      "INVALID_INPUT",
+      `Invalid confirmation timeout: expected a non-negative number of milliseconds, received ${String(timeoutMs)}`
+    );
+  }
+  if (typeof pollIntervalMs !== "number" || Number.isNaN(pollIntervalMs) || pollIntervalMs <= 0) {
+    throw createSolanaError(
+      "INVALID_INPUT",
+      `Invalid confirmation poll interval: expected a positive number of milliseconds, received ${String(pollIntervalMs)}`
+    );
+  }
+  abortSignal?.throwIfAborted();
+  const deadline = Date.now() + timeoutMs;
+  let sawStatus = false;
   try {
-    while (elapsedMs < timeoutMs) {
-      const response = await client.rpc.getSignatureStatuses([signature]).send();
+    while (Date.now() < deadline) {
+      abortSignal?.throwIfAborted();
+      const response = await client.rpc.getSignatureStatuses([signature], { searchTransactionHistory }).send({ abortSignal });
       const [status] = response.value;
       if (!status) {
-        throw new Error(`Transaction ${signature} was not found.`);
+        await wait(pollIntervalMs, abortSignal);
+        continue;
       }
+      sawStatus = true;
       if (status.err) {
         throw createSolanaError(
-          "RPC_FAILURE",
+          "TRANSACTION_FAILED",
           `Transaction ${signature} failed to reach ${commitment} commitment.`,
           { cause: status.err }
         );
@@ -49,14 +68,22 @@ async function confirmTransactionSignature(client, signature, options = {}) {
       if (hasReachedCommitment(status.confirmationStatus, commitment)) {
         return { signature, commitment, status };
       }
-      await wait(SIGNATURE_STATUS_POLL_INTERVAL_MS);
-      elapsedMs += SIGNATURE_STATUS_POLL_INTERVAL_MS;
+      await wait(pollIntervalMs, abortSignal);
+    }
+    if (!sawStatus) {
+      throw createSolanaError("TRANSACTION_NOT_FOUND", `Transaction ${signature} was not found.`);
     }
     throw createSolanaError(
       "TRANSACTION_TIMEOUT",
       `Timed out waiting for transaction ${signature} to reach ${commitment} commitment.`
     );
   } catch (cause) {
+    if (abortSignal?.aborted) {
+      throw abortSignal.reason ?? cause;
+    }
+    if (isAbortErrorLike(cause)) {
+      throw cause;
+    }
     throw normalizeSolanaError(cause, "RPC_FAILURE");
   }
 }
@@ -69,10 +96,25 @@ function hasReachedCommitment(actualStatus, targetCommitment) {
   }
   return (COMMITMENT_RANK[actualStatus] ?? 0) >= (COMMITMENT_RANK[targetCommitment] ?? 0);
 }
-function wait(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+function wait(ms, signal) {
+  if (ms <= 0) {
+    signal?.throwIfAborted();
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timeoutId);
+      reject(signal.reason);
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
+function isAbortErrorLike(cause) {
+  return typeof cause === "object" && cause !== null && cause.name === "AbortError";
+}
 
 export { confirmTransactionSignature, signAndSendTransaction };

package/dist/types.d.ts

@@ -1,3 +1,3 @@
 import '@solana/kit';
-export { C as ConfirmTransactionOptions, S as SendTransactionOptions, a as SolanaChain, c as SolanaCluster, d as SolanaConfig, e as SolanaContext, f as SolanaSignInAccount, g as SolanaSignInInput, h as SolanaSignInResult, i as SolanaSignMessageResult, j as SolanaTransaction, k as SolanaWallet, l as SolanaWalletInfo, T as TransactionConfirmation, m as TransactionStatus } from './shared/core.C9vxHRXl.js';
+export { C as ConfirmTransactionOptions, S as SendTransactionOptions, a as SolanaChain, c as SolanaCluster, d as SolanaConfig, e as SolanaContext, f as SolanaSignInAccount, g as SolanaSignInInput, h as SolanaSignInResult, i as SolanaSignMessageResult, j as SolanaTransaction, k as SolanaWallet, l as SolanaWalletInfo, T as TransactionConfirmation, m as TransactionStatus } from './shared/core.BhF1J_tt.js';
 import '@solana/kit-plugin-rpc';