@bitgo/wasm-solana 2.4.0 → 2.5.0

package/dist/cjs/js/explain.d.ts

@@ -0,0 +1,100 @@
+/**
+ * High-level transaction explanation.
+ *
+ * Builds on top of `parseTransaction` (WASM) to provide a structured
+ * "explain" view of a Solana transaction: type, outputs, inputs, fee, etc.
+ *
+ * The WASM parser returns raw individual instructions. This module combines
+ * related instruction sequences into higher-level operations and derives the
+ * overall transaction type.
+ */
+export declare enum TransactionType {
+    Send = "Send",
+    StakingActivate = "StakingActivate",
+    StakingDeactivate = "StakingDeactivate",
+    StakingWithdraw = "StakingWithdraw",
+    StakingAuthorize = "StakingAuthorize",
+    StakingDelegate = "StakingDelegate",
+    WalletInitialization = "WalletInitialization",
+    AssociatedTokenAccountInitialization = "AssociatedTokenAccountInitialization"
+}
+export interface ExplainOptions {
+    /** Defaults to 5000 (Solana protocol constant). */
+    lamportsPerSignature?: bigint | number | string;
+    tokenAccountRentExemptAmount?: bigint | number | string;
+}
+export interface ExplainedOutput {
+    address: string;
+    amount: bigint;
+    tokenName?: string;
+}
+export interface ExplainedInput {
+    address: string;
+    value: bigint;
+}
+export interface TokenEnablement {
+    /** The ATA address being created */
+    address: string;
+    /** The SPL token mint address */
+    mintAddress: string;
+}
+export interface StakingAuthorizeInfo {
+    stakingAddress: string;
+    oldAuthorizeAddress: string;
+    newAuthorizeAddress: string;
+    authorizeType: "Staker" | "Withdrawer";
+    custodianAddress?: string;
+}
+export interface ExplainedTransaction {
+    /** Transaction ID (base58 signature). Undefined if the transaction is unsigned. */
+    id: string | undefined;
+    type: TransactionType;
+    feePayer: string;
+    fee: bigint;
+    blockhash: string;
+    durableNonce?: {
+        walletNonceAddress: string;
+        authWalletAddress: string;
+    };
+    outputs: ExplainedOutput[];
+    inputs: ExplainedInput[];
+    outputAmount: bigint;
+    memo?: string;
+    /**
+     * Maps ATA address → owner address for CreateAssociatedTokenAccount instructions.
+     * Allows resolving newly-created token account ownership without an external lookup.
+     */
+    ataOwnerMap: Record<string, string>;
+    /**
+     * Token enablements from CreateAssociatedTokenAccount instructions.
+     * Contains the ATA address and mint address (consumer resolves token names).
+     */
+    tokenEnablements: TokenEnablement[];
+    /** Staking authorize details, present when the transaction changes stake authority. */
+    stakingAuthorize?: StakingAuthorizeInfo;
+    numSignatures: number;
+}
+/**
+ * Explain a Solana transaction.
+ *
+ * Takes raw transaction bytes and fee parameters, then returns a structured
+ * explanation including transaction type, outputs, inputs, fee, memo, and
+ * associated-token-account owner mappings.
+ *
+ * @param input - Raw transaction bytes (caller is responsible for decoding base64/hex)
+ * @param options - Fee parameters for calculating the total fee
+ * @returns An ExplainedTransaction with all fields populated
+ *
+ * @example
+ * ```typescript
+ * import { explainTransaction } from '@bitgo/wasm-solana';
+ *
+ * const txBytes = Buffer.from(txBase64, 'base64');
+ * const explained = explainTransaction(txBytes, {
+ *   lamportsPerSignature: 5000n,
+ *   tokenAccountRentExemptAmount: 2039280n,
+ * });
+ * console.log(explained.type); // "Send", "StakingActivate", etc.
+ * ```
+ */
+export declare function explainTransaction(input: Uint8Array, options: ExplainOptions): ExplainedTransaction;

package/dist/cjs/js/explain.js

