@bitgo-beta/sdk-core 8.2.1-beta.204 → 8.2.1-beta.2041

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

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

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

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

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

@@ -0,0 +1,173 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const cbor_x_1 = require("cbor-x");
+const t = __importStar(require("io-ts"));
+const src_1 = require("../../../../../../src");
+const codecs_1 = require("../../../../../../src/bitgo/utils/codecs");
+const eddsaVrfMPCv2_1 = require("../../../../../../src/bitgo/utils/tss/eddsa/eddsaVrfMPCv2");
+const typesMPCv2_1 = require("../../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2");
+const Uint8ArrayCodec = new t.Type('Uint8Array', (value) => value instanceof Uint8Array, (value, context) => (value instanceof Uint8Array ? t.success(value) : t.failure(value, context)), t.identity);
+const VrfEnvelope = t.type({
+    version: t.literal(1),
+    prvKeyShare: Uint8ArrayCodec,
+    vrf: Uint8ArrayCodec,
+});
+function decodeVrfEnvelope(encoded) {
+    return (0, codecs_1.decodeWithCodec)(VrfEnvelope, (0, cbor_x_1.decode)(encoded), 'VRF key envelope');
+}
+describe('EdDSA MPCv2 VRF root material', function () {
+    it('encodes signing and VRF shares in both full and reduced envelopes', function () {
+        const privateMaterial = Buffer.from('signing-share');
+        const reducedPrivateMaterial = Buffer.from('reduced-signing-share');
+        const vrfKeyShare = Buffer.from('vrf-share');
+        const { envelope, reducedEnvelope } = (0, eddsaVrfMPCv2_1.buildVrfKeyEnvelopes)(privateMaterial, reducedPrivateMaterial, vrfKeyShare);
+        const decodedEnvelope = decodeVrfEnvelope(envelope);
+        const decodedReducedEnvelope = decodeVrfEnvelope(reducedEnvelope);
+        assert_1.default.deepStrictEqual(Buffer.from(decodedEnvelope.prvKeyShare), privateMaterial);
+        assert_1.default.deepStrictEqual(Buffer.from(decodedEnvelope.vrf), vrfKeyShare);
+        assert_1.default.deepStrictEqual(Buffer.from(decodedReducedEnvelope.prvKeyShare), reducedPrivateMaterial);
+        assert_1.default.deepStrictEqual(Buffer.from(decodedReducedEnvelope.vrf), vrfKeyShare);
+    });
+    it('keeps ordinary MPCv2 participant material as bare base64', async function () {
+        const encryptedInputs = [];
+        const addedKeychains = [];
+        const bitgo = {
+            encrypt: async (params) => {
+                encryptedInputs.push(params.input);
+                return `encrypted:${params.input}`;
+            },
+        };
+        const keychains = {
+            add: async (params) => {
+                addedKeychains.push(params);
+                return { id: 'user-key' };
+            },
+        };
+        const baseCoin = {
+            keychains: () => keychains,
+        };
+        const utils = new src_1.EddsaMPCv2Utils(bitgo, baseCoin);
+        const privateMaterial = Buffer.from('signing-share');
+        const reducedPrivateMaterial = Buffer.from('reduced-signing-share');
+        await utils.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.USER, 'common-keychain', privateMaterial, reducedPrivateMaterial, 'passphrase');
+        assert_1.default.deepStrictEqual(encryptedInputs, [
+            privateMaterial.toString('base64'),
+            reducedPrivateMaterial.toString('base64'),
+        ]);
+        assert_1.default.strictEqual(addedKeychains[0].encryptedPrv, `encrypted:${privateMaterial.toString('base64')}`);
+        assert_1.default.strictEqual(addedKeychains[0].safeId, undefined);
+    });
+    it('encrypts the VRF envelope and tags the keychain with safeId', async function () {
+        const encryptedInputs = [];
+        const addedKeychains = [];
+        const bitgo = {
+            encrypt: async (params) => {
+                encryptedInputs.push(params.input);
+                return `encrypted:${params.input}`;
+            },
+        };
+        const keychains = {
+            add: async (params) => {
+                addedKeychains.push(params);
+                return { id: 'user-key' };
+            },
+        };
+        const baseCoin = {
+            keychains: () => keychains,
+        };
+        const utils = new src_1.EddsaMPCv2Utils(bitgo, baseCoin);
+        const { envelope, reducedEnvelope } = (0, eddsaVrfMPCv2_1.buildVrfKeyEnvelopes)(Buffer.from('signing-share'), Buffer.from('reduced-signing-share'), Buffer.from('vrf-share'));
+        await utils.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.USER, 'common-keychain', envelope, reducedEnvelope, 'passphrase', undefined, undefined, undefined, undefined, 'safe-id');
+        assert_1.default.deepStrictEqual(encryptedInputs[0], envelope.toString('base64'));
+        assert_1.default.strictEqual(addedKeychains[0].safeId, 'safe-id');
+        const decoded = decodeVrfEnvelope(Buffer.from(encryptedInputs[0], 'base64'));
+        assert_1.default.deepStrictEqual(Buffer.from(decoded.vrf), Buffer.from('vrf-share'));
+    });
+    it('tags the BitGo keychain with safeId and does not encrypt', async function () {
+        const encryptedInputs = [];
+        const addedKeychains = [];
+        const bitgo = {
+            encrypt: async (params) => {
+                encryptedInputs.push(params.input);
+                return `encrypted:${params.input}`;
+            },
+        };
+        const keychains = {
+            add: async (params) => {
+                addedKeychains.push(params);
+                return { id: 'bitgo-key' };
+            },
+        };
+        const baseCoin = {
+            keychains: () => keychains,
+        };
+        const utils = new src_1.EddsaMPCv2Utils(bitgo, baseCoin);
+        await utils.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 'common-keychain', undefined, undefined, undefined, undefined, undefined, undefined, undefined, 'safe-id');
+        assert_1.default.deepStrictEqual(encryptedInputs, []);
+        assert_1.default.strictEqual(addedKeychains[0].source, 'bitgo');
+        assert_1.default.strictEqual(addedKeychains[0].safeId, 'safe-id');
+        assert_1.default.strictEqual(addedKeychains[0].encryptedPrv, undefined);
+    });
+    it('round-trips opaque VRF blobs and keeps only the recipient p2p messages', function () {
+        const blob = (0, eddsaVrfMPCv2_1.serializeVrfMessages)({
+            broadcastMessages: [{ from: typesMPCv2_1.MPCv2PartiesEnum.BITGO, payload: new Uint8Array([1, 2, 3]) }],
+            p2pMessages: [
+                { from: typesMPCv2_1.MPCv2PartiesEnum.BITGO, to: typesMPCv2_1.MPCv2PartiesEnum.USER, payload: new Uint8Array([4]) },
+                { from: typesMPCv2_1.MPCv2PartiesEnum.BITGO, to: typesMPCv2_1.MPCv2PartiesEnum.BACKUP, payload: new Uint8Array([5]) },
+            ],
+        });
+        const forUser = (0, eddsaVrfMPCv2_1.deserializeVrfMessages)(blob, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        assert_1.default.deepStrictEqual(Buffer.from(forUser.broadcastMessages[0].payload), Buffer.from([1, 2, 3]));
+        assert_1.default.strictEqual(forUser.p2pMessages.length, 1);
+        assert_1.default.strictEqual(forUser.p2pMessages[0].to, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        assert_1.default.deepStrictEqual(Buffer.from(forUser.p2pMessages[0].payload), Buffer.from([4]));
+        const forBackup = (0, eddsaVrfMPCv2_1.deserializeVrfMessages)(blob, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert_1.default.strictEqual(forBackup.p2pMessages.length, 1);
+        assert_1.default.strictEqual(forBackup.p2pMessages[0].to, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+    });
+    it('rejects malformed VRF DKG message blobs', function () {
+        assert_1.default.throws(() => (0, eddsaVrfMPCv2_1.deserializeVrfMessages)('%%%', typesMPCv2_1.MPCv2PartiesEnum.USER), /Invalid VRF DKG message blob/);
+        const notAnArray = Buffer.from(JSON.stringify({ from: 0 })).toString('base64');
+        assert_1.default.throws(() => (0, eddsaVrfMPCv2_1.deserializeVrfMessages)(notAnArray, typesMPCv2_1.MPCv2PartiesEnum.USER), /VRF DKG message blob/);
+        const badParty = Buffer.from(JSON.stringify([{ from: 9, payload: Buffer.from([1]).toString('base64') }])).toString('base64');
+        assert_1.default.throws(() => (0, eddsaVrfMPCv2_1.deserializeVrfMessages)(badParty, typesMPCv2_1.MPCv2PartiesEnum.USER), /VRF DKG message blob/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eddsaVrfMPCv2.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/eddsa/eddsaVrfMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport { decode } from 'cbor-x';\nimport * as t from 'io-ts';\n\nimport { EddsaMPCv2Utils, BitGoBase, IBaseCoin, Keychain } from '../../../../../../src';\nimport { decodeWithCodec } from '../../../../../../src/bitgo/utils/codecs';\nimport {\n  buildVrfKeyEnvelopes,\n  deserializeVrfMessages,\n  serializeVrfMessages,\n} from '../../../../../../src/bitgo/utils/tss/eddsa/eddsaVrfMPCv2';\nimport { MPCv2PartiesEnum } from '../../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2';\n\nconst Uint8ArrayCodec = new t.Type<Uint8Array, Uint8Array, unknown>(\n  'Uint8Array',\n  (value): value is Uint8Array => value instanceof Uint8Array,\n  (value, context) => (value instanceof Uint8Array ? t.success(value) : t.failure(value, context)),\n  t.identity\n);\n\nconst VrfEnvelope = t.type({\n  version: t.literal(1),\n  prvKeyShare: Uint8ArrayCodec,\n  vrf: Uint8ArrayCodec,\n});\n\ntype AddedKeychainParams = {\n  source?: string;\n  encryptedPrv?: string;\n  safeId?: string;\n};\n\nfunction decodeVrfEnvelope(encoded: Buffer): t.TypeOf<typeof VrfEnvelope> {\n  return decodeWithCodec(VrfEnvelope, decode(encoded), 'VRF key envelope');\n}\n\ndescribe('EdDSA MPCv2 VRF root material', function () {\n  it('encodes signing and VRF shares in both full and reduced envelopes', function () {\n    const privateMaterial = Buffer.from('signing-share');\n    const reducedPrivateMaterial = Buffer.from('reduced-signing-share');\n    const vrfKeyShare = Buffer.from('vrf-share');\n\n    const { envelope, reducedEnvelope } = buildVrfKeyEnvelopes(privateMaterial, reducedPrivateMaterial, vrfKeyShare);\n    const decodedEnvelope = decodeVrfEnvelope(envelope);\n    const decodedReducedEnvelope = decodeVrfEnvelope(reducedEnvelope);\n\n    assert.deepStrictEqual(Buffer.from(decodedEnvelope.prvKeyShare), privateMaterial);\n    assert.deepStrictEqual(Buffer.from(decodedEnvelope.vrf), vrfKeyShare);\n    assert.deepStrictEqual(Buffer.from(decodedReducedEnvelope.prvKeyShare), reducedPrivateMaterial);\n    assert.deepStrictEqual(Buffer.from(decodedReducedEnvelope.vrf), vrfKeyShare);\n  });\n\n  it('keeps ordinary MPCv2 participant material as bare base64', async function () {\n    const encryptedInputs: string[] = [];\n    const addedKeychains: AddedKeychainParams[] = [];\n    const bitgo = {\n      encrypt: async (params: { input: string }): Promise<string> => {\n        encryptedInputs.push(params.input);\n        return `encrypted:${params.input}`;\n      },\n    } as unknown as BitGoBase;\n    const keychains = {\n      add: async (params: AddedKeychainParams): Promise<Keychain> => {\n        addedKeychains.push(params);\n        return { id: 'user-key' } as unknown as Keychain;\n      },\n    };\n    const baseCoin = {\n      keychains: () => keychains,\n    } as unknown as IBaseCoin;\n    const utils = new EddsaMPCv2Utils(bitgo, baseCoin);\n    const privateMaterial = Buffer.from('signing-share');\n    const reducedPrivateMaterial = Buffer.from('reduced-signing-share');\n\n    await utils.createParticipantKeychain(\n      MPCv2PartiesEnum.USER,\n      'common-keychain',\n      privateMaterial,\n      reducedPrivateMaterial,\n      'passphrase'\n    );\n\n    assert.deepStrictEqual(encryptedInputs, [\n      privateMaterial.toString('base64'),\n      reducedPrivateMaterial.toString('base64'),\n    ]);\n    assert.strictEqual(addedKeychains[0].encryptedPrv, `encrypted:${privateMaterial.toString('base64')}`);\n    assert.strictEqual(addedKeychains[0].safeId, undefined);\n  });\n\n  it('encrypts the VRF envelope and tags the keychain with safeId', async function () {\n    const encryptedInputs: string[] = [];\n    const addedKeychains: AddedKeychainParams[] = [];\n    const bitgo = {\n      encrypt: async (params: { input: string }): Promise<string> => {\n        encryptedInputs.push(params.input);\n        return `encrypted:${params.input}`;\n      },\n    } as unknown as BitGoBase;\n    const keychains = {\n      add: async (params: AddedKeychainParams): Promise<Keychain> => {\n        addedKeychains.push(params);\n        return { id: 'user-key' } as unknown as Keychain;\n      },\n    };\n    const baseCoin = {\n      keychains: () => keychains,\n    } as unknown as IBaseCoin;\n    const utils = new EddsaMPCv2Utils(bitgo, baseCoin);\n    const { envelope, reducedEnvelope } = buildVrfKeyEnvelopes(\n      Buffer.from('signing-share'),\n      Buffer.from('reduced-signing-share'),\n      Buffer.from('vrf-share')\n    );\n\n    await utils.createParticipantKeychain(\n      MPCv2PartiesEnum.USER,\n      'common-keychain',\n      envelope,\n      reducedEnvelope,\n      'passphrase',\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      'safe-id'\n    );\n\n    assert.deepStrictEqual(encryptedInputs[0], envelope.toString('base64'));\n    assert.strictEqual(addedKeychains[0].safeId, 'safe-id');\n    const decoded = decodeVrfEnvelope(Buffer.from(encryptedInputs[0], 'base64'));\n    assert.deepStrictEqual(Buffer.from(decoded.vrf), Buffer.from('vrf-share'));\n  });\n\n  it('tags the BitGo keychain with safeId and does not encrypt', async function () {\n    const encryptedInputs: string[] = [];\n    const addedKeychains: AddedKeychainParams[] = [];\n    const bitgo = {\n      encrypt: async (params: { input: string }): Promise<string> => {\n        encryptedInputs.push(params.input);\n        return `encrypted:${params.input}`;\n      },\n    } as unknown as BitGoBase;\n    const keychains = {\n      add: async (params: AddedKeychainParams): Promise<Keychain> => {\n        addedKeychains.push(params);\n        return { id: 'bitgo-key' } as unknown as Keychain;\n      },\n    };\n    const baseCoin = {\n      keychains: () => keychains,\n    } as unknown as IBaseCoin;\n    const utils = new EddsaMPCv2Utils(bitgo, baseCoin);\n\n    await utils.createParticipantKeychain(\n      MPCv2PartiesEnum.BITGO,\n      'common-keychain',\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      'safe-id'\n    );\n\n    assert.deepStrictEqual(encryptedInputs, []);\n    assert.strictEqual(addedKeychains[0].source, 'bitgo');\n    assert.strictEqual(addedKeychains[0].safeId, 'safe-id');\n    assert.strictEqual(addedKeychains[0].encryptedPrv, undefined);\n  });\n\n  it('round-trips opaque VRF blobs and keeps only the recipient p2p messages', function () {\n    const blob = serializeVrfMessages({\n      broadcastMessages: [{ from: MPCv2PartiesEnum.BITGO, payload: new Uint8Array([1, 2, 3]) }],\n      p2pMessages: [\n        { from: MPCv2PartiesEnum.BITGO, to: MPCv2PartiesEnum.USER, payload: new Uint8Array([4]) },\n        { from: MPCv2PartiesEnum.BITGO, to: MPCv2PartiesEnum.BACKUP, payload: new Uint8Array([5]) },\n      ],\n    });\n\n    const forUser = deserializeVrfMessages(blob, MPCv2PartiesEnum.USER);\n    assert.deepStrictEqual(Buffer.from(forUser.broadcastMessages[0].payload), Buffer.from([1, 2, 3]));\n    assert.strictEqual(forUser.p2pMessages.length, 1);\n    assert.strictEqual(forUser.p2pMessages[0].to, MPCv2PartiesEnum.USER);\n    assert.deepStrictEqual(Buffer.from(forUser.p2pMessages[0].payload), Buffer.from([4]));\n\n    const forBackup = deserializeVrfMessages(blob, MPCv2PartiesEnum.BACKUP);\n    assert.strictEqual(forBackup.p2pMessages.length, 1);\n    assert.strictEqual(forBackup.p2pMessages[0].to, MPCv2PartiesEnum.BACKUP);\n  });\n\n  it('rejects malformed VRF DKG message blobs', function () {\n    assert.throws(() => deserializeVrfMessages('%%%', MPCv2PartiesEnum.USER), /Invalid VRF DKG message blob/);\n    const notAnArray = Buffer.from(JSON.stringify({ from: 0 })).toString('base64');\n    assert.throws(() => deserializeVrfMessages(notAnArray, MPCv2PartiesEnum.USER), /VRF DKG message blob/);\n    const badParty = Buffer.from(JSON.stringify([{ from: 9, payload: Buffer.from([1]).toString('base64') }])).toString(\n      'base64'\n    );\n    assert.throws(() => deserializeVrfMessages(badParty, MPCv2PartiesEnum.USER), /VRF DKG message blob/);\n  });\n});\n"]}

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/tss/preHashedSignable.d.ts

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

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

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