@bitgo-beta/sdk-lib-mpc 8.2.1-alpha.467 → 8.2.1-alpha.469

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

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detachSignMpsMessage = detachSignMpsMessage;
+exports.verifyMpsMessage = verifyMpsMessage;
+exports.extractEd25519PublicKey = extractEd25519PublicKey;
+exports.extractEd25519KeyPair = extractEd25519KeyPair;
+const pgp = __importStar(require("openpgp"));
+/**
+ * PGP detached-signs raw WASM bytes with the given private key.
+ * Returns an MPSSignedMessage with the base64-encoded payload and armored signature.
+ *
+ * Mirrors `detachSignMpsMessage` in `../eddsa-mps/commsLayer.ts`. Kept as an independent
+ * copy (rather than a shared import) so RedPallas MPS never depends on the EdDSA MPS
+ * module, and vice versa.
+ */
+async function detachSignMpsMessage(rawBytes, signingKey) {
+    const signature = await pgp.sign({
+        message: await pgp.createMessage({ binary: rawBytes }),
+        signingKeys: signingKey,
+        detached: true,
+    });
+    return {
+        message: Buffer.from(rawBytes).toString('base64'),
+        signature: signature,
+    };
+}
+/**
+ * Verifies a PGP detached signature on an MPSSignedMessage and returns the decoded raw bytes.
+ * Throws if the signature is invalid or not present.
+ */
+async function verifyMpsMessage(msg, verificationKey) {
+    const rawBytes = Buffer.from(msg.message, 'base64');
+    const result = await pgp.verify({
+        message: await pgp.createMessage({ binary: rawBytes }),
+        signature: await pgp.readSignature({ armoredSignature: msg.signature }),
+        verificationKeys: verificationKey,
+        expectSigned: true,
+    });
+    await result.signatures[0].verified;
+    return rawBytes;
+}
+/**
+ * Extracts the X25519 public key bytes from a GPG key's encryption subkey.
+ * Works for both public-only and private keys — use this for third-party keys (e.g. BitGo's).
+ *
+ * @param key - A GPG key with an X25519 encryption subkey.
+ * @returns 32-byte X25519 public key.
+ */
+async function extractEd25519PublicKey(key) {
+    const { keyPacket } = await key.getEncryptionKey();
+    return Buffer.from(keyPacket.publicParams.Q).subarray(1);
+}
+/**
+ * Extracts the X25519 public and private key bytes from a GPG ed25519 private key's
+ * encryption subkey. Encapsulates the keyPacket internals and the little-endian scalar
+ * reversal in one place so sdk-core only deals with plain Buffers.
+ *
+ * @param privateKey - An ed25519 GPG private key with an X25519 encryption subkey.
+ * @returns  [pk, sk] — 32-byte X25519 public key and private scalar.
+ */
+async function extractEd25519KeyPair(privateKey) {
+    const encKey = await privateKey.getEncryptionKey();
+    const pk = Buffer.from(encKey.keyPacket.publicParams.Q).subarray(1);
+    const sk = Buffer.from(encKey.keyPacket.privateParams.d).reverse();
+    return [pk, sk];
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,103 @@
+import { DeserializedMessage, DeserializedMessages, RedPallasDkgState } from './types';
+/**
+ * RedPallas (Zcash Ironwood) Distributed Key Generation (DKG) implementation using @bitgo/wasm-mps.
+ *
+ * Mirrors the structure of the EdDSA MPS `DKG` class (see `../eddsa-mps/dkg.ts`), but wraps the
+ * `redpallas_dkg_*` WASM bindings. Round2 additionally requires a `derivationSeed` and returns a
+ * `MsgDerivationInit` (msg/pk/share/state) rather than a final `Share`, because RedPallas key
+ * derivation (ask/nk/rivk/ivks, via `redpallas_derivation_process`) is a separate, subsequent
+ * process that is platform-side only and intentionally not exposed here.
+ *
+ * State is explicit: each round function returns `{ msg, state }` bytes. The state bytes are
+ * stored between rounds and passed to the next round function, mirroring the server-side
+ * persistence pattern (state would be serialised to DB, or in OVC's case, a microSD card).
+ *
+ * @example
+ * ```typescript
+ * const dkg = new RedPallasDKG(3, 2, 0);
+ * // X25519 keys come from GPG encryption subkeys (extracted by the orchestrator)
+ * await dkg.initDkg(myX25519PrivKey, [otherParty1X25519PubKey, otherParty2X25519PubKey]);
+ * const msg1 = dkg.getFirstMessage();
+ * const msg2s = dkg.handleIncomingMessages(allThreeMsg1s);
+ * dkg.handleIncomingMessages(allThreeMsg2s, derivationSeed);  // completes DKG
+ * const keyShare = dkg.getKeyShare();
+ * ```
+ */
+export declare class RedPallasDKG {
+    protected n: number;
+    protected t: number;
+    protected partyIdx: number;
+    /** Private X25519 key (from GPG encryption subkey) */
+    private decryptionKey;
+    /** Other parties' X25519 public keys (from their GPG encryption subkeys), sorted by party index */
+    private otherPubKeys;
+    /** Serialised round state bytes returned by the previous round function */
+    private dkgStateBytes;
+    /** Opaque bincode-serialised keyshare from round2 */
+    private keyShare;
+    /** RedPallas public key (verification key) from round2 */
+    private sharePk;
+    /** Lazily loaded WASM module */
+    private wasmMps;
+    protected dkgState: RedPallasDkgState;
+    constructor(n: number, t: number, partyIdx: number);
+    private loadWasmMps;
+    private getWasmMps;
+    getState(): RedPallasDkgState;
+    /**
+     * Initialises the DKG session with this party's X25519 private key and the other parties'
+     * X25519 public keys. Keys are extracted from GPG encryption subkeys by the orchestrator.
+     *
+     * @param decryptionKey - This party's 32-byte X25519 private key (GPG enc subkey private part).
+     * @param otherEncPublicKeys - Other parties' 32-byte X25519 public keys, sorted by ascending
+     *   party index (excluding own). For a 3-party setup, this is [party_A_pub, party_B_pub].
+     */
+    initDkg(decryptionKey: Buffer, otherEncPublicKeys: Buffer[]): Promise<void>;
+    /**
+     * Runs round0 of the DKG protocol. Returns this party's broadcast message.
+     * Stores the round state bytes internally for the next round.
+     *
+     * @param dkgSeed - Optional 32-byte seed for deterministic DKG output (testing only).
+     */
+    getFirstMessage(dkgSeed?: Buffer): DeserializedMessage;
+    /**
+     * Handles incoming messages from all parties and advances the protocol.
+     *
+     * - In WaitMsg1: runs round1, returns this party's round1 broadcast message.
+     * - In WaitMsg2: runs round2, completes DKG, returns [].
+     *
+     * The caller passes all n messages (including own); own message is filtered
+     * out internally. Other parties' messages are sorted by ascending party index,
+     * matching the ordering expected by @bitgo/wasm-mps.
+     *
+     * @param messagesForIthRound - All n messages for this round (including own).
+     */
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
+    /**
+     * Returns the opaque bincode-serialised keyshare produced by round2.
+     * This is used as input to the (platform-side) signing and derivation protocols.
+     */
+    getKeyShare(): Buffer;
+    /**
+     * Returns the RedPallas public key (verification key) agreed by all parties during DKG.
+     */
+    getSharePublicKey(): Buffer;
+    /**
+     * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's opaque
+     * signing key share in the `keyShare` field. This buffer is private key material.
+     * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.
+     */
+    getReducedKeyShare(): Buffer;
+    /**
+     * Exports the current session state as a JSON string for persistence.
+     * Includes: round state bytes, current DKG round, decryption key, other parties' pub keys.
+     * This mirrors what a server would store in a database between API rounds.
+     */
+    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): void;
+}
+//# sourceMappingURL=dkg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dkg.d.ts","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/dkg.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,iBAAiB,EAA4B,MAAM,SAAS,CAAC;AAMjH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,YAAY;IACvB,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE3B,sDAAsD;IACtD,OAAO,CAAC,aAAa,CAAuB;IAC5C,mGAAmG;IACnG,OAAO,CAAC,YAAY,CAAyB;IAC7C,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAAuB;IAC5C,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAuB;IACvC,0DAA0D;IAC1D,OAAO,CAAC,OAAO,CAAuB;IACtC,gCAAgC;IAChC,OAAO,CAAC,OAAO,CAAwB;IAEvC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,CAAmC;gBAE5D,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;YAMpC,WAAW;IAoBzB,OAAO,CAAC,UAAU;IAOlB,QAAQ,IAAI,iBAAiB;IAI7B;;;;;;;OAOG;IACG,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjF;;;;;OAKG;IACH,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,mBAAmB;IAmBtD;;;;;;;;;;;OAWG;IACH,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IAsDvF;;;OAGG;IACH,WAAW,IAAI,MAAM;IAOrB;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAO3B;;;;OAIG;IACH,kBAAkB,IAAI,MAAM;IAW5B;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAepB;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAOtC"}

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

