@bitgo-beta/sdk-lib-mpc 8.2.0-beta.208 → 8.2.0-beta.2080

package/dist/src/tss/ecdsa-dkls/derive.js

@@ -0,0 +1,329 @@
+"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.Derive = exports.DeriveState = void 0;
+const cbor_x_1 = require("cbor-x");
+const buffer_1 = require("buffer");
+const DERIVE_SEED_LENGTH = 32;
+var DeriveState;
+(function (DeriveState) {
+    DeriveState[DeriveState["Uninitialized"] = 0] = "Uninitialized";
+    DeriveState[DeriveState["Round1"] = 1] = "Round1";
+    DeriveState[DeriveState["Round2"] = 2] = "Round2";
+    DeriveState[DeriveState["Complete"] = 3] = "Complete";
+    DeriveState[DeriveState["InvalidState"] = 4] = "InvalidState";
+})(DeriveState || (exports.DeriveState = DeriveState = {}));
+/**
+ * Round driver for the DKLS23 hard-derivation protocol (Ristretto VRF backed),
+ * which derives a child signing keyshare from a root keyshare and its VRF keyshare.
+ *
+ * Each session is a 2-party threshold protocol between this party and one partner:
+ * every round accepts exactly two broadcast messages — this party's own (created by
+ * `initDerive()` and re-fed automatically) and the partner's. A ceremony runs one
+ * `Derive` per SDK party, each paired with the BitGo party:
+ *
+ * - Round 1 (`WaitMsg1`): consume `{own msg1, partner msg1}`, emit own broadcast msg2.
+ * - Round 2 (`WaitMsg2`): consume `{own msg2, partner msg2}`, finalize the session
+ *   and extract the derived DKLS `Keyshare`.
+ *
+ * The session is seeded from the decrypted root blob: the DKLS signing keyshare and
+ * the Ristretto VRF keyshare produced by root keygen, plus the child's hardened
+ * derivation path.
+ *
+ * Party indices follow the MPCv2 convention: 0 = user, 1 = backup, 2 = bitgo.
+ */
+class Derive {
+    constructor(n, t, partyIdx, rootKeyShare, vrfKeyShare, path, seed, vrfWasm) {
+        this.deriveState = DeriveState.Uninitialized;
+        this.n = n;
+        this.t = t;
+        this.partyIdx = partyIdx;
+        this.rootKeyShare = rootKeyShare;
+        this.vrfKeyShare = vrfKeyShare;
+        this.path = path;
+        this.seed = seed;
+        this.vrfWasm = vrfWasm ?? null;
+        this.deriveSessionBytes = new Uint8Array(0);
+    }
+    async loadVrfWasm() {
+        if (!this.vrfWasm) {
+            this.vrfWasm = await Promise.resolve().then(() => __importStar(require('@silencelaboratories/dkls-wasm-ll-vrf-node')));
+        }
+    }
+    getVrfWasm() {
+        if (!this.vrfWasm) {
+            throw Error('VRF wasm not loaded');
+        }
+        return this.vrfWasm;
+    }
+    _restoreSession() {
+        if (!this.deriveSession) {
+            this.deriveSession = this.getVrfWasm().HardDeriveSession.fromBytes(this.deriveSessionBytes);
+        }
+    }
+    /**
+     * Re-derive the round state from the wasm session bytes instead of trusting a
+     * caller-supplied enum. The wasm embeds the round tag (`WaitMsg1`/`WaitMsg2`,
+     * then a `Share` payload once finalized) for exactly this reason.
+     */
+    _deserializeState() {
+        if (!this.deriveSession) {
+            throw Error('Session not initialized');
+        }
+        const decoded = (0, cbor_x_1.decode)(this.deriveSession.toBytes());
+        const round = decoded?.inner?.round;
+        if (round === 'WaitMsg1') {
+            this.deriveState = DeriveState.Round1;
+        }
+        else if (round === 'WaitMsg2') {
+            this.deriveState = DeriveState.Round2;
+        }
+        else if (decoded?.inner?.state?.Share !== undefined || this.deriveSession.isFinished()) {
+            this.deriveState = DeriveState.Complete;
+        }
+        else {
+            this.deriveState = DeriveState.InvalidState;
+            throw Error(`Invalid State: ${JSON.stringify(round)}`);
+        }
+    }
+    /**
+     * Create this party's first hard-derive message (broadcast). Seeds the wasm
+     * session from the root keyshare, VRF keyshare and derivation path.
+     */
+    async initDerive() {
+        if (!this.vrfWasm) {
+            await this.loadVrfWasm();
+        }
+        if (this.t > this.n || this.partyIdx >= this.n) {
+            throw Error('Invalid parameters for hard derive');
+        }
+        if (this.deriveState !== DeriveState.Uninitialized) {
+            throw Error('Hard derive session already initialized');
+        }
+        if (this.seed && this.seed.length !== DERIVE_SEED_LENGTH) {
+            throw Error(`Seed should be ${DERIVE_SEED_LENGTH} bytes, got ${this.seed.length}.`);
+        }
+        if (typeof window !== 'undefined' &&
+            /* checks for electron processes */
+            !window.process &&
+            !window.process?.['type']) {
+            /* This is only needed for browsers/web because it uses fetch to resolve the wasm asset for the web */
+            const initVrf = await Promise.resolve().then(() => __importStar(require('@silencelaboratories/dkls-wasm-ll-vrf-web')));
+            await initVrf.default();
+        }
+        const { HardDeriveSession, Keyshare, VrfKeyshare } = this.getVrfWasm();
+        const rootKeyShare = Keyshare.fromBytes(this.rootKeyShare);
+        if (rootKeyShare.partyId !== this.partyIdx) {
+            throw Error(`Party index: ${this.partyIdx} does not match root key share partyId: ${rootKeyShare.partyId}`);
+        }
+        const vrfKeyShare = VrfKeyshare.fromBytes(this.vrfKeyShare);
+        if (vrfKeyShare.partyId !== this.partyIdx) {
+            throw Error(`Party index: ${this.partyIdx} does not match VRF key share partyId: ${vrfKeyShare.partyId}`);
+        }
+        this.deriveSession = this.seed
+            ? new HardDeriveSession(rootKeyShare, vrfKeyShare, this.path, new Uint8Array(this.seed))
+            : new HardDeriveSession(rootKeyShare, vrfKeyShare, this.path);
+        try {
+            const message = this.deriveSession.createFirstMessage();
+            // Copy the payload out before freeing the wasm message object.
+            const payload = new Uint8Array(message.payload);
+            const from = message.from_id;
+            message.free();
+            this.ownMsg1 = payload;
+            this.deriveSessionBytes = this.deriveSession.toBytes();
+            this._deserializeState();
+            return { payload, from };
+        }
+        catch (e) {
+            throw Error(`Error while creating the first hard-derive message from party ${this.partyIdx}: ${e}`);
+        }
+    }
+    /**
+     * Process the messages this party holds for the current round and return this
+     * party's messages for the next round. Callers pass the partner's broadcast
+     * message only; this party's own message is re-fed automatically because the
+     * wasm session validates the sender set as `{self, partner}`.
+     *
+     * - Round 1 (WaitMsg1): consumes `{own msg1, partner msg1}` and emits this
+     *   party's broadcast msg2.
+     * - Round 2 (WaitMsg2): consumes `{own msg2, partner msg2}` and finalizes the
+     *   session, returning no messages.
+     */
+    handleIncomingMessages(messagesForIthRound) {
+        this._restoreSession();
+        if (!this.deriveSession) {
+            throw Error('Session not initialized');
+        }
+        const { Message } = this.getVrfWasm();
+        let nextRoundMessages = [];
+        const nextRoundDeserializedMessages = { broadcastMessages: [], p2pMessages: [] };
+        try {
+            switch (this.deriveState) {
+                case DeriveState.Round1: {
+                    const partnerMessages = messagesForIthRound.broadcastMessages.filter((m) => m.from !== this.partyIdx);
+                    if (partnerMessages.length !== 1 || !this.ownMsg1) {
+                        throw Error('Expected exactly one broadcast message from the derive partner in round 1');
+                    }
+                    nextRoundMessages = this.deriveSession.handleMessages([
+                        new Message(this.ownMsg1, this.partyIdx),
+                        new Message(partnerMessages[0].payload, partnerMessages[0].from),
+                    ]);
+                    this._deserializeState();
+                    break;
+                }
+                case DeriveState.Round2: {
+                    const partnerMessages = messagesForIthRound.broadcastMessages.filter((m) => m.from !== this.partyIdx);
+                    if (partnerMessages.length !== 1 || !this.ownMsg2) {
+                        throw Error('Expected exactly one broadcast message from the derive partner in round 2');
+                    }
+                    nextRoundMessages = this.deriveSession.handleMessages([
+                        new Message(this.ownMsg2, this.partyIdx),
+                        new Message(partnerMessages[0].payload, partnerMessages[0].from),
+                    ]);
+                    // handleMessages() consumes the session; keyshare() extracts the derived share.
+                    const keyShare = this.deriveSession.keyshare();
+                    this.keyShareBuff = buffer_1.Buffer.from(keyShare.toBytes());
+                    keyShare.free();
+                    this.deriveState = DeriveState.Complete;
+                    return nextRoundDeserializedMessages;
+                }
+                default:
+                    throw Error(`Invalid hard-derive state: ${this.deriveState}`);
+            }
+            nextRoundDeserializedMessages.broadcastMessages = nextRoundMessages
+                .filter((m) => m.to_id === undefined)
+                .map((m) => ({ payload: new Uint8Array(m.payload), from: m.from_id }));
+            nextRoundDeserializedMessages.p2pMessages = nextRoundMessages
+                .filter((m) => m.to_id !== undefined)
+                .map((m) => ({ payload: new Uint8Array(m.payload), from: m.from_id, to: m.to_id }));
+            // The round-1 output is this party's msg2, re-fed into the session on round 2.
+            const ownMsg2 = nextRoundDeserializedMessages.broadcastMessages.find((m) => m.from === this.partyIdx);
+            if (ownMsg2) {
+                this.ownMsg2 = ownMsg2.payload;
+            }
+            return nextRoundDeserializedMessages;
+        }
+        catch (e) {
+            throw Error(`Error while creating hard-derive messages from party ${this.partyIdx}, state ${this.deriveState}: ${e}`);
+        }
+        finally {
+            nextRoundMessages.forEach((m) => m.free());
+            // keyshare() consumed (and deallocated) the session on round 2; only persist
+            // mid-protocol session bytes while the session object still exists.
+            if (this.deriveState !== DeriveState.Complete && this.deriveSession) {
+                this.deriveSessionBytes = this.deriveSession.toBytes();
+            }
+            this.deriveSession = undefined;
+        }
+    }
+    /**
+     * Get the derived DKLS keyshare bytes (CBOR `Keyshare`) once the derive is
+     * complete. This buffer is private key material.
+     */
+    getKeyShare() {
+        if (!this.keyShareBuff) {
+            throw Error('Can not get key share, hard derive is not complete yet.');
+        }
+        return this.keyShareBuff;
+    }
+    /**
+     * Returns a CBOR-encoded ReducedKeyShare buffer containing the derived party's
+     * private scalar (s_i) in the `prv` field. This buffer is private key material;
+     * the caller encrypts it as `reducedEncryptedPrv`, matching `Dkg.getReducedKeyShare`.
+     */
+    getReducedKeyShare() {
+        if (!this.keyShareBuff) {
+            throw Error('Can not get key share, hard derive is not complete yet.');
+        }
+        const decodedKeyshare = (0, cbor_x_1.decode)(this.keyShareBuff);
+        const reducedKeyShare = {
+            bigSList: decodedKeyshare.big_s_list,
+            xList: decodedKeyshare.x_i_list,
+            rootChainCode: decodedKeyshare.root_chain_code,
+            prv: decodedKeyshare.s_i,
+            pub: decodedKeyshare.public_key,
+        };
+        return buffer_1.Buffer.from((0, cbor_x_1.encode)(reducedKeyShare));
+    }
+    /**
+     * Get the current session data that can be used to restore the session later.
+     *
+     * The returned session bytes are secret key material — they carry this party's
+     * root keyshares. They must never be logged or persisted in the clear; the
+     * caller encrypts them exactly like the key share itself.
+     */
+    getSessionData() {
+        const sessionData = {
+            deriveSessionBytes: this.deriveSessionBytes,
+            deriveState: this.deriveState,
+        };
+        if (this.keyShareBuff) {
+            sessionData.keyShareBuff = this.keyShareBuff;
+        }
+        if (this.ownMsg1) {
+            sessionData.ownMsg1 = this.ownMsg1;
+        }
+        if (this.ownMsg2) {
+            sessionData.ownMsg2 = this.ownMsg2;
+        }
+        return sessionData;
+    }
+    /**
+     * Restore a session snapshot captured after initDerive() or round 1 processing.
+     * Do not call this before initDerive() has created session bytes.
+     * The round state is re-derived from the wasm session bytes, not the caller enum.
+     */
+    static async restoreSession(n, t, partyIdx, rootKeyShare, vrfKeyShare, path, sessionData, seed, vrfWasm) {
+        const derive = new Derive(n, t, partyIdx, rootKeyShare, vrfKeyShare, path, seed, vrfWasm);
+        if (!derive.vrfWasm) {
+            await derive.loadVrfWasm();
+        }
+        derive.deriveSessionBytes = sessionData.deriveSessionBytes;
+        if (sessionData.keyShareBuff) {
+            derive.keyShareBuff = sessionData.keyShareBuff;
+        }
+        if (sessionData.ownMsg1) {
+            derive.ownMsg1 = sessionData.ownMsg1;
+        }
+        if (sessionData.ownMsg2) {
+            derive.ownMsg2 = sessionData.ownMsg2;
+        }
+        derive._restoreSession();
+        derive._deserializeState();
+        return derive;
+    }
+}
+exports.Derive = Derive;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/derive.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,mCAAwC;AACxC,mCAAgC;AAYhC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAI9B,IAAY,WAMX;AAND,WAAY,WAAW;IACrB,+DAAa,CAAA;IACb,iDAAM,CAAA;IACN,iDAAM,CAAA;IACN,qDAAQ,CAAA;IACR,6DAAY,CAAA;AACd,CAAC,EANW,WAAW,2BAAX,WAAW,QAMtB;AAYD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAa,MAAM;IAkBjB,YACE,CAAS,EACT,CAAS,EACT,QAAgB,EAChB,YAAoB,EACpB,WAAmB,EACnB,IAAgB,EAChB,IAAa,EACb,OAA0B;QAflB,gBAAW,GAAgB,WAAW,CAAC,aAAa,CAAC;QAiB7D,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,OAAO,IAAI,IAAI,CAAC;QAC/B,IAAI,CAAC,kBAAkB,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC;IAEO,KAAK,CAAC,WAAW;QACvB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,IAAI,CAAC,OAAO,GAAG,wDAAa,4CAA4C,GAAC,CAAC;QAC5E,CAAC;IACH,CAAC;IAEO,UAAU;QAChB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,iBAAiB;QACvB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,MAAM,KAAK,CAAC,yBAAyB,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,OAAO,GAAG,IAAA,eAAM,EAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC;QACrD,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC;QACpC,IAAI,KAAK,KAAK,UAAU,EAAE,CAAC;YACzB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;QACxC,CAAC;aAAM,IAAI,KAAK,KAAK,UAAU,EAAE,CAAC;YAChC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;QACxC,CAAC;aAAM,IAAI,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,EAAE,CAAC;YACzF,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,YAAY,CAAC;YAC5C,MAAM,KAAK,CAAC,kBAAkB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC;YAC/C,MAAM,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,aAAa,EAAE,CAAC;YACnD,MAAM,KAAK,CAAC,yCAAyC,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,kBAAkB,EAAE,CAAC;YACzD,MAAM,KAAK,CAAC,kBAAkB,kBAAkB,eAAe,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QACtF,CAAC;QACD,IACE,OAAO,MAAM,KAAK,WAAW;YAC7B,mCAAmC;YACnC,CAAC,MAAM,CAAC,OAAO;YACf,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,EACzB,CAAC;YACD,sGAAsG;YACtG,MAAM,OAAO,GAAG,wDAAa,2CAA2C,GAAC,CAAC;YAC1E,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;QAC1B,CAAC;QACD,MAAM,EAAE,iBAAiB,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QACvE,MAAM,YAAY,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3D,IAAI,YAAY,CAAC,OAAO,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC3C,MAAM,KAAK,CAAC,gBAAgB,IAAI,CAAC,QAAQ,2CAA2C,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9G,CAAC;QACD,MAAM,WAAW,GAAG,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC5D,IAAI,WAAW,CAAC,OAAO,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1C,MAAM,KAAK,CAAC,gBAAgB,IAAI,CAAC,QAAQ,0CAA0C,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5G,CAAC;QACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,IAAI;YAC5B,CAAC,CAAC,IAAI,iBAAiB,CAAC,YAAY,EAAE,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxF,CAAC,CAAC,IAAI,iBAAiB,CAAC,YAAY,EAAE,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAChE,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,CAAC;YACxD,+DAA+D;YAC/D,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAChD,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC;YAC7B,OAAO,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YACvB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;YACvD,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC3B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,KAAK,CAAC,iEAAiE,IAAI,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC,CAAC;QACtG,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACH,sBAAsB,CAAC,mBAAyC;QAC9D,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,MAAM,KAAK,CAAC,yBAAyB,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QACtC,IAAI,iBAAiB,GAAqB,EAAE,CAAC;QAC7C,MAAM,6BAA6B,GAAyB,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC;QACvG,IAAI,CAAC;YACH,QAAQ,IAAI,CAAC,WAAW,EAAE,CAAC;gBACzB,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;oBACxB,MAAM,eAAe,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC;oBACtG,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;wBAClD,MAAM,KAAK,CAAC,2EAA2E,CAAC,CAAC;oBAC3F,CAAC;oBACD,iBAAiB,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;wBACpD,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC;wBACxC,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;qBACjE,CAAC,CAAC;oBACH,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBACzB,MAAM;gBACR,CAAC;gBACD,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;oBACxB,MAAM,eAAe,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC;oBACtG,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;wBAClD,MAAM,KAAK,CAAC,2EAA2E,CAAC,CAAC;oBAC3F,CAAC;oBACD,iBAAiB,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;wBACpD,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC;wBACxC,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;qBACjE,CAAC,CAAC;oBACH,gFAAgF;oBAChF,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;oBAC/C,IAAI,CAAC,YAAY,GAAG,eAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;oBACpD,QAAQ,CAAC,IAAI,EAAE,CAAC;oBAChB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC;oBACxC,OAAO,6BAA6B,CAAC;gBACvC,CAAC;gBACD;oBACE,MAAM,KAAK,CAAC,8BAA8B,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;YAClE,CAAC;YAED,6BAA6B,CAAC,iBAAiB,GAAG,iBAAiB;iBAChE,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC;iBACpC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;YACzE,6BAA6B,CAAC,WAAW,GAAG,iBAAiB;iBAC1D,MAAM,CAAC,CAAC,CAAC,EAA2C,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC;iBAC7E,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACtF,+EAA+E;YAC/E,MAAM,OAAO,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtG,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;YACjC,CAAC;YACD,OAAO,6BAA6B,CAAC;QACvC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,KAAK,CACT,wDAAwD,IAAI,CAAC,QAAQ,WAAW,IAAI,CAAC,WAAW,KAAK,CAAC,EAAE,CACzG,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAC3C,6EAA6E;YAC7E,oEAAoE;YACpE,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,QAAQ,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACpE,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;YACzD,CAAC;YACD,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QACjC,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,KAAK,CAAC,yDAAyD,CAAC,CAAC;QACzE,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,kBAAkB;QAChB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,KAAK,CAAC,yDAAyD,CAAC,CAAC;QACzE,CAAC;QACD,MAAM,eAAe,GAAG,IAAA,eAAM,EAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAClD,MAAM,eAAe,GAAoB;YACvC,QAAQ,EAAE,eAAe,CAAC,UAAU;YACpC,KAAK,EAAE,eAAe,CAAC,QAAQ;YAC/B,aAAa,EAAE,eAAe,CAAC,eAAe;YAC9C,GAAG,EAAE,eAAe,CAAC,GAAG;YACxB,GAAG,EAAE,eAAe,CAAC,UAAU;SAChC,CAAC;QACF,OAAO,eAAM,CAAC,IAAI,CAAC,IAAA,eAAM,EAAC,eAAe,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;OAMG;IACH,cAAc;QACZ,MAAM,WAAW,GAAsB;YACrC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC;QACF,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,WAAW,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QAC/C,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QACrC,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QACrC,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,cAAc,CACzB,CAAS,EACT,CAAS,EACT,QAAgB,EAChB,YAAoB,EACpB,WAAmB,EACnB,IAAgB,EAChB,WAA8B,EAC9B,IAAa,EACb,OAA0B;QAE1B,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC1F,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,MAAM,CAAC,WAAW,EAAE,CAAC;QAC7B,CAAC;QACD,MAAM,CAAC,kBAAkB,GAAG,WAAW,CAAC,kBAAkB,CAAC;QAC3D,IAAI,WAAW,CAAC,YAAY,EAAE,CAAC;YAC7B,MAAM,CAAC,YAAY,GAAG,WAAW,CAAC,YAAY,CAAC;QACjD,CAAC;QACD,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;YACxB,MAAM,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;QACvC,CAAC;QACD,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;YACxB,MAAM,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;QACvC,CAAC;QACD,MAAM,CAAC,eAAe,EAAE,CAAC;QACzB,MAAM,CAAC,iBAAiB,EAAE,CAAC;QAC3B,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAhTD,wBAgTC","sourcesContent":["import type {\n  HardDeriveSession as DklsHardDeriveSession,\n  Message as VrfWasmMessage,\n  VrfKeygenSession as DklsVrfKeygenSession,\n} from '@silencelaboratories/dkls-wasm-ll-vrf-node';\nimport type {\n  HardDeriveSession as DklsVrfWebHardDeriveSession,\n  VrfKeygenSession as DklsVrfWebKeygenSession,\n} from '@silencelaboratories/dkls-wasm-ll-vrf-web';\nimport { decode, encode } from 'cbor-x';\nimport { Buffer } from 'buffer';\nimport { DeserializedBroadcastMessage, DeserializedMessages, ReducedKeyShare } from './types';\n\n// Platform-specific modules that do not exist everywhere: the node/web/bundler wasm\n// variants are mutually exclusive and selected at runtime (node process vs browser vs\n// bundler). Static imports would load the wrong platform's wasm binding, so both the\n// type aliases below and the lazy `await import()` calls are deliberate.\ntype NodeVrfWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-vrf-node');\ntype WebVrfWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-vrf-web');\ntype BundlerVrfWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-vrf-bundler');\n\ntype VrfWasm = NodeVrfWasmer | WebVrfWasmer | BundlerVrfWasmer;\nconst DERIVE_SEED_LENGTH = 32;\n\nexport type { DklsHardDeriveSession, DklsVrfWebHardDeriveSession, DklsVrfKeygenSession, DklsVrfWebKeygenSession };\n\nexport enum DeriveState {\n  Uninitialized,\n  Round1,\n  Round2,\n  Complete,\n  InvalidState,\n}\n\nexport interface DeriveSessionData {\n  deriveSessionBytes: Uint8Array;\n  deriveState: DeriveState;\n  keyShareBuff?: Buffer;\n  // This party's own protocol messages, re-fed into the session on the next round\n  // because the wasm session validates the sender set against {self, partner}.\n  ownMsg1?: Uint8Array;\n  ownMsg2?: Uint8Array;\n}\n\n/**\n * Round driver for the DKLS23 hard-derivation protocol (Ristretto VRF backed),\n * which derives a child signing keyshare from a root keyshare and its VRF keyshare.\n *\n * Each session is a 2-party threshold protocol between this party and one partner:\n * every round accepts exactly two broadcast messages — this party's own (created by\n * `initDerive()` and re-fed automatically) and the partner's. A ceremony runs one\n * `Derive` per SDK party, each paired with the BitGo party:\n *\n * - Round 1 (`WaitMsg1`): consume `{own msg1, partner msg1}`, emit own broadcast msg2.\n * - Round 2 (`WaitMsg2`): consume `{own msg2, partner msg2}`, finalize the session\n *   and extract the derived DKLS `Keyshare`.\n *\n * The session is seeded from the decrypted root blob: the DKLS signing keyshare and\n * the Ristretto VRF keyshare produced by root keygen, plus the child's hardened\n * derivation path.\n *\n * Party indices follow the MPCv2 convention: 0 = user, 1 = backup, 2 = bitgo.\n */\nexport class Derive {\n  protected deriveSession: DklsHardDeriveSession | DklsVrfWebHardDeriveSession | undefined;\n  protected deriveSessionBytes: Uint8Array;\n  protected keyShareBuff: Buffer | undefined;\n  protected n: number;\n  protected t: number;\n  protected partyIdx: number;\n  protected rootKeyShare: Buffer;\n  protected vrfKeyShare: Buffer;\n  protected path: Uint8Array;\n  protected seed: Buffer | undefined;\n  protected deriveState: DeriveState = DeriveState.Uninitialized;\n  protected vrfWasm: VrfWasm | null;\n  // This party's own protocol messages, re-fed into the session on the next round:\n  // the wasm hard-derive session validates the sender set against {self, partner}.\n  protected ownMsg1: Uint8Array | undefined;\n  protected ownMsg2: Uint8Array | undefined;\n\n  constructor(\n    n: number,\n    t: number,\n    partyIdx: number,\n    rootKeyShare: Buffer,\n    vrfKeyShare: Buffer,\n    path: Uint8Array,\n    seed?: Buffer,\n    vrfWasm?: BundlerVrfWasmer\n  ) {\n    this.n = n;\n    this.t = t;\n    this.partyIdx = partyIdx;\n    this.rootKeyShare = rootKeyShare;\n    this.vrfKeyShare = vrfKeyShare;\n    this.path = path;\n    this.seed = seed;\n    this.vrfWasm = vrfWasm ?? null;\n    this.deriveSessionBytes = new Uint8Array(0);\n  }\n\n  private async loadVrfWasm(): Promise<void> {\n    if (!this.vrfWasm) {\n      this.vrfWasm = await import('@silencelaboratories/dkls-wasm-ll-vrf-node');\n    }\n  }\n\n  private getVrfWasm() {\n    if (!this.vrfWasm) {\n      throw Error('VRF wasm not loaded');\n    }\n    return this.vrfWasm;\n  }\n\n  private _restoreSession() {\n    if (!this.deriveSession) {\n      this.deriveSession = this.getVrfWasm().HardDeriveSession.fromBytes(this.deriveSessionBytes);\n    }\n  }\n\n  /**\n   * Re-derive the round state from the wasm session bytes instead of trusting a\n   * caller-supplied enum. The wasm embeds the round tag (`WaitMsg1`/`WaitMsg2`,\n   * then a `Share` payload once finalized) for exactly this reason.\n   */\n  private _deserializeState() {\n    if (!this.deriveSession) {\n      throw Error('Session not initialized');\n    }\n    const decoded = decode(this.deriveSession.toBytes());\n    const round = decoded?.inner?.round;\n    if (round === 'WaitMsg1') {\n      this.deriveState = DeriveState.Round1;\n    } else if (round === 'WaitMsg2') {\n      this.deriveState = DeriveState.Round2;\n    } else if (decoded?.inner?.state?.Share !== undefined || this.deriveSession.isFinished()) {\n      this.deriveState = DeriveState.Complete;\n    } else {\n      this.deriveState = DeriveState.InvalidState;\n      throw Error(`Invalid State: ${JSON.stringify(round)}`);\n    }\n  }\n\n  /**\n   * Create this party's first hard-derive message (broadcast). Seeds the wasm\n   * session from the root keyshare, VRF keyshare and derivation path.\n   */\n  async initDerive(): Promise<DeserializedBroadcastMessage> {\n    if (!this.vrfWasm) {\n      await this.loadVrfWasm();\n    }\n    if (this.t > this.n || this.partyIdx >= this.n) {\n      throw Error('Invalid parameters for hard derive');\n    }\n    if (this.deriveState !== DeriveState.Uninitialized) {\n      throw Error('Hard derive session already initialized');\n    }\n    if (this.seed && this.seed.length !== DERIVE_SEED_LENGTH) {\n      throw Error(`Seed should be ${DERIVE_SEED_LENGTH} bytes, got ${this.seed.length}.`);\n    }\n    if (\n      typeof window !== 'undefined' &&\n      /* checks for electron processes */\n      !window.process &&\n      !window.process?.['type']\n    ) {\n      /* This is only needed for browsers/web because it uses fetch to resolve the wasm asset for the web */\n      const initVrf = await import('@silencelaboratories/dkls-wasm-ll-vrf-web');\n      await initVrf.default();\n    }\n    const { HardDeriveSession, Keyshare, VrfKeyshare } = this.getVrfWasm();\n    const rootKeyShare = Keyshare.fromBytes(this.rootKeyShare);\n    if (rootKeyShare.partyId !== this.partyIdx) {\n      throw Error(`Party index: ${this.partyIdx} does not match root key share partyId: ${rootKeyShare.partyId}`);\n    }\n    const vrfKeyShare = VrfKeyshare.fromBytes(this.vrfKeyShare);\n    if (vrfKeyShare.partyId !== this.partyIdx) {\n      throw Error(`Party index: ${this.partyIdx} does not match VRF key share partyId: ${vrfKeyShare.partyId}`);\n    }\n    this.deriveSession = this.seed\n      ? new HardDeriveSession(rootKeyShare, vrfKeyShare, this.path, new Uint8Array(this.seed))\n      : new HardDeriveSession(rootKeyShare, vrfKeyShare, this.path);\n    try {\n      const message = this.deriveSession.createFirstMessage();\n      // Copy the payload out before freeing the wasm message object.\n      const payload = new Uint8Array(message.payload);\n      const from = message.from_id;\n      message.free();\n      this.ownMsg1 = payload;\n      this.deriveSessionBytes = this.deriveSession.toBytes();\n      this._deserializeState();\n      return { payload, from };\n    } catch (e) {\n      throw Error(`Error while creating the first hard-derive message from party ${this.partyIdx}: ${e}`);\n    }\n  }\n\n  /**\n   * Process the messages this party holds for the current round and return this\n   * party's messages for the next round. Callers pass the partner's broadcast\n   * message only; this party's own message is re-fed automatically because the\n   * wasm session validates the sender set as `{self, partner}`.\n   *\n   * - Round 1 (WaitMsg1): consumes `{own msg1, partner msg1}` and emits this\n   *   party's broadcast msg2.\n   * - Round 2 (WaitMsg2): consumes `{own msg2, partner msg2}` and finalizes the\n   *   session, returning no messages.\n   */\n  handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages {\n    this._restoreSession();\n    if (!this.deriveSession) {\n      throw Error('Session not initialized');\n    }\n    const { Message } = this.getVrfWasm();\n    let nextRoundMessages: VrfWasmMessage[] = [];\n    const nextRoundDeserializedMessages: DeserializedMessages = { broadcastMessages: [], p2pMessages: [] };\n    try {\n      switch (this.deriveState) {\n        case DeriveState.Round1: {\n          const partnerMessages = messagesForIthRound.broadcastMessages.filter((m) => m.from !== this.partyIdx);\n          if (partnerMessages.length !== 1 || !this.ownMsg1) {\n            throw Error('Expected exactly one broadcast message from the derive partner in round 1');\n          }\n          nextRoundMessages = this.deriveSession.handleMessages([\n            new Message(this.ownMsg1, this.partyIdx),\n            new Message(partnerMessages[0].payload, partnerMessages[0].from),\n          ]);\n          this._deserializeState();\n          break;\n        }\n        case DeriveState.Round2: {\n          const partnerMessages = messagesForIthRound.broadcastMessages.filter((m) => m.from !== this.partyIdx);\n          if (partnerMessages.length !== 1 || !this.ownMsg2) {\n            throw Error('Expected exactly one broadcast message from the derive partner in round 2');\n          }\n          nextRoundMessages = this.deriveSession.handleMessages([\n            new Message(this.ownMsg2, this.partyIdx),\n            new Message(partnerMessages[0].payload, partnerMessages[0].from),\n          ]);\n          // handleMessages() consumes the session; keyshare() extracts the derived share.\n          const keyShare = this.deriveSession.keyshare();\n          this.keyShareBuff = Buffer.from(keyShare.toBytes());\n          keyShare.free();\n          this.deriveState = DeriveState.Complete;\n          return nextRoundDeserializedMessages;\n        }\n        default:\n          throw Error(`Invalid hard-derive state: ${this.deriveState}`);\n      }\n\n      nextRoundDeserializedMessages.broadcastMessages = nextRoundMessages\n        .filter((m) => m.to_id === undefined)\n        .map((m) => ({ payload: new Uint8Array(m.payload), from: m.from_id }));\n      nextRoundDeserializedMessages.p2pMessages = nextRoundMessages\n        .filter((m): m is VrfWasmMessage & { to_id: number } => m.to_id !== undefined)\n        .map((m) => ({ payload: new Uint8Array(m.payload), from: m.from_id, to: m.to_id }));\n      // The round-1 output is this party's msg2, re-fed into the session on round 2.\n      const ownMsg2 = nextRoundDeserializedMessages.broadcastMessages.find((m) => m.from === this.partyIdx);\n      if (ownMsg2) {\n        this.ownMsg2 = ownMsg2.payload;\n      }\n      return nextRoundDeserializedMessages;\n    } catch (e) {\n      throw Error(\n        `Error while creating hard-derive messages from party ${this.partyIdx}, state ${this.deriveState}: ${e}`\n      );\n    } finally {\n      nextRoundMessages.forEach((m) => m.free());\n      // keyshare() consumed (and deallocated) the session on round 2; only persist\n      // mid-protocol session bytes while the session object still exists.\n      if (this.deriveState !== DeriveState.Complete && this.deriveSession) {\n        this.deriveSessionBytes = this.deriveSession.toBytes();\n      }\n      this.deriveSession = undefined;\n    }\n  }\n\n  /**\n   * Get the derived DKLS keyshare bytes (CBOR `Keyshare`) once the derive is\n   * complete. This buffer is private key material.\n   */\n  getKeyShare(): Buffer {\n    if (!this.keyShareBuff) {\n      throw Error('Can not get key share, hard derive is not complete yet.');\n    }\n    return this.keyShareBuff;\n  }\n\n  /**\n   * Returns a CBOR-encoded ReducedKeyShare buffer containing the derived party's\n   * private scalar (s_i) in the `prv` field. This buffer is private key material;\n   * the caller encrypts it as `reducedEncryptedPrv`, matching `Dkg.getReducedKeyShare`.\n   */\n  getReducedKeyShare(): Buffer {\n    if (!this.keyShareBuff) {\n      throw Error('Can not get key share, hard derive is not complete yet.');\n    }\n    const decodedKeyshare = decode(this.keyShareBuff);\n    const reducedKeyShare: ReducedKeyShare = {\n      bigSList: decodedKeyshare.big_s_list,\n      xList: decodedKeyshare.x_i_list,\n      rootChainCode: decodedKeyshare.root_chain_code,\n      prv: decodedKeyshare.s_i,\n      pub: decodedKeyshare.public_key,\n    };\n    return Buffer.from(encode(reducedKeyShare));\n  }\n\n  /**\n   * Get the current session data that can be used to restore the session later.\n   *\n   * The returned session bytes are secret key material — they carry this party's\n   * root keyshares. They must never be logged or persisted in the clear; the\n   * caller encrypts them exactly like the key share itself.\n   */\n  getSessionData(): DeriveSessionData {\n    const sessionData: DeriveSessionData = {\n      deriveSessionBytes: this.deriveSessionBytes,\n      deriveState: this.deriveState,\n    };\n    if (this.keyShareBuff) {\n      sessionData.keyShareBuff = this.keyShareBuff;\n    }\n    if (this.ownMsg1) {\n      sessionData.ownMsg1 = this.ownMsg1;\n    }\n    if (this.ownMsg2) {\n      sessionData.ownMsg2 = this.ownMsg2;\n    }\n    return sessionData;\n  }\n\n  /**\n   * Restore a session snapshot captured after initDerive() or round 1 processing.\n   * Do not call this before initDerive() has created session bytes.\n   * The round state is re-derived from the wasm session bytes, not the caller enum.\n   */\n  static async restoreSession(\n    n: number,\n    t: number,\n    partyIdx: number,\n    rootKeyShare: Buffer,\n    vrfKeyShare: Buffer,\n    path: Uint8Array,\n    sessionData: DeriveSessionData,\n    seed?: Buffer,\n    vrfWasm?: BundlerVrfWasmer\n  ): Promise<Derive> {\n    const derive = new Derive(n, t, partyIdx, rootKeyShare, vrfKeyShare, path, seed, vrfWasm);\n    if (!derive.vrfWasm) {\n      await derive.loadVrfWasm();\n    }\n    derive.deriveSessionBytes = sessionData.deriveSessionBytes;\n    if (sessionData.keyShareBuff) {\n      derive.keyShareBuff = sessionData.keyShareBuff;\n    }\n    if (sessionData.ownMsg1) {\n      derive.ownMsg1 = sessionData.ownMsg1;\n    }\n    if (sessionData.ownMsg2) {\n      derive.ownMsg2 = sessionData.ownMsg2;\n    }\n    derive._restoreSession();\n    derive._deserializeState();\n    return derive;\n  }\n}\n"]}

