@qorechain/svm 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,396 @@
+import { Commitment, Connection, PublicKey, AccountInfo, GetLatestBlockhashConfig, TokenAccountsFilter, Keypair, Transaction, ConfirmOptions, RpcResponseAndContext, SimulatedTransactionResponse, TransactionInstruction, AccountMeta, VersionedTransaction, AccountChangeCallback, LogsFilter, LogsCallback, SlotChangeCallback } from '@solana/web3.js';
+export { SignatureResult } from '@solana/web3.js';
+
+/**
+ * Client factory for QoreChain's Solana-compatible JSON-RPC.
+ *
+ * This is a thin convenience layer over `@solana/web3.js`: it builds (or accepts)
+ * a `Connection` bound to the network's SVM RPC endpoint and exposes typed
+ * wrappers over the documented Solana-compatible JSON-RPC method set plus
+ * transaction build/sign/send helpers.
+ *
+ * `@solana/web3.js` is a peer dependency; nothing here reimplements it.
+ */
+
+/** Subset of a qorechain-sdk network's endpoints relevant to the SVM runtime. */
+interface SvmEndpoints {
+    /** Solana-compatible JSON-RPC HTTP endpoint. */
+    svmRpc: string;
+}
+/** Default testnet SVM RPC endpoint (Solana-compatible JSON-RPC, port 8899). */
+declare const DEFAULT_SVM_RPC_URL = "http://localhost:8899";
+/** Options for {@link createSvmClient}. */
+interface CreateSvmClientOptions {
+    /** Solana-compatible JSON-RPC HTTP URL. Mutually exclusive with `endpoints`. */
+    rpcUrl?: string;
+    /** A qorechain-sdk network endpoints object (uses `svmRpc`). */
+    endpoints?: SvmEndpoints;
+    /** Default commitment level for the connection. */
+    commitment?: Commitment;
+    /**
+     * A preconstructed `Connection`. When provided it is used as-is and `rpcUrl`/
+     * `endpoints`/`commitment` are ignored — primarily for testing.
+     */
+    connection?: Connection;
+}
+/** Arguments for building/sending a SOL transfer. */
+interface TransferSolArgs {
+    /** Funding/source keypair (signer). */
+    from: Keypair;
+    /** Destination address. */
+    to: PublicKey;
+    /** Amount in lamports. */
+    lamports: number | bigint;
+}
+/** A configured QoreChain SVM client bundle. */
+interface SvmClient {
+    /** The underlying `@solana/web3.js` `Connection`. */
+    connection: Connection;
+    /** Lamport balance for an account. */
+    getBalance(pubkey: PublicKey, commitment?: Commitment): Promise<number>;
+    /** Raw account info, or `null` if the account does not exist. */
+    getAccountInfo(pubkey: PublicKey, commitment?: Commitment): Promise<AccountInfo<Buffer> | null>;
+    /** Latest blockhash and last valid block height. */
+    getLatestBlockhash(commitmentOrConfig?: Commitment | GetLatestBlockhashConfig): Promise<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>;
+    /** Token accounts owned by `owner`, filtered by mint or program id. */
+    getTokenAccountsByOwner(owner: PublicKey, filter: TokenAccountsFilter, commitment?: Commitment): ReturnType<Connection["getTokenAccountsByOwner"]>;
+    /** Confirmed signatures for transactions involving `address`. */
+    getSignaturesForAddress(address: PublicKey, options?: Parameters<Connection["getSignaturesForAddress"]>[1]): ReturnType<Connection["getSignaturesForAddress"]>;
+    /** Request an airdrop of `lamports` to `pubkey` (testnet/devnet only). */
+    requestAirdrop(pubkey: PublicKey, lamports: number): Promise<string>;
+    /** Build (unsigned, no blockhash) a SOL transfer transaction. */
+    buildTransferSol(args: TransferSolArgs): Transaction;
+    /** Build, sign, send, and confirm a SOL transfer. */
+    transferSol(args: TransferSolArgs, options?: ConfirmOptions): Promise<string>;
+    /** Sign, send, and confirm an arbitrary transaction. */
+    sendTransaction(tx: Transaction, signers: Keypair[], options?: ConfirmOptions): Promise<string>;
+    /** Simulate a transaction without submitting it. */
+    simulateTransaction(tx: Transaction): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
+}
+/**
+ * Create a QoreChain SVM client bundle.
+ *
+ * With no options it targets the testnet localhost endpoint
+ * (`http://localhost:8899`) at `confirmed` commitment.
+ */
+declare function createSvmClient(opts?: CreateSvmClientOptions): SvmClient;
+
+/**
+ * Key helpers for QoreChain's Solana-compatible runtime.
+ *
+ * These are thin wrappers over `@solana/web3.js` so callers don't need a second
+ * import path. `@qorechain/sdk`'s `deriveSvmAccount(mnemonic)` provides the
+ * 64-byte `secretKey` you can pass straight into {@link svmKeypairFromSecretKey}.
+ */
+
+/**
+ * Reconstruct a `@solana/web3.js` `Keypair` from a 64-byte ed25519 secret key
+ * (the standard Solana secret-key encoding: 32-byte seed + 32-byte public key).
+ *
+ * Pair with `@qorechain/sdk`'s `deriveSvmAccount`, which returns this exact
+ * 64-byte `secretKey`.
+ */
+declare function svmKeypairFromSecretKey(secretKey: Uint8Array): Keypair;
+/** Return the base58 address for a `Keypair` or a `PublicKey`. */
+declare function svmAddress(key: Keypair | PublicKey): string;
+
+/**
+ * Well-known native program ids for QoreChain's Solana-compatible runtime, plus
+ * thin instruction builders for the Memo and SPL-Token programs and the
+ * Associated Token Account program.
+ *
+ * The program ids are the exact canonical ones used by Solana-compatible
+ * runtimes, so standard wallets, explorers, and tooling interoperate directly.
+ * The SPL-Token / ATA / Memo instructions are built minimally here (by hand)
+ * to keep the dependency surface to a single peer — `@solana/web3.js` — with no
+ * `@solana/spl-token` requirement.
+ */
+
+/** System program (account creation, SOL transfers). */
+declare const SYSTEM_PROGRAM_ID: PublicKey;
+/** SPL-Token program. */
+declare const TOKEN_PROGRAM_ID: PublicKey;
+/** Associated Token Account program. */
+declare const ASSOCIATED_TOKEN_PROGRAM_ID: PublicKey;
+/** SPL Memo program. */
+declare const MEMO_PROGRAM_ID: PublicKey;
+/** Convenience grouping of the well-known program ids. */
+declare const PROGRAM_IDS: {
+    readonly system: PublicKey;
+    readonly token: PublicKey;
+    readonly associatedToken: PublicKey;
+    readonly memo: PublicKey;
+};
+/**
+ * Build a Memo program instruction carrying `text` (encoded UTF-8).
+ *
+ * @param text    Memo contents.
+ * @param signers Optional accounts that must sign the memo; each is included as
+ *                a read-only signer (the Memo program's convention).
+ */
+declare function createMemoInstruction(text: string, signers?: PublicKey[]): TransactionInstruction;
+/** Arguments for {@link createTransferTokenInstruction}. */
+interface TransferTokenInstructionArgs {
+    /** Source SPL-Token account. */
+    source: PublicKey;
+    /** Destination SPL-Token account. */
+    destination: PublicKey;
+    /** Owner/authority of the source account (signer). */
+    owner: PublicKey;
+    /** Amount in the token's base units. */
+    amount: bigint;
+    /** Additional multisig signers, if `owner` is a multisig. */
+    multiSigners?: PublicKey[];
+}
+/**
+ * Build an SPL-Token `Transfer` instruction.
+ *
+ * Layout: 1 byte instruction discriminator (`3` = Transfer) followed by a
+ * little-endian u64 amount.
+ */
+declare function createTransferTokenInstruction(args: TransferTokenInstructionArgs): TransactionInstruction;
+/**
+ * Derive the deterministic Associated Token Account (ATA) address for an owner
+ * and mint under the SPL-Token program.
+ */
+declare function getAssociatedTokenAddress(mint: PublicKey, owner: PublicKey, tokenProgramId?: PublicKey): PublicKey;
+/** Arguments for {@link createAssociatedTokenAccountInstruction}. */
+interface CreateAssociatedTokenAccountInstructionArgs {
+    /** Account funding the rent for the new ATA (signer, writable). */
+    payer: PublicKey;
+    /** Wallet that will own the new ATA. */
+    owner: PublicKey;
+    /** Token mint. */
+    mint: PublicKey;
+    /** SPL-Token program id (defaults to the canonical SPL-Token program). */
+    tokenProgramId?: PublicKey;
+}
+/**
+ * Build an instruction that creates the Associated Token Account for
+ * `(owner, mint)`. The ATA address is derived deterministically.
+ */
+declare function createAssociatedTokenAccountInstruction(args: CreateAssociatedTokenAccountInstructionArgs): TransactionInstruction;
+/**
+ * Generic instruction builder for invoking an arbitrary on-chain program.
+ *
+ * Use this with {@link createSvmClient}'s `sendTransaction` to call a deployed
+ * BPF program. Deploy programs with standard Solana tooling (e.g.
+ * `solana program deploy`); this package intentionally does not wrap the loader.
+ */
+declare function createInvokeInstruction(programId: PublicKey, keys: AccountMeta[], data: Uint8Array): TransactionInstruction;
+
+/**
+ * SVM browser-wallet integration for QoreChain (Phantom and Wallet-Standard).
+ *
+ * Adapts an injected Solana provider (Phantom's `window.solana` is the baseline)
+ * into a shape usable with `@solana/web3.js`, so apps can sign and send via the
+ * existing SVM client.
+ *
+ * ```ts
+ * import { getSvmWallet } from "@qorechain/svm";
+ * import { createSvmClient } from "@qorechain/svm";
+ *
+ * const wallet = await getSvmWallet();
+ * const signed = await wallet.signTransaction(tx);
+ * // ...then send with createSvmClient(...).sendRawTransaction(...)
+ * ```
+ */
+
+/** A transaction the wallet can sign (legacy or versioned). */
+type SvmSignableTransaction = Transaction | VersionedTransaction;
+/**
+ * The minimal injected Solana-wallet surface used here. Phantom (and most
+ * Wallet-Standard providers) implement at least these. Declared structurally so
+ * no wallet types package is required.
+ */
+interface InjectedSvmWallet {
+    /** Phantom marker; present on the Phantom provider. */
+    isPhantom?: boolean;
+    /** Connect and return the account public key. */
+    connect(opts?: {
+        onlyIfTrusted?: boolean;
+    }): Promise<{
+        publicKey: PublicKey;
+    }>;
+    /** Disconnect the wallet. */
+    disconnect?(): Promise<void>;
+    /** The connected account public key (populated after `connect`). */
+    publicKey?: PublicKey | null;
+    /** Sign a single transaction. */
+    signTransaction<T extends SvmSignableTransaction>(tx: T): Promise<T>;
+    /** Sign multiple transactions. */
+    signAllTransactions?<T extends SvmSignableTransaction>(txs: T[]): Promise<T[]>;
+}
+/** Options for {@link getSvmWallet}. */
+interface GetSvmWalletOptions {
+    /** The injected provider to use. Defaults to `window.solana` (Phantom). */
+    provider?: InjectedSvmWallet;
+    /** Pass through to the provider's `connect` (e.g. silent reconnect). */
+    onlyIfTrusted?: boolean;
+}
+/**
+ * A connected SVM wallet adapted for use with `@solana/web3.js`.
+ *
+ * `signTransaction` / `signAllTransactions` accept and return web3.js
+ * `Transaction` / `VersionedTransaction` objects, so they drop into the existing
+ * SVM client's send path.
+ */
+interface SvmWalletConnection {
+    /** The connected account public key. */
+    publicKey: PublicKey;
+    /** Sign a single transaction. */
+    signTransaction<T extends SvmSignableTransaction>(tx: T): Promise<T>;
+    /** Sign multiple transactions (falls back to sequential signing). */
+    signAllTransactions<T extends SvmSignableTransaction>(txs: T[]): Promise<T[]>;
+    /** The underlying injected provider. */
+    provider: InjectedSvmWallet;
+}
+/**
+ * Connect to an injected Solana wallet (Phantom by default) and return an
+ * adapter usable with `@solana/web3.js`.
+ *
+ * Browser-only: throws a clear error if no `window` or no injected provider.
+ */
+declare function getSvmWallet(opts?: GetSvmWalletOptions): Promise<SvmWalletConnection>;
+/**
+ * Detect a Wallet-Standard / Phantom Solana provider on `window`.
+ *
+ * Returns the injected provider if present, else `undefined`. Phantom's
+ * `window.solana` is the baseline; this is a light convenience for apps that
+ * want to feature-detect before prompting a connection.
+ */
+declare function detectSvmProvider(): InjectedSvmWallet | undefined;
+
+/**
+ * Human-readable decoding of SVM (Solana-compatible) transaction errors.
+ *
+ * `@solana/web3.js` throws a `SendTransactionError` (and related shapes) whose
+ * useful detail — the failing instruction index, a program's custom error code,
+ * and the program logs — is spread across several fields that differ slightly
+ * between library versions. {@link decodeSvmError} reads those fields
+ * structurally (so it works across versions) and produces a flat summary with
+ * the program logs and, where present, the failing instruction index.
+ */
+/** A decoded SVM error. */
+interface DecodedSvmError {
+    /** A readable summary message. */
+    message: string;
+    /** A short, stable kind discriminator. */
+    kind: "instruction_error" | "simulation" | "send" | "unknown";
+    /** Zero-based index of the failing instruction, when determinable. */
+    instructionIndex?: number;
+    /** A program's custom error code, when present in the logs. */
+    customErrorCode?: number;
+    /** The program logs, when available. */
+    logs?: string[];
+}
+/**
+ * Decode an SVM error thrown by `@solana/web3.js` into a readable, structured
+ * form.
+ *
+ * @param error - The thrown error (a `SendTransactionError` or any value).
+ */
+declare function decodeSvmError(error: unknown): DecodedSvmError;
+
+/**
+ * Real-time SVM subscriptions over the `@solana/web3.js` `Connection`.
+ *
+ * The `Connection` owns the websocket and its lifecycle; these helpers are thin
+ * wrappers that register a listener and return both the numeric subscription id
+ * and an `off()` function that removes it via the matching
+ * `remove*Listener` call. This keeps callers from having to remember which
+ * removal method pairs with which subscription.
+ */
+
+/** A registered subscription: its id and a function to remove it. */
+interface SvmSubscription {
+    /** The numeric subscription id returned by `@solana/web3.js`. */
+    id: number;
+    /** Remove the listener (idempotent best-effort). */
+    off(): Promise<void>;
+}
+/**
+ * Subscribe to transaction logs matching `filter`.
+ *
+ * @param connection - A `@solana/web3.js` `Connection`.
+ * @param filter - A `LogsFilter` (`"all"`, `"allWithVotes"`, or a `PublicKey`).
+ * @param callback - Invoked with each matching logs notification.
+ * @param commitment - Optional commitment level.
+ */
+declare function onLogs(connection: Connection, filter: LogsFilter, callback: LogsCallback, commitment?: Commitment): SvmSubscription;
+/**
+ * Subscribe to changes of an account's data.
+ *
+ * @param connection - A `@solana/web3.js` `Connection`.
+ * @param pubkey - The account to watch.
+ * @param callback - Invoked with each account change.
+ * @param commitment - Optional commitment level.
+ */
+declare function onAccountChange(connection: Connection, pubkey: PublicKey, callback: AccountChangeCallback, commitment?: Commitment): SvmSubscription;
+/**
+ * Subscribe to slot changes (new slots as they are processed).
+ *
+ * @param connection - A `@solana/web3.js` `Connection`.
+ * @param callback - Invoked with each slot change.
+ */
+declare function onSlotChange(connection: Connection, callback: SlotChangeCallback): SvmSubscription;
+
+/**
+ * Compute-budget and priority-fee conveniences over `@solana/web3.js`.
+ *
+ * {@link withComputeBudget} prepends `ComputeBudgetProgram` instructions to a
+ * legacy `Transaction` so it requests a compute-unit limit and pays a per-CU
+ * priority price; {@link estimatePriorityFee} reads recent prioritization fees
+ * from the RPC to suggest a `microLamports` price.
+ */
+
+/** Compute-budget options for {@link withComputeBudget}. */
+interface ComputeBudgetOptions {
+    /** Compute-unit limit to request (`setComputeUnitLimit`). */
+    units?: number;
+    /** Per-compute-unit price in micro-lamports (`setComputeUnitPrice`). */
+    microLamports?: number | bigint;
+}
+/**
+ * Prepend `ComputeBudgetProgram` instructions to `tx` (mutating it in place and
+ * returning it). A unit-limit instruction is added when `units` is given, and a
+ * unit-price instruction when `microLamports` is given; both are inserted at the
+ * front of the instruction list, as required by the runtime.
+ *
+ * @returns The same `tx`, for chaining.
+ */
+declare function withComputeBudget(tx: Transaction, options: ComputeBudgetOptions): Transaction;
+/**
+ * Estimate a priority fee (`microLamports` per CU) from the RPC's
+ * `getRecentPrioritizationFees`. Returns the maximum recently observed fee,
+ * which is a conservative choice for landing a transaction quickly. Returns `0`
+ * when the RPC reports no recent fees.
+ *
+ * @param connection - SVM RPC connection.
+ * @param accounts   - Optional accounts the tx will lock, scoping the query.
+ */
+declare function estimatePriorityFee(connection: Connection, accounts?: readonly PublicKey[]): Promise<number>;
+/** Namespaced compute-budget / fee helpers. */
+declare const fees: {
+    readonly withComputeBudget: typeof withComputeBudget;
+    readonly estimatePriorityFee: typeof estimatePriorityFee;
+};
+
+/**
+ * `@qorechain/svm` — a thin, type-safe adapter over
+ * [`@solana/web3.js`](https://solana-labs.github.io/solana-web3.js/) for
+ * QoreChain's Solana-compatible JSON-RPC.
+ *
+ * It does not reimplement an SVM client; `@solana/web3.js` is a peer dependency.
+ * This package adds QoreChain-specific conveniences: a client factory targeting
+ * the SVM RPC endpoint, key helpers, typed read wrappers, SOL transfer
+ * build/sign/send, and minimal native-program instruction builders (Memo,
+ * SPL-Token, Associated Token Account) plus a generic program-invoke builder.
+ */
+/** Package version. */
+declare const VERSION = "0.3.0";
+
+export { ASSOCIATED_TOKEN_PROGRAM_ID, type ComputeBudgetOptions, type CreateAssociatedTokenAccountInstructionArgs, type CreateSvmClientOptions, DEFAULT_SVM_RPC_URL, type DecodedSvmError, type GetSvmWalletOptions, type InjectedSvmWallet, MEMO_PROGRAM_ID, PROGRAM_IDS, SYSTEM_PROGRAM_ID, type SvmClient, type SvmEndpoints, type SvmSignableTransaction, type SvmSubscription, type SvmWalletConnection, TOKEN_PROGRAM_ID, type TransferSolArgs, type TransferTokenInstructionArgs, VERSION, createAssociatedTokenAccountInstruction, createInvokeInstruction, createMemoInstruction, createSvmClient, createTransferTokenInstruction, decodeSvmError, detectSvmProvider, estimatePriorityFee, fees, getAssociatedTokenAddress, getSvmWallet, onAccountChange, onLogs, onSlotChange, svmAddress, svmKeypairFromSecretKey, withComputeBudget };