@@ -0,0 +1,285 @@
+"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.RedPallasDKG = void 0;
+const cbor_x_1 = require("cbor-x");
+const crypto_1 = __importDefault(require("crypto"));
+const types_1 = require("./types");
+/**
+ * RedPallas (Zcash Ironwood) Distributed Key Generation (DKG) implementation using @bitgo/wasm-mps.
+ *
+ * Mirrors the structure of the EdDSA MPS `DKG` class (see `../eddsa-mps/dkg.ts`), but wraps the
+ * `redpallas_dkg_*` WASM bindings. Round2 additionally requires a `derivationSeed` and returns a
+ * `MsgDerivationInit` (msg/pk/share/state) rather than a final `Share`, because RedPallas key
+ * derivation (ask/nk/rivk/ivks, via `redpallas_derivation_process`) is a separate, subsequent
+ * process that is platform-side only and intentionally not exposed here.
+ *
+ * State is explicit: each round function returns `{ msg, state }` bytes. The state bytes are
+ * stored between rounds and passed to the next round function, mirroring the server-side
+ * persistence pattern (state would be serialised to DB, or in OVC's case, a microSD card).
+ *
+ * @example
+ * ```typescript
+ * const dkg = new RedPallasDKG(3, 2, 0);
+ * // X25519 keys come from GPG encryption subkeys (extracted by the orchestrator)
+ * await dkg.initDkg(myX25519PrivKey, [otherParty1X25519PubKey, otherParty2X25519PubKey]);
+ * const msg1 = dkg.getFirstMessage();
+ * const msg2s = dkg.handleIncomingMessages(allThreeMsg1s);
+ * dkg.handleIncomingMessages(allThreeMsg2s, derivationSeed);  // completes DKG
+ * const keyShare = dkg.getKeyShare();
+ * ```
+ */
+class RedPallasDKG {
+    constructor(n, t, partyIdx) {
+        /** Private X25519 key (from GPG encryption subkey) */
+        this.decryptionKey = null;
+        /** Other parties' X25519 public keys (from their GPG encryption subkeys), sorted by party index */
+        this.otherPubKeys = null;
+        /** Serialised round state bytes returned by the previous round function */
+        this.dkgStateBytes = null;
+        /** Opaque bincode-serialised keyshare from round2 */
+        this.keyShare = null;
+        /** RedPallas public key (verification key) from round2 */
+        this.sharePk = null;
+        /** Lazily loaded WASM module */
+        this.wasmMps = null;
+        this.dkgState = types_1.RedPallasDkgState.Uninitialized;
+        this.n = n;
+        this.t = t;
+        this.partyIdx = partyIdx;
+    }
+    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;
+    }
+    getState() {
+        return this.dkgState;
+    }
+    /**
+     * Initialises the DKG session with this party's X25519 private key and the other parties'
+     * X25519 public keys. Keys are extracted from GPG encryption subkeys by the orchestrator.
+     *
+     * @param decryptionKey - This party's 32-byte X25519 private key (GPG enc subkey private part).
+     * @param otherEncPublicKeys - Other parties' 32-byte X25519 public keys, sorted by ascending
+     *   party index (excluding own). For a 3-party setup, this is [party_A_pub, party_B_pub].
+     */
+    async initDkg(decryptionKey, otherEncPublicKeys) {
+        await this.loadWasmMps();
+        if (!decryptionKey || decryptionKey.length !== 32) {
+            throw Error('Missing or invalid decryption key: must be 32 bytes');
+        }
+        if (!otherEncPublicKeys || otherEncPublicKeys.length !== this.n - 1) {
+            throw Error(`Expected ${this.n - 1} other parties' public keys`);
+        }
+        if (this.t > this.n || this.partyIdx >= this.n) {
+            throw Error('Invalid parameters for DKG');
+        }
+        this.decryptionKey = decryptionKey;
+        this.otherPubKeys = otherEncPublicKeys;
+        this.dkgState = types_1.RedPallasDkgState.Init;
+    }
+    /**
+     * Runs round0 of the DKG protocol. Returns this party's broadcast message.
+     * Stores the round state bytes internally for the next round.
+     *
+     * @param dkgSeed - Optional 32-byte seed for deterministic DKG output (testing only).
+     */
+    getFirstMessage(dkgSeed) {
+        if (this.dkgState !== types_1.RedPallasDkgState.Init) {
+            throw Error('DKG session not initialized');
+        }
+        const seed = dkgSeed ?? crypto_1.default.randomBytes(32);
+        const wasm = this.getWasmMps();
+        let result;
+        try {
+            result = wasm.redpallas_dkg_round0_process(this.partyIdx, this.decryptionKey, this.otherPubKeys, seed);
+        }
+        catch (err) {
+            throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);
+        }
+        this.dkgStateBytes = Buffer.from(result.state);
+        this.dkgState = types_1.RedPallasDkgState.WaitMsg1;
+        return { payload: new Uint8Array(result.msg), from: this.partyIdx };
+    }
+    /**
+     * Handles incoming messages from all parties and advances the protocol.
+     *
+     * - In WaitMsg1: runs round1, returns this party's round1 broadcast message.
+     * - In WaitMsg2: runs round2, completes DKG, returns [].
+     *
+     * The caller passes all n messages (including own); own message is filtered
+     * out internally. Other parties' messages are sorted by ascending party index,
+     * matching the ordering expected by @bitgo/wasm-mps.
+     *
+     * @param messagesForIthRound - All n messages for this round (including own).
+     */
+    handleIncomingMessages(messagesForIthRound) {
+        if (this.dkgState === types_1.RedPallasDkgState.Complete) {
+            throw Error('DKG session already completed');
+        }
+        if (this.dkgState === types_1.RedPallasDkgState.Uninitialized) {
+            throw Error('DKG session not initialized');
+        }
+        if (this.dkgState === types_1.RedPallasDkgState.Init) {
+            throw Error('DKG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.');
+        }
+        if (messagesForIthRound.length !== this.n) {
+            throw Error('Invalid number of messages for the round. Number of messages should be equal to N');
+        }
+        // Extract other parties' messages, sorted by party index (ascending)
+        const otherMsgs = messagesForIthRound
+            .filter((m) => m.from !== this.partyIdx)
+            .sort((a, b) => a.from - b.from)
+            .map((m) => m.payload);
+        const wasm = this.getWasmMps();
+        if (this.dkgState === types_1.RedPallasDkgState.WaitMsg1) {
+            let result;
+            try {
+                result = wasm.redpallas_dkg_round1_process(otherMsgs, this.dkgStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);
+            }
+            // Store new state; this is what would be persisted between API rounds / microSD exchanges
+            this.dkgStateBytes = Buffer.from(result.state);
+            this.dkgState = types_1.RedPallasDkgState.WaitMsg2;
+            return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];
+        }
+        if (this.dkgState === types_1.RedPallasDkgState.WaitMsg2) {
+            let result;
+            try {
+                result = wasm.redpallas_dkg_round2_process(otherMsgs, this.dkgStateBytes);
+            }
+            catch (err) {
+                throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);
+            }
+            this.keyShare = Buffer.from(result.share);
+            this.sharePk = Buffer.from(result.pk);
+            this.dkgStateBytes = null;
+            this.dkgState = types_1.RedPallasDkgState.Complete;
+            return [];
+        }
+        throw Error('Unexpected DKG state');
+    }
+    /**
+     * Returns the opaque bincode-serialised keyshare produced by round2.
+     * This is used as input to the (platform-side) signing and derivation protocols.
+     */
+    getKeyShare() {
+        if (!this.keyShare) {
+            throw Error('DKG session not initialized');
+        }
+        return this.keyShare;
+    }
+    /**
+     * Returns the RedPallas public key (verification key) agreed by all parties during DKG.
+     */
+    getSharePublicKey() {
+        if (!this.sharePk) {
+            throw Error('DKG session not initialized');
+        }
+        return this.sharePk;
+    }
+    /**
+     * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's opaque
+     * signing key share in the `keyShare` field. This buffer is private key material.
+     * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.
+     */
+    getReducedKeyShare() {
+        if (!this.keyShare || !this.sharePk) {
+            throw Error('DKG session not initialized');
+        }
+        const reducedKeyShare = {
+            keyShare: Array.from(this.keyShare),
+            pub: Array.from(this.sharePk),
+        };
+        return Buffer.from((0, cbor_x_1.encode)(reducedKeyShare));
+    }
+    /**
+     * Exports the current session state as a JSON string for persistence.
+     * Includes: round state bytes, current DKG round, decryption key, other parties' pub keys.
+     * This mirrors what a server would store in a database between API rounds.
+     */
+    getSession() {
+        if (this.dkgState === types_1.RedPallasDkgState.Complete) {
+            throw Error('DKG session is complete. Exporting the session is not allowed.');
+        }
+        if (this.dkgState === types_1.RedPallasDkgState.Uninitialized) {
+            throw Error('DKG session not initialized');
+        }
+        return JSON.stringify({
+            dkgStateBytes: this.dkgStateBytes?.toString('base64') ?? null,
+            dkgRound: this.dkgState,
+            decryptionKey: this.decryptionKey?.toString('base64') ?? null,
+            otherPubKeys: this.otherPubKeys?.map((k) => k.toString('base64')) ?? null,
+        });
+    }
+    /**
+     * 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) {
+        const data = JSON.parse(session);
+        this.dkgStateBytes = data.dkgStateBytes ? Buffer.from(data.dkgStateBytes, 'base64') : null;
+        this.dkgState = data.dkgRound;
+        this.decryptionKey = data.decryptionKey ? Buffer.from(data.decryptionKey, 'base64') : null;
+        this.otherPubKeys = data.otherPubKeys ? data.otherPubKeys.map((k) => Buffer.from(k, 'base64')) : null;
+    }
+}
+exports.RedPallasDKG = RedPallasDKG;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dkg.js","sourceRoot":"","sources":["../../../../src/tss/redpallas-mps/dkg.ts"],"names":[],"mappings":"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","sourcesContent":["import type { MsgState } from '@bitgo/wasm-mps';\nimport { encode } from 'cbor-x';\nimport crypto from 'crypto';\nimport { DeserializedMessage, DeserializedMessages, RedPallasDkgState, RedPallasReducedKeyShare } 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 Key Generation (DKG) implementation using @bitgo/wasm-mps.\n *\n * Mirrors the structure of the EdDSA MPS `DKG` class (see `../eddsa-mps/dkg.ts`), but wraps the\n * `redpallas_dkg_*` WASM bindings. Round2 additionally requires a `derivationSeed` and returns a\n * `MsgDerivationInit` (msg/pk/share/state) rather than a final `Share`, because RedPallas key\n * derivation (ask/nk/rivk/ivks, via `redpallas_derivation_process`) is a separate, subsequent\n * process that is platform-side only and intentionally not exposed here.\n *\n * State is explicit: each round function returns `{ msg, state }` bytes. The state bytes are\n * stored between rounds and passed to the next round function, mirroring the server-side\n * persistence pattern (state would be serialised to DB, or in OVC's case, a microSD card).\n *\n * @example\n * ```typescript\n * const dkg = new RedPallasDKG(3, 2, 0);\n * // X25519 keys come from GPG encryption subkeys (extracted by the orchestrator)\n * await dkg.initDkg(myX25519PrivKey, [otherParty1X25519PubKey, otherParty2X25519PubKey]);\n * const msg1 = dkg.getFirstMessage();\n * const msg2s = dkg.handleIncomingMessages(allThreeMsg1s);\n * dkg.handleIncomingMessages(allThreeMsg2s, derivationSeed);  // completes DKG\n * const keyShare = dkg.getKeyShare();\n * ```\n */\nexport class RedPallasDKG {\n  protected n: number;\n  protected t: number;\n  protected partyIdx: number;\n\n  /** Private X25519 key (from GPG encryption subkey) */\n  private decryptionKey: Buffer | null = null;\n  /** Other parties' X25519 public keys (from their GPG encryption subkeys), sorted by party index */\n  private otherPubKeys: Buffer[] | null = null;\n  /** Serialised round state bytes returned by the previous round function */\n  private dkgStateBytes: Buffer | null = null;\n  /** Opaque bincode-serialised keyshare from round2 */\n  private keyShare: Buffer | null = null;\n  /** RedPallas public key (verification key) from round2 */\n  private sharePk: Buffer | null = null;\n  /** Lazily loaded WASM module */\n  private wasmMps: WasmMps | null = null;\n\n  protected dkgState: RedPallasDkgState = RedPallasDkgState.Uninitialized;\n\n  constructor(n: number, t: number, partyIdx: number) {\n    this.n = n;\n    this.t = t;\n    this.partyIdx = partyIdx;\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  getState(): RedPallasDkgState {\n    return this.dkgState;\n  }\n\n  /**\n   * Initialises the DKG session with this party's X25519 private key and the other parties'\n   * X25519 public keys. Keys are extracted from GPG encryption subkeys by the orchestrator.\n   *\n   * @param decryptionKey - This party's 32-byte X25519 private key (GPG enc subkey private part).\n   * @param otherEncPublicKeys - Other parties' 32-byte X25519 public keys, sorted by ascending\n   *   party index (excluding own). For a 3-party setup, this is [party_A_pub, party_B_pub].\n   */\n  async initDkg(decryptionKey: Buffer, otherEncPublicKeys: Buffer[]): Promise<void> {\n    await this.loadWasmMps();\n    if (!decryptionKey || decryptionKey.length !== 32) {\n      throw Error('Missing or invalid decryption key: must be 32 bytes');\n    }\n    if (!otherEncPublicKeys || otherEncPublicKeys.length !== this.n - 1) {\n      throw Error(`Expected ${this.n - 1} other parties' public keys`);\n    }\n    if (this.t > this.n || this.partyIdx >= this.n) {\n      throw Error('Invalid parameters for DKG');\n    }\n\n    this.decryptionKey = decryptionKey;\n    this.otherPubKeys = otherEncPublicKeys;\n    this.dkgState = RedPallasDkgState.Init;\n  }\n\n  /**\n   * Runs round0 of the DKG protocol. Returns this party's broadcast message.\n   * Stores the round state bytes internally for the next round.\n   *\n   * @param dkgSeed - Optional 32-byte seed for deterministic DKG output (testing only).\n   */\n  getFirstMessage(dkgSeed?: Buffer): DeserializedMessage {\n    if (this.dkgState !== RedPallasDkgState.Init) {\n      throw Error('DKG session not initialized');\n    }\n\n    const seed = dkgSeed ?? crypto.randomBytes(32);\n    const wasm = this.getWasmMps();\n    let result: MsgState;\n    try {\n      result = wasm.redpallas_dkg_round0_process(this.partyIdx, this.decryptionKey!, this.otherPubKeys!, seed);\n    } catch (err) {\n      throw new Error(`Error while creating the first message from party ${this.partyIdx}: ${err}`);\n    }\n\n    this.dkgStateBytes = Buffer.from(result.state);\n    this.dkgState = RedPallasDkgState.WaitMsg1;\n    return { payload: new Uint8Array(result.msg), from: this.partyIdx };\n  }\n\n  /**\n   * Handles incoming messages from all parties and advances the protocol.\n   *\n   * - In WaitMsg1: runs round1, returns this party's round1 broadcast message.\n   * - In WaitMsg2: runs round2, completes DKG, returns [].\n   *\n   * The caller passes all n messages (including own); own message is filtered\n   * out internally. Other parties' messages are sorted by ascending party index,\n   * matching the ordering expected by @bitgo/wasm-mps.\n   *\n   * @param messagesForIthRound - All n messages for this round (including own).\n   */\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    if (this.dkgState === RedPallasDkgState.Complete) {\n      throw Error('DKG session already completed');\n    }\n    if (this.dkgState === RedPallasDkgState.Uninitialized) {\n      throw Error('DKG session not initialized');\n    }\n    if (this.dkgState === RedPallasDkgState.Init) {\n      throw Error(\n        'DKG session must call getFirstMessage() before handling incoming messages. Call getFirstMessage() first.'\n      );\n    }\n    if (messagesForIthRound.length !== this.n) {\n      throw Error('Invalid number of messages for the round. Number of messages should be equal to N');\n    }\n\n    // Extract other parties' messages, sorted by party index (ascending)\n    const otherMsgs = messagesForIthRound\n      .filter((m) => m.from !== this.partyIdx)\n      .sort((a, b) => a.from - b.from)\n      .map((m) => m.payload);\n\n    const wasm = this.getWasmMps();\n\n    if (this.dkgState === RedPallasDkgState.WaitMsg1) {\n      let result: MsgState;\n      try {\n        result = wasm.redpallas_dkg_round1_process(otherMsgs, this.dkgStateBytes!);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);\n      }\n      // Store new state; this is what would be persisted between API rounds / microSD exchanges\n      this.dkgStateBytes = Buffer.from(result.state);\n      this.dkgState = RedPallasDkgState.WaitMsg2;\n      return [{ payload: new Uint8Array(result.msg), from: this.partyIdx }];\n    }\n\n    if (this.dkgState === RedPallasDkgState.WaitMsg2) {\n      let result;\n      try {\n        result = wasm.redpallas_dkg_round2_process(otherMsgs, this.dkgStateBytes!);\n      } catch (err) {\n        throw new Error(`Error while creating messages from party ${this.partyIdx}, round ${this.dkgState}: ${err}`);\n      }\n      this.keyShare = Buffer.from(result.share);\n      this.sharePk = Buffer.from(result.pk);\n      this.dkgStateBytes = null;\n      this.dkgState = RedPallasDkgState.Complete;\n      return [];\n    }\n\n    throw Error('Unexpected DKG state');\n  }\n\n  /**\n   * Returns the opaque bincode-serialised keyshare produced by round2.\n   * This is used as input to the (platform-side) signing and derivation protocols.\n   */\n  getKeyShare(): Buffer {\n    if (!this.keyShare) {\n      throw Error('DKG session not initialized');\n    }\n    return this.keyShare;\n  }\n\n  /**\n   * Returns the RedPallas public key (verification key) agreed by all parties during DKG.\n   */\n  getSharePublicKey(): Buffer {\n    if (!this.sharePk) {\n      throw Error('DKG session not initialized');\n    }\n    return this.sharePk;\n  }\n\n  /**\n   * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's opaque\n   * signing key share in the `keyShare` field. This buffer is private key material.\n   * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.\n   */\n  getReducedKeyShare(): Buffer {\n    if (!this.keyShare || !this.sharePk) {\n      throw Error('DKG session not initialized');\n    }\n    const reducedKeyShare: RedPallasReducedKeyShare = {\n      keyShare: Array.from(this.keyShare),\n      pub: Array.from(this.sharePk),\n    };\n    return Buffer.from(encode(reducedKeyShare));\n  }\n\n  /**\n   * Exports the current session state as a JSON string for persistence.\n   * Includes: round state bytes, current DKG round, decryption key, other parties' pub keys.\n   * This mirrors what a server would store in a database between API rounds.\n   */\n  getSession(): string {\n    if (this.dkgState === RedPallasDkgState.Complete) {\n      throw Error('DKG session is complete. Exporting the session is not allowed.');\n    }\n    if (this.dkgState === RedPallasDkgState.Uninitialized) {\n      throw Error('DKG session not initialized');\n    }\n    return JSON.stringify({\n      dkgStateBytes: this.dkgStateBytes?.toString('base64') ?? null,\n      dkgRound: this.dkgState,\n      decryptionKey: this.decryptionKey?.toString('base64') ?? null,\n      otherPubKeys: this.otherPubKeys?.map((k) => k.toString('base64')) ?? null,\n    });\n  }\n\n  /**\n   * Restores a previously exported session. Allows the protocol to continue\n   * from where it left off, as if the round state was loaded from a database.\n   */\n  restoreSession(session: string): void {\n    const data = JSON.parse(session);\n    this.dkgStateBytes = data.dkgStateBytes ? Buffer.from(data.dkgStateBytes, 'base64') : null;\n    this.dkgState = data.dkgRound;\n    this.decryptionKey = data.decryptionKey ? Buffer.from(data.decryptionKey, 'base64') : null;\n    this.otherPubKeys = data.otherPubKeys ? (data.otherPubKeys as string[]).map((k) => Buffer.from(k, 'base64')) : null;\n  }\n}\n"]}

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

@@ -0,0 +1,108 @@
+import { DeserializedMessage, DeserializedMessages, RedPallasDsgState, RedPallasSignatureResult } from './types';
+/**
+ * RedPallas (Zcash Ironwood) Distributed Sign Generation (DSG) implementation using
+ * @bitgo/wasm-mps.
+ *
+ * Mirrors the structure of the EdDSA MPS `DSG` class (see `../eddsa-mps/dsg.ts`), but wraps
+ * the `redpallas_dsg_*` WASM bindings. Unlike the EdDSA version:
+ *
+ * - `redpallas_dsg_round0_process` does not take a derivation path: RedPallas key derivation
+ *   (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`.
+ * - 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`.
+ *
+ * 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
+ * server would persist to a database between API rounds).
+ *
+ * The protocol is hard-coded 2-of-3: each signing party communicates with exactly one
+ * counterpart. `handleIncomingMessages` accepts both messages (own + counterpart), and
+ * filters own out internally.
+ *
+ * @example
+ * ```typescript
+ * 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
+ * ```
+ */
+export declare class RedPallasDSG {
+    protected partyIdx: number;
+    protected otherPartyIdx: number | null;
+    /** Opaque bincode-serialised Keyshare from a prior DKG (already derived, if applicable) */
+    private keyShare;
+    /** Raw message bytes to sign */
+    private message;
+    /** Serialised round state bytes returned by the previous round function */
+    private dsgStateBytes;
+    /** Final signature bundle, available after WaitMsg3 -> Complete */
+    private signatureResult;
+    /** Lazily loaded WASM module */
+    private wasmMps;
+    protected dsgState: RedPallasDsgState;
+    constructor(partyIdx: number);
+    getState(): RedPallasDsgState;
+    getPartyIdx(): number;
+    getOtherPartyIdx(): number | null;
+    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.
+     *
+     * @param keyShare - Opaque bincode-serialised Keyshare bytes from `RedPallasDKG.getKeyShare()`.
+     * @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]`.
+     */
+    initDsg(keyShare: Buffer, message: Buffer, otherPartyIdx: number): Promise<void>;
+    /**
+     * Runs round 0 of the DSG protocol. Returns this party's broadcast message
+     * (a `SignMsg1` containing the commitment to `R_i`). 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, returns this party's `SignMsg2` broadcast.
+     * - In `WaitMsg2`: runs round 2 (which internally fuses two Silence Labs transitions),
+     *   returns this party's `SignMsg3` broadcast (partial signature).
+     * - In `WaitMsg3`: runs round 3, completes DSG, returns `[]`.
+     *
+     * The caller passes both messages (own + counterpart) for symmetry with
+     * `RedPallasDKG.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 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.
+     */
+    getSignature(): RedPallasSignatureResult;
+    /**
+     * 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, message, 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=dsg.d.ts.map