feat(wasm-utxo): add multi-stage PSBT fixture loading helpers

Introduces PsbtStages and PsbtInputStages types to simplify testing across
different signing stages (unsigned, halfsigned, fullsigned). Refactors test
helpers to use these new types for more structured testing.

Issue: BTC-2652

Co-authored-by: llm-git <[email protected]>

Author: OttoAllmendinger

packages/wasm-utxo/src/bitgo_psbt/mod.rs

@@ -238,7 +238,6 @@ mod tests {
     use crate::fixed_script_wallet::{RootWalletKeys, WalletScripts};
     use crate::test_utils::fixtures;
     use base64::engine::{general_purpose::STANDARD as BASE64_STANDARD, Engine};
-    use miniscript::bitcoin::bip32::Xpub;
     use miniscript::bitcoin::consensus::Decodable;
     use miniscript::bitcoin::Transaction;
 
@@ -386,7 +385,7 @@ mod tests {
         output.script_pubkey.to_hex_string()
     }
 
-    fn assert_matches_wallet_scripts(
+    fn assert_full_signed_matches_wallet_scripts(
         network: Network,
         tx_format: fixtures::TxFormat,
         fixture: &fixtures::PsbtFixture,
@@ -497,50 +496,35 @@ mod tests {
         network: Network,
         tx_format: fixtures::TxFormat,
     ) -> Result<(), String> {
-        let fixture = fixtures::load_psbt_fixture_with_format(
-            network.to_utxolib_name(),
-            fixtures::SignatureState::Fullsigned,
-            tx_format,
-        )
-        .expect("Failed to load fixture");
-        let wallet_keys =
-            fixtures::parse_wallet_keys(&fixture).expect("Failed to parse wallet keys");
-        let secp = crate::bitcoin::secp256k1::Secp256k1::new();
-        let wallet_keys = RootWalletKeys::new(
-            wallet_keys
-                .iter()
-                .map(|x| Xpub::from_priv(&secp, x))
-                .collect::<Vec<_>>()
-                .try_into()
-                .expect("Failed to convert to XpubTriple"),
-        );
+        let psbt_stages = fixtures::PsbtStages::load(network, tx_format)?;
+        let psbt_input_stages =
+            fixtures::PsbtInputStages::from_psbt_stages(&psbt_stages, script_type);
 
         // Check if the script type is supported by the network
         let output_script_support = network.output_script_support();
-        let input_fixture = fixture.find_input_with_script_type(script_type);
         if !script_type.is_supported_by(&output_script_support) {
             // Script type not supported by network - skip test (no fixture expected)
             assert!(
-                input_fixture.is_err(),
+                psbt_input_stages.is_err(),
                 "Expected error for unsupported script type"
             );
             return Ok(());
         }
 
-        let (input_index, input_fixture) = input_fixture.unwrap();
+        let psbt_input_stages = psbt_input_stages.unwrap();
 
-        assert_matches_wallet_scripts(
+        assert_full_signed_matches_wallet_scripts(
             network,
             tx_format,
-            &fixture,
-            &wallet_keys,
-            input_index,
-            input_fixture,
+            &psbt_stages.fullsigned,
+            &psbt_input_stages.wallet_keys,
+            psbt_input_stages.input_index,
+            &psbt_input_stages.input_fixture_fullsigned,
         )?;
 
         assert_finalize_input(
-            fixture.to_bitgo_psbt(network).unwrap(),
-            input_index,
+            psbt_stages.fullsigned.to_bitgo_psbt(network).unwrap(),
+            psbt_input_stages.input_index,
             network,
             tx_format,
         )?;

packages/wasm-utxo/src/fixed_script_wallet/test_utils/fixtures.rs

@@ -480,6 +480,106 @@ pub struct PsbtFixture {
     pub extracted_transaction: Option<String>,
 }
 
+// Test helper types for multi-stage PSBT testing
+
+pub struct PsbtStages {
+    pub network: Network,
+    pub tx_format: TxFormat,
+    pub wallet_keys: crate::fixed_script_wallet::RootWalletKeys,
+    pub unsigned: PsbtFixture,
+    pub halfsigned: PsbtFixture,
+    pub fullsigned: PsbtFixture,
+}
+
+impl PsbtStages {
+    pub fn load(network: Network, tx_format: TxFormat) -> Result<Self, String> {
+        let unsigned = load_psbt_fixture_with_format(
+            network.to_utxolib_name(),
+            SignatureState::Unsigned,
+            tx_format,
+        )
+        .expect("Failed to load unsigned fixture");
+        let halfsigned = load_psbt_fixture_with_format(
+            network.to_utxolib_name(),
+            SignatureState::Halfsigned,
+            tx_format,
+        )
+        .expect("Failed to load halfsigned fixture");
+        let fullsigned = load_psbt_fixture_with_format(
+            network.to_utxolib_name(),
+            SignatureState::Fullsigned,
+            tx_format,
+        )
+        .expect("Failed to load fullsigned fixture");
+        let wallet_keys_unsigned =
+            parse_wallet_keys(&unsigned).expect("Failed to parse wallet keys");
+        let wallet_keys_halfsigned =
+            parse_wallet_keys(&halfsigned).expect("Failed to parse wallet keys");
+        let wallet_keys_fullsigned =
+            parse_wallet_keys(&fullsigned).expect("Failed to parse wallet keys");
+        assert_eq!(wallet_keys_unsigned, wallet_keys_halfsigned);
+        assert_eq!(wallet_keys_unsigned, wallet_keys_fullsigned);
+        let secp = crate::bitcoin::secp256k1::Secp256k1::new();
+        let wallet_keys = crate::fixed_script_wallet::RootWalletKeys::new(
+            wallet_keys_unsigned
+                .iter()
+                .map(|x| crate::bitcoin::bip32::Xpub::from_priv(&secp, x))
+                .collect::<Vec<_>>()
+                .try_into()
+                .expect("Failed to convert to XpubTriple"),
+        );
+
+        Ok(Self {
+            network,
+            tx_format,
+            wallet_keys,
+            unsigned,
+            halfsigned,
+            fullsigned,
+        })
+    }
+}
+
+pub struct PsbtInputStages {
+    pub network: Network,
+    pub tx_format: TxFormat,
+    pub wallet_keys: crate::fixed_script_wallet::RootWalletKeys,
+    pub wallet_script_type: ScriptType,
+    pub input_index: usize,
+    pub input_fixture_unsigned: PsbtInputFixture,
+    pub input_fixture_halfsigned: PsbtInputFixture,
+    pub input_fixture_fullsigned: PsbtInputFixture,
+}
+
+impl PsbtInputStages {
+    pub fn from_psbt_stages(
+        psbt_stages: &PsbtStages,
+        wallet_script_type: ScriptType,
+    ) -> Result<Self, String> {
+        let input_fixture_unsigned = psbt_stages
+            .unsigned
+            .find_input_with_script_type(wallet_script_type)?;
+        let input_fixture_halfsigned = psbt_stages
+            .halfsigned
+            .find_input_with_script_type(wallet_script_type)?;
+        let input_fixture_fullsigned = psbt_stages
+            .fullsigned
+            .find_input_with_script_type(wallet_script_type)?;
+        assert_eq!(input_fixture_unsigned.0, input_fixture_halfsigned.0);
+        assert_eq!(input_fixture_unsigned.0, input_fixture_fullsigned.0);
+        Ok(Self {
+            network: psbt_stages.network,
+            tx_format: psbt_stages.tx_format,
+            wallet_keys: psbt_stages.wallet_keys.clone(),
+            wallet_script_type,
+            input_index: input_fixture_unsigned.0,
+            input_fixture_unsigned: input_fixture_unsigned.1.clone(),
+            input_fixture_halfsigned: input_fixture_halfsigned.1.clone(),
+            input_fixture_fullsigned: input_fixture_fullsigned.1.clone(),
+        })
+    }
+}
+
 /// Helper function to find a unique input matching a predicate
 fn find_unique_input<'a, T, I, F>(
     iter: I,

packages/wasm-utxo/src/fixed_script_wallet/wallet_keys.rs

@@ -32,7 +32,7 @@ pub fn to_pub_triple(xpubs: &XpubTriple) -> PubTriple {
         .expect("could not convert vec to array")
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct RootWalletKeys {
     xpubs: XpubTriple,
     derivation_prefixes: [DerivationPath; 3],