test: add transactionFromBytes factory and supportsCoin methods for mainnet coin dispatch

- Add static supportsCoin(coin) method to Transaction, ZcashTransaction, DashTransaction classes
- Each class is now a single source of truth for which coins it supports
- Add transactionFromBytes(coin, bytes) factory function that dispatches to correct class
- Export transactionFromBytes from public API
- Extend test/transaction.ts with comprehensive supportsCoin tests for all 21 coins
- Add transactionFromBytes dispatch tests using real third-party fixture data
- Update test/fixtures_thirdparty/parse.ts to use factory dispatch instead of manual isZcash check
- All 1272 tests passing; parse.ts now validates dispatch across all 9 mainnet networks

Prepares for improved transaction dispatch and unified coin-family identification utilities.

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

wasmutxo

Author: OttoAllmendinger

packages/wasm-utxo/js/index.ts

@@ -126,6 +126,7 @@ export {
   DashTransaction,
   Transaction,
   ZcashTransaction,
+  transactionFromBytes,
   type ITransaction,
   type ITransactionCommon,
 } from "./transaction.js";

packages/wasm-utxo/js/transaction.ts

@@ -30,6 +30,14 @@ export class Transaction extends TransactionBase<WasmTransaction> {
     super(wasm);
   }
 
+  /**
+   * Check if a coin is supported by this transaction class.
+   * Bitcoin-like transactions support all coins except Zcash and Dash.
+   */
+  static supportsCoin(coin: CoinName): boolean {
+    return !ZcashTransaction.supportsCoin(coin) && !DashTransaction.supportsCoin(coin);
+  }
+
   /**
    * Create an empty transaction (version 1, locktime 0)
    */
@@ -96,6 +104,14 @@ export class ZcashTransaction extends TransactionBase<WasmZcashTransaction> {
     super(wasm);
   }
 
+  /**
+   * Check if a coin is supported by this transaction class.
+   * Zcash transactions support Zcash mainnet and testnet.
+   */
+  static supportsCoin(coin: CoinName): boolean {
+    return coin === "zec" || coin === "tzec";
+  }
+
   static fromBytes(bytes: Uint8Array): ZcashTransaction {
     return new ZcashTransaction(WasmZcashTransaction.from_bytes(bytes));
   }
@@ -121,6 +137,14 @@ export class DashTransaction extends TransactionBase<WasmDashTransaction> {
     super(wasm);
   }
 
+  /**
+   * Check if a coin is supported by this transaction class.
+   * Dash transactions support Dash mainnet and testnet.
+   */
+  static supportsCoin(coin: CoinName): boolean {
+    return coin === "dash" || coin === "tdash";
+  }
+
   static fromBytes(bytes: Uint8Array): DashTransaction {
     return new DashTransaction(WasmDashTransaction.from_bytes(bytes));
   }
@@ -135,3 +159,19 @@ export class DashTransaction extends TransactionBase<WasmDashTransaction> {
     return this._wasm;
   }
 }
+
+/**
+ * Factory function to create the appropriate transaction wrapper from bytes based on coin type.
+ *
+ * Dispatches to ZcashTransaction for Zcash coins, DashTransaction for Dash coins,
+ * and Transaction for all other Bitcoin-like coins.
+ */
+export function transactionFromBytes(coin: CoinName, bytes: Uint8Array): ITransaction {
+  if (ZcashTransaction.supportsCoin(coin)) {
+    return ZcashTransaction.fromBytes(bytes);
+  }
+  if (DashTransaction.supportsCoin(coin)) {
+    return DashTransaction.fromBytes(bytes);
+  }
+  return Transaction.fromBytes(bytes);
+}

packages/wasm-utxo/node/src/scan/auxpow.rs

@@ -1,9 +1,9 @@
 import * as assert from "assert/strict";
 import { describe } from "mocha";
-import { getNetworkList, getNetworkName, isZcash } from "../networks.js";
+import { getNetworkList, getNetworkName } from "../networks.js";
 import { testFixtureArray, txValidTestFile, TxValidVector } from "./fixtures.js";
-
-import { Transaction, ZcashTransaction } from "../../js/index.js";
+import { transactionFromBytes } from "../../js/index.js";
+import { toCoinName } from "../../js/coinName.js";
 
 describe("Third-Party Fixtures", function () {
   getNetworkList().forEach((network) => {
@@ -13,18 +13,17 @@ describe("Third-Party Fixtures", function () {
           const [, /* inputs , */ txHex] = v;
           const buffer = Buffer.from(txHex, "hex");
 
-          // Parse transaction to verify it's valid
-          if (isZcash(network)) {
-            const tx = ZcashTransaction.fromBytes(buffer);
-            // Round-trip to verify serialization
-            const serialized = Buffer.from(tx.toBytes());
-            assert.deepEqual(serialized, buffer, `Zcash transaction ${i} failed round-trip`);
-          } else {
-            const tx = Transaction.fromBytes(buffer);
-            // Round-trip to verify serialization
-            const serialized = Buffer.from(tx.toBytes());
-            assert.deepEqual(serialized, buffer, `Transaction ${i} failed round-trip`);
-          }
+          // Parse transaction using factory dispatch
+          const coin = toCoinName(getNetworkName(network));
+          const tx = transactionFromBytes(coin, buffer);
+
+          // Round-trip to verify serialization
+          const serialized = Buffer.from(tx.toBytes());
+          assert.deepEqual(
+            serialized,
+            buffer,
+            `Transaction round-trip failed for ${coin} vector ${i}`,
+          );
         });
       });
     });

