feat(abstract-utxo): replace should.js with node's assert module

Update test assertions to use Node's built-in assert module instead of
should.js. This improves code consistency and reduces dependencies.

Issue: BTC-2732

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

Author: OttoAllmendinger

modules/abstract-utxo/test/unit/explainTransaction.ts

@@ -1,4 +1,5 @@
-import should from 'should';
+import assert from 'assert';
+
 import { Triple } from '@bitgo/sdk-core';
 
 import { bip322Fixtures } from './fixtures/bip322/fixtures';
@@ -22,51 +23,51 @@ describe('Explain Transaction', function () {
     it('should successfully run with a user nonce', async function () {
       const psbtHex = bip322Fixtures.valid.userNonce;
       const result = await coin.explainTransaction({ txHex: psbtHex, pubs });
-      should.equal(result.outputAmount, '0');
-      should.equal(result.changeAmount, '0');
-      should.equal(result.outputs.length, 1);
-      should.equal(result.outputs[0].address, 'scriptPubKey:6a');
-      should.equal(result.fee, '0');
-      should.equal(result.signatures, 0);
-      should.exist(result.messages);
+      assert.strictEqual(result.outputAmount, '0');
+      assert.strictEqual(result.changeAmount, '0');
+      assert.strictEqual(result.outputs.length, 1);
+      assert.strictEqual(result.outputs[0].address, 'scriptPubKey:6a');
+      assert.strictEqual(result.fee, '0');
+      assert.strictEqual(result.signatures, 0);
+      assert.ok(result.messages);
       result.messages?.forEach((obj) => {
-        should.exist(obj.address);
-        should.exist(obj.message);
-        should.equal(obj.message, bip322Fixtures.valid.message);
+        assert.ok(obj.address);
+        assert.ok(obj.message);
+        assert.strictEqual(obj.message, bip322Fixtures.valid.message);
       });
     });
 
     it('should successfully run with a user signature', async function () {
       const psbtHex = bip322Fixtures.valid.userSignature;
       const result = await coin.explainTransaction({ txHex: psbtHex, pubs });
-      should.equal(result.outputAmount, '0');
-      should.equal(result.changeAmount, '0');
-      should.equal(result.outputs.length, 1);
-      should.equal(result.outputs[0].address, 'scriptPubKey:6a');
-      should.equal(result.fee, '0');
-      should.equal(result.signatures, 1);
-      should.exist(result.messages);
+      assert.strictEqual(result.outputAmount, '0');
+      assert.strictEqual(result.changeAmount, '0');
+      assert.strictEqual(result.outputs.length, 1);
+      assert.strictEqual(result.outputs[0].address, 'scriptPubKey:6a');
+      assert.strictEqual(result.fee, '0');
+      assert.strictEqual(result.signatures, 1);
+      assert.ok(result.messages);
       result.messages?.forEach((obj) => {
-        should.exist(obj.address);
-        should.exist(obj.message);
-        should.equal(obj.message, bip322Fixtures.valid.message);
+        assert.ok(obj.address);
+        assert.ok(obj.message);
+        assert.strictEqual(obj.message, bip322Fixtures.valid.message);
       });
     });
 
     it('should successfully run with a hsm signature', async function () {
       const psbtHex = bip322Fixtures.valid.hsmSignature;
       const result = await coin.explainTransaction({ txHex: psbtHex, pubs });
-      should.equal(result.outputAmount, '0');
-      should.equal(result.changeAmount, '0');
-      should.equal(result.outputs.length, 1);
-      should.equal(result.outputs[0].address, 'scriptPubKey:6a');
-      should.equal(result.fee, '0');
-      should.equal(result.signatures, 2);
-      should.exist(result.messages);
+      assert.strictEqual(result.outputAmount, '0');
+      assert.strictEqual(result.changeAmount, '0');
+      assert.strictEqual(result.outputs.length, 1);
+      assert.strictEqual(result.outputs[0].address, 'scriptPubKey:6a');
+      assert.strictEqual(result.fee, '0');
+      assert.strictEqual(result.signatures, 2);
+      assert.ok(result.messages);
       result.messages?.forEach((obj) => {
-        should.exist(obj.address);
-        should.exist(obj.message);
-        should.equal(obj.message, bip322Fixtures.valid.message);
+        assert.ok(obj.address);
+        assert.ok(obj.message);
+        assert.strictEqual(obj.message, bip322Fixtures.valid.message);
       });
     });
   });

modules/abstract-utxo/test/unit/parseTransaction.ts

