@bitgo/sdk-core 38.13.0 → 38.16.0

package/dist/src/bitgo/utils/tss/ecdsa/ecdsaVrfMPCv2.js

@@ -0,0 +1,494 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcdsaVrfMPCv2Utils = void 0;
+exports.buildVrfKeyEnvelopes = buildVrfKeyEnvelopes;
+exports.parseVrfKeyEnvelopes = parseVrfKeyEnvelopes;
+exports.hardenedDerivationPath = hardenedDerivationPath;
+const sdk_lib_mpc_1 = require("@bitgo/sdk-lib-mpc");
+const cbor_x_1 = require("cbor-x");
+const assert_1 = __importDefault(require("assert"));
+const io_ts_types_1 = require("io-ts-types");
+const public_types_1 = require("@bitgo/public-types");
+const opengpgUtils_1 = require("../../opengpgUtils");
+const bitgoPubKeys_1 = require("../../../tss/bitgoPubKeys");
+const ecdsaMPCv2_1 = require("./ecdsaMPCv2");
+const ecdsaMPCv2KeyGenSender_1 = require("./ecdsaMPCv2KeyGenSender");
+const typesMPCv2_1 = require("./typesMPCv2");
+/**
+ * Version field of the `encryptedPrv` envelope used when a ceremony produces both a
+ * signing keyshare and a VRF keyshare. The plaintext handed to encrypt() is
+ * `base64(cborEncode(envelope))`, keeping it a single opaque base64 token exactly as
+ * the ordinary MPCv2 format does.
+ */
+const VRF_KEY_ENVELOPE_VERSION = 1;
+function isVrfKeyEnvelope(value) {
+    return typeof value === 'object' && value !== null && 'version' in value && 'prvKeyShare' in value && 'vrf' in value;
+}
+function serializeVrfMessages(messages) {
+    const transfers = [
+        ...messages.broadcastMessages.map((m) => ({ from: m.from, payload: Buffer.from(m.payload).toString('base64') })),
+        ...messages.p2pMessages.map((m) => ({
+            from: m.from,
+            to: m.to,
+            payload: Buffer.from(m.payload).toString('base64'),
+        })),
+    ];
+    return Buffer.from(JSON.stringify(transfers)).toString('base64');
+}
+function deserializeVrfMessages(blob, forParty) {
+    const transfers = JSON.parse(Buffer.from(blob, 'base64').toString());
+    return {
+        broadcastMessages: transfers
+            .filter((t) => t.to === undefined)
+            .map((t) => ({ from: t.from, payload: new Uint8Array(Buffer.from(t.payload, 'base64')) })),
+        p2pMessages: transfers
+            .filter((t) => t.to === forParty)
+            .map((t) => ({ from: t.from, to: t.to, payload: new Uint8Array(Buffer.from(t.payload, 'base64')) })),
+    };
+}
+/**
+ * Combines the signing keyshare with the VRF keyshare into the `encryptedPrv` envelope
+ * (`base64(cborEncode({version, prvKeyShare, vrf}))` once the caller base64-encodes the
+ * returned buffers). The same container wraps the reduced signing share for
+ * `reducedEncryptedPrv`.
+ */
+function buildVrfKeyEnvelopes(privateMaterial, reducedPrivateMaterial, vrfKeyShare) {
+    const envelope = (0, cbor_x_1.encode)({
+        version: VRF_KEY_ENVELOPE_VERSION,
+        prvKeyShare: new Uint8Array(privateMaterial),
+        vrf: new Uint8Array(vrfKeyShare),
+    });
+    const reducedEnvelope = (0, cbor_x_1.encode)({
+        version: VRF_KEY_ENVELOPE_VERSION,
+        prvKeyShare: new Uint8Array(reducedPrivateMaterial),
+        vrf: new Uint8Array(vrfKeyShare),
+    });
+    return { envelope: Buffer.from(envelope), reducedEnvelope: Buffer.from(reducedEnvelope) };
+}
+/**
+ * Parses a decrypted root blob produced by {@link buildVrfKeyEnvelopes}: a CBOR
+ * envelope `{version: 1, prvKeyShare, vrf}`. Returns the signing and VRF keyshares
+ * as Buffers. Throws if the blob is not a valid VRF key envelope.
+ */
+function parseVrfKeyEnvelopes(decryptedBlob) {
+    let envelope;
+    try {
+        envelope = (0, cbor_x_1.decode)(Buffer.from(decryptedBlob, 'base64'));
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to decode safe MPC root key envelope: ${message}`);
+    }
+    if (!isVrfKeyEnvelope(envelope)) {
+        throw new Error('Invalid safe MPC root key envelope: expected version, signing keyshare, and VRF keyshare');
+    }
+    const { version, prvKeyShare, vrf } = envelope;
+    if (version !== VRF_KEY_ENVELOPE_VERSION) {
+        throw new Error(`Unsupported safe MPC root key envelope version: ${String(version)}`);
+    }
+    if (!(prvKeyShare instanceof Uint8Array) || prvKeyShare.length === 0) {
+        throw new Error('Safe MPC root key envelope is missing a signing keyshare');
+    }
+    if (!(vrf instanceof Uint8Array) || vrf.length === 0) {
+        throw new Error('Safe MPC root key envelope is missing a VRF keyshare');
+    }
+    return { signing: Buffer.from(prvKeyShare), vrf: Buffer.from(vrf) };
+}
+/**
+ * Encodes a hardened derivation index as the byte path the DKLS hard-derive wasm
+ * expects: one big-endian u32 with the hardened bit (0x80000000) set — i.e. the
+ * child path `m/<index>'`. The server derives the same hardened path from the
+ * `derivationIndex` it receives on round 1.
+ */
+function hardenedDerivationPath(index) {
+    if (!Number.isInteger(index) || index < 0 || index > 0x7fffffff) {
+        throw new Error(`Invalid derivation index: ${index}`);
+    }
+    return new Uint8Array([0x80 | (index >>> 24), (index >>> 16) & 0xff, (index >>> 8) & 0xff, index & 0xff]);
+}
+/**
+ * EcdsaMPCv2Utils variant that runs the Ristretto VRF DKG alongside the signing DKLS
+ * DKG inside the same MPCv2 keygen rounds, for safe MPC root creation.
+ *
+ * The round enum is unchanged: the VRF commitment rides MPCv2-R1, the opening rides
+ * MPCv2-R2, and the VRF DKG finalizes locally before MPCv2-R3. VRF messages travel as
+ * opaque base64 fields on the round payloads, never through the DKLS broadcast/p2p slots.
+ * At the end, the signing and VRF keyshares are combined into a single CBOR envelope
+ * before encryption.
+ */
+class EcdsaVrfMPCv2Utils extends ecdsaMPCv2_1.EcdsaMPCv2Utils {
+    /** @inheritdoc */
+    async createKeychains(params) {
+        const { userSession, backupSession } = this.createSigningDkgSessions(params.retrofit);
+        const userVrfSession = new sdk_lib_mpc_1.DklsVrf.VrfDkg(3, 2, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const backupVrfSession = new sdk_lib_mpc_1.DklsVrf.VrfDkg(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        const backupGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        // Get the BitGo public key based on user/enterprise feature flags
+        // If it doesn't work, use the default public key from the constants
+        const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);
+        const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;
+        (0, assert_1.default)(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');
+        const bitgoPublicGpgKey = mpcv2Key.armor();
+        if ((0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+            // Ensure the public key is one of the expected BitGo public keys when in test or prod.
+            (0, assert_1.default)((0, bitgoPubKeys_1.isBitgoMpcPubKey)(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');
+        }
+        const userGpgPrvKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.USER,
+            gpgKey: userGpgKey.privateKey,
+        };
+        const backupGpgPrvKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.BACKUP,
+            gpgKey: backupGpgKey.privateKey,
+        };
+        const bitgoGpgPubKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+            gpgKey: bitgoPublicGpgKey,
+        };
+        // #region round 1
+        const userRound1BroadcastMsg = await userSession.initDkg();
+        const backupRound1BroadcastMsg = await backupSession.initDkg();
+        const userVrfRound1Msg = await userVrfSession.initDkg();
+        const backupVrfRound1Msg = await backupVrfSession.initDkg();
+        const round1SerializedMessages = sdk_lib_mpc_1.DklsTypes.serializeMessages({
+            broadcastMessages: [userRound1BroadcastMsg, backupRound1BroadcastMsg],
+            p2pMessages: [],
+        });
+        const round1Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages(round1SerializedMessages, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const userMsg1 = round1Messages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER)?.payload;
+        const backupMsg1 = round1Messages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP)?.payload;
+        (0, assert_1.default)(userMsg1, 'User message 1 not found in broadcast messages');
+        (0, assert_1.default)(backupMsg1, 'Backup message 1 not found in broadcast messages');
+        const userGpgPublicKey = userGpgKey.publicKey;
+        const backupGpgPublicKey = backupGpgKey.publicKey;
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(backupGpgPublicKey), 'Backup GPG public key is required');
+        // Keep VRF messages opaque on the key-generation request.
+        const round1Sender = (0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, params.enterprise, params.safeId);
+        const { sessionId, bitgoMsg1, bitgoToBackupMsg2, bitgoToUserMsg2, bitgoVrfMsg1 } = await round1Sender(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1'], {
+            userMsg1: { from: typesMPCv2_1.MPCv2PartiesEnum.USER, ...userMsg1 },
+            backupMsg1: { from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP, ...backupMsg1 },
+            userGpgPublicKey,
+            backupGpgPublicKey,
+            userVrfMsg1: serializeVrfMessages(userVrfRound1Msg),
+            backupVrfMsg1: serializeVrfMessages(backupVrfRound1Msg),
+            walletId: params.retrofit?.walletId,
+        });
+        (0, assert_1.default)(bitgoVrfMsg1, 'BitGo VRF message 1 not found in round 1 response');
+        // #endregion
+        // #region round 2
+        const bitgoRound1BroadcastMessages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg1)] }, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const bitgoRound1BroadcastMsg = bitgoRound1BroadcastMessages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(bitgoRound1BroadcastMsg, 'BitGo message 1 not found in broadcast messages');
+        const userRound2P2PMessages = userSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [sdk_lib_mpc_1.DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg), backupRound1BroadcastMsg],
+        });
+        const userToBitgoMsg2 = userRound2P2PMessages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(userToBitgoMsg2, 'User message 2 not found in P2P messages');
+        const serializedUserToBitgoMsg2 = sdk_lib_mpc_1.DklsTypes.serializeP2PMessage(userToBitgoMsg2);
+        const backupRound2P2PMessages = backupSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [userRound1BroadcastMsg, sdk_lib_mpc_1.DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg)],
+        });
+        const serializedBackupToBitgoMsg2 = sdk_lib_mpc_1.DklsTypes.serializeMessages(backupRound2P2PMessages).p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(serializedBackupToBitgoMsg2, 'Backup message 2 not found in P2P messages');
+        // VRF: consume BitGo's and the counterparty's commitments, emit this party's openings.
+        // Openings come back as p2p messages addressed to each party (including the sender).
+        const userVrfRound2Messages = await userVrfSession.handleIncomingMessages({
+            broadcastMessages: [
+                ...backupVrfRound1Msg.broadcastMessages,
+                ...deserializeVrfMessages(bitgoVrfMsg1, typesMPCv2_1.MPCv2PartiesEnum.USER).broadcastMessages,
+            ],
+            p2pMessages: [],
+        });
+        const backupVrfRound2Messages = await backupVrfSession.handleIncomingMessages({
+            broadcastMessages: [
+                ...userVrfRound1Msg.broadcastMessages,
+                ...deserializeVrfMessages(bitgoVrfMsg1, typesMPCv2_1.MPCv2PartiesEnum.BACKUP).broadcastMessages,
+            ],
+            p2pMessages: [],
+        });
+        const round2Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages({ p2pMessages: [serializedUserToBitgoMsg2, serializedBackupToBitgoMsg2], broadcastMessages: [] }, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const userRound2Msg = round2Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const backupRound2Msg = round2Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(userRound2Msg, 'User to Bitgo message 2 not found in P2P messages');
+        (0, assert_1.default)(userRound2Msg.commitment, 'User to Bitgo commitment not found in P2P messages');
+        (0, assert_1.default)(backupRound2Msg, 'Backup to Bitgo message 2 not found in P2P messages');
+        (0, assert_1.default)(backupRound2Msg.commitment, 'Backup to Bitgo commitment not found in P2P messages');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(userRound2Msg.commitment), 'User to Bitgo commitment is required');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(backupRound2Msg.commitment), 'Backup to Bitgo commitment is required');
+        const round2Sender = (0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, params.enterprise);
+        const { sessionId: sessionIdRound2, bitgoCommitment2, bitgoToUserMsg3, bitgoToBackupMsg3, bitgoVrfMsg2, } = await round2Sender(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R2'], {
+            sessionId,
+            userMsg2: {
+                from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+                to: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+                signature: userRound2Msg.payload.signature,
+                encryptedMessage: userRound2Msg.payload.encryptedMessage,
+            },
+            userCommitment2: userRound2Msg.commitment,
+            backupMsg2: {
+                from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP,
+                to: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+                signature: backupRound2Msg.payload.signature,
+                encryptedMessage: backupRound2Msg.payload.encryptedMessage,
+            },
+            backupCommitment2: backupRound2Msg.commitment,
+            userVrfMsg2: serializeVrfMessages(userVrfRound2Messages),
+            backupVrfMsg2: serializeVrfMessages(backupVrfRound2Messages),
+        });
+        // #endregion
+        // #region round 3
+        assert_1.default.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');
+        (0, assert_1.default)(bitgoVrfMsg2, 'BitGo VRF message 2 not found in round 2 response');
+        // VRF: finalize both DKGs locally by consuming the opening messages addressed to each
+        // party (including each party's own) from the R2 exchanges. The VRF DKG completes here,
+        // a full round of slack before MPCv2-R3.
+        await userVrfSession.handleIncomingMessages({
+            broadcastMessages: [],
+            p2pMessages: [
+                ...userVrfRound2Messages.p2pMessages.filter((m) => m.to === typesMPCv2_1.MPCv2PartiesEnum.USER),
+                ...backupVrfRound2Messages.p2pMessages.filter((m) => m.to === typesMPCv2_1.MPCv2PartiesEnum.USER),
+                ...deserializeVrfMessages(bitgoVrfMsg2, typesMPCv2_1.MPCv2PartiesEnum.USER).p2pMessages,
+            ],
+        });
+        await backupVrfSession.handleIncomingMessages({
+            broadcastMessages: [],
+            p2pMessages: [
+                ...userVrfRound2Messages.p2pMessages.filter((m) => m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP),
+                ...backupVrfRound2Messages.p2pMessages.filter((m) => m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP),
+                ...deserializeVrfMessages(bitgoVrfMsg2, typesMPCv2_1.MPCv2PartiesEnum.BACKUP).p2pMessages,
+            ],
+        });
+        const decryptedBitgoToUserRound2Msgs = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [this.formatP2PMessage(bitgoToUserMsg2)], broadcastMessages: [] }, [bitgoGpgPubKey], [userGpgPrvKey]);
+        const serializedBitgoToUserRound2Msg = decryptedBitgoToUserRound2Msgs.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(serializedBitgoToUserRound2Msg, 'BitGo to User message 2 not found in P2P messages');
+        const bitgoToUserRound2Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound2Msg);
+        const decryptedBitgoToBackupRound2Msg = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg2)], broadcastMessages: [] }, [bitgoGpgPubKey], [backupGpgPrvKey]);
+        const serializedBitgoToBackupRound2Msg = decryptedBitgoToBackupRound2Msg.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(serializedBitgoToBackupRound2Msg, 'BitGo to Backup message 2 not found in P2P messages');
+        const bitgoToBackupRound2Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound2Msg);
+        const userToBackupMsg2 = userRound2P2PMessages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(userToBackupMsg2, 'User to Backup message 2 not found in P2P messages');
+        const backupToUserMsg2 = backupRound2P2PMessages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(backupToUserMsg2, 'Backup to User message 2 not found in P2P messages');
+        const userRound3Messages = userSession.handleIncomingMessages({
+            broadcastMessages: [],
+            p2pMessages: [bitgoToUserRound2Msg, backupToUserMsg2],
+        });
+        const userToBackupMsg3 = userRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(userToBackupMsg3, 'User to Backup message 3 not found in P2P messages');
+        const userToBitgoMsg3 = userRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(userToBitgoMsg3, 'User to Bitgo message 3 not found in P2P messages');
+        const serializedUserToBitgoMsg3 = sdk_lib_mpc_1.DklsTypes.serializeP2PMessage(userToBitgoMsg3);
+        const backupRound3Messages = backupSession.handleIncomingMessages({
+            broadcastMessages: [],
+            p2pMessages: [bitgoToBackupRound2Msg, userToBackupMsg2],
+        });
+        const backupToUserMsg3 = backupRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(backupToUserMsg3, 'Backup to User message 3 not found in P2P messages');
+        const backupToBitgoMsg3 = backupRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(backupToBitgoMsg3, 'Backup to Bitgo message 3 not found in P2P messages');
+        const serializedBackupToBitgoMsg3 = sdk_lib_mpc_1.DklsTypes.serializeP2PMessage(backupToBitgoMsg3);
+        const decryptedBitgoToUserRound3Messages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToUserMsg3, bitgoCommitment2)] }, [bitgoGpgPubKey], [userGpgPrvKey]);
+        const serializedBitgoToUserRound3Msg = decryptedBitgoToUserRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(serializedBitgoToUserRound3Msg, 'BitGo to User message 3 not found in P2P messages');
+        const bitgoToUserRound3Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound3Msg);
+        const decryptedBitgoToBackupRound3Messages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg3, bitgoCommitment2)] }, [bitgoGpgPubKey], [backupGpgPrvKey]);
+        const serializedBitgoToBackupRound3Msg = decryptedBitgoToBackupRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(serializedBitgoToBackupRound3Msg, 'BitGo to Backup message 3 not found in P2P messages');
+        const bitgoToBackupRound3Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound3Msg);
+        const userRound4Messages = userSession.handleIncomingMessages({
+            p2pMessages: [backupToUserMsg3, bitgoToUserRound3Msg],
+            broadcastMessages: [],
+        });
+        const userRound4BroadcastMsg = userRound4Messages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(userRound4BroadcastMsg, 'User message 4 not found in broadcast messages');
+        const serializedUserRound4BroadcastMsg = sdk_lib_mpc_1.DklsTypes.serializeBroadcastMessage(userRound4BroadcastMsg);
+        const backupRound4Messages = backupSession.handleIncomingMessages({
+            p2pMessages: [userToBackupMsg3, bitgoToBackupRound3Msg],
+            broadcastMessages: [],
+        });
+        const backupRound4BroadcastMsg = backupRound4Messages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(backupRound4BroadcastMsg, 'Backup message 4 not found in broadcast messages');
+        const serializedBackupRound4BroadcastMsg = sdk_lib_mpc_1.DklsTypes.serializeBroadcastMessage(backupRound4BroadcastMsg);
+        const round3Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages({
+            p2pMessages: [serializedUserToBitgoMsg3, serializedBackupToBitgoMsg3],
+            broadcastMessages: [serializedUserRound4BroadcastMsg, serializedBackupRound4BroadcastMsg],
+        }, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const { sessionId: sessionIdRound3, bitgoMsg4, commonKeychain: bitgoCommonKeychain, } = await this.sendKeyGenerationRound3(params.enterprise, sessionId, round3Messages);
+        // #endregion
+        // #region keychain creation
+        assert_1.default.equal(sessionId, sessionIdRound3, 'Round 1 and 3 Session IDs do not match');
+        const bitgoRound4BroadcastMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages(await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg4)] }, [bitgoGpgPubKey], [])).broadcastMessages;
+        const bitgoRound4BroadcastMsg = bitgoRound4BroadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(bitgoRound4BroadcastMsg, 'BitGo message 4 not found in broadcast messages');
+        userSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [bitgoRound4BroadcastMsg, backupRound4BroadcastMsg],
+        });
+        backupSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [bitgoRound4BroadcastMsg, userRound4BroadcastMsg],
+        });
+        const userPrivateMaterial = userSession.getKeyShare();
+        const backupPrivateMaterial = backupSession.getKeyShare();
+        const userReducedPrivateMaterial = userSession.getReducedKeyShare();
+        const backupReducedPrivateMaterial = backupSession.getReducedKeyShare();
+        const userVrfKeyShare = userVrfSession.getKeyShare();
+        const backupVrfKeyShare = backupVrfSession.getKeyShare();
+        const userCommonKeychain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userPrivateMaterial);
+        const backupCommonKeychain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(backupPrivateMaterial);
+        assert_1.default.equal(bitgoCommonKeychain, userCommonKeychain, 'User and Bitgo Common keychains do not match');
+        assert_1.default.equal(bitgoCommonKeychain, backupCommonKeychain, 'Backup and Bitgo Common keychains do not match');
+        const { envelope: userEnvelope, reducedEnvelope: userReducedEnvelope } = buildVrfKeyEnvelopes(userPrivateMaterial, userReducedPrivateMaterial, userVrfKeyShare);
+        const { envelope: backupEnvelope, reducedEnvelope: backupReducedEnvelope } = buildVrfKeyEnvelopes(backupPrivateMaterial, backupReducedPrivateMaterial, backupVrfKeyShare);
+        const encryptionSession = params.encryptionVersion === 2 ? await this.bitgo.createEncryptionSession(params.passphrase) : undefined;
+        try {
+            const userKeychainPromise = this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.USER, bitgoCommonKeychain, userEnvelope, userReducedEnvelope, params.passphrase, params.originalPasscodeEncryptionCode, params.webauthnInfo, encryptionSession, params.encryptionVersion, params.enterprise, params.safeId);
+            const backupKeychainPromise = this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, bitgoCommonKeychain, backupEnvelope, backupReducedEnvelope, params.passphrase, params.originalPasscodeEncryptionCode, undefined, encryptionSession, params.encryptionVersion, undefined, params.safeId);
+            const bitgoKeychainPromise = this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BITGO, bitgoCommonKeychain, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, params.safeId);
+            const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([
+                userKeychainPromise,
+                backupKeychainPromise,
+                bitgoKeychainPromise,
+            ]);
+            // #endregion
+            return {
+                userKeychain,
+                backupKeychain,
+                bitgoKeychain,
+            };
+        }
+        finally {
+            encryptionSession?.destroy();
+        }
+    }
+    /**
+     * Sends round 1 for the user/BitGo hard-derive ceremony.
+     */
+    async sendDerivationRound1BySender(senderFn, userGpgPublicKey, payload, parentKeyId, derivationIndex) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(parentKeyId), 'Parent key id is required');
+        const userMsg1 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER)?.payload;
+        (0, assert_1.default)(userMsg1, 'User message 1 not found in broadcast messages');
+        (0, assert_1.default)(public_types_1.MPCv2DeriveRound1Request.props.derivationIndex.is(derivationIndex), 'Derivation index must be a non-negative safe integer');
+        const request = {
+            userGpgPublicKey,
+            userMsg1: { from: typesMPCv2_1.MPCv2PartiesEnum.USER, ...userMsg1 },
+            parentKeyId,
+            derivationIndex,
+        };
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2Derive-R1'], request);
+    }
+    /**
+     * Sends round 2 for the user/BitGo hard-derive ceremony.
+     */
+    async sendDerivationRound2BySender(senderFn, sessionId, payload) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(sessionId), 'Session ID is required');
+        const userMsg2 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER)?.payload;
+        (0, assert_1.default)(userMsg2, 'User message 2 not found in broadcast messages');
+        const request = {
+            sessionId,
+            userMsg2: { from: typesMPCv2_1.MPCv2PartiesEnum.USER, ...userMsg2 },
+        };
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2Derive-R2'], request);
+    }
+    /**
+     * Completes round 3 and returns the child common keychain.
+     */
+    async sendDerivationRound3BySender(senderFn, sessionId) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(sessionId), 'Session ID is required');
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2Derive-R3'], { sessionId });
+    }
+    /**
+     * Runs the safe child hard-derive ceremony and registers child key documents.
+     */
+    async createSafeChildKeychains(params) {
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);
+        const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;
+        (0, assert_1.default)(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');
+        const bitgoPublicGpgKey = mpcv2Key.armor();
+        if ((0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+            (0, assert_1.default)((0, bitgoPubKeys_1.isBitgoMpcPubKey)(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');
+        }
+        const userGpgPrvKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.USER,
+            gpgKey: userGpgKey.privateKey,
+        };
+        const bitgoGpgPubKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+            gpgKey: bitgoPublicGpgKey,
+        };
+        const path = hardenedDerivationPath(params.derivationIndex);
+        const userDeriveSession = new sdk_lib_mpc_1.DklsDrv.Derive(3, 2, typesMPCv2_1.MPCv2PartiesEnum.USER, params.userRootKeyShare, params.userRootVrfKeyShare, path);
+        // Round 1: send the user's first message.
+        const userRound1Msg = await userDeriveSession.initDerive();
+        const round1Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages({
+            broadcastMessages: [sdk_lib_mpc_1.DklsTypes.serializeBroadcastMessage(userRound1Msg)],
+            p2pMessages: [],
+        }, [bitgoGpgPubKey], [userGpgPrvKey]);
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(userGpgKey.publicKey), 'User GPG public key is required');
+        const { sessionId, bitgoMsg1 } = await this.sendDerivationRound1BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForSafeChild)(this.bitgo, params.enterprise, params.safeId), userGpgKey.publicKey, round1Messages, params.parentKeyId, params.derivationIndex);
+        // Round 2: process the peer's first message and return the user's second.
+        const decryptedBitgoRound1 = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg1)] }, [bitgoGpgPubKey], []);
+        const bitgoRound1Msg = decryptedBitgoRound1.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(bitgoRound1Msg, 'BitGo derive message 1 not found in broadcast messages');
+        const userRound2Messages = userDeriveSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [sdk_lib_mpc_1.DklsTypes.deserializeBroadcastMessage(bitgoRound1Msg)],
+        });
+        const round2Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages(sdk_lib_mpc_1.DklsTypes.serializeMessages(userRound2Messages), [bitgoGpgPubKey], [userGpgPrvKey]);
+        const { sessionId: sessionIdRound2, bitgoMsg2 } = await this.sendDerivationRound2BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForSafeChild)(this.bitgo, params.enterprise, params.safeId), sessionId, round2Messages);
+        assert_1.default.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');
+        // Process the peer response to finalize the local child share.
+        const decryptedBitgoRound2 = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg2)] }, [bitgoGpgPubKey], []);
+        const bitgoRound2Msg = decryptedBitgoRound2.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(bitgoRound2Msg, 'BitGo derive message 2 not found in broadcast messages');
+        userDeriveSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [sdk_lib_mpc_1.DklsTypes.deserializeBroadcastMessage(bitgoRound2Msg)],
+        });
+        // Round 3: obtain the child common-keychain metadata.
+        const { sessionId: sessionIdRound3, commonKeychain } = await this.sendDerivationRound3BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForSafeChild)(this.bitgo, params.enterprise, params.safeId), sessionId);
+        assert_1.default.equal(sessionId, sessionIdRound3, 'Round 1 and 3 Session IDs do not match');
+        const userPrivateMaterial = userDeriveSession.getKeyShare();
+        const userReducedPrivateMaterial = userDeriveSession.getReducedKeyShare();
+        const userCommonKeychain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userPrivateMaterial);
+        assert_1.default.equal(commonKeychain, userCommonKeychain, 'User and BitGo common keychains do not match');
+        const encryptionSession = params.encryptionVersion === 2 ? await this.bitgo.createEncryptionSession(params.passphrase) : undefined;
+        try {
+            const userKeychainPromise = this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.USER, commonKeychain, userPrivateMaterial, userReducedPrivateMaterial, params.passphrase, params.originalPasscodeEncryptionCode, params.webauthnInfo, encryptionSession, params.encryptionVersion, params.enterprise, params.safeId, { parentKeyId: params.userRootKeyId, index: params.derivationIndex });
+            const backupKeychainPromise = this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, commonKeychain, undefined, undefined, params.passphrase, params.originalPasscodeEncryptionCode, undefined, encryptionSession, params.encryptionVersion, undefined, params.safeId, { parentKeyId: params.backupRootKeyId, index: params.derivationIndex });
+            const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);
+            return { userKeychain, backupKeychain };
+        }
+        finally {
+            encryptionSession?.destroy();
+        }
+    }
+    createSigningDkgSessions(retrofit) {
+        if (retrofit) {
+            const retrofitData = this.getMpcV2RetrofitDataFromMpcV1Keys({
+                mpcv1UserKeyShare: retrofit.decryptedUserKey,
+                mpcv1BackupKeyShare: retrofit.decryptedBackupKey,
+            });
+            return {
+                userSession: new sdk_lib_mpc_1.DklsDkg.Dkg(3, 2, typesMPCv2_1.MPCv2PartiesEnum.USER, undefined, retrofitData.mpcv2UserKeyShare),
+                backupSession: new sdk_lib_mpc_1.DklsDkg.Dkg(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BACKUP, undefined, retrofitData.mpcv2BackupKeyShare),
+            };
+        }
+        return {
+            userSession: new sdk_lib_mpc_1.DklsDkg.Dkg(3, 2, typesMPCv2_1.MPCv2PartiesEnum.USER),
+            backupSession: new sdk_lib_mpc_1.DklsDkg.Dkg(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BACKUP),
+        };
+    }
+}
+exports.EcdsaVrfMPCv2Utils = EcdsaVrfMPCv2Utils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecdsaVrfMPCv2.js","sourceRoot":"","sources":["../../../../../../src/bitgo/utils/tss/ecdsa/ecdsaVrfMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import { DklsComms, DklsDkg, DklsDrv, DklsTypes, DklsVrf } from '@bitgo/sdk-lib-mpc';\nimport { decode, encode } from 'cbor-x';\nimport assert from 'assert';\nimport { NonEmptyString } from 'io-ts-types';\nimport {\n  MPCv2DeriveRound1Request,\n  MPCv2DeriveRound1Response,\n  MPCv2DeriveRound2Request,\n  MPCv2DeriveRound2Response,\n  MPCv2DeriveRound3Response,\n  MPCv2KeyGenRound1Response,\n  MPCv2KeyGenRound2Response,\n  MPCv2KeyGenStateEnum,\n} from '@bitgo/public-types';\nimport { KeychainsTriplet } from '../../../baseCoin';\nimport { DecryptedRetrofitPayload } from '../../../keychain/iKeychains';\nimport { EncryptionVersion } from '../../../../api';\nimport { generateGPGKeyPair } from '../../opengpgUtils';\nimport { WebauthnKeyEncryptionInfo } from '../../../keychain';\nimport { envRequiresBitgoPubGpgKeyConfig, isBitgoMpcPubKey } from '../../../tss/bitgoPubKeys';\nimport { EcdsaMPCv2Utils } from './ecdsaMPCv2';\nimport {\n  EcdsaMPCv2DeriveKeySendFn,\n  KeyGenSenderForEnterprise,\n  KeyGenSenderForSafeChild,\n} from './ecdsaMPCv2KeyGenSender';\nimport { MPCv2PartiesEnum, MpcV2VrfKeyGenResponseFields } from './typesMPCv2';\n\n/**\n * Version field of the `encryptedPrv` envelope used when a ceremony produces both a\n * signing keyshare and a VRF keyshare. The plaintext handed to encrypt() is\n * `base64(cborEncode(envelope))`, keeping it a single opaque base64 token exactly as\n * the ordinary MPCv2 format does.\n */\nconst VRF_KEY_ENVELOPE_VERSION = 1;\ntype VrfKeyEnvelope = {\n  version: unknown;\n  prvKeyShare: unknown;\n  vrf: unknown;\n};\n\nfunction isVrfKeyEnvelope(value: unknown): value is VrfKeyEnvelope {\n  return typeof value === 'object' && value !== null && 'version' in value && 'prvKeyShare' in value && 'vrf' in value;\n}\n\n/**\n * Wire format for VRF DKG messages riding the MPCv2-R1/R2 payloads: an opaque blob,\n * `base64(JSON.stringify(VrfMessageTransfer[]))`, carrying the party's full batch of\n * emitted messages. The VRF DKG emits broadcast commitments (R1) and per-recipient\n * opening messages addressed to each party including the sender (R2), so the receiving\n * side routes by `to` and keeps messages addressed to itself.\n */\ninterface VrfMessageTransfer {\n  from: number;\n  to?: number;\n  payload: string; // base64\n}\n\nfunction serializeVrfMessages(messages: DklsTypes.DeserializedMessages): string {\n  const transfers: VrfMessageTransfer[] = [\n    ...messages.broadcastMessages.map((m) => ({ from: m.from, payload: Buffer.from(m.payload).toString('base64') })),\n    ...messages.p2pMessages.map((m) => ({\n      from: m.from,\n      to: m.to,\n      payload: Buffer.from(m.payload).toString('base64'),\n    })),\n  ];\n  return Buffer.from(JSON.stringify(transfers)).toString('base64');\n}\n\nfunction deserializeVrfMessages(blob: string, forParty: number): DklsTypes.DeserializedMessages {\n  const transfers: VrfMessageTransfer[] = JSON.parse(Buffer.from(blob, 'base64').toString());\n  return {\n    broadcastMessages: transfers\n      .filter((t) => t.to === undefined)\n      .map((t) => ({ from: t.from, payload: new Uint8Array(Buffer.from(t.payload, 'base64')) })),\n    p2pMessages: transfers\n      .filter((t): t is VrfMessageTransfer & { to: number } => t.to === forParty)\n      .map((t) => ({ from: t.from, to: t.to, payload: new Uint8Array(Buffer.from(t.payload, 'base64')) })),\n  };\n}\n\n/**\n * Combines the signing keyshare with the VRF keyshare into the `encryptedPrv` envelope\n * (`base64(cborEncode({version, prvKeyShare, vrf}))` once the caller base64-encodes the\n * returned buffers). The same container wraps the reduced signing share for\n * `reducedEncryptedPrv`.\n */\nexport function buildVrfKeyEnvelopes(\n  privateMaterial: Buffer,\n  reducedPrivateMaterial: Buffer,\n  vrfKeyShare: Buffer\n): { envelope: Buffer; reducedEnvelope: Buffer } {\n  const envelope = encode({\n    version: VRF_KEY_ENVELOPE_VERSION,\n    prvKeyShare: new Uint8Array(privateMaterial),\n    vrf: new Uint8Array(vrfKeyShare),\n  });\n  const reducedEnvelope = encode({\n    version: VRF_KEY_ENVELOPE_VERSION,\n    prvKeyShare: new Uint8Array(reducedPrivateMaterial),\n    vrf: new Uint8Array(vrfKeyShare),\n  });\n  return { envelope: Buffer.from(envelope), reducedEnvelope: Buffer.from(reducedEnvelope) };\n}\n\n/**\n * Parses a decrypted root blob produced by {@link buildVrfKeyEnvelopes}: a CBOR\n * envelope `{version: 1, prvKeyShare, vrf}`. Returns the signing and VRF keyshares\n * as Buffers. Throws if the blob is not a valid VRF key envelope.\n */\nexport function parseVrfKeyEnvelopes(decryptedBlob: string): { signing: Buffer; vrf: Buffer } {\n  let envelope: unknown;\n  try {\n    envelope = decode(Buffer.from(decryptedBlob, 'base64'));\n  } catch (e) {\n    const message = e instanceof Error ? e.message : String(e);\n    throw new Error(`Failed to decode safe MPC root key envelope: ${message}`);\n  }\n  if (!isVrfKeyEnvelope(envelope)) {\n    throw new Error('Invalid safe MPC root key envelope: expected version, signing keyshare, and VRF keyshare');\n  }\n  const { version, prvKeyShare, vrf } = envelope;\n  if (version !== VRF_KEY_ENVELOPE_VERSION) {\n    throw new Error(`Unsupported safe MPC root key envelope version: ${String(version)}`);\n  }\n  if (!(prvKeyShare instanceof Uint8Array) || prvKeyShare.length === 0) {\n    throw new Error('Safe MPC root key envelope is missing a signing keyshare');\n  }\n  if (!(vrf instanceof Uint8Array) || vrf.length === 0) {\n    throw new Error('Safe MPC root key envelope is missing a VRF keyshare');\n  }\n  return { signing: Buffer.from(prvKeyShare), vrf: Buffer.from(vrf) };\n}\n\n/**\n * Encodes a hardened derivation index as the byte path the DKLS hard-derive wasm\n * expects: one big-endian u32 with the hardened bit (0x80000000) set — i.e. the\n * child path `m/<index>'`. The server derives the same hardened path from the\n * `derivationIndex` it receives on round 1.\n */\nexport function hardenedDerivationPath(index: number): Uint8Array {\n  if (!Number.isInteger(index) || index < 0 || index > 0x7fffffff) {\n    throw new Error(`Invalid derivation index: ${index}`);\n  }\n  return new Uint8Array([0x80 | (index >>> 24), (index >>> 16) & 0xff, (index >>> 8) & 0xff, index & 0xff]);\n}\n\n/**\n * EcdsaMPCv2Utils variant that runs the Ristretto VRF DKG alongside the signing DKLS\n * DKG inside the same MPCv2 keygen rounds, for safe MPC root creation.\n *\n * The round enum is unchanged: the VRF commitment rides MPCv2-R1, the opening rides\n * MPCv2-R2, and the VRF DKG finalizes locally before MPCv2-R3. VRF messages travel as\n * opaque base64 fields on the round payloads, never through the DKLS broadcast/p2p slots.\n * At the end, the signing and VRF keyshares are combined into a single CBOR envelope\n * before encryption.\n */\nexport class EcdsaVrfMPCv2Utils extends EcdsaMPCv2Utils {\n  /** @inheritdoc */\n  async createKeychains(params: {\n    passphrase: string;\n    enterprise: string;\n    originalPasscodeEncryptionCode?: string;\n    retrofit?: DecryptedRetrofitPayload;\n    webauthnInfo?: WebauthnKeyEncryptionInfo;\n    encryptionVersion?: EncryptionVersion;\n    // Tags the resulting user/backup/bitgo root keys with this safe.\n    safeId: string;\n  }): Promise<KeychainsTriplet> {\n    const { userSession, backupSession } = this.createSigningDkgSessions(params.retrofit);\n    const userVrfSession = new DklsVrf.VrfDkg(3, 2, MPCv2PartiesEnum.USER);\n    const backupVrfSession = new DklsVrf.VrfDkg(3, 2, MPCv2PartiesEnum.BACKUP);\n\n    const userGpgKey = await generateGPGKeyPair('secp256k1');\n    const backupGpgKey = await generateGPGKeyPair('secp256k1');\n\n    // Get the BitGo public key based on user/enterprise feature flags\n    // If it doesn't work, use the default public key from the constants\n    const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);\n    const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;\n    assert(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');\n    const bitgoPublicGpgKey = mpcv2Key.armor();\n\n    if (envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n      // Ensure the public key is one of the expected BitGo public keys when in test or prod.\n      assert(isBitgoMpcPubKey(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');\n    }\n\n    const userGpgPrvKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.USER,\n      gpgKey: userGpgKey.privateKey,\n    };\n    const backupGpgPrvKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.BACKUP,\n      gpgKey: backupGpgKey.privateKey,\n    };\n    const bitgoGpgPubKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.BITGO,\n      gpgKey: bitgoPublicGpgKey,\n    };\n\n    // #region round 1\n    const userRound1BroadcastMsg = await userSession.initDkg();\n    const backupRound1BroadcastMsg = await backupSession.initDkg();\n    const userVrfRound1Msg = await userVrfSession.initDkg();\n    const backupVrfRound1Msg = await backupVrfSession.initDkg();\n\n    const round1SerializedMessages = DklsTypes.serializeMessages({\n      broadcastMessages: [userRound1BroadcastMsg, backupRound1BroadcastMsg],\n      p2pMessages: [],\n    });\n    const round1Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      round1SerializedMessages,\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n    const userMsg1 = round1Messages.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER)?.payload;\n    const backupMsg1 = round1Messages.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BACKUP)?.payload;\n    assert(userMsg1, 'User message 1 not found in broadcast messages');\n    assert(backupMsg1, 'Backup message 1 not found in broadcast messages');\n\n    const userGpgPublicKey = userGpgKey.publicKey;\n    const backupGpgPublicKey = backupGpgKey.publicKey;\n    assert(NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');\n    assert(NonEmptyString.is(backupGpgPublicKey), 'Backup GPG public key is required');\n    // Keep VRF messages opaque on the key-generation request.\n    const round1Sender = KeyGenSenderForEnterprise<MPCv2KeyGenRound1Response & MpcV2VrfKeyGenResponseFields>(\n      this.bitgo,\n      params.enterprise,\n      params.safeId\n    );\n    const { sessionId, bitgoMsg1, bitgoToBackupMsg2, bitgoToUserMsg2, bitgoVrfMsg1 } = await round1Sender(\n      MPCv2KeyGenStateEnum['MPCv2-R1'],\n      {\n        userMsg1: { from: MPCv2PartiesEnum.USER, ...userMsg1 },\n        backupMsg1: { from: MPCv2PartiesEnum.BACKUP, ...backupMsg1 },\n        userGpgPublicKey,\n        backupGpgPublicKey,\n        userVrfMsg1: serializeVrfMessages(userVrfRound1Msg),\n        backupVrfMsg1: serializeVrfMessages(backupVrfRound1Msg),\n        walletId: params.retrofit?.walletId,\n      }\n    );\n    assert(bitgoVrfMsg1, 'BitGo VRF message 1 not found in round 1 response');\n    // #endregion\n\n    // #region round 2\n    const bitgoRound1BroadcastMessages = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg1)] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n    const bitgoRound1BroadcastMsg = bitgoRound1BroadcastMessages.broadcastMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO\n    );\n    assert(bitgoRound1BroadcastMsg, 'BitGo message 1 not found in broadcast messages');\n\n    const userRound2P2PMessages = userSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg), backupRound1BroadcastMsg],\n    });\n\n    const userToBitgoMsg2 = userRound2P2PMessages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(userToBitgoMsg2, 'User message 2 not found in P2P messages');\n    const serializedUserToBitgoMsg2 = DklsTypes.serializeP2PMessage(userToBitgoMsg2);\n\n    const backupRound2P2PMessages = backupSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [userRound1BroadcastMsg, DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg)],\n    });\n    const serializedBackupToBitgoMsg2 = DklsTypes.serializeMessages(backupRound2P2PMessages).p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(serializedBackupToBitgoMsg2, 'Backup message 2 not found in P2P messages');\n\n    // VRF: consume BitGo's and the counterparty's commitments, emit this party's openings.\n    // Openings come back as p2p messages addressed to each party (including the sender).\n    const userVrfRound2Messages = await userVrfSession.handleIncomingMessages({\n      broadcastMessages: [\n        ...backupVrfRound1Msg.broadcastMessages,\n        ...deserializeVrfMessages(bitgoVrfMsg1, MPCv2PartiesEnum.USER).broadcastMessages,\n      ],\n      p2pMessages: [],\n    });\n\n    const backupVrfRound2Messages = await backupVrfSession.handleIncomingMessages({\n      broadcastMessages: [\n        ...userVrfRound1Msg.broadcastMessages,\n        ...deserializeVrfMessages(bitgoVrfMsg1, MPCv2PartiesEnum.BACKUP).broadcastMessages,\n      ],\n      p2pMessages: [],\n    });\n\n    const round2Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      { p2pMessages: [serializedUserToBitgoMsg2, serializedBackupToBitgoMsg2], broadcastMessages: [] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n    const userRound2Msg = round2Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    );\n    const backupRound2Msg = round2Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(userRound2Msg, 'User to Bitgo message 2 not found in P2P messages');\n    assert(userRound2Msg.commitment, 'User to Bitgo commitment not found in P2P messages');\n    assert(backupRound2Msg, 'Backup to Bitgo message 2 not found in P2P messages');\n    assert(backupRound2Msg.commitment, 'Backup to Bitgo commitment not found in P2P messages');\n    assert(NonEmptyString.is(userRound2Msg.commitment), 'User to Bitgo commitment is required');\n    assert(NonEmptyString.is(backupRound2Msg.commitment), 'Backup to Bitgo commitment is required');\n    const round2Sender = KeyGenSenderForEnterprise<MPCv2KeyGenRound2Response & MpcV2VrfKeyGenResponseFields>(\n      this.bitgo,\n      params.enterprise\n    );\n    const {\n      sessionId: sessionIdRound2,\n      bitgoCommitment2,\n      bitgoToUserMsg3,\n      bitgoToBackupMsg3,\n      bitgoVrfMsg2,\n    } = await round2Sender(MPCv2KeyGenStateEnum['MPCv2-R2'], {\n      sessionId,\n      userMsg2: {\n        from: MPCv2PartiesEnum.USER,\n        to: MPCv2PartiesEnum.BITGO,\n        signature: userRound2Msg.payload.signature,\n        encryptedMessage: userRound2Msg.payload.encryptedMessage,\n      },\n      userCommitment2: userRound2Msg.commitment,\n      backupMsg2: {\n        from: MPCv2PartiesEnum.BACKUP,\n        to: MPCv2PartiesEnum.BITGO,\n        signature: backupRound2Msg.payload.signature,\n        encryptedMessage: backupRound2Msg.payload.encryptedMessage,\n      },\n      backupCommitment2: backupRound2Msg.commitment,\n      userVrfMsg2: serializeVrfMessages(userVrfRound2Messages),\n      backupVrfMsg2: serializeVrfMessages(backupVrfRound2Messages),\n    });\n    // #endregion\n\n    // #region round 3\n    assert.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');\n    assert(bitgoVrfMsg2, 'BitGo VRF message 2 not found in round 2 response');\n\n    // VRF: finalize both DKGs locally by consuming the opening messages addressed to each\n    // party (including each party's own) from the R2 exchanges. The VRF DKG completes here,\n    // a full round of slack before MPCv2-R3.\n    await userVrfSession.handleIncomingMessages({\n      broadcastMessages: [],\n      p2pMessages: [\n        ...userVrfRound2Messages.p2pMessages.filter((m) => m.to === MPCv2PartiesEnum.USER),\n        ...backupVrfRound2Messages.p2pMessages.filter((m) => m.to === MPCv2PartiesEnum.USER),\n        ...deserializeVrfMessages(bitgoVrfMsg2, MPCv2PartiesEnum.USER).p2pMessages,\n      ],\n    });\n    await backupVrfSession.handleIncomingMessages({\n      broadcastMessages: [],\n      p2pMessages: [\n        ...userVrfRound2Messages.p2pMessages.filter((m) => m.to === MPCv2PartiesEnum.BACKUP),\n        ...backupVrfRound2Messages.p2pMessages.filter((m) => m.to === MPCv2PartiesEnum.BACKUP),\n        ...deserializeVrfMessages(bitgoVrfMsg2, MPCv2PartiesEnum.BACKUP).p2pMessages,\n      ],\n    });\n\n    const decryptedBitgoToUserRound2Msgs = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [this.formatP2PMessage(bitgoToUserMsg2)], broadcastMessages: [] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey]\n    );\n    const serializedBitgoToUserRound2Msg = decryptedBitgoToUserRound2Msgs.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(serializedBitgoToUserRound2Msg, 'BitGo to User message 2 not found in P2P messages');\n    const bitgoToUserRound2Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound2Msg);\n\n    const decryptedBitgoToBackupRound2Msg = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg2)], broadcastMessages: [] },\n      [bitgoGpgPubKey],\n      [backupGpgPrvKey]\n    );\n    const serializedBitgoToBackupRound2Msg = decryptedBitgoToBackupRound2Msg.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(serializedBitgoToBackupRound2Msg, 'BitGo to Backup message 2 not found in P2P messages');\n    const bitgoToBackupRound2Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound2Msg);\n\n    const userToBackupMsg2 = userRound2P2PMessages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(userToBackupMsg2, 'User to Backup message 2 not found in P2P messages');\n\n    const backupToUserMsg2 = backupRound2P2PMessages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(backupToUserMsg2, 'Backup to User message 2 not found in P2P messages');\n\n    const userRound3Messages = userSession.handleIncomingMessages({\n      broadcastMessages: [],\n      p2pMessages: [bitgoToUserRound2Msg, backupToUserMsg2],\n    });\n    const userToBackupMsg3 = userRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(userToBackupMsg3, 'User to Backup message 3 not found in P2P messages');\n    const userToBitgoMsg3 = userRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(userToBitgoMsg3, 'User to Bitgo message 3 not found in P2P messages');\n    const serializedUserToBitgoMsg3 = DklsTypes.serializeP2PMessage(userToBitgoMsg3);\n\n    const backupRound3Messages = backupSession.handleIncomingMessages({\n      broadcastMessages: [],\n      p2pMessages: [bitgoToBackupRound2Msg, userToBackupMsg2],\n    });\n\n    const backupToUserMsg3 = backupRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(backupToUserMsg3, 'Backup to User message 3 not found in P2P messages');\n    const backupToBitgoMsg3 = backupRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(backupToBitgoMsg3, 'Backup to Bitgo message 3 not found in P2P messages');\n    const serializedBackupToBitgoMsg3 = DklsTypes.serializeP2PMessage(backupToBitgoMsg3);\n\n    const decryptedBitgoToUserRound3Messages = await DklsComms.decryptAndVerifyIncomingMessages(\n      { broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToUserMsg3, bitgoCommitment2)] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey]\n    );\n    const serializedBitgoToUserRound3Msg = decryptedBitgoToUserRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(serializedBitgoToUserRound3Msg, 'BitGo to User message 3 not found in P2P messages');\n    const bitgoToUserRound3Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound3Msg);\n\n    const decryptedBitgoToBackupRound3Messages = await DklsComms.decryptAndVerifyIncomingMessages(\n      { broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg3, bitgoCommitment2)] },\n      [bitgoGpgPubKey],\n      [backupGpgPrvKey]\n    );\n    const serializedBitgoToBackupRound3Msg = decryptedBitgoToBackupRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(serializedBitgoToBackupRound3Msg, 'BitGo to Backup message 3 not found in P2P messages');\n    const bitgoToBackupRound3Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound3Msg);\n\n    const userRound4Messages = userSession.handleIncomingMessages({\n      p2pMessages: [backupToUserMsg3, bitgoToUserRound3Msg],\n      broadcastMessages: [],\n    });\n\n    const userRound4BroadcastMsg = userRound4Messages.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER);\n    assert(userRound4BroadcastMsg, 'User message 4 not found in broadcast messages');\n    const serializedUserRound4BroadcastMsg = DklsTypes.serializeBroadcastMessage(userRound4BroadcastMsg);\n\n    const backupRound4Messages = backupSession.handleIncomingMessages({\n      p2pMessages: [userToBackupMsg3, bitgoToBackupRound3Msg],\n      broadcastMessages: [],\n    });\n    const backupRound4BroadcastMsg = backupRound4Messages.broadcastMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP\n    );\n    assert(backupRound4BroadcastMsg, 'Backup message 4 not found in broadcast messages');\n    const serializedBackupRound4BroadcastMsg = DklsTypes.serializeBroadcastMessage(backupRound4BroadcastMsg);\n\n    const round3Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      {\n        p2pMessages: [serializedUserToBitgoMsg3, serializedBackupToBitgoMsg3],\n        broadcastMessages: [serializedUserRound4BroadcastMsg, serializedBackupRound4BroadcastMsg],\n      },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n\n    const {\n      sessionId: sessionIdRound3,\n      bitgoMsg4,\n      commonKeychain: bitgoCommonKeychain,\n    } = await this.sendKeyGenerationRound3(params.enterprise, sessionId, round3Messages);\n\n    // #endregion\n\n    // #region keychain creation\n    assert.equal(sessionId, sessionIdRound3, 'Round 1 and 3 Session IDs do not match');\n    const bitgoRound4BroadcastMessages = DklsTypes.deserializeMessages(\n      await DklsComms.decryptAndVerifyIncomingMessages(\n        { p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg4)] },\n        [bitgoGpgPubKey],\n        []\n      )\n    ).broadcastMessages;\n    const bitgoRound4BroadcastMsg = bitgoRound4BroadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BITGO);\n\n    assert(bitgoRound4BroadcastMsg, 'BitGo message 4 not found in broadcast messages');\n    userSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [bitgoRound4BroadcastMsg, backupRound4BroadcastMsg],\n    });\n\n    backupSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [bitgoRound4BroadcastMsg, userRound4BroadcastMsg],\n    });\n\n    const userPrivateMaterial = userSession.getKeyShare();\n    const backupPrivateMaterial = backupSession.getKeyShare();\n    const userReducedPrivateMaterial = userSession.getReducedKeyShare();\n    const backupReducedPrivateMaterial = backupSession.getReducedKeyShare();\n    const userVrfKeyShare = userVrfSession.getKeyShare();\n    const backupVrfKeyShare = backupVrfSession.getKeyShare();\n\n    const userCommonKeychain = DklsTypes.getCommonKeychain(userPrivateMaterial);\n    const backupCommonKeychain = DklsTypes.getCommonKeychain(backupPrivateMaterial);\n\n    assert.equal(bitgoCommonKeychain, userCommonKeychain, 'User and Bitgo Common keychains do not match');\n    assert.equal(bitgoCommonKeychain, backupCommonKeychain, 'Backup and Bitgo Common keychains do not match');\n\n    const { envelope: userEnvelope, reducedEnvelope: userReducedEnvelope } = buildVrfKeyEnvelopes(\n      userPrivateMaterial,\n      userReducedPrivateMaterial,\n      userVrfKeyShare\n    );\n    const { envelope: backupEnvelope, reducedEnvelope: backupReducedEnvelope } = buildVrfKeyEnvelopes(\n      backupPrivateMaterial,\n      backupReducedPrivateMaterial,\n      backupVrfKeyShare\n    );\n\n    const encryptionSession =\n      params.encryptionVersion === 2 ? await this.bitgo.createEncryptionSession(params.passphrase) : undefined;\n    try {\n      const userKeychainPromise = this.createParticipantKeychain(\n        MPCv2PartiesEnum.USER,\n        bitgoCommonKeychain,\n        userEnvelope,\n        userReducedEnvelope,\n        params.passphrase,\n        params.originalPasscodeEncryptionCode,\n        params.webauthnInfo,\n        encryptionSession,\n        params.encryptionVersion,\n        params.enterprise,\n        params.safeId\n      );\n      const backupKeychainPromise = this.createParticipantKeychain(\n        MPCv2PartiesEnum.BACKUP,\n        bitgoCommonKeychain,\n        backupEnvelope,\n        backupReducedEnvelope,\n        params.passphrase,\n        params.originalPasscodeEncryptionCode,\n        undefined,\n        encryptionSession,\n        params.encryptionVersion,\n        undefined,\n        params.safeId\n      );\n      const bitgoKeychainPromise = this.createParticipantKeychain(\n        MPCv2PartiesEnum.BITGO,\n        bitgoCommonKeychain,\n        undefined,\n        undefined,\n        undefined,\n        undefined,\n        undefined,\n        undefined,\n        undefined,\n        undefined,\n        params.safeId\n      );\n\n      const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([\n        userKeychainPromise,\n        backupKeychainPromise,\n        bitgoKeychainPromise,\n      ]);\n      // #endregion\n\n      return {\n        userKeychain,\n        backupKeychain,\n        bitgoKeychain,\n      };\n    } finally {\n      encryptionSession?.destroy();\n    }\n  }\n  /**\n   * Sends round 1 for the user/BitGo hard-derive ceremony.\n   */\n  async sendDerivationRound1BySender(\n    senderFn: EcdsaMPCv2DeriveKeySendFn<MPCv2DeriveRound1Response>,\n    userGpgPublicKey: string,\n    payload: DklsTypes.AuthEncMessages,\n    parentKeyId: string,\n    derivationIndex: number\n  ): Promise<MPCv2DeriveRound1Response> {\n    assert(NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');\n    assert(NonEmptyString.is(parentKeyId), 'Parent key id is required');\n    const userMsg1 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER)?.payload;\n    assert(userMsg1, 'User message 1 not found in broadcast messages');\n\n    assert(\n      MPCv2DeriveRound1Request.props.derivationIndex.is(derivationIndex),\n      'Derivation index must be a non-negative safe integer'\n    );\n    const request: MPCv2DeriveRound1Request = {\n      userGpgPublicKey,\n      userMsg1: { from: MPCv2PartiesEnum.USER, ...userMsg1 },\n      parentKeyId,\n      derivationIndex,\n    };\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2Derive-R1'], request);\n  }\n\n  /**\n   * Sends round 2 for the user/BitGo hard-derive ceremony.\n   */\n  async sendDerivationRound2BySender(\n    senderFn: EcdsaMPCv2DeriveKeySendFn<MPCv2DeriveRound2Response>,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2DeriveRound2Response> {\n    assert(NonEmptyString.is(sessionId), 'Session ID is required');\n    const userMsg2 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER)?.payload;\n    assert(userMsg2, 'User message 2 not found in broadcast messages');\n\n    const request: MPCv2DeriveRound2Request = {\n      sessionId,\n      userMsg2: { from: MPCv2PartiesEnum.USER, ...userMsg2 },\n    };\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2Derive-R2'], request);\n  }\n\n  /**\n   * Completes round 3 and returns the child common keychain.\n   */\n  async sendDerivationRound3BySender(\n    senderFn: EcdsaMPCv2DeriveKeySendFn<MPCv2DeriveRound3Response>,\n    sessionId: string\n  ): Promise<MPCv2DeriveRound3Response> {\n    assert(NonEmptyString.is(sessionId), 'Session ID is required');\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2Derive-R3'], { sessionId });\n  }\n\n  /**\n   * Runs the safe child hard-derive ceremony and registers child key documents.\n   */\n  async createSafeChildKeychains(params: {\n    passphrase: string;\n    enterprise: string;\n    safeId: string;\n    /** Root key ID used for the derive. */\n    parentKeyId: string;\n    derivationIndex: number;\n    userRootKeyId: string;\n    backupRootKeyId: string;\n    userRootKeyShare: Buffer;\n    userRootVrfKeyShare: Buffer;\n    originalPasscodeEncryptionCode?: string;\n    webauthnInfo?: WebauthnKeyEncryptionInfo;\n    encryptionVersion?: EncryptionVersion;\n  }): Promise<Pick<KeychainsTriplet, 'userKeychain' | 'backupKeychain'>> {\n    const userGpgKey = await generateGPGKeyPair('secp256k1');\n\n    const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);\n    const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;\n    assert(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');\n    const bitgoPublicGpgKey = mpcv2Key.armor();\n\n    if (envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n      assert(isBitgoMpcPubKey(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');\n    }\n\n    const userGpgPrvKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.USER,\n      gpgKey: userGpgKey.privateKey,\n    };\n    const bitgoGpgPubKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.BITGO,\n      gpgKey: bitgoPublicGpgKey,\n    };\n\n    const path = hardenedDerivationPath(params.derivationIndex);\n    const userDeriveSession = new DklsDrv.Derive(\n      3,\n      2,\n      MPCv2PartiesEnum.USER,\n      params.userRootKeyShare,\n      params.userRootVrfKeyShare,\n      path\n    );\n\n    // Round 1: send the user's first message.\n    const userRound1Msg = await userDeriveSession.initDerive();\n    const round1Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      {\n        broadcastMessages: [DklsTypes.serializeBroadcastMessage(userRound1Msg)],\n        p2pMessages: [],\n      },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey]\n    );\n    assert(NonEmptyString.is(userGpgKey.publicKey), 'User GPG public key is required');\n    const { sessionId, bitgoMsg1 } = await this.sendDerivationRound1BySender(\n      KeyGenSenderForSafeChild<MPCv2DeriveRound1Response>(this.bitgo, params.enterprise, params.safeId),\n      userGpgKey.publicKey,\n      round1Messages,\n      params.parentKeyId,\n      params.derivationIndex\n    );\n\n    // Round 2: process the peer's first message and return the user's second.\n    const decryptedBitgoRound1 = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg1)] },\n      [bitgoGpgPubKey],\n      []\n    );\n    const bitgoRound1Msg = decryptedBitgoRound1.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BITGO);\n    assert(bitgoRound1Msg, 'BitGo derive message 1 not found in broadcast messages');\n    const userRound2Messages = userDeriveSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [DklsTypes.deserializeBroadcastMessage(bitgoRound1Msg)],\n    });\n    const round2Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      DklsTypes.serializeMessages(userRound2Messages),\n      [bitgoGpgPubKey],\n      [userGpgPrvKey]\n    );\n    const { sessionId: sessionIdRound2, bitgoMsg2 } = await this.sendDerivationRound2BySender(\n      KeyGenSenderForSafeChild<MPCv2DeriveRound2Response>(this.bitgo, params.enterprise, params.safeId),\n      sessionId,\n      round2Messages\n    );\n    assert.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');\n\n    // Process the peer response to finalize the local child share.\n    const decryptedBitgoRound2 = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg2)] },\n      [bitgoGpgPubKey],\n      []\n    );\n    const bitgoRound2Msg = decryptedBitgoRound2.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BITGO);\n    assert(bitgoRound2Msg, 'BitGo derive message 2 not found in broadcast messages');\n    userDeriveSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [DklsTypes.deserializeBroadcastMessage(bitgoRound2Msg)],\n    });\n\n    // Round 3: obtain the child common-keychain metadata.\n    const { sessionId: sessionIdRound3, commonKeychain } = await this.sendDerivationRound3BySender(\n      KeyGenSenderForSafeChild<MPCv2DeriveRound3Response>(this.bitgo, params.enterprise, params.safeId),\n      sessionId\n    );\n    assert.equal(sessionId, sessionIdRound3, 'Round 1 and 3 Session IDs do not match');\n\n    const userPrivateMaterial = userDeriveSession.getKeyShare();\n    const userReducedPrivateMaterial = userDeriveSession.getReducedKeyShare();\n    const userCommonKeychain = DklsTypes.getCommonKeychain(userPrivateMaterial);\n    assert.equal(commonKeychain, userCommonKeychain, 'User and BitGo common keychains do not match');\n\n    const encryptionSession =\n      params.encryptionVersion === 2 ? await this.bitgo.createEncryptionSession(params.passphrase) : undefined;\n    try {\n      const userKeychainPromise = this.createParticipantKeychain(\n        MPCv2PartiesEnum.USER,\n        commonKeychain,\n        userPrivateMaterial,\n        userReducedPrivateMaterial,\n        params.passphrase,\n        params.originalPasscodeEncryptionCode,\n        params.webauthnInfo,\n        encryptionSession,\n        params.encryptionVersion,\n        params.enterprise,\n        params.safeId,\n        { parentKeyId: params.userRootKeyId, index: params.derivationIndex }\n      );\n      const backupKeychainPromise = this.createParticipantKeychain(\n        MPCv2PartiesEnum.BACKUP,\n        commonKeychain,\n        undefined,\n        undefined,\n        params.passphrase,\n        params.originalPasscodeEncryptionCode,\n        undefined,\n        encryptionSession,\n        params.encryptionVersion,\n        undefined,\n        params.safeId,\n        { parentKeyId: params.backupRootKeyId, index: params.derivationIndex }\n      );\n\n      const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);\n      return { userKeychain, backupKeychain };\n    } finally {\n      encryptionSession?.destroy();\n    }\n  }\n\n  private createSigningDkgSessions(retrofit?: DecryptedRetrofitPayload) {\n    if (retrofit) {\n      const retrofitData = this.getMpcV2RetrofitDataFromMpcV1Keys({\n        mpcv1UserKeyShare: retrofit.decryptedUserKey,\n        mpcv1BackupKeyShare: retrofit.decryptedBackupKey,\n      });\n      return {\n        userSession: new DklsDkg.Dkg(3, 2, MPCv2PartiesEnum.USER, undefined, retrofitData.mpcv2UserKeyShare),\n        backupSession: new DklsDkg.Dkg(3, 2, MPCv2PartiesEnum.BACKUP, undefined, retrofitData.mpcv2BackupKeyShare),\n      };\n    }\n    return {\n      userSession: new DklsDkg.Dkg(3, 2, MPCv2PartiesEnum.USER),\n      backupSession: new DklsDkg.Dkg(3, 2, MPCv2PartiesEnum.BACKUP),\n    };\n  }\n}\n"]}