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

package/dist/test/unit/bitgo/tss/redpallas/redpallasMPCv2.js

@@ -0,0 +1,370 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const pgp = __importStar(require("openpgp"));
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const public_types_1 = require("@bitgo/public-types");
+const src_1 = require("../../../../../src");
+const redpallasMPCv2_1 = require("../../../../../src/bitgo/tss/redpallas/redpallasMPCv2");
+const codecs_1 = require("../../../../../src/bitgo/utils/codecs");
+const opengpgUtils_1 = require("../../../../../src/bitgo/utils/opengpgUtils");
+const typesMPCv2_1 = require("../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2");
+/** N distinct spend payloads for one round, spend-index order baked into the bytes. */
+const payloads = (party, round, n) => Array.from({ length: n }, (_, spendIndex) => ({
+    from: party,
+    payload: new Uint8Array(Buffer.from(`${party}-round-${round}-spend-${spendIndex}-payload`)),
+}));
+const TAMPERED_SIGNATURE = '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n';
+const tamperedMessage = () => ({
+    message: Buffer.from('tampered').toString('base64'),
+    signature: TAMPERED_SIGNATURE,
+});
+describe('RedPallas MPS DSG helper functions', function () {
+    let userGpgPrivKey;
+    let backupGpgPrivKey;
+    let bitgoGpgPrivKey;
+    let bitgoGpgPubKey;
+    before('generate GPG key pairs', async function () {
+        const userGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const backupGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        const bitgoGpgKeyPair = await (0, opengpgUtils_1.generateGPGKeyPair)('ed25519');
+        userGpgPrivKey = await pgp.readPrivateKey({ armoredKey: userGpgKeyPair.privateKey });
+        backupGpgPrivKey = await pgp.readPrivateKey({ armoredKey: backupGpgKeyPair.privateKey });
+        bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });
+        bitgoGpgPubKey = await pgp.readKey({ armoredKey: bitgoGpgKeyPair.publicKey });
+    });
+    // ── Round 1 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundOne should build a valid N=1 round-1 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundOne)(payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 1, 1), userGpgPrivKey);
+        assert.strictEqual(share.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound1Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound1Input');
+        assert.strictEqual(parsed.type, 'round1Input');
+        assert.strictEqual(parsed.data.msg1.length, 1);
+        assert.ok(parsed.data.msg1[0].message, 'msg1[0].message should be set');
+        assert.ok(parsed.data.msg1[0].signature, 'msg1[0].signature should be set');
+    });
+    it('getSignatureShareRoundOne should build a valid N=1 round-1 share for the backup', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundOne)(payloads(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, 1, 1), backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+    });
+    it('getSignatureShareRoundOne N=3 should decode and preserve spend order', async function () {
+        const userMsg1s = payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 1, 3);
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundOne)(userMsg1s, userGpgPrivKey);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound1Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound1Input');
+        assert.strictEqual(parsed.data.msg1.length, 3);
+        const userGpgPubKey = userGpgPrivKey.toPublic();
+        for (const [spendIndex, signedMsg1] of parsed.data.msg1.entries()) {
+            const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg1, userGpgPubKey);
+            assert.deepStrictEqual(rawBytes, Buffer.from(userMsg1s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        }
+    });
+    it('getSignatureShareRoundOne should reject an empty message array', async function () {
+        await assert.rejects((0, redpallasMPCv2_1.getSignatureShareRoundOne)([], userGpgPrivKey), /Expected at least 1 round-1 message/);
+    });
+    it('verifyPeerMessageRoundOne should verify valid N=3 BitGo round-1 messages in order', async function () {
+        const bitgoMsg1s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 1, 3);
+        const signedMsg1s = await Promise.all(bitgoMsg1s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: signedMsg1s },
+        };
+        const results = await (0, redpallasMPCv2_1.verifyPeerMessageRoundOne)(round1Output, bitgoGpgPubKey);
+        assert.strictEqual(results.length, 3);
+        results.forEach((result, spendIndex) => {
+            assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+            assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoMsg1s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        });
+    });
+    it('verifyPeerMessageRoundOne should fail the whole N=3 round when one spend signature is bad', async function () {
+        const bitgoMsg1s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 1, 3);
+        const signedMsg1s = await Promise.all(bitgoMsg1s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        signedMsg1s[1] = tamperedMessage();
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: signedMsg1s },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundOne)(round1Output, bitgoGpgPubKey));
+    });
+    it('verifyPeerMessageRoundOne should throw on a tampered round-1 message', async function () {
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: [tamperedMessage()] },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundOne)(round1Output, bitgoGpgPubKey));
+    });
+    // ── Round 2 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundTwo should build a valid N=1 round-2 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundTwo)(payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 2, 1), userGpgPrivKey);
+        assert.strictEqual(share.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound2Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound2Input');
+        assert.strictEqual(parsed.type, 'round2Input');
+        assert.strictEqual(parsed.data.msg2.length, 1);
+        assert.ok(parsed.data.msg2[0].message, 'msg2[0].message should be set');
+        assert.ok(parsed.data.msg2[0].signature, 'msg2[0].signature should be set');
+    });
+    it('getSignatureShareRoundTwo N=3 should decode and preserve spend order', async function () {
+        const userMsg2s = payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 2, 3);
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundTwo)(userMsg2s, userGpgPrivKey);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound2Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound2Input');
+        assert.strictEqual(parsed.data.msg2.length, 3);
+        const userGpgPubKey = userGpgPrivKey.toPublic();
+        for (const [spendIndex, signedMsg2] of parsed.data.msg2.entries()) {
+            const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg2, userGpgPubKey);
+            assert.deepStrictEqual(rawBytes, Buffer.from(userMsg2s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        }
+    });
+    it('getSignatureShareRoundTwo should reject an empty message array', async function () {
+        await assert.rejects((0, redpallasMPCv2_1.getSignatureShareRoundTwo)([], userGpgPrivKey), /Expected at least 1 round-2 message/);
+    });
+    it('verifyPeerMessageRoundTwo should verify valid N=3 BitGo round-2 messages in order', async function () {
+        const bitgoMsg2s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 2, 3);
+        const signedMsg2s = await Promise.all(bitgoMsg2s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: signedMsg2s },
+        };
+        const results = await (0, redpallasMPCv2_1.verifyPeerMessageRoundTwo)(round2Output, bitgoGpgPubKey);
+        assert.strictEqual(results.length, 3);
+        results.forEach((result, spendIndex) => {
+            assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+            assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoMsg2s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        });
+    });
+    it('verifyPeerMessageRoundTwo should fail the whole N=3 round when one spend signature is bad', async function () {
+        const bitgoMsg2s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 2, 3);
+        const signedMsg2s = await Promise.all(bitgoMsg2s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        signedMsg2s[2] = tamperedMessage();
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: signedMsg2s },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundTwo)(round2Output, bitgoGpgPubKey));
+    });
+    it('verifyPeerMessageRoundTwo should throw on a tampered round-2 message', async function () {
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: [tamperedMessage()] },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundTwo)(round2Output, bitgoGpgPubKey));
+    });
+    // ── Round 3 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundThree should build a valid N=1 round-3 share for the backup', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundThree)(payloads(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, 3, 1), backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound3Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound3Input');
+        assert.strictEqual(parsed.type, 'round3Input');
+        assert.strictEqual(parsed.data.msg3.length, 1);
+        assert.ok(parsed.data.msg3[0].message, 'msg3[0].message should be set');
+        assert.ok(parsed.data.msg3[0].signature, 'msg3[0].signature should be set');
+    });
+    it('getSignatureShareRoundThree N=3 should decode and preserve spend order', async function () {
+        const userMsg3s = payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 3, 3);
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundThree)(userMsg3s, userGpgPrivKey);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound3Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound3Input');
+        assert.strictEqual(parsed.data.msg3.length, 3);
+        const userGpgPubKey = userGpgPrivKey.toPublic();
+        for (const [spendIndex, signedMsg3] of parsed.data.msg3.entries()) {
+            const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg3, userGpgPubKey);
+            assert.deepStrictEqual(rawBytes, Buffer.from(userMsg3s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        }
+    });
+    it('getSignatureShareRoundThree should reject an empty message array', async function () {
+        await assert.rejects((0, redpallasMPCv2_1.getSignatureShareRoundThree)([], userGpgPrivKey), /Expected at least 1 round-3 message/);
+    });
+    it('verifyPeerMessageRoundThree should verify valid N=3 BitGo round-3 messages in order', async function () {
+        const bitgoMsg3s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 3, 3);
+        const signedMsg3s = await Promise.all(bitgoMsg3s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        const round3Output = {
+            type: 'round3Output',
+            data: { msg3: signedMsg3s },
+        };
+        const results = await (0, redpallasMPCv2_1.verifyPeerMessageRoundThree)(round3Output, bitgoGpgPubKey);
+        assert.strictEqual(results.length, 3);
+        results.forEach((result, spendIndex) => {
+            assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+            assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoMsg3s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        });
+    });
+    it('verifyPeerMessageRoundThree should fail the whole N=3 round when one spend signature is bad', async function () {
+        const bitgoMsg3s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 3, 3);
+        const signedMsg3s = await Promise.all(bitgoMsg3s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        signedMsg3s[0] = tamperedMessage();
+        const round3Output = {
+            type: 'round3Output',
+            data: { msg3: signedMsg3s },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundThree)(round3Output, bitgoGpgPubKey));
+    });
+    it('verifyPeerMessageRoundThree should throw on a tampered round-3 message', async function () {
+        const round3Output = {
+            type: 'round3Output',
+            data: { msg3: [tamperedMessage()] },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundThree)(round3Output, bitgoGpgPubKey));
+    });
+    // ── Rerand (must run before every DSG, same 2 parties, once per spend) ──────
+    it('getRerandShareRoundOne should build a valid N=1 rerand round-1 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundOne)(payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 1, 1), userGpgPrivKey);
+        assert.strictEqual(share.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2RerandShareRound1Input, JSON.parse(share.share), 'RedpallasMPCv2RerandShareRound1Input');
+        assert.strictEqual(parsed.type, 'round1Input');
+        assert.strictEqual(parsed.data.msg1.length, 1);
+        assert.ok(parsed.data.msg1[0].message, 'msg1[0].message should be set');
+        assert.ok(parsed.data.msg1[0].signature, 'msg1[0].signature should be set');
+    });
+    it('getRerandShareRoundOne should build a valid N=1 rerand round-1 share for the backup', async function () {
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundOne)(payloads(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, 1, 1), backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+    });
+    it('getRerandShareRoundOne N=3 should decode and preserve spend order', async function () {
+        const userMsg1s = payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 1, 3);
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundOne)(userMsg1s, userGpgPrivKey);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2RerandShareRound1Input, JSON.parse(share.share), 'RedpallasMPCv2RerandShareRound1Input');
+        assert.strictEqual(parsed.data.msg1.length, 3);
+        const userGpgPubKey = userGpgPrivKey.toPublic();
+        for (const [spendIndex, signedMsg1] of parsed.data.msg1.entries()) {
+            const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg1, userGpgPubKey);
+            assert.deepStrictEqual(rawBytes, Buffer.from(userMsg1s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        }
+    });
+    it('getRerandShareRoundOne should reject an empty message array', async function () {
+        await assert.rejects((0, redpallasMPCv2_1.getRerandShareRoundOne)([], userGpgPrivKey), /Expected at least 1 rerand round-1 message/);
+    });
+    it('verifyPeerRerandMessageRoundOne should verify valid N=3 BitGo rerand round-1 messages in order', async function () {
+        const bitgoMsg1s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 1, 3);
+        const signedMsg1s = await Promise.all(bitgoMsg1s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: signedMsg1s },
+        };
+        const results = await (0, redpallasMPCv2_1.verifyPeerRerandMessageRoundOne)(round1Output, bitgoGpgPubKey);
+        assert.strictEqual(results.length, 3);
+        results.forEach((result, spendIndex) => {
+            assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+            assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoMsg1s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        });
+    });
+    it('verifyPeerRerandMessageRoundOne should fail the whole N=3 round when one spend signature is bad', async function () {
+        const bitgoMsg1s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 1, 3);
+        const signedMsg1s = await Promise.all(bitgoMsg1s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        signedMsg1s[1] = tamperedMessage();
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: signedMsg1s },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerRerandMessageRoundOne)(round1Output, bitgoGpgPubKey));
+    });
+    it('verifyPeerRerandMessageRoundOne should throw on a tampered rerand round-1 message', async function () {
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: [tamperedMessage()] },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerRerandMessageRoundOne)(round1Output, bitgoGpgPubKey));
+    });
+    it('getRerandShareRoundTwo should build a valid N=1 rerand round-2 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundTwo)(payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 2, 1), userGpgPrivKey);
+        assert.strictEqual(share.from, src_1.SignatureShareType.USER);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2RerandShareRound2Input, JSON.parse(share.share), 'RedpallasMPCv2RerandShareRound2Input');
+        assert.strictEqual(parsed.type, 'round2Input');
+        assert.strictEqual(parsed.data.msg2.length, 1);
+        assert.ok(parsed.data.msg2[0].message, 'msg2[0].message should be set');
+        assert.ok(parsed.data.msg2[0].signature, 'msg2[0].signature should be set');
+    });
+    it('getRerandShareRoundTwo N=3 should decode and preserve spend order', async function () {
+        const userMsg2s = payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 2, 3);
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundTwo)(userMsg2s, userGpgPrivKey);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2RerandShareRound2Input, JSON.parse(share.share), 'RedpallasMPCv2RerandShareRound2Input');
+        assert.strictEqual(parsed.data.msg2.length, 3);
+        const userGpgPubKey = userGpgPrivKey.toPublic();
+        for (const [spendIndex, signedMsg2] of parsed.data.msg2.entries()) {
+            const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg2, userGpgPubKey);
+            assert.deepStrictEqual(rawBytes, Buffer.from(userMsg2s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        }
+    });
+    it('getRerandShareRoundTwo should reject an empty message array', async function () {
+        await assert.rejects((0, redpallasMPCv2_1.getRerandShareRoundTwo)([], userGpgPrivKey), /Expected at least 1 rerand round-2 message/);
+    });
+    it('verifyPeerRerandMessageRoundTwo should verify valid N=3 BitGo rerand round-2 messages in order', async function () {
+        const bitgoMsg2s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 2, 3);
+        const signedMsg2s = await Promise.all(bitgoMsg2s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: signedMsg2s },
+        };
+        const results = await (0, redpallasMPCv2_1.verifyPeerRerandMessageRoundTwo)(round2Output, bitgoGpgPubKey);
+        assert.strictEqual(results.length, 3);
+        results.forEach((result, spendIndex) => {
+            assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+            assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoMsg2s[spendIndex].payload), `spend ${spendIndex} out of order`);
+        });
+    });
+    it('verifyPeerRerandMessageRoundTwo should fail the whole N=3 round when one spend signature is bad', async function () {
+        const bitgoMsg2s = payloads(typesMPCv2_1.MPCv2PartiesEnum.BITGO, 2, 3);
+        const signedMsg2s = await Promise.all(bitgoMsg2s.map((msg) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey)));
+        signedMsg2s[2] = tamperedMessage();
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: signedMsg2s },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerRerandMessageRoundTwo)(round2Output, bitgoGpgPubKey));
+    });
+    it('verifyPeerRerandMessageRoundTwo should throw on a tampered rerand round-2 message', async function () {
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: [tamperedMessage()] },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerRerandMessageRoundTwo)(round2Output, bitgoGpgPubKey));
+    });
+    // ── Envelope round-trip via the independent RedPallas MPS comms layer ───────
+    it('N=3 shares built by getSignatureShareRoundOne verify against RedPallasMPSComms directly', async function () {
+        const userMsg1s = payloads(typesMPCv2_1.MPCv2PartiesEnum.USER, 1, 3);
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundOne)(userMsg1s, userGpgPrivKey);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound1Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound1Input');
+        const userGpgPubKey = userGpgPrivKey.toPublic();
+        for (const [spendIndex, signedMsg1] of parsed.data.msg1.entries()) {
+            const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg1, userGpgPubKey);
+            assert.deepStrictEqual(rawBytes, Buffer.from(userMsg1s[spendIndex].payload));
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redpallasMPCv2.js","sourceRoot":"","sources":["../../../../../../test/unit/bitgo/tss/redpallas/redpallasMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport * as pgp from 'openpgp';\nimport { RedPallasMPSComms, RedPallasMPSTypes } from '@bitgo-beta/sdk-lib-mpc';\nimport {\n  RedpallasMPCv2RerandShareRound1Input,\n  RedpallasMPCv2RerandShareRound1Output,\n  RedpallasMPCv2RerandShareRound2Input,\n  RedpallasMPCv2RerandShareRound2Output,\n  RedpallasMPCv2SignatureShareRound1Input,\n  RedpallasMPCv2SignatureShareRound1Output,\n  RedpallasMPCv2SignatureShareRound2Input,\n  RedpallasMPCv2SignatureShareRound2Output,\n  RedpallasMPCv2SignatureShareRound3Input,\n  RedpallasMPCv2SignatureShareRound3Output,\n} from '@bitgo/public-types';\nimport { SignatureShareRecord, SignatureShareType } from '../../../../../src';\nimport {\n  getRerandShareRoundOne,\n  getRerandShareRoundTwo,\n  getSignatureShareRoundOne,\n  getSignatureShareRoundTwo,\n  getSignatureShareRoundThree,\n  verifyPeerRerandMessageRoundOne,\n  verifyPeerRerandMessageRoundTwo,\n  verifyPeerMessageRoundOne,\n  verifyPeerMessageRoundTwo,\n  verifyPeerMessageRoundThree,\n} from '../../../../../src/bitgo/tss/redpallas/redpallasMPCv2';\nimport { decodeWithCodec } from '../../../../../src/bitgo/utils/codecs';\nimport { generateGPGKeyPair } from '../../../../../src/bitgo/utils/opengpgUtils';\nimport { MPCv2PartiesEnum } from '../../../../../src/bitgo/utils/tss/ecdsa/typesMPCv2';\n\n/** N distinct spend payloads for one round, spend-index order baked into the bytes. */\nconst payloads = (party: MPCv2PartiesEnum, round: number, n: number): RedPallasMPSTypes.DeserializedMessage[] =>\n  Array.from({ length: n }, (_, spendIndex) => ({\n    from: party,\n    payload: new Uint8Array(Buffer.from(`${party}-round-${round}-spend-${spendIndex}-payload`)),\n  }));\n\nconst TAMPERED_SIGNATURE = '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n';\n\nconst tamperedMessage = () => ({\n  message: Buffer.from('tampered').toString('base64'),\n  signature: TAMPERED_SIGNATURE,\n});\n\ndescribe('RedPallas MPS DSG helper functions', function () {\n  let userGpgPrivKey: pgp.PrivateKey;\n  let backupGpgPrivKey: pgp.PrivateKey;\n  let bitgoGpgPrivKey: pgp.PrivateKey;\n  let bitgoGpgPubKey: pgp.Key;\n\n  before('generate GPG key pairs', async function () {\n    const userGpgKeyPair = await generateGPGKeyPair('ed25519');\n    const backupGpgKeyPair = await generateGPGKeyPair('ed25519');\n    const bitgoGpgKeyPair = await generateGPGKeyPair('ed25519');\n\n    userGpgPrivKey = await pgp.readPrivateKey({ armoredKey: userGpgKeyPair.privateKey });\n    backupGpgPrivKey = await pgp.readPrivateKey({ armoredKey: backupGpgKeyPair.privateKey });\n    bitgoGpgPrivKey = await pgp.readPrivateKey({ armoredKey: bitgoGpgKeyPair.privateKey });\n    bitgoGpgPubKey = await pgp.readKey({ armoredKey: bitgoGpgKeyPair.publicKey });\n  });\n\n  // ── Round 1 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundOne should build a valid N=1 round-1 share for the user', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundOne(\n      payloads(MPCv2PartiesEnum.USER, 1, 1),\n      userGpgPrivKey\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.USER);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound1Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound1Input'\n    );\n    assert.strictEqual(parsed.type, 'round1Input');\n    assert.strictEqual(parsed.data.msg1.length, 1);\n    assert.ok(parsed.data.msg1[0].message, 'msg1[0].message should be set');\n    assert.ok(parsed.data.msg1[0].signature, 'msg1[0].signature should be set');\n  });\n\n  it('getSignatureShareRoundOne should build a valid N=1 round-1 share for the backup', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundOne(\n      payloads(MPCv2PartiesEnum.BACKUP, 1, 1),\n      backupGpgPrivKey,\n      MPCv2PartiesEnum.BACKUP\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.BACKUP);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n  });\n\n  it('getSignatureShareRoundOne N=3 should decode and preserve spend order', async function () {\n    const userMsg1s = payloads(MPCv2PartiesEnum.USER, 1, 3);\n    const share: SignatureShareRecord = await getSignatureShareRoundOne(userMsg1s, userGpgPrivKey);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound1Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound1Input'\n    );\n    assert.strictEqual(parsed.data.msg1.length, 3);\n\n    const userGpgPubKey = userGpgPrivKey.toPublic();\n    for (const [spendIndex, signedMsg1] of parsed.data.msg1.entries()) {\n      const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg1, userGpgPubKey);\n      assert.deepStrictEqual(rawBytes, Buffer.from(userMsg1s[spendIndex].payload), `spend ${spendIndex} out of order`);\n    }\n  });\n\n  it('getSignatureShareRoundOne should reject an empty message array', async function () {\n    await assert.rejects(getSignatureShareRoundOne([], userGpgPrivKey), /Expected at least 1 round-1 message/);\n  });\n\n  it('verifyPeerMessageRoundOne should verify valid N=3 BitGo round-1 messages in order', async function () {\n    const bitgoMsg1s = payloads(MPCv2PartiesEnum.BITGO, 1, 3);\n    const signedMsg1s = await Promise.all(\n      bitgoMsg1s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    const round1Output: RedpallasMPCv2SignatureShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: signedMsg1s },\n    };\n\n    const results = await verifyPeerMessageRoundOne(round1Output, bitgoGpgPubKey);\n\n    assert.strictEqual(results.length, 3);\n    results.forEach((result, spendIndex) => {\n      assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n      assert.deepStrictEqual(\n        Buffer.from(result.payload),\n        Buffer.from(bitgoMsg1s[spendIndex].payload),\n        `spend ${spendIndex} out of order`\n      );\n    });\n  });\n\n  it('verifyPeerMessageRoundOne should fail the whole N=3 round when one spend signature is bad', async function () {\n    const bitgoMsg1s = payloads(MPCv2PartiesEnum.BITGO, 1, 3);\n    const signedMsg1s = await Promise.all(\n      bitgoMsg1s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    signedMsg1s[1] = tamperedMessage();\n    const round1Output: RedpallasMPCv2SignatureShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: signedMsg1s },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundOne(round1Output, bitgoGpgPubKey));\n  });\n\n  it('verifyPeerMessageRoundOne should throw on a tampered round-1 message', async function () {\n    const round1Output: RedpallasMPCv2SignatureShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: [tamperedMessage()] },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundOne(round1Output, bitgoGpgPubKey));\n  });\n\n  // ── Round 2 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundTwo should build a valid N=1 round-2 share for the user', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundTwo(\n      payloads(MPCv2PartiesEnum.USER, 2, 1),\n      userGpgPrivKey\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.USER);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound2Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound2Input'\n    );\n    assert.strictEqual(parsed.type, 'round2Input');\n    assert.strictEqual(parsed.data.msg2.length, 1);\n    assert.ok(parsed.data.msg2[0].message, 'msg2[0].message should be set');\n    assert.ok(parsed.data.msg2[0].signature, 'msg2[0].signature should be set');\n  });\n\n  it('getSignatureShareRoundTwo N=3 should decode and preserve spend order', async function () {\n    const userMsg2s = payloads(MPCv2PartiesEnum.USER, 2, 3);\n    const share: SignatureShareRecord = await getSignatureShareRoundTwo(userMsg2s, userGpgPrivKey);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound2Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound2Input'\n    );\n    assert.strictEqual(parsed.data.msg2.length, 3);\n\n    const userGpgPubKey = userGpgPrivKey.toPublic();\n    for (const [spendIndex, signedMsg2] of parsed.data.msg2.entries()) {\n      const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg2, userGpgPubKey);\n      assert.deepStrictEqual(rawBytes, Buffer.from(userMsg2s[spendIndex].payload), `spend ${spendIndex} out of order`);\n    }\n  });\n\n  it('getSignatureShareRoundTwo should reject an empty message array', async function () {\n    await assert.rejects(getSignatureShareRoundTwo([], userGpgPrivKey), /Expected at least 1 round-2 message/);\n  });\n\n  it('verifyPeerMessageRoundTwo should verify valid N=3 BitGo round-2 messages in order', async function () {\n    const bitgoMsg2s = payloads(MPCv2PartiesEnum.BITGO, 2, 3);\n    const signedMsg2s = await Promise.all(\n      bitgoMsg2s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    const round2Output: RedpallasMPCv2SignatureShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: signedMsg2s },\n    };\n\n    const results = await verifyPeerMessageRoundTwo(round2Output, bitgoGpgPubKey);\n\n    assert.strictEqual(results.length, 3);\n    results.forEach((result, spendIndex) => {\n      assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n      assert.deepStrictEqual(\n        Buffer.from(result.payload),\n        Buffer.from(bitgoMsg2s[spendIndex].payload),\n        `spend ${spendIndex} out of order`\n      );\n    });\n  });\n\n  it('verifyPeerMessageRoundTwo should fail the whole N=3 round when one spend signature is bad', async function () {\n    const bitgoMsg2s = payloads(MPCv2PartiesEnum.BITGO, 2, 3);\n    const signedMsg2s = await Promise.all(\n      bitgoMsg2s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    signedMsg2s[2] = tamperedMessage();\n    const round2Output: RedpallasMPCv2SignatureShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: signedMsg2s },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundTwo(round2Output, bitgoGpgPubKey));\n  });\n\n  it('verifyPeerMessageRoundTwo should throw on a tampered round-2 message', async function () {\n    const round2Output: RedpallasMPCv2SignatureShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: [tamperedMessage()] },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundTwo(round2Output, bitgoGpgPubKey));\n  });\n\n  // ── Round 3 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundThree should build a valid N=1 round-3 share for the backup', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundThree(\n      payloads(MPCv2PartiesEnum.BACKUP, 3, 1),\n      backupGpgPrivKey,\n      MPCv2PartiesEnum.BACKUP\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.BACKUP);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound3Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound3Input'\n    );\n    assert.strictEqual(parsed.type, 'round3Input');\n    assert.strictEqual(parsed.data.msg3.length, 1);\n    assert.ok(parsed.data.msg3[0].message, 'msg3[0].message should be set');\n    assert.ok(parsed.data.msg3[0].signature, 'msg3[0].signature should be set');\n  });\n\n  it('getSignatureShareRoundThree N=3 should decode and preserve spend order', async function () {\n    const userMsg3s = payloads(MPCv2PartiesEnum.USER, 3, 3);\n    const share: SignatureShareRecord = await getSignatureShareRoundThree(userMsg3s, userGpgPrivKey);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound3Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound3Input'\n    );\n    assert.strictEqual(parsed.data.msg3.length, 3);\n\n    const userGpgPubKey = userGpgPrivKey.toPublic();\n    for (const [spendIndex, signedMsg3] of parsed.data.msg3.entries()) {\n      const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg3, userGpgPubKey);\n      assert.deepStrictEqual(rawBytes, Buffer.from(userMsg3s[spendIndex].payload), `spend ${spendIndex} out of order`);\n    }\n  });\n\n  it('getSignatureShareRoundThree should reject an empty message array', async function () {\n    await assert.rejects(getSignatureShareRoundThree([], userGpgPrivKey), /Expected at least 1 round-3 message/);\n  });\n\n  it('verifyPeerMessageRoundThree should verify valid N=3 BitGo round-3 messages in order', async function () {\n    const bitgoMsg3s = payloads(MPCv2PartiesEnum.BITGO, 3, 3);\n    const signedMsg3s = await Promise.all(\n      bitgoMsg3s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    const round3Output: RedpallasMPCv2SignatureShareRound3Output = {\n      type: 'round3Output',\n      data: { msg3: signedMsg3s },\n    };\n\n    const results = await verifyPeerMessageRoundThree(round3Output, bitgoGpgPubKey);\n\n    assert.strictEqual(results.length, 3);\n    results.forEach((result, spendIndex) => {\n      assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n      assert.deepStrictEqual(\n        Buffer.from(result.payload),\n        Buffer.from(bitgoMsg3s[spendIndex].payload),\n        `spend ${spendIndex} out of order`\n      );\n    });\n  });\n\n  it('verifyPeerMessageRoundThree should fail the whole N=3 round when one spend signature is bad', async function () {\n    const bitgoMsg3s = payloads(MPCv2PartiesEnum.BITGO, 3, 3);\n    const signedMsg3s = await Promise.all(\n      bitgoMsg3s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    signedMsg3s[0] = tamperedMessage();\n    const round3Output: RedpallasMPCv2SignatureShareRound3Output = {\n      type: 'round3Output',\n      data: { msg3: signedMsg3s },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundThree(round3Output, bitgoGpgPubKey));\n  });\n\n  it('verifyPeerMessageRoundThree should throw on a tampered round-3 message', async function () {\n    const round3Output: RedpallasMPCv2SignatureShareRound3Output = {\n      type: 'round3Output',\n      data: { msg3: [tamperedMessage()] },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundThree(round3Output, bitgoGpgPubKey));\n  });\n\n  // ── Rerand (must run before every DSG, same 2 parties, once per spend) ──────\n\n  it('getRerandShareRoundOne should build a valid N=1 rerand round-1 share for the user', async function () {\n    const share: SignatureShareRecord = await getRerandShareRoundOne(\n      payloads(MPCv2PartiesEnum.USER, 1, 1),\n      userGpgPrivKey\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.USER);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2RerandShareRound1Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2RerandShareRound1Input'\n    );\n    assert.strictEqual(parsed.type, 'round1Input');\n    assert.strictEqual(parsed.data.msg1.length, 1);\n    assert.ok(parsed.data.msg1[0].message, 'msg1[0].message should be set');\n    assert.ok(parsed.data.msg1[0].signature, 'msg1[0].signature should be set');\n  });\n\n  it('getRerandShareRoundOne should build a valid N=1 rerand round-1 share for the backup', async function () {\n    const share: SignatureShareRecord = await getRerandShareRoundOne(\n      payloads(MPCv2PartiesEnum.BACKUP, 1, 1),\n      backupGpgPrivKey,\n      MPCv2PartiesEnum.BACKUP\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.BACKUP);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n  });\n\n  it('getRerandShareRoundOne N=3 should decode and preserve spend order', async function () {\n    const userMsg1s = payloads(MPCv2PartiesEnum.USER, 1, 3);\n    const share: SignatureShareRecord = await getRerandShareRoundOne(userMsg1s, userGpgPrivKey);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2RerandShareRound1Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2RerandShareRound1Input'\n    );\n    assert.strictEqual(parsed.data.msg1.length, 3);\n\n    const userGpgPubKey = userGpgPrivKey.toPublic();\n    for (const [spendIndex, signedMsg1] of parsed.data.msg1.entries()) {\n      const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg1, userGpgPubKey);\n      assert.deepStrictEqual(rawBytes, Buffer.from(userMsg1s[spendIndex].payload), `spend ${spendIndex} out of order`);\n    }\n  });\n\n  it('getRerandShareRoundOne should reject an empty message array', async function () {\n    await assert.rejects(getRerandShareRoundOne([], userGpgPrivKey), /Expected at least 1 rerand round-1 message/);\n  });\n\n  it('verifyPeerRerandMessageRoundOne should verify valid N=3 BitGo rerand round-1 messages in order', async function () {\n    const bitgoMsg1s = payloads(MPCv2PartiesEnum.BITGO, 1, 3);\n    const signedMsg1s = await Promise.all(\n      bitgoMsg1s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    const round1Output: RedpallasMPCv2RerandShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: signedMsg1s },\n    };\n\n    const results = await verifyPeerRerandMessageRoundOne(round1Output, bitgoGpgPubKey);\n\n    assert.strictEqual(results.length, 3);\n    results.forEach((result, spendIndex) => {\n      assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n      assert.deepStrictEqual(\n        Buffer.from(result.payload),\n        Buffer.from(bitgoMsg1s[spendIndex].payload),\n        `spend ${spendIndex} out of order`\n      );\n    });\n  });\n\n  it('verifyPeerRerandMessageRoundOne should fail the whole N=3 round when one spend signature is bad', async function () {\n    const bitgoMsg1s = payloads(MPCv2PartiesEnum.BITGO, 1, 3);\n    const signedMsg1s = await Promise.all(\n      bitgoMsg1s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    signedMsg1s[1] = tamperedMessage();\n    const round1Output: RedpallasMPCv2RerandShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: signedMsg1s },\n    };\n\n    await assert.rejects(verifyPeerRerandMessageRoundOne(round1Output, bitgoGpgPubKey));\n  });\n\n  it('verifyPeerRerandMessageRoundOne should throw on a tampered rerand round-1 message', async function () {\n    const round1Output: RedpallasMPCv2RerandShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: [tamperedMessage()] },\n    };\n\n    await assert.rejects(verifyPeerRerandMessageRoundOne(round1Output, bitgoGpgPubKey));\n  });\n\n  it('getRerandShareRoundTwo should build a valid N=1 rerand round-2 share for the user', async function () {\n    const share: SignatureShareRecord = await getRerandShareRoundTwo(\n      payloads(MPCv2PartiesEnum.USER, 2, 1),\n      userGpgPrivKey\n    );\n\n    assert.strictEqual(share.from, SignatureShareType.USER);\n    assert.strictEqual(share.to, SignatureShareType.BITGO);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2RerandShareRound2Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2RerandShareRound2Input'\n    );\n    assert.strictEqual(parsed.type, 'round2Input');\n    assert.strictEqual(parsed.data.msg2.length, 1);\n    assert.ok(parsed.data.msg2[0].message, 'msg2[0].message should be set');\n    assert.ok(parsed.data.msg2[0].signature, 'msg2[0].signature should be set');\n  });\n\n  it('getRerandShareRoundTwo N=3 should decode and preserve spend order', async function () {\n    const userMsg2s = payloads(MPCv2PartiesEnum.USER, 2, 3);\n    const share: SignatureShareRecord = await getRerandShareRoundTwo(userMsg2s, userGpgPrivKey);\n\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2RerandShareRound2Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2RerandShareRound2Input'\n    );\n    assert.strictEqual(parsed.data.msg2.length, 3);\n\n    const userGpgPubKey = userGpgPrivKey.toPublic();\n    for (const [spendIndex, signedMsg2] of parsed.data.msg2.entries()) {\n      const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg2, userGpgPubKey);\n      assert.deepStrictEqual(rawBytes, Buffer.from(userMsg2s[spendIndex].payload), `spend ${spendIndex} out of order`);\n    }\n  });\n\n  it('getRerandShareRoundTwo should reject an empty message array', async function () {\n    await assert.rejects(getRerandShareRoundTwo([], userGpgPrivKey), /Expected at least 1 rerand round-2 message/);\n  });\n\n  it('verifyPeerRerandMessageRoundTwo should verify valid N=3 BitGo rerand round-2 messages in order', async function () {\n    const bitgoMsg2s = payloads(MPCv2PartiesEnum.BITGO, 2, 3);\n    const signedMsg2s = await Promise.all(\n      bitgoMsg2s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    const round2Output: RedpallasMPCv2RerandShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: signedMsg2s },\n    };\n\n    const results = await verifyPeerRerandMessageRoundTwo(round2Output, bitgoGpgPubKey);\n\n    assert.strictEqual(results.length, 3);\n    results.forEach((result, spendIndex) => {\n      assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n      assert.deepStrictEqual(\n        Buffer.from(result.payload),\n        Buffer.from(bitgoMsg2s[spendIndex].payload),\n        `spend ${spendIndex} out of order`\n      );\n    });\n  });\n\n  it('verifyPeerRerandMessageRoundTwo should fail the whole N=3 round when one spend signature is bad', async function () {\n    const bitgoMsg2s = payloads(MPCv2PartiesEnum.BITGO, 2, 3);\n    const signedMsg2s = await Promise.all(\n      bitgoMsg2s.map((msg) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(msg.payload), bitgoGpgPrivKey))\n    );\n    signedMsg2s[2] = tamperedMessage();\n    const round2Output: RedpallasMPCv2RerandShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: signedMsg2s },\n    };\n\n    await assert.rejects(verifyPeerRerandMessageRoundTwo(round2Output, bitgoGpgPubKey));\n  });\n\n  it('verifyPeerRerandMessageRoundTwo should throw on a tampered rerand round-2 message', async function () {\n    const round2Output: RedpallasMPCv2RerandShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: [tamperedMessage()] },\n    };\n\n    await assert.rejects(verifyPeerRerandMessageRoundTwo(round2Output, bitgoGpgPubKey));\n  });\n\n  // ── Envelope round-trip via the independent RedPallas MPS comms layer ───────\n\n  it('N=3 shares built by getSignatureShareRoundOne verify against RedPallasMPSComms directly', async function () {\n    const userMsg1s = payloads(MPCv2PartiesEnum.USER, 1, 3);\n    const share = await getSignatureShareRoundOne(userMsg1s, userGpgPrivKey);\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound1Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound1Input'\n    );\n\n    const userGpgPubKey = userGpgPrivKey.toPublic();\n    for (const [spendIndex, signedMsg1] of parsed.data.msg1.entries()) {\n      const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg1, userGpgPubKey);\n      assert.deepStrictEqual(rawBytes, Buffer.from(userMsg1s[spendIndex].payload));\n    }\n  });\n});\n"]}

package/dist/test/unit/bitgo/utils/abstractUtxoCoinUtil.js

@@ -8,18 +8,59 @@ const src_1 = require("../../../../src");
 describe('getUtxoCoinScriptTypes', function () {
     it('success', function () {
         const fn = (coin, arr) => {
-            const scriptTypes = src_1.getUtxoCoinScriptTypes2Of3(coin);
+            const scriptTypes = (0, src_1.getUtxoCoinScriptTypes2Of3)(coin);
             return arr.find((v) => scriptTypes.includes(v));
         };
         assert_1.default.ok(fn('btc', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));
         assert_1.default.ok(fn('ltc', ['p2sh', 'p2shP2wsh', 'p2wsh']));
         assert_1.default.ok(fn('doge', ['p2sh']));
     });
+    it('fail with an actionable message for wasm-only coins', function () {
+        // pearl is served through @bitgo/wasm-utxo and has no utxo-lib network, so its
+        // utxolibName does not resolve here. Assert the guidance rather than letting it
+        // fall through to a bare `TypeError: invalid network`.
+        for (const coinName of ['pearl', 'tpearl']) {
+            assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypes2Of3)(coinName), (e) => /has no utxo-lib network/.test(e.message) && /@bitgo\/wasm-utxo/.test(e.message));
+        }
+    });
+    it('fail for invalid coin name', function () {
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypes2Of3)('dummy'), (e) => e.message === `coin 'dummy' is not defined`);
+    });
+    it('fail for non-utxo coin name', function () {
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypes2Of3)('eth'), (e) => e.message === 'coin eth is not a utxo coin');
+    });
+});
+describe('getUtxoCoinScriptTypesForWalletType', function () {
+    it('success', function () {
+        const fn = (coin, walletType, arr) => {
+            const scriptTypes = (0, src_1.getUtxoCoinScriptTypesForWalletType)(coin, walletType);
+            return arr.find((v) => scriptTypes.includes(v));
+        };
+        assert_1.default.ok(fn('btc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));
+        assert_1.default.ok(fn('btc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr']));
+        assert_1.default.ok(fn('ltc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh']));
+        assert_1.default.ok(fn('ltc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh']));
+        assert_1.default.ok(fn('doge', 'hot', ['p2sh']));
+        assert_1.default.ok(fn('doge', 'cold', ['p2sh']));
+    });
+    it('applies the wallet-type rule for p2trMusig2', function () {
+        // p2trMusig2 is hot-only on mainnet; cold is allowed on testnet
+        assert_1.default.ok((0, src_1.getUtxoCoinScriptTypesForWalletType)('btc', 'hot').includes('p2trMusig2'));
+        assert_1.default.ok(!(0, src_1.getUtxoCoinScriptTypesForWalletType)('btc', 'cold').includes('p2trMusig2'));
+        assert_1.default.ok((0, src_1.getUtxoCoinScriptTypesForWalletType)('tbtc', 'cold').includes('p2trMusig2'));
+    });
+    it('fail with an actionable message for wasm-only coins', function () {
+        for (const coinName of ['pearl', 'tpearl']) {
+            for (const walletType of ['hot', 'cold']) {
+                assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypesForWalletType)(coinName, walletType), (e) => /has no utxo-lib network/.test(e.message) && /@bitgo\/wasm-utxo/.test(e.message));
+            }
+        }
+    });
     it('fail for invalid coin name', function () {
-        assert_1.default.throws(() => src_1.getUtxoCoinScriptTypes2Of3('dummy'), (e) => e.message === `coin 'dummy' is not defined`);
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypesForWalletType)('dummy', 'hot'), (e) => e.message === `coin 'dummy' is not defined`);
     });
     it('fail for non-utxo coin name', function () {
-        assert_1.default.throws(() => src_1.getUtxoCoinScriptTypes2Of3('eth'), (e) => e.message === 'coin eth is not a utxo coin');
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypesForWalletType)('eth', 'hot'), (e) => e.message === 'coin eth is not a utxo coin');
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractUtxoCoinUtil.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/utils/abstractUtxoCoinUtil.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport { getUtxoCoinScriptTypes2Of3, getUtxoCoinScriptTypesForWalletType } from '../../../../src';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\n\ndescribe('getUtxoCoinScriptTypes', function () {\n  it('success', function () {\n    const fn = (coin: string, arr: utxolib.bitgo.outputScripts.ScriptType2Of3[]) => {\n      const scriptTypes = getUtxoCoinScriptTypes2Of3(coin);\n      return arr.find((v) => scriptTypes.includes(v));\n    };\n    assert.ok(fn('btc', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));\n    assert.ok(fn('ltc', ['p2sh', 'p2shP2wsh', 'p2wsh']));\n    assert.ok(fn('doge', ['p2sh']));\n  });\n\n  it('fail with an actionable message for wasm-only coins', function () {\n    // pearl is served through @bitgo/wasm-utxo and has no utxo-lib network, so its\n    // utxolibName does not resolve here. Assert the guidance rather than letting it\n    // fall through to a bare `TypeError: invalid network`.\n    for (const coinName of ['pearl', 'tpearl']) {\n      assert.throws(\n        () => getUtxoCoinScriptTypes2Of3(coinName),\n        (e: any) => /has no utxo-lib network/.test(e.message) && /@bitgo\\/wasm-utxo/.test(e.message)\n      );\n    }\n  });\n\n  it('fail for invalid coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypes2Of3('dummy'),\n      (e: any) => e.message === `coin 'dummy' is not defined`\n    );\n  });\n\n  it('fail for non-utxo coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypes2Of3('eth'),\n      (e: any) => e.message === 'coin eth is not a utxo coin'\n    );\n  });\n});\n\ndescribe('getUtxoCoinScriptTypesForWalletType', function () {\n  it('success', function () {\n    const fn = (coin: string, walletType: 'hot' | 'cold', arr: utxolib.bitgo.outputScripts.ScriptType2Of3[]) => {\n      const scriptTypes = getUtxoCoinScriptTypesForWalletType(coin, walletType);\n      return arr.find((v) => scriptTypes.includes(v));\n    };\n    assert.ok(fn('btc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));\n    assert.ok(fn('btc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr']));\n    assert.ok(fn('ltc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh']));\n    assert.ok(fn('ltc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh']));\n    assert.ok(fn('doge', 'hot', ['p2sh']));\n    assert.ok(fn('doge', 'cold', ['p2sh']));\n  });\n\n  it('applies the wallet-type rule for p2trMusig2', function () {\n    // p2trMusig2 is hot-only on mainnet; cold is allowed on testnet\n    assert.ok(getUtxoCoinScriptTypesForWalletType('btc', 'hot').includes('p2trMusig2'));\n    assert.ok(!getUtxoCoinScriptTypesForWalletType('btc', 'cold').includes('p2trMusig2'));\n    assert.ok(getUtxoCoinScriptTypesForWalletType('tbtc', 'cold').includes('p2trMusig2'));\n  });\n\n  it('fail with an actionable message for wasm-only coins', function () {\n    for (const coinName of ['pearl', 'tpearl']) {\n      for (const walletType of ['hot', 'cold'] as const) {\n        assert.throws(\n          () => getUtxoCoinScriptTypesForWalletType(coinName, walletType),\n          (e: any) => /has no utxo-lib network/.test(e.message) && /@bitgo\\/wasm-utxo/.test(e.message)\n        );\n      }\n    }\n  });\n\n  it('fail for invalid coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypesForWalletType('dummy', 'hot'),\n      (e: any) => e.message === `coin 'dummy' is not defined`\n    );\n  });\n\n  it('fail for non-utxo coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypesForWalletType('eth', 'hot'),\n      (e: any) => e.message === 'coin eth is not a utxo coin'\n    );\n  });\n});\n"]}

package/dist/test/unit/bitgo/utils/messageTypes.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=messageTypes.d.ts.map

package/dist/test/unit/bitgo/utils/messageTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageTypes.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/utils/messageTypes.ts"],"names":[],"mappings":""}