@bitgo-beta/sdk-core 8.2.1-beta.206 → 8.2.1-beta.2060

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

@@ -0,0 +1,1937 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const cbor_x_1 = require("cbor-x");
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+const pgp = __importStar(require("openpgp"));
+const crypto_1 = require("crypto");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const ed25519_1 = require("@noble/curves/ed25519");
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const public_types_1 = require("@bitgo/public-types");
+const src_1 = require("../../../../../../src");
+const eddsaMPCv2_1 = require("../../../../../../src/bitgo/tss/eddsa/eddsaMPCv2");
+const eddsa_1 = require("../../../../../../src/bitgo/tss/eddsa/eddsa");
+const common_1 = require("../../../../../../src/bitgo/tss/common");
+const codecs_1 = require("../../../../../../src/bitgo/utils/codecs");
+const opengpgUtils_1 = require("../../../../../../src/bitgo/utils/opengpgUtils");
+const typesMPCv2_1 = require("../../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2");
+const baseTypes_1 = require("../../../../../../src/bitgo/utils/tss/baseTypes");
+describe('EdDSA MPS DSG helper functions', async () => {
+    let userKeyShare;
+    let backupKeyShare;
+    let bitgoKeyShare;
+    let userGpgPrivKey;
+    let backupGpgPrivKey;
+    let bitgoGpgPrivKey;
+    let bitgoGpgPubKey;
+    const signableHex = 'deadbeef';
+    const derivationPath = 'm/0';
+    before('generate EdDSA DKG key shares', async () => {
+        const userGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const backupGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const bitgoGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        userGpgPrivKey = await pgp.readPrivateKey({ armoredKey: userGpgKeyPair.privateKey });
+        backupGpgPrivKey = await pgp.readPrivateKey({ armoredKey: backupGpgKeyPair.privateKey });
+        bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });
+        bitgoGpgPubKey = await pgp.readKey({ armoredKey: bitgoGpgKeyPair.publicKey });
+        const [userDkg, backupDkg, bitgoDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        userKeyShare = userDkg.getKeyShare();
+        backupKeyShare = backupDkg.getKeyShare();
+        bitgoKeyShare = bitgoDkg.getKeyShare();
+    });
+    // ── Round 1 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundOne should build a valid round-1 share', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const userMsg1 = userDsg.getFirstMessage();
+        const share = await (0, eddsaMPCv2_1.getSignatureShareRoundOne)(userMsg1, userGpgPrivKey);
+        assert.strictEqual(share.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound1Input, JSON.parse(share.share), 'EddsaMPCv2SignatureShareRound1Input');
+        assert.strictEqual(parsed.type, 'round1Input');
+        assert.ok(parsed.data.msg1.message, 'msg1.message should be set');
+        assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');
+    });
+    it('getSignatureShareRoundOne should build a valid backup round-1 share', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const backupDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        await backupDsg.initDsg(backupKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const backupMsg1 = backupDsg.getFirstMessage();
+        const share = await (0, eddsaMPCv2_1.getSignatureShareRoundOne)(backupMsg1, backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound1Input, JSON.parse(share.share), 'EddsaMPCv2SignatureShareRound1Input');
+        assert.strictEqual(parsed.type, 'round1Input');
+        assert.ok(parsed.data.msg1.message, 'msg1.message should be set');
+        assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');
+    });
+    it('verifyPeerMessageRoundOne should verify a valid BitGo round-1 message', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const bitgoMsg1 = bitgoDsg.getFirstMessage();
+        const bitgoSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: bitgoSignedMsg1 },
+        };
+        const result = await (0, eddsaMPCv2_1.verifyPeerMessageRoundOne)(round1Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.ok(result.payload.length > 0, 'payload should be non-empty');
+    });
+    it('verifyPeerMessageRoundOne should throw on a tampered message', async () => {
+        const round1Output = {
+            type: 'round1Output',
+            data: {
+                msg1: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, eddsaMPCv2_1.verifyPeerMessageRoundOne)(round1Output, bitgoGpgPubKey), 'should throw on invalid signature');
+    });
+    // ── Round 2 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundTwo should build a valid round-2 share', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const userMsg1 = userDsg.getFirstMessage();
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const bitgoMsg1 = bitgoDsg.getFirstMessage();
+        const bitgoSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);
+        const bitgoDeserializedMsg1 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundOne)({ type: 'round1Output', data: { msg1: bitgoSignedMsg1 } }, bitgoGpgPubKey);
+        const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);
+        const share = await (0, eddsaMPCv2_1.getSignatureShareRoundTwo)(userMsg2, userGpgPrivKey);
+        assert.strictEqual(share.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound2Input, JSON.parse(share.share), 'EddsaMPCv2SignatureShareRound2Input');
+        assert.strictEqual(parsed.type, 'round2Input');
+        assert.ok(parsed.data.msg2.message, 'msg2.message should be set');
+        assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');
+    });
+    it('getSignatureShareRoundTwo should build a valid backup round-2 share', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const backupDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        await backupDsg.initDsg(backupKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const backupMsg1 = backupDsg.getFirstMessage();
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        const bitgoMsg1 = bitgoDsg.getFirstMessage();
+        const bitgoSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);
+        const bitgoDeserializedMsg1 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundOne)({ type: 'round1Output', data: { msg1: bitgoSignedMsg1 } }, bitgoGpgPubKey);
+        const [backupMsg2] = backupDsg.handleIncomingMessages([backupMsg1, bitgoDeserializedMsg1]);
+        const share = await (0, eddsaMPCv2_1.getSignatureShareRoundTwo)(backupMsg2, backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound2Input, JSON.parse(share.share), 'EddsaMPCv2SignatureShareRound2Input');
+        assert.strictEqual(parsed.type, 'round2Input');
+        assert.ok(parsed.data.msg2.message, 'msg2.message should be set');
+        assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');
+    });
+    it('verifyPeerMessageRoundTwo should verify a valid BitGo round-2 message', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const userMsg1 = userDsg.getFirstMessage();
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const bitgoMsg1 = bitgoDsg.getFirstMessage();
+        const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, userMsg1]);
+        const bitgoSignedMsg2 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: bitgoSignedMsg2 },
+        };
+        const result = await (0, eddsaMPCv2_1.verifyPeerMessageRoundTwo)(round2Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.ok(result.payload.length > 0, 'payload should be non-empty');
+    });
+    it('verifyPeerMessageRoundTwo should throw on a tampered message', async () => {
+        const round2Output = {
+            type: 'round2Output',
+            data: {
+                msg2: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, eddsaMPCv2_1.verifyPeerMessageRoundTwo)(round2Output, bitgoGpgPubKey), 'should throw on invalid signature');
+    });
+    // ── Round 3 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundThree should build a valid round-3 share', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const userDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const userMsg1 = userDsg.getFirstMessage();
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const bitgoMsg1 = bitgoDsg.getFirstMessage();
+        // Advance to round 2
+        const bitgoSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);
+        const bitgoDeserializedMsg1 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundOne)({ type: 'round1Output', data: { msg1: bitgoSignedMsg1 } }, bitgoGpgPubKey);
+        const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);
+        const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, userMsg1]);
+        const bitgoSignedMsg2 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);
+        const bitgoDeserializedMsg2 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundTwo)({ type: 'round2Output', data: { msg2: bitgoSignedMsg2 } }, bitgoGpgPubKey);
+        const [userMsg3] = userDsg.handleIncomingMessages([userMsg2, bitgoDeserializedMsg2]);
+        const share = await (0, eddsaMPCv2_1.getSignatureShareRoundThree)(userMsg3, userGpgPrivKey);
+        assert.strictEqual(share.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound3Input, JSON.parse(share.share), 'EddsaMPCv2SignatureShareRound3Input');
+        assert.strictEqual(parsed.type, 'round3Input');
+        assert.ok(parsed.data.msg3.message, 'msg3.message should be set');
+        assert.ok(parsed.data.msg3.signature, 'msg3.signature should be set');
+    });
+    it('getSignatureShareRoundThree should build a valid backup round-3 share', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const backupDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        await backupDsg.initDsg(backupKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        const backupMsg1 = backupDsg.getFirstMessage();
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        const bitgoMsg1 = bitgoDsg.getFirstMessage();
+        const bitgoSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);
+        const bitgoDeserializedMsg1 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundOne)({ type: 'round1Output', data: { msg1: bitgoSignedMsg1 } }, bitgoGpgPubKey);
+        const [backupMsg2] = backupDsg.handleIncomingMessages([backupMsg1, bitgoDeserializedMsg1]);
+        const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, backupMsg1]);
+        const bitgoSignedMsg2 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);
+        const bitgoDeserializedMsg2 = await (0, eddsaMPCv2_1.verifyPeerMessageRoundTwo)({ type: 'round2Output', data: { msg2: bitgoSignedMsg2 } }, bitgoGpgPubKey);
+        const [backupMsg3] = backupDsg.handleIncomingMessages([backupMsg2, bitgoDeserializedMsg2]);
+        const share = await (0, eddsaMPCv2_1.getSignatureShareRoundThree)(backupMsg3, backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound3Input, JSON.parse(share.share), 'EddsaMPCv2SignatureShareRound3Input');
+        assert.strictEqual(parsed.type, 'round3Input');
+        assert.ok(parsed.data.msg3.message, 'msg3.message should be set');
+        assert.ok(parsed.data.msg3.signature, 'msg3.signature should be set');
+    });
+    it('verifyPeerMessageRoundThree should verify a valid BitGo round-3 message', async () => {
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const [, [bitgoMsg3]] = (await sdk_lib_mpc_1.MPSUtil.executeTillRound(2, new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.USER), new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO), userKeyShare, bitgoKeyShare, messageBuffer, derivationPath));
+        const bitgoSignedMsg3 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg3.payload), bitgoGpgPrivKey);
+        const round3Output = {
+            type: 'round3Output',
+            data: { msg3: bitgoSignedMsg3 },
+        };
+        const result = await (0, eddsaMPCv2_1.verifyPeerMessageRoundThree)(round3Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.ok(result.payload.length > 0, 'payload should be non-empty');
+    });
+    it('verifyPeerMessageRoundThree should throw on a tampered message', async () => {
+        const round3Output = {
+            type: 'round3Output',
+            data: {
+                msg3: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, eddsaMPCv2_1.verifyPeerMessageRoundThree)(round3Output, bitgoGpgPubKey), 'should throw on invalid signature');
+    });
+});
+describe('getEddsaMPCv2RecoveryKeyShares', () => {
+    const walletPassphrase = 'testPass';
+    const encryptKey = (keyShare) => sjcl.encrypt(walletPassphrase, keyShare.toString('base64'));
+    it('should return recovery key shares from v1-encrypted reduced keys (no bitgo instance)', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const result = await src_1.EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(encryptKey(userDkg.getReducedKeyShare()), encryptKey(backupDkg.getReducedKeyShare()), walletPassphrase);
+        assert.deepStrictEqual(result.userKeyShare, userDkg.getKeyShare());
+        assert.deepStrictEqual(result.backupKeyShare, backupDkg.getKeyShare());
+        assert.strictEqual(result.commonKeyChain, userDkg.getCommonKeychain());
+    });
+    it('should unwrap versioned safe-root envelopes and return VRF keyshares', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const userVrfKeyShare = Buffer.from('user-vrf-keyshare');
+        const backupVrfKeyShare = Buffer.from('backup-vrf-keyshare');
+        const encodeEnvelope = (reducedKeyShare, vrfKeyShare) => Buffer.from((0, cbor_x_1.encode)({
+            version: 1,
+            prvKeyShare: new Uint8Array(reducedKeyShare),
+            vrf: new Uint8Array(vrfKeyShare),
+        }));
+        const result = await src_1.EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(encryptKey(encodeEnvelope(userDkg.getReducedKeyShare(), userVrfKeyShare)), encryptKey(encodeEnvelope(backupDkg.getReducedKeyShare(), backupVrfKeyShare)), walletPassphrase);
+        assert.strictEqual(Buffer.compare(result.userKeyShare, userDkg.getKeyShare()), 0);
+        assert.strictEqual(Buffer.compare(result.backupKeyShare, backupDkg.getKeyShare()), 0);
+        assert.strictEqual(result.commonKeyChain, userDkg.getCommonKeychain());
+        assert.ok(result.userVrfKeyShare);
+        assert.ok(result.backupVrfKeyShare);
+        assert.strictEqual(Buffer.compare(result.userVrfKeyShare, userVrfKeyShare), 0);
+        assert.strictEqual(Buffer.compare(result.backupVrfKeyShare, backupVrfKeyShare), 0);
+    });
+    it('should route decryption through bitgo.decrypt when a bitgo instance is provided', async () => {
+        // sdk-core has no devDependency on sdk-api or argon2, so we cannot encrypt with a real v2 envelope here.
+        // The stub verifies that the function delegates to bitgo.decrypt (which supports v1 + v2 in
+        // production) rather than falling back to sjcl.decrypt.
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const userKeyBase64 = userDkg.getReducedKeyShare().toString('base64');
+        const backupKeyBase64 = backupDkg.getReducedKeyShare().toString('base64');
+        const mockBitgo = {
+            decrypt: sinon.stub().onFirstCall().resolves(userKeyBase64).onSecondCall().resolves(backupKeyBase64),
+        };
+        const result = await src_1.EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey('encrypted-user-key', 'encrypted-backup-key', walletPassphrase, mockBitgo);
+        sinon.assert.calledTwice(mockBitgo.decrypt);
+        assert.deepStrictEqual(result.userKeyShare, userDkg.getKeyShare());
+        assert.deepStrictEqual(result.backupKeyShare, backupDkg.getKeyShare());
+        assert.strictEqual(result.commonKeyChain, userDkg.getCommonKeychain());
+    });
+    it('should reject a malformed keycard with a descriptive error', async () => {
+        const [userDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const malformedKey = sjcl.encrypt(walletPassphrase, (0, crypto_1.randomBytes)(64).toString('base64'));
+        await assert.rejects(src_1.EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(malformedKey, encryptKey(userDkg.getReducedKeyShare()), walletPassphrase), /unable to decode reduced key share/);
+    });
+    it('should reject reduced keys from different wallets', async () => {
+        const [userDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const [, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        await assert.rejects(src_1.EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(encryptKey(userDkg.getReducedKeyShare()), encryptKey(backupDkg.getReducedKeyShare()), walletPassphrase), /pub keys do not match/);
+    });
+    it('should reject reduced keys with matching pub but mismatched rootChainCodes', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const userReducedKeyShare = userDkg.getReducedKeyShare();
+        const backupReducedKeyShare = backupDkg.getReducedKeyShare();
+        const getDecodedReducedKeyShare = sdk_lib_mpc_1.MPSTypes.getDecodedReducedKeyShare;
+        const decodeStub = sinon.stub(sdk_lib_mpc_1.MPSTypes, 'getDecodedReducedKeyShare').callsFake((buf) => {
+            const reduced = getDecodedReducedKeyShare(buf);
+            if (Buffer.from(buf).equals(backupReducedKeyShare)) {
+                return {
+                    ...reduced,
+                    rootChainCode: Array.from((0, crypto_1.randomBytes)(32)),
+                };
+            }
+            return reduced;
+        });
+        try {
+            await assert.rejects(src_1.EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(encryptKey(userReducedKeyShare), encryptKey(backupReducedKeyShare), walletPassphrase), /rootChainCodes do not match/);
+        }
+        finally {
+            decodeStub.restore();
+        }
+    });
+});
+describe('EddsaMPCv2Utils.createOfflineRound1Share', () => {
+    let eddsaMPCv2Utils;
+    let mockBitgo;
+    let userKeyShare;
+    const walletPassphrase = 'testPass';
+    const signableHex = 'deadbeef';
+    const derivationPath = 'm/0/0';
+    const expectedAdata = `${signableHex}:${derivationPath}`;
+    const txRequest = {
+        txRequestId: 'txreq-eddsa-round1',
+        walletId: 'wallet-eddsa-round1',
+        enterpriseId: 'enterprise-eddsa-round1',
+        apiVersion: 'full',
+        transactions: [
+            {
+                unsignedTx: {
+                    signableHex,
+                    derivationPath,
+                    serializedTxHex: signableHex,
+                },
+                signatureShares: [],
+            },
+        ],
+        intent: { intentType: 'payment' },
+        unsignedTxs: [],
+    };
+    before('generate EdDSA user key share', async () => {
+        const [userDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        userKeyShare = userDkg.getKeyShare();
+    });
+    beforeEach(() => {
+        const sjclEncrypt = (params) => {
+            const salt = (0, crypto_1.randomBytes)(8);
+            const iv = (0, crypto_1.randomBytes)(16);
+            return sjcl.encrypt(params.password, params.input, {
+                salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],
+                iv: [
+                    bytesToWord(iv.subarray(0, 4)),
+                    bytesToWord(iv.subarray(4, 8)),
+                    bytesToWord(iv.subarray(8, 12)),
+                    bytesToWord(iv.subarray(12, 16)),
+                ],
+                adata: params.adata,
+            });
+        };
+        mockBitgo = {
+            encrypt: sinon.stub().callsFake(async (params) => sjclEncrypt(params)),
+        };
+        const mockCoin = {
+            getMPCAlgorithm: sinon.stub().returns('eddsa'),
+        };
+        eddsaMPCv2Utils = new src_1.EddsaMPCv2Utils(mockBitgo, mockCoin);
+    });
+    it('should create a round-1 share and encrypted SJCL session payload', async () => {
+        const result = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        assert.strictEqual(result.signatureShareRound1.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(result.signatureShareRound1.to, src_1.SignatureShareType.BITGO);
+        assert.ok(result.userGpgPubKey.includes('BEGIN PGP PUBLIC KEY BLOCK'));
+        assert.ok(JSON.parse(result.encryptedRound1Session).ct, 'encryptedRound1Session should be an SJCL JSON blob');
+        assert.ok(JSON.parse(result.encryptedUserGpgPrvKey).ct, 'encryptedUserGpgPrvKey should be an SJCL JSON blob');
+        const parsedShare = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound1Input, JSON.parse(result.signatureShareRound1.share), 'EddsaMPCv2SignatureShareRound1Input');
+        assert.strictEqual(parsedShare.type, 'round1Input');
+        assert.ok(parsedShare.data.msg1.message, 'msg1.message should be set');
+        assert.ok(parsedShare.data.msg1.signature, 'msg1.signature should be set');
+        const encryptedRound1Session = JSON.parse(result.encryptedRound1Session);
+        const encryptedUserGpgPrvKey = JSON.parse(result.encryptedUserGpgPrvKey);
+        assert.strictEqual(decodeURIComponent(encryptedRound1Session.adata), `MPS_DSG_SIGNING_ROUND1_STATE:${expectedAdata}`, 'round-1 session adata should bind the signing context');
+        assert.strictEqual(decodeURIComponent(encryptedUserGpgPrvKey.adata), `MPS_DSG_SIGNING_USER_GPG_KEY:${expectedAdata}`, 'GPG private key adata should bind the signing context');
+        const sessionPayload = JSON.parse(sjcl.decrypt(walletPassphrase, result.encryptedRound1Session));
+        assert.ok(sessionPayload.dsgSession, 'dsgSession should be persisted for round 2');
+        assert.ok(sessionPayload.userMsgPayload, 'userMsgPayload should be persisted for round 2');
+    });
+    it('should use v2 encryption when encryptedPrv is a v2 envelope', async () => {
+        const encrypt = sinon
+            .stub()
+            .callsFake((input, adata) => Promise.resolve(JSON.stringify({ v: 2, input, adata })));
+        const destroy = sinon.stub();
+        const createEncryptionSession = sinon.stub().resolves({ encrypt, destroy });
+        mockBitgo.createEncryptionSession = createEncryptionSession;
+        const result = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+            encryptedPrv: JSON.stringify({ v: 2 }),
+        });
+        sinon.assert.calledOnce(createEncryptionSession);
+        assert.strictEqual(createEncryptionSession.getCall(0).args[0], walletPassphrase);
+        sinon.assert.notCalled(mockBitgo.encrypt);
+        sinon.assert.calledTwice(encrypt);
+        sinon.assert.calledOnce(destroy);
+        const encryptedRound1Session = JSON.parse(result.encryptedRound1Session);
+        const encryptedUserGpgPrvKey = JSON.parse(result.encryptedUserGpgPrvKey);
+        assert.strictEqual(encryptedRound1Session.v, 2);
+        assert.strictEqual(encryptedRound1Session.adata, `MPS_DSG_SIGNING_ROUND1_STATE:${expectedAdata}`);
+        assert.strictEqual(encryptedUserGpgPrvKey.v, 2);
+        assert.strictEqual(encryptedUserGpgPrvKey.adata, `MPS_DSG_SIGNING_USER_GPG_KEY:${expectedAdata}`);
+        const sessionPayload = JSON.parse(encryptedRound1Session.input);
+        assert.ok(sessionPayload.dsgSession, 'dsgSession should be persisted for round 2');
+        assert.ok(sessionPayload.userMsgPayload, 'userMsgPayload should be persisted for round 2');
+    });
+    it('should use SJCL encryption when encryptedPrv is a v1 blob', async () => {
+        mockBitgo.createEncryptionSession = sinon.stub();
+        const encryptedPrv = sjcl.encrypt(walletPassphrase, userKeyShare.toString('base64'));
+        const result = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+            encryptedPrv,
+        });
+        sinon.assert.notCalled(mockBitgo.createEncryptionSession);
+        sinon.assert.calledTwice(mockBitgo.encrypt);
+        assert.ok(JSON.parse(result.encryptedRound1Session).ct, 'encryptedRound1Session should be an SJCL JSON blob');
+        assert.ok(JSON.parse(result.encryptedUserGpgPrvKey).ct, 'encryptedUserGpgPrvKey should be an SJCL JSON blob');
+    });
+    it('should propagate the tx-only guard when transactions are missing', async () => {
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: { ...txRequest, transactions: undefined },
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        }), /Unable to find transactions in txRequest/);
+    });
+});
+describe('EddsaMPCv2Utils.createOfflineKeyGenRound1Share', () => {
+    let eddsaMPCv2Utils;
+    let mockBitgo;
+    let userGpgKeyPair;
+    let backupGpgKeyPair;
+    let bitgoGpgKeyPair;
+    const walletPassphrase = 'testPass';
+    before('generate GPG key pairs', async () => {
+        userGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        backupGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        bitgoGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+    });
+    beforeEach(() => {
+        const sjclEncrypt = (params) => {
+            const salt = (0, crypto_1.randomBytes)(8);
+            const iv = (0, crypto_1.randomBytes)(16);
+            return sjcl.encrypt(params.password, params.input, {
+                salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],
+                iv: [
+                    bytesToWord(iv.subarray(0, 4)),
+                    bytesToWord(iv.subarray(4, 8)),
+                    bytesToWord(iv.subarray(8, 12)),
+                    bytesToWord(iv.subarray(12, 16)),
+                ],
+                adata: params.adata,
+            });
+        };
+        mockBitgo = {
+            encrypt: sinon.stub().callsFake(sjclEncrypt),
+            encryptAsync: sinon.stub().callsFake(async (params) => sjclEncrypt(params)),
+            decrypt: sinon.stub().callsFake((params) => sjcl.decrypt(params.password, params.input)),
+            decryptAsync: sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input)),
+            getEnv: sinon.stub().returns('mock'),
+        };
+        const mockCoin = {
+            getMPCAlgorithm: sinon.stub().returns('eddsa'),
+        };
+        eddsaMPCv2Utils = new src_1.EddsaMPCv2Utils(mockBitgo, mockCoin);
+    });
+    it('should produce valid signedMsg1 and encrypted round-1 session', async () => {
+        const encryptedUserGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);
+        const result = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({
+            walletPassphrase,
+            encryptedUserGpgPrvKey,
+            bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,
+            counterPartyGpgPubKey: backupGpgKeyPair.publicKey,
+        });
+        assert.ok(result.signedMsg1.message, 'signedMsg1.message should be set');
+        assert.ok(result.signedMsg1.signature.includes('BEGIN PGP SIGNATURE'), 'signedMsg1.signature should be PGP armored');
+        assert.ok(JSON.parse(result.encryptedRound1Session).ct, 'encryptedRound1Session should be an SJCL JSON blob');
+    });
+    it('encryptedRound1Session should only be decryptable with correct walletPassphrase', async () => {
+        const encryptedUserGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);
+        const result = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({
+            walletPassphrase,
+            encryptedUserGpgPrvKey,
+            bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,
+            counterPartyGpgPubKey: backupGpgKeyPair.publicKey,
+        });
+        const decrypted = sjcl.decrypt(walletPassphrase, result.encryptedRound1Session);
+        const session = JSON.parse(decrypted);
+        assert.ok(session.dkgSession, 'dkgSession should be persisted');
+        assert.ok(session.ownMsgPayload, 'ownMsgPayload should be persisted');
+        assert.strictEqual(typeof session.ownMsgFrom, 'number', 'ownMsgFrom should be a number');
+        assert.throws(() => sjcl.decrypt('wrongpassphrase', result.encryptedRound1Session), 'should throw on wrong passphrase');
+    });
+    it('should restore DKG session and handle round-2 messages after round 1', async () => {
+        const encryptedUserGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);
+        const result = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({
+            walletPassphrase,
+            encryptedUserGpgPrvKey,
+            bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,
+            counterPartyGpgPubKey: backupGpgKeyPair.publicKey,
+        });
+        const decrypted = sjcl.decrypt(walletPassphrase, result.encryptedRound1Session);
+        const { dkgSession, ownMsgPayload, ownMsgFrom } = JSON.parse(decrypted);
+        const restoredDkg = new sdk_lib_mpc_1.EddsaMPSDkg.DKG(3, 2, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        await restoredDkg.restoreSession(dkgSession);
+        const ownMsg1 = {
+            from: ownMsgFrom,
+            payload: new Uint8Array(Buffer.from(ownMsgPayload, 'base64')),
+        };
+        assert.ok(ownMsg1.payload.length > 0, 'restored payload should be non-empty');
+        const userGpgKey = await pgp.readKey({ armoredKey: userGpgKeyPair.publicKey });
+        const rawBytes = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(result.signedMsg1, userGpgKey);
+        assert.ok(rawBytes.length > 0, 'signedMsg1 should verify against user GPG key');
+    });
+    it('should reject invalid encryptedUserGpgPrvKey', async () => {
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineKeyGenRound1Share({
+            walletPassphrase,
+            encryptedUserGpgPrvKey: sjcl.encrypt(walletPassphrase, 'not-a-gpg-key'),
+            bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,
+            counterPartyGpgPubKey: backupGpgKeyPair.publicKey,
+        }), 'should throw when GPG key cannot be parsed');
+    });
+    it('USER and BACKUP partyId produce different encrypted session state', async () => {
+        const userEncryptedGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);
+        const userResult = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({
+            walletPassphrase,
+            encryptedUserGpgPrvKey: userEncryptedGpgPrvKey,
+            bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,
+            counterPartyGpgPubKey: backupGpgKeyPair.publicKey,
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.USER,
+        });
+        const backupEncryptedGpgPrvKey2 = sjcl.encrypt(walletPassphrase, backupGpgKeyPair.privateKey);
+        const backupResult = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({
+            walletPassphrase,
+            encryptedUserGpgPrvKey: backupEncryptedGpgPrvKey2,
+            bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,
+            counterPartyGpgPubKey: userGpgKeyPair.publicKey,
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.BACKUP,
+        });
+        const userSession = JSON.parse(sjcl.decrypt(walletPassphrase, userResult.encryptedRound1Session));
+        const backupSession = JSON.parse(sjcl.decrypt(walletPassphrase, backupResult.encryptedRound1Session));
+        assert.strictEqual(userSession.ownMsgFrom, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        assert.strictEqual(backupSession.ownMsgFrom, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.notStrictEqual(userSession.dkgSession, backupSession.dkgSession, 'Sessions should differ between parties');
+        // Sessions encrypted with party-bound adata — tampered adata fails CCM tag check
+        const tamperedSession = (() => {
+            const parsed = JSON.parse(userResult.encryptedRound1Session);
+            parsed.adata = encodeURIComponent(`MPS_DKG_KEYGEN_ROUND1_STATE:${typesMPCv2_1.MPCv2PartiesEnum.BACKUP}`);
+            return JSON.stringify(parsed);
+        })();
+        assert.throws(() => sjcl.decrypt(walletPassphrase, tamperedSession), 'should fail to decrypt with wrong party adata');
+    });
+});
+describe('EddsaMPCv2Utils.createOfflineRound2Share', () => {
+    let eddsaMPCv2Utils;
+    let mockBitgo;
+    let userKeyShare;
+    let bitgoKeyShare;
+    let bitgoGpgKeyPair;
+    let bitgoGpgPrivKey;
+    const walletPassphrase = 'testPass';
+    const signableHex = 'deadbeef';
+    const derivationPath = 'm/0/0';
+    const expectedAdata = `${signableHex}:${derivationPath}`;
+    const baseTxRequest = {
+        txRequestId: 'txreq-eddsa-round2',
+        walletId: 'wallet-eddsa-round2',
+        enterpriseId: 'enterprise-eddsa-round2',
+        apiVersion: 'full',
+        transactions: [
+            {
+                unsignedTx: {
+                    signableHex,
+                    derivationPath,
+                    serializedTxHex: signableHex,
+                },
+                signatureShares: [],
+            },
+        ],
+        intent: { intentType: 'payment' },
+        unsignedTxs: [],
+    };
+    before('generate EdDSA key shares and GPG keys', async () => {
+        const [userDkg, , bitgoDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        userKeyShare = userDkg.getKeyShare();
+        bitgoKeyShare = bitgoDkg.getKeyShare();
+        bitgoGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });
+    });
+    beforeEach(() => {
+        mockBitgo = {
+            encrypt: sinon.stub().callsFake(async (params) => {
+                const salt = (0, crypto_1.randomBytes)(8);
+                const iv = (0, crypto_1.randomBytes)(16);
+                return sjcl.encrypt(params.password, params.input, {
+                    salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],
+                    iv: [
+                        bytesToWord(iv.subarray(0, 4)),
+                        bytesToWord(iv.subarray(4, 8)),
+                        bytesToWord(iv.subarray(8, 12)),
+                        bytesToWord(iv.subarray(12, 16)),
+                    ],
+                    adata: params.adata,
+                });
+            }),
+            decrypt: sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input)),
+        };
+        const mockCoin = {
+            getMPCAlgorithm: sinon.stub().returns('eddsa'),
+        };
+        eddsaMPCv2Utils = new src_1.EddsaMPCv2Utils(mockBitgo, mockCoin);
+    });
+    it('should create a round-2 share from offline round 1', async () => {
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: baseTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const txRequestRound1 = await signBitgoEddsaRound1(bitgoDsg, cloneTxRequestWithEmptySignatureShares(baseTxRequest), round1.signatureShareRound1, round1.userGpgPubKey, bitgoGpgPrivKey);
+        const round2 = await eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: txRequestRound1,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        });
+        assert.strictEqual(round2.signatureShareRound2.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(round2.signatureShareRound2.to, src_1.SignatureShareType.BITGO);
+        const parsedShare = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound2Input, JSON.parse(round2.signatureShareRound2.share), 'EddsaMPCv2SignatureShareRound2Input');
+        assert.strictEqual(parsedShare.type, 'round2Input');
+        assert.ok(parsedShare.data.msg2.message, 'msg2.message should be set');
+        assert.ok(parsedShare.data.msg2.signature, 'msg2.signature should be set');
+        const encryptedRound2Session = JSON.parse(round2.encryptedRound2Session);
+        assert.strictEqual(decodeURIComponent(encryptedRound2Session.adata), `MPS_DSG_SIGNING_ROUND2_STATE:${expectedAdata}`);
+        const sessionPayload = JSON.parse(sjcl.decrypt(walletPassphrase, round2.encryptedRound2Session));
+        assert.ok(sessionPayload.dsgSession, 'dsgSession should be persisted for round 3');
+        assert.ok(sessionPayload.userMsgPayload, 'userMsgPayload should be persisted for round 3');
+    });
+    it('should use v2 decryption when encryptedRound1Session is a v2 envelope', async () => {
+        const encrypt = sinon
+            .stub()
+            .callsFake((input, adata) => Promise.resolve(JSON.stringify({ v: 2, input, adata })));
+        const destroy = sinon.stub();
+        const createEncryptionSession = sinon.stub().resolves({ encrypt, destroy });
+        mockBitgo.createEncryptionSession = createEncryptionSession;
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: baseTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+            encryptedPrv: JSON.stringify({ v: 2 }),
+        });
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const txRequestRound1 = await signBitgoEddsaRound1(bitgoDsg, cloneTxRequestWithEmptySignatureShares(baseTxRequest), round1.signatureShareRound1, round1.userGpgPubKey, bitgoGpgPrivKey);
+        const decrypt = sinon.stub().callsFake(async (params) => {
+            const envelope = JSON.parse(params.input);
+            return envelope.input;
+        });
+        mockBitgo.decrypt = decrypt;
+        const round2 = await eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: txRequestRound1,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        });
+        sinon.assert.called(mockBitgo.decrypt);
+        assert.strictEqual(round2.signatureShareRound2.from, src_1.SignatureShareType.USER);
+        const encryptedRound2Session = JSON.parse(round2.encryptedRound2Session);
+        assert.strictEqual(encryptedRound2Session.v, 2);
+        assert.strictEqual(encryptedRound2Session.adata, `MPS_DSG_SIGNING_ROUND2_STATE:${expectedAdata}`);
+    });
+    it('should reject tampered encryptedRound1Session adata', async () => {
+        const otherTxRequest = {
+            ...baseTxRequest,
+            transactions: [
+                {
+                    unsignedTx: {
+                        signableHex: 'cafebabe',
+                        derivationPath: 'm/1/2',
+                        serializedTxHex: 'cafebabe',
+                    },
+                    signatureShares: [],
+                },
+            ],
+        };
+        const round1Other = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: otherTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: baseTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const txRequestRound1 = await signBitgoEddsaRound1(bitgoDsg, cloneTxRequestWithEmptySignatureShares(baseTxRequest), round1.signatureShareRound1, round1.userGpgPubKey, bitgoGpgPrivKey);
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: txRequestRound1,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1Other.encryptedRound1Session,
+        }), /Adata does not match cyphertext adata/);
+    });
+    it('should reject tampered encryptedUserGpgPrvKey adata', async () => {
+        const otherTxRequest = {
+            ...baseTxRequest,
+            transactions: [
+                {
+                    unsignedTx: {
+                        signableHex: 'cafebabe',
+                        derivationPath: 'm/1/2',
+                        serializedTxHex: 'cafebabe',
+                    },
+                    signatureShares: [],
+                },
+            ],
+        };
+        const round1Other = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: otherTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: baseTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        const messageBuffer = Buffer.from(signableHex, 'hex');
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const txRequestRound1 = await signBitgoEddsaRound1(bitgoDsg, cloneTxRequestWithEmptySignatureShares(baseTxRequest), round1.signatureShareRound1, round1.userGpgPubKey, bitgoGpgPrivKey);
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: txRequestRound1,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1Other.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        }), /Adata does not match cyphertext adata/);
+    });
+    it('should reject when BitGo signature share is missing', async () => {
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: baseTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        const baseTransaction = assertSingleTransaction(baseTxRequest);
+        const txRequestNoBitgoShare = {
+            ...baseTxRequest,
+            transactions: [
+                {
+                    ...baseTransaction,
+                    signatureShares: [round1.signatureShareRound1],
+                },
+            ],
+        };
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: txRequestNoBitgoShare,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        }), /Missing BitGo round1Output signature share/);
+    });
+    it('should propagate the tx-only guard when transactions are missing', async () => {
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: baseTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: { ...baseTxRequest, transactions: undefined },
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        }), /Unable to find transactions in txRequest/);
+    });
+    it('should reject when transactions array is empty', async () => {
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest: baseTxRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+        });
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: { ...baseTxRequest, transactions: [] },
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        }), /Unable to find transactions in txRequest/);
+    });
+});
+describe('EddsaMPCv2Utils.createOfflineRound3Share', () => {
+    let eddsaMPCv2Utils;
+    let mockBitgo;
+    let userKeyShare;
+    let bitgoKeyShare;
+    let bitgoGpgKeyPair;
+    let bitgoGpgPrivKey;
+    const walletPassphrase = 'testPass';
+    const signableHex = 'deadbeef';
+    const derivationPath = 'm/0/0';
+    const baseTxRequest = {
+        txRequestId: 'txreq-eddsa-round3',
+        walletId: 'wallet-eddsa-round3',
+        enterpriseId: 'enterprise-eddsa-round3',
+        apiVersion: 'full',
+        transactions: [
+            {
+                unsignedTx: {
+                    signableHex,
+                    derivationPath,
+                    serializedTxHex: signableHex,
+                },
+                signatureShares: [],
+            },
+        ],
+        intent: { intentType: 'payment' },
+        unsignedTxs: [],
+    };
+    before('generate EdDSA key shares and GPG keys', async () => {
+        const [userDkg, , bitgoDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        userKeyShare = userDkg.getKeyShare();
+        bitgoKeyShare = bitgoDkg.getKeyShare();
+        bitgoGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });
+    });
+    beforeEach(() => {
+        mockBitgo = {
+            encrypt: sinon.stub().callsFake(async (params) => {
+                const salt = (0, crypto_1.randomBytes)(8);
+                const iv = (0, crypto_1.randomBytes)(16);
+                return sjcl.encrypt(params.password, params.input, {
+                    salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],
+                    iv: [
+                        bytesToWord(iv.subarray(0, 4)),
+                        bytesToWord(iv.subarray(4, 8)),
+                        bytesToWord(iv.subarray(8, 12)),
+                        bytesToWord(iv.subarray(12, 16)),
+                    ],
+                    adata: params.adata,
+                });
+            }),
+            decrypt: sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input)),
+        };
+        const mockCoin = {
+            getMPCAlgorithm: sinon.stub().returns('eddsa'),
+        };
+        eddsaMPCv2Utils = new src_1.EddsaMPCv2Utils(mockBitgo, mockCoin);
+    });
+    async function createRound2Flow(txRequest, encryptedPrv) {
+        const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({
+            txRequest,
+            prv: userKeyShare.toString('base64'),
+            walletPassphrase,
+            encryptedPrv,
+        });
+        const transaction = assertSingleTransaction(txRequest);
+        const messageBuffer = Buffer.from(transaction.unsignedTx.signableHex, 'hex');
+        const bitgoDsg = new sdk_lib_mpc_1.EddsaMPSDsg.DSG(typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, transaction.unsignedTx.derivationPath, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const txRequestRound1 = await signBitgoEddsaRound1(bitgoDsg, cloneTxRequestWithEmptySignatureShares(txRequest), round1.signatureShareRound1, round1.userGpgPubKey, bitgoGpgPrivKey);
+        const round2 = await eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: txRequestRound1,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        });
+        const round1Transaction = assertSingleTransaction(txRequestRound1);
+        const txRequestRound2 = await signBitgoEddsaRound2(bitgoDsg, {
+            ...txRequestRound1,
+            transactions: [
+                {
+                    ...round1Transaction,
+                    signatureShares: [...round1Transaction.signatureShares],
+                },
+            ],
+        }, round2.signatureShareRound2, round1.userGpgPubKey, bitgoGpgPrivKey);
+        return { round1, round2, txRequestRound1, txRequestRound2, messageBuffer };
+    }
+    it('should create a round-3 share from offline round 2', async () => {
+        const { round1, round2, txRequestRound2 } = await createRound2Flow(baseTxRequest);
+        const round3 = await eddsaMPCv2Utils.createOfflineRound3Share({
+            txRequest: txRequestRound2,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound2Session: round2.encryptedRound2Session,
+        });
+        assert.strictEqual(round3.signatureShareRound3.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(round3.signatureShareRound3.to, src_1.SignatureShareType.BITGO);
+        const parsedShare = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound3Input, JSON.parse(round3.signatureShareRound3.share), 'EddsaMPCv2SignatureShareRound3Input');
+        assert.strictEqual(parsedShare.type, 'round3Input');
+        assert.ok(parsedShare.data.msg3.message, 'msg3.message should be set');
+        assert.ok(parsedShare.data.msg3.signature, 'msg3.signature should be set');
+    });
+    it('should use v2 decryption when encryptedRound2Session is a v2 envelope', async () => {
+        const encrypt = sinon
+            .stub()
+            .callsFake((input, adata) => Promise.resolve(JSON.stringify({ v: 2, input, adata })));
+        const destroy = sinon.stub();
+        const createEncryptionSession = sinon.stub().resolves({ encrypt, destroy });
+        mockBitgo.createEncryptionSession = createEncryptionSession;
+        const decrypt = sinon.stub().callsFake(async (params) => {
+            const envelope = JSON.parse(params.input);
+            return envelope.input;
+        });
+        mockBitgo.decrypt = decrypt;
+        const { round1, round2, txRequestRound2 } = await createRound2Flow(baseTxRequest, JSON.stringify({ v: 2 }));
+        const round3 = await eddsaMPCv2Utils.createOfflineRound3Share({
+            txRequest: txRequestRound2,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound2Session: round2.encryptedRound2Session,
+        });
+        assert.strictEqual(mockBitgo.decrypt.callCount, 4);
+        assert.strictEqual(round3.signatureShareRound3.from, src_1.SignatureShareType.USER);
+    });
+    it('should reject tampered encryptedRound2Session adata', async () => {
+        const otherTxRequest = {
+            ...baseTxRequest,
+            transactions: [
+                {
+                    unsignedTx: {
+                        signableHex: 'cafebabe',
+                        derivationPath: 'm/1/2',
+                        serializedTxHex: 'cafebabe',
+                    },
+                    signatureShares: [],
+                },
+            ],
+        };
+        const otherFlow = await createRound2Flow(otherTxRequest);
+        const { round1, txRequestRound2 } = await createRound2Flow(baseTxRequest);
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound3Share({
+            txRequest: txRequestRound2,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound2Session: otherFlow.round2.encryptedRound2Session,
+        }), /Adata does not match cyphertext adata/);
+    });
+    it('should reject tampered encryptedUserGpgPrvKey adata', async () => {
+        const otherTxRequest = {
+            ...baseTxRequest,
+            transactions: [
+                {
+                    unsignedTx: {
+                        signableHex: 'cafebabe',
+                        derivationPath: 'm/1/2',
+                        serializedTxHex: 'cafebabe',
+                    },
+                    signatureShares: [],
+                },
+            ],
+        };
+        const otherFlow = await createRound2Flow(otherTxRequest);
+        const { round2, txRequestRound2 } = await createRound2Flow(baseTxRequest);
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound3Share({
+            txRequest: txRequestRound2,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: otherFlow.round1.encryptedUserGpgPrvKey,
+            encryptedRound2Session: round2.encryptedRound2Session,
+        }), /Adata does not match cyphertext adata/);
+    });
+    it('should reject when BitGo round-2 signature share is missing', async () => {
+        const { round1, round2, txRequestRound1 } = await createRound2Flow(baseTxRequest);
+        const round1Transaction = assertSingleTransaction(txRequestRound1);
+        const txRequestNoBitgoRound2Share = {
+            ...txRequestRound1,
+            transactions: [
+                {
+                    ...round1Transaction,
+                    signatureShares: [...round1Transaction.signatureShares, round2.signatureShareRound2],
+                },
+            ],
+        };
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound3Share({
+            txRequest: txRequestNoBitgoRound2Share,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound2Session: round2.encryptedRound2Session,
+        }), /Missing BitGo round2Output signature share/);
+    });
+    it('should propagate the tx-only guard when transactions are missing', async () => {
+        const { round1, round2 } = await createRound2Flow(baseTxRequest);
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound3Share({
+            txRequest: { ...baseTxRequest, transactions: undefined },
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound2Session: round2.encryptedRound2Session,
+        }), /Unable to find transactions in txRequest/);
+    });
+    it('should reject when transactions array is empty', async () => {
+        const { round1, round2 } = await createRound2Flow(baseTxRequest);
+        await assert.rejects(() => eddsaMPCv2Utils.createOfflineRound3Share({
+            txRequest: { ...baseTxRequest, transactions: [] },
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound2Session: round2.encryptedRound2Session,
+        }), /Unable to find transactions in txRequest/);
+    });
+});
+describe('getBitgoSignatureShare', () => {
+    const round1OutputShare = {
+        from: src_1.SignatureShareType.BITGO,
+        to: src_1.SignatureShareType.USER,
+        share: JSON.stringify({ type: 'round1Output', data: {} }),
+    };
+    const round2OutputShare = {
+        from: src_1.SignatureShareType.BITGO,
+        to: src_1.SignatureShareType.USER,
+        share: JSON.stringify({ type: 'round2Output', data: {} }),
+    };
+    it('selects the requested BitGo round output when multiple round outputs are present', () => {
+        const signatureShares = [round1OutputShare, round2OutputShare];
+        assert.strictEqual((0, common_1.getBitgoSignatureShare)(signatureShares, src_1.SignatureShareType.USER, 'round2Output'), round2OutputShare);
+        assert.strictEqual((0, common_1.getBitgoSignatureShare)(signatureShares, src_1.SignatureShareType.USER, 'round1Output'), round1OutputShare);
+    });
+    it('skips malformed share records while selecting the requested BitGo round output', () => {
+        const malformedShare = {
+            from: src_1.SignatureShareType.BITGO,
+            to: src_1.SignatureShareType.USER,
+            share: 'not-json',
+        };
+        assert.strictEqual((0, common_1.getBitgoSignatureShare)([malformedShare, round2OutputShare], src_1.SignatureShareType.USER, 'round2Output'), round2OutputShare);
+    });
+});
+function assertSingleTransaction(txRequest) {
+    assert.ok(txRequest.transactions, 'txRequest must include transactions');
+    assert.strictEqual(txRequest.transactions.length, 1, 'txRequest must have exactly one transaction');
+    return txRequest.transactions[0];
+}
+function cloneTxRequestWithEmptySignatureShares(txRequest) {
+    const transaction = assertSingleTransaction(txRequest);
+    return {
+        ...txRequest,
+        transactions: [{ ...transaction, signatureShares: [] }],
+    };
+}
+async function signBitgoEddsaRound1(bitgoDsg, txRequest, userRound1Share, userGpgPubKeyArmored, bitgoGpgPrivKey) {
+    const transaction = assertSingleTransaction(txRequest);
+    transaction.signatureShares.push(userRound1Share);
+    const bitgoMsg1 = bitgoDsg.getFirstMessage();
+    const parsedUserShare = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound1Input, JSON.parse(userRound1Share.share), 'EddsaMPCv2SignatureShareRound1Input');
+    const userGpgKey = await pgp.readKey({ armoredKey: userGpgPubKeyArmored });
+    const userRawMsg1Bytes = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(parsedUserShare.data.msg1, userGpgKey);
+    const userMsg1 = {
+        from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+        payload: new Uint8Array(userRawMsg1Bytes),
+    };
+    const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, userMsg1]);
+    assert.ok(bitgoMsg2, 'BitGo DSG produced no round-2 output');
+    bitgoDsg.round2Message = bitgoMsg2;
+    const bitgoSignedMsg1 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);
+    const round1Output = {
+        type: 'round1Output',
+        data: { msg1: bitgoSignedMsg1 },
+    };
+    transaction.signatureShares.push({
+        from: src_1.SignatureShareType.BITGO,
+        to: src_1.SignatureShareType.USER,
+        share: JSON.stringify(round1Output),
+    });
+    return txRequest;
+}
+async function signBitgoEddsaRound2(bitgoDsg, txRequest, userRound2Share, userGpgPubKeyArmored, bitgoGpgPrivKey) {
+    const transaction = assertSingleTransaction(txRequest);
+    transaction.signatureShares.push(userRound2Share);
+    const userGpgKey = await pgp.readKey({ armoredKey: userGpgPubKeyArmored });
+    const bitgoMsg2 = bitgoDsg.round2Message;
+    assert.ok(bitgoMsg2, 'BitGo DSG is missing the cached round-2 output');
+    const parsedUserRound2Share = (0, codecs_1.decodeWithCodec)(public_types_1.EddsaMPCv2SignatureShareRound2Input, JSON.parse(userRound2Share.share), 'EddsaMPCv2SignatureShareRound2Input');
+    const userRawMsg2Bytes = await sdk_lib_mpc_1.MPSComms.verifyMpsMessage(parsedUserRound2Share.data.msg2, userGpgKey);
+    const userMsg2 = {
+        from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+        payload: new Uint8Array(userRawMsg2Bytes),
+    };
+    const bitgoSignedMsg2 = await sdk_lib_mpc_1.MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);
+    const round2Output = {
+        type: 'round2Output',
+        data: { msg2: bitgoSignedMsg2 },
+    };
+    transaction.signatureShares.push({
+        from: src_1.SignatureShareType.BITGO,
+        to: src_1.SignatureShareType.USER,
+        share: JSON.stringify(round2Output),
+    });
+    bitgoDsg.handleIncomingMessages([bitgoMsg2, userMsg2]);
+    return txRequest;
+}
+describe('EddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner', () => {
+    let sandbox;
+    let eddsaMPCv2Utils;
+    let mockBitgo;
+    let bitgoGpgKeyPair;
+    let bitgoGpgPubKey;
+    const walletId = 'abc123wallet';
+    const txRequestId = 'txreq-001';
+    const enterpriseId = 'ent-001';
+    const mockTxRequest = {
+        txRequestId,
+        walletId,
+        enterpriseId,
+        apiVersion: 'full',
+        transactions: [
+            {
+                unsignedTx: {
+                    signableHex: 'deadbeef',
+                    derivationPath: 'm/0',
+                    serializedTxHex: 'deadbeef',
+                },
+                signatureShares: [
+                    {
+                        from: src_1.SignatureShareType.BITGO,
+                        to: src_1.SignatureShareType.USER,
+                        share: JSON.stringify({ type: 'round1Output', data: {} }),
+                    },
+                ],
+            },
+        ],
+        intent: { intentType: 'payment' },
+        unsignedTxs: [],
+    };
+    const mockTxRequestTransaction = assertSingleTransaction(mockTxRequest);
+    const mockTxRequestRound2 = {
+        ...mockTxRequest,
+        transactions: [
+            {
+                ...mockTxRequestTransaction,
+                signatureShares: [
+                    {
+                        from: src_1.SignatureShareType.BITGO,
+                        to: src_1.SignatureShareType.USER,
+                        share: JSON.stringify({ type: 'round2Output', data: {} }),
+                    },
+                ],
+            },
+        ],
+    };
+    const dummyShare = {
+        from: src_1.SignatureShareType.USER,
+        to: src_1.SignatureShareType.BITGO,
+        share: JSON.stringify({ type: 'round1Input', data: {} }),
+    };
+    // Returns a chain compatible with: bitgo.post(url).send(body).result()
+    const makePostChain = (response) => ({ send: () => ({ result: sinon.stub().resolves(response) }) });
+    // Returns a chain compatible with: bitgo.get(url).query(params).retry(n).result()
+    const makeGetChain = (txRequests) => ({
+        query: () => ({
+            retry: () => ({ result: sinon.stub().resolves({ txRequests }) }),
+        }),
+    });
+    before(async () => {
+        bitgoGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        bitgoGpgPubKey = await pgp.readKey({ armoredKey: bitgoGpgKeyPair.publicKey });
+    });
+    beforeEach(async () => {
+        sandbox = sinon.createSandbox();
+        // Full mock of the BitGo HTTP client (consistent with other sdk-core tests such as
+        // tokenApproval.ts and walletsEvmKeyring.ts).  Module-level stubs on tssCommon functions
+        // do not work under tsx 4.x (ESM live bindings), so we mock at the bitgo object level.
+        mockBitgo = {
+            getEnv: sinon.stub().returns('test'),
+            setRequestTracer: sinon.stub(),
+            url: sinon.stub().callsFake((path) => `https://test.bitgo.com${path}`),
+            post: sinon.stub(),
+            get: sinon.stub(),
+        };
+        const mockCoin = {
+            getMPCAlgorithm: sinon.stub().returns('eddsa'),
+        };
+        const mockWallet = {
+            id: sinon.stub().returns(walletId),
+            keyIds: sinon.stub().returns(['userKeyId', 'backupKeyId', 'bitgoKeyId']),
+            multisigTypeVersion: sinon.stub().returns('MPCv2'),
+        };
+        eddsaMPCv2Utils = new src_1.EddsaMPCv2Utils(mockBitgo, mockCoin, mockWallet);
+        sandbox.stub(eddsaMPCv2Utils, 'pickBitgoPubGpgKeyForSigning').resolves(bitgoGpgPubKey);
+    });
+    afterEach(() => {
+        sandbox.restore();
+    });
+    it('should call all 3 generators and return the final tx request', async () => {
+        const finalTxRequest = { ...mockTxRequest, txRequestId };
+        // sendSignatureShareV2 is called 3 times (one per round), sendTxRequest once — all use bitgo.post
+        mockBitgo.post
+            .onCall(0)
+            .returns(makePostChain(mockTxRequest)) // round 1 sign
+            .onCall(1)
+            .returns(makePostChain(mockTxRequestRound2)) // round 2 sign
+            .onCall(2)
+            .returns(makePostChain(mockTxRequestRound2)) // round 3 sign
+            .onCall(3)
+            .returns(makePostChain(finalTxRequest)); // sendTxRequest (send)
+        const encryptedRound1Session = 'encrypted-r1-session';
+        const encryptedRound2Session = 'encrypted-r2-session';
+        const encryptedUserGpgPrvKey = 'encrypted-gpg-key';
+        const userGpgPubKey = bitgoGpgKeyPair.publicKey;
+        const round1Share = { ...dummyShare };
+        const round2Share = { ...dummyShare, share: JSON.stringify({ type: 'round2Input' }) };
+        const round3Share = { ...dummyShare, share: JSON.stringify({ type: 'round3Input' }) };
+        const round1Generator = sinon
+            .stub()
+            .resolves({ signatureShareRound1: round1Share, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey });
+        const round2Generator = sinon.stub().resolves({ signatureShareRound2: round2Share, encryptedRound2Session });
+        const round3Generator = sinon.stub().resolves({ signatureShareRound3: round3Share });
+        const result = await eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner({ txRequest: mockTxRequest, reqId: new src_1.RequestTracer() }, round1Generator, round2Generator, round3Generator);
+        assert.deepStrictEqual(result, finalTxRequest);
+        sinon.assert.calledOnce(round1Generator);
+        sinon.assert.calledWith(round1Generator, { txRequest: mockTxRequest });
+        sinon.assert.calledOnce(round2Generator);
+        const round2Call = round2Generator.getCall(0);
+        assert.strictEqual(round2Call.args[0].txRequest, mockTxRequest);
+        assert.strictEqual(round2Call.args[0].encryptedRound1Session, encryptedRound1Session);
+        assert.strictEqual(round2Call.args[0].encryptedUserGpgPrvKey, encryptedUserGpgPrvKey);
+        assert.strictEqual(round2Call.args[0].bitgoPublicGpgKey, bitgoGpgPubKey.armor());
+        sinon.assert.calledOnce(round3Generator);
+        const round3Call = round3Generator.getCall(0);
+        assert.strictEqual(round3Call.args[0].txRequest, mockTxRequestRound2);
+        assert.strictEqual(round3Call.args[0].encryptedRound2Session, encryptedRound2Session);
+        assert.strictEqual(round3Call.args[0].encryptedUserGpgPrvKey, encryptedUserGpgPrvKey);
+        assert.strictEqual(round3Call.args[0].bitgoPublicGpgKey, bitgoGpgPubKey.armor());
+        // 3 sendSignatureShareV2 calls + 1 sendTxRequest = 4 POST calls total
+        assert.strictEqual(mockBitgo.post.callCount, 4);
+    });
+    it('should resolve txRequest by ID string using getTxRequest', async () => {
+        // getTxRequest uses bitgo.get; sendSignatureShareV2 (×3) + sendTxRequest use bitgo.post
+        mockBitgo.get.returns(makeGetChain([mockTxRequest]));
+        mockBitgo.post
+            .onCall(0)
+            .returns(makePostChain(mockTxRequest))
+            .onCall(1)
+            .returns(makePostChain(mockTxRequestRound2))
+            .onCall(2)
+            .returns(makePostChain(mockTxRequestRound2))
+            .onCall(3)
+            .returns(makePostChain(mockTxRequest));
+        const round1Generator = sinon.stub().resolves({
+            signatureShareRound1: dummyShare,
+            userGpgPubKey: bitgoGpgKeyPair.publicKey,
+            encryptedRound1Session: 'r1',
+            encryptedUserGpgPrvKey: 'key',
+        });
+        const round2Generator = sinon.stub().resolves({ signatureShareRound2: dummyShare, encryptedRound2Session: 'r2' });
+        const round3Generator = sinon.stub().resolves({ signatureShareRound3: dummyShare });
+        await eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner({ txRequest: txRequestId, reqId: new src_1.RequestTracer() }, round1Generator, round2Generator, round3Generator);
+        sinon.assert.calledOnce(mockBitgo.get);
+        sinon.assert.calledWith(round1Generator, { txRequest: mockTxRequest });
+    });
+    it('should throw when round 2 txRequest is missing signatureShares', async () => {
+        const round2NoShares = {
+            ...mockTxRequest,
+            transactions: [{ ...mockTxRequestTransaction, signatureShares: undefined }],
+        };
+        mockBitgo.post
+            .onCall(0)
+            .returns(makePostChain(mockTxRequest))
+            .onCall(1)
+            .returns(makePostChain(round2NoShares));
+        const round1Generator = sinon.stub().resolves({
+            signatureShareRound1: dummyShare,
+            userGpgPubKey: bitgoGpgKeyPair.publicKey,
+            encryptedRound1Session: 'r1',
+            encryptedUserGpgPrvKey: 'key',
+        });
+        const round2Generator = sinon.stub().resolves({ signatureShareRound2: dummyShare, encryptedRound2Session: 'r2' });
+        const round3Generator = sinon.stub().resolves({ signatureShareRound3: dummyShare });
+        await assert.rejects(() => eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner({ txRequest: mockTxRequest, reqId: new src_1.RequestTracer() }, round1Generator, round2Generator, round3Generator), /Missing signature shares in round 2 txRequest/);
+    });
+    it('should pass armored BitGo public GPG key to round 2 and round 3 generators', async () => {
+        mockBitgo.post
+            .onCall(0)
+            .returns(makePostChain(mockTxRequest))
+            .onCall(1)
+            .returns(makePostChain(mockTxRequestRound2))
+            .onCall(2)
+            .returns(makePostChain(mockTxRequestRound2))
+            .onCall(3)
+            .returns(makePostChain(mockTxRequest));
+        const round1Generator = sinon.stub().resolves({
+            signatureShareRound1: dummyShare,
+            userGpgPubKey: bitgoGpgKeyPair.publicKey,
+            encryptedRound1Session: 'r1',
+            encryptedUserGpgPrvKey: 'key',
+        });
+        const round2Generator = sinon.stub().resolves({ signatureShareRound2: dummyShare, encryptedRound2Session: 'r2' });
+        const round3Generator = sinon.stub().resolves({ signatureShareRound3: dummyShare });
+        await eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner({ txRequest: mockTxRequest, reqId: new src_1.RequestTracer() }, round1Generator, round2Generator, round3Generator);
+        const armoredKey = bitgoGpgPubKey.armor();
+        assert.strictEqual(round2Generator.getCall(0).args[0].bitgoPublicGpgKey, armoredKey, 'round 2 should receive armored BitGo GPG key');
+        assert.strictEqual(round3Generator.getCall(0).args[0].bitgoPublicGpgKey, armoredKey, 'round 3 should receive armored BitGo GPG key');
+    });
+});
+function bytesToWord(bytes) {
+    if (!(bytes instanceof Uint8Array) || bytes.length !== 4) {
+        throw new Error('bytes must be a Uint8Array with length 4');
+    }
+    return bytes.reduce((num, byte) => num * 0x100 + byte, 0);
+}
+describe('EDDSAUtils.isEddsaMpcV1SigningMaterial', () => {
+    const PASSPHRASE = 'test-passphrase';
+    const MPCv1_MATERIAL_BACKUP = {
+        uShare: { i: 1, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },
+        bitgoYShare: { i: 3, j: 1, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },
+        backupYShare: { i: 2, j: 1, y: 'aabbcc', u: 'backup-u-value', chaincode: '00' },
+    };
+    const MPCv1_MATERIAL_USER = {
+        uShare: { i: 2, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },
+        bitgoYShare: { i: 3, j: 2, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },
+        userYShare: { i: 1, j: 2, y: 'aabbcc', u: 'user-u-value', chaincode: '00' },
+    };
+    const MPCv2_CBOR_BYTES = Buffer.from([0xd9, 0x01, 0x04, 0xa3, 0x61, 0x78, 0x18, 0x00]).toString('base64');
+    let mockBitgo;
+    beforeEach(() => {
+        // sdk-core has no devDependency on sdk-api/argon2, so v2 envelopes are simulated here.
+        // Real bitgo.decrypt routes v2 to Argon2id; the stub returns MPCv2 CBOR plaintext instead.
+        mockBitgo = {
+            decrypt: sinon.stub().callsFake(async (params) => {
+                if ((0, baseTypes_1.isV2Envelope)(params.input)) {
+                    return MPCv2_CBOR_BYTES;
+                }
+                return sjcl.decrypt(params.password, params.input);
+            }),
+        };
+    });
+    it('returns true for MPCv1 SJCL-encrypted keycard with backupYShare + correct passphrase', async () => {
+        const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL_BACKUP));
+        assert.strictEqual(await src_1.EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), true);
+    });
+    it('returns true for MPCv1 SJCL-encrypted keycard with userYShare + correct passphrase', async () => {
+        const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL_USER));
+        assert.strictEqual(await src_1.EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), true);
+    });
+    it('returns false for MPCv2 CBOR content wrapped in SJCL envelope + correct passphrase', async () => {
+        const encrypted = sjcl.encrypt(PASSPHRASE, MPCv2_CBOR_BYTES);
+        assert.strictEqual(await src_1.EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), false);
+    });
+    it('returns false for MPCv2 Argon2id envelope (v2) + correct passphrase (forward-compat)', async () => {
+        const fakeV2Envelope = JSON.stringify({ v: 2, m: 65536, t: 3, p: 4, salt: 'AAAA', iv: 'AAAA', ct: 'AAAA' });
+        assert.strictEqual(await src_1.EDDSAUtils.isEddsaMpcV1SigningMaterial(fakeV2Envelope, PASSPHRASE, mockBitgo), false);
+    });
+    it('throws on wrong passphrase', async () => {
+        const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL_BACKUP));
+        await assert.rejects(src_1.EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, 'wrong-passphrase'), /ccm: tag doesn't match/);
+    });
+    it('returns false when neither backupYShare.u nor userYShare.u is present', async () => {
+        const partial = { uShare: { seed: 'abc' }, bitgoYShare: { u: 'xyz' } };
+        const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(partial));
+        assert.strictEqual(await src_1.EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), false);
+    });
+});
+describe('signRecoveryEddsaMPCv2', () => {
+    const derivationPath = 'm/0/0';
+    it('should return a 64-byte signature that verifies against the derived public key', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const message = Buffer.from('deadbeef', 'hex');
+        const commonKeyChain = userDkg.getCommonKeychain();
+        const signature = await src_1.EDDSAUtils.signRecoveryEddsaMPCv2(message, derivationPath, userDkg.getKeyShare(), backupDkg.getKeyShare(), commonKeyChain);
+        assert.strictEqual(signature.length, 64);
+        const mpc = await (0, eddsa_1.getInitializedMpcInstance)();
+        const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);
+        const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');
+        const ok = ed25519_1.ed25519.verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKeyBytes));
+        assert.strictEqual(ok, true);
+    });
+    it('should return false when verifying the signature against a different message', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const message = Buffer.from('deadbeef', 'hex');
+        const commonKeyChain = userDkg.getCommonKeychain();
+        const signature = await src_1.EDDSAUtils.signRecoveryEddsaMPCv2(message, derivationPath, userDkg.getKeyShare(), backupDkg.getKeyShare(), commonKeyChain);
+        const differentMessage = Buffer.from('cafebabe', 'hex');
+        const mpc = await (0, eddsa_1.getInitializedMpcInstance)();
+        const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);
+        const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');
+        const ok = ed25519_1.ed25519.verify(new Uint8Array(signature), new Uint8Array(differentMessage), new Uint8Array(publicKeyBytes));
+        assert.strictEqual(ok, false);
+    });
+    it('should throw when a wrong commonKeyChain is provided (verification mismatch)', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const [wrongDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const message = Buffer.from('deadbeef', 'hex');
+        await assert.rejects(() => src_1.EDDSAUtils.signRecoveryEddsaMPCv2(message, derivationPath, userDkg.getKeyShare(), backupDkg.getKeyShare(), wrongDkg.getCommonKeychain() // key chain from a different wallet
+        ), /EdDSA MPCv2 recovery signature verification failed/);
+    });
+});
+describe('getEddsaSigningMaterial', () => {
+    const PASSPHRASE = 'test-passphrase';
+    const MPCv1_MATERIAL = {
+        uShare: { i: 1, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },
+        bitgoYShare: { i: 3, j: 1, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },
+        backupYShare: { i: 2, j: 1, y: 'aabbcc', u: 'backup-u-value', chaincode: '00' },
+    };
+    it('returns { version: v1, userPrv } for MPCv1 JSON keycard', async () => {
+        const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL));
+        const decryptStub = sinon.stub().resolves(JSON.stringify(MPCv1_MATERIAL));
+        const mockBitgo = { decrypt: decryptStub };
+        const result = await (0, src_1.getEddsaSigningMaterial)(encrypted, PASSPHRASE, mockBitgo);
+        assert.strictEqual(result.version, 'v1');
+        assert.strictEqual(result.userPrv, JSON.stringify(MPCv1_MATERIAL));
+        sinon.assert.calledOnce(decryptStub);
+        sinon.assert.calledWithMatch(decryptStub, { input: sinon.match.string, password: PASSPHRASE });
+    });
+    it('returns { version: v2, encryptedUserKey } for MPCv2 CBOR keycard', async () => {
+        const MPCv2_CBOR_BYTES = Buffer.from([0xd9, 0x01, 0x04, 0xa3, 0x61, 0x78, 0x18, 0x00]).toString('base64');
+        const encrypted = sjcl.encrypt(PASSPHRASE, MPCv2_CBOR_BYTES);
+        const normalizedKey = encrypted.replace(/\s/g, '');
+        const result = await (0, src_1.getEddsaSigningMaterial)(encrypted, PASSPHRASE);
+        assert.strictEqual(result.version, 'v2');
+        assert.ok('encryptedUserKey' in result);
+        assert.strictEqual(result.encryptedUserKey, normalizedKey);
+    });
+    it('throws with context message when decryption fails', async () => {
+        const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL));
+        await assert.rejects(() => (0, src_1.getEddsaSigningMaterial)(encrypted, 'wrong-passphrase'), /Error decrypting user keychain/);
+    });
+    it('returns v1 via sjcl fallback when bitgo is omitted', async () => {
+        const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL));
+        const result = await (0, src_1.getEddsaSigningMaterial)(encrypted, PASSPHRASE);
+        assert.strictEqual(result.version, 'v1');
+        assert.strictEqual(result.userPrv, JSON.stringify(MPCv1_MATERIAL));
+    });
+});
+describe('isEddsaSigningMaterial', () => {
+    it('returns true for a valid v1 shape', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)({ version: 'v1', userPrv: '{}' }), true);
+    });
+    it('returns true for a valid v2 shape', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)({ version: 'v2', encryptedUserKey: 'abc123' }), true);
+    });
+    it('returns false for a v1 shape with a non-string userPrv', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)({ version: 'v1', userPrv: 123 }), false);
+    });
+    it('returns false for a v2 shape with a non-string encryptedUserKey', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)({ version: 'v2', encryptedUserKey: 123 }), false);
+    });
+    it('returns false for an unrecognized version value', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)({ version: 'v3', userPrv: '{}' }), false);
+    });
+    it('returns false for an object missing a version field', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)({ userPrv: '{}' }), false);
+    });
+    it('returns false for null', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)(null), false);
+    });
+    it('returns false for undefined', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)(undefined), false);
+    });
+    it('returns false for primitive values', () => {
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)('a string'), false);
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)(42), false);
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)(true), false);
+    });
+    it('returns false for an ArrayBuffer (regression: WRW openSSLBytes collision)', () => {
+        // WRW's generic Electron 'recover' IPC handler passes openSSLBytes as a second
+        // positional argument to every coin's recover(), colliding with precomputedMaterial
+        // on coins that accept it. This must be rejected rather than misread as signing material.
+        assert.strictEqual((0, src_1.isEddsaSigningMaterial)(new ArrayBuffer(8)), false);
+    });
+});
+describe('signEddsaMpcV2RecoveryTx', () => {
+    const derivationPath = 'm/0/0';
+    const walletPassphrase = 'testPass';
+    const makeDecryptBitgo = (userKeyBase64, backupKeyBase64) => ({
+        decrypt: sinon.stub().onFirstCall().resolves(userKeyBase64).onSecondCall().resolves(backupKeyBase64),
+    });
+    it('returns a 64-byte signature that verifies against the derived public key', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const message = Buffer.from('deadbeef', 'hex');
+        const commonKeyChain = userDkg.getCommonKeychain();
+        const mockBitgo = makeDecryptBitgo(userDkg.getReducedKeyShare().toString('base64'), backupDkg.getReducedKeyShare().toString('base64'));
+        const result = await (0, src_1.signEddsaMpcV2RecoveryTx)({
+            message,
+            userKey: 'encrypted-user-key',
+            backupKey: 'encrypted-backup-key',
+            walletPassphrase,
+            bitgoKey: commonKeyChain,
+            derivationPath,
+            bitgo: mockBitgo,
+        });
+        assert.strictEqual(result.length, 64);
+        const mpc = await (0, eddsa_1.getInitializedMpcInstance)();
+        const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);
+        const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');
+        const ok = ed25519_1.ed25519.verify(new Uint8Array(result), new Uint8Array(message), new Uint8Array(publicKeyBytes));
+        assert.strictEqual(ok, true);
+    });
+    it('throws when commonKeyChain does not match bitgoKey', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const message = Buffer.from('deadbeef', 'hex');
+        const mockBitgo = makeDecryptBitgo(userDkg.getReducedKeyShare().toString('base64'), backupDkg.getReducedKeyShare().toString('base64'));
+        await assert.rejects(() => (0, src_1.signEddsaMpcV2RecoveryTx)({
+            message,
+            userKey: 'encrypted-user-key',
+            backupKey: 'encrypted-backup-key',
+            walletPassphrase,
+            bitgoKey: 'bbbb'.repeat(32),
+            derivationPath,
+            bitgo: mockBitgo,
+        }), /commonKeyChain from keycard does not match bitgoKey/);
+    });
+    it('passes userKey, backupKey, passphrase, and bitgo to getEddsaMpcV2RecoveryKeySharesFromReducedKey', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const message = Buffer.from('deadbeef', 'hex');
+        const decryptStub = sinon
+            .stub()
+            .onFirstCall()
+            .resolves(userDkg.getReducedKeyShare().toString('base64'))
+            .onSecondCall()
+            .resolves(backupDkg.getReducedKeyShare().toString('base64'));
+        const mockBitgo = { decrypt: decryptStub };
+        await (0, src_1.signEddsaMpcV2RecoveryTx)({
+            message,
+            userKey: 'u-key',
+            backupKey: 'b-key',
+            walletPassphrase,
+            bitgoKey: userDkg.getCommonKeychain(),
+            derivationPath,
+            bitgo: mockBitgo,
+        });
+        sinon.assert.calledWith(decryptStub.firstCall, { input: 'u-key', password: walletPassphrase });
+        sinon.assert.calledWith(decryptStub.secondCall, { input: 'b-key', password: walletPassphrase });
+    });
+});
+describe('EddsaMPCv2Utils.createKeychainsWithExternalSigner', function () {
+    let utils;
+    let callbacks;
+    const enterprise = 'enterprise-id';
+    const sessionId = 'session-001';
+    const commonKeychain = 'common-keychain-hex';
+    const userState = { encryptedData: 'u-data', encryptedDataKey: 'u-data-key' };
+    const backupState = { encryptedData: 'b-data', encryptedDataKey: 'b-data-key' };
+    const userSignedMsg1 = { message: 'umsg1', signature: 'usig1' };
+    const backupSignedMsg1 = { message: 'bmsg1', signature: 'bsig1' };
+    const userSignedMsg2 = { message: 'umsg2', signature: 'usig2' };
+    const backupSignedMsg2 = { message: 'bmsg2', signature: 'bsig2' };
+    const bitgoMsg1 = { message: 'bitgo-msg1', signature: 'bitgo-sig1' };
+    const bitgoMsg2 = { message: 'bitgo-msg2', signature: 'bitgo-sig2' };
+    beforeEach(function () {
+        callbacks = {
+            initializeCallback: sinon.stub().resolves({
+                userGpgPublicKey: 'user-gpg-pub',
+                backupGpgPublicKey: 'backup-gpg-pub',
+                userState,
+                backupState,
+            }),
+            round1Callback: sinon.stub().resolves({
+                userSignedMsg1,
+                backupSignedMsg1,
+                userState,
+                backupState,
+            }),
+            round2Callback: sinon.stub().resolves({
+                userSignedMsg2,
+                backupSignedMsg2,
+                userState,
+                backupState,
+            }),
+            finalizeCallback: sinon.stub().resolves({ commonKeychain }),
+        };
+        const mockBitGo = {
+            getEnv: sinon.stub().returns('dev'),
+        };
+        const mockKeychains = {
+            add: sinon
+                .stub()
+                .callsFake((params) => Promise.resolve({ id: `${params.source}-key-id`, commonKeychain, isMPCv2: true })),
+        };
+        const mockCoin = {
+            keychains: sinon.stub().returns(mockKeychains),
+        };
+        utils = new src_1.EddsaMPCv2Utils(mockBitGo, mockCoin);
+        sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({ eddsaMpcv2PublicKey: null });
+        utils.bitgoEddsaMpcv2PublicGpgKey = { armor: () => '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' };
+        sinon.stub(utils, 'sendKeyGenerationRound1').resolves({
+            sessionId: sessionId,
+            bitgoMsg1,
+        });
+        sinon.stub(utils, 'sendKeyGenerationRound2').resolves({
+            sessionId: sessionId,
+            commonPublicKeychain: commonKeychain,
+            bitgoMsg2,
+        });
+        sinon.stub(utils, 'addBitgoKeychain').resolves({ id: 'bitgo-key-id', commonKeychain, isMPCv2: true });
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('should invoke callbacks in order and return keychains', async function () {
+        const keychains = await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        assert.ok(keychains.userKeychain);
+        assert.ok(keychains.backupKeychain);
+        assert.ok(keychains.bitgoKeychain);
+        sinon.assert.calledOnce(callbacks.initializeCallback);
+        sinon.assert.calledOnce(callbacks.round1Callback);
+        sinon.assert.calledOnce(callbacks.round2Callback);
+        sinon.assert.calledOnce(callbacks.finalizeCallback);
+    });
+    it('should pass round1 response to round2Callback', async function () {
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        const round2Args = callbacks.round2Callback.firstCall.args[0];
+        assert.deepStrictEqual(round2Args.bitgoMsg1, bitgoMsg1);
+        assert.deepStrictEqual(round2Args.userSignedMsg1, userSignedMsg1);
+        assert.deepStrictEqual(round2Args.backupSignedMsg1, backupSignedMsg1);
+        assert.deepStrictEqual(round2Args.userState, userState);
+        assert.deepStrictEqual(round2Args.backupState, backupState);
+    });
+    it('should pass round2 response to finalizeCallback', async function () {
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        const finalizeArgs = callbacks.finalizeCallback.firstCall.args[0];
+        assert.deepStrictEqual(finalizeArgs.bitgoMsg2, bitgoMsg2);
+        assert.strictEqual(finalizeArgs.bitgoCommonKeychain, commonKeychain);
+        assert.deepStrictEqual(finalizeArgs.userState, userState);
+        assert.deepStrictEqual(finalizeArgs.backupState, backupState);
+    });
+    it('should register keychains with isMPCv2: true', async function () {
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        const mockKeychains = utils.baseCoin.keychains();
+        const addCalls = mockKeychains.add.getCalls();
+        assert.ok(addCalls.length >= 2, 'keychains.add should be called for user and backup');
+        for (const call of addCalls) {
+            assert.strictEqual(call.args[0].isMPCv2, true);
+            assert.strictEqual(call.args[0].keyType, 'tss');
+            assert.strictEqual(call.args[0].commonKeychain, commonKeychain);
+        }
+    });
+    it('should reject when finalizeCallback returns mismatched commonKeychain', async function () {
+        callbacks.finalizeCallback.resolves({ commonKeychain: 'different-keychain' });
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /Common keychains do not match/);
+    });
+    it('should reject when round2 returns mismatched sessionId', async function () {
+        utils.sendKeyGenerationRound2.resolves({
+            sessionId: 'different-session',
+            commonPublicKeychain: commonKeychain,
+            bitgoMsg2,
+        });
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /Round 1 and round 2 session IDs do not match/);
+    });
+    it('should reject when BitGo EdDSA MPCv2 GPG public key is missing', async function () {
+        utils.bitgoEddsaMpcv2PublicGpgKey = undefined;
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /Failed to get BitGo EdDSA MPCv2 GPG public key/);
+    });
+});
+describe('EddsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Keys', () => {
+    let utils;
+    // Real 3-party MPCv1 EdDSA key shares: 1 = user, 2 = backup, 3 = bitgo.
+    let userSigningMaterial;
+    let backupSigningMaterial;
+    let expectedUserPShare;
+    let expectedBackupPShare;
+    before(async () => {
+        const MPC = await (0, eddsa_1.getInitializedMpcInstance)();
+        const user = MPC.keyShare(1, 2, 3);
+        const backup = MPC.keyShare(2, 2, 3);
+        const bitgo = MPC.keyShare(3, 2, 3);
+        expectedUserPShare = MPC.keyCombine(user.uShare, [backup.yShares[1], bitgo.yShares[1]]).pShare;
+        expectedBackupPShare = MPC.keyCombine(backup.uShare, [user.yShares[2], bitgo.yShares[2]]).pShare;
+        userSigningMaterial = {
+            uShare: user.uShare,
+            bitgoYShare: bitgo.yShares[1],
+            backupYShare: backup.yShares[1],
+        };
+        backupSigningMaterial = {
+            uShare: backup.uShare,
+            bitgoYShare: bitgo.yShares[2],
+            userYShare: user.yShares[2],
+        };
+    });
+    beforeEach(() => {
+        const mockBitGo = {};
+        const mockCoin = {};
+        utils = new src_1.EddsaMPCv2Utils(mockBitGo, mockCoin);
+    });
+    it('derives matching expectedPk and chainCode for user and backup from real MPCv1 key combine', async () => {
+        const { userRetrofitData, backupRetrofitData } = await utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),
+            mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),
+        });
+        assert.strictEqual(userRetrofitData.expectedPk, expectedUserPShare.y);
+        assert.strictEqual(backupRetrofitData.expectedPk, expectedBackupPShare.y);
+        assert.strictEqual(userRetrofitData.expectedPk, backupRetrofitData.expectedPk);
+        assert.strictEqual(userRetrofitData.chainCode, expectedUserPShare.chaincode);
+        assert.strictEqual(backupRetrofitData.chainCode, expectedBackupPShare.chaincode);
+        assert.strictEqual(userRetrofitData.chainCode, backupRetrofitData.chainCode);
+    });
+    it('derives s_i_0 as the combined pShare.u (clamped scalar) for each party', async () => {
+        const { userRetrofitData, backupRetrofitData } = await utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),
+            mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),
+        });
+        assert.strictEqual(userRetrofitData.s_i_0, expectedUserPShare.u);
+        assert.strictEqual(backupRetrofitData.s_i_0, expectedBackupPShare.u);
+        assert.notStrictEqual(userRetrofitData.s_i_0, backupRetrofitData.s_i_0);
+    });
+    it('throws if user key is missing uShare', async () => {
+        const keyNoUShare = JSON.stringify({
+            bitgoYShare: userSigningMaterial.bitgoYShare,
+            backupYShare: userSigningMaterial.backupYShare,
+        });
+        await assert.rejects(() => utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: keyNoUShare,
+            mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),
+        }), /MPCv1 key material missing uShare/);
+    });
+    it('throws if user key is missing bitgoYShare', async () => {
+        const keyNoBitgoYShare = JSON.stringify({
+            uShare: userSigningMaterial.uShare,
+            backupYShare: userSigningMaterial.backupYShare,
+        });
+        await assert.rejects(() => utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: keyNoBitgoYShare,
+            mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),
+        }), /MPCv1 key material missing bitgoYShare/);
+    });
+    it('throws if user key is missing backupYShare', async () => {
+        const keyNoBackupYShare = JSON.stringify({
+            uShare: userSigningMaterial.uShare,
+            bitgoYShare: userSigningMaterial.bitgoYShare,
+        });
+        await assert.rejects(() => utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: keyNoBackupYShare,
+            mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),
+        }), /User MPCv1 key material missing backupYShare/);
+    });
+    it('throws if backup key is missing uShare', async () => {
+        const keyNoUShare = JSON.stringify({
+            bitgoYShare: backupSigningMaterial.bitgoYShare,
+            userYShare: backupSigningMaterial.userYShare,
+        });
+        await assert.rejects(() => utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),
+            mpcv1BackupKeyShare: keyNoUShare,
+        }), /MPCv1 key material missing uShare/);
+    });
+    it('throws if backup key is missing bitgoYShare', async () => {
+        const keyNoBitgoYShare = JSON.stringify({
+            uShare: backupSigningMaterial.uShare,
+            userYShare: backupSigningMaterial.userYShare,
+        });
+        await assert.rejects(() => utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),
+            mpcv1BackupKeyShare: keyNoBitgoYShare,
+        }), /MPCv1 key material missing bitgoYShare/);
+    });
+    it('throws if backup key is missing userYShare', async () => {
+        const keyNoUserYShare = JSON.stringify({
+            uShare: backupSigningMaterial.uShare,
+            bitgoYShare: backupSigningMaterial.bitgoYShare,
+        });
+        await assert.rejects(() => utils.getMpcV2RetrofitDataFromMpcV1Keys({
+            mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),
+            mpcv1BackupKeyShare: keyNoUserYShare,
+        }), /Backup MPCv1 key material missing userYShare/);
+    });
+});
+describe('EddsaMPCv2Utils.getUserAndBackupSession', () => {
+    let utils;
+    let userSigningMaterial;
+    let backupSigningMaterial;
+    before(async () => {
+        const MPC = await (0, eddsa_1.getInitializedMpcInstance)();
+        const user = MPC.keyShare(1, 2, 3);
+        const backup = MPC.keyShare(2, 2, 3);
+        const bitgo = MPC.keyShare(3, 2, 3);
+        userSigningMaterial = {
+            uShare: user.uShare,
+            bitgoYShare: bitgo.yShares[1],
+            backupYShare: backup.yShares[1],
+        };
+        backupSigningMaterial = {
+            uShare: backup.uShare,
+            bitgoYShare: bitgo.yShares[2],
+            userYShare: user.yShares[2],
+        };
+    });
+    beforeEach(() => {
+        const mockBitGo = {};
+        const mockCoin = {};
+        utils = new src_1.EddsaMPCv2Utils(mockBitGo, mockCoin);
+    });
+    afterEach(() => {
+        sinon.restore();
+    });
+    it('returns plain DKG sessions when retrofit is undefined', async () => {
+        const { userDkg, backupDkg } = await utils.getUserAndBackupSession(undefined);
+        assert.ok(userDkg, 'user DKG should be created');
+        assert.ok(backupDkg, 'backup DKG should be created');
+    });
+    it('returns retrofit-seeded DKG sessions when retrofit payload is supplied', async () => {
+        const retrofit = {
+            decryptedUserKey: JSON.stringify(userSigningMaterial),
+            decryptedBackupKey: JSON.stringify(backupSigningMaterial),
+            walletId: 'wallet-123',
+        };
+        const { userDkg, backupDkg } = await utils.getUserAndBackupSession(retrofit);
+        assert.ok(userDkg, 'user DKG should be created with retrofit data');
+        assert.ok(backupDkg, 'backup DKG should be created with retrofit data');
+    });
+});
+describe('EddsaMPCv2Utils.createKeychains with retrofit wiring', () => {
+    let utils;
+    let userSigningMaterial;
+    let backupSigningMaterial;
+    let bitgoGpgPublicKeyArmored;
+    const enterprise = 'enterprise-id';
+    const sessionId = 'session-001';
+    const walletId = 'wallet-retrofit-123';
+    before(async () => {
+        const MPC = await (0, eddsa_1.getInitializedMpcInstance)();
+        const user = MPC.keyShare(1, 2, 3);
+        const backup = MPC.keyShare(2, 2, 3);
+        const bitgo = MPC.keyShare(3, 2, 3);
+        userSigningMaterial = {
+            uShare: user.uShare,
+            bitgoYShare: bitgo.yShares[1],
+            backupYShare: backup.yShares[1],
+        };
+        backupSigningMaterial = {
+            uShare: backup.uShare,
+            bitgoYShare: bitgo.yShares[2],
+            userYShare: user.yShares[2],
+        };
+        // Generate a real Ed25519 GPG key to stand in for the BitGo GPG key
+        const bitgoGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        bitgoGpgPublicKeyArmored = bitgoGpgKeyPair.publicKey;
+    });
+    beforeEach(() => {
+        const mockBitGo = {
+            getEnv: sinon.stub().returns('dev'),
+            encrypt: sinon.stub().resolves('encrypted'),
+        };
+        const mockKeychains = {
+            add: sinon
+                .stub()
+                .callsFake((params) => Promise.resolve({ id: `${params.source}-key-id`, commonKeychain: 'a'.repeat(128), isMPCv2: true })),
+        };
+        const mockCoin = {
+            keychains: sinon.stub().returns(mockKeychains),
+        };
+        utils = new src_1.EddsaMPCv2Utils(mockBitGo, mockCoin);
+        sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({ eddsaMpcv2PublicKey: null });
+        // Use a real armored GPG public key so pgp.readKey() succeeds inside createKeychains
+        utils.bitgoEddsaMpcv2PublicGpgKey = { armor: () => bitgoGpgPublicKeyArmored };
+        sinon.stub(utils, 'addBitgoKeychain').resolves({ id: 'bitgo-key-id', commonKeychain: 'a'.repeat(128) });
+    });
+    afterEach(() => {
+        sinon.restore();
+    });
+    it('spreads walletId into round-1 payload when retrofit is provided', async () => {
+        const capturedPayloads = [];
+        sinon.stub(utils, 'sendKeyGenerationRound1').callsFake(async (_enterprise, payload) => {
+            capturedPayloads.push(payload);
+            // Return a bad bitgoMsg1 to short-circuit the ceremony after R1 capture
+            return { sessionId: sessionId, bitgoMsg1: { message: '', signature: '' } };
+        });
+        const retrofit = {
+            decryptedUserKey: JSON.stringify(userSigningMaterial),
+            decryptedBackupKey: JSON.stringify(backupSigningMaterial),
+            walletId,
+        };
+        await assert.rejects(() => utils.createKeychains({ passphrase: 'test', enterprise, retrofit }), () => true);
+        assert.strictEqual(capturedPayloads.length, 1, 'sendKeyGenerationRound1 should be called once');
+        assert.strictEqual(capturedPayloads[0].walletId, walletId, 'walletId must be present in round-1 payload');
+    });
+    it('omits walletId from round-1 payload when retrofit is absent', async () => {
+        const capturedPayloads = [];
+        sinon.stub(utils, 'sendKeyGenerationRound1').callsFake(async (_enterprise, payload) => {
+            capturedPayloads.push(payload);
+            return { sessionId: sessionId, bitgoMsg1: { message: '', signature: '' } };
+        });
+        await assert.rejects(() => utils.createKeychains({ passphrase: 'test', enterprise }), () => true);
+        assert.strictEqual(capturedPayloads.length, 1, 'sendKeyGenerationRound1 should be called once');
+        assert.strictEqual(capturedPayloads[0].walletId, undefined, 'walletId must be absent when no retrofit');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eddsaMPCv2.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/eddsa/eddsaMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import { encode } from 'cbor-x';\nimport * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport * as pgp from 'openpgp';\nimport { randomBytes } from 'crypto';\nimport { EddsaMPSDkg, EddsaMPSDsg, MPSComms, MPSTypes, MPSUtil } from '@bitgo-beta/sdk-lib-mpc';\nimport { ed25519 } from '@noble/curves/ed25519';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport {\n  EddsaMPCv2SignatureShareRound1Input,\n  EddsaMPCv2SignatureShareRound1Output,\n  EddsaMPCv2SignatureShareRound2Input,\n  EddsaMPCv2SignatureShareRound2Output,\n  EddsaMPCv2SignatureShareRound3Input,\n  EddsaMPCv2SignatureShareRound3Output,\n} from '@bitgo/public-types';\nimport {\n  BitGoBase,\n  BitGoRequest,\n  CustomEddsaMPCv2SigningRound1GeneratingFunction,\n  CustomEddsaMPCv2SigningRound2GeneratingFunction,\n  CustomEddsaMPCv2SigningRound3GeneratingFunction,\n  EDDSAUtils,\n  EddsaMPCv2KeyGenCallbacks,\n  EddsaMPCv2Utils,\n  IBaseCoin,\n  IWallet,\n  RequestTracer,\n  SignatureShareRecord,\n  SignatureShareType,\n  TxRequest,\n  getEddsaSigningMaterial,\n  isEddsaSigningMaterial,\n  signEddsaMpcV2RecoveryTx,\n} from '../../../../../../src';\nimport {\n  getSignatureShareRoundOne,\n  getSignatureShareRoundTwo,\n  getSignatureShareRoundThree,\n  verifyPeerMessageRoundOne,\n  verifyPeerMessageRoundTwo,\n  verifyPeerMessageRoundThree,\n} from '../../../../../../src/bitgo/tss/eddsa/eddsaMPCv2';\nimport { getInitializedMpcInstance } from '../../../../../../src/bitgo/tss/eddsa/eddsa';\nimport { getBitgoSignatureShare } from '../../../../../../src/bitgo/tss/common';\nimport { decodeWithCodec } from '../../../../../../src/bitgo/utils/codecs';\nimport { generateGPGKeyPair } from '../../../../../../src/bitgo/utils/opengpgUtils';\nimport { MPCv2PartiesEnum } from '../../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2';\nimport { isV2Envelope } from '../../../../../../src/bitgo/utils/tss/baseTypes';\n\ndescribe('EdDSA MPS DSG helper functions', async () => {\n  let userKeyShare: Buffer;\n  let backupKeyShare: Buffer;\n  let bitgoKeyShare: Buffer;\n  let userGpgPrivKey: pgp.PrivateKey;\n  let backupGpgPrivKey: pgp.PrivateKey;\n  let bitgoGpgPrivKey: pgp.PrivateKey;\n  let bitgoGpgPubKey: pgp.Key;\n\n  const signableHex = 'deadbeef';\n  const derivationPath = 'm/0';\n\n  before('generate EdDSA DKG key shares', async () => {\n    const userGpgKeyPair = await generateGPGKeyPair('ed25519');\n    const backupGpgKeyPair = await generateGPGKeyPair('ed25519');\n    const bitgoGpgKeyPair = await generateGPGKeyPair('ed25519');\n\n    userGpgPrivKey = await pgp.readPrivateKey({ armoredKey: userGpgKeyPair.privateKey });\n    backupGpgPrivKey = await pgp.readPrivateKey({ armoredKey: backupGpgKeyPair.privateKey });\n    bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });\n    bitgoGpgPubKey = await pgp.readKey({ armoredKey: bitgoGpgKeyPair.publicKey });\n\n    const [userDkg, backupDkg, bitgoDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    userKeyShare = userDkg.getKeyShare();\n    backupKeyShare = backupDkg.getKeyShare();\n    bitgoKeyShare = bitgoDkg.getKeyShare();\n  });\n\n  // ── Round 1 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundOne should build a valid round-1 share', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n    await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BITGO);\n    const userMsg1 = userDsg.getFirstMessage();\n\n    const share: SignatureShareRecord = await getSignatureShareRoundOne(userMsg1, userGpgPrivKey);\n\n    assert.strictEqual(share.from, SignatureShareType.USER);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound1Input,\n      JSON.parse(share.share),\n      'EddsaMPCv2SignatureShareRound1Input'\n    );\n    assert.strictEqual(parsed.type, 'round1Input');\n    assert.ok(parsed.data.msg1.message, 'msg1.message should be set');\n    assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');\n  });\n\n  it('getSignatureShareRoundOne should build a valid backup round-1 share', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const backupDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BACKUP);\n    await backupDsg.initDsg(backupKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BITGO);\n    const backupMsg1 = backupDsg.getFirstMessage();\n\n    const share: SignatureShareRecord = await getSignatureShareRoundOne(\n      backupMsg1,\n      backupGpgPrivKey,\n      MPCv2PartiesEnum.BACKUP\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.BACKUP);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound1Input,\n      JSON.parse(share.share),\n      'EddsaMPCv2SignatureShareRound1Input'\n    );\n    assert.strictEqual(parsed.type, 'round1Input');\n    assert.ok(parsed.data.msg1.message, 'msg1.message should be set');\n    assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');\n  });\n\n  it('verifyPeerMessageRoundOne should verify a valid BitGo round-1 message', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n    const bitgoMsg1 = bitgoDsg.getFirstMessage();\n\n    const bitgoSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);\n    const round1Output: EddsaMPCv2SignatureShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: bitgoSignedMsg1 },\n    };\n\n    const result = await verifyPeerMessageRoundOne(round1Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.ok(result.payload.length > 0, 'payload should be non-empty');\n  });\n\n  it('verifyPeerMessageRoundOne should throw on a tampered message', async () => {\n    const round1Output: EddsaMPCv2SignatureShareRound1Output = {\n      type: 'round1Output',\n      data: {\n        msg1: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundOne(round1Output, bitgoGpgPubKey), 'should throw on invalid signature');\n  });\n\n  // ── Round 2 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundTwo should build a valid round-2 share', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n    await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BITGO);\n    const userMsg1 = userDsg.getFirstMessage();\n\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n    const bitgoMsg1 = bitgoDsg.getFirstMessage();\n\n    const bitgoSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);\n    const bitgoDeserializedMsg1 = await verifyPeerMessageRoundOne(\n      { type: 'round1Output', data: { msg1: bitgoSignedMsg1 } },\n      bitgoGpgPubKey\n    );\n    const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);\n\n    const share: SignatureShareRecord = await getSignatureShareRoundTwo(userMsg2, userGpgPrivKey);\n\n    assert.strictEqual(share.from, SignatureShareType.USER);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound2Input,\n      JSON.parse(share.share),\n      'EddsaMPCv2SignatureShareRound2Input'\n    );\n    assert.strictEqual(parsed.type, 'round2Input');\n    assert.ok(parsed.data.msg2.message, 'msg2.message should be set');\n    assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');\n  });\n\n  it('getSignatureShareRoundTwo should build a valid backup round-2 share', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const backupDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BACKUP);\n    await backupDsg.initDsg(backupKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BITGO);\n    const backupMsg1 = backupDsg.getFirstMessage();\n\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BACKUP);\n    const bitgoMsg1 = bitgoDsg.getFirstMessage();\n\n    const bitgoSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);\n    const bitgoDeserializedMsg1 = await verifyPeerMessageRoundOne(\n      { type: 'round1Output', data: { msg1: bitgoSignedMsg1 } },\n      bitgoGpgPubKey\n    );\n    const [backupMsg2] = backupDsg.handleIncomingMessages([backupMsg1, bitgoDeserializedMsg1]);\n\n    const share: SignatureShareRecord = await getSignatureShareRoundTwo(\n      backupMsg2,\n      backupGpgPrivKey,\n      MPCv2PartiesEnum.BACKUP\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.BACKUP);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound2Input,\n      JSON.parse(share.share),\n      'EddsaMPCv2SignatureShareRound2Input'\n    );\n    assert.strictEqual(parsed.type, 'round2Input');\n    assert.ok(parsed.data.msg2.message, 'msg2.message should be set');\n    assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');\n  });\n\n  it('verifyPeerMessageRoundTwo should verify a valid BitGo round-2 message', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n    await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BITGO);\n    const userMsg1 = userDsg.getFirstMessage();\n\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n    const bitgoMsg1 = bitgoDsg.getFirstMessage();\n\n    const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, userMsg1]);\n    const bitgoSignedMsg2 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);\n\n    const round2Output: EddsaMPCv2SignatureShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: bitgoSignedMsg2 },\n    };\n\n    const result = await verifyPeerMessageRoundTwo(round2Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.ok(result.payload.length > 0, 'payload should be non-empty');\n  });\n\n  it('verifyPeerMessageRoundTwo should throw on a tampered message', async () => {\n    const round2Output: EddsaMPCv2SignatureShareRound2Output = {\n      type: 'round2Output',\n      data: {\n        msg2: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundTwo(round2Output, bitgoGpgPubKey), 'should throw on invalid signature');\n  });\n\n  // ── Round 3 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundThree should build a valid round-3 share', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const userDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER);\n    await userDsg.initDsg(userKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BITGO);\n    const userMsg1 = userDsg.getFirstMessage();\n\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n    const bitgoMsg1 = bitgoDsg.getFirstMessage();\n\n    // Advance to round 2\n    const bitgoSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);\n    const bitgoDeserializedMsg1 = await verifyPeerMessageRoundOne(\n      { type: 'round1Output', data: { msg1: bitgoSignedMsg1 } },\n      bitgoGpgPubKey\n    );\n    const [userMsg2] = userDsg.handleIncomingMessages([userMsg1, bitgoDeserializedMsg1]);\n\n    const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, userMsg1]);\n    const bitgoSignedMsg2 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);\n    const bitgoDeserializedMsg2 = await verifyPeerMessageRoundTwo(\n      { type: 'round2Output', data: { msg2: bitgoSignedMsg2 } },\n      bitgoGpgPubKey\n    );\n    const [userMsg3] = userDsg.handleIncomingMessages([userMsg2, bitgoDeserializedMsg2]);\n\n    const share: SignatureShareRecord = await getSignatureShareRoundThree(userMsg3, userGpgPrivKey);\n\n    assert.strictEqual(share.from, SignatureShareType.USER);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound3Input,\n      JSON.parse(share.share),\n      'EddsaMPCv2SignatureShareRound3Input'\n    );\n    assert.strictEqual(parsed.type, 'round3Input');\n    assert.ok(parsed.data.msg3.message, 'msg3.message should be set');\n    assert.ok(parsed.data.msg3.signature, 'msg3.signature should be set');\n  });\n\n  it('getSignatureShareRoundThree should build a valid backup round-3 share', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const backupDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BACKUP);\n    await backupDsg.initDsg(backupKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BITGO);\n    const backupMsg1 = backupDsg.getFirstMessage();\n\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.BACKUP);\n    const bitgoMsg1 = bitgoDsg.getFirstMessage();\n\n    const bitgoSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);\n    const bitgoDeserializedMsg1 = await verifyPeerMessageRoundOne(\n      { type: 'round1Output', data: { msg1: bitgoSignedMsg1 } },\n      bitgoGpgPubKey\n    );\n    const [backupMsg2] = backupDsg.handleIncomingMessages([backupMsg1, bitgoDeserializedMsg1]);\n\n    const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, backupMsg1]);\n    const bitgoSignedMsg2 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);\n    const bitgoDeserializedMsg2 = await verifyPeerMessageRoundTwo(\n      { type: 'round2Output', data: { msg2: bitgoSignedMsg2 } },\n      bitgoGpgPubKey\n    );\n    const [backupMsg3] = backupDsg.handleIncomingMessages([backupMsg2, bitgoDeserializedMsg2]);\n\n    const share: SignatureShareRecord = await getSignatureShareRoundThree(\n      backupMsg3,\n      backupGpgPrivKey,\n      MPCv2PartiesEnum.BACKUP\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.BACKUP);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound3Input,\n      JSON.parse(share.share),\n      'EddsaMPCv2SignatureShareRound3Input'\n    );\n    assert.strictEqual(parsed.type, 'round3Input');\n    assert.ok(parsed.data.msg3.message, 'msg3.message should be set');\n    assert.ok(parsed.data.msg3.signature, 'msg3.signature should be set');\n  });\n\n  it('verifyPeerMessageRoundThree should verify a valid BitGo round-3 message', async () => {\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const [, [bitgoMsg3]] = (await MPSUtil.executeTillRound(\n      2,\n      new EddsaMPSDsg.DSG(MPCv2PartiesEnum.USER),\n      new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO),\n      userKeyShare,\n      bitgoKeyShare,\n      messageBuffer,\n      derivationPath\n    )) as MPSTypes.DeserializedMessages[];\n    const bitgoSignedMsg3 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg3.payload), bitgoGpgPrivKey);\n\n    const round3Output: EddsaMPCv2SignatureShareRound3Output = {\n      type: 'round3Output',\n      data: { msg3: bitgoSignedMsg3 },\n    };\n\n    const result = await verifyPeerMessageRoundThree(round3Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.ok(result.payload.length > 0, 'payload should be non-empty');\n  });\n\n  it('verifyPeerMessageRoundThree should throw on a tampered message', async () => {\n    const round3Output: EddsaMPCv2SignatureShareRound3Output = {\n      type: 'round3Output',\n      data: {\n        msg3: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(\n      verifyPeerMessageRoundThree(round3Output, bitgoGpgPubKey),\n      'should throw on invalid signature'\n    );\n  });\n});\n\ndescribe('getEddsaMPCv2RecoveryKeyShares', () => {\n  const walletPassphrase = 'testPass';\n\n  const encryptKey = (keyShare: Buffer): string => sjcl.encrypt(walletPassphrase, keyShare.toString('base64'));\n\n  it('should return recovery key shares from v1-encrypted reduced keys (no bitgo instance)', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const result = await EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n      encryptKey(userDkg.getReducedKeyShare()),\n      encryptKey(backupDkg.getReducedKeyShare()),\n      walletPassphrase\n    );\n\n    assert.deepStrictEqual(result.userKeyShare, userDkg.getKeyShare());\n    assert.deepStrictEqual(result.backupKeyShare, backupDkg.getKeyShare());\n    assert.strictEqual(result.commonKeyChain, userDkg.getCommonKeychain());\n  });\n\n  it('should unwrap versioned safe-root envelopes and return VRF keyshares', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const userVrfKeyShare = Buffer.from('user-vrf-keyshare');\n    const backupVrfKeyShare = Buffer.from('backup-vrf-keyshare');\n    const encodeEnvelope = (reducedKeyShare: Buffer, vrfKeyShare: Buffer): Buffer =>\n      Buffer.from(\n        encode({\n          version: 1,\n          prvKeyShare: new Uint8Array(reducedKeyShare),\n          vrf: new Uint8Array(vrfKeyShare),\n        })\n      );\n\n    const result = await EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n      encryptKey(encodeEnvelope(userDkg.getReducedKeyShare(), userVrfKeyShare)),\n      encryptKey(encodeEnvelope(backupDkg.getReducedKeyShare(), backupVrfKeyShare)),\n      walletPassphrase\n    );\n\n    assert.strictEqual(Buffer.compare(result.userKeyShare, userDkg.getKeyShare()), 0);\n    assert.strictEqual(Buffer.compare(result.backupKeyShare, backupDkg.getKeyShare()), 0);\n    assert.strictEqual(result.commonKeyChain, userDkg.getCommonKeychain());\n    assert.ok(result.userVrfKeyShare);\n    assert.ok(result.backupVrfKeyShare);\n    assert.strictEqual(Buffer.compare(result.userVrfKeyShare, userVrfKeyShare), 0);\n    assert.strictEqual(Buffer.compare(result.backupVrfKeyShare, backupVrfKeyShare), 0);\n  });\n\n  it('should route decryption through bitgo.decrypt when a bitgo instance is provided', async () => {\n    // sdk-core has no devDependency on sdk-api or argon2, so we cannot encrypt with a real v2 envelope here.\n    // The stub verifies that the function delegates to bitgo.decrypt (which supports v1 + v2 in\n    // production) rather than falling back to sjcl.decrypt.\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const userKeyBase64 = userDkg.getReducedKeyShare().toString('base64');\n    const backupKeyBase64 = backupDkg.getReducedKeyShare().toString('base64');\n\n    const mockBitgo = {\n      decrypt: sinon.stub().onFirstCall().resolves(userKeyBase64).onSecondCall().resolves(backupKeyBase64),\n    } as unknown as BitGoBase;\n\n    const result = await EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n      'encrypted-user-key',\n      'encrypted-backup-key',\n      walletPassphrase,\n      mockBitgo\n    );\n\n    sinon.assert.calledTwice(mockBitgo.decrypt as sinon.SinonStub);\n    assert.deepStrictEqual(result.userKeyShare, userDkg.getKeyShare());\n    assert.deepStrictEqual(result.backupKeyShare, backupDkg.getKeyShare());\n    assert.strictEqual(result.commonKeyChain, userDkg.getCommonKeychain());\n  });\n\n  it('should reject a malformed keycard with a descriptive error', async () => {\n    const [userDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const malformedKey = sjcl.encrypt(walletPassphrase, randomBytes(64).toString('base64'));\n    await assert.rejects(\n      EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n        malformedKey,\n        encryptKey(userDkg.getReducedKeyShare()),\n        walletPassphrase\n      ),\n      /unable to decode reduced key share/\n    );\n  });\n\n  it('should reject reduced keys from different wallets', async () => {\n    const [userDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const [, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    await assert.rejects(\n      EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n        encryptKey(userDkg.getReducedKeyShare()),\n        encryptKey(backupDkg.getReducedKeyShare()),\n        walletPassphrase\n      ),\n      /pub keys do not match/\n    );\n  });\n\n  it('should reject reduced keys with matching pub but mismatched rootChainCodes', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const userReducedKeyShare = userDkg.getReducedKeyShare();\n    const backupReducedKeyShare = backupDkg.getReducedKeyShare();\n    const getDecodedReducedKeyShare = MPSTypes.getDecodedReducedKeyShare;\n    const decodeStub = sinon.stub(MPSTypes, 'getDecodedReducedKeyShare').callsFake((buf) => {\n      const reduced = getDecodedReducedKeyShare(buf);\n      if (Buffer.from(buf).equals(backupReducedKeyShare)) {\n        return {\n          ...reduced,\n          rootChainCode: Array.from(randomBytes(32)),\n        };\n      }\n      return reduced;\n    });\n\n    try {\n      await assert.rejects(\n        EDDSAUtils.getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n          encryptKey(userReducedKeyShare),\n          encryptKey(backupReducedKeyShare),\n          walletPassphrase\n        ),\n        /rootChainCodes do not match/\n      );\n    } finally {\n      decodeStub.restore();\n    }\n  });\n});\n\ndescribe('EddsaMPCv2Utils.createOfflineRound1Share', () => {\n  let eddsaMPCv2Utils: EddsaMPCv2Utils;\n  let mockBitgo: BitGoBase;\n  let userKeyShare: Buffer;\n\n  const walletPassphrase = 'testPass';\n  const signableHex = 'deadbeef';\n  const derivationPath = 'm/0/0';\n  const expectedAdata = `${signableHex}:${derivationPath}`;\n  const txRequest: TxRequest = {\n    txRequestId: 'txreq-eddsa-round1',\n    walletId: 'wallet-eddsa-round1',\n    enterpriseId: 'enterprise-eddsa-round1',\n    apiVersion: 'full',\n    transactions: [\n      {\n        unsignedTx: {\n          signableHex,\n          derivationPath,\n          serializedTxHex: signableHex,\n        },\n        signatureShares: [],\n      },\n    ],\n    intent: { intentType: 'payment' },\n    unsignedTxs: [],\n  } as unknown as TxRequest;\n\n  before('generate EdDSA user key share', async () => {\n    const [userDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    userKeyShare = userDkg.getKeyShare();\n  });\n\n  beforeEach(() => {\n    const sjclEncrypt = (params: { password: string; input: string; adata?: string }) => {\n      const salt = randomBytes(8);\n      const iv = randomBytes(16);\n      return sjcl.encrypt(params.password, params.input, {\n        salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],\n        iv: [\n          bytesToWord(iv.subarray(0, 4)),\n          bytesToWord(iv.subarray(4, 8)),\n          bytesToWord(iv.subarray(8, 12)),\n          bytesToWord(iv.subarray(12, 16)),\n        ],\n        adata: params.adata,\n      });\n    };\n    mockBitgo = {\n      encrypt: sinon.stub().callsFake(async (params) => sjclEncrypt(params)),\n    } as unknown as BitGoBase;\n\n    const mockCoin = {\n      getMPCAlgorithm: sinon.stub().returns('eddsa'),\n    } as unknown as IBaseCoin;\n\n    eddsaMPCv2Utils = new EddsaMPCv2Utils(mockBitgo, mockCoin);\n  });\n\n  it('should create a round-1 share and encrypted SJCL session payload', async () => {\n    const result = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    assert.strictEqual(result.signatureShareRound1.from, SignatureShareType.USER);\n    assert.strictEqual(result.signatureShareRound1.to, SignatureShareType.BITGO);\n    assert.ok(result.userGpgPubKey.includes('BEGIN PGP PUBLIC KEY BLOCK'));\n    assert.ok(JSON.parse(result.encryptedRound1Session).ct, 'encryptedRound1Session should be an SJCL JSON blob');\n    assert.ok(JSON.parse(result.encryptedUserGpgPrvKey).ct, 'encryptedUserGpgPrvKey should be an SJCL JSON blob');\n\n    const parsedShare = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound1Input,\n      JSON.parse(result.signatureShareRound1.share),\n      'EddsaMPCv2SignatureShareRound1Input'\n    );\n    assert.strictEqual(parsedShare.type, 'round1Input');\n    assert.ok(parsedShare.data.msg1.message, 'msg1.message should be set');\n    assert.ok(parsedShare.data.msg1.signature, 'msg1.signature should be set');\n\n    const encryptedRound1Session = JSON.parse(result.encryptedRound1Session);\n    const encryptedUserGpgPrvKey = JSON.parse(result.encryptedUserGpgPrvKey);\n    assert.strictEqual(\n      decodeURIComponent(encryptedRound1Session.adata),\n      `MPS_DSG_SIGNING_ROUND1_STATE:${expectedAdata}`,\n      'round-1 session adata should bind the signing context'\n    );\n    assert.strictEqual(\n      decodeURIComponent(encryptedUserGpgPrvKey.adata),\n      `MPS_DSG_SIGNING_USER_GPG_KEY:${expectedAdata}`,\n      'GPG private key adata should bind the signing context'\n    );\n\n    const sessionPayload = JSON.parse(sjcl.decrypt(walletPassphrase, result.encryptedRound1Session));\n    assert.ok(sessionPayload.dsgSession, 'dsgSession should be persisted for round 2');\n    assert.ok(sessionPayload.userMsgPayload, 'userMsgPayload should be persisted for round 2');\n  });\n\n  it('should use v2 encryption when encryptedPrv is a v2 envelope', async () => {\n    const encrypt = sinon\n      .stub()\n      .callsFake((input: string, adata: string) => Promise.resolve(JSON.stringify({ v: 2, input, adata })));\n    const destroy = sinon.stub();\n    const createEncryptionSession = sinon.stub().resolves({ encrypt, destroy });\n    mockBitgo.createEncryptionSession = createEncryptionSession;\n\n    const result = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n      encryptedPrv: JSON.stringify({ v: 2 }),\n    });\n\n    sinon.assert.calledOnce(createEncryptionSession);\n    assert.strictEqual(createEncryptionSession.getCall(0).args[0], walletPassphrase);\n    sinon.assert.notCalled(mockBitgo.encrypt as sinon.SinonStub);\n    sinon.assert.calledTwice(encrypt);\n    sinon.assert.calledOnce(destroy);\n\n    const encryptedRound1Session = JSON.parse(result.encryptedRound1Session);\n    const encryptedUserGpgPrvKey = JSON.parse(result.encryptedUserGpgPrvKey);\n    assert.strictEqual(encryptedRound1Session.v, 2);\n    assert.strictEqual(encryptedRound1Session.adata, `MPS_DSG_SIGNING_ROUND1_STATE:${expectedAdata}`);\n    assert.strictEqual(encryptedUserGpgPrvKey.v, 2);\n    assert.strictEqual(encryptedUserGpgPrvKey.adata, `MPS_DSG_SIGNING_USER_GPG_KEY:${expectedAdata}`);\n\n    const sessionPayload = JSON.parse(encryptedRound1Session.input);\n    assert.ok(sessionPayload.dsgSession, 'dsgSession should be persisted for round 2');\n    assert.ok(sessionPayload.userMsgPayload, 'userMsgPayload should be persisted for round 2');\n  });\n\n  it('should use SJCL encryption when encryptedPrv is a v1 blob', async () => {\n    mockBitgo.createEncryptionSession = sinon.stub();\n    const encryptedPrv = sjcl.encrypt(walletPassphrase, userKeyShare.toString('base64'));\n\n    const result = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n      encryptedPrv,\n    });\n\n    sinon.assert.notCalled(mockBitgo.createEncryptionSession as sinon.SinonStub);\n    sinon.assert.calledTwice(mockBitgo.encrypt as sinon.SinonStub);\n    assert.ok(JSON.parse(result.encryptedRound1Session).ct, 'encryptedRound1Session should be an SJCL JSON blob');\n    assert.ok(JSON.parse(result.encryptedUserGpgPrvKey).ct, 'encryptedUserGpgPrvKey should be an SJCL JSON blob');\n  });\n\n  it('should propagate the tx-only guard when transactions are missing', async () => {\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound1Share({\n          txRequest: { ...txRequest, transactions: undefined } as unknown as TxRequest,\n          prv: userKeyShare.toString('base64'),\n          walletPassphrase,\n        }),\n      /Unable to find transactions in txRequest/\n    );\n  });\n});\n\ndescribe('EddsaMPCv2Utils.createOfflineKeyGenRound1Share', () => {\n  let eddsaMPCv2Utils: EddsaMPCv2Utils;\n  let mockBitgo: BitGoBase;\n  let userGpgKeyPair: pgp.SerializedKeyPair<string>;\n  let backupGpgKeyPair: pgp.SerializedKeyPair<string>;\n  let bitgoGpgKeyPair: pgp.SerializedKeyPair<string>;\n\n  const walletPassphrase = 'testPass';\n\n  before('generate GPG key pairs', async () => {\n    userGpgKeyPair = await generateGPGKeyPair('ed25519');\n    backupGpgKeyPair = await generateGPGKeyPair('ed25519');\n    bitgoGpgKeyPair = await generateGPGKeyPair('ed25519');\n  });\n\n  beforeEach(() => {\n    const sjclEncrypt = (params: { password: string; input: string; adata?: string }) => {\n      const salt = randomBytes(8);\n      const iv = randomBytes(16);\n      return sjcl.encrypt(params.password, params.input, {\n        salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],\n        iv: [\n          bytesToWord(iv.subarray(0, 4)),\n          bytesToWord(iv.subarray(4, 8)),\n          bytesToWord(iv.subarray(8, 12)),\n          bytesToWord(iv.subarray(12, 16)),\n        ],\n        adata: params.adata,\n      });\n    };\n    mockBitgo = {\n      encrypt: sinon.stub().callsFake(sjclEncrypt),\n      encryptAsync: sinon.stub().callsFake(async (params) => sjclEncrypt(params)),\n      decrypt: sinon.stub().callsFake((params) => sjcl.decrypt(params.password, params.input)),\n      decryptAsync: sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input)),\n      getEnv: sinon.stub().returns('mock'),\n    } as unknown as BitGoBase;\n\n    const mockCoin = {\n      getMPCAlgorithm: sinon.stub().returns('eddsa'),\n    } as unknown as IBaseCoin;\n\n    eddsaMPCv2Utils = new EddsaMPCv2Utils(mockBitgo, mockCoin);\n  });\n\n  it('should produce valid signedMsg1 and encrypted round-1 session', async () => {\n    const encryptedUserGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);\n\n    const result = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({\n      walletPassphrase,\n      encryptedUserGpgPrvKey,\n      bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,\n      counterPartyGpgPubKey: backupGpgKeyPair.publicKey,\n    });\n\n    assert.ok(result.signedMsg1.message, 'signedMsg1.message should be set');\n    assert.ok(\n      result.signedMsg1.signature.includes('BEGIN PGP SIGNATURE'),\n      'signedMsg1.signature should be PGP armored'\n    );\n    assert.ok(JSON.parse(result.encryptedRound1Session).ct, 'encryptedRound1Session should be an SJCL JSON blob');\n  });\n\n  it('encryptedRound1Session should only be decryptable with correct walletPassphrase', async () => {\n    const encryptedUserGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);\n\n    const result = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({\n      walletPassphrase,\n      encryptedUserGpgPrvKey,\n      bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,\n      counterPartyGpgPubKey: backupGpgKeyPair.publicKey,\n    });\n\n    const decrypted = sjcl.decrypt(walletPassphrase, result.encryptedRound1Session);\n    const session = JSON.parse(decrypted);\n    assert.ok(session.dkgSession, 'dkgSession should be persisted');\n    assert.ok(session.ownMsgPayload, 'ownMsgPayload should be persisted');\n    assert.strictEqual(typeof session.ownMsgFrom, 'number', 'ownMsgFrom should be a number');\n\n    assert.throws(\n      () => sjcl.decrypt('wrongpassphrase', result.encryptedRound1Session),\n      'should throw on wrong passphrase'\n    );\n  });\n\n  it('should restore DKG session and handle round-2 messages after round 1', async () => {\n    const encryptedUserGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);\n\n    const result = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({\n      walletPassphrase,\n      encryptedUserGpgPrvKey,\n      bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,\n      counterPartyGpgPubKey: backupGpgKeyPair.publicKey,\n    });\n\n    const decrypted = sjcl.decrypt(walletPassphrase, result.encryptedRound1Session);\n    const { dkgSession, ownMsgPayload, ownMsgFrom } = JSON.parse(decrypted) as {\n      dkgSession: string;\n      ownMsgPayload: string;\n      ownMsgFrom: number;\n    };\n\n    const restoredDkg = new EddsaMPSDkg.DKG(3, 2, MPCv2PartiesEnum.USER);\n    await restoredDkg.restoreSession(dkgSession);\n\n    const ownMsg1: MPSTypes.DeserializedMessage = {\n      from: ownMsgFrom,\n      payload: new Uint8Array(Buffer.from(ownMsgPayload, 'base64')),\n    };\n    assert.ok(ownMsg1.payload.length > 0, 'restored payload should be non-empty');\n\n    const userGpgKey = await pgp.readKey({ armoredKey: userGpgKeyPair.publicKey });\n    const rawBytes = await MPSComms.verifyMpsMessage(result.signedMsg1, userGpgKey);\n    assert.ok(rawBytes.length > 0, 'signedMsg1 should verify against user GPG key');\n  });\n\n  it('should reject invalid encryptedUserGpgPrvKey', async () => {\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineKeyGenRound1Share({\n          walletPassphrase,\n          encryptedUserGpgPrvKey: sjcl.encrypt(walletPassphrase, 'not-a-gpg-key'),\n          bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,\n          counterPartyGpgPubKey: backupGpgKeyPair.publicKey,\n        }),\n      'should throw when GPG key cannot be parsed'\n    );\n  });\n\n  it('USER and BACKUP partyId produce different encrypted session state', async () => {\n    const userEncryptedGpgPrvKey = sjcl.encrypt(walletPassphrase, userGpgKeyPair.privateKey);\n\n    const userResult = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({\n      walletPassphrase,\n      encryptedUserGpgPrvKey: userEncryptedGpgPrvKey,\n      bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,\n      counterPartyGpgPubKey: backupGpgKeyPair.publicKey,\n      partyId: MPCv2PartiesEnum.USER,\n    });\n\n    const backupEncryptedGpgPrvKey2 = sjcl.encrypt(walletPassphrase, backupGpgKeyPair.privateKey);\n    const backupResult = await eddsaMPCv2Utils.createOfflineKeyGenRound1Share({\n      walletPassphrase,\n      encryptedUserGpgPrvKey: backupEncryptedGpgPrvKey2,\n      bitgoGpgPubKey: bitgoGpgKeyPair.publicKey,\n      counterPartyGpgPubKey: userGpgKeyPair.publicKey,\n      partyId: MPCv2PartiesEnum.BACKUP,\n    });\n\n    const userSession = JSON.parse(sjcl.decrypt(walletPassphrase, userResult.encryptedRound1Session));\n    const backupSession = JSON.parse(sjcl.decrypt(walletPassphrase, backupResult.encryptedRound1Session));\n\n    assert.strictEqual(userSession.ownMsgFrom, MPCv2PartiesEnum.USER);\n    assert.strictEqual(backupSession.ownMsgFrom, MPCv2PartiesEnum.BACKUP);\n    assert.notStrictEqual(userSession.dkgSession, backupSession.dkgSession, 'Sessions should differ between parties');\n\n    // Sessions encrypted with party-bound adata — tampered adata fails CCM tag check\n    const tamperedSession = (() => {\n      const parsed = JSON.parse(userResult.encryptedRound1Session);\n      parsed.adata = encodeURIComponent(`MPS_DKG_KEYGEN_ROUND1_STATE:${MPCv2PartiesEnum.BACKUP}`);\n      return JSON.stringify(parsed);\n    })();\n    assert.throws(\n      () => sjcl.decrypt(walletPassphrase, tamperedSession),\n      'should fail to decrypt with wrong party adata'\n    );\n  });\n});\n\ndescribe('EddsaMPCv2Utils.createOfflineRound2Share', () => {\n  let eddsaMPCv2Utils: EddsaMPCv2Utils;\n  let mockBitgo: BitGoBase;\n  let userKeyShare: Buffer;\n  let bitgoKeyShare: Buffer;\n  let bitgoGpgKeyPair: pgp.SerializedKeyPair<string>;\n  let bitgoGpgPrivKey: pgp.PrivateKey;\n\n  const walletPassphrase = 'testPass';\n  const signableHex = 'deadbeef';\n  const derivationPath = 'm/0/0';\n  const expectedAdata = `${signableHex}:${derivationPath}`;\n\n  const baseTxRequest: TxRequest = {\n    txRequestId: 'txreq-eddsa-round2',\n    walletId: 'wallet-eddsa-round2',\n    enterpriseId: 'enterprise-eddsa-round2',\n    apiVersion: 'full',\n    transactions: [\n      {\n        unsignedTx: {\n          signableHex,\n          derivationPath,\n          serializedTxHex: signableHex,\n        },\n        signatureShares: [],\n      },\n    ],\n    intent: { intentType: 'payment' },\n    unsignedTxs: [],\n  } as unknown as TxRequest;\n\n  before('generate EdDSA key shares and GPG keys', async () => {\n    const [userDkg, , bitgoDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    userKeyShare = userDkg.getKeyShare();\n    bitgoKeyShare = bitgoDkg.getKeyShare();\n\n    bitgoGpgKeyPair = await generateGPGKeyPair('ed25519');\n    bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });\n  });\n\n  beforeEach(() => {\n    mockBitgo = {\n      encrypt: sinon.stub().callsFake(async (params) => {\n        const salt = randomBytes(8);\n        const iv = randomBytes(16);\n        return sjcl.encrypt(params.password, params.input, {\n          salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],\n          iv: [\n            bytesToWord(iv.subarray(0, 4)),\n            bytesToWord(iv.subarray(4, 8)),\n            bytesToWord(iv.subarray(8, 12)),\n            bytesToWord(iv.subarray(12, 16)),\n          ],\n          adata: params.adata,\n        });\n      }),\n      decrypt: sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input)),\n    } as unknown as BitGoBase;\n\n    const mockCoin = {\n      getMPCAlgorithm: sinon.stub().returns('eddsa'),\n    } as unknown as IBaseCoin;\n\n    eddsaMPCv2Utils = new EddsaMPCv2Utils(mockBitgo, mockCoin);\n  });\n\n  it('should create a round-2 share from offline round 1', async () => {\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: baseTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n\n    const txRequestRound1 = await signBitgoEddsaRound1(\n      bitgoDsg,\n      cloneTxRequestWithEmptySignatureShares(baseTxRequest),\n      round1.signatureShareRound1,\n      round1.userGpgPubKey,\n      bitgoGpgPrivKey\n    );\n\n    const round2 = await eddsaMPCv2Utils.createOfflineRound2Share({\n      txRequest: txRequestRound1,\n      walletPassphrase,\n      bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n      encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n      encryptedRound1Session: round1.encryptedRound1Session,\n    });\n\n    assert.strictEqual(round2.signatureShareRound2.from, SignatureShareType.USER);\n    assert.strictEqual(round2.signatureShareRound2.to, SignatureShareType.BITGO);\n\n    const parsedShare = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound2Input,\n      JSON.parse(round2.signatureShareRound2.share),\n      'EddsaMPCv2SignatureShareRound2Input'\n    );\n    assert.strictEqual(parsedShare.type, 'round2Input');\n    assert.ok(parsedShare.data.msg2.message, 'msg2.message should be set');\n    assert.ok(parsedShare.data.msg2.signature, 'msg2.signature should be set');\n\n    const encryptedRound2Session = JSON.parse(round2.encryptedRound2Session);\n    assert.strictEqual(\n      decodeURIComponent(encryptedRound2Session.adata),\n      `MPS_DSG_SIGNING_ROUND2_STATE:${expectedAdata}`\n    );\n\n    const sessionPayload = JSON.parse(sjcl.decrypt(walletPassphrase, round2.encryptedRound2Session));\n    assert.ok(sessionPayload.dsgSession, 'dsgSession should be persisted for round 3');\n    assert.ok(sessionPayload.userMsgPayload, 'userMsgPayload should be persisted for round 3');\n  });\n\n  it('should use v2 decryption when encryptedRound1Session is a v2 envelope', async () => {\n    const encrypt = sinon\n      .stub()\n      .callsFake((input: string, adata: string) => Promise.resolve(JSON.stringify({ v: 2, input, adata })));\n    const destroy = sinon.stub();\n    const createEncryptionSession = sinon.stub().resolves({ encrypt, destroy });\n    mockBitgo.createEncryptionSession = createEncryptionSession;\n\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: baseTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n      encryptedPrv: JSON.stringify({ v: 2 }),\n    });\n\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n\n    const txRequestRound1 = await signBitgoEddsaRound1(\n      bitgoDsg,\n      cloneTxRequestWithEmptySignatureShares(baseTxRequest),\n      round1.signatureShareRound1,\n      round1.userGpgPubKey,\n      bitgoGpgPrivKey\n    );\n\n    const decrypt = sinon.stub().callsFake(async (params: { input: string }) => {\n      const envelope = JSON.parse(params.input);\n      return envelope.input;\n    });\n    mockBitgo.decrypt = decrypt;\n\n    const round2 = await eddsaMPCv2Utils.createOfflineRound2Share({\n      txRequest: txRequestRound1,\n      walletPassphrase,\n      bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n      encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n      encryptedRound1Session: round1.encryptedRound1Session,\n    });\n\n    sinon.assert.called(mockBitgo.decrypt as sinon.SinonStub);\n    assert.strictEqual(round2.signatureShareRound2.from, SignatureShareType.USER);\n\n    const encryptedRound2Session = JSON.parse(round2.encryptedRound2Session);\n    assert.strictEqual(encryptedRound2Session.v, 2);\n    assert.strictEqual(encryptedRound2Session.adata, `MPS_DSG_SIGNING_ROUND2_STATE:${expectedAdata}`);\n  });\n\n  it('should reject tampered encryptedRound1Session adata', async () => {\n    const otherTxRequest: TxRequest = {\n      ...baseTxRequest,\n      transactions: [\n        {\n          unsignedTx: {\n            signableHex: 'cafebabe',\n            derivationPath: 'm/1/2',\n            serializedTxHex: 'cafebabe',\n          },\n          signatureShares: [],\n        },\n      ],\n    } as unknown as TxRequest;\n\n    const round1Other = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: otherTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: baseTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n\n    const txRequestRound1 = await signBitgoEddsaRound1(\n      bitgoDsg,\n      cloneTxRequestWithEmptySignatureShares(baseTxRequest),\n      round1.signatureShareRound1,\n      round1.userGpgPubKey,\n      bitgoGpgPrivKey\n    );\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound2Share({\n          txRequest: txRequestRound1,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound1Session: round1Other.encryptedRound1Session,\n        }),\n      /Adata does not match cyphertext adata/\n    );\n  });\n\n  it('should reject tampered encryptedUserGpgPrvKey adata', async () => {\n    const otherTxRequest: TxRequest = {\n      ...baseTxRequest,\n      transactions: [\n        {\n          unsignedTx: {\n            signableHex: 'cafebabe',\n            derivationPath: 'm/1/2',\n            serializedTxHex: 'cafebabe',\n          },\n          signatureShares: [],\n        },\n      ],\n    } as unknown as TxRequest;\n\n    const round1Other = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: otherTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: baseTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    const messageBuffer = Buffer.from(signableHex, 'hex');\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, derivationPath, MPCv2PartiesEnum.USER);\n\n    const txRequestRound1 = await signBitgoEddsaRound1(\n      bitgoDsg,\n      cloneTxRequestWithEmptySignatureShares(baseTxRequest),\n      round1.signatureShareRound1,\n      round1.userGpgPubKey,\n      bitgoGpgPrivKey\n    );\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound2Share({\n          txRequest: txRequestRound1,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1Other.encryptedUserGpgPrvKey,\n          encryptedRound1Session: round1.encryptedRound1Session,\n        }),\n      /Adata does not match cyphertext adata/\n    );\n  });\n\n  it('should reject when BitGo signature share is missing', async () => {\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: baseTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    const baseTransaction = assertSingleTransaction(baseTxRequest);\n    const txRequestNoBitgoShare: TxRequest = {\n      ...baseTxRequest,\n      transactions: [\n        {\n          ...baseTransaction,\n          signatureShares: [round1.signatureShareRound1],\n        },\n      ],\n    };\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound2Share({\n          txRequest: txRequestNoBitgoShare,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound1Session: round1.encryptedRound1Session,\n        }),\n      /Missing BitGo round1Output signature share/\n    );\n  });\n\n  it('should propagate the tx-only guard when transactions are missing', async () => {\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: baseTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound2Share({\n          txRequest: { ...baseTxRequest, transactions: undefined } as unknown as TxRequest,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound1Session: round1.encryptedRound1Session,\n        }),\n      /Unable to find transactions in txRequest/\n    );\n  });\n\n  it('should reject when transactions array is empty', async () => {\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest: baseTxRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n    });\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound2Share({\n          txRequest: { ...baseTxRequest, transactions: [] },\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound1Session: round1.encryptedRound1Session,\n        }),\n      /Unable to find transactions in txRequest/\n    );\n  });\n});\n\ndescribe('EddsaMPCv2Utils.createOfflineRound3Share', () => {\n  let eddsaMPCv2Utils: EddsaMPCv2Utils;\n  let mockBitgo: BitGoBase;\n  let userKeyShare: Buffer;\n  let bitgoKeyShare: Buffer;\n  let bitgoGpgKeyPair: pgp.SerializedKeyPair<string>;\n  let bitgoGpgPrivKey: pgp.PrivateKey;\n\n  const walletPassphrase = 'testPass';\n  const signableHex = 'deadbeef';\n  const derivationPath = 'm/0/0';\n\n  const baseTxRequest: TxRequest = {\n    txRequestId: 'txreq-eddsa-round3',\n    walletId: 'wallet-eddsa-round3',\n    enterpriseId: 'enterprise-eddsa-round3',\n    apiVersion: 'full',\n    transactions: [\n      {\n        unsignedTx: {\n          signableHex,\n          derivationPath,\n          serializedTxHex: signableHex,\n        },\n        signatureShares: [],\n      },\n    ],\n    intent: { intentType: 'payment' },\n    unsignedTxs: [],\n  } as unknown as TxRequest;\n\n  before('generate EdDSA key shares and GPG keys', async () => {\n    const [userDkg, , bitgoDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    userKeyShare = userDkg.getKeyShare();\n    bitgoKeyShare = bitgoDkg.getKeyShare();\n\n    bitgoGpgKeyPair = await generateGPGKeyPair('ed25519');\n    bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });\n  });\n\n  beforeEach(() => {\n    mockBitgo = {\n      encrypt: sinon.stub().callsFake(async (params) => {\n        const salt = randomBytes(8);\n        const iv = randomBytes(16);\n        return sjcl.encrypt(params.password, params.input, {\n          salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],\n          iv: [\n            bytesToWord(iv.subarray(0, 4)),\n            bytesToWord(iv.subarray(4, 8)),\n            bytesToWord(iv.subarray(8, 12)),\n            bytesToWord(iv.subarray(12, 16)),\n          ],\n          adata: params.adata,\n        });\n      }),\n      decrypt: sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input)),\n    } as unknown as BitGoBase;\n\n    const mockCoin = {\n      getMPCAlgorithm: sinon.stub().returns('eddsa'),\n    } as unknown as IBaseCoin;\n\n    eddsaMPCv2Utils = new EddsaMPCv2Utils(mockBitgo, mockCoin);\n  });\n\n  async function createRound2Flow(\n    txRequest: TxRequest,\n    encryptedPrv?: string\n  ): Promise<{\n    round1: {\n      signatureShareRound1: SignatureShareRecord;\n      userGpgPubKey: string;\n      encryptedRound1Session: string;\n      encryptedUserGpgPrvKey: string;\n    };\n    round2: {\n      signatureShareRound2: SignatureShareRecord;\n      encryptedRound2Session: string;\n    };\n    txRequestRound1: TxRequest;\n    txRequestRound2: TxRequest;\n    messageBuffer: Buffer;\n  }> {\n    const round1 = await eddsaMPCv2Utils.createOfflineRound1Share({\n      txRequest,\n      prv: userKeyShare.toString('base64'),\n      walletPassphrase,\n      encryptedPrv,\n    });\n\n    const transaction = assertSingleTransaction(txRequest);\n    const messageBuffer = Buffer.from(transaction.unsignedTx.signableHex, 'hex');\n    const bitgoDsg = new EddsaMPSDsg.DSG(MPCv2PartiesEnum.BITGO);\n    await bitgoDsg.initDsg(bitgoKeyShare, messageBuffer, transaction.unsignedTx.derivationPath, MPCv2PartiesEnum.USER);\n\n    const txRequestRound1 = await signBitgoEddsaRound1(\n      bitgoDsg,\n      cloneTxRequestWithEmptySignatureShares(txRequest),\n      round1.signatureShareRound1,\n      round1.userGpgPubKey,\n      bitgoGpgPrivKey\n    );\n\n    const round2 = await eddsaMPCv2Utils.createOfflineRound2Share({\n      txRequest: txRequestRound1,\n      walletPassphrase,\n      bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n      encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n      encryptedRound1Session: round1.encryptedRound1Session,\n    });\n\n    const round1Transaction = assertSingleTransaction(txRequestRound1);\n    const txRequestRound2 = await signBitgoEddsaRound2(\n      bitgoDsg,\n      {\n        ...txRequestRound1,\n        transactions: [\n          {\n            ...round1Transaction,\n            signatureShares: [...round1Transaction.signatureShares],\n          },\n        ],\n      },\n      round2.signatureShareRound2,\n      round1.userGpgPubKey,\n      bitgoGpgPrivKey\n    );\n\n    return { round1, round2, txRequestRound1, txRequestRound2, messageBuffer };\n  }\n\n  it('should create a round-3 share from offline round 2', async () => {\n    const { round1, round2, txRequestRound2 } = await createRound2Flow(baseTxRequest);\n\n    const round3 = await eddsaMPCv2Utils.createOfflineRound3Share({\n      txRequest: txRequestRound2,\n      walletPassphrase,\n      bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n      encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n      encryptedRound2Session: round2.encryptedRound2Session,\n    });\n\n    assert.strictEqual(round3.signatureShareRound3.from, SignatureShareType.USER);\n    assert.strictEqual(round3.signatureShareRound3.to, SignatureShareType.BITGO);\n\n    const parsedShare = decodeWithCodec(\n      EddsaMPCv2SignatureShareRound3Input,\n      JSON.parse(round3.signatureShareRound3.share),\n      'EddsaMPCv2SignatureShareRound3Input'\n    );\n    assert.strictEqual(parsedShare.type, 'round3Input');\n    assert.ok(parsedShare.data.msg3.message, 'msg3.message should be set');\n    assert.ok(parsedShare.data.msg3.signature, 'msg3.signature should be set');\n  });\n\n  it('should use v2 decryption when encryptedRound2Session is a v2 envelope', async () => {\n    const encrypt = sinon\n      .stub()\n      .callsFake((input: string, adata: string) => Promise.resolve(JSON.stringify({ v: 2, input, adata })));\n    const destroy = sinon.stub();\n    const createEncryptionSession = sinon.stub().resolves({ encrypt, destroy });\n    mockBitgo.createEncryptionSession = createEncryptionSession;\n\n    const decrypt = sinon.stub().callsFake(async (params: { input: string }) => {\n      const envelope = JSON.parse(params.input);\n      return envelope.input;\n    });\n    mockBitgo.decrypt = decrypt;\n\n    const { round1, round2, txRequestRound2 } = await createRound2Flow(baseTxRequest, JSON.stringify({ v: 2 }));\n\n    const round3 = await eddsaMPCv2Utils.createOfflineRound3Share({\n      txRequest: txRequestRound2,\n      walletPassphrase,\n      bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n      encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n      encryptedRound2Session: round2.encryptedRound2Session,\n    });\n\n    assert.strictEqual((mockBitgo.decrypt as sinon.SinonStub).callCount, 4);\n    assert.strictEqual(round3.signatureShareRound3.from, SignatureShareType.USER);\n  });\n\n  it('should reject tampered encryptedRound2Session adata', async () => {\n    const otherTxRequest: TxRequest = {\n      ...baseTxRequest,\n      transactions: [\n        {\n          unsignedTx: {\n            signableHex: 'cafebabe',\n            derivationPath: 'm/1/2',\n            serializedTxHex: 'cafebabe',\n          },\n          signatureShares: [],\n        },\n      ],\n    } as unknown as TxRequest;\n\n    const otherFlow = await createRound2Flow(otherTxRequest);\n    const { round1, txRequestRound2 } = await createRound2Flow(baseTxRequest);\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound3Share({\n          txRequest: txRequestRound2,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound2Session: otherFlow.round2.encryptedRound2Session,\n        }),\n      /Adata does not match cyphertext adata/\n    );\n  });\n\n  it('should reject tampered encryptedUserGpgPrvKey adata', async () => {\n    const otherTxRequest: TxRequest = {\n      ...baseTxRequest,\n      transactions: [\n        {\n          unsignedTx: {\n            signableHex: 'cafebabe',\n            derivationPath: 'm/1/2',\n            serializedTxHex: 'cafebabe',\n          },\n          signatureShares: [],\n        },\n      ],\n    } as unknown as TxRequest;\n\n    const otherFlow = await createRound2Flow(otherTxRequest);\n    const { round2, txRequestRound2 } = await createRound2Flow(baseTxRequest);\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound3Share({\n          txRequest: txRequestRound2,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: otherFlow.round1.encryptedUserGpgPrvKey,\n          encryptedRound2Session: round2.encryptedRound2Session,\n        }),\n      /Adata does not match cyphertext adata/\n    );\n  });\n\n  it('should reject when BitGo round-2 signature share is missing', async () => {\n    const { round1, round2, txRequestRound1 } = await createRound2Flow(baseTxRequest);\n\n    const round1Transaction = assertSingleTransaction(txRequestRound1);\n    const txRequestNoBitgoRound2Share: TxRequest = {\n      ...txRequestRound1,\n      transactions: [\n        {\n          ...round1Transaction,\n          signatureShares: [...round1Transaction.signatureShares, round2.signatureShareRound2],\n        },\n      ],\n    };\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound3Share({\n          txRequest: txRequestNoBitgoRound2Share,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound2Session: round2.encryptedRound2Session,\n        }),\n      /Missing BitGo round2Output signature share/\n    );\n  });\n\n  it('should propagate the tx-only guard when transactions are missing', async () => {\n    const { round1, round2 } = await createRound2Flow(baseTxRequest);\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound3Share({\n          txRequest: { ...baseTxRequest, transactions: undefined } as unknown as TxRequest,\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound2Session: round2.encryptedRound2Session,\n        }),\n      /Unable to find transactions in txRequest/\n    );\n  });\n\n  it('should reject when transactions array is empty', async () => {\n    const { round1, round2 } = await createRound2Flow(baseTxRequest);\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.createOfflineRound3Share({\n          txRequest: { ...baseTxRequest, transactions: [] },\n          walletPassphrase,\n          bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,\n          encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,\n          encryptedRound2Session: round2.encryptedRound2Session,\n        }),\n      /Unable to find transactions in txRequest/\n    );\n  });\n});\n\ndescribe('getBitgoSignatureShare', () => {\n  const round1OutputShare: SignatureShareRecord = {\n    from: SignatureShareType.BITGO,\n    to: SignatureShareType.USER,\n    share: JSON.stringify({ type: 'round1Output', data: {} }),\n  };\n  const round2OutputShare: SignatureShareRecord = {\n    from: SignatureShareType.BITGO,\n    to: SignatureShareType.USER,\n    share: JSON.stringify({ type: 'round2Output', data: {} }),\n  };\n\n  it('selects the requested BitGo round output when multiple round outputs are present', () => {\n    const signatureShares = [round1OutputShare, round2OutputShare];\n\n    assert.strictEqual(\n      getBitgoSignatureShare(signatureShares, SignatureShareType.USER, 'round2Output'),\n      round2OutputShare\n    );\n    assert.strictEqual(\n      getBitgoSignatureShare(signatureShares, SignatureShareType.USER, 'round1Output'),\n      round1OutputShare\n    );\n  });\n\n  it('skips malformed share records while selecting the requested BitGo round output', () => {\n    const malformedShare: SignatureShareRecord = {\n      from: SignatureShareType.BITGO,\n      to: SignatureShareType.USER,\n      share: 'not-json',\n    };\n\n    assert.strictEqual(\n      getBitgoSignatureShare([malformedShare, round2OutputShare], SignatureShareType.USER, 'round2Output'),\n      round2OutputShare\n    );\n  });\n});\n\ntype TxRequestTransaction = NonNullable<TxRequest['transactions']>[number];\n\nfunction assertSingleTransaction(txRequest: TxRequest): TxRequestTransaction {\n  assert.ok(txRequest.transactions, 'txRequest must include transactions');\n  assert.strictEqual(txRequest.transactions.length, 1, 'txRequest must have exactly one transaction');\n  return txRequest.transactions[0];\n}\n\nfunction cloneTxRequestWithEmptySignatureShares(txRequest: TxRequest): TxRequest {\n  const transaction = assertSingleTransaction(txRequest);\n  return {\n    ...txRequest,\n    transactions: [{ ...transaction, signatureShares: [] }],\n  };\n}\n\nasync function signBitgoEddsaRound1(\n  bitgoDsg: EddsaMPSDsg.DSG,\n  txRequest: TxRequest,\n  userRound1Share: SignatureShareRecord,\n  userGpgPubKeyArmored: string,\n  bitgoGpgPrivKey: pgp.PrivateKey\n): Promise<TxRequest> {\n  const transaction = assertSingleTransaction(txRequest);\n  transaction.signatureShares.push(userRound1Share);\n\n  const bitgoMsg1 = bitgoDsg.getFirstMessage();\n\n  const parsedUserShare = decodeWithCodec(\n    EddsaMPCv2SignatureShareRound1Input,\n    JSON.parse(userRound1Share.share),\n    'EddsaMPCv2SignatureShareRound1Input'\n  );\n  const userGpgKey = await pgp.readKey({ armoredKey: userGpgPubKeyArmored });\n  const userRawMsg1Bytes = await MPSComms.verifyMpsMessage(parsedUserShare.data.msg1, userGpgKey);\n  const userMsg1 = {\n    from: MPCv2PartiesEnum.USER,\n    payload: new Uint8Array(userRawMsg1Bytes),\n  };\n\n  const [bitgoMsg2] = bitgoDsg.handleIncomingMessages([bitgoMsg1, userMsg1]);\n  assert.ok(bitgoMsg2, 'BitGo DSG produced no round-2 output');\n  (bitgoDsg as EddsaMPSDsg.DSG & { round2Message?: MPSTypes.DeserializedMessage }).round2Message = bitgoMsg2;\n\n  const bitgoSignedMsg1 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg1.payload), bitgoGpgPrivKey);\n  const round1Output: EddsaMPCv2SignatureShareRound1Output = {\n    type: 'round1Output',\n    data: { msg1: bitgoSignedMsg1 },\n  };\n\n  transaction.signatureShares.push({\n    from: SignatureShareType.BITGO,\n    to: SignatureShareType.USER,\n    share: JSON.stringify(round1Output),\n  });\n\n  return txRequest;\n}\n\nasync function signBitgoEddsaRound2(\n  bitgoDsg: EddsaMPSDsg.DSG,\n  txRequest: TxRequest,\n  userRound2Share: SignatureShareRecord,\n  userGpgPubKeyArmored: string,\n  bitgoGpgPrivKey: pgp.PrivateKey\n): Promise<TxRequest> {\n  const transaction = assertSingleTransaction(txRequest);\n  transaction.signatureShares.push(userRound2Share);\n\n  const userGpgKey = await pgp.readKey({ armoredKey: userGpgPubKeyArmored });\n  const bitgoMsg2 = (bitgoDsg as EddsaMPSDsg.DSG & { round2Message?: MPSTypes.DeserializedMessage }).round2Message;\n  assert.ok(bitgoMsg2, 'BitGo DSG is missing the cached round-2 output');\n\n  const parsedUserRound2Share = decodeWithCodec(\n    EddsaMPCv2SignatureShareRound2Input,\n    JSON.parse(userRound2Share.share),\n    'EddsaMPCv2SignatureShareRound2Input'\n  );\n  const userRawMsg2Bytes = await MPSComms.verifyMpsMessage(parsedUserRound2Share.data.msg2, userGpgKey);\n  const userMsg2 = {\n    from: MPCv2PartiesEnum.USER,\n    payload: new Uint8Array(userRawMsg2Bytes),\n  };\n\n  const bitgoSignedMsg2 = await MPSComms.detachSignMpsMessage(Buffer.from(bitgoMsg2.payload), bitgoGpgPrivKey);\n  const round2Output: EddsaMPCv2SignatureShareRound2Output = {\n    type: 'round2Output',\n    data: { msg2: bitgoSignedMsg2 },\n  };\n\n  transaction.signatureShares.push({\n    from: SignatureShareType.BITGO,\n    to: SignatureShareType.USER,\n    share: JSON.stringify(round2Output),\n  });\n\n  bitgoDsg.handleIncomingMessages([bitgoMsg2, userMsg2]);\n\n  return txRequest;\n}\n\ndescribe('EddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner', () => {\n  let sandbox: sinon.SinonSandbox;\n  let eddsaMPCv2Utils: EddsaMPCv2Utils;\n  let mockBitgo: BitGoBase;\n  let bitgoGpgKeyPair: pgp.SerializedKeyPair<string>;\n  let bitgoGpgPubKey: pgp.Key;\n\n  const walletId = 'abc123wallet';\n  const txRequestId = 'txreq-001';\n  const enterpriseId = 'ent-001';\n\n  const mockTxRequest: TxRequest = {\n    txRequestId,\n    walletId,\n    enterpriseId,\n    apiVersion: 'full',\n    transactions: [\n      {\n        unsignedTx: {\n          signableHex: 'deadbeef',\n          derivationPath: 'm/0',\n          serializedTxHex: 'deadbeef',\n        },\n        signatureShares: [\n          {\n            from: SignatureShareType.BITGO,\n            to: SignatureShareType.USER,\n            share: JSON.stringify({ type: 'round1Output', data: {} }),\n          },\n        ],\n      },\n    ],\n    intent: { intentType: 'payment' },\n    unsignedTxs: [],\n  } as unknown as TxRequest;\n\n  const mockTxRequestTransaction = assertSingleTransaction(mockTxRequest);\n  const mockTxRequestRound2: TxRequest = {\n    ...mockTxRequest,\n    transactions: [\n      {\n        ...mockTxRequestTransaction,\n        signatureShares: [\n          {\n            from: SignatureShareType.BITGO,\n            to: SignatureShareType.USER,\n            share: JSON.stringify({ type: 'round2Output', data: {} }),\n          },\n        ],\n      },\n    ],\n  };\n\n  const dummyShare: SignatureShareRecord = {\n    from: SignatureShareType.USER,\n    to: SignatureShareType.BITGO,\n    share: JSON.stringify({ type: 'round1Input', data: {} }),\n  };\n\n  // Returns a chain compatible with: bitgo.post(url).send(body).result()\n  const makePostChain = (response: TxRequest): BitGoRequest<TxRequest> =>\n    ({ send: () => ({ result: sinon.stub().resolves(response) }) } as unknown as BitGoRequest<TxRequest>);\n\n  // Returns a chain compatible with: bitgo.get(url).query(params).retry(n).result()\n  const makeGetChain = (txRequests: TxRequest[]): BitGoRequest<{ txRequests: TxRequest[] }> =>\n    ({\n      query: () => ({\n        retry: () => ({ result: sinon.stub().resolves({ txRequests }) }),\n      }),\n    } as unknown as BitGoRequest<{ txRequests: TxRequest[] }>);\n\n  before(async () => {\n    bitgoGpgKeyPair = await generateGPGKeyPair('ed25519');\n    bitgoGpgPubKey = await pgp.readKey({ armoredKey: bitgoGpgKeyPair.publicKey });\n  });\n\n  beforeEach(async () => {\n    sandbox = sinon.createSandbox();\n\n    // Full mock of the BitGo HTTP client (consistent with other sdk-core tests such as\n    // tokenApproval.ts and walletsEvmKeyring.ts).  Module-level stubs on tssCommon functions\n    // do not work under tsx 4.x (ESM live bindings), so we mock at the bitgo object level.\n    mockBitgo = {\n      getEnv: sinon.stub().returns('test'),\n      setRequestTracer: sinon.stub(),\n      url: sinon.stub().callsFake((path: string) => `https://test.bitgo.com${path}`),\n      post: sinon.stub(),\n      get: sinon.stub(),\n    } as unknown as BitGoBase;\n\n    const mockCoin = {\n      getMPCAlgorithm: sinon.stub().returns('eddsa'),\n    } as unknown as IBaseCoin;\n\n    const mockWallet = {\n      id: sinon.stub().returns(walletId),\n      keyIds: sinon.stub().returns(['userKeyId', 'backupKeyId', 'bitgoKeyId']),\n      multisigTypeVersion: sinon.stub().returns('MPCv2'),\n    } as unknown as IWallet;\n\n    eddsaMPCv2Utils = new EddsaMPCv2Utils(mockBitgo, mockCoin, mockWallet);\n\n    sandbox.stub(eddsaMPCv2Utils, 'pickBitgoPubGpgKeyForSigning').resolves(bitgoGpgPubKey);\n  });\n\n  afterEach(() => {\n    sandbox.restore();\n  });\n\n  it('should call all 3 generators and return the final tx request', async () => {\n    const finalTxRequest = { ...mockTxRequest, txRequestId };\n\n    // sendSignatureShareV2 is called 3 times (one per round), sendTxRequest once — all use bitgo.post\n    (mockBitgo.post as sinon.SinonStub)\n      .onCall(0)\n      .returns(makePostChain(mockTxRequest)) // round 1 sign\n      .onCall(1)\n      .returns(makePostChain(mockTxRequestRound2)) // round 2 sign\n      .onCall(2)\n      .returns(makePostChain(mockTxRequestRound2)) // round 3 sign\n      .onCall(3)\n      .returns(makePostChain(finalTxRequest)); // sendTxRequest (send)\n\n    const encryptedRound1Session = 'encrypted-r1-session';\n    const encryptedRound2Session = 'encrypted-r2-session';\n    const encryptedUserGpgPrvKey = 'encrypted-gpg-key';\n    const userGpgPubKey = bitgoGpgKeyPair.publicKey;\n\n    const round1Share: SignatureShareRecord = { ...dummyShare };\n    const round2Share: SignatureShareRecord = { ...dummyShare, share: JSON.stringify({ type: 'round2Input' }) };\n    const round3Share: SignatureShareRecord = { ...dummyShare, share: JSON.stringify({ type: 'round3Input' }) };\n\n    const round1Generator = sinon\n      .stub()\n      .resolves({ signatureShareRound1: round1Share, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey });\n    const round2Generator = sinon.stub().resolves({ signatureShareRound2: round2Share, encryptedRound2Session });\n    const round3Generator = sinon.stub().resolves({ signatureShareRound3: round3Share });\n\n    const result = await eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner(\n      { txRequest: mockTxRequest, reqId: new RequestTracer() },\n      round1Generator as unknown as CustomEddsaMPCv2SigningRound1GeneratingFunction,\n      round2Generator as unknown as CustomEddsaMPCv2SigningRound2GeneratingFunction,\n      round3Generator as unknown as CustomEddsaMPCv2SigningRound3GeneratingFunction\n    );\n\n    assert.deepStrictEqual(result, finalTxRequest);\n\n    sinon.assert.calledOnce(round1Generator);\n    sinon.assert.calledWith(round1Generator, { txRequest: mockTxRequest });\n\n    sinon.assert.calledOnce(round2Generator);\n    const round2Call = round2Generator.getCall(0);\n    assert.strictEqual(round2Call.args[0].txRequest, mockTxRequest);\n    assert.strictEqual(round2Call.args[0].encryptedRound1Session, encryptedRound1Session);\n    assert.strictEqual(round2Call.args[0].encryptedUserGpgPrvKey, encryptedUserGpgPrvKey);\n    assert.strictEqual(round2Call.args[0].bitgoPublicGpgKey, bitgoGpgPubKey.armor());\n\n    sinon.assert.calledOnce(round3Generator);\n    const round3Call = round3Generator.getCall(0);\n    assert.strictEqual(round3Call.args[0].txRequest, mockTxRequestRound2);\n    assert.strictEqual(round3Call.args[0].encryptedRound2Session, encryptedRound2Session);\n    assert.strictEqual(round3Call.args[0].encryptedUserGpgPrvKey, encryptedUserGpgPrvKey);\n    assert.strictEqual(round3Call.args[0].bitgoPublicGpgKey, bitgoGpgPubKey.armor());\n\n    // 3 sendSignatureShareV2 calls + 1 sendTxRequest = 4 POST calls total\n    assert.strictEqual((mockBitgo.post as sinon.SinonStub).callCount, 4);\n  });\n\n  it('should resolve txRequest by ID string using getTxRequest', async () => {\n    // getTxRequest uses bitgo.get; sendSignatureShareV2 (×3) + sendTxRequest use bitgo.post\n    (mockBitgo.get as sinon.SinonStub).returns(makeGetChain([mockTxRequest]));\n    (mockBitgo.post as sinon.SinonStub)\n      .onCall(0)\n      .returns(makePostChain(mockTxRequest))\n      .onCall(1)\n      .returns(makePostChain(mockTxRequestRound2))\n      .onCall(2)\n      .returns(makePostChain(mockTxRequestRound2))\n      .onCall(3)\n      .returns(makePostChain(mockTxRequest));\n\n    const round1Generator = sinon.stub().resolves({\n      signatureShareRound1: dummyShare,\n      userGpgPubKey: bitgoGpgKeyPair.publicKey,\n      encryptedRound1Session: 'r1',\n      encryptedUserGpgPrvKey: 'key',\n    });\n    const round2Generator = sinon.stub().resolves({ signatureShareRound2: dummyShare, encryptedRound2Session: 'r2' });\n    const round3Generator = sinon.stub().resolves({ signatureShareRound3: dummyShare });\n\n    await eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner(\n      { txRequest: txRequestId, reqId: new RequestTracer() },\n      round1Generator as unknown as CustomEddsaMPCv2SigningRound1GeneratingFunction,\n      round2Generator as unknown as CustomEddsaMPCv2SigningRound2GeneratingFunction,\n      round3Generator as unknown as CustomEddsaMPCv2SigningRound3GeneratingFunction\n    );\n\n    sinon.assert.calledOnce(mockBitgo.get as sinon.SinonStub);\n    sinon.assert.calledWith(round1Generator, { txRequest: mockTxRequest });\n  });\n\n  it('should throw when round 2 txRequest is missing signatureShares', async () => {\n    const round2NoShares: TxRequest = {\n      ...mockTxRequest,\n      transactions: [{ ...mockTxRequestTransaction, signatureShares: undefined as unknown as [] }],\n    };\n\n    (mockBitgo.post as sinon.SinonStub)\n      .onCall(0)\n      .returns(makePostChain(mockTxRequest))\n      .onCall(1)\n      .returns(makePostChain(round2NoShares));\n\n    const round1Generator = sinon.stub().resolves({\n      signatureShareRound1: dummyShare,\n      userGpgPubKey: bitgoGpgKeyPair.publicKey,\n      encryptedRound1Session: 'r1',\n      encryptedUserGpgPrvKey: 'key',\n    });\n    const round2Generator = sinon.stub().resolves({ signatureShareRound2: dummyShare, encryptedRound2Session: 'r2' });\n    const round3Generator = sinon.stub().resolves({ signatureShareRound3: dummyShare });\n\n    await assert.rejects(\n      () =>\n        eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner(\n          { txRequest: mockTxRequest, reqId: new RequestTracer() },\n          round1Generator as unknown as CustomEddsaMPCv2SigningRound1GeneratingFunction,\n          round2Generator as unknown as CustomEddsaMPCv2SigningRound2GeneratingFunction,\n          round3Generator as unknown as CustomEddsaMPCv2SigningRound3GeneratingFunction\n        ),\n      /Missing signature shares in round 2 txRequest/\n    );\n  });\n\n  it('should pass armored BitGo public GPG key to round 2 and round 3 generators', async () => {\n    (mockBitgo.post as sinon.SinonStub)\n      .onCall(0)\n      .returns(makePostChain(mockTxRequest))\n      .onCall(1)\n      .returns(makePostChain(mockTxRequestRound2))\n      .onCall(2)\n      .returns(makePostChain(mockTxRequestRound2))\n      .onCall(3)\n      .returns(makePostChain(mockTxRequest));\n\n    const round1Generator = sinon.stub().resolves({\n      signatureShareRound1: dummyShare,\n      userGpgPubKey: bitgoGpgKeyPair.publicKey,\n      encryptedRound1Session: 'r1',\n      encryptedUserGpgPrvKey: 'key',\n    });\n    const round2Generator = sinon.stub().resolves({ signatureShareRound2: dummyShare, encryptedRound2Session: 'r2' });\n    const round3Generator = sinon.stub().resolves({ signatureShareRound3: dummyShare });\n\n    await eddsaMPCv2Utils.signEddsaMPCv2TssUsingExternalSigner(\n      { txRequest: mockTxRequest, reqId: new RequestTracer() },\n      round1Generator as unknown as CustomEddsaMPCv2SigningRound1GeneratingFunction,\n      round2Generator as unknown as CustomEddsaMPCv2SigningRound2GeneratingFunction,\n      round3Generator as unknown as CustomEddsaMPCv2SigningRound3GeneratingFunction\n    );\n\n    const armoredKey = bitgoGpgPubKey.armor();\n    assert.strictEqual(\n      round2Generator.getCall(0).args[0].bitgoPublicGpgKey,\n      armoredKey,\n      'round 2 should receive armored BitGo GPG key'\n    );\n    assert.strictEqual(\n      round3Generator.getCall(0).args[0].bitgoPublicGpgKey,\n      armoredKey,\n      'round 3 should receive armored BitGo GPG key'\n    );\n  });\n});\n\nfunction bytesToWord(bytes?: Uint8Array | number[]): number {\n  if (!(bytes instanceof Uint8Array) || bytes.length !== 4) {\n    throw new Error('bytes must be a Uint8Array with length 4');\n  }\n\n  return bytes.reduce((num, byte) => num * 0x100 + byte, 0);\n}\n\ndescribe('EDDSAUtils.isEddsaMpcV1SigningMaterial', () => {\n  const PASSPHRASE = 'test-passphrase';\n\n  const MPCv1_MATERIAL_BACKUP = {\n    uShare: { i: 1, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },\n    bitgoYShare: { i: 3, j: 1, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },\n    backupYShare: { i: 2, j: 1, y: 'aabbcc', u: 'backup-u-value', chaincode: '00' },\n  };\n\n  const MPCv1_MATERIAL_USER = {\n    uShare: { i: 2, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },\n    bitgoYShare: { i: 3, j: 2, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },\n    userYShare: { i: 1, j: 2, y: 'aabbcc', u: 'user-u-value', chaincode: '00' },\n  };\n\n  const MPCv2_CBOR_BYTES = Buffer.from([0xd9, 0x01, 0x04, 0xa3, 0x61, 0x78, 0x18, 0x00]).toString('base64');\n\n  let mockBitgo: BitGoBase;\n  beforeEach(() => {\n    // sdk-core has no devDependency on sdk-api/argon2, so v2 envelopes are simulated here.\n    // Real bitgo.decrypt routes v2 to Argon2id; the stub returns MPCv2 CBOR plaintext instead.\n    mockBitgo = {\n      decrypt: sinon.stub().callsFake(async (params: { input: string; password: string }) => {\n        if (isV2Envelope(params.input)) {\n          return MPCv2_CBOR_BYTES;\n        }\n        return sjcl.decrypt(params.password, params.input);\n      }),\n    } as unknown as BitGoBase;\n  });\n\n  it('returns true for MPCv1 SJCL-encrypted keycard with backupYShare + correct passphrase', async () => {\n    const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL_BACKUP));\n    assert.strictEqual(await EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), true);\n  });\n\n  it('returns true for MPCv1 SJCL-encrypted keycard with userYShare + correct passphrase', async () => {\n    const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL_USER));\n    assert.strictEqual(await EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), true);\n  });\n\n  it('returns false for MPCv2 CBOR content wrapped in SJCL envelope + correct passphrase', async () => {\n    const encrypted = sjcl.encrypt(PASSPHRASE, MPCv2_CBOR_BYTES);\n    assert.strictEqual(await EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), false);\n  });\n\n  it('returns false for MPCv2 Argon2id envelope (v2) + correct passphrase (forward-compat)', async () => {\n    const fakeV2Envelope = JSON.stringify({ v: 2, m: 65536, t: 3, p: 4, salt: 'AAAA', iv: 'AAAA', ct: 'AAAA' });\n    assert.strictEqual(await EDDSAUtils.isEddsaMpcV1SigningMaterial(fakeV2Envelope, PASSPHRASE, mockBitgo), false);\n  });\n\n  it('throws on wrong passphrase', async () => {\n    const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL_BACKUP));\n    await assert.rejects(\n      EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, 'wrong-passphrase'),\n      /ccm: tag doesn't match/\n    );\n  });\n\n  it('returns false when neither backupYShare.u nor userYShare.u is present', async () => {\n    const partial = { uShare: { seed: 'abc' }, bitgoYShare: { u: 'xyz' } };\n    const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(partial));\n    assert.strictEqual(await EDDSAUtils.isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), false);\n  });\n});\n\ndescribe('signRecoveryEddsaMPCv2', () => {\n  const derivationPath = 'm/0/0';\n\n  it('should return a 64-byte signature that verifies against the derived public key', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const message = Buffer.from('deadbeef', 'hex');\n    const commonKeyChain = userDkg.getCommonKeychain();\n\n    const signature = await EDDSAUtils.signRecoveryEddsaMPCv2(\n      message,\n      derivationPath,\n      userDkg.getKeyShare(),\n      backupDkg.getKeyShare(),\n      commonKeyChain\n    );\n\n    assert.strictEqual(signature.length, 64);\n\n    const mpc = await getInitializedMpcInstance();\n    const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);\n    const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');\n    const ok = ed25519.verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKeyBytes));\n    assert.strictEqual(ok, true);\n  });\n\n  it('should return false when verifying the signature against a different message', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const message = Buffer.from('deadbeef', 'hex');\n    const commonKeyChain = userDkg.getCommonKeychain();\n\n    const signature = await EDDSAUtils.signRecoveryEddsaMPCv2(\n      message,\n      derivationPath,\n      userDkg.getKeyShare(),\n      backupDkg.getKeyShare(),\n      commonKeyChain\n    );\n\n    const differentMessage = Buffer.from('cafebabe', 'hex');\n    const mpc = await getInitializedMpcInstance();\n    const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);\n    const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');\n    const ok = ed25519.verify(\n      new Uint8Array(signature),\n      new Uint8Array(differentMessage),\n      new Uint8Array(publicKeyBytes)\n    );\n    assert.strictEqual(ok, false);\n  });\n\n  it('should throw when a wrong commonKeyChain is provided (verification mismatch)', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const [wrongDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const message = Buffer.from('deadbeef', 'hex');\n\n    await assert.rejects(\n      () =>\n        EDDSAUtils.signRecoveryEddsaMPCv2(\n          message,\n          derivationPath,\n          userDkg.getKeyShare(),\n          backupDkg.getKeyShare(),\n          wrongDkg.getCommonKeychain() // key chain from a different wallet\n        ),\n      /EdDSA MPCv2 recovery signature verification failed/\n    );\n  });\n});\n\ndescribe('getEddsaSigningMaterial', () => {\n  const PASSPHRASE = 'test-passphrase';\n\n  const MPCv1_MATERIAL = {\n    uShare: { i: 1, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },\n    bitgoYShare: { i: 3, j: 1, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },\n    backupYShare: { i: 2, j: 1, y: 'aabbcc', u: 'backup-u-value', chaincode: '00' },\n  };\n\n  it('returns { version: v1, userPrv } for MPCv1 JSON keycard', async () => {\n    const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL));\n    const decryptStub = sinon.stub().resolves(JSON.stringify(MPCv1_MATERIAL));\n    const mockBitgo = { decrypt: decryptStub } as unknown as BitGoBase;\n\n    const result = await getEddsaSigningMaterial(encrypted, PASSPHRASE, mockBitgo);\n\n    assert.strictEqual(result.version, 'v1');\n    assert.strictEqual((result as { version: 'v1'; userPrv: string }).userPrv, JSON.stringify(MPCv1_MATERIAL));\n    sinon.assert.calledOnce(decryptStub);\n    sinon.assert.calledWithMatch(decryptStub, { input: sinon.match.string, password: PASSPHRASE });\n  });\n\n  it('returns { version: v2, encryptedUserKey } for MPCv2 CBOR keycard', async () => {\n    const MPCv2_CBOR_BYTES = Buffer.from([0xd9, 0x01, 0x04, 0xa3, 0x61, 0x78, 0x18, 0x00]).toString('base64');\n    const encrypted = sjcl.encrypt(PASSPHRASE, MPCv2_CBOR_BYTES);\n    const normalizedKey = encrypted.replace(/\\s/g, '');\n\n    const result = await getEddsaSigningMaterial(encrypted, PASSPHRASE);\n\n    assert.strictEqual(result.version, 'v2');\n    assert.ok('encryptedUserKey' in result);\n    assert.strictEqual((result as { version: 'v2'; encryptedUserKey: string }).encryptedUserKey, normalizedKey);\n  });\n\n  it('throws with context message when decryption fails', async () => {\n    const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL));\n    await assert.rejects(\n      () => getEddsaSigningMaterial(encrypted, 'wrong-passphrase'),\n      /Error decrypting user keychain/\n    );\n  });\n\n  it('returns v1 via sjcl fallback when bitgo is omitted', async () => {\n    const encrypted = sjcl.encrypt(PASSPHRASE, JSON.stringify(MPCv1_MATERIAL));\n    const result = await getEddsaSigningMaterial(encrypted, PASSPHRASE);\n    assert.strictEqual(result.version, 'v1');\n    assert.strictEqual((result as { version: 'v1'; userPrv: string }).userPrv, JSON.stringify(MPCv1_MATERIAL));\n  });\n});\n\ndescribe('isEddsaSigningMaterial', () => {\n  it('returns true for a valid v1 shape', () => {\n    assert.strictEqual(isEddsaSigningMaterial({ version: 'v1', userPrv: '{}' }), true);\n  });\n\n  it('returns true for a valid v2 shape', () => {\n    assert.strictEqual(isEddsaSigningMaterial({ version: 'v2', encryptedUserKey: 'abc123' }), true);\n  });\n\n  it('returns false for a v1 shape with a non-string userPrv', () => {\n    assert.strictEqual(isEddsaSigningMaterial({ version: 'v1', userPrv: 123 }), false);\n  });\n\n  it('returns false for a v2 shape with a non-string encryptedUserKey', () => {\n    assert.strictEqual(isEddsaSigningMaterial({ version: 'v2', encryptedUserKey: 123 }), false);\n  });\n\n  it('returns false for an unrecognized version value', () => {\n    assert.strictEqual(isEddsaSigningMaterial({ version: 'v3', userPrv: '{}' }), false);\n  });\n\n  it('returns false for an object missing a version field', () => {\n    assert.strictEqual(isEddsaSigningMaterial({ userPrv: '{}' }), false);\n  });\n\n  it('returns false for null', () => {\n    assert.strictEqual(isEddsaSigningMaterial(null), false);\n  });\n\n  it('returns false for undefined', () => {\n    assert.strictEqual(isEddsaSigningMaterial(undefined), false);\n  });\n\n  it('returns false for primitive values', () => {\n    assert.strictEqual(isEddsaSigningMaterial('a string'), false);\n    assert.strictEqual(isEddsaSigningMaterial(42), false);\n    assert.strictEqual(isEddsaSigningMaterial(true), false);\n  });\n\n  it('returns false for an ArrayBuffer (regression: WRW openSSLBytes collision)', () => {\n    // WRW's generic Electron 'recover' IPC handler passes openSSLBytes as a second\n    // positional argument to every coin's recover(), colliding with precomputedMaterial\n    // on coins that accept it. This must be rejected rather than misread as signing material.\n    assert.strictEqual(isEddsaSigningMaterial(new ArrayBuffer(8)), false);\n  });\n});\n\ndescribe('signEddsaMpcV2RecoveryTx', () => {\n  const derivationPath = 'm/0/0';\n  const walletPassphrase = 'testPass';\n\n  const makeDecryptBitgo = (userKeyBase64: string, backupKeyBase64: string): BitGoBase =>\n    ({\n      decrypt: sinon.stub().onFirstCall().resolves(userKeyBase64).onSecondCall().resolves(backupKeyBase64),\n    } as unknown as BitGoBase);\n\n  it('returns a 64-byte signature that verifies against the derived public key', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const message = Buffer.from('deadbeef', 'hex');\n    const commonKeyChain = userDkg.getCommonKeychain();\n    const mockBitgo = makeDecryptBitgo(\n      userDkg.getReducedKeyShare().toString('base64'),\n      backupDkg.getReducedKeyShare().toString('base64')\n    );\n\n    const result = await signEddsaMpcV2RecoveryTx({\n      message,\n      userKey: 'encrypted-user-key',\n      backupKey: 'encrypted-backup-key',\n      walletPassphrase,\n      bitgoKey: commonKeyChain,\n      derivationPath,\n      bitgo: mockBitgo,\n    });\n\n    assert.strictEqual(result.length, 64);\n    const mpc = await getInitializedMpcInstance();\n    const derivedKeychain = mpc.deriveUnhardened(commonKeyChain, derivationPath);\n    const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');\n    const ok = ed25519.verify(new Uint8Array(result), new Uint8Array(message), new Uint8Array(publicKeyBytes));\n    assert.strictEqual(ok, true);\n  });\n\n  it('throws when commonKeyChain does not match bitgoKey', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const message = Buffer.from('deadbeef', 'hex');\n    const mockBitgo = makeDecryptBitgo(\n      userDkg.getReducedKeyShare().toString('base64'),\n      backupDkg.getReducedKeyShare().toString('base64')\n    );\n\n    await assert.rejects(\n      () =>\n        signEddsaMpcV2RecoveryTx({\n          message,\n          userKey: 'encrypted-user-key',\n          backupKey: 'encrypted-backup-key',\n          walletPassphrase,\n          bitgoKey: 'bbbb'.repeat(32),\n          derivationPath,\n          bitgo: mockBitgo,\n        }),\n      /commonKeyChain from keycard does not match bitgoKey/\n    );\n  });\n\n  it('passes userKey, backupKey, passphrase, and bitgo to getEddsaMpcV2RecoveryKeySharesFromReducedKey', async () => {\n    const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const message = Buffer.from('deadbeef', 'hex');\n    const decryptStub = sinon\n      .stub()\n      .onFirstCall()\n      .resolves(userDkg.getReducedKeyShare().toString('base64'))\n      .onSecondCall()\n      .resolves(backupDkg.getReducedKeyShare().toString('base64'));\n    const mockBitgo = { decrypt: decryptStub } as unknown as BitGoBase;\n\n    await signEddsaMpcV2RecoveryTx({\n      message,\n      userKey: 'u-key',\n      backupKey: 'b-key',\n      walletPassphrase,\n      bitgoKey: userDkg.getCommonKeychain(),\n      derivationPath,\n      bitgo: mockBitgo,\n    });\n\n    sinon.assert.calledWith(decryptStub.firstCall, { input: 'u-key', password: walletPassphrase });\n    sinon.assert.calledWith(decryptStub.secondCall, { input: 'b-key', password: walletPassphrase });\n  });\n});\n\ndescribe('EddsaMPCv2Utils.createKeychainsWithExternalSigner', function () {\n  let utils: EddsaMPCv2Utils;\n  let callbacks: EddsaMPCv2KeyGenCallbacks;\n  const enterprise = 'enterprise-id';\n  const sessionId = 'session-001';\n  const commonKeychain = 'common-keychain-hex';\n\n  const userState = { encryptedData: 'u-data', encryptedDataKey: 'u-data-key' };\n  const backupState = { encryptedData: 'b-data', encryptedDataKey: 'b-data-key' };\n  const userSignedMsg1: MPSTypes.MPSSignedMessage = { message: 'umsg1', signature: 'usig1' };\n  const backupSignedMsg1: MPSTypes.MPSSignedMessage = { message: 'bmsg1', signature: 'bsig1' };\n  const userSignedMsg2: MPSTypes.MPSSignedMessage = { message: 'umsg2', signature: 'usig2' };\n  const backupSignedMsg2: MPSTypes.MPSSignedMessage = { message: 'bmsg2', signature: 'bsig2' };\n  const bitgoMsg1: MPSTypes.MPSSignedMessage = { message: 'bitgo-msg1', signature: 'bitgo-sig1' };\n  const bitgoMsg2: MPSTypes.MPSSignedMessage = { message: 'bitgo-msg2', signature: 'bitgo-sig2' };\n\n  beforeEach(function () {\n    callbacks = {\n      initializeCallback: sinon.stub().resolves({\n        userGpgPublicKey: 'user-gpg-pub',\n        backupGpgPublicKey: 'backup-gpg-pub',\n        userState,\n        backupState,\n      }),\n      round1Callback: sinon.stub().resolves({\n        userSignedMsg1,\n        backupSignedMsg1,\n        userState,\n        backupState,\n      }),\n      round2Callback: sinon.stub().resolves({\n        userSignedMsg2,\n        backupSignedMsg2,\n        userState,\n        backupState,\n      }),\n      finalizeCallback: sinon.stub().resolves({ commonKeychain }),\n    };\n\n    const mockBitGo = {\n      getEnv: sinon.stub().returns('dev'),\n    } as any;\n\n    const mockKeychains = {\n      add: sinon\n        .stub()\n        .callsFake((params: any) => Promise.resolve({ id: `${params.source}-key-id`, commonKeychain, isMPCv2: true })),\n    };\n\n    const mockCoin = {\n      keychains: sinon.stub().returns(mockKeychains),\n    } as any;\n\n    utils = new EddsaMPCv2Utils(mockBitGo, mockCoin);\n\n    sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags' as any).resolves({ eddsaMpcv2PublicKey: null });\n    (utils as any).bitgoEddsaMpcv2PublicGpgKey = { armor: () => '-----BEGIN PGP PUBLIC KEY BLOCK-----\\n' };\n\n    sinon.stub(utils, 'sendKeyGenerationRound1').resolves({\n      sessionId: sessionId as any,\n      bitgoMsg1,\n    });\n    sinon.stub(utils, 'sendKeyGenerationRound2').resolves({\n      sessionId: sessionId as any,\n      commonPublicKeychain: commonKeychain as any,\n      bitgoMsg2,\n    });\n    sinon.stub(utils as any, 'addBitgoKeychain').resolves({ id: 'bitgo-key-id', commonKeychain, isMPCv2: true });\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('should invoke callbacks in order and return keychains', async function () {\n    const keychains = await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    assert.ok(keychains.userKeychain);\n    assert.ok(keychains.backupKeychain);\n    assert.ok(keychains.bitgoKeychain);\n\n    sinon.assert.calledOnce(callbacks.initializeCallback as sinon.SinonStub);\n    sinon.assert.calledOnce(callbacks.round1Callback as sinon.SinonStub);\n    sinon.assert.calledOnce(callbacks.round2Callback as sinon.SinonStub);\n    sinon.assert.calledOnce(callbacks.finalizeCallback as sinon.SinonStub);\n  });\n\n  it('should pass round1 response to round2Callback', async function () {\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    const round2Args = (callbacks.round2Callback as sinon.SinonStub).firstCall.args[0];\n    assert.deepStrictEqual(round2Args.bitgoMsg1, bitgoMsg1);\n    assert.deepStrictEqual(round2Args.userSignedMsg1, userSignedMsg1);\n    assert.deepStrictEqual(round2Args.backupSignedMsg1, backupSignedMsg1);\n    assert.deepStrictEqual(round2Args.userState, userState);\n    assert.deepStrictEqual(round2Args.backupState, backupState);\n  });\n\n  it('should pass round2 response to finalizeCallback', async function () {\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    const finalizeArgs = (callbacks.finalizeCallback as sinon.SinonStub).firstCall.args[0];\n    assert.deepStrictEqual(finalizeArgs.bitgoMsg2, bitgoMsg2);\n    assert.strictEqual(finalizeArgs.bitgoCommonKeychain, commonKeychain);\n    assert.deepStrictEqual(finalizeArgs.userState, userState);\n    assert.deepStrictEqual(finalizeArgs.backupState, backupState);\n  });\n\n  it('should register keychains with isMPCv2: true', async function () {\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    const mockKeychains = (utils as any).baseCoin.keychains();\n    const addCalls = (mockKeychains.add as sinon.SinonStub).getCalls();\n    assert.ok(addCalls.length >= 2, 'keychains.add should be called for user and backup');\n    for (const call of addCalls) {\n      assert.strictEqual(call.args[0].isMPCv2, true);\n      assert.strictEqual(call.args[0].keyType, 'tss');\n      assert.strictEqual(call.args[0].commonKeychain, commonKeychain);\n    }\n  });\n\n  it('should reject when finalizeCallback returns mismatched commonKeychain', async function () {\n    (callbacks.finalizeCallback as sinon.SinonStub).resolves({ commonKeychain: 'different-keychain' });\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /Common keychains do not match/\n    );\n  });\n\n  it('should reject when round2 returns mismatched sessionId', async function () {\n    (utils.sendKeyGenerationRound2 as sinon.SinonStub).resolves({\n      sessionId: 'different-session' as any,\n      commonPublicKeychain: commonKeychain as any,\n      bitgoMsg2,\n    });\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /Round 1 and round 2 session IDs do not match/\n    );\n  });\n\n  it('should reject when BitGo EdDSA MPCv2 GPG public key is missing', async function () {\n    (utils as any).bitgoEddsaMpcv2PublicGpgKey = undefined;\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /Failed to get BitGo EdDSA MPCv2 GPG public key/\n    );\n  });\n});\n\ndescribe('EddsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Keys', () => {\n  let utils: EddsaMPCv2Utils;\n  // Real 3-party MPCv1 EdDSA key shares: 1 = user, 2 = backup, 3 = bitgo.\n  let userSigningMaterial: Record<string, unknown>;\n  let backupSigningMaterial: Record<string, unknown>;\n  let expectedUserPShare: { y: string; u: string; chaincode: string };\n  let expectedBackupPShare: { y: string; u: string; chaincode: string };\n\n  before(async () => {\n    const MPC = await getInitializedMpcInstance();\n    const user = MPC.keyShare(1, 2, 3);\n    const backup = MPC.keyShare(2, 2, 3);\n    const bitgo = MPC.keyShare(3, 2, 3);\n\n    expectedUserPShare = MPC.keyCombine(user.uShare, [backup.yShares[1], bitgo.yShares[1]]).pShare;\n    expectedBackupPShare = MPC.keyCombine(backup.uShare, [user.yShares[2], bitgo.yShares[2]]).pShare;\n\n    userSigningMaterial = {\n      uShare: user.uShare,\n      bitgoYShare: bitgo.yShares[1],\n      backupYShare: backup.yShares[1],\n    };\n    backupSigningMaterial = {\n      uShare: backup.uShare,\n      bitgoYShare: bitgo.yShares[2],\n      userYShare: user.yShares[2],\n    };\n  });\n\n  beforeEach(() => {\n    const mockBitGo = {} as unknown as BitGoBase;\n    const mockCoin = {} as unknown as IBaseCoin;\n    utils = new EddsaMPCv2Utils(mockBitGo, mockCoin);\n  });\n\n  it('derives matching expectedPk and chainCode for user and backup from real MPCv1 key combine', async () => {\n    const { userRetrofitData, backupRetrofitData } = await utils.getMpcV2RetrofitDataFromMpcV1Keys({\n      mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),\n      mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),\n    });\n\n    assert.strictEqual(userRetrofitData.expectedPk, expectedUserPShare.y);\n    assert.strictEqual(backupRetrofitData.expectedPk, expectedBackupPShare.y);\n    assert.strictEqual(userRetrofitData.expectedPk, backupRetrofitData.expectedPk);\n\n    assert.strictEqual(userRetrofitData.chainCode, expectedUserPShare.chaincode);\n    assert.strictEqual(backupRetrofitData.chainCode, expectedBackupPShare.chaincode);\n    assert.strictEqual(userRetrofitData.chainCode, backupRetrofitData.chainCode);\n  });\n\n  it('derives s_i_0 as the combined pShare.u (clamped scalar) for each party', async () => {\n    const { userRetrofitData, backupRetrofitData } = await utils.getMpcV2RetrofitDataFromMpcV1Keys({\n      mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),\n      mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),\n    });\n\n    assert.strictEqual(userRetrofitData.s_i_0, expectedUserPShare.u);\n    assert.strictEqual(backupRetrofitData.s_i_0, expectedBackupPShare.u);\n    assert.notStrictEqual(userRetrofitData.s_i_0, backupRetrofitData.s_i_0);\n  });\n\n  it('throws if user key is missing uShare', async () => {\n    const keyNoUShare = JSON.stringify({\n      bitgoYShare: userSigningMaterial.bitgoYShare,\n      backupYShare: userSigningMaterial.backupYShare,\n    });\n    await assert.rejects(\n      () =>\n        utils.getMpcV2RetrofitDataFromMpcV1Keys({\n          mpcv1UserKeyShare: keyNoUShare,\n          mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),\n        }),\n      /MPCv1 key material missing uShare/\n    );\n  });\n\n  it('throws if user key is missing bitgoYShare', async () => {\n    const keyNoBitgoYShare = JSON.stringify({\n      uShare: userSigningMaterial.uShare,\n      backupYShare: userSigningMaterial.backupYShare,\n    });\n    await assert.rejects(\n      () =>\n        utils.getMpcV2RetrofitDataFromMpcV1Keys({\n          mpcv1UserKeyShare: keyNoBitgoYShare,\n          mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),\n        }),\n      /MPCv1 key material missing bitgoYShare/\n    );\n  });\n\n  it('throws if user key is missing backupYShare', async () => {\n    const keyNoBackupYShare = JSON.stringify({\n      uShare: userSigningMaterial.uShare,\n      bitgoYShare: userSigningMaterial.bitgoYShare,\n    });\n    await assert.rejects(\n      () =>\n        utils.getMpcV2RetrofitDataFromMpcV1Keys({\n          mpcv1UserKeyShare: keyNoBackupYShare,\n          mpcv1BackupKeyShare: JSON.stringify(backupSigningMaterial),\n        }),\n      /User MPCv1 key material missing backupYShare/\n    );\n  });\n\n  it('throws if backup key is missing uShare', async () => {\n    const keyNoUShare = JSON.stringify({\n      bitgoYShare: backupSigningMaterial.bitgoYShare,\n      userYShare: backupSigningMaterial.userYShare,\n    });\n    await assert.rejects(\n      () =>\n        utils.getMpcV2RetrofitDataFromMpcV1Keys({\n          mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),\n          mpcv1BackupKeyShare: keyNoUShare,\n        }),\n      /MPCv1 key material missing uShare/\n    );\n  });\n\n  it('throws if backup key is missing bitgoYShare', async () => {\n    const keyNoBitgoYShare = JSON.stringify({\n      uShare: backupSigningMaterial.uShare,\n      userYShare: backupSigningMaterial.userYShare,\n    });\n    await assert.rejects(\n      () =>\n        utils.getMpcV2RetrofitDataFromMpcV1Keys({\n          mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),\n          mpcv1BackupKeyShare: keyNoBitgoYShare,\n        }),\n      /MPCv1 key material missing bitgoYShare/\n    );\n  });\n\n  it('throws if backup key is missing userYShare', async () => {\n    const keyNoUserYShare = JSON.stringify({\n      uShare: backupSigningMaterial.uShare,\n      bitgoYShare: backupSigningMaterial.bitgoYShare,\n    });\n    await assert.rejects(\n      () =>\n        utils.getMpcV2RetrofitDataFromMpcV1Keys({\n          mpcv1UserKeyShare: JSON.stringify(userSigningMaterial),\n          mpcv1BackupKeyShare: keyNoUserYShare,\n        }),\n      /Backup MPCv1 key material missing userYShare/\n    );\n  });\n});\n\ndescribe('EddsaMPCv2Utils.getUserAndBackupSession', () => {\n  let utils: EddsaMPCv2Utils;\n  let userSigningMaterial: Record<string, unknown>;\n  let backupSigningMaterial: Record<string, unknown>;\n\n  before(async () => {\n    const MPC = await getInitializedMpcInstance();\n    const user = MPC.keyShare(1, 2, 3);\n    const backup = MPC.keyShare(2, 2, 3);\n    const bitgo = MPC.keyShare(3, 2, 3);\n    userSigningMaterial = {\n      uShare: user.uShare,\n      bitgoYShare: bitgo.yShares[1],\n      backupYShare: backup.yShares[1],\n    };\n    backupSigningMaterial = {\n      uShare: backup.uShare,\n      bitgoYShare: bitgo.yShares[2],\n      userYShare: user.yShares[2],\n    };\n  });\n\n  beforeEach(() => {\n    const mockBitGo = {} as unknown as BitGoBase;\n    const mockCoin = {} as unknown as IBaseCoin;\n    utils = new EddsaMPCv2Utils(mockBitGo, mockCoin);\n  });\n\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  it('returns plain DKG sessions when retrofit is undefined', async () => {\n    const { userDkg, backupDkg } = await (utils as any).getUserAndBackupSession(undefined);\n    assert.ok(userDkg, 'user DKG should be created');\n    assert.ok(backupDkg, 'backup DKG should be created');\n  });\n\n  it('returns retrofit-seeded DKG sessions when retrofit payload is supplied', async () => {\n    const retrofit = {\n      decryptedUserKey: JSON.stringify(userSigningMaterial),\n      decryptedBackupKey: JSON.stringify(backupSigningMaterial),\n      walletId: 'wallet-123',\n    };\n    const { userDkg, backupDkg } = await (utils as any).getUserAndBackupSession(retrofit);\n    assert.ok(userDkg, 'user DKG should be created with retrofit data');\n    assert.ok(backupDkg, 'backup DKG should be created with retrofit data');\n  });\n});\n\ndescribe('EddsaMPCv2Utils.createKeychains with retrofit wiring', () => {\n  let utils: EddsaMPCv2Utils;\n  let userSigningMaterial: Record<string, unknown>;\n  let backupSigningMaterial: Record<string, unknown>;\n  let bitgoGpgPublicKeyArmored: string;\n  const enterprise = 'enterprise-id';\n  const sessionId = 'session-001';\n  const walletId = 'wallet-retrofit-123';\n\n  before(async () => {\n    const MPC = await getInitializedMpcInstance();\n    const user = MPC.keyShare(1, 2, 3);\n    const backup = MPC.keyShare(2, 2, 3);\n    const bitgo = MPC.keyShare(3, 2, 3);\n    userSigningMaterial = {\n      uShare: user.uShare,\n      bitgoYShare: bitgo.yShares[1],\n      backupYShare: backup.yShares[1],\n    };\n    backupSigningMaterial = {\n      uShare: backup.uShare,\n      bitgoYShare: bitgo.yShares[2],\n      userYShare: user.yShares[2],\n    };\n    // Generate a real Ed25519 GPG key to stand in for the BitGo GPG key\n    const bitgoGpgKeyPair = await generateGPGKeyPair('ed25519');\n    bitgoGpgPublicKeyArmored = bitgoGpgKeyPair.publicKey;\n  });\n\n  beforeEach(() => {\n    const mockBitGo = {\n      getEnv: sinon.stub().returns('dev'),\n      encrypt: sinon.stub().resolves('encrypted'),\n    } as any;\n    const mockKeychains = {\n      add: sinon\n        .stub()\n        .callsFake((params: any) =>\n          Promise.resolve({ id: `${params.source}-key-id`, commonKeychain: 'a'.repeat(128), isMPCv2: true })\n        ),\n    };\n    const mockCoin = {\n      keychains: sinon.stub().returns(mockKeychains),\n    } as any;\n\n    utils = new EddsaMPCv2Utils(mockBitGo, mockCoin);\n    sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags' as any).resolves({ eddsaMpcv2PublicKey: null });\n    // Use a real armored GPG public key so pgp.readKey() succeeds inside createKeychains\n    (utils as any).bitgoEddsaMpcv2PublicGpgKey = { armor: () => bitgoGpgPublicKeyArmored };\n    sinon.stub(utils as any, 'addBitgoKeychain').resolves({ id: 'bitgo-key-id', commonKeychain: 'a'.repeat(128) });\n  });\n\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  it('spreads walletId into round-1 payload when retrofit is provided', async () => {\n    const capturedPayloads: any[] = [];\n    sinon.stub(utils, 'sendKeyGenerationRound1').callsFake(async (_enterprise: string, payload: any) => {\n      capturedPayloads.push(payload);\n      // Return a bad bitgoMsg1 to short-circuit the ceremony after R1 capture\n      return { sessionId: sessionId as any, bitgoMsg1: { message: '', signature: '' } as any };\n    });\n\n    const retrofit = {\n      decryptedUserKey: JSON.stringify(userSigningMaterial),\n      decryptedBackupKey: JSON.stringify(backupSigningMaterial),\n      walletId,\n    };\n\n    await assert.rejects(\n      () => utils.createKeychains({ passphrase: 'test', enterprise, retrofit }),\n      () => true\n    );\n\n    assert.strictEqual(capturedPayloads.length, 1, 'sendKeyGenerationRound1 should be called once');\n    assert.strictEqual(capturedPayloads[0].walletId, walletId, 'walletId must be present in round-1 payload');\n  });\n\n  it('omits walletId from round-1 payload when retrofit is absent', async () => {\n    const capturedPayloads: any[] = [];\n    sinon.stub(utils, 'sendKeyGenerationRound1').callsFake(async (_enterprise: string, payload: any) => {\n      capturedPayloads.push(payload);\n      return { sessionId: sessionId as any, bitgoMsg1: { message: '', signature: '' } as any };\n    });\n\n    await assert.rejects(\n      () => utils.createKeychains({ passphrase: 'test', enterprise }),\n      () => true\n    );\n\n    assert.strictEqual(capturedPayloads.length, 1, 'sendKeyGenerationRound1 should be called once');\n    assert.strictEqual(capturedPayloads[0].walletId, undefined, 'walletId must be absent when no retrofit');\n  });\n});\n"]}