@bitgo-beta/sdk-lib-mpc 8.2.0-beta.212 → 8.2.0-beta.2120

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

@@ -0,0 +1,330 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedPallasRerand = void 0;
+const assert_1 = __importDefault(require("assert"));
+const types_1 = require("./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
+ * ```
+ */
+class RedPallasRerand {
+    constructor(partyIdx) {
+        this.otherPartyIdx = null;
+        /** Opaque bincode-serialised Keyshare from a prior DKG (already derived, if applicable) */
+        this.keyShare = null;
+        /** Serialised round state bytes returned by the previous round function */
+        this.rerandStateBytes = null;
+        /** Final rerandomized share bundle, available after WaitMsg2 -> Complete */
+        this.rerandResult = null;
+        /** Lazily loaded WASM module */
+        this.wasmMps = null;
+        this.rerandState = types_1.RedPallasRerandState.Uninitialized;
+        this.partyIdx = partyIdx;
+    }
+    getState() {
+        return this.rerandState;
+    }
+    getPartyIdx() {
+        return this.partyIdx;
+    }
+    getOtherPartyIdx() {
+        return this.otherPartyIdx;
+    }
+    async loadWasmMps() {
+        if (!this.wasmMps) {
+            if (typeof window !== 'undefined' &&
+                /* checks for electron processes */
+                !window.process &&
+                !window.process?.['type']) {
+                // Browser: web build has explicit init() — guaranteed ready after await
+                // eslint-disable-next-line import/no-internal-modules -- @bitgo/wasm-mps exposes environment-specific subpath exports.
+                const webWasm = await Promise.resolve().then(() => __importStar(require('@bitgo/wasm-mps/web')));
+                await webWasm.default();
+                this.wasmMps = webWasm;
+            }
+            else {
+                // Node.js: dynamic import() rewritten to require() by tsc → CJS build → readFileSync
+                this.wasmMps = await Promise.resolve().then(() => __importStar(require('@bitgo/wasm-mps')));
+            }
+        }
+    }
+    getWasmMps() {
+        if (!this.wasmMps) {
+            throw Error('WASM module not loaded');
+        }
+        return this.wasmMps;
+    }
+    /**
+     * 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]`.
+     */
+    async initRerand(keyShare, otherPartyIdx) {
+        await this.loadWasmMps();
+        if (!keyShare || keyShare.length === 0) {
+            throw Error('Missing or invalid keyShare');
+        }
+        if (this.partyIdx < 0 || this.partyIdx > 2) {
+            throw Error(`Invalid partyIdx ${this.partyIdx}: must be in [0, 2]`);
+        }
+        if (otherPartyIdx < 0 || otherPartyIdx > 2 || otherPartyIdx === this.partyIdx) {
+            throw Error(`Invalid otherPartyIdx ${otherPartyIdx}: must be in [0, 2] and != partyIdx`);
+        }
+        this.keyShare = keyShare;
+        this.otherPartyIdx = otherPartyIdx;
+        this.rerandState = types_1.RedPallasRerandState.Init;
+    }
+    /**
+     * 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() {
+        if (this.rerandState !== types_1.RedPallasRerandState.Init) {
+            throw Error('Rerand session not initialized');
+        }
+        (0, assert_1.default)(this.keyShare, 'keyShare must be set after initRerand');
+        const wasm = this.getWasmMps();
+        let result;
+        try {
+            result = wasm.redpallas_rerand_round0_process(this.keyShare);
+        }
+        catch (err) {
+            throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);
+        }
+        this.rerandStateBytes = Buffer.from(result.state);
+        this.rerandState = types_1.RedPallasRerandState.WaitMsg1;
+        return { payload: new Uint8Array(result.msg), from: this.partyIdx };
+    }
+    /**
+     * 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) {
+        if (this.rerandState === types_1.RedPallasRerandState.Complete) {
+            throw Error('Rerand session already completed');
+        }
+        if (this.rerandState === types_1.RedPallasRerandState.Uninitialized) {
+            throw Error('Rerand session not initialized');
+        }
+        if (this.rerandState === types_1.RedPallasRerandState.Init) {
+            throw Error('Rerand session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.');
+        }
+        if (messagesForIthRound.length !== 2) {
+            throw Error('Invalid number of messages for the round. Expected 2 messages (own + counterpart) for 2-of-3 rerand');
+        }
+        const peerMessages = messagesForIthRound.filter((m) => m.from !== this.partyIdx);
+        if (peerMessages.length !== 1) {
+            throw Error(`Expected exactly 1 counterpart message; got ${peerMessages.length}`);
+        }
+        const peerMsg = peerMessages[0];
+        if (peerMsg.from !== this.otherPartyIdx) {
+            throw Error(`Unexpected counterpart party index: got ${peerMsg.from}, expected ${this.otherPartyIdx}`);
+        }
+        const peerPayload = Buffer.from(peerMsg.payload);
+        const wasm = this.getWasmMps();
+        if (this.rerandState === types_1.RedPallasRerandState.WaitMsg1) {
+            (0, assert_1.default)(this.rerandStateBytes, 'rerandStateBytes must be set in WaitMsg1');
+            let result;
+            try {
+                result = wasm.redpallas_rerand_round1_process(peerPayload, this.rerandStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.rerandState}: ${err}`);
+            }
+            this.rerandStateBytes = Buffer.from(result.state);
+            this.rerandState = types_1.RedPallasRerandState.WaitMsg2;
+            return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];
+        }
+        if (this.rerandState === types_1.RedPallasRerandState.WaitMsg2) {
+            (0, assert_1.default)(this.rerandStateBytes, 'rerandStateBytes must be set in WaitMsg2');
+            let result;
+            try {
+                result = wasm.redpallas_rerand_round2_process(peerPayload, this.rerandStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.rerandState}: ${err}`);
+            }
+            this.rerandResult = {
+                keyShare: Buffer.from(result.share),
+                pk: Buffer.from(result.pk),
+                alpha: Buffer.from(result.alpha),
+            };
+            this.rerandStateBytes = null;
+            this.rerandState = types_1.RedPallasRerandState.Complete;
+            return [];
+        }
+        throw Error('Unexpected rerand state');
+    }
+    /**
+     * 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() {
+        if (!this.rerandResult) {
+            throw Error('Rerand session has not produced a rerandomized key share yet');
+        }
+        return this.rerandResult;
+    }
+    /**
+     * 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() {
+        if (this.rerandState === types_1.RedPallasRerandState.Complete) {
+            throw Error('Rerand session is complete. Exporting the session is not allowed.');
+        }
+        if (this.rerandState === types_1.RedPallasRerandState.Uninitialized) {
+            throw Error('Rerand session not initialized');
+        }
+        if (this.rerandState === types_1.RedPallasRerandState.Init) {
+            throw Error('Rerand session must produce its first message before exporting.');
+        }
+        return JSON.stringify({
+            rerandStateBytes: this.rerandStateBytes?.toString('base64') ?? null,
+            rerandRound: this.rerandState,
+            keyShare: this.keyShare?.toString('base64') ?? null,
+            partyIdx: this.partyIdx,
+            otherPartyIdx: this.otherPartyIdx,
+        });
+    }
+    /**
+     * 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.
+     */
+    async restoreSession(session) {
+        await this.loadWasmMps();
+        const data = JSON.parse(session);
+        if (!Object.values(types_1.RedPallasRerandState).includes(data.rerandRound)) {
+            throw Error(`Invalid rerandRound in session: ${data.rerandRound}`);
+        }
+        if (data.rerandRound === types_1.RedPallasRerandState.Uninitialized || data.rerandRound === types_1.RedPallasRerandState.Init) {
+            throw Error(`Cannot restore rerand session in state ${data.rerandRound}`);
+        }
+        if (data.rerandRound === types_1.RedPallasRerandState.Complete) {
+            throw Error('Rerand session is complete. Restoring the session is not allowed.');
+        }
+        if (typeof data.partyIdx !== 'number' || data.partyIdx < 0 || data.partyIdx > 2) {
+            throw Error(`Invalid partyIdx in session: ${data.partyIdx}`);
+        }
+        if (typeof data.otherPartyIdx !== 'number' ||
+            data.otherPartyIdx < 0 ||
+            data.otherPartyIdx > 2 ||
+            data.otherPartyIdx === data.partyIdx) {
+            throw Error(`Invalid otherPartyIdx in session: ${data.otherPartyIdx}`);
+        }
+        if (this.partyIdx !== data.partyIdx) {
+            throw Error(`Session partyIdx ${data.partyIdx} does not match instance ${this.partyIdx}`);
+        }
+        if (typeof data.rerandStateBytes !== 'string' || data.rerandStateBytes.length === 0) {
+            throw Error(`Round ${data.rerandRound} requires rerandStateBytes`);
+        }
+        if (typeof data.keyShare !== 'string' || data.keyShare.length === 0) {
+            throw Error('Restored session missing keyShare');
+        }
+        const rerandStateBytes = Buffer.from(data.rerandStateBytes, 'base64');
+        const keyShare = Buffer.from(data.keyShare, 'base64');
+        if (rerandStateBytes.length === 0) {
+            throw Error(`Round ${data.rerandRound} requires rerandStateBytes`);
+        }
+        if (keyShare.length === 0) {
+            throw Error('Restored session missing keyShare');
+        }
+        this.rerandStateBytes = rerandStateBytes;
+        this.rerandState = data.rerandRound;
+        this.keyShare = keyShare;
+        this.partyIdx = data.partyIdx;
+        this.otherPartyIdx = data.otherPartyIdx;
+    }
+}
+exports.RedPallasRerand = RedPallasRerand;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rerand.js","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/rerand.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport type { MsgState, RedPallasRerandShare } from '@bitgo/wasm-mps';\nimport { DeserializedMessage, DeserializedMessages, RedPallasRerandResult, RedPallasRerandState } 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) key re-randomization implementation using @bitgo/wasm-mps.\n *\n * As of `@bitgo/wasm-mps` 1.17.0, key re-randomization has moved out of DSG and into\n * this separate `rerand` protocol: DSG no longer randomizes the key it signs with.\n * A rerand session MUST run before every RedPallas DSG, between the same 2 parties\n * that will then sign:\n *\n * - Round 0 (local): each party commits to a fresh random randomizer.\n * - Round 1 (commit): each party broadcasts its commitment.\n * - Round 2 (open): each party broadcasts its randomizer and blind, bound to the\n *   session id. Both parties then locally verify the openings and apply the same\n *   tweak `alpha = hash(Σ randomizers)`: `d_i += alpha`, `pk += G·alpha`.\n *\n * The output `RedPallasRerandShare` is a rerandomized keyshare (`share`), the\n * rerandomized public key (`pk`) and the tweak scalar (`alpha`). `share` is what\n * goes into `RedPallasDSG.initDsg`; the resulting DSG signature verifies under\n * `rk == pk`, and `alpha` is only available here — not from the DSG result.\n *\n * Signing a stored DKG keyshare directly (without rerand) still yields a valid\n * signature, but under the bare DKG public key with the same `rk` every time; the\n * rerand → DSG sequence is the supported path.\n *\n * Mirrors the structure of `RedPallasDSG` (see `./dsg.ts`): lazy web/node WASM\n * loading, explicit round state bytes persisted between rounds, hard-coded 2-of-3\n * with a single counterpart, and the same 2-message `handleIncomingMessages`\n * contract (own + counterpart; own is filtered out internally).\n *\n * @example\n * ```typescript\n * const rerand = new RedPallasRerand(0);  // partyIdx 0\n * await rerand.initRerand(keyShare, 2);  // counterpart is party 2\n * const msg1 = rerand.getFirstMessage();\n * const msg2 = rerand.handleIncomingMessages([msg1, peerMsg1]);  // emits rerand msg2\n * rerand.handleIncomingMessages([msg2[0], peerMsg2]);  // completes rerand\n * const { keyShare, pk, alpha } = rerand.getRerandomizedKeyShare();\n * const dsg = new RedPallasDSG(0);\n * await dsg.initDsg(keyShare, message, 2);  // DSG verifies under rk == pk\n * ```\n */\nexport class RedPallasRerand {\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\n  /** Serialised round state bytes returned by the previous round function */\n  private rerandStateBytes: Buffer | null = null;\n  /** Final rerandomized share bundle, available after WaitMsg2 -> Complete */\n  private rerandResult: RedPallasRerandResult | null = null;\n  /** Lazily loaded WASM module */\n  private wasmMps: WasmMps | null = null;\n\n  protected rerandState: RedPallasRerandState = RedPallasRerandState.Uninitialized;\n\n  constructor(partyIdx: number) {\n    this.partyIdx = partyIdx;\n  }\n\n  getState(): RedPallasRerandState {\n    return this.rerandState;\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 rerand session. The keyshare must come from a prior DKG run (and,\n   * if a derived key is being used, from the subsequent platform-side derivation\n   * process), and `otherPartyIdx` must be the single counterpart who will then co-sign\n   * (via DSG) with this party. Rerand and DSG must use the same 2 parties.\n   *\n   * @param keyShare - Opaque bincode-serialised Keyshare bytes from `RedPallasDKG.getKeyShare()`.\n   * @param otherPartyIdx - Party index of the single counterpart in this rerand session.\n   *   Must differ from this party's own `partyIdx` and be in `[0, 2]`.\n   */\n  async initRerand(keyShare: 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 (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.otherPartyIdx = otherPartyIdx;\n    this.rerandState = RedPallasRerandState.Init;\n  }\n\n  /**\n   * Runs round 0 of the rerand protocol (local). Returns this party's broadcast\n   * message (a commitment to a fresh random randomizer). Stores the round state\n   * bytes internally for the next round.\n   */\n  getFirstMessage(): DeserializedMessage {\n    if (this.rerandState !== RedPallasRerandState.Init) {\n      throw Error('Rerand session not initialized');\n    }\n    assert(this.keyShare, 'keyShare must be set after initRerand');\n\n    const wasm = this.getWasmMps();\n    let result: MsgState;\n    try {\n      result = wasm.redpallas_rerand_round0_process(this.keyShare);\n    } catch (err) {\n      throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);\n    }\n\n    this.rerandStateBytes = Buffer.from(result.state);\n    this.rerandState = RedPallasRerandState.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 (commit), returns this party's round 2 broadcast\n   *   (its randomizer and blind).\n   * - In `WaitMsg2`: runs round 2 (open + local tweak), completes rerand, returns `[]`.\n   *\n   * The caller passes both messages (own + counterpart) for symmetry with\n   * `RedPallasDSG.handleIncomingMessages`. Own message is filtered out internally;\n   * only the 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.rerandState === RedPallasRerandState.Complete) {\n      throw Error('Rerand session already completed');\n    }\n    if (this.rerandState === RedPallasRerandState.Uninitialized) {\n      throw Error('Rerand session not initialized');\n    }\n    if (this.rerandState === RedPallasRerandState.Init) {\n      throw Error(\n        'Rerand session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.'\n      );\n    }\n    if (messagesForIthRound.length !== 2) {\n      throw Error(\n        'Invalid number of messages for the round. Expected 2 messages (own + counterpart) for 2-of-3 rerand'\n      );\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.rerandState === RedPallasRerandState.WaitMsg1) {\n      assert(this.rerandStateBytes, 'rerandStateBytes must be set in WaitMsg1');\n      let result: MsgState;\n      try {\n        result = wasm.redpallas_rerand_round1_process(peerPayload, this.rerandStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.rerandState}: ${err}`);\n      }\n      this.rerandStateBytes = Buffer.from(result.state);\n      this.rerandState = RedPallasRerandState.WaitMsg2;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.rerandState === RedPallasRerandState.WaitMsg2) {\n      assert(this.rerandStateBytes, 'rerandStateBytes must be set in WaitMsg2');\n      let result: RedPallasRerandShare;\n      try {\n        result = wasm.redpallas_rerand_round2_process(peerPayload, this.rerandStateBytes);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.rerandState}: ${err}`);\n      }\n      this.rerandResult = {\n        keyShare: Buffer.from(result.share),\n        pk: Buffer.from(result.pk),\n        alpha: Buffer.from(result.alpha),\n      };\n      this.rerandStateBytes = null;\n      this.rerandState = RedPallasRerandState.Complete;\n      return [];\n    }\n\n    throw Error('Unexpected rerand state');\n  }\n\n  /**\n   * Returns the rerandomized share bundle produced by round 2: the rerandomized\n   * keyshare `keyShare` (to be passed to `RedPallasDSG.initDsg`), the rerandomized\n   * public key `pk` (the DSG result's `rk` equals it), and the 32-byte tweak scalar\n   * `alpha` (fresh per rerand session, identical on both parties).\n   */\n  getRerandomizedKeyShare(): RedPallasRerandResult {\n    if (!this.rerandResult) {\n      throw Error('Rerand session has not produced a rerandomized key share yet');\n    }\n    return this.rerandResult;\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, counterpart).\n   */\n  getSession(): string {\n    if (this.rerandState === RedPallasRerandState.Complete) {\n      throw Error('Rerand session is complete. Exporting the session is not allowed.');\n    }\n    if (this.rerandState === RedPallasRerandState.Uninitialized) {\n      throw Error('Rerand session not initialized');\n    }\n    if (this.rerandState === RedPallasRerandState.Init) {\n      throw Error('Rerand session must produce its first message before exporting.');\n    }\n    return JSON.stringify({\n      rerandStateBytes: this.rerandStateBytes?.toString('base64') ?? null,\n      rerandRound: this.rerandState,\n      keyShare: this.keyShare?.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(RedPallasRerandState).includes(data.rerandRound)) {\n      throw Error(`Invalid rerandRound in session: ${data.rerandRound}`);\n    }\n    if (data.rerandRound === RedPallasRerandState.Uninitialized || data.rerandRound === RedPallasRerandState.Init) {\n      throw Error(`Cannot restore rerand session in state ${data.rerandRound}`);\n    }\n    if (data.rerandRound === RedPallasRerandState.Complete) {\n      throw Error('Rerand 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.rerandStateBytes !== 'string' || data.rerandStateBytes.length === 0) {\n      throw Error(`Round ${data.rerandRound} requires rerandStateBytes`);\n    }\n    if (typeof data.keyShare !== 'string' || data.keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n\n    const rerandStateBytes = Buffer.from(data.rerandStateBytes, 'base64');\n    const keyShare = Buffer.from(data.keyShare, 'base64');\n    if (rerandStateBytes.length === 0) {\n      throw Error(`Round ${data.rerandRound} requires rerandStateBytes`);\n    }\n    if (keyShare.length === 0) {\n      throw Error('Restored session missing keyShare');\n    }\n\n    this.rerandStateBytes = rerandStateBytes;\n    this.rerandState = data.rerandRound;\n    this.keyShare = keyShare;\n    this.partyIdx = data.partyIdx;\n    this.otherPartyIdx = data.otherPartyIdx;\n  }\n}\n"]}

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

@@ -0,0 +1,120 @@
+import * as t from 'io-ts';
+export declare const RedPallasReducedKeyShareType: t.TypeC<{
+    keyShare: t.ArrayC<t.NumberC>;
+    pub: t.ArrayC<t.NumberC>;
+}>;
+export type RedPallasReducedKeyShare = t.TypeOf<typeof RedPallasReducedKeyShareType>;
+/**
+ * Represents the state of a RedPallas DKG (Distributed Key Generation) session.
+ *
+ * Unlike the EdDSA MPS `DkgState`, there is no `Share` state: `redpallas_dkg_round2_process`
+ * returns a `MsgDerivationInit` (msg/pk/share/state) directly, completing the DKG session in
+ * one step. Key derivation (ask/nk/rivk/ivks) is a separate, subsequent, platform-side-only
+ * process (`redpallas_derivation_process`) not modelled here.
+ */
+export declare enum RedPallasDkgState {
+    /** DKG session has not been initialized */
+    Uninitialized = "Uninitialized",
+    /** DKG session has been initialized (Init state in WASM) */
+    Init = "Init",
+    /** DKG session is waiting for first message (WaitMsg1 state in WASM) */
+    WaitMsg1 = "WaitMsg1",
+    /** DKG session is waiting for second message (WaitMsg2 state in WASM) */
+    WaitMsg2 = "WaitMsg2",
+    /** DKG session has completed successfully and key shares are available */
+    Complete = "Complete"
+}
+/**
+ * Represents the state of a RedPallas DSG (Distributed Sign Generation) session.
+ *
+ * Mirrors the EdDSA MPS `DsgState`, except `redpallas_dsg_round0_process` does not take a
+ * derivation path: RedPallas key derivation (ask/nk/rivk/ivks) happens separately, upstream,
+ * as part of DKG (see `RedPallasDkgState`); the DSG round functions only ever operate on an
+ * already-derived (or root) `Keyshare`. The keyshare passed to DSG must come from a prior
+ * `RedPallasRerand` session (see `RedPallasRerandState`).
+ */
+export declare enum RedPallasDsgState {
+    /** DSG session has not been initialized */
+    Uninitialized = "Uninitialized",
+    /** initDsg() has been called; ready for getFirstMessage() */
+    Init = "Init",
+    /** R0 broadcast emitted; waiting for counterpart's R0 broadcast (SignMsg1) */
+    WaitMsg1 = "WaitMsg1",
+    /** R1 broadcast emitted; waiting for counterpart's R1 broadcast (SignMsg2) */
+    WaitMsg2 = "WaitMsg2",
+    /** R2 broadcast emitted; waiting for counterpart's R2 broadcast (SignMsg3, the partial sig) */
+    WaitMsg3 = "WaitMsg3",
+    /** Final RedPallas signature (signature/rk) is available via getSignature() */
+    Complete = "Complete"
+}
+/**
+ * Represents the state of a RedPallas rerand (key re-randomization) session.
+ *
+ * A rerand session must run before every RedPallas DSG, between the same 2 parties
+ * that will then sign. Since `@bitgo/wasm-mps` 1.17.0, DSG no longer randomizes the
+ * key it signs with; the randomizer (`alpha`) is produced here instead.
+ */
+export declare enum RedPallasRerandState {
+    /** Rerand session has not been initialized */
+    Uninitialized = "Uninitialized",
+    /** initRerand() has been called; ready for getFirstMessage() */
+    Init = "Init",
+    /** R0 (local commitment) emitted; waiting for counterpart's R0 broadcast (commitment) */
+    WaitMsg1 = "WaitMsg1",
+    /** R1 broadcast emitted; waiting for counterpart's R1 broadcast (randomizer + blind opening) */
+    WaitMsg2 = "WaitMsg2",
+    /** Rerandomized key share (keyShare/pk/alpha) is available via getRerandomizedKeyShare() */
+    Complete = "Complete"
+}
+/**
+ * The final output of a RedPallas rerand session.
+ *
+ * - `keyShare` is the rerandomized keyshare to be passed to `RedPallasDSG.initDsg`.
+ * - `pk` is the rerandomized public key; the DSG result's `rk` equals it, and the DSG
+ *   signature verifies under it.
+ * - `alpha` is the 32-byte tweak scalar applied to both the DKG keyshares and the DKG
+ *   public key (`pk = pk_dkg + [alpha]G`). It is fresh per rerand session and identical
+ *   on both parties. Since the rerand protocol moved out of DSG (wasm-mps 1.17.0), this
+ *   is the only place `alpha` is exposed.
+ */
+export interface RedPallasRerandResult {
+    keyShare: Buffer;
+    pk: Buffer;
+    alpha: Buffer;
+}
+/**
+ * The final output of a RedPallas DSG session.
+ *
+ * - `signature` is the 64-byte raw Schnorr (RedPallas) signature.
+ * - `rk` is the rerandomized verification key that the signature must be verified against
+ *   (i.e. `redpallas_verify(rk, signature, message)`), not the DKG public key. DSG does
+ *   not randomize the key it signs with: `rk` equals the `pk` of the rerandomized
+ *   keyshare the DSG session was initialized with (see `RedPallasRerandResult`), and
+ *   the corresponding `alpha` is available from that rerand result.
+ */
+export interface RedPallasSignatureResult {
+    signature: Buffer;
+    rk: Buffer;
+}
+/** A PGP detached-signed message by a party.
+ * `message` is the raw payload encoded as base64.
+ * `signature` is an armored PGP detached signature over those bytes.
+ */
+export interface MPSSignedMessage {
+    message: string;
+    signature: string;
+}
+export interface Message<T> {
+    payload: T;
+    from: number;
+}
+export type SerializedMessage = Message<string>;
+export type SerializedMessages = Message<string>[];
+export type DeserializedMessage = Message<Uint8Array>;
+export type DeserializedMessages = Message<Uint8Array>[];
+export declare function serializeMessage(msg: DeserializedMessage): SerializedMessage;
+export declare function deserializeMessage(msg: SerializedMessage): DeserializedMessage;
+export declare function serializeMessages(msgs: DeserializedMessages): SerializedMessages;
+export declare function deserializeMessages(msgs: SerializedMessages): DeserializedMessages;
+export declare function getDecodedReducedKeyShare(reducedKeyShare: Buffer | Uint8Array): RedPallasReducedKeyShare;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAE3B,eAAO,MAAM,4BAA4B;;;EAGvC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAErF;;;;;;;GAOG;AACH,oBAAY,iBAAiB;IAC3B,2CAA2C;IAC3C,aAAa,kBAAkB;IAC/B,4DAA4D;IAC5D,IAAI,SAAS;IACb,wEAAwE;IACxE,QAAQ,aAAa;IACrB,yEAAyE;IACzE,QAAQ,aAAa;IACrB,0EAA0E;IAC1E,QAAQ,aAAa;CACtB;AAED;;;;;;;;GAQG;AACH,oBAAY,iBAAiB;IAC3B,2CAA2C;IAC3C,aAAa,kBAAkB;IAC/B,6DAA6D;IAC7D,IAAI,SAAS;IACb,8EAA8E;IAC9E,QAAQ,aAAa;IACrB,8EAA8E;IAC9E,QAAQ,aAAa;IACrB,+FAA+F;IAC/F,QAAQ,aAAa;IACrB,+EAA+E;IAC/E,QAAQ,aAAa;CACtB;AAED;;;;;;GAMG;AACH,oBAAY,oBAAoB;IAC9B,8CAA8C;IAC9C,aAAa,kBAAkB;IAC/B,gEAAgE;IAChE,IAAI,SAAS;IACb,yFAAyF;IACzF,QAAQ,aAAa;IACrB,gGAAgG;IAChG,QAAQ,aAAa;IACrB,4FAA4F;IAC5F,QAAQ,aAAa;CACtB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAEhD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;AAEnD,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAEtD,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;AAEzD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,CAE5E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,iBAAiB,GAAG,mBAAmB,CAE9E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,oBAAoB,GAAG,kBAAkB,CAEhF;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,GAAG,oBAAoB,CAElF;AAED,wBAAgB,yBAAyB,CAAC,eAAe,EAAE,MAAM,GAAG,UAAU,GAAG,wBAAwB,CAMxG"}