package/dist/index.js

@@ -0,0 +1,274 @@
+import { PublicKey, Keypair, TransactionInstruction, ComputeBudgetProgram, Transaction, SystemProgram, sendAndConfirmTransaction, Connection } from '@solana/web3.js';
+
+// src/client.ts
+var DEFAULT_SVM_RPC_URL = "http://localhost:8899";
+function resolveConnection(opts) {
+  if (opts.connection) return opts.connection;
+  const url = opts.rpcUrl ?? opts.endpoints?.svmRpc ?? DEFAULT_SVM_RPC_URL;
+  return new Connection(url, opts.commitment ?? "confirmed");
+}
+function createSvmClient(opts = {}) {
+  const connection = resolveConnection(opts);
+  const buildTransferSol = (args) => {
+    const tx = new Transaction();
+    tx.add(
+      SystemProgram.transfer({
+        fromPubkey: args.from.publicKey,
+        toPubkey: args.to,
+        lamports: args.lamports
+      })
+    );
+    return tx;
+  };
+  const sendTransaction = (tx, signers, options) => sendAndConfirmTransaction(connection, tx, signers, options);
+  return {
+    connection,
+    getBalance: (pubkey, commitment) => connection.getBalance(pubkey, commitment),
+    getAccountInfo: (pubkey, commitment) => connection.getAccountInfo(pubkey, commitment),
+    getLatestBlockhash: (commitmentOrConfig) => connection.getLatestBlockhash(commitmentOrConfig),
+    getTokenAccountsByOwner: (owner, filter, commitment) => connection.getTokenAccountsByOwner(owner, filter, commitment),
+    getSignaturesForAddress: (address, options) => connection.getSignaturesForAddress(address, options),
+    requestAirdrop: (pubkey, lamports) => connection.requestAirdrop(pubkey, lamports),
+    buildTransferSol,
+    transferSol: (args, options) => sendTransaction(buildTransferSol(args), [args.from], options),
+    sendTransaction,
+    simulateTransaction: (tx) => (
+      // The single-arg overload signs/derives blockhash as needed for v1
+      // legacy transactions.
+      connection.simulateTransaction(tx)
+    )
+  };
+}
+function svmKeypairFromSecretKey(secretKey) {
+  if (secretKey.length !== 64) {
+    throw new Error(
+      `svmKeypairFromSecretKey: expected a 64-byte secret key, got ${secretKey.length}`
+    );
+  }
+  return Keypair.fromSecretKey(secretKey);
+}
+function svmAddress(key) {
+  const pubkey = key instanceof PublicKey ? key : key.publicKey;
+  return pubkey.toBase58();
+}
+var SYSTEM_PROGRAM_ID = new PublicKey("11111111111111111111111111111111");
+var TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey(
+  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+);
+var MEMO_PROGRAM_ID = new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
+var PROGRAM_IDS = {
+  system: SYSTEM_PROGRAM_ID,
+  token: TOKEN_PROGRAM_ID,
+  associatedToken: ASSOCIATED_TOKEN_PROGRAM_ID,
+  memo: MEMO_PROGRAM_ID
+};
+function createMemoInstruction(text, signers = []) {
+  return new TransactionInstruction({
+    programId: MEMO_PROGRAM_ID,
+    keys: signers.map((pubkey) => ({ pubkey, isSigner: true, isWritable: false })),
+    data: Buffer.from(text, "utf8")
+  });
+}
+function createTransferTokenInstruction(args) {
+  const { source, destination, owner, amount, multiSigners = [] } = args;
+  const data = Buffer.alloc(9);
+  data.writeUInt8(3, 0);
+  data.writeBigUInt64LE(amount, 1);
+  const keys = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    {
+      pubkey: owner,
+      isSigner: multiSigners.length === 0,
+      isWritable: false
+    },
+    ...multiSigners.map((pubkey) => ({ pubkey, isSigner: true, isWritable: false }))
+  ];
+  return new TransactionInstruction({ programId: TOKEN_PROGRAM_ID, keys, data });
+}
+function getAssociatedTokenAddress(mint, owner, tokenProgramId = TOKEN_PROGRAM_ID) {
+  const [address] = PublicKey.findProgramAddressSync(
+    [owner.toBuffer(), tokenProgramId.toBuffer(), mint.toBuffer()],
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+  return address;
+}
+function createAssociatedTokenAccountInstruction(args) {
+  const { payer, owner, mint, tokenProgramId = TOKEN_PROGRAM_ID } = args;
+  const ata = getAssociatedTokenAddress(mint, owner, tokenProgramId);
+  const keys = [
+    { pubkey: payer, isSigner: true, isWritable: true },
+    { pubkey: ata, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: tokenProgramId, isSigner: false, isWritable: false }
+  ];
+  return new TransactionInstruction({
+    programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+    keys,
+    data: Buffer.alloc(0)
+  });
+}
+function createInvokeInstruction(programId, keys, data) {
+  return new TransactionInstruction({
+    programId,
+    keys,
+    data: Buffer.from(data)
+  });
+}
+
+// src/wallet.ts
+function resolveProvider(provider) {
+  if (provider) return provider;
+  if (typeof window === "undefined") {
+    throw new Error(
+      "getSvmWallet: no browser `window` available. Run in a browser, or pass `provider` explicitly."
+    );
+  }
+  const injected = window.solana;
+  if (!injected) {
+    throw new Error(
+      "getSvmWallet: no injected Solana provider found (window.solana). Install Phantom, or pass `provider`."
+    );
+  }
+  return injected;
+}
+async function getSvmWallet(opts = {}) {
+  const provider = resolveProvider(opts.provider);
+  const { publicKey } = await provider.connect(
+    opts.onlyIfTrusted ? { onlyIfTrusted: true } : void 0
+  );
+  if (!publicKey) {
+    throw new Error("getSvmWallet: wallet connected but returned no public key");
+  }
+  const signTransaction = (tx) => provider.signTransaction(tx);
+  const signAllTransactions = async (txs) => {
+    if (provider.signAllTransactions) return provider.signAllTransactions(txs);
+    const out = [];
+    for (const tx of txs) out.push(await provider.signTransaction(tx));
+    return out;
+  };
+  return { publicKey, signTransaction, signAllTransactions, provider };
+}
+function detectSvmProvider() {
+  if (typeof window === "undefined") return void 0;
+  return window.solana;
+}
+
+// src/errors.ts
+function extractLogs(err) {
+  const e = err;
+  const logs = e?.logs ?? e?.transactionLogs;
+  if (Array.isArray(logs)) return logs;
+  return void 0;
+}
+function extractMessage(err) {
+  const e = err;
+  if (typeof e?.transactionMessage === "string" && e.transactionMessage) {
+    return e.transactionMessage;
+  }
+  if (typeof e?.message === "string" && e.message) return e.message;
+  return String(err);
+}
+function parseFromLogs(logs) {
+  if (!logs) return {};
+  let instructionIndex;
+  let customErrorCode;
+  for (const line of logs) {
+    const instr = /instruction\s+#?(\d+)/i.exec(line);
+    if (instr) instructionIndex = Number(instr[1]);
+    const custom = /custom program error:\s*(0x[0-9a-fA-F]+|\d+)/i.exec(line);
+    if (custom) {
+      customErrorCode = custom[1].startsWith("0x") ? parseInt(custom[1], 16) : Number(custom[1]);
+    }
+  }
+  return { instructionIndex, customErrorCode };
+}
+function decodeSvmError(error) {
+  const logs = extractLogs(error);
+  const base = extractMessage(error);
+  const { instructionIndex, customErrorCode } = parseFromLogs(logs);
+  const name = error?.name;
+  const isSendError = name === "SendTransactionError" || /simulation failed|transaction simulation/i.test(base);
+  const parts = [base];
+  if (instructionIndex !== void 0) {
+    parts.push(`(failing instruction #${instructionIndex})`);
+  }
+  if (customErrorCode !== void 0) {
+    parts.push(`(custom program error ${customErrorCode})`);
+  }
+  let kind;
+  if (customErrorCode !== void 0 || instructionIndex !== void 0) {
+    kind = "instruction_error";
+  } else if (isSendError) {
+    kind = "simulation";
+  } else if (error instanceof Error) {
+    kind = "send";
+  } else {
+    kind = "unknown";
+  }
+  return {
+    message: parts.join(" "),
+    kind,
+    instructionIndex,
+    customErrorCode,
+    logs
+  };
+}
+
+// src/subscribe.ts
+function onLogs(connection, filter, callback, commitment) {
+  const id = connection.onLogs(filter, callback, commitment);
+  return {
+    id,
+    off: () => connection.removeOnLogsListener(id)
+  };
+}
+function onAccountChange(connection, pubkey, callback, commitment) {
+  const id = connection.onAccountChange(pubkey, callback, commitment);
+  return {
+    id,
+    off: () => connection.removeAccountChangeListener(id)
+  };
+}
+function onSlotChange(connection, callback) {
+  const id = connection.onSlotChange(callback);
+  return {
+    id,
+    off: () => connection.removeSlotChangeListener(id)
+  };
+}
+function withComputeBudget(tx, options) {
+  const { units, microLamports } = options;
+  const prepend = [];
+  if (microLamports !== void 0) {
+    prepend.unshift(
+      ComputeBudgetProgram.setComputeUnitPrice({ microLamports })
+    );
+  }
+  if (units !== void 0) {
+    prepend.unshift(ComputeBudgetProgram.setComputeUnitLimit({ units }));
+  }
+  tx.instructions.unshift(...prepend);
+  return tx;
+}
+async function estimatePriorityFee(connection, accounts = []) {
+  const fees2 = await connection.getRecentPrioritizationFees(
+    accounts.length > 0 ? { lockedWritableAccounts: [...accounts] } : void 0
+  );
+  if (!fees2 || fees2.length === 0) return 0;
+  return fees2.reduce((max, f) => Math.max(max, f.prioritizationFee), 0);
+}
+var fees = {
+  withComputeBudget,
+  estimatePriorityFee
+};
+
+// src/index.ts
+var VERSION = "0.3.0";
+
+export { ASSOCIATED_TOKEN_PROGRAM_ID, DEFAULT_SVM_RPC_URL, MEMO_PROGRAM_ID, PROGRAM_IDS, SYSTEM_PROGRAM_ID, TOKEN_PROGRAM_ID, VERSION, createAssociatedTokenAccountInstruction, createInvokeInstruction, createMemoInstruction, createSvmClient, createTransferTokenInstruction, decodeSvmError, detectSvmProvider, estimatePriorityFee, fees, getAssociatedTokenAddress, getSvmWallet, onAccountChange, onLogs, onSlotChange, svmAddress, svmKeypairFromSecretKey, withComputeBudget };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map