feat(utxo-lib): add AcidTest utility for comprehensive PSBT testing

Creates a utility class for testing that generates PSBTs with all
supported input and output types for a given network. The AcidTest class
can create PSBTs with:
- All wallet script types supported by the network
- p2shP2pk inputs (for replay protection)
- Various output types including those from another wallet
- OP_RETURN outputs

Refactors existing tests to use this utility, making them more
comprehensive and maintainable.

Issue: BTC-2732

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

Author: OttoAllmendinger

modules/utxo-lib/src/testutil/psbt.ts

@@ -3,6 +3,7 @@ import { ok as assert } from 'assert';
 
 import {
   createOutputScriptP2shP2pk,
+  isSupportedScriptType,
   ScriptType,
   ScriptType2Of3,
   scriptTypeP2shP2pk,
@@ -26,10 +27,12 @@ import {
   UtxoTransaction,
   verifySignatureWithUnspent,
   addXpubsToPsbt,
+  clonePsbtWithoutNonWitnessUtxo,
 } from '../bitgo';
 import { Network } from '../networks';
 import { mockReplayProtectionUnspent, mockWalletUnspent } from './mock';
 import { toOutputScript } from '../address';
+import { getDefaultWalletKeys, getWalletKeysForSeed } from './keys';
 
 /**
  * This is a bit of a misnomer, as it actually specifies the spend type of the input.
@@ -48,6 +51,8 @@ export type Input = {
   value: bigint;
 };
 
+export type SignStage = 'unsigned' | 'halfsigned' | 'fullsigned';
+
 /**
  * Set isInternalAddress=true for internal output address
  */
@@ -169,7 +174,7 @@ export function constructPsbt(
   outputs: Output[],
   network: Network,
   rootWalletKeys: RootWalletKeys,
-  sign: 'unsigned' | 'halfsigned' | 'fullsigned',
+  signStage: SignStage,
   params?: {
     signers?: { signerName: KeyName; cosignerName?: KeyName };
     deterministic?: boolean;
@@ -183,6 +188,11 @@ export function constructPsbt(
   assert(totalInputAmount >= outputInputAmount, 'total output can not exceed total input');
 
   const psbt = createPsbtForNetwork({ network });
+
+  if (params?.addGlobalXPubs) {
+    addXpubsToPsbt(psbt, rootWalletKeys);
+  }
+
   const unspents = inputs.map((input, i) => toUnspent(input, i, network, rootWalletKeys));
 
   unspents.forEach((u, i) => {
@@ -226,7 +236,7 @@ export function constructPsbt(
     throw new Error('invalid output');
   });
 
-  if (sign === 'unsigned') {
+  if (signStage === 'unsigned') {
     return psbt;
   }
 
@@ -237,15 +247,90 @@ export function constructPsbt(
 
   signAllPsbtInputs(psbt, inputs, rootWalletKeys, 'halfsigned', { signers, skipNonWitnessUtxo });
 
-  if (sign === 'fullsigned') {
-    signAllPsbtInputs(psbt, inputs, rootWalletKeys, sign, { signers, deterministic, skipNonWitnessUtxo });
+  if (signStage === 'fullsigned') {
+    signAllPsbtInputs(psbt, inputs, rootWalletKeys, signStage, { signers, deterministic, skipNonWitnessUtxo });
   }
 
-  if (params?.addGlobalXPubs) {
-    addXpubsToPsbt(psbt, rootWalletKeys);
+  return psbt;
+}
+
+export type TxFormat = 'psbt' | 'psbt-lite';
+
+/**
+ * Creates a valid PSBT with as many features as possible.
+ *
+ * - Inputs:
+ *   - All wallet script types that are supported by the network.
+ *   - A p2shP2pk input (for replay protection)
+ * - Outputs:
+ *   - All wallet script types that are supported by the network.
+ *   - A p2sh output with derivation info of a different wallet (not in the global psbt xpubs)
+ *   - A p2sh output with no derivation info (external output)
+ *   - An OP_RETURN output
+ */
+export class AcidTest {
+  public readonly network: Network;
+  public readonly signStage: SignStage;
+  public readonly txFormat: TxFormat;
+  public readonly rootWalletKeys: RootWalletKeys;
+  public readonly otherWalletKeys: RootWalletKeys;
+  public readonly inputs: Input[];
+  public readonly outputs: Output[];
+
+  constructor(
+    network: Network,
+    signStage: SignStage,
+    txFormat: TxFormat,
+    rootWalletKeys: RootWalletKeys,
+    otherWalletKeys: RootWalletKeys,
+    inputs: Input[],
+    outputs: Output[]
+  ) {
+    this.network = network;
+    this.signStage = signStage;
+    this.txFormat = txFormat;
+    this.rootWalletKeys = rootWalletKeys;
+    this.otherWalletKeys = otherWalletKeys;
+    this.inputs = inputs;
+    this.outputs = outputs;
   }
 
-  return psbt;
+  static withDefaults(network: Network, signStage: SignStage, txFormat: TxFormat): AcidTest {
+    const rootWalletKeys = getDefaultWalletKeys();
+
+    const otherWalletKeys = getWalletKeysForSeed('too many secrets');
+    const inputs: Input[] = inputScriptTypes
+      .filter((scriptType) =>
+        scriptType === 'taprootKeyPathSpend'
+          ? isSupportedScriptType(network, 'p2trMusig2')
+          : isSupportedScriptType(network, scriptType)
+      )
+      .map((scriptType) => ({ scriptType, value: BigInt(2000) }));
+
+    const outputs: Output[] = outputScriptTypes
+      .filter((scriptType) => isSupportedScriptType(network, scriptType))
+      .map((scriptType) => ({ scriptType, value: BigInt(900) }));
+
+    // Test other wallet output (with derivation info)
+    outputs.push({ scriptType: 'p2sh', value: BigInt(900), walletKeys: otherWalletKeys });
+    // Tes non-wallet output
+    outputs.push({ scriptType: 'p2sh', value: BigInt(900), walletKeys: null });
+    // Test OP_RETURN output
+    outputs.push({ opReturn: 'setec astronomy', value: BigInt(900) });
+
+    return new AcidTest(network, signStage, txFormat, rootWalletKeys, otherWalletKeys, inputs, outputs);
+  }
+
+  createPsbt(): UtxoPsbt {
+    const psbt = constructPsbt(this.inputs, this.outputs, this.network, this.rootWalletKeys, this.signStage, {
+      deterministic: true,
+      addGlobalXPubs: true,
+    });
+    if (this.txFormat === 'psbt-lite') {
+      return clonePsbtWithoutNonWitnessUtxo(psbt);
+    }
+    return psbt;
+  }
 }
 
 /**

modules/utxo-lib/src/testutil/transaction.ts

@@ -154,8 +154,12 @@ export function constructTxnBuilder<TNumber extends number | bigint>(
   const outputInputAmount = outputs.reduce((sum, output) => sum + BigInt(output.value), BigInt(0));
   assert(totalInputAmount >= outputInputAmount, 'total output can not exceed total input');
   assert(
-    !outputs.some((o) => (o.scriptType && o.address) || (!o.scriptType && !o.address)),
-    'only either output script type or address should be provided'
+    outputs.every((o) => o.scriptType || o.address),
+    'must provide either scriptType or address for each output'
+  );
+  assert(
+    outputs.every((o) => !(o.scriptType && o.address)),
+    'cannot provide both scriptType and address for the same output'
   );
 
   const txb = createTransactionBuilderForNetwork<TNumber>(network);