package/dist/src/tss/ecdsa-dkls/dkg.d.ts

@@ -0,0 +1,64 @@
+import type { KeygenSession, Keyshare } from '@silencelaboratories/dkls-wasm-ll-node';
+import type { VrfKeygenSession as DklsVrfKeygenSession } from '@silencelaboratories/dkls-wasm-ll-vrf-node';
+import type { VrfKeygenSession as DklsVrfWebKeygenSession } from '@silencelaboratories/dkls-wasm-ll-vrf-web';
+import { DeserializedBroadcastMessage, DeserializedMessages, DkgState, RetrofitData } from './types';
+type NodeWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-node');
+type WebWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-web');
+type BundlerWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-bundler');
+type DklsWasm = NodeWasmer | WebWasmer | BundlerWasmer;
+export type { DklsVrfKeygenSession, DklsVrfWebKeygenSession };
+export interface DkgSessionData {
+    dkgSessionBytes: Uint8Array;
+    dkgState: DkgState;
+    chainCodeCommitment?: Uint8Array;
+    keyShareBuff?: Buffer;
+}
+export declare class Dkg {
+    protected dkgSession: KeygenSession | undefined;
+    protected dkgSessionBytes: Uint8Array;
+    protected dkgKeyShare: Keyshare;
+    protected keyShareBuff: Buffer;
+    protected n: number;
+    protected t: number;
+    protected seed: Buffer | undefined;
+    protected chainCodeCommitment: Uint8Array | undefined;
+    protected partyIdx: number;
+    protected dkgState: DkgState;
+    protected dklsKeyShareRetrofitObject: Keyshare | undefined;
+    protected retrofitData: RetrofitData | undefined;
+    protected dklsWasm: DklsWasm | null;
+    constructor(n: number, t: number, partyIdx: number, seed?: Buffer, retrofitData?: RetrofitData, dklsWasm?: BundlerWasmer);
+    private loadDklsWasm;
+    private getDklsWasm;
+    private _restoreSession;
+    private _createDKLsRetrofitKeyShare;
+    private _deserializeState;
+    initDkg(): Promise<DeserializedBroadcastMessage>;
+    getKeyShare(): Buffer;
+    /**
+     * Returns a CBOR-encoded ReducedKeyShare buffer containing the party's private
+     * scalar (s_i) in the `prv` field. This buffer is private key material.
+     * The caller encrypts it and stores it as `reducedEncryptedPrv` on the key card QR code.
+     */
+    getReducedKeyShare(): Buffer;
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): DeserializedMessages;
+    /**
+     * Get the current session data that can be used to restore the session later
+     * @returns The current session data
+     */
+    getSessionData(): DkgSessionData;
+    /**
+     * Restore a DKG session from previous session data
+     * Note: This should not be used for Round 1 as that's the initialization phase
+     * @param n Number of parties
+     * @param t Threshold
+     * @param partyIdx Party index
+     * @param sessionData Previous session data
+     * @param seed Optional seed
+     * @param retrofitData Optional retrofit data
+     * @param dklsWasm Optional DKLS wasm instance
+     * @returns A new DKG instance with the restored session
+     */
+    static restoreSession(n: number, t: number, partyIdx: number, sessionData: DkgSessionData, seed?: Buffer, retrofitData?: RetrofitData, dklsWasm?: BundlerWasmer): Promise<Dkg>;
+}
+//# sourceMappingURL=dkg.d.ts.map

