@bitgo-beta/sdk-core 8.2.1-beta.2121 → 8.2.1-beta.2123

package/dist/src/bitgo/tss/redpallas/redpallasMPCv2.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSignatureShareRoundOne = getSignatureShareRoundOne;
 exports.verifyPeerMessageRoundOne = verifyPeerMessageRoundOne;
@@ -10,6 +13,7 @@ exports.getRerandShareRoundOne = getRerandShareRoundOne;
 exports.verifyPeerRerandMessageRoundOne = verifyPeerRerandMessageRoundOne;
 exports.getRerandShareRoundTwo = getRerandShareRoundTwo;
 exports.verifyPeerRerandMessageRoundTwo = verifyPeerRerandMessageRoundTwo;
+const assert_1 = __importDefault(require("assert"));
 const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
 const baseTypes_1 = require("../../utils/tss/baseTypes");
 const typesMPCv2_1 = require("../../utils/tss/ecdsa/typesMPCv2");
@@ -24,35 +28,66 @@ function partyIdToSignatureShareType(partyId) {
     }
 }
 /**
- * RedPallas MPS DSG and rerand signature-share helpers.
+ * RedPallas MPS DSG and rerand signature-share helpers (multi-spend, WCI-1949).
  *
- * Consumed by the custodial/cold (SMC/OVC) signing flow: OVC builds its rerand and DSG
- * shares with these and submits them via the /sign txRequest route (see
- * `sendSignatureShareV2`, body types `redPallasRerand` / `redPallasMpcV2`). No caller
- * inside this SDK yet. Mirrors `../eddsa/eddsaMPCv2.ts` (same round shape, same
- * PGP-signed-message envelope), but kept as an independent copy - built on
- * `RedPallasMPSComms` - so RedPallas MPS never depends on the EdDSA MPS module, and
- * vice versa.
+ * A shielded ZEC transaction can spend several Orchard notes; every per-spend
+ * value on the /sign wire is an ARRAY of length N ordered by spend index, where
+ * N is the number of Orchard spends
+ * (`txRequest.transactions[i].unsignedTx.parsedTx.inputs.length`), derived on
+ * the client and never a wire field. Each spend runs its own rerand session and
+ * its own DSG session (N instances of `RedPallasRerand` / `RedPallasDSG` — they
+ * are single-session by design; the per-spend fan-out lives in the caller, see
+ * OVC's `MpcSignerRedPallas`), but each round still produces exactly ONE
+ * `SignatureShareRecord` per transaction: the builders below take N
+ * PGP-signed messages in and emit one record whose `msgN` is the spend-ordered
+ * array; the verifiers take a parsed peer `roundNOutput` (msgN array) and
+ * return N verified messages out, in the same order.
  *
- * Since `@bitgo/wasm-mps` 1.17.0, key re-randomization is a separate 2-round rerand
- * protocol that must run before every RedPallas DSG, between the same 2 parties that
- * will then sign: `getRerandShareRoundOne/Two` build those share records and
- * `verifyPeerRerandMessageRoundOne/Two` unwrap the peer's rerand messages (see
- * `RedPallasRerand` in `@bitgo-beta/sdk-lib-mpc`). The rerand result exposes
- * `{keyShare, pk, alpha}`; `pk` is the `rk` the DSG signature verifies under, and the
- * DSG keyshare is the rerandomized `keyShare` - never the bare DKG keyshare.
+ * Builders:
+ * - assert a non-empty input array (N >= 1; an Orchard spend transaction has at
+ *   least one input) and preserve spend order — Wallet Platform index-pairs
+ *   `msgN[i]` with spend i's HSM state, so a misordered array silently mispairs
+ *   spends.
+ * - emit exactly ONE share record per round — WP reads only the LAST share in
+ *   `signatureShares`; multiple partial records would be silently dropped.
+ *
+ * Verifiers:
+ * - return one verified message per array entry, same order, all signed by the
+ *   BitGo RedPallas GPG key; a single failed verification fails the whole round
+ *   (all-or-nothing, mirroring WP's per-round share handling).
+ *
+ * Consumed by the custodial/cold (SMC/OVC) signing flow: OVC builds its rerand
+ * and DSG shares with these and submits them via the /sign txRequest route (see
+ * `sendSignatureShareV2`, body types `redPallasRerand` / `redPallasMpcV2`). No
+ * caller inside this SDK yet. Mirrors `../eddsa/eddsaMPCv2.ts` (same round
+ * shape, same PGP-signed-message envelope), but kept as an independent copy -
+ * built on `RedPallasMPSComms` - so RedPallas MPS never depends on the EdDSA MPS
+ * module, and vice versa. The EdDSA helpers themselves remain scalar
+ * (single-signable): EdDSA is not part of the multi-spend cutover.
+ *
+ * Since `@bitgo/wasm-mps` 1.17.0, key re-randomization is a separate 2-round
+ * rerand protocol that must run before every RedPallas DSG, between the same 2
+ * parties that will then sign: `getRerandShareRoundOne/Two` build those share
+ * records and `verifyPeerRerandMessageRoundOne/Two` unwrap the peer's rerand
+ * messages (see `RedPallasRerand` in `@bitgo-beta/sdk-lib-mpc`). Rerand R1 seeds
+ * every spend's session from the SAME DKG keyshare; after R2 each spend has its
+ * own rerand result `{keyShare, pk, alpha}`. The per-spend `keyShare` - never
+ * the bare DKG keyshare - initializes that spend's DSG session, and the DSG
+ * signature verifies under `rk == pk` of the same spend.
  */
 /**
  * Builds the round-1 signature share record.
  *
- * PGP-signs the WASM round-0 broadcast message with the signer's ephemeral key and
- * wraps it into a SignatureShareRecord ready for `sendSignatureShareV2`.
+ * PGP-signs each spend's WASM round-0 broadcast message with the signer's
+ * ephemeral key and wraps all N of them, in spend order, into ONE
+ * SignatureShareRecord (`msg1` array) ready for `sendSignatureShareV2`.
  */
