feat(wasm-solana): add transaction deserialization

Add WASM bindings for Solana transaction parsing and inspection:
- Transaction.fromBase64() / fromBytes() for deserialization
- Access to fee payer, recent blockhash, account keys
- Instruction decoding with programId, accounts, and data
- AccountMeta with isSigner/isWritable flags
- Signature access by index (base58 or bytes)
- Signable payload extraction for verification

Uses official Solana crates exclusively:
- solana-transaction for Transaction type and bincode serialization
- solana-message is_signer()/is_maybe_writable() for account flags
- solana-keypair Keypair::new_from_array() for 32-byte seed support

Removed ed25519-dalek dependency (-44KB WASM, -36KB gzipped).

Replaces @solana/web3.js Transaction.from() in BitGoJS.

Ticket: BTC-2929

Author: lcovar

packages/wasm-solana/Cargo.lock

@@ -16,8 +16,10 @@ js-sys = "0.3"
 solana-pubkey = { version = "2.0", features = ["curve25519"] }
 solana-keypair = "2.0"
 solana-signer = "2.0"
-# Ed25519 for deriving pubkey from 32-byte seed (solana-keypair expects 64-byte format)
-ed25519-dalek = { version = "2.1", default-features = false, features = ["std"] }
+solana-transaction = { version = "3.0", features = ["serde", "bincode"] }
+# Serialization for transaction deserialization
+bincode = "1.3"
+base64 = "0.22"
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3"

packages/wasm-solana/Cargo.toml

@@ -6,7 +6,12 @@ void wasm;
 // Namespace exports for explicit imports
 export * as keypair from "./keypair.js";
 export * as pubkey from "./pubkey.js";
+export * as transaction from "./transaction.js";
 
 // Top-level class exports for convenience
 export { Keypair } from "./keypair.js";
 export { Pubkey } from "./pubkey.js";
+export { Transaction } from "./transaction.js";
+
+// Type exports
+export type { AccountMeta, Instruction } from "./transaction.js";

packages/wasm-solana/js/index.ts

@@ -0,0 +1,163 @@
+import { WasmTransaction } from "./wasm/wasm_solana.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 deserialization and inspection
+ *
+ * This class wraps a deserialized Solana transaction and provides
+ * accessors for its components (instructions, signatures, etc.).
+ */
+export class Transaction {
+  private constructor(private _wasm: WasmTransaction) {}
+
+  /**
+   * Deserialize a transaction from a base64-encoded string
+   * This is the format used by @solana/web3.js Transaction.serialize()
+   * @param base64 - The base64-encoded transaction
+   * @returns A Transaction instance
+   */
+  static fromBase64(base64: string): Transaction {
+    const wasm = WasmTransaction.from_base64(base64);
+    return new Transaction(wasm);
+  }
+
+  /**
+   * Deserialize a transaction from raw bytes
+   * @param bytes - The raw transaction bytes
+   * @returns A Transaction instance
+   */
+  static fromBytes(bytes: Uint8Array): Transaction {
+    const wasm = WasmTransaction.from_bytes(bytes);
+    return new Transaction(wasm);
+  }
+
+  /**
+   * 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 {
+    return this._wasm.fee_payer ?? null;
+  }
+
+  /**
+   * Get the recent blockhash as a base58 string
+   */
+  get recentBlockhash(): string {
+    return this._wasm.recent_blockhash;
+  }
+
+  /**
+   * Get the number of instructions in the transaction
+   */
+  get numInstructions(): number {
+    return this._wasm.num_instructions;
+  }
+
+  /**
+   * Get the number of signatures in the transaction
+   */
+  get numSignatures(): number {
+    return this._wasm.num_signatures;
+  }
+
+  /**
+   * Get the signable message payload (what gets signed)
+   * This is the serialized message that signers sign
+   * @returns The message bytes
+   */
+  signablePayload(): Uint8Array {
+    return this._wasm.signable_payload();
+  }
+
+  /**
+   * Serialize the transaction to bytes
+   * @returns The serialized transaction bytes
+   */
+  toBytes(): Uint8Array {
+    return this._wasm.to_bytes();
+  }
+
+  /**
+   * Serialize the transaction to base64
+   * @returns The base64-encoded transaction
+   */
+  toBase64(): string {
+    return this._wasm.to_base64();
+  }
+
+  /**
+   * Get all account keys as an array of base58 strings
+   * @returns Array of account public keys
+   */
+  accountKeys(): string[] {
+    return Array.from(this._wasm.account_keys()) as string[];
+  }
+
+  /**
+   * Get a signature at the given index as a base58 string
+   * @param index - The signature index
+   * @returns The signature as a base58 string, or null if index is out of bounds
+   */
+  signatureAt(index: number): string | null {
+    return this._wasm.signature_at(index) ?? null;
+  }
+
+  /**
+   * Get a signature at the given index as bytes
+   * @param index - The signature index
+   * @returns The signature bytes, or null if index is out of bounds
+   */
+  signatureBytesAt(index: number): Uint8Array | null {
+    return this._wasm.signature_bytes_at(index) ?? null;
+  }
+
+  /**
+   * Get all instructions in the transaction
+   * @returns Array of instructions with programId, accounts, and data
+   */
+  instructions(): Instruction[] {
+    const rawInstructions = this._wasm.instructions();
+    return Array.from(rawInstructions) as Instruction[];
+  }
+
+  /**
+   * Get an instruction at the given index
+   * @param index - The instruction index
+   * @returns The instruction, or null if index is out of bounds
+   */
+  instructionAt(index: number): Instruction | null {
+    const instr = this._wasm.instruction_at(index);
+    return (instr as Instruction) ?? null;
+  }
+
+  /**
+   * Get the underlying WASM instance (internal use only)
+   * @internal
+   */
+  get wasm(): WasmTransaction {
+    return this._wasm;
+  }
+}

