Merge pull request #5695 from BitGo/WP-3785-multisigtype-is-require

fix(sdk-core): multisig type should not be a required type

Author: lokesh-bitgo

modules/abstract-cosmos/src/cosmosCoin.ts

@@ -9,6 +9,8 @@ import {
   InvalidMemoIdError,
   KeyPair,
   MPCAlgorithm,
+  MultisigType,
+  multisigTypes,
   ParsedTransaction,
   ParseTransactionOptions,
   SignedTransaction,
@@ -105,6 +107,11 @@ export class CosmosCoin extends BaseCoin {
     return true;
   }
 
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.tss;
+  }
+
   /** @inheritDoc **/
   getMPCAlgorithm(): MPCAlgorithm {
     return 'ecdsa';

modules/abstract-substrate/src/abstractSubstrateCoin.ts

@@ -13,6 +13,8 @@ import {
   MPCTx,
   MPCTxs,
   MPCUnsignedTx,
+  MultisigType,
+  multisigTypes,
   ParsedTransaction,
   ParseTransactionOptions,
   RecoveryTxRequest,
@@ -78,6 +80,11 @@ export class SubstrateCoin extends BaseCoin {
     return true;
   }
 
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.tss;
+  }
+
   /** @inheritDoc **/
   getMPCAlgorithm(): MPCAlgorithm {
     return 'eddsa';

modules/abstract-utxo/src/abstractUtxoCoin.ts

@@ -21,6 +21,8 @@ import {
   IWallet,
   KeychainsTriplet,
   KeyIndices,
+  MultisigType,
+  multisigTypes,
   P2shP2wshUnsupportedError,
   P2trMusig2UnsupportedError,
   P2trUnsupportedError,
@@ -693,6 +695,16 @@ export abstract class AbstractUtxoCoin extends BaseCoin {
     return utxolib.bitgo.outputScripts.isSupportedScriptType(this.network, addressType);
   }
 
+  /** {@inheritDoc } **/
+  supportsMultisig(): boolean {
+    return true;
+  }
+
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.onchain;
+  }
+
   /**
    * @param chain
    * @return true iff coin supports spending from chain

modules/bitgo/test/v2/unit/wallets.ts

@@ -25,6 +25,7 @@ import {
   BulkWalletShareOptions,
   KeychainWithEncryptedPrv,
   WalletWithKeychains,
+  multisigTypes,
 } from '@bitgo/sdk-core';
 import { BitGo } from '../../../src';
 import { afterEach } from 'mocha';
@@ -184,6 +185,7 @@ describe('V2 Wallets:', function () {
   });
 
   describe('Generate wallet:', function () {
+    const sandbox = sinon.createSandbox();
     it('should validate parameters', async function () {
       let params = {};
       await wallets.generateWallet(params).should.be.rejectedWith('Missing parameter: label');
@@ -475,6 +477,42 @@ describe('V2 Wallets:', function () {
         params.passphrase
       );
     });
+
+    it('should generate hot onchain wallet without passing multisig type', async () => {
+      const params: GenerateWalletOptions = {
+        label: 'test wallet',
+        passphrase: 'multisig password',
+        enterprise: 'enterprise',
+        passcodeEncryptionCode: 'originalPasscodeEncryptionCode',
+      };
+
+      const walletNock = nock(bgUrl)
+        .post('/api/v2/tbtc/wallet/add', function (body) {
+          body.type.should.equal('hot');
+          return true;
+        })
+        .reply(200);
+
+      nock(bgUrl)
+        .post('/api/v2/tbtc/key', _.matches({ source: 'bitgo' }))
+        .reply(200, { pub: 'bitgoPub' });
+      nock(bgUrl).post('/api/v2/tbtc/key', _.matches({})).reply(200);
+      nock(bgUrl)
+        .post('/api/v2/tbtc/key', _.matches({ source: 'backup' }))
+        .reply(200, { pub: 'backupPub' });
+
+      const generateWalletSpy = sandbox.spy(wallets, 'generateWallet');
+      const response = await wallets.generateWallet(params);
+      walletNock.isDone().should.be.true();
+      sinon.assert.calledOnce(generateWalletSpy);
+      assert.equal(generateWalletSpy.firstCall?.args[0]?.multisigType, multisigTypes.onchain);
+      assert.ok(response.encryptedWalletPassphrase);
+      assert.ok(response.wallet);
+      assert.equal(
+        bitgo.decrypt({ input: response.encryptedWalletPassphrase, password: params.passcodeEncryptionCode }),
+        params.passphrase
+      );
+    });
   });
 
   describe('Generate TSS wallet:', function () {
@@ -552,6 +590,58 @@ describe('V2 Wallets:', function () {
       );
     });
 
+    it('should create a new TSS wallet without passing multisig type', async function () {
+      const stubbedKeychainsTriplet: KeychainsTriplet = {
+        userKeychain: {
+          id: '1',
+          pub: 'userPub',
+          type: 'independent',
+          source: 'user',
+        },
+        backupKeychain: {
+          id: '2',
+          pub: 'userPub',
+          type: 'independent',
+          source: 'backup',
+        },
+        bitgoKeychain: {
+          id: '3',
+          pub: 'userPub',
+          type: 'independent',
+          source: 'bitgo',
+        },
+      };
+      sandbox.stub(TssUtils.prototype, 'createKeychains').resolves(stubbedKeychainsTriplet);
+
+      const walletNock = nock('https://bitgo.fakeurl')
+        .post('/api/v2/tsol/wallet/add', function (body) {
+          body.multisigType.should.equal(multisigTypes.tss);
+          return true;
+        })
+        .reply(200);
+
+      const wallets = new Wallets(bitgo, tsol);
+
+      const params = {
+        label: 'tss wallet',
+        passphrase: 'tss password',
+        enterprise: 'enterprise',
+        passcodeEncryptionCode: 'originalPasscodeEncryptionCode',
+      };
+
+      const generateWalletSpy = sandbox.spy(wallets, 'generateWallet');
+      const response = await wallets.generateWallet(params);
+      walletNock.isDone().should.be.true();
+      sinon.assert.calledOnce(generateWalletSpy);
+      assert.equal(generateWalletSpy.firstCall?.args[0]?.multisigType, multisigTypes.tss);
+      assert.ok(response.encryptedWalletPassphrase);
+      assert.ok(response.wallet);
+      assert.equal(
+        bitgo.decrypt({ input: response.encryptedWalletPassphrase, password: params.passcodeEncryptionCode }),
+        params.passphrase
+      );
+    });
+
     it('should create a new TSS wallet without providing passcodeEncryptionCode', async function () {
       const stubbedKeychainsTriplet: KeychainsTriplet = {
         userKeychain: {
@@ -961,6 +1051,62 @@ describe('V2 Wallets:', function () {
         );
       });
 
+      it(`should create a new ${coin} TSS MPCv2 hot wallet without passing multisig type`, async function () {
+        const testCoin = bitgo.coin(coin);
+        const stubbedKeychainsTriplet: KeychainsTriplet = {
+          userKeychain: {
+            id: '1',
+            commonKeychain: 'userPub',
+            type: 'tss',
+            source: 'user',
+          },
+          backupKeychain: {
+            id: '2',
+            commonKeychain: 'userPub',
+            type: 'tss',
+            source: 'backup',
+          },
+          bitgoKeychain: {
+            id: '3',
+            commonKeychain: 'userPub',
+            type: 'tss',
+            source: 'bitgo',
+          },
+        };
+        const stubCreateKeychains = sandbox
+          .stub(ECDSAUtils.EcdsaMPCv2Utils.prototype, 'createKeychains')
+          .resolves(stubbedKeychainsTriplet);
+
+        const walletNock = nock('https://bitgo.fakeurl')
+          .post(`/api/v2/${coin}/wallet/add`, function (body) {
+            body.multisigType.should.equal(multisigTypes.tss);
+            return true;
+          })
+          .reply(200);
+
+        const wallets = new Wallets(bitgo, testCoin);
+
+        const params = {
+          label: 'tss wallet',
+          passphrase: 'tss password',
+          enterprise: 'enterprise',
+          passcodeEncryptionCode: 'originalPasscodeEncryptionCode',
+          walletVersion: 3,
+        };
+
+        const response = await wallets.generateWallet(params);
+
+        walletNock.isDone().should.be.true();
+        stubCreateKeychains.calledOnce.should.be.true();
+
+        assert.ok(response.encryptedWalletPassphrase);
+        assert.ok(response.wallet);
+        assert.equal(
+          bitgo.decrypt({ input: response.encryptedWalletPassphrase, password: params.passcodeEncryptionCode }),
+          params.passphrase
+        );
+      });
+
       it(`should create a new ${coin} TSS MPCv2 cold wallet`, async function () {
         const testCoin = bitgo.coin(coin);
         const bitgoKeyId = 'key123';

modules/sdk-coin-ada/src/ada.ts

@@ -29,6 +29,8 @@ import {
   MPCTxs,
   PopulatedIntent,
   PrebuildTransactionWithIntentOptions,
+  MultisigType,
+  multisigTypes,
 } from '@bitgo/sdk-core';
 import { KeyPair as AdaKeyPair, Transaction, TransactionBuilderFactory, Utils } from './lib';
 import { BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';
@@ -602,6 +604,11 @@ export class Ada extends BaseCoin {
     return true;
   }
 
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.tss;
+  }
+
   /** inherited doc */
   getMPCAlgorithm(): MPCAlgorithm {
     return 'eddsa';

modules/sdk-coin-algo/src/algo.ts

@@ -27,6 +27,8 @@ import {
   VerifyAddressOptions,
   VerifyTransactionOptions,
   NotSupported,
+  MultisigType,
+  multisigTypes,
 } from '@bitgo/sdk-core';
 import stellar from 'stellar-sdk';
 import BigNumber from 'bignumber.js';
@@ -592,6 +594,16 @@ export class Algo extends BaseCoin {
     return false;
   }
 
+  /** {@inheritDoc } **/
+  supportsMultisig(): boolean {
+    return true;
+  }
+
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.onchain;
+  }
+
   /**
    * Gets config for how token enablements work for this coin
    * @returns

modules/sdk-coin-apt/src/apt.ts

@@ -5,6 +5,8 @@ import {
   InvalidAddressError,
   KeyPair,
   MPCAlgorithm,
+  MultisigType,
+  multisigTypes,
   ParsedTransaction,
   ParseTransactionOptions,
   SignedTransaction,
@@ -64,6 +66,11 @@ export class Apt extends BaseCoin {
     return true;
   }
 
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.tss;
+  }
+
   getMPCAlgorithm(): MPCAlgorithm {
     return 'eddsa';
   }

modules/sdk-coin-arbeth/src/arbeth.ts

@@ -1,7 +1,7 @@
 /**
  * @prettier
  */
-import { BaseCoin, BitGoBase, common } from '@bitgo/sdk-core';
+import { BaseCoin, BitGoBase, common, MultisigType, multisigTypes } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin, coins, ethGasConfigs } from '@bitgo/statics';
 import {
   AbstractEthLikeNewCoins,
@@ -51,4 +51,14 @@ export class Arbeth extends AbstractEthLikeNewCoins {
     }
     return userGasLimit;
   }
+
+  /** {@inheritDoc } **/
+  supportsMultisig(): boolean {
+    return true;
+  }
+
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.onchain;
+  }
 }

