test(wasm-utxo): simplify fromHalfSignedLegacy test dependencies

Replace utxolib network objects with coin-based utilities throughout
tests for `fromHalfSignedLegacyTransaction`. Update helper functions
to accept `CoinName` instead of `Network`, and use new coin utilities
for mainnet checks and script type validation.

- Replace `isSupportedNetwork` with `isSupportedCoin` using `CoinName`
- Update `createHalfSignedP2msPsbt` to use coin-based utilities
- Use `supportsScriptType` instead of network-based validation
- Replace network list iteration with `coinNames` filtering
- Remove `getCoinNameForNetwork` dependency
- Clarify test descriptions for transaction instance handling

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

Author: OttoAllmendinger

packages/wasm-utxo/test/fixedScript/fromHalfSignedLegacyTransaction.ts

@@ -11,36 +11,38 @@
  */
 import { describe, it } from "mocha";
 import * as assert from "assert";
-import * as utxolib from "@bitgo/utxo-lib";
 import { BitGoPsbt, type HydrationUnspent } from "../../js/fixedScriptWallet/BitGoPsbt.js";
 import { ZcashBitGoPsbt } from "../../js/fixedScriptWallet/ZcashBitGoPsbt.js";
+import { supportsScriptType } from "../../js/fixedScriptWallet/index.js";
 import { ChainCode } from "../../js/fixedScriptWallet/chains.js";
 import { ECPair } from "../../js/ecpair.js";
-import { Transaction } from "../../js/transaction.js";
+import { Transaction, ZcashTransaction } from "../../js/transaction.js";
+import { coinNames, type CoinName, isMainnet } from "../../js/coinName.js";
 import { getDefaultWalletKeys, getKeyTriple } from "../../js/testutils/keys.js";
-import { getCoinNameForNetwork } from "../networks.js";
 
 const ZCASH_NU5_HEIGHT = 1687105;
 
 const p2msScriptTypes = ["p2sh", "p2shP2wsh", "p2wsh"] as const;
 