@@ -0,0 +1,311 @@
+"use strict";
+/**
+ * High-level transaction explanation.
+ *
+ * Builds on top of `parseTransaction` (WASM) to provide a structured
+ * "explain" view of a Solana transaction: type, outputs, inputs, fee, etc.
+ *
+ * The WASM parser returns raw individual instructions. This module combines
+ * related instruction sequences into higher-level operations and derives the
+ * overall transaction type.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionType = void 0;
+exports.explainTransaction = explainTransaction;
+const parser_js_1 = require("./parser.js");
+// =============================================================================
+// Public types
+// =============================================================================
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["Send"] = "Send";
+    TransactionType["StakingActivate"] = "StakingActivate";
+    TransactionType["StakingDeactivate"] = "StakingDeactivate";
+    TransactionType["StakingWithdraw"] = "StakingWithdraw";
+    TransactionType["StakingAuthorize"] = "StakingAuthorize";
+    TransactionType["StakingDelegate"] = "StakingDelegate";
+    TransactionType["WalletInitialization"] = "WalletInitialization";
+    TransactionType["AssociatedTokenAccountInitialization"] = "AssociatedTokenAccountInitialization";
+})(TransactionType || (exports.TransactionType = TransactionType = {}));
+/** Solana base fee per signature (protocol constant). */
+const DEFAULT_LAMPORTS_PER_SIGNATURE = 5000n;
+/**
+ * Scan for multi-instruction patterns that should be combined:
+ *
+ * 1. CreateAccount + StakeInitialize [+ StakingDelegate] → StakingActivate
+ *    - With Delegate following = NATIVE staking
+ *    - Without Delegate = MARINADE staking (Marinade's program handles delegation)
+ * 2. CreateAccount + NonceInitialize → WalletInitialization
+ *    - BitGo creates a nonce account during wallet initialization
+ */
+function detectCombinedPattern(instructions) {
+    for (let i = 0; i < instructions.length - 1; i++) {
+        const curr = instructions[i];
+        const next = instructions[i + 1];
+        if (curr.type === "CreateAccount" && next.type === "StakeInitialize") {
+            return {
+                kind: "StakingActivate",
+                fromAddress: curr.fromAddress,
+                stakingAddress: curr.newAddress,
+                amount: curr.amount,
+            };
+        }
+        if (curr.type === "CreateAccount" && next.type === "NonceInitialize") {
+            return {
+                kind: "WalletInitialization",
+                fromAddress: curr.fromAddress,
+                nonceAddress: curr.newAddress,
+                amount: curr.amount,
+            };
+        }
+    }
+    return null;
+}
+// =============================================================================
+// Transaction type derivation
+// =============================================================================
+const BOILERPLATE_TYPES = new Set([
+    "NonceAdvance",
+    "Memo",
+    "SetComputeUnitLimit",
+    "SetPriorityFee",
+]);
+function deriveTransactionType(instructions, combined, memo) {
+    if (combined)
+        return TransactionType[combined.kind];
+    // Marinade deactivate: Transfer + memo containing "PrepareForRevoke"
+    if (memo?.includes("PrepareForRevoke"))
+        return TransactionType.StakingDeactivate;
+    // Jito pool operations map to staking types
+    if (instructions.some((i) => i.type === "StakePoolDepositSol"))
+        return TransactionType.StakingActivate;
+    if (instructions.some((i) => i.type === "StakePoolWithdrawStake"))
+        return TransactionType.StakingDeactivate;
+    // ATA-only transactions (ignoring boilerplate like nonce/memo/compute budget)
+    const meaningful = instructions.filter((i) => !BOILERPLATE_TYPES.has(i.type));
+    if (meaningful.length > 0 && meaningful.every((i) => i.type === "CreateAssociatedTokenAccount")) {
+        return TransactionType.AssociatedTokenAccountInitialization;
+    }
+    // For staking instructions, the instruction type IS the transaction type
+    const staking = instructions.find((i) => i.type in TransactionType);
+    if (staking)
+        return TransactionType[staking.type];
+    return TransactionType.Send;
+}
+// =============================================================================
+// Transaction ID extraction
+// =============================================================================
+// Base58 encoding of 64 zero bytes. Unsigned transactions have all-zero
+// signatures which encode to this constant.
+const ALL_ZEROS_BASE58 = "1111111111111111111111111111111111111111111111111111111111111111";
+function extractTransactionId(signatures) {
+    const sig = signatures[0];
+    if (!sig || sig === ALL_ZEROS_BASE58)
+        return undefined;
+    return sig;
+}
+// =============================================================================
+// Main export
+// =============================================================================
+/**
+ * Explain a Solana transaction.
+ *
+ * Takes raw transaction bytes and fee parameters, then returns a structured
+ * explanation including transaction type, outputs, inputs, fee, memo, and
+ * associated-token-account owner mappings.
+ *
+ * @param input - Raw transaction bytes (caller is responsible for decoding base64/hex)
+ * @param options - Fee parameters for calculating the total fee
+ * @returns An ExplainedTransaction with all fields populated
+ *
+ * @example
+ * ```typescript
+ * import { explainTransaction } from '@bitgo/wasm-solana';
+ *
+ * const txBytes = Buffer.from(txBase64, 'base64');
+ * const explained = explainTransaction(txBytes, {
+ *   lamportsPerSignature: 5000n,
+ *   tokenAccountRentExemptAmount: 2039280n,
+ * });
+ * console.log(explained.type); // "Send", "StakingActivate", etc.
+ * ```
+ */
+function explainTransaction(input, options) {
+    const { lamportsPerSignature, tokenAccountRentExemptAmount } = options;
+    const parsed = (0, parser_js_1.parseTransactionData)(input);
+    // --- Transaction ID ---
+    const id = extractTransactionId(parsed.signatures);
+    // --- Fee calculation ---
+    // Base fee = numSignatures × lamportsPerSignature
+    let fee = BigInt(parsed.numSignatures) *
+        (lamportsPerSignature !== undefined
+            ? BigInt(lamportsPerSignature)
+            : DEFAULT_LAMPORTS_PER_SIGNATURE);
+    // Each CreateAssociatedTokenAccount instruction creates a new token account,
+    // which requires a rent-exempt deposit. Add that to the fee.
+    const ataCount = parsed.instructionsData.filter((i) => i.type === "CreateAssociatedTokenAccount").length;
+    if (ataCount > 0 && tokenAccountRentExemptAmount !== undefined) {
+        fee += BigInt(ataCount) * BigInt(tokenAccountRentExemptAmount);
+    }
+    // --- Extract memo (needed before type derivation) ---
+    let memo;
+    for (const instr of parsed.instructionsData) {
+        if (instr.type === "Memo") {
+            memo = instr.memo;
+        }
+    }
+    // --- Detect combined instruction patterns ---
+    const combined = detectCombinedPattern(parsed.instructionsData);
+    const txType = deriveTransactionType(parsed.instructionsData, combined, memo);
+    // Marinade deactivate: Transfer + PrepareForRevoke memo.
+    // The Transfer is a contract interaction (not a real value transfer),
+    // so we skip it from outputs.
+    const isMarinadeDeactivate = txType === TransactionType.StakingDeactivate &&
+        memo !== undefined &&
+        memo.includes("PrepareForRevoke");
+    // --- Extract outputs and inputs ---
+    const outputs = [];
+    const inputs = [];
+    if (combined?.kind === "StakingActivate") {
+        // Combined native/Marinade staking activate — the staking address receives
+        // the full amount from the funding account.
+        outputs.push({
+            address: combined.stakingAddress,
+            amount: combined.amount,
+        });
+        inputs.push({
+            address: combined.fromAddress,
+            value: combined.amount,
+        });
+    }
+    else if (combined?.kind === "WalletInitialization") {
+        // Wallet initialization — funds the new nonce account.
+        outputs.push({
+            address: combined.nonceAddress,
+            amount: combined.amount,
+        });
+        inputs.push({
+            address: combined.fromAddress,
+            value: combined.amount,
+        });
+    }
+    else {
+        // Process individual instructions for outputs/inputs
+        for (const instr of parsed.instructionsData) {
+            switch (instr.type) {
+                case "Transfer":
+                    // Skip Transfer for Marinade deactivate — it's a program interaction,
+                    // not a real value transfer to an external address.
+                    if (isMarinadeDeactivate)
+                        break;
+                    outputs.push({
+                        address: instr.toAddress,
+                        amount: instr.amount,
+                    });
+                    inputs.push({
+                        address: instr.fromAddress,
+                        value: instr.amount,
+                    });
+                    break;
+                case "TokenTransfer":
+                    outputs.push({
+                        address: instr.toAddress,
+                        amount: instr.amount,
+                        tokenName: instr.tokenAddress,
+                    });
+                    inputs.push({
+                        address: instr.fromAddress,
+                        value: instr.amount,
+                    });
+                    break;
+                case "StakingActivate":
+                    outputs.push({
+                        address: instr.stakingAddress,
+                        amount: instr.amount,
+                    });
+                    inputs.push({
+                        address: instr.fromAddress,
+                        value: instr.amount,
+                    });
+                    break;
+                case "StakingWithdraw":
+                    // Withdraw: SOL flows FROM the staking address TO the recipient.
+                    // `fromAddress` is the recipient (where funds go),
+                    // `stakingAddress` is the source.
+                    outputs.push({
+                        address: instr.fromAddress,
+                        amount: instr.amount,
+                    });
+                    inputs.push({
+                        address: instr.stakingAddress,
+                        value: instr.amount,
+                    });
+                    break;
+                case "StakePoolDepositSol":
+                    // Jito liquid staking: SOL is deposited into the stake pool.
+                    // The funding account is debited; output goes to the pool address.
+                    outputs.push({
+                        address: instr.stakePool,
+                        amount: instr.lamports,
+                    });
+                    inputs.push({
+                        address: instr.fundingAccount,
+                        value: instr.lamports,
+                    });
+                    break;
+                // StakingDeactivate, StakingAuthorize, StakingDelegate,
+                // StakePoolWithdrawStake, NonceAdvance, CreateAccount,
+                // StakeInitialize, NonceInitialize, SetComputeUnitLimit,
+                // SetPriorityFee, CreateAssociatedTokenAccount,
+                // CloseAssociatedTokenAccount, Memo, Unknown
+                // — no value inputs/outputs.
+            }
+        }
+    }
+    // --- Output amount ---
+    // Only count native SOL outputs (no tokenName). Token amounts are in different
+    // denominations and shouldn't be mixed with SOL lamports.
+    const outputAmount = outputs.filter((o) => !o.tokenName).reduce((sum, o) => sum + o.amount, 0n);
+    // --- ATA owner mapping and token enablements ---
+    const ataOwnerMap = {};
+    const tokenEnablements = [];
+    for (const instr of parsed.instructionsData) {
+        if (instr.type === "CreateAssociatedTokenAccount") {
+            ataOwnerMap[instr.ataAddress] = instr.ownerAddress;
+            tokenEnablements.push({
+                address: instr.ataAddress,
+                mintAddress: instr.mintAddress,
+            });
+        }
+    }
+    // --- Staking authorize ---
+    let stakingAuthorize;
+    for (const instr of parsed.instructionsData) {
+        if (instr.type === "StakingAuthorize") {
+            stakingAuthorize = {
+                stakingAddress: instr.stakingAddress,
+                oldAuthorizeAddress: instr.oldAuthorizeAddress,
+                newAuthorizeAddress: instr.newAuthorizeAddress,
+                authorizeType: instr.authorizeType,
+                custodianAddress: instr.custodianAddress,
+            };
+            break;
+        }
+    }
+    return {
+        id,
+        type: txType,
+        feePayer: parsed.feePayer,
+        fee,
+        blockhash: parsed.nonce,
+        durableNonce: parsed.durableNonce,
+        outputs,
+        inputs,
+        outputAmount,
+        memo,
+        ataOwnerMap,
+        tokenEnablements,
+        stakingAuthorize,
+        numSignatures: parsed.numSignatures,
+    };
+}