modules/sdk-coin-avaxc/src/avaxc.ts

@@ -25,6 +25,8 @@ import {
   InvalidAddressError,
   IWallet,
   KeyPair,
+  MultisigType,
+  multisigTypes,
   ParsedTransaction,
   ParseTransactionOptions,
   Recipient,
@@ -133,6 +135,16 @@ export class AvaxC extends AbstractEthLikeNewCoins {
     return false;
   }
 
+  /** {@inheritDoc } **/
+  supportsMultisig(): boolean {
+    return true;
+  }
+
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.onchain;
+  }
+
   generateKeyPair(seed?: Buffer): KeyPair {
     const avaxKeyPair = seed ? new AvaxcKeyPair({ seed }) : new AvaxcKeyPair();
     const extendedKeys = avaxKeyPair.getExtendedKeys();

modules/sdk-coin-avaxp/src/avaxp.ts

@@ -14,6 +14,8 @@ import {
   UnexpectedAddressError,
   ITransactionRecipient,
   ParsedTransaction,
+  MultisigType,
+  multisigTypes,
 } from '@bitgo/sdk-core';
 import * as AvaxpLib from './lib';
 import {
@@ -58,6 +60,16 @@ export class AvaxP extends BaseCoin {
     return Math.pow(10, this._staticsCoin.decimalPlaces);
   }
 
+  /** {@inheritDoc } **/
+  supportsMultisig(): boolean {
+    return true;
+  }
+
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.onchain;
+  }
+
   /**
    * Check if staking txn is valid, based on expected tx params.
    *