@bitgo-beta/sdk-lib-mpc 8.2.0-beta.209 → 8.2.0-beta.2090

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 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      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,29 @@
+import { Buffer } from 'buffer';
+import { Derive } from '../ecdsa-dkls/derive';
+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]>;
+/**
+ * Runs the hard-derivation ceremony on top of completed root sessions: the user (0)
+ * hard-derive session pairs with a fresh BitGo (2) session, and the backup (1)
+ * session with a second fresh BitGo session. The hard-derive wasm session is a
+ * 2-party threshold protocol per instance, so the BitGo server side runs two
+ * sessions — one per SDK party. All four derived keyshares agree on the child
+ * public key; the two BitGo shares are distinct private shares of that same key.
+ *
+ * @param path hardened derivation path bytes (e.g. `m/0'` as a 4-byte big-endian
+ *   index with the hardened bit set)
+ * @returns [user, backup, bitgoUserPair, bitgoBackupPair] completed Derive sessions
+ */
+export declare function generateHardDerivedKeyShares(userRoot: {
+    getKeyShare(): Buffer;
+}, backupRoot: {
+    getKeyShare(): Buffer;
+}, bitgoRoot: {
+    getKeyShare(): Buffer;
+}, userVrf: VrfDkg, backupVrf: VrfDkg, bitgoVrf: VrfDkg, path: Uint8Array, seedUser?: Buffer, seedBackup?: Buffer): Promise<[Derive, Derive, Derive, Derive]>;
+//# 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,sBAAsB,CAAC;AAC9C,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;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE;IAAE,WAAW,IAAI,MAAM,CAAA;CAAE,EACnC,UAAU,EAAE;IAAE,WAAW,IAAI,MAAM,CAAA;CAAE,EACrC,SAAS,EAAE;IAAE,WAAW,IAAI,MAAM,CAAA;CAAE,EACpC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAkD3C"}

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVrfDKGKeyShares = generateVrfDKGKeyShares;
+exports.generateHardDerivedKeyShares = generateHardDerivedKeyShares;
+const derive_1 = require("../ecdsa-dkls/derive");
+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];
+}
+/**
+ * Runs the hard-derivation ceremony on top of completed root sessions: the user (0)
+ * hard-derive session pairs with a fresh BitGo (2) session, and the backup (1)
+ * session with a second fresh BitGo session. The hard-derive wasm session is a
+ * 2-party threshold protocol per instance, so the BitGo server side runs two
+ * sessions — one per SDK party. All four derived keyshares agree on the child
+ * public key; the two BitGo shares are distinct private shares of that same key.
+ *
+ * @param path hardened derivation path bytes (e.g. `m/0'` as a 4-byte big-endian
+ *   index with the hardened bit set)
+ * @returns [user, backup, bitgoUserPair, bitgoBackupPair] completed Derive sessions
+ */
+async function generateHardDerivedKeyShares(userRoot, backupRoot, bitgoRoot, userVrf, backupVrf, bitgoVrf, path, seedUser, seedBackup) {
+    const user = new derive_1.Derive(3, 2, 0, userRoot.getKeyShare(), userVrf.getKeyShare(), path, seedUser);
+    const backup = new derive_1.Derive(3, 2, 1, backupRoot.getKeyShare(), backupVrf.getKeyShare(), path, seedBackup);
+    const bitgoUserPair = new derive_1.Derive(3, 2, 2, bitgoRoot.getKeyShare(), bitgoVrf.getKeyShare(), path);
+    const bitgoBackupPair = new derive_1.Derive(3, 2, 2, bitgoRoot.getKeyShare(), bitgoVrf.getKeyShare(), path);
+    // #region round 1
+    const userMsg1 = await user.initDerive();
+    const backupMsg1 = await backup.initDerive();
+    const bitgoUserPairMsg1 = await bitgoUserPair.initDerive();
+    const bitgoBackupPairMsg1 = await bitgoBackupPair.initDerive();
+    const userMsg2 = user.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: bitgoUserPairMsg1.payload, from: bitgoUserPairMsg1.from }],
+    });
+    const bitgoUserPairMsg2 = bitgoUserPair.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: userMsg1.payload, from: userMsg1.from }],
+    });
+    const backupMsg2 = backup.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: bitgoBackupPairMsg1.payload, from: bitgoBackupPairMsg1.from }],
+    });
+    const bitgoBackupPairMsg2 = bitgoBackupPair.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: backupMsg1.payload, from: backupMsg1.from }],
+    });
+    // #endregion
+    // #region round 2
+    user.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: bitgoUserPairMsg2.broadcastMessages[0].payload, from: 2 }],
+    });
+    bitgoUserPair.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: userMsg2.broadcastMessages[0].payload, from: 0 }],
+    });
+    backup.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: bitgoBackupPairMsg2.broadcastMessages[0].payload, from: 2 }],
+    });
+    bitgoBackupPair.handleIncomingMessages({
+        p2pMessages: [],
+        broadcastMessages: [{ payload: backupMsg2.broadcastMessages[0].payload, from: 1 }],
+    });
+    // #endregion
+    return [user, backup, bitgoUserPair, bitgoBackupPair];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/tss/dkls-vrf/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { Buffer } from 'buffer';\nimport { Derive } from '../ecdsa-dkls/derive';\nimport { VrfDkg } from './dkg';\n\n/**\n * Runs a local 2-of-3 VRF DKG across user (0), backup (1) and bitgo (2) parties and\n * returns the three completed VrfDkg sessions, mirroring `generateDKGKeyShares` from\n * `ecdsa-dkls/util.ts` so VRF tests read like the existing DKLS ones.\n */\nexport async function generateVrfDKGKeyShares(\n  seedUser?: Buffer,\n  seedBackup?: Buffer,\n  seedBitgo?: Buffer\n): Promise<[VrfDkg, VrfDkg, VrfDkg]> {\n  const user = new VrfDkg(3, 2, 0, seedUser);\n  const backup = new VrfDkg(3, 2, 1, seedBackup);\n  const bitgo = new VrfDkg(3, 2, 2, seedBitgo);\n  // #region round 1\n  const userRound1Messages = await user.initDkg();\n  const backupRound1Messages = await backup.initDkg();\n  const bitgoRound1Messages = await bitgo.initDkg();\n  const bitgoRound2Messages = await bitgo.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [...userRound1Messages.broadcastMessages, ...backupRound1Messages.broadcastMessages],\n  });\n  // #endregion\n\n  // #region round 2\n  const userRound2Messages = await user.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [...bitgoRound1Messages.broadcastMessages, ...backupRound1Messages.broadcastMessages],\n  });\n  const backupRound2Messages = await backup.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [...userRound1Messages.broadcastMessages, ...bitgoRound1Messages.broadcastMessages],\n  });\n  await bitgo.handleIncomingMessages({\n    p2pMessages: [bitgoRound2Messages, userRound2Messages, backupRound2Messages]\n      .flatMap((m) => m.p2pMessages)\n      .filter((m) => m.to === 2),\n    broadcastMessages: [],\n  });\n  await user.handleIncomingMessages({\n    p2pMessages: [bitgoRound2Messages, userRound2Messages, backupRound2Messages]\n      .flatMap((m) => m.p2pMessages)\n      .filter((m) => m.to === 0),\n    broadcastMessages: [],\n  });\n  await backup.handleIncomingMessages({\n    p2pMessages: [bitgoRound2Messages, userRound2Messages, backupRound2Messages]\n      .flatMap((m) => m.p2pMessages)\n      .filter((m) => m.to === 1),\n    broadcastMessages: [],\n  });\n  return [user, backup, bitgo];\n}\n\n/**\n * Runs the hard-derivation ceremony on top of completed root sessions: the user (0)\n * hard-derive session pairs with a fresh BitGo (2) session, and the backup (1)\n * session with a second fresh BitGo session. The hard-derive wasm session is a\n * 2-party threshold protocol per instance, so the BitGo server side runs two\n * sessions — one per SDK party. All four derived keyshares agree on the child\n * public key; the two BitGo shares are distinct private shares of that same key.\n *\n * @param path hardened derivation path bytes (e.g. `m/0'` as a 4-byte big-endian\n *   index with the hardened bit set)\n * @returns [user, backup, bitgoUserPair, bitgoBackupPair] completed Derive sessions\n */\nexport async function generateHardDerivedKeyShares(\n  userRoot: { getKeyShare(): Buffer },\n  backupRoot: { getKeyShare(): Buffer },\n  bitgoRoot: { getKeyShare(): Buffer },\n  userVrf: VrfDkg,\n  backupVrf: VrfDkg,\n  bitgoVrf: VrfDkg,\n  path: Uint8Array,\n  seedUser?: Buffer,\n  seedBackup?: Buffer\n): Promise<[Derive, Derive, Derive, Derive]> {\n  const user = new Derive(3, 2, 0, userRoot.getKeyShare(), userVrf.getKeyShare(), path, seedUser);\n  const backup = new Derive(3, 2, 1, backupRoot.getKeyShare(), backupVrf.getKeyShare(), path, seedBackup);\n  const bitgoUserPair = new Derive(3, 2, 2, bitgoRoot.getKeyShare(), bitgoVrf.getKeyShare(), path);\n  const bitgoBackupPair = new Derive(3, 2, 2, bitgoRoot.getKeyShare(), bitgoVrf.getKeyShare(), path);\n\n  // #region round 1\n  const userMsg1 = await user.initDerive();\n  const backupMsg1 = await backup.initDerive();\n  const bitgoUserPairMsg1 = await bitgoUserPair.initDerive();\n  const bitgoBackupPairMsg1 = await bitgoBackupPair.initDerive();\n\n  const userMsg2 = user.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: bitgoUserPairMsg1.payload, from: bitgoUserPairMsg1.from }],\n  });\n  const bitgoUserPairMsg2 = bitgoUserPair.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: userMsg1.payload, from: userMsg1.from }],\n  });\n  const backupMsg2 = backup.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: bitgoBackupPairMsg1.payload, from: bitgoBackupPairMsg1.from }],\n  });\n  const bitgoBackupPairMsg2 = bitgoBackupPair.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: backupMsg1.payload, from: backupMsg1.from }],\n  });\n  // #endregion\n\n  // #region round 2\n  user.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: bitgoUserPairMsg2.broadcastMessages[0].payload, from: 2 }],\n  });\n  bitgoUserPair.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: userMsg2.broadcastMessages[0].payload, from: 0 }],\n  });\n  backup.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: bitgoBackupPairMsg2.broadcastMessages[0].payload, from: 2 }],\n  });\n  bitgoBackupPair.handleIncomingMessages({\n    p2pMessages: [],\n    broadcastMessages: [{ payload: backupMsg2.broadcastMessages[0].payload, from: 1 }],\n  });\n  // #endregion\n\n  return [user, backup, bitgoUserPair, bitgoBackupPair];\n}\n"]}