package/dist/cjs/js/index.d.ts

@@ -3,16 +3,53 @@ export * as pubkey from "./pubkey.js";
 export * as transaction from "./transaction.js";
 export * as parser from "./parser.js";
 export * as builder from "./builder.js";
+export * as explain from "./explain.js";
 export { Keypair } from "./keypair.js";
 export { Pubkey } from "./pubkey.js";
 export { Transaction } from "./transaction.js";
 export { VersionedTransaction, isVersionedTransaction } from "./versioned.js";
 export type { AddressLookupTableData } from "./versioned.js";
-export { parseTransaction } from "./parser.js";
+export { parseTransactionData } from "./parser.js";
 export { buildFromVersionedData } from "./builder.js";
 export { buildFromIntent, buildFromIntent as buildTransactionFromIntent } from "./intentBuilder.js";
-export type { BaseIntent, PaymentIntent, StakeIntent, UnstakeIntent, ClaimIntent, DeactivateIntent, DelegateIntent, EnableTokenIntent, CloseAtaIntent, ConsolidateIntent, SolanaIntent, StakePoolConfig, BuildFromIntentParams, BuildFromIntentResult, GeneratedKeypair, NonceSource, BlockhashNonce, DurableNonce, } from "./intentBuilder.js";
+export { explainTransaction, TransactionType } from "./explain.js";
+import { Transaction as _Transaction } from "./transaction.js";
+/**
+ * Parse a Solana transaction from raw bytes.
+ *
+ * Returns a `Transaction` instance that can be both inspected and signed.
+ * Use `.parse()` on the returned Transaction to get decoded instruction data.
+ *
+ * This is the single entry point for working with transactions — like
+ * `BitGoPsbt.fromBytes()` in wasm-utxo.
+ *
+ * @param bytes - Raw transaction bytes
+ * @returns A Transaction that can be inspected (`.parse()`) and signed (`.addSignature()`)
+ *
+ * @example
+ * ```typescript
+ * import { parseTransaction } from '@bitgo/wasm-solana';
+ *
+ * const tx = parseTransaction(txBytes);
+ *
+ * // Inspect
+ * const parsed = tx.parse();
+ * console.log(parsed.feePayer);
+ * for (const instr of parsed.instructionsData) {
+ *   if (instr.type === 'Transfer') {
+ *     console.log(`${instr.amount} lamports to ${instr.toAddress}`);
+ *   }
+ * }
+ *
+ * // Sign
+ * tx.addSignature(pubkey, signature);
+ * const signedBytes = tx.toBytes();
+ * ```
+ */
+export declare function parseTransaction(bytes: Uint8Array): _Transaction;
+export type { BaseIntent, PaymentIntent, StakeIntent, UnstakeIntent, ClaimIntent, DeactivateIntent, DelegateIntent, EnableTokenIntent, CloseAtaIntent, ConsolidateIntent, AuthorizeIntent, CustomTxIntent, CustomTxInstruction, CustomTxKey, SolanaIntent, StakePoolConfig, BuildFromIntentParams, BuildFromIntentResult, GeneratedKeypair, NonceSource, BlockhashNonce, DurableNonce, } from "./intentBuilder.js";
 export { system_program_id as systemProgramId, stake_program_id as stakeProgramId, compute_budget_program_id as computeBudgetProgramId, memo_program_id as memoProgramId, token_program_id as tokenProgramId, token_2022_program_id as token2022ProgramId, ata_program_id as ataProgramId, stake_pool_program_id as stakePoolProgramId, stake_account_space as stakeAccountSpace, nonce_account_space as nonceAccountSpace, sysvar_recent_blockhashes as sysvarRecentBlockhashes, get_associated_token_address as getAssociatedTokenAddress, find_withdraw_authority_program_address as findWithdrawAuthorityProgramAddress, } from "./wasm/wasm_solana.js";
 export type { AccountMeta, Instruction } from "./transaction.js";