packages/wasm-utxo/node/src/scan/pow_test_data.rs

@@ -1,6 +1,18 @@
 import assert from "node:assert";
-import { Transaction } from "../js/transaction.js";
+import {
+  Transaction,
+  ZcashTransaction,
+  DashTransaction,
+  transactionFromBytes,
+} from "../js/transaction.js";
 import { fixedScriptWallet } from "../js/index.js";
+import { coinNames, getMainnet, type CoinName } from "../js/coinName.js";
+import { getNetworkList, getNetworkName, isZcash } from "./networks.js";
+import {
+  testFixtureArray,
+  txValidTestFile,
+  type TxValidVector,
+} from "./fixtures_thirdparty/fixtures.js";
 
 describe("Transaction builder", function () {
   it("should create an empty transaction", function () {
@@ -83,3 +95,108 @@ describe("Transaction builder", function () {
     assert.deepStrictEqual(tx2.toBytes(), bytes);
   });
 });
+
+describe("supportsCoin", function () {
+  it("should identify Zcash coins correctly", function () {
+    assert.ok(ZcashTransaction.supportsCoin("zec"), "zec should be supported by ZcashTransaction");
+    assert.ok(
+      ZcashTransaction.supportsCoin("tzec"),
+      "tzec should be supported by ZcashTransaction",
+    );
+  });
+
+  it("should reject non-Zcash coins in ZcashTransaction", function () {
+    const nonZcashCoins = coinNames.filter((c) => !ZcashTransaction.supportsCoin(c));
+    assert.ok(nonZcashCoins.length > 0, "should have non-Zcash coins");
+    nonZcashCoins.forEach((coin) => {
+      assert.ok(
+        !ZcashTransaction.supportsCoin(coin),
+        `ZcashTransaction should not support ${coin}`,
+      );
+    });
+  });
+
+  it("should identify Dash coins correctly", function () {
+    assert.ok(DashTransaction.supportsCoin("dash"), "dash should be supported by DashTransaction");
+    assert.ok(
+      DashTransaction.supportsCoin("tdash"),
+      "tdash should be supported by DashTransaction",
+    );
+  });
+
+  it("should reject non-Dash coins in DashTransaction", function () {
+    const nonDashCoins = coinNames.filter((c) => !DashTransaction.supportsCoin(c));
+    assert.ok(nonDashCoins.length > 0, "should have non-Dash coins");
+    nonDashCoins.forEach((coin) => {
+      assert.ok(!DashTransaction.supportsCoin(coin), `DashTransaction should not support ${coin}`);
+    });
+  });
+
+  it("should identify Bitcoin-like coins correctly", function () {
+    const bitcoinLikeCoins = coinNames.filter((c) => Transaction.supportsCoin(c));
+    assert.ok(bitcoinLikeCoins.length > 0, "should have Bitcoin-like coins");
+    bitcoinLikeCoins.forEach((coin) => {
+      assert.ok(
+        !ZcashTransaction.supportsCoin(coin) && !DashTransaction.supportsCoin(coin),
+        `${coin} should only be supported by Transaction`,
+      );
+    });
+  });
+
+  it("should partition all coins into exactly one family", function () {
+    coinNames.forEach((coin) => {
+      const zSupports = ZcashTransaction.supportsCoin(coin);
+      const dSupports = DashTransaction.supportsCoin(coin);
+      const bSupports = Transaction.supportsCoin(coin);
+
+      const supportCount = [zSupports, dSupports, bSupports].filter(Boolean).length;
+      assert.strictEqual(
+        supportCount,
+        1,
+        `${coin} should be supported by exactly one transaction class`,
+      );
+    });
+  });
+});
+
+describe("transactionFromBytes", function () {
+  // Test each mainnet network with a real transaction from the third-party fixtures
+  const testedNetworks = getNetworkList();
+
+  testedNetworks.forEach((network) => {
+    const networkName = getNetworkName(network);
+    describe(`dispatch for ${networkName}`, function () {
+      testFixtureArray(this, network, txValidTestFile, function (vectors: TxValidVector[]) {
+        // Use the first non-comment vector for dispatch testing
+        const vector = vectors[0];
+        if (!vector) {
+          this.skip();
+        }
+
+        const [, /* inputs */ txHex] = vector;
+        const bytes = Buffer.from(txHex, "hex");
+
+        it("should dispatch to the correct transaction class and round-trip", function () {
+          const coin = getMainnet(network as CoinName);
+          const tx = transactionFromBytes(coin, bytes);
+
+          // Verify dispatch to correct class
+          if (isZcash(network)) {
+            assert.ok(
+              tx instanceof ZcashTransaction,
+              `${coin} should dispatch to ZcashTransaction`,
+            );
+          } else if (DashTransaction.supportsCoin(coin)) {
+            assert.ok(tx instanceof DashTransaction, `${coin} should dispatch to DashTransaction`);
+          } else {
+            assert.ok(tx instanceof Transaction, `${coin} should dispatch to Transaction`);
+          }
+
+          // Verify round-trip
+          const serialized = Buffer.from(tx.toBytes());
+          assert.deepEqual(serialized, bytes, `round-trip should match original bytes for ${coin}`);
+        });
+      });
+    });
+  });
+});