@bitgo/wasm-solana 1.4.1 → 1.4.2

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

@@ -0,0 +1,47 @@
+import { WasmKeypair } from "./wasm/wasm_solana.js";
+/**
+ * Solana Ed25519 Keypair for address generation and signing
+ *
+ * A keypair consists of a 32-byte secret key and a 32-byte public key.
+ * The public key (base58-encoded) is the Solana address.
+ */
+export declare class Keypair {
+    private _wasm;
+    private constructor();
+    /**
+     * Create a keypair from a 32-byte secret key
+     * @param secretKey - The 32-byte Ed25519 secret key
+     * @returns A Keypair instance
+     */
+    static fromSecretKey(secretKey: Uint8Array): Keypair;
+    /**
+     * Create a keypair from a 64-byte Solana secret key (secret + public concatenated)
+     * This is the format used by @solana/web3.js Keypair.fromSecretKey()
+     * @param secretKey - The 64-byte Solana secret key
+     * @returns A Keypair instance
+     */
+    static fromSolanaSecretKey(secretKey: Uint8Array): Keypair;
+    /**
+     * Get the public key as a 32-byte Uint8Array
+     */
+    get publicKey(): Uint8Array;
+    /**
+     * Get the secret key as a 32-byte Uint8Array
+     */
+    get secretKey(): Uint8Array;
+    /**
+     * Get the Solana address (base58-encoded public key)
+     * @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;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmKeypair;
+}

package/dist/esm/js/keypair.js

@@ -0,0 +1,65 @@
+import { WasmKeypair } from "./wasm/wasm_solana.js";
+/**
+ * Solana Ed25519 Keypair for address generation and signing
+ *
+ * A keypair consists of a 32-byte secret key and a 32-byte public key.
+ * The public key (base58-encoded) is the Solana address.
+ */
+export class Keypair {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create a keypair from a 32-byte secret key
+     * @param secretKey - The 32-byte Ed25519 secret key
+     * @returns A Keypair instance
+     */
+    static fromSecretKey(secretKey) {
+        const wasm = WasmKeypair.from_secret_key(secretKey);
+        return new Keypair(wasm);
+    }
+    /**
+     * Create a keypair from a 64-byte Solana secret key (secret + public concatenated)
+     * This is the format used by @solana/web3.js Keypair.fromSecretKey()
+     * @param secretKey - The 64-byte Solana secret key
+     * @returns A Keypair instance
+     */
+    static fromSolanaSecretKey(secretKey) {
+        const wasm = WasmKeypair.from_solana_secret_key(secretKey);
+        return new Keypair(wasm);
+    }
+    /**
+     * Get the public key as a 32-byte Uint8Array
+     */
+    get publicKey() {
+        return this._wasm.public_key;
+    }
+    /**
+     * Get the secret key as a 32-byte Uint8Array
+     */
+    get secretKey() {
+        return this._wasm.secret_key;
+    }
+    /**
+     * Get the Solana address (base58-encoded public key)
+     * @returns The address as a base58 string
+     */
+    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();
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}

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

@@ -0,0 +1,253 @@
+/**
+ * High-level transaction parsing.
+ *
+ * Provides types and functions for parsing Solana transactions into semantic data
+ * 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";
+    fromAddress: string;
+    toAddress: string;
+    amount: bigint;
+}
+/** Create account parameters */
+export interface CreateAccountParams {
+    type: "CreateAccount";
+    fromAddress: string;
+    newAddress: string;
+    amount: bigint;
+    space: number;
+    owner: string;
+}
+/** Nonce advance parameters */
+export interface NonceAdvanceParams {
+    type: "NonceAdvance";
+    walletNonceAddress: string;
+    authWalletAddress: string;
+}
+/** Create nonce account parameters (combined type) */
+export interface CreateNonceAccountParams {
+    type: "CreateNonceAccount";
+    fromAddress: string;
+    nonceAddress: string;
+    authAddress: string;
+    amount: bigint;
+}
+/** Nonce initialize parameters (intermediate - combined into CreateNonceAccount) */
+export interface NonceInitializeParams {
+    type: "NonceInitialize";
+    nonceAddress: string;
+    authAddress: string;
+}
+/** Stake initialize parameters (intermediate - combined into StakingActivate) */
+export interface StakeInitializeParams {
+    type: "StakeInitialize";
+    stakingAddress: string;
+    staker: string;
+    withdrawer: string;
+}
+/** Staking activate parameters (combined type) */
+export interface StakingActivateParams {
+    type: "StakingActivate";
+    fromAddress: string;
+    stakingAddress: string;
+    amount: bigint;
+    validator: string;
+    stakingType: "NATIVE" | "JITO" | "MARINADE";
+}
+/** Staking deactivate parameters */
+export interface StakingDeactivateParams {
+    type: "StakingDeactivate";
+    stakingAddress: string;
+    fromAddress: string;
+}
+/** Staking withdraw parameters */
+export interface StakingWithdrawParams {
+    type: "StakingWithdraw";
+    fromAddress: string;
+    stakingAddress: string;
+    amount: bigint;
+}
+/** Staking delegate parameters */
+export interface StakingDelegateParams {
+    type: "StakingDelegate";
+    stakingAddress: string;
+    fromAddress: string;
+    validator: string;
+}
+/** Staking authorize parameters */
+export interface StakingAuthorizeParams {
+    type: "StakingAuthorize";
+    stakingAddress: string;
+    oldAuthorizeAddress: string;
+    newAuthorizeAddress: string;
+    authorizeType: "Staker" | "Withdrawer";
+    custodianAddress?: string;
+}
+/** Stake initialize parameters (intermediate type) */
+export interface StakeInitializeParams {
+    type: "StakeInitialize";
+    stakingAddress: string;
+    staker: string;
+    withdrawer: string;
+}
+/** Set compute unit limit parameters */
+export interface SetComputeUnitLimitParams {
+    type: "SetComputeUnitLimit";
+    units: number;
+}
+/** Set priority fee parameters */
+export interface SetPriorityFeeParams {
+    type: "SetPriorityFee";
+    fee: bigint;
+}
+/** Token transfer parameters */
+export interface TokenTransferParams {
+    type: "TokenTransfer";
+    fromAddress: string;
+    toAddress: string;
+    amount: bigint;
+    sourceAddress: string;
+    tokenAddress?: string;
+    programId: string;
+    decimalPlaces?: number;
+}
+/** Create associated token account parameters */
+export interface CreateAtaParams {
+    type: "CreateAssociatedTokenAccount";
+    mintAddress: string;
+    ataAddress: string;
+    ownerAddress: string;
+    payerAddress: string;
+    programId: string;
+}
+/** Close associated token account parameters */
+export interface CloseAtaParams {
+    type: "CloseAssociatedTokenAccount";
+    accountAddress: string;
+    destinationAddress: string;
+    authorityAddress: string;
+}
+/** Memo parameters */
+export interface MemoParams {
+    type: "Memo";
+    memo: string;
+}
+/** Stake pool deposit SOL parameters (Jito liquid staking) */
+export interface StakePoolDepositSolParams {
+    type: "StakePoolDepositSol";
+    stakePool: string;
+    withdrawAuthority: string;
+    reserveStake: string;
+    fundingAccount: string;
+    destinationPoolAccount: string;
+    managerFeeAccount: string;
+    referralPoolAccount: string;
+    poolMint: string;
+    lamports: bigint;
+}
+/** Stake pool withdraw stake parameters (Jito liquid staking) */
+export interface StakePoolWithdrawStakeParams {
+    type: "StakePoolWithdrawStake";
+    stakePool: string;
+    validatorList: string;
+    withdrawAuthority: string;
+    validatorStake: string;
+    destinationStake: string;
+    destinationStakeAuthority: string;
+    sourceTransferAuthority: string;
+    sourcePoolAccount: string;
+    managerFeeAccount: string;
+    poolMint: string;
+    poolTokens: bigint;
+}
+/** Account metadata for unknown instructions */
+export interface AccountMeta {
+    pubkey: string;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+/** Unknown instruction parameters */
+export interface UnknownInstructionParams {
+    type: "Unknown";
+    programId: string;
+    accounts: AccountMeta[];
+    data: string;
+}
+/** Union of all instruction parameter types */
+export type InstructionParams = TransferParams | CreateAccountParams | NonceAdvanceParams | CreateNonceAccountParams | NonceInitializeParams | StakingActivateParams | StakingDeactivateParams | StakingWithdrawParams | StakingDelegateParams | StakingAuthorizeParams | StakeInitializeParams | SetComputeUnitLimitParams | SetPriorityFeeParams | TokenTransferParams | CreateAtaParams | CloseAtaParams | MemoParams | StakePoolDepositSolParams | StakePoolWithdrawStakeParams | UnknownInstructionParams;
+/** Durable nonce information */
+export interface DurableNonce {
+    walletNonceAddress: string;
+    authWalletAddress: string;
+}
+/**
+ * A fully parsed Solana transaction with decoded instructions.
+ *
+ * This structure matches BitGoJS's TxData interface for seamless integration.
+ * All monetary amounts are returned as bigint directly from WASM.
+ */
+export interface ParsedTransaction {
+    /** The fee payer address (base58) */
+    feePayer: string;
+    /** Number of required signatures */
+    numSignatures: number;
+    /** The blockhash or nonce value (base58) */
+    nonce: string;
+    /** If this is a durable nonce transaction, contains the nonce info */
+    durableNonce?: DurableNonce;
+    /** All decoded instructions with semantic types */
+    instructionsData: InstructionParams[];
+    /** All account keys (base58 strings) */
+    accountKeys: string[];
+    /** All signatures (base58 strings). Non-empty signatures indicate signed transaction. */
+    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.
+ *
+ * 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.
+ *
+ * @param input - Raw transaction bytes, Transaction, or VersionedTransaction
+ * @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;

package/dist/esm/js/parser.js

@@ -0,0 +1,55 @@
+/**
+ * High-level transaction parsing.
+ *
+ * Provides types and functions for parsing Solana transactions into semantic data
+ * 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 { ParserNamespace } from "./wasm/wasm_solana.js";
+// =============================================================================
+// parseTransaction function
+// =============================================================================
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * @param input - Raw transaction bytes, Transaction, or VersionedTransaction
+ * @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 function parseTransaction(input) {
+    // If input is a Transaction or VersionedTransaction, extract bytes
+    const bytes = input instanceof Uint8Array ? input : input.toBytes();
+    return ParserNamespace.parse_transaction(bytes);
+}

package/dist/esm/js/pubkey.d.ts

@@ -0,0 +1,54 @@
+import { WasmPubkey } from "./wasm/wasm_solana.js";
+/**
+ * Solana public key (address)
+ *
+ * A Solana address is a 32-byte Ed25519 public key, typically represented as a base58 string.
+ */
+export declare class Pubkey {
+    private _wasm;
+    private constructor();
+    /**
+     * Create a Pubkey from a base58 string
+     * @param address - The base58-encoded address
+     * @returns A Pubkey instance
+     */
+    static fromBase58(address: string): Pubkey;
+    /**
+     * Create a Pubkey from raw bytes (32 bytes)
+     * @param bytes - The 32-byte public key
+     * @returns A Pubkey instance
+     */
+    static fromBytes(bytes: Uint8Array): Pubkey;
+    /**
+     * Convert to base58 string (the standard Solana address format)
+     * @returns The address as a base58 string
+     */
+    toBase58(): string;
+    /**
+     * Get as raw bytes (32 bytes)
+     * @returns The public key as a Uint8Array
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Check if two pubkeys are equal
+     * @param other - The other Pubkey to compare
+     * @returns true if the pubkeys are equal
+     */
+    equals(other: Pubkey): boolean;
+    /**
+     * Check if this public key is on the Ed25519 curve.
+     *
+     * Regular Solana keypair addresses are on the curve, while Program Derived Addresses (PDAs)
+     * are intentionally off the curve to ensure they can only be signed by programs.
+     *
+     * This is equivalent to `@solana/web3.js` `PublicKey.isOnCurve()`.
+     *
+     * @returns true if the public key is on the Ed25519 curve
+     */
+    isOnCurve(): boolean;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmPubkey;
+}

package/dist/esm/js/pubkey.js

@@ -0,0 +1,72 @@
+import { WasmPubkey } from "./wasm/wasm_solana.js";
+/**
+ * Solana public key (address)
+ *
+ * A Solana address is a 32-byte Ed25519 public key, typically represented as a base58 string.
+ */
+export class Pubkey {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create a Pubkey from a base58 string
+     * @param address - The base58-encoded address
+     * @returns A Pubkey instance
+     */
+    static fromBase58(address) {
+        const wasm = WasmPubkey.from_base58(address);
+        return new Pubkey(wasm);
+    }
+    /**
+     * Create a Pubkey from raw bytes (32 bytes)
+     * @param bytes - The 32-byte public key
+     * @returns A Pubkey instance
+     */
+    static fromBytes(bytes) {
+        const wasm = WasmPubkey.from_bytes(bytes);
+        return new Pubkey(wasm);
+    }
+    /**
+     * Convert to base58 string (the standard Solana address format)
+     * @returns The address as a base58 string
+     */
+    toBase58() {
+        return this._wasm.to_base58();
+    }
+    /**
+     * Get as raw bytes (32 bytes)
+     * @returns The public key as a Uint8Array
+     */
+    toBytes() {
+        return this._wasm.to_bytes();
+    }
+    /**
+     * Check if two pubkeys are equal
+     * @param other - The other Pubkey to compare
+     * @returns true if the pubkeys are equal
+     */
+    equals(other) {
+        return this._wasm.equals(other._wasm);
+    }
+    /**
+     * Check if this public key is on the Ed25519 curve.
+     *
+     * Regular Solana keypair addresses are on the curve, while Program Derived Addresses (PDAs)
+     * are intentionally off the curve to ensure they can only be signed by programs.
+     *
+     * This is equivalent to `@solana/web3.js` `PublicKey.isOnCurve()`.
+     *
+     * @returns true if the public key is on the Ed25519 curve
+     */
+    isOnCurve() {
+        return this._wasm.is_on_curve();
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}

package/dist/esm/js/transaction.d.ts

@@ -0,0 +1,156 @@
+import { WasmTransaction } from "./wasm/wasm_solana.js";
+import { Pubkey } from "./pubkey.js";
+/**
+ * Account metadata for an instruction
+ */
+export interface AccountMeta {
+    /** The account public key as a base58 string */
+    pubkey: string;
+    /** Whether this account is a signer */
+    isSigner: boolean;
+    /** Whether this account is writable */
+    isWritable: boolean;
+}
+/**
+ * A decoded Solana instruction
+ */
+export interface Instruction {
+    /** The program ID (base58 string) that will execute this instruction */
+    programId: string;
+    /** The accounts required by this instruction */
+    accounts: AccountMeta[];
+    /** The instruction data */
+    data: Uint8Array;
+}
+/**
+ * Solana Transaction wrapper for low-level deserialization and inspection.
+ *
+ * This class provides low-level access to transaction structure.
+ * For high-level semantic parsing with decoded instructions, use `parseTransaction()` instead.
+ *
+ * @example
+ * ```typescript
+ * import { Transaction, parseTransaction } from '@bitgo/wasm-solana';
+ *
+ * // Low-level access:
+ * const tx = Transaction.fromBytes(txBytes);
+ * console.log(tx.feePayer);
+ *
+ * // High-level parsing (preferred):
+ * const parsed = parseTransaction(txBytes);
+ * console.log(parsed.instructionsData); // Decoded instruction types
+ * ```
+ */
+export declare class Transaction {
+    private _wasm;
+    private constructor();
+    /**
+     * Deserialize a transaction from raw bytes
+     * @param bytes - The raw transaction bytes
+     * @returns A Transaction instance
+     */
+    static fromBytes(bytes: Uint8Array): Transaction;
+    /**
+     * Create a Transaction from a WasmTransaction instance.
+     * @internal Used by builder functions
+     */
+    static fromWasm(wasm: WasmTransaction): Transaction;
+    /**
+     * Get the fee payer address as a base58 string
+     * Returns null if there are no account keys (shouldn't happen for valid transactions)
+     */
+    get feePayer(): string | null;
+    /**
+     * Get the recent blockhash as a base58 string
+     */
+    get recentBlockhash(): string;
+    /**
+     * Get the number of signatures in the transaction
+     */
+    get numSignatures(): number;
+    /**
+     * Get the signable message payload (what gets signed)
+     * This is the serialized message that signers sign
+     * @returns The message bytes
+     */
+    signablePayload(): Uint8Array;
+    /**
+     * Serialize the message portion of the transaction.
+     * Alias for signablePayload() - provides compatibility with @solana/web3.js API.
+     * Returns a Buffer for compatibility with code expecting .toString('base64').
+     * @returns The serialized message bytes as a Buffer
+     */
+    serializeMessage(): Buffer;
+    /**
+     * Serialize the transaction to bytes
+     * @returns The serialized transaction bytes
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Get all account keys as Pubkey instances
+     * @returns Array of account public keys
+     */
+    accountKeys(): Pubkey[];
+    /**
+     * Get all signatures as byte arrays.
+     * Provides compatibility with @solana/web3.js Transaction.signatures API.
+     * @returns Array of signature byte arrays
+     */
+    get signatures(): Uint8Array[];
+    /**
+     * Get all signatures as byte arrays (method form).
+     * Alias for the `signatures` property getter.
+     * @returns Array of signature byte arrays
+     */
+    getSignatures(): Uint8Array[];
+    /**
+     * Get all instructions in the transaction.
+     * Returns an array with programId, accounts, and data for each instruction.
+     *
+     * Note: This is a getter property to provide compatibility with code
+     * expecting @solana/web3.js Transaction.instructions API. If you need
+     * to call this as a method, use `getInstructions()` instead.
+     */
+    get instructions(): Instruction[];
+    /**
+     * Get all instructions in the transaction (method form).
+     * Alias for the `instructions` property getter.
+     * @returns Array of instructions with programId, accounts, and data
+     */
+    getInstructions(): Instruction[];
+    /**
+     * Add a signature for a given public key.
+     *
+     * The pubkey must be one of the required signers in the transaction.
+     * The signature must be exactly 64 bytes (Ed25519 signature).
+     *
+     * @param pubkey - The public key as a base58 string
+     * @param signature - The 64-byte signature as Uint8Array
+     * @throws Error if pubkey is not a signer or signature is invalid
+     *
+     * @example
+     * ```typescript
+     * // Add a pre-computed signature (e.g., from TSS)
+     * tx.addSignature(signerPubkey, signatureBytes);
+     *
+     * // Serialize and broadcast
+     * const signedTxBytes = tx.toBytes();
+     * ```
+     */
+    addSignature(pubkey: string, signature: Uint8Array): void;
+    /**
+     * Get the signer index for a public key.
+     *
+     * Returns the index in the signatures array where this pubkey's
+     * signature should be placed, or null if the pubkey is not a signer.
+     *
+     * @param pubkey - The public key as a base58 string
+     * @returns The signer index, or null if not a signer
+     */
+    signerIndex(pubkey: string): number | null;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmTransaction;
+}