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

@@ -3,13 +3,14 @@ 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,
@@ -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).
  *
@@ -158,6 +175,7 @@ export class AcidTest {
   ): AcidTest {
     const rootWalletKeys = getDefaultWalletKeys();
     const otherWalletKeys = getWalletKeysForSeed("too many secrets");
+    const coin = 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
@@ -234,66 +252,80 @@ export class AcidTest {
     // Use ZcashBitGoPsbt for Zcash networks
     const isZcash = this.network === "zec" || this.network === "tzec";
     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" ? 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 +398,27 @@ export class AcidTest {
     );
 
     if (hasMusig2Inputs) {
-      const isZcash = this.network === "zec" || this.network === "tzec";
-      if (isZcash) {
+      if (this.network === "zec" || this.network === "tzec") {
         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);
       }
     }
 
@@ -446,8 +465,8 @@ export class AcidTest {
    * Generate test suite for all networks, sign stages, and tx formats
    */
   static forAllNetworksSignStagesTxFormats(suiteConfig: SuiteConfig = {}): AcidTest[] {
-    return (coinNames as readonly CoinName[])
-      .filter((network) => isMainnet(network) && network !== "bsv") // Exclude bitcoinsv
+    return coinNames
+      .filter((network): network is CoinName => isMainnet(network) && network !== "bsv")
       .flatMap((network) =>
         signStages.flatMap((signStage) =>
           txFormats.map((txFormat) =>