@vue-solana/core 1.2.0 → 2.1.0

package/dist/shared/{core.DjbtrJWl.mjs → core.DEcQDbtz.mjs}

@@ -1,8 +1,6 @@
 import { StandardEvents, StandardDisconnect, StandardConnect } from '@wallet-standard/features';
-import { SolanaSignAndSendTransaction, SolanaSignTransaction, SolanaSignMessage } from '@solana/wallet-standard-features';
-import { Transaction, VersionedTransaction, PublicKey } from '@solana/web3-compat';
+import { SolanaSignTransaction, SolanaSignIn, SolanaSignAndSendTransaction, SolanaSignMessage } from '@solana/wallet-standard-features';
 import bs58 from 'bs58';
-import { SolanaWalletError } from '../wallet.mjs';
 import { getWallets } from '@wallet-standard/app';
 
 const SOLANA_CHAINS = [
@@ -18,27 +16,21 @@ function getSolanaChain(cluster) {
   return `solana:${cluster}`;
 }
 
+function hasVersionedFeature(wallet, feature) {
+  const value = wallet.features[feature];
+  return typeof value === "object" && value !== null && typeof value.version === "string";
+}
 function hasSignTransaction(wallet) {
-  return SolanaSignTransaction in wallet.features;
+  return hasVersionedFeature(wallet, SolanaSignTransaction);
+}
+function hasSignIn(wallet) {
+  return hasVersionedFeature(wallet, SolanaSignIn);
 }
 function hasSignAndSendTransaction(wallet) {
-  return SolanaSignAndSendTransaction in wallet.features;
+  return hasVersionedFeature(wallet, SolanaSignAndSendTransaction);
 }
 function hasSignMessage(wallet) {
-  return SolanaSignMessage in wallet.features;
-}
-
-function serializeTransaction(transaction) {
-  if (transaction instanceof Transaction) {
-    return transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
-  }
-  return transaction.serialize();
-}
-function deserializeTransaction(source, bytes) {
-  if (source instanceof Transaction) {
-    return Transaction.from(bytes);
-  }
-  return VersionedTransaction.deserialize(bytes);
+  return hasVersionedFeature(wallet, SolanaSignMessage);
 }
 
 function adaptSolanaStandardWallet(walletInfo, options = {}) {
@@ -61,10 +53,7 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
     platform: walletInfo.platform,
     source: walletInfo.source,
     get publicKey() {
-      return account ? new PublicKey(account.publicKey) : null;
-    },
-    get address() {
-      return account ? account.address : void 0;
+      return account ? account.address : null;
     },
     get connected() {
       return Boolean(account);
@@ -114,6 +103,13 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
         options.onChange?.();
       }
     },
+    signIn: hasSignIn(wallet) ? async (input) => {
+      const [result] = await wallet.features[SolanaSignIn].signIn(...input ? [input] : []);
+      if (!result) {
+        throw new Error("Solana wallet did not return a sign-in result");
+      }
+      return toSolanaSignInResult(result);
+    } : void 0,
     signMessage: hasSignMessage(wallet) ? async (message) => {
       const activeAccount = getActiveAccount(account);
       const [result] = await wallet.features[SolanaSignMessage].signMessage({
@@ -129,20 +125,20 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       const activeAccount = getActiveAccount(account);
       const [result] = await wallet.features[SolanaSignTransaction].signTransaction({
         account: activeAccount,
-        transaction: serializeTransaction(transaction),
+        transaction,
         chain: options.chain
       });
       if (!result) {
         throw new Error("Solana wallet did not return a signed transaction");
       }
-      return deserializeTransaction(transaction, result.signedTransaction);
+      return result.signedTransaction;
     } : void 0,
     signAllTransactions: hasSignTransaction(wallet) ? async (transactions) => {
       const activeAccount = getActiveAccount(account);
       const results = await wallet.features[SolanaSignTransaction].signTransaction(
         ...transactions.map((transaction) => ({
           account: activeAccount,
-          transaction: serializeTransaction(transaction),
+          transaction,
           chain: options.chain
         }))
       );
@@ -151,26 +147,24 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
           `Solana wallet returned ${results.length} signed transactions for ${transactions.length} requested transactions`
         );
       }
-      return results.map((result, index) => {
+      return results.map((result) => {
         if (!result) {
           throw new Error("Solana wallet did not return a signed transaction");
         }
-        const transaction = transactions[index];
-        if (!transaction) {
-          throw new SolanaWalletError(
-            "WALLET_FEATURE_UNSUPPORTED",
-            "Solana wallet returned a signed transaction without a matching request",
-            { feature: "signTransaction" }
-          );
-        }
-        return deserializeTransaction(transaction, result.signedTransaction);
+        return result.signedTransaction;
       });
     } : void 0,
+    signTransactions: hasSignTransaction(wallet) ? async (transactions) => signAllThroughFeature(
+      wallet,
+      () => getActiveAccount(account),
+      transactions,
+      options.chain
+    ) : void 0,
     signAndSendTransaction: hasSignAndSendTransaction(wallet) ? async (transaction, sendOptions) => {
       const activeAccount = getActiveAccount(account);
       const [result] = await wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
         account: activeAccount,
-        transaction: serializeTransaction(transaction),
+        transaction,
         chain: options.chain ?? getSolanaAccountChain(activeAccount),
         options: sendOptions
       });
@@ -178,9 +172,66 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
         throw new Error("Solana wallet did not return a transaction signature");
       }
       return { signature: bs58.encode(result.signature) };
+    } : void 0,
+    signAndSendTransactions: hasSignAndSendTransaction(wallet) ? async (transactions, sendOptions) => {
+      const activeAccount = getActiveAccount(account);
+      const results = await wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction(
+        ...transactions.map((transaction) => ({
+          account: activeAccount,
+          transaction,
+          chain: options.chain ?? getSolanaAccountChain(activeAccount),
+          options: sendOptions
+        }))
+      );
+      if (results.length !== transactions.length) {
+        throw new Error(
+          `Solana wallet returned ${results.length} signatures for ${transactions.length} requested transactions`
+        );
+      }
+      return results.map((result) => {
+        if (!result) {
+          throw new Error("Solana wallet did not return a transaction signature");
+        }
+        return bs58.encode(result.signature);
+      });
     } : void 0
   };
 }