-async function getSignatureShareRoundOne(userMsg1, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const signedMsg1 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey);
+async function getSignatureShareRoundOne(userMsg1s, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
+    (0, assert_1.default)(userMsg1s.length >= 1, 'Expected at least 1 round-1 message (one per shielded spend)');
+    const signedMsg1s = await Promise.all(userMsg1s.map((userMsg1) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey)));
     const share = {
         type: 'round1Input',
-        data: { msg1: signedMsg1 },
+        data: { msg1: signedMsg1s },
     };
     return {
         from: partyIdToSignatureShareType(partyId),
@@ -61,24 +96,31 @@ async function getSignatureShareRoundOne(userMsg1, userGpgPrivKey, partyId = typ
     };
 }
 /**
- * Verifies the peer's round-1 PGP signature and returns the raw deserialized
- * message ready for `RedPallasDSG.handleIncomingMessages`.
+ * Verifies the peer's round-1 PGP signatures and returns the raw deserialized
+ * messages, one per shielded spend in the peer's array order, ready for
+ * `RedPallasDSG.handleIncomingMessages` (feed `msg1[i]` into spend i's session).
+ * All-or-nothing: a single failed verification rejects the whole round.
  */
 async function verifyPeerMessageRoundOne(parsedRound1Output, peerGpgKey, peerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(parsedRound1Output.data.msg1, peerGpgKey);
-    return {
-        from: peerPartyId,
-        payload: new Uint8Array(rawBytes),
-    };
+    const verifiedMsgs = [];
+    for (const signedMsg1 of parsedRound1Output.data.msg1) {
+        const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg1, peerGpgKey);
+        verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });
+    }
+    return verifiedMsgs;
 }
 /**
  * Builds the round-2 signature share record.
+ *
+ * PGP-signs each spend's round-2 message and wraps all N of them, in spend
+ * order, into ONE SignatureShareRecord (`msg2` array).
  */
