@bitgo/sdk-lib-mpc 10.17.0 → 10.19.0

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

@@ -0,0 +1,91 @@
+import type { VrfKeygenSession, VrfKeyshare as DklsVrfKeyshare } from '@silencelaboratories/dkls-wasm-ll-vrf-node';
+import type { VrfKeygenSession as VrfWebKeygenSession } from '@silencelaboratories/dkls-wasm-ll-vrf-web';
+import { Buffer } from 'buffer';
+import { DeserializedMessages } from '../ecdsa-dkls/types';
+import { VrfDkgSessionData, VrfDkgState } from './types';
+type NodeVrfWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-vrf-node');
+type WebVrfWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-vrf-web');
+type BundlerVrfWasmer = typeof import('@silencelaboratories/dkls-wasm-ll-vrf-bundler');
+type VrfWasm = NodeVrfWasmer | WebVrfWasmer | BundlerVrfWasmer;
+/**
+ * Round driver for the DKLS VRF DKG, which produces a Ristretto VRF keyshare.
+ *
+ * Two rounds, all broadcast: round 1 exchanges commitments (VrfKeygenMsg1), round 2
+ * exchanges openings (VrfKeygenMsg2, emitted per recipient) and the DKG finalizes
+ * locally. There is no chain-code commitment step, unlike the signing DKG.
+ *
+ * Callers pass every message they hold; this class routes them internally. Round 1
+ * must exclude the party's own commitment (the wasm rejects a sender set containing
+ * it) and round 2 consumes the openings addressed to this party, own included.
+ *
+ * Party indices follow the MPCv2 convention: 0 = user, 1 = backup, 2 = bitgo.
+ */
+export declare class VrfDkg {
+    protected vrfSession: VrfKeygenSession | VrfWebKeygenSession | undefined;
+    protected vrfSessionBytes: Uint8Array;
+    protected vrfKeyShare: DklsVrfKeyshare | undefined;
+    protected keyShareBuff: Buffer | undefined;
+    protected publicKey: Buffer | undefined;
+    protected keyId: Buffer | undefined;
+    protected rootChainCode: Buffer | undefined;
+    protected n: number;
+    protected t: number;
+    protected partyIdx: number;
+    protected seed: Buffer | undefined;
+    protected vrfState: VrfDkgState;
+    protected vrfWasm: VrfWasm | null;
+    constructor(n: number, t: number, partyIdx: number, seed?: Buffer, vrfWasm?: BundlerVrfWasmer);
+    private loadVrfWasm;
+    private getVrfWasm;
+    private _restoreSession;
+    /**
+     * Re-derive the round state from the wasm session bytes instead of trusting a
+     * caller-supplied enum. The wasm embeds a round tag for exactly this reason; this
+     * is what lets a stateless server resume mid-protocol.
+     */
+    private _deserializeState;
+    /**
+     * Create this party's VRF DKG commitment (VrfKeygenMsg1, broadcast).
+     */
+    initDkg(): Promise<DeserializedMessages>;
+    /**
+     * Process the messages this party holds for the current round and return this
+     * party's messages for the next round. Callers pass everything they hold; the
+     * round routing happens here:
+     *
+     * - Round 1 (WaitMsg1): consumes the other parties' commitments (own excluded —
+     *   the wasm rejects a sender set containing the party's own Msg1) and emits this
+     *   party's openings (VrfKeygenMsg2), one broadcast message per recipient.
+     * - Round 2 (WaitMsg2): consumes the openings addressed to this party (own
+     *   self-addressed opening included) and finalizes the DKG, returning no messages.
+     */
+    handleIncomingMessages(messagesForIthRound: DeserializedMessages): Promise<DeserializedMessages>;
+    /**
+     * Get the VRF keyshare bytes (CBOR VrfKeyshare) once the DKG is complete.
+     * This buffer is private key material.
+     */
+    getKeyShare(): Buffer;
+    /** 32-byte compressed Ristretto VRF public key, available once the DKG is complete. */
+    getPublicKey(): Buffer;
+    /** 32-byte VRF key identifier, available once the DKG is complete. */
+    getKeyId(): Buffer;
+    /** 32-byte VRF root chain code, available once the DKG is complete. */
+    getRootChainCode(): Buffer;
+    /**
+     * 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
+     * secret polynomial share. They must never be logged or persisted in the clear;
+     * the caller encrypts them exactly like the key share itself.
+     */
+    getSessionData(): VrfDkgSessionData;
+    /**
+     * Restore a VRF DKG session from previous session data.
+     * Note: This should not be used for Round 1 as that's the initialization phase.
+     * The round state is re-derived from the wasm session bytes, not trusted from the
+     * caller-supplied enum, so a tampered `vrfState` cannot steer the protocol.
+     */
+    static restoreSession(n: number, t: number, partyIdx: number, sessionData: VrfDkgSessionData, seed?: Buffer, vrfWasm?: BundlerVrfWasmer): Promise<VrfDkg>;
+}
+export {};
+//# sourceMappingURL=dkg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dkg.d.ts","sourceRoot":"","sources":["../../../../src/tss/dkls-vrf/dkg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAChB,WAAW,IAAI,eAAe,EAC/B,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,IAAI,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAEzG,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAMzD,KAAK,aAAa,GAAG,cAAc,4CAA4C,CAAC,CAAC;AACjF,KAAK,YAAY,GAAG,cAAc,2CAA2C,CAAC,CAAC;AAC/E,KAAK,gBAAgB,GAAG,cAAc,+CAA+C,CAAC,CAAC;AAEvF,KAAK,OAAO,GAAG,aAAa,GAAG,YAAY,GAAG,gBAAgB,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,qBAAa,MAAM;IACjB,SAAS,CAAC,UAAU,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,SAAS,CAAC;IACzE,SAAS,CAAC,eAAe,EAAE,UAAU,CAAC;IACtC,SAAS,CAAC,WAAW,EAAE,eAAe,GAAG,SAAS,CAAC;IACnD,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,SAAS,CAAC,QAAQ,EAAE,WAAW,CAA6B;IAC5D,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;gBAEtB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB;YAQ/E,WAAW;IAMzB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,eAAe;IAMvB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAmBzB;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAwC9C;;;;;;;;;;OAUG;IACG,sBAAsB,CAAC,mBAAmB,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAwDtG;;;OAGG;IACH,WAAW,IAAI,MAAM;IAOrB,uFAAuF;IACvF,YAAY,IAAI,MAAM;IAOtB,sEAAsE;IACtE,QAAQ,IAAI,MAAM;IAOlB,uEAAuE;IACvE,gBAAgB,IAAI,MAAM;IAO1B;;;;;;OAMG;IACH,cAAc,IAAI,iBAAiB;IAWnC;;;;;OAKG;WACU,cAAc,CACzB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,iBAAiB,EAC9B,IAAI,CAAC,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC;CAanB"}

