@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

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

@@ -0,0 +1,549 @@
+"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 pgp = __importStar(require("openpgp"));
+const sinon = __importStar(require("sinon"));
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const public_types_1 = require("@bitgo/public-types");
+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 keyShareEnvelope_1 = require("../../../../../../src/bitgo/utils/tss/keyShareEnvelope");
+const eddsaVrfMPCv2_1 = require("../../../../../../src/bitgo/utils/tss/eddsa/eddsaVrfMPCv2");
+const typesMPCv2_1 = require("../../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2");
+const opengpgUtils_1 = require("../../../../../../src/bitgo/utils/opengpgUtils");
+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');
+}
+function createKeychainFixture() {
+    const encryptedInputs = [];
+    const addedKeychains = [];
+    const post = sinon.stub();
+    const bitgo = {
+        getEnv: () => 'dev',
+        url: (path) => path,
+        post,
+        encrypt: async (params) => {
+            encryptedInputs.push(params.input);
+            return `encrypted:${params.input}`;
+        },
+    };
+    const keychains = {
+        add: async (params) => {
+            addedKeychains.push(params);
+            return { id: `${params.source}-child`, type: 'tss', encryptedPrv: params.encryptedPrv };
+        },
+    };
+    const baseCoin = {
+        keychains: () => keychains,
+    };
+    return { bitgo, baseCoin, post, encryptedInputs, addedKeychains };
+}
+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, keyShareEnvelope_1.buildSafeMpcKeyEnvelopes)(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 { bitgo, baseCoin, encryptedInputs, addedKeychains } = createKeychainFixture();
+        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('rejects a public-only backup outside a safe child derivation', async function () {
+        const { bitgo, baseCoin, encryptedInputs, addedKeychains } = createKeychainFixture();
+        const utils = new src_1.EddsaMPCv2Utils(bitgo, baseCoin);
+        await assert_1.default.rejects(utils.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, 'common-keychain', undefined, undefined, 'passphrase'), /Private material is required for backup keychain/);
+        assert_1.default.deepStrictEqual(encryptedInputs, []);
+        assert_1.default.deepStrictEqual(addedKeychains, []);
+    });
+    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, keyShareEnvelope_1.buildSafeMpcKeyEnvelopes)(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);
+    });
+    describe('safe root keygen against the HSM contract', function () {
+        const KeyGenRequest = t.intersection([
+            t.type({ enterprise: t.string, type: t.string, curveType: t.string, round: t.string }),
+            t.partial({ safeId: t.string, payload: t.UnknownRecord }),
+        ]);
+        const R1Payload = t.intersection([
+            t.type({
+                userGpgPublicKey: t.string,
+                backupGpgPublicKey: t.string,
+                userMsg1: public_types_1.EddsaMPCv2SignedMessage,
+                backupMsg1: public_types_1.EddsaMPCv2SignedMessage,
+            }),
+            t.type({
+                userVrfMsg1: public_types_1.EddsaMPCv2SignedMessage,
+                backupVrfMsg1: public_types_1.EddsaMPCv2SignedMessage,
+            }),
+        ]);
+        const R2Payload = t.intersection([
+            t.type({ sessionId: t.string, userMsg2: public_types_1.EddsaMPCv2SignedMessage, backupMsg2: public_types_1.EddsaMPCv2SignedMessage }),
+            t.type({
+                userVrfMsg2: public_types_1.EddsaMPCv2SignedMessage,
+                backupVrfMsg2: public_types_1.EddsaMPCv2SignedMessage,
+            }),
+        ]);
+        let bitgoPrivateKey;
+        let bitgoPublicKey;
+        before(async function () {
+            const bitgoGpg = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+            bitgoPrivateKey = await pgp.readPrivateKey({ armoredKey: bitgoGpg.privateKey });
+            bitgoPublicKey = await pgp.readKey({ armoredKey: bitgoGpg.publicKey });
+        });
+        afterEach(function () {
+            sinon.restore();
+        });
+        /** BitGo's side of the ceremony: signing DKG + VRF DKG, verifying every client signature like the HSM does. */
+        async function keygenWithHsmPeer(fault) {
+            const { bitgo, baseCoin, post, encryptedInputs, addedKeychains } = createKeychainFixture();
+            const utils = new eddsaVrfMPCv2_1.EddsaVrfMPCv2Utils(bitgo, baseCoin);
+            sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({
+                mpcv2PublicKey: bitgoPublicKey,
+                eddsaMpcv2PublicKey: bitgoPublicKey,
+                redpallasMpcv2PublicKey: undefined,
+            });
+            const bitgoDkg = new sdk_lib_mpc_1.EddsaMPSDkg.DKG(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+            const bitgoVrf = new sdk_lib_mpc_1.MpsVrf.VrfDkg(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+            const requests = [];
+            let bitgoMsg2;
+            let userGpgKey;
+            let backupGpgKey;
+            let userCommitment;
+            let backupCommitment;
+            const signAsBitgo = (payload) => sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(payload, bitgoPrivateKey);
+            const encryptTo = async (recipient, plaintext) => {
+                const { signature } = await signAsBitgo(plaintext);
+                const message = await pgp.encrypt({
+                    message: await pgp.createMessage({ binary: plaintext }),
+                    encryptionKeys: recipient,
+                    format: 'armored',
+                });
+                return {
+                    message,
+                    signature: fault === 'bitgo-vrf-opening-signature' ? (await signAsBitgo(new Uint8Array([9]))).signature : signature,
+                };
+            };
+            post.callsFake(() => ({
+                send: (rawBody) => ({
+                    result: async () => {
+                        const body = (0, codecs_1.decodeWithCodec)(KeyGenRequest, rawBody, 'EdDSA keygen request');
+                        assert_1.default.strictEqual(body.type, public_types_1.KeyGenTypeEnum.MPCv2);
+                        assert_1.default.strictEqual(body.curveType, public_types_1.KeyCurveEnum.EdDSA);
+                        // WP only reads safeId in round 1; round 2 is routed by the stored session.
+                        assert_1.default.strictEqual(body.safeId, body.round === public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1'] ? 'safe-id' : undefined);
+                        requests.push({ round: body.round, ...body.payload });
+                        if (body.round === public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1']) {
+                            const payload = (0, codecs_1.decodeWithCodec)(R1Payload, body.payload, 'EdDSA keygen round 1');
+                            userGpgKey = await pgp.readKey({ armoredKey: payload.userGpgPublicKey });
+                            backupGpgKey = await pgp.readKey({ armoredKey: payload.backupGpgPublicKey });
+                            const [userPk, backupPk] = await Promise.all([
+                                sdk_lib_mpc_1.MPSComms.extractEd25519PublicKey(userGpgKey),
+                                sdk_lib_mpc_1.MPSComms.extractEd25519PublicKey(backupGpgKey),
+                            ]);
+                            const [, bitgoSk] = await sdk_lib_mpc_1.MPSComms.extractEd25519KeyPair(bitgoPrivateKey);
+                            const userMsg1 = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.userMsg1, userGpgKey);
+                            const backupMsg1 = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.backupMsg1, backupGpgKey);
+                            // The VRF messages must be signed by the same party key as userMsg1/backupMsg1.
+                            userCommitment = new Uint8Array(await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.userVrfMsg1, userGpgKey));
+                            backupCommitment = new Uint8Array(await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.backupVrfMsg1, backupGpgKey));
+                            await assert_1.default.rejects(sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.userVrfMsg1, backupGpgKey));
+                            await bitgoDkg.initDkg(bitgoSk, [userPk, backupPk]);
+                            const bitgoRawMsg1 = bitgoDkg.getFirstMessage();
+                            [bitgoMsg2] = bitgoDkg.handleIncomingMessages([
+                                { from: typesMPCv2_1.MPCv2PartiesEnum.USER, payload: new Uint8Array(userMsg1) },
+                                { from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP, payload: new Uint8Array(backupMsg1) },
+                                bitgoRawMsg1,
+                            ]);
+                            const [bitgoVrfCommitment] = (await bitgoVrf.initDkg()).broadcastMessages;
+                            const signedVrfMsg1 = await signAsBitgo(bitgoVrfCommitment.payload);
+                            return {
+                                sessionId: 'session-id',
+                                bitgoMsg1: await signAsBitgo(bitgoRawMsg1.payload),
+                                bitgoVrfMsg1: fault === 'bitgo-vrf-msg1-signature'
+                                    ? { ...signedVrfMsg1, message: Buffer.from('tampered').toString('base64') }
+                                    : signedVrfMsg1,
+                            };
+                        }
+                        assert_1.default.strictEqual(body.round, public_types_1.MPCv2KeyGenStateEnum['MPCv2-R2']);
+                        const payload = (0, codecs_1.decodeWithCodec)(R2Payload, body.payload, 'EdDSA keygen round 2');
+                        assert_1.default.ok(userGpgKey && backupGpgKey && userCommitment && backupCommitment && bitgoMsg2);
+                        assert_1.default.deepStrictEqual(Object.keys(payload).sort(), [
+                            'backupMsg2',
+                            'backupVrfMsg2',
+                            'sessionId',
+                            'userMsg2',
+                            'userVrfMsg2',
+                        ]);
+                        const userMsg2 = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.userMsg2, userGpgKey);
+                        const backupMsg2 = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.backupMsg2, backupGpgKey);
+                        const userOpening = new Uint8Array(await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.userVrfMsg2, userGpgKey));
+                        const backupOpening = new Uint8Array(await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(payload.backupVrfMsg2, backupGpgKey));
+                        bitgoDkg.handleIncomingMessages([
+                            { from: typesMPCv2_1.MPCv2PartiesEnum.USER, payload: new Uint8Array(userMsg2) },
+                            { from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP, payload: new Uint8Array(backupMsg2) },
+                            bitgoMsg2,
+                        ]);
+                        const openings = await bitgoVrf.handleIncomingMessages({
+                            broadcastMessages: [
+                                { from: typesMPCv2_1.MPCv2PartiesEnum.USER, payload: userCommitment },
+                                { from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP, payload: backupCommitment },
+                            ],
+                            p2pMessages: [],
+                        });
+                        const toUser = openings.p2pMessages.find(({ to }) => to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+                        const toBackup = openings.p2pMessages.find(({ to }) => to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+                        assert_1.default.ok(toUser && toBackup);
+                        await bitgoVrf.handleIncomingMessages({
+                            broadcastMessages: [],
+                            p2pMessages: [
+                                { from: typesMPCv2_1.MPCv2PartiesEnum.USER, to: typesMPCv2_1.MPCv2PartiesEnum.BITGO, payload: userOpening },
+                                { from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP, to: typesMPCv2_1.MPCv2PartiesEnum.BITGO, payload: backupOpening },
+                            ],
+                        });
+                        return {
+                            sessionId: payload.sessionId,
+                            commonPublicKeychain: bitgoDkg.getCommonKeychain(),
+                            bitgoMsg2: await signAsBitgo(bitgoMsg2.payload),
+                            ...(fault === 'missing-opening'
+                                ? {}
+                                : { bitgoVrfMsgToUser: await encryptTo(userGpgKey, toUser.payload) }),
+                            bitgoVrfMsgToBackup: await encryptTo(backupGpgKey, toBackup.payload),
+                        };
+                    },
+                }),
+            }));
+            await utils.createKeychains({
+                passphrase: 'passphrase',
+                enterprise: 'enterprise-id',
+                safeId: 'safe-id',
+            });
+            return { requests, encryptedInputs, addedKeychains };
+        }
+        it('signs VRF messages with the party keys and decrypts BitGo openings without handling the HSM VRF state', async function () {
+            const { requests, encryptedInputs, addedKeychains } = await keygenWithHsmPeer();
+            assert_1.default.deepStrictEqual(requests.map(({ round }) => round), [public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1'], public_types_1.MPCv2KeyGenStateEnum['MPCv2-R2']]);
+            // WP keeps the HSM VRF state between rounds, so neither client round carries it.
+            for (const request of requests) {
+                assert_1.default.strictEqual('bitgoEncryptedVrfDkgState' in request, false);
+            }
+            // Both client roots end up with a signing share and a VRF share, tagged with the safe.
+            assert_1.default.deepStrictEqual(addedKeychains.map(({ source }) => source).sort(), ['backup', 'bitgo', 'user']);
+            for (const keychain of addedKeychains) {
+                assert_1.default.strictEqual(keychain.safeId, 'safe-id');
+            }
+            // User and backup each encrypt a full and a reduced envelope; every one carries a VRF share, and
+            // the two parties' shares differ. Order-independent: the roots are registered concurrently.
+            const vrfShares = new Set(encryptedInputs.map((input) => {
+                const { vrf, prvKeyShare } = decodeVrfEnvelope(Buffer.from(input, 'base64'));
+                assert_1.default.ok(vrf.length > 0);
+                assert_1.default.ok(prvKeyShare.length > 0);
+                return Buffer.from(vrf).toString('hex');
+            }));
+            assert_1.default.strictEqual(encryptedInputs.length, 4);
+            assert_1.default.strictEqual(vrfShares.size, 2);
+        });
+        it('rejects a BitGo VRF round 1 message whose signature does not verify', async function () {
+            await assert_1.default.rejects(keygenWithHsmPeer('bitgo-vrf-msg1-signature'), /signature|verification|signed/i);
+        });
+        it('rejects a BitGo VRF opening whose signature does not verify', async function () {
+            await assert_1.default.rejects(keygenWithHsmPeer('bitgo-vrf-opening-signature'), /signature|verification|signed/i);
+        });
+        it('fails when the HSM omits a BitGo VRF opening in round 2', async function () {
+            await assert_1.default.rejects(keygenWithHsmPeer('missing-opening'), /VRF message to user/);
+        });
+    });
+});
+describe('EdDSA safe-child MPS derivation', function () {
+    let userSigningShare;
+    let userVrfShare;
+    let bitgoSigningShare;
+    let bitgoVrfShare;
+    let bitgoPrivateKey;
+    let bitgoPublicKey;
+    const sessionId = 'derive-session';
+    const derivationIndex = 7;
+    const path = "m/7'";
+    const Request = t.intersection([
+        t.type({ enterprise: t.string, type: t.string, curveType: t.string, round: t.string, payload: t.unknown }),
+        t.partial({ safeId: t.string }),
+    ]);
+    before(async function () {
+        const signing = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const vrf = await sdk_lib_mpc_1.MpsVrfUtils.generateVrfDKGKeyShares();
+        userSigningShare = signing[typesMPCv2_1.MPCv2PartiesEnum.USER].getKeyShare();
+        bitgoSigningShare = signing[typesMPCv2_1.MPCv2PartiesEnum.BITGO].getKeyShare();
+        userVrfShare = vrf[typesMPCv2_1.MPCv2PartiesEnum.USER].getKeyShare();
+        bitgoVrfShare = vrf[typesMPCv2_1.MPCv2PartiesEnum.BITGO].getKeyShare();
+        const bitgoGpg = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        bitgoPrivateKey = await pgp.readPrivateKey({ armoredKey: bitgoGpg.privateKey });
+        bitgoPublicKey = await pgp.readKey({ armoredKey: bitgoGpg.publicKey });
+    });
+    async function deriveWithPeer(fault, recordedKeychains) {
+        const { bitgo, baseCoin, post, encryptedInputs, addedKeychains } = createKeychainFixture();
+        const utils = new eddsaVrfMPCv2_1.EddsaVrfMPCv2Utils(bitgo, baseCoin);
+        sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({
+            mpcv2PublicKey: bitgoPublicKey,
+            eddsaMpcv2PublicKey: bitgoPublicKey,
+            redpallasMpcv2PublicKey: undefined,
+        });
+        const bitgoPeer = new sdk_lib_mpc_1.MpsDerive.Derive(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BITGO, bitgoSigningShare, bitgoVrfShare, path);
+        let bitgoMsg2;
+        let userGpgPublicKey = '';
+        let rounds = 0;
+        post.callsFake((_url) => ({
+            send: (rawBody) => ({
+                result: async () => {
+                    const body = (0, codecs_1.decodeWithCodec)(Request, rawBody, 'EdDSA derive request');
+                    assert_1.default.strictEqual(_url, '/mpc/generatekey');
+                    assert_1.default.strictEqual(body.enterprise, 'enterprise-id');
+                    assert_1.default.strictEqual(body.type, public_types_1.KeyGenTypeEnum.MPCv2);
+                    assert_1.default.strictEqual(body.curveType, public_types_1.KeyCurveEnum.EdDSA);
+                    if (rounds++ === 0) {
+                        assert_1.default.strictEqual(body.round, public_types_1.MPCv2KeyGenStateEnum['MPCv2Derive-R1']);
+                        assert_1.default.strictEqual(body.safeId, 'safe-id');
+                        const request = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2DeriveRound1Request, body.payload, 'EdDSA derive round 1');
+                        assert_1.default.deepStrictEqual(Object.keys(request).sort(), [
+                            'derivationIndex',
+                            'parentKeyId',
+                            'userGpgPublicKey',
+                            'userMsg1',
+                        ]);
+                        assert_1.default.strictEqual(request.parentKeyId, 'bitgo-root-id');
+                        assert_1.default.strictEqual(request.derivationIndex, derivationIndex);
+                        userGpgPublicKey = request.userGpgPublicKey;
+                        const userGpgKey = await pgp.readKey({ armoredKey: request.userGpgPublicKey });
+                        const userPayload = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(request.userMsg1, userGpgKey);
+                        const bitgoFirst = await bitgoPeer.initDerive();
+                        const [outgoing] = bitgoPeer.handleIncomingMessages([
+                            { from: typesMPCv2_1.MPCv2PartiesEnum.USER, payload: new Uint8Array(userPayload) },
+                        ]);
+                        assert_1.default.ok(outgoing);
+                        bitgoMsg2 = outgoing.payload;
+                        const signed = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoFirst.payload), bitgoPrivateKey);
+                        return {
+                            sessionId,
+                            bitgoMsg1: fault === 'r1-signature' ? { ...signed, message: Buffer.from('tampered').toString('base64') } : signed,
+                        };
+                    }
+                    assert_1.default.strictEqual(rounds, 2);
+                    assert_1.default.strictEqual(body.round, public_types_1.MPCv2KeyGenStateEnum['MPCv2Derive-R2']);
+                    assert_1.default.strictEqual(body.safeId, 'safe-id');
+                    const request = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2DeriveRound2Request, body.payload, 'EdDSA derive round 2');
+                    assert_1.default.deepStrictEqual(Object.keys(request).sort(), ['sessionId', 'userMsg2']);
+                    assert_1.default.strictEqual(request.sessionId, sessionId);
+                    const userPayload = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(request.userMsg2, await pgp.readKey({ armoredKey: userGpgPublicKey }));
+                    assert_1.default.deepStrictEqual(bitgoPeer.handleIncomingMessages([{ from: typesMPCv2_1.MPCv2PartiesEnum.USER, payload: new Uint8Array(userPayload) }]), []);
+                    assert_1.default.ok(bitgoMsg2);
+                    const signed = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2), bitgoPrivateKey);
+                    const commonPublicKeychain = bitgoPeer.getCommonKeychain();
+                    return {
+                        sessionId: fault === 'session' ? 'different-session' : sessionId,
+                        commonPublicKeychain: fault === 'commonKeychain'
+                            ? `${commonPublicKeychain.slice(0, -1)}${commonPublicKeychain.endsWith('0') ? '1' : '0'}`
+                            : commonPublicKeychain,
+                        bitgoMsg2: fault === 'r2-signature' ? { ...signed, message: Buffer.from('tampered').toString('base64') } : signed,
+                    };
+                },
+            }),
+        }));
+        try {
+            const result = await utils.createSafeChildKeychains({
+                passphrase: 'passphrase',
+                enterprise: 'enterprise-id',
+                safeId: 'safe-id',
+                parentKeyId: 'bitgo-root-id',
+                derivationIndex,
+                userRootKeyId: 'user-root-id',
+                backupRootKeyId: 'backup-root-id',
+                userRootKeyShare: userSigningShare,
+                userRootVrfKeyShare: userVrfShare,
+            });
+            return { result, encryptedInputs, addedKeychains, bitgoPeer, rounds };
+        }
+        finally {
+            recordedKeychains?.push(...addedKeychains);
+        }
+    }
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('registers the child signing share and two public-only placeholders after the signed ceremony', async function () {
+        const { result, encryptedInputs, addedKeychains, bitgoPeer, rounds } = await deriveWithPeer();
+        assert_1.default.strictEqual(rounds, 2);
+        assert_1.default.deepStrictEqual(addedKeychains.map(({ source }) => source).sort(), ['backup', 'bitgo', 'user']);
+        assert_1.default.deepStrictEqual([result.userKeychain.id, result.backupKeychain.id, result.bitgoKeychain.id], ['user-child', 'backup-child', 'bitgo-child']);
+        for (const keychain of addedKeychains) {
+            assert_1.default.strictEqual(keychain.safeId, 'safe-id');
+            assert_1.default.strictEqual(keychain.derivedFromParentWithPath, path);
+            assert_1.default.strictEqual(keychain.commonKeychain, bitgoPeer.getCommonKeychain());
+            assert_1.default.strictEqual(keychain.keyType, 'tss');
+            assert_1.default.strictEqual(keychain.isMPCv2, true);
+        }
+        const userChild = addedKeychains.find(({ source }) => source === 'user');
+        const backupChild = addedKeychains.find(({ source }) => source === 'backup');
+        const bitgoChild = addedKeychains.find(({ source }) => source === 'bitgo');
+        assert_1.default.ok(userChild);
+        assert_1.default.ok(backupChild);
+        assert_1.default.ok(bitgoChild);
+        assert_1.default.strictEqual(userChild.parent, 'user-root-id');
+        assert_1.default.strictEqual(backupChild.parent, 'backup-root-id');
+        assert_1.default.strictEqual(bitgoChild.parent, 'bitgo-root-id');
+        assert_1.default.strictEqual(encryptedInputs.length, 2);
+        assert_1.default.strictEqual(userChild.encryptedPrv, `encrypted:${encryptedInputs[0]}`);
+        const signingShare = Buffer.from(result.userKeychain.encryptedPrv?.slice('encrypted:'.length) ?? '', 'base64');
+        assert_1.default.deepStrictEqual(signingShare, Buffer.from(encryptedInputs[0], 'base64'));
+        assert_1.default.notDeepStrictEqual(signingShare, userSigningShare);
+        assert_1.default.notDeepStrictEqual(signingShare, bitgoPeer.getKeyShare());
+        assert_1.default.strictEqual(userChild.reducedEncryptedPrv, undefined);
+        const reduced = result.userKeychain.reducedEncryptedPrv;
+        assert_1.default.ok(reduced);
+        const reducedShare = sdk_lib_mpc_1.MPSTypes.getDecodedReducedKeyShare(Buffer.from(reduced.slice('encrypted:'.length), 'base64'));
+        assert_1.default.deepStrictEqual(Buffer.from(reducedShare.keyShare), signingShare);
+        assert_1.default.strictEqual(Buffer.from(reducedShare.pub).toString('hex'), bitgoPeer.getCommonKeychain().slice(0, 64));
+        assert_1.default.throws(() => decodeVrfEnvelope(signingShare));
+        assert_1.default.strictEqual(backupChild.encryptedPrv, undefined);
+        assert_1.default.strictEqual(bitgoChild.encryptedPrv, undefined);
+    });
+    it('rejects indexes outside the hardened Safe range before contacting WP', async function () {
+        const { bitgo, baseCoin, post, addedKeychains } = createKeychainFixture();
+        const utils = new eddsaVrfMPCv2_1.EddsaVrfMPCv2Utils(bitgo, baseCoin);
+        await assert_1.default.rejects(utils.createSafeChildKeychains({
+            passphrase: 'passphrase',
+            enterprise: 'enterprise-id',
+            safeId: 'safe-id',
+            parentKeyId: 'bitgo-root-id',
+            derivationIndex: 0x80000000,
+            userRootKeyId: 'user-root-id',
+            backupRootKeyId: 'backup-root-id',
+            userRootKeyShare: userSigningShare,
+            userRootVrfKeyShare: userVrfShare,
+        }), /derivedFromParentWithPath/);
+        assert_1.default.strictEqual(post.called, false);
+        assert_1.default.deepStrictEqual(addedKeychains, []);
+    });
+    const faults = [
+        'r1-signature',
+        'r2-signature',
+        'session',
+        'commonKeychain',
+    ];
+    for (const fault of faults) {
+        it(`rejects ${fault} before registering any child`, async function () {
+            const recordedKeychains = [];
+            await assert_1.default.rejects(() => deriveWithPeer(fault, recordedKeychains), fault === 'session'
+                ? /session id/i
+                : fault === 'commonKeychain'
+                    ? /common keychain/i
+                    : /signature|verification|signed/i);
+            assert_1.default.deepStrictEqual(recordedKeychains, []);
+        });
+    }
+});
+//# 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 * as pgp from 'openpgp';\nimport * as sinon from 'sinon';\nimport { EddsaMPSDkg, MPSComms, MPSUtil, MPSTypes, MpsDerive, MpsVrf, MpsVrfUtils } from '@bitgo-beta/sdk-lib-mpc';\nimport {\n  EddsaMPCv2DeriveRound1Request,\n  EddsaMPCv2DeriveRound2Request,\n  EddsaMPCv2SignedMessage,\n  KeyCurveEnum,\n  KeyGenTypeEnum,\n  MPCv2KeyGenStateEnum,\n} from '@bitgo/public-types';\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 { buildSafeMpcKeyEnvelopes } from '../../../../../../src/bitgo/utils/tss/keyShareEnvelope';\nimport { EddsaVrfMPCv2Utils } from '../../../../../../src/bitgo/utils/tss/eddsa/eddsaVrfMPCv2';\nimport { MPCv2PartiesEnum } from '../../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2';\nimport { generateGPGKeyPair } from '../../../../../../src/bitgo/utils/opengpgUtils';\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  reducedEncryptedPrv?: string;\n  safeId?: string;\n  parent?: string;\n  derivedFromParentWithPath?: string;\n  commonKeychain?: string;\n  isMPCv2?: boolean;\n  keyType?: string;\n};\n\nfunction decodeVrfEnvelope(encoded: Buffer): t.TypeOf<typeof VrfEnvelope> {\n  return decodeWithCodec(VrfEnvelope, decode(encoded), 'VRF key envelope');\n}\n\nfunction createKeychainFixture() {\n  const encryptedInputs: string[] = [];\n  const addedKeychains: AddedKeychainParams[] = [];\n  const post = sinon.stub();\n  const bitgo = {\n    getEnv: () => 'dev',\n    url: (path: string) => path,\n    post,\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: `${params.source}-child`, type: 'tss', encryptedPrv: params.encryptedPrv };\n    },\n  };\n  const baseCoin = {\n    keychains: () => keychains,\n  } as unknown as IBaseCoin;\n  return { bitgo, baseCoin, post, encryptedInputs, addedKeychains };\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 } = buildSafeMpcKeyEnvelopes(\n      privateMaterial,\n      reducedPrivateMaterial,\n      vrfKeyShare\n    );\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 { bitgo, baseCoin, encryptedInputs, addedKeychains } = createKeychainFixture();\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('rejects a public-only backup outside a safe child derivation', async function () {\n    const { bitgo, baseCoin, encryptedInputs, addedKeychains } = createKeychainFixture();\n    const utils = new EddsaMPCv2Utils(bitgo, baseCoin);\n\n    await assert.rejects(\n      utils.createParticipantKeychain(MPCv2PartiesEnum.BACKUP, 'common-keychain', undefined, undefined, 'passphrase'),\n      /Private material is required for backup keychain/\n    );\n    assert.deepStrictEqual(encryptedInputs, []);\n    assert.deepStrictEqual(addedKeychains, []);\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 } = buildSafeMpcKeyEnvelopes(\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  describe('safe root keygen against the HSM contract', function () {\n    const KeyGenRequest = t.intersection([\n      t.type({ enterprise: t.string, type: t.string, curveType: t.string, round: t.string }),\n      t.partial({ safeId: t.string, payload: t.UnknownRecord }),\n    ]);\n    const R1Payload = t.intersection([\n      t.type({\n        userGpgPublicKey: t.string,\n        backupGpgPublicKey: t.string,\n        userMsg1: EddsaMPCv2SignedMessage,\n        backupMsg1: EddsaMPCv2SignedMessage,\n      }),\n      t.type({\n        userVrfMsg1: EddsaMPCv2SignedMessage,\n        backupVrfMsg1: EddsaMPCv2SignedMessage,\n      }),\n    ]);\n    const R2Payload = t.intersection([\n      t.type({ sessionId: t.string, userMsg2: EddsaMPCv2SignedMessage, backupMsg2: EddsaMPCv2SignedMessage }),\n      t.type({\n        userVrfMsg2: EddsaMPCv2SignedMessage,\n        backupVrfMsg2: EddsaMPCv2SignedMessage,\n      }),\n    ]);\n\n    let bitgoPrivateKey: pgp.PrivateKey;\n    let bitgoPublicKey: pgp.Key;\n\n    before(async function () {\n      const bitgoGpg = await generateGPGKeyPair('ed25519');\n      bitgoPrivateKey = await pgp.readPrivateKey({ armoredKey: bitgoGpg.privateKey });\n      bitgoPublicKey = await pgp.readKey({ armoredKey: bitgoGpg.publicKey });\n    });\n\n    afterEach(function () {\n      sinon.restore();\n    });\n\n    /** BitGo's side of the ceremony: signing DKG + VRF DKG, verifying every client signature like the HSM does. */\n    async function keygenWithHsmPeer(\n      fault?: 'bitgo-vrf-msg1-signature' | 'bitgo-vrf-opening-signature' | 'missing-opening'\n    ) {\n      const { bitgo, baseCoin, post, encryptedInputs, addedKeychains } = createKeychainFixture();\n      const utils = new EddsaVrfMPCv2Utils(bitgo, baseCoin);\n      sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({\n        mpcv2PublicKey: bitgoPublicKey,\n        eddsaMpcv2PublicKey: bitgoPublicKey,\n        redpallasMpcv2PublicKey: undefined,\n      });\n\n      const bitgoDkg = new EddsaMPSDkg.DKG(3, 2, MPCv2PartiesEnum.BITGO);\n      const bitgoVrf = new MpsVrf.VrfDkg(3, 2, MPCv2PartiesEnum.BITGO);\n      const requests: Record<string, unknown>[] = [];\n      let bitgoMsg2: MPSTypes.DeserializedMessage | undefined;\n      let userGpgKey: pgp.Key | undefined;\n      let backupGpgKey: pgp.Key | undefined;\n      let userCommitment: Uint8Array | undefined;\n      let backupCommitment: Uint8Array | undefined;\n\n      const signAsBitgo = (payload: Uint8Array) => MPSComms.detachSignMpsMessage(payload, bitgoPrivateKey);\n      const encryptTo = async (recipient: pgp.Key, plaintext: Uint8Array): Promise<EddsaMPCv2SignedMessage> => {\n        const { signature } = await signAsBitgo(plaintext);\n        const message = await pgp.encrypt({\n          message: await pgp.createMessage({ binary: plaintext }),\n          encryptionKeys: recipient,\n          format: 'armored',\n        });\n        return {\n          message,\n          signature:\n            fault === 'bitgo-vrf-opening-signature' ? (await signAsBitgo(new Uint8Array([9]))).signature : signature,\n        };\n      };\n\n      post.callsFake(() => ({\n        send: (rawBody: unknown) => ({\n          result: async () => {\n            const body = decodeWithCodec(KeyGenRequest, rawBody, 'EdDSA keygen request');\n            assert.strictEqual(body.type, KeyGenTypeEnum.MPCv2);\n            assert.strictEqual(body.curveType, KeyCurveEnum.EdDSA);\n            // WP only reads safeId in round 1; round 2 is routed by the stored session.\n            assert.strictEqual(body.safeId, body.round === MPCv2KeyGenStateEnum['MPCv2-R1'] ? 'safe-id' : undefined);\n            requests.push({ round: body.round, ...body.payload });\n\n            if (body.round === MPCv2KeyGenStateEnum['MPCv2-R1']) {\n              const payload = decodeWithCodec(R1Payload, body.payload, 'EdDSA keygen round 1');\n              userGpgKey = await pgp.readKey({ armoredKey: payload.userGpgPublicKey });\n              backupGpgKey = await pgp.readKey({ armoredKey: payload.backupGpgPublicKey });\n              const [userPk, backupPk] = await Promise.all([\n                MPSComms.extractEd25519PublicKey(userGpgKey),\n                MPSComms.extractEd25519PublicKey(backupGpgKey),\n              ]);\n              const [, bitgoSk] = await MPSComms.extractEd25519KeyPair(bitgoPrivateKey);\n\n              const userMsg1 = await MPSComms.verifyMpsMessage(payload.userMsg1, userGpgKey);\n              const backupMsg1 = await MPSComms.verifyMpsMessage(payload.backupMsg1, backupGpgKey);\n              // The VRF messages must be signed by the same party key as userMsg1/backupMsg1.\n              userCommitment = new Uint8Array(await MPSComms.verifyMpsMessage(payload.userVrfMsg1, userGpgKey));\n              backupCommitment = new Uint8Array(await MPSComms.verifyMpsMessage(payload.backupVrfMsg1, backupGpgKey));\n              await assert.rejects(MPSComms.verifyMpsMessage(payload.userVrfMsg1, backupGpgKey));\n\n              await bitgoDkg.initDkg(bitgoSk, [userPk, backupPk]);\n              const bitgoRawMsg1 = bitgoDkg.getFirstMessage();\n              [bitgoMsg2] = bitgoDkg.handleIncomingMessages([\n                { from: MPCv2PartiesEnum.USER, payload: new Uint8Array(userMsg1) },\n                { from: MPCv2PartiesEnum.BACKUP, payload: new Uint8Array(backupMsg1) },\n                bitgoRawMsg1,\n              ]);\n\n              const [bitgoVrfCommitment] = (await bitgoVrf.initDkg()).broadcastMessages;\n              const signedVrfMsg1 = await signAsBitgo(bitgoVrfCommitment.payload);\n              return {\n                sessionId: 'session-id',\n                bitgoMsg1: await signAsBitgo(bitgoRawMsg1.payload),\n                bitgoVrfMsg1:\n                  fault === 'bitgo-vrf-msg1-signature'\n                    ? { ...signedVrfMsg1, message: Buffer.from('tampered').toString('base64') }\n                    : signedVrfMsg1,\n              };\n            }\n\n            assert.strictEqual(body.round, MPCv2KeyGenStateEnum['MPCv2-R2']);\n            const payload = decodeWithCodec(R2Payload, body.payload, 'EdDSA keygen round 2');\n            assert.ok(userGpgKey && backupGpgKey && userCommitment && backupCommitment && bitgoMsg2);\n            assert.deepStrictEqual(Object.keys(payload).sort(), [\n              'backupMsg2',\n              'backupVrfMsg2',\n              'sessionId',\n              'userMsg2',\n              'userVrfMsg2',\n            ]);\n\n            const userMsg2 = await MPSComms.verifyMpsMessage(payload.userMsg2, userGpgKey);\n            const backupMsg2 = await MPSComms.verifyMpsMessage(payload.backupMsg2, backupGpgKey);\n            const userOpening = new Uint8Array(await MPSComms.verifyMpsMessage(payload.userVrfMsg2, userGpgKey));\n            const backupOpening = new Uint8Array(await MPSComms.verifyMpsMessage(payload.backupVrfMsg2, backupGpgKey));\n\n            bitgoDkg.handleIncomingMessages([\n              { from: MPCv2PartiesEnum.USER, payload: new Uint8Array(userMsg2) },\n              { from: MPCv2PartiesEnum.BACKUP, payload: new Uint8Array(backupMsg2) },\n              bitgoMsg2,\n            ]);\n\n            const openings = await bitgoVrf.handleIncomingMessages({\n              broadcastMessages: [\n                { from: MPCv2PartiesEnum.USER, payload: userCommitment },\n                { from: MPCv2PartiesEnum.BACKUP, payload: backupCommitment },\n              ],\n              p2pMessages: [],\n            });\n            const toUser = openings.p2pMessages.find(({ to }) => to === MPCv2PartiesEnum.USER);\n            const toBackup = openings.p2pMessages.find(({ to }) => to === MPCv2PartiesEnum.BACKUP);\n            assert.ok(toUser && toBackup);\n            await bitgoVrf.handleIncomingMessages({\n              broadcastMessages: [],\n              p2pMessages: [\n                { from: MPCv2PartiesEnum.USER, to: MPCv2PartiesEnum.BITGO, payload: userOpening },\n                { from: MPCv2PartiesEnum.BACKUP, to: MPCv2PartiesEnum.BITGO, payload: backupOpening },\n              ],\n            });\n\n            return {\n              sessionId: payload.sessionId,\n              commonPublicKeychain: bitgoDkg.getCommonKeychain(),\n              bitgoMsg2: await signAsBitgo(bitgoMsg2.payload),\n              ...(fault === 'missing-opening'\n                ? {}\n                : { bitgoVrfMsgToUser: await encryptTo(userGpgKey, toUser.payload) }),\n              bitgoVrfMsgToBackup: await encryptTo(backupGpgKey, toBackup.payload),\n            };\n          },\n        }),\n      }));\n\n      await utils.createKeychains({\n        passphrase: 'passphrase',\n        enterprise: 'enterprise-id',\n        safeId: 'safe-id',\n      });\n      return { requests, encryptedInputs, addedKeychains };\n    }\n\n    it('signs VRF messages with the party keys and decrypts BitGo openings without handling the HSM VRF state', async function () {\n      const { requests, encryptedInputs, addedKeychains } = await keygenWithHsmPeer();\n\n      assert.deepStrictEqual(\n        requests.map(({ round }) => round),\n        [MPCv2KeyGenStateEnum['MPCv2-R1'], MPCv2KeyGenStateEnum['MPCv2-R2']]\n      );\n      // WP keeps the HSM VRF state between rounds, so neither client round carries it.\n      for (const request of requests) {\n        assert.strictEqual('bitgoEncryptedVrfDkgState' in request, false);\n      }\n\n      // Both client roots end up with a signing share and a VRF share, tagged with the safe.\n      assert.deepStrictEqual(addedKeychains.map(({ source }) => source).sort(), ['backup', 'bitgo', 'user']);\n      for (const keychain of addedKeychains) {\n        assert.strictEqual(keychain.safeId, 'safe-id');\n      }\n      // User and backup each encrypt a full and a reduced envelope; every one carries a VRF share, and\n      // the two parties' shares differ. Order-independent: the roots are registered concurrently.\n      const vrfShares = new Set(\n        encryptedInputs.map((input) => {\n          const { vrf, prvKeyShare } = decodeVrfEnvelope(Buffer.from(input, 'base64'));\n          assert.ok(vrf.length > 0);\n          assert.ok(prvKeyShare.length > 0);\n          return Buffer.from(vrf).toString('hex');\n        })\n      );\n      assert.strictEqual(encryptedInputs.length, 4);\n      assert.strictEqual(vrfShares.size, 2);\n    });\n\n    it('rejects a BitGo VRF round 1 message whose signature does not verify', async function () {\n      await assert.rejects(keygenWithHsmPeer('bitgo-vrf-msg1-signature'), /signature|verification|signed/i);\n    });\n\n    it('rejects a BitGo VRF opening whose signature does not verify', async function () {\n      await assert.rejects(keygenWithHsmPeer('bitgo-vrf-opening-signature'), /signature|verification|signed/i);\n    });\n\n    it('fails when the HSM omits a BitGo VRF opening in round 2', async function () {\n      await assert.rejects(keygenWithHsmPeer('missing-opening'), /VRF message to user/);\n    });\n  });\n});\n\ndescribe('EdDSA safe-child MPS derivation', function () {\n  let userSigningShare: Buffer;\n  let userVrfShare: Buffer;\n  let bitgoSigningShare: Buffer;\n  let bitgoVrfShare: Buffer;\n  let bitgoPrivateKey: pgp.PrivateKey;\n  let bitgoPublicKey: pgp.Key;\n\n  const sessionId = 'derive-session';\n  const derivationIndex = 7;\n  const path = \"m/7'\";\n  const Request = t.intersection([\n    t.type({ enterprise: t.string, type: t.string, curveType: t.string, round: t.string, payload: t.unknown }),\n    t.partial({ safeId: t.string }),\n  ]);\n\n  before(async function () {\n    const signing = await MPSUtil.generateEdDsaDKGKeyShares();\n    const vrf = await MpsVrfUtils.generateVrfDKGKeyShares();\n    userSigningShare = signing[MPCv2PartiesEnum.USER].getKeyShare();\n    bitgoSigningShare = signing[MPCv2PartiesEnum.BITGO].getKeyShare();\n    userVrfShare = vrf[MPCv2PartiesEnum.USER].getKeyShare();\n    bitgoVrfShare = vrf[MPCv2PartiesEnum.BITGO].getKeyShare();\n    const bitgoGpg = await generateGPGKeyPair('ed25519');\n    bitgoPrivateKey = await pgp.readPrivateKey({ armoredKey: bitgoGpg.privateKey });\n    bitgoPublicKey = await pgp.readKey({ armoredKey: bitgoGpg.publicKey });\n  });\n\n  async function deriveWithPeer(\n    fault?: 'r1-signature' | 'r2-signature' | 'session' | 'commonKeychain',\n    recordedKeychains?: AddedKeychainParams[]\n  ) {\n    const { bitgo, baseCoin, post, encryptedInputs, addedKeychains } = createKeychainFixture();\n    const utils = new EddsaVrfMPCv2Utils(bitgo, baseCoin);\n    sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({\n      mpcv2PublicKey: bitgoPublicKey,\n      eddsaMpcv2PublicKey: bitgoPublicKey,\n      redpallasMpcv2PublicKey: undefined,\n    });\n    const bitgoPeer = new MpsDerive.Derive(3, 2, MPCv2PartiesEnum.BITGO, bitgoSigningShare, bitgoVrfShare, path);\n    let bitgoMsg2: Uint8Array | undefined;\n    let userGpgPublicKey = '';\n    let rounds = 0;\n    post.callsFake((_url: string) => ({\n      send: (rawBody: unknown) => ({\n        result: async () => {\n          const body = decodeWithCodec(Request, rawBody, 'EdDSA derive request');\n          assert.strictEqual(_url, '/mpc/generatekey');\n          assert.strictEqual(body.enterprise, 'enterprise-id');\n          assert.strictEqual(body.type, KeyGenTypeEnum.MPCv2);\n          assert.strictEqual(body.curveType, KeyCurveEnum.EdDSA);\n          if (rounds++ === 0) {\n            assert.strictEqual(body.round, MPCv2KeyGenStateEnum['MPCv2Derive-R1']);\n            assert.strictEqual(body.safeId, 'safe-id');\n            const request = decodeWithCodec(EddsaMPCv2DeriveRound1Request, body.payload, 'EdDSA derive round 1');\n            assert.deepStrictEqual(Object.keys(request).sort(), [\n              'derivationIndex',\n              'parentKeyId',\n              'userGpgPublicKey',\n              'userMsg1',\n            ]);\n            assert.strictEqual(request.parentKeyId, 'bitgo-root-id');\n            assert.strictEqual(request.derivationIndex, derivationIndex);\n            userGpgPublicKey = request.userGpgPublicKey;\n            const userGpgKey = await pgp.readKey({ armoredKey: request.userGpgPublicKey });\n            const userPayload = await MPSComms.verifyMpsMessage(request.userMsg1, userGpgKey);\n            const bitgoFirst = await bitgoPeer.initDerive();\n            const [outgoing] = bitgoPeer.handleIncomingMessages([\n              { from: MPCv2PartiesEnum.USER, payload: new Uint8Array(userPayload) },\n            ]);\n            assert.ok(outgoing);\n            bitgoMsg2 = outgoing.payload;\n            const signed = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoFirst.payload), bitgoPrivateKey);\n            return {\n              sessionId,\n              bitgoMsg1:\n                fault === 'r1-signature' ? { ...signed, message: Buffer.from('tampered').toString('base64') } : signed,\n            };\n          }\n          assert.strictEqual(rounds, 2);\n          assert.strictEqual(body.round, MPCv2KeyGenStateEnum['MPCv2Derive-R2']);\n          assert.strictEqual(body.safeId, 'safe-id');\n          const request = decodeWithCodec(EddsaMPCv2DeriveRound2Request, body.payload, 'EdDSA derive round 2');\n          assert.deepStrictEqual(Object.keys(request).sort(), ['sessionId', 'userMsg2']);\n          assert.strictEqual(request.sessionId, sessionId);\n          const userPayload = await MPSComms.verifyMpsMessage(\n            request.userMsg2,\n            await pgp.readKey({ armoredKey: userGpgPublicKey })\n          );\n          assert.deepStrictEqual(\n            bitgoPeer.handleIncomingMessages([{ from: MPCv2PartiesEnum.USER, payload: new Uint8Array(userPayload) }]),\n            []\n          );\n          assert.ok(bitgoMsg2);\n          const signed = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2), bitgoPrivateKey);\n          const commonPublicKeychain = bitgoPeer.getCommonKeychain();\n          return {\n            sessionId: fault === 'session' ? 'different-session' : sessionId,\n            commonPublicKeychain:\n              fault === 'commonKeychain'\n                ? `${commonPublicKeychain.slice(0, -1)}${commonPublicKeychain.endsWith('0') ? '1' : '0'}`\n                : commonPublicKeychain,\n            bitgoMsg2:\n              fault === 'r2-signature' ? { ...signed, message: Buffer.from('tampered').toString('base64') } : signed,\n          };\n        },\n      }),\n    }));\n\n    try {\n      const result = await utils.createSafeChildKeychains({\n        passphrase: 'passphrase',\n        enterprise: 'enterprise-id',\n        safeId: 'safe-id',\n        parentKeyId: 'bitgo-root-id',\n        derivationIndex,\n        userRootKeyId: 'user-root-id',\n        backupRootKeyId: 'backup-root-id',\n        userRootKeyShare: userSigningShare,\n        userRootVrfKeyShare: userVrfShare,\n      });\n      return { result, encryptedInputs, addedKeychains, bitgoPeer, rounds };\n    } finally {\n      recordedKeychains?.push(...addedKeychains);\n    }\n  }\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('registers the child signing share and two public-only placeholders after the signed ceremony', async function () {\n    const { result, encryptedInputs, addedKeychains, bitgoPeer, rounds } = await deriveWithPeer();\n    assert.strictEqual(rounds, 2);\n    assert.deepStrictEqual(addedKeychains.map(({ source }) => source).sort(), ['backup', 'bitgo', 'user']);\n    assert.deepStrictEqual(\n      [result.userKeychain.id, result.backupKeychain.id, result.bitgoKeychain.id],\n      ['user-child', 'backup-child', 'bitgo-child']\n    );\n    for (const keychain of addedKeychains) {\n      assert.strictEqual(keychain.safeId, 'safe-id');\n      assert.strictEqual(keychain.derivedFromParentWithPath, path);\n      assert.strictEqual(keychain.commonKeychain, bitgoPeer.getCommonKeychain());\n      assert.strictEqual(keychain.keyType, 'tss');\n      assert.strictEqual(keychain.isMPCv2, true);\n    }\n    const userChild = addedKeychains.find(({ source }) => source === 'user');\n    const backupChild = addedKeychains.find(({ source }) => source === 'backup');\n    const bitgoChild = addedKeychains.find(({ source }) => source === 'bitgo');\n    assert.ok(userChild);\n    assert.ok(backupChild);\n    assert.ok(bitgoChild);\n    assert.strictEqual(userChild.parent, 'user-root-id');\n    assert.strictEqual(backupChild.parent, 'backup-root-id');\n    assert.strictEqual(bitgoChild.parent, 'bitgo-root-id');\n    assert.strictEqual(encryptedInputs.length, 2);\n    assert.strictEqual(userChild.encryptedPrv, `encrypted:${encryptedInputs[0]}`);\n    const signingShare = Buffer.from(result.userKeychain.encryptedPrv?.slice('encrypted:'.length) ?? '', 'base64');\n    assert.deepStrictEqual(signingShare, Buffer.from(encryptedInputs[0], 'base64'));\n    assert.notDeepStrictEqual(signingShare, userSigningShare);\n    assert.notDeepStrictEqual(signingShare, bitgoPeer.getKeyShare());\n    assert.strictEqual(userChild.reducedEncryptedPrv, undefined);\n    const reduced = result.userKeychain.reducedEncryptedPrv;\n    assert.ok(reduced);\n    const reducedShare = MPSTypes.getDecodedReducedKeyShare(Buffer.from(reduced.slice('encrypted:'.length), 'base64'));\n    assert.deepStrictEqual(Buffer.from(reducedShare.keyShare), signingShare);\n    assert.strictEqual(Buffer.from(reducedShare.pub).toString('hex'), bitgoPeer.getCommonKeychain().slice(0, 64));\n    assert.throws(() => decodeVrfEnvelope(signingShare));\n    assert.strictEqual(backupChild.encryptedPrv, undefined);\n    assert.strictEqual(bitgoChild.encryptedPrv, undefined);\n  });\n\n  it('rejects indexes outside the hardened Safe range before contacting WP', async function () {\n    const { bitgo, baseCoin, post, addedKeychains } = createKeychainFixture();\n    const utils = new EddsaVrfMPCv2Utils(bitgo, baseCoin);\n\n    await assert.rejects(\n      utils.createSafeChildKeychains({\n        passphrase: 'passphrase',\n        enterprise: 'enterprise-id',\n        safeId: 'safe-id',\n        parentKeyId: 'bitgo-root-id',\n        derivationIndex: 0x80000000,\n        userRootKeyId: 'user-root-id',\n        backupRootKeyId: 'backup-root-id',\n        userRootKeyShare: userSigningShare,\n        userRootVrfKeyShare: userVrfShare,\n      }),\n      /derivedFromParentWithPath/\n    );\n    assert.strictEqual(post.called, false);\n    assert.deepStrictEqual(addedKeychains, []);\n  });\n\n  const faults: Array<'r1-signature' | 'r2-signature' | 'session' | 'commonKeychain'> = [\n    'r1-signature',\n    'r2-signature',\n    'session',\n    'commonKeychain',\n  ];\n  for (const fault of faults) {\n    it(`rejects ${fault} before registering any child`, async function () {\n      const recordedKeychains: AddedKeychainParams[] = [];\n      await assert.rejects(\n        () => deriveWithPeer(fault, recordedKeychains),\n        fault === 'session'\n          ? /session id/i\n          : fault === 'commonKeychain'\n          ? /common keychain/i\n          : /signature|verification|signed/i\n      );\n      assert.deepStrictEqual(recordedKeychains, []);\n    });\n  }\n});\n"]}