@bitgo-beta/sdk-lib-mpc 8.2.0-beta.2093 → 8.2.0-beta.2094

package/dist/src/tss/redpallas-mps/dsg.d.ts

@@ -10,10 +10,18 @@ import { DeserializedMessage, DeserializedMessages, RedPallasDsgState, RedPallas
  *   (ask/nk/rivk/ivks) happens upstream, as part of DKG (`redpallas_dkg_round2_process` +
  *   the platform-side-only `redpallas_derivation_process`); DSG only ever operates on an
  *   already-derived (or root) opaque `Keyshare`.
+ * - DSG does not randomize the key it signs with: since `@bitgo/wasm-mps` 1.17.0, key
+ *   re-randomization is a separate `rerand` protocol (see `./rerand.ts`, `RedPallasRerand`)
+ *   that must run before every DSG, between the same 2 parties. The keyshare passed to
+ *   `initDsg` must be the `keyShare` from that rerand result.
  * - Round3 does not return a raw signature; it returns a `RedPallasSignature` bundle of
- *   `signature` (64 raw bytes), `rk` (the randomized verification key the signature
- *   verifies against — NOT the DKG public key) and `alpha` (the 32-byte randomizer scalar
- *   used to re-randomize the DKG public key into `rk`). See `RedPallasSignatureResult`.
+ *   `signature` (64 raw bytes) and `rk` (the rerandomized verification key the signature
+ *   verifies against — NOT the DKG public key). `rk` equals the `pk` of the rerand result
+ *   the DSG session was initialized with. See `RedPallasSignatureResult`.
+ *
+ * Signing a stored DKG keyshare directly (without rerand) still produces a valid
+ * signature — under the bare DKG public key, with the same `rk` every spend — but the
+ * supported, tested path is rerand → DSG.
  *
  * State is explicit: each WASM round function returns `{ msg, state }` bytes; the state
  * bytes are stored between rounds and passed to the next round function (this is what a
@@ -25,13 +33,21 @@ import { DeserializedMessage, DeserializedMessages, RedPallasDsgState, RedPallas
  *
  * @example
  * ```typescript
+ * // Rerand first — same 2 parties that will sign (see RedPallasRerand).
+ * const rerand = new RedPallasRerand(0);
+ * await rerand.initRerand(dkgKeyShare, 2);
+ * const rerandMsg1 = rerand.getFirstMessage();
+ * const rerandMsg2 = rerand.handleIncomingMessages([rerandMsg1, peerRerandMsg1]);
+ * rerand.handleIncomingMessages([rerandMsg2[0], peerRerandMsg2]);
+ * const { keyShare, pk, alpha } = rerand.getRerandomizedKeyShare();
+ *
  * const dsg = new RedPallasDSG(0);  // partyIdx 0
  * await dsg.initDsg(keyShare, message, 2);  // counterpart is party 2
  * const msg1 = dsg.getFirstMessage();
  * const msg2 = dsg.handleIncomingMessages([msg1, peerMsg1]);  // emits SignMsg2
  * const msg3 = dsg.handleIncomingMessages([msg2[0], peerMsg2]);  // emits SignMsg3
  * dsg.handleIncomingMessages([msg3[0], peerMsg3]);  // completes DSG
- * const { signature, rk, alpha } = dsg.getSignature();  // 64-byte RedPallas signature + rk/alpha
+ * const { signature, rk } = dsg.getSignature();  // verifies under rk == pk
  * ```
  */
 export declare class RedPallasDSG {
@@ -55,14 +71,19 @@ export declare class RedPallasDSG {
     private loadWasmMps;
     private getWasmMps;
     /**
-     * Initialises the DSG session. The keyshare must come from a prior DKG run (and, if a
-     * derived key is being used, from the subsequent platform-side derivation process), and
-     * `otherPartyIdx` must be the single counterpart who will co-sign with this party.
+     * Initialises the DSG session. The keyshare must be the rerandomized `keyShare` from
+     * a prior `RedPallasRerand` run with the same counterpart (which itself takes the
+     * opaque Keyshare from DKG — already derived, if applicable). Signing a bare DKG
+     * keyshare produces a valid but non-rerandomized signature under the DKG public key;
+     * use rerand → DSG instead. `otherPartyIdx` must be the single counterpart who ran
+     * that rerand session and will co-sign with this party.
      *
-     * @param keyShare - Opaque bincode-serialised Keyshare bytes from `RedPallasDKG.getKeyShare()`.
+     * @param keyShare - Opaque bincode-serialised rerandomized Keyshare bytes from
+     *   `RedPallasRerand.getRerandomizedKeyShare().keyShare`.
      * @param message - Raw message bytes to sign.
      * @param otherPartyIdx - Party index of the single counterpart in this signing session.
-     *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.
+     *   Must differ from this party's own `partyIdx` and be in `[0, 2]`, and match the
+     *   counterpart of the preceding rerand session.
      */
     initDsg(keyShare: Buffer, message: Buffer, otherPartyIdx: number): Promise<void>;
     /**
@@ -88,9 +109,10 @@ export declare class RedPallasDSG {
     handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
     /**
      * Returns the final signature bundle produced by round 3: the 64-byte raw RedPallas
-     * signature, the randomized verification key `rk` it must be verified against (via
-     * `redpallas_verify(rk, signature, message)` — NOT the DKG public key), and the
-     * `alpha` randomizer scalar used to derive `rk` from the DKG public key.
+     * signature and the rerandomized verification key `rk` it must be verified against
+     * (via `redpallas_verify(rk, signature, message)` — NOT the DKG public key). `rk`
+     * equals the `pk` of the rerand result this session was initialized with; the
+     * corresponding `alpha` is available from `RedPallasRerand.getRerandomizedKeyShare()`.
      */
     getSignature(): RedPallasSignatureResult;
     /**

package/dist/src/tss/redpallas-mps/dsg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dsg.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/dsg.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAMjH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,YAAY;IACvB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE9C,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,CAAuB;IACvC,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAuB;IAEtC,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAAuB;IAC5C,mEAAmE;IACnE,OAAO,CAAC,eAAe,CAAyC;IAChE,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAwB;IAEvC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,CAAmC;gBAE5D,QAAQ,EAAE,MAAM;IAI5B,QAAQ,IAAI,iBAAiB;IAI7B,WAAW,IAAI,MAAM;IAIrB,gBAAgB,IAAI,MAAM,GAAG,IAAI;YAInB,WAAW;IAoBzB,OAAO,CAAC,UAAU;IAOlB;;;;;;;;;OASG;IACG,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBtF;;;;OAIG;IACH,eAAe,IAAI,mBAAmB;IAoBtC;;;;;;;;;;;;;OAaG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IA0EvF;;;;;OAKG;IACH,YAAY,IAAI,wBAAwB;IAOxC;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAoBpB;;;OAGG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAwDrD"}
+{"version":3,"file":"dsg.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/dsg.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAMjH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,qBAAa,YAAY;IACvB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE9C,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,CAAuB;IACvC,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAuB;IAEtC,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAAuB;IAC5C,mEAAmE;IACnE,OAAO,CAAC,eAAe,CAAyC;IAChE,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAwB;IAEvC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,CAAmC;gBAE5D,QAAQ,EAAE,MAAM;IAI5B,QAAQ,IAAI,iBAAiB;IAI7B,WAAW,IAAI,MAAM;IAIrB,gBAAgB,IAAI,MAAM,GAAG,IAAI;YAInB,WAAW;IAoBzB,OAAO,CAAC,UAAU;IAOlB;;;;;;;;;;;;;;OAcG;IACG,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBtF;;;;OAIG;IACH,eAAe,IAAI,mBAAmB;IAoBtC;;;;;;;;;;;;;OAaG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IAyEvF;;;;;;OAMG;IACH,YAAY,IAAI,wBAAwB;IAOxC;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAoBpB;;;OAGG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAwDrD"}

package/dist/src/tss/redpallas-mps/dsg.js

@@ -50,10 +50,18 @@ const types_1 = require("./types");
  *   (ask/nk/rivk/ivks) happens upstream, as part of DKG (`redpallas_dkg_round2_process` +
  *   the platform-side-only `redpallas_derivation_process`); DSG only ever operates on an
  *   already-derived (or root) opaque `Keyshare`.
+ * - DSG does not randomize the key it signs with: since `@bitgo/wasm-mps` 1.17.0, key
+ *   re-randomization is a separate `rerand` protocol (see `./rerand.ts`, `RedPallasRerand`)
+ *   that must run before every DSG, between the same 2 parties. The keyshare passed to
+ *   `initDsg` must be the `keyShare` from that rerand result.
  * - Round3 does not return a raw signature; it returns a `RedPallasSignature` bundle of
- *   `signature` (64 raw bytes), `rk` (the randomized verification key the signature
- *   verifies against — NOT the DKG public key) and `alpha` (the 32-byte randomizer scalar
- *   used to re-randomize the DKG public key into `rk`). See `RedPallasSignatureResult`.
+ *   `signature` (64 raw bytes) and `rk` (the rerandomized verification key the signature
+ *   verifies against — NOT the DKG public key). `rk` equals the `pk` of the rerand result
+ *   the DSG session was initialized with. See `RedPallasSignatureResult`.
+ *
+ * Signing a stored DKG keyshare directly (without rerand) still produces a valid
+ * signature — under the bare DKG public key, with the same `rk` every spend — but the
+ * supported, tested path is rerand → DSG.
  *
  * State is explicit: each WASM round function returns `{ msg, state }` bytes; the state
  * bytes are stored between rounds and passed to the next round function (this is what a
@@ -65,13 +73,21 @@ const types_1 = require("./types");
  *
  * @example
  * ```typescript
+ * // Rerand first — same 2 parties that will sign (see RedPallasRerand).
+ * const rerand = new RedPallasRerand(0);
+ * await rerand.initRerand(dkgKeyShare, 2);
+ * const rerandMsg1 = rerand.getFirstMessage();
+ * const rerandMsg2 = rerand.handleIncomingMessages([rerandMsg1, peerRerandMsg1]);
+ * rerand.handleIncomingMessages([rerandMsg2[0], peerRerandMsg2]);
+ * const { keyShare, pk, alpha } = rerand.getRerandomizedKeyShare();
+ *
  * const dsg = new RedPallasDSG(0);  // partyIdx 0
  * await dsg.initDsg(keyShare, message, 2);  // counterpart is party 2
  * const msg1 = dsg.getFirstMessage();
  * const msg2 = dsg.handleIncomingMessages([msg1, peerMsg1]);  // emits SignMsg2
  * const msg3 = dsg.handleIncomingMessages([msg2[0], peerMsg2]);  // emits SignMsg3
  * dsg.handleIncomingMessages([msg3[0], peerMsg3]);  // completes DSG
- * const { signature, rk, alpha } = dsg.getSignature();  // 64-byte RedPallas signature + rk/alpha
+ * const { signature, rk } = dsg.getSignature();  // verifies under rk == pk
  * ```
  */
 class RedPallasDSG {
@@ -124,14 +140,19 @@ class RedPallasDSG {
         return this.wasmMps;
     }
     /**
-     * Initialises the DSG session. The keyshare must come from a prior DKG run (and, if a
-     * derived key is being used, from the subsequent platform-side derivation process), and
-     * `otherPartyIdx` must be the single counterpart who will co-sign with this party.
+     * Initialises the DSG session. The keyshare must be the rerandomized `keyShare` from
+     * a prior `RedPallasRerand` run with the same counterpart (which itself takes the
+     * opaque Keyshare from DKG — already derived, if applicable). Signing a bare DKG
+     * keyshare produces a valid but non-rerandomized signature under the DKG public key;
+     * use rerand → DSG instead. `otherPartyIdx` must be the single counterpart who ran
+     * that rerand session and will co-sign with this party.
      *
-     * @param keyShare - Opaque bincode-serialised Keyshare bytes from `RedPallasDKG.getKeyShare()`.
+     * @param keyShare - Opaque bincode-serialised rerandomized Keyshare bytes from
+     *   `RedPallasRerand.getRerandomizedKeyShare().keyShare`.
      * @param message - Raw message bytes to sign.
      * @param otherPartyIdx - Party index of the single counterpart in this signing session.
-     *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.
+     *   Must differ from this party's own `partyIdx` and be in `[0, 2]`, and match the
+     *   counterpart of the preceding rerand session.
      */
     async initDsg(keyShare, message, otherPartyIdx) {
         await this.loadWasmMps();
@@ -250,7 +271,6 @@ class RedPallasDSG {
             this.signatureResult = {
                 signature: Buffer.from(result.signature),
                 rk: Buffer.from(result.rk),
-                alpha: Buffer.from(result.alpha),
             };
             this.dsgStateBytes = null;
             this.dsgState = types_1.RedPallasDsgState.Complete;
@@ -260,9 +280,10 @@ class RedPallasDSG {
     }
     /**
      * Returns the final signature bundle produced by round 3: the 64-byte raw RedPallas
-     * signature, the randomized verification key `rk` it must be verified against (via
-     * `redpallas_verify(rk, signature, message)` — NOT the DKG public key), and the
-     * `alpha` randomizer scalar used to derive `rk` from the DKG public key.
+     * signature and the rerandomized verification key `rk` it must be verified against
+     * (via `redpallas_verify(rk, signature, message)` — NOT the DKG public key). `rk`
+     * equals the `pk` of the rerand result this session was initialized with; the
+     * corresponding `alpha` is available from `RedPallasRerand.getRerandomizedKeyShare()`.
      */
     getSignature() {
         if (!this.signatureResult) {
@@ -352,4 +373,4 @@ class RedPallasDSG {
     }
 }
 exports.RedPallasDSG = RedPallasDSG;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dsg.js","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/dsg.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport type { MsgState, RedPallasSignature } from '@bitgo/wasm-mps';\nimport { DeserializedMessage, DeserializedMessages, RedPallasDsgState, RedPallasSignatureResult } from './types';\n\ntype NodeWasmer = typeof import('@bitgo/wasm-mps');\ntype WebWasmer = typeof import('@bitgo/wasm-mps/web');\ntype WasmMps = NodeWasmer | WebWasmer;\n\n/**\n * RedPallas (Zcash Ironwood) Distributed Sign Generation (DSG) implementation using\n * @bitgo/wasm-mps.\n *\n * Mirrors the structure of the EdDSA MPS `DSG` class (see `../eddsa-mps/dsg.ts`), but wraps\n * the `redpallas_dsg_*` WASM bindings. Unlike the EdDSA version:\n *\n * - `redpallas_dsg_round0_process` does not take a derivation path: RedPallas key derivation\n *   (ask/nk/rivk/ivks) happens upstream, as part of DKG (`redpallas_dkg_round2_process` +\n *   the platform-side-only `redpallas_derivation_process`); DSG only ever operates on an\n *   already-derived (or root) opaque `Keyshare`.\n * - Round3 does not return a raw signature; it returns a `RedPallasSignature` bundle of\n *   `signature` (64 raw bytes), `rk` (the randomized verification key the signature\n *   verifies against — NOT the DKG public key) and `alpha` (the 32-byte randomizer scalar\n *   used to re-randomize the DKG public key into `rk`). See `RedPallasSignatureResult`.\n *\n * State is explicit: each WASM round function returns `{ msg, state }` bytes; the state\n * bytes are stored between rounds and passed to the next round function (this is what a\n * server would persist to a database between API rounds).\n *\n * The protocol is hard-coded 2-of-3: each signing party communicates with exactly one\n * counterpart. `handleIncomingMessages` accepts both messages (own + counterpart), and\n * filters own out internally.\n *\n * @example\n * ```typescript\n * const dsg = new RedPallasDSG(0);  // partyIdx 0\n * await dsg.initDsg(keyShare, message, 2);  // counterpart is party 2\n * const msg1 = dsg.getFirstMessage();\n * const msg2 = dsg.handleIncomingMessages([msg1, peerMsg1]);  // emits SignMsg2\n * const msg3 = dsg.handleIncomingMessages([msg2[0], peerMsg2]);  // emits SignMsg3\n * dsg.handleIncomingMessages([msg3[0], peerMsg3]);  // completes DSG\n * const { signature, rk, alpha } = dsg.getSignature();  // 64-byte RedPallas signature + rk/alpha\n * ```\n */\nexport class RedPallasDSG {\n  protected partyIdx: number;\n  protected otherPartyIdx: number | null = null;\n\n  /** Opaque bincode-serialised Keyshare from a prior DKG (already derived, if applicable) */\n  private keyShare: Buffer | null = null;\n  /** Raw message bytes to sign */\n  private message: Buffer | null = null;\n\n  /** Serialised round state bytes returned by the previous round function */\n  private dsgStateBytes: Buffer | null = null;\n  /** Final signature bundle, available after WaitMsg3 -> Complete */\n  private signatureResult: RedPallasSignatureResult | null = null;\n  /** Lazily loaded WASM module */\n  private wasmMps: WasmMps | null = null;\n\n  protected dsgState: RedPallasDsgState = RedPallasDsgState.Uninitialized;\n\n  constructor(partyIdx: number) {\n    this.partyIdx = partyIdx;\n  }\n\n  getState(): RedPallasDsgState {\n    return this.dsgState;\n  }\n\n  getPartyIdx(): number {\n    return this.partyIdx;\n  }\n\n  getOtherPartyIdx(): number | null {\n    return this.otherPartyIdx;\n  }\n\n  private async loadWasmMps(): Promise<void> {\n    if (!this.wasmMps) {\n      if (\n        typeof window !== 'undefined' &&\n        /* checks for electron processes */\n        !window.process &&\n        !window.process?.['type']\n      ) {\n        // Browser: web build has explicit init() — guaranteed ready after await\n        // eslint-disable-next-line import/no-internal-modules -- @bitgo/wasm-mps exposes environment-specific subpath exports.\n        const webWasm = await import('@bitgo/wasm-mps/web');\n        await webWasm.default();\n        this.wasmMps = webWasm;\n      } else {\n        // Node.js: dynamic import() rewritten to require() by tsc → CJS build → readFileSync\n        this.wasmMps = await import('@bitgo/wasm-mps');\n      }\n    }\n  }\n\n  private getWasmMps(): WasmMps {\n    if (!this.wasmMps) {\n      throw Error('WASM module not loaded');\n    }\n    return this.wasmMps;\n  }\n\n  /**\n   * Initialises the DSG session. The keyshare must come from a prior DKG run (and, if a\n   * derived key is being used, from the subsequent platform-side derivation process), and\n   * `otherPartyIdx` must be the single counterpart who will co-sign with this party.\n   *\n   * @param keyShare - Opaque bincode-serialised Keyshare bytes from `RedPallasDKG.getKeyShare()`.\n   * @param message - Raw message bytes to sign.\n   * @param otherPartyIdx - Party index of the single counterpart in this signing session.\n   *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.\n   */\n  async initDsg(keyShare: Buffer, message: Buffer, otherPartyIdx: number): Promise<void> {\n    await this.loadWasmMps();\n    if (!keyShare || keyShare.length === 0) {\n      throw Error('Missing or invalid keyShare');\n    }\n    if (!message || message.length === 0) {\n      throw Error('Missing or invalid message');\n    }\n    if (this.partyIdx < 0 || this.partyIdx > 2) {\n      throw Error(`Invalid partyIdx ${this.partyIdx}: must be in [0, 2]`);\n    }\n    if (otherPartyIdx < 0 || otherPartyIdx > 2 || otherPartyIdx === this.partyIdx) {\n      throw Error(`Invalid otherPartyIdx ${otherPartyIdx}: must be in [0, 2] and != partyIdx`);\n    }\n\n    this.keyShare = keyShare;\n    this.message = message;\n    this.otherPartyIdx = otherPartyIdx;\n    this.dsgState = RedPallasDsgState.Init;\n  }\n\n  /**\n   * Runs round 0 of the DSG protocol. Returns this party's broadcast message\n   * (a `SignMsg1` containing the commitment to `R_i`). Stores the round state\n   * bytes internally for the next round.\n   */\n  getFirstMessage(): DeserializedMessage {\n    if (this.dsgState !== RedPallasDsgState.Init) {\n      throw Error('DSG session not initialized');\n    }\n    assert(this.keyShare, 'keyShare must be set after initDsg');\n    assert(this.message, 'message must be set after initDsg');\n\n    const wasm = this.getWasmMps();\n    let result: MsgState;\n    try {\n      result = wasm.redpallas_dsg_round0_process(this.keyShare, this.message);\n    } catch (err) {\n      throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);\n    }\n\n    this.dsgStateBytes = Buffer.from(result.state);\n    this.dsgState = RedPallasDsgState.WaitMsg1;\n    return { payload: new Uint8Array(result.msg), from: this.partyIdx };\n  }\n\n  /**\n   * Handles incoming messages for the current round and advances the protocol.\n   *\n   * - In `WaitMsg1`: runs round 1, returns this party's `SignMsg2` broadcast.\n   * - In `WaitMsg2`: runs round 2 (which internally fuses two Silence Labs transitions),\n   *   returns this party's `SignMsg3` broadcast (partial signature).\n   * - In `WaitMsg3`: runs round 3, completes DSG, returns `[]`.\n   *\n   * The caller passes both messages (own + counterpart) for symmetry with\n   * `RedPallasDKG.handleIncomingMessages`. Own message is filtered out internally; only the\n   * counterpart's payload is forwarded to the WASM round function.\n   *\n   * @param messagesForIthRound - Both messages for this round (own + counterpart).\n   */\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    if (this.dsgState === RedPallasDsgState.Complete) {\n      throw Error('DSG session already completed');\n    }\n    if (this.dsgState === RedPallasDsgState.Uninitialized) {\n      throw Error('DSG session not initialized');\n    }\n    if (this.dsgState === RedPallasDsgState.Init) {\n      throw Error(\n        'DSG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.'\n      );\n    }\n    if (messagesForIthRound.length !== 2) {\n      throw Error('Invalid number of messages for the round. Expected 2 messages (own + counterpart) for 2-of-3 DSG');\n    }\n\n    const peerMessages = messagesForIthRound.filter((m) => m.from !== this.partyIdx);\n    if (peerMessages.length !== 1) {\n      throw Error(`Expected exactly 1 counterpart message; got ${peerMessages.length}`);\n    }\n    const peerMsg = peerMessages[0];\n    if (peerMsg.from !== this.otherPartyIdx) {\n      throw Error(`Unexpected counterpart party index: got ${peerMsg.from}, expected ${this.otherPartyIdx}`);\n    }\n    const peerPayload = Buffer.from(peerMsg.payload);\n    const wasm = this.getWasmMps();\n\n    if (this.dsgState === RedPallasDsgState.WaitMsg1) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg1');\n      let result: MsgState;\n      try {\n        result = wasm.redpallas_dsg_round1_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.dsgStateBytes = Buffer.from(result.state);\n      this.dsgState = RedPallasDsgState.WaitMsg2;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dsgState === RedPallasDsgState.WaitMsg2) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg2');\n      let result: MsgState;\n      try {\n        result = wasm.redpallas_dsg_round2_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.dsgStateBytes = Buffer.from(result.state);\n      this.dsgState = RedPallasDsgState.WaitMsg3;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dsgState === RedPallasDsgState.WaitMsg3) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg3');\n      let result: RedPallasSignature;\n      try {\n        result = wasm.redpallas_dsg_round3_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.signatureResult = {\n        signature: Buffer.from(result.signature),\n        rk: Buffer.from(result.rk),\n        alpha: Buffer.from(result.alpha),\n      };\n      this.dsgStateBytes = null;\n      this.dsgState = RedPallasDsgState.Complete;\n      return [];\n    }\n\n    throw Error('Unexpected DSG state');\n  }\n\n  /**\n   * Returns the final signature bundle produced by round 3: the 64-byte raw RedPallas\n   * signature, the randomized verification key `rk` it must be verified against (via\n   * `redpallas_verify(rk, signature, message)` — NOT the DKG public key), and the\n   * `alpha` randomizer scalar used to derive `rk` from the DKG public key.\n   */\n  getSignature(): RedPallasSignatureResult {\n    if (!this.signatureResult) {\n      throw Error('DSG session has not produced a signature yet');\n    }\n    return this.signatureResult;\n  }\n\n  /**\n   * Exports the current session state as a JSON string for persistence.\n   * Includes the opaque round state bytes plus everything needed to re-enter the\n   * protocol after a restart (keyshare, message, counterpart).\n   */\n  getSession(): string {\n    if (this.dsgState === RedPallasDsgState.Complete) {\n      throw Error('DSG session is complete. Exporting the session is not allowed.');\n    }\n    if (this.dsgState === RedPallasDsgState.Uninitialized) {\n      throw Error('DSG session not initialized');\n    }\n    if (this.dsgState === RedPallasDsgState.Init) {\n      throw Error('DSG session must produce its first message before exporting.');\n    }\n    return JSON.stringify({\n      dsgStateBytes: this.dsgStateBytes?.toString('base64') ?? null,\n      dsgRound: this.dsgState,\n      keyShare: this.keyShare?.toString('base64') ?? null,\n      message: this.message?.toString('base64') ?? null,\n      partyIdx: this.partyIdx,\n      otherPartyIdx: this.otherPartyIdx,\n    });\n  }\n\n  /**\n   * Restores a previously exported session. Allows the protocol to continue from\n   * where it left off, as if the round state was loaded from a database.\n   */\n  async restoreSession(session: string): Promise<void> {\n    await this.loadWasmMps();\n    const data = JSON.parse(session);\n    if (!Object.values(RedPallasDsgState).includes(data.dsgRound)) {\n      throw Error(`Invalid dsgRound in session: ${data.dsgRound}`);\n    }\n    if (data.dsgRound === RedPallasDsgState.Uninitialized || data.dsgRound === RedPallasDsgState.Init) {\n      throw Error(`Cannot restore DSG session in state ${data.dsgRound}`);\n    }\n    if (data.dsgRound === RedPallasDsgState.Complete) {\n      throw Error('DSG session is complete. Restoring the session is not allowed.');\n    }\n    if (typeof data.partyIdx !== 'number' || data.partyIdx < 0 || data.partyIdx > 2) {\n      throw Error(`Invalid partyIdx in session: ${data.partyIdx}`);\n    }\n    if (\n      typeof data.otherPartyIdx !== 'number' ||\n      data.otherPartyIdx < 0 ||\n      data.otherPartyIdx > 2 ||\n      data.otherPartyIdx === data.partyIdx\n    ) {\n      throw Error(`Invalid otherPartyIdx in session: ${data.otherPartyIdx}`);\n    }\n    if (this.partyIdx !== data.partyIdx) {\n      throw Error(`Session partyIdx ${data.partyIdx} does not match instance ${this.partyIdx}`);\n    }\n    if (typeof data.dsgStateBytes !== 'string' || data.dsgStateBytes.length === 0) {\n      throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);\n    }\n    if (typeof data.keyShare !== 'string' || data.keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n    if (typeof data.message !== 'string' || data.message.length === 0) {\n      throw Error('Restored session missing message');\n    }\n\n    const dsgStateBytes = Buffer.from(data.dsgStateBytes, 'base64');\n    const keyShare = Buffer.from(data.keyShare, 'base64');\n    const message = Buffer.from(data.message, 'base64');\n    if (dsgStateBytes.length === 0) {\n      throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);\n    }\n    if (keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n    if (message.length === 0) {\n      throw Error('Restored session missing message');\n    }\n\n    this.dsgStateBytes = dsgStateBytes;\n    this.dsgState = data.dsgRound;\n    this.keyShare = keyShare;\n    this.message = message;\n    this.partyIdx = data.partyIdx;\n    this.otherPartyIdx = data.otherPartyIdx;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dsg.js","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/dsg.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport type { MsgState, RedPallasSignature } from '@bitgo/wasm-mps';\nimport { DeserializedMessage, DeserializedMessages, RedPallasDsgState, RedPallasSignatureResult } from './types';\n\ntype NodeWasmer = typeof import('@bitgo/wasm-mps');\ntype WebWasmer = typeof import('@bitgo/wasm-mps/web');\ntype WasmMps = NodeWasmer | WebWasmer;\n\n/**\n * RedPallas (Zcash Ironwood) Distributed Sign Generation (DSG) implementation using\n * @bitgo/wasm-mps.\n *\n * Mirrors the structure of the EdDSA MPS `DSG` class (see `../eddsa-mps/dsg.ts`), but wraps\n * the `redpallas_dsg_*` WASM bindings. Unlike the EdDSA version:\n *\n * - `redpallas_dsg_round0_process` does not take a derivation path: RedPallas key derivation\n *   (ask/nk/rivk/ivks) happens upstream, as part of DKG (`redpallas_dkg_round2_process` +\n *   the platform-side-only `redpallas_derivation_process`); DSG only ever operates on an\n *   already-derived (or root) opaque `Keyshare`.\n * - DSG does not randomize the key it signs with: since `@bitgo/wasm-mps` 1.17.0, key\n *   re-randomization is a separate `rerand` protocol (see `./rerand.ts`, `RedPallasRerand`)\n *   that must run before every DSG, between the same 2 parties. The keyshare passed to\n *   `initDsg` must be the `keyShare` from that rerand result.\n * - Round3 does not return a raw signature; it returns a `RedPallasSignature` bundle of\n *   `signature` (64 raw bytes) and `rk` (the rerandomized verification key the signature\n *   verifies against — NOT the DKG public key). `rk` equals the `pk` of the rerand result\n *   the DSG session was initialized with. See `RedPallasSignatureResult`.\n *\n * Signing a stored DKG keyshare directly (without rerand) still produces a valid\n * signature — under the bare DKG public key, with the same `rk` every spend — but the\n * supported, tested path is rerand → DSG.\n *\n * State is explicit: each WASM round function returns `{ msg, state }` bytes; the state\n * bytes are stored between rounds and passed to the next round function (this is what a\n * server would persist to a database between API rounds).\n *\n * The protocol is hard-coded 2-of-3: each signing party communicates with exactly one\n * counterpart. `handleIncomingMessages` accepts both messages (own + counterpart), and\n * filters own out internally.\n *\n * @example\n * ```typescript\n * // Rerand first — same 2 parties that will sign (see RedPallasRerand).\n * const rerand = new RedPallasRerand(0);\n * await rerand.initRerand(dkgKeyShare, 2);\n * const rerandMsg1 = rerand.getFirstMessage();\n * const rerandMsg2 = rerand.handleIncomingMessages([rerandMsg1, peerRerandMsg1]);\n * rerand.handleIncomingMessages([rerandMsg2[0], peerRerandMsg2]);\n * const { keyShare, pk, alpha } = rerand.getRerandomizedKeyShare();\n *\n * const dsg = new RedPallasDSG(0);  // partyIdx 0\n * await dsg.initDsg(keyShare, message, 2);  // counterpart is party 2\n * const msg1 = dsg.getFirstMessage();\n * const msg2 = dsg.handleIncomingMessages([msg1, peerMsg1]);  // emits SignMsg2\n * const msg3 = dsg.handleIncomingMessages([msg2[0], peerMsg2]);  // emits SignMsg3\n * dsg.handleIncomingMessages([msg3[0], peerMsg3]);  // completes DSG\n * const { signature, rk } = dsg.getSignature();  // verifies under rk == pk\n * ```\n */\nexport class RedPallasDSG {\n  protected partyIdx: number;\n  protected otherPartyIdx: number | null = null;\n\n  /** Opaque bincode-serialised Keyshare from a prior DKG (already derived, if applicable) */\n  private keyShare: Buffer | null = null;\n  /** Raw message bytes to sign */\n  private message: Buffer | null = null;\n\n  /** Serialised round state bytes returned by the previous round function */\n  private dsgStateBytes: Buffer | null = null;\n  /** Final signature bundle, available after WaitMsg3 -> Complete */\n  private signatureResult: RedPallasSignatureResult | null = null;\n  /** Lazily loaded WASM module */\n  private wasmMps: WasmMps | null = null;\n\n  protected dsgState: RedPallasDsgState = RedPallasDsgState.Uninitialized;\n\n  constructor(partyIdx: number) {\n    this.partyIdx = partyIdx;\n  }\n\n  getState(): RedPallasDsgState {\n    return this.dsgState;\n  }\n\n  getPartyIdx(): number {\n    return this.partyIdx;\n  }\n\n  getOtherPartyIdx(): number | null {\n    return this.otherPartyIdx;\n  }\n\n  private async loadWasmMps(): Promise<void> {\n    if (!this.wasmMps) {\n      if (\n        typeof window !== 'undefined' &&\n        /* checks for electron processes */\n        !window.process &&\n        !window.process?.['type']\n      ) {\n        // Browser: web build has explicit init() — guaranteed ready after await\n        // eslint-disable-next-line import/no-internal-modules -- @bitgo/wasm-mps exposes environment-specific subpath exports.\n        const webWasm = await import('@bitgo/wasm-mps/web');\n        await webWasm.default();\n        this.wasmMps = webWasm;\n      } else {\n        // Node.js: dynamic import() rewritten to require() by tsc → CJS build → readFileSync\n        this.wasmMps = await import('@bitgo/wasm-mps');\n      }\n    }\n  }\n\n  private getWasmMps(): WasmMps {\n    if (!this.wasmMps) {\n      throw Error('WASM module not loaded');\n    }\n    return this.wasmMps;\n  }\n\n  /**\n   * Initialises the DSG session. The keyshare must be the rerandomized `keyShare` from\n   * a prior `RedPallasRerand` run with the same counterpart (which itself takes the\n   * opaque Keyshare from DKG — already derived, if applicable). Signing a bare DKG\n   * keyshare produces a valid but non-rerandomized signature under the DKG public key;\n   * use rerand → DSG instead. `otherPartyIdx` must be the single counterpart who ran\n   * that rerand session and will co-sign with this party.\n   *\n   * @param keyShare - Opaque bincode-serialised rerandomized Keyshare bytes from\n   *   `RedPallasRerand.getRerandomizedKeyShare().keyShare`.\n   * @param message - Raw message bytes to sign.\n   * @param otherPartyIdx - Party index of the single counterpart in this signing session.\n   *   Must differ from this party's own `partyIdx` and be in `[0, 2]`, and match the\n   *   counterpart of the preceding rerand session.\n   */\n  async initDsg(keyShare: Buffer, message: Buffer, otherPartyIdx: number): Promise<void> {\n    await this.loadWasmMps();\n    if (!keyShare || keyShare.length === 0) {\n      throw Error('Missing or invalid keyShare');\n    }\n    if (!message || message.length === 0) {\n      throw Error('Missing or invalid message');\n    }\n    if (this.partyIdx < 0 || this.partyIdx > 2) {\n      throw Error(`Invalid partyIdx ${this.partyIdx}: must be in [0, 2]`);\n    }\n    if (otherPartyIdx < 0 || otherPartyIdx > 2 || otherPartyIdx === this.partyIdx) {\n      throw Error(`Invalid otherPartyIdx ${otherPartyIdx}: must be in [0, 2] and != partyIdx`);\n    }\n\n    this.keyShare = keyShare;\n    this.message = message;\n    this.otherPartyIdx = otherPartyIdx;\n    this.dsgState = RedPallasDsgState.Init;\n  }\n\n  /**\n   * Runs round 0 of the DSG protocol. Returns this party's broadcast message\n   * (a `SignMsg1` containing the commitment to `R_i`). Stores the round state\n   * bytes internally for the next round.\n   */\n  getFirstMessage(): DeserializedMessage {\n    if (this.dsgState !== RedPallasDsgState.Init) {\n      throw Error('DSG session not initialized');\n    }\n    assert(this.keyShare, 'keyShare must be set after initDsg');\n    assert(this.message, 'message must be set after initDsg');\n\n    const wasm = this.getWasmMps();\n    let result: MsgState;\n    try {\n      result = wasm.redpallas_dsg_round0_process(this.keyShare, this.message);\n    } catch (err) {\n      throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);\n    }\n\n    this.dsgStateBytes = Buffer.from(result.state);\n    this.dsgState = RedPallasDsgState.WaitMsg1;\n    return { payload: new Uint8Array(result.msg), from: this.partyIdx };\n  }\n\n  /**\n   * Handles incoming messages for the current round and advances the protocol.\n   *\n   * - In `WaitMsg1`: runs round 1, returns this party's `SignMsg2` broadcast.\n   * - In `WaitMsg2`: runs round 2 (which internally fuses two Silence Labs transitions),\n   *   returns this party's `SignMsg3` broadcast (partial signature).\n   * - In `WaitMsg3`: runs round 3, completes DSG, returns `[]`.\n   *\n   * The caller passes both messages (own + counterpart) for symmetry with\n   * `RedPallasDKG.handleIncomingMessages`. Own message is filtered out internally; only the\n   * counterpart's payload is forwarded to the WASM round function.\n   *\n   * @param messagesForIthRound - Both messages for this round (own + counterpart).\n   */\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    if (this.dsgState === RedPallasDsgState.Complete) {\n      throw Error('DSG session already completed');\n    }\n    if (this.dsgState === RedPallasDsgState.Uninitialized) {\n      throw Error('DSG session not initialized');\n    }\n    if (this.dsgState === RedPallasDsgState.Init) {\n      throw Error(\n        'DSG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.'\n      );\n    }\n    if (messagesForIthRound.length !== 2) {\n      throw Error('Invalid number of messages for the round. Expected 2 messages (own + counterpart) for 2-of-3 DSG');\n    }\n\n    const peerMessages = messagesForIthRound.filter((m) => m.from !== this.partyIdx);\n    if (peerMessages.length !== 1) {\n      throw Error(`Expected exactly 1 counterpart message; got ${peerMessages.length}`);\n    }\n    const peerMsg = peerMessages[0];\n    if (peerMsg.from !== this.otherPartyIdx) {\n      throw Error(`Unexpected counterpart party index: got ${peerMsg.from}, expected ${this.otherPartyIdx}`);\n    }\n    const peerPayload = Buffer.from(peerMsg.payload);\n    const wasm = this.getWasmMps();\n\n    if (this.dsgState === RedPallasDsgState.WaitMsg1) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg1');\n      let result: MsgState;\n      try {\n        result = wasm.redpallas_dsg_round1_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.dsgStateBytes = Buffer.from(result.state);\n      this.dsgState = RedPallasDsgState.WaitMsg2;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dsgState === RedPallasDsgState.WaitMsg2) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg2');\n      let result: MsgState;\n      try {\n        result = wasm.redpallas_dsg_round2_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.dsgStateBytes = Buffer.from(result.state);\n      this.dsgState = RedPallasDsgState.WaitMsg3;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dsgState === RedPallasDsgState.WaitMsg3) {\n      assert(this.dsgStateBytes, 'dsgStateBytes must be set in WaitMsg3');\n      let result: RedPallasSignature;\n      try {\n        result = wasm.redpallas_dsg_round3_process(peerPayload, this.dsgStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dsgState}: ${err}`);\n      }\n      this.signatureResult = {\n        signature: Buffer.from(result.signature),\n        rk: Buffer.from(result.rk),\n      };\n      this.dsgStateBytes = null;\n      this.dsgState = RedPallasDsgState.Complete;\n      return [];\n    }\n\n    throw Error('Unexpected DSG state');\n  }\n\n  /**\n   * Returns the final signature bundle produced by round 3: the 64-byte raw RedPallas\n   * signature and the rerandomized verification key `rk` it must be verified against\n   * (via `redpallas_verify(rk, signature, message)` — NOT the DKG public key). `rk`\n   * equals the `pk` of the rerand result this session was initialized with; the\n   * corresponding `alpha` is available from `RedPallasRerand.getRerandomizedKeyShare()`.\n   */\n  getSignature(): RedPallasSignatureResult {\n    if (!this.signatureResult) {\n      throw Error('DSG session has not produced a signature yet');\n    }\n    return this.signatureResult;\n  }\n\n  /**\n   * Exports the current session state as a JSON string for persistence.\n   * Includes the opaque round state bytes plus everything needed to re-enter the\n   * protocol after a restart (keyshare, message, counterpart).\n   */\n  getSession(): string {\n    if (this.dsgState === RedPallasDsgState.Complete) {\n      throw Error('DSG session is complete. Exporting the session is not allowed.');\n    }\n    if (this.dsgState === RedPallasDsgState.Uninitialized) {\n      throw Error('DSG session not initialized');\n    }\n    if (this.dsgState === RedPallasDsgState.Init) {\n      throw Error('DSG session must produce its first message before exporting.');\n    }\n    return JSON.stringify({\n      dsgStateBytes: this.dsgStateBytes?.toString('base64') ?? null,\n      dsgRound: this.dsgState,\n      keyShare: this.keyShare?.toString('base64') ?? null,\n      message: this.message?.toString('base64') ?? null,\n      partyIdx: this.partyIdx,\n      otherPartyIdx: this.otherPartyIdx,\n    });\n  }\n\n  /**\n   * Restores a previously exported session. Allows the protocol to continue from\n   * where it left off, as if the round state was loaded from a database.\n   */\n  async restoreSession(session: string): Promise<void> {\n    await this.loadWasmMps();\n    const data = JSON.parse(session);\n    if (!Object.values(RedPallasDsgState).includes(data.dsgRound)) {\n      throw Error(`Invalid dsgRound in session: ${data.dsgRound}`);\n    }\n    if (data.dsgRound === RedPallasDsgState.Uninitialized || data.dsgRound === RedPallasDsgState.Init) {\n      throw Error(`Cannot restore DSG session in state ${data.dsgRound}`);\n    }\n    if (data.dsgRound === RedPallasDsgState.Complete) {\n      throw Error('DSG session is complete. Restoring the session is not allowed.');\n    }\n    if (typeof data.partyIdx !== 'number' || data.partyIdx < 0 || data.partyIdx > 2) {\n      throw Error(`Invalid partyIdx in session: ${data.partyIdx}`);\n    }\n    if (\n      typeof data.otherPartyIdx !== 'number' ||\n      data.otherPartyIdx < 0 ||\n      data.otherPartyIdx > 2 ||\n      data.otherPartyIdx === data.partyIdx\n    ) {\n      throw Error(`Invalid otherPartyIdx in session: ${data.otherPartyIdx}`);\n    }\n    if (this.partyIdx !== data.partyIdx) {\n      throw Error(`Session partyIdx ${data.partyIdx} does not match instance ${this.partyIdx}`);\n    }\n    if (typeof data.dsgStateBytes !== 'string' || data.dsgStateBytes.length === 0) {\n      throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);\n    }\n    if (typeof data.keyShare !== 'string' || data.keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n    if (typeof data.message !== 'string' || data.message.length === 0) {\n      throw Error('Restored session missing message');\n    }\n\n    const dsgStateBytes = Buffer.from(data.dsgStateBytes, 'base64');\n    const keyShare = Buffer.from(data.keyShare, 'base64');\n    const message = Buffer.from(data.message, 'base64');\n    if (dsgStateBytes.length === 0) {\n      throw Error(`Round ${data.dsgRound} requires dsgStateBytes`);\n    }\n    if (keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n    if (message.length === 0) {\n      throw Error('Restored session missing message');\n    }\n\n    this.dsgStateBytes = dsgStateBytes;\n    this.dsgState = data.dsgRound;\n    this.keyShare = keyShare;\n    this.message = message;\n    this.partyIdx = data.partyIdx;\n    this.otherPartyIdx = data.otherPartyIdx;\n  }\n}\n"]}

package/dist/src/tss/redpallas-mps/index.d.ts

@@ -1,7 +1,8 @@
 export * as RedPallasMPSDkg from './dkg';
 export * as RedPallasMPSDsg from './dsg';
+export * as RedPallasMPSRerand from './rerand';
 export * as RedPallasMPSUtil from './util';
 export * as RedPallasMPSTypes from './types';
 export * as RedPallasMPSComms from './commsLayer';
-export type { RedPallasSignatureResult } from './types';
+export type { RedPallasRerandResult, RedPallasSignatureResult } from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/tss/redpallas-mps/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,eAAe,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,gBAAgB,MAAM,QAAQ,CAAC;AAC3C,OAAO,KAAK,iBAAiB,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,iBAAiB,MAAM,cAAc,CAAC;AAClD,YAAY,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,eAAe,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,kBAAkB,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,gBAAgB,MAAM,QAAQ,CAAC;AAC3C,OAAO,KAAK,iBAAiB,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,iBAAiB,MAAM,cAAc,CAAC;AAClD,YAAY,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC"}

package/dist/src/tss/redpallas-mps/index.js

@@ -33,10 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedPallasMPSComms = exports.RedPallasMPSTypes = exports.RedPallasMPSUtil = exports.RedPallasMPSDsg = exports.RedPallasMPSDkg = void 0;
+exports.RedPallasMPSComms = exports.RedPallasMPSTypes = exports.RedPallasMPSUtil = exports.RedPallasMPSRerand = exports.RedPallasMPSDsg = exports.RedPallasMPSDkg = void 0;
 exports.RedPallasMPSDkg = __importStar(require("./dkg"));
 exports.RedPallasMPSDsg = __importStar(require("./dsg"));
+exports.RedPallasMPSRerand = __importStar(require("./rerand"));
 exports.RedPallasMPSUtil = __importStar(require("./util"));
 exports.RedPallasMPSTypes = __importStar(require("./types"));
 exports.RedPallasMPSComms = __importStar(require("./commsLayer"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHNzL3JlZHBhbGxhcy1tcHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseURBQXlDO0FBQ3pDLHlEQUF5QztBQUN6QywyREFBMkM7QUFDM0MsNkRBQTZDO0FBQzdDLGtFQUFrRCIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGFzIFJlZFBhbGxhc01QU0RrZyBmcm9tICcuL2RrZyc7XG5leHBvcnQgKiBhcyBSZWRQYWxsYXNNUFNEc2cgZnJvbSAnLi9kc2cnO1xuZXhwb3J0ICogYXMgUmVkUGFsbGFzTVBTVXRpbCBmcm9tICcuL3V0aWwnO1xuZXhwb3J0ICogYXMgUmVkUGFsbGFzTVBTVHlwZXMgZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBhcyBSZWRQYWxsYXNNUFNDb21tcyBmcm9tICcuL2NvbW1zTGF5ZXInO1xuZXhwb3J0IHR5cGUgeyBSZWRQYWxsYXNTaWduYXR1cmVSZXN1bHQgfSBmcm9tICcuL3R5cGVzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHNzL3JlZHBhbGxhcy1tcHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseURBQXlDO0FBQ3pDLHlEQUF5QztBQUN6QywrREFBK0M7QUFDL0MsMkRBQTJDO0FBQzNDLDZEQUE2QztBQUM3QyxrRUFBa0QiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBhcyBSZWRQYWxsYXNNUFNEa2cgZnJvbSAnLi9ka2cnO1xuZXhwb3J0ICogYXMgUmVkUGFsbGFzTVBTRHNnIGZyb20gJy4vZHNnJztcbmV4cG9ydCAqIGFzIFJlZFBhbGxhc01QU1JlcmFuZCBmcm9tICcuL3JlcmFuZCc7XG5leHBvcnQgKiBhcyBSZWRQYWxsYXNNUFNVdGlsIGZyb20gJy4vdXRpbCc7XG5leHBvcnQgKiBhcyBSZWRQYWxsYXNNUFNUeXBlcyBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCAqIGFzIFJlZFBhbGxhc01QU0NvbW1zIGZyb20gJy4vY29tbXNMYXllcic7XG5leHBvcnQgdHlwZSB7IFJlZFBhbGxhc1JlcmFuZFJlc3VsdCwgUmVkUGFsbGFzU2lnbmF0dXJlUmVzdWx0IH0gZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/dist/src/tss/redpallas-mps/rerand.d.ts

@@ -0,0 +1,110 @@
+import { DeserializedMessage, DeserializedMessages, RedPallasRerandResult, RedPallasRerandState } from './types';
+/**
+ * RedPallas (Zcash Ironwood) key re-randomization implementation using @bitgo/wasm-mps.
+ *
+ * As of `@bitgo/wasm-mps` 1.17.0, key re-randomization has moved out of DSG and into
+ * this separate `rerand` protocol: DSG no longer randomizes the key it signs with.
+ * A rerand session MUST run before every RedPallas DSG, between the same 2 parties
+ * that will then sign:
+ *
+ * - Round 0 (local): each party commits to a fresh random randomizer.
+ * - Round 1 (commit): each party broadcasts its commitment.
+ * - Round 2 (open): each party broadcasts its randomizer and blind, bound to the
+ *   session id. Both parties then locally verify the openings and apply the same
+ *   tweak `alpha = hash(Σ randomizers)`: `d_i += alpha`, `pk += G·alpha`.
+ *
+ * The output `RedPallasRerandShare` is a rerandomized keyshare (`share`), the
+ * rerandomized public key (`pk`) and the tweak scalar (`alpha`). `share` is what
+ * goes into `RedPallasDSG.initDsg`; the resulting DSG signature verifies under
+ * `rk == pk`, and `alpha` is only available here — not from the DSG result.
+ *
+ * Signing a stored DKG keyshare directly (without rerand) still yields a valid
+ * signature, but under the bare DKG public key with the same `rk` every time; the
+ * rerand → DSG sequence is the supported path.
+ *
+ * Mirrors the structure of `RedPallasDSG` (see `./dsg.ts`): lazy web/node WASM
+ * loading, explicit round state bytes persisted between rounds, hard-coded 2-of-3
+ * with a single counterpart, and the same 2-message `handleIncomingMessages`
+ * contract (own + counterpart; own is filtered out internally).
+ *
+ * @example
+ * ```typescript
+ * const rerand = new RedPallasRerand(0);  // partyIdx 0
+ * await rerand.initRerand(keyShare, 2);  // counterpart is party 2
+ * const msg1 = rerand.getFirstMessage();
+ * const msg2 = rerand.handleIncomingMessages([msg1, peerMsg1]);  // emits rerand msg2
+ * rerand.handleIncomingMessages([msg2[0], peerMsg2]);  // completes rerand
+ * const { keyShare, pk, alpha } = rerand.getRerandomizedKeyShare();
+ * const dsg = new RedPallasDSG(0);
+ * await dsg.initDsg(keyShare, message, 2);  // DSG verifies under rk == pk
+ * ```
+ */
+export declare class RedPallasRerand {
+    protected partyIdx: number;
+    protected otherPartyIdx: number | null;
+    /** Opaque bincode-serialised Keyshare from a prior DKG (already derived, if applicable) */
+    private keyShare;
+    /** Serialised round state bytes returned by the previous round function */
+    private rerandStateBytes;
+    /** Final rerandomized share bundle, available after WaitMsg2 -> Complete */
+    private rerandResult;
+    /** Lazily loaded WASM module */
+    private wasmMps;
+    protected rerandState: RedPallasRerandState;
+    constructor(partyIdx: number);
+    getState(): RedPallasRerandState;
+    getPartyIdx(): number;
+    getOtherPartyIdx(): number | null;
+    private loadWasmMps;
+    private getWasmMps;
+    /**
+     * Initialises the rerand session. The keyshare must come from a prior DKG run (and,
+     * if a derived key is being used, from the subsequent platform-side derivation
+     * process), and `otherPartyIdx` must be the single counterpart who will then co-sign
+     * (via DSG) with this party. Rerand and DSG must use the same 2 parties.
+     *
+     * @param keyShare - Opaque bincode-serialised Keyshare bytes from `RedPallasDKG.getKeyShare()`.
+     * @param otherPartyIdx - Party index of the single counterpart in this rerand session.
+     *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.
+     */
+    initRerand(keyShare: Buffer, otherPartyIdx: number): Promise<void>;
+    /**
+     * Runs round 0 of the rerand protocol (local). Returns this party's broadcast
+     * message (a commitment to a fresh random randomizer). Stores the round state
+     * bytes internally for the next round.
+     */
+    getFirstMessage(): DeserializedMessage;
+    /**
+     * Handles incoming messages for the current round and advances the protocol.
+     *
+     * - In `WaitMsg1`: runs round 1 (commit), returns this party's round 2 broadcast
+     *   (its randomizer and blind).
+     * - In `WaitMsg2`: runs round 2 (open + local tweak), completes rerand, returns `[]`.
+     *
+     * The caller passes both messages (own + counterpart) for symmetry with
+     * `RedPallasDSG.handleIncomingMessages`. Own message is filtered out internally;
+     * only the counterpart's payload is forwarded to the WASM round function.
+     *
+     * @param messagesForIthRound - Both messages for this round (own + counterpart).
+     */
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
+    /**
+     * Returns the rerandomized share bundle produced by round 2: the rerandomized
+     * keyshare `keyShare` (to be passed to `RedPallasDSG.initDsg`), the rerandomized
+     * public key `pk` (the DSG result's `rk` equals it), and the 32-byte tweak scalar
+     * `alpha` (fresh per rerand session, identical on both parties).
+     */
+    getRerandomizedKeyShare(): RedPallasRerandResult;
+    /**
+     * Exports the current session state as a JSON string for persistence.
+     * Includes the opaque round state bytes plus everything needed to re-enter the
+     * protocol after a restart (keyshare, counterpart).
+     */
+    getSession(): string;
+    /**
+     * Restores a previously exported session. Allows the protocol to continue from
+     * where it left off, as if the round state was loaded from a database.
+     */
+    restoreSession(session: string): Promise<void>;
+}
+//# sourceMappingURL=rerand.d.ts.map

package/dist/src/tss/redpallas-mps/rerand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rerand.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/rerand.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAMjH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,eAAe;IAC1B,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE9C,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,CAAuB;IAEvC,2EAA2E;IAC3E,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,4EAA4E;IAC5E,OAAO,CAAC,YAAY,CAAsC;IAC1D,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAwB;IAEvC,SAAS,CAAC,WAAW,EAAE,oBAAoB,CAAsC;gBAErE,QAAQ,EAAE,MAAM;IAI5B,QAAQ,IAAI,oBAAoB;IAIhC,WAAW,IAAI,MAAM;IAIrB,gBAAgB,IAAI,MAAM,GAAG,IAAI;YAInB,WAAW;IAoBzB,OAAO,CAAC,UAAU;IAOlB;;;;;;;;;OASG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBxE;;;;OAIG;IACH,eAAe,IAAI,mBAAmB;IAmBtC;;;;;;;;;;;;OAYG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IA+DvF;;;;;OAKG;IACH,uBAAuB,IAAI,qBAAqB;IAOhD;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAmBpB;;;OAGG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAgDrD"}