@bitgo-beta/sdk-core 8.2.1-beta.213 → 8.2.1-beta.2131

package/dist/test/unit/bitgo/utils/tss/ecdsa/ecdsaMPCv2.js

@@ -0,0 +1,1246 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+const crypto_1 = require("crypto");
+const keccak_1 = __importDefault(require("keccak"));
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const src_1 = require("../../../../../../src");
+const gpgKeys_1 = require("./gpgKeys");
+const openpgp = __importStar(require("openpgp"));
+describe('ECDSA MPC v2', async () => {
+    let userShare;
+    let bitgoShare;
+    before('generate key shares for testing', async () => {
+        const [userDkgSession, backupDkgSession, bitgoDkgSession] = await sdk_lib_mpc_1.DklsUtils.generateDKGKeyShares();
+        assert.ok(userDkgSession);
+        assert.ok(backupDkgSession);
+        assert.ok(bitgoDkgSession);
+        userShare = userDkgSession.getKeyShare();
+        bitgoShare = bitgoDkgSession.getKeyShare();
+    });
+    let ecdsaMPCv2Utils;
+    before('initialize EcdsaMPCv2Utils', async () => {
+        const mockBg = {};
+        mockBg.getEnv = sinon.stub().returns('test');
+        const encryptImpl = (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,
+            });
+        };
+        const decryptImpl = (params) => {
+            return sjcl.decrypt(params.password, params.input);
+        };
+        mockBg.encrypt = sinon.stub().callsFake(encryptImpl);
+        mockBg.encrypt = sinon.stub().callsFake(async (params) => encryptImpl(params));
+        mockBg.decrypt = sinon.stub().callsFake(decryptImpl);
+        mockBg.decrypt = sinon.stub().callsFake(async (params) => decryptImpl(params));
+        const mockCoin = {};
+        mockCoin.getHashFunction = sinon.stub().callsFake(() => (0, keccak_1.default)('keccak256'));
+        mockCoin.isSignablePreHashed = (unsignedTx) => unsignedTx.serializedTxHex?.startsWith('0000') ?? false;
+        ecdsaMPCv2Utils = new src_1.EcdsaMPCv2Utils(mockBg, mockCoin);
+    });
+    const walletID = '62fe536a6b4cf70007acb48c0e7bb0b0';
+    const walletPassphrase = 'testPass';
+    it('should sign a message hash using ECDSA MPC v2 offline rounds', async () => {
+        const tMessage = 'testMessage';
+        const derivationPath = 'm/0';
+        // round 1
+        const reqMPCv2SigningRound1 = {
+            txRequest: {
+                txRequestId: '123456',
+                apiVersion: 'full',
+                walletId: walletID,
+                transactions: [
+                    {
+                        unsignedTx: {
+                            derivationPath,
+                            signableHex: tMessage,
+                        },
+                        signatureShares: [],
+                    },
+                ],
+            },
+            prv: userShare.toString('base64'),
+            walletPassphrase,
+        };
+        const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1);
+        resMPCv2SigningRound1.should.have.property('signatureShareRound1');
+        resMPCv2SigningRound1.should.have.property('userGpgPubKey');
+        resMPCv2SigningRound1.should.have.property('encryptedRound1Session');
+        resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');
+        const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;
+        const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;
+        const hashBuffer = (0, keccak_1.default)('keccak256').update(Buffer.from(tMessage, 'hex')).digest();
+        const bitgoSession = new sdk_lib_mpc_1.DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);
+        const txRequestRound1 = await signBitgoMPCv2Round1(bitgoSession, reqMPCv2SigningRound1.txRequest, resMPCv2SigningRound1.signatureShareRound1, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound1.transactions &&
+            txRequestRound1.transactions.length === 1 &&
+            txRequestRound1.transactions[0].signatureShares.length === 2, 'txRequestRound1.transactions is not an array of length 1 with 2 signatureShares');
+        // round 2
+        const reqMPCv2SigningRound2 = {
+            ...reqMPCv2SigningRound1,
+            txRequest: txRequestRound1,
+            encryptedRound1Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: gpgKeys_1.bitgoGpgKey.public,
+        };
+        const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2);
+        resMPCv2SigningRound2.should.have.property('signatureShareRound2');
+        resMPCv2SigningRound2.should.have.property('encryptedRound2Session');
+        const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;
+        const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(bitgoSession, reqMPCv2SigningRound2.txRequest, resMPCv2SigningRound2.signatureShareRound2, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound2.transactions &&
+            txRequestRound2.transactions.length === 1 &&
+            txRequestRound2.transactions[0].signatureShares.length === 4, 'txRequestRound2.transactions is not an array of length 1 with 4 signatureShares');
+        bitgoMsg4.should.have.property('signatureR');
+        // round 3
+        const reqMPCv2SigningRound3 = {
+            ...reqMPCv2SigningRound2,
+            txRequest: txRequestRound2,
+            encryptedRound1Session: null, // not needed for round 3
+            encryptedRound2Session,
+        };
+        const resMPCv2SigningRound3 = await ecdsaMPCv2Utils.createOfflineRound3Share(reqMPCv2SigningRound3);
+        resMPCv2SigningRound3.should.have.property('signatureShareRound3');
+        const { userMsg4 } = await signBitgoMPCv2Round3(bitgoSession, resMPCv2SigningRound3.signatureShareRound3, resMPCv2SigningRound1.userGpgPubKey);
+        // signature generation and validation
+        assert.ok(userMsg4.data.msg4.signatureR === bitgoMsg4.signatureR, 'User and BitGo signaturesR do not match');
+        const deserializedBitgoMsg4 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: [],
+            broadcastMessages: [bitgoMsg4],
+        });
+        const deserializedUserMsg4 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: [],
+            broadcastMessages: [
+                {
+                    from: userMsg4.data.msg4.from,
+                    payload: userMsg4.data.msg4.message,
+                },
+            ],
+        });
+        const combinedSigUsingUtil = sdk_lib_mpc_1.DklsUtils.combinePartialSignatures([deserializedUserMsg4.broadcastMessages[0].payload, deserializedBitgoMsg4.broadcastMessages[0].payload], Buffer.from(userMsg4.data.msg4.signatureR, 'base64').toString('hex'));
+        const convertedSignature = sdk_lib_mpc_1.DklsUtils.verifyAndConvertDklsSignature(Buffer.from(tMessage, 'hex'), combinedSigUsingUtil, sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userShare), derivationPath, (0, keccak_1.default)('keccak256'));
+        assert.ok(convertedSignature, 'Signature is not valid');
+        assert.ok(convertedSignature.split(':').length === 4, 'Signature is not valid');
+    });
+    it('should fail to sign using session after round X when session after round Y is expected', async () => {
+        const tMessage = 'testMessage';
+        const derivationPath = 'm/1/2';
+        // round 1
+        const reqMPCv2SigningRound1 = {
+            txRequest: {
+                txRequestId: '123456',
+                apiVersion: 'full',
+                walletId: walletID,
+                transactions: [
+                    {
+                        unsignedTx: {
+                            derivationPath,
+                            signableHex: tMessage,
+                        },
+                        signatureShares: [],
+                    },
+                ],
+            },
+            prv: userShare.toString('base64'),
+            walletPassphrase,
+        };
+        const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1);
+        resMPCv2SigningRound1.should.have.property('signatureShareRound1');
+        resMPCv2SigningRound1.should.have.property('userGpgPubKey');
+        resMPCv2SigningRound1.should.have.property('encryptedRound1Session');
+        resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');
+        const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;
+        const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;
+        const hashBuffer = (0, keccak_1.default)('keccak256').update(Buffer.from(tMessage, 'hex')).digest();
+        const bitgoSession = new sdk_lib_mpc_1.DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);
+        const txRequestRound1 = await signBitgoMPCv2Round1(bitgoSession, reqMPCv2SigningRound1.txRequest, resMPCv2SigningRound1.signatureShareRound1, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound1.transactions &&
+            txRequestRound1.transactions.length === 1 &&
+            txRequestRound1.transactions[0].signatureShares.length === 2, 'txRequestRound1.transactions is not an array of length 1 with 2 signatureShares');
+        // round 2
+        const reqMPCv2SigningRound2 = {
+            ...reqMPCv2SigningRound1,
+            txRequest: txRequestRound1,
+            encryptedRound1Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: gpgKeys_1.bitgoGpgKey.public,
+        };
+        const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2);
+        resMPCv2SigningRound2.should.have.property('signatureShareRound2');
+        resMPCv2SigningRound2.should.have.property('encryptedRound2Session');
+        const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(bitgoSession, reqMPCv2SigningRound2.txRequest, resMPCv2SigningRound2.signatureShareRound2, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound2.transactions &&
+            txRequestRound2.transactions.length === 1 &&
+            txRequestRound2.transactions[0].signatureShares.length === 4, 'txRequestRound2.transactions is not an array of length 1 with 4 signatureShares');
+        bitgoMsg4.should.have.property('signatureR');
+        const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;
+        // A bogus round 3 signing request containing encrypted session from round 1 instead of round 2 should fail.
+        const bogusReqMPCv2SigningRound3 = {
+            ...reqMPCv2SigningRound2,
+            txRequest: txRequestRound2,
+            encryptedRound1Session: null, // not needed for round 3
+            encryptedRound2Session: encryptedRound1Session, // instaed of encryptedRound2Session
+        };
+        await ecdsaMPCv2Utils
+            .createOfflineRound3Share(bogusReqMPCv2SigningRound3)
+            .should.be.rejectedWith('Adata does not match cyphertext adata');
+        // A bogus round 2 signing request containing encrypted session from round 2 instead of round 1 should fail.
+        const bogusReqMPCv2SigningRound2 = {
+            ...reqMPCv2SigningRound2,
+            encryptedRound1Session: encryptedRound2Session, // instaed of encryptedRound1Session
+        };
+        await ecdsaMPCv2Utils
+            .createOfflineRound2Share(bogusReqMPCv2SigningRound2)
+            .should.be.rejectedWith('Unexpected signature share response. Unable to parse data.');
+    });
+    it('should fail to sign reusing a session on different message', async () => {
+        const tMessage1 = 'testMessage1';
+        const tMessage2 = 'testMessage2';
+        const derivationPath = 'm/3/4';
+        // round 1 of signing tMessage1
+        const reqMPCv2SigningMsg1Round1 = {
+            txRequest: {
+                txRequestId: '123456',
+                apiVersion: 'full',
+                walletId: walletID,
+                transactions: [
+                    {
+                        unsignedTx: {
+                            derivationPath,
+                            signableHex: tMessage1,
+                        },
+                        signatureShares: [],
+                    },
+                ],
+            },
+            prv: userShare.toString('base64'),
+            walletPassphrase,
+        };
+        const resMPCv2SigningMsg1Round1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningMsg1Round1);
+        resMPCv2SigningMsg1Round1.should.have.property('signatureShareRound1');
+        resMPCv2SigningMsg1Round1.should.have.property('userGpgPubKey');
+        resMPCv2SigningMsg1Round1.should.have.property('encryptedRound1Session');
+        resMPCv2SigningMsg1Round1.should.have.property('encryptedUserGpgPrvKey');
+        const encryptedMsg1Round1Session = resMPCv2SigningMsg1Round1.encryptedRound1Session;
+        const hashBuffer1 = (0, keccak_1.default)('keccak256').update(Buffer.from(tMessage1, 'hex')).digest();
+        const bitgoSession1 = new sdk_lib_mpc_1.DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer1);
+        const txRequestMsg1Round1 = await signBitgoMPCv2Round1(bitgoSession1, reqMPCv2SigningMsg1Round1.txRequest, resMPCv2SigningMsg1Round1.signatureShareRound1, resMPCv2SigningMsg1Round1.userGpgPubKey);
+        assert.ok(txRequestMsg1Round1.transactions &&
+            txRequestMsg1Round1.transactions.length === 1 &&
+            txRequestMsg1Round1.transactions[0].signatureShares.length === 2, 'txRequestMsg1Round1.transactions is not an array of length 1 with 2 signatureShares');
+        // round 1 of signing tMessage2
+        const reqMPCv2SigningMsg2Round1 = {
+            ...reqMPCv2SigningMsg1Round1,
+            txRequest: {
+                ...reqMPCv2SigningMsg1Round1.txRequest,
+                transactions: [
+                    {
+                        unsignedTx: {
+                            derivationPath,
+                            signableHex: tMessage2,
+                        },
+                        signatureShares: [],
+                    },
+                ],
+            },
+        };
+        const resMPCv2SigningMsg2Round1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningMsg2Round1);
+        resMPCv2SigningMsg2Round1.should.have.property('signatureShareRound1');
+        resMPCv2SigningMsg2Round1.should.have.property('userGpgPubKey');
+        resMPCv2SigningMsg2Round1.should.have.property('encryptedRound1Session');
+        resMPCv2SigningMsg2Round1.should.have.property('encryptedUserGpgPrvKey');
+        const encryptedMsg2UserGpgPrvKey = resMPCv2SigningMsg2Round1.encryptedUserGpgPrvKey;
+        const hashBuffer2 = (0, keccak_1.default)('keccak256').update(Buffer.from(tMessage2, 'hex')).digest();
+        const bitgoSession2 = new sdk_lib_mpc_1.DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer2);
+        const txRequestMsg2Round1 = await signBitgoMPCv2Round1(bitgoSession2, reqMPCv2SigningMsg2Round1.txRequest, resMPCv2SigningMsg2Round1.signatureShareRound1, resMPCv2SigningMsg2Round1.userGpgPubKey);
+        assert.ok(txRequestMsg2Round1.transactions &&
+            txRequestMsg2Round1.transactions.length === 1 &&
+            txRequestMsg2Round1.transactions[0].signatureShares.length === 2, 'txRequestMsg2Round1.transactions is not an array of length 1 with 2 signatureShares');
+        // Attempting to reuse round 1 session from signing tMessage1 for signing tMessage2 should fail at round 2.
+        const reqMPCv2SigningMsg2Round2WithMsg1Session = {
+            ...reqMPCv2SigningMsg2Round1,
+            txRequest: txRequestMsg2Round1,
+            encryptedRound1Session: encryptedMsg1Round1Session, // instead of resMPCv2SigningMsg2Round1.encryptedRound1Session
+            encryptedUserGpgPrvKey: encryptedMsg2UserGpgPrvKey,
+            bitgoPublicGpgKey: gpgKeys_1.bitgoGpgKey.public,
+        };
+        await ecdsaMPCv2Utils
+            .createOfflineRound2Share(reqMPCv2SigningMsg2Round2WithMsg1Session)
+            .should.be.rejectedWith('Error while creating messages from party 0, round 2: Error: Invalid final_session_id');
+    });
+    it('should sign a pre-hashed Avalanche atomic export tx without applying keccak256', async () => {
+        // Real Avalanche ExportInC transaction from sdk-coin-flr test resources.
+        // Mirrors the sandbox flow: c2pMpcToMpcTss.ts → signWithMpc() where
+        // FlareJS builds an ExportInC tx, SHA-256 hashes the unsigned bytes,
+        // and MPC signs the raw SHA-256 hash (NOT keccak256 of it).
+        //
+        // serializedTxHex = full unsigned Avalanche atomic tx (codec type ID 0x0000)
+        // signableHex     = SHA-256(txBody) — 32 bytes, already the final signing hash
+        //
+        // Sandbox reference (coins-sandbox/flareCP/flrC_MPC_to_flrP_MPC):
+        //
+        // C→P direction (c2pMpcToMpcTss.ts — export from C-chain):
+        //   Message hash (SHA-256): 9b3e1c8fc9322b667ec61619487b3993e91dcfc5...
+        //   Signature r: d5bc2e2cad314023...  s: 47af9d7109135f7a...  Recovery: 1
+        //   Export TX ID: 2Z5ELShnmmMgvTeupzLQzEKtAgbvZkDvq6KRYqbzVgcyBGVGpb
+        //
+        // P→C direction (p2cMpcToMpcTss.ts — export from P-chain):
+        //   Threshold: 1 (MPC single-sig on-chain, NO hop transaction)
+        //   Message hash (SHA-256): f1afd7bb3df2019ee61b41334abf95172d469d18...
+        //   Signature r: fae44ca89e7a0d3effd0912c16d69735aabbc73ad2d140ffa2c3b46af48d159c
+        //   Signature s: 1dec05d0d477a5b245a0a2e5f3a67e75489ff9b98b29780fc757b12d9f687db3
+        //   Recovery: 0
+        //   Export TX ID: 2tDQmQUtDMyVWe8Bo36yHXykV2RMvh8rft3to5QsgoNhATMDXz
+        //   Network: Coston2 Testnet (ID: 114)
+        const serializedTxHex = '0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da5552479' +
+            '00000000000000000000000000000000000000000000000000000000000000000000000128a05933dc76' +
+            'e4e6c25f35d5c9b2a58769700e760000000002ff3d1658734f94af871c3d131b56131b6fb7a0291eac' +
+            'add261e69dfb42a9cdf6f7fddd00000000000000090000000158734f94af871c3d131b56131b6fb7a029' +
+            '1eacadd261e69dfb42a9cdf6f7fddd000000070000000002faf08000000000000000000000000200000003' +
+            '12cb32eaf92553064db98d271b56cba079ec78f5a6e0c1abd0132f70efb77e2274637ff336a29a57c386' +
+            'd58d09a9ae77cf1cf07bf1c9de44ebb0c9f3';
+        // SHA-256(serializedTxHex bytes) — same as FlareJS unsignedTx.toBytes() → sha256
+        const signableHex = (0, crypto_1.createHash)('sha256').update(Buffer.from(serializedTxHex, 'hex')).digest('hex');
+        const derivationPath = 'm/0';
+        // Validate fixture properties match sandbox expectations:
+        // - serializedTxHex starts with Avalanche codec type ID (0x0000)
+        // - signableHex is exactly 64 hex chars (32-byte SHA-256 digest)
+        assert.ok(serializedTxHex.startsWith('0000'), 'Fixture must start with Avalanche codec prefix');
+        assert.strictEqual(signableHex.length, 64, 'signableHex must be 32-byte SHA-256 (64 hex chars)');
+        // Verify keccak256(signableHex) differs — proves skipping hash matters
+        const keccakHash = (0, keccak_1.default)('keccak256').update(Buffer.from(signableHex, 'hex')).digest('hex');
+        assert.notStrictEqual(signableHex, keccakHash, 'SHA-256 and keccak256 hashes must differ');
+        // round 1
+        const reqMPCv2SigningRound1 = {
+            txRequest: {
+                txRequestId: 'flr-export-c2p',
+                apiVersion: 'full',
+                walletId: walletID,
+                transactions: [
+                    {
+                        unsignedTx: {
+                            derivationPath,
+                            signableHex,
+                            serializedTxHex,
+                        },
+                        signatureShares: [],
+                    },
+                ],
+            },
+            prv: userShare.toString('base64'),
+            walletPassphrase,
+        };
+        const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1);
+        resMPCv2SigningRound1.should.have.property('signatureShareRound1');
+        resMPCv2SigningRound1.should.have.property('encryptedRound1Session');
+        resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');
+        const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;
+        const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;
+        // BitGo/HSM party uses the raw SHA-256 hash directly (no keccak256).
+        // This matches WP's MPCv2Signer isPreHashed=true path where
+        // txHash = signableMaterial (raw signableHex bytes).
+        // If the SDK incorrectly applied keccak256, user party would use
+        // keccak256(SHA-256(txBody)) while HSM uses SHA-256(txBody) — the
+        // two DKLS parties would disagree, producing an invalid combined sig.
+        const hashBuffer = Buffer.from(signableHex, 'hex');
+        assert.strictEqual(hashBuffer.length, 32, 'DKLS message hash must be 32 bytes');
+        const bitgoSession = new sdk_lib_mpc_1.DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);
+        const txRequestRound1 = await signBitgoMPCv2Round1(bitgoSession, reqMPCv2SigningRound1.txRequest, resMPCv2SigningRound1.signatureShareRound1, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound1.transactions &&
+            txRequestRound1.transactions.length === 1 &&
+            txRequestRound1.transactions[0].signatureShares.length === 2);
+        // round 2
+        const reqMPCv2SigningRound2 = {
+            ...reqMPCv2SigningRound1,
+            txRequest: txRequestRound1,
+            encryptedRound1Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: gpgKeys_1.bitgoGpgKey.public,
+        };
+        const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2);
+        resMPCv2SigningRound2.should.have.property('signatureShareRound2');
+        resMPCv2SigningRound2.should.have.property('encryptedRound2Session');
+        const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;
+        const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(bitgoSession, reqMPCv2SigningRound2.txRequest, resMPCv2SigningRound2.signatureShareRound2, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound2.transactions &&
+            txRequestRound2.transactions.length === 1 &&
+            txRequestRound2.transactions[0].signatureShares.length === 4);
+        bitgoMsg4.should.have.property('signatureR');
+        // round 3
+        const reqMPCv2SigningRound3 = {
+            ...reqMPCv2SigningRound2,
+            txRequest: txRequestRound2,
+            encryptedRound1Session: null,
+            encryptedRound2Session,
+        };
+        const resMPCv2SigningRound3 = await ecdsaMPCv2Utils.createOfflineRound3Share(reqMPCv2SigningRound3);
+        resMPCv2SigningRound3.should.have.property('signatureShareRound3');
+        const { userMsg4 } = await signBitgoMPCv2Round3(bitgoSession, resMPCv2SigningRound3.signatureShareRound3, resMPCv2SigningRound1.userGpgPubKey);
+        // Both parties must produce matching R values for a valid combined signature
+        assert.ok(userMsg4.data.msg4.signatureR === bitgoMsg4.signatureR, 'User and BitGo signaturesR do not match');
+        const deserializedBitgoMsg4 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: [],
+            broadcastMessages: [bitgoMsg4],
+        });
+        const deserializedUserMsg4 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: [],
+            broadcastMessages: [
+                {
+                    from: userMsg4.data.msg4.from,
+                    payload: userMsg4.data.msg4.message,
+                },
+            ],
+        });
+        const combinedSigUsingUtil = sdk_lib_mpc_1.DklsUtils.combinePartialSignatures([deserializedUserMsg4.broadcastMessages[0].payload, deserializedBitgoMsg4.broadcastMessages[0].payload], Buffer.from(userMsg4.data.msg4.signatureR, 'base64').toString('hex'));
+        // Combined signature must have valid R and S components (32 bytes each)
+        assert.strictEqual(combinedSigUsingUtil.R.length, 32, 'Signature R must be 32 bytes');
+        assert.strictEqual(combinedSigUsingUtil.S.length, 32, 'Signature S must be 32 bytes');
+        // Verify with shouldHash=false — signableHex is already SHA-256(txBody).
+        // This mirrors WP's combineSigSharesMPCv2 where shouldHash=false for
+        // pre-hashed Avalanche atomic transactions (isSignablePreHashed=true).
+        // On-chain, Avalanche verifies: ecdsaRecover(SHA-256(txBody)) == signerPubKey
+        const convertedSignature = sdk_lib_mpc_1.DklsUtils.verifyAndConvertDklsSignature(Buffer.from(signableHex, 'hex'), combinedSigUsingUtil, sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userShare), derivationPath, (0, crypto_1.createHash)('sha256'), false // shouldHash=false: message is already SHA-256(txBody)
+        );
+        assert.ok(convertedSignature, 'Pre-hashed Avalanche atomic signature is not valid');
+        // Format: recid:R_hex:S_hex:publicKey_hex
+        // Sandbox produces the same structure — e.g. P→C export:
+        //   r: fae44ca89e7a0d3effd0912c16d69735aabbc73ad2d140ffa2c3b46af48d159c (32 bytes)
+        //   s: 1dec05d0d477a5b245a0a2e5f3a67e75489ff9b98b29780fc757b12d9f687db3 (32 bytes)
+        //   Recovery: 0
+        const sigParts = convertedSignature.split(':');
+        assert.strictEqual(sigParts.length, 4, 'Signature must be recid:R:S:pubkey format');
+        assert.ok(['0', '1'].includes(sigParts[0]), 'Recovery ID must be 0 or 1');
+        assert.strictEqual(sigParts[1].length, 64, 'Signature R must be 32 bytes hex');
+        assert.strictEqual(sigParts[2].length, 64, 'Signature S must be 32 bytes hex');
+    });
+    it('signRequestBase (hot wallet path) should skip keccak256 for Avalanche atomic tx', async () => {
+        const serializedTxHex = '0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da5552479' +
+            '00000000000000000000000000000000000000000000000000000000000000000000000128a05933dc76' +
+            'e4e6c25f35d5c9b2a58769700e760000000002ff3d1658734f94af871c3d131b56131b6fb7a0291eac' +
+            'add261e69dfb42a9cdf6f7fddd00000000000000090000000158734f94af871c3d131b56131b6fb7a029' +
+            '1eacadd261e69dfb42a9cdf6f7fddd000000070000000002faf08000000000000000000000000200000003' +
+            '12cb32eaf92553064db98d271b56cba079ec78f5a6e0c1abd0132f70efb77e2274637ff336a29a57c386' +
+            'd58d09a9ae77cf1cf07bf1c9de44ebb0c9f3';
+        const signableHex = (0, crypto_1.createHash)('sha256').update(Buffer.from(serializedTxHex, 'hex')).digest('hex');
+        const derivationPath = 'm/0';
+        const mockBgWithPost = {};
+        mockBgWithPost.getEnv = sinon.stub().returns('test');
+        mockBgWithPost.setRequestTracer = sinon.stub();
+        mockBgWithPost.encrypt = sinon.stub().returns('encrypted');
+        mockBgWithPost.encrypt = sinon.stub().resolves('encrypted');
+        mockBgWithPost.decrypt = sinon.stub().returns('decrypted');
+        mockBgWithPost.decrypt = sinon.stub().resolves('decrypted');
+        mockBgWithPost.post = sinon.stub().returns({
+            send: sinon.stub().returnsThis(),
+            set: sinon.stub().returnsThis(),
+            result: sinon.stub().rejects(new Error('mock: HTTP not available')),
+        });
+        const hashFunctionSpy = sinon.stub().callsFake(() => (0, keccak_1.default)('keccak256'));
+        const mockCoinForHotWallet = {
+            getHashFunction: hashFunctionSpy,
+            verifyTransaction: sinon.stub().resolves(true),
+            getMPCAlgorithm: sinon.stub().returns('ecdsa'),
+            getConfig: sinon.stub().returns({ family: 'flrp' }),
+            isSignablePreHashed: (unsignedTx) => unsignedTx.serializedTxHex?.startsWith('0000') ?? false,
+        };
+        const mockWallet = {
+            id: sinon.stub().returns(walletID),
+            multisigType: sinon.stub().returns('tss'),
+            multisigTypeVersion: sinon.stub().returns('MPCv2'),
+        };
+        const hotWalletUtils = new src_1.EcdsaMPCv2Utils(mockBgWithPost, mockCoinForHotWallet, mockWallet);
+        sinon.stub(hotWalletUtils, 'pickBitgoPubGpgKeyForSigning').resolves(gpgKeys_1.bitgoGpgKey.public);
+        const txRequest = {
+            txRequestId: 'flrp-export-test',
+            apiVersion: 'full',
+            walletId: walletID,
+            transactions: [
+                {
+                    unsignedTx: {
+                        derivationPath,
+                        signableHex,
+                        serializedTxHex,
+                    },
+                    signatureShares: [],
+                },
+            ],
+        };
+        try {
+            await hotWalletUtils.signTxRequest({
+                txRequest,
+                txParams: { recipients: [{ address: '0x' + '00'.repeat(20), amount: '1000' }] },
+                prv: userShare.toString('base64'),
+                reqId: { inc: sinon.stub(), toString: sinon.stub().returns('test-req') },
+            });
+        }
+        catch (e) { }
+        assert.strictEqual(hashFunctionSpy.callCount, 0, 'getHashFunction must NOT be called for Avalanche atomic tx (serializedTxHex starts with 0000)');
+    });
+    it('signRequestBase (hot wallet path) should apply keccak256 for regular EVM tx', async () => {
+        const serializedTxHex = 'f86c808504a817c80082520894' + '00'.repeat(20) + '80808080';
+        const signableHex = serializedTxHex;
+        const derivationPath = 'm/0';
+        assert.ok(!serializedTxHex.startsWith('0000'), 'EVM tx must not start with Avalanche prefix');
+        const mockBgWithPost = {};
+        mockBgWithPost.getEnv = sinon.stub().returns('test');
+        mockBgWithPost.setRequestTracer = sinon.stub();
+        mockBgWithPost.encrypt = sinon.stub().returns('encrypted');
+        mockBgWithPost.encrypt = sinon.stub().resolves('encrypted');
+        mockBgWithPost.decrypt = sinon.stub().returns('decrypted');
+        mockBgWithPost.decrypt = sinon.stub().resolves('decrypted');
+        mockBgWithPost.post = sinon.stub().returns({
+            send: sinon.stub().returnsThis(),
+            set: sinon.stub().returnsThis(),
+            result: sinon.stub().rejects(new Error('mock: HTTP not available')),
+        });
+        const hashFunctionSpy = sinon.stub().callsFake(() => (0, keccak_1.default)('keccak256'));
+        const mockCoinForEvmWallet = {
+            getHashFunction: hashFunctionSpy,
+            verifyTransaction: sinon.stub().resolves(true),
+            getMPCAlgorithm: sinon.stub().returns('ecdsa'),
+            getConfig: sinon.stub().returns({ family: 'flr' }),
+        };
+        const mockWallet = {
+            id: sinon.stub().returns(walletID),
+            multisigType: sinon.stub().returns('tss'),
+            multisigTypeVersion: sinon.stub().returns('MPCv2'),
+        };
+        const evmUtils = new src_1.EcdsaMPCv2Utils(mockBgWithPost, mockCoinForEvmWallet, mockWallet);
+        sinon.stub(evmUtils, 'pickBitgoPubGpgKeyForSigning').resolves(gpgKeys_1.bitgoGpgKey.public);
+        const txRequest = {
+            txRequestId: 'flr-evm-test',
+            apiVersion: 'full',
+            walletId: walletID,
+            transactions: [
+                {
+                    unsignedTx: {
+                        derivationPath,
+                        signableHex,
+                        serializedTxHex,
+                    },
+                    signatureShares: [],
+                },
+            ],
+        };
+        try {
+            await evmUtils.signTxRequest({
+                txRequest,
+                txParams: { recipients: [{ address: '0x' + '00'.repeat(20), amount: '1000' }] },
+                prv: userShare.toString('base64'),
+                reqId: { inc: sinon.stub(), toString: sinon.stub().returns('test-req') },
+            });
+        }
+        catch (e) { }
+        assert.strictEqual(hashFunctionSpy.callCount, 1, 'getHashFunction must be called for regular EVM tx (serializedTxHex does not start with 0000)');
+    });
+    // Regression test for CGD-1815 / DEFI-661: resolveEffectiveTxParams() special-cases wrap-native
+    // and unwrap-native so the no-recipients guard in verifyTssTransaction doesn't reject them. That
+    // bypass is security-sensitive (it's what lets a DeFi vault wrap/unwrap tx skip recipient
+    // verification), so pin it through the real signRequestBase() -> resolveEffectiveTxParams() ->
+    // verifyTransaction() wiring instead of only unit-testing resolveEffectiveTxParams() in isolation.
+    // pendingApproval.approve() -> recreateTxRequest() -> signTxRequest() carries no txParams at all,
+    // so intentType is the ONLY source of the type here — exactly the path that only ever sees the
+    // kebab-case spelling ('wrap-native' / 'unwrap-native'), never the camelCase 'wrapNative'/'unwrapNative'.
+    ['wrap-native', 'unwrap-native'].forEach((intentType) => {
+        it(`signRequestBase should verify a no-txParams ${intentType} intent without requiring recipients`, async () => {
+            const serializedTxHex = 'f86c808504a817c80082520894' + '00'.repeat(20) + '80808080';
+            const signableHex = serializedTxHex;
+            const derivationPath = 'm/0';
+            const mockBgWithPost = {};
+            mockBgWithPost.getEnv = sinon.stub().returns('test');
+            mockBgWithPost.setRequestTracer = sinon.stub();
+            mockBgWithPost.encrypt = sinon.stub().resolves('encrypted');
+            mockBgWithPost.decrypt = sinon.stub().resolves('decrypted');
+            mockBgWithPost.post = sinon.stub().returns({
+                send: sinon.stub().returnsThis(),
+                set: sinon.stub().returnsThis(),
+                result: sinon.stub().rejects(new Error('mock: HTTP not available')),
+            });
+            const verifyTransactionSpy = sinon.stub().resolves(true);
+            const mockCoinForWrap = {
+                getHashFunction: sinon.stub().callsFake(() => (0, keccak_1.default)('keccak256')),
+                verifyTransaction: verifyTransactionSpy,
+                getMPCAlgorithm: sinon.stub().returns('ecdsa'),
+                getConfig: sinon.stub().returns({ family: 'hteth' }),
+            };
+            const mockWallet = {
+                id: sinon.stub().returns(walletID),
+                multisigType: sinon.stub().returns('tss'),
+                multisigTypeVersion: sinon.stub().returns('MPCv2'),
+            };
+            const wrapUtils = new src_1.EcdsaMPCv2Utils(mockBgWithPost, mockCoinForWrap, mockWallet);
+            sinon.stub(wrapUtils, 'pickBitgoPubGpgKeyForSigning').resolves(gpgKeys_1.bitgoGpgKey.public);
+            // No recipients anywhere (neither txParams.recipients nor intent.recipients) — the wrap-native/
+            // unwrap-native calldata is built server-side from defiParams, per DefiVault.sendWrapIntent.
+            const txRequest = {
+                txRequestId: `wrap-native-test-${intentType}`,
+                apiVersion: 'full',
+                walletId: walletID,
+                intent: { intentType, defiParams: { vaultId: 'vlt-galaxy-weth', amount: '1000000000000000000' } },
+                transactions: [
+                    {
+                        unsignedTx: { derivationPath, signableHex, serializedTxHex },
+                        signatureShares: [],
+                    },
+                ],
+            };
+            try {
+                await wrapUtils.signTxRequest({
+                    txRequest,
+                    // No txParams at all — mirrors pendingApproval.approve() -> recreateTxRequest() ->
+                    // signTxRequest(), the one signing path that only ever sees the kebab-case intentType.
+                    txParams: undefined,
+                    prv: userShare.toString('base64'),
+                    reqId: { inc: sinon.stub(), toString: sinon.stub().returns('test-req') },
+                });
+            }
+            catch (e) { }
+            assert.strictEqual(verifyTransactionSpy.callCount, 1, 'verifyTransaction must be reached: resolveEffectiveTxParams must not throw for a no-recipients ' +
+                `${intentType} intent`);
+            const verifyCallArgs = verifyTransactionSpy.firstCall.args[0];
+            assert.strictEqual(verifyCallArgs.txParams.type, intentType);
+            assert.strictEqual(verifyCallArgs.txParams.recipients, undefined);
+        });
+    });
+    it('should still apply keccak256 for regular FLR EVM transactions', async () => {
+        // Regular EVM transaction on FLR (e.g. token transfer, not cross-chain).
+        // serializedTxHex starts with 'f8' (RLP prefix), NOT '0000'.
+        // The SDK must apply keccak256 as the hash function — standard EVM path.
+        // Use valid hex for signableHex (unlike the pre-existing 'testMessage' pattern
+        // in earlier tests) so keccak256 operates on a realistic byte buffer.
+        const serializedTxHex = 'f86c808504a817c80082520894' + '00'.repeat(20) + '80808080';
+        const signableHex = serializedTxHex; // In EVM, signableHex is the RLP-encoded unsigned tx
+        const derivationPath = 'm/0';
+        // Verify fixture does NOT trigger the Avalanche detection
+        assert.ok(!serializedTxHex.startsWith('0000'), 'EVM tx must not start with Avalanche prefix');
+        // round 1
+        const reqMPCv2SigningRound1 = {
+            txRequest: {
+                txRequestId: 'flr-evm-transfer',
+                apiVersion: 'full',
+                walletId: walletID,
+                transactions: [
+                    {
+                        unsignedTx: {
+                            derivationPath,
+                            signableHex,
+                            serializedTxHex,
+                        },
+                        signatureShares: [],
+                    },
+                ],
+            },
+            prv: userShare.toString('base64'),
+            walletPassphrase,
+        };
+        const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1);
+        resMPCv2SigningRound1.should.have.property('signatureShareRound1');
+        resMPCv2SigningRound1.should.have.property('encryptedRound1Session');
+        resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');
+        const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;
+        const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;
+        // BitGo party uses keccak256(signableHex) — standard EVM path.
+        // Both SDK and WP/HSM apply keccak256 for regular EVM transactions.
+        const hashBuffer = (0, keccak_1.default)('keccak256').update(Buffer.from(signableHex, 'hex')).digest();
+        const bitgoSession = new sdk_lib_mpc_1.DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);
+        const txRequestRound1 = await signBitgoMPCv2Round1(bitgoSession, reqMPCv2SigningRound1.txRequest, resMPCv2SigningRound1.signatureShareRound1, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound1.transactions &&
+            txRequestRound1.transactions.length === 1 &&
+            txRequestRound1.transactions[0].signatureShares.length === 2);
+        // round 2
+        const reqMPCv2SigningRound2 = {
+            ...reqMPCv2SigningRound1,
+            txRequest: txRequestRound1,
+            encryptedRound1Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: gpgKeys_1.bitgoGpgKey.public,
+        };
+        const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2);
+        resMPCv2SigningRound2.should.have.property('signatureShareRound2');
+        resMPCv2SigningRound2.should.have.property('encryptedRound2Session');
+        const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;
+        const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(bitgoSession, reqMPCv2SigningRound2.txRequest, resMPCv2SigningRound2.signatureShareRound2, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(txRequestRound2.transactions &&
+            txRequestRound2.transactions.length === 1 &&
+            txRequestRound2.transactions[0].signatureShares.length === 4);
+        bitgoMsg4.should.have.property('signatureR');
+        // round 3
+        const reqMPCv2SigningRound3 = {
+            ...reqMPCv2SigningRound2,
+            txRequest: txRequestRound2,
+            encryptedRound1Session: null,
+            encryptedRound2Session,
+        };
+        const resMPCv2SigningRound3 = await ecdsaMPCv2Utils.createOfflineRound3Share(reqMPCv2SigningRound3);
+        resMPCv2SigningRound3.should.have.property('signatureShareRound3');
+        const { userMsg4 } = await signBitgoMPCv2Round3(bitgoSession, resMPCv2SigningRound3.signatureShareRound3, resMPCv2SigningRound1.userGpgPubKey);
+        assert.ok(userMsg4.data.msg4.signatureR === bitgoMsg4.signatureR, 'User and BitGo signaturesR do not match');
+        const deserializedBitgoMsg4 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: [],
+            broadcastMessages: [bitgoMsg4],
+        });
+        const deserializedUserMsg4 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: [],
+            broadcastMessages: [
+                {
+                    from: userMsg4.data.msg4.from,
+                    payload: userMsg4.data.msg4.message,
+                },
+            ],
+        });
+        const combinedSigUsingUtil = sdk_lib_mpc_1.DklsUtils.combinePartialSignatures([deserializedUserMsg4.broadcastMessages[0].payload, deserializedBitgoMsg4.broadcastMessages[0].payload], Buffer.from(userMsg4.data.msg4.signatureR, 'base64').toString('hex'));
+        // Verify with shouldHash=true and keccak256 — standard EVM verification
+        const convertedSignature = sdk_lib_mpc_1.DklsUtils.verifyAndConvertDklsSignature(Buffer.from(signableHex, 'hex'), combinedSigUsingUtil, sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userShare), derivationPath, (0, keccak_1.default)('keccak256'));
+        assert.ok(convertedSignature, 'EVM signature with serializedTxHex is not valid');
+        const sigParts = convertedSignature.split(':');
+        assert.strictEqual(sigParts.length, 4, 'Signature must be recid:R:S:pubkey format');
+        assert.strictEqual(sigParts[1].length, 64, 'Signature R must be 32 bytes hex');
+        assert.strictEqual(sigParts[2].length, 64, 'Signature S must be 32 bytes hex');
+    });
+    describe('createOfflineRound1Share and createOfflineRound2Share - encryptionVersion: 1 in v1 path', async () => {
+        let ecdsaMPCv2UtilsWithSpy;
+        let encryptAsyncSpy;
+        before(async () => {
+            const mockBg = {};
+            mockBg.getEnv = sinon.stub().returns('test');
+            const encryptImpl = (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,
+                });
+            };
+            encryptAsyncSpy = sinon.stub().callsFake(async (params) => encryptImpl(params));
+            mockBg.encrypt = sinon.stub().callsFake(encryptImpl);
+            mockBg.encrypt = encryptAsyncSpy;
+            mockBg.decrypt = sinon.stub().callsFake((params) => sjcl.decrypt(params.password, params.input));
+            mockBg.decrypt = sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input));
+            const mockCoin = {};
+            mockCoin.getHashFunction = sinon.stub().callsFake(() => (0, keccak_1.default)('keccak256'));
+            mockCoin.isSignablePreHashed = (unsignedTx) => unsignedTx.serializedTxHex?.startsWith('0000') ?? false;
+            ecdsaMPCv2UtilsWithSpy = new src_1.EcdsaMPCv2Utils(mockBg, mockCoin);
+        });
+        it('createOfflineRound1Share uses encryptionVersion: 1 in v1 (non-v2 envelope) path', async () => {
+            const txRequest = {
+                txRequestId: 'req-id',
+                walletId: walletID,
+                transactions: [{ unsignedTx: { signableHex: 'deadbeef01', derivationPath: 'm/0', serializedTxHex: '' } }],
+                apiVersion: 'full',
+            };
+            encryptAsyncSpy.resetHistory();
+            await ecdsaMPCv2UtilsWithSpy.createOfflineRound1Share({
+                txRequest,
+                prv: Buffer.from(userShare).toString('base64'),
+                walletPassphrase,
+                encryptedPrv: undefined,
+            });
+            assert.ok(encryptAsyncSpy.called, 'encrypt should be called in v1 path');
+            for (const call of encryptAsyncSpy.getCalls()) {
+                assert.strictEqual(call.args[0].encryptionVersion, 1, 'encryptionVersion should be hardcoded to 1 in the v1 signing session path');
+            }
+        });
+    });
+});
+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);
+}
+function getUserPartyGpgKeyPublic(userPubKey) {
+    return {
+        partyId: 0,
+        gpgKey: userPubKey,
+    };
+}
+function getBitGoPartyGpgKeyPrv(bitgoPrvKey) {
+    return {
+        partyId: 2,
+        gpgKey: bitgoPrvKey,
+    };
+}
+async function signBitgoMPCv2Round1(bitgoSession, txRequest, userShare, userGPGPubKey) {
+    assert.ok(txRequest.transactions && txRequest.transactions.length === 1, 'txRequest.transactions is not an array of length 1');
+    txRequest.transactions[0].signatureShares.push(userShare);
+    // Do the actual signing on BitGo's side based on User's messages
+    const signatureShare = JSON.parse(userShare.share);
+    const deserializedMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+        p2pMessages: [],
+        broadcastMessages: [
+            {
+                from: signatureShare.data.msg1.from,
+                payload: signatureShare.data.msg1.message,
+            },
+        ],
+    });
+    const bitgoToUserRound1BroadcastMsg = await bitgoSession.init();
+    const bitgoToUserRound2Msg = bitgoSession.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: deserializedMessages.broadcastMessages,
+    });
+    const serializedBitGoToUserRound1And2Msgs = sdk_lib_mpc_1.DklsTypes.serializeMessages({
+        p2pMessages: bitgoToUserRound2Msg.p2pMessages,
+        broadcastMessages: [bitgoToUserRound1BroadcastMsg],
+    });
+    const authEncMessages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages(serializedBitGoToUserRound1And2Msgs, [getUserPartyGpgKeyPublic(userGPGPubKey)], [getBitGoPartyGpgKeyPrv(gpgKeys_1.bitgoGpgKey.private)]);
+    const bitgoToUserSignatureShare = {
+        type: 'round1Output',
+        data: {
+            msg1: {
+                from: authEncMessages.broadcastMessages[0].from,
+                signature: authEncMessages.broadcastMessages[0].payload.signature,
+                message: authEncMessages.broadcastMessages[0].payload.message,
+            },
+            msg2: {
+                from: authEncMessages.p2pMessages[0].from,
+                to: authEncMessages.p2pMessages[0].to,
+                encryptedMessage: authEncMessages.p2pMessages[0].payload.encryptedMessage,
+                signature: authEncMessages.p2pMessages[0].payload.signature,
+            },
+        },
+    };
+    txRequest.transactions[0].signatureShares.push({
+        from: src_1.SignatureShareType.BITGO,
+        to: src_1.SignatureShareType.USER,
+        share: JSON.stringify(bitgoToUserSignatureShare),
+    });
+    return txRequest;
+}
+async function signBitgoMPCv2Round2(bitgoSession, txRequest, userShare, userGPGPubKey) {
+    assert.ok(txRequest.transactions && txRequest.transactions.length === 1, 'txRequest.transactions is not an array of length 1');
+    txRequest.transactions[0].signatureShares.push(userShare);
+    // Do the actual signing on BitGo's side based on User's messages
+    const parsedSignatureShare = JSON.parse(userShare.share);
+    const serializedMessages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({
+        p2pMessages: [
+            {
+                from: parsedSignatureShare.data.msg2.from,
+                to: parsedSignatureShare.data.msg2.to,
+                payload: {
+                    encryptedMessage: parsedSignatureShare.data.msg2.encryptedMessage,
+                    signature: parsedSignatureShare.data.msg2.signature,
+                },
+            },
+            {
+                from: parsedSignatureShare.data.msg3.from,
+                to: parsedSignatureShare.data.msg3.to,
+                payload: {
+                    encryptedMessage: parsedSignatureShare.data.msg3.encryptedMessage,
+                    signature: parsedSignatureShare.data.msg3.signature,
+                },
+            },
+        ],
+        broadcastMessages: [],
+    }, [getUserPartyGpgKeyPublic(userGPGPubKey)], [getBitGoPartyGpgKeyPrv(gpgKeys_1.bitgoGpgKey.private)]);
+    const deserializedMessages2 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+        p2pMessages: [serializedMessages.p2pMessages[0]],
+        broadcastMessages: [],
+    });
+    const bitgoToUserRound3Msg = bitgoSession.handleIncomingMessages(deserializedMessages2);
+    const serializedBitGoToUserRound3Msgs = sdk_lib_mpc_1.DklsTypes.serializeMessages(bitgoToUserRound3Msg);
+    const authEncMessages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages(serializedBitGoToUserRound3Msgs, [getUserPartyGpgKeyPublic(userGPGPubKey)], [getBitGoPartyGpgKeyPrv(gpgKeys_1.bitgoGpgKey.private)]);
+    const bitgoToUserSignatureShare = {
+        type: 'round2Output',
+        data: {
+            msg3: {
+                from: authEncMessages.p2pMessages[0].from,
+                to: authEncMessages.p2pMessages[0].to,
+                encryptedMessage: authEncMessages.p2pMessages[0].payload.encryptedMessage,
+                signature: authEncMessages.p2pMessages[0].payload.signature,
+            },
+        },
+    };
+    // handling user msg3 but not returning bitgo msg4 since its stored on bitgo side only
+    const deserializedMessages3 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+        p2pMessages: [serializedMessages.p2pMessages[1]],
+        broadcastMessages: [],
+    });
+    const deserializedBitgoMsg4 = bitgoSession.handleIncomingMessages(deserializedMessages3);
+    const serializedBitGoToUserRound4Msgs = sdk_lib_mpc_1.DklsTypes.serializeMessages(deserializedBitgoMsg4);
+    txRequest.transactions[0].signatureShares.push({
+        from: src_1.SignatureShareType.BITGO,
+        to: src_1.SignatureShareType.USER,
+        share: JSON.stringify(bitgoToUserSignatureShare),
+    });
+    return { txRequest, bitgoMsg4: serializedBitGoToUserRound4Msgs.broadcastMessages[0] };
+}
+async function signBitgoMPCv2Round3(bitgoSession, userShare, userGPGPubKey) {
+    const parsedSignatureShare = JSON.parse(userShare.share);
+    const msg4 = parsedSignatureShare.data.msg4;
+    const signatureRAuthMessage = msg4.signatureR && msg4.signatureRSignature
+        ? { message: msg4.signatureR, signature: msg4.signatureRSignature }
+        : undefined;
+    const serializedMessages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [
+            {
+                from: msg4.from,
+                payload: {
+                    message: msg4.message,
+                    signature: msg4.signature,
+                },
+                signatureR: signatureRAuthMessage,
+            },
+        ],
+    }, [getUserPartyGpgKeyPublic(userGPGPubKey)], [getBitGoPartyGpgKeyPrv(gpgKeys_1.bitgoGpgKey.private)]);
+    const deserializedMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+        p2pMessages: [],
+        broadcastMessages: [serializedMessages.broadcastMessages[0]],
+    });
+    bitgoSession.handleIncomingMessages(deserializedMessages);
+    return {
+        userMsg4: parsedSignatureShare,
+    };
+}
+describe('EcdsaMPCv2Utils.createKeychainsWithExternalSigner', function () {
+    let utils;
+    let callbacks;
+    const enterprise = 'enterprise-id';
+    const sessionId = 'session-001';
+    const commonKeychain = 'common-keychain-abc';
+    const emptyMessages = { broadcastMessages: [], p2pMessages: [] };
+    const userState = { encryptedData: 'u-data', encryptedDataKey: 'u-data-key' };
+    const backupState = { encryptedData: 'b-data', encryptedDataKey: 'b-data-key' };
+    const bitgoMsg1 = { from: 2, message: 'msg1', signature: 'sig1' };
+    const bitgoToUserMsg2 = { from: 2, to: 0, encryptedMessage: 'u2', signature: 'su2' };
+    const bitgoToBackupMsg2 = { from: 2, to: 1, encryptedMessage: 'b2', signature: 'sb2' };
+    const bitgoToUserMsg3 = { from: 2, to: 0, encryptedMessage: 'u3', signature: 'su3' };
+    const bitgoToBackupMsg3 = { from: 2, to: 1, encryptedMessage: 'b3', signature: 'sb3' };
+    const bitgoMsg4 = { from: 2, message: 'msg4', signature: 'sig4' };
+    beforeEach(function () {
+        callbacks = {
+            initializeCallback: sinon.stub().resolves({
+                userGpgPublicKey: 'user-gpg-pub',
+                backupGpgPublicKey: 'backup-gpg-pub',
+                round1Messages: emptyMessages,
+                userState,
+                backupState,
+            }),
+            round2Callback: sinon.stub().resolves({ round2Messages: emptyMessages, userState, backupState }),
+            round3Callback: sinon.stub().resolves({ round3Messages: emptyMessages, userState, backupState }),
+            finalizeCallback: sinon.stub().resolves({ commonKeychain }),
+        };
+        const mockBitGo = {
+            getEnv: sinon.stub().returns('dev'),
+        };
+        const mockKeychains = {
+            add: sinon
+                .stub()
+                .callsFake((params) => Promise.resolve({ id: `${params.source}-key-id`, commonKeychain, isMPCv2: true })),
+            createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', commonKeychain, isMPCv2: true }),
+        };
+        const mockCoin = {
+            keychains: sinon.stub().returns(mockKeychains),
+        };
+        utils = new src_1.EcdsaMPCv2Utils(mockBitGo, mockCoin);
+        sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags').resolves({ mpcv2PublicKey: null });
+        utils.bitgoMPCv2PublicGpgKey = { armor: () => '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' };
+        sinon.stub(utils, 'sendKeyGenerationRound1').resolves({
+            sessionId: sessionId,
+            walletGpgPubKeySigs: 'sigs',
+            bitgoMsg1,
+            bitgoToUserMsg2,
+            bitgoToBackupMsg2,
+        });
+        sinon.stub(utils, 'sendKeyGenerationRound2').resolves({
+            sessionId: sessionId,
+            bitgoCommitment2: 'commitment2',
+            bitgoToUserMsg3,
+            bitgoToBackupMsg3,
+        });
+        sinon.stub(utils, 'sendKeyGenerationRound3').resolves({
+            sessionId: sessionId,
+            bitgoMsg4,
+            commonKeychain: commonKeychain,
+        });
+        sinon.stub(utils, 'addBitgoKeychain').resolves({ id: 'bitgo-key-id', commonKeychain, isMPCv2: true });
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    it('should invoke callbacks in order and return keychains', async function () {
+        const keychains = await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        assert.ok(keychains.userKeychain);
+        assert.ok(keychains.backupKeychain);
+        assert.ok(keychains.bitgoKeychain);
+        sinon.assert.calledOnce(callbacks.initializeCallback);
+        sinon.assert.calledOnce(callbacks.round2Callback);
+        sinon.assert.calledOnce(callbacks.round3Callback);
+        sinon.assert.calledOnce(callbacks.finalizeCallback);
+    });
+    it('should pass round1 response and state to round2Callback', async function () {
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        const round2Args = callbacks.round2Callback.firstCall.args[0];
+        assert.strictEqual(round2Args.sessionId, sessionId);
+        assert.deepStrictEqual(round2Args.bitgoMsg1, bitgoMsg1);
+        assert.deepStrictEqual(round2Args.bitgoToUserMsg2, bitgoToUserMsg2);
+        assert.deepStrictEqual(round2Args.bitgoToBackupMsg2, bitgoToBackupMsg2);
+        assert.deepStrictEqual(round2Args.userState, userState);
+        assert.deepStrictEqual(round2Args.backupState, backupState);
+    });
+    it('should pass round2 response and threaded state to round3Callback', async function () {
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        const round3Args = callbacks.round3Callback.firstCall.args[0];
+        assert.strictEqual(round3Args.sessionId, sessionId);
+        assert.strictEqual(round3Args.bitgoCommitment2, 'commitment2');
+        assert.deepStrictEqual(round3Args.bitgoToUserMsg3, bitgoToUserMsg3);
+        assert.deepStrictEqual(round3Args.bitgoToBackupMsg3, bitgoToBackupMsg3);
+        assert.deepStrictEqual(round3Args.userState, userState);
+        assert.deepStrictEqual(round3Args.backupState, backupState);
+    });
+    it('should pass round3 response and bitgoCommonKeychain to finalizeCallback', async function () {
+        await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });
+        const finalizeArgs = callbacks.finalizeCallback.firstCall.args[0];
+        assert.strictEqual(finalizeArgs.sessionId, sessionId);
+        assert.deepStrictEqual(finalizeArgs.bitgoMsg4, bitgoMsg4);
+        assert.strictEqual(finalizeArgs.bitgoCommonKeychain, commonKeychain);
+        assert.deepStrictEqual(finalizeArgs.userState, userState);
+        assert.deepStrictEqual(finalizeArgs.backupState, backupState);
+    });
+    it('should reject when finalizeCallback returns mismatched commonKeychain', async function () {
+        callbacks.finalizeCallback.resolves({ commonKeychain: 'different-keychain' });
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /Common keychains do not match/);
+    });
+    it('should reject when round2 returns mismatched sessionId', async function () {
+        utils.sendKeyGenerationRound2.resolves({
+            sessionId: 'different-session',
+            bitgoCommitment2: 'commitment2',
+            bitgoToUserMsg3,
+            bitgoToBackupMsg3,
+        });
+        await assert.rejects(() => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }), /Session ID mismatch after round 2/);
+    });
+});
+describe('signRequestBase message finalization', () => {
+    let sandbox;
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+    });
+    afterEach(() => {
+        sandbox.restore();
+    });
+    const walletID = '62fe536a6b4cf70007acb48c0e7bb0b0';
+    const fakeReqId = { inc: sinon.stub(), toString: sinon.stub().returns('test-req') };
+    let userShare;
+    let bitgoKeyShare;
+    before('generate key shares for finalization tests', async () => {
+        const [userDkgSession, , bitgoDkgSession] = await sdk_lib_mpc_1.DklsUtils.generateDKGKeyShares();
+        userShare = userDkgSession.getKeyShare();
+        bitgoKeyShare = bitgoDkgSession.getKeyShare();
+    });
+    /**
+     * Drives signRequestBase through the REAL DKLS protocol: the user-side DSG
+     * session is the one the class builds itself; the BitGo-side session is a
+     * real DSG advanced by this test's mocked HTTP layer on every /sign POST,
+     * using the signBitgoMPCv2RoundX helpers. Only the HTTP transport is faked
+     * (bitgo.get / bitgo.post chains), which is exactly the surface the
+     * finalization-tail decision acts on: GET txrequests vs POST /send.
+     */
+    const runFullSigningFlow = async (params) => {
+        const postedUrls = [];
+        const getUrls = [];
+        const hashBuffer = Buffer.alloc(32, 1);
+        const derivationPath = 'm/0';
+        // The BitGo-side session signs the same hash buffer the user session is
+        // given via the getMpcv2HashBuffer stub below.
+        const bitgoSession = new sdk_lib_mpc_1.DklsDsg.Dsg(bitgoKeyShare, 2, derivationPath, hashBuffer);
+        // Carrier shaped for the signBitgoMPCv2RoundX helpers, which index
+        // transactions[0]; the response is remapped back to the real resource.
+        const carrier = { transactions: [{ signatureShares: [] }] };
+        let signPostCount = 0;
+        const mockBg = {
+            getEnv: () => 'test',
+            setRequestTracer: () => undefined,
+            url: (p) => p,
+            get: (url) => ({
+                query() {
+                    return this;
+                },
+                retry() {
+                    return this;
+                },
+                async result() {
+                    getUrls.push(url);
+                    return {
+                        txRequests: [
+                            {
+                                ...params.txRequest,
+                                state: 'delivered',
+                                [params.requestType === 'message' ? 'messages' : 'transactions']: [
+                                    {
+                                        state: 'signed',
+                                        txHash: '0xsigned-message-hash',
+                                        signatureShares: [],
+                                        ...(params.requestType === 'tx'
+                                            ? { unsignedTx: { derivationPath, signableHex: 'abcd', serializedTxHex: 'abcd' } }
+                                            : {}),
+                                    },
+                                ],
+                            },
+                        ],
+                    };
+                },
+            }),
+            post: (url) => {
+                postedUrls.push(url);
+                return {
+                    _body: undefined,
+                    send(body) {
+                        this._body = body;
+                        return this;
+                    },
+                    async result() {
+                        if (!url.endsWith('/sign')) {
+                            return { ...params.txRequest, state: 'delivered' };
+                        }
+                        signPostCount += 1;
+                        const body = this._body;
+                        const userShareRecord = body.signatureShares[0];
+                        if (signPostCount === 1) {
+                            await signBitgoMPCv2Round1(bitgoSession, carrier, userShareRecord, body.signerGpgPublicKey);
+                        }
+                        else if (signPostCount === 2) {
+                            await signBitgoMPCv2Round2(bitgoSession, carrier, userShareRecord, body.signerGpgPublicKey);
+                        }
+                        else {
+                            await signBitgoMPCv2Round3(bitgoSession, userShareRecord, body.signerGpgPublicKey);
+                        }
+                        const shares = carrier.transactions[0].signatureShares;
+                        return {
+                            ...params.txRequest,
+                            [params.requestType === 'message' ? 'messages' : 'transactions']: [{ signatureShares: shares }],
+                        };
+                    },
+                };
+            },
+        };
+        const mockCoin = {
+            getMPCAlgorithm: () => 'ecdsa',
+            verifyTransaction: () => Promise.resolve(true),
+            getConfig: () => ({ family: 'eth' }),
+        };
+        const mockWallet = {
+            id: () => walletID,
+            multisigType: () => 'tss',
+            multisigTypeVersion: () => 'MPCv2',
+        };
+        const utils = new src_1.EcdsaMPCv2Utils(mockBg, mockCoin, mockWallet);
+        sandbox
+            .stub(utils, 'pickBitgoPubGpgKeyForSigning')
+            .resolves(await openpgp.readKey({ armoredKey: gpgKeys_1.bitgoGpgKey.public }));
+        sandbox.stub(utils, 'getMpcv2HashBuffer').returns(hashBuffer);
+        const baseParams = {
+            txRequest: params.txRequest,
+            prv: userShare.toString('base64'),
+            reqId: fakeReqId,
+        };
+        const result = params.requestType === 'message'
+            ? await utils.signTxRequestForMessage({
+                ...baseParams,
+                messageRaw: 'raw',
+                messageEncoded: 'abcd',
+                bufferToSign: Buffer.from('abcd', 'hex'),
+            })
+            : await utils.signTxRequest({
+                ...baseParams,
+                txParams: { recipients: [{ address: '0x' + '00'.repeat(20), amount: '1000' }] },
+            });
+        return { result, postedUrls, getUrls };
+    };
+    it('message requests finalize via GET (wallet-platform delivers at share ingestion), never POST /send', async () => {
+        const txRequestId = 'msg-txreq-finalization';
+        const { result, postedUrls, getUrls } = await runFullSigningFlow({
+            requestType: 'message',
+            txRequest: {
+                txRequestId,
+                walletId: walletID,
+                apiVersion: 'full',
+                state: 'pendingDelivery',
+                messages: [{ messageRaw: 'raw', messageEncoded: 'abcd', derivationPath: 'm/0' }],
+            },
+        });
+        assert.strictEqual(result.state, 'delivered');
+        assert.strictEqual(postedUrls.filter((url) => url.endsWith('/send')).length, 0, 'message signing must not POST /send (wallet-platform already delivered at share ingestion)');
+        assert.ok(postedUrls.every((url) => url.includes(`/txrequests/${txRequestId}/messages/0/sign`)), 'all message POSTs must be share submissions');
+        // The park-check GET is skipped (object txRequest) so the only GET is the
+        // final re-fetch.
+        assert.strictEqual(getUrls.length, 1);
+        assert.ok(getUrls[0].includes('/txrequests'));
+    });
+    it('transaction requests still finalize via POST /send', async () => {
+        const txRequestId = 'tx-txreq-finalization';
+        const { result, postedUrls } = await runFullSigningFlow({
+            requestType: 'tx',
+            txRequest: {
+                txRequestId,
+                walletId: walletID,
+                apiVersion: 'full',
+                state: 'pendingDelivery',
+                transactions: [
+                    {
+                        unsignedTx: { derivationPath: 'm/0', signableHex: 'abcd', serializedTxHex: 'abcd' },
+                        signatureShares: [],
+                    },
+                ],
+            },
+        });
+        assert.strictEqual(result.state, 'delivered');
+        assert.strictEqual(postedUrls.filter((url) => url.endsWith('/transactions/0/send')).length, 1, 'transaction signing must POST /send to broadcast');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecdsaMPCv2.js","sourceRoot":"","sources":["../../../../../../../test/unit/bitgo/utils/tss/ecdsa/ecdsaMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as sinon from 'sinon';\nimport { Hash, createHash, randomBytes } from 'crypto';\nimport createKeccakHash from 'keccak';\nimport {\n  MPCv2BroadcastMessage,\n  MPCv2P2PMessage,\n  MPCv2PartyFromStringOrNumber,\n  MPCv2SignatureShareRound1Input,\n  MPCv2SignatureShareRound1Output,\n  MPCv2SignatureShareRound2Input,\n  MPCv2SignatureShareRound2Output,\n  MPCv2SignatureShareRound3Input,\n} from '@bitgo/public-types';\nimport { DklsComms, DklsDsg, DklsTypes, DklsUtils } from '@bitgo-beta/sdk-lib-mpc';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport {\n  BitGoBase,\n  EcdsaMPCv2Utils,\n  EcdsaMPCv2KeyGenCallbacks,\n  IBaseCoin,\n  SignatureShareRecord,\n  SignatureShareType,\n  TxRequest,\n  RequestTracer,\n} from '../../../../../../src';\nimport { bitgoGpgKey } from './gpgKeys';\nimport * as openpgp from 'openpgp';\n\ndescribe('ECDSA MPC v2', async () => {\n  let userShare: Buffer;\n  let bitgoShare: Buffer;\n\n  before('generate key shares for testing', async () => {\n    const [userDkgSession, backupDkgSession, bitgoDkgSession] = await DklsUtils.generateDKGKeyShares();\n    assert.ok(userDkgSession);\n    assert.ok(backupDkgSession);\n    assert.ok(bitgoDkgSession);\n\n    userShare = userDkgSession.getKeyShare();\n    bitgoShare = bitgoDkgSession.getKeyShare();\n  });\n\n  let ecdsaMPCv2Utils: EcdsaMPCv2Utils;\n\n  before('initialize EcdsaMPCv2Utils', async () => {\n    const mockBg = {} as BitGoBase;\n    mockBg.getEnv = sinon.stub().returns('test');\n    const encryptImpl = (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    const decryptImpl = (params: { password: string; input: string }) => {\n      return sjcl.decrypt(params.password, params.input);\n    };\n    mockBg.encrypt = sinon.stub().callsFake(encryptImpl);\n    mockBg.encrypt = sinon.stub().callsFake(async (params) => encryptImpl(params));\n    mockBg.decrypt = sinon.stub().callsFake(decryptImpl);\n    mockBg.decrypt = sinon.stub().callsFake(async (params) => decryptImpl(params));\n\n    const mockCoin = {} as IBaseCoin;\n    mockCoin.getHashFunction = sinon.stub().callsFake(() => createKeccakHash('keccak256') as Hash);\n    mockCoin.isSignablePreHashed = (unsignedTx) => unsignedTx.serializedTxHex?.startsWith('0000') ?? false;\n\n    ecdsaMPCv2Utils = new EcdsaMPCv2Utils(mockBg, mockCoin);\n  });\n\n  const walletID = '62fe536a6b4cf70007acb48c0e7bb0b0';\n  const walletPassphrase = 'testPass';\n\n  it('should sign a message hash using ECDSA MPC v2 offline rounds', async () => {\n    const tMessage = 'testMessage';\n    const derivationPath = 'm/0';\n\n    // round 1\n    const reqMPCv2SigningRound1 = {\n      txRequest: {\n        txRequestId: '123456',\n        apiVersion: 'full',\n        walletId: walletID,\n        transactions: [\n          {\n            unsignedTx: {\n              derivationPath,\n              signableHex: tMessage,\n            },\n            signatureShares: [],\n          },\n        ],\n      },\n      prv: userShare.toString('base64'),\n      walletPassphrase,\n    };\n\n    const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1 as any);\n    resMPCv2SigningRound1.should.have.property('signatureShareRound1');\n    resMPCv2SigningRound1.should.have.property('userGpgPubKey');\n    resMPCv2SigningRound1.should.have.property('encryptedRound1Session');\n    resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');\n\n    const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;\n    const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;\n\n    const hashBuffer = createKeccakHash('keccak256').update(Buffer.from(tMessage, 'hex')).digest();\n    const bitgoSession = new DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);\n\n    const txRequestRound1 = await signBitgoMPCv2Round1(\n      bitgoSession,\n      reqMPCv2SigningRound1.txRequest as any,\n      resMPCv2SigningRound1.signatureShareRound1,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound1.transactions &&\n        txRequestRound1.transactions.length === 1 &&\n        txRequestRound1.transactions[0].signatureShares.length === 2,\n      'txRequestRound1.transactions is not an array of length 1 with 2 signatureShares'\n    );\n\n    // round 2\n    const reqMPCv2SigningRound2 = {\n      ...reqMPCv2SigningRound1,\n      txRequest: txRequestRound1,\n      encryptedRound1Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoGpgKey.public,\n    };\n\n    const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2 as any);\n    resMPCv2SigningRound2.should.have.property('signatureShareRound2');\n    resMPCv2SigningRound2.should.have.property('encryptedRound2Session');\n\n    const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;\n\n    const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(\n      bitgoSession,\n      reqMPCv2SigningRound2.txRequest,\n      resMPCv2SigningRound2.signatureShareRound2,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound2.transactions &&\n        txRequestRound2.transactions.length === 1 &&\n        txRequestRound2.transactions[0].signatureShares.length === 4,\n      'txRequestRound2.transactions is not an array of length 1 with 4 signatureShares'\n    );\n    bitgoMsg4.should.have.property('signatureR');\n\n    // round 3\n    const reqMPCv2SigningRound3 = {\n      ...reqMPCv2SigningRound2,\n      txRequest: txRequestRound2,\n      encryptedRound1Session: null, // not needed for round 3\n      encryptedRound2Session,\n    };\n\n    const resMPCv2SigningRound3 = await ecdsaMPCv2Utils.createOfflineRound3Share(reqMPCv2SigningRound3 as any);\n    resMPCv2SigningRound3.should.have.property('signatureShareRound3');\n\n    const { userMsg4 } = await signBitgoMPCv2Round3(\n      bitgoSession,\n      resMPCv2SigningRound3.signatureShareRound3,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n\n    // signature generation and validation\n    assert.ok(userMsg4.data.msg4.signatureR === bitgoMsg4.signatureR, 'User and BitGo signaturesR do not match');\n\n    const deserializedBitgoMsg4 = DklsTypes.deserializeMessages({\n      p2pMessages: [],\n      broadcastMessages: [bitgoMsg4],\n    });\n\n    const deserializedUserMsg4 = DklsTypes.deserializeMessages({\n      p2pMessages: [],\n      broadcastMessages: [\n        {\n          from: userMsg4.data.msg4.from,\n          payload: userMsg4.data.msg4.message,\n        },\n      ],\n    });\n\n    const combinedSigUsingUtil = DklsUtils.combinePartialSignatures(\n      [deserializedUserMsg4.broadcastMessages[0].payload, deserializedBitgoMsg4.broadcastMessages[0].payload],\n      Buffer.from(userMsg4.data.msg4.signatureR, 'base64').toString('hex')\n    );\n\n    const convertedSignature = DklsUtils.verifyAndConvertDklsSignature(\n      Buffer.from(tMessage, 'hex'),\n      combinedSigUsingUtil,\n      DklsTypes.getCommonKeychain(userShare),\n      derivationPath,\n      createKeccakHash('keccak256') as Hash\n    );\n    assert.ok(convertedSignature, 'Signature is not valid');\n    assert.ok(convertedSignature.split(':').length === 4, 'Signature is not valid');\n  });\n\n  it('should fail to sign using session after round X when session after round Y is expected', async () => {\n    const tMessage = 'testMessage';\n    const derivationPath = 'm/1/2';\n\n    // round 1\n    const reqMPCv2SigningRound1 = {\n      txRequest: {\n        txRequestId: '123456',\n        apiVersion: 'full',\n        walletId: walletID,\n        transactions: [\n          {\n            unsignedTx: {\n              derivationPath,\n              signableHex: tMessage,\n            },\n            signatureShares: [],\n          },\n        ],\n      },\n      prv: userShare.toString('base64'),\n      walletPassphrase,\n    };\n\n    const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1 as any);\n    resMPCv2SigningRound1.should.have.property('signatureShareRound1');\n    resMPCv2SigningRound1.should.have.property('userGpgPubKey');\n    resMPCv2SigningRound1.should.have.property('encryptedRound1Session');\n    resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');\n\n    const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;\n    const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;\n\n    const hashBuffer = createKeccakHash('keccak256').update(Buffer.from(tMessage, 'hex')).digest();\n    const bitgoSession = new DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);\n\n    const txRequestRound1 = await signBitgoMPCv2Round1(\n      bitgoSession,\n      reqMPCv2SigningRound1.txRequest as any,\n      resMPCv2SigningRound1.signatureShareRound1,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound1.transactions &&\n        txRequestRound1.transactions.length === 1 &&\n        txRequestRound1.transactions[0].signatureShares.length === 2,\n      'txRequestRound1.transactions is not an array of length 1 with 2 signatureShares'\n    );\n\n    // round 2\n    const reqMPCv2SigningRound2 = {\n      ...reqMPCv2SigningRound1,\n      txRequest: txRequestRound1,\n      encryptedRound1Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoGpgKey.public,\n    };\n\n    const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2 as any);\n    resMPCv2SigningRound2.should.have.property('signatureShareRound2');\n    resMPCv2SigningRound2.should.have.property('encryptedRound2Session');\n\n    const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(\n      bitgoSession,\n      reqMPCv2SigningRound2.txRequest,\n      resMPCv2SigningRound2.signatureShareRound2,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound2.transactions &&\n        txRequestRound2.transactions.length === 1 &&\n        txRequestRound2.transactions[0].signatureShares.length === 4,\n      'txRequestRound2.transactions is not an array of length 1 with 4 signatureShares'\n    );\n    bitgoMsg4.should.have.property('signatureR');\n\n    const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;\n\n    // A bogus round 3 signing request containing encrypted session from round 1 instead of round 2 should fail.\n    const bogusReqMPCv2SigningRound3 = {\n      ...reqMPCv2SigningRound2,\n      txRequest: txRequestRound2,\n      encryptedRound1Session: null, // not needed for round 3\n      encryptedRound2Session: encryptedRound1Session, // instaed of encryptedRound2Session\n    };\n\n    await ecdsaMPCv2Utils\n      .createOfflineRound3Share(bogusReqMPCv2SigningRound3 as any)\n      .should.be.rejectedWith('Adata does not match cyphertext adata');\n\n    // A bogus round 2 signing request containing encrypted session from round 2 instead of round 1 should fail.\n    const bogusReqMPCv2SigningRound2 = {\n      ...reqMPCv2SigningRound2,\n      encryptedRound1Session: encryptedRound2Session, // instaed of encryptedRound1Session\n    };\n\n    await ecdsaMPCv2Utils\n      .createOfflineRound2Share(bogusReqMPCv2SigningRound2 as any)\n      .should.be.rejectedWith('Unexpected signature share response. Unable to parse data.');\n  });\n\n  it('should fail to sign reusing a session on different message', async () => {\n    const tMessage1 = 'testMessage1';\n    const tMessage2 = 'testMessage2';\n    const derivationPath = 'm/3/4';\n\n    // round 1 of signing tMessage1\n    const reqMPCv2SigningMsg1Round1 = {\n      txRequest: {\n        txRequestId: '123456',\n        apiVersion: 'full',\n        walletId: walletID,\n        transactions: [\n          {\n            unsignedTx: {\n              derivationPath,\n              signableHex: tMessage1,\n            },\n            signatureShares: [],\n          },\n        ],\n      },\n      prv: userShare.toString('base64'),\n      walletPassphrase,\n    };\n\n    const resMPCv2SigningMsg1Round1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningMsg1Round1 as any);\n    resMPCv2SigningMsg1Round1.should.have.property('signatureShareRound1');\n    resMPCv2SigningMsg1Round1.should.have.property('userGpgPubKey');\n    resMPCv2SigningMsg1Round1.should.have.property('encryptedRound1Session');\n    resMPCv2SigningMsg1Round1.should.have.property('encryptedUserGpgPrvKey');\n\n    const encryptedMsg1Round1Session = resMPCv2SigningMsg1Round1.encryptedRound1Session;\n\n    const hashBuffer1 = createKeccakHash('keccak256').update(Buffer.from(tMessage1, 'hex')).digest();\n    const bitgoSession1 = new DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer1);\n\n    const txRequestMsg1Round1 = await signBitgoMPCv2Round1(\n      bitgoSession1,\n      reqMPCv2SigningMsg1Round1.txRequest as any,\n      resMPCv2SigningMsg1Round1.signatureShareRound1,\n      resMPCv2SigningMsg1Round1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestMsg1Round1.transactions &&\n        txRequestMsg1Round1.transactions.length === 1 &&\n        txRequestMsg1Round1.transactions[0].signatureShares.length === 2,\n      'txRequestMsg1Round1.transactions is not an array of length 1 with 2 signatureShares'\n    );\n\n    // round 1 of signing tMessage2\n    const reqMPCv2SigningMsg2Round1 = {\n      ...reqMPCv2SigningMsg1Round1,\n      txRequest: {\n        ...reqMPCv2SigningMsg1Round1.txRequest,\n        transactions: [\n          {\n            unsignedTx: {\n              derivationPath,\n              signableHex: tMessage2,\n            },\n            signatureShares: [],\n          },\n        ],\n      },\n    };\n\n    const resMPCv2SigningMsg2Round1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningMsg2Round1 as any);\n    resMPCv2SigningMsg2Round1.should.have.property('signatureShareRound1');\n    resMPCv2SigningMsg2Round1.should.have.property('userGpgPubKey');\n    resMPCv2SigningMsg2Round1.should.have.property('encryptedRound1Session');\n    resMPCv2SigningMsg2Round1.should.have.property('encryptedUserGpgPrvKey');\n\n    const encryptedMsg2UserGpgPrvKey = resMPCv2SigningMsg2Round1.encryptedUserGpgPrvKey;\n\n    const hashBuffer2 = createKeccakHash('keccak256').update(Buffer.from(tMessage2, 'hex')).digest();\n    const bitgoSession2 = new DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer2);\n\n    const txRequestMsg2Round1 = await signBitgoMPCv2Round1(\n      bitgoSession2,\n      reqMPCv2SigningMsg2Round1.txRequest as any,\n      resMPCv2SigningMsg2Round1.signatureShareRound1,\n      resMPCv2SigningMsg2Round1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestMsg2Round1.transactions &&\n        txRequestMsg2Round1.transactions.length === 1 &&\n        txRequestMsg2Round1.transactions[0].signatureShares.length === 2,\n      'txRequestMsg2Round1.transactions is not an array of length 1 with 2 signatureShares'\n    );\n\n    // Attempting to reuse round 1 session from signing tMessage1 for signing tMessage2 should fail at round 2.\n    const reqMPCv2SigningMsg2Round2WithMsg1Session = {\n      ...reqMPCv2SigningMsg2Round1,\n      txRequest: txRequestMsg2Round1,\n      encryptedRound1Session: encryptedMsg1Round1Session, // instead of resMPCv2SigningMsg2Round1.encryptedRound1Session\n      encryptedUserGpgPrvKey: encryptedMsg2UserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoGpgKey.public,\n    };\n\n    await ecdsaMPCv2Utils\n      .createOfflineRound2Share(reqMPCv2SigningMsg2Round2WithMsg1Session as any)\n      .should.be.rejectedWith('Error while creating messages from party 0, round 2: Error: Invalid final_session_id');\n  });\n\n  it('should sign a pre-hashed Avalanche atomic export tx without applying keccak256', async () => {\n    // Real Avalanche ExportInC transaction from sdk-coin-flr test resources.\n    // Mirrors the sandbox flow: c2pMpcToMpcTss.ts → signWithMpc() where\n    // FlareJS builds an ExportInC tx, SHA-256 hashes the unsigned bytes,\n    // and MPC signs the raw SHA-256 hash (NOT keccak256 of it).\n    //\n    // serializedTxHex = full unsigned Avalanche atomic tx (codec type ID 0x0000)\n    // signableHex     = SHA-256(txBody) — 32 bytes, already the final signing hash\n    //\n    // Sandbox reference (coins-sandbox/flareCP/flrC_MPC_to_flrP_MPC):\n    //\n    // C→P direction (c2pMpcToMpcTss.ts — export from C-chain):\n    //   Message hash (SHA-256): 9b3e1c8fc9322b667ec61619487b3993e91dcfc5...\n    //   Signature r: d5bc2e2cad314023...  s: 47af9d7109135f7a...  Recovery: 1\n    //   Export TX ID: 2Z5ELShnmmMgvTeupzLQzEKtAgbvZkDvq6KRYqbzVgcyBGVGpb\n    //\n    // P→C direction (p2cMpcToMpcTss.ts — export from P-chain):\n    //   Threshold: 1 (MPC single-sig on-chain, NO hop transaction)\n    //   Message hash (SHA-256): f1afd7bb3df2019ee61b41334abf95172d469d18...\n    //   Signature r: fae44ca89e7a0d3effd0912c16d69735aabbc73ad2d140ffa2c3b46af48d159c\n    //   Signature s: 1dec05d0d477a5b245a0a2e5f3a67e75489ff9b98b29780fc757b12d9f687db3\n    //   Recovery: 0\n    //   Export TX ID: 2tDQmQUtDMyVWe8Bo36yHXykV2RMvh8rft3to5QsgoNhATMDXz\n    //   Network: Coston2 Testnet (ID: 114)\n    const serializedTxHex =\n      '0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da5552479' +\n      '00000000000000000000000000000000000000000000000000000000000000000000000128a05933dc76' +\n      'e4e6c25f35d5c9b2a58769700e760000000002ff3d1658734f94af871c3d131b56131b6fb7a0291eac' +\n      'add261e69dfb42a9cdf6f7fddd00000000000000090000000158734f94af871c3d131b56131b6fb7a029' +\n      '1eacadd261e69dfb42a9cdf6f7fddd000000070000000002faf08000000000000000000000000200000003' +\n      '12cb32eaf92553064db98d271b56cba079ec78f5a6e0c1abd0132f70efb77e2274637ff336a29a57c386' +\n      'd58d09a9ae77cf1cf07bf1c9de44ebb0c9f3';\n    // SHA-256(serializedTxHex bytes) — same as FlareJS unsignedTx.toBytes() → sha256\n    const signableHex = createHash('sha256').update(Buffer.from(serializedTxHex, 'hex')).digest('hex');\n    const derivationPath = 'm/0';\n\n    // Validate fixture properties match sandbox expectations:\n    // - serializedTxHex starts with Avalanche codec type ID (0x0000)\n    // - signableHex is exactly 64 hex chars (32-byte SHA-256 digest)\n    assert.ok(serializedTxHex.startsWith('0000'), 'Fixture must start with Avalanche codec prefix');\n    assert.strictEqual(signableHex.length, 64, 'signableHex must be 32-byte SHA-256 (64 hex chars)');\n    // Verify keccak256(signableHex) differs — proves skipping hash matters\n    const keccakHash = createKeccakHash('keccak256').update(Buffer.from(signableHex, 'hex')).digest('hex');\n    assert.notStrictEqual(signableHex, keccakHash, 'SHA-256 and keccak256 hashes must differ');\n\n    // round 1\n    const reqMPCv2SigningRound1 = {\n      txRequest: {\n        txRequestId: 'flr-export-c2p',\n        apiVersion: 'full',\n        walletId: walletID,\n        transactions: [\n          {\n            unsignedTx: {\n              derivationPath,\n              signableHex,\n              serializedTxHex,\n            },\n            signatureShares: [],\n          },\n        ],\n      },\n      prv: userShare.toString('base64'),\n      walletPassphrase,\n    };\n\n    const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1 as any);\n    resMPCv2SigningRound1.should.have.property('signatureShareRound1');\n    resMPCv2SigningRound1.should.have.property('encryptedRound1Session');\n    resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');\n\n    const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;\n    const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;\n\n    // BitGo/HSM party uses the raw SHA-256 hash directly (no keccak256).\n    // This matches WP's MPCv2Signer isPreHashed=true path where\n    // txHash = signableMaterial (raw signableHex bytes).\n    // If the SDK incorrectly applied keccak256, user party would use\n    // keccak256(SHA-256(txBody)) while HSM uses SHA-256(txBody) — the\n    // two DKLS parties would disagree, producing an invalid combined sig.\n    const hashBuffer = Buffer.from(signableHex, 'hex');\n    assert.strictEqual(hashBuffer.length, 32, 'DKLS message hash must be 32 bytes');\n    const bitgoSession = new DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);\n\n    const txRequestRound1 = await signBitgoMPCv2Round1(\n      bitgoSession,\n      reqMPCv2SigningRound1.txRequest as any,\n      resMPCv2SigningRound1.signatureShareRound1,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound1.transactions &&\n        txRequestRound1.transactions.length === 1 &&\n        txRequestRound1.transactions[0].signatureShares.length === 2\n    );\n\n    // round 2\n    const reqMPCv2SigningRound2 = {\n      ...reqMPCv2SigningRound1,\n      txRequest: txRequestRound1,\n      encryptedRound1Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoGpgKey.public,\n    };\n\n    const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2 as any);\n    resMPCv2SigningRound2.should.have.property('signatureShareRound2');\n    resMPCv2SigningRound2.should.have.property('encryptedRound2Session');\n\n    const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;\n\n    const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(\n      bitgoSession,\n      reqMPCv2SigningRound2.txRequest,\n      resMPCv2SigningRound2.signatureShareRound2,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound2.transactions &&\n        txRequestRound2.transactions.length === 1 &&\n        txRequestRound2.transactions[0].signatureShares.length === 4\n    );\n    bitgoMsg4.should.have.property('signatureR');\n\n    // round 3\n    const reqMPCv2SigningRound3 = {\n      ...reqMPCv2SigningRound2,\n      txRequest: txRequestRound2,\n      encryptedRound1Session: null,\n      encryptedRound2Session,\n    };\n\n    const resMPCv2SigningRound3 = await ecdsaMPCv2Utils.createOfflineRound3Share(reqMPCv2SigningRound3 as any);\n    resMPCv2SigningRound3.should.have.property('signatureShareRound3');\n\n    const { userMsg4 } = await signBitgoMPCv2Round3(\n      bitgoSession,\n      resMPCv2SigningRound3.signatureShareRound3,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n\n    // Both parties must produce matching R values for a valid combined signature\n    assert.ok(userMsg4.data.msg4.signatureR === bitgoMsg4.signatureR, 'User and BitGo signaturesR do not match');\n\n    const deserializedBitgoMsg4 = DklsTypes.deserializeMessages({\n      p2pMessages: [],\n      broadcastMessages: [bitgoMsg4],\n    });\n\n    const deserializedUserMsg4 = DklsTypes.deserializeMessages({\n      p2pMessages: [],\n      broadcastMessages: [\n        {\n          from: userMsg4.data.msg4.from,\n          payload: userMsg4.data.msg4.message,\n        },\n      ],\n    });\n\n    const combinedSigUsingUtil = DklsUtils.combinePartialSignatures(\n      [deserializedUserMsg4.broadcastMessages[0].payload, deserializedBitgoMsg4.broadcastMessages[0].payload],\n      Buffer.from(userMsg4.data.msg4.signatureR, 'base64').toString('hex')\n    );\n\n    // Combined signature must have valid R and S components (32 bytes each)\n    assert.strictEqual(combinedSigUsingUtil.R.length, 32, 'Signature R must be 32 bytes');\n    assert.strictEqual(combinedSigUsingUtil.S.length, 32, 'Signature S must be 32 bytes');\n\n    // Verify with shouldHash=false — signableHex is already SHA-256(txBody).\n    // This mirrors WP's combineSigSharesMPCv2 where shouldHash=false for\n    // pre-hashed Avalanche atomic transactions (isSignablePreHashed=true).\n    // On-chain, Avalanche verifies: ecdsaRecover(SHA-256(txBody)) == signerPubKey\n    const convertedSignature = DklsUtils.verifyAndConvertDklsSignature(\n      Buffer.from(signableHex, 'hex'),\n      combinedSigUsingUtil,\n      DklsTypes.getCommonKeychain(userShare),\n      derivationPath,\n      createHash('sha256') as Hash,\n      false // shouldHash=false: message is already SHA-256(txBody)\n    );\n    assert.ok(convertedSignature, 'Pre-hashed Avalanche atomic signature is not valid');\n    // Format: recid:R_hex:S_hex:publicKey_hex\n    // Sandbox produces the same structure — e.g. P→C export:\n    //   r: fae44ca89e7a0d3effd0912c16d69735aabbc73ad2d140ffa2c3b46af48d159c (32 bytes)\n    //   s: 1dec05d0d477a5b245a0a2e5f3a67e75489ff9b98b29780fc757b12d9f687db3 (32 bytes)\n    //   Recovery: 0\n    const sigParts = convertedSignature.split(':');\n    assert.strictEqual(sigParts.length, 4, 'Signature must be recid:R:S:pubkey format');\n    assert.ok(['0', '1'].includes(sigParts[0]), 'Recovery ID must be 0 or 1');\n    assert.strictEqual(sigParts[1].length, 64, 'Signature R must be 32 bytes hex');\n    assert.strictEqual(sigParts[2].length, 64, 'Signature S must be 32 bytes hex');\n  });\n\n  it('signRequestBase (hot wallet path) should skip keccak256 for Avalanche atomic tx', async () => {\n    const serializedTxHex =\n      '0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da5552479' +\n      '00000000000000000000000000000000000000000000000000000000000000000000000128a05933dc76' +\n      'e4e6c25f35d5c9b2a58769700e760000000002ff3d1658734f94af871c3d131b56131b6fb7a0291eac' +\n      'add261e69dfb42a9cdf6f7fddd00000000000000090000000158734f94af871c3d131b56131b6fb7a029' +\n      '1eacadd261e69dfb42a9cdf6f7fddd000000070000000002faf08000000000000000000000000200000003' +\n      '12cb32eaf92553064db98d271b56cba079ec78f5a6e0c1abd0132f70efb77e2274637ff336a29a57c386' +\n      'd58d09a9ae77cf1cf07bf1c9de44ebb0c9f3';\n    const signableHex = createHash('sha256').update(Buffer.from(serializedTxHex, 'hex')).digest('hex');\n    const derivationPath = 'm/0';\n\n    const mockBgWithPost = {} as BitGoBase;\n    mockBgWithPost.getEnv = sinon.stub().returns('test');\n    mockBgWithPost.setRequestTracer = sinon.stub();\n    mockBgWithPost.encrypt = sinon.stub().returns('encrypted');\n    mockBgWithPost.encrypt = sinon.stub().resolves('encrypted');\n    mockBgWithPost.decrypt = sinon.stub().returns('decrypted');\n    mockBgWithPost.decrypt = sinon.stub().resolves('decrypted');\n    mockBgWithPost.post = sinon.stub().returns({\n      send: sinon.stub().returnsThis(),\n      set: sinon.stub().returnsThis(),\n      result: sinon.stub().rejects(new Error('mock: HTTP not available')),\n    });\n\n    const hashFunctionSpy = sinon.stub().callsFake(() => createKeccakHash('keccak256') as Hash);\n    const mockCoinForHotWallet = {\n      getHashFunction: hashFunctionSpy,\n      verifyTransaction: sinon.stub().resolves(true),\n      getMPCAlgorithm: sinon.stub().returns('ecdsa'),\n      getConfig: sinon.stub().returns({ family: 'flrp' }),\n      isSignablePreHashed: (unsignedTx: { serializedTxHex?: string }) =>\n        unsignedTx.serializedTxHex?.startsWith('0000') ?? false,\n    } as unknown as IBaseCoin;\n\n    const mockWallet = {\n      id: sinon.stub().returns(walletID),\n      multisigType: sinon.stub().returns('tss'),\n      multisigTypeVersion: sinon.stub().returns('MPCv2'),\n    };\n\n    const hotWalletUtils = new EcdsaMPCv2Utils(mockBgWithPost, mockCoinForHotWallet, mockWallet as any);\n    sinon.stub(hotWalletUtils as any, 'pickBitgoPubGpgKeyForSigning').resolves(bitgoGpgKey.public);\n\n    const txRequest = {\n      txRequestId: 'flrp-export-test',\n      apiVersion: 'full',\n      walletId: walletID,\n      transactions: [\n        {\n          unsignedTx: {\n            derivationPath,\n            signableHex,\n            serializedTxHex,\n          },\n          signatureShares: [],\n        },\n      ],\n    } as unknown as TxRequest;\n\n    try {\n      await hotWalletUtils.signTxRequest({\n        txRequest,\n        txParams: { recipients: [{ address: '0x' + '00'.repeat(20), amount: '1000' }] },\n        prv: userShare.toString('base64'),\n        reqId: { inc: sinon.stub(), toString: sinon.stub().returns('test-req') } as any,\n      });\n    } catch (e) {}\n\n    assert.strictEqual(\n      hashFunctionSpy.callCount,\n      0,\n      'getHashFunction must NOT be called for Avalanche atomic tx (serializedTxHex starts with 0000)'\n    );\n  });\n\n  it('signRequestBase (hot wallet path) should apply keccak256 for regular EVM tx', async () => {\n    const serializedTxHex = 'f86c808504a817c80082520894' + '00'.repeat(20) + '80808080';\n    const signableHex = serializedTxHex;\n    const derivationPath = 'm/0';\n\n    assert.ok(!serializedTxHex.startsWith('0000'), 'EVM tx must not start with Avalanche prefix');\n\n    const mockBgWithPost = {} as BitGoBase;\n    mockBgWithPost.getEnv = sinon.stub().returns('test');\n    mockBgWithPost.setRequestTracer = sinon.stub();\n    mockBgWithPost.encrypt = sinon.stub().returns('encrypted');\n    mockBgWithPost.encrypt = sinon.stub().resolves('encrypted');\n    mockBgWithPost.decrypt = sinon.stub().returns('decrypted');\n    mockBgWithPost.decrypt = sinon.stub().resolves('decrypted');\n    mockBgWithPost.post = sinon.stub().returns({\n      send: sinon.stub().returnsThis(),\n      set: sinon.stub().returnsThis(),\n      result: sinon.stub().rejects(new Error('mock: HTTP not available')),\n    });\n\n    const hashFunctionSpy = sinon.stub().callsFake(() => createKeccakHash('keccak256') as Hash);\n    const mockCoinForEvmWallet = {\n      getHashFunction: hashFunctionSpy,\n      verifyTransaction: sinon.stub().resolves(true),\n      getMPCAlgorithm: sinon.stub().returns('ecdsa'),\n      getConfig: sinon.stub().returns({ family: 'flr' }),\n    } as unknown as IBaseCoin;\n\n    const mockWallet = {\n      id: sinon.stub().returns(walletID),\n      multisigType: sinon.stub().returns('tss'),\n      multisigTypeVersion: sinon.stub().returns('MPCv2'),\n    };\n\n    const evmUtils = new EcdsaMPCv2Utils(mockBgWithPost, mockCoinForEvmWallet, mockWallet as any);\n    sinon.stub(evmUtils as any, 'pickBitgoPubGpgKeyForSigning').resolves(bitgoGpgKey.public);\n\n    const txRequest = {\n      txRequestId: 'flr-evm-test',\n      apiVersion: 'full',\n      walletId: walletID,\n      transactions: [\n        {\n          unsignedTx: {\n            derivationPath,\n            signableHex,\n            serializedTxHex,\n          },\n          signatureShares: [],\n        },\n      ],\n    } as unknown as TxRequest;\n\n    try {\n      await evmUtils.signTxRequest({\n        txRequest,\n        txParams: { recipients: [{ address: '0x' + '00'.repeat(20), amount: '1000' }] },\n        prv: userShare.toString('base64'),\n        reqId: { inc: sinon.stub(), toString: sinon.stub().returns('test-req') } as any,\n      });\n    } catch (e) {}\n\n    assert.strictEqual(\n      hashFunctionSpy.callCount,\n      1,\n      'getHashFunction must be called for regular EVM tx (serializedTxHex does not start with 0000)'\n    );\n  });\n\n  // Regression test for CGD-1815 / DEFI-661: resolveEffectiveTxParams() special-cases wrap-native\n  // and unwrap-native so the no-recipients guard in verifyTssTransaction doesn't reject them. That\n  // bypass is security-sensitive (it's what lets a DeFi vault wrap/unwrap tx skip recipient\n  // verification), so pin it through the real signRequestBase() -> resolveEffectiveTxParams() ->\n  // verifyTransaction() wiring instead of only unit-testing resolveEffectiveTxParams() in isolation.\n  // pendingApproval.approve() -> recreateTxRequest() -> signTxRequest() carries no txParams at all,\n  // so intentType is the ONLY source of the type here — exactly the path that only ever sees the\n  // kebab-case spelling ('wrap-native' / 'unwrap-native'), never the camelCase 'wrapNative'/'unwrapNative'.\n  ['wrap-native', 'unwrap-native'].forEach((intentType) => {\n    it(`signRequestBase should verify a no-txParams ${intentType} intent without requiring recipients`, async () => {\n      const serializedTxHex = 'f86c808504a817c80082520894' + '00'.repeat(20) + '80808080';\n      const signableHex = serializedTxHex;\n      const derivationPath = 'm/0';\n\n      const mockBgWithPost = {} as BitGoBase;\n      mockBgWithPost.getEnv = sinon.stub().returns('test');\n      mockBgWithPost.setRequestTracer = sinon.stub();\n      mockBgWithPost.encrypt = sinon.stub().resolves('encrypted');\n      mockBgWithPost.decrypt = sinon.stub().resolves('decrypted');\n      mockBgWithPost.post = sinon.stub().returns({\n        send: sinon.stub().returnsThis(),\n        set: sinon.stub().returnsThis(),\n        result: sinon.stub().rejects(new Error('mock: HTTP not available')),\n      });\n\n      const verifyTransactionSpy = sinon.stub().resolves(true);\n      const mockCoinForWrap = {\n        getHashFunction: sinon.stub().callsFake(() => createKeccakHash('keccak256') as Hash),\n        verifyTransaction: verifyTransactionSpy,\n        getMPCAlgorithm: sinon.stub().returns('ecdsa'),\n        getConfig: sinon.stub().returns({ family: 'hteth' }),\n      } as unknown as IBaseCoin;\n\n      const mockWallet = {\n        id: sinon.stub().returns(walletID),\n        multisigType: sinon.stub().returns('tss'),\n        multisigTypeVersion: sinon.stub().returns('MPCv2'),\n      };\n\n      const wrapUtils = new EcdsaMPCv2Utils(mockBgWithPost, mockCoinForWrap, mockWallet as any);\n      sinon.stub(wrapUtils as any, 'pickBitgoPubGpgKeyForSigning').resolves(bitgoGpgKey.public);\n\n      // No recipients anywhere (neither txParams.recipients nor intent.recipients) — the wrap-native/\n      // unwrap-native calldata is built server-side from defiParams, per DefiVault.sendWrapIntent.\n      const txRequest = {\n        txRequestId: `wrap-native-test-${intentType}`,\n        apiVersion: 'full',\n        walletId: walletID,\n        intent: { intentType, defiParams: { vaultId: 'vlt-galaxy-weth', amount: '1000000000000000000' } },\n        transactions: [\n          {\n            unsignedTx: { derivationPath, signableHex, serializedTxHex },\n            signatureShares: [],\n          },\n        ],\n      } as unknown as TxRequest;\n\n      try {\n        await wrapUtils.signTxRequest({\n          txRequest,\n          // No txParams at all — mirrors pendingApproval.approve() -> recreateTxRequest() ->\n          // signTxRequest(), the one signing path that only ever sees the kebab-case intentType.\n          txParams: undefined,\n          prv: userShare.toString('base64'),\n          reqId: { inc: sinon.stub(), toString: sinon.stub().returns('test-req') } as any,\n        });\n      } catch (e) {}\n\n      assert.strictEqual(\n        verifyTransactionSpy.callCount,\n        1,\n        'verifyTransaction must be reached: resolveEffectiveTxParams must not throw for a no-recipients ' +\n          `${intentType} intent`\n      );\n      const verifyCallArgs = verifyTransactionSpy.firstCall.args[0];\n      assert.strictEqual(verifyCallArgs.txParams.type, intentType);\n      assert.strictEqual(verifyCallArgs.txParams.recipients, undefined);\n    });\n  });\n\n  it('should still apply keccak256 for regular FLR EVM transactions', async () => {\n    // Regular EVM transaction on FLR (e.g. token transfer, not cross-chain).\n    // serializedTxHex starts with 'f8' (RLP prefix), NOT '0000'.\n    // The SDK must apply keccak256 as the hash function — standard EVM path.\n    // Use valid hex for signableHex (unlike the pre-existing 'testMessage' pattern\n    // in earlier tests) so keccak256 operates on a realistic byte buffer.\n    const serializedTxHex = 'f86c808504a817c80082520894' + '00'.repeat(20) + '80808080';\n    const signableHex = serializedTxHex; // In EVM, signableHex is the RLP-encoded unsigned tx\n    const derivationPath = 'm/0';\n\n    // Verify fixture does NOT trigger the Avalanche detection\n    assert.ok(!serializedTxHex.startsWith('0000'), 'EVM tx must not start with Avalanche prefix');\n\n    // round 1\n    const reqMPCv2SigningRound1 = {\n      txRequest: {\n        txRequestId: 'flr-evm-transfer',\n        apiVersion: 'full',\n        walletId: walletID,\n        transactions: [\n          {\n            unsignedTx: {\n              derivationPath,\n              signableHex,\n              serializedTxHex,\n            },\n            signatureShares: [],\n          },\n        ],\n      },\n      prv: userShare.toString('base64'),\n      walletPassphrase,\n    };\n\n    const resMPCv2SigningRound1 = await ecdsaMPCv2Utils.createOfflineRound1Share(reqMPCv2SigningRound1 as any);\n    resMPCv2SigningRound1.should.have.property('signatureShareRound1');\n    resMPCv2SigningRound1.should.have.property('encryptedRound1Session');\n    resMPCv2SigningRound1.should.have.property('encryptedUserGpgPrvKey');\n\n    const encryptedRound1Session = resMPCv2SigningRound1.encryptedRound1Session;\n    const encryptedUserGpgPrvKey = resMPCv2SigningRound1.encryptedUserGpgPrvKey;\n\n    // BitGo party uses keccak256(signableHex) — standard EVM path.\n    // Both SDK and WP/HSM apply keccak256 for regular EVM transactions.\n    const hashBuffer = createKeccakHash('keccak256').update(Buffer.from(signableHex, 'hex')).digest();\n    const bitgoSession = new DklsDsg.Dsg(bitgoShare, 2, derivationPath, hashBuffer);\n\n    const txRequestRound1 = await signBitgoMPCv2Round1(\n      bitgoSession,\n      reqMPCv2SigningRound1.txRequest as any,\n      resMPCv2SigningRound1.signatureShareRound1,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound1.transactions &&\n        txRequestRound1.transactions.length === 1 &&\n        txRequestRound1.transactions[0].signatureShares.length === 2\n    );\n\n    // round 2\n    const reqMPCv2SigningRound2 = {\n      ...reqMPCv2SigningRound1,\n      txRequest: txRequestRound1,\n      encryptedRound1Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoGpgKey.public,\n    };\n\n    const resMPCv2SigningRound2 = await ecdsaMPCv2Utils.createOfflineRound2Share(reqMPCv2SigningRound2 as any);\n    resMPCv2SigningRound2.should.have.property('signatureShareRound2');\n    resMPCv2SigningRound2.should.have.property('encryptedRound2Session');\n\n    const encryptedRound2Session = resMPCv2SigningRound2.encryptedRound2Session;\n\n    const { txRequest: txRequestRound2, bitgoMsg4 } = await signBitgoMPCv2Round2(\n      bitgoSession,\n      reqMPCv2SigningRound2.txRequest,\n      resMPCv2SigningRound2.signatureShareRound2,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n    assert.ok(\n      txRequestRound2.transactions &&\n        txRequestRound2.transactions.length === 1 &&\n        txRequestRound2.transactions[0].signatureShares.length === 4\n    );\n    bitgoMsg4.should.have.property('signatureR');\n\n    // round 3\n    const reqMPCv2SigningRound3 = {\n      ...reqMPCv2SigningRound2,\n      txRequest: txRequestRound2,\n      encryptedRound1Session: null,\n      encryptedRound2Session,\n    };\n\n    const resMPCv2SigningRound3 = await ecdsaMPCv2Utils.createOfflineRound3Share(reqMPCv2SigningRound3 as any);\n    resMPCv2SigningRound3.should.have.property('signatureShareRound3');\n\n    const { userMsg4 } = await signBitgoMPCv2Round3(\n      bitgoSession,\n      resMPCv2SigningRound3.signatureShareRound3,\n      resMPCv2SigningRound1.userGpgPubKey\n    );\n\n    assert.ok(userMsg4.data.msg4.signatureR === bitgoMsg4.signatureR, 'User and BitGo signaturesR do not match');\n\n    const deserializedBitgoMsg4 = DklsTypes.deserializeMessages({\n      p2pMessages: [],\n      broadcastMessages: [bitgoMsg4],\n    });\n\n    const deserializedUserMsg4 = DklsTypes.deserializeMessages({\n      p2pMessages: [],\n      broadcastMessages: [\n        {\n          from: userMsg4.data.msg4.from,\n          payload: userMsg4.data.msg4.message,\n        },\n      ],\n    });\n\n    const combinedSigUsingUtil = DklsUtils.combinePartialSignatures(\n      [deserializedUserMsg4.broadcastMessages[0].payload, deserializedBitgoMsg4.broadcastMessages[0].payload],\n      Buffer.from(userMsg4.data.msg4.signatureR, 'base64').toString('hex')\n    );\n\n    // Verify with shouldHash=true and keccak256 — standard EVM verification\n    const convertedSignature = DklsUtils.verifyAndConvertDklsSignature(\n      Buffer.from(signableHex, 'hex'),\n      combinedSigUsingUtil,\n      DklsTypes.getCommonKeychain(userShare),\n      derivationPath,\n      createKeccakHash('keccak256') as Hash\n    );\n    assert.ok(convertedSignature, 'EVM signature with serializedTxHex is not valid');\n    const sigParts = convertedSignature.split(':');\n    assert.strictEqual(sigParts.length, 4, 'Signature must be recid:R:S:pubkey format');\n    assert.strictEqual(sigParts[1].length, 64, 'Signature R must be 32 bytes hex');\n    assert.strictEqual(sigParts[2].length, 64, 'Signature S must be 32 bytes hex');\n  });\n\n  describe('createOfflineRound1Share and createOfflineRound2Share - encryptionVersion: 1 in v1 path', async () => {\n    let ecdsaMPCv2UtilsWithSpy: EcdsaMPCv2Utils;\n    let encryptAsyncSpy: sinon.SinonStub;\n\n    before(async () => {\n      const mockBg = {} as BitGoBase;\n      mockBg.getEnv = sinon.stub().returns('test');\n      const encryptImpl = (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      encryptAsyncSpy = sinon.stub().callsFake(async (params) => encryptImpl(params));\n      mockBg.encrypt = sinon.stub().callsFake(encryptImpl);\n      mockBg.encrypt = encryptAsyncSpy;\n      mockBg.decrypt = sinon.stub().callsFake((params) => sjcl.decrypt(params.password, params.input));\n      mockBg.decrypt = sinon.stub().callsFake(async (params) => sjcl.decrypt(params.password, params.input));\n\n      const mockCoin = {} as IBaseCoin;\n      mockCoin.getHashFunction = sinon.stub().callsFake(() => createKeccakHash('keccak256') as Hash);\n      mockCoin.isSignablePreHashed = (unsignedTx) => unsignedTx.serializedTxHex?.startsWith('0000') ?? false;\n      ecdsaMPCv2UtilsWithSpy = new EcdsaMPCv2Utils(mockBg, mockCoin);\n    });\n\n    it('createOfflineRound1Share uses encryptionVersion: 1 in v1 (non-v2 envelope) path', async () => {\n      const txRequest = {\n        txRequestId: 'req-id',\n        walletId: walletID,\n        transactions: [{ unsignedTx: { signableHex: 'deadbeef01', derivationPath: 'm/0', serializedTxHex: '' } }],\n        apiVersion: 'full',\n      } as any;\n\n      encryptAsyncSpy.resetHistory();\n\n      await ecdsaMPCv2UtilsWithSpy.createOfflineRound1Share({\n        txRequest,\n        prv: Buffer.from(userShare).toString('base64'),\n        walletPassphrase,\n        encryptedPrv: undefined,\n      });\n\n      assert.ok(encryptAsyncSpy.called, 'encrypt should be called in v1 path');\n      for (const call of encryptAsyncSpy.getCalls()) {\n        assert.strictEqual(\n          call.args[0].encryptionVersion,\n          1,\n          'encryptionVersion should be hardcoded to 1 in the v1 signing session path'\n        );\n      }\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\nfunction getUserPartyGpgKeyPublic(userPubKey: string): DklsTypes.PartyGpgKey {\n  return {\n    partyId: 0,\n    gpgKey: userPubKey,\n  };\n}\n\nfunction getBitGoPartyGpgKeyPrv(bitgoPrvKey: string): DklsTypes.PartyGpgKey {\n  return {\n    partyId: 2,\n    gpgKey: bitgoPrvKey,\n  };\n}\n\nasync function signBitgoMPCv2Round1(\n  bitgoSession: DklsDsg.Dsg,\n  txRequest: TxRequest,\n  userShare: SignatureShareRecord,\n  userGPGPubKey: string\n): Promise<TxRequest> {\n  assert.ok(\n    txRequest.transactions && txRequest.transactions.length === 1,\n    'txRequest.transactions is not an array of length 1'\n  );\n  txRequest.transactions[0].signatureShares.push(userShare);\n  // Do the actual signing on BitGo's side based on User's messages\n  const signatureShare = JSON.parse(userShare.share) as MPCv2SignatureShareRound1Input;\n  const deserializedMessages = DklsTypes.deserializeMessages({\n    p2pMessages: [],\n    broadcastMessages: [\n      {\n        from: signatureShare.data.msg1.from,\n        payload: signatureShare.data.msg1.message,\n      },\n    ],\n  });\n  const bitgoToUserRound1BroadcastMsg = await bitgoSession.init();\n  const bitgoToUserRound2Msg = bitgoSession.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: deserializedMessages.broadcastMessages,\n  });\n  const serializedBitGoToUserRound1And2Msgs = DklsTypes.serializeMessages({\n    p2pMessages: bitgoToUserRound2Msg.p2pMessages,\n    broadcastMessages: [bitgoToUserRound1BroadcastMsg],\n  });\n\n  const authEncMessages = await DklsComms.encryptAndAuthOutgoingMessages(\n    serializedBitGoToUserRound1And2Msgs,\n    [getUserPartyGpgKeyPublic(userGPGPubKey)],\n    [getBitGoPartyGpgKeyPrv(bitgoGpgKey.private)]\n  );\n\n  const bitgoToUserSignatureShare: MPCv2SignatureShareRound1Output = {\n    type: 'round1Output',\n    data: {\n      msg1: {\n        from: authEncMessages.broadcastMessages[0].from as MPCv2PartyFromStringOrNumber,\n        signature: authEncMessages.broadcastMessages[0].payload.signature,\n        message: authEncMessages.broadcastMessages[0].payload.message,\n      },\n      msg2: {\n        from: authEncMessages.p2pMessages[0].from as MPCv2PartyFromStringOrNumber,\n        to: authEncMessages.p2pMessages[0].to as MPCv2PartyFromStringOrNumber,\n        encryptedMessage: authEncMessages.p2pMessages[0].payload.encryptedMessage,\n        signature: authEncMessages.p2pMessages[0].payload.signature,\n      },\n    },\n  };\n  txRequest.transactions[0].signatureShares.push({\n    from: SignatureShareType.BITGO,\n    to: SignatureShareType.USER,\n    share: JSON.stringify(bitgoToUserSignatureShare),\n  });\n  return txRequest;\n}\n\nasync function signBitgoMPCv2Round2(\n  bitgoSession: DklsDsg.Dsg,\n  txRequest: TxRequest,\n  userShare: SignatureShareRecord,\n  userGPGPubKey: string\n): Promise<{ txRequest: TxRequest; bitgoMsg4: DklsTypes.SerializedBroadcastMessage }> {\n  assert.ok(\n    txRequest.transactions && txRequest.transactions.length === 1,\n    'txRequest.transactions is not an array of length 1'\n  );\n  txRequest.transactions[0].signatureShares.push(userShare);\n\n  // Do the actual signing on BitGo's side based on User's messages\n  const parsedSignatureShare = JSON.parse(userShare.share) as MPCv2SignatureShareRound2Input;\n  const serializedMessages = await DklsComms.decryptAndVerifyIncomingMessages(\n    {\n      p2pMessages: [\n        {\n          from: parsedSignatureShare.data.msg2.from,\n          to: parsedSignatureShare.data.msg2.to,\n          payload: {\n            encryptedMessage: parsedSignatureShare.data.msg2.encryptedMessage,\n            signature: parsedSignatureShare.data.msg2.signature,\n          },\n        },\n        {\n          from: parsedSignatureShare.data.msg3.from,\n          to: parsedSignatureShare.data.msg3.to,\n          payload: {\n            encryptedMessage: parsedSignatureShare.data.msg3.encryptedMessage,\n            signature: parsedSignatureShare.data.msg3.signature,\n          },\n        },\n      ],\n      broadcastMessages: [],\n    },\n    [getUserPartyGpgKeyPublic(userGPGPubKey)],\n    [getBitGoPartyGpgKeyPrv(bitgoGpgKey.private)]\n  );\n  const deserializedMessages2 = DklsTypes.deserializeMessages({\n    p2pMessages: [serializedMessages.p2pMessages[0]],\n    broadcastMessages: [],\n  });\n\n  const bitgoToUserRound3Msg = bitgoSession.handleIncomingMessages(deserializedMessages2);\n  const serializedBitGoToUserRound3Msgs = DklsTypes.serializeMessages(bitgoToUserRound3Msg);\n\n  const authEncMessages = await DklsComms.encryptAndAuthOutgoingMessages(\n    serializedBitGoToUserRound3Msgs,\n    [getUserPartyGpgKeyPublic(userGPGPubKey)],\n    [getBitGoPartyGpgKeyPrv(bitgoGpgKey.private)]\n  );\n\n  const bitgoToUserSignatureShare: MPCv2SignatureShareRound2Output = {\n    type: 'round2Output',\n    data: {\n      msg3: {\n        from: authEncMessages.p2pMessages[0].from as MPCv2PartyFromStringOrNumber,\n        to: authEncMessages.p2pMessages[0].to as MPCv2PartyFromStringOrNumber,\n        encryptedMessage: authEncMessages.p2pMessages[0].payload.encryptedMessage,\n        signature: authEncMessages.p2pMessages[0].payload.signature,\n      },\n    },\n  };\n\n  // handling user msg3 but not returning bitgo msg4 since its stored on bitgo side only\n  const deserializedMessages3 = DklsTypes.deserializeMessages({\n    p2pMessages: [serializedMessages.p2pMessages[1]],\n    broadcastMessages: [],\n  });\n  const deserializedBitgoMsg4 = bitgoSession.handleIncomingMessages(deserializedMessages3);\n  const serializedBitGoToUserRound4Msgs = DklsTypes.serializeMessages(deserializedBitgoMsg4);\n\n  txRequest.transactions[0].signatureShares.push({\n    from: SignatureShareType.BITGO,\n    to: SignatureShareType.USER,\n    share: JSON.stringify(bitgoToUserSignatureShare),\n  });\n  return { txRequest, bitgoMsg4: serializedBitGoToUserRound4Msgs.broadcastMessages[0] };\n}\n\nasync function signBitgoMPCv2Round3(\n  bitgoSession: DklsDsg.Dsg,\n  userShare: SignatureShareRecord,\n  userGPGPubKey: string\n): Promise<{ userMsg4: MPCv2SignatureShareRound3Input }> {\n  const parsedSignatureShare = JSON.parse(userShare.share) as MPCv2SignatureShareRound3Input;\n  const msg4 = parsedSignatureShare.data.msg4;\n  const signatureRAuthMessage =\n    msg4.signatureR && msg4.signatureRSignature\n      ? { message: msg4.signatureR, signature: msg4.signatureRSignature }\n      : undefined;\n  const serializedMessages = await DklsComms.decryptAndVerifyIncomingMessages(\n    {\n      p2pMessages: [],\n      broadcastMessages: [\n        {\n          from: msg4.from,\n          payload: {\n            message: msg4.message,\n            signature: msg4.signature,\n          },\n          signatureR: signatureRAuthMessage,\n        },\n      ],\n    },\n    [getUserPartyGpgKeyPublic(userGPGPubKey)],\n    [getBitGoPartyGpgKeyPrv(bitgoGpgKey.private)]\n  );\n  const deserializedMessages = DklsTypes.deserializeMessages({\n    p2pMessages: [],\n    broadcastMessages: [serializedMessages.broadcastMessages[0]],\n  });\n  bitgoSession.handleIncomingMessages(deserializedMessages);\n\n  return {\n    userMsg4: parsedSignatureShare,\n  };\n}\n\ndescribe('EcdsaMPCv2Utils.createKeychainsWithExternalSigner', function () {\n  let utils: EcdsaMPCv2Utils;\n  let callbacks: EcdsaMPCv2KeyGenCallbacks;\n  const enterprise = 'enterprise-id';\n  const sessionId = 'session-001';\n  const commonKeychain = 'common-keychain-abc';\n\n  const emptyMessages: DklsTypes.AuthEncMessages = { broadcastMessages: [], p2pMessages: [] };\n  const userState = { encryptedData: 'u-data', encryptedDataKey: 'u-data-key' };\n  const backupState = { encryptedData: 'b-data', encryptedDataKey: 'b-data-key' };\n  const bitgoMsg1: MPCv2BroadcastMessage = { from: 2, message: 'msg1', signature: 'sig1' };\n  const bitgoToUserMsg2: MPCv2P2PMessage = { from: 2, to: 0, encryptedMessage: 'u2', signature: 'su2' };\n  const bitgoToBackupMsg2: MPCv2P2PMessage = { from: 2, to: 1, encryptedMessage: 'b2', signature: 'sb2' };\n  const bitgoToUserMsg3: MPCv2P2PMessage = { from: 2, to: 0, encryptedMessage: 'u3', signature: 'su3' };\n  const bitgoToBackupMsg3: MPCv2P2PMessage = { from: 2, to: 1, encryptedMessage: 'b3', signature: 'sb3' };\n  const bitgoMsg4: MPCv2BroadcastMessage = { from: 2, message: 'msg4', signature: 'sig4' };\n\n  beforeEach(function () {\n    callbacks = {\n      initializeCallback: sinon.stub().resolves({\n        userGpgPublicKey: 'user-gpg-pub',\n        backupGpgPublicKey: 'backup-gpg-pub',\n        round1Messages: emptyMessages,\n        userState,\n        backupState,\n      }),\n      round2Callback: sinon.stub().resolves({ round2Messages: emptyMessages, userState, backupState }),\n      round3Callback: sinon.stub().resolves({ round3Messages: emptyMessages, userState, backupState }),\n      finalizeCallback: sinon.stub().resolves({ commonKeychain }),\n    };\n\n    const mockBitGo = {\n      getEnv: sinon.stub().returns('dev'),\n    } as any;\n\n    const mockKeychains = {\n      add: sinon\n        .stub()\n        .callsFake((params: any) => Promise.resolve({ id: `${params.source}-key-id`, commonKeychain, isMPCv2: true })),\n      createBitGo: sinon.stub().resolves({ id: 'bitgo-key-id', commonKeychain, isMPCv2: true }),\n    };\n\n    const mockCoin = {\n      keychains: sinon.stub().returns(mockKeychains),\n    } as any;\n\n    utils = new EcdsaMPCv2Utils(mockBitGo, mockCoin);\n\n    sinon.stub(utils, 'getBitgoGpgPubkeyBasedOnFeatureFlags' as any).resolves({ mpcv2PublicKey: null });\n    (utils as any).bitgoMPCv2PublicGpgKey = { armor: () => '-----BEGIN PGP PUBLIC KEY BLOCK-----\\n' };\n\n    sinon.stub(utils, 'sendKeyGenerationRound1').resolves({\n      sessionId: sessionId as any,\n      walletGpgPubKeySigs: 'sigs' as any,\n      bitgoMsg1,\n      bitgoToUserMsg2,\n      bitgoToBackupMsg2,\n    });\n    sinon.stub(utils, 'sendKeyGenerationRound2').resolves({\n      sessionId: sessionId as any,\n      bitgoCommitment2: 'commitment2' as any,\n      bitgoToUserMsg3,\n      bitgoToBackupMsg3,\n    });\n    sinon.stub(utils, 'sendKeyGenerationRound3').resolves({\n      sessionId: sessionId as any,\n      bitgoMsg4,\n      commonKeychain: commonKeychain as any,\n    });\n    sinon.stub(utils as any, 'addBitgoKeychain').resolves({ id: 'bitgo-key-id', commonKeychain, isMPCv2: true });\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('should invoke callbacks in order and return keychains', async function () {\n    const keychains = await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    assert.ok(keychains.userKeychain);\n    assert.ok(keychains.backupKeychain);\n    assert.ok(keychains.bitgoKeychain);\n\n    sinon.assert.calledOnce(callbacks.initializeCallback as sinon.SinonStub);\n    sinon.assert.calledOnce(callbacks.round2Callback as sinon.SinonStub);\n    sinon.assert.calledOnce(callbacks.round3Callback as sinon.SinonStub);\n    sinon.assert.calledOnce(callbacks.finalizeCallback as sinon.SinonStub);\n  });\n\n  it('should pass round1 response and state to round2Callback', async function () {\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    const round2Args = (callbacks.round2Callback as sinon.SinonStub).firstCall.args[0];\n    assert.strictEqual(round2Args.sessionId, sessionId);\n    assert.deepStrictEqual(round2Args.bitgoMsg1, bitgoMsg1);\n    assert.deepStrictEqual(round2Args.bitgoToUserMsg2, bitgoToUserMsg2);\n    assert.deepStrictEqual(round2Args.bitgoToBackupMsg2, bitgoToBackupMsg2);\n    assert.deepStrictEqual(round2Args.userState, userState);\n    assert.deepStrictEqual(round2Args.backupState, backupState);\n  });\n\n  it('should pass round2 response and threaded state to round3Callback', async function () {\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    const round3Args = (callbacks.round3Callback as sinon.SinonStub).firstCall.args[0];\n    assert.strictEqual(round3Args.sessionId, sessionId);\n    assert.strictEqual(round3Args.bitgoCommitment2, 'commitment2');\n    assert.deepStrictEqual(round3Args.bitgoToUserMsg3, bitgoToUserMsg3);\n    assert.deepStrictEqual(round3Args.bitgoToBackupMsg3, bitgoToBackupMsg3);\n    assert.deepStrictEqual(round3Args.userState, userState);\n    assert.deepStrictEqual(round3Args.backupState, backupState);\n  });\n\n  it('should pass round3 response and bitgoCommonKeychain to finalizeCallback', async function () {\n    await utils.createKeychainsWithExternalSigner({ enterprise, callbacks });\n\n    const finalizeArgs = (callbacks.finalizeCallback as sinon.SinonStub).firstCall.args[0];\n    assert.strictEqual(finalizeArgs.sessionId, sessionId);\n    assert.deepStrictEqual(finalizeArgs.bitgoMsg4, bitgoMsg4);\n    assert.strictEqual(finalizeArgs.bitgoCommonKeychain, commonKeychain);\n    assert.deepStrictEqual(finalizeArgs.userState, userState);\n    assert.deepStrictEqual(finalizeArgs.backupState, backupState);\n  });\n\n  it('should reject when finalizeCallback returns mismatched commonKeychain', async function () {\n    (callbacks.finalizeCallback as sinon.SinonStub).resolves({ commonKeychain: 'different-keychain' });\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /Common keychains do not match/\n    );\n  });\n\n  it('should reject when round2 returns mismatched sessionId', async function () {\n    (utils.sendKeyGenerationRound2 as sinon.SinonStub).resolves({\n      sessionId: 'different-session' as any,\n      bitgoCommitment2: 'commitment2' as any,\n      bitgoToUserMsg3,\n      bitgoToBackupMsg3,\n    });\n\n    await assert.rejects(\n      () => utils.createKeychainsWithExternalSigner({ enterprise, callbacks }),\n      /Session ID mismatch after round 2/\n    );\n  });\n});\n\ndescribe('signRequestBase message finalization', () => {\n  let sandbox: sinon.SinonSandbox;\n\n  beforeEach(() => {\n    sandbox = sinon.createSandbox();\n  });\n\n  afterEach(() => {\n    sandbox.restore();\n  });\n\n  const walletID = '62fe536a6b4cf70007acb48c0e7bb0b0';\n  const fakeReqId = { inc: sinon.stub(), toString: sinon.stub().returns('test-req') } as unknown as RequestTracer;\n\n  let userShare: Buffer;\n  let bitgoKeyShare: Buffer;\n  before('generate key shares for finalization tests', async () => {\n    const [userDkgSession, , bitgoDkgSession] = await DklsUtils.generateDKGKeyShares();\n    userShare = userDkgSession.getKeyShare();\n    bitgoKeyShare = bitgoDkgSession.getKeyShare();\n  });\n\n  /**\n   * Drives signRequestBase through the REAL DKLS protocol: the user-side DSG\n   * session is the one the class builds itself; the BitGo-side session is a\n   * real DSG advanced by this test's mocked HTTP layer on every /sign POST,\n   * using the signBitgoMPCv2RoundX helpers. Only the HTTP transport is faked\n   * (bitgo.get / bitgo.post chains), which is exactly the surface the\n   * finalization-tail decision acts on: GET txrequests vs POST /send.\n   */\n  const runFullSigningFlow = async (params: { requestType: 'tx' | 'message'; txRequest: TxRequest }) => {\n    const postedUrls: string[] = [];\n    const getUrls: string[] = [];\n    const hashBuffer = Buffer.alloc(32, 1);\n    const derivationPath = 'm/0';\n\n    // The BitGo-side session signs the same hash buffer the user session is\n    // given via the getMpcv2HashBuffer stub below.\n    const bitgoSession = new DklsDsg.Dsg(bitgoKeyShare, 2, derivationPath, hashBuffer);\n\n    // Carrier shaped for the signBitgoMPCv2RoundX helpers, which index\n    // transactions[0]; the response is remapped back to the real resource.\n    const carrier = { transactions: [{ signatureShares: [] }] } as unknown as TxRequest;\n    let signPostCount = 0;\n\n    const mockBg = {\n      getEnv: () => 'test',\n      setRequestTracer: () => undefined,\n      url: (p: string) => p,\n      get: (url: string) => ({\n        query() {\n          return this;\n        },\n        retry() {\n          return this;\n        },\n        async result() {\n          getUrls.push(url);\n          return {\n            txRequests: [\n              {\n                ...params.txRequest,\n                state: 'delivered',\n                [params.requestType === 'message' ? 'messages' : 'transactions']: [\n                  {\n                    state: 'signed',\n                    txHash: '0xsigned-message-hash',\n                    signatureShares: [],\n                    ...(params.requestType === 'tx'\n                      ? { unsignedTx: { derivationPath, signableHex: 'abcd', serializedTxHex: 'abcd' } }\n                      : {}),\n                  },\n                ],\n              },\n            ],\n          };\n        },\n      }),\n      post: (url: string) => {\n        postedUrls.push(url);\n        return {\n          _body: undefined as unknown,\n          send(body?: unknown) {\n            this._body = body;\n            return this;\n          },\n          async result() {\n            if (!url.endsWith('/sign')) {\n              return { ...params.txRequest, state: 'delivered' };\n            }\n            signPostCount += 1;\n            const body = this._body as { signatureShares: SignatureShareRecord[]; signerGpgPublicKey: string };\n            const userShareRecord = body.signatureShares[0];\n            if (signPostCount === 1) {\n              await signBitgoMPCv2Round1(bitgoSession, carrier, userShareRecord, body.signerGpgPublicKey);\n            } else if (signPostCount === 2) {\n              await signBitgoMPCv2Round2(bitgoSession, carrier, userShareRecord, body.signerGpgPublicKey);\n            } else {\n              await signBitgoMPCv2Round3(bitgoSession, userShareRecord, body.signerGpgPublicKey);\n            }\n            const shares = carrier.transactions![0].signatureShares;\n            return {\n              ...params.txRequest,\n              [params.requestType === 'message' ? 'messages' : 'transactions']: [{ signatureShares: shares }],\n            } as unknown as TxRequest;\n          },\n        };\n      },\n    } as unknown as BitGoBase;\n\n    const mockCoin = {\n      getMPCAlgorithm: () => 'ecdsa',\n      verifyTransaction: () => Promise.resolve(true),\n      getConfig: () => ({ family: 'eth' }),\n    } as unknown as IBaseCoin;\n    const mockWallet = {\n      id: () => walletID,\n      multisigType: () => 'tss',\n      multisigTypeVersion: () => 'MPCv2',\n    };\n    const utils = new EcdsaMPCv2Utils(mockBg, mockCoin, mockWallet as never);\n    sandbox\n      .stub(utils as unknown as Record<string, unknown>, 'pickBitgoPubGpgKeyForSigning')\n      .resolves(await openpgp.readKey({ armoredKey: bitgoGpgKey.public }));\n    sandbox.stub(utils as unknown as Record<string, unknown>, 'getMpcv2HashBuffer').returns(hashBuffer);\n\n    const baseParams = {\n      txRequest: params.txRequest,\n      prv: userShare.toString('base64'),\n      reqId: fakeReqId,\n    };\n    const result =\n      params.requestType === 'message'\n        ? await utils.signTxRequestForMessage({\n            ...baseParams,\n            messageRaw: 'raw',\n            messageEncoded: 'abcd',\n            bufferToSign: Buffer.from('abcd', 'hex'),\n          })\n        : await utils.signTxRequest({\n            ...baseParams,\n            txParams: { recipients: [{ address: '0x' + '00'.repeat(20), amount: '1000' }] },\n          });\n\n    return { result, postedUrls, getUrls };\n  };\n\n  it('message requests finalize via GET (wallet-platform delivers at share ingestion), never POST /send', async () => {\n    const txRequestId = 'msg-txreq-finalization';\n    const { result, postedUrls, getUrls } = await runFullSigningFlow({\n      requestType: 'message',\n      txRequest: {\n        txRequestId,\n        walletId: walletID,\n        apiVersion: 'full',\n        state: 'pendingDelivery',\n        messages: [{ messageRaw: 'raw', messageEncoded: 'abcd', derivationPath: 'm/0' }],\n      } as unknown as TxRequest,\n    });\n\n    assert.strictEqual(result.state, 'delivered');\n    assert.strictEqual(\n      postedUrls.filter((url) => url.endsWith('/send')).length,\n      0,\n      'message signing must not POST /send (wallet-platform already delivered at share ingestion)'\n    );\n    assert.ok(\n      postedUrls.every((url) => url.includes(`/txrequests/${txRequestId}/messages/0/sign`)),\n      'all message POSTs must be share submissions'\n    );\n    // The park-check GET is skipped (object txRequest) so the only GET is the\n    // final re-fetch.\n    assert.strictEqual(getUrls.length, 1);\n    assert.ok(getUrls[0].includes('/txrequests'));\n  });\n\n  it('transaction requests still finalize via POST /send', async () => {\n    const txRequestId = 'tx-txreq-finalization';\n    const { result, postedUrls } = await runFullSigningFlow({\n      requestType: 'tx',\n      txRequest: {\n        txRequestId,\n        walletId: walletID,\n        apiVersion: 'full',\n        state: 'pendingDelivery',\n        transactions: [\n          {\n            unsignedTx: { derivationPath: 'm/0', signableHex: 'abcd', serializedTxHex: 'abcd' },\n            signatureShares: [],\n          },\n        ],\n      } as unknown as TxRequest,\n    });\n\n    assert.strictEqual(result.state, 'delivered');\n    assert.strictEqual(\n      postedUrls.filter((url) => url.endsWith('/transactions/0/send')).length,\n      1,\n      'transaction signing must POST /send to broadcast'\n    );\n  });\n});\n"]}