@bitgo-beta/sdk-core 8.2.1-beta.182 → 8.2.1-beta.1821

package/dist/test/unit/bitgo/utils/tss/eddsa/smcUtil.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=smcUtil.d.ts.map

package/dist/test/unit/bitgo/utils/tss/eddsa/smcUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smcUtil.d.ts","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/eddsa/smcUtil.ts"],"names":[],"mappings":""}

package/dist/test/unit/bitgo/utils/tss/eddsa/smcUtil.js

@@ -0,0 +1,311 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+const public_types_1 = require("@bitgo/public-types");
+const utils_1 = require("../../../../../../src/bitgo/utils/tss/eddsa/SMC/utils");
+describe('EdDSA MPCv2 SMC Utils:', function () {
+    const enterpriseId = '6449153a6f6bc20006d66771cdbe15d3';
+    const coinName = 'sol';
+    let smcUtils;
+    let mockBitgo;
+    let mockBaseCoin;
+    let keychainsStub;
+    let postChain;
+    const fakeSignedMessage = (suffix) => ({
+        message: Buffer.from(`message-${suffix}`).toString('base64'),
+        signature: `signature-${suffix}`,
+    });
+    const buildRound1Payload = (state = public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data) => ({
+        state,
+        tssVersion: '0.0.1',
+        walletType: public_types_1.WalletTypeEnum.tss,
+        coin: coinName,
+        ovc: {
+            [public_types_1.OVCIndexEnum.ONE]: {
+                gpgPubKey: 'user-gpg-pubkey',
+                ovcMsg1: fakeSignedMessage('user-1'),
+            },
+            [public_types_1.OVCIndexEnum.TWO]: {
+                gpgPubKey: 'backup-gpg-pubkey',
+                ovcMsg1: fakeSignedMessage('backup-1'),
+            },
+        },
+    });
+    const buildRound2Payload = (sessionId = 'test-session-id', state = public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data) => ({
+        state,
+        tssVersion: '0.0.1',
+        walletType: public_types_1.WalletTypeEnum.tss,
+        coin: coinName,
+        ovc: {
+            [public_types_1.OVCIndexEnum.ONE]: {
+                gpgPubKey: 'user-gpg-pubkey',
+                ovcMsg1: fakeSignedMessage('user-1'),
+                ovcMsg2: fakeSignedMessage('user-2'),
+            },
+            [public_types_1.OVCIndexEnum.TWO]: {
+                gpgPubKey: 'backup-gpg-pubkey',
+                ovcMsg1: fakeSignedMessage('backup-1'),
+                ovcMsg2: fakeSignedMessage('backup-2'),
+            },
+        },
+        platform: {
+            sessionId: sessionId,
+            bitgoMsg1: fakeSignedMessage('bitgo-1'),
+        },
+    });
+    beforeEach(function () {
+        postChain = {
+            send: sinon.stub().returnsThis(),
+            result: sinon.stub(),
+        };
+        mockBitgo = {
+            post: sinon.stub().returns(postChain),
+            url: sinon.stub().callsFake((path) => `/api/v2${path}`),
+        };
+        keychainsStub = {
+            get: sinon.stub(),
+            add: sinon.stub(),
+        };
+        mockBaseCoin = {
+            keychains: sinon.stub().returns(keychainsStub),
+        };
+        smcUtils = new utils_1.MPCv2SMCUtils(mockBitgo, mockBaseCoin);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('keyGenRound1BySender', function () {
+        it('returns a well-formed BitGo→OVC1 round 1 response on success', async function () {
+            const payload = buildRound1Payload();
+            const senderFn = sinon.stub().resolves({
+                sessionId: 'session-abc',
+                bitgoMsg1: fakeSignedMessage('bitgo-r1'),
+            });
+            const response = (await smcUtils.keyGenRound1BySender(senderFn, payload));
+            assert.strictEqual(response.state, public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data);
+            assert.strictEqual(response.tssVersion, payload.tssVersion);
+            assert.strictEqual(response.walletType, payload.walletType);
+            assert.strictEqual(response.coin, payload.coin);
+            assert.deepStrictEqual(response.ovc, payload.ovc);
+            assert.strictEqual(response.platform.sessionId, 'session-abc');
+            assert.deepStrictEqual(response.platform.bitgoMsg1, fakeSignedMessage('bitgo-r1'));
+            assert.ok(senderFn.calledOnce);
+            const [, senderPayload] = senderFn.firstCall.args;
+            assert.strictEqual(senderPayload.userGpgPublicKey, payload.ovc[public_types_1.OVCIndexEnum.ONE].gpgPubKey);
+            assert.strictEqual(senderPayload.backupGpgPublicKey, payload.ovc[public_types_1.OVCIndexEnum.TWO].gpgPubKey);
+            assert.deepStrictEqual(senderPayload.userMsg1, payload.ovc[public_types_1.OVCIndexEnum.ONE].ovcMsg1);
+            assert.deepStrictEqual(senderPayload.backupMsg1, payload.ovc[public_types_1.OVCIndexEnum.TWO].ovcMsg1);
+        });
+        it('rejects when the payload state is not WaitingForBitgoRound1Data', async function () {
+            const payload = buildRound1Payload(public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data);
+            const senderFn = sinon.stub().rejects(new Error('sender should not be invoked'));
+            await assert.rejects(smcUtils.keyGenRound1BySender(senderFn, payload), {
+                message: `Invalid state for round 1, expected: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,
+            });
+            assert.ok(senderFn.notCalled);
+        });
+        it('rejects when the response is malformed (sessionId empty)', async function () {
+            const payload = buildRound1Payload();
+            const senderFn = sinon.stub().resolves({
+                sessionId: '',
+                bitgoMsg1: fakeSignedMessage('bitgo-r1'),
+            });
+            await assert.rejects(smcUtils.keyGenRound1BySender(senderFn, payload), /error\(s\) parsing response/);
+        });
+    });
+    describe('keyGenRound2BySender', function () {
+        beforeEach(function () {
+            const fakeKeychain = {
+                id: 'bitgo-keychain-id',
+                source: 'bitgo',
+                type: 'tss',
+                commonKeychain: 'a'.repeat(64),
+            };
+            keychainsStub.add.resolves(fakeKeychain);
+        });
+        it('returns a well-formed BitGo→OVC1 round 2 response and adds the BitGo keychain', async function () {
+            const payload = buildRound2Payload('session-xyz');
+            const senderFn = sinon.stub().resolves({
+                sessionId: 'session-xyz',
+                commonPublicKeychain: 'a'.repeat(64),
+                bitgoMsg2: fakeSignedMessage('bitgo-r2'),
+            });
+            const response = (await smcUtils.keyGenRound2BySender(senderFn, payload));
+            assert.strictEqual(response.state, public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey);
+            assert.strictEqual(response.bitGoKeyId, 'bitgo-keychain-id');
+            assert.strictEqual(response.tssVersion, payload.tssVersion);
+            assert.strictEqual(response.walletType, payload.walletType);
+            assert.strictEqual(response.coin, payload.coin);
+            assert.deepStrictEqual(response.ovc, payload.ovc);
+            assert.strictEqual(response.platform.sessionId, 'session-xyz');
+            assert.strictEqual(response.platform.commonPublicKeychain, 'a'.repeat(64));
+            assert.deepStrictEqual(response.platform.bitgoMsg1, payload.platform.bitgoMsg1);
+            assert.deepStrictEqual(response.platform.bitgoMsg2, fakeSignedMessage('bitgo-r2'));
+            const [, senderPayload] = senderFn.firstCall.args;
+            assert.strictEqual(senderPayload.sessionId, 'session-xyz');
+            assert.deepStrictEqual(senderPayload.userMsg2, payload.ovc[public_types_1.OVCIndexEnum.ONE].ovcMsg2);
+            assert.deepStrictEqual(senderPayload.backupMsg2, payload.ovc[public_types_1.OVCIndexEnum.TWO].ovcMsg2);
+            // BitGo keychain is added with the keychain from the round-2 response
+            assert.ok(keychainsStub.add.calledOnce);
+            assert.deepStrictEqual(keychainsStub.add.firstCall.args[0], {
+                source: 'bitgo',
+                keyType: 'tss',
+                commonKeychain: 'a'.repeat(64),
+                isMPCv2: true,
+            });
+        });
+        it('rejects when the payload state is not WaitingForBitgoRound2Data', async function () {
+            const payload = buildRound2Payload('session-xyz', public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC2Round2Data);
+            const senderFn = sinon.stub().rejects(new Error('sender should not be invoked'));
+            await assert.rejects(smcUtils.keyGenRound2BySender(senderFn, payload), {
+                message: `Invalid state for round 2, expected: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC2Round2Data}`,
+            });
+            assert.ok(senderFn.notCalled);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+        it('rejects when session IDs returned by BitGo do not match the payload', async function () {
+            const payload = buildRound2Payload('session-xyz');
+            const senderFn = sinon.stub().resolves({
+                sessionId: 'different-session-id',
+                commonPublicKeychain: 'a'.repeat(64),
+                bitgoMsg2: fakeSignedMessage('bitgo-r2'),
+            });
+            await assert.rejects(smcUtils.keyGenRound2BySender(senderFn, payload), /Round 1 and round 2 session IDs do not match/);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+    });
+    describe('keyGenRound1 (enterprise)', function () {
+        it('rejects for an invalid payload state without calling the API', async function () {
+            const invalidPayload = {
+                state: public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,
+            };
+            await assert.rejects(smcUtils.keyGenRound1(enterpriseId, invalidPayload), {
+                message: `Invalid state for round 1, expected: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,
+            });
+            assert.ok(mockBitgo.post.notCalled);
+        });
+        it('POSTs to the MPCv2 generatekey endpoint and returns a parsed round 1 response', async function () {
+            const payload = buildRound1Payload();
+            postChain.result.resolves({
+                sessionId: 'enterprise-session',
+                bitgoMsg1: fakeSignedMessage('bitgo-r1'),
+            });
+            const response = await smcUtils.keyGenRound1(enterpriseId, payload);
+            assert.ok(mockBitgo.post.calledOnce);
+            assert.strictEqual(mockBitgo.post.firstCall.args[0], '/api/v2/mpc/generatekey');
+            const sentBody = postChain.send.firstCall.args[0];
+            assert.strictEqual(sentBody.enterprise, enterpriseId);
+            assert.strictEqual(sentBody.round, 'MPCv2-R1');
+            assert.strictEqual(sentBody.payload.userGpgPublicKey, payload.ovc[public_types_1.OVCIndexEnum.ONE].gpgPubKey);
+            assert.strictEqual(sentBody.payload.backupGpgPublicKey, payload.ovc[public_types_1.OVCIndexEnum.TWO].gpgPubKey);
+            assert.strictEqual(response.state, public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data);
+            assert.strictEqual(response.platform.sessionId, 'enterprise-session');
+        });
+    });
+    describe('keyGenRound2 (enterprise)', function () {
+        it('rejects for an invalid payload state without calling the API', async function () {
+            const invalidPayload = {
+                state: public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,
+            };
+            await assert.rejects(smcUtils.keyGenRound2(enterpriseId, invalidPayload), {
+                message: `Invalid state for round 2, expected: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${public_types_1.EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,
+            });
+            assert.ok(mockBitgo.post.notCalled);
+        });
+    });
+    describe('uploadClientKeys', function () {
+        const bitgoKeyId = 'bitgo-key-id';
+        const commonKeychain = 'a'.repeat(64);
+        it('uploads user/backup keychains and returns the triplet on the happy path', async function () {
+            const bitgoKeychain = { id: bitgoKeyId, type: 'tss', source: 'bitgo', commonKeychain };
+            const userKeychain = { id: 'user-id', type: 'tss', source: 'user', commonKeychain };
+            const backupKeychain = { id: 'backup-id', type: 'tss', source: 'backup', commonKeychain };
+            keychainsStub.get.resolves(bitgoKeychain);
+            keychainsStub.add.withArgs(sinon.match({ source: 'user' })).resolves(userKeychain);
+            keychainsStub.add.withArgs(sinon.match({ source: 'backup' })).resolves(backupKeychain);
+            const result = await smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain);
+            assert.deepStrictEqual(result.userKeychain, userKeychain);
+            assert.deepStrictEqual(result.backupKeychain, backupKeychain);
+            assert.deepStrictEqual(result.bitgoKeychain, bitgoKeychain);
+            assert.ok(keychainsStub.get.calledOnceWithExactly({ id: bitgoKeyId }));
+            assert.strictEqual(keychainsStub.add.callCount, 2);
+            assert.deepStrictEqual(keychainsStub.add.firstCall.args[0], {
+                source: 'user',
+                keyType: 'tss',
+                commonKeychain,
+                isMPCv2: true,
+            });
+            assert.deepStrictEqual(keychainsStub.add.secondCall.args[0], {
+                source: 'backup',
+                keyType: 'tss',
+                commonKeychain,
+                isMPCv2: true,
+            });
+        });
+        it('rejects when user and backup common keychains differ', async function () {
+            await assert.rejects(smcUtils.uploadClientKeys(bitgoKeyId, 'a'.repeat(64), 'b'.repeat(64)), /Common keychain mismatch between the user and backup keychains/);
+            assert.ok(keychainsStub.get.notCalled);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+        it('rejects when the BitGo keychain cannot be found', async function () {
+            keychainsStub.get.resolves(undefined);
+            await assert.rejects(smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain), /Keychain not found/);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+        it('rejects when the fetched keychain is not a BitGo-source keychain', async function () {
+            keychainsStub.get.resolves({ id: bitgoKeyId, type: 'tss', source: 'user', commonKeychain });
+            await assert.rejects(smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain), /The keychain is not a BitGo keychain/);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+        it('rejects when the fetched keychain is not a TSS keychain', async function () {
+            keychainsStub.get.resolves({ id: bitgoKeyId, type: 'independent', source: 'bitgo', commonKeychain });
+            await assert.rejects(smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain), /BitGo keychain is not a TSS keychain/);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+        it('rejects when the BitGo keychain has no commonKeychain', async function () {
+            keychainsStub.get.resolves({ id: bitgoKeyId, type: 'tss', source: 'bitgo' });
+            await assert.rejects(smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain), /BitGo keychain does not have a common keychain/);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+        it('rejects when OVC-supplied common keychain does not match BitGo', async function () {
+            keychainsStub.get.resolves({ id: bitgoKeyId, type: 'tss', source: 'bitgo', commonKeychain: 'c'.repeat(64) });
+            await assert.rejects(smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain), /Common keychain mismatch between the OVCs and BitGo/);
+            assert.ok(keychainsStub.add.notCalled);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smcUtil.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/eddsa/smcUtil.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { NonEmptyString } from 'io-ts-types';\nimport {\n  EddsaBitgoToOVC1Round1Response,\n  EddsaBitgoToOVC1Round2Response,\n  EddsaKeyCreationMPCv2StateEnum,\n  EddsaMPCv2KeyGenRound1Response,\n  EddsaMPCv2KeyGenRound2Response,\n  EddsaOVC1ToBitgoRound1Payload,\n  EddsaOVC2ToBitgoRound2Payload,\n  OVCIndexEnum,\n  WalletTypeEnum,\n} from '@bitgo/public-types';\nimport { BitGoBase, IBaseCoin } from '../../../../../../src';\nimport { MPCv2SMCUtils } from '../../../../../../src/bitgo/utils/tss/eddsa/SMC/utils';\n\ndescribe('EdDSA MPCv2 SMC Utils:', function () {\n  const enterpriseId = '6449153a6f6bc20006d66771cdbe15d3';\n  const coinName = 'sol';\n\n  let smcUtils: MPCv2SMCUtils;\n  let mockBitgo: BitGoBase;\n  let mockBaseCoin: IBaseCoin;\n  let keychainsStub: { get: sinon.SinonStub; add: sinon.SinonStub };\n  let postChain: { send: sinon.SinonStub; result: sinon.SinonStub };\n\n  const fakeSignedMessage = (suffix: string) => ({\n    message: Buffer.from(`message-${suffix}`).toString('base64'),\n    signature: `signature-${suffix}`,\n  });\n\n  const buildRound1Payload = (\n    state: EddsaKeyCreationMPCv2StateEnum = EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data\n  ): EddsaOVC1ToBitgoRound1Payload =>\n    ({\n      state,\n      tssVersion: '0.0.1' as NonEmptyString,\n      walletType: WalletTypeEnum.tss,\n      coin: coinName as NonEmptyString,\n      ovc: {\n        [OVCIndexEnum.ONE]: {\n          gpgPubKey: 'user-gpg-pubkey' as NonEmptyString,\n          ovcMsg1: fakeSignedMessage('user-1'),\n        },\n        [OVCIndexEnum.TWO]: {\n          gpgPubKey: 'backup-gpg-pubkey' as NonEmptyString,\n          ovcMsg1: fakeSignedMessage('backup-1'),\n        },\n      },\n    } as EddsaOVC1ToBitgoRound1Payload);\n\n  const buildRound2Payload = (\n    sessionId = 'test-session-id',\n    state: EddsaKeyCreationMPCv2StateEnum = EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data\n  ): EddsaOVC2ToBitgoRound2Payload =>\n    ({\n      state,\n      tssVersion: '0.0.1' as NonEmptyString,\n      walletType: WalletTypeEnum.tss,\n      coin: coinName as NonEmptyString,\n      ovc: {\n        [OVCIndexEnum.ONE]: {\n          gpgPubKey: 'user-gpg-pubkey' as NonEmptyString,\n          ovcMsg1: fakeSignedMessage('user-1'),\n          ovcMsg2: fakeSignedMessage('user-2'),\n        },\n        [OVCIndexEnum.TWO]: {\n          gpgPubKey: 'backup-gpg-pubkey' as NonEmptyString,\n          ovcMsg1: fakeSignedMessage('backup-1'),\n          ovcMsg2: fakeSignedMessage('backup-2'),\n        },\n      },\n      platform: {\n        sessionId: sessionId as NonEmptyString,\n        bitgoMsg1: fakeSignedMessage('bitgo-1'),\n      },\n    } as EddsaOVC2ToBitgoRound2Payload);\n\n  beforeEach(function () {\n    postChain = {\n      send: sinon.stub().returnsThis(),\n      result: sinon.stub(),\n    };\n    mockBitgo = {\n      post: sinon.stub().returns(postChain),\n      url: sinon.stub().callsFake((path: string) => `/api/v2${path}`),\n    } as unknown as BitGoBase;\n\n    keychainsStub = {\n      get: sinon.stub(),\n      add: sinon.stub(),\n    };\n    mockBaseCoin = {\n      keychains: sinon.stub().returns(keychainsStub),\n    } as unknown as IBaseCoin;\n\n    smcUtils = new MPCv2SMCUtils(mockBitgo, mockBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('keyGenRound1BySender', function () {\n    it('returns a well-formed BitGo→OVC1 round 1 response on success', async function () {\n      const payload = buildRound1Payload();\n      const senderFn = sinon.stub().resolves({\n        sessionId: 'session-abc' as NonEmptyString,\n        bitgoMsg1: fakeSignedMessage('bitgo-r1'),\n      } as EddsaMPCv2KeyGenRound1Response);\n\n      const response = (await smcUtils.keyGenRound1BySender(\n        senderFn as never,\n        payload\n      )) as EddsaBitgoToOVC1Round1Response;\n\n      assert.strictEqual(response.state, EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data);\n      assert.strictEqual(response.tssVersion, payload.tssVersion);\n      assert.strictEqual(response.walletType, payload.walletType);\n      assert.strictEqual(response.coin, payload.coin);\n      assert.deepStrictEqual(response.ovc, payload.ovc);\n      assert.strictEqual(response.platform.sessionId, 'session-abc');\n      assert.deepStrictEqual(response.platform.bitgoMsg1, fakeSignedMessage('bitgo-r1'));\n      assert.ok(senderFn.calledOnce);\n\n      const [, senderPayload] = senderFn.firstCall.args as [unknown, Record<string, unknown>];\n      assert.strictEqual(senderPayload.userGpgPublicKey, payload.ovc[OVCIndexEnum.ONE].gpgPubKey);\n      assert.strictEqual(senderPayload.backupGpgPublicKey, payload.ovc[OVCIndexEnum.TWO].gpgPubKey);\n      assert.deepStrictEqual(senderPayload.userMsg1, payload.ovc[OVCIndexEnum.ONE].ovcMsg1);\n      assert.deepStrictEqual(senderPayload.backupMsg1, payload.ovc[OVCIndexEnum.TWO].ovcMsg1);\n    });\n\n    it('rejects when the payload state is not WaitingForBitgoRound1Data', async function () {\n      const payload = buildRound1Payload(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data);\n      const senderFn = sinon.stub().rejects(new Error('sender should not be invoked'));\n\n      await assert.rejects(smcUtils.keyGenRound1BySender(senderFn as never, payload), {\n        message: `Invalid state for round 1, expected: ${EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,\n      });\n      assert.ok(senderFn.notCalled);\n    });\n\n    it('rejects when the response is malformed (sessionId empty)', async function () {\n      const payload = buildRound1Payload();\n      const senderFn = sinon.stub().resolves({\n        sessionId: '' as unknown as NonEmptyString,\n        bitgoMsg1: fakeSignedMessage('bitgo-r1'),\n      });\n\n      await assert.rejects(smcUtils.keyGenRound1BySender(senderFn as never, payload), /error\\(s\\) parsing response/);\n    });\n  });\n\n  describe('keyGenRound2BySender', function () {\n    beforeEach(function () {\n      const fakeKeychain = {\n        id: 'bitgo-keychain-id',\n        source: 'bitgo',\n        type: 'tss' as const,\n        commonKeychain: 'a'.repeat(64),\n      };\n      keychainsStub.add.resolves(fakeKeychain);\n    });\n\n    it('returns a well-formed BitGo→OVC1 round 2 response and adds the BitGo keychain', async function () {\n      const payload = buildRound2Payload('session-xyz');\n      const senderFn = sinon.stub().resolves({\n        sessionId: 'session-xyz' as NonEmptyString,\n        commonPublicKeychain: 'a'.repeat(64) as NonEmptyString,\n        bitgoMsg2: fakeSignedMessage('bitgo-r2'),\n      } as EddsaMPCv2KeyGenRound2Response);\n\n      const response = (await smcUtils.keyGenRound2BySender(\n        senderFn as never,\n        payload\n      )) as EddsaBitgoToOVC1Round2Response;\n\n      assert.strictEqual(response.state, EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey);\n      assert.strictEqual(response.bitGoKeyId, 'bitgo-keychain-id');\n      assert.strictEqual(response.tssVersion, payload.tssVersion);\n      assert.strictEqual(response.walletType, payload.walletType);\n      assert.strictEqual(response.coin, payload.coin);\n      assert.deepStrictEqual(response.ovc, payload.ovc);\n      assert.strictEqual(response.platform.sessionId, 'session-xyz');\n      assert.strictEqual(response.platform.commonPublicKeychain, 'a'.repeat(64));\n      assert.deepStrictEqual(response.platform.bitgoMsg1, payload.platform.bitgoMsg1);\n      assert.deepStrictEqual(response.platform.bitgoMsg2, fakeSignedMessage('bitgo-r2'));\n\n      const [, senderPayload] = senderFn.firstCall.args as [unknown, Record<string, unknown>];\n      assert.strictEqual(senderPayload.sessionId, 'session-xyz');\n      assert.deepStrictEqual(senderPayload.userMsg2, payload.ovc[OVCIndexEnum.ONE].ovcMsg2);\n      assert.deepStrictEqual(senderPayload.backupMsg2, payload.ovc[OVCIndexEnum.TWO].ovcMsg2);\n\n      // BitGo keychain is added with the keychain from the round-2 response\n      assert.ok(keychainsStub.add.calledOnce);\n      assert.deepStrictEqual(keychainsStub.add.firstCall.args[0], {\n        source: 'bitgo',\n        keyType: 'tss',\n        commonKeychain: 'a'.repeat(64),\n        isMPCv2: true,\n      });\n    });\n\n    it('rejects when the payload state is not WaitingForBitgoRound2Data', async function () {\n      const payload = buildRound2Payload('session-xyz', EddsaKeyCreationMPCv2StateEnum.WaitingForOVC2Round2Data);\n      const senderFn = sinon.stub().rejects(new Error('sender should not be invoked'));\n\n      await assert.rejects(smcUtils.keyGenRound2BySender(senderFn as never, payload), {\n        message: `Invalid state for round 2, expected: ${EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${EddsaKeyCreationMPCv2StateEnum.WaitingForOVC2Round2Data}`,\n      });\n      assert.ok(senderFn.notCalled);\n      assert.ok(keychainsStub.add.notCalled);\n    });\n\n    it('rejects when session IDs returned by BitGo do not match the payload', async function () {\n      const payload = buildRound2Payload('session-xyz');\n      const senderFn = sinon.stub().resolves({\n        sessionId: 'different-session-id' as NonEmptyString,\n        commonPublicKeychain: 'a'.repeat(64) as NonEmptyString,\n        bitgoMsg2: fakeSignedMessage('bitgo-r2'),\n      } as EddsaMPCv2KeyGenRound2Response);\n\n      await assert.rejects(\n        smcUtils.keyGenRound2BySender(senderFn as never, payload),\n        /Round 1 and round 2 session IDs do not match/\n      );\n      assert.ok(keychainsStub.add.notCalled);\n    });\n  });\n\n  describe('keyGenRound1 (enterprise)', function () {\n    it('rejects for an invalid payload state without calling the API', async function () {\n      const invalidPayload = {\n        state: EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,\n      } as unknown as EddsaOVC1ToBitgoRound1Payload;\n\n      await assert.rejects(smcUtils.keyGenRound1(enterpriseId, invalidPayload), {\n        message: `Invalid state for round 1, expected: ${EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,\n      });\n      assert.ok((mockBitgo.post as sinon.SinonStub).notCalled);\n    });\n\n    it('POSTs to the MPCv2 generatekey endpoint and returns a parsed round 1 response', async function () {\n      const payload = buildRound1Payload();\n      postChain.result.resolves({\n        sessionId: 'enterprise-session',\n        bitgoMsg1: fakeSignedMessage('bitgo-r1'),\n      });\n\n      const response = await smcUtils.keyGenRound1(enterpriseId, payload);\n\n      assert.ok((mockBitgo.post as sinon.SinonStub).calledOnce);\n      assert.strictEqual((mockBitgo.post as sinon.SinonStub).firstCall.args[0], '/api/v2/mpc/generatekey');\n      const sentBody = postChain.send.firstCall.args[0] as {\n        enterprise: string;\n        round: string;\n        payload: { userGpgPublicKey: string; backupGpgPublicKey: string };\n      };\n      assert.strictEqual(sentBody.enterprise, enterpriseId);\n      assert.strictEqual(sentBody.round, 'MPCv2-R1');\n      assert.strictEqual(sentBody.payload.userGpgPublicKey, payload.ovc[OVCIndexEnum.ONE].gpgPubKey);\n      assert.strictEqual(sentBody.payload.backupGpgPublicKey, payload.ovc[OVCIndexEnum.TWO].gpgPubKey);\n\n      assert.strictEqual(response.state, EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data);\n      assert.strictEqual(response.platform.sessionId, 'enterprise-session');\n    });\n  });\n\n  describe('keyGenRound2 (enterprise)', function () {\n    it('rejects for an invalid payload state without calling the API', async function () {\n      const invalidPayload = {\n        state: EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,\n      } as unknown as EddsaOVC2ToBitgoRound2Payload;\n\n      await assert.rejects(smcUtils.keyGenRound2(enterpriseId, invalidPayload), {\n        message: `Invalid state for round 2, expected: ${EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,\n      });\n      assert.ok((mockBitgo.post as sinon.SinonStub).notCalled);\n    });\n  });\n\n  describe('uploadClientKeys', function () {\n    const bitgoKeyId = 'bitgo-key-id';\n    const commonKeychain = 'a'.repeat(64);\n\n    it('uploads user/backup keychains and returns the triplet on the happy path', async function () {\n      const bitgoKeychain = { id: bitgoKeyId, type: 'tss', source: 'bitgo', commonKeychain };\n      const userKeychain = { id: 'user-id', type: 'tss', source: 'user', commonKeychain };\n      const backupKeychain = { id: 'backup-id', type: 'tss', source: 'backup', commonKeychain };\n\n      keychainsStub.get.resolves(bitgoKeychain);\n      keychainsStub.add.withArgs(sinon.match({ source: 'user' })).resolves(userKeychain);\n      keychainsStub.add.withArgs(sinon.match({ source: 'backup' })).resolves(backupKeychain);\n\n      const result = await smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain);\n\n      assert.deepStrictEqual(result.userKeychain, userKeychain);\n      assert.deepStrictEqual(result.backupKeychain, backupKeychain);\n      assert.deepStrictEqual(result.bitgoKeychain, bitgoKeychain);\n\n      assert.ok(keychainsStub.get.calledOnceWithExactly({ id: bitgoKeyId }));\n      assert.strictEqual(keychainsStub.add.callCount, 2);\n      assert.deepStrictEqual(keychainsStub.add.firstCall.args[0], {\n        source: 'user',\n        keyType: 'tss',\n        commonKeychain,\n        isMPCv2: true,\n      });\n      assert.deepStrictEqual(keychainsStub.add.secondCall.args[0], {\n        source: 'backup',\n        keyType: 'tss',\n        commonKeychain,\n        isMPCv2: true,\n      });\n    });\n\n    it('rejects when user and backup common keychains differ', async function () {\n      await assert.rejects(\n        smcUtils.uploadClientKeys(bitgoKeyId, 'a'.repeat(64), 'b'.repeat(64)),\n        /Common keychain mismatch between the user and backup keychains/\n      );\n      assert.ok(keychainsStub.get.notCalled);\n      assert.ok(keychainsStub.add.notCalled);\n    });\n\n    it('rejects when the BitGo keychain cannot be found', async function () {\n      keychainsStub.get.resolves(undefined);\n\n      await assert.rejects(smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain), /Keychain not found/);\n      assert.ok(keychainsStub.add.notCalled);\n    });\n\n    it('rejects when the fetched keychain is not a BitGo-source keychain', async function () {\n      keychainsStub.get.resolves({ id: bitgoKeyId, type: 'tss', source: 'user', commonKeychain });\n\n      await assert.rejects(\n        smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain),\n        /The keychain is not a BitGo keychain/\n      );\n      assert.ok(keychainsStub.add.notCalled);\n    });\n\n    it('rejects when the fetched keychain is not a TSS keychain', async function () {\n      keychainsStub.get.resolves({ id: bitgoKeyId, type: 'independent', source: 'bitgo', commonKeychain });\n\n      await assert.rejects(\n        smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain),\n        /BitGo keychain is not a TSS keychain/\n      );\n      assert.ok(keychainsStub.add.notCalled);\n    });\n\n    it('rejects when the BitGo keychain has no commonKeychain', async function () {\n      keychainsStub.get.resolves({ id: bitgoKeyId, type: 'tss', source: 'bitgo' });\n\n      await assert.rejects(\n        smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain),\n        /BitGo keychain does not have a common keychain/\n      );\n      assert.ok(keychainsStub.add.notCalled);\n    });\n\n    it('rejects when OVC-supplied common keychain does not match BitGo', async function () {\n      keychainsStub.get.resolves({ id: bitgoKeyId, type: 'tss', source: 'bitgo', commonKeychain: 'c'.repeat(64) });\n\n      await assert.rejects(\n        smcUtils.uploadClientKeys(bitgoKeyId, commonKeychain, commonKeychain),\n        /Common keychain mismatch between the OVCs and BitGo/\n      );\n      assert.ok(keychainsStub.add.notCalled);\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/utils/txRequest.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=txRequest.d.ts.map

package/dist/test/unit/bitgo/utils/txRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txRequest.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/utils/txRequest.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,CAAC"}

package/dist/test/unit/bitgo/utils/txRequest.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const txRequest_1 = require("../../../../src/bitgo/utils/txRequest");
+describe('txRequest utils', () => {
+    describe('getTxRequestApiVersion', function () {
+        const testCases = [
+            {
+                wallet: {
+                    baseCoin: { getMPCAlgorithm: () => 'ecdsa' },
+                    type: () => 'hot',
+                    multisigType: () => 'tss',
+                    multisigTypeVersion: () => undefined,
+                },
+                requestedApiVersion: 'lite',
+                expectedApiVersion: '',
+                expectedErrorMessage: 'For ECDSA tss wallets, parameter `apiVersion` must be `full`.',
+            },
+            {
+                wallet: {
+                    baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                    type: () => 'cold',
+                    multisigType: () => 'tss',
+                    multisigTypeVersion: () => undefined,
+                },
+                requestedApiVersion: 'lite',
+                expectedApiVersion: '',
+                expectedErrorMessage: 'For non self-custodial (hot) tss wallets, parameter `apiVersion` must be `full`.',
+            },
+            {
+                wallet: {
+                    baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                    type: () => 'hot',
+                    multisigType: () => 'tss',
+                    multisigTypeVersion: () => undefined,
+                },
+                requestedApiVersion: undefined,
+                expectedApiVersion: 'lite',
+                expectedErrorMessage: '',
+            },
+            {
+                wallet: {
+                    baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                    type: () => 'hot',
+                    multisigType: () => 'tss',
+                    multisigTypeVersion: () => 'MPCv2',
+                },
+                requestedApiVersion: 'lite',
+                expectedApiVersion: '',
+                expectedErrorMessage: 'For EdDSA MPCv2 tss wallets, parameter `apiVersion` must be `full`.',
+            },
+            {
+                wallet: {
+                    baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                    type: () => 'hot',
+                    multisigType: () => 'tss',
+                    multisigTypeVersion: () => 'MPCv2',
+                },
+                requestedApiVersion: undefined,
+                expectedApiVersion: 'full',
+                expectedErrorMessage: '',
+            },
+            ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {
+                return {
+                    wallet: {
+                        baseCoin: { getMPCAlgorithm: () => 'ecdsa' },
+                        type: () => walletType,
+                        multisigType: () => 'tss',
+                        multisigTypeVersion: () => undefined,
+                    },
+                    requestedApiVersion: 'full',
+                    expectedApiVersion: 'full',
+                    expectedErrorMessage: '',
+                    shouldThrow: false,
+                };
+            }),
+            ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {
+                return {
+                    wallet: {
+                        baseCoin: { getMPCAlgorithm: () => 'ecdsa' },
+                        type: () => walletType,
+                        multisigType: () => 'tss',
+                        multisigTypeVersion: () => undefined,
+                    },
+                    requestedApiVersion: undefined,
+                    expectedApiVersion: 'full',
+                    expectedErrorMessage: '',
+                    shouldThrow: false,
+                };
+            }),
+            ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {
+                return {
+                    wallet: {
+                        baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                        type: () => walletType,
+                        multisigType: () => 'tss',
+                        multisigTypeVersion: () => undefined,
+                    },
+                    requestedApiVersion: 'full',
+                    expectedApiVersion: 'full',
+                    expectedErrorMessage: '',
+                    shouldThrow: false,
+                };
+            }),
+            ...['cold', 'custodial', 'backing'].map((walletType) => {
+                return {
+                    wallet: {
+                        baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                        type: () => walletType,
+                        multisigType: () => 'tss',
+                        multisigTypeVersion: () => undefined,
+                    },
+                    requestedApiVersion: undefined,
+                    expectedApiVersion: 'full',
+                    expectedErrorMessage: '',
+                    shouldThrow: false,
+                };
+            }),
+            // EdDSA MPCv2: all wallet types + 'full' explicitly → returns 'full'
+            ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {
+                return {
+                    wallet: {
+                        baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                        type: () => walletType,
+                        multisigType: () => 'tss',
+                        multisigTypeVersion: () => 'MPCv2',
+                    },
+                    requestedApiVersion: 'full',
+                    expectedApiVersion: 'full',
+                    expectedErrorMessage: '',
+                    shouldThrow: false,
+                };
+            }),
+            // EdDSA MPCv2: non-hot wallet types + undefined → defaults to 'full'
+            ...['cold', 'custodial', 'backing'].map((walletType) => {
+                return {
+                    wallet: {
+                        baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                        type: () => walletType,
+                        multisigType: () => 'tss',
+                        multisigTypeVersion: () => 'MPCv2',
+                    },
+                    requestedApiVersion: undefined,
+                    expectedApiVersion: 'full',
+                    expectedErrorMessage: '',
+                    shouldThrow: false,
+                };
+            }),
+            // EdDSA MPCv2: non-hot wallet types + 'lite' → throws EdDSA MPCv2 error
+            ...['cold', 'custodial', 'backing'].map((walletType) => {
+                return {
+                    wallet: {
+                        baseCoin: { getMPCAlgorithm: () => 'eddsa' },
+                        type: () => walletType,
+                        multisigType: () => 'tss',
+                        multisigTypeVersion: () => 'MPCv2',
+                    },
+                    requestedApiVersion: 'lite',
+                    expectedApiVersion: '',
+                    expectedErrorMessage: 'For EdDSA MPCv2 tss wallets, parameter `apiVersion` must be `full`.',
+                    shouldThrow: true,
+                };
+            }),
+        ];
+        testCases.forEach((testCase) => {
+            if (testCase.expectedErrorMessage) {
+                it(`should throw an error if requested apiVersion is ${testCase.requestedApiVersion} for wallet type ${testCase.wallet.type()} for a ${testCase.wallet.baseCoin.getMPCAlgorithm()} wallet`, () => {
+                    (() => (0, txRequest_1.getTxRequestApiVersion)(testCase.wallet, testCase.requestedApiVersion)).should.throw(testCase.expectedErrorMessage);
+                });
+            }
+            else {
+                it(`should return ${testCase.expectedApiVersion} if requested apiVersion is ${testCase.requestedApiVersion} for wallet type ${testCase.wallet.type()} for a ${testCase.wallet.baseCoin.getMPCAlgorithm()} wallet`, () => {
+                    (0, txRequest_1.getTxRequestApiVersion)(testCase.wallet, testCase.requestedApiVersion).should.equal(testCase.expectedApiVersion);
+                });
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"txRequest.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/utils/txRequest.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { ApiVersion, IWallet } from '../../../../src';\nimport { getTxRequestApiVersion } from '../../../../src/bitgo/utils/txRequest';\n\ndescribe('txRequest utils', () => {\n  describe('getTxRequestApiVersion', function () {\n    const testCases = [\n      {\n        wallet: {\n          baseCoin: { getMPCAlgorithm: () => 'ecdsa' },\n          type: () => 'hot',\n          multisigType: () => 'tss',\n          multisigTypeVersion: () => undefined,\n        } as any as IWallet,\n        requestedApiVersion: 'lite',\n        expectedApiVersion: '',\n        expectedErrorMessage: 'For ECDSA tss wallets, parameter `apiVersion` must be `full`.',\n      },\n      {\n        wallet: {\n          baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n          type: () => 'cold',\n          multisigType: () => 'tss',\n          multisigTypeVersion: () => undefined,\n        } as any as IWallet,\n        requestedApiVersion: 'lite',\n        expectedApiVersion: '',\n        expectedErrorMessage: 'For non self-custodial (hot) tss wallets, parameter `apiVersion` must be `full`.',\n      },\n      {\n        wallet: {\n          baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n          type: () => 'hot',\n          multisigType: () => 'tss',\n          multisigTypeVersion: () => undefined,\n        } as any as IWallet,\n        requestedApiVersion: undefined,\n        expectedApiVersion: 'lite',\n        expectedErrorMessage: '',\n      },\n      {\n        wallet: {\n          baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n          type: () => 'hot',\n          multisigType: () => 'tss',\n          multisigTypeVersion: () => 'MPCv2',\n        } as any as IWallet,\n        requestedApiVersion: 'lite' as ApiVersion,\n        expectedApiVersion: '',\n        expectedErrorMessage: 'For EdDSA MPCv2 tss wallets, parameter `apiVersion` must be `full`.',\n      },\n      {\n        wallet: {\n          baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n          type: () => 'hot',\n          multisigType: () => 'tss',\n          multisigTypeVersion: () => 'MPCv2',\n        } as any as IWallet,\n        requestedApiVersion: undefined,\n        expectedApiVersion: 'full',\n        expectedErrorMessage: '',\n      },\n      ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {\n        return {\n          wallet: {\n            baseCoin: { getMPCAlgorithm: () => 'ecdsa' },\n            type: () => walletType,\n            multisigType: () => 'tss',\n            multisigTypeVersion: () => undefined,\n          } as any as IWallet,\n          requestedApiVersion: 'full',\n          expectedApiVersion: 'full',\n          expectedErrorMessage: '',\n          shouldThrow: false,\n        };\n      }),\n      ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {\n        return {\n          wallet: {\n            baseCoin: { getMPCAlgorithm: () => 'ecdsa' },\n            type: () => walletType,\n            multisigType: () => 'tss',\n            multisigTypeVersion: () => undefined,\n          } as any as IWallet,\n          requestedApiVersion: undefined,\n          expectedApiVersion: 'full',\n          expectedErrorMessage: '',\n          shouldThrow: false,\n        };\n      }),\n      ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {\n        return {\n          wallet: {\n            baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n            type: () => walletType,\n            multisigType: () => 'tss',\n            multisigTypeVersion: () => undefined,\n          } as any as IWallet,\n          requestedApiVersion: 'full',\n          expectedApiVersion: 'full',\n          expectedErrorMessage: '',\n          shouldThrow: false,\n        };\n      }),\n      ...['cold', 'custodial', 'backing'].map((walletType) => {\n        return {\n          wallet: {\n            baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n            type: () => walletType,\n            multisigType: () => 'tss',\n            multisigTypeVersion: () => undefined,\n          } as any as IWallet,\n          requestedApiVersion: undefined,\n          expectedApiVersion: 'full',\n          expectedErrorMessage: '',\n          shouldThrow: false,\n        };\n      }),\n      // EdDSA MPCv2: all wallet types + 'full' explicitly → returns 'full'\n      ...['hot', 'cold', 'custodial', 'backing'].map((walletType) => {\n        return {\n          wallet: {\n            baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n            type: () => walletType,\n            multisigType: () => 'tss',\n            multisigTypeVersion: () => 'MPCv2',\n          } as any as IWallet,\n          requestedApiVersion: 'full' as ApiVersion,\n          expectedApiVersion: 'full',\n          expectedErrorMessage: '',\n          shouldThrow: false,\n        };\n      }),\n      // EdDSA MPCv2: non-hot wallet types + undefined → defaults to 'full'\n      ...['cold', 'custodial', 'backing'].map((walletType) => {\n        return {\n          wallet: {\n            baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n            type: () => walletType,\n            multisigType: () => 'tss',\n            multisigTypeVersion: () => 'MPCv2',\n          } as any as IWallet,\n          requestedApiVersion: undefined,\n          expectedApiVersion: 'full',\n          expectedErrorMessage: '',\n          shouldThrow: false,\n        };\n      }),\n      // EdDSA MPCv2: non-hot wallet types + 'lite' → throws EdDSA MPCv2 error\n      ...['cold', 'custodial', 'backing'].map((walletType) => {\n        return {\n          wallet: {\n            baseCoin: { getMPCAlgorithm: () => 'eddsa' },\n            type: () => walletType,\n            multisigType: () => 'tss',\n            multisigTypeVersion: () => 'MPCv2',\n          } as any as IWallet,\n          requestedApiVersion: 'lite' as ApiVersion,\n          expectedApiVersion: '',\n          expectedErrorMessage: 'For EdDSA MPCv2 tss wallets, parameter `apiVersion` must be `full`.',\n          shouldThrow: true,\n        };\n      }),\n    ];\n\n    testCases.forEach((testCase) => {\n      if (testCase.expectedErrorMessage) {\n        it(`should throw an error if requested apiVersion is ${\n          testCase.requestedApiVersion\n        } for wallet type ${testCase.wallet.type()} for a ${testCase.wallet.baseCoin.getMPCAlgorithm()} wallet`, () => {\n          (() =>\n            getTxRequestApiVersion(\n              testCase.wallet,\n              testCase.requestedApiVersion as ApiVersion | undefined\n            )).should.throw(testCase.expectedErrorMessage);\n        });\n      } else {\n        it(`should return ${testCase.expectedApiVersion} if requested apiVersion is ${\n          testCase.requestedApiVersion\n        } for wallet type ${testCase.wallet.type()} for a ${testCase.wallet.baseCoin.getMPCAlgorithm()} wallet`, () => {\n          getTxRequestApiVersion(testCase.wallet, testCase.requestedApiVersion as ApiVersion | undefined).should.equal(\n            testCase.expectedApiVersion\n          );\n        });\n      }\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/wallet/BuildParams.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BuildParams.d.ts.map

package/dist/test/unit/bitgo/wallet/BuildParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BuildParams.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/BuildParams.ts"],"names":[],"mappings":""}