package/dist/src/tss/dkls-vrf/dkg.js

@@ -0,0 +1,278 @@
+"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.VrfDkg = void 0;
+const cbor_x_1 = require("cbor-x");
+const buffer_1 = require("buffer");
+const types_1 = require("./types");
+/**
+ * Round driver for the DKLS VRF DKG, which produces a Ristretto VRF keyshare.
+ *
+ * Two rounds, all broadcast: round 1 exchanges commitments (VrfKeygenMsg1), round 2
+ * exchanges openings (VrfKeygenMsg2, emitted per recipient) and the DKG finalizes
+ * locally. There is no chain-code commitment step, unlike the signing DKG.
+ *
+ * Callers pass every message they hold; this class routes them internally. Round 1
+ * must exclude the party's own commitment (the wasm rejects a sender set containing
+ * it) and round 2 consumes the openings addressed to this party, own included.
+ *
+ * Party indices follow the MPCv2 convention: 0 = user, 1 = backup, 2 = bitgo.
+ */
+class VrfDkg {
+    constructor(n, t, partyIdx, seed, vrfWasm) {
+        this.vrfState = types_1.VrfDkgState.Uninitialized;
+        this.n = n;
+        this.t = t;
+        this.partyIdx = partyIdx;
+        this.seed = seed;
+        this.vrfWasm = vrfWasm ?? null;
+    }
+    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.vrfSession) {
+            this.vrfSession = this.getVrfWasm().VrfKeygenSession.fromBytes(this.vrfSessionBytes);
+        }
+    }
+    /**
+     * Re-derive the round state from the wasm session bytes instead of trusting a
+     * caller-supplied enum. The wasm embeds a round tag for exactly this reason; this
+     * is what lets a stateless server resume mid-protocol.
+     */
+    _deserializeState() {
+        if (!this.vrfSession) {
+            throw Error('Session not initialized');
+        }
+        const round = (0, cbor_x_1.decode)(this.vrfSession.toBytes()).round;
+        if (round === 'Init') {
+            this.vrfState = types_1.VrfDkgState.Uninitialized;
+        }
+        else if (round === 'WaitMsg1') {
+            this.vrfState = types_1.VrfDkgState.Round1;
+        }
+        else if (round === 'WaitMsg2') {
+            this.vrfState = types_1.VrfDkgState.Round2;
+        }
+        else if (typeof round === 'object' && round !== null && 'Share' in round) {
+            this.vrfState = types_1.VrfDkgState.Complete;
+        }
+        else {
+            this.vrfState = types_1.VrfDkgState.InvalidState;
+            throw Error(`Invalid State: ${JSON.stringify(round)}`);
+        }
+    }
+    /**
+     * Create this party's VRF DKG commitment (VrfKeygenMsg1, broadcast).
+     */
+    async initDkg() {
+        if (!this.vrfWasm) {
+            await this.loadVrfWasm();
+        }
+        if (this.t > this.n || this.partyIdx >= this.n) {
+            throw Error('Invalid parameters for VRF DKG');
+        }
+        if (this.vrfState != types_1.VrfDkgState.Uninitialized) {
+            throw Error('VRF DKG session already initialized');
+        }
+        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();
+        }
+        if (this.seed && this.seed.length !== 32) {
+            throw Error(`Seed should be 32 bytes, got ${this.seed.length}.`);
+        }
+        const { VrfKeygenSession } = this.getVrfWasm();
+        this.vrfSession = this.seed
+            ? new VrfKeygenSession(this.n, this.t, this.partyIdx, new Uint8Array(this.seed))
+            : new VrfKeygenSession(this.n, this.t, this.partyIdx);
+        try {
+            const message = this.vrfSession.createFirstMessage();
+            // Copy the payload out before freeing the wasm message object.
+            const payload = new Uint8Array(message.payload);
+            message.free();
+            this.vrfSessionBytes = this.vrfSession.toBytes();
+            this._deserializeState();
+            return { broadcastMessages: [{ payload, from: this.partyIdx }], p2pMessages: [] };
+        }
+        catch (e) {
+            throw Error(`Error while creating the first VRF 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 everything they hold; the
+     * round routing happens here:
+     *
+     * - Round 1 (WaitMsg1): consumes the other parties' commitments (own excluded —
+     *   the wasm rejects a sender set containing the party's own Msg1) and emits this
+     *   party's openings (VrfKeygenMsg2), one broadcast message per recipient.
+     * - Round 2 (WaitMsg2): consumes the openings addressed to this party (own
+     *   self-addressed opening included) and finalizes the DKG, returning no messages.
+     */
+    async handleIncomingMessages(messagesForIthRound) {
+        this._restoreSession();
+        if (!this.vrfSession) {
+            throw Error('Session not initialized');
+        }
+        const { Message: VrfMessage } = this.getVrfWasm();
+        let nextRoundMessages = [];
+        const nextRoundDeserializedMessages = { broadcastMessages: [], p2pMessages: [] };
+        try {
+            switch (this.vrfState) {
+                case types_1.VrfDkgState.Round1: {
+                    const othersCommitments = messagesForIthRound.broadcastMessages.filter((m) => m.from !== this.partyIdx);
+                    nextRoundMessages = this.vrfSession.handleMessages(othersCommitments.map((m) => new VrfMessage(m.payload, m.from)));
+                    this._deserializeState();
+                    break;
+                }
+                case types_1.VrfDkgState.Round2: {
+                    const openingsForMe = messagesForIthRound.p2pMessages.filter((m) => m.to === this.partyIdx);
+                    nextRoundMessages = this.vrfSession.handleMessages(openingsForMe.map((m) => new VrfMessage(m.payload, m.from, m.to)));
+                    // vrfKeyshare() consumes (and deallocates) the session in all cases.
+                    const vrfKeyShare = this.vrfSession.vrfKeyshare();
+                    this.vrfKeyShare = vrfKeyShare;
+                    this.keyShareBuff = buffer_1.Buffer.from(vrfKeyShare.toBytes());
+                    this.publicKey = buffer_1.Buffer.from(vrfKeyShare.publicKey);
+                    this.keyId = buffer_1.Buffer.from(vrfKeyShare.keyId);
+                    this.rootChainCode = buffer_1.Buffer.from(vrfKeyShare.rootChainCode);
+                    vrfKeyShare.free();
+                    this.vrfState = types_1.VrfDkgState.Complete;
+                    return nextRoundDeserializedMessages;
+                }
+                default:
+                    throw Error(`Invalid VRF DKG state: ${this.vrfState}`);
+            }
+            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 }));
+            return nextRoundDeserializedMessages;
+        }
+        catch (e) {
+            throw Error(`Error while creating VRF messages from party ${this.partyIdx}, state ${this.vrfState}: ${e}`);
+        }
+        finally {
+            nextRoundMessages.forEach((m) => m.free());
+            if (this.vrfState !== types_1.VrfDkgState.Complete) {
+                this.vrfSessionBytes = this.vrfSession.toBytes();
+                this.vrfSession = undefined;
+            }
+        }
+    }
+    /**
+     * Get the VRF keyshare bytes (CBOR VrfKeyshare) once the DKG is complete.
+     * This buffer is private key material.
+     */
+    getKeyShare() {
+        if (!this.keyShareBuff) {
+            throw Error('Can not get key share, VRF DKG is not complete yet.');
+        }
+        return this.keyShareBuff;
+    }
+    /** 32-byte compressed Ristretto VRF public key, available once the DKG is complete. */
+    getPublicKey() {
+        if (!this.publicKey) {
+            throw Error('Can not get public key, VRF DKG is not complete yet.');
+        }
+        return this.publicKey;
+    }
+    /** 32-byte VRF key identifier, available once the DKG is complete. */
+    getKeyId() {
+        if (!this.keyId) {
+            throw Error('Can not get key id, VRF DKG is not complete yet.');
+        }
+        return this.keyId;
+    }
+    /** 32-byte VRF root chain code, available once the DKG is complete. */
+    getRootChainCode() {
+        if (!this.rootChainCode) {
+            throw Error('Can not get root chain code, VRF DKG is not complete yet.');
+        }
+        return this.rootChainCode;
+    }
+    /**
+     * 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
+     * secret polynomial share. They must never be logged or persisted in the clear;
+     * the caller encrypts them exactly like the key share itself.
+     */
+    getSessionData() {
+        const sessionData = {
+            vrfSessionBytes: this.vrfSessionBytes,
+            vrfState: this.vrfState,
+        };
+        if (this.keyShareBuff) {
+            sessionData.keyShareBuff = this.keyShareBuff;
+        }
+        return sessionData;
+    }
+    /**
+     * Restore a VRF DKG session from previous session data.
+     * Note: This should not be used for Round 1 as that's the initialization phase.
+     * The round state is re-derived from the wasm session bytes, not trusted from the
+     * caller-supplied enum, so a tampered `vrfState` cannot steer the protocol.
+     */
+    static async restoreSession(n, t, partyIdx, sessionData, seed, vrfWasm) {
+        const vrfDkg = new VrfDkg(n, t, partyIdx, seed, vrfWasm);
+        if (!vrfDkg.vrfWasm) {
+            await vrfDkg.loadVrfWasm();
+        }
+        vrfDkg.vrfSessionBytes = sessionData.vrfSessionBytes;
+        vrfDkg._restoreSession();
+        vrfDkg._deserializeState();
+        if (sessionData.keyShareBuff) {
+            vrfDkg.keyShareBuff = sessionData.keyShareBuff;
+        }
+        return vrfDkg;
+    }
+}
+exports.VrfDkg = VrfDkg;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dkg.js","sourceRoot":"","sources":["../../../../src/tss/dkls-vrf/dkg.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  Message as VrfWasmMessage,\n  VrfKeygenSession,\n  VrfKeyshare as DklsVrfKeyshare,\n} from '@silencelaboratories/dkls-wasm-ll-vrf-node';\nimport type { VrfKeygenSession as VrfWebKeygenSession } from '@silencelaboratories/dkls-wasm-ll-vrf-web';\nimport { decode } from 'cbor-x';\nimport { Buffer } from 'buffer';\nimport { DeserializedMessages } from '../ecdsa-dkls/types';\nimport { VrfDkgSessionData, VrfDkgState } 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;\n\n/**\n * Round driver for the DKLS VRF DKG, which produces a Ristretto VRF keyshare.\n *\n * Two rounds, all broadcast: round 1 exchanges commitments (VrfKeygenMsg1), round 2\n * exchanges openings (VrfKeygenMsg2, emitted per recipient) and the DKG finalizes\n * locally. There is no chain-code commitment step, unlike the signing DKG.\n *\n * Callers pass every message they hold; this class routes them internally. Round 1\n * must exclude the party's own commitment (the wasm rejects a sender set containing\n * it) and round 2 consumes the openings addressed to this party, own included.\n *\n * Party indices follow the MPCv2 convention: 0 = user, 1 = backup, 2 = bitgo.\n */\nexport class VrfDkg {\n  protected vrfSession: VrfKeygenSession | VrfWebKeygenSession | undefined;\n  protected vrfSessionBytes: Uint8Array;\n  protected vrfKeyShare: DklsVrfKeyshare | undefined;\n  protected keyShareBuff: Buffer | undefined;\n  protected publicKey: Buffer | undefined;\n  protected keyId: Buffer | undefined;\n  protected rootChainCode: Buffer | undefined;\n  protected n: number;\n  protected t: number;\n  protected partyIdx: number;\n  protected seed: Buffer | undefined;\n  protected vrfState: VrfDkgState = VrfDkgState.Uninitialized;\n  protected vrfWasm: VrfWasm | null;\n\n  constructor(n: number, t: number, partyIdx: number, seed?: Buffer, vrfWasm?: BundlerVrfWasmer) {\n    this.n = n;\n    this.t = t;\n    this.partyIdx = partyIdx;\n    this.seed = seed;\n    this.vrfWasm = vrfWasm ?? null;\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.vrfSession) {\n      this.vrfSession = this.getVrfWasm().VrfKeygenSession.fromBytes(this.vrfSessionBytes);\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 a round tag for exactly this reason; this\n   * is what lets a stateless server resume mid-protocol.\n   */\n  private _deserializeState() {\n    if (!this.vrfSession) {\n      throw Error('Session not initialized');\n    }\n    const round = decode(this.vrfSession.toBytes()).round;\n    if (round === 'Init') {\n      this.vrfState = VrfDkgState.Uninitialized;\n    } else if (round === 'WaitMsg1') {\n      this.vrfState = VrfDkgState.Round1;\n    } else if (round === 'WaitMsg2') {\n      this.vrfState = VrfDkgState.Round2;\n    } else if (typeof round === 'object' && round !== null && 'Share' in round) {\n      this.vrfState = VrfDkgState.Complete;\n    } else {\n      this.vrfState = VrfDkgState.InvalidState;\n      throw Error(`Invalid State: ${JSON.stringify(round)}`);\n    }\n  }\n\n  /**\n   * Create this party's VRF DKG commitment (VrfKeygenMsg1, broadcast).\n   */\n  async initDkg(): Promise<DeserializedMessages> {\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 VRF DKG');\n    }\n    if (this.vrfState != VrfDkgState.Uninitialized) {\n      throw Error('VRF DKG session already initialized');\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    if (this.seed && this.seed.length !== 32) {\n      throw Error(`Seed should be 32 bytes, got ${this.seed.length}.`);\n    }\n    const { VrfKeygenSession } = this.getVrfWasm();\n    this.vrfSession = this.seed\n      ? new VrfKeygenSession(this.n, this.t, this.partyIdx, new Uint8Array(this.seed))\n      : new VrfKeygenSession(this.n, this.t, this.partyIdx);\n    try {\n      const message = this.vrfSession.createFirstMessage();\n      // Copy the payload out before freeing the wasm message object.\n      const payload = new Uint8Array(message.payload);\n      message.free();\n      this.vrfSessionBytes = this.vrfSession.toBytes();\n      this._deserializeState();\n      return { broadcastMessages: [{ payload, from: this.partyIdx }], p2pMessages: [] };\n    } catch (e) {\n      throw Error(`Error while creating the first VRF 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 everything they hold; the\n   * round routing happens here:\n   *\n   * - Round 1 (WaitMsg1): consumes the other parties' commitments (own excluded —\n   *   the wasm rejects a sender set containing the party's own Msg1) and emits this\n   *   party's openings (VrfKeygenMsg2), one broadcast message per recipient.\n   * - Round 2 (WaitMsg2): consumes the openings addressed to this party (own\n   *   self-addressed opening included) and finalizes the DKG, returning no messages.\n   */\n  async handleIncomingMessages(messagesForIthRound: DeserializedMessages): Promise<DeserializedMessages> {\n    this._restoreSession();\n    if (!this.vrfSession) {\n      throw Error('Session not initialized');\n    }\n    const { Message: VrfMessage } = this.getVrfWasm();\n    let nextRoundMessages: VrfWasmMessage[] = [];\n    const nextRoundDeserializedMessages: DeserializedMessages = { broadcastMessages: [], p2pMessages: [] };\n    try {\n      switch (this.vrfState) {\n        case VrfDkgState.Round1: {\n          const othersCommitments = messagesForIthRound.broadcastMessages.filter((m) => m.from !== this.partyIdx);\n          nextRoundMessages = this.vrfSession.handleMessages(\n            othersCommitments.map((m) => new VrfMessage(m.payload, m.from))\n          );\n          this._deserializeState();\n          break;\n        }\n        case VrfDkgState.Round2: {\n          const openingsForMe = messagesForIthRound.p2pMessages.filter((m) => m.to === this.partyIdx);\n          nextRoundMessages = this.vrfSession.handleMessages(\n            openingsForMe.map((m) => new VrfMessage(m.payload, m.from, m.to))\n          );\n          // vrfKeyshare() consumes (and deallocates) the session in all cases.\n          const vrfKeyShare = this.vrfSession.vrfKeyshare();\n          this.vrfKeyShare = vrfKeyShare;\n          this.keyShareBuff = Buffer.from(vrfKeyShare.toBytes());\n          this.publicKey = Buffer.from(vrfKeyShare.publicKey);\n          this.keyId = Buffer.from(vrfKeyShare.keyId);\n          this.rootChainCode = Buffer.from(vrfKeyShare.rootChainCode);\n          vrfKeyShare.free();\n          this.vrfState = VrfDkgState.Complete;\n          return nextRoundDeserializedMessages;\n        }\n        default:\n          throw Error(`Invalid VRF DKG state: ${this.vrfState}`);\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.to_id !== undefined)\n        .map((m) => ({ payload: new Uint8Array(m.payload), from: m.from_id, to: m.to_id! }));\n      return nextRoundDeserializedMessages;\n    } catch (e) {\n      throw Error(`Error while creating VRF messages from party ${this.partyIdx}, state ${this.vrfState}: ${e}`);\n    } finally {\n      nextRoundMessages.forEach((m) => m.free());\n      if (this.vrfState !== VrfDkgState.Complete) {\n        this.vrfSessionBytes = this.vrfSession.toBytes();\n        this.vrfSession = undefined;\n      }\n    }\n  }\n\n  /**\n   * Get the VRF keyshare bytes (CBOR VrfKeyshare) once the DKG is complete.\n   * This buffer is private key material.\n   */\n  getKeyShare(): Buffer {\n    if (!this.keyShareBuff) {\n      throw Error('Can not get key share, VRF DKG is not complete yet.');\n    }\n    return this.keyShareBuff;\n  }\n\n  /** 32-byte compressed Ristretto VRF public key, available once the DKG is complete. */\n  getPublicKey(): Buffer {\n    if (!this.publicKey) {\n      throw Error('Can not get public key, VRF DKG is not complete yet.');\n    }\n    return this.publicKey;\n  }\n\n  /** 32-byte VRF key identifier, available once the DKG is complete. */\n  getKeyId(): Buffer {\n    if (!this.keyId) {\n      throw Error('Can not get key id, VRF DKG is not complete yet.');\n    }\n    return this.keyId;\n  }\n\n  /** 32-byte VRF root chain code, available once the DKG is complete. */\n  getRootChainCode(): Buffer {\n    if (!this.rootChainCode) {\n      throw Error('Can not get root chain code, VRF DKG is not complete yet.');\n    }\n    return this.rootChainCode;\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   * secret polynomial share. They must never be logged or persisted in the clear;\n   * the caller encrypts them exactly like the key share itself.\n   */\n  getSessionData(): VrfDkgSessionData {\n    const sessionData: VrfDkgSessionData = {\n      vrfSessionBytes: this.vrfSessionBytes,\n      vrfState: this.vrfState,\n    };\n    if (this.keyShareBuff) {\n      sessionData.keyShareBuff = this.keyShareBuff;\n    }\n    return sessionData;\n  }\n\n  /**\n   * Restore a VRF DKG session from previous session data.\n   * Note: This should not be used for Round 1 as that's the initialization phase.\n   * The round state is re-derived from the wasm session bytes, not trusted from the\n   * caller-supplied enum, so a tampered `vrfState` cannot steer the protocol.\n   */\n  static async restoreSession(\n    n: number,\n    t: number,\n    partyIdx: number,\n    sessionData: VrfDkgSessionData,\n    seed?: Buffer,\n    vrfWasm?: BundlerVrfWasmer\n  ): Promise<VrfDkg> {\n    const vrfDkg = new VrfDkg(n, t, partyIdx, seed, vrfWasm);\n    if (!vrfDkg.vrfWasm) {\n      await vrfDkg.loadVrfWasm();\n    }\n    vrfDkg.vrfSessionBytes = sessionData.vrfSessionBytes;\n    vrfDkg._restoreSession();\n    vrfDkg._deserializeState();\n    if (sessionData.keyShareBuff) {\n      vrfDkg.keyShareBuff = sessionData.keyShareBuff;\n    }\n    return vrfDkg;\n  }\n}\n"]}

