@bitgo-beta/sdk-core 8.2.1-beta.188 → 8.2.1-beta.1881

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

@@ -0,0 +1,1307 @@
+"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 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 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');
+    });
+});
+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 route decryption through bitgo.decryptAsync 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.decryptAsync (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 = {
+            decryptAsync: 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.decryptAsync);
+        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(sjclEncrypt),
+            encryptAsync: 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.encryptAsync);
+        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.encryptAsync);
+        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.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((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,
+                });
+            }),
+            encryptAsync: 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((params) => sjcl.decrypt(params.password, params.input)),
+            decryptAsync: 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 decryptAsync = sinon.stub().callsFake(async (params) => {
+            const envelope = JSON.parse(params.input);
+            return envelope.input;
+        });
+        mockBitgo.decryptAsync = decryptAsync;
+        const round2 = await eddsaMPCv2Utils.createOfflineRound2Share({
+            txRequest: txRequestRound1,
+            walletPassphrase,
+            bitgoPublicGpgKey: bitgoGpgKeyPair.publicKey,
+            encryptedUserGpgPrvKey: round1.encryptedUserGpgPrvKey,
+            encryptedRound1Session: round1.encryptedRound1Session,
+        });
+        sinon.assert.called(mockBitgo.decryptAsync);
+        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((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,
+                });
+            }),
+            encryptAsync: 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((params) => sjcl.decrypt(params.password, params.input)),
+            decryptAsync: 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 decryptAsync = sinon.stub().callsFake(async (params) => {
+            const envelope = JSON.parse(params.input);
+            return envelope.input;
+        });
+        mockBitgo.decryptAsync = decryptAsync;
+        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.decryptAsync.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.decryptAsync routes v2 to Argon2id; the stub returns MPCv2 CBOR plaintext instead.
+        mockBitgo = {
+            decryptAsync: 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 derivedKeychain = (0, sdk_lib_mpc_1.deriveUnhardenedMps)(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 throw when the signed message is different from the verified 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 derivedKeychain = (0, sdk_lib_mpc_1.deriveUnhardenedMps)(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/);
+    });
+});
+//# 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 * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport * as pgp from 'openpgp';\nimport { randomBytes } from 'crypto';\nimport { deriveUnhardenedMps, 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} from '@bitgo/public-types';\nimport {\n  BitGoBase,\n  BitGoRequest,\n  CustomEddsaMPCv2SigningRound1GeneratingFunction,\n  CustomEddsaMPCv2SigningRound2GeneratingFunction,\n  CustomEddsaMPCv2SigningRound3GeneratingFunction,\n  EDDSAUtils,\n  EddsaMPCv2Utils,\n  IBaseCoin,\n  IWallet,\n  RequestTracer,\n  SignatureShareRecord,\n  SignatureShareType,\n  TxRequest,\n} from '../../../../../../src';\nimport {\n  getSignatureShareRoundOne,\n  getSignatureShareRoundTwo,\n  getSignatureShareRoundThree,\n  verifyPeerMessageRoundOne,\n  verifyPeerMessageRoundTwo,\n} from '../../../../../../src/bitgo/tss/eddsa/eddsaMPCv2';\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\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 route decryption through bitgo.decryptAsync 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.decryptAsync (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      decryptAsync: 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.decryptAsync 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(sjclEncrypt),\n      encryptAsync: 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.encryptAsync 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.encryptAsync 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.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((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      encryptAsync: 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((params) => sjcl.decrypt(params.password, params.input)),\n      decryptAsync: 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 decryptAsync = sinon.stub().callsFake(async (params: { input: string }) => {\n      const envelope = JSON.parse(params.input);\n      return envelope.input;\n    });\n    mockBitgo.decryptAsync = decryptAsync;\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.decryptAsync 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((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      encryptAsync: 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((params) => sjcl.decrypt(params.password, params.input)),\n      decryptAsync: 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 decryptAsync = sinon.stub().callsFake(async (params: { input: string }) => {\n      const envelope = JSON.parse(params.input);\n      return envelope.input;\n    });\n    mockBitgo.decryptAsync = decryptAsync;\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.decryptAsync 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.decryptAsync routes v2 to Argon2id; the stub returns MPCv2 CBOR plaintext instead.\n    mockBitgo = {\n      decryptAsync: 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 derivedKeychain = deriveUnhardenedMps(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 throw when the signed message is different from the verified 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 derivedKeychain = deriveUnhardenedMps(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      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"]}