@@ -1,4 +1,5 @@
-import should = require('should');
+import assert from 'assert';
+
 import * as sinon from 'sinon';
 import { Wallet, UnexpectedAddressError, VerificationOptions } from '@bitgo/sdk-core';
 
@@ -51,17 +52,23 @@ describe('Parse Transaction', function () {
       verification,
     });
 
-    should.exist(parsedTransaction.outputs[0]);
-    parsedTransaction.outputs[0].should.deepEqual({
+    assert.ok(parsedTransaction.outputs[0]);
+    assert.deepStrictEqual(parsedTransaction.outputs[0], {
       address: outputAddress,
       amount: outputAmount,
       external: expectExternal,
     });
 
     const isExplicit =
       txParams.recipients !== undefined && txParams.recipients.some((recipient) => recipient.address === outputAddress);
-    should.equal(parsedTransaction.explicitExternalSpendAmount, isExplicit && expectExternal ? outputAmount : '0');
-    should.equal(parsedTransaction.implicitExternalSpendAmount, !isExplicit && expectExternal ? outputAmount : '0');
+    assert.strictEqual(
+      parsedTransaction.explicitExternalSpendAmount,
+      Number(isExplicit && expectExternal ? outputAmount : 0)
+    );
+    assert.strictEqual(
+      parsedTransaction.implicitExternalSpendAmount,
+      Number(!isExplicit && expectExternal ? outputAmount : 0)
+    );
 
     (coin.explainTransaction as any).restore();
 

modules/abstract-utxo/test/unit/verifyTransaction.ts

@@ -1,5 +1,6 @@
+import assert from 'assert';
+
 import * as utxolib from '@bitgo/utxo-lib';
-import 'should';
 import * as sinon from 'sinon';
 import { Wallet } from '@bitgo/sdk-core';
 
@@ -85,69 +86,71 @@ describe('Verify Transaction', function () {
     sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.badKey as any);
     const verifyWallet = sinon.createStubInstance(Wallet, {});
 
-    await coin
-      .verifyTransaction({
+    await assert.rejects(
+      coin.verifyTransaction({
         txParams: {
           walletPassphrase: passphrase,
         },
         txPrebuild: {},
         wallet: verifyWallet as any,
         verification: {},
-      })
-      .should.be.rejectedWith(/transaction requires verification of user public key, but it was unable to be verified/);
+      }),
+      /transaction requires verification of user public key, but it was unable to be verified/
+    );
 
     (coin.parseTransaction as any).restore();
   });
 
   it('should fail if the custom change verification data is required but missing', async () => {
     sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.noCustomChange as any);
 
-    await coin
-      .verifyTransaction({
+    await assert.rejects(
+      coin.verifyTransaction({
         txParams: {
           walletPassphrase: passphrase,
         },
         txPrebuild: {},
         wallet: unsignedSendingWallet as any,
         verification: {},
-      })
-      .should.be.rejectedWith(/parsed transaction is missing required custom change verification data/);
+      }),
+      /parsed transaction is missing required custom change verification data/
+    );
 
     (coin.parseTransaction as any).restore();
   });
 
   it('should fail if the custom change keys or key signatures are missing', async () => {
     sinon.stub(coin, 'parseTransaction').resolves(stubData.parseTransactionData.emptyCustomChange as any);
 
-    await coin
-      .verifyTransaction({
+    await assert.rejects(
+      coin.verifyTransaction({
         txParams: {
           walletPassphrase: passphrase,
         },
         txPrebuild: {},
         wallet: unsignedSendingWallet as any,
         verification: {},
-      })
-      .should.be.rejectedWith(/customChange property is missing keys or signatures/);
+      }),
+      /customChange property is missing keys or signatures/
+    );
 
     (coin.parseTransaction as any).restore();
   });
 
   it('should fail if the custom change key signatures cannot be verified', async () => {
     sinon.stub(coin, 'parseTransaction').resolves((await stubData.parseTransactionData.badSigs()) as any);
 
-    await coin
-      .verifyTransaction({
+    await assert.rejects(
+      coin.verifyTransaction({
         txParams: {
           walletPassphrase: passphrase,
         },
         txPrebuild: {},
         wallet: unsignedSendingWallet as any,
         verification: {},
-      })
-      .should.be.rejectedWith(
-        /transaction requires verification of custom change key signatures, but they were unable to be verified/
-      );
+      }),
+      /transaction requires verification of custom change key signatures, but they were unable to be verified/
+    );
 
     (coin.parseTransaction as any).restore();
   });
