refactor(wasm-solana): move instruction combining from Rust to TypeScript

- Remove combine_instructions function from Rust parser
- Add intermediate types (NonceInitialize, StakeInitialize) to TypeScript
- Raw instructions now returned from WASM, combining done by consumer
- This enables all combining logic to be in one place (TypeScript)

Author: lcovar

packages/wasm-solana/js/parser.ts

@@ -36,7 +36,7 @@ export interface NonceAdvanceParams {
   authWalletAddress: string;
 }
 
-/** Create nonce account parameters */
+/** Create nonce account parameters (combined type) */
 export interface CreateNonceAccountParams {
   type: "CreateNonceAccount";
   fromAddress: string;
@@ -45,7 +45,22 @@ export interface CreateNonceAccountParams {
   amount: string;
 }
 
-/** Staking activate parameters */
+/** 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;
@@ -186,11 +201,13 @@ export type InstructionParams =
   | CreateAccountParams
   | NonceAdvanceParams
   | CreateNonceAccountParams
+  | NonceInitializeParams
   | StakingActivateParams
   | StakingDeactivateParams
   | StakingWithdrawParams
   | StakingDelegateParams
   | StakingAuthorizeParams
+  | StakeInitializeParams
   | SetComputeUnitLimitParams
   | SetPriorityFeeParams
   | TokenTransferParams

packages/wasm-solana/src/parser.rs

@@ -3,15 +3,11 @@
 //! Provides a single `parse_transaction` function that deserializes transaction bytes
 //! and decodes all instructions into semantic types matching BitGoJS's TxData format.
 //!
-//! The parser performs post-processing to combine sequential instructions into
-//! compound types that match BitGoJS's semantic representation:
-//! - CreateAccount + NonceInitialize → CreateNonceAccount
-//! - CreateAccount + StakeInitialize + StakingDelegate → StakingActivate
-
-use crate::instructions::{
-    decode_instruction, CreateNonceAccountParams, InstructionContext, ParsedInstruction,
-    StakingActivateParams, STAKE_PROGRAM_ID, SYSTEM_PROGRAM_ID,
-};
+//! This parser returns raw decoded instructions. Instruction combining (e.g.,
+//! CreateAccount + NonceInitialize → CreateNonceAccount) is handled by the
+//! TypeScript consumer (mapWasmInstructionsToBitGoJS in BitGoJS).
+
+use crate::instructions::{decode_instruction, InstructionContext, ParsedInstruction};
 use crate::transaction::{Transaction, TransactionExt};
 use serde::Serialize;
 
@@ -126,8 +122,8 @@ pub fn parse_transaction(bytes: &[u8]) -> Result<ParsedTransaction, String> {
         instructions_data.push(parsed);
     }
 
-    // Post-process: combine sequential instructions into compound types
-    let instructions_data = combine_instructions(instructions_data);
+    // Note: Instruction combining (e.g., CreateAccount + StakeInitialize → StakingActivate)
+    // is handled by TypeScript in mapWasmInstructionsToBitGoJS for flexibility
 
     // The nonce is either the blockhash or, for durable nonce txs, still the blockhash
     // (which is the nonce value from the nonce account)
@@ -144,109 +140,6 @@ pub fn parse_transaction(bytes: &[u8]) -> Result<ParsedTransaction, String> {
     })
 }
 
-/// Combine sequential instructions into compound semantic types.
-///
-/// This matches BitGoJS's behavior where certain instruction sequences are
-/// represented as a single high-level instruction:
-/// - CreateAccount + NonceInitialize → CreateNonceAccount
-/// - CreateAccount + StakeInitialize + StakingDelegate → StakingActivate
-fn combine_instructions(instructions: Vec<ParsedInstruction>) -> Vec<ParsedInstruction> {
-    let mut result = Vec::with_capacity(instructions.len());
-    let mut i = 0;
-
-    while i < instructions.len() {
-        // Try to match CreateAccount patterns
-        if let ParsedInstruction::CreateAccount(ref create) = instructions[i] {
-            // Pattern 1: CreateAccount + NonceInitialize → CreateNonceAccount
-            if i + 1 < instructions.len() {
-                if let ParsedInstruction::NonceInitialize(ref nonce_init) = instructions[i + 1] {
-                    // Check if CreateAccount target matches NonceInitialize nonce address
-                    // and owner is System Program (nonce accounts owned by system program)
-                    if create.new_address == nonce_init.nonce_address
-                        && create.owner == SYSTEM_PROGRAM_ID
-                    {
-                        result.push(ParsedInstruction::CreateNonceAccount(
-                            CreateNonceAccountParams {
-                                from_address: create.from_address.clone(),
-                                nonce_address: nonce_init.nonce_address.clone(),
-                                auth_address: nonce_init.auth_address.clone(),
-                                amount: create.amount.clone(),
-                            },
-                        ));
-                        i += 2; // Skip both instructions
-                        continue;
-                    }
-                }
-            }
-
-            // Pattern 2: CreateAccount + StakeInitialize + StakingDelegate → StakingActivate (NATIVE)
-            // Must check this 3-instruction pattern BEFORE the 2-instruction Marinade pattern
-            if i + 2 < instructions.len() {
-                if let (
-                    ParsedInstruction::StakeInitialize(ref stake_init),
-                    ParsedInstruction::StakingDelegate(ref delegate),
-                ) = (&instructions[i + 1], &instructions[i + 2])
-                {
-                    // Check if CreateAccount target matches StakeInitialize staking address
-                    // and owner is Stake Program
-                    if create.new_address == stake_init.staking_address
-                        && create.owner == STAKE_PROGRAM_ID
-                        && stake_init.staking_address == delegate.staking_address
-                    {
-                        result.push(ParsedInstruction::StakingActivate(StakingActivateParams {
-                            from_address: create.from_address.clone(),
-                            staking_address: stake_init.staking_address.clone(),
-                            amount: create.amount.clone(),
-                            validator: delegate.validator.clone(),
-                            staking_type: "NATIVE".to_string(),
-                        }));
-                        i += 3; // Skip all three instructions
-                        continue;
-                    }
-                }
-            }
-
-            // Pattern 3: CreateAccount + StakeInitialize (without Delegate) → StakingActivate (MARINADE)
-            // Marinade staking creates a stake account but doesn't delegate to a validator
-            // The "validator" field stores the authorized staker address instead
-            if i + 1 < instructions.len() {
-                if let ParsedInstruction::StakeInitialize(ref stake_init) = instructions[i + 1] {
-                    // Check if CreateAccount target matches StakeInitialize staking address
-                    // and owner is Stake Program
-                    // Also make sure the next instruction (if any) is NOT a StakingDelegate
-                    let is_not_followed_by_delegate = i + 2 >= instructions.len()
-                        || !matches!(
-                            instructions[i + 2],
-                            ParsedInstruction::StakingDelegate(_)
-                        );
-
-                    if create.new_address == stake_init.staking_address
-                        && create.owner == STAKE_PROGRAM_ID
-                        && is_not_followed_by_delegate
-                    {
-                        result.push(ParsedInstruction::StakingActivate(StakingActivateParams {
-                            from_address: create.from_address.clone(),
-                            staking_address: stake_init.staking_address.clone(),
-                            amount: create.amount.clone(),
-                            // For Marinade, the validator field stores the authorized staker
-                            validator: stake_init.staker.clone(),
-                            staking_type: "MARINADE".to_string(),
-                        }));
-                        i += 2; // Skip both instructions
-                        continue;
-                    }
-                }
-            }
-        }
-
-        // No pattern matched, keep the instruction as-is
-        result.push(instructions[i].clone());
-        i += 1;
-    }
-
-    result
-}
-
 /// Serialize signatures as base64 strings for JSON output.
 mod signatures_serde {
     use base64::prelude::*;
@@ -312,6 +205,7 @@ mod tests {
     }
 
     // Marinade staking activate transaction (CreateAccount + StakeInitialize without Delegate)
+    // Note: Combining is now done in TypeScript, so we expect raw instructions here
     const MARINADE_STAKING_ACTIVATE: &str = "AuRFS0r7hJ+/+WuDQbbwdjSgxfnKOWi94EnWEha9uaBPt8VZOXiOoSiSoES34VkyBNLlLqlfK0fP3d5eJR+srQvN04gqzpOZPTVzqiomyMXqwQ6FYoQg5nEkdiDVny8SsyhRnAeDMzexkKD+3rwSGP0E+XN/2crTL6PZRnip42YFAgADBUXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBYnsvugEnYfm5Gbz5TLtMncgFHZ8JMpkxTTlJIzJovekAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxksXFEhjMlMPUrxf1ja7gibof1E49vZigAAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQICAgABNAAAAADgkwQAAAAAAMgAAAAAAAAABqHYF5E3VCqYNDe9/ip6slV/U1yKeHIraKSdwAAAAAADAgEEdAAAAACx+Xl4mhxH0TxI2HovJxcQ63+TJglRFzFikL1sKdr12UXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBAAAAAAAAAAAAAAAAAAAAAEXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItB";
 
     #[test]
@@ -322,17 +216,29 @@ mod tests {
         println!("Parsed instructions: {:?}", parsed.instructions_data);
         println!("Parsed JSON: {}", serde_json::to_string_pretty(&parsed).unwrap());
 
-        // Should combine CreateAccount + StakeInitialize into StakingActivate(MARINADE)
-        assert_eq!(parsed.instructions_data.len(), 1, "Expected 1 combined instruction");
+        // WASM returns raw instructions; combining is done in TypeScript
+        // Expect: CreateAccount + StakeInitialize (2 instructions)
+        assert_eq!(parsed.instructions_data.len(), 2, "Expected 2 raw instructions");
 
+        // First instruction: CreateAccount
         match &parsed.instructions_data[0] {
-            ParsedInstruction::StakingActivate(params) => {
-                assert_eq!(params.staking_type, "MARINADE");
+            ParsedInstruction::CreateAccount(params) => {
                 assert_eq!(params.from_address, "5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe");
-                assert_eq!(params.staking_address, "7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za");
+                assert_eq!(params.new_address, "7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za");
                 assert_eq!(params.amount, "300000");
             }
-            other => panic!("Expected StakingActivate(MARINADE) instruction, got {:?}", other),
+            other => panic!("Expected CreateAccount instruction, got {:?}", other),
+        }
+
+        // Second instruction: StakeInitialize
+        match &parsed.instructions_data[1] {
+            ParsedInstruction::StakeInitialize(params) => {
+                assert_eq!(params.staking_address, "7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za");
+                // The staker is the authorized staker for Marinade
+                assert_eq!(params.staker, "CyjoLt3kjqB57K7ewCBHmnHq3UgEj3ak6A7m6EsBsuhA");
+                assert_eq!(params.withdrawer, "5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe");
+            }
+            other => panic!("Expected StakeInitialize instruction, got {:?}", other),
         }
     }
 }