-export type { TransactionInput, ParsedTransaction, DurableNonce as ParsedDurableNonce, InstructionParams, TransferParams, CreateAccountParams, NonceAdvanceParams, CreateNonceAccountParams, NonceInitializeParams, StakeInitializeParams, StakingActivateParams, StakingDeactivateParams, StakingWithdrawParams, StakingDelegateParams, StakingAuthorizeParams, SetComputeUnitLimitParams, SetPriorityFeeParams, TokenTransferParams, CreateAtaParams, CloseAtaParams, MemoParams, StakePoolDepositSolParams, StakePoolWithdrawStakeParams, UnknownInstructionParams, } from "./parser.js";
+export type { ParsedTransaction, DurableNonce as ParsedDurableNonce, InstructionParams, TransferParams, CreateAccountParams, NonceAdvanceParams, CreateNonceAccountParams, NonceInitializeParams, StakeInitializeParams, StakingActivateParams, StakingDeactivateParams, StakingWithdrawParams, StakingDelegateParams, StakingAuthorizeParams, SetComputeUnitLimitParams, SetPriorityFeeParams, TokenTransferParams, CreateAtaParams, CloseAtaParams, MemoParams, StakePoolDepositSolParams, StakePoolWithdrawStakeParams, UnknownInstructionParams, } from "./parser.js";
+export type { ExplainedTransaction, ExplainedOutput, ExplainedInput, ExplainOptions, TokenEnablement, StakingAuthorizeInfo, } from "./explain.js";
 export type { AddressLookupTable as BuilderAddressLookupTable, RawVersionedTransactionData, VersionedInstruction as BuilderVersionedInstruction, MessageHeader, } from "./builder.js";

