@bitgo-beta/sdk-core 8.2.1-beta.202 → 8.2.1-beta.2021

package/dist/src/bitgo/utils/tss/eddsa/eddsaMPCv2.js

@@ -0,0 +1,862 @@
+"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.EddsaMPCv2RecoveryFunctions = exports.EddsaMPCv2Utils = void 0;
+exports.isEddsaMpcV1SigningMaterial = isEddsaMpcV1SigningMaterial;
+exports.getEddsaMpcV2RecoveryKeySharesFromReducedKey = getEddsaMpcV2RecoveryKeySharesFromReducedKey;
+exports.signRecoveryEddsaMPCv2 = signRecoveryEddsaMPCv2;
+exports.getEddsaSigningMaterial = getEddsaSigningMaterial;
+exports.isEddsaSigningMaterial = isEddsaSigningMaterial;
+exports.signEddsaMpcV2RecoveryTx = signEddsaMpcV2RecoveryTx;
+const assert_1 = __importDefault(require("assert"));
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const pgp = __importStar(require("openpgp"));
+const io_ts_types_1 = require("io-ts-types");
+const public_types_1 = require("@bitgo/public-types");
+const ed25519_1 = require("@noble/curves/ed25519");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const bitgoPubKeys_1 = require("../../../tss/bitgoPubKeys");
+const common_1 = require("../../../tss/common");
+const codecs_1 = require("../../codecs");
+const eddsaMPCv2_1 = require("../../../tss/eddsa/eddsaMPCv2");
+const eddsa_1 = require("../../../tss/eddsa/eddsa");
+const opengpgUtils_1 = require("../../opengpgUtils");
+const typesMPCv2_1 = require("../ecdsa/typesMPCv2");
+const baseTypes_1 = require("../baseTypes");
+const base_1 = require("./base");
+const recipientUtils_1 = require("../recipientUtils");
+const eddsaMPCv2KeyGenSender_1 = require("./eddsaMPCv2KeyGenSender");
+class EddsaMPCv2Utils extends base_1.BaseEddsaUtils {
+    /** @inheritdoc */
+    async createKeychains(params) {
+        const userKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const userGpgKey = await pgp.readPrivateKey({ armoredKey: userKeyPair.privateKey });
+        const userGpgPublicKey = userKeyPair.publicKey;
+        const [userPk, userSk] = await sdk_lib_mpc_1.MPSComms.extractEd25519KeyPair(userGpgKey);
+        const backupKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const backupGpgKey = await pgp.readPrivateKey({ armoredKey: backupKeyPair.privateKey });
+        const backupGpgPublicKey = backupKeyPair.publicKey;
+        const [backupPk, backupSk] = await sdk_lib_mpc_1.MPSComms.extractEd25519KeyPair(backupGpgKey);
+        // Get the BitGo EdDSA MPCv2 public key (ed25519). Using the default mpcv2PublicKey (secp256k1)
+        // here would cause a WASM "Invalid Input" error, so we require the dedicated eddsaMpcv2PublicKey.
+        const { eddsaMpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);
+        const bitgoPublicGpgKey = eddsaMpcv2PublicKey ?? this.bitgoEddsaMpcv2PublicGpgKey;
+        (0, assert_1.default)(bitgoPublicGpgKey, 'Failed to get BitGo EdDSA MPCv2 GPG public key');
+        const bitgoPublicGpgKeyArmored = bitgoPublicGpgKey.armor();
+        if ((0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+            (0, assert_1.default)((0, bitgoPubKeys_1.isBitgoEddsaMpcv2PubKey)(bitgoPublicGpgKeyArmored), 'Invalid BitGo GPG public key');
+        }
+        const bitgoKeyObj = await pgp.readKey({ armoredKey: bitgoPublicGpgKeyArmored });
+        const bitgoPk = await sdk_lib_mpc_1.MPSComms.extractEd25519PublicKey(bitgoKeyObj);
+        // Create DKG sessions for user (party 0) and backup (party 1)
+        const { userDkg, backupDkg } = await this.getUserAndBackupSession(params.retrofit);
+        // #region round 1
+        await userDkg.initDkg(userSk, [backupPk, bitgoPk]);
+        await backupDkg.initDkg(backupSk, [userPk, bitgoPk]);
+        const userMsg1 = userDkg.getFirstMessage();
+        const backupMsg1 = backupDkg.getFirstMessage();
+        const userSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgKey);
+        const backupSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(backupMsg1.payload), backupGpgKey);
+        (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 { sessionId, bitgoMsg1 } = await this.sendKeyGenerationRound1(params.enterprise, {
+            userGpgPublicKey,
+            backupGpgPublicKey,
+            userMsg1: userSignedMsg1,
+            backupMsg1: backupSignedMsg1,
+            ...(params.retrofit?.walletId ? { walletId: params.retrofit.walletId } : {}),
+        }, params.safeId);
+        // #endregion
+        // #region round 2
+        const bitgoRawMsg1Bytes = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(bitgoMsg1, bitgoKeyObj);
+        const bitgoDeserializedMsg1 = {
+            from: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+            payload: new Uint8Array(bitgoRawMsg1Bytes),
+        };
+        const round1Messages = [userMsg1, backupMsg1, bitgoDeserializedMsg1];
+        const userRound2Msgs = userDkg.handleIncomingMessages(round1Messages);
+        const backupRound2Msgs = backupDkg.handleIncomingMessages(round1Messages);
+        (0, assert_1.default)(userRound2Msgs.length === 1, 'User round 1 should produce exactly one round 2 message');
+        (0, assert_1.default)(backupRound2Msgs.length === 1, 'Backup round 1 should produce exactly one round 2 message');
+        const userMsg2 = userRound2Msgs[0];
+        const backupMsg2 = backupRound2Msgs[0];
+        const userSignedMsg2 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgKey);
+        const backupSignedMsg2 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(backupMsg2.payload), backupGpgKey);
+        const { sessionId: sessionIdRound2, commonPublicKeychain, bitgoMsg2, } = await this.sendKeyGenerationRound2(params.enterprise, {
+            sessionId,
+            userMsg2: userSignedMsg2,
+            backupMsg2: backupSignedMsg2,
+        });
+        // #endregion
+        // #region keychain creation
+        assert_1.default.equal(sessionId, sessionIdRound2, 'Round 1 and round 2 session IDs do not match');
+        const bitgoRawMsg2Bytes = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(bitgoMsg2, bitgoKeyObj);
+        const bitgoDeserializedMsg2 = {
+            from: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+            payload: new Uint8Array(bitgoRawMsg2Bytes),
+        };
+        const round2Messages = [userMsg2, backupMsg2, bitgoDeserializedMsg2];
+        const userFinalMsgs = userDkg.handleIncomingMessages(round2Messages);
+        const backupFinalMsgs = backupDkg.handleIncomingMessages(round2Messages);
+        (0, assert_1.default)(userFinalMsgs.length === 0, 'WASM round 2 should produce no output messages for user');
+        (0, assert_1.default)(backupFinalMsgs.length === 0, 'WASM round 2 should produce no output messages for backup');
+        const userCommonKeychain = userDkg.getCommonKeychain();
+        const backupCommonKeychain = backupDkg.getCommonKeychain();
+        assert_1.default.equal(userCommonKeychain, commonPublicKeychain, 'User computed keychain does not match BitGo common keychain');
+        assert_1.default.equal(backupCommonKeychain, commonPublicKeychain, 'Backup computed keychain does not match BitGo common keychain');
+        const userPrivateMaterial = userDkg.getKeyShare();
+        const backupPrivateMaterial = backupDkg.getKeyShare();
+        const userReducedPrivateMaterial = userDkg.getReducedKeyShare();
+        const backupReducedPrivateMaterial = backupDkg.getReducedKeyShare();
+        const userKeychainPromise = this.addUserKeychain(userCommonKeychain, userPrivateMaterial, userReducedPrivateMaterial, params.passphrase, params.originalPasscodeEncryptionCode, params.webauthnInfo, params.encryptionVersion, params.enterprise, params.safeId);
+        const backupKeychainPromise = this.addBackupKeychain(backupCommonKeychain, backupPrivateMaterial, backupReducedPrivateMaterial, params.passphrase, params.originalPasscodeEncryptionCode, params.encryptionVersion, params.enterprise, params.safeId);
+        const bitgoKeychainPromise = this.addBitgoKeychain(userCommonKeychain, params.safeId);
+        const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([
+            userKeychainPromise,
+            backupKeychainPromise,
+            bitgoKeychainPromise,
+        ]);
+        // #endregion
+        return {
+            userKeychain,
+            backupKeychain,
+            bitgoKeychain,
+        };
+    }
+    async createKeychainsWithExternalSigner(params) {
+        const { enterprise, callbacks } = params;
+        const { eddsaMpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(enterprise, true);
+        const bitgoPublicGpgKey = eddsaMpcv2PublicKey ?? this.bitgoEddsaMpcv2PublicGpgKey;
+        (0, assert_1.default)(bitgoPublicGpgKey, 'Failed to get BitGo EdDSA MPCv2 GPG public key');
+        const bitgoPublicGpgKeyArmored = bitgoPublicGpgKey.armor();
+        if ((0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+            (0, assert_1.default)((0, bitgoPubKeys_1.isBitgoEddsaMpcv2PubKey)(bitgoPublicGpgKeyArmored), 'Invalid BitGo EdDSA MPCv2 GPG public key');
+        }
+        // Round 0: both parties generate GPG keys
+        const { userGpgPublicKey, backupGpgPublicKey, userState, backupState } = await callbacks.initializeCallback({
+            enterprise,
+            bitgoPublicGpgKey: bitgoPublicGpgKeyArmored,
+        });
+        (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');
+        // Round 1: both parties run DKG round 1
+        const { userSignedMsg1, backupSignedMsg1, userState: userStateAfter1, backupState: backupStateAfter1, } = await callbacks.round1Callback({
+            bitgoPublicGpgKey: bitgoPublicGpgKeyArmored,
+            userGpgPublicKey,
+            backupGpgPublicKey,
+            userState,
+            backupState,
+        });
+        const { sessionId, bitgoMsg1 } = await this.sendKeyGenerationRound1(enterprise, {
+            userGpgPublicKey,
+            backupGpgPublicKey,
+            userMsg1: userSignedMsg1,
+            backupMsg1: backupSignedMsg1,
+        });
+        // Round 2: both parties run DKG round 2
+        const { userSignedMsg2, backupSignedMsg2, userState: userStateAfter2, backupState: backupStateAfter2, } = await callbacks.round2Callback({
+            bitgoMsg1,
+            userSignedMsg1,
+            backupSignedMsg1,
+            userState: userStateAfter1,
+            backupState: backupStateAfter1,
+        });
+        const { sessionId: sessionIdRound2, commonPublicKeychain: bitgoCommonKeychain, bitgoMsg2, } = await this.sendKeyGenerationRound2(enterprise, {
+            sessionId,
+            userMsg2: userSignedMsg2,
+            backupMsg2: backupSignedMsg2,
+        });
+        assert_1.default.strictEqual(sessionId, sessionIdRound2, 'Round 1 and round 2 session IDs do not match');
+        // Finalize: both parties verify and derive the common keychain
+        const { commonKeychain } = await callbacks.finalizeCallback({
+            bitgoMsg2,
+            bitgoCommonKeychain,
+            userState: userStateAfter2,
+            backupState: backupStateAfter2,
+        });
+        assert_1.default.strictEqual(commonKeychain, bitgoCommonKeychain, 'Common keychains do not match');
+        const keychains = this.baseCoin.keychains();
+        const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([
+            keychains.add({ source: 'user', keyType: 'tss', commonKeychain, isMPCv2: true, enterprise }),
+            keychains.add({ source: 'backup', keyType: 'tss', commonKeychain, isMPCv2: true, enterprise }),
+            this.addBitgoKeychain(commonKeychain),
+        ]);
+        return { userKeychain, backupKeychain, bitgoKeychain };
+    }
+    // #region keychain utils
+    async createParticipantKeychain(participantIndex, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, webauthnInfo, encryptionVersion, enterprise, safeId) {
+        let source;
+        let encryptedPrv = undefined;
+        let reducedEncryptedPrv = undefined;
+        let privateMaterialBase64 = 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`);
+                privateMaterialBase64 = privateMaterial.toString('base64');
+                encryptedPrv = await this.bitgo.encrypt({
+                    input: privateMaterialBase64,
+                    password: passphrase,
+                    encryptionVersion,
+                });
+                // Encrypts the CBOR-encoded ReducedKeyShare (which contains the party's public
+                // key) with the wallet passphrase. The result is stored as reducedEncryptedPrv
+                // on the key card QR code and represents a second copy of key material
+                // beyond the server-stored encryptedPrv.
+                reducedEncryptedPrv = await 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 separated string of the array values.
+                    input: btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial)))),
+                    password: passphrase,
+                    encryptionVersion,
+                });
+                break;
+            case typesMPCv2_1.MPCv2PartiesEnum.BITGO:
+                source = 'bitgo';
+                break;
+            default:
+                throw new Error('Invalid participant index');
+        }
+        const keychainParams = {
+            source,
+            keyType: 'tss',
+            commonKeychain,
+            encryptedPrv,
+            originalPasscodeEncryptionCode,
+            isMPCv2: true,
+            safeId,
+            enterprise,
+        };
+        if (webauthnInfo && participantIndex === typesMPCv2_1.MPCv2PartiesEnum.USER && privateMaterialBase64) {
+            // Send the passkey as `webauthnInfo`; the deprecated `webauthnDevices` array is ignored by POST /key.
+            (0, assert_1.default)(enterprise, 'enterprise is required to attach a webauthn device to the user keychain');
+            keychainParams.webauthnInfo = {
+                otpDeviceId: webauthnInfo.otpDeviceId,
+                prfSalt: webauthnInfo.prfSalt,
+                encryptedPrv: await this.bitgo.encrypt({
+                    input: privateMaterialBase64,
+                    password: webauthnInfo.passphrase,
+                    encryptionVersion,
+                }),
+                enterpriseId: enterprise,
+            };
+        }
+        const keychains = this.baseCoin.keychains();
+        return { ...(await keychains.add(keychainParams)), reducedEncryptedPrv };
+    }
+    async addUserKeychain(commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, webauthnInfo, encryptionVersion, enterprise, safeId) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.USER, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, webauthnInfo, encryptionVersion, enterprise, safeId);
+    }
+    async addBackupKeychain(commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, encryptionVersion, enterprise, safeId) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, undefined, encryptionVersion, enterprise, safeId);
+    }
+    async addBitgoKeychain(commonKeychain, safeId) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BITGO, commonKeychain, undefined, undefined, undefined, undefined, undefined, undefined, undefined, safeId);
+    }
+    // #endregion
+    async sendKeyGenerationRound1(enterprise, payload, safeId) {
+        return this.sendKeyGenerationRound1BySender((0, eddsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise, safeId), payload);
+    }
+    async sendKeyGenerationRound1BySender(senderFn, payload) {
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1'], payload);
+    }
+    async sendKeyGenerationRound2(enterprise, payload) {
+        return this.sendKeyGenerationRound2BySender((0, eddsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise), payload);
+    }
+    async sendKeyGenerationRound2BySender(senderFn, payload) {
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R2'], payload);
+    }
+    // #endregion
+    // #region sign tx request
+    /**
+     * Signs the transaction associated with 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
+     */
+    async signTxRequest(params) {
+        this.bitgo.setRequestTracer(params.reqId);
+        return this.signRequestBase(params, baseTypes_1.RequestType.tx);
+    }
+    /**
+     * Signs the message associated with 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
+     */
+    async signTxRequestForMessage(params) {
+        this.bitgo.setRequestTracer(params.reqId);
+        return this.signRequestBase(params, baseTypes_1.RequestType.message);
+    }
+    /**
+     * Full 3-round EdDSA MPCv2 (MPS) online signing orchestration.
+     *
+     * Protocol overview:
+     *   WASM Round 0  → getFirstMessage()      (produces userMsg1)
+     *   API  Round 1  → send userMsg1 / recv bitgoMsg1
+     *   WASM Round 1  → handleIncomingMessages([userMsg1, bitgoMsg1])  (produces userMsg2)
+     *   API  Round 2  → send userMsg2 / recv bitgoMsg2
+     *   WASM Round 2  → handleIncomingMessages([userMsg2, bitgoMsg2])  (produces userMsg3)
+     *   API  Round 3  → send userMsg3 (WP finalises; no BitGo msg returned to client)
+     */
+    async signRequestBase(params, requestType) {
+        const userKeyShare = Buffer.from(params.prv, 'base64');
+        const txRequest = typeof params.txRequest === 'string'
+            ? await (0, common_1.getTxRequest)(this.bitgo, this.wallet.id(), params.txRequest, params.reqId)
+            : params.txRequest;
+        let txOrMessageToSign;
+        let derivationPath;
+        let bufferContent;
+        // One fresh ed25519 GPG key pair per signing session, reused across all signing rounds.
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const userGpgPrvKey = await pgp.readPrivateKey({ armoredKey: userGpgKey.privateKey });
+        const bitgoGpgPubKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequest.enterpriseId, true);
+        (0, assert_1.default)(bitgoGpgPubKey, '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];
+            txOrMessageToSign = unsignedTx.signableHex;
+            (0, assert_1.default)(txOrMessageToSign, 'Missing signableHex in unsignedTx');
+            derivationPath = unsignedTx.derivationPath;
+            bufferContent = Buffer.from(txOrMessageToSign, 'hex');
+            await this.baseCoin.verifyTransaction({
+                txPrebuild: { txHex: unsignedTx.serializedTxHex ?? txOrMessageToSign },
+                txParams: (0, recipientUtils_1.resolveEffectiveTxParams)(txRequest, params.txParams, this.baseCoin.getChain()),
+                wallet: this.wallet,
+                walletType: this.wallet.multisigType(),
+            });
+        }
+        else if (requestType === baseTypes_1.RequestType.message) {
+            (0, assert_1.default)(txRequest.messages && txRequest.messages.length > 0, 'Unable to find messages in txRequest');
+            txOrMessageToSign = txRequest.messages[0].messageEncoded;
+            (0, assert_1.default)(txOrMessageToSign, 'Missing messageEncoded in messages[0]');
+            derivationPath = txRequest.messages[0].derivationPath || 'm/0';
+            bufferContent = Buffer.from(txOrMessageToSign, 'hex');
+        }
+        else {
+            throw new Error('Invalid request type');
+        }
+        // ── WASM Round 0 ──────────────────────────────────────────────────────────
+        const partyId = params.mpcv2PartyId ?? typesMPCv2_1.MPCv2PartiesEnum.USER;
+        const signerShareType = partyId === typesMPCv2_1.MPCv2PartiesEnum.USER ? baseTypes_1.SignatureShareType.USER : baseTypes_1.SignatureShareType.BACKUP;
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(partyId);
+        await userDsg.initDsg(userKeyShare, bufferContent, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const userMsg1 = userDsg.getFirstMessage();
+        // ── API Round 1 ───────────────────────────────────────────────────────────
+        const signatureShareRound1 = await (0, eddsaMPCv2_1.getSignatureShareRoundOne)(userMsg1, userGpgPrvKey, partyId);
+        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 after round 1');
+        const signatureShares1 = requestType === baseTypes_1.RequestType.tx
+            ? latestTxRequest.transactions[0].signatureShares
+            : latestTxRequest.messages[0].signatureShares;
+        const bitgoShareRoundOne = (0, common_1.getBitgoSignatureShare)(signatureShares1, signerShareType, 'round1Output');
+        const parsedBitGoToUserSigShareRoundOne = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound1Output, JSON.parse(bitgoShareRoundOne.share), 'Unexpected signature share response. Unable to parse data.');
+        if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const bitgoDeserializedMsg1 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundOne)(parsedBitGoToUserSigShareRoundOne, bitgoGpgPubKey);
+        // ── WASM Round 1 ──────────────────────────────────────────────────────────
+        const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);
+        (0, assert_1.default)(userMsg2, 'WASM round 1 produced no message');
+        // ── API Round 2 ───────────────────────────────────────────────────────────
+        const signatureShareRoundTwo = await (0, eddsaMPCv2_1.getSignatureShareRoundTwo)(userMsg2, userGpgPrvKey, partyId);
+        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 after round 2');
+        const txRequestSignatureShares = requestType === baseTypes_1.RequestType.tx
+            ? latestTxRequest.transactions[0].signatureShares
+            : latestTxRequest.messages[0].signatureShares;
+        const bitgoShareRoundTwo = (0, common_1.getBitgoSignatureShare)(txRequestSignatureShares, signerShareType, 'round2Output');
+        const parsedBitGoToUserSigShareRoundTwo = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound2Output, JSON.parse(bitgoShareRoundTwo.share), 'Unexpected signature share response. Unable to parse data.');
+        if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const bitgoDeserializedMsg2 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundTwo)(parsedBitGoToUserSigShareRoundTwo, bitgoGpgPubKey);
+        // ── WASM Round 2 ──────────────────────────────────────────────────────────
+        const [userMsg3] = userDsg.handleIncomingMessages([userMsg2, bitgoDeserializedMsg2]);
+        (0, assert_1.default)(userMsg3, 'WASM round 2 produced no message');
+        // ── API Round 3 ───────────────────────────────────────────────────────────
+        // No BitGo response to verify; WP finalises the signing server-side
+        const signatureShareRound3 = await (0, eddsaMPCv2_1.getSignatureShareRoundThree)(userMsg3, userGpgPrvKey, partyId);
+        const round3TxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequest.walletId, txRequest.txRequestId, [signatureShareRound3], requestType, this.baseCoin.getMPCAlgorithm(), userGpgKey.publicKey, undefined, this.wallet.multisigTypeVersion(), params.reqId);
+        (0, assert_1.default)(round3TxRequest?.txRequestId === txRequest.txRequestId, 'Invalid txRequest object after round 3');
+        return (0, common_1.sendTxRequest)(this.bitgo, txRequest.walletId, txRequest.txRequestId, requestType, params.reqId);
+    }
+    // #endregion
+    // #region external signer
+    // #region KeyGenRound1Share
+    async createOfflineKeyGenRound1Share(params) {
+        const { walletPassphrase, encryptedUserGpgPrvKey, bitgoGpgPubKey, counterPartyGpgPubKey } = params;
+        const partyId = params.partyId ?? typesMPCv2_1.MPCv2PartiesEnum.USER;
+        const decryptedGpgPrvKey = await this.bitgo.decrypt({ input: encryptedUserGpgPrvKey, password: walletPassphrase });
+        const gpgPrvKey = await pgp.readPrivateKey({ armoredKey: decryptedGpgPrvKey });
+        const [, ownSk] = await sdk_lib_mpc_1.MPSComms.extractEd25519KeyPair(gpgPrvKey);
+        if ((0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+            (0, assert_1.default)((0, bitgoPubKeys_1.isBitgoEddsaMpcv2PubKey)(bitgoGpgPubKey), 'Invalid BitGo GPG public key');
+        }
+        const bitgoKeyObj = await pgp.readKey({ armoredKey: bitgoGpgPubKey });
+        const bitgoPk = await sdk_lib_mpc_1.MPSComms.extractEd25519PublicKey(bitgoKeyObj);
+        const counterPartyKeyObj = await pgp.readKey({ armoredKey: counterPartyGpgPubKey });
+        const counterPartyPk = await sdk_lib_mpc_1.MPSComms.extractEd25519PublicKey(counterPartyKeyObj);
+        const dkg = new sdk_lib_mpc_1.EddsaMPSDkg.DKG(3, 2, partyId);
+        await dkg.initDkg(ownSk, [counterPartyPk, bitgoPk]);
+        const msg1 = dkg.getFirstMessage();
+        const signedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(msg1.payload), gpgPrvKey);
+        const sessionPayload = JSON.stringify({
+            dkgSession: dkg.getSession(),
+            ownMsgPayload: Buffer.from(msg1.payload).toString('base64'),
+            ownMsgFrom: msg1.from,
+        });
+        const encryptedRound1Session = await this.bitgo.encrypt({
+            input: sessionPayload,
+            password: walletPassphrase,
+            adata: `${EddsaMPCv2Utils.MPS_DKG_KEYGEN_ROUND1_STATE}:${partyId}`,
+            encryptionVersion: 1,
+        });
+        return { signedMsg1, encryptedRound1Session };
+    }
+    // #endregion
+    // #region Round1Share
+    async createOfflineRound1Share(params) {
+        const { prv, walletPassphrase, txRequest, encryptedPrv } = params;
+        const { signableHex, derivationPath } = this.getSignableHexAndDerivationPath(txRequest, 'Unable to find transactions in txRequest');
+        const adata = `${signableHex}:${derivationPath}`;
+        const userKeyShare = Buffer.from(prv, 'base64');
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const userGpgPrvKey = await pgp.readPrivateKey({ armoredKey: userGpgKey.privateKey });
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await userDsg.initDsg(userKeyShare, Buffer.from(signableHex, 'hex'), derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const userMsg1 = userDsg.getFirstMessage();
+        const signatureShareRound1 = await (0, eddsaMPCv2_1.getSignatureShareRoundOne)(userMsg1, userGpgPrvKey);
+        const sessionPayload = JSON.stringify({
+            dsgSession: userDsg.getSession(),
+            userMsgPayload: Buffer.from(userMsg1.payload).toString('base64'),
+        });
+        const userGpgPubKey = userGpgKey.publicKey;
+        const useV2 = encryptedPrv !== undefined && (0, baseTypes_1.isV2Envelope)(encryptedPrv);
+        if (useV2) {
+            const session = await this.bitgo.createEncryptionSession(walletPassphrase);
+            try {
+                const encryptedRound1Session = await session.encrypt(sessionPayload, `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND1_STATE}:${adata}`);
+                const encryptedUserGpgPrvKey = await session.encrypt(userGpgKey.privateKey, `${EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY}:${adata}`);
+                return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };
+            }
+            finally {
+                session.destroy();
+            }
+        }
+        const encryptedRound1Session = await this.bitgo.encrypt({
+            input: sessionPayload,
+            password: walletPassphrase,
+            adata: `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND1_STATE}:${adata}`,
+            encryptionVersion: 1,
+        });
+        const encryptedUserGpgPrvKey = await this.bitgo.encrypt({
+            input: userGpgKey.privateKey,
+            password: walletPassphrase,
+            adata: `${EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY}:${adata}`,
+            encryptionVersion: 1,
+        });
+        return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };
+    }
+    // #endregion
+    // #region Round2Share
+    async createOfflineRound2Share(params) {
+        const { walletPassphrase, encryptedUserGpgPrvKey, encryptedRound1Session, bitgoPublicGpgKey, txRequest } = params;
+        const { signableHex, derivationPath } = this.getSignableHexAndDerivationPath(txRequest, 'Unable to find transactions in txRequest');
+        const adata = `${signableHex}:${derivationPath}`;
+        const useV2 = (0, baseTypes_1.isV2Envelope)(encryptedRound1Session);
+        const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase, adata, EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY);
+        const transactions = txRequest.transactions;
+        (0, assert_1.default)(Array.isArray(transactions) && transactions.length === 1, 'txRequest must have exactly one transaction');
+        const signatureShares = transactions[0].signatureShares;
+        (0, assert_1.default)(signatureShares, 'Missing signature shares in round 1 txRequest');
+        const bitgoShareRoundOne = (0, common_1.getBitgoSignatureShare)(signatureShares, baseTypes_1.SignatureShareType.USER, 'round1Output');
+        const parsedBitGoToUserSigShareRoundOne = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound1Output, JSON.parse(bitgoShareRoundOne.share), 'Unexpected signature share response. Unable to parse data.');
+        if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const bitgoDeserializedMsg1 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundOne)(parsedBitGoToUserSigShareRoundOne, bitgoGpgKey);
+        this.validateAdata(adata, encryptedRound1Session, EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND1_STATE);
+        const decryptedRound1Session = await this.bitgo.decrypt({
+            input: encryptedRound1Session,
+            password: walletPassphrase,
+        });
+        const { dsgSession, userMsgPayload } = JSON.parse(decryptedRound1Session);
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await userDsg.restoreSession(dsgSession);
+        const userMsg1 = {
+            from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+            payload: new Uint8Array(Buffer.from(userMsgPayload, 'base64')),
+        };
+        const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);
+        (0, assert_1.default)(userMsg2, 'DSG handleIncomingMessages produced no round-2 output');
+        const signatureShareRound2 = await (0, eddsaMPCv2_1.getSignatureShareRoundTwo)(userMsg2, userGpgPrvKey);
+        const sessionPayload = JSON.stringify({
+            dsgSession: userDsg.getSession(),
+            userMsgPayload: Buffer.from(userMsg2.payload).toString('base64'),
+        });
+        if (useV2) {
+            const session = await this.bitgo.createEncryptionSession(walletPassphrase);
+            try {
+                const encryptedRound2Session = await session.encrypt(sessionPayload, `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND2_STATE}:${adata}`);
+                return { signatureShareRound2, encryptedRound2Session };
+            }
+            finally {
+                session.destroy();
+            }
+        }
+        const encryptedRound2Session = await this.bitgo.encrypt({
+            input: sessionPayload,
+            password: walletPassphrase,
+            adata: `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND2_STATE}:${adata}`,
+            encryptionVersion: 1,
+        });
+        return { signatureShareRound2, encryptedRound2Session };
+    }
+    // #endregion
+    // #region Round3Share
+    async createOfflineRound3Share(params) {
+        const { walletPassphrase, encryptedUserGpgPrvKey, encryptedRound2Session, bitgoPublicGpgKey, txRequest } = params;
+        const { signableHex, derivationPath } = this.getSignableHexAndDerivationPath(txRequest, 'Unable to find transactions in txRequest');
+        const adata = `${signableHex}:${derivationPath}`;
+        const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase, adata, EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY);
+        const transactions = txRequest.transactions;
+        (0, assert_1.default)(Array.isArray(transactions) && transactions.length === 1, 'txRequest must have exactly one transaction');
+        const signatureShares = transactions[0].signatureShares;
+        (0, assert_1.default)(signatureShares, 'Missing signature shares in round 2 txRequest');
+        const bitgoShareRoundTwo = (0, common_1.getBitgoSignatureShare)(signatureShares, baseTypes_1.SignatureShareType.USER, 'round2Output');
+        const parsedBitGoToUserSigShareRoundTwo = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound2Output, JSON.parse(bitgoShareRoundTwo.share), 'Unexpected signature share response. Unable to parse data.');
+        if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const bitgoDeserializedMsg2 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundTwo)(parsedBitGoToUserSigShareRoundTwo, bitgoGpgKey);
+        this.validateAdata(adata, encryptedRound2Session, EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND2_STATE);
+        const decryptedRound2Session = await this.bitgo.decrypt({
+            input: encryptedRound2Session,
+            password: walletPassphrase,
+        });
+        const { dsgSession, userMsgPayload } = JSON.parse(decryptedRound2Session);
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await userDsg.restoreSession(dsgSession);
+        const userMsg2 = {
+            from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+            payload: new Uint8Array(Buffer.from(userMsgPayload, 'base64')),
+        };
+        const [userMsg3] = userDsg.handleIncomingMessages([userMsg2, bitgoDeserializedMsg2]);
+        (0, assert_1.default)(userMsg3, 'DSG handleIncomingMessages produced no round-3 output');
+        const signatureShareRound3 = await (0, eddsaMPCv2_1.getSignatureShareRoundThree)(userMsg3, userGpgPrvKey);
+        return { signatureShareRound3 };
+    }
+    // #endregion
+    /** @inheritdoc */
+    async signEddsaMPCv2TssUsingExternalSigner(params, externalSignerEddsaMPCv2SigningRound1Generator, externalSignerEddsaMPCv2SigningRound2Generator, externalSignerEddsaMPCv2SigningRound3Generator, requestType = baseTypes_1.RequestType.tx) {
+        const { txRequest, reqId } = params;
+        // 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);
+        let txRequestResolved;
+        if (typeof txRequest === 'string') {
+            txRequestResolved = await (0, common_1.getTxRequest)(this.bitgo, this.wallet.id(), txRequest, reqId);
+        }
+        else {
+            txRequestResolved = txRequest;
+        }
+        const bitgoPublicGpgKey = await this.pickBitgoPubGpgKeyForSigning(true, reqId, txRequestResolved.enterpriseId, true);
+        if (!bitgoPublicGpgKey) {
+            throw new Error('Missing BitGo GPG key for MPCv2');
+        }
+        // round 1
+        const { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey } = await externalSignerEddsaMPCv2SigningRound1Generator({ 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 externalSignerEddsaMPCv2SigningRound2Generator({
+            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 externalSignerEddsaMPCv2SigningRound3Generator({
+            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);
+    }
+    // #endregion
+    // #region retrofit
+    async getUserAndBackupSession(retrofit) {
+        if (retrofit) {
+            const { userRetrofitData, backupRetrofitData } = await this.getMpcV2RetrofitDataFromMpcV1Keys({
+                mpcv1UserKeyShare: retrofit.decryptedUserKey,
+                mpcv1BackupKeyShare: retrofit.decryptedBackupKey,
+            });
+            return {
+                userDkg: new sdk_lib_mpc_1.EddsaMPSDkg.DKG(3, 2, typesMPCv2_1.MPCv2PartiesEnum.USER, userRetrofitData),
+                backupDkg: new sdk_lib_mpc_1.EddsaMPSDkg.DKG(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BACKUP, backupRetrofitData),
+            };
+        }
+        return {
+            userDkg: new sdk_lib_mpc_1.EddsaMPSDkg.DKG(3, 2, typesMPCv2_1.MPCv2PartiesEnum.USER),
+            backupDkg: new sdk_lib_mpc_1.EddsaMPSDkg.DKG(3, 2, typesMPCv2_1.MPCv2PartiesEnum.BACKUP),
+        };
+    }
+    async getMpcV2RetrofitDataFromMpcV1Keys(params) {
+        const MPC = await (0, eddsa_1.getInitializedMpcInstance)();
+        const userRetrofitData = EddsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key(params.mpcv1UserKeyShare, typesMPCv2_1.MPCv2PartiesEnum.USER, MPC);
+        const backupRetrofitData = EddsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key(params.mpcv1BackupKeyShare, typesMPCv2_1.MPCv2PartiesEnum.BACKUP, MPC);
+        (0, assert_1.default)(userRetrofitData.expectedPk === backupRetrofitData.expectedPk, 'MPCv1 user and backup keys combine to different aggregate public keys');
+        (0, assert_1.default)(userRetrofitData.chainCode === backupRetrofitData.chainCode, 'MPCv1 user and backup keys combine to different chain codes');
+        return { userRetrofitData, backupRetrofitData };
+    }
+    static getMpcV2RetrofitDataFromMpcV1Key(mpcv1PartyKeyShare, mpcv1PartyIndex, mpc) {
+        const signingMaterial = JSON.parse(mpcv1PartyKeyShare);
+        (0, assert_1.default)(signingMaterial.uShare, 'MPCv1 key material missing uShare');
+        (0, assert_1.default)(signingMaterial.bitgoYShare, 'MPCv1 key material missing bitgoYShare');
+        let pShare;
+        switch (mpcv1PartyIndex) {
+            case typesMPCv2_1.MPCv2PartiesEnum.USER:
+                (0, assert_1.default)(signingMaterial.backupYShare, 'User MPCv1 key material missing backupYShare');
+                pShare = mpc.keyCombine(signingMaterial.uShare, [
+                    signingMaterial.bitgoYShare,
+                    signingMaterial.backupYShare,
+                ]).pShare;
+                break;
+            case typesMPCv2_1.MPCv2PartiesEnum.BACKUP:
+                (0, assert_1.default)(signingMaterial.userYShare, 'Backup MPCv1 key material missing userYShare');
+                pShare = mpc.keyCombine(signingMaterial.uShare, [
+                    signingMaterial.bitgoYShare,
+                    signingMaterial.userYShare,
+                ]).pShare;
+                break;
+            default:
+                throw new Error('Invalid participant index');
+        }
+        return {
+            s_i_0: pShare.u,
+            expectedPk: pShare.y,
+            chainCode: pShare.chaincode,
+        };
+    }
+}
+exports.EddsaMPCv2Utils = EddsaMPCv2Utils;
+EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY = 'MPS_DSG_SIGNING_USER_GPG_KEY';
+EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND1_STATE = 'MPS_DSG_SIGNING_ROUND1_STATE';
+EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND2_STATE = 'MPS_DSG_SIGNING_ROUND2_STATE';
+EddsaMPCv2Utils.MPS_DKG_KEYGEN_ROUND1_STATE = 'MPS_DKG_KEYGEN_ROUND1_STATE';
+/**
+ * Detect whether an encrypted keycard contains MPCv1 signing material.
+ *
+ * Decrypts the keycard and checks for the JSON shape produced by the MPCv1 TSS
+ * key-generation flow (uShare.seed + bitgoYShare.u + backupYShare.u / userYShare.u).
+ * Returns false for MPCv2 CBOR keycards, wrong passwords, or any decryption error.
+ *
+ * @param encryptedKeyShare encrypted user or backup keycard
+ * @param walletPassphrase passphrase used to encrypt the keycard
+ * @param bitgo optional BitGoBase instance; when provided, decrypts via
+ *   bitgo.decrypt (supports both v1 SJCL and v2 Argon2id envelopes);
+ *   when absent, falls back to sjcl.decrypt (v1 only)
+ */
+function parseEddsaMpcV1Material(decrypted) {
+    try {
+        const m = JSON.parse(decrypted);
+        if (typeof m?.uShare?.seed === 'string' &&
+            typeof m?.bitgoYShare?.u === 'string' &&
+            (typeof m?.backupYShare?.u === 'string' || typeof m?.userYShare?.u === 'string')) {
+            return decrypted;
+        }
+    }
+    catch {
+        // Not JSON → MPCv2 CBOR
+    }
+    return null;
+}
+async function isEddsaMpcV1SigningMaterial(encryptedKeyShare, walletPassphrase, bitgo) {
+    const decrypted = bitgo
+        ? await bitgo.decrypt({ input: encryptedKeyShare, password: walletPassphrase })
+        : sjcl.decrypt(walletPassphrase, encryptedKeyShare);
+    return parseEddsaMpcV1Material(decrypted) !== null;
+}
+/**
+ * Get EdDSA MPCv2 recovery key shares from encrypted reduced user and backup keys.
+ *
+ * The encrypted inputs are the `reducedEncryptedPrv` values stored on EdDSA MPCv2
+ * key cards. They decrypt to CBOR-encoded reduced shares that contain the opaque
+ * MPS signing key-share bytes plus the common public keychain material.
+ *
+ * @param encryptedUserKey encrypted EdDSA MPCv2 reduced user key
+ * @param encryptedBackupKey encrypted EdDSA MPCv2 reduced backup key
+ * @param walletPassphrase password for user and backup keys
+ * @returns EdDSA MPCv2 recovery key shares and common keychain
+ */
+async function getEddsaMpcV2RecoveryKeySharesFromReducedKey(encryptedUserKey, encryptedBackupKey, walletPassphrase, bitgo) {
+    const decodeKey = async (encryptedKey) => {
+        const decrypted = bitgo
+            ? await bitgo.decrypt({ input: encryptedKey, password: walletPassphrase })
+            : sjcl.decrypt(walletPassphrase, encryptedKey);
+        let reduced;
+        try {
+            reduced = sdk_lib_mpc_1.MPSTypes.getDecodedReducedKeyShare(Buffer.from(decrypted, 'base64'));
+        }
+        catch {
+            throw new Error('EdDSA MPCv2 recovery: unable to decode reduced key share from keycard material. The encrypted key may be corrupted, malformed, or not an EdDSA MPCv2 reduced key.');
+        }
+        if (!reduced.keyShare?.length || !reduced.pub?.length || !reduced.rootChainCode?.length) {
+            throw new Error('EdDSA MPCv2 recovery: reduced key share is missing keyShare, pub, or rootChainCode. This keycard may be public-only and cannot be used for recovery.');
+        }
+        return reduced;
+    };
+    const [userReduced, backupReduced] = await Promise.all([decodeKey(encryptedUserKey), decodeKey(encryptedBackupKey)]);
+    const userPub = Buffer.from(userReduced.pub).toString('hex');
+    const backupPub = Buffer.from(backupReduced.pub).toString('hex');
+    if (userPub !== backupPub) {
+        throw new Error('EdDSA MPCv2 recovery: user and backup pub keys do not match');
+    }
+    const userChainCode = Buffer.from(userReduced.rootChainCode).toString('hex');
+    const backupChainCode = Buffer.from(backupReduced.rootChainCode).toString('hex');
+    if (userChainCode !== backupChainCode) {
+        throw new Error('EdDSA MPCv2 recovery: user and backup rootChainCodes do not match');
+    }
+    return {
+        userKeyShare: Buffer.from(userReduced.keyShare),
+        backupKeyShare: Buffer.from(backupReduced.keyShare),
+        commonKeyChain: userPub + userChainCode,
+    };
+}
+/**
+ * Sign a message for recovery using EdDSA MPCv2 (MPS) with user and backup key shares.
+ *
+ * Runs the MPS DSG protocol locally to round 3, then verifies the resulting
+ * Ed25519 signature against the public key derived from the common keychain.
+ *
+ * @param message raw bytes to sign
+ * @param derivationPath BIP-32-style derivation path, e.g. `"m/0"`
+ * @param userKeyShare opaque MPS signing key-share bytes for the user party
+ * @param backupKeyShare opaque MPS signing key-share bytes for the backup party
+ * @param commonKeyChain 128-hex-char string: 32-byte pub + 32-byte rootChainCode
+ * @returns 64-byte Ed25519 signature Buffer
+ */
+async function signRecoveryEddsaMPCv2(message, derivationPath, userKeyShare, backupKeyShare, commonKeyChain) {
+    const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+    const backupDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+    const signature = (await sdk_lib_mpc_1.MPSUtil.executeTillRound(3, userDsg, backupDsg, userKeyShare, backupKeyShare, message, derivationPath));
+    // Use Eddsa.deriveUnhardened (BIP32-Ed25519), which matches what DSG uses
+    // internally for path derivation since wasm-mps 1.9.0.
+    const mpc = await (0, eddsa_1.getInitializedMpcInstance)();
+    const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);
+    const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');
+    const verified = ed25519_1.ed25519.verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKeyBytes));
+    if (!verified) {
+        throw new Error('EdDSA MPCv2 recovery signature verification failed');
+    }
+    return signature;
+}
+/**
+ * Detects MPCv1 vs MPCv2 keycard format and returns typed signing material.
+ * For v1: decrypts once and returns the plaintext as userPrv.
+ * For v2: returns the encrypted key as-is for use with signEddsaMpcV2RecoveryTx.
+ * When bitgo is omitted, falls back to sjcl (v1 only).
+ */
+async function getEddsaSigningMaterial(userKey, walletPassphrase, bitgo) {
+    const normalized = userKey.replace(/\s/g, '');
+    let decrypted;
+    try {
+        decrypted = bitgo
+            ? await bitgo.decrypt({ input: normalized, password: walletPassphrase })
+            : sjcl.decrypt(walletPassphrase, normalized);
+    }
+    catch (e) {
+        throw new Error(`Error decrypting user keychain: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const userPrv = parseEddsaMpcV1Material(decrypted);
+    return userPrv !== null ? { version: 'v1', userPrv } : { version: 'v2', encryptedUserKey: normalized };
+}
+/**
+ * Type guard validating that a value has the shape of EddsaSigningMaterial.
+ *
+ * Coin `recover()` implementations accept an optional precomputed signing-material
+ * parameter (set by recoverConsolidations() to avoid re-decrypting the keycard per
+ * scanned index). Some callers pass an unrelated second positional argument to
+ * recover() for other purposes (e.g. openSSLBytes for EVM-like coins); validating
+ * the shape here prevents that from being misinterpreted as signing material.
+ */
+function isEddsaSigningMaterial(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (!('version' in value)) {
+        return false;
+    }
+    if (value.version === 'v1') {
+        return 'userPrv' in value && typeof value.userPrv === 'string';
+    }
+    if (value.version === 'v2') {
+        return 'encryptedUserKey' in value && typeof value.encryptedUserKey === 'string';
+    }
+    return false;
+}
+/**
+ * Full MPCv2 recovery signing flow: decrypt key shares → validate commonKeyChain → MPS DSG.
+ * Returns raw 64-byte Ed25519 signature Buffer.
+ * Caller is responsible for any coin-specific envelope
+ * (e.g. 0x00 Substrate prefix, SUI flag+pubkey wrapper, or raw for NEAR/ADA/TON).
+ */
+async function signEddsaMpcV2RecoveryTx(params) {
+    const { userKeyShare, backupKeyShare, commonKeyChain } = await getEddsaMpcV2RecoveryKeySharesFromReducedKey(params.userKey, params.backupKey, params.walletPassphrase, params.bitgo);
+    if (commonKeyChain.toLowerCase() !== params.bitgoKey.toLowerCase()) {
+        throw new Error('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');
+    }
+    return signRecoveryEddsaMPCv2(params.message, params.derivationPath, userKeyShare, backupKeyShare, commonKeyChain);
+}
+exports.EddsaMPCv2RecoveryFunctions = {
+    isEddsaMpcV1SigningMaterial,
+    getEddsaMpcV2RecoveryKeySharesFromReducedKey,
+    signRecoveryEddsaMPCv2,
+    getEddsaSigningMaterial,
+    isEddsaSigningMaterial,
+    signEddsaMpcV2RecoveryTx,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eddsaMPCv2.js","sourceRoot":"","sources":["../../../../../../src/bitgo/utils/tss/eddsa/eddsaMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport * as pgp from 'openpgp';\nimport { NonEmptyString } from 'io-ts-types';\nimport {\n  EddsaMPCv2KeyGenRound1Request,\n  EddsaMPCv2KeyGenRound1Response,\n  EddsaMPCv2KeyGenRound2Request,\n  EddsaMPCv2KeyGenRound2Response,\n  EddsaMPCv2SignatureShareRound1Output,\n  EddsaMPCv2SignatureShareRound2Output,\n  MPCv2KeyGenStateEnum,\n  MPCv2PartyFromStringOrNumber,\n} from '@bitgo/public-types';\nimport { EddsaMPCv2KeyGenCallbacks } from '../../../wallet/iWallets';\nimport { ed25519 } from '@noble/curves/ed25519';\nimport { EddsaMPSDkg, EddsaMPSDsg, MPSComms, MPSTypes, MPSUtil } from '@bitgo-beta/sdk-lib-mpc';\nimport { KeychainsTriplet } from '../../../baseCoin';\nimport {\n  AddKeychainOptions,\n  DecryptedRetrofitPayload,\n  Keychain,\n  KeyType,\n  WebauthnKeyEncryptionInfo,\n} from '../../../keychain';\nimport { envRequiresBitgoPubGpgKeyConfig, isBitgoEddsaMpcv2PubKey } from '../../../tss/bitgoPubKeys';\nimport { getBitgoSignatureShare, getTxRequest, sendSignatureShareV2, sendTxRequest } from '../../../tss/common';\nimport { decodeWithCodec } from '../../codecs';\nimport {\n  getSignatureShareRoundOne,\n  getSignatureShareRoundTwo,\n  getSignatureShareRoundThree,\n  verifyPeerMessageRoundOne,\n  verifyPeerMessageRoundTwo,\n} from '../../../tss/eddsa/eddsaMPCv2';\nimport { getInitializedMpcInstance } from '../../../tss/eddsa/eddsa';\nimport { generateGPGKeyPair } from '../../opengpgUtils';\nimport { MPCv2PartiesEnum } from '../ecdsa/typesMPCv2';\nimport {\n  CustomEddsaMPCv2SigningRound1GeneratingFunction,\n  CustomEddsaMPCv2SigningRound2GeneratingFunction,\n  CustomEddsaMPCv2SigningRound3GeneratingFunction,\n  RequestType,\n  SignatureShareRecord,\n  SignatureShareType,\n  TSSParams,\n  TSSParamsForMessage,\n  TSSParamsForMessageWithPrv,\n  TSSParamsWithPrv,\n  TxRequest,\n  isV2Envelope,\n} from '../baseTypes';\nimport { EncryptionVersion } from '../../../../api';\nimport { BitGoBase } from '../../../bitgoBase';\nimport { BaseEddsaUtils } from './base';\nimport { resolveEffectiveTxParams } from '../recipientUtils';\nimport { EddsaMPCv2KeyGenSendFn, KeyGenSenderForEnterprise } from './eddsaMPCv2KeyGenSender';\nimport { EddsaMPCv2RecoveryKeyShares } from './types';\nimport { SigningMaterial } from '../../../tss';\n\nexport class EddsaMPCv2Utils extends BaseEddsaUtils {\n  private static readonly MPS_DSG_SIGNING_USER_GPG_KEY = 'MPS_DSG_SIGNING_USER_GPG_KEY';\n  private static readonly MPS_DSG_SIGNING_ROUND1_STATE = 'MPS_DSG_SIGNING_ROUND1_STATE';\n  private static readonly MPS_DSG_SIGNING_ROUND2_STATE = 'MPS_DSG_SIGNING_ROUND2_STATE';\n  private static readonly MPS_DKG_KEYGEN_ROUND1_STATE = 'MPS_DKG_KEYGEN_ROUND1_STATE';\n\n  /** @inheritdoc */\n  async createKeychains(params: {\n    passphrase: string;\n    enterprise: string;\n    originalPasscodeEncryptionCode?: string;\n    retrofit?: DecryptedRetrofitPayload;\n    webauthnInfo?: WebauthnKeyEncryptionInfo;\n    encryptionVersion?: EncryptionVersion;\n    // Wallet Safes v1 (@experimental): tags the resulting user/backup/bitgo root keys with this safe.\n    safeId?: string;\n  }): Promise<KeychainsTriplet> {\n    const userKeyPair = await generateGPGKeyPair('ed25519');\n    const userGpgKey = await pgp.readPrivateKey({ armoredKey: userKeyPair.privateKey });\n    const userGpgPublicKey = userKeyPair.publicKey;\n    const [userPk, userSk] = await MPSComms.extractEd25519KeyPair(userGpgKey);\n\n    const backupKeyPair = await generateGPGKeyPair('ed25519');\n    const backupGpgKey = await pgp.readPrivateKey({ armoredKey: backupKeyPair.privateKey });\n    const backupGpgPublicKey = backupKeyPair.publicKey;\n    const [backupPk, backupSk] = await MPSComms.extractEd25519KeyPair(backupGpgKey);\n\n    // Get the BitGo EdDSA MPCv2 public key (ed25519). Using the default mpcv2PublicKey (secp256k1)\n    // here would cause a WASM \"Invalid Input\" error, so we require the dedicated eddsaMpcv2PublicKey.\n    const { eddsaMpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);\n    const bitgoPublicGpgKey = eddsaMpcv2PublicKey ?? this.bitgoEddsaMpcv2PublicGpgKey;\n    assert(bitgoPublicGpgKey, 'Failed to get BitGo EdDSA MPCv2 GPG public key');\n    const bitgoPublicGpgKeyArmored = bitgoPublicGpgKey.armor();\n\n    if (envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n      assert(isBitgoEddsaMpcv2PubKey(bitgoPublicGpgKeyArmored), 'Invalid BitGo GPG public key');\n    }\n\n    const bitgoKeyObj = await pgp.readKey({ armoredKey: bitgoPublicGpgKeyArmored });\n    const bitgoPk = await MPSComms.extractEd25519PublicKey(bitgoKeyObj);\n\n    // Create DKG sessions for user (party 0) and backup (party 1)\n    const { userDkg, backupDkg } = await this.getUserAndBackupSession(params.retrofit);\n\n    // #region round 1\n    await userDkg.initDkg(userSk, [backupPk, bitgoPk]);\n    await backupDkg.initDkg(backupSk, [userPk, bitgoPk]);\n\n    const userMsg1 = userDkg.getFirstMessage();\n    const backupMsg1 = backupDkg.getFirstMessage();\n\n    const userSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgKey);\n    const backupSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(backupMsg1.payload), backupGpgKey);\n\n    assert(NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');\n    assert(NonEmptyString.is(backupGpgPublicKey), 'Backup GPG public key is required');\n\n    const { sessionId, bitgoMsg1 } = await this.sendKeyGenerationRound1(\n      params.enterprise,\n      {\n        userGpgPublicKey,\n        backupGpgPublicKey,\n        userMsg1: userSignedMsg1,\n        backupMsg1: backupSignedMsg1,\n        ...(params.retrofit?.walletId ? { walletId: params.retrofit.walletId } : {}),\n      },\n      params.safeId\n    );\n    // #endregion\n\n    // #region round 2\n    const bitgoRawMsg1Bytes = await MPSComms.verifyMpsMessage(bitgoMsg1, bitgoKeyObj);\n    const bitgoDeserializedMsg1: MPSTypes.DeserializedMessage = {\n      from: MPCv2PartiesEnum.BITGO,\n      payload: new Uint8Array(bitgoRawMsg1Bytes),\n    };\n\n    const round1Messages: MPSTypes.DeserializedMessages = [userMsg1, backupMsg1, bitgoDeserializedMsg1];\n\n    const userRound2Msgs = userDkg.handleIncomingMessages(round1Messages);\n    const backupRound2Msgs = backupDkg.handleIncomingMessages(round1Messages);\n\n    assert(userRound2Msgs.length === 1, 'User round 1 should produce exactly one round 2 message');\n    assert(backupRound2Msgs.length === 1, 'Backup round 1 should produce exactly one round 2 message');\n\n    const userMsg2 = userRound2Msgs[0];\n    const backupMsg2 = backupRound2Msgs[0];\n\n    const userSignedMsg2 = await MPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgKey);\n    const backupSignedMsg2 = await MPSComms.detachSignMpsMessage(Buffer.from(backupMsg2.payload), backupGpgKey);\n\n    const {\n      sessionId: sessionIdRound2,\n      commonPublicKeychain,\n      bitgoMsg2,\n    } = await this.sendKeyGenerationRound2(params.enterprise, {\n      sessionId,\n      userMsg2: userSignedMsg2,\n      backupMsg2: backupSignedMsg2,\n    });\n    // #endregion\n\n    // #region keychain creation\n    assert.equal(sessionId, sessionIdRound2, 'Round 1 and round 2 session IDs do not match');\n\n    const bitgoRawMsg2Bytes = await MPSComms.verifyMpsMessage(bitgoMsg2, bitgoKeyObj);\n    const bitgoDeserializedMsg2: MPSTypes.DeserializedMessage = {\n      from: MPCv2PartiesEnum.BITGO,\n      payload: new Uint8Array(bitgoRawMsg2Bytes),\n    };\n\n    const round2Messages: MPSTypes.DeserializedMessages = [userMsg2, backupMsg2, bitgoDeserializedMsg2];\n\n    const userFinalMsgs = userDkg.handleIncomingMessages(round2Messages);\n    const backupFinalMsgs = backupDkg.handleIncomingMessages(round2Messages);\n\n    assert(userFinalMsgs.length === 0, 'WASM round 2 should produce no output messages for user');\n    assert(backupFinalMsgs.length === 0, 'WASM round 2 should produce no output messages for backup');\n\n    const userCommonKeychain = userDkg.getCommonKeychain();\n    const backupCommonKeychain = backupDkg.getCommonKeychain();\n\n    assert.equal(\n      userCommonKeychain,\n      commonPublicKeychain,\n      'User computed keychain does not match BitGo common keychain'\n    );\n    assert.equal(\n      backupCommonKeychain,\n      commonPublicKeychain,\n      'Backup computed keychain does not match BitGo common keychain'\n    );\n\n    const userPrivateMaterial = userDkg.getKeyShare();\n    const backupPrivateMaterial = backupDkg.getKeyShare();\n    const userReducedPrivateMaterial = userDkg.getReducedKeyShare();\n    const backupReducedPrivateMaterial = backupDkg.getReducedKeyShare();\n\n    const userKeychainPromise = this.addUserKeychain(\n      userCommonKeychain,\n      userPrivateMaterial,\n      userReducedPrivateMaterial,\n      params.passphrase,\n      params.originalPasscodeEncryptionCode,\n      params.webauthnInfo,\n      params.encryptionVersion,\n      params.enterprise,\n      params.safeId\n    );\n    const backupKeychainPromise = this.addBackupKeychain(\n      backupCommonKeychain,\n      backupPrivateMaterial,\n      backupReducedPrivateMaterial,\n      params.passphrase,\n      params.originalPasscodeEncryptionCode,\n      params.encryptionVersion,\n      params.enterprise,\n      params.safeId\n    );\n    const bitgoKeychainPromise = this.addBitgoKeychain(userCommonKeychain, params.safeId);\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  async createKeychainsWithExternalSigner(params: {\n    enterprise: string;\n    callbacks: EddsaMPCv2KeyGenCallbacks;\n  }): Promise<KeychainsTriplet> {\n    const { enterprise, callbacks } = params;\n\n    const { eddsaMpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(enterprise, true);\n    const bitgoPublicGpgKey = eddsaMpcv2PublicKey ?? this.bitgoEddsaMpcv2PublicGpgKey;\n    assert(bitgoPublicGpgKey, 'Failed to get BitGo EdDSA MPCv2 GPG public key');\n    const bitgoPublicGpgKeyArmored = bitgoPublicGpgKey.armor();\n\n    if (envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n      assert(isBitgoEddsaMpcv2PubKey(bitgoPublicGpgKeyArmored), 'Invalid BitGo EdDSA MPCv2 GPG public key');\n    }\n\n    // Round 0: both parties generate GPG keys\n    const { userGpgPublicKey, backupGpgPublicKey, userState, backupState } = await callbacks.initializeCallback({\n      enterprise,\n      bitgoPublicGpgKey: bitgoPublicGpgKeyArmored,\n    });\n\n    assert(NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');\n    assert(NonEmptyString.is(backupGpgPublicKey), 'Backup GPG public key is required');\n\n    // Round 1: both parties run DKG round 1\n    const {\n      userSignedMsg1,\n      backupSignedMsg1,\n      userState: userStateAfter1,\n      backupState: backupStateAfter1,\n    } = await callbacks.round1Callback({\n      bitgoPublicGpgKey: bitgoPublicGpgKeyArmored,\n      userGpgPublicKey,\n      backupGpgPublicKey,\n      userState,\n      backupState,\n    });\n\n    const { sessionId, bitgoMsg1 } = await this.sendKeyGenerationRound1(enterprise, {\n      userGpgPublicKey,\n      backupGpgPublicKey,\n      userMsg1: userSignedMsg1,\n      backupMsg1: backupSignedMsg1,\n    });\n\n    // Round 2: both parties run DKG round 2\n    const {\n      userSignedMsg2,\n      backupSignedMsg2,\n      userState: userStateAfter2,\n      backupState: backupStateAfter2,\n    } = await callbacks.round2Callback({\n      bitgoMsg1,\n      userSignedMsg1,\n      backupSignedMsg1,\n      userState: userStateAfter1,\n      backupState: backupStateAfter1,\n    });\n\n    const {\n      sessionId: sessionIdRound2,\n      commonPublicKeychain: bitgoCommonKeychain,\n      bitgoMsg2,\n    } = await this.sendKeyGenerationRound2(enterprise, {\n      sessionId,\n      userMsg2: userSignedMsg2,\n      backupMsg2: backupSignedMsg2,\n    });\n    assert.strictEqual(sessionId, sessionIdRound2, 'Round 1 and round 2 session IDs do not match');\n\n    // Finalize: both parties verify and derive the common keychain\n    const { commonKeychain } = await callbacks.finalizeCallback({\n      bitgoMsg2,\n      bitgoCommonKeychain,\n      userState: userStateAfter2,\n      backupState: backupStateAfter2,\n    });\n    assert.strictEqual(commonKeychain, bitgoCommonKeychain, 'Common keychains do not match');\n\n    const keychains = this.baseCoin.keychains();\n    const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([\n      keychains.add({ source: 'user', keyType: 'tss' as KeyType, commonKeychain, isMPCv2: true, enterprise }),\n      keychains.add({ source: 'backup', keyType: 'tss' as KeyType, commonKeychain, isMPCv2: true, enterprise }),\n      this.addBitgoKeychain(commonKeychain),\n    ]);\n\n    return { userKeychain, backupKeychain, bitgoKeychain };\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    webauthnInfo?: WebauthnKeyEncryptionInfo,\n    encryptionVersion?: EncryptionVersion,\n    enterprise?: string,\n    safeId?: string\n  ): Promise<Keychain> {\n    let source: string;\n    let encryptedPrv: string | undefined = undefined;\n    let reducedEncryptedPrv: string | undefined = undefined;\n    let privateMaterialBase64: string | undefined = undefined;\n\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        privateMaterialBase64 = privateMaterial.toString('base64');\n        encryptedPrv = await this.bitgo.encrypt({\n          input: privateMaterialBase64,\n          password: passphrase,\n          encryptionVersion,\n        });\n        // Encrypts the CBOR-encoded ReducedKeyShare (which contains the party's public\n        // key) with the wallet passphrase. The result is stored as reducedEncryptedPrv\n        // on the key card QR code and represents a second copy of key material\n        // beyond the server-stored encryptedPrv.\n        reducedEncryptedPrv = await 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 separated string of the array values.\n          input: btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial)))),\n          password: passphrase,\n          encryptionVersion,\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 keychainParams: AddKeychainOptions = {\n      source,\n      keyType: 'tss' as KeyType,\n      commonKeychain,\n      encryptedPrv,\n      originalPasscodeEncryptionCode,\n      isMPCv2: true,\n      safeId,\n      enterprise,\n    };\n\n    if (webauthnInfo && participantIndex === MPCv2PartiesEnum.USER && privateMaterialBase64) {\n      // Send the passkey as `webauthnInfo`; the deprecated `webauthnDevices` array is ignored by POST /key.\n      assert(enterprise, 'enterprise is required to attach a webauthn device to the user keychain');\n      keychainParams.webauthnInfo = {\n        otpDeviceId: webauthnInfo.otpDeviceId,\n        prfSalt: webauthnInfo.prfSalt,\n        encryptedPrv: await this.bitgo.encrypt({\n          input: privateMaterialBase64,\n          password: webauthnInfo.passphrase,\n          encryptionVersion,\n        }),\n        enterpriseId: enterprise,\n      };\n    }\n\n    const keychains = this.baseCoin.keychains();\n    return { ...(await keychains.add(keychainParams)), reducedEncryptedPrv };\n  }\n\n  private async addUserKeychain(\n    commonKeychain: string,\n    privateMaterial: Buffer,\n    reducedPrivateMaterial: Buffer,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string,\n    webauthnInfo?: WebauthnKeyEncryptionInfo,\n    encryptionVersion?: EncryptionVersion,\n    enterprise?: string,\n    safeId?: string\n  ): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.USER,\n      commonKeychain,\n      privateMaterial,\n      reducedPrivateMaterial,\n      passphrase,\n      originalPasscodeEncryptionCode,\n      webauthnInfo,\n      encryptionVersion,\n      enterprise,\n      safeId\n    );\n  }\n\n  private async addBackupKeychain(\n    commonKeychain: string,\n    privateMaterial: Buffer,\n    reducedPrivateMaterial: Buffer,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string,\n    encryptionVersion?: EncryptionVersion,\n    enterprise?: string,\n    safeId?: string\n  ): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.BACKUP,\n      commonKeychain,\n      privateMaterial,\n      reducedPrivateMaterial,\n      passphrase,\n      originalPasscodeEncryptionCode,\n      undefined,\n      encryptionVersion,\n      enterprise,\n      safeId\n    );\n  }\n\n  private async addBitgoKeychain(commonKeychain: string, safeId?: string): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.BITGO,\n      commonKeychain,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      safeId\n    );\n  }\n  // #endregion\n\n  async sendKeyGenerationRound1(\n    enterprise: string,\n    payload: EddsaMPCv2KeyGenRound1Request & { walletId?: string },\n    safeId?: string\n  ): Promise<EddsaMPCv2KeyGenRound1Response> {\n    return this.sendKeyGenerationRound1BySender(KeyGenSenderForEnterprise(this.bitgo, enterprise, safeId), payload);\n  }\n\n  async sendKeyGenerationRound1BySender(\n    senderFn: EddsaMPCv2KeyGenSendFn<EddsaMPCv2KeyGenRound1Response>,\n    payload: EddsaMPCv2KeyGenRound1Request & { walletId?: string }\n  ): Promise<EddsaMPCv2KeyGenRound1Response> {\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R1'], payload);\n  }\n\n  async sendKeyGenerationRound2(\n    enterprise: string,\n    payload: EddsaMPCv2KeyGenRound2Request\n  ): Promise<EddsaMPCv2KeyGenRound2Response> {\n    return this.sendKeyGenerationRound2BySender(KeyGenSenderForEnterprise(this.bitgo, enterprise), payload);\n  }\n\n  async sendKeyGenerationRound2BySender(\n    senderFn: EddsaMPCv2KeyGenSendFn<EddsaMPCv2KeyGenRound2Response>,\n    payload: EddsaMPCv2KeyGenRound2Request\n  ): Promise<EddsaMPCv2KeyGenRound2Response> {\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R2'], payload);\n  }\n\n  // #endregion\n\n  // #region sign tx request\n\n  /**\n   * Signs the transaction associated with 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\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 with 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\n   */\n  async signTxRequestForMessage(params: TSSParamsForMessageWithPrv): Promise<TxRequest> {\n    this.bitgo.setRequestTracer(params.reqId);\n    return this.signRequestBase(params, RequestType.message);\n  }\n\n  /**\n   * Full 3-round EdDSA MPCv2 (MPS) online signing orchestration.\n   *\n   * Protocol overview:\n   *   WASM Round 0  → getFirstMessage()      (produces userMsg1)\n   *   API  Round 1  → send userMsg1 / recv bitgoMsg1\n   *   WASM Round 1  → handleIncomingMessages([userMsg1, bitgoMsg1])  (produces userMsg2)\n   *   API  Round 2  → send userMsg2 / recv bitgoMsg2\n   *   WASM Round 2  → handleIncomingMessages([userMsg2, bitgoMsg2])  (produces userMsg3)\n   *   API  Round 3  → send userMsg3 (WP finalises; no BitGo msg returned to client)\n   */\n  private async signRequestBase(\n    params: TSSParamsWithPrv | TSSParamsForMessageWithPrv,\n    requestType: RequestType\n  ): Promise<TxRequest> {\n    const userKeyShare = Buffer.from(params.prv, 'base64');\n\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\n    let txOrMessageToSign;\n    let derivationPath;\n    let bufferContent;\n    // One fresh ed25519 GPG key pair per signing session, reused across all signing rounds.\n    const userGpgKey = await generateGPGKeyPair('ed25519');\n    const userGpgPrvKey = await pgp.readPrivateKey({ armoredKey: userGpgKey.privateKey });\n    const bitgoGpgPubKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequest.enterpriseId, true);\n    assert(bitgoGpgPubKey, 'Missing BitGo GPG key for MPCv2');\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      txOrMessageToSign = unsignedTx.signableHex;\n      assert(txOrMessageToSign, 'Missing signableHex in unsignedTx');\n      derivationPath = unsignedTx.derivationPath;\n      bufferContent = Buffer.from(txOrMessageToSign, 'hex');\n      await this.baseCoin.verifyTransaction({\n        txPrebuild: { txHex: unsignedTx.serializedTxHex ?? txOrMessageToSign },\n        txParams: resolveEffectiveTxParams(txRequest, params.txParams, this.baseCoin.getChain()),\n        wallet: this.wallet,\n        walletType: this.wallet.multisigType(),\n      });\n    } else if (requestType === RequestType.message) {\n      assert(txRequest.messages && txRequest.messages.length > 0, 'Unable to find messages in txRequest');\n      txOrMessageToSign = txRequest.messages[0].messageEncoded;\n      assert(txOrMessageToSign, 'Missing messageEncoded in messages[0]');\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    // ── WASM Round 0 ──────────────────────────────────────────────────────────\n    const partyId = params.mpcv2PartyId ?? MPCv2PartiesEnum.USER;\n    const signerShareType = partyId === MPCv2PartiesEnum.USER ? SignatureShareType.USER : SignatureShareType.BACKUP;\n    const userDsg = new EddsaMPSDsg.DSG(partyId);\n    await userDsg.initDsg(userKeyShare, bufferContent, derivationPath, MPCv2PartiesEnum.BITGO);\n    const userMsg1 = userDsg.getFirstMessage();\n\n    // ── API Round 1 ───────────────────────────────────────────────────────────\n    const signatureShareRound1 = await getSignatureShareRoundOne(userMsg1, userGpgPrvKey, partyId);\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 after round 1');\n\n    const signatureShares1 =\n      requestType === RequestType.tx\n        ? latestTxRequest.transactions![0].signatureShares\n        : latestTxRequest.messages![0].signatureShares;\n\n    const bitgoShareRoundOne = getBitgoSignatureShare(signatureShares1, signerShareType, 'round1Output');\n    const parsedBitGoToUserSigShareRoundOne = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound1Output,\n      JSON.parse(bitgoShareRoundOne.share),\n      'Unexpected signature share response. Unable to parse data.'\n    );\n\n    if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n\n    const bitgoDeserializedMsg1 = await verifyPeerMessageRoundOne(parsedBitGoToUserSigShareRoundOne, bitgoGpgPubKey);\n\n    // ── WASM Round 1 ──────────────────────────────────────────────────────────\n    const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);\n    assert(userMsg2, 'WASM round 1 produced no message');\n\n    // ── API Round 2 ───────────────────────────────────────────────────────────\n    const signatureShareRoundTwo = await getSignatureShareRoundTwo(userMsg2, userGpgPrvKey, partyId);\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\n    assert(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest object after round 2');\n\n    const txRequestSignatureShares =\n      requestType === RequestType.tx\n        ? latestTxRequest.transactions![0].signatureShares\n        : latestTxRequest.messages![0].signatureShares;\n\n    const bitgoShareRoundTwo = getBitgoSignatureShare(txRequestSignatureShares, signerShareType, 'round2Output');\n    const parsedBitGoToUserSigShareRoundTwo = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound2Output,\n      JSON.parse(bitgoShareRoundTwo.share),\n      'Unexpected signature share response. Unable to parse data.'\n    );\n\n    if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n\n    const bitgoDeserializedMsg2 = await verifyPeerMessageRoundTwo(parsedBitGoToUserSigShareRoundTwo, bitgoGpgPubKey);\n\n    // ── WASM Round 2 ──────────────────────────────────────────────────────────\n    const [userMsg3] = userDsg.handleIncomingMessages([userMsg2, bitgoDeserializedMsg2]);\n    assert(userMsg3, 'WASM round 2 produced no message');\n\n    // ── API Round 3 ───────────────────────────────────────────────────────────\n    // No BitGo response to verify; WP finalises the signing server-side\n    const signatureShareRound3 = await getSignatureShareRoundThree(userMsg3, userGpgPrvKey, partyId);\n    const round3TxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequest.walletId,\n      txRequest.txRequestId,\n      [signatureShareRound3],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgKey.publicKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      params.reqId\n    );\n    assert(round3TxRequest?.txRequestId === txRequest.txRequestId, 'Invalid txRequest object after round 3');\n\n    return sendTxRequest(this.bitgo, txRequest.walletId, txRequest.txRequestId, requestType, params.reqId);\n  }\n\n  // #endregion\n\n  // #region external signer\n\n  // #region KeyGenRound1Share\n  async createOfflineKeyGenRound1Share(params: {\n    walletPassphrase: string;\n    encryptedUserGpgPrvKey: string;\n    bitgoGpgPubKey: string;\n    counterPartyGpgPubKey: string;\n    partyId?: MPCv2PartiesEnum.USER | MPCv2PartiesEnum.BACKUP;\n  }): Promise<{\n    signedMsg1: MPSTypes.MPSSignedMessage;\n    encryptedRound1Session: string;\n  }> {\n    const { walletPassphrase, encryptedUserGpgPrvKey, bitgoGpgPubKey, counterPartyGpgPubKey } = params;\n    const partyId = params.partyId ?? MPCv2PartiesEnum.USER;\n\n    const decryptedGpgPrvKey = await this.bitgo.decrypt({ input: encryptedUserGpgPrvKey, password: walletPassphrase });\n    const gpgPrvKey = await pgp.readPrivateKey({ armoredKey: decryptedGpgPrvKey });\n\n    const [, ownSk] = await MPSComms.extractEd25519KeyPair(gpgPrvKey);\n\n    if (envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n      assert(isBitgoEddsaMpcv2PubKey(bitgoGpgPubKey), 'Invalid BitGo GPG public key');\n    }\n\n    const bitgoKeyObj = await pgp.readKey({ armoredKey: bitgoGpgPubKey });\n    const bitgoPk = await MPSComms.extractEd25519PublicKey(bitgoKeyObj);\n\n    const counterPartyKeyObj = await pgp.readKey({ armoredKey: counterPartyGpgPubKey });\n    const counterPartyPk = await MPSComms.extractEd25519PublicKey(counterPartyKeyObj);\n\n    const dkg = new EddsaMPSDkg.DKG(3, 2, partyId);\n    await dkg.initDkg(ownSk, [counterPartyPk, bitgoPk]);\n\n    const msg1 = dkg.getFirstMessage();\n    const signedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(msg1.payload), gpgPrvKey);\n\n    const sessionPayload = JSON.stringify({\n      dkgSession: dkg.getSession(),\n      ownMsgPayload: Buffer.from(msg1.payload).toString('base64'),\n      ownMsgFrom: msg1.from,\n    });\n\n    const encryptedRound1Session = await this.bitgo.encrypt({\n      input: sessionPayload,\n      password: walletPassphrase,\n      adata: `${EddsaMPCv2Utils.MPS_DKG_KEYGEN_ROUND1_STATE}:${partyId}`,\n      encryptionVersion: 1,\n    });\n\n    return { signedMsg1, encryptedRound1Session };\n  }\n  // #endregion\n\n  // #region Round1Share\n  async createOfflineRound1Share(params: {\n    txRequest: TxRequest;\n    prv: string;\n    walletPassphrase: string;\n    encryptedPrv?: string;\n  }): Promise<{\n    signatureShareRound1: SignatureShareRecord;\n    userGpgPubKey: string;\n    encryptedRound1Session: string;\n    encryptedUserGpgPrvKey: string;\n  }> {\n    const { prv, walletPassphrase, txRequest, encryptedPrv } = params;\n    const { signableHex, derivationPath } = this.getSignableHexAndDerivationPath(\n      txRequest,\n      'Unable to find transactions in txRequest'\n    );\n    const adata = `${signableHex}:${derivationPath}`;\n\n    const userKeyShare = Buffer.from(prv, 'base64');\n    const userGpgKey = await generateGPGKeyPair('ed25519');\n    const userGpgPrvKey = await pgp.readPrivateKey({ armoredKey: userGpgKey.privateKey });\n\n    const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n    await userDsg.initDsg(userKeyShare, Buffer.from(signableHex, 'hex'), derivationPath, MPCv2PartiesEnum.BITGO);\n    const userMsg1 = userDsg.getFirstMessage();\n    const signatureShareRound1 = await getSignatureShareRoundOne(userMsg1, userGpgPrvKey);\n    const sessionPayload = JSON.stringify({\n      dsgSession: userDsg.getSession(),\n      userMsgPayload: Buffer.from(userMsg1.payload).toString('base64'),\n    });\n    const userGpgPubKey = userGpgKey.publicKey;\n\n    const useV2 = encryptedPrv !== undefined && isV2Envelope(encryptedPrv);\n    if (useV2) {\n      const session = await this.bitgo.createEncryptionSession(walletPassphrase);\n      try {\n        const encryptedRound1Session = await session.encrypt(\n          sessionPayload,\n          `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND1_STATE}:${adata}`\n        );\n        const encryptedUserGpgPrvKey = await session.encrypt(\n          userGpgKey.privateKey,\n          `${EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY}:${adata}`\n        );\n        return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };\n      } finally {\n        session.destroy();\n      }\n    }\n\n    const encryptedRound1Session = await this.bitgo.encrypt({\n      input: sessionPayload,\n      password: walletPassphrase,\n      adata: `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND1_STATE}:${adata}`,\n      encryptionVersion: 1,\n    });\n    const encryptedUserGpgPrvKey = await this.bitgo.encrypt({\n      input: userGpgKey.privateKey,\n      password: walletPassphrase,\n      adata: `${EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY}:${adata}`,\n      encryptionVersion: 1,\n    });\n\n    return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };\n  }\n  // #endregion\n\n  // #region Round2Share\n  async createOfflineRound2Share(params: {\n    txRequest: TxRequest;\n    walletPassphrase: string;\n    bitgoPublicGpgKey: string;\n    encryptedUserGpgPrvKey: string;\n    encryptedRound1Session: string;\n  }): Promise<{\n    signatureShareRound2: SignatureShareRecord;\n    encryptedRound2Session: string;\n  }> {\n    const { walletPassphrase, encryptedUserGpgPrvKey, encryptedRound1Session, bitgoPublicGpgKey, txRequest } = params;\n\n    const { signableHex, derivationPath } = this.getSignableHexAndDerivationPath(\n      txRequest,\n      'Unable to find transactions in txRequest'\n    );\n    const adata = `${signableHex}:${derivationPath}`;\n\n    const useV2 = isV2Envelope(encryptedRound1Session);\n\n    const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(\n      bitgoPublicGpgKey,\n      encryptedUserGpgPrvKey,\n      walletPassphrase,\n      adata,\n      EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY\n    );\n\n    const transactions = txRequest.transactions;\n    assert(Array.isArray(transactions) && transactions.length === 1, 'txRequest must have exactly one transaction');\n    const signatureShares = transactions[0].signatureShares;\n    assert(signatureShares, 'Missing signature shares in round 1 txRequest');\n\n    const bitgoShareRoundOne = getBitgoSignatureShare(signatureShares, SignatureShareType.USER, 'round1Output');\n    const parsedBitGoToUserSigShareRoundOne = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound1Output,\n      JSON.parse(bitgoShareRoundOne.share),\n      'Unexpected signature share response. Unable to parse data.'\n    );\n\n    if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n\n    const bitgoDeserializedMsg1 = await verifyPeerMessageRoundOne(parsedBitGoToUserSigShareRoundOne, bitgoGpgKey);\n\n    this.validateAdata(adata, encryptedRound1Session, EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND1_STATE);\n\n    const decryptedRound1Session = await this.bitgo.decrypt({\n      input: encryptedRound1Session,\n      password: walletPassphrase,\n    });\n\n    const { dsgSession, userMsgPayload } = JSON.parse(decryptedRound1Session) as {\n      dsgSession: string;\n      userMsgPayload: string;\n    };\n\n    const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n    await userDsg.restoreSession(dsgSession);\n    const userMsg1: MPSTypes.DeserializedMessage = {\n      from: MPCv2PartiesEnum.USER,\n      payload: new Uint8Array(Buffer.from(userMsgPayload, 'base64')),\n    };\n\n    const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);\n    assert(userMsg2, 'DSG handleIncomingMessages produced no round-2 output');\n\n    const signatureShareRound2 = await getSignatureShareRoundTwo(userMsg2, userGpgPrvKey);\n    const sessionPayload = JSON.stringify({\n      dsgSession: userDsg.getSession(),\n      userMsgPayload: Buffer.from(userMsg2.payload).toString('base64'),\n    });\n\n    if (useV2) {\n      const session = await this.bitgo.createEncryptionSession(walletPassphrase);\n      try {\n        const encryptedRound2Session = await session.encrypt(\n          sessionPayload,\n          `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND2_STATE}:${adata}`\n        );\n        return { signatureShareRound2, encryptedRound2Session };\n      } finally {\n        session.destroy();\n      }\n    }\n\n    const encryptedRound2Session = await this.bitgo.encrypt({\n      input: sessionPayload,\n      password: walletPassphrase,\n      adata: `${EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND2_STATE}:${adata}`,\n      encryptionVersion: 1,\n    });\n\n    return { signatureShareRound2, encryptedRound2Session };\n  }\n  // #endregion\n\n  // #region Round3Share\n  async createOfflineRound3Share(params: {\n    txRequest: TxRequest;\n    walletPassphrase: string;\n    bitgoPublicGpgKey: string;\n    encryptedUserGpgPrvKey: string;\n    encryptedRound2Session: string;\n  }): Promise<{\n    signatureShareRound3: SignatureShareRecord;\n  }> {\n    const { walletPassphrase, encryptedUserGpgPrvKey, encryptedRound2Session, bitgoPublicGpgKey, txRequest } = params;\n\n    const { signableHex, derivationPath } = this.getSignableHexAndDerivationPath(\n      txRequest,\n      'Unable to find transactions in txRequest'\n    );\n    const adata = `${signableHex}:${derivationPath}`;\n\n    const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(\n      bitgoPublicGpgKey,\n      encryptedUserGpgPrvKey,\n      walletPassphrase,\n      adata,\n      EddsaMPCv2Utils.MPS_DSG_SIGNING_USER_GPG_KEY\n    );\n\n    const transactions = txRequest.transactions;\n    assert(Array.isArray(transactions) && transactions.length === 1, 'txRequest must have exactly one transaction');\n    const signatureShares = transactions[0].signatureShares;\n    assert(signatureShares, 'Missing signature shares in round 2 txRequest');\n\n    const bitgoShareRoundTwo = getBitgoSignatureShare(signatureShares, SignatureShareType.USER, 'round2Output');\n\n    const parsedBitGoToUserSigShareRoundTwo = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound2Output,\n      JSON.parse(bitgoShareRoundTwo.share),\n      'Unexpected signature share response. Unable to parse data.'\n    );\n\n    if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n\n    const bitgoDeserializedMsg2 = await verifyPeerMessageRoundTwo(parsedBitGoToUserSigShareRoundTwo, bitgoGpgKey);\n\n    this.validateAdata(adata, encryptedRound2Session, EddsaMPCv2Utils.MPS_DSG_SIGNING_ROUND2_STATE);\n\n    const decryptedRound2Session = await this.bitgo.decrypt({\n      input: encryptedRound2Session,\n      password: walletPassphrase,\n    });\n\n    const { dsgSession, userMsgPayload } = JSON.parse(decryptedRound2Session) as {\n      dsgSession: string;\n      userMsgPayload: string;\n    };\n\n    const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n    await userDsg.restoreSession(dsgSession);\n    const userMsg2: MPSTypes.DeserializedMessage = {\n      from: MPCv2PartiesEnum.USER,\n      payload: new Uint8Array(Buffer.from(userMsgPayload, 'base64')),\n    };\n\n    const [userMsg3] = userDsg.handleIncomingMessages([userMsg2, bitgoDeserializedMsg2]);\n    assert(userMsg3, 'DSG handleIncomingMessages produced no round-3 output');\n\n    const signatureShareRound3 = await getSignatureShareRoundThree(userMsg3, userGpgPrvKey);\n\n    return { signatureShareRound3 };\n  }\n  // #endregion\n\n  /** @inheritdoc */\n  async signEddsaMPCv2TssUsingExternalSigner(\n    params: TSSParams | TSSParamsForMessage,\n    externalSignerEddsaMPCv2SigningRound1Generator: CustomEddsaMPCv2SigningRound1GeneratingFunction,\n    externalSignerEddsaMPCv2SigningRound2Generator: CustomEddsaMPCv2SigningRound2GeneratingFunction,\n    externalSignerEddsaMPCv2SigningRound3Generator: CustomEddsaMPCv2SigningRound3GeneratingFunction,\n    requestType: RequestType = RequestType.tx\n  ): Promise<TxRequest> {\n    const { txRequest, reqId } = params;\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    let txRequestResolved: TxRequest;\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      reqId,\n      txRequestResolved.enterpriseId,\n      true\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 externalSignerEddsaMPCv2SigningRound1Generator({ 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 externalSignerEddsaMPCv2SigningRound2Generator({\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 externalSignerEddsaMPCv2SigningRound3Generator({\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  // #endregion\n\n  // #region retrofit\n\n  private async getUserAndBackupSession(retrofit?: DecryptedRetrofitPayload): Promise<{\n    userDkg: EddsaMPSDkg.DKG;\n    backupDkg: EddsaMPSDkg.DKG;\n  }> {\n    if (retrofit) {\n      const { userRetrofitData, backupRetrofitData } = await this.getMpcV2RetrofitDataFromMpcV1Keys({\n        mpcv1UserKeyShare: retrofit.decryptedUserKey,\n        mpcv1BackupKeyShare: retrofit.decryptedBackupKey,\n      });\n      return {\n        userDkg: new EddsaMPSDkg.DKG(3, 2, MPCv2PartiesEnum.USER, userRetrofitData),\n        backupDkg: new EddsaMPSDkg.DKG(3, 2, MPCv2PartiesEnum.BACKUP, backupRetrofitData),\n      };\n    }\n    return {\n      userDkg: new EddsaMPSDkg.DKG(3, 2, MPCv2PartiesEnum.USER),\n      backupDkg: new EddsaMPSDkg.DKG(3, 2, MPCv2PartiesEnum.BACKUP),\n    };\n  }\n\n  async getMpcV2RetrofitDataFromMpcV1Keys(params: { mpcv1UserKeyShare: string; mpcv1BackupKeyShare: string }): Promise<{\n    userRetrofitData: MPSTypes.EddsaRetrofitData;\n    backupRetrofitData: MPSTypes.EddsaRetrofitData;\n  }> {\n    const MPC = await getInitializedMpcInstance();\n    const userRetrofitData = EddsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key(\n      params.mpcv1UserKeyShare,\n      MPCv2PartiesEnum.USER,\n      MPC\n    );\n    const backupRetrofitData = EddsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key(\n      params.mpcv1BackupKeyShare,\n      MPCv2PartiesEnum.BACKUP,\n      MPC\n    );\n\n    assert(\n      userRetrofitData.expectedPk === backupRetrofitData.expectedPk,\n      'MPCv1 user and backup keys combine to different aggregate public keys'\n    );\n    assert(\n      userRetrofitData.chainCode === backupRetrofitData.chainCode,\n      'MPCv1 user and backup keys combine to different chain codes'\n    );\n\n    return { userRetrofitData, backupRetrofitData };\n  }\n\n  private static getMpcV2RetrofitDataFromMpcV1Key(\n    mpcv1PartyKeyShare: string,\n    mpcv1PartyIndex: MPCv2PartiesEnum.USER | MPCv2PartiesEnum.BACKUP,\n    mpc: Awaited<ReturnType<typeof getInitializedMpcInstance>>\n  ): MPSTypes.EddsaRetrofitData {\n    const signingMaterial: SigningMaterial = JSON.parse(mpcv1PartyKeyShare);\n    assert(signingMaterial.uShare, 'MPCv1 key material missing uShare');\n    assert(signingMaterial.bitgoYShare, 'MPCv1 key material missing bitgoYShare');\n\n    let pShare;\n    switch (mpcv1PartyIndex) {\n      case MPCv2PartiesEnum.USER:\n        assert(signingMaterial.backupYShare, 'User MPCv1 key material missing backupYShare');\n        pShare = mpc.keyCombine(signingMaterial.uShare, [\n          signingMaterial.bitgoYShare,\n          signingMaterial.backupYShare,\n        ]).pShare;\n        break;\n      case MPCv2PartiesEnum.BACKUP:\n        assert(signingMaterial.userYShare, 'Backup MPCv1 key material missing userYShare');\n        pShare = mpc.keyCombine(signingMaterial.uShare, [\n          signingMaterial.bitgoYShare,\n          signingMaterial.userYShare,\n        ]).pShare;\n        break;\n      default:\n        throw new Error('Invalid participant index');\n    }\n\n    return {\n      s_i_0: pShare.u,\n      expectedPk: pShare.y,\n      chainCode: pShare.chaincode,\n    };\n  }\n\n  // #endregion\n}\n\n/**\n * Detect whether an encrypted keycard contains MPCv1 signing material.\n *\n * Decrypts the keycard and checks for the JSON shape produced by the MPCv1 TSS\n * key-generation flow (uShare.seed + bitgoYShare.u + backupYShare.u / userYShare.u).\n * Returns false for MPCv2 CBOR keycards, wrong passwords, or any decryption error.\n *\n * @param encryptedKeyShare encrypted user or backup keycard\n * @param walletPassphrase passphrase used to encrypt the keycard\n * @param bitgo optional BitGoBase instance; when provided, decrypts via\n *   bitgo.decrypt (supports both v1 SJCL and v2 Argon2id envelopes);\n *   when absent, falls back to sjcl.decrypt (v1 only)\n */\nfunction parseEddsaMpcV1Material(decrypted: string): string | null {\n  try {\n    const m = JSON.parse(decrypted);\n    if (\n      typeof m?.uShare?.seed === 'string' &&\n      typeof m?.bitgoYShare?.u === 'string' &&\n      (typeof m?.backupYShare?.u === 'string' || typeof m?.userYShare?.u === 'string')\n    ) {\n      return decrypted;\n    }\n  } catch {\n    // Not JSON → MPCv2 CBOR\n  }\n  return null;\n}\n\nexport async function isEddsaMpcV1SigningMaterial(\n  encryptedKeyShare: string,\n  walletPassphrase: string,\n  bitgo?: BitGoBase\n): Promise<boolean> {\n  const decrypted = bitgo\n    ? await bitgo.decrypt({ input: encryptedKeyShare, password: walletPassphrase })\n    : sjcl.decrypt(walletPassphrase, encryptedKeyShare);\n  return parseEddsaMpcV1Material(decrypted) !== null;\n}\n\n/**\n * Get EdDSA MPCv2 recovery key shares from encrypted reduced user and backup keys.\n *\n * The encrypted inputs are the `reducedEncryptedPrv` values stored on EdDSA MPCv2\n * key cards. They decrypt to CBOR-encoded reduced shares that contain the opaque\n * MPS signing key-share bytes plus the common public keychain material.\n *\n * @param encryptedUserKey encrypted EdDSA MPCv2 reduced user key\n * @param encryptedBackupKey encrypted EdDSA MPCv2 reduced backup key\n * @param walletPassphrase password for user and backup keys\n * @returns EdDSA MPCv2 recovery key shares and common keychain\n */\nexport async function getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n  encryptedUserKey: string,\n  encryptedBackupKey: string,\n  walletPassphrase?: string,\n  bitgo?: BitGoBase\n): Promise<EddsaMPCv2RecoveryKeyShares> {\n  const decodeKey = async (encryptedKey: string): Promise<MPSTypes.EddsaReducedKeyShare> => {\n    const decrypted = bitgo\n      ? await bitgo.decrypt({ input: encryptedKey, password: walletPassphrase })\n      : sjcl.decrypt(walletPassphrase, encryptedKey);\n    let reduced: MPSTypes.EddsaReducedKeyShare;\n    try {\n      reduced = MPSTypes.getDecodedReducedKeyShare(Buffer.from(decrypted, 'base64'));\n    } catch {\n      throw new Error(\n        'EdDSA MPCv2 recovery: unable to decode reduced key share from keycard material. The encrypted key may be corrupted, malformed, or not an EdDSA MPCv2 reduced key.'\n      );\n    }\n    if (!reduced.keyShare?.length || !reduced.pub?.length || !reduced.rootChainCode?.length) {\n      throw new Error(\n        'EdDSA MPCv2 recovery: reduced key share is missing keyShare, pub, or rootChainCode. This keycard may be public-only and cannot be used for recovery.'\n      );\n    }\n    return reduced;\n  };\n\n  const [userReduced, backupReduced] = await Promise.all([decodeKey(encryptedUserKey), decodeKey(encryptedBackupKey)]);\n\n  const userPub = Buffer.from(userReduced.pub).toString('hex');\n  const backupPub = Buffer.from(backupReduced.pub).toString('hex');\n  if (userPub !== backupPub) {\n    throw new Error('EdDSA MPCv2 recovery: user and backup pub keys do not match');\n  }\n\n  const userChainCode = Buffer.from(userReduced.rootChainCode).toString('hex');\n  const backupChainCode = Buffer.from(backupReduced.rootChainCode).toString('hex');\n  if (userChainCode !== backupChainCode) {\n    throw new Error('EdDSA MPCv2 recovery: user and backup rootChainCodes do not match');\n  }\n\n  return {\n    userKeyShare: Buffer.from(userReduced.keyShare),\n    backupKeyShare: Buffer.from(backupReduced.keyShare),\n    commonKeyChain: userPub + userChainCode,\n  };\n}\n\n/**\n * Sign a message for recovery using EdDSA MPCv2 (MPS) with user and backup key shares.\n *\n * Runs the MPS DSG protocol locally to round 3, then verifies the resulting\n * Ed25519 signature against the public key derived from the common keychain.\n *\n * @param message raw bytes to sign\n * @param derivationPath BIP-32-style derivation path, e.g. `\"m/0\"`\n * @param userKeyShare opaque MPS signing key-share bytes for the user party\n * @param backupKeyShare opaque MPS signing key-share bytes for the backup party\n * @param commonKeyChain 128-hex-char string: 32-byte pub + 32-byte rootChainCode\n * @returns 64-byte Ed25519 signature Buffer\n */\nexport async function signRecoveryEddsaMPCv2(\n  message: Buffer,\n  derivationPath: string,\n  userKeyShare: Buffer,\n  backupKeyShare: Buffer,\n  commonKeyChain: string\n): Promise<Buffer> {\n  const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n  const backupDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BACKUP);\n\n  const signature = (await MPSUtil.executeTillRound(\n    3,\n    userDsg,\n    backupDsg,\n    userKeyShare,\n    backupKeyShare,\n    message,\n    derivationPath\n  )) as Buffer;\n\n  // Use Eddsa.deriveUnhardened (BIP32-Ed25519), which matches what DSG uses\n  // internally for path derivation since wasm-mps 1.9.0.\n  const mpc = await getInitializedMpcInstance();\n  const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);\n  const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');\n\n  const verified = ed25519.verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKeyBytes));\n  if (!verified) {\n    throw new Error('EdDSA MPCv2 recovery signature verification failed');\n  }\n\n  return signature;\n}\n\n/**\n * Discriminated union representing EdDSA signing material detected from a keycard.\n * v1: MPCv1 JSON keycard — userPrv is the decrypted plaintext.\n * v2: MPCv2 CBOR keycard — encryptedUserKey is returned as-is for MPS DSG.\n */\nexport type EddsaSigningMaterial = { version: 'v1'; userPrv: string } | { version: 'v2'; encryptedUserKey: string };\n\n/**\n * Detects MPCv1 vs MPCv2 keycard format and returns typed signing material.\n * For v1: decrypts once and returns the plaintext as userPrv.\n * For v2: returns the encrypted key as-is for use with signEddsaMpcV2RecoveryTx.\n * When bitgo is omitted, falls back to sjcl (v1 only).\n */\nexport async function getEddsaSigningMaterial(\n  userKey: string,\n  walletPassphrase: string,\n  bitgo?: BitGoBase\n): Promise<EddsaSigningMaterial> {\n  const normalized = userKey.replace(/\\s/g, '');\n  let decrypted: string;\n  try {\n    decrypted = bitgo\n      ? await bitgo.decrypt({ input: normalized, password: walletPassphrase })\n      : sjcl.decrypt(walletPassphrase, normalized);\n  } catch (e) {\n    throw new Error(`Error decrypting user keychain: ${e instanceof Error ? e.message : String(e)}`);\n  }\n  const userPrv = parseEddsaMpcV1Material(decrypted);\n  return userPrv !== null ? { version: 'v1', userPrv } : { version: 'v2', encryptedUserKey: normalized };\n}\n\n/**\n * Type guard validating that a value has the shape of EddsaSigningMaterial.\n *\n * Coin `recover()` implementations accept an optional precomputed signing-material\n * parameter (set by recoverConsolidations() to avoid re-decrypting the keycard per\n * scanned index). Some callers pass an unrelated second positional argument to\n * recover() for other purposes (e.g. openSSLBytes for EVM-like coins); validating\n * the shape here prevents that from being misinterpreted as signing material.\n */\nexport function isEddsaSigningMaterial(value: unknown): value is EddsaSigningMaterial {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (!('version' in value)) {\n    return false;\n  }\n  if (value.version === 'v1') {\n    return 'userPrv' in value && typeof value.userPrv === 'string';\n  }\n  if (value.version === 'v2') {\n    return 'encryptedUserKey' in value && typeof value.encryptedUserKey === 'string';\n  }\n  return false;\n}\n\n/**\n * Full MPCv2 recovery signing flow: decrypt key shares → validate commonKeyChain → MPS DSG.\n * Returns raw 64-byte Ed25519 signature Buffer.\n * Caller is responsible for any coin-specific envelope\n * (e.g. 0x00 Substrate prefix, SUI flag+pubkey wrapper, or raw for NEAR/ADA/TON).\n */\nexport async function signEddsaMpcV2RecoveryTx(params: {\n  message: Buffer;\n  userKey: string;\n  backupKey: string;\n  walletPassphrase: string;\n  bitgoKey: string;\n  derivationPath: string;\n  bitgo?: BitGoBase;\n}): Promise<Buffer> {\n  const { userKeyShare, backupKeyShare, commonKeyChain } = await getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n    params.userKey,\n    params.backupKey,\n    params.walletPassphrase,\n    params.bitgo\n  );\n  if (commonKeyChain.toLowerCase() !== params.bitgoKey.toLowerCase()) {\n    throw new Error('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');\n  }\n  return signRecoveryEddsaMPCv2(params.message, params.derivationPath, userKeyShare, backupKeyShare, commonKeyChain);\n}\n\nexport const EddsaMPCv2RecoveryFunctions = {\n  isEddsaMpcV1SigningMaterial,\n  getEddsaMpcV2RecoveryKeySharesFromReducedKey,\n  signRecoveryEddsaMPCv2,\n  getEddsaSigningMaterial,\n  isEddsaSigningMaterial,\n  signEddsaMpcV2RecoveryTx,\n};\n"]}