test(wasm-utxo): remove utxo-lib dependencies from fixed-script tests

Remove utxo-lib dependencies from fixed-script PSBT tests and implement
fixture auto-generation. Tests now generate fixtures on-demand when
missing, ensuring consistency across all signature states (unsigned,
halfsigned, fullsigned).

Changes:
- Implement fixture generation in generateFixture.ts
- Update fixtureUtil to auto-generate missing fixtures
- Remove utxo-lib network references, use NetworkName type
- Remove txid validation against utxo-lib
- Remove OP_RETURN output construction via utxo-lib
- Update all test files to use async fixture loading
- Switch to format validation for txids instead of cross-library checks

Issue: BTC-3047
Co-authored-by: llm-git <llm-git@ttll.de>

feat(wasm-utxo): attach non_witness_utxo to PSBT inputs in AcidTest

Use the new Transaction builder to construct a fake previous transaction
for each input when txFormat is "psbt", populating non_witness_utxo.

refactor(wasm-utxo): make txFormat a parameter in fixture generation

Accept txFormat in generateAllStates() and loadPsbtFixture() instead of
hardcoding "psbt-lite", enabling generation of both psbt and psbt-lite
fixtures from the same infrastructure.

test(wasm-utxo): run fixed-script tests across both psbt and psbt-lite formats

Iterate over txFormats in parseTransactionWithWalletKeys and
signAndVerifySignature, skipping psbt for zcash which doesn't support
non_witness_utxo.

update fixtures

test(wasm-utxo): add psbt-format fixtures for all 7 coins

Generate unsigned/halfsigned/fullsigned PSBT fixtures (with
non_witness_utxo) for bitcoin, bitcoincash, bitcoingold, dash,
dogecoin, ecash, and litecoin.

Author: OttoAllmendinger

packages/wasm-utxo/js/coinName.ts