package/dist/cjs/js/index.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findWithdrawAuthorityProgramAddress = exports.getAssociatedTokenAddress = exports.sysvarRecentBlockhashes = exports.nonceAccountSpace = exports.stakeAccountSpace = exports.stakePoolProgramId = exports.ataProgramId = exports.token2022ProgramId = exports.tokenProgramId = exports.memoProgramId = exports.computeBudgetProgramId = exports.stakeProgramId = exports.systemProgramId = exports.buildTransactionFromIntent = exports.buildFromIntent = exports.buildFromVersionedData = exports.parseTransaction = exports.isVersionedTransaction = exports.VersionedTransaction = exports.Transaction = exports.Pubkey = exports.Keypair = exports.builder = exports.parser = exports.transaction = exports.pubkey = exports.keypair = void 0;
+exports.findWithdrawAuthorityProgramAddress = exports.getAssociatedTokenAddress = exports.sysvarRecentBlockhashes = exports.nonceAccountSpace = exports.stakeAccountSpace = exports.stakePoolProgramId = exports.ataProgramId = exports.token2022ProgramId = exports.tokenProgramId = exports.memoProgramId = exports.computeBudgetProgramId = exports.stakeProgramId = exports.systemProgramId = exports.TransactionType = exports.explainTransaction = exports.buildTransactionFromIntent = exports.buildFromIntent = exports.buildFromVersionedData = exports.parseTransactionData = exports.isVersionedTransaction = exports.VersionedTransaction = exports.Transaction = exports.Pubkey = exports.Keypair = exports.explain = exports.builder = exports.parser = exports.transaction = exports.pubkey = exports.keypair = void 0;
+exports.parseTransaction = parseTransaction;
 const wasm = __importStar(require("./wasm/wasm_solana.js"));
 // Force webpack to include the WASM module
 void wasm;