package/dist/src/tss/dkls-vrf/index.d.ts

@@ -0,0 +1,4 @@
+export * as DklsVrf from './dkg';
+export * as DklsVrfTypes from './types';
+export * as DklsVrfUtils from './util';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/tss/dkls-vrf/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tss/dkls-vrf/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,YAAY,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC"}

package/dist/src/tss/dkls-vrf/index.js

@@ -0,0 +1,40 @@
+"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.DklsVrfUtils = exports.DklsVrfTypes = exports.DklsVrf = void 0;
+exports.DklsVrf = __importStar(require("./dkg"));
+exports.DklsVrfTypes = __importStar(require("./types"));
+exports.DklsVrfUtils = __importStar(require("./util"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHNzL2RrbHMtdnJmL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUFpQztBQUNqQyx3REFBd0M7QUFDeEMsdURBQXVDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogYXMgRGtsc1ZyZiBmcm9tICcuL2RrZyc7XG5leHBvcnQgKiBhcyBEa2xzVnJmVHlwZXMgZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBhcyBEa2xzVnJmVXRpbHMgZnJvbSAnLi91dGlsJztcbiJdfQ==

package/dist/src/tss/dkls-vrf/types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * States of the VRF DKG state machine: a two-round, commit-then-open distributed
+ * key generation. Kept separate from `ecdsa-dkls`'s `DkgState` because the round
+ * counts differ (2 vs 4).
+ *
+ * The wasm session bytes embed a round tag (`Init` / `WaitMsg1` / `WaitMsg2` /
+ * `{Share: …}`); `VrfDkg` re-derives this state from the bytes rather than
+ * trusting a caller-supplied value.
+ */
+export declare enum VrfDkgState {
+    Uninitialized = 0,
+    /** Commitment created and broadcast; waiting for the other parties' VrfKeygenMsg1. */
+    Round1 = 1,
+    /** Openings created and broadcast; waiting for the other parties' VrfKeygenMsg2. */
+    Round2 = 2,
+    Complete = 3,
+    InvalidState = 4
+}
+export interface VrfDkgSessionData {
+    /**
+     * Serialized wasm session. Secret key material — it carries the party's
+     * secret polynomial share. Never log it or persist it in the clear.
+     */
+    vrfSessionBytes: Uint8Array;
+    vrfState: VrfDkgState;
+    keyShareBuff?: Buffer;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/tss/dkls-vrf/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tss/dkls-vrf/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,oBAAY,WAAW;IACrB,aAAa,IAAI;IACjB,sFAAsF;IACtF,MAAM,IAAA;IACN,oFAAoF;IACpF,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,YAAY,IAAA;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,eAAe,EAAE,UAAU,CAAC;IAC5B,QAAQ,EAAE,WAAW,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/src/tss/dkls-vrf/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VrfDkgState = void 0;
+/**
+ * States of the VRF DKG state machine: a two-round, commit-then-open distributed
+ * key generation. Kept separate from `ecdsa-dkls`'s `DkgState` because the round
+ * counts differ (2 vs 4).
+ *
+ * The wasm session bytes embed a round tag (`Init` / `WaitMsg1` / `WaitMsg2` /
+ * `{Share: …}`); `VrfDkg` re-derives this state from the bytes rather than
+ * trusting a caller-supplied value.
+ */
+var VrfDkgState;
+(function (VrfDkgState) {
+    VrfDkgState[VrfDkgState["Uninitialized"] = 0] = "Uninitialized";
+    /** Commitment created and broadcast; waiting for the other parties' VrfKeygenMsg1. */
+    VrfDkgState[VrfDkgState["Round1"] = 1] = "Round1";
+    /** Openings created and broadcast; waiting for the other parties' VrfKeygenMsg2. */
+    VrfDkgState[VrfDkgState["Round2"] = 2] = "Round2";
+    VrfDkgState[VrfDkgState["Complete"] = 3] = "Complete";
+    VrfDkgState[VrfDkgState["InvalidState"] = 4] = "InvalidState";
+})(VrfDkgState || (exports.VrfDkgState = VrfDkgState = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHNzL2RrbHMtdnJmL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7OztHQVFHO0FBQ0gsSUFBWSxXQVFYO0FBUkQsV0FBWSxXQUFXO0lBQ3JCLCtEQUFpQixDQUFBO0lBQ2pCLHNGQUFzRjtJQUN0RixpREFBTSxDQUFBO0lBQ04sb0ZBQW9GO0lBQ3BGLGlEQUFNLENBQUE7SUFDTixxREFBUSxDQUFBO0lBQ1IsNkRBQVksQ0FBQTtBQUNkLENBQUMsRUFSVyxXQUFXLDJCQUFYLFdBQVcsUUFRdEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFN0YXRlcyBvZiB0aGUgVlJGIERLRyBzdGF0ZSBtYWNoaW5lOiBhIHR3by1yb3VuZCwgY29tbWl0LXRoZW4tb3BlbiBkaXN0cmlidXRlZFxuICoga2V5IGdlbmVyYXRpb24uIEtlcHQgc2VwYXJhdGUgZnJvbSBgZWNkc2EtZGtsc2AncyBgRGtnU3RhdGVgIGJlY2F1c2UgdGhlIHJvdW5kXG4gKiBjb3VudHMgZGlmZmVyICgyIHZzIDQpLlxuICpcbiAqIFRoZSB3YXNtIHNlc3Npb24gYnl0ZXMgZW1iZWQgYSByb3VuZCB0YWcgKGBJbml0YCAvIGBXYWl0TXNnMWAgLyBgV2FpdE1zZzJgIC9cbiAqIGB7U2hhcmU6IOKApn1gKTsgYFZyZkRrZ2AgcmUtZGVyaXZlcyB0aGlzIHN0YXRlIGZyb20gdGhlIGJ5dGVzIHJhdGhlciB0aGFuXG4gKiB0cnVzdGluZyBhIGNhbGxlci1zdXBwbGllZCB2YWx1ZS5cbiAqL1xuZXhwb3J0IGVudW0gVnJmRGtnU3RhdGUge1xuICBVbmluaXRpYWxpemVkID0gMCxcbiAgLyoqIENvbW1pdG1lbnQgY3JlYXRlZCBhbmQgYnJvYWRjYXN0OyB3YWl0aW5nIGZvciB0aGUgb3RoZXIgcGFydGllcycgVnJmS2V5Z2VuTXNnMS4gKi9cbiAgUm91bmQxLFxuICAvKiogT3BlbmluZ3MgY3JlYXRlZCBhbmQgYnJvYWRjYXN0OyB3YWl0aW5nIGZvciB0aGUgb3RoZXIgcGFydGllcycgVnJmS2V5Z2VuTXNnMi4gKi9cbiAgUm91bmQyLFxuICBDb21wbGV0ZSxcbiAgSW52YWxpZFN0YXRlLFxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFZyZkRrZ1Nlc3Npb25EYXRhIHtcbiAgLyoqXG4gICAqIFNlcmlhbGl6ZWQgd2FzbSBzZXNzaW9uLiBTZWNyZXQga2V5IG1hdGVyaWFsIOKAlCBpdCBjYXJyaWVzIHRoZSBwYXJ0eSdzXG4gICAqIHNlY3JldCBwb2x5bm9taWFsIHNoYXJlLiBOZXZlciBsb2cgaXQgb3IgcGVyc2lzdCBpdCBpbiB0aGUgY2xlYXIuXG4gICAqL1xuICB2cmZTZXNzaW9uQnl0ZXM6IFVpbnQ4QXJyYXk7XG4gIHZyZlN0YXRlOiBWcmZEa2dTdGF0ZTtcbiAga2V5U2hhcmVCdWZmPzogQnVmZmVyO1xufVxuIl19

package/dist/src/tss/dkls-vrf/util.d.ts

@@ -0,0 +1,9 @@
+import { Buffer } from 'buffer';
+import { VrfDkg } from './dkg';
+/**
+ * Runs a local 2-of-3 VRF DKG across user (0), backup (1) and bitgo (2) parties and
+ * returns the three completed VrfDkg sessions, mirroring `generateDKGKeyShares` from
+ * `ecdsa-dkls/util.ts` so VRF tests read like the existing DKLS ones.
+ */
+export declare function generateVrfDKGKeyShares(seedUser?: Buffer, seedBackup?: Buffer, seedBitgo?: Buffer): Promise<[VrfDkg, VrfDkg, VrfDkg]>;
+//# sourceMappingURL=util.d.ts.map

package/dist/src/tss/dkls-vrf/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/tss/dkls-vrf/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAE/B;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CA0CnC"}

package/dist/src/tss/dkls-vrf/util.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVrfDKGKeyShares = generateVrfDKGKeyShares;
+const dkg_1 = require("./dkg");
+/**
+ * Runs a local 2-of-3 VRF DKG across user (0), backup (1) and bitgo (2) parties and
+ * returns the three completed VrfDkg sessions, mirroring `generateDKGKeyShares` from
+ * `ecdsa-dkls/util.ts` so VRF tests read like the existing DKLS ones.
+ */
+async function generateVrfDKGKeyShares(seedUser, seedBackup, seedBitgo) {
+    const user = new dkg_1.VrfDkg(3, 2, 0, seedUser);
+    const backup = new dkg_1.VrfDkg(3, 2, 1, seedBackup);
+    const bitgo = new dkg_1.VrfDkg(3, 2, 2, seedBitgo);
+    // #region round 1
+    const userRound1Messages = await user.initDkg();
+    const backupRound1Messages = await backup.initDkg();
+    const bitgoRound1Messages = await bitgo.initDkg();
+    const bitgoRound2Messages = await bitgo.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [...userRound1Messages.broadcastMessages, ...backupRound1Messages.broadcastMessages],
+    });
+    // #endregion
+    // #region round 2
+    const userRound2Messages = await user.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [...bitgoRound1Messages.broadcastMessages, ...backupRound1Messages.broadcastMessages],
+    });
+    const backupRound2Messages = await backup.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [...userRound1Messages.broadcastMessages, ...bitgoRound1Messages.broadcastMessages],
+    });
+    await bitgo.handleIncomingMessages({
+        p2pMessages: [bitgoRound2Messages, userRound2Messages, backupRound2Messages]
+            .flatMap((m) => m.p2pMessages)
+            .filter((m) => m.to === 2),
+        broadcastMessages: [],
+    });
+    await user.handleIncomingMessages({
+        p2pMessages: [bitgoRound2Messages, userRound2Messages, backupRound2Messages]
+            .flatMap((m) => m.p2pMessages)
+            .filter((m) => m.to === 0),
+        broadcastMessages: [],
+    });
+    await backup.handleIncomingMessages({
+        p2pMessages: [bitgoRound2Messages, userRound2Messages, backupRound2Messages]
+            .flatMap((m) => m.p2pMessages)
+            .filter((m) => m.to === 1),
+        broadcastMessages: [],
+    });
+    return [user, backup, bitgo];
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,9 +1,12 @@
 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;
@@ -58,5 +61,4 @@ export declare class Dkg {
      */
     static restoreSession(n: number, t: number, partyIdx: number, sessionData: DkgSessionData, seed?: Buffer, retrofitData?: RetrofitData, dklsWasm?: BundlerWasmer): Promise<Dkg>;
 }
-export {};
 //# sourceMappingURL=dkg.d.ts.map