@vue-solana/core 1.1.0 → 2.0.0

package/dist/token-accounts.d.ts

@@ -1,17 +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.DMgTrB_2.js';
 
+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;
 }
-declare function getTokenAccountsByOwner(connection: Connection, owner: PublicKey, options?: TokenAccountsByOwnerOptions): Promise<Account[]>;
-declare function getTokenAccount(connection: Connection, address: PublicKey): Promise<Account | null>;
+/**
+ * Get all SPL token accounts for an owner using parsed kit RPC reads.
+ */
+declare function getTokenAccountsByOwner(client: SolanaClient, owner: Address, options?: TokenAccountsByOwnerOptions): Promise<TokenAccountInfo[]>;
+/**
+ * Get a single parsed token account at the given address.
+ */
+declare function getTokenAccount(client: SolanaClient, address: Address, commitment?: Commitment): Promise<TokenAccountInfo | null>;
 interface TokenBalanceResult {
     amount: bigint;
     decimals: number;
 }
-declare function getTokenBalance(connection: Connection, mint: PublicKey, owner: PublicKey): Promise<TokenBalanceResult | null>;
+/**
+ * Read the token balance of the accounts an owner holds for a given mint.
+ */
+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.mjs

@@ -1,52 +1,68 @@
-import { unpackAccount, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, getAssociatedTokenAddressSync, unpackMint } from '@solana/spl-token';
+import { address } from '@solana/kit';
 import { normalizeSolanaError } from './errors.mjs';
 
-async function getTokenAccountsByOwner(connection, owner, options) {
-  const commitment = options?.commitment ?? "confirmed";
-  const programId = options?.programId;
-  const programIds = programId ? [programId] : [TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID];
+const TOKEN_PROGRAM_ADDRESS = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_2022_PROGRAM_ADDRESS = 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) => 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 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 unpackAccount(address, accountInfo);
+    return tokenAccountInfoFromParsed(address2, accountInfo.data);
   } catch (cause) {
     throw normalizeSolanaError(cause, "RPC_FAILURE");
   }
 }