@@ -64,3 +64,54 @@ export function isTestnet(name: CoinName): boolean {
 export function isCoinName(v: string): v is CoinName {
   return (coinNames as readonly string[]).includes(v);
 }
+
+import type { UtxolibName } from "./utxolibCompat.js";
+
+/** Convert a CoinName or UtxolibName to CoinName */
+export function toCoinName(name: CoinName | UtxolibName): CoinName {
+  switch (name) {
+    case "bitcoin":
+      return "btc";
+    case "testnet":
+      return "tbtc";
+    case "bitcoinTestnet4":
+      return "tbtc4";
+    case "bitcoinPublicSignet":
+      return "tbtcsig";
+    case "bitcoinBitGoSignet":
+      return "tbtcbgsig";
+    case "bitcoincash":
+      return "bch";
+    case "bitcoincashTestnet":
+      return "tbch";
+    case "ecash":
+      return "bcha";
+    case "ecashTest":
+      return "tbcha";
+    case "bitcoingold":
+      return "btg";
+    case "bitcoingoldTestnet":
+      return "tbtg";
+    case "bitcoinsv":
+      return "bsv";
+    case "bitcoinsvTestnet":
+      return "tbsv";
+    case "dashTest":
+      return "tdash";
+    case "dogecoin":
+      return "doge";
+    case "dogecoinTest":
+      return "tdoge";
+    case "litecoin":
+      return "ltc";
+    case "litecoinTest":
+      return "tltc";
+    case "zcash":
+      return "zec";
+    case "zcashTest":
+      return "tzec";
+    default:
+      // CoinName values pass through (including "dash" which is both CoinName and UtxolibName)
+      return name;
+  }
+}

packages/wasm-utxo/js/testutils/AcidTest.ts

@@ -1,22 +1,23 @@
-import { BitGoPsbt, type SignerKey } from "../fixedScriptWallet/BitGoPsbt.js";
+import { BitGoPsbt, type NetworkName, type SignerKey } from "../fixedScriptWallet/BitGoPsbt.js";
 import { ZcashBitGoPsbt } from "../fixedScriptWallet/ZcashBitGoPsbt.js";
 import { RootWalletKeys } from "../fixedScriptWallet/RootWalletKeys.js";
 import { BIP32 } from "../bip32.js";
 import { ECPair } from "../ecpair.js";
+import { Transaction } from "../transaction.js";
 import {
-  assertChainCode,
   ChainCode,
   createOpReturnScript,
   inputScriptTypes,
   outputScript,
   outputScriptTypes,
+  p2shP2pkOutputScript,
   supportsScriptType,
   type InputScriptType,
   type OutputScriptType,
   type ScriptId,
 } from "../fixedScriptWallet/index.js";
 import type { CoinName } from "../coinName.js";
-import { coinNames, isMainnet } from "../coinName.js";
+import { coinNames, isMainnet, toCoinName } from "../coinName.js";
 import { getDefaultWalletKeys, getWalletKeysForSeed, getKeyTriple } from "./keys.js";
 import type { Triple } from "../triple.js";
 
@@ -91,6 +92,22 @@ type SuiteConfig = {
 // Re-export for convenience
 export { inputScriptTypes, outputScriptTypes };
 
+/** Map InputScriptType to the OutputScriptType used for chain code derivation */
+function inputScriptTypeToOutputScriptType(scriptType: InputScriptType): OutputScriptType {
+  switch (scriptType) {
+    case "p2sh":
+    case "p2shP2wsh":
+    case "p2wsh":
+    case "p2trLegacy":
+      return scriptType;
+    case "p2shP2pk":
+      return "p2sh";
+    case "p2trMusig2ScriptPath":
+    case "p2trMusig2KeyPath":
+      return "p2trMusig2";
+  }
+}
+
 /**
  * Creates a valid PSBT with as many features as possible (kitchen sink).
  *
@@ -113,7 +130,7 @@ export { inputScriptTypes, outputScriptTypes };
  * - psbt-lite: Only witness_utxo (no non_witness_utxo)
  */
 export class AcidTest {
-  public readonly network: CoinName;
+  public readonly network: CoinName | NetworkName;
   public readonly signStage: SignStage;
   public readonly txFormat: TxFormat;
   public readonly rootWalletKeys: RootWalletKeys;
@@ -126,7 +143,7 @@ export class AcidTest {
   private readonly bitgoXprv: BIP32;
 
   constructor(
-    network: CoinName,
+    network: CoinName | NetworkName,
     signStage: SignStage,
     txFormat: TxFormat,
     rootWalletKeys: RootWalletKeys,
@@ -151,13 +168,14 @@ export class AcidTest {
    * Create an AcidTest with specific configuration
    */
   static withConfig(
-    network: CoinName,
+    network: CoinName | NetworkName,
     signStage: SignStage,
     txFormat: TxFormat,
     suiteConfig: SuiteConfig = {},
   ): AcidTest {
     const rootWalletKeys = getDefaultWalletKeys();
     const otherWalletKeys = getWalletKeysForSeed("too many secrets");
+    const coin = toCoinName(network);
 
     // Filter inputs based on network support
     const inputs: Input[] = inputScriptTypes
@@ -167,9 +185,9 @@ export class AcidTest {
 
         // Map input script types to output script types for support check
         if (scriptType === "p2trMusig2KeyPath" || scriptType === "p2trMusig2ScriptPath") {
-          return supportsScriptType(network, "p2trMusig2");
+          return supportsScriptType(coin, "p2trMusig2");
         }
-        return supportsScriptType(network, scriptType);
+        return supportsScriptType(coin, scriptType);
       })
       .filter(
         (scriptType) =>
@@ -183,7 +201,7 @@ export class AcidTest {
 
     // Filter outputs based on network support
     const outputs: Output[] = outputScriptTypes
-      .filter((scriptType) => supportsScriptType(network, scriptType))
+      .filter((scriptType) => supportsScriptType(coin, scriptType))
       .map((scriptType, index) => ({
         scriptType,
         value: BigInt(900 + index * 100), // Deterministic amounts
@@ -232,68 +250,86 @@ export class AcidTest {
    */
   createPsbt(): BitGoPsbt {
     // Use ZcashBitGoPsbt for Zcash networks
-    const isZcash = this.network === "zec" || this.network === "tzec";
+    const isZcash =
+      this.network === "zec" ||
+      this.network === "tzec" ||
+      this.network === "zcash" ||
+      this.network === "zcashTest";
     const psbt = isZcash
-      ? ZcashBitGoPsbt.createEmptyWithConsensusBranchId(this.network, this.rootWalletKeys, {
-          version: 2,
-          lockTime: 0,
-          consensusBranchId: 0xc2d6d0b4, // NU5
+      ? ZcashBitGoPsbt.createEmpty(this.network, this.rootWalletKeys, {
+          // Sapling activation height: mainnet=419200, testnet=280000
+          blockHeight: this.network === "zec" || this.network === "zcash" ? 419200 : 280000,
         })
       : BitGoPsbt.createEmpty(this.network, this.rootWalletKeys, {
           version: 2,
           lockTime: 0,
         });
 
+    // Build a fake previous transaction for non_witness_utxo (psbt format)
+    const usePrevTx = this.txFormat === "psbt" && !isZcash;
+    const buildPrevTx = (
+      vout: number,
+      script: Uint8Array,
+      value: bigint,
+    ): Uint8Array | undefined => {
+      if (!usePrevTx) return undefined;
+      const tx = Transaction.create();
+      tx.addInput("0".repeat(64), 0xffffffff);
+      for (let i = 0; i < vout; i++) {
+        tx.addOutput(new Uint8Array(0), 0n);
+      }
+      tx.addOutput(script, value);
+      return tx.toBytes();
+    };
+
     // Add inputs with deterministic outpoints
     this.inputs.forEach((input, index) => {
-      // Resolve scriptId: either from explicit scriptId or from scriptType + index
-      const scriptId: ScriptId = input.scriptId ?? {
-        chain: ChainCode.value("p2sh", "external"),
-        index: input.index ?? index,
-      };
       const walletKeys = input.walletKeys ?? this.rootWalletKeys;
+      const outpoint = { txid: "0".repeat(64), vout: index, value: input.value };
 
-      // Get scriptType: either explicit or derive from scriptId chain
-      const scriptType = input.scriptType ?? ChainCode.scriptType(assertChainCode(scriptId.chain));
+      // scriptId variant: caller provides explicit chain + index
+      if (input.scriptId) {
+        const script = outputScript(
+          walletKeys,
+          input.scriptId.chain,
+          input.scriptId.index,
+          this.network,
+        );
+        psbt.addWalletInput(
+          { ...outpoint, prevTx: buildPrevTx(index, script, input.value) },
+          walletKeys,
+          { scriptId: input.scriptId, signPath: { signer: "user", cosigner: "bitgo" } },
+        );
+        return;
+      }
+
+      const scriptType = input.scriptType ?? "p2sh";
 
       if (scriptType === "p2shP2pk") {
-        // Add replay protection input
-        const replayKey = this.getReplayProtectionKey();
-        // Convert BIP32 to ECPair using public key
-        const ecpair = ECPair.fromPublicKey(replayKey.publicKey);
+        const ecpair = ECPair.fromPublicKey(this.getReplayProtectionKey().publicKey);
+        const script = p2shP2pkOutputScript(ecpair.publicKey);
         psbt.addReplayProtectionInput(
-          {
-            txid: "0".repeat(64),
-            vout: index,
-            value: input.value,
-          },
+          { ...outpoint, prevTx: buildPrevTx(index, script, input.value) },
           ecpair,
         );
-      } else {
-        // Determine signing path based on input type
-        let signPath: { signer: SignerKey; cosigner: SignerKey };
-
-        if (scriptType === "p2trMusig2ScriptPath") {
-          // Script path uses user + backup
-          signPath = { signer: "user", cosigner: "backup" };
-        } else {
-          // Default: user + bitgo
-          signPath = { signer: "user", cosigner: "bitgo" };
-        }
-
-        psbt.addWalletInput(
-          {
-            txid: "0".repeat(64),
-            vout: index,
-            value: input.value,
-          },
-          walletKeys,
-          {
-            scriptId,
-            signPath,
-          },
-        );
+        return;
       }
+
+      const scriptId: ScriptId = {
+        chain: ChainCode.value(inputScriptTypeToOutputScriptType(scriptType), "external"),
+        index: input.index ?? index,
+      };
+      const signPath: { signer: SignerKey; cosigner: SignerKey } =
+        scriptType === "p2trMusig2ScriptPath"
+          ? { signer: "user", cosigner: "backup" }
+          : { signer: "user", cosigner: "bitgo" };
+      const script = outputScript(walletKeys, scriptId.chain, scriptId.index, this.network);
+
+      psbt.addWalletInput(
+        { ...outpoint, prevTx: buildPrevTx(index, script, input.value) },
+        walletKeys,
+        { scriptId, signPath },
+      );
     });
 
     // Add outputs
@@ -366,40 +402,32 @@ export class AcidTest {
     );
 
     if (hasMusig2Inputs) {
-      const isZcash = this.network === "zec" || this.network === "tzec";
+      const isZcash =
+        this.network === "zec" ||
+        this.network === "tzec" ||
+        this.network === "zcash" ||
+        this.network === "zcashTest";
       if (isZcash) {
         throw new Error("Zcash does not support MuSig2/Taproot inputs");
       }
 
-      // Generate nonces with user key
+      // MuSig2 requires ALL participant nonces before ANY signing.
+      // Generate nonces directly on the same PSBT for each participant key.
       psbt.generateMusig2Nonces(userKey);
 
-      if (this.signStage === "fullsigned") {
-        // Create a second PSBT with cosigner nonces for combination
-        // For p2trMusig2ScriptPath use backup, for p2trMusig2KeyPath use bitgo
-        // Since we might have both types, we need to generate nonces separately
-        const bytes = psbt.serialize();
-
-        const hasKeyPath = this.inputs.some((input) => input.scriptType === "p2trMusig2KeyPath");
-        const hasScriptPath = this.inputs.some(
-          (input) => input.scriptType === "p2trMusig2ScriptPath",
-        );
+      const hasKeyPath = this.inputs.some((input) => input.scriptType === "p2trMusig2KeyPath");
+      const hasScriptPath = this.inputs.some(
+        (input) => input.scriptType === "p2trMusig2ScriptPath",
+      );
 
-        if (hasKeyPath && !hasScriptPath) {
-          // Only key path inputs - generate bitgo nonces for all
-          const psbt2 = BitGoPsbt.fromBytes(bytes, this.network);
-          psbt2.generateMusig2Nonces(bitgoKey);
-          psbt.combineMusig2Nonces(psbt2);
-        } else if (hasScriptPath && !hasKeyPath) {
-          // Only script path inputs - generate backup nonces for all
-          const psbt2 = BitGoPsbt.fromBytes(bytes, this.network);
-          psbt2.generateMusig2Nonces(backupKey);
-          psbt.combineMusig2Nonces(psbt2);
-        } else {
-          const psbt2 = BitGoPsbt.fromBytes(bytes, this.network);
-          psbt2.generateMusig2Nonces(bitgoKey);
-          psbt.combineMusig2Nonces(psbt2);
-        }
+      // Key path uses user+bitgo, script path uses user+backup.
+      // generateMusig2Nonces fails if the key isn't a participant in any musig2 input,
+      // so we only call it for keys that match.
+      if (hasKeyPath) {
+        psbt.generateMusig2Nonces(bitgoKey);
+      }
+      if (hasScriptPath) {
+        psbt.generateMusig2Nonces(backupKey);
       }
     }
 

packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/p2tr_musig2_input.rs

@@ -1388,18 +1388,13 @@ mod tests {
         assert_eq!(fixture_witness_bytes[1], 0x40, "Expected 64-byte signature");
         let fixture_signature = &fixture_witness_bytes[2..66];
 
-        // Get tap merkle root from fixture
+        // Get tap merkle root from PSBT input (more reliable than fixture JSON)
         use crate::bitcoin::sighash::SighashCache;
         use crate::bitcoin::taproot::TapNodeHash;
 
-        let tap_tree_root_bytes =
-            <Vec<u8> as hex::FromHex>::from_hex(&fixture_keypath_input.tap_merkle_root)
-                .expect("Failed to decode tap merkle root");
-        let tap_tree_root_array: [u8; 32] = tap_tree_root_bytes
-            .as_slice()
-            .try_into()
-            .expect("Invalid tap merkle root length");
-        let tap_tree_root = TapNodeHash::from_byte_array(tap_tree_root_array);
+        let tap_tree_root = psbt.inputs[*musig2_input_index]
+            .tap_merkle_root
+            .expect("Expected tap_merkle_root in PSBT input");
 
         // Collect all prevouts for sighash computation
         let prevouts = collect_prevouts(&psbt).expect("Failed to collect prevouts");