@bitgo/sdk-core 38.9.1 → 38.11.0

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

@@ -0,0 +1,281 @@
+"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/redpallas/SMC/utils");
+describe('RedPallas MPCv2 SMC Utils:', function () {
+    const enterpriseId = '6449153a6f6bc20006d66771cdbe15d3';
+    const coinName = 'zec';
+    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.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data) => ({
+        state,
+        tssVersion: '0.0.1',
+        walletType: 'cold',
+        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.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data) => ({
+        state,
+        tssVersion: '0.0.1',
+        walletType: 'cold',
+        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,
+            bitgoMsg1: fakeSignedMessage('bitgo-1'),
+        },
+        derivationSeed: 'a'.repeat(64),
+    });
+    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.RedpallasMPCv2SMCUtils(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.RedpallasKeyCreationMPCv2StateEnum.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.RedpallasKeyCreationMPCv2StateEnum.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.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.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.RedpallasKeyCreationMPCv2StateEnum.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);
+            assert.strictEqual(senderPayload.derivationSeed, payload.derivationSeed);
+            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.RedpallasKeyCreationMPCv2StateEnum.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.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.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.RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,
+            };
+            await assert.rejects(smcUtils.keyGenRound1(enterpriseId, invalidPayload), {
+                message: `Invalid state for round 1, expected: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,
+            });
+            assert.ok(mockBitgo.post.notCalled);
+        });
+        it('POSTs to the MPCv2 generatekey endpoint with curveType RedPallas 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.curveType, 'RedPallas');
+            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.RedpallasKeyCreationMPCv2StateEnum.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.RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,
+            };
+            await assert.rejects(smcUtils.keyGenRound2(enterpriseId, invalidPayload), {
+                message: `Invalid state for round 2, expected: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.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);
+        });
+        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);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smcUtil.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/redpallas/smcUtil.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport {\n  OVCIndexEnum,\n  RedpallasBitgoToOVC1Round1Response,\n  RedpallasBitgoToOVC1Round2Response,\n  RedpallasKeyCreationMPCv2StateEnum,\n  RedpallasMPCv2KeyGenRound1Response,\n  RedpallasMPCv2KeyGenRound2Response,\n  RedpallasOVC1ToBitgoRound1Payload,\n  RedpallasOVC2ToBitgoRound2Payload,\n} from '@bitgo/public-types';\nimport { BitGoBase, IBaseCoin } from '../../../../../../src';\nimport { RedpallasMPCv2SMCUtils } from '../../../../../../src/bitgo/utils/tss/redpallas/SMC/utils';\n\ndescribe('RedPallas MPCv2 SMC Utils:', function () {\n  const enterpriseId = '6449153a6f6bc20006d66771cdbe15d3';\n  const coinName = 'zec';\n\n  let smcUtils: RedpallasMPCv2SMCUtils;\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: RedpallasKeyCreationMPCv2StateEnum = RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data\n  ): RedpallasOVC1ToBitgoRound1Payload =>\n    ({\n      state,\n      tssVersion: '0.0.1',\n      walletType: 'cold',\n      coin: coinName,\n      ovc: {\n        [OVCIndexEnum.ONE]: {\n          gpgPubKey: 'user-gpg-pubkey',\n          ovcMsg1: fakeSignedMessage('user-1'),\n        },\n        [OVCIndexEnum.TWO]: {\n          gpgPubKey: 'backup-gpg-pubkey',\n          ovcMsg1: fakeSignedMessage('backup-1'),\n        },\n      },\n    } as unknown as RedpallasOVC1ToBitgoRound1Payload);\n\n  const buildRound2Payload = (\n    sessionId = 'test-session-id',\n    state: RedpallasKeyCreationMPCv2StateEnum = RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data\n  ): RedpallasOVC2ToBitgoRound2Payload =>\n    ({\n      state,\n      tssVersion: '0.0.1',\n      walletType: 'cold',\n      coin: coinName,\n      ovc: {\n        [OVCIndexEnum.ONE]: {\n          gpgPubKey: 'user-gpg-pubkey',\n          ovcMsg1: fakeSignedMessage('user-1'),\n          ovcMsg2: fakeSignedMessage('user-2'),\n        },\n        [OVCIndexEnum.TWO]: {\n          gpgPubKey: 'backup-gpg-pubkey',\n          ovcMsg1: fakeSignedMessage('backup-1'),\n          ovcMsg2: fakeSignedMessage('backup-2'),\n        },\n      },\n      platform: {\n        sessionId,\n        bitgoMsg1: fakeSignedMessage('bitgo-1'),\n      },\n      derivationSeed: 'a'.repeat(64),\n    } as unknown as RedpallasOVC2ToBitgoRound2Payload);\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 RedpallasMPCv2SMCUtils(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',\n        bitgoMsg1: fakeSignedMessage('bitgo-r1'),\n      } as unknown as RedpallasMPCv2KeyGenRound1Response);\n\n      const response = (await smcUtils.keyGenRound1BySender(\n        senderFn as never,\n        payload\n      )) as RedpallasBitgoToOVC1Round1Response;\n\n      assert.strictEqual(response.state, RedpallasKeyCreationMPCv2StateEnum.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(RedpallasKeyCreationMPCv2StateEnum.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: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${RedpallasKeyCreationMPCv2StateEnum.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: '',\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',\n        commonPublicKeychain: 'a'.repeat(64),\n        bitgoMsg2: fakeSignedMessage('bitgo-r2'),\n      } as unknown as RedpallasMPCv2KeyGenRound2Response);\n\n      const response = (await smcUtils.keyGenRound2BySender(\n        senderFn as never,\n        payload\n      )) as RedpallasBitgoToOVC1Round2Response;\n\n      assert.strictEqual(response.state, RedpallasKeyCreationMPCv2StateEnum.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      assert.strictEqual(senderPayload.derivationSeed, payload.derivationSeed);\n\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', RedpallasKeyCreationMPCv2StateEnum.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: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${RedpallasKeyCreationMPCv2StateEnum.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',\n        commonPublicKeychain: 'a'.repeat(64),\n        bitgoMsg2: fakeSignedMessage('bitgo-r2'),\n      } as unknown as RedpallasMPCv2KeyGenRound2Response);\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: RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,\n      } as unknown as RedpallasOVC1ToBitgoRound1Payload;\n\n      await assert.rejects(smcUtils.keyGenRound1(enterpriseId, invalidPayload), {\n        message: `Invalid state for round 1, expected: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data}`,\n      });\n      assert.ok((mockBitgo.post as sinon.SinonStub).notCalled);\n    });\n\n    it('POSTs to the MPCv2 generatekey endpoint with curveType RedPallas 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        curveType: 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.curveType, 'RedPallas');\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, RedpallasKeyCreationMPCv2StateEnum.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: RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,\n      } as unknown as RedpallasOVC2ToBitgoRound2Payload;\n\n      await assert.rejects(smcUtils.keyGenRound2(enterpriseId, invalidPayload), {\n        message: `Invalid state for round 2, expected: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${RedpallasKeyCreationMPCv2StateEnum.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    });\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});\n"]}

package/dist/test/unit/bitgo/utils/tss/redpallasBitgoGpgKey.d.ts

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

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

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

package/dist/test/unit/bitgo/utils/tss/redpallasBitgoGpgKey.js

@@ -0,0 +1,111 @@
+"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 src_1 = require("../../../../../src");
+const bitgoPubKeys_1 = require("../../../../../src/bitgo/tss/bitgoPubKeys");
+const BaseTssUtils = src_1.BaseTssUtils.default;
+class TestBaseTssUtils extends BaseTssUtils {
+    async setBitgoGpgPubKeyForTest(bitgo) {
+        return this.setBitgoGpgPubKey(bitgo);
+    }
+    getBitgoRedpallasMpcv2PublicGpgKeyForTest() {
+        return this.getBitgoRedpallasMpcv2PublicGpgKey();
+    }
+    getBitgoEddsaMpcv2PublicGpgKeyForTest() {
+        return this.getBitgoEddsaMpcv2PublicGpgKey();
+    }
+}
+describe('BaseTssUtils RedPallas MPCv2 BitGo GPG key', function () {
+    let utils;
+    let mockBitGo;
+    beforeEach(function () {
+        mockBitGo = {};
+        utils = new TestBaseTssUtils(mockBitGo, {});
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('setBitgoGpgPubKey populates bitgoRedpallasMpcv2PublicGpgKey from constants', async function () {
+        mockBitGo.fetchConstants = sinon.stub().resolves({
+            mpc: {
+                bitgoPublicKey: bitgoPubKeys_1.bitgoMpcGpgPubKeys.mpcv1.nitro.test,
+                bitgoRedpallasMpcv2PublicKey: bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test,
+            },
+        });
+        await utils.setBitgoGpgPubKeyForTest(mockBitGo);
+        const key = await utils.getBitgoRedpallasMpcv2PublicGpgKeyForTest();
+        assert.ok(key);
+        assert.strictEqual(key.armor(), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test);
+    });
+    it('does not populate bitgoRedpallasMpcv2PublicGpgKey when constants omit it', async function () {
+        mockBitGo.fetchConstants = sinon.stub().resolves({
+            mpc: {
+                bitgoPublicKey: bitgoPubKeys_1.bitgoMpcGpgPubKeys.mpcv1.nitro.test,
+            },
+        });
+        await utils.setBitgoGpgPubKeyForTest(mockBitGo);
+        await assert.rejects(utils.getBitgoRedpallasMpcv2PublicGpgKeyForTest(), /Failed to get Bitgo's RedPallas MPCv2 gpg key/);
+    });
+    it('populating the RedPallas key does not clobber a separately-set EdDSA MPCv2 key', async function () {
+        mockBitGo.fetchConstants = sinon
+            .stub()
+            .onFirstCall()
+            .resolves({
+            mpc: {
+                bitgoPublicKey: bitgoPubKeys_1.bitgoMpcGpgPubKeys.mpcv1.nitro.test,
+                bitgoEddsaMpcv2PublicKey: bitgoPubKeys_1.bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test,
+            },
+        })
+            .onSecondCall()
+            .resolves({
+            mpc: {
+                bitgoPublicKey: bitgoPubKeys_1.bitgoMpcGpgPubKeys.mpcv1.nitro.test,
+                bitgoRedpallasMpcv2PublicKey: bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test,
+            },
+        });
+        await utils.setBitgoGpgPubKeyForTest(mockBitGo);
+        const eddsaKey = await utils.getBitgoEddsaMpcv2PublicGpgKeyForTest();
+        assert.strictEqual(eddsaKey.armor(), bitgoPubKeys_1.bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test);
+        await utils.setBitgoGpgPubKeyForTest(mockBitGo);
+        const redpallasKey = await utils.getBitgoRedpallasMpcv2PublicGpgKeyForTest();
+        assert.strictEqual(redpallasKey.armor(), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test);
+        // EdDSA key should still be set - it must not have been unset by the second call.
+        const eddsaKeyAgain = await utils.getBitgoEddsaMpcv2PublicGpgKeyForTest();
+        assert.strictEqual(eddsaKeyAgain.armor(), bitgoPubKeys_1.bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redpallasBitgoGpgKey.js","sourceRoot":"","sources":["../../../../../../test/unit/bitgo/utils/tss/redpallasBitgoGpgKey.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { BitGoBase, IBaseCoin, BaseTssUtils as BaseTssUtilsNamespace } from '../../../../../src';\nimport { bitgoMpcGpgPubKeys } from '../../../../../src/bitgo/tss/bitgoPubKeys';\n\nconst BaseTssUtils = BaseTssUtilsNamespace.default;\n\nclass TestBaseTssUtils extends BaseTssUtils<Buffer> {\n  async setBitgoGpgPubKeyForTest(bitgo): Promise<void> {\n    return this.setBitgoGpgPubKey(bitgo);\n  }\n\n  getBitgoRedpallasMpcv2PublicGpgKeyForTest(): Promise<import('openpgp').Key> {\n    return this.getBitgoRedpallasMpcv2PublicGpgKey();\n  }\n\n  getBitgoEddsaMpcv2PublicGpgKeyForTest(): Promise<import('openpgp').Key> {\n    return this.getBitgoEddsaMpcv2PublicGpgKey();\n  }\n}\n\ndescribe('BaseTssUtils RedPallas MPCv2 BitGo GPG key', function () {\n  let utils: TestBaseTssUtils;\n  let mockBitGo: BitGoBase;\n\n  beforeEach(function () {\n    mockBitGo = {} as unknown as BitGoBase;\n    utils = new TestBaseTssUtils(mockBitGo, {} as unknown as IBaseCoin);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('setBitgoGpgPubKey populates bitgoRedpallasMpcv2PublicGpgKey from constants', async function () {\n    mockBitGo.fetchConstants = sinon.stub().resolves({\n      mpc: {\n        bitgoPublicKey: bitgoMpcGpgPubKeys.mpcv1.nitro.test,\n        bitgoRedpallasMpcv2PublicKey: bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test,\n      },\n    });\n\n    await utils.setBitgoGpgPubKeyForTest(mockBitGo);\n    const key = await utils.getBitgoRedpallasMpcv2PublicGpgKeyForTest();\n\n    assert.ok(key);\n    assert.strictEqual(key.armor(), bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test);\n  });\n\n  it('does not populate bitgoRedpallasMpcv2PublicGpgKey when constants omit it', async function () {\n    mockBitGo.fetchConstants = sinon.stub().resolves({\n      mpc: {\n        bitgoPublicKey: bitgoMpcGpgPubKeys.mpcv1.nitro.test,\n      },\n    });\n\n    await utils.setBitgoGpgPubKeyForTest(mockBitGo);\n\n    await assert.rejects(\n      utils.getBitgoRedpallasMpcv2PublicGpgKeyForTest(),\n      /Failed to get Bitgo's RedPallas MPCv2 gpg key/\n    );\n  });\n\n  it('populating the RedPallas key does not clobber a separately-set EdDSA MPCv2 key', async function () {\n    mockBitGo.fetchConstants = sinon\n      .stub()\n      .onFirstCall()\n      .resolves({\n        mpc: {\n          bitgoPublicKey: bitgoMpcGpgPubKeys.mpcv1.nitro.test,\n          bitgoEddsaMpcv2PublicKey: bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test,\n        },\n      })\n      .onSecondCall()\n      .resolves({\n        mpc: {\n          bitgoPublicKey: bitgoMpcGpgPubKeys.mpcv1.nitro.test,\n          bitgoRedpallasMpcv2PublicKey: bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test,\n        },\n      });\n\n    await utils.setBitgoGpgPubKeyForTest(mockBitGo);\n    const eddsaKey = await utils.getBitgoEddsaMpcv2PublicGpgKeyForTest();\n    assert.strictEqual(eddsaKey.armor(), bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test);\n\n    await utils.setBitgoGpgPubKeyForTest(mockBitGo);\n    const redpallasKey = await utils.getBitgoRedpallasMpcv2PublicGpgKeyForTest();\n    assert.strictEqual(redpallasKey.armor(), bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test);\n\n    // EdDSA key should still be set - it must not have been unset by the second call.\n    const eddsaKeyAgain = await utils.getBitgoEddsaMpcv2PublicGpgKeyForTest();\n    assert.strictEqual(eddsaKeyAgain.armor(), bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test);\n  });\n});\n"]}