-async function getSignatureShareRoundTwo(userMsg2, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const signedMsg2 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey);
+async function getSignatureShareRoundTwo(userMsg2s, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
+    (0, assert_1.default)(userMsg2s.length >= 1, 'Expected at least 1 round-2 message (one per shielded spend)');
+    const signedMsg2s = await Promise.all(userMsg2s.map((userMsg2) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey)));
     const share = {
         type: 'round2Input',
-        data: { msg2: signedMsg2 },
+        data: { msg2: signedMsg2s },
     };
     return {
         from: partyIdToSignatureShareType(partyId),
@@ -87,36 +129,49 @@ async function getSignatureShareRoundTwo(userMsg2, userGpgPrivKey, partyId = typ
     };
 }
 /**
- * Verifies the peer's round-2 PGP signature and returns the raw deserialized
- * message ready for `RedPallasDSG.handleIncomingMessages`.
+ * Verifies the peer's round-2 PGP signatures and returns the raw deserialized
+ * messages, one per shielded spend in the peer's array order, ready for
+ * `RedPallasDSG.handleIncomingMessages` (feed `msg2[i]` into spend i's session).
+ * All-or-nothing: a single failed verification rejects the whole round.
  */
 async function verifyPeerMessageRoundTwo(parsedRound2Output, peerGpgKey, peerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(parsedRound2Output.data.msg2, peerGpgKey);
-    return {
-        from: peerPartyId,
-        payload: new Uint8Array(rawBytes),
-    };
+    const verifiedMsgs = [];
+    for (const signedMsg2 of parsedRound2Output.data.msg2) {
+        const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg2, peerGpgKey);
+        verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });
+    }
+    return verifiedMsgs;
 }
 /**
- * Verifies the peer's round-3 PGP signature and returns the raw deserialized
- * message ready for `RedPallasDSG.handleIncomingMessages`.
+ * Verifies the peer's round-3 PGP signatures and returns the raw deserialized
+ * messages, one per shielded spend in the peer's array order, ready for
+ * `RedPallasDSG.handleIncomingMessages` (feed `msg3[i]` into spend i's session).
+ * All-or-nothing: a single failed verification rejects the whole round.
  */
 async function verifyPeerMessageRoundThree(parsedRound3Output, peerGpgKey, peerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(parsedRound3Output.data.msg3, peerGpgKey);
-    return { from: peerPartyId, payload: new Uint8Array(rawBytes) };
+    const verifiedMsgs = [];
+    for (const signedMsg3 of parsedRound3Output.data.msg3) {
+        const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg3, peerGpgKey);
+        verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });
+    }
+    return verifiedMsgs;
 }
 /**
- * Builds the round-3 signature share record (final signer message).
+ * Builds the round-3 signature share record (final signer messages).
+ *
+ * PGP-signs each spend's round-3 message and wraps all N of them, in spend
+ * order, into ONE SignatureShareRecord (`msg3` array).
  *
  * There is no corresponding `verifyBitGoMessageRoundThree` because Wallet Platform
- * finalises the signing server-side after receiving round 3; the client obtains the
- * signed transaction via `sendTxRequest`.
+ * finalises the signing server-side after receiving round 3; the client obtains
+ * the signed transaction via `sendTxRequest`.
  */
-async function getSignatureShareRoundThree(userMsg3, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const signedMsg3 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg3.payload), userGpgPrivKey);
+async function getSignatureShareRoundThree(userMsg3s, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
+    (0, assert_1.default)(userMsg3s.length >= 1, 'Expected at least 1 round-3 message (one per shielded spend)');
+    const signedMsg3s = await Promise.all(userMsg3s.map((userMsg3) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg3.payload), userGpgPrivKey)));
     const share = {
         type: 'round3Input',
-        data: { msg3: signedMsg3 },
+        data: { msg3: signedMsg3s },
     };
     return {
         from: partyIdToSignatureShareType(partyId),
@@ -127,14 +182,18 @@ async function getSignatureShareRoundThree(userMsg3, userGpgPrivKey, partyId = t
 /**
  * Builds the rerand round-1 signature share record.
  *
- * Rerand must run before every RedPallas DSG, with the same counterpart. Round 1
- * carries the PGP-signed WASM commitment broadcast (`RedPallasRerand.getFirstMessage()`).
+ * Rerand must run before every RedPallas DSG, with the same counterpart, once
+ * per shielded spend: the caller initializes N `RedPallasRerand` sessions on the
+ * SAME DKG keyshare and passes each session's `getFirstMessage()`, in spend
+ * order. Round 1 carries the PGP-signed WASM commitments; all N are wrapped
+ * into ONE SignatureShareRecord (`msg1` array).
  */
-async function getRerandShareRoundOne(userMsg1, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const signedMsg1 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey);
+async function getRerandShareRoundOne(userMsg1s, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
+    (0, assert_1.default)(userMsg1s.length >= 1, 'Expected at least 1 rerand round-1 message (one per shielded spend)');
+    const signedMsg1s = await Promise.all(userMsg1s.map((userMsg1) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey)));
     const share = {
         type: 'round1Input',
-        data: { msg1: signedMsg1 },
+        data: { msg1: signedMsg1s },
     };
     return {
         from: partyIdToSignatureShareType(partyId),
@@ -143,24 +202,32 @@ async function getRerandShareRoundOne(userMsg1, userGpgPrivKey, partyId = typesM
     };
 }
 /**
- * Verifies the peer's rerand round-1 PGP signature and returns the raw deserialized
- * message ready for `RedPallasRerand.handleIncomingMessages`.
+ * Verifies the peer's rerand round-1 PGP signatures and returns the raw
+ * deserialized messages, one per shielded spend in the peer's array order,
+ * ready for `RedPallasRerand.handleIncomingMessages` (feed `msg1[i]` into
+ * spend i's session). All-or-nothing: a single failed verification rejects the
+ * whole round.
  */
 async function verifyPeerRerandMessageRoundOne(parsedRound1Output, peerGpgKey, peerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(parsedRound1Output.data.msg1, peerGpgKey);
-    return {
-        from: peerPartyId,
-        payload: new Uint8Array(rawBytes),
-    };
+    const verifiedMsgs = [];
+    for (const signedMsg1 of parsedRound1Output.data.msg1) {
+        const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg1, peerGpgKey);
+        verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });
+    }
+    return verifiedMsgs;
 }
 /**
- * Builds the rerand round-2 signature share record (opening message).
+ * Builds the rerand round-2 signature share record (opening messages).
+ *
+ * PGP-signs each spend's rerand round-2 message and wraps all N of them, in
+ * spend order, into ONE SignatureShareRecord (`msg2` array).
  */