@@ -43,6 +44,7 @@ exports.pubkey = __importStar(require("./pubkey.js"));
 exports.transaction = __importStar(require("./transaction.js"));
 exports.parser = __importStar(require("./parser.js"));
 exports.builder = __importStar(require("./builder.js"));
+exports.explain = __importStar(require("./explain.js"));
 // Top-level class exports for convenience
 var keypair_js_1 = require("./keypair.js");
 Object.defineProperty(exports, "Keypair", { enumerable: true, get: function () { return keypair_js_1.Keypair; } });
@@ -56,12 +58,52 @@ Object.defineProperty(exports, "VersionedTransaction", { enumerable: true, get:
 Object.defineProperty(exports, "isVersionedTransaction", { enumerable: true, get: function () { return versioned_js_1.isVersionedTransaction; } });
 // Top-level function exports
 var parser_js_1 = require("./parser.js");
-Object.defineProperty(exports, "parseTransaction", { enumerable: true, get: function () { return parser_js_1.parseTransaction; } });
+Object.defineProperty(exports, "parseTransactionData", { enumerable: true, get: function () { return parser_js_1.parseTransactionData; } });
 var builder_js_1 = require("./builder.js");
 Object.defineProperty(exports, "buildFromVersionedData", { enumerable: true, get: function () { return builder_js_1.buildFromVersionedData; } });
 var intentBuilder_js_1 = require("./intentBuilder.js");
 Object.defineProperty(exports, "buildFromIntent", { enumerable: true, get: function () { return intentBuilder_js_1.buildFromIntent; } });
 Object.defineProperty(exports, "buildTransactionFromIntent", { enumerable: true, get: function () { return intentBuilder_js_1.buildFromIntent; } });
+var explain_js_1 = require("./explain.js");
+Object.defineProperty(exports, "explainTransaction", { enumerable: true, get: function () { return explain_js_1.explainTransaction; } });
+Object.defineProperty(exports, "TransactionType", { enumerable: true, get: function () { return explain_js_1.TransactionType; } });
+// Re-export Transaction import for parseTransaction
+const transaction_js_2 = require("./transaction.js");
+/**
+ * Parse a Solana transaction from raw bytes.
+ *
+ * Returns a `Transaction` instance that can be both inspected and signed.
+ * Use `.parse()` on the returned Transaction to get decoded instruction data.
+ *
+ * This is the single entry point for working with transactions — like
+ * `BitGoPsbt.fromBytes()` in wasm-utxo.
+ *
+ * @param bytes - Raw transaction bytes
+ * @returns A Transaction that can be inspected (`.parse()`) and signed (`.addSignature()`)
+ *
+ * @example
+ * ```typescript
+ * import { parseTransaction } from '@bitgo/wasm-solana';
+ *
+ * const tx = parseTransaction(txBytes);
+ *
+ * // Inspect
+ * const parsed = tx.parse();
+ * console.log(parsed.feePayer);
+ * for (const instr of parsed.instructionsData) {
+ *   if (instr.type === 'Transfer') {
+ *     console.log(`${instr.amount} lamports to ${instr.toAddress}`);
+ *   }
+ * }
+ *
+ * // Sign
+ * tx.addSignature(pubkey, signature);
+ * const signedBytes = tx.toBytes();
+ * ```
+ */
+function parseTransaction(bytes) {
+    return transaction_js_2.Transaction.fromBytes(bytes);
+}
 // Program ID constants (from WASM)
 var wasm_solana_js_1 = require("./wasm/wasm_solana.js");
 Object.defineProperty(exports, "systemProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.system_program_id; } });

package/dist/cjs/js/keypair.d.ts

@@ -39,11 +39,6 @@ export declare class Keypair {
      * @returns The address as a base58 string
      */
     getAddress(): string;
-    /**
-     * Get the public key as a base58 string
-     * @returns The public key as a base58 string
-     */
-    toBase58(): string;
     /**
      * Sign a message with this keypair
      * @param message - The message bytes to sign

package/dist/cjs/js/keypair.js

@@ -59,13 +59,6 @@ class Keypair {
     getAddress() {
         return this._wasm.address();
     }
-    /**
-     * Get the public key as a base58 string
-     * @returns The public key as a base58 string
-     */
-    toBase58() {
-        return this._wasm.to_base58();
-    }
     /**
      * Sign a message with this keypair
      * @param message - The message bytes to sign

package/dist/cjs/js/parser.d.ts

@@ -5,14 +5,7 @@
  * matching BitGoJS's TxData format.
  *
  * All monetary amounts (amount, fee, lamports, poolTokens) are returned as bigint.
- * Accepts both raw bytes and Transaction objects for convenience.
  */
-import type { Transaction } from "./transaction.js";
-import type { VersionedTransaction } from "./versioned.js";
-/**
- * Input type for parseTransaction - accepts bytes or Transaction objects.
- */
-export type TransactionInput = Uint8Array | Transaction | VersionedTransaction;
 /** SOL transfer parameters */
 export interface TransferParams {
     type: "Transfer";
@@ -214,40 +207,13 @@ export interface ParsedTransaction {
     signatures: string[];
 }
 /**
- * Parse a Solana transaction into structured data.
- *
- * This is the main entry point for transaction parsing. It deserializes the
- * transaction and decodes all instructions into semantic types.
- *
- * All monetary amounts (amount, fee, lamports, poolTokens) are returned as bigint
- * directly from WASM - no post-processing needed.
+ * Parse raw transaction bytes into a plain data object with decoded instructions.
  *
- * Note: This returns the raw parsed data including NonceAdvance instructions.
- * Consumers (like BitGoJS) may choose to filter NonceAdvance from instructionsData
- * since that info is also available in durableNonce.
+ * This is the low-level parsing function. Most callers should use the top-level
+ * `parseTransaction(bytes)` which returns a `Transaction` instance with both
+ * inspection (`.parse()`) and signing (`.addSignature()`) capabilities.
  *
- * @param input - Raw transaction bytes, Transaction, or VersionedTransaction
+ * @param bytes - Raw transaction bytes
  * @returns A ParsedTransaction with all instructions decoded
- * @throws Error if the transaction cannot be parsed
- *
- * @example
- * ```typescript
- * import { parseTransaction, buildTransaction, Transaction } from '@bitgo/wasm-solana';
- *
- * // From bytes
- * const txBytes = Buffer.from(base64EncodedTx, 'base64');
- * const parsed = parseTransaction(txBytes);
- *
- * // Directly from a Transaction object (no roundtrip through bytes)
- * const tx = buildTransaction(intent);
- * const parsed = parseTransaction(tx);
- *
- * console.log(parsed.feePayer);
- * for (const instr of parsed.instructionsData) {
- *   if (instr.type === 'Transfer') {
- *     console.log(`Transfer ${instr.amount} from ${instr.fromAddress} to ${instr.toAddress}`);
- *   }
- * }
- * ```
  */
-export declare function parseTransaction(input: TransactionInput): ParsedTransaction;
+export declare function parseTransactionData(bytes: Uint8Array): ParsedTransaction;