+async function signAllThroughFeature(wallet, getAccount, transactions, chain) {
+  const activeAccount = getAccount();
+  const results = await wallet.features[SolanaSignTransaction].signTransaction(
+    ...transactions.map((transaction) => ({
+      account: activeAccount,
+      transaction,
+      chain
+    }))
+  );
+  if (results.length !== transactions.length) {
+    throw new Error(
+      `Solana wallet returned ${results.length} signed transactions for ${transactions.length} requested transactions`
+    );
+  }
+  return results.map((result) => {
+    if (!result) {
+      throw new Error("Solana wallet did not return a signed transaction");
+    }
+    return result.signedTransaction;
+  });
+}
+function toSolanaSignInResult(result) {
+  return {
+    account: {
+      address: result.account.address,
+      publicKey: Uint8Array.from(result.account.publicKey),
+      chains: [...result.account.chains],
+      label: result.account.label,
+      icon: result.account.icon
+    },
+    signedMessage: result.signedMessage,
+    signature: result.signature,
+    signatureType: result.signatureType
+  };
+}
 function getSolanaAccount(accounts, chain) {
   return accounts.find((account) => account.chains.some((accountChain) => accountChain === chain)) ?? accounts.find(
     (account) => account.chains.some((accountChain) => SOLANA_CHAINS.includes(accountChain))
@@ -237,6 +288,7 @@ function createSolanaWalletInfo(wallet) {
     capabilities: {
       connect: true,
       disconnect: true,
+      signIn: hasSignIn(wallet),
       signMessage: hasSignMessage(wallet),
       signTransaction: hasSignTransaction(wallet),
       signAllTransactions: hasSignTransaction(wallet),

package/dist/shared/{core.BQoh-5Wu.cjs → core.DjxUirkw.cjs}

@@ -2,9 +2,7 @@
 
 const features = require('@wallet-standard/features');
 const walletStandardFeatures = require('@solana/wallet-standard-features');
-const web3Compat = require('@solana/web3-compat');
 const bs58 = require('bs58');
-const wallet = require('../wallet.cjs');
 const app = require('@wallet-standard/app');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -24,38 +22,32 @@ function getSolanaChain(cluster) {
   return `solana:${cluster}`;
 }
 
+function hasVersionedFeature(wallet, feature) {
+  const value = wallet.features[feature];
+  return typeof value === "object" && value !== null && typeof value.version === "string";
+}
 function hasSignTransaction(wallet) {
-  return walletStandardFeatures.SolanaSignTransaction in wallet.features;
+  return hasVersionedFeature(wallet, walletStandardFeatures.SolanaSignTransaction);
+}
+function hasSignIn(wallet) {
+  return hasVersionedFeature(wallet, walletStandardFeatures.SolanaSignIn);
 }
 function hasSignAndSendTransaction(wallet) {
-  return walletStandardFeatures.SolanaSignAndSendTransaction in wallet.features;
+  return hasVersionedFeature(wallet, walletStandardFeatures.SolanaSignAndSendTransaction);
 }
 function hasSignMessage(wallet) {
-  return walletStandardFeatures.SolanaSignMessage in wallet.features;
-}
-
-function serializeTransaction(transaction) {
-  if (transaction instanceof web3Compat.Transaction) {
-    return transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
-  }
-  return transaction.serialize();
-}
-function deserializeTransaction(source, bytes) {
-  if (source instanceof web3Compat.Transaction) {
-    return web3Compat.Transaction.from(bytes);
-  }
-  return web3Compat.VersionedTransaction.deserialize(bytes);
+  return hasVersionedFeature(wallet, walletStandardFeatures.SolanaSignMessage);
 }
 
 function adaptSolanaStandardWallet(walletInfo, options = {}) {
-  const wallet$1 = walletInfo.wallet;
-  let accounts = wallet$1.accounts;
+  const wallet = walletInfo.wallet;
+  let accounts = wallet.accounts;
   let account = options.account;
   let allowAccountUpdates = Boolean(options.account);
   let connecting = false;
   let disconnecting = false;
   let manuallyDisconnected = false;
-  const eventsFeature = wallet$1.features[features.StandardEvents];
+  const eventsFeature = wallet.features[features.StandardEvents];
   eventsFeature?.on("change", (properties) => {
     if (properties.accounts) {
       accounts = properties.accounts;
@@ -67,10 +59,7 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
     platform: walletInfo.platform,
     source: walletInfo.source,
     get publicKey() {
-      return account ? new web3Compat.PublicKey(account.publicKey) : null;
-    },
-    get address() {
-      return account ? account.address : void 0;
+      return account ? account.address : null;
     },
     get connected() {
       return Boolean(account);
@@ -86,7 +75,7 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       manuallyDisconnected = false;
       options.onChange?.();
       try {
-        const feature = wallet$1.features[features.StandardConnect];
+        const feature = wallet.features[features.StandardConnect];
         const result = await feature.connect();
         accounts = result.accounts;
         allowAccountUpdates = true;
@@ -100,7 +89,7 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       }
     },
     async disconnect() {
-      const feature = wallet$1.features[features.StandardDisconnect];
+      const feature = wallet.features[features.StandardDisconnect];
       disconnecting = true;
       manuallyDisconnected = true;
       allowAccountUpdates = false;
@@ -120,9 +109,16 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
         options.onChange?.();
       }
     },
-    signMessage: hasSignMessage(wallet$1) ? async (message) => {
+    signIn: hasSignIn(wallet) ? async (input) => {
+      const [result] = await wallet.features[walletStandardFeatures.SolanaSignIn].signIn(...input ? [input] : []);
+      if (!result) {
+        throw new Error("Solana wallet did not return a sign-in result");
+      }
+      return toSolanaSignInResult(result);
+    } : void 0,
+    signMessage: hasSignMessage(wallet) ? async (message) => {
       const activeAccount = getActiveAccount(account);
-      const [result] = await wallet$1.features[walletStandardFeatures.SolanaSignMessage].signMessage({
+      const [result] = await wallet.features[walletStandardFeatures.SolanaSignMessage].signMessage({
         account: activeAccount,
         message
       });
@@ -131,24 +127,24 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       }
       return result;
     } : void 0,
-    signTransaction: hasSignTransaction(wallet$1) ? async (transaction) => {
+    signTransaction: hasSignTransaction(wallet) ? async (transaction) => {
       const activeAccount = getActiveAccount(account);
-      const [result] = await wallet$1.features[walletStandardFeatures.SolanaSignTransaction].signTransaction({
+      const [result] = await wallet.features[walletStandardFeatures.SolanaSignTransaction].signTransaction({
         account: activeAccount,
-        transaction: serializeTransaction(transaction),
+        transaction,
         chain: options.chain
       });
       if (!result) {
         throw new Error("Solana wallet did not return a signed transaction");
       }
-      return deserializeTransaction(transaction, result.signedTransaction);
+      return result.signedTransaction;
     } : void 0,
-    signAllTransactions: hasSignTransaction(wallet$1) ? async (transactions) => {
+    signAllTransactions: hasSignTransaction(wallet) ? async (transactions) => {
       const activeAccount = getActiveAccount(account);
-      const results = await wallet$1.features[walletStandardFeatures.SolanaSignTransaction].signTransaction(
+      const results = await wallet.features[walletStandardFeatures.SolanaSignTransaction].signTransaction(
         ...transactions.map((transaction) => ({
           account: activeAccount,
-          transaction: serializeTransaction(transaction),
+          transaction,
           chain: options.chain
         }))
       );
@@ -157,26 +153,24 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
           `Solana wallet returned ${results.length} signed transactions for ${transactions.length} requested transactions`
         );
       }
-      return results.map((result, index) => {
+      return results.map((result) => {
         if (!result) {
           throw new Error("Solana wallet did not return a signed transaction");
         }
-        const transaction = transactions[index];
-        if (!transaction) {
-          throw new wallet.SolanaWalletError(
-            "WALLET_FEATURE_UNSUPPORTED",
-            "Solana wallet returned a signed transaction without a matching request",
-            { feature: "signTransaction" }
-          );
-        }
-        return deserializeTransaction(transaction, result.signedTransaction);
+        return result.signedTransaction;
       });
     } : void 0,
-    signAndSendTransaction: hasSignAndSendTransaction(wallet$1) ? async (transaction, sendOptions) => {
+    signTransactions: hasSignTransaction(wallet) ? async (transactions) => signAllThroughFeature(
+      wallet,
+      () => getActiveAccount(account),
+      transactions,
+      options.chain
+    ) : void 0,
+    signAndSendTransaction: hasSignAndSendTransaction(wallet) ? async (transaction, sendOptions) => {
       const activeAccount = getActiveAccount(account);
-      const [result] = await wallet$1.features[walletStandardFeatures.SolanaSignAndSendTransaction].signAndSendTransaction({
+      const [result] = await wallet.features[walletStandardFeatures.SolanaSignAndSendTransaction].signAndSendTransaction({
         account: activeAccount,
-        transaction: serializeTransaction(transaction),
+        transaction,
         chain: options.chain ?? getSolanaAccountChain(activeAccount),
         options: sendOptions
       });
@@ -184,9 +178,66 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
         throw new Error("Solana wallet did not return a transaction signature");
       }
       return { signature: bs58__default.encode(result.signature) };
+    } : void 0,
+    signAndSendTransactions: hasSignAndSendTransaction(wallet) ? async (transactions, sendOptions) => {
+      const activeAccount = getActiveAccount(account);
+      const results = await wallet.features[walletStandardFeatures.SolanaSignAndSendTransaction].signAndSendTransaction(
+        ...transactions.map((transaction) => ({
+          account: activeAccount,
+          transaction,
+          chain: options.chain ?? getSolanaAccountChain(activeAccount),
+          options: sendOptions
+        }))
+      );
+      if (results.length !== transactions.length) {
+        throw new Error(
+          `Solana wallet returned ${results.length} signatures for ${transactions.length} requested transactions`
+        );
+      }
+      return results.map((result) => {
+        if (!result) {
+          throw new Error("Solana wallet did not return a transaction signature");
+        }
+        return bs58__default.encode(result.signature);
+      });
     } : void 0
   };
 }
+async function signAllThroughFeature(wallet, getAccount, transactions, chain) {
+  const activeAccount = getAccount();
+  const results = await wallet.features[walletStandardFeatures.SolanaSignTransaction].signTransaction(
+    ...transactions.map((transaction) => ({
+      account: activeAccount,
+      transaction,
+      chain
+    }))
+  );
+  if (results.length !== transactions.length) {
+    throw new Error(
+      `Solana wallet returned ${results.length} signed transactions for ${transactions.length} requested transactions`
+    );
+  }
+  return results.map((result) => {
+    if (!result) {
+      throw new Error("Solana wallet did not return a signed transaction");
+    }
+    return result.signedTransaction;
+  });
+}
+function toSolanaSignInResult(result) {
+  return {
+    account: {
+      address: result.account.address,
+      publicKey: Uint8Array.from(result.account.publicKey),
+      chains: [...result.account.chains],
+      label: result.account.label,
+      icon: result.account.icon
+    },
+    signedMessage: result.signedMessage,
+    signature: result.signature,
+    signatureType: result.signatureType
+  };
+}
 function getSolanaAccount(accounts, chain) {
   return accounts.find((account) => account.chains.some((accountChain) => accountChain === chain)) ?? accounts.find(
     (account) => account.chains.some((accountChain) => SOLANA_CHAINS.includes(accountChain))
@@ -243,6 +294,7 @@ function createSolanaWalletInfo(wallet) {
     capabilities: {
       connect: true,
       disconnect: true,
+      signIn: hasSignIn(wallet),
       signMessage: hasSignMessage(wallet),
       signTransaction: hasSignTransaction(wallet),
       signAllTransactions: hasSignTransaction(wallet),

package/dist/token-accounts.cjs

@@ -1,55 +1,71 @@
 'use strict';
 
-const splToken = require('@solana/spl-token');
+const kit = require('@solana/kit');
 const errors = require('./errors.cjs');
 
-async function getTokenAccountsByOwner(connection, owner, options) {
-  const commitment = options?.commitment ?? "confirmed";
-  const programId = options?.programId;
-  const programIds = programId ? [programId] : [splToken.TOKEN_PROGRAM_ID, splToken.TOKEN_2022_PROGRAM_ID];
+const TOKEN_PROGRAM_ADDRESS = kit.address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_2022_PROGRAM_ADDRESS = kit.address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+async function getTokenAccountsByOwner(client, owner, options = {}) {
+  const programIds = options.programId ? [options.programId] : [TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS];
   try {
-    const responses = await Promise.all(
-      programIds.map(async (pid) => {
-        const resp = await connection.getTokenAccountsByOwner(owner, { programId: pid }, commitment);
-        return resp.value.map(
-          (info) => splToken.unpackAccount(info.pubkey, { data: info.account.data })
-        );
-      })
+    const results = await Promise.all(
+      programIds.map(
+        (programId) => fetchParsedTokenAccounts(client, owner, { programId }, options.commitment)
+      )
     );
-    return responses.flat();
+    return results.flat();
   } catch (cause) {
     throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
   }
 }
-async function getTokenAccount(connection, address) {
+async function getTokenAccount(client, address2, commitment) {
   try {
-    const accountInfo = await connection.getAccountInfo(address);
-    if (!accountInfo) {
+    const response = await client.rpc.getAccountInfo(address2, { encoding: "jsonParsed", commitment }).send();
+    const accountInfo = response.value;
+    if (!accountInfo || !isParsedTokenAccount(accountInfo.data) || accountInfo.data.parsed.type !== "account") {
       return null;
     }
-    return splToken.unpackAccount(address, accountInfo);
+    return tokenAccountInfoFromParsed(address2, accountInfo.data);
   } catch (cause) {
     throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
   }
 }
-async function getTokenBalance(connection, mint, owner) {
+async function getTokenBalance(client, mint, owner, commitment) {
   try {
-    const ata = splToken.getAssociatedTokenAddressSync(mint, owner, true);
-    const accountInfo = await connection.getAccountInfo(ata);
-    if (!accountInfo) {
+    const [account] = await fetchParsedTokenAccounts(client, owner, { mint }, commitment);
+    if (!account) {
       return null;
     }
-    const tokenAccount = splToken.unpackAccount(ata, accountInfo);
-    const mintAccountInfo = await connection.getAccountInfo(mint);
-    if (!mintAccountInfo) {
-      return null;
-    }
-    const mintAccount = splToken.unpackMint(mint, mintAccountInfo);
-    return { amount: tokenAccount.amount, decimals: mintAccount.decimals };
+    return { amount: account.amount, decimals: account.decimals };
   } catch (cause) {
     throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
   }
 }
+async function fetchParsedTokenAccounts(client, owner, filter, commitment) {
+  const response = await client.rpc.getTokenAccountsByOwner(owner, filter, { encoding: "jsonParsed", commitment }).send();
+  return response.value.filter(({ account }) => isParsedTokenAccount(account.data)).map(({ pubkey, account }) => tokenAccountInfoFromParsed(pubkey, account.data));
+}
+function isParsedTokenAccount(data) {
+  return typeof data === "object" && data !== null && "parsed" in data;
+}
+function tokenAccountInfoFromParsed(address2, data) {
+  if (data.parsed.type !== "account") {
+    throw new Error(`Token account ${address2} is not a parsed token account`);
+  }
+  const parsed = data.parsed.info;
+  if (!parsed) {
+    throw new Error(`Token account ${address2} has no parsed data`);
+  }
+  return {
+    address: address2,
+    mint: parsed.mint,
+    owner: parsed.owner,
+    amount: BigInt(parsed.tokenAmount.amount),
+    decimals: parsed.tokenAmount.decimals,
+    state: parsed.state,
+    isNative: parsed.isNative
+  };
+}
 
 exports.getTokenAccount = getTokenAccount;
 exports.getTokenAccountsByOwner = getTokenAccountsByOwner;

package/dist/token-accounts.d.cts

@@ -1,35 +1,35 @@
-import { PublicKey, Connection } from '@vue-solana/core/web3';
-import { Account } from '@solana/spl-token';
+import { Address, Commitment } from '@solana/kit';
+import { b as SolanaClient } from './shared/core.CQ_yMDAL.cjs';
 
+interface TokenAccountInfo {
+    address: Address;
+    mint: Address;
+    owner: Address;
+    amount: bigint;
+    decimals: number;
+    state: "frozen" | "initialized" | "uninitialized";
+    isNative: boolean;
+}
 interface TokenAccountsByOwnerOptions {
-    commitment?: "processed" | "confirmed" | "finalized";
-    programId?: PublicKey;
+    commitment?: Commitment;
+    programId?: Address;
 }
 /**
- * Get all SPL token accounts for an owner using the legacy `Connection` API.
- *
- * @deprecated Prefer `@solana-program/token` reads against `client.rpc` from
- * `@vue-solana/core/kit`.
+ * Get all SPL token accounts for an owner using parsed kit RPC reads.
  */
-declare function getTokenAccountsByOwner(connection: Connection, owner: PublicKey, options?: TokenAccountsByOwnerOptions): Promise<Account[]>;
+declare function getTokenAccountsByOwner(client: SolanaClient, owner: Address, options?: TokenAccountsByOwnerOptions): Promise<TokenAccountInfo[]>;
 /**
- * Get a single token account using the legacy `Connection` API.
- *
- * @deprecated Prefer `@solana-program/token` reads against `client.rpc` from
- * `@vue-solana/core/kit`.
+ * Get a single parsed token account at the given address.
  */
-declare function getTokenAccount(connection: Connection, address: PublicKey): Promise<Account | null>;
+declare function getTokenAccount(client: SolanaClient, address: Address, commitment?: Commitment): Promise<TokenAccountInfo | null>;
 interface TokenBalanceResult {
     amount: bigint;
     decimals: number;
 }
 /**
- * Read the token balance of the associated token account for an owner.
- *
- * @deprecated Prefer `@solana-program/token` reads against `client.rpc` from
- * `@vue-solana/core/kit`.
+ * Read the token balance of the accounts an owner holds for a given mint.
  */
-declare function getTokenBalance(connection: Connection, mint: PublicKey, owner: PublicKey): Promise<TokenBalanceResult | null>;
+declare function getTokenBalance(client: SolanaClient, mint: Address, owner: Address, commitment?: Commitment): Promise<TokenBalanceResult | null>;
 
 export { getTokenAccount, getTokenAccountsByOwner, getTokenBalance };
-export type { TokenAccountsByOwnerOptions, TokenBalanceResult };
+export type { TokenAccountInfo, TokenAccountsByOwnerOptions, TokenBalanceResult };

package/dist/token-accounts.d.mts

@@ -1,35 +1,35 @@
-import { PublicKey, Connection } from '@vue-solana/core/web3';
-import { Account } from '@solana/spl-token';
+import { Address, Commitment } from '@solana/kit';
+import { b as SolanaClient } from './shared/core.CQ_yMDAL.mjs';
 
+interface TokenAccountInfo {
+    address: Address;
+    mint: Address;
+    owner: Address;
+    amount: bigint;
+    decimals: number;
+    state: "frozen" | "initialized" | "uninitialized";
+    isNative: boolean;
+}
 interface TokenAccountsByOwnerOptions {
-    commitment?: "processed" | "confirmed" | "finalized";
-    programId?: PublicKey;
+    commitment?: Commitment;
+    programId?: Address;
 }
 /**
- * Get all SPL token accounts for an owner using the legacy `Connection` API.
- *
- * @deprecated Prefer `@solana-program/token` reads against `client.rpc` from
- * `@vue-solana/core/kit`.
+ * Get all SPL token accounts for an owner using parsed kit RPC reads.
  */
-declare function getTokenAccountsByOwner(connection: Connection, owner: PublicKey, options?: TokenAccountsByOwnerOptions): Promise<Account[]>;
+declare function getTokenAccountsByOwner(client: SolanaClient, owner: Address, options?: TokenAccountsByOwnerOptions): Promise<TokenAccountInfo[]>;
 /**
- * Get a single token account using the legacy `Connection` API.
- *
- * @deprecated Prefer `@solana-program/token` reads against `client.rpc` from
- * `@vue-solana/core/kit`.
+ * Get a single parsed token account at the given address.
  */
-declare function getTokenAccount(connection: Connection, address: PublicKey): Promise<Account | null>;
+declare function getTokenAccount(client: SolanaClient, address: Address, commitment?: Commitment): Promise<TokenAccountInfo | null>;
 interface TokenBalanceResult {
     amount: bigint;
     decimals: number;
 }
 /**
- * Read the token balance of the associated token account for an owner.
- *
- * @deprecated Prefer `@solana-program/token` reads against `client.rpc` from
- * `@vue-solana/core/kit`.
+ * Read the token balance of the accounts an owner holds for a given mint.
  */
-declare function getTokenBalance(connection: Connection, mint: PublicKey, owner: PublicKey): Promise<TokenBalanceResult | null>;
+declare function getTokenBalance(client: SolanaClient, mint: Address, owner: Address, commitment?: Commitment): Promise<TokenBalanceResult | null>;
 
 export { getTokenAccount, getTokenAccountsByOwner, getTokenBalance };
-export type { TokenAccountsByOwnerOptions, TokenBalanceResult };
+export type { TokenAccountInfo, TokenAccountsByOwnerOptions, TokenBalanceResult };