-function isSupportedNetwork(n: utxolib.Network): boolean {
-  return utxolib.isMainnet(n) && n !== utxolib.networks.bitcoinsv && n !== utxolib.networks.ecash;
+// Coins excluded from round-trip tests (use special handling or not supported)
+const EXCLUDED_COINS: CoinName[] = ["bsv", "bcha", "zec"];
+
+function isSupportedCoin(coin: CoinName): boolean {
+  return isMainnet(coin) && !EXCLUDED_COINS.includes(coin);
 }
 
 function createHalfSignedP2msPsbt(
-  network: utxolib.Network,
+  coinName: CoinName,
   valueOverride?: bigint,
 ): { psbt: BitGoPsbt; unspents: HydrationUnspent[] } {
-  const coinName = getCoinNameForNetwork(network);
   const rootWalletKeys = getDefaultWalletKeys();
   const [userXprv] = getKeyTriple("default");
 
   const supportedTypes = p2msScriptTypes.filter((scriptType) =>
-    utxolib.bitgo.outputScripts.isSupportedScriptType(network, scriptType),
+    supportsScriptType(coinName, scriptType),
   );
 
-  const isZcash = utxolib.getMainnet(network) === utxolib.networks.zcash;
+  const isZcash = coinName === "zec" || coinName === "tzec";
   const psbt = isZcash
     ? ZcashBitGoPsbt.createEmpty(coinName as "zec" | "tzec", rootWalletKeys, {
         version: 4,
@@ -79,11 +81,12 @@ describe("BitGoPsbt.fromHalfSignedLegacyTransaction", function () {
       // because BigInt::from(value_js).as_f64() calls JsValue::as_f64(), which
       // returns None for JS BigInt (it only works for JS Number).
       const rootWalletKeys = getDefaultWalletKeys();
-      const { psbt, unspents } = createHalfSignedP2msPsbt(utxolib.networks.bitcoin);
+      const { psbt, unspents } = createHalfSignedP2msPsbt("btc");
       const txBytes = psbt.getHalfSignedLegacyFormat();
+      const tx = Transaction.fromBytes(txBytes, "btc");
 
       assert.doesNotThrow(() => {
-        BitGoPsbt.fromHalfSignedLegacyTransaction(txBytes, "btc", rootWalletKeys, unspents);
+        BitGoPsbt.fromHalfSignedLegacyTransaction(tx, "btc", rootWalletKeys, unspents);
       }, "fromHalfSignedLegacyTransaction must not throw for valid JS BigInt values");
     });
 
@@ -93,33 +96,29 @@ describe("BitGoPsbt.fromHalfSignedLegacyTransaction", function () {
       const rootWalletKeys = getDefaultWalletKeys();
       // 21 million BTC in satoshis — the maximum possible UTXO value
       const maxSats = 21_000_000n * 100_000_000n;
-      const { psbt, unspents } = createHalfSignedP2msPsbt(utxolib.networks.bitcoin, maxSats);
+      const { psbt, unspents } = createHalfSignedP2msPsbt("btc", maxSats);
       const txBytes = psbt.getHalfSignedLegacyFormat();
+      const tx = Transaction.fromBytes(txBytes, "btc");
 
       assert.doesNotThrow(() => {
-        BitGoPsbt.fromHalfSignedLegacyTransaction(txBytes, "btc", rootWalletKeys, unspents);
+        BitGoPsbt.fromHalfSignedLegacyTransaction(tx, "btc", rootWalletKeys, unspents);
       }, "fromHalfSignedLegacyTransaction must handle large satoshi values");
     });
   });
 
   describe("Round-trip: getHalfSignedLegacyFormat → fromHalfSignedLegacyTransaction", function () {
-    // Zcash uses a non-standard transaction format (version 4 overwintered) that
-    // fromHalfSignedLegacyTransaction does not support; skip it here.
-    const roundTripNetworks = utxolib
-      .getNetworkList()
-      .filter(isSupportedNetwork)
-      .filter((n) => utxolib.getMainnet(n) !== utxolib.networks.zcash);
-
-    for (const network of roundTripNetworks) {
-      const networkName = utxolib.getNetworkName(network);
-      it(`${networkName}: reconstructed PSBT serializes without error`, function () {
+    // Supported coins for round-trip: all mainnet UTXO coins except special formats
+    const roundTripCoins = coinNames.filter(isSupportedCoin);
+
+    for (const coinName of roundTripCoins) {
+      it(`${coinName}: reconstructed PSBT serializes without error`, function () {
         const rootWalletKeys = getDefaultWalletKeys();
-        const coinName = getCoinNameForNetwork(network);
-        const { psbt, unspents } = createHalfSignedP2msPsbt(network);
+        const { psbt, unspents } = createHalfSignedP2msPsbt(coinName);
         const txBytes = psbt.getHalfSignedLegacyFormat();
+        const tx = Transaction.fromBytes(txBytes, coinName);
 
         const reconstructed = BitGoPsbt.fromHalfSignedLegacyTransaction(
-          txBytes,
+          tx,
           coinName,
           rootWalletKeys,
           unspents,
@@ -152,13 +151,14 @@ describe("BitGoPsbt.fromHalfSignedLegacyTransaction", function () {
       psbt.sign(userXprv);
 
       const txBytes = psbt.getHalfSignedLegacyFormat();
+      const tx = Transaction.fromBytes(txBytes, "btc");
 
       const unspents: HydrationUnspent[] = [
         { chain: 0, index: 0, value: BigInt(10000) }, // wallet
         { pubkey: ecpair.publicKey, value: BigInt(1000) }, // replay protection
       ];
       const reconstructed = BitGoPsbt.fromHalfSignedLegacyTransaction(
-        txBytes,
+        tx,
         "btc",
         rootWalletKeys,
         unspents,
@@ -174,21 +174,25 @@ describe("BitGoPsbt.fromHalfSignedLegacyTransaction", function () {
   });
 
   describe("Zcash legacy format round-trip", function () {
-    it("should reject Zcash via dynamic dispatch in fromHalfSignedLegacyTransaction", function () {
-      // With dynamic dispatch, fromHalfSignedLegacyTransaction now validates the transaction type
-      // and rejects Zcash early with a clear error message, directing to ZcashBitGoPsbt.createEmpty().
+    it("should reject Zcash via type check in fromHalfSignedLegacyTransaction", function () {
+      // fromHalfSignedLegacyTransaction validates the transaction type at call time
+      // and rejects Zcash with a clear error message.
       const rootWalletKeys = getDefaultWalletKeys();
-      const { psbt: zcashPsbt, unspents } = createHalfSignedP2msPsbt(utxolib.networks.zcash);
+      const { psbt: zcashPsbt, unspents } = createHalfSignedP2msPsbt("zec");
 
       // Step 1: Extract Zcash PSBT as legacy format
       const txBytes = zcashPsbt.getHalfSignedLegacyFormat();
       assert.ok(txBytes.length > 0, "ZcashBitGoPsbt.getHalfSignedLegacyFormat() produces bytes");
 
-      // Step 2: Call fromHalfSignedLegacyTransaction with Zcash bytes
-      // Expected: Throws clear error after detecting Zcash transaction via dynamic dispatch
+      // Step 2: Parse the transaction (will be ZcashTransaction)
+      const tx = Transaction.fromBytes(txBytes, "zec");
+      assert.ok(tx instanceof ZcashTransaction, "Parsed transaction is ZcashTransaction");
+
+      // Step 3: Call fromHalfSignedLegacyTransaction with Zcash transaction
+      // Expected: Throws clear error after detecting Zcash transaction
       assert.throws(
         () => {
-          BitGoPsbt.fromHalfSignedLegacyTransaction(txBytes, "zec", rootWalletKeys, unspents);
+          BitGoPsbt.fromHalfSignedLegacyTransaction(tx, "zec", rootWalletKeys, unspents);
         },
         /Use ZcashBitGoPsbt.fromHalfSignedLegacyTransaction\(\) for Zcash transactions/,
       );
@@ -197,7 +201,7 @@ describe("BitGoPsbt.fromHalfSignedLegacyTransaction", function () {
     it("should round-trip Zcash PSBT via ZcashBitGoPsbt.fromHalfSignedLegacyTransaction (with blockHeight)", function () {
       // This test verifies the round-trip: create Zcash PSBT → extract legacy format → reconstruct PSBT
       const rootWalletKeys = getDefaultWalletKeys();
-      const { psbt, unspents } = createHalfSignedP2msPsbt(utxolib.networks.zcash);
+      const { psbt, unspents } = createHalfSignedP2msPsbt("zec");
 
       // Step 1: Extract half-signed legacy format (this is what would be transmitted)
       const legacyBytes = psbt.getHalfSignedLegacyFormat();
@@ -227,7 +231,7 @@ describe("BitGoPsbt.fromHalfSignedLegacyTransaction", function () {
     it("should round-trip Zcash PSBT via ZcashBitGoPsbt.fromHalfSignedLegacyTransaction (with consensusBranchId)", function () {
       // This test verifies the round-trip with explicit consensus branch ID instead of block height
       const rootWalletKeys = getDefaultWalletKeys();
-      const { psbt, unspents } = createHalfSignedP2msPsbt(utxolib.networks.zcash);
+      const { psbt, unspents } = createHalfSignedP2msPsbt("zec");
 
       // Step 1: Extract half-signed legacy format
       const legacyBytes = psbt.getHalfSignedLegacyFormat();
@@ -254,26 +258,22 @@ describe("BitGoPsbt.fromHalfSignedLegacyTransaction", function () {
       assert.ok(serialized.length > 0, "Reconstructed Zcash PSBT serializes without error");
     });
 
-    it("should accept pre-decoded transaction instance to avoid re-parsing", function () {
-      // Dynamic dispatch enhancement: fromHalfSignedLegacyTransaction now accepts
-      // either txBytes OR a pre-decoded ITransaction instance
+    it("should accept pre-decoded transaction instance", function () {
+      // fromHalfSignedLegacyTransaction accepts a pre-decoded Transaction instance.
+      // This is more efficient than parsing bytes twice.
       const rootWalletKeys = getDefaultWalletKeys();
-      const { psbt, unspents } = createHalfSignedP2msPsbt(utxolib.networks.bitcoin);
+      const { psbt, unspents } = createHalfSignedP2msPsbt("btc");
       const txBytes = psbt.getHalfSignedLegacyFormat();
 
-      // Method 1: Pass raw bytes (uses dynamic dispatch internally)
-      const psbt1 = BitGoPsbt.fromHalfSignedLegacyTransaction(
-        txBytes,
-        "btc",
-        rootWalletKeys,
-        unspents,
-      );
+      // Parse transaction once and pass the instance
+      const tx = Transaction.fromBytes(txBytes, "btc");
+      const psbt1 = BitGoPsbt.fromHalfSignedLegacyTransaction(tx, "btc", rootWalletKeys, unspents);
 
-      // Method 2: Pre-decode transaction and pass instance (avoids re-parsing)
-      const tx = Transaction.fromBytes(txBytes);
-      const psbt2 = BitGoPsbt.fromHalfSignedLegacyTransaction(tx, "btc", rootWalletKeys, unspents);
+      // Parse again to compare
+      const tx2 = Transaction.fromBytes(txBytes, "btc");
+      const psbt2 = BitGoPsbt.fromHalfSignedLegacyTransaction(tx2, "btc", rootWalletKeys, unspents);
 
-      // Both methods should produce equivalent results
+      // Both should produce equivalent results
       assert.strictEqual(psbt1.inputCount(), psbt2.inputCount(), "Same input count");
       assert.strictEqual(psbt1.outputCount(), psbt2.outputCount(), "Same output count");
       assert.deepStrictEqual(psbt1.serialize(), psbt2.serialize(), "Identical serialization");