package/dist/src/tss/ecdsa-dkls/dkg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dkg.d.ts","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/dkg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAW,MAAM,wCAAwC,CAAC;AAC/F,OAAO,KAAK,EAAE,gBAAgB,IAAI,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAC3G,OAAO,KAAK,EAAE,gBAAgB,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAK7G,OAAO,EAAE,4BAA4B,EAAE,oBAAoB,EAAE,QAAQ,EAAmB,YAAY,EAAE,MAAM,SAAS,CAAC;AAEtH,KAAK,UAAU,GAAG,cAAc,wCAAwC,CAAC,CAAC;AAC1E,KAAK,SAAS,GAAG,cAAc,uCAAuC,CAAC,CAAC;AACxE,KAAK,aAAa,GAAG,cAAc,2CAA2C,CAAC,CAAC;AAEhF,KAAK,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,aAAa,CAAC;AACvD,YAAY,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,CAAC;AAE9D,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,UAAU,CAAC;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,mBAAmB,CAAC,EAAE,UAAU,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,GAAG;IACd,SAAS,CAAC,UAAU,EAAE,aAAa,GAAG,SAAS,CAAC;IAChD,SAAS,CAAC,eAAe,EAAE,UAAU,CAAC;IACtC,SAAS,CAAC,WAAW,EAAE,QAAQ,CAAC;IAChC,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,SAAS,CAAC,mBAAmB,EAAE,UAAU,GAAG,SAAS,CAAC;IACtD,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAA0B;IACtD,SAAS,CAAC,0BAA0B,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC3D,SAAS,CAAC,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;IACjD,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;gBAGlC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAC3B,QAAQ,CAAC,EAAE,aAAa;YAWZ,YAAY;IAM1B,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,2BAA2B;IAuCnC,OAAO,CAAC,iBAAiB;IA4BnB,OAAO,IAAI,OAAO,CAAC,4BAA4B,CAAC;IA+CtD,WAAW,IAAI,MAAM;IAOrB;;;;OAIG;IACH,kBAAkB,IAAI,MAAM;IAgB5B,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,oBAAoB;IAqFvF;;;OAGG;IACH,cAAc,IAAI,cAAc;IAiBhC;;;;;;;;;;;OAWG;WACU,cAAc,CACzB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,cAAc,EAC3B,IAAI,CAAC,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAC3B,QAAQ,CAAC,EAAE,aAAa,GACvB,OAAO,CAAC,GAAG,CAAC;CAwBhB"}