@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

package/dist/test/unit/bitgo/tss/common.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+const common_1 = require("../../../../src/bitgo/tss/common");
+const src_1 = require("../../../../src");
+describe('sendSignatureShareV2 request type dispatch', function () {
+    afterEach(function () {
+        sinon.restore();
+    });
+    async function captureRequestType(mpcAlgorithm, multisigTypeVersion) {
+        let capturedBody;
+        const send = sinon.stub().callsFake((body) => {
+            capturedBody = body;
+            return { result: sinon.stub().resolves({}) };
+        });
+        const mockBitGo = {
+            url: sinon.stub().returns('/mock/url'),
+            post: sinon.stub().returns({ send }),
+            setRequestTracer: sinon.stub(),
+        };
+        await (0, common_1.sendSignatureShareV2)(mockBitGo, 'walletId', 'txRequestId', [], src_1.RequestType.tx, mpcAlgorithm, 'signerGpgPublicKey', undefined, multisigTypeVersion);
+        if (!capturedBody) {
+            throw new Error('request body should have been captured');
+        }
+        return capturedBody.type;
+    }
+    it('resolves ecdsaMpcV2 for MPCv2 + ecdsa', async function () {
+        assert.strictEqual(await captureRequestType('ecdsa', 'MPCv2'), 'ecdsaMpcV2');
+    });
+    it('resolves eddsaMpcV2 for MPCv2 + eddsa', async function () {
+        assert.strictEqual(await captureRequestType('eddsa', 'MPCv2'), 'eddsaMpcV2');
+    });
+    it('resolves redpallasMpcV2 for MPCv2 + redpallas', async function () {
+        assert.strictEqual(await captureRequestType('redpallas', 'MPCv2'), 'redpallasMpcV2');
+    });
+    it('resolves eddsaMpcV1 for undefined multisigTypeVersion + eddsa', async function () {
+        assert.strictEqual(await captureRequestType('eddsa', undefined), 'eddsaMpcV1');
+    });
+    it('resolves an empty type for redpallas without MPCv2 (no MPCv1 variant exists)', async function () {
+        assert.strictEqual(await captureRequestType('redpallas', undefined), '');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/bitgo/tss/redpallas/redpallasMPCv2.d.ts

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

package/dist/test/unit/bitgo/tss/redpallas/redpallasMPCv2.d.ts.map

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

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

@@ -0,0 +1,249 @@
+"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");
+describe('RedPallas MPS DSG helper functions', function () {
+    let userGpgPrivKey;
+    let backupGpgPrivKey;
+    let bitgoGpgPrivKey;
+    let bitgoGpgPubKey;
+    const userPayload = (round) => ({
+        from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+        payload: new Uint8Array(Buffer.from(`user-round-${round}-payload`)),
+    });
+    const backupPayload = (round) => ({
+        from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP,
+        payload: new Uint8Array(Buffer.from(`backup-round-${round}-payload`)),
+    });
+    const bitgoPayload = (round) => ({
+        from: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+        payload: new Uint8Array(Buffer.from(`bitgo-round-${round}-payload`)),
+    });
+    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 round-1 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundOne)(userPayload(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.ok(parsed.data.msg1.message, 'msg1.message should be set');
+        assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');
+    });
+    it('getSignatureShareRoundOne should build a valid round-1 share for the backup', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundOne)(backupPayload(1), backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+    });
+    it('verifyPeerMessageRoundOne should verify a valid BitGo round-1 message', async function () {
+        const bitgoSignedMsg1 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(bitgoPayload(1).payload), bitgoGpgPrivKey);
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: bitgoSignedMsg1 },
+        };
+        const result = await (0, redpallasMPCv2_1.verifyPeerMessageRoundOne)(round1Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(1).payload));
+    });
+    it('verifyPeerMessageRoundOne should throw on a tampered round-1 message', async function () {
+        const round1Output = {
+            type: 'round1Output',
+            data: {
+                msg1: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundOne)(round1Output, bitgoGpgPubKey));
+    });
+    // ── Round 2 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundTwo should build a valid round-2 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundTwo)(userPayload(2), 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.ok(parsed.data.msg2.message, 'msg2.message should be set');
+        assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');
+    });
+    it('verifyPeerMessageRoundTwo should verify a valid BitGo round-2 message', async function () {
+        const bitgoSignedMsg2 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(bitgoPayload(2).payload), bitgoGpgPrivKey);
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: bitgoSignedMsg2 },
+        };
+        const result = await (0, redpallasMPCv2_1.verifyPeerMessageRoundTwo)(round2Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(2).payload));
+    });
+    it('verifyPeerMessageRoundTwo should throw on a tampered round-2 message', async function () {
+        const round2Output = {
+            type: 'round2Output',
+            data: {
+                msg2: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundTwo)(round2Output, bitgoGpgPubKey));
+    });
+    // ── Round 3 ─────────────────────────────────────────────────────────────────
+    it('getSignatureShareRoundThree should build a valid round-3 share for the backup', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundThree)(backupPayload(3), 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.ok(parsed.data.msg3.message, 'msg3.message should be set');
+        assert.ok(parsed.data.msg3.signature, 'msg3.signature should be set');
+    });
+    it('verifyPeerMessageRoundThree should verify a valid BitGo round-3 message', async function () {
+        const bitgoSignedMsg3 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(bitgoPayload(3).payload), bitgoGpgPrivKey);
+        const round3Output = {
+            type: 'round3Output',
+            data: { msg3: bitgoSignedMsg3 },
+        };
+        const result = await (0, redpallasMPCv2_1.verifyPeerMessageRoundThree)(round3Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(3).payload));
+    });
+    it('verifyPeerMessageRoundThree should throw on a tampered round-3 message', async function () {
+        const round3Output = {
+            type: 'round3Output',
+            data: {
+                msg3: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerMessageRoundThree)(round3Output, bitgoGpgPubKey));
+    });
+    // ── Rerand (must run before every DSG, same 2 parties) ──────────────────────
+    it('getRerandShareRoundOne should build a valid rerand round-1 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundOne)(userPayload(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.ok(parsed.data.msg1.message, 'msg1.message should be set');
+        assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');
+    });
+    it('getRerandShareRoundOne should build a valid rerand round-1 share for the backup', async function () {
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundOne)(backupPayload(1), backupGpgPrivKey, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        assert.strictEqual(share.from, src_1.SignatureShareType.BACKUP);
+        assert.strictEqual(share.to, src_1.SignatureShareType.BITGO);
+    });
+    it('verifyPeerRerandMessageRoundOne should verify a valid BitGo rerand round-1 message', async function () {
+        const bitgoSignedMsg1 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(bitgoPayload(1).payload), bitgoGpgPrivKey);
+        const round1Output = {
+            type: 'round1Output',
+            data: { msg1: bitgoSignedMsg1 },
+        };
+        const result = await (0, redpallasMPCv2_1.verifyPeerRerandMessageRoundOne)(round1Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(1).payload));
+    });
+    it('verifyPeerRerandMessageRoundOne should throw on a tampered rerand round-1 message', async function () {
+        const round1Output = {
+            type: 'round1Output',
+            data: {
+                msg1: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerRerandMessageRoundOne)(round1Output, bitgoGpgPubKey));
+    });
+    it('getRerandShareRoundTwo should build a valid rerand round-2 share for the user', async function () {
+        const share = await (0, redpallasMPCv2_1.getRerandShareRoundTwo)(userPayload(2), 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.ok(parsed.data.msg2.message, 'msg2.message should be set');
+        assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');
+    });
+    it('verifyPeerRerandMessageRoundTwo should verify a valid BitGo rerand round-2 message', async function () {
+        const bitgoSignedMsg2 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(bitgoPayload(2).payload), bitgoGpgPrivKey);
+        const round2Output = {
+            type: 'round2Output',
+            data: { msg2: bitgoSignedMsg2 },
+        };
+        const result = await (0, redpallasMPCv2_1.verifyPeerRerandMessageRoundTwo)(round2Output, bitgoGpgPubKey);
+        assert.strictEqual(result.from, typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(2).payload));
+    });
+    it('verifyPeerRerandMessageRoundTwo should throw on a tampered rerand round-2 message', async function () {
+        const round2Output = {
+            type: 'round2Output',
+            data: {
+                msg2: {
+                    message: Buffer.from('tampered').toString('base64'),
+                    signature: '-----BEGIN PGP SIGNATURE-----\n\nINVALID\n-----END PGP SIGNATURE-----\n',
+                },
+            },
+        };
+        await assert.rejects((0, redpallasMPCv2_1.verifyPeerRerandMessageRoundTwo)(round2Output, bitgoGpgPubKey));
+    });
+    // ── Envelope round-trip via the independent RedPallas MPS comms layer ───────
+    it('a share built by getSignatureShareRoundOne verifies against RedPallasMPSComms directly', async function () {
+        const share = await (0, redpallasMPCv2_1.getSignatureShareRoundOne)(userPayload(1), userGpgPrivKey);
+        const parsed = (0, codecs_1.decodeWithCodec)(public_types_1.RedpallasMPCv2SignatureShareRound1Input, JSON.parse(share.share), 'RedpallasMPCv2SignatureShareRound1Input');
+        const userGpgPubKey = userGpgPrivKey.toPublic();
+        const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(parsed.data.msg1, userGpgPubKey);
+        assert.deepStrictEqual(rawBytes, Buffer.from(userPayload(1).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\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  const userPayload = (round: number): RedPallasMPSTypes.DeserializedMessage => ({\n    from: MPCv2PartiesEnum.USER,\n    payload: new Uint8Array(Buffer.from(`user-round-${round}-payload`)),\n  });\n  const backupPayload = (round: number): RedPallasMPSTypes.DeserializedMessage => ({\n    from: MPCv2PartiesEnum.BACKUP,\n    payload: new Uint8Array(Buffer.from(`backup-round-${round}-payload`)),\n  });\n  const bitgoPayload = (round: number): RedPallasMPSTypes.DeserializedMessage => ({\n    from: MPCv2PartiesEnum.BITGO,\n    payload: new Uint8Array(Buffer.from(`bitgo-round-${round}-payload`)),\n  });\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 round-1 share for the user', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundOne(userPayload(1), userGpgPrivKey);\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.ok(parsed.data.msg1.message, 'msg1.message should be set');\n    assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');\n  });\n\n  it('getSignatureShareRoundOne should build a valid round-1 share for the backup', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundOne(\n      backupPayload(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('verifyPeerMessageRoundOne should verify a valid BitGo round-1 message', async function () {\n    const bitgoSignedMsg1 = await RedPallasMPSComms.detachSignMpsMessage(\n      Buffer.from(bitgoPayload(1).payload),\n      bitgoGpgPrivKey\n    );\n    const round1Output: RedpallasMPCv2SignatureShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: bitgoSignedMsg1 },\n    };\n\n    const result = await verifyPeerMessageRoundOne(round1Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(1).payload));\n  });\n\n  it('verifyPeerMessageRoundOne should throw on a tampered round-1 message', async function () {\n    const round1Output: RedpallasMPCv2SignatureShareRound1Output = {\n      type: 'round1Output',\n      data: {\n        msg1: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundOne(round1Output, bitgoGpgPubKey));\n  });\n\n  // ── Round 2 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundTwo should build a valid round-2 share for the user', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundTwo(userPayload(2), userGpgPrivKey);\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.ok(parsed.data.msg2.message, 'msg2.message should be set');\n    assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');\n  });\n\n  it('verifyPeerMessageRoundTwo should verify a valid BitGo round-2 message', async function () {\n    const bitgoSignedMsg2 = await RedPallasMPSComms.detachSignMpsMessage(\n      Buffer.from(bitgoPayload(2).payload),\n      bitgoGpgPrivKey\n    );\n    const round2Output: RedpallasMPCv2SignatureShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: bitgoSignedMsg2 },\n    };\n\n    const result = await verifyPeerMessageRoundTwo(round2Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(2).payload));\n  });\n\n  it('verifyPeerMessageRoundTwo should throw on a tampered round-2 message', async function () {\n    const round2Output: RedpallasMPCv2SignatureShareRound2Output = {\n      type: 'round2Output',\n      data: {\n        msg2: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundTwo(round2Output, bitgoGpgPubKey));\n  });\n\n  // ── Round 3 ─────────────────────────────────────────────────────────────────\n\n  it('getSignatureShareRoundThree should build a valid round-3 share for the backup', async function () {\n    const share: SignatureShareRecord = await getSignatureShareRoundThree(\n      backupPayload(3),\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.ok(parsed.data.msg3.message, 'msg3.message should be set');\n    assert.ok(parsed.data.msg3.signature, 'msg3.signature should be set');\n  });\n\n  it('verifyPeerMessageRoundThree should verify a valid BitGo round-3 message', async function () {\n    const bitgoSignedMsg3 = await RedPallasMPSComms.detachSignMpsMessage(\n      Buffer.from(bitgoPayload(3).payload),\n      bitgoGpgPrivKey\n    );\n    const round3Output: RedpallasMPCv2SignatureShareRound3Output = {\n      type: 'round3Output',\n      data: { msg3: bitgoSignedMsg3 },\n    };\n\n    const result = await verifyPeerMessageRoundThree(round3Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(3).payload));\n  });\n\n  it('verifyPeerMessageRoundThree should throw on a tampered round-3 message', async function () {\n    const round3Output: RedpallasMPCv2SignatureShareRound3Output = {\n      type: 'round3Output',\n      data: {\n        msg3: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(verifyPeerMessageRoundThree(round3Output, bitgoGpgPubKey));\n  });\n\n  // ── Rerand (must run before every DSG, same 2 parties) ──────────────────────\n\n  it('getRerandShareRoundOne should build a valid rerand round-1 share for the user', async function () {\n    const share: SignatureShareRecord = await getRerandShareRoundOne(userPayload(1), userGpgPrivKey);\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.ok(parsed.data.msg1.message, 'msg1.message should be set');\n    assert.ok(parsed.data.msg1.signature, 'msg1.signature should be set');\n  });\n\n  it('getRerandShareRoundOne should build a valid rerand round-1 share for the backup', async function () {\n    const share: SignatureShareRecord = await getRerandShareRoundOne(\n      backupPayload(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('verifyPeerRerandMessageRoundOne should verify a valid BitGo rerand round-1 message', async function () {\n    const bitgoSignedMsg1 = await RedPallasMPSComms.detachSignMpsMessage(\n      Buffer.from(bitgoPayload(1).payload),\n      bitgoGpgPrivKey\n    );\n    const round1Output: RedpallasMPCv2RerandShareRound1Output = {\n      type: 'round1Output',\n      data: { msg1: bitgoSignedMsg1 },\n    };\n\n    const result = await verifyPeerRerandMessageRoundOne(round1Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(1).payload));\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: {\n        msg1: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(verifyPeerRerandMessageRoundOne(round1Output, bitgoGpgPubKey));\n  });\n\n  it('getRerandShareRoundTwo should build a valid rerand round-2 share for the user', async function () {\n    const share: SignatureShareRecord = await getRerandShareRoundTwo(userPayload(2), userGpgPrivKey);\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.ok(parsed.data.msg2.message, 'msg2.message should be set');\n    assert.ok(parsed.data.msg2.signature, 'msg2.signature should be set');\n  });\n\n  it('verifyPeerRerandMessageRoundTwo should verify a valid BitGo rerand round-2 message', async function () {\n    const bitgoSignedMsg2 = await RedPallasMPSComms.detachSignMpsMessage(\n      Buffer.from(bitgoPayload(2).payload),\n      bitgoGpgPrivKey\n    );\n    const round2Output: RedpallasMPCv2RerandShareRound2Output = {\n      type: 'round2Output',\n      data: { msg2: bitgoSignedMsg2 },\n    };\n\n    const result = await verifyPeerRerandMessageRoundTwo(round2Output, bitgoGpgPubKey);\n\n    assert.strictEqual(result.from, MPCv2PartiesEnum.BITGO);\n    assert.deepStrictEqual(Buffer.from(result.payload), Buffer.from(bitgoPayload(2).payload));\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: {\n        msg2: {\n          message: Buffer.from('tampered').toString('base64'),\n          signature: '-----BEGIN PGP SIGNATURE-----\\n\\nINVALID\\n-----END PGP SIGNATURE-----\\n',\n        },\n      },\n    };\n\n    await assert.rejects(verifyPeerRerandMessageRoundTwo(round2Output, bitgoGpgPubKey));\n  });\n\n  // ── Envelope round-trip via the independent RedPallas MPS comms layer ───────\n\n  it('a share built by getSignatureShareRoundOne verifies against RedPallasMPSComms directly', async function () {\n    const share = await getSignatureShareRoundOne(userPayload(1), userGpgPrivKey);\n    const parsed = decodeWithCodec(\n      RedpallasMPCv2SignatureShareRound1Input,\n      JSON.parse(share.share),\n      'RedpallasMPCv2SignatureShareRound1Input'\n    );\n\n    const userGpgPubKey = userGpgPrivKey.toPublic();\n    const rawBytes = await RedPallasMPSComms.verifyMpsMessage(parsed.data.msg1, userGpgPubKey);\n\n    assert.deepStrictEqual(rawBytes, Buffer.from(userPayload(1).payload));\n  });\n});\n"]}

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

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

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

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

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

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const src_1 = require("../../../../src");
+describe('getUtxoCoinScriptTypes', function () {
+    it('success', function () {
+        const fn = (coin, arr) => {
+            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(() => (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(() => (0, src_1.getUtxoCoinScriptTypesForWalletType)('eth', 'hot'), (e) => e.message === 'coin eth is not a utxo coin');
+    });
+});
+//# 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":""}

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should_1 = __importDefault(require("should"));
+const src_1 = require("../../../../src");
+describe('Message Types', () => {
+    describe('MessageStandardType', () => {
+        it('should define supported message standard types', () => {
+            should_1.default.exist(src_1.MessageStandardType.UNKNOWN);
+            should_1.default.exist(src_1.MessageStandardType.EIP191);
+            should_1.default.equal(src_1.MessageStandardType.UNKNOWN, 'UNKNOWN');
+            should_1.default.equal(src_1.MessageStandardType.EIP191, 'EIP191');
+        });
+    });
+    describe('BroadcastableMessage', () => {
+        it('should validate interface structure', () => {
+            const message = {
+                type: src_1.MessageStandardType.EIP191,
+                payload: 'Test payload',
+                serializedSignatures: [
+                    {
+                        publicKey: 'pub1',
+                        signature: 'signature1',
+                    },
+                    {
+                        publicKey: 'pub2',
+                        signature: 'signature2',
+                    },
+                ],
+                signers: ['signer1', 'signer2'],
+                metadata: { chainId: 1 },
+                signablePayload: 'signable payload',
+            };
+            should_1.default.equal(message.type, src_1.MessageStandardType.EIP191);
+            should_1.default.equal(message.payload, 'Test payload');
+            should_1.default.deepEqual(message.serializedSignatures, [
+                {
+                    publicKey: 'pub1',
+                    signature: 'signature1',
+                },
+                {
+                    publicKey: 'pub2',
+                    signature: 'signature2',
+                },
+            ]);
+            should_1.default.deepEqual(message.signers, ['signer1', 'signer2']);
+            should_1.default.deepEqual(message.metadata, { chainId: 1 });
+            should_1.default.deepEqual(message.signablePayload, 'signable payload');
+        });
+        it('should allow optional fields to be undefined', () => {
+            const message = {
+                type: src_1.MessageStandardType.UNKNOWN,
+                payload: 'Minimal message',
+                serializedSignatures: [],
+                signers: [],
+            };
+            should_1.default.not.exist(message.metadata);
+            should_1.default.not.exist(message.signablePayload);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/bitgo/utils/mpcUtils.unwrap.d.ts

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

package/dist/test/unit/bitgo/utils/mpcUtils.unwrap.d.ts.map

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