@@ -157,16 +160,17 @@ describe('Verify Transaction', function () {
 
     // if verify transaction gets rejected with the outputs missing error message,
     // then we know that the verification of the custom change key signatures was successful
-    await coin
-      .verifyTransaction({
+    await assert.rejects(
+      coin.verifyTransaction({
         txParams: {
           walletPassphrase: passphrase,
         },
         txPrebuild: {},
         wallet: unsignedSendingWallet as any,
         verification: {},
-      })
-      .should.be.rejectedWith(/expected outputs missing in transaction prebuild/);
+      }),
+      /expected outputs missing in transaction prebuild/
+    );
 
     (coin.parseTransaction as any).restore();
   });
@@ -185,15 +189,16 @@ describe('Verify Transaction', function () {
       needsCustomChangeKeySignatureVerification: false,
     });
 
-    await coin
-      .verifyTransaction({
+    await assert.rejects(
+      coin.verifyTransaction({
         txParams: {
           walletPassphrase: passphrase,
         },
         txPrebuild: {},
         wallet: unsignedSendingWallet as any,
-      })
-      .should.be.rejectedWith('prebuild attempts to spend to unintended external recipients');
+      }),
+      /prebuild attempts to spend to unintended external recipients/
+    );
 
     coinMock.restore();
   });
@@ -216,17 +221,17 @@ describe('Verify Transaction', function () {
       .stub(coin, 'createTransactionFromHex')
       .returns({ ins: [] } as unknown as utxolib.bitgo.UtxoTransaction);
 
-    await coin
-      .verifyTransaction({
-        txParams: {
-          walletPassphrase: passphrase,
-        },
-        txPrebuild: {
-          txHex: '00',
-        },
-        wallet: unsignedSendingWallet as any,
-      })
-      .should.eventually.be.true();
+    const result = await coin.verifyTransaction({
+      txParams: {
+        walletPassphrase: passphrase,
+      },
+      txPrebuild: {
+        txHex: '00',
+      },
+      wallet: unsignedSendingWallet as any,
+    });
+
+    assert.strictEqual(result, true);
 
     coinMock.restore();
     bitcoinMock.restore();
@@ -246,8 +251,8 @@ describe('Verify Transaction', function () {
       needsCustomChangeKeySignatureVerification: false,
     });
 
-    await coin
-      .verifyTransaction({
+    await assert.rejects(
+      coin.verifyTransaction({
         txParams: {
           walletPassphrase: passphrase,
         },
@@ -258,8 +263,9 @@ describe('Verify Transaction', function () {
         verification: {
           allowPaygoOutput: false,
         },
-      })
-      .should.be.rejectedWith('prebuild attempts to spend to unintended external recipients');
+      }),
+      /prebuild attempts to spend to unintended external recipients/
+    );
 
     coinMock.restore();
   });
@@ -282,18 +288,18 @@ describe('Verify Transaction', function () {
       .stub(coin, 'createTransactionFromHex')
       .returns({ ins: [] } as unknown as utxolib.bitgo.UtxoTransaction);
 
-    await coin
-      .verifyTransaction({
-        txParams: {
-          walletPassphrase: passphrase,
-        },
-        txPrebuild: {
-          txHex: '00',
-        },
-        wallet: unsignedSendingWallet as any,
-        verification: {},
-      })
-      .should.eventually.be.true();
+    const result = await coin.verifyTransaction({
+      txParams: {
+        walletPassphrase: passphrase,
+      },
+      txPrebuild: {
+        txHex: '00',
+      },
+      wallet: unsignedSendingWallet as any,
+      verification: {},
+    });
+
+    assert.strictEqual(result, true);
 
     coinMock.restore();
     bitcoinMock.restore();
@@ -330,18 +336,18 @@ describe('Verify Transaction', function () {
       .stub(bigintCoin, 'createTransactionFromHex')
       .returns({ ins: [] } as unknown as utxolib.bitgo.UtxoTransaction);
 
-    await bigintCoin
-      .verifyTransaction({
-        txParams: {
-          walletPassphrase: passphrase,
-        },
-        txPrebuild: {
-          txHex: '00',
-        },
-        wallet: unsignedSendingWallet as any,
-        verification: {},
-      })
-      .should.eventually.be.true();
+    const result = await bigintCoin.verifyTransaction({
+      txParams: {
+        walletPassphrase: passphrase,
+      },
+      txPrebuild: {
+        txHex: '00',
+      },
+      wallet: unsignedSendingWallet as any,
+      verification: {},
+    });
+
+    assert.strictEqual(result, true);
 
     coinMock.restore();
     bitcoinMock.restore();