-async function getRerandShareRoundTwo(userMsg2, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const signedMsg2 = await sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey);
+async function getRerandShareRoundTwo(userMsg2s, userGpgPrivKey, partyId = typesMPCv2_1.MPCv2PartiesEnum.USER, otherSignerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
+    (0, assert_1.default)(userMsg2s.length >= 1, 'Expected at least 1 rerand round-2 message (one per shielded spend)');
+    const signedMsg2s = await Promise.all(userMsg2s.map((userMsg2) => sdk_lib_mpc_1.RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey)));
     const share = {
         type: 'round2Input',
-        data: { msg2: signedMsg2 },
+        data: { msg2: signedMsg2s },
     };
     return {
         from: partyIdToSignatureShareType(partyId),
@@ -169,16 +236,20 @@ async function getRerandShareRoundTwo(userMsg2, userGpgPrivKey, partyId = typesM
     };
 }
 /**
- * Verifies the peer's rerand round-2 PGP signature and returns the raw deserialized
- * message ready for `RedPallasRerand.handleIncomingMessages`. After this exchange
- * both parties read the rerandomized keyshare via `getRerandomizedKeyShare()` and
- * feed it into `RedPallasDSG.initDsg`.
+ * Verifies the peer's rerand round-2 PGP signatures and returns the raw
+ * deserialized messages, one per shielded spend in the peer's array order,
+ * ready for `RedPallasRerand.handleIncomingMessages` (feed `msg2[i]` into
+ * spend i's session). All-or-nothing: a single failed verification rejects the
+ * whole round. After this exchange both parties read each spend's
+ * rerandomized keyshare via `getRerandomizedKeyShare()` and feed it into that
+ * spend's `RedPallasDSG.initDsg` - never the bare DKG keyshare.
  */
 async function verifyPeerRerandMessageRoundTwo(parsedRound2Output, peerGpgKey, peerPartyId = typesMPCv2_1.MPCv2PartiesEnum.BITGO) {
-    const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(parsedRound2Output.data.msg2, peerGpgKey);
-    return {
-        from: peerPartyId,
-        payload: new Uint8Array(rawBytes),
-    };
+    const verifiedMsgs = [];
+    for (const signedMsg2 of parsedRound2Output.data.msg2) {
+        const rawBytes = await sdk_lib_mpc_1.RedPallasMPSComms.verifyMpsMessage(signedMsg2, peerGpgKey);
+        verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });
+    }
+    return verifiedMsgs;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redpallasMPCv2.js","sourceRoot":"","sources":["../../../../../src/bitgo/tss/redpallas/redpallasMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import * as openpgp 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 '../../utils/tss/baseTypes';\nimport { MPCv2PartiesEnum } from '../../utils/tss/ecdsa/typesMPCv2';\n\ntype SignerPartyId = MPCv2PartiesEnum.USER | MPCv2PartiesEnum.BACKUP;\n\nfunction partyIdToSignatureShareType(partyId: MPCv2PartiesEnum): SignatureShareType {\n  switch (partyId) {\n    case MPCv2PartiesEnum.USER:\n      return SignatureShareType.USER;\n    case MPCv2PartiesEnum.BACKUP:\n      return SignatureShareType.BACKUP;\n    case MPCv2PartiesEnum.BITGO:\n      return SignatureShareType.BITGO;\n  }\n}\n\n/**\n * RedPallas MPS DSG and rerand signature-share helpers.\n *\n * Consumed by the custodial/cold (SMC/OVC) signing flow: OVC builds its rerand and DSG\n * shares with these and submits them via the /sign txRequest route (see\n * `sendSignatureShareV2`, body types `redPallasRerand` / `redPallasMpcV2`). No caller\n * inside this SDK yet. Mirrors `../eddsa/eddsaMPCv2.ts` (same round shape, same\n * PGP-signed-message envelope), but kept as an independent copy - built on\n * `RedPallasMPSComms` - so RedPallas MPS never depends on the EdDSA MPS module, and\n * vice versa.\n *\n * Since `@bitgo/wasm-mps` 1.17.0, key re-randomization is a separate 2-round rerand\n * protocol that must run before every RedPallas DSG, between the same 2 parties that\n * will then sign: `getRerandShareRoundOne/Two` build those share records and\n * `verifyPeerRerandMessageRoundOne/Two` unwrap the peer's rerand messages (see\n * `RedPallasRerand` in `@bitgo-beta/sdk-lib-mpc`). The rerand result exposes\n * `{keyShare, pk, alpha}`; `pk` is the `rk` the DSG signature verifies under, and the\n * DSG keyshare is the rerandomized `keyShare` - never the bare DKG keyshare.\n */\n\n/**\n * Builds the round-1 signature share record.\n *\n * PGP-signs the WASM round-0 broadcast message with the signer's ephemeral key and\n * wraps it into a SignatureShareRecord ready for `sendSignatureShareV2`.\n */\nexport async function getSignatureShareRoundOne(\n  userMsg1: RedPallasMPSTypes.DeserializedMessage,\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  const signedMsg1 = await RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey);\n  const share: RedpallasMPCv2SignatureShareRound1Input = {\n    type: 'round1Input',\n    data: { msg1: signedMsg1 },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's round-1 PGP signature and returns the raw deserialized\n * message ready for `RedPallasDSG.handleIncomingMessages`.\n */\nexport async function verifyPeerMessageRoundOne(\n  parsedRound1Output: RedpallasMPCv2SignatureShareRound1Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage> {\n  const rawBytes = await RedPallasMPSComms.verifyMpsMessage(parsedRound1Output.data.msg1, peerGpgKey);\n  return {\n    from: peerPartyId,\n    payload: new Uint8Array(rawBytes),\n  };\n}\n\n/**\n * Builds the round-2 signature share record.\n */\nexport async function getSignatureShareRoundTwo(\n  userMsg2: RedPallasMPSTypes.DeserializedMessage,\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  const signedMsg2 = await RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey);\n  const share: RedpallasMPCv2SignatureShareRound2Input = {\n    type: 'round2Input',\n    data: { msg2: signedMsg2 },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's round-2 PGP signature and returns the raw deserialized\n * message ready for `RedPallasDSG.handleIncomingMessages`.\n */\nexport async function verifyPeerMessageRoundTwo(\n  parsedRound2Output: RedpallasMPCv2SignatureShareRound2Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage> {\n  const rawBytes = await RedPallasMPSComms.verifyMpsMessage(parsedRound2Output.data.msg2, peerGpgKey);\n  return {\n    from: peerPartyId,\n    payload: new Uint8Array(rawBytes),\n  };\n}\n\n/**\n * Verifies the peer's round-3 PGP signature and returns the raw deserialized\n * message ready for `RedPallasDSG.handleIncomingMessages`.\n */\nexport async function verifyPeerMessageRoundThree(\n  parsedRound3Output: RedpallasMPCv2SignatureShareRound3Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage> {\n  const rawBytes = await RedPallasMPSComms.verifyMpsMessage(parsedRound3Output.data.msg3, peerGpgKey);\n  return { from: peerPartyId, payload: new Uint8Array(rawBytes) };\n}\n\n/**\n * Builds the round-3 signature share record (final signer message).\n *\n * There is no corresponding `verifyBitGoMessageRoundThree` because Wallet Platform\n * finalises the signing server-side after receiving round 3; the client obtains the\n * signed transaction via `sendTxRequest`.\n */\nexport async function getSignatureShareRoundThree(\n  userMsg3: RedPallasMPSTypes.DeserializedMessage,\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  const signedMsg3 = await RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg3.payload), userGpgPrivKey);\n  const share: RedpallasMPCv2SignatureShareRound3Input = {\n    type: 'round3Input',\n    data: { msg3: signedMsg3 },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Builds the rerand round-1 signature share record.\n *\n * Rerand must run before every RedPallas DSG, with the same counterpart. Round 1\n * carries the PGP-signed WASM commitment broadcast (`RedPallasRerand.getFirstMessage()`).\n */\nexport async function getRerandShareRoundOne(\n  userMsg1: RedPallasMPSTypes.DeserializedMessage,\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  const signedMsg1 = await RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey);\n  const share: RedpallasMPCv2RerandShareRound1Input = {\n    type: 'round1Input',\n    data: { msg1: signedMsg1 },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's rerand round-1 PGP signature and returns the raw deserialized\n * message ready for `RedPallasRerand.handleIncomingMessages`.\n */\nexport async function verifyPeerRerandMessageRoundOne(\n  parsedRound1Output: RedpallasMPCv2RerandShareRound1Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage> {\n  const rawBytes = await RedPallasMPSComms.verifyMpsMessage(parsedRound1Output.data.msg1, peerGpgKey);\n  return {\n    from: peerPartyId,\n    payload: new Uint8Array(rawBytes),\n  };\n}\n\n/**\n * Builds the rerand round-2 signature share record (opening message).\n */\nexport async function getRerandShareRoundTwo(\n  userMsg2: RedPallasMPSTypes.DeserializedMessage,\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  const signedMsg2 = await RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey);\n  const share: RedpallasMPCv2RerandShareRound2Input = {\n    type: 'round2Input',\n    data: { msg2: signedMsg2 },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's rerand round-2 PGP signature and returns the raw deserialized\n * message ready for `RedPallasRerand.handleIncomingMessages`. After this exchange\n * both parties read the rerandomized keyshare via `getRerandomizedKeyShare()` and\n * feed it into `RedPallasDSG.initDsg`.\n */\nexport async function verifyPeerRerandMessageRoundTwo(\n  parsedRound2Output: RedpallasMPCv2RerandShareRound2Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage> {\n  const rawBytes = await RedPallasMPSComms.verifyMpsMessage(parsedRound2Output.data.msg2, peerGpgKey);\n  return {\n    from: peerPartyId,\n    payload: new Uint8Array(rawBytes),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redpallasMPCv2.js","sourceRoot":"","sources":["../../../../../src/bitgo/tss/redpallas/redpallasMPCv2.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport * as openpgp 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 '../../utils/tss/baseTypes';\nimport { MPCv2PartiesEnum } from '../../utils/tss/ecdsa/typesMPCv2';\n\ntype SignerPartyId = MPCv2PartiesEnum.USER | MPCv2PartiesEnum.BACKUP;\n\nfunction partyIdToSignatureShareType(partyId: MPCv2PartiesEnum): SignatureShareType {\n  switch (partyId) {\n    case MPCv2PartiesEnum.USER:\n      return SignatureShareType.USER;\n    case MPCv2PartiesEnum.BACKUP:\n      return SignatureShareType.BACKUP;\n    case MPCv2PartiesEnum.BITGO:\n      return SignatureShareType.BITGO;\n  }\n}\n\n/**\n * RedPallas MPS DSG and rerand signature-share helpers (multi-spend, WCI-1949).\n *\n * A shielded ZEC transaction can spend several Orchard notes; every per-spend\n * value on the /sign wire is an ARRAY of length N ordered by spend index, where\n * N is the number of Orchard spends\n * (`txRequest.transactions[i].unsignedTx.parsedTx.inputs.length`), derived on\n * the client and never a wire field. Each spend runs its own rerand session and\n * its own DSG session (N instances of `RedPallasRerand` / `RedPallasDSG` — they\n * are single-session by design; the per-spend fan-out lives in the caller, see\n * OVC's `MpcSignerRedPallas`), but each round still produces exactly ONE\n * `SignatureShareRecord` per transaction: the builders below take N\n * PGP-signed messages in and emit one record whose `msgN` is the spend-ordered\n * array; the verifiers take a parsed peer `roundNOutput` (msgN array) and\n * return N verified messages out, in the same order.\n *\n * Builders:\n * - assert a non-empty input array (N >= 1; an Orchard spend transaction has at\n *   least one input) and preserve spend order — Wallet Platform index-pairs\n *   `msgN[i]` with spend i's HSM state, so a misordered array silently mispairs\n *   spends.\n * - emit exactly ONE share record per round — WP reads only the LAST share in\n *   `signatureShares`; multiple partial records would be silently dropped.\n *\n * Verifiers:\n * - return one verified message per array entry, same order, all signed by the\n *   BitGo RedPallas GPG key; a single failed verification fails the whole round\n *   (all-or-nothing, mirroring WP's per-round share handling).\n *\n * Consumed by the custodial/cold (SMC/OVC) signing flow: OVC builds its rerand\n * and DSG shares with these and submits them via the /sign txRequest route (see\n * `sendSignatureShareV2`, body types `redPallasRerand` / `redPallasMpcV2`). No\n * caller inside this SDK yet. Mirrors `../eddsa/eddsaMPCv2.ts` (same round\n * shape, same PGP-signed-message envelope), but kept as an independent copy -\n * built on `RedPallasMPSComms` - so RedPallas MPS never depends on the EdDSA MPS\n * module, and vice versa. The EdDSA helpers themselves remain scalar\n * (single-signable): EdDSA is not part of the multi-spend cutover.\n *\n * Since `@bitgo/wasm-mps` 1.17.0, key re-randomization is a separate 2-round\n * rerand protocol that must run before every RedPallas DSG, between the same 2\n * parties that will then sign: `getRerandShareRoundOne/Two` build those share\n * records and `verifyPeerRerandMessageRoundOne/Two` unwrap the peer's rerand\n * messages (see `RedPallasRerand` in `@bitgo-beta/sdk-lib-mpc`). Rerand R1 seeds\n * every spend's session from the SAME DKG keyshare; after R2 each spend has its\n * own rerand result `{keyShare, pk, alpha}`. The per-spend `keyShare` - never\n * the bare DKG keyshare - initializes that spend's DSG session, and the DSG\n * signature verifies under `rk == pk` of the same spend.\n */\n\n/**\n * Builds the round-1 signature share record.\n *\n * PGP-signs each spend's WASM round-0 broadcast message with the signer's\n * ephemeral key and wraps all N of them, in spend order, into ONE\n * SignatureShareRecord (`msg1` array) ready for `sendSignatureShareV2`.\n */\nexport async function getSignatureShareRoundOne(\n  userMsg1s: RedPallasMPSTypes.DeserializedMessage[],\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  assert(userMsg1s.length >= 1, 'Expected at least 1 round-1 message (one per shielded spend)');\n  const signedMsg1s = await Promise.all(\n    userMsg1s.map((userMsg1) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey))\n  );\n  const share: RedpallasMPCv2SignatureShareRound1Input = {\n    type: 'round1Input',\n    data: { msg1: signedMsg1s },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's round-1 PGP signatures and returns the raw deserialized\n * messages, one per shielded spend in the peer's array order, ready for\n * `RedPallasDSG.handleIncomingMessages` (feed `msg1[i]` into spend i's session).\n * All-or-nothing: a single failed verification rejects the whole round.\n */\nexport async function verifyPeerMessageRoundOne(\n  parsedRound1Output: RedpallasMPCv2SignatureShareRound1Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage[]> {\n  const verifiedMsgs: RedPallasMPSTypes.DeserializedMessage[] = [];\n  for (const signedMsg1 of parsedRound1Output.data.msg1) {\n    const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg1, peerGpgKey);\n    verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });\n  }\n  return verifiedMsgs;\n}\n\n/**\n * Builds the round-2 signature share record.\n *\n * PGP-signs each spend's round-2 message and wraps all N of them, in spend\n * order, into ONE SignatureShareRecord (`msg2` array).\n */\nexport async function getSignatureShareRoundTwo(\n  userMsg2s: RedPallasMPSTypes.DeserializedMessage[],\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  assert(userMsg2s.length >= 1, 'Expected at least 1 round-2 message (one per shielded spend)');\n  const signedMsg2s = await Promise.all(\n    userMsg2s.map((userMsg2) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey))\n  );\n  const share: RedpallasMPCv2SignatureShareRound2Input = {\n    type: 'round2Input',\n    data: { msg2: signedMsg2s },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's round-2 PGP signatures and returns the raw deserialized\n * messages, one per shielded spend in the peer's array order, ready for\n * `RedPallasDSG.handleIncomingMessages` (feed `msg2[i]` into spend i's session).\n * All-or-nothing: a single failed verification rejects the whole round.\n */\nexport async function verifyPeerMessageRoundTwo(\n  parsedRound2Output: RedpallasMPCv2SignatureShareRound2Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage[]> {\n  const verifiedMsgs: RedPallasMPSTypes.DeserializedMessage[] = [];\n  for (const signedMsg2 of parsedRound2Output.data.msg2) {\n    const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg2, peerGpgKey);\n    verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });\n  }\n  return verifiedMsgs;\n}\n\n/**\n * Verifies the peer's round-3 PGP signatures and returns the raw deserialized\n * messages, one per shielded spend in the peer's array order, ready for\n * `RedPallasDSG.handleIncomingMessages` (feed `msg3[i]` into spend i's session).\n * All-or-nothing: a single failed verification rejects the whole round.\n */\nexport async function verifyPeerMessageRoundThree(\n  parsedRound3Output: RedpallasMPCv2SignatureShareRound3Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage[]> {\n  const verifiedMsgs: RedPallasMPSTypes.DeserializedMessage[] = [];\n  for (const signedMsg3 of parsedRound3Output.data.msg3) {\n    const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg3, peerGpgKey);\n    verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });\n  }\n  return verifiedMsgs;\n}\n\n/**\n * Builds the round-3 signature share record (final signer messages).\n *\n * PGP-signs each spend's round-3 message and wraps all N of them, in spend\n * order, into ONE SignatureShareRecord (`msg3` array).\n *\n * There is no corresponding `verifyBitGoMessageRoundThree` because Wallet Platform\n * finalises the signing server-side after receiving round 3; the client obtains\n * the signed transaction via `sendTxRequest`.\n */\nexport async function getSignatureShareRoundThree(\n  userMsg3s: RedPallasMPSTypes.DeserializedMessage[],\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  assert(userMsg3s.length >= 1, 'Expected at least 1 round-3 message (one per shielded spend)');\n  const signedMsg3s = await Promise.all(\n    userMsg3s.map((userMsg3) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg3.payload), userGpgPrivKey))\n  );\n  const share: RedpallasMPCv2SignatureShareRound3Input = {\n    type: 'round3Input',\n    data: { msg3: signedMsg3s },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Builds the rerand round-1 signature share record.\n *\n * Rerand must run before every RedPallas DSG, with the same counterpart, once\n * per shielded spend: the caller initializes N `RedPallasRerand` sessions on the\n * SAME DKG keyshare and passes each session's `getFirstMessage()`, in spend\n * order. Round 1 carries the PGP-signed WASM commitments; all N are wrapped\n * into ONE SignatureShareRecord (`msg1` array).\n */\nexport async function getRerandShareRoundOne(\n  userMsg1s: RedPallasMPSTypes.DeserializedMessage[],\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  assert(userMsg1s.length >= 1, 'Expected at least 1 rerand round-1 message (one per shielded spend)');\n  const signedMsg1s = await Promise.all(\n    userMsg1s.map((userMsg1) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg1.payload), userGpgPrivKey))\n  );\n  const share: RedpallasMPCv2RerandShareRound1Input = {\n    type: 'round1Input',\n    data: { msg1: signedMsg1s },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's rerand round-1 PGP signatures and returns the raw\n * deserialized messages, one per shielded spend in the peer's array order,\n * ready for `RedPallasRerand.handleIncomingMessages` (feed `msg1[i]` into\n * spend i's session). All-or-nothing: a single failed verification rejects the\n * whole round.\n */\nexport async function verifyPeerRerandMessageRoundOne(\n  parsedRound1Output: RedpallasMPCv2RerandShareRound1Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage[]> {\n  const verifiedMsgs: RedPallasMPSTypes.DeserializedMessage[] = [];\n  for (const signedMsg1 of parsedRound1Output.data.msg1) {\n    const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg1, peerGpgKey);\n    verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });\n  }\n  return verifiedMsgs;\n}\n\n/**\n * Builds the rerand round-2 signature share record (opening messages).\n *\n * PGP-signs each spend's rerand round-2 message and wraps all N of them, in\n * spend order, into ONE SignatureShareRecord (`msg2` array).\n */\nexport async function getRerandShareRoundTwo(\n  userMsg2s: RedPallasMPSTypes.DeserializedMessage[],\n  userGpgPrivKey: openpgp.PrivateKey,\n  partyId: SignerPartyId = MPCv2PartiesEnum.USER,\n  otherSignerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<SignatureShareRecord> {\n  assert(userMsg2s.length >= 1, 'Expected at least 1 rerand round-2 message (one per shielded spend)');\n  const signedMsg2s = await Promise.all(\n    userMsg2s.map((userMsg2) => RedPallasMPSComms.detachSignMpsMessage(Buffer.from(userMsg2.payload), userGpgPrivKey))\n  );\n  const share: RedpallasMPCv2RerandShareRound2Input = {\n    type: 'round2Input',\n    data: { msg2: signedMsg2s },\n  };\n  return {\n    from: partyIdToSignatureShareType(partyId),\n    to: partyIdToSignatureShareType(otherSignerPartyId),\n    share: JSON.stringify(share),\n  };\n}\n\n/**\n * Verifies the peer's rerand round-2 PGP signatures and returns the raw\n * deserialized messages, one per shielded spend in the peer's array order,\n * ready for `RedPallasRerand.handleIncomingMessages` (feed `msg2[i]` into\n * spend i's session). All-or-nothing: a single failed verification rejects the\n * whole round. After this exchange both parties read each spend's\n * rerandomized keyshare via `getRerandomizedKeyShare()` and feed it into that\n * spend's `RedPallasDSG.initDsg` - never the bare DKG keyshare.\n */\nexport async function verifyPeerRerandMessageRoundTwo(\n  parsedRound2Output: RedpallasMPCv2RerandShareRound2Output,\n  peerGpgKey: openpgp.Key,\n  peerPartyId: MPCv2PartiesEnum = MPCv2PartiesEnum.BITGO\n): Promise<RedPallasMPSTypes.DeserializedMessage[]> {\n  const verifiedMsgs: RedPallasMPSTypes.DeserializedMessage[] = [];\n  for (const signedMsg2 of parsedRound2Output.data.msg2) {\n    const rawBytes = await RedPallasMPSComms.verifyMpsMessage(signedMsg2, peerGpgKey);\n    verifiedMsgs.push({ from: peerPartyId, payload: new Uint8Array(rawBytes) });\n  }\n  return verifiedMsgs;\n}\n"]}