@bitgo-beta/sdk-core 8.2.1-beta.169 → 8.2.1-beta.1690

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

@@ -0,0 +1,958 @@
+"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 });
+exports.EcdsaMPCv2Utils = void 0;
+exports.isGG18SigningMaterial = isGG18SigningMaterial;
+exports.getMpcV2RecoveryKeyShares = getMpcV2RecoveryKeyShares;
+exports.signRecoveryMpcV2 = signRecoveryMpcV2;
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const assert_1 = __importDefault(require("assert"));
+const buffer_1 = require("buffer");
+const io_ts_types_1 = require("io-ts-types");
+const keccak_1 = __importDefault(require("keccak"));
+const pgp = __importStar(require("openpgp"));
+const public_types_1 = require("@bitgo/public-types");
+const account_lib_1 = require("../../../../account-lib");
+const tss_1 = require("../../../tss");
+const common_1 = require("../../../tss/common");
+const typesMPCv2_1 = require("./typesMPCv2");
+const ecdsaMPCv2_1 = require("../../../tss/ecdsa/ecdsaMPCv2");
+const errors_1 = require("../../../errors");
+const opengpgUtils_1 = require("../../opengpgUtils");
+const baseTypes_1 = require("../baseTypes");
+const base_1 = require("./base");
+const ecdsaMPCv2KeyGenSender_1 = require("./ecdsaMPCv2KeyGenSender");
+const bitgoPubKeys_1 = require("../../../tss/bitgoPubKeys");
+class EcdsaMPCv2Utils extends base_1.BaseEcdsaUtils {
+    /** @inheritdoc */
+    async createKeychains(params) {
+        const { userSession, backupSession } = this.getUserAndBackupSession(2, 3, params.retrofit);
+        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 bitgoPublicGpgKey = ((await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true)) ?? this.bitgoMPCv2PublicGpgKey).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 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 { sessionId, bitgoMsg1, bitgoToBackupMsg2, bitgoToUserMsg2 } = await this.sendKeyGenerationRound1(params.enterprise, userGpgKey.publicKey, backupGpgKey.publicKey, params.retrofit?.walletId
+            ? {
+                ...round1Messages,
+                walletId: params.retrofit.walletId,
+            }
+            : round1Messages);
+        // #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');
+        const round2Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages({ p2pMessages: [serializedUserToBitgoMsg2, serializedBackupToBitgoMsg2], broadcastMessages: [] }, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const { sessionId: sessionIdRound2, bitgoCommitment2, bitgoToUserMsg3, bitgoToBackupMsg3, } = await this.sendKeyGenerationRound2(params.enterprise, sessionId, round2Messages);
+        // #endregion
+        // #region round 3
+        assert_1.default.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');
+        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 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 userKeychainPromise = this.addUserKeychain(bitgoCommonKeychain, userPrivateMaterial, userReducedPrivateMaterial, params.passphrase, params.originalPasscodeEncryptionCode);
+        const backupKeychainPromise = this.addBackupKeychain(bitgoCommonKeychain, backupPrivateMaterial, backupReducedPrivateMaterial, params.passphrase, params.originalPasscodeEncryptionCode);
+        const bitgoKeychainPromise = this.addBitgoKeychain(bitgoCommonKeychain);
+        const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([
+            userKeychainPromise,
+            backupKeychainPromise,
+            bitgoKeychainPromise,
+        ]);
+        // #endregion
+        return {
+            userKeychain,
+            backupKeychain,
+            bitgoKeychain,
+        };
+    }
+    // #region keychain utils
+    async createParticipantKeychain(participantIndex, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode) {
+        let source;
+        let encryptedPrv = undefined;
+        let reducedEncryptedPrv = undefined;
+        switch (participantIndex) {
+            case typesMPCv2_1.MPCv2PartiesEnum.USER:
+            case typesMPCv2_1.MPCv2PartiesEnum.BACKUP:
+                source = participantIndex === typesMPCv2_1.MPCv2PartiesEnum.USER ? 'user' : 'backup';
+                (0, assert_1.default)(privateMaterial, `Private material is required for ${source} keychain`);
+                (0, assert_1.default)(reducedPrivateMaterial, `Reduced private material is required for ${source} keychain`);
+                (0, assert_1.default)(passphrase, `Passphrase is required for ${source} keychain`);
+                encryptedPrv = this.bitgo.encrypt({
+                    input: privateMaterial.toString('base64'),
+                    password: passphrase,
+                });
+                // Encrypts the CBOR-encoded ReducedKeyShare (which contains the party's private
+                // scalar s_i) with the wallet passphrase. The result is stored as reducedEncryptedPrv
+                // on the key card QR code and represents a second copy of private key material
+                // beyond the server-stored encryptedPrv.
+                reducedEncryptedPrv = this.bitgo.encrypt({
+                    // Buffer.toString('base64') can not be used here as it does not work on the browser.
+                    // The browser deals with a Buffer as Uint8Array, therefore in the browser .toString('base64') just creates a comma seperated string of the array values.
+                    input: btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial)))),
+                    password: passphrase,
+                });
+                break;
+            case typesMPCv2_1.MPCv2PartiesEnum.BITGO:
+                source = 'bitgo';
+                break;
+            default:
+                throw new Error('Invalid participant index');
+        }
+        const recipientKeychainParams = {
+            source,
+            keyType: 'tss',
+            commonKeychain,
+            encryptedPrv,
+            originalPasscodeEncryptionCode,
+            isMPCv2: true,
+        };
+        const keychains = this.baseCoin.keychains();
+        return { ...(await keychains.add(recipientKeychainParams)), reducedEncryptedPrv: reducedEncryptedPrv };
+    }
+    /**
+     * Converts a User or Backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.
+     *
+     * @param decryptedKeyshare - MPCv1 decrypted signing material for user or backup as a json.stringify string and bitgo's Big Si.
+     * @param partyId - The party ID of the MPCv1 keyshare.
+     * @returns The retrofit data needed to start an MPCv2 DKG session.
+     * @deprecated
+     */
+    static getKeyDataForRetrofit(decryptedKeyshare, partyId) {
+        const mpc = new account_lib_1.Ecdsa();
+        const xiList = [
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(1), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(2), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(3), 32)),
+        ];
+        return EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({
+            mpcv1PartyKeyShare: decryptedKeyshare,
+            mpcv1PartyIndex: partyId === typesMPCv2_1.MPCv2PartiesEnum.USER ? 1 : 2,
+            xiList,
+            mpc,
+        });
+    }
+    /**
+     * Converts user and backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.
+     *
+     * @param {Object} params - MPCv1 decrypted signing material for user and backup as a json.stringify string and bitgo's Big Si.
+     * @returns {{ mpcv2UserKeyShare: DklsTypes.RetrofitData; mpcv2BakcupKeyShare: DklsTypes.RetrofitData }} - the retrofit data needed to start an MPCv2 DKG session.
+     */
+    getMpcV2RetrofitDataFromMpcV1Keys(params) {
+        const mpc = new account_lib_1.Ecdsa();
+        const xiList = [
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(1), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(2), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(3), 32)),
+        ];
+        return {
+            mpcv2UserKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({
+                mpcv1PartyKeyShare: params.mpcv1UserKeyShare,
+                mpcv1PartyIndex: 1,
+                xiList,
+                mpc,
+            }),
+            mpcv2BackupKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({
+                mpcv1PartyKeyShare: params.mpcv1BackupKeyShare,
+                mpcv1PartyIndex: 2,
+                xiList,
+                mpc,
+            }),
+        };
+    }
+    /**
+     * Get retrofit data from MPCv1 key share.
+     * @param mpcv1PartyKeyShare
+     * @param mpcv1PartyIndex
+     * @param xiList
+     * @param mpc
+     * @deprecated
+     */
+    static getMpcV2RetrofitDataFromMpcV1Key({ mpcv1PartyKeyShare, mpcv1PartyIndex, xiList, mpc, }) {
+        const signingMaterial = JSON.parse(mpcv1PartyKeyShare);
+        let keyCombined = undefined;
+        switch (mpcv1PartyIndex) {
+            case 1:
+                (0, assert_1.default)(signingMaterial.backupNShare, 'User MPCv1 key material should have backup NShare.');
+                (0, assert_1.default)(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');
+                keyCombined = mpc.keyCombine(signingMaterial.pShare, [
+                    signingMaterial.backupNShare,
+                    signingMaterial.bitgoNShare,
+                ]);
+                break;
+            case 2:
+                (0, assert_1.default)(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');
+                (0, assert_1.default)(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');
+                keyCombined = mpc.keyCombine(signingMaterial.pShare, [signingMaterial.userNShare, signingMaterial.bitgoNShare]);
+                break;
+            case 3:
+                (0, assert_1.default)(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');
+                (0, assert_1.default)(signingMaterial.backupNShare, 'Backup MPCv1 key material should have user NShare.');
+                keyCombined = mpc.keyCombine(signingMaterial.pShare, [
+                    signingMaterial.userNShare,
+                    signingMaterial.backupNShare,
+                ]);
+                break;
+            default:
+                throw new Error('Invalid participant index');
+        }
+        return {
+            xShare: keyCombined.xShare,
+            xiList: xiList,
+        };
+    }
+    async addUserKeychain(commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.USER, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode);
+    }
+    async addBackupKeychain(commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode);
+    }
+    getUserAndBackupSession(m, n, retrofit) {
+        if (retrofit) {
+            const retrofitData = this.getMpcV2RetrofitDataFromMpcV1Keys({
+                mpcv1UserKeyShare: retrofit.decryptedUserKey,
+                mpcv1BackupKeyShare: retrofit.decryptedBackupKey,
+            });
+            const userSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.USER, undefined, retrofitData.mpcv2UserKeyShare);
+            const backupSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.BACKUP, undefined, retrofitData.mpcv2BackupKeyShare);
+            return { userSession, backupSession };
+        }
+        const userSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const backupSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        return { userSession, backupSession };
+    }
+    async addBitgoKeychain(commonKeychain) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BITGO, commonKeychain);
+    }
+    // #endregion
+    async sendKeyGenerationRound1(enterprise, userGpgPublicKey, backupGpgPublicKey, payload) {
+        return this.sendKeyGenerationRound1BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise), userGpgPublicKey, backupGpgPublicKey, payload);
+    }
+    async sendKeyGenerationRound2(enterprise, sessionId, payload) {
+        return this.sendKeyGenerationRound2BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise), sessionId, payload);
+    }
+    async sendKeyGenerationRound3(enterprise, sessionId, payload) {
+        return this.sendKeyGenerationRound3BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise), sessionId, payload);
+    }
+    async sendKeyGenerationRound1BySender(senderFn, userGpgPublicKey, backupGpgPublicKey, payload) {
+        (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');
+        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');
+        const backupMsg1 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP)?.payload;
+        (0, assert_1.default)(backupMsg1, 'Backup message 1 not found in broadcast messages');
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1'], {
+            userGpgPublicKey,
+            backupGpgPublicKey,
+            userMsg1: { from: 0, ...userMsg1 },
+            backupMsg1: { from: 1, ...backupMsg1 },
+            walletId: payload.walletId,
+        });
+    }
+    async sendKeyGenerationRound2BySender(senderFn, sessionId, payload) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(sessionId), 'Session ID is required');
+        const userMsg2 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(userMsg2, 'User to Bitgo message 2 not found in P2P messages');
+        (0, assert_1.default)(userMsg2.commitment, 'User to Bitgo commitment not found in P2P messages');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(userMsg2.commitment), 'User to Bitgo commitment is required');
+        const backupMsg2 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(backupMsg2, 'Backup to Bitgo message 2 not found in P2P messages');
+        (0, assert_1.default)(backupMsg2.commitment, 'Backup to Bitgo commitment not found in P2P messages');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(backupMsg2.commitment), 'Backup to Bitgo commitment is required');
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R2'], {
+            sessionId,
+            userMsg2: {
+                from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+                to: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+                signature: userMsg2.payload.signature,
+                encryptedMessage: userMsg2.payload.encryptedMessage,
+            },
+            userCommitment2: userMsg2.commitment,
+            backupMsg2: {
+                from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP,
+                to: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+                signature: backupMsg2.payload.signature,
+                encryptedMessage: backupMsg2.payload.encryptedMessage,
+            },
+            backupCommitment2: backupMsg2.commitment,
+        });
+    }
+    async sendKeyGenerationRound3BySender(senderFn, sessionId, payload) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(sessionId), 'Session ID is required');
+        const userMsg3 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO)?.payload;
+        (0, assert_1.default)(userMsg3, 'User to Bitgo message 3 not found in P2P messages');
+        const backupMsg3 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO)?.payload;
+        (0, assert_1.default)(backupMsg3, 'Backup to Bitgo message 3 not found in P2P messages');
+        const userMsg4 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER)?.payload;
+        (0, assert_1.default)(userMsg4, 'User message 1 not found in broadcast messages');
+        const backupMsg4 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP)?.payload;
+        (0, assert_1.default)(backupMsg4, 'Backup message 1 not found in broadcast messages');
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R3'], {
+            sessionId,
+            userMsg3: { from: 0, to: 2, ...userMsg3 },
+            backupMsg3: { from: 1, to: 2, ...backupMsg3 },
+            userMsg4: { from: 0, ...userMsg4 },
+            backupMsg4: { from: 1, ...backupMsg4 },
+        });
+    }
+    // #endregion
+    // #region sign tx request
+    /**
+     * Signs the transaction associated to the transaction request.
+     * @param {string | TxRequest} params.txRequest - transaction request object or id
+     * @param {string} params.prv - decrypted private key
+     * @param {string} params.reqId - request id
+     * @param {string} params.mpcv2PartyId - party id for the signer involved in this mpcv2 request (either 0 for user or 1 for backup)
+     * @returns {Promise<TxRequest>} fully signed TxRequest object
+     */
+    async signTxRequest(params) {
+        this.bitgo.setRequestTracer(params.reqId);
+        return this.signRequestBase(params, baseTypes_1.RequestType.tx);
+    }
+    /**
+     * Signs the message associated to the transaction request.
+     * @param {string | TxRequest} params.txRequest - transaction request object or id
+     * @param {string} params.prv - decrypted private key
+     * @param {string} params.reqId - request id
+     * @returns {Promise<TxRequest>} fully signed TxRequest object
+     */
+    async signTxRequestForMessage(params) {
+        this.bitgo.setRequestTracer(params.reqId);
+        return this.signRequestBase(params, baseTypes_1.RequestType.message);
+    }
+    async signRequestBase(params, requestType) {
+        const userKeyShare = buffer_1.Buffer.from(params.prv, 'base64');
+        const txRequest = typeof params.txRequest === 'string'
+            ? await (0, tss_1.getTxRequest)(this.bitgo, this.wallet.id(), params.txRequest, params.reqId)
+            : params.txRequest;
+        let txOrMessageToSign;
+        let derivationPath;
+        let bufferContent;
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        const bitgoGpgPubKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequest.enterpriseId);
+        if (!bitgoGpgPubKey) {
+            throw new Error('Missing BitGo GPG key for MPCv2');
+        }
+        if (requestType === baseTypes_1.RequestType.tx) {
+            (0, assert_1.default)(txRequest.transactions || txRequest.unsignedTxs, 'Unable to find transactions in txRequest');
+            const unsignedTx = txRequest.apiVersion === 'full' ? txRequest.transactions[0].unsignedTx : txRequest.unsignedTxs[0];
+            if (!params.txParams?.recipients?.length) {
+                throw new errors_1.InvalidTransactionError('Recipient details are required to verify this transaction before signing. Pass txParams with at least one recipient.');
+            }
+            // For ICP transactions, the HSM signs the serializedTxHex, while the user signs the signableHex separately.
+            // Verification cannot be performed directly on the signableHex alone. However, we can parse the serializedTxHex
+            // to regenerate the signableHex and compare it against the provided value for verification.
+            // In contrast, for other coin families, verification is typically done using just the signableHex.
+            if (this.baseCoin.getConfig().family === 'icp') {
+                await this.baseCoin.verifyTransaction({
+                    txPrebuild: { txHex: unsignedTx.serializedTxHex, txInfo: unsignedTx.signableHex },
+                    txParams: params.txParams,
+                    wallet: this.wallet,
+                    walletType: this.wallet.multisigType(),
+                });
+            }
+            else {
+                await this.baseCoin.verifyTransaction({
+                    txPrebuild: { txHex: unsignedTx.signableHex },
+                    txParams: params.txParams,
+                    wallet: this.wallet,
+                    walletType: this.wallet.multisigType(),
+                });
+            }
+            txOrMessageToSign = unsignedTx.signableHex;
+            derivationPath = unsignedTx.derivationPath;
+            bufferContent = buffer_1.Buffer.from(txOrMessageToSign, 'hex');
+        }
+        else if (requestType === baseTypes_1.RequestType.message) {
+            txOrMessageToSign = txRequest.messages[0].messageEncoded;
+            derivationPath = txRequest.messages[0].derivationPath || 'm/0';
+            bufferContent = buffer_1.Buffer.from(txOrMessageToSign, 'hex');
+        }
+        else {
+            throw new Error('Invalid request type');
+        }
+        let hash;
+        try {
+            hash = this.baseCoin.getHashFunction();
+        }
+        catch (err) {
+            hash = (0, keccak_1.default)('keccak256');
+        }
+        // check what the encoding is supposed to be for message
+        const hashBuffer = hash.update(bufferContent).digest();
+        const otherSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, params.mpcv2PartyId !== undefined ? params.mpcv2PartyId : 0, derivationPath, hashBuffer);
+        const userSignerBroadcastMsg1 = await otherSigner.init();
+        const signatureShareRound1 = await (0, ecdsaMPCv2_1.getSignatureShareRoundOne)(userSignerBroadcastMsg1, userGpgKey, params.mpcv2PartyId);
+        let latestTxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequest.walletId, txRequest.txRequestId, [signatureShareRound1], requestType, this.baseCoin.getMPCAlgorithm(), userGpgKey.publicKey, undefined, this.wallet.multisigTypeVersion(), params.reqId);
+        (0, assert_1.default)(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');
+        let bitgoToUserMessages1And2;
+        if (requestType === baseTypes_1.RequestType.tx) {
+            bitgoToUserMessages1And2 = latestTxRequest.transactions[0].signatureShares;
+        }
+        else {
+            bitgoToUserMessages1And2 = latestTxRequest.messages[0].signatureShares;
+        }
+        // TODO: Use codec for parsing
+        const parsedBitGoToUserSigShareRoundOne = JSON.parse(bitgoToUserMessages1And2[bitgoToUserMessages1And2.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound1And2 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundOne)(parsedBitGoToUserSigShareRoundOne, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        /** Round 2 **/
+        const deserializedMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1And2);
+        const userToBitGoMessagesRound2 = otherSigner.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: deserializedMessages.broadcastMessages,
+        });
+        const userToBitGoMessagesRound3 = otherSigner.handleIncomingMessages({
+            p2pMessages: deserializedMessages.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRoundTwo = await (0, ecdsaMPCv2_1.getSignatureShareRoundTwo)(userToBitGoMessagesRound2, userToBitGoMessagesRound3, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        latestTxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequest.walletId, txRequest.txRequestId, [signatureShareRoundTwo], requestType, this.baseCoin.getMPCAlgorithm(), userGpgKey.publicKey, undefined, this.wallet.multisigTypeVersion(), params.reqId);
+        (0, assert_1.default)(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');
+        const txRequestSignatureShares = requestType === baseTypes_1.RequestType.tx
+            ? latestTxRequest.transactions[0].signatureShares
+            : latestTxRequest.messages[0].signatureShares;
+        // TODO: Use codec for parsing
+        const parsedBitGoToUserSigShareRoundTwo = JSON.parse(txRequestSignatureShares[txRequestSignatureShares.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound3 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundTwo)(parsedBitGoToUserSigShareRoundTwo, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        /** Round 3 **/
+        const deserializedBitGoToUserMessagesRound3 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const userToBitGoMessagesRound4 = otherSigner.handleIncomingMessages({
+            p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRoundThree = await (0, ecdsaMPCv2_1.getSignatureShareRoundThree)(userToBitGoMessagesRound4, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        // Submit for final signature share combine
+        await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequest.walletId, txRequest.txRequestId, [signatureShareRoundThree], requestType, this.baseCoin.getMPCAlgorithm(), userGpgKey.publicKey, undefined, this.wallet.multisigTypeVersion(), params.reqId);
+        return (0, common_1.sendTxRequest)(this.bitgo, txRequest.walletId, txRequest.txRequestId, requestType, params.reqId);
+    }
+    // #endregion
+    // #region formatting utils
+    formatBitgoBroadcastMessage(broadcastMessage) {
+        return {
+            from: broadcastMessage.from,
+            payload: { message: broadcastMessage.message, signature: broadcastMessage.signature },
+        };
+    }
+    formatP2PMessage(p2pMessage, commitment) {
+        return {
+            payload: { encryptedMessage: p2pMessage.encryptedMessage, signature: p2pMessage.signature },
+            from: p2pMessage.from,
+            to: p2pMessage.to,
+            commitment,
+        };
+    }
+    // #endregion
+    // #region private utils
+    /**
+     * Get the hash string and derivation path from the transaction request.
+     * @param {TxRequest} txRequest - the transaction request object
+     * @param {RequestType} requestType - the request type
+     * @returns {{ hashBuffer: Buffer; derivationPath: string }} - the hash string and derivation path
+     */
+    getHashStringAndDerivationPath(txRequest, requestType = baseTypes_1.RequestType.tx) {
+        let txToSign;
+        let derivationPath;
+        if (requestType === baseTypes_1.RequestType.tx) {
+            (0, assert_1.default)(txRequest.transactions && txRequest.transactions.length === 1, 'Unable to find transactions in txRequest');
+            txToSign = txRequest.transactions[0].unsignedTx.signableHex;
+            derivationPath = txRequest.transactions[0].unsignedTx.derivationPath;
+        }
+        else if (requestType === baseTypes_1.RequestType.message) {
+            // TODO(WP-2176): Add support for message signing
+            throw new Error('MPCv2 message signing not supported yet.');
+        }
+        else {
+            throw new Error('Invalid request type, got: ' + requestType);
+        }
+        let hash;
+        try {
+            hash = this.baseCoin.getHashFunction();
+        }
+        catch (err) {
+            hash = (0, keccak_1.default)('keccak256');
+        }
+        const hashBuffer = hash.update(buffer_1.Buffer.from(txToSign, 'hex')).digest();
+        return { hashBuffer, derivationPath };
+    }
+    /**
+     * Gets the BitGo and user GPG keys from the BitGo public GPG key and the encrypted user GPG private key.
+     * @param {string} bitgoPublicGpgKey  - the BitGo public GPG key
+     * @param {string} encryptedUserGpgPrvKey  - the encrypted user GPG private key
+     * @param {string} walletPassphrase  - the wallet passphrase
+     * @returns {Promise<{ bitgoGpgKey: pgp.Key; userGpgKey: pgp.SerializedKeyPair<string> }>} - the BitGo and user GPG keys
+     */
+    async getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase) {
+        const bitgoGpgKey = await pgp.readKey({ armoredKey: bitgoPublicGpgKey });
+        const userDecryptedKey = await pgp.readKey({
+            armoredKey: this.bitgo.decrypt({ input: encryptedUserGpgPrvKey, password: walletPassphrase }),
+        });
+        const userGpgKey = {
+            privateKey: userDecryptedKey.armor(),
+            publicKey: userDecryptedKey.toPublic().armor(),
+        };
+        return {
+            bitgoGpgKey,
+            userGpgKey,
+        };
+    }
+    /**
+     * Validates the adata and cyphertext.
+     * @param adata string
+     * @param cyphertext string
+     * @returns void
+     * @throws {Error} if the adata or cyphertext is invalid
+     */
+    validateAdata(adata, cyphertext) {
+        let cypherJson;
+        try {
+            cypherJson = JSON.parse(cyphertext);
+        }
+        catch (e) {
+            throw new Error('Failed to parse cyphertext to JSON, got: ' + cyphertext);
+        }
+        // using decodeURIComponent to handle special characters
+        if (decodeURIComponent(cypherJson.adata) !== decodeURIComponent(adata)) {
+            throw new Error('Adata does not match cyphertext adata');
+        }
+    }
+    // #endregion
+    // #region external signer
+    /** @inheritdoc */
+    async signEcdsaMPCv2TssUsingExternalSigner(params, externalSignerMPCv2SigningRound1Generator, externalSignerMPCv2SigningRound2Generator, externalSignerMPCv2SigningRound3Generator, requestType = baseTypes_1.RequestType.tx) {
+        const { txRequest, reqId } = params;
+        let txRequestResolved;
+        // TODO(WP-2176): Add support for message signing
+        (0, assert_1.default)(requestType === baseTypes_1.RequestType.tx, 'Only transaction signing is supported for external signer, got: ' + requestType);
+        if (typeof txRequest === 'string') {
+            txRequestResolved = await (0, tss_1.getTxRequest)(this.bitgo, this.wallet.id(), txRequest, reqId);
+        }
+        else {
+            txRequestResolved = txRequest;
+        }
+        const bitgoPublicGpgKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequestResolved.enterpriseId);
+        if (!bitgoPublicGpgKey) {
+            throw new Error('Missing BitGo GPG key for MPCv2');
+        }
+        // round 1
+        const { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey } = await externalSignerMPCv2SigningRound1Generator({ txRequest: txRequestResolved });
+        const round1TxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, [signatureShareRound1], requestType, this.baseCoin.getMPCAlgorithm(), userGpgPubKey, undefined, this.wallet.multisigTypeVersion(), reqId);
+        // round 2
+        const { signatureShareRound2, encryptedRound2Session } = await externalSignerMPCv2SigningRound2Generator({
+            txRequest: round1TxRequest,
+            encryptedRound1Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),
+        });
+        const round2TxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, [signatureShareRound2], requestType, this.baseCoin.getMPCAlgorithm(), userGpgPubKey, undefined, this.wallet.multisigTypeVersion(), reqId);
+        (0, assert_1.default)(round2TxRequest.transactions && round2TxRequest.transactions[0].signatureShares, 'Missing signature shares in round 2 txRequest');
+        // round 3
+        const { signatureShareRound3 } = await externalSignerMPCv2SigningRound3Generator({
+            txRequest: round2TxRequest,
+            encryptedRound2Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),
+        });
+        await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, [signatureShareRound3], requestType, this.baseCoin.getMPCAlgorithm(), userGpgPubKey, undefined, this.wallet.multisigTypeVersion(), reqId);
+        return (0, common_1.sendTxRequest)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, requestType, reqId);
+    }
+    async createOfflineRound1Share(params) {
+        const { prv, walletPassphrase, txRequest } = params;
+        const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);
+        const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;
+        const userKeyShare = buffer_1.Buffer.from(prv, 'base64');
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        const userSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);
+        const userSignerBroadcastMsg1 = await userSigner.init();
+        const signatureShareRound1 = await (0, ecdsaMPCv2_1.getSignatureShareRoundOne)(userSignerBroadcastMsg1, userGpgKey);
+        const session = userSigner.getSession();
+        const encryptedRound1Session = this.bitgo.encrypt({ input: session, password: walletPassphrase, adata });
+        const userGpgPubKey = userGpgKey.publicKey;
+        const encryptedUserGpgPrvKey = this.bitgo.encrypt({
+            input: userGpgKey.privateKey,
+            password: walletPassphrase,
+            adata,
+        });
+        return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };
+    }
+    async createOfflineRound2Share(params) {
+        const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound1Session, bitgoPublicGpgKey, txRequest } = params;
+        const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);
+        const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;
+        const { bitgoGpgKey, userGpgKey } = await this.getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase);
+        const signatureShares = txRequest.transactions?.[0].signatureShares;
+        (0, assert_1.default)(signatureShares, 'Missing signature shares in round 1 txRequest');
+        const parsedBitGoToUserSigShareRoundOne = JSON.parse(signatureShares[signatureShares.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound1 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundOne)(parsedBitGoToUserSigShareRoundOne, userGpgKey, bitgoGpgKey);
+        const round1Session = this.bitgo.decrypt({ input: encryptedRound1Session, password: walletPassphrase });
+        this.validateAdata(adata, encryptedRound1Session);
+        const userKeyShare = buffer_1.Buffer.from(prv, 'base64');
+        const userSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);
+        await userSigner.setSession(round1Session);
+        const deserializedMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1);
+        const userToBitGoMessagesRound2 = userSigner.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: deserializedMessages.broadcastMessages,
+        });
+        const userToBitGoMessagesRound3 = userSigner.handleIncomingMessages({
+            p2pMessages: deserializedMessages.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRound2 = await (0, ecdsaMPCv2_1.getSignatureShareRoundTwo)(userToBitGoMessagesRound2, userToBitGoMessagesRound3, userGpgKey, bitgoGpgKey);
+        const session = userSigner.getSession();
+        const encryptedRound2Session = this.bitgo.encrypt({ input: session, password: walletPassphrase, adata });
+        return {
+            signatureShareRound2,
+            encryptedRound2Session,
+        };
+    }
+    async createOfflineRound3Share(params) {
+        const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound2Session, bitgoPublicGpgKey, txRequest } = params;
+        (0, assert_1.default)(txRequest.transactions && txRequest.transactions.length === 1, 'Unable to find transactions in txRequest');
+        const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);
+        const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;
+        const { bitgoGpgKey, userGpgKey } = await this.getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase);
+        const signatureShares = txRequest.transactions?.[0].signatureShares;
+        (0, assert_1.default)(signatureShares, 'Missing signature shares in round 2 txRequest');
+        const parsedBitGoToUserSigShareRoundTwo = JSON.parse(signatureShares[signatureShares.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound3 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundTwo)(parsedBitGoToUserSigShareRoundTwo, userGpgKey, bitgoGpgKey);
+        const deserializedBitGoToUserMessagesRound3 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const round2Session = this.bitgo.decrypt({ input: encryptedRound2Session, password: walletPassphrase });
+        this.validateAdata(adata, encryptedRound2Session);
+        const userKeyShare = buffer_1.Buffer.from(prv, 'base64');
+        const userSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);
+        await userSigner.setSession(round2Session);
+        const userToBitGoMessagesRound4 = userSigner.handleIncomingMessages({
+            p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRound3 = await (0, ecdsaMPCv2_1.getSignatureShareRoundThree)(userToBitGoMessagesRound4, userGpgKey, bitgoGpgKey);
+        return { signatureShareRound3 };
+    }
+}
+exports.EcdsaMPCv2Utils = EcdsaMPCv2Utils;
+/**
+ * Checks if the given key share, when decrypted, contains valid GG18 signing material.
+ *
+ * @param {string} keyShare - The encrypted key share string.
+ * @param {string|undefined} walletPassphrase - The passphrase used to decrypt the key share
+ * @returns {boolean} - Returns `true` if the decrypted data contains valid signing material, otherwise `false`.
+ */
+function isGG18SigningMaterial(keyShare, walletPassphrase) {
+    const prv = sjcl.decrypt(walletPassphrase, keyShare);
+    try {
+        const signingMaterial = JSON.parse(prv);
+        return (signingMaterial.pShare &&
+            signingMaterial.bitgoNShare &&
+            (signingMaterial.userNShare || signingMaterial.backupNShare));
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Get the MPC v2 recovery key shares from the provided user and backup key shares.
+ * @param encryptedUserKey encrypted gg18 or MPCv2 user key
+ * @param encryptedBackupKey encrypted gg18 or MPCv2 backup key
+ * @param walletPassphrase password for user and backup key
+ * @returns MPC v2 recovery key shares
+ */
+async function getMpcV2RecoveryKeyShares(encryptedUserKey, encryptedBackupKey, walletPassphrase) {
+    if (isGG18SigningMaterial(encryptedUserKey, walletPassphrase)) {
+        return getMpcV2RecoveryKeySharesFromGG18(encryptedUserKey, encryptedBackupKey, walletPassphrase);
+    }
+    return getMpcV2RecoveryKeySharesFromReducedKey(encryptedUserKey, encryptedBackupKey, walletPassphrase);
+}
+/**
+ * Signs a message hash using MPC v2 recovery key shares.
+ *
+ * @param {Buffer} messageHash
+ * @param {Buffer} userKeyShare
+ * @param {Buffer} backupKeyShare
+ * @param {string} commonKeyChain
+ * @returns {Promise<{ recid: number, r: string, s: string, y: string }>}
+ *
+ * @async
+ */
+async function signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain) {
+    const userDsg = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, 'm/0', messageHash);
+    const backupDsg = new sdk_lib_mpc_1.DklsDsg.Dsg(backupKeyShare, 1, 'm/0', messageHash);
+    const signatureString = sdk_lib_mpc_1.DklsUtils.verifyAndConvertDklsSignature(messageHash, (await sdk_lib_mpc_1.DklsUtils.executeTillRound(5, userDsg, backupDsg)), commonKeyChain, 'm/0', undefined, false);
+    const sigParts = signatureString.split(':');
+    return {
+        recid: parseInt(sigParts[0], 10),
+        r: sigParts[1],
+        s: sigParts[2],
+        y: sigParts[3],
+    };
+}
+// #region private utils
+/**
+ * Get the MPC v2 recovery key shares from the provided user and backup key shares.
+ * @param encryptedGG18UserKey encrypted gg18 user key
+ * @param encryptedGG18BackupKey encrypted gg18 backup key
+ * @param walletPassphrase password for user and backup key
+ * @returns MPC v2 recovery key shares
+ */
+async function getMpcV2RecoveryKeySharesFromGG18(encryptedGG18UserKey, encryptedGG18BackupKey, walletPassphrase) {
+    const [userKeyCombined, backupKeyCombined] = getKeyCombinedFromTssKeyShares(encryptedGG18UserKey, encryptedGG18BackupKey, walletPassphrase);
+    const retrofitDataA = {
+        xShare: userKeyCombined.xShare,
+    };
+    const retrofitDataB = {
+        xShare: backupKeyCombined.xShare,
+    };
+    const [user, backup] = await sdk_lib_mpc_1.DklsUtils.generate2of2KeyShares(retrofitDataA, retrofitDataB);
+    const userKeyShare = user.getKeyShare();
+    const backupKeyShare = backup.getKeyShare();
+    return {
+        userKeyShare,
+        backupKeyShare,
+        commonKeyChain: sdk_lib_mpc_1.DklsTypes.getCommonKeychain(backupKeyShare),
+    };
+}
+/**
+ * Retrieves the MPC v2 recovery key shares from the provided user and backup key shares.
+ *
+ * @param {string} encryptedMPCv2UserKey
+ * @param {string} encryptedMPCv2BackupKey
+ * @param {string} [walletPassphrase] - The passphrase used to decrypt the key shares
+ * @returns {Promise<{ userKeyShare: KeyShare, backupKeyShare: KeyShare, commonKeyChain: string }>}
+ *
+ * @async
+ */
+async function getMpcV2RecoveryKeySharesFromReducedKey(encryptedMPCv2UserKey, encryptedMPCv2BackupKey, walletPassphrase) {
+    const userCompressedPrv = buffer_1.Buffer.from(sjcl.decrypt(walletPassphrase, encryptedMPCv2UserKey), 'base64');
+    const bakcupCompressedPrv = buffer_1.Buffer.from(sjcl.decrypt(walletPassphrase, encryptedMPCv2BackupKey), 'base64');
+    const userPrvJSON = sdk_lib_mpc_1.DklsTypes.getDecodedReducedKeyShare(userCompressedPrv);
+    const backupPrvJSON = sdk_lib_mpc_1.DklsTypes.getDecodedReducedKeyShare(bakcupCompressedPrv);
+    const userKeyRetrofit = {
+        xShare: {
+            x: buffer_1.Buffer.from(userPrvJSON.prv).toString('hex'),
+            y: buffer_1.Buffer.from(userPrvJSON.pub).toString('hex'),
+            chaincode: buffer_1.Buffer.from(userPrvJSON.rootChainCode).toString('hex'),
+        },
+        xiList: userPrvJSON.xList.slice(0, 2),
+    };
+    const backupKeyRetrofit = {
+        xShare: {
+            x: buffer_1.Buffer.from(backupPrvJSON.prv).toString('hex'),
+            y: buffer_1.Buffer.from(backupPrvJSON.pub).toString('hex'),
+            chaincode: buffer_1.Buffer.from(backupPrvJSON.rootChainCode).toString('hex'),
+        },
+        xiList: backupPrvJSON.xList.slice(0, 2),
+    };
+    const [user, backup] = await sdk_lib_mpc_1.DklsUtils.generate2of2KeyShares(userKeyRetrofit, backupKeyRetrofit);
+    const userKeyShare = user.getKeyShare();
+    const backupKeyShare = backup.getKeyShare();
+    const commonKeyChain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userKeyShare);
+    return { userKeyShare, backupKeyShare, commonKeyChain };
+}
+/**
+ * Gets the combined key for GG18
+ * @param encryptedGG18UserKey encrypted GG18 user key
+ * @param encryptedGG18BackupKey encrypted GG18 backup key
+ * @param walletPassphrase wallet passphrase
+ * @returns key shares
+ */
+function getKeyCombinedFromTssKeyShares(encryptedGG18UserKey, encryptedGG18BackupKey, walletPassphrase) {
+    let backupPrv;
+    let userPrv;
+    try {
+        backupPrv = sjcl.decrypt(walletPassphrase, encryptedGG18BackupKey);
+        userPrv = sjcl.decrypt(walletPassphrase, encryptedGG18UserKey);
+    }
+    catch (e) {
+        throw new Error(`Error decrypting backup keychain: ${e.message}`);
+    }
+    const userSigningMaterial = JSON.parse(userPrv);
+    const backupSigningMaterial = JSON.parse(backupPrv);
+    if (!userSigningMaterial.backupNShare) {
+        throw new Error('Invalid user key - missing backupNShare');
+    }
+    if (!backupSigningMaterial.userNShare) {
+        throw new Error('Invalid backup key - missing userNShare');
+    }
+    const MPC = new account_lib_1.Ecdsa();
+    const userKeyCombined = MPC.keyCombine(userSigningMaterial.pShare, [
+        userSigningMaterial.bitgoNShare,
+        userSigningMaterial.backupNShare,
+    ]);
+    const backupKeyCombined = MPC.keyCombine(backupSigningMaterial.pShare, [
+        backupSigningMaterial.userNShare,
+        backupSigningMaterial.bitgoNShare,
+    ]);
+    if (userKeyCombined.xShare.y !== backupKeyCombined.xShare.y ||
+        userKeyCombined.xShare.chaincode !== backupKeyCombined.xShare.chaincode) {
+        throw new Error('Common keychains do not match');
+    }
+    return [userKeyCombined, backupKeyCombined];
+}
+// #endregion
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecdsaMPCv2.js","sourceRoot":"","sources":["../../../../../../src/bitgo/utils/tss/ecdsa/ecdsaMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import { bigIntToBufferBE, DklsComms, DklsDkg, DklsDsg, DklsTypes, DklsUtils } from '@bitgo-beta/sdk-lib-mpc';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport assert from 'assert';\nimport { Buffer } from 'buffer';\nimport { Hash } from 'crypto';\nimport { NonEmptyString } from 'io-ts-types';\nimport createKeccakHash from 'keccak';\nimport * as pgp from 'openpgp';\nimport { KeychainsTriplet } from '../../../baseCoin';\nimport {\n  MPCv2BroadcastMessage,\n  MPCv2KeyGenRound1Response,\n  MPCv2KeyGenRound2Response,\n  MPCv2KeyGenRound3Response,\n  MPCv2KeyGenStateEnum,\n  MPCv2P2PMessage,\n  MPCv2PartyFromStringOrNumber,\n  MPCv2SignatureShareRound1Output,\n  MPCv2SignatureShareRound2Output,\n} from '@bitgo/public-types';\n\nimport { Ecdsa } from '../../../../account-lib';\nimport { AddKeychainOptions, Keychain, KeyType } from '../../../keychain';\nimport { DecryptedRetrofitPayload } from '../../../keychain/iKeychains';\nimport { ECDSAMethodTypes, getTxRequest } from '../../../tss';\nimport { sendSignatureShareV2, sendTxRequest } from '../../../tss/common';\nimport { MPCv2PartiesEnum } from './typesMPCv2';\nimport {\n  getSignatureShareRoundOne,\n  getSignatureShareRoundThree,\n  getSignatureShareRoundTwo,\n  verifyBitGoMessagesAndSignaturesRoundOne,\n  verifyBitGoMessagesAndSignaturesRoundTwo,\n} from '../../../tss/ecdsa/ecdsaMPCv2';\nimport { InvalidTransactionError } from '../../../errors';\nimport { KeyCombined } from '../../../tss/ecdsa/types';\nimport { generateGPGKeyPair } from '../../opengpgUtils';\nimport {\n  CustomMPCv2SigningRound1GeneratingFunction,\n  CustomMPCv2SigningRound2GeneratingFunction,\n  CustomMPCv2SigningRound3GeneratingFunction,\n  RequestType,\n  SignatureShareRecord,\n  TSSParams,\n  TSSParamsForMessage,\n  TSSParamsForMessageWithPrv,\n  TSSParamsWithPrv,\n  TxRequest,\n} from '../baseTypes';\nimport { BaseEcdsaUtils } from './base';\nimport { EcdsaMPCv2KeyGenSendFn, KeyGenSenderForEnterprise } from './ecdsaMPCv2KeyGenSender';\nimport { envRequiresBitgoPubGpgKeyConfig, isBitgoMpcPubKey } from '../../../tss/bitgoPubKeys';\n\nexport class EcdsaMPCv2Utils extends BaseEcdsaUtils {\n  /** @inheritdoc */\n  async createKeychains(params: {\n    passphrase: string;\n    enterprise: string;\n    originalPasscodeEncryptionCode?: string;\n    retrofit?: DecryptedRetrofitPayload;\n  }): Promise<KeychainsTriplet> {\n    const { userSession, backupSession } = this.getUserAndBackupSession(2, 3, params.retrofit);\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 bitgoPublicGpgKey = (\n      (await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true)) ?? this.bitgoMPCv2PublicGpgKey\n    ).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\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\n    const { sessionId, bitgoMsg1, bitgoToBackupMsg2, bitgoToUserMsg2 } = await this.sendKeyGenerationRound1(\n      params.enterprise,\n      userGpgKey.publicKey,\n      backupGpgKey.publicKey,\n      params.retrofit?.walletId\n        ? {\n            ...round1Messages,\n            walletId: params.retrofit.walletId,\n          }\n        : round1Messages\n    );\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    const round2Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      { p2pMessages: [serializedUserToBitgoMsg2, serializedBackupToBitgoMsg2], broadcastMessages: [] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n\n    const {\n      sessionId: sessionIdRound2,\n      bitgoCommitment2,\n      bitgoToUserMsg3,\n      bitgoToBackupMsg3,\n    } = await this.sendKeyGenerationRound2(params.enterprise, sessionId, round2Messages);\n    // #endregion\n\n    // #region round 3\n    assert.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');\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\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 userKeychainPromise = this.addUserKeychain(\n      bitgoCommonKeychain,\n      userPrivateMaterial,\n      userReducedPrivateMaterial,\n      params.passphrase,\n      params.originalPasscodeEncryptionCode\n    );\n    const backupKeychainPromise = this.addBackupKeychain(\n      bitgoCommonKeychain,\n      backupPrivateMaterial,\n      backupReducedPrivateMaterial,\n      params.passphrase,\n      params.originalPasscodeEncryptionCode\n    );\n    const bitgoKeychainPromise = this.addBitgoKeychain(bitgoCommonKeychain);\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  }\n\n  // #region keychain utils\n  async createParticipantKeychain(\n    participantIndex: MPCv2PartyFromStringOrNumber,\n    commonKeychain: string,\n    privateMaterial?: Buffer,\n    reducedPrivateMaterial?: Buffer,\n    passphrase?: string,\n    originalPasscodeEncryptionCode?: string\n  ): Promise<Keychain> {\n    let source: string;\n    let encryptedPrv: string | undefined = undefined;\n    let reducedEncryptedPrv: string | undefined = undefined;\n    switch (participantIndex) {\n      case MPCv2PartiesEnum.USER:\n      case MPCv2PartiesEnum.BACKUP:\n        source = participantIndex === MPCv2PartiesEnum.USER ? 'user' : 'backup';\n        assert(privateMaterial, `Private material is required for ${source} keychain`);\n        assert(reducedPrivateMaterial, `Reduced private material is required for ${source} keychain`);\n        assert(passphrase, `Passphrase is required for ${source} keychain`);\n        encryptedPrv = this.bitgo.encrypt({\n          input: privateMaterial.toString('base64'),\n          password: passphrase,\n        });\n        // Encrypts the CBOR-encoded ReducedKeyShare (which contains the party's private\n        // scalar s_i) with the wallet passphrase. The result is stored as reducedEncryptedPrv\n        // on the key card QR code and represents a second copy of private key material\n        // beyond the server-stored encryptedPrv.\n        reducedEncryptedPrv = this.bitgo.encrypt({\n          // Buffer.toString('base64') can not be used here as it does not work on the browser.\n          // The browser deals with a Buffer as Uint8Array, therefore in the browser .toString('base64') just creates a comma seperated string of the array values.\n          input: btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial)))),\n          password: passphrase,\n        });\n        break;\n      case MPCv2PartiesEnum.BITGO:\n        source = 'bitgo';\n        break;\n      default:\n        throw new Error('Invalid participant index');\n    }\n\n    const recipientKeychainParams: AddKeychainOptions = {\n      source,\n      keyType: 'tss' as KeyType,\n      commonKeychain,\n      encryptedPrv,\n      originalPasscodeEncryptionCode,\n      isMPCv2: true,\n    };\n\n    const keychains = this.baseCoin.keychains();\n    return { ...(await keychains.add(recipientKeychainParams)), reducedEncryptedPrv: reducedEncryptedPrv };\n  }\n\n  /**\n   * Converts a User or Backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.\n   *\n   * @param decryptedKeyshare - MPCv1 decrypted signing material for user or backup as a json.stringify string and bitgo's Big Si.\n   * @param partyId - The party ID of the MPCv1 keyshare.\n   * @returns The retrofit data needed to start an MPCv2 DKG session.\n   * @deprecated\n   */\n  static getKeyDataForRetrofit(\n    decryptedKeyshare: string,\n    partyId: MPCv2PartiesEnum.BACKUP | MPCv2PartiesEnum.USER\n  ): DklsTypes.RetrofitData {\n    const mpc = new Ecdsa();\n    const xiList = [\n      Array.from(bigIntToBufferBE(BigInt(1), 32)),\n      Array.from(bigIntToBufferBE(BigInt(2), 32)),\n      Array.from(bigIntToBufferBE(BigInt(3), 32)),\n    ];\n    return EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({\n      mpcv1PartyKeyShare: decryptedKeyshare,\n      mpcv1PartyIndex: partyId === MPCv2PartiesEnum.USER ? 1 : 2,\n      xiList,\n      mpc,\n    });\n  }\n\n  /**\n   * Converts user and backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.\n   *\n   * @param {Object} params - MPCv1 decrypted signing material for user and backup as a json.stringify string and bitgo's Big Si.\n   * @returns {{ mpcv2UserKeyShare: DklsTypes.RetrofitData; mpcv2BakcupKeyShare: DklsTypes.RetrofitData }} - the retrofit data needed to start an MPCv2 DKG session.\n   */\n  getMpcV2RetrofitDataFromMpcV1Keys(params: { mpcv1UserKeyShare: string; mpcv1BackupKeyShare: string }): {\n    mpcv2UserKeyShare: DklsTypes.RetrofitData;\n    mpcv2BackupKeyShare: DklsTypes.RetrofitData;\n  } {\n    const mpc = new Ecdsa();\n    const xiList = [\n      Array.from(bigIntToBufferBE(BigInt(1), 32)),\n      Array.from(bigIntToBufferBE(BigInt(2), 32)),\n      Array.from(bigIntToBufferBE(BigInt(3), 32)),\n    ];\n    return {\n      mpcv2UserKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({\n        mpcv1PartyKeyShare: params.mpcv1UserKeyShare,\n        mpcv1PartyIndex: 1,\n        xiList,\n        mpc,\n      }),\n      mpcv2BackupKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({\n        mpcv1PartyKeyShare: params.mpcv1BackupKeyShare,\n        mpcv1PartyIndex: 2,\n        xiList,\n        mpc,\n      }),\n    };\n  }\n\n  /**\n   * Get retrofit data from MPCv1 key share.\n   * @param mpcv1PartyKeyShare\n   * @param mpcv1PartyIndex\n   * @param xiList\n   * @param mpc\n   * @deprecated\n   */\n  static getMpcV2RetrofitDataFromMpcV1Key({\n    mpcv1PartyKeyShare,\n    mpcv1PartyIndex,\n    xiList,\n    mpc,\n  }: {\n    mpcv1PartyKeyShare: string;\n    mpcv1PartyIndex: number;\n    xiList: number[][];\n    mpc: Ecdsa;\n  }): DklsTypes.RetrofitData {\n    const signingMaterial: ECDSAMethodTypes.SigningMaterial = JSON.parse(mpcv1PartyKeyShare);\n    let keyCombined: KeyCombined | undefined = undefined;\n    switch (mpcv1PartyIndex) {\n      case 1:\n        assert(signingMaterial.backupNShare, 'User MPCv1 key material should have backup NShare.');\n        assert(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');\n        keyCombined = mpc.keyCombine(signingMaterial.pShare, [\n          signingMaterial.backupNShare,\n          signingMaterial.bitgoNShare,\n        ]);\n        break;\n      case 2:\n        assert(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');\n        assert(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');\n        keyCombined = mpc.keyCombine(signingMaterial.pShare, [signingMaterial.userNShare, signingMaterial.bitgoNShare]);\n        break;\n      case 3:\n        assert(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');\n        assert(signingMaterial.backupNShare, 'Backup MPCv1 key material should have user NShare.');\n        keyCombined = mpc.keyCombine(signingMaterial.pShare, [\n          signingMaterial.userNShare,\n          signingMaterial.backupNShare,\n        ]);\n        break;\n      default:\n        throw new Error('Invalid participant index');\n    }\n    return {\n      xShare: keyCombined.xShare,\n      xiList: xiList,\n    };\n  }\n\n  private async addUserKeychain(\n    commonKeychain: string,\n    privateMaterial: Buffer,\n    reducedPrivateMaterial: Buffer,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string\n  ): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.USER,\n      commonKeychain,\n      privateMaterial,\n      reducedPrivateMaterial,\n      passphrase,\n      originalPasscodeEncryptionCode\n    );\n  }\n\n  private async addBackupKeychain(\n    commonKeychain: string,\n    privateMaterial: Buffer,\n    reducedPrivateMaterial: Buffer,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string\n  ): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.BACKUP,\n      commonKeychain,\n      privateMaterial,\n      reducedPrivateMaterial,\n      passphrase,\n      originalPasscodeEncryptionCode\n    );\n  }\n\n  private getUserAndBackupSession(m: number, n: number, retrofit?: DecryptedRetrofitPayload) {\n    if (retrofit) {\n      const retrofitData = this.getMpcV2RetrofitDataFromMpcV1Keys({\n        mpcv1UserKeyShare: retrofit.decryptedUserKey,\n        mpcv1BackupKeyShare: retrofit.decryptedBackupKey,\n      });\n\n      const userSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.USER, undefined, retrofitData.mpcv2UserKeyShare);\n      const backupSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.BACKUP, undefined, retrofitData.mpcv2BackupKeyShare);\n\n      return { userSession, backupSession };\n    }\n\n    const userSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.USER);\n    const backupSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.BACKUP);\n\n    return { userSession, backupSession };\n  }\n\n  private async addBitgoKeychain(commonKeychain: string): Promise<Keychain> {\n    return this.createParticipantKeychain(MPCv2PartiesEnum.BITGO, commonKeychain);\n  }\n  // #endregion\n\n  async sendKeyGenerationRound1(\n    enterprise: string,\n    userGpgPublicKey: string,\n    backupGpgPublicKey: string,\n    payload: DklsTypes.AuthEncMessages & { walletId?: string }\n  ): Promise<MPCv2KeyGenRound1Response> {\n    return this.sendKeyGenerationRound1BySender(\n      KeyGenSenderForEnterprise(this.bitgo, enterprise),\n      userGpgPublicKey,\n      backupGpgPublicKey,\n      payload\n    );\n  }\n\n  async sendKeyGenerationRound2(\n    enterprise: string,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound2Response> {\n    return this.sendKeyGenerationRound2BySender(KeyGenSenderForEnterprise(this.bitgo, enterprise), sessionId, payload);\n  }\n\n  async sendKeyGenerationRound3(\n    enterprise: string,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound3Response> {\n    return this.sendKeyGenerationRound3BySender(KeyGenSenderForEnterprise(this.bitgo, enterprise), sessionId, payload);\n  }\n\n  async sendKeyGenerationRound1BySender(\n    senderFn: EcdsaMPCv2KeyGenSendFn<MPCv2KeyGenRound1Response>,\n    userGpgPublicKey: string,\n    backupGpgPublicKey: string,\n    payload: DklsTypes.AuthEncMessages & { walletId?: string }\n  ): Promise<MPCv2KeyGenRound1Response> {\n    assert(NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');\n    assert(NonEmptyString.is(backupGpgPublicKey), 'Backup GPG public key 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    const backupMsg1 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BACKUP)?.payload;\n    assert(backupMsg1, 'Backup message 1 not found in broadcast messages');\n\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R1'], {\n      userGpgPublicKey,\n      backupGpgPublicKey,\n      userMsg1: { from: 0, ...userMsg1 },\n      backupMsg1: { from: 1, ...backupMsg1 },\n      walletId: payload.walletId,\n    });\n  }\n\n  async sendKeyGenerationRound2BySender(\n    senderFn: EcdsaMPCv2KeyGenSendFn<MPCv2KeyGenRound2Response>,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound2Response> {\n    assert(NonEmptyString.is(sessionId), 'Session ID is required');\n    const userMsg2 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(userMsg2, 'User to Bitgo message 2 not found in P2P messages');\n    assert(userMsg2.commitment, 'User to Bitgo commitment not found in P2P messages');\n    assert(NonEmptyString.is(userMsg2.commitment), 'User to Bitgo commitment is required');\n    const backupMsg2 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(backupMsg2, 'Backup to Bitgo message 2 not found in P2P messages');\n    assert(backupMsg2.commitment, 'Backup to Bitgo commitment not found in P2P messages');\n    assert(NonEmptyString.is(backupMsg2.commitment), 'Backup to Bitgo commitment is required');\n\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R2'], {\n      sessionId,\n      userMsg2: {\n        from: MPCv2PartiesEnum.USER,\n        to: MPCv2PartiesEnum.BITGO,\n        signature: userMsg2.payload.signature,\n        encryptedMessage: userMsg2.payload.encryptedMessage,\n      },\n      userCommitment2: userMsg2.commitment,\n      backupMsg2: {\n        from: MPCv2PartiesEnum.BACKUP,\n        to: MPCv2PartiesEnum.BITGO,\n        signature: backupMsg2.payload.signature,\n        encryptedMessage: backupMsg2.payload.encryptedMessage,\n      },\n      backupCommitment2: backupMsg2.commitment,\n    });\n  }\n\n  async sendKeyGenerationRound3BySender(\n    senderFn: EcdsaMPCv2KeyGenSendFn<MPCv2KeyGenRound3Response>,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound3Response> {\n    assert(NonEmptyString.is(sessionId), 'Session ID is required');\n    const userMsg3 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    )?.payload;\n    assert(userMsg3, 'User to Bitgo message 3 not found in P2P messages');\n    const backupMsg3 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    )?.payload;\n    assert(backupMsg3, 'Backup to Bitgo message 3 not found in P2P messages');\n    const userMsg4 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER)?.payload;\n    assert(userMsg4, 'User message 1 not found in broadcast messages');\n    const backupMsg4 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BACKUP)?.payload;\n    assert(backupMsg4, 'Backup message 1 not found in broadcast messages');\n\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R3'], {\n      sessionId,\n      userMsg3: { from: 0, to: 2, ...userMsg3 },\n      backupMsg3: { from: 1, to: 2, ...backupMsg3 },\n      userMsg4: { from: 0, ...userMsg4 },\n      backupMsg4: { from: 1, ...backupMsg4 },\n    });\n  }\n\n  // #endregion\n\n  // #region sign tx request\n\n  /**\n   * Signs the transaction associated to the transaction request.\n   * @param {string | TxRequest} params.txRequest - transaction request object or id\n   * @param {string} params.prv - decrypted private key\n   * @param {string} params.reqId - request id\n   * @param {string} params.mpcv2PartyId - party id for the signer involved in this mpcv2 request (either 0 for user or 1 for backup)\n   * @returns {Promise<TxRequest>} fully signed TxRequest object\n   */\n\n  async signTxRequest(params: TSSParamsWithPrv): Promise<TxRequest> {\n    this.bitgo.setRequestTracer(params.reqId);\n    return this.signRequestBase(params, RequestType.tx);\n  }\n\n  /**\n   * Signs the message associated to the transaction request.\n   * @param {string | TxRequest} params.txRequest - transaction request object or id\n   * @param {string} params.prv - decrypted private key\n   * @param {string} params.reqId - request id\n   * @returns {Promise<TxRequest>} fully signed TxRequest object\n   */\n  async signTxRequestForMessage(params: TSSParamsForMessageWithPrv): Promise<TxRequest> {\n    this.bitgo.setRequestTracer(params.reqId);\n    return this.signRequestBase(params, RequestType.message);\n  }\n\n  private async signRequestBase(\n    params: TSSParamsWithPrv | TSSParamsForMessageWithPrv,\n    requestType: RequestType\n  ): Promise<TxRequest> {\n    const userKeyShare = Buffer.from(params.prv, 'base64');\n    const txRequest: TxRequest =\n      typeof params.txRequest === 'string'\n        ? await getTxRequest(this.bitgo, this.wallet.id(), params.txRequest, params.reqId)\n        : params.txRequest;\n    let txOrMessageToSign;\n    let derivationPath;\n    let bufferContent;\n    const userGpgKey = await generateGPGKeyPair('secp256k1');\n    const bitgoGpgPubKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequest.enterpriseId);\n\n    if (!bitgoGpgPubKey) {\n      throw new Error('Missing BitGo GPG key for MPCv2');\n    }\n\n    if (requestType === RequestType.tx) {\n      assert(txRequest.transactions || txRequest.unsignedTxs, 'Unable to find transactions in txRequest');\n      const unsignedTx =\n        txRequest.apiVersion === 'full' ? txRequest.transactions![0].unsignedTx : txRequest.unsignedTxs[0];\n\n      if (!params.txParams?.recipients?.length) {\n        throw new InvalidTransactionError(\n          'Recipient details are required to verify this transaction before signing. Pass txParams with at least one recipient.'\n        );\n      }\n\n      // For ICP transactions, the HSM signs the serializedTxHex, while the user signs the signableHex separately.\n      // Verification cannot be performed directly on the signableHex alone. However, we can parse the serializedTxHex\n      // to regenerate the signableHex and compare it against the provided value for verification.\n      // In contrast, for other coin families, verification is typically done using just the signableHex.\n      if (this.baseCoin.getConfig().family === 'icp') {\n        await this.baseCoin.verifyTransaction({\n          txPrebuild: { txHex: unsignedTx.serializedTxHex, txInfo: unsignedTx.signableHex },\n          txParams: params.txParams,\n          wallet: this.wallet,\n          walletType: this.wallet.multisigType(),\n        });\n      } else {\n        await this.baseCoin.verifyTransaction({\n          txPrebuild: { txHex: unsignedTx.signableHex },\n          txParams: params.txParams,\n          wallet: this.wallet,\n          walletType: this.wallet.multisigType(),\n        });\n      }\n      txOrMessageToSign = unsignedTx.signableHex;\n      derivationPath = unsignedTx.derivationPath;\n      bufferContent = Buffer.from(txOrMessageToSign, 'hex');\n    } else if (requestType === RequestType.message) {\n      txOrMessageToSign = txRequest.messages![0].messageEncoded;\n      derivationPath = txRequest.messages![0].derivationPath || 'm/0';\n      bufferContent = Buffer.from(txOrMessageToSign, 'hex');\n    } else {\n      throw new Error('Invalid request type');\n    }\n\n    let hash: Hash;\n    try {\n      hash = this.baseCoin.getHashFunction();\n    } catch (err) {\n      hash = createKeccakHash('keccak256') as Hash;\n    }\n    // check what the encoding is supposed to be for message\n    const hashBuffer = hash.update(bufferContent).digest();\n    const otherSigner = new DklsDsg.Dsg(\n      userKeyShare,\n      params.mpcv2PartyId !== undefined ? params.mpcv2PartyId : 0,\n      derivationPath,\n      hashBuffer\n    );\n    const userSignerBroadcastMsg1 = await otherSigner.init();\n    const signatureShareRound1 = await getSignatureShareRoundOne(\n      userSignerBroadcastMsg1,\n      userGpgKey,\n      params.mpcv2PartyId\n    );\n\n    let latestTxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequest.walletId,\n      txRequest.txRequestId,\n      [signatureShareRound1],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgKey.publicKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      params.reqId\n    );\n\n    assert(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');\n\n    let bitgoToUserMessages1And2: any;\n    if (requestType === RequestType.tx) {\n      bitgoToUserMessages1And2 = latestTxRequest.transactions![0].signatureShares;\n    } else {\n      bitgoToUserMessages1And2 = latestTxRequest.messages![0].signatureShares;\n    }\n    // TODO: Use codec for parsing\n    const parsedBitGoToUserSigShareRoundOne = JSON.parse(\n      bitgoToUserMessages1And2[bitgoToUserMessages1And2.length - 1].share\n    ) as MPCv2SignatureShareRound1Output;\n    if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound1And2 = await verifyBitGoMessagesAndSignaturesRoundOne(\n      parsedBitGoToUserSigShareRoundOne,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n\n    /** Round 2 **/\n    const deserializedMessages = DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1And2);\n    const userToBitGoMessagesRound2 = otherSigner.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: deserializedMessages.broadcastMessages,\n    });\n    const userToBitGoMessagesRound3 = otherSigner.handleIncomingMessages({\n      p2pMessages: deserializedMessages.p2pMessages,\n      broadcastMessages: [],\n    });\n    const signatureShareRoundTwo = await getSignatureShareRoundTwo(\n      userToBitGoMessagesRound2,\n      userToBitGoMessagesRound3,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n    latestTxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequest.walletId,\n      txRequest.txRequestId,\n      [signatureShareRoundTwo],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgKey.publicKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      params.reqId\n    );\n    assert(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');\n\n    const txRequestSignatureShares =\n      requestType === RequestType.tx\n        ? latestTxRequest.transactions![0].signatureShares\n        : latestTxRequest.messages![0].signatureShares;\n    // TODO: Use codec for parsing\n    const parsedBitGoToUserSigShareRoundTwo = JSON.parse(\n      txRequestSignatureShares[txRequestSignatureShares.length - 1].share\n    ) as MPCv2SignatureShareRound2Output;\n    if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound3 = await verifyBitGoMessagesAndSignaturesRoundTwo(\n      parsedBitGoToUserSigShareRoundTwo,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n\n    /** Round 3 **/\n    const deserializedBitGoToUserMessagesRound3 = DklsTypes.deserializeMessages({\n      p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n    const userToBitGoMessagesRound4 = otherSigner.handleIncomingMessages({\n      p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n\n    const signatureShareRoundThree = await getSignatureShareRoundThree(\n      userToBitGoMessagesRound4,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n    // Submit for final signature share combine\n    await sendSignatureShareV2(\n      this.bitgo,\n      txRequest.walletId,\n      txRequest.txRequestId,\n      [signatureShareRoundThree],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgKey.publicKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      params.reqId\n    );\n\n    return sendTxRequest(this.bitgo, txRequest.walletId, txRequest.txRequestId, requestType, params.reqId);\n  }\n\n  // #endregion\n\n  // #region formatting utils\n  formatBitgoBroadcastMessage(broadcastMessage: MPCv2BroadcastMessage) {\n    return {\n      from: broadcastMessage.from,\n      payload: { message: broadcastMessage.message, signature: broadcastMessage.signature },\n    };\n  }\n\n  formatP2PMessage(p2pMessage: MPCv2P2PMessage, commitment?: string) {\n    return {\n      payload: { encryptedMessage: p2pMessage.encryptedMessage, signature: p2pMessage.signature },\n      from: p2pMessage.from,\n      to: p2pMessage.to,\n      commitment,\n    };\n  }\n  // #endregion\n\n  // #region private utils\n  /**\n   * Get the hash string and derivation path from the transaction request.\n   * @param {TxRequest} txRequest - the transaction request object\n   * @param {RequestType} requestType - the request type\n   * @returns {{ hashBuffer: Buffer; derivationPath: string }} - the hash string and derivation path\n   */\n  private getHashStringAndDerivationPath(\n    txRequest: TxRequest,\n    requestType: RequestType = RequestType.tx\n  ): { hashBuffer: Buffer; derivationPath: string } {\n    let txToSign: string;\n    let derivationPath: string;\n    if (requestType === RequestType.tx) {\n      assert(txRequest.transactions && txRequest.transactions.length === 1, 'Unable to find transactions in txRequest');\n      txToSign = txRequest.transactions[0].unsignedTx.signableHex;\n      derivationPath = txRequest.transactions[0].unsignedTx.derivationPath;\n    } else if (requestType === RequestType.message) {\n      // TODO(WP-2176): Add support for message signing\n      throw new Error('MPCv2 message signing not supported yet.');\n    } else {\n      throw new Error('Invalid request type, got: ' + requestType);\n    }\n\n    let hash: Hash;\n    try {\n      hash = this.baseCoin.getHashFunction();\n    } catch (err) {\n      hash = createKeccakHash('keccak256') as Hash;\n    }\n    const hashBuffer = hash.update(Buffer.from(txToSign, 'hex')).digest();\n\n    return { hashBuffer, derivationPath };\n  }\n\n  /**\n   * Gets the BitGo and user GPG keys from the BitGo public GPG key and the encrypted user GPG private key.\n   * @param {string} bitgoPublicGpgKey  - the BitGo public GPG key\n   * @param {string} encryptedUserGpgPrvKey  - the encrypted user GPG private key\n   * @param {string} walletPassphrase  - the wallet passphrase\n   * @returns {Promise<{ bitgoGpgKey: pgp.Key; userGpgKey: pgp.SerializedKeyPair<string> }>} - the BitGo and user GPG keys\n   */\n  private async getBitgoAndUserGpgKeys(\n    bitgoPublicGpgKey: string,\n    encryptedUserGpgPrvKey: string,\n    walletPassphrase: string\n  ): Promise<{\n    bitgoGpgKey: pgp.Key;\n    userGpgKey: pgp.SerializedKeyPair<string>;\n  }> {\n    const bitgoGpgKey = await pgp.readKey({ armoredKey: bitgoPublicGpgKey });\n    const userDecryptedKey = await pgp.readKey({\n      armoredKey: this.bitgo.decrypt({ input: encryptedUserGpgPrvKey, password: walletPassphrase }),\n    });\n    const userGpgKey: pgp.SerializedKeyPair<string> = {\n      privateKey: userDecryptedKey.armor(),\n      publicKey: userDecryptedKey.toPublic().armor(),\n    };\n    return {\n      bitgoGpgKey,\n      userGpgKey,\n    };\n  }\n\n  /**\n   * Validates the adata and cyphertext.\n   * @param adata string\n   * @param cyphertext string\n   * @returns void\n   * @throws {Error} if the adata or cyphertext is invalid\n   */\n  private validateAdata(adata: string, cyphertext: string): void {\n    let cypherJson;\n    try {\n      cypherJson = JSON.parse(cyphertext);\n    } catch (e) {\n      throw new Error('Failed to parse cyphertext to JSON, got: ' + cyphertext);\n    }\n    // using decodeURIComponent to handle special characters\n    if (decodeURIComponent(cypherJson.adata) !== decodeURIComponent(adata)) {\n      throw new Error('Adata does not match cyphertext adata');\n    }\n  }\n\n  // #endregion\n\n  // #region external signer\n  /** @inheritdoc */\n  async signEcdsaMPCv2TssUsingExternalSigner(\n    params: TSSParams | TSSParamsForMessage,\n    externalSignerMPCv2SigningRound1Generator: CustomMPCv2SigningRound1GeneratingFunction,\n    externalSignerMPCv2SigningRound2Generator: CustomMPCv2SigningRound2GeneratingFunction,\n    externalSignerMPCv2SigningRound3Generator: CustomMPCv2SigningRound3GeneratingFunction,\n    requestType: RequestType = RequestType.tx\n  ): Promise<TxRequest> {\n    const { txRequest, reqId } = params;\n    let txRequestResolved: TxRequest;\n\n    // TODO(WP-2176): Add support for message signing\n    assert(\n      requestType === RequestType.tx,\n      'Only transaction signing is supported for external signer, got: ' + requestType\n    );\n\n    if (typeof txRequest === 'string') {\n      txRequestResolved = await getTxRequest(this.bitgo, this.wallet.id(), txRequest, reqId);\n    } else {\n      txRequestResolved = txRequest;\n    }\n\n    const bitgoPublicGpgKey = await this.pickBitgoPubGpgKeyForSigning(\n      true,\n      params.reqId,\n      txRequestResolved.enterpriseId\n    );\n\n    if (!bitgoPublicGpgKey) {\n      throw new Error('Missing BitGo GPG key for MPCv2');\n    }\n\n    // round 1\n    const { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey } =\n      await externalSignerMPCv2SigningRound1Generator({ txRequest: txRequestResolved });\n    const round1TxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequestResolved.walletId,\n      txRequestResolved.txRequestId,\n      [signatureShareRound1],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgPubKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      reqId\n    );\n\n    // round 2\n    const { signatureShareRound2, encryptedRound2Session } = await externalSignerMPCv2SigningRound2Generator({\n      txRequest: round1TxRequest,\n      encryptedRound1Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),\n    });\n    const round2TxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequestResolved.walletId,\n      txRequestResolved.txRequestId,\n      [signatureShareRound2],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgPubKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      reqId\n    );\n    assert(\n      round2TxRequest.transactions && round2TxRequest.transactions[0].signatureShares,\n      'Missing signature shares in round 2 txRequest'\n    );\n\n    // round 3\n    const { signatureShareRound3 } = await externalSignerMPCv2SigningRound3Generator({\n      txRequest: round2TxRequest,\n      encryptedRound2Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),\n    });\n    await sendSignatureShareV2(\n      this.bitgo,\n      txRequestResolved.walletId,\n      txRequestResolved.txRequestId,\n      [signatureShareRound3],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgPubKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      reqId\n    );\n\n    return sendTxRequest(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, requestType, reqId);\n  }\n\n  async createOfflineRound1Share(params: { txRequest: TxRequest; prv: string; walletPassphrase: string }): Promise<{\n    signatureShareRound1: SignatureShareRecord;\n    userGpgPubKey: string;\n    encryptedRound1Session: string;\n    encryptedUserGpgPrvKey: string;\n  }> {\n    const { prv, walletPassphrase, txRequest } = params;\n    const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);\n    const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;\n\n    const userKeyShare = Buffer.from(prv, 'base64');\n    const userGpgKey = await generateGPGKeyPair('secp256k1');\n\n    const userSigner = new DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);\n    const userSignerBroadcastMsg1 = await userSigner.init();\n    const signatureShareRound1 = await getSignatureShareRoundOne(userSignerBroadcastMsg1, userGpgKey);\n    const session = userSigner.getSession();\n    const encryptedRound1Session = this.bitgo.encrypt({ input: session, password: walletPassphrase, adata });\n\n    const userGpgPubKey = userGpgKey.publicKey;\n    const encryptedUserGpgPrvKey = this.bitgo.encrypt({\n      input: userGpgKey.privateKey,\n      password: walletPassphrase,\n      adata,\n    });\n\n    return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };\n  }\n\n  async createOfflineRound2Share(params: {\n    txRequest: TxRequest;\n    prv: string;\n    walletPassphrase: string;\n    bitgoPublicGpgKey: string;\n    encryptedUserGpgPrvKey: string;\n    encryptedRound1Session: string;\n  }): Promise<{\n    signatureShareRound2: SignatureShareRecord;\n    encryptedRound2Session: string;\n  }> {\n    const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound1Session, bitgoPublicGpgKey, txRequest } =\n      params;\n\n    const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);\n    const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;\n    const { bitgoGpgKey, userGpgKey } = await this.getBitgoAndUserGpgKeys(\n      bitgoPublicGpgKey,\n      encryptedUserGpgPrvKey,\n      walletPassphrase\n    );\n\n    const signatureShares = txRequest.transactions?.[0].signatureShares;\n    assert(signatureShares, 'Missing signature shares in round 1 txRequest');\n    const parsedBitGoToUserSigShareRoundOne = JSON.parse(\n      signatureShares[signatureShares.length - 1].share\n    ) as MPCv2SignatureShareRound1Output;\n    if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound1 = await verifyBitGoMessagesAndSignaturesRoundOne(\n      parsedBitGoToUserSigShareRoundOne,\n      userGpgKey,\n      bitgoGpgKey\n    );\n\n    const round1Session = this.bitgo.decrypt({ input: encryptedRound1Session, password: walletPassphrase });\n\n    this.validateAdata(adata, encryptedRound1Session);\n    const userKeyShare = Buffer.from(prv, 'base64');\n    const userSigner = new DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);\n    await userSigner.setSession(round1Session);\n\n    const deserializedMessages = DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1);\n    const userToBitGoMessagesRound2 = userSigner.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: deserializedMessages.broadcastMessages,\n    });\n    const userToBitGoMessagesRound3 = userSigner.handleIncomingMessages({\n      p2pMessages: deserializedMessages.p2pMessages,\n      broadcastMessages: [],\n    });\n    const signatureShareRound2 = await getSignatureShareRoundTwo(\n      userToBitGoMessagesRound2,\n      userToBitGoMessagesRound3,\n      userGpgKey,\n      bitgoGpgKey\n    );\n    const session = userSigner.getSession();\n    const encryptedRound2Session = this.bitgo.encrypt({ input: session, password: walletPassphrase, adata });\n\n    return {\n      signatureShareRound2,\n      encryptedRound2Session,\n    };\n  }\n\n  async createOfflineRound3Share(params: {\n    txRequest: TxRequest;\n    prv: string;\n    walletPassphrase: string;\n    bitgoPublicGpgKey: string;\n    encryptedUserGpgPrvKey: string;\n    encryptedRound2Session: string;\n  }): Promise<{\n    signatureShareRound3: SignatureShareRecord;\n  }> {\n    const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound2Session, bitgoPublicGpgKey, txRequest } =\n      params;\n\n    assert(txRequest.transactions && txRequest.transactions.length === 1, 'Unable to find transactions in txRequest');\n    const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);\n    const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;\n\n    const { bitgoGpgKey, userGpgKey } = await this.getBitgoAndUserGpgKeys(\n      bitgoPublicGpgKey,\n      encryptedUserGpgPrvKey,\n      walletPassphrase\n    );\n\n    const signatureShares = txRequest.transactions?.[0].signatureShares;\n    assert(signatureShares, 'Missing signature shares in round 2 txRequest');\n    const parsedBitGoToUserSigShareRoundTwo = JSON.parse(\n      signatureShares[signatureShares.length - 1].share\n    ) as MPCv2SignatureShareRound2Output;\n    if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound3 = await verifyBitGoMessagesAndSignaturesRoundTwo(\n      parsedBitGoToUserSigShareRoundTwo,\n      userGpgKey,\n      bitgoGpgKey\n    );\n\n    const deserializedBitGoToUserMessagesRound3 = DklsTypes.deserializeMessages({\n      p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n\n    const round2Session = this.bitgo.decrypt({ input: encryptedRound2Session, password: walletPassphrase });\n    this.validateAdata(adata, encryptedRound2Session);\n    const userKeyShare = Buffer.from(prv, 'base64');\n    const userSigner = new DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);\n    await userSigner.setSession(round2Session);\n\n    const userToBitGoMessagesRound4 = userSigner.handleIncomingMessages({\n      p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n\n    const signatureShareRound3 = await getSignatureShareRoundThree(userToBitGoMessagesRound4, userGpgKey, bitgoGpgKey);\n\n    return { signatureShareRound3 };\n  }\n  // #endregion\n}\n\n/**\n * Checks if the given key share, when decrypted, contains valid GG18 signing material.\n *\n * @param {string} keyShare - The encrypted key share string.\n * @param {string|undefined} walletPassphrase - The passphrase used to decrypt the key share\n * @returns {boolean} - Returns `true` if the decrypted data contains valid signing material, otherwise `false`.\n */\nexport function isGG18SigningMaterial(keyShare: string, walletPassphrase: string | undefined): boolean {\n  const prv = sjcl.decrypt(walletPassphrase, keyShare);\n  try {\n    const signingMaterial = JSON.parse(prv);\n    return (\n      signingMaterial.pShare &&\n      signingMaterial.bitgoNShare &&\n      (signingMaterial.userNShare || signingMaterial.backupNShare)\n    );\n  } catch (error) {\n    return false;\n  }\n}\n\n/**\n * Get the MPC v2 recovery key shares from the provided user and backup key shares.\n * @param encryptedUserKey encrypted gg18 or MPCv2 user key\n * @param encryptedBackupKey encrypted gg18 or MPCv2 backup key\n * @param walletPassphrase password for user and backup key\n * @returns MPC v2 recovery key shares\n */\nexport async function getMpcV2RecoveryKeyShares(\n  encryptedUserKey: string,\n  encryptedBackupKey: string,\n  walletPassphrase?: string\n): Promise<{\n  userKeyShare: Buffer;\n  backupKeyShare: Buffer;\n  commonKeyChain: string;\n}> {\n  if (isGG18SigningMaterial(encryptedUserKey, walletPassphrase)) {\n    return getMpcV2RecoveryKeySharesFromGG18(encryptedUserKey, encryptedBackupKey, walletPassphrase);\n  }\n  return getMpcV2RecoveryKeySharesFromReducedKey(encryptedUserKey, encryptedBackupKey, walletPassphrase);\n}\n\n/**\n * Signs a message hash using MPC v2 recovery key shares.\n *\n * @param {Buffer} messageHash\n * @param {Buffer} userKeyShare\n * @param {Buffer} backupKeyShare\n * @param {string} commonKeyChain\n * @returns {Promise<{ recid: number, r: string, s: string, y: string }>}\n *\n * @async\n */\nexport async function signRecoveryMpcV2(\n  messageHash: Buffer,\n  userKeyShare: Buffer,\n  backupKeyShare: Buffer,\n  commonKeyChain: string\n): Promise<{\n  recid: number;\n  r: string;\n  s: string;\n  y: string;\n}> {\n  const userDsg = new DklsDsg.Dsg(userKeyShare, 0, 'm/0', messageHash);\n  const backupDsg = new DklsDsg.Dsg(backupKeyShare, 1, 'm/0', messageHash);\n\n  const signatureString = DklsUtils.verifyAndConvertDklsSignature(\n    messageHash,\n    (await DklsUtils.executeTillRound(5, userDsg, backupDsg)) as DklsTypes.DeserializedDklsSignature,\n    commonKeyChain,\n    'm/0',\n    undefined,\n    false\n  );\n  const sigParts = signatureString.split(':');\n\n  return {\n    recid: parseInt(sigParts[0], 10),\n    r: sigParts[1],\n    s: sigParts[2],\n    y: sigParts[3],\n  };\n}\n\n// #region private utils\n\n/**\n * Get the MPC v2 recovery key shares from the provided user and backup key shares.\n * @param encryptedGG18UserKey encrypted gg18 user key\n * @param encryptedGG18BackupKey encrypted gg18 backup key\n * @param walletPassphrase password for user and backup key\n * @returns MPC v2 recovery key shares\n */\nasync function getMpcV2RecoveryKeySharesFromGG18(\n  encryptedGG18UserKey: string,\n  encryptedGG18BackupKey: string,\n  walletPassphrase?: string\n): Promise<{\n  userKeyShare: Buffer;\n  backupKeyShare: Buffer;\n  commonKeyChain: string;\n}> {\n  const [userKeyCombined, backupKeyCombined] = getKeyCombinedFromTssKeyShares(\n    encryptedGG18UserKey,\n    encryptedGG18BackupKey,\n    walletPassphrase\n  );\n  const retrofitDataA: DklsTypes.RetrofitData = {\n    xShare: userKeyCombined.xShare,\n  };\n  const retrofitDataB: DklsTypes.RetrofitData = {\n    xShare: backupKeyCombined.xShare,\n  };\n  const [user, backup] = await DklsUtils.generate2of2KeyShares(retrofitDataA, retrofitDataB);\n\n  const userKeyShare = user.getKeyShare();\n  const backupKeyShare = backup.getKeyShare();\n  return {\n    userKeyShare,\n    backupKeyShare,\n    commonKeyChain: DklsTypes.getCommonKeychain(backupKeyShare),\n  };\n}\n\n/**\n * Retrieves the MPC v2 recovery key shares from the provided user and backup key shares.\n *\n * @param {string} encryptedMPCv2UserKey\n * @param {string} encryptedMPCv2BackupKey\n * @param {string} [walletPassphrase] - The passphrase used to decrypt the key shares\n * @returns {Promise<{ userKeyShare: KeyShare, backupKeyShare: KeyShare, commonKeyChain: string }>}\n *\n * @async\n */\nasync function getMpcV2RecoveryKeySharesFromReducedKey(\n  encryptedMPCv2UserKey: string,\n  encryptedMPCv2BackupKey: string,\n  walletPassphrase?: string\n): Promise<{\n  userKeyShare: Buffer;\n  backupKeyShare: Buffer;\n  commonKeyChain: string;\n}> {\n  const userCompressedPrv = Buffer.from(sjcl.decrypt(walletPassphrase, encryptedMPCv2UserKey), 'base64');\n  const bakcupCompressedPrv = Buffer.from(sjcl.decrypt(walletPassphrase, encryptedMPCv2BackupKey), 'base64');\n\n  const userPrvJSON: DklsTypes.ReducedKeyShare = DklsTypes.getDecodedReducedKeyShare(userCompressedPrv);\n  const backupPrvJSON: DklsTypes.ReducedKeyShare = DklsTypes.getDecodedReducedKeyShare(bakcupCompressedPrv);\n  const userKeyRetrofit: DklsTypes.RetrofitData = {\n    xShare: {\n      x: Buffer.from(userPrvJSON.prv).toString('hex'),\n      y: Buffer.from(userPrvJSON.pub).toString('hex'),\n      chaincode: Buffer.from(userPrvJSON.rootChainCode).toString('hex'),\n    },\n    xiList: userPrvJSON.xList.slice(0, 2),\n  };\n  const backupKeyRetrofit: DklsTypes.RetrofitData = {\n    xShare: {\n      x: Buffer.from(backupPrvJSON.prv).toString('hex'),\n      y: Buffer.from(backupPrvJSON.pub).toString('hex'),\n      chaincode: Buffer.from(backupPrvJSON.rootChainCode).toString('hex'),\n    },\n    xiList: backupPrvJSON.xList.slice(0, 2),\n  };\n  const [user, backup] = await DklsUtils.generate2of2KeyShares(userKeyRetrofit, backupKeyRetrofit);\n  const userKeyShare = user.getKeyShare();\n  const backupKeyShare = backup.getKeyShare();\n  const commonKeyChain = DklsTypes.getCommonKeychain(userKeyShare);\n  return { userKeyShare, backupKeyShare, commonKeyChain };\n}\n\n/**\n * Gets the combined key for GG18\n * @param encryptedGG18UserKey encrypted GG18 user key\n * @param encryptedGG18BackupKey encrypted GG18 backup key\n * @param walletPassphrase wallet passphrase\n * @returns key shares\n */\nfunction getKeyCombinedFromTssKeyShares(\n  encryptedGG18UserKey: string,\n  encryptedGG18BackupKey: string,\n  walletPassphrase?: string\n): [ECDSAMethodTypes.KeyCombined, ECDSAMethodTypes.KeyCombined] {\n  let backupPrv;\n  let userPrv;\n  try {\n    backupPrv = sjcl.decrypt(walletPassphrase, encryptedGG18BackupKey);\n    userPrv = sjcl.decrypt(walletPassphrase, encryptedGG18UserKey);\n  } catch (e) {\n    throw new Error(`Error decrypting backup keychain: ${e.message}`);\n  }\n\n  const userSigningMaterial = JSON.parse(userPrv) as ECDSAMethodTypes.SigningMaterial;\n  const backupSigningMaterial = JSON.parse(backupPrv) as ECDSAMethodTypes.SigningMaterial;\n\n  if (!userSigningMaterial.backupNShare) {\n    throw new Error('Invalid user key - missing backupNShare');\n  }\n\n  if (!backupSigningMaterial.userNShare) {\n    throw new Error('Invalid backup key - missing userNShare');\n  }\n\n  const MPC = new Ecdsa();\n\n  const userKeyCombined = MPC.keyCombine(userSigningMaterial.pShare, [\n    userSigningMaterial.bitgoNShare,\n    userSigningMaterial.backupNShare,\n  ]);\n  const backupKeyCombined = MPC.keyCombine(backupSigningMaterial.pShare, [\n    backupSigningMaterial.userNShare,\n    backupSigningMaterial.bitgoNShare,\n  ]);\n  if (\n    userKeyCombined.xShare.y !== backupKeyCombined.xShare.y ||\n    userKeyCombined.xShare.chaincode !== backupKeyCombined.xShare.chaincode\n  ) {\n    throw new Error('Common keychains do not match');\n  }\n  return [userKeyCombined, backupKeyCombined];\n}\n\n// #endregion\n"]}