packages/wasm-solana/js/transaction.ts

@@ -20,27 +20,15 @@ pub trait KeypairExt {
 impl KeypairExt for Keypair {
     /// Create a keypair from a 32-byte secret key (Ed25519 seed).
     fn from_secret_key_bytes(secret_key: &[u8]) -> Result<Keypair, WasmSolanaError> {
-        if secret_key.len() != 32 {
-            return Err(WasmSolanaError::new(&format!(
+        let bytes: [u8; 32] = secret_key.try_into().map_err(|_| {
+            WasmSolanaError::new(&format!(
                 "Secret key must be 32 bytes, got {}",
                 secret_key.len()
-            )));
-        }
+            ))
+        })?;
 
-        // Generate public key from secret to create full 64-byte format
-        use ed25519_dalek::SigningKey;
-        let bytes: [u8; 32] = secret_key
-            .try_into()
-            .map_err(|_| WasmSolanaError::new("Failed to convert secret key to array"))?;
-        let signing_key = SigningKey::from_bytes(&bytes);
-        let pubkey_bytes = signing_key.verifying_key().to_bytes();
-
-        let mut full_secret = [0u8; 64];
-        full_secret[..32].copy_from_slice(secret_key);
-        full_secret[32..].copy_from_slice(&pubkey_bytes);
-
-        Keypair::try_from(full_secret.as_slice())
-            .map_err(|e| WasmSolanaError::new(&format!("Invalid keypair: {}", e)))
+        // Use official solana-keypair method that handles 32-byte seeds
+        Ok(Keypair::new_from_array(bytes))
     }
 
     /// Create a keypair from a 64-byte Solana secret key (secret + public concatenated).

packages/wasm-solana/src/keypair.rs

@@ -26,12 +26,14 @@
 mod error;
 pub mod keypair;
 pub mod pubkey;
+pub mod transaction;
 pub mod wasm;
 
 // Re-export core types at crate root
 pub use error::WasmSolanaError;
 pub use keypair::{Keypair, KeypairExt};
 pub use pubkey::{Pubkey, PubkeyExt};
+pub use transaction::{Transaction, TransactionExt};
 
 // Re-export WASM types
-pub use wasm::{WasmKeypair, WasmPubkey};
+pub use wasm::{WasmKeypair, WasmPubkey, WasmTransaction};