-async function getTokenBalance(connection, mint, owner) {
+async function getTokenBalance(client, mint, owner, commitment) {
   try {
-    const ata = 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 = unpackAccount(ata, accountInfo);
-    const mintAccountInfo = await connection.getAccountInfo(mint);
-    if (!mintAccountInfo) {
-      return null;
-    }
-    const mintAccount = unpackMint(mint, mintAccountInfo);
-    return { amount: tokenAccount.amount, decimals: mintAccount.decimals };
+    return { amount: account.amount, decimals: account.decimals };
   } catch (cause) {
     throw 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
+  };
+}
 
 export { getTokenAccount, getTokenAccountsByOwner, getTokenBalance };

package/dist/transaction.cjs

@@ -1,61 +1,80 @@
 'use strict';
 
+const kit = require('@solana/kit');
 const errors = require('./errors.cjs');
-const timeout = require('./timeout.cjs');
 const wallet = require('./wallet.cjs');
 
 const DEFAULT_CONFIRMATION_COMMITMENT = "confirmed";
 const DEFAULT_CONFIRMATION_TIMEOUT_MS = 6e4;
-async function signAndSendTransaction(connection, wallet$1, transaction, options) {
+const SIGNATURE_STATUS_POLL_INTERVAL_MS = 1500;
+const COMMITMENT_RANK = { processed: 0, confirmed: 1, finalized: 2 };
+async function signAndSendTransaction(client, wallet$1, transaction, options) {
   try {
     wallet.assertWalletConnected(wallet$1);
-    if (isMobileWalletAdapterWallet(wallet$1) && wallet$1.signTransaction) {
-      wallet.assertWalletCanSign(wallet$1);
-      return await signAndSendRawTransaction(connection, wallet$1, transaction, options);
-    }
     if (wallet$1.signAndSendTransaction) {
       const result = await wallet$1.signAndSendTransaction(transaction, options);
       return result.signature;
     }
     wallet.assertWalletCanSign(wallet$1);
-    return await signAndSendRawTransaction(connection, wallet$1, transaction, options);
+    const signedTransaction = await wallet$1.signTransaction(transaction);
+    const base64Transaction = toBase64WireTransaction(signedTransaction);
+    const { maxRetries, minContextSlot, preflightCommitment, skipPreflight } = options ?? {};
+    return await client.rpc.sendTransaction(base64Transaction, {
+      encoding: "base64",
+      maxRetries,
+      minContextSlot,
+      preflightCommitment,
+      skipPreflight
+    }).send();
   } catch (cause) {
     throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
   }
 }
-async function confirmTransactionSignature(connection, signature, options = {}) {
+async function confirmTransactionSignature(client, signature, options = {}) {
   const commitment = options.commitment ?? DEFAULT_CONFIRMATION_COMMITMENT;
-  const confirmation = connection.confirmTransaction(signature, commitment);
-  let result;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_CONFIRMATION_TIMEOUT_MS;
+  let elapsedMs = 0;
   try {
-    result = await timeout.withSolanaTimeout(
-      confirmation,
-      options.timeoutMs ?? DEFAULT_CONFIRMATION_TIMEOUT_MS,
+    while (elapsedMs < timeoutMs) {
+      const response = await client.rpc.getSignatureStatuses([signature]).send();
+      const [status] = response.value;
+      if (!status) {
+        throw new Error(`Transaction ${signature} was not found.`);
+      }
+      if (status.err) {
+        throw errors.createSolanaError(
+          "RPC_FAILURE",
+          `Transaction ${signature} failed to reach ${commitment} commitment.`,
+          { cause: status.err }
+        );
+      }
+      if (hasReachedCommitment(status.confirmationStatus, commitment)) {
+        return { signature, commitment, status };
+      }
+      await wait(SIGNATURE_STATUS_POLL_INTERVAL_MS);
+      elapsedMs += SIGNATURE_STATUS_POLL_INTERVAL_MS;
+    }
+    throw errors.createSolanaError(
+      "TRANSACTION_TIMEOUT",
       `Timed out waiting for transaction ${signature} to reach ${commitment} commitment.`
     );
   } catch (cause) {
     throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
   }
-  if (result.value.err) {
-    throw errors.createSolanaError(
-      "RPC_FAILURE",
-      `Transaction ${signature} failed to reach ${commitment} commitment.`,
-      { cause: result.value.err }
-    );
-  }
-  return {
-    signature,
-    commitment,
-    result
-  };
 }
-async function signAndSendRawTransaction(connection, wallet, transaction, options) {
-  const signedTransaction = await wallet.signTransaction(transaction);
-  const rawTransaction = signedTransaction.serialize();
-  return connection.sendRawTransaction(rawTransaction, options);
+function toBase64WireTransaction(transaction) {
+  return kit.getBase64EncodedWireTransaction(kit.getTransactionDecoder().decode(transaction));
+}
+function hasReachedCommitment(actualStatus, targetCommitment) {
+  if (!actualStatus) {
+    return false;
+  }
+  return (COMMITMENT_RANK[actualStatus] ?? 0) >= (COMMITMENT_RANK[targetCommitment] ?? 0);
 }
-function isMobileWalletAdapterWallet(wallet) {
-  return wallet.source === "mobile-wallet-adapter";
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
 }
 
 exports.confirmTransactionSignature = confirmTransactionSignature;

package/dist/transaction.d.cts

@@ -1,9 +1,17 @@
-/// <reference path="../types/web3-compat.d.ts" />
-/// <reference path="../types/buffer.d.ts" />
-import { Connection, TransactionSignature } from '@solana/web3-compat';
-import { ConfirmTransactionOptions, TransactionConfirmation, SolanaWallet, SolanaTransaction, SendTransactionOptions } from './types.cjs';
+import { Signature } from '@solana/kit';
+import { b as SolanaClient, C as ConfirmTransactionOptions, T as TransactionConfirmation, h as SolanaWallet, g as SolanaTransaction, S as SendTransactionOptions } from './shared/core.DMgTrB_2.cjs';
 
-declare function signAndSendTransaction(connection: Connection, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<TransactionSignature>;
-declare function confirmTransactionSignature(connection: Connection, signature: TransactionSignature, options?: ConfirmTransactionOptions): Promise<TransactionConfirmation>;
+/**
+ * Sign and send a transaction through a connected wallet.
+ *
+ * Walks through the supported kit RPC path: the wallet signs the raw wire
+ * transaction, and the client sends it via `client.rpc.sendTransaction`.
+ */
+declare function signAndSendTransaction(client: SolanaClient, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<Signature>;
+/**
+ * Confirm a transaction signature against the kit RPC until it reaches the
+ * requested commitment.
+ */
+declare function confirmTransactionSignature(client: SolanaClient, signature: Signature, options?: ConfirmTransactionOptions): Promise<TransactionConfirmation>;
 
 export { confirmTransactionSignature, signAndSendTransaction };

package/dist/transaction.d.mts

@@ -1,9 +1,17 @@
-/// <reference path="../types/web3-compat.d.ts" />
-/// <reference path="../types/buffer.d.ts" />
-import { Connection, TransactionSignature } from '@solana/web3-compat';
-import { ConfirmTransactionOptions, TransactionConfirmation, SolanaWallet, SolanaTransaction, SendTransactionOptions } from './types.mjs';
+import { Signature } from '@solana/kit';
+import { b as SolanaClient, C as ConfirmTransactionOptions, T as TransactionConfirmation, h as SolanaWallet, g as SolanaTransaction, S as SendTransactionOptions } from './shared/core.DMgTrB_2.mjs';
 
-declare function signAndSendTransaction(connection: Connection, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<TransactionSignature>;
-declare function confirmTransactionSignature(connection: Connection, signature: TransactionSignature, options?: ConfirmTransactionOptions): Promise<TransactionConfirmation>;
+/**
+ * Sign and send a transaction through a connected wallet.
+ *
+ * Walks through the supported kit RPC path: the wallet signs the raw wire
+ * transaction, and the client sends it via `client.rpc.sendTransaction`.
+ */
+declare function signAndSendTransaction(client: SolanaClient, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<Signature>;
+/**
+ * Confirm a transaction signature against the kit RPC until it reaches the
+ * requested commitment.
+ */
+declare function confirmTransactionSignature(client: SolanaClient, signature: Signature, options?: ConfirmTransactionOptions): Promise<TransactionConfirmation>;
 
 export { confirmTransactionSignature, signAndSendTransaction };

package/dist/transaction.d.ts

@@ -1,9 +1,17 @@
-/// <reference path="../types/web3-compat.d.ts" />
-/// <reference path="../types/buffer.d.ts" />
-import { Connection, TransactionSignature } from '@solana/web3-compat';
-import { ConfirmTransactionOptions, TransactionConfirmation, SolanaWallet, SolanaTransaction, SendTransactionOptions } from './types.js';
+import { Signature } from '@solana/kit';
+import { b as SolanaClient, C as ConfirmTransactionOptions, T as TransactionConfirmation, h as SolanaWallet, g as SolanaTransaction, S as SendTransactionOptions } from './shared/core.DMgTrB_2.js';
 
-declare function signAndSendTransaction(connection: Connection, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<TransactionSignature>;
-declare function confirmTransactionSignature(connection: Connection, signature: TransactionSignature, options?: ConfirmTransactionOptions): Promise<TransactionConfirmation>;
+/**
+ * Sign and send a transaction through a connected wallet.
+ *
+ * Walks through the supported kit RPC path: the wallet signs the raw wire
+ * transaction, and the client sends it via `client.rpc.sendTransaction`.
+ */
+declare function signAndSendTransaction(client: SolanaClient, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<Signature>;
+/**
+ * Confirm a transaction signature against the kit RPC until it reaches the
+ * requested commitment.
+ */
+declare function confirmTransactionSignature(client: SolanaClient, signature: Signature, options?: ConfirmTransactionOptions): Promise<TransactionConfirmation>;
 
 export { confirmTransactionSignature, signAndSendTransaction };

package/dist/transaction.mjs

@@ -1,59 +1,78 @@
-import { normalizeSolanaError, createSolanaError } from './errors.mjs';
-import { withSolanaTimeout } from './timeout.mjs';
+import { getBase64EncodedWireTransaction, getTransactionDecoder } from '@solana/kit';
+import { createSolanaError, normalizeSolanaError } from './errors.mjs';
 import { assertWalletConnected, assertWalletCanSign } from './wallet.mjs';
 
 const DEFAULT_CONFIRMATION_COMMITMENT = "confirmed";
 const DEFAULT_CONFIRMATION_TIMEOUT_MS = 6e4;
-async function signAndSendTransaction(connection, wallet, transaction, options) {
+const SIGNATURE_STATUS_POLL_INTERVAL_MS = 1500;
+const COMMITMENT_RANK = { processed: 0, confirmed: 1, finalized: 2 };
+async function signAndSendTransaction(client, wallet, transaction, options) {
   try {
     assertWalletConnected(wallet);
-    if (isMobileWalletAdapterWallet(wallet) && wallet.signTransaction) {
-      assertWalletCanSign(wallet);
-      return await signAndSendRawTransaction(connection, wallet, transaction, options);
-    }
     if (wallet.signAndSendTransaction) {
       const result = await wallet.signAndSendTransaction(transaction, options);
       return result.signature;
     }
     assertWalletCanSign(wallet);
-    return await signAndSendRawTransaction(connection, wallet, transaction, options);
+    const signedTransaction = await wallet.signTransaction(transaction);
+    const base64Transaction = toBase64WireTransaction(signedTransaction);
+    const { maxRetries, minContextSlot, preflightCommitment, skipPreflight } = options ?? {};
+    return await client.rpc.sendTransaction(base64Transaction, {
+      encoding: "base64",
+      maxRetries,
+      minContextSlot,
+      preflightCommitment,
+      skipPreflight
+    }).send();
   } catch (cause) {
     throw normalizeSolanaError(cause, "RPC_FAILURE");
   }
 }
-async function confirmTransactionSignature(connection, signature, options = {}) {
+async function confirmTransactionSignature(client, signature, options = {}) {
   const commitment = options.commitment ?? DEFAULT_CONFIRMATION_COMMITMENT;
-  const confirmation = connection.confirmTransaction(signature, commitment);
-  let result;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_CONFIRMATION_TIMEOUT_MS;
+  let elapsedMs = 0;
   try {
-    result = await withSolanaTimeout(
-      confirmation,
-      options.timeoutMs ?? DEFAULT_CONFIRMATION_TIMEOUT_MS,
+    while (elapsedMs < timeoutMs) {
+      const response = await client.rpc.getSignatureStatuses([signature]).send();
+      const [status] = response.value;
+      if (!status) {
+        throw new Error(`Transaction ${signature} was not found.`);
+      }
+      if (status.err) {
+        throw createSolanaError(
+          "RPC_FAILURE",
+          `Transaction ${signature} failed to reach ${commitment} commitment.`,
+          { cause: status.err }
+        );
+      }
+      if (hasReachedCommitment(status.confirmationStatus, commitment)) {
+        return { signature, commitment, status };
+      }
+      await wait(SIGNATURE_STATUS_POLL_INTERVAL_MS);
+      elapsedMs += SIGNATURE_STATUS_POLL_INTERVAL_MS;
+    }
+    throw createSolanaError(
+      "TRANSACTION_TIMEOUT",
       `Timed out waiting for transaction ${signature} to reach ${commitment} commitment.`
     );
   } catch (cause) {
     throw normalizeSolanaError(cause, "RPC_FAILURE");
   }
-  if (result.value.err) {
-    throw createSolanaError(
-      "RPC_FAILURE",
-      `Transaction ${signature} failed to reach ${commitment} commitment.`,
-      { cause: result.value.err }
-    );
-  }
-  return {
-    signature,
-    commitment,
-    result
-  };
 }
-async function signAndSendRawTransaction(connection, wallet, transaction, options) {
-  const signedTransaction = await wallet.signTransaction(transaction);
-  const rawTransaction = signedTransaction.serialize();
-  return connection.sendRawTransaction(rawTransaction, options);
+function toBase64WireTransaction(transaction) {
+  return getBase64EncodedWireTransaction(getTransactionDecoder().decode(transaction));
+}
+function hasReachedCommitment(actualStatus, targetCommitment) {
+  if (!actualStatus) {
+    return false;
+  }
+  return (COMMITMENT_RANK[actualStatus] ?? 0) >= (COMMITMENT_RANK[targetCommitment] ?? 0);
 }
-function isMobileWalletAdapterWallet(wallet) {
-  return wallet.source === "mobile-wallet-adapter";
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
 }
 
 export { confirmTransactionSignature, signAndSendTransaction };

package/dist/types.d.cts

@@ -1,80 +1,2 @@
-/// <reference path="../types/web3-compat.d.ts" />
-/// <reference path="../types/buffer.d.ts" />
-import { Commitment, SendOptions, Connection, Transaction, VersionedTransaction, PublicKey, TransactionSignature, RpcResponseAndContext, SignatureResult } from '@solana/web3-compat';
-
-type SolanaCluster = "mainnet-beta" | "testnet" | "devnet" | "localnet";
-type SolanaChain = "solana:mainnet" | "solana:testnet" | "solana:devnet" | "solana:localnet";
-interface SolanaConfig {
-    cluster?: SolanaCluster;
-    endpoint?: string;
-    wsEndpoint?: string;
-    commitment?: Commitment;
-    autoConnect?: boolean;
-}
-interface SolanaContext {
-    cluster: SolanaCluster;
-    endpoint: string;
-    wsEndpoint: string;
-    connection: Connection;
-}
-type SolanaTransaction = Transaction | VersionedTransaction;
-interface SolanaSignMessageResult {
-    signedMessage: Uint8Array;
-    signature: Uint8Array;
-}
-interface SolanaWallet {
-    publicKey: PublicKey | null;
-    connected: boolean;
-    connecting?: boolean;
-    disconnecting?: boolean;
-    platform?: SolanaWalletInfo["platform"];
-    source?: SolanaWalletInfo["source"];
-    connect: () => Promise<void>;
-    disconnect: () => Promise<void>;
-    signMessage?: (message: Uint8Array) => Promise<SolanaSignMessageResult>;
-    signTransaction?: <T extends SolanaTransaction>(transaction: T) => Promise<T>;
-    signAllTransactions?: <T extends SolanaTransaction>(transactions: T[]) => Promise<T[]>;
-    signAndSendTransaction?: (transaction: SolanaTransaction, options?: SendOptions) => Promise<{
-        signature: TransactionSignature;
-    }>;
-}
-interface SolanaWalletInfo {
-    name: string;
-    icon: string;
-    chains: readonly string[];
-    platform?: "browser" | "mobile" | "desktop";
-    source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
-    appUrl?: string;
-    installUrl?: string;
-    callbackUrl?: string;
-    capabilities?: {
-        connect?: boolean;
-        disconnect?: boolean;
-        signMessage?: boolean;
-        signTransaction?: boolean;
-        signAllTransactions?: boolean;
-        signAndSendTransaction?: boolean;
-    };
-    accounts: readonly {
-        address: string;
-        publicKey: Uint8Array;
-        chains: readonly string[];
-        label?: string;
-        icon?: string;
-    }[];
-    wallet: unknown;
-}
-interface SendTransactionOptions extends SendOptions {
-    skipPreflight?: boolean;
-}
-interface ConfirmTransactionOptions {
-    commitment?: Commitment;
-    timeoutMs?: number;
-}
-interface TransactionConfirmation {
-    signature: TransactionSignature;
-    commitment: Commitment;
-    result: RpcResponseAndContext<SignatureResult>;
-}
-
-export type { ConfirmTransactionOptions, SendTransactionOptions, SolanaChain, SolanaCluster, SolanaConfig, SolanaContext, SolanaSignMessageResult, SolanaTransaction, SolanaWallet, SolanaWalletInfo, TransactionConfirmation };
+import '@solana/kit';
+export { C as ConfirmTransactionOptions, S as SendTransactionOptions, a as SolanaChain, c as SolanaCluster, d as SolanaConfig, e as SolanaContext, f as SolanaSignMessageResult, g as SolanaTransaction, h as SolanaWallet, i as SolanaWalletInfo, T as TransactionConfirmation, j as TransactionStatus } from './shared/core.DMgTrB_2.cjs';

package/dist/types.d.mts

@@ -1,80 +1,2 @@
-/// <reference path="../types/web3-compat.d.ts" />
-/// <reference path="../types/buffer.d.ts" />
-import { Commitment, SendOptions, Connection, Transaction, VersionedTransaction, PublicKey, TransactionSignature, RpcResponseAndContext, SignatureResult } from '@solana/web3-compat';
-
-type SolanaCluster = "mainnet-beta" | "testnet" | "devnet" | "localnet";
-type SolanaChain = "solana:mainnet" | "solana:testnet" | "solana:devnet" | "solana:localnet";
-interface SolanaConfig {
-    cluster?: SolanaCluster;
-    endpoint?: string;
-    wsEndpoint?: string;
-    commitment?: Commitment;
-    autoConnect?: boolean;
-}
-interface SolanaContext {
-    cluster: SolanaCluster;
-    endpoint: string;
-    wsEndpoint: string;
-    connection: Connection;
-}
-type SolanaTransaction = Transaction | VersionedTransaction;
-interface SolanaSignMessageResult {
-    signedMessage: Uint8Array;
-    signature: Uint8Array;
-}
-interface SolanaWallet {
-    publicKey: PublicKey | null;
-    connected: boolean;
-    connecting?: boolean;
-    disconnecting?: boolean;
-    platform?: SolanaWalletInfo["platform"];
-    source?: SolanaWalletInfo["source"];
-    connect: () => Promise<void>;
-    disconnect: () => Promise<void>;
-    signMessage?: (message: Uint8Array) => Promise<SolanaSignMessageResult>;
-    signTransaction?: <T extends SolanaTransaction>(transaction: T) => Promise<T>;
-    signAllTransactions?: <T extends SolanaTransaction>(transactions: T[]) => Promise<T[]>;
-    signAndSendTransaction?: (transaction: SolanaTransaction, options?: SendOptions) => Promise<{
-        signature: TransactionSignature;
-    }>;
-}
-interface SolanaWalletInfo {
-    name: string;
-    icon: string;
-    chains: readonly string[];
-    platform?: "browser" | "mobile" | "desktop";
-    source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
-    appUrl?: string;
-    installUrl?: string;
-    callbackUrl?: string;
-    capabilities?: {
-        connect?: boolean;
-        disconnect?: boolean;
-        signMessage?: boolean;
-        signTransaction?: boolean;
-        signAllTransactions?: boolean;
-        signAndSendTransaction?: boolean;
-    };
-    accounts: readonly {
-        address: string;
-        publicKey: Uint8Array;
-        chains: readonly string[];
-        label?: string;
-        icon?: string;
-    }[];
-    wallet: unknown;
-}
-interface SendTransactionOptions extends SendOptions {
-    skipPreflight?: boolean;
-}
-interface ConfirmTransactionOptions {
-    commitment?: Commitment;
-    timeoutMs?: number;
-}
-interface TransactionConfirmation {
-    signature: TransactionSignature;
-    commitment: Commitment;
-    result: RpcResponseAndContext<SignatureResult>;
-}
-
-export type { ConfirmTransactionOptions, SendTransactionOptions, SolanaChain, SolanaCluster, SolanaConfig, SolanaContext, SolanaSignMessageResult, SolanaTransaction, SolanaWallet, SolanaWalletInfo, TransactionConfirmation };
+import '@solana/kit';
+export { C as ConfirmTransactionOptions, S as SendTransactionOptions, a as SolanaChain, c as SolanaCluster, d as SolanaConfig, e as SolanaContext, f as SolanaSignMessageResult, g as SolanaTransaction, h as SolanaWallet, i as SolanaWalletInfo, T as TransactionConfirmation, j as TransactionStatus } from './shared/core.DMgTrB_2.mjs';