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

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"]}

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

@@ -0,0 +1,111 @@
+import type { HardDeriveSession as DklsHardDeriveSession, VrfKeygenSession as DklsVrfKeygenSession } from '@silencelaboratories/dkls-wasm-ll-vrf-node';
+import type { HardDeriveSession as DklsVrfWebHardDeriveSession, VrfKeygenSession as DklsVrfWebKeygenSession } from '@silencelaboratories/dkls-wasm-ll-vrf-web';
+import { Buffer } from 'buffer';
+import { DeserializedBroadcastMessage, DeserializedMessages } 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;
+export type { DklsHardDeriveSession, DklsVrfWebHardDeriveSession, DklsVrfKeygenSession, DklsVrfWebKeygenSession };
+export declare enum DeriveState {
+    Uninitialized = 0,
+    Round1 = 1,
+    Round2 = 2,
+    Complete = 3,
+    InvalidState = 4
+}
+export interface DeriveSessionData {
+    deriveSessionBytes: Uint8Array;
+    deriveState: DeriveState;
+    keyShareBuff?: Buffer;
+    ownMsg1?: Uint8Array;
+    ownMsg2?: Uint8Array;
+}
+/**
+ * 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.
+ */
+export declare class Derive {
+    protected deriveSession: DklsHardDeriveSession | DklsVrfWebHardDeriveSession | undefined;
+    protected deriveSessionBytes: Uint8Array;
+    protected keyShareBuff: Buffer | undefined;
+    protected n: number;
+    protected t: number;
+    protected partyIdx: number;
+    protected rootKeyShare: Buffer;
+    protected vrfKeyShare: Buffer;
+    protected path: Uint8Array;
+    protected seed: Buffer | undefined;
+    protected deriveState: DeriveState;
+    protected vrfWasm: VrfWasm | null;
+    protected ownMsg1: Uint8Array | undefined;
+    protected ownMsg2: Uint8Array | undefined;
+    constructor(n: number, t: number, partyIdx: number, rootKeyShare: Buffer, vrfKeyShare: Buffer, path: Uint8Array, 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 the round tag (`WaitMsg1`/`WaitMsg2`,
+     * then a `Share` payload once finalized) for exactly this reason.
+     */
+    private _deserializeState;
+    /**
+     * Create this party's first hard-derive message (broadcast). Seeds the wasm
+     * session from the root keyshare, VRF keyshare and derivation path.
+     */
+    initDerive(): Promise<DeserializedBroadcastMessage>;
+    /**
+     * 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: DeserializedMessages): DeserializedMessages;
+    /**
+     * Get the derived DKLS keyshare bytes (CBOR `Keyshare`) once the derive is
+     * complete. This buffer is private key material.
+     */
+    getKeyShare(): Buffer;
+    /**
+     * 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(): 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
+     * root keyshares. They must never be logged or persisted in the clear; the
+     * caller encrypts them exactly like the key share itself.
+     */
+    getSessionData(): DeriveSessionData;
+    /**
+     * 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 restoreSession(n: number, t: number, partyIdx: number, rootKeyShare: Buffer, vrfKeyShare: Buffer, path: Uint8Array, sessionData: DeriveSessionData, seed?: Buffer, vrfWasm?: BundlerVrfWasmer): Promise<Derive>;
+}
+//# sourceMappingURL=derive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derive.d.ts","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/derive.ts"],"names":[],"mappings":"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"}

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":"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","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"]}