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

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

@@ -0,0 +1,268 @@
+"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.SIGNATURE_DATE_TOLERANCE_MS = void 0;
+exports.detachSignData = detachSignData;
+exports.encryptAndDetachSignData = encryptAndDetachSignData;
+exports.decryptAndVerifySignedData = decryptAndVerifySignedData;
+exports.verifySignedData = verifySignedData;
+exports.decryptAndVerifyIncomingMessages = decryptAndVerifyIncomingMessages;
+exports.encryptAndAuthOutgoingMessages = encryptAndAuthOutgoingMessages;
+const pgp = __importStar(require("openpgp"));
+/**
+ * Tolerance window for OpenPGP date-based key validity checks (24 hours).
+ *
+ * Background: OpenPGP.js uses the `date` parameter to check key expiry at a
+ * given point in time. We previously passed `date: null` to disable this check
+ * entirely (see HSM-706) because OVC cold-signing flows for trust and SMC
+ * clients can involve significant clock skew between the signing device and the
+ * server — the device may be air-gapped and its clock can drift by hours.
+ *
+ * Note: this GPG expiry check is not strictly required for replay protection.
+ * The DKLS protocol has its own mechanism for preventing replay attacks
+ * (session-bound commitments and round-specific message validation), so the
+ * OpenPGP date check is a defense-in-depth measure rather than the primary
+ * replay mitigation.
+ *
+ * OpenPGP's `date` parameter shifts the reference time for ALL temporal
+ * checks simultaneously (key expiry, self-signature validity, signature
+ * freshness). This means a single shifted date cannot independently relax
+ * key-expiry checks without breaking self-signature validation on fresh keys.
+ *
+ * Therefore:
+ * - encrypt/decrypt omit `date` (use default = current time) for normal key
+ *   expiry checking and self-signature validation.
+ * - verify uses `now + tolerance` so that signatures from OVC devices whose
+ *   clocks are up to 24 hours ahead are not rejected as "from the future".
+ */
+exports.SIGNATURE_DATE_TOLERANCE_MS = 24 * 60 * 60 * 1000;
+/**
+ * Detach signs a binary and encodes it in base64
+ * @param data binary to encode in base64 and sign
+ * @param privateArmor private key to sign with
+ */
+async function detachSignData(data, privateArmor) {
+    const message = await pgp.createMessage({ binary: data });
+    const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });
+    const signature = await pgp.sign({
+        message,
+        signingKeys: privateKey,
+        format: 'armored',
+        detached: true,
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+    return {
+        message: data.toString('base64'),
+        signature: signature,
+    };
+}
+/**
+ * Encrypts and detach signs a binary
+ * @param data binary to encrypt and sign
+ * @param publicArmor public key to encrypt with
+ * @param privateArmor private key to sign with
+ */
+async function encryptAndDetachSignData(data, publicArmor, privateArmor) {
+    const message = await pgp.createMessage({ binary: data });
+    const publicKey = await pgp.readKey({ armoredKey: publicArmor });
+    const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });
+    const encryptedMessage = await pgp.encrypt({
+        message,
+        encryptionKeys: publicKey,
+        format: 'armored',
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+    const signature = await pgp.sign({
+        message,
+        signingKeys: privateKey,
+        format: 'armored',
+        detached: true,
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+    return {
+        encryptedMessage: encryptedMessage,
+        signature: signature,
+    };
+}
+/**
+ * Decrypts and verifies signature on a binary
+ * @param encryptedAndSignedMessage message to decrypt and verify
+ * @param publicArmor public key to verify signature with
+ * @param privateArmor private key to decrypt with
+ */
+async function decryptAndVerifySignedData(encryptedAndSignedMessage, publicArmor, privateArmor) {
+    const publicKey = await pgp.readKey({ armoredKey: publicArmor });
+    const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });
+    const decryptedMessage = await pgp.decrypt({
+        message: await pgp.readMessage({ armoredMessage: encryptedAndSignedMessage.encryptedMessage }),
+        decryptionKeys: [privateKey],
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+        format: 'binary',
+    });
+    const verificationResult = await pgp.verify({
+        message: await pgp.createMessage({ binary: decryptedMessage.data }),
+        signature: await pgp.readSignature({ armoredSignature: encryptedAndSignedMessage.signature }),
+        verificationKeys: publicKey,
+        date: new Date(Date.now() + exports.SIGNATURE_DATE_TOLERANCE_MS),
+    });
+    await verificationResult.signatures[0].verified;
+    return Buffer.from(decryptedMessage.data).toString('base64');
+}
+/**
+ * Verifies signature on a binary (message passed should be encoded in base64).
+ * @param signedMessage message to verify
+ * @param publicArmor public key to verify signature with
+ */
+async function verifySignedData(signedMessage, publicArmor) {
+    const publicKey = await pgp.readKey({ armoredKey: publicArmor });
+    const verificationResult = await pgp.verify({
+        message: await pgp.createMessage({ binary: Buffer.from(signedMessage.message, 'base64') }),
+        signature: await pgp.readSignature({ armoredSignature: signedMessage.signature }),
+        verificationKeys: publicKey,
+        date: new Date(Date.now() + exports.SIGNATURE_DATE_TOLERANCE_MS),
+    });
+    try {
+        await verificationResult.signatures[0].verified;
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * Decrypts and verifies p2p messages + verifies broadcast messages
+ * @param messages message to decrypt and verify
+ * @param pubVerificationGpgKeys public keys to verify signatures with
+ * @param prvDecryptionGpgKeys private keys to decrypt with
+ */
+async function decryptAndVerifyIncomingMessages(messages, pubVerificationGpgKeys, prvDecryptionGpgKeys) {
+    return {
+        p2pMessages: await Promise.all(messages.p2pMessages.map(async (m) => {
+            const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);
+            const prvGpgKey = prvDecryptionGpgKeys.find((k) => k.partyId === m.to);
+            if (!pubGpgKey) {
+                throw Error(`No public key provided for sender with ID: ${m.from}`);
+            }
+            if (!prvGpgKey) {
+                throw Error(`No private key provided for recepient with ID: ${m.to}`);
+            }
+            return {
+                to: m.to,
+                from: m.from,
+                payload: await decryptAndVerifySignedData(m.payload, pubGpgKey.gpgKey, prvGpgKey.gpgKey),
+                commitment: m.commitment,
+            };
+        })),
+        broadcastMessages: await Promise.all(messages.broadcastMessages.map(async (m) => {
+            const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);
+            if (!pubGpgKey) {
+                throw Error(`No public key provided for sender with ID: ${m.from}`);
+            }
+            if (!(await verifySignedData(m.payload, pubGpgKey.gpgKey))) {
+                throw Error(`Failed to authenticate broadcast message from party: ${m.from}`);
+            }
+            if (m.signatureR !== undefined) {
+                if (!(await verifySignedData(m.signatureR, pubGpgKey.gpgKey))) {
+                    throw Error(`Failed to authenticate signatureR in broadcast message from party: ${m.from}`);
+                }
+            }
+            return {
+                from: m.from,
+                payload: m.payload.message,
+                signatureR: m.signatureR?.message,
+            };
+        })),
+    };
+}
+/**
+ * Encrypts and signs p2p messages + signs broadcast messages
+ * @param messages messages to encrypt and sign
+ * @param pubEncryptionGpgKey public keys to encrypt data to
+ * @param prvAuthenticationGpgKey private keys to sign with
+ */
+async function encryptAndAuthOutgoingMessages(messages, pubEncryptionGpgKeys, prvAuthenticationGpgKeys) {
+    return {
+        p2pMessages: await Promise.all(messages.p2pMessages.map(async (m) => {
+            const pubGpgKey = pubEncryptionGpgKeys.find((k) => k.partyId === m.to);
+            const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);
+            if (!pubGpgKey) {
+                throw Error(`No public key provided for recipient with ID: ${m.to}`);
+            }
+            if (!prvGpgKey) {
+                throw Error(`No private key provided for sender with ID: ${m.from}`);
+            }
+            return {
+                to: m.to,
+                from: m.from,
+                payload: await encryptAndDetachSignData(Buffer.from(m.payload, 'base64'), pubGpgKey.gpgKey, prvGpgKey.gpgKey),
+                commitment: m.commitment,
+            };
+        })),
+        broadcastMessages: await Promise.all(messages.broadcastMessages.map(async (m) => {
+            const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);
+            if (!prvGpgKey) {
+                throw Error(`No private key provided for sender with ID: ${m.from}`);
+            }
+            const [signedPayload, signedSignatureR] = await Promise.all([
+                detachSignData(Buffer.from(m.payload, 'base64'), prvGpgKey.gpgKey),
+                m.signatureR
+                    ? detachSignData(Buffer.from(m.signatureR, 'base64'), prvGpgKey.gpgKey)
+                    : Promise.resolve(undefined),
+            ]);
+            return {
+                from: m.from,
+                payload: signedPayload,
+                signatureR: signedSignatureR,
+            };
+        })),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commsLayer.js","sourceRoot":"","sources":["../../../../src/tss/ecdsa-dkls/commsLayer.ts"],"names":[],"mappings":"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","sourcesContent":["import { SerializedMessages, AuthEncMessage, AuthEncMessages, PartyGpgKey, AuthMessage } from './types';\nimport * as pgp from 'openpgp';\n\n/**\n * Tolerance window for OpenPGP date-based key validity checks (24 hours).\n *\n * Background: OpenPGP.js uses the `date` parameter to check key expiry at a\n * given point in time. We previously passed `date: null` to disable this check\n * entirely (see HSM-706) because OVC cold-signing flows for trust and SMC\n * clients can involve significant clock skew between the signing device and the\n * server — the device may be air-gapped and its clock can drift by hours.\n *\n * Note: this GPG expiry check is not strictly required for replay protection.\n * The DKLS protocol has its own mechanism for preventing replay attacks\n * (session-bound commitments and round-specific message validation), so the\n * OpenPGP date check is a defense-in-depth measure rather than the primary\n * replay mitigation.\n *\n * OpenPGP's `date` parameter shifts the reference time for ALL temporal\n * checks simultaneously (key expiry, self-signature validity, signature\n * freshness). This means a single shifted date cannot independently relax\n * key-expiry checks without breaking self-signature validation on fresh keys.\n *\n * Therefore:\n * - encrypt/decrypt omit `date` (use default = current time) for normal key\n *   expiry checking and self-signature validation.\n * - verify uses `now + tolerance` so that signatures from OVC devices whose\n *   clocks are up to 24 hours ahead are not rejected as \"from the future\".\n */\nexport const SIGNATURE_DATE_TOLERANCE_MS = 24 * 60 * 60 * 1000;\n\n/**\n * Detach signs a binary and encodes it in base64\n * @param data binary to encode in base64 and sign\n * @param privateArmor private key to sign with\n */\nexport async function detachSignData(data: Buffer, privateArmor: string): Promise<AuthMessage> {\n  const message = await pgp.createMessage({ binary: data });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const signature = await pgp.sign({\n    message,\n    signingKeys: privateKey,\n    format: 'armored',\n    detached: true,\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  return {\n    message: data.toString('base64'),\n    signature: signature,\n  };\n}\n\n/**\n * Encrypts and detach signs a binary\n * @param data binary to encrypt and sign\n * @param publicArmor public key to encrypt with\n * @param privateArmor private key to sign with\n */\nexport async function encryptAndDetachSignData(\n  data: Buffer,\n  publicArmor: string,\n  privateArmor: string\n): Promise<AuthEncMessage> {\n  const message = await pgp.createMessage({ binary: data });\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const encryptedMessage = await pgp.encrypt({\n    message,\n    encryptionKeys: publicKey,\n    format: 'armored',\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  const signature = await pgp.sign({\n    message,\n    signingKeys: privateKey,\n    format: 'armored',\n    detached: true,\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n  return {\n    encryptedMessage: encryptedMessage,\n    signature: signature,\n  };\n}\n\n/**\n * Decrypts and verifies signature on a binary\n * @param encryptedAndSignedMessage message to decrypt and verify\n * @param publicArmor public key to verify signature with\n * @param privateArmor private key to decrypt with\n */\nexport async function decryptAndVerifySignedData(\n  encryptedAndSignedMessage: AuthEncMessage,\n  publicArmor: string,\n  privateArmor: string\n): Promise<string> {\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const privateKey = await pgp.readPrivateKey({ armoredKey: privateArmor });\n  const decryptedMessage = await pgp.decrypt({\n    message: await pgp.readMessage({ armoredMessage: encryptedAndSignedMessage.encryptedMessage }),\n    decryptionKeys: [privateKey],\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n    format: 'binary',\n  });\n  const verificationResult = await pgp.verify({\n    message: await pgp.createMessage({ binary: decryptedMessage.data }),\n    signature: await pgp.readSignature({ armoredSignature: encryptedAndSignedMessage.signature }),\n    verificationKeys: publicKey,\n    date: new Date(Date.now() + SIGNATURE_DATE_TOLERANCE_MS),\n  });\n  await verificationResult.signatures[0].verified;\n  return Buffer.from(decryptedMessage.data).toString('base64');\n}\n\n/**\n * Verifies signature on a binary (message passed should be encoded in base64).\n * @param signedMessage message to verify\n * @param publicArmor public key to verify signature with\n */\nexport async function verifySignedData(signedMessage: AuthMessage, publicArmor: string): Promise<boolean> {\n  const publicKey = await pgp.readKey({ armoredKey: publicArmor });\n  const verificationResult = await pgp.verify({\n    message: await pgp.createMessage({ binary: Buffer.from(signedMessage.message, 'base64') }),\n    signature: await pgp.readSignature({ armoredSignature: signedMessage.signature }),\n    verificationKeys: publicKey,\n    date: new Date(Date.now() + SIGNATURE_DATE_TOLERANCE_MS),\n  });\n  try {\n    await verificationResult.signatures[0].verified;\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Decrypts and verifies p2p messages + verifies broadcast messages\n * @param messages message to decrypt and verify\n * @param pubVerificationGpgKeys public keys to verify signatures with\n * @param prvDecryptionGpgKeys private keys to decrypt with\n */\nexport async function decryptAndVerifyIncomingMessages(\n  messages: AuthEncMessages,\n  pubVerificationGpgKeys: PartyGpgKey[],\n  prvDecryptionGpgKeys: PartyGpgKey[]\n): Promise<SerializedMessages> {\n  return {\n    p2pMessages: await Promise.all(\n      messages.p2pMessages.map(async (m) => {\n        const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);\n        const prvGpgKey = prvDecryptionGpgKeys.find((k) => k.partyId === m.to);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for sender with ID: ${m.from}`);\n        }\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for recepient with ID: ${m.to}`);\n        }\n        return {\n          to: m.to,\n          from: m.from,\n          payload: await decryptAndVerifySignedData(m.payload, pubGpgKey.gpgKey, prvGpgKey.gpgKey),\n          commitment: m.commitment,\n        };\n      })\n    ),\n    broadcastMessages: await Promise.all(\n      messages.broadcastMessages.map(async (m) => {\n        const pubGpgKey = pubVerificationGpgKeys.find((k) => k.partyId === m.from);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for sender with ID: ${m.from}`);\n        }\n        if (!(await verifySignedData(m.payload, pubGpgKey.gpgKey))) {\n          throw Error(`Failed to authenticate broadcast message from party: ${m.from}`);\n        }\n        if (m.signatureR !== undefined) {\n          if (!(await verifySignedData(m.signatureR, pubGpgKey.gpgKey))) {\n            throw Error(`Failed to authenticate signatureR in broadcast message from party: ${m.from}`);\n          }\n        }\n        return {\n          from: m.from,\n          payload: m.payload.message,\n          signatureR: m.signatureR?.message,\n        };\n      })\n    ),\n  };\n}\n\n/**\n * Encrypts and signs p2p messages + signs broadcast messages\n * @param messages messages to encrypt and sign\n * @param pubEncryptionGpgKey public keys to encrypt data to\n * @param prvAuthenticationGpgKey private keys to sign with\n */\nexport async function encryptAndAuthOutgoingMessages(\n  messages: SerializedMessages,\n  pubEncryptionGpgKeys: PartyGpgKey[],\n  prvAuthenticationGpgKeys: PartyGpgKey[]\n): Promise<AuthEncMessages> {\n  return {\n    p2pMessages: await Promise.all(\n      messages.p2pMessages.map(async (m) => {\n        const pubGpgKey = pubEncryptionGpgKeys.find((k) => k.partyId === m.to);\n        const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);\n        if (!pubGpgKey) {\n          throw Error(`No public key provided for recipient with ID: ${m.to}`);\n        }\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for sender with ID: ${m.from}`);\n        }\n        return {\n          to: m.to,\n          from: m.from,\n          payload: await encryptAndDetachSignData(Buffer.from(m.payload, 'base64'), pubGpgKey.gpgKey, prvGpgKey.gpgKey),\n          commitment: m.commitment,\n        };\n      })\n    ),\n    broadcastMessages: await Promise.all(\n      messages.broadcastMessages.map(async (m) => {\n        const prvGpgKey = prvAuthenticationGpgKeys.find((k) => k.partyId === m.from);\n        if (!prvGpgKey) {\n          throw Error(`No private key provided for sender with ID: ${m.from}`);\n        }\n        const [signedPayload, signedSignatureR] = await Promise.all([\n          detachSignData(Buffer.from(m.payload, 'base64'), prvGpgKey.gpgKey),\n          m.signatureR\n            ? detachSignData(Buffer.from(m.signatureR, 'base64'), prvGpgKey.gpgKey)\n            : Promise.resolve(undefined),\n        ]);\n        return {\n          from: m.from,\n          payload: signedPayload,\n          signatureR: signedSignatureR,\n        };\n      })\n    ),\n  };\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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"}