@spirobel/monero-wallet-api 0.4.0 → 0.5.0

package/README.md

@@ -1,27 +1,99 @@
 # @spirobel/monero-wallet-api
 
-To install dependencies:
+## quick start
+
+```ts
+import { openWallets } from "@spirobel/monero-wallet-api";
+
+// scan all non-halted wallets from the settings file:
+const wallets = await openWallets();
+```
+
+## kitchen sink + transaction sending
+
+```ts
+import { openWallets } from "@spirobel/monero-wallet-api";
+
+// add a wallet address to ScanSettings.json first
+
+// convenience script to make a regtest wallet and write to RegtestScanSettings.json + keys to .env.local:
+// bun run scripts/regtest_gen.ts
+
+// scan all non-halted wallets from the settings file:
+const wallets = await openWallets({
+  scan_settings_path: "./ScanSettings.json", // this is the default scan settings file name
+  pathPrefix: "./", // default path for wallet scan caches, stats files, connection status file
+  notifyMasterChanged: async (params) => {
+    // called on each scan result: outputs, new_height, etc.
+    console.log("progress", params.newCache.current_height);
+  },
+});
+
+// change node url mid scan
+await wallets.changeNodeUrl("http://127.0.0.1:18081");
+
+// send a transaction
+wallets.wallets[0].makeSignSendTransaction();
+wallets.wallets[0].makeStandardTransaction(
+  escrow_address.mainnet_primary,
+  "133700000000",
+);
+wallets.wallets[0].signTransaction();
+wallets.wallets[0].sendTransaction();
+
+// sweep all funds to another wallet
+const unsigned_tx_hex = await escrowWallet.sweepToExternalWallet(
+  merchant_final_address,
+  escrowWallet.spendableInputs(),
+);
+
+// stop scan worker
+wallets.stopWorker();
+```
+
+See the [reorg handling test](tests/acceptance/reorg_handling.test.ts) for a regtest reorg example.
+
+After running this test a local node is available, which
+makes it possible to easily run the [escrow test](tests/acceptance/escrow.test.ts) described in detail [here](https://monerochan.news/article/19).
+
+See the [acceptance test](tests/acceptance/dont_rescan.test.ts) for a full working sync example with mainnet data.
+
+## install
+
+To install the package:
 
 ```bash
-cd typescript || cd ../typescript
-bun install
+bun add @spirobel/monero-wallet-api
 ```
 
-To build:
+## build
+
+#### 1. rust release build
+
+```bash
+cd rust || cd ../rust
+cargo build  --target wasm32-wasip1 --release --lib
+```
+
+```bash
+cd frost-dkg || cd ../frost-dkg
+cargo build  --target wasm32-wasip1 --release --lib
+```
+
+#### 2. build typescript:
 
 ```bash
 cd typescript || cd ../typescript
 bun build
 ```
 
-rust release build
+### prerequisite: init submodule (frost-dkg uses serai submodule)
 
 ```bash
-cd rust || cd ../rust
-cargo build  --target wasm32-wasip1 --release --lib
+git submodule update --init --recursive
 ```
 
-prerequisite: install rust
+### prerequisite: install rust (or use docker image, see below)
 
 ```bash
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

package/dist/api.d.ts

@@ -11,6 +11,10 @@ export * from "./io/sleep";
 export { writeScanSettings, readScanSettings, } from "./scanning-syncing/scanSettings";
 export { signTransaction, parseAddress, type ParsedAddress, type ParseAddressError, } from "./send-functionality/transactionBuilding";
 export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
+export * from "./multisig/multisig";
+export * from "./multisig/DistributedKeyGenerator";
+export * from "./multisig/escrow";
+export * from "./multisig/MultiSigTxSigner";
 export { startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
 export { spendable } from "./scanning-syncing/scanresult/scanResult";
 export { openWallets, openWallet } from "./scanning-syncing/openWallet";

package/dist/api.js

@@ -10,6 +10,10 @@ export * from "./io/sleep";
 export { writeScanSettings, readScanSettings, } from "./scanning-syncing/scanSettings";
 export { signTransaction, parseAddress, } from "./send-functionality/transactionBuilding";
 export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
+export * from "./multisig/multisig";
+export * from "./multisig/DistributedKeyGenerator";
+export * from "./multisig/escrow";
+export * from "./multisig/MultiSigTxSigner";
 export { startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
 export { spendable } from "./scanning-syncing/scanresult/scanResult";
 export { openWallets, openWallet } from "./scanning-syncing/openWallet";

package/dist/io/atomicWrite.js

@@ -1,5 +1,6 @@
+import { log } from "./logging";
 export async function atomicWrite(targetPath, data) {
-    //console.log("[atomicWrite] writing to", targetPath);
+    log("atomicWrite", ["writing to", targetPath]);
     // in the browser we don't have rename + indexedDB writes are atomic in any case
     if (areWeInTheBrowser)
         return await Bun.write(targetPath, data);

package/dist/io/logging.d.ts

@@ -0,0 +1,40 @@
+/**
+ * logging function names registry.
+ *
+ * useful filter combinations for `scanSettings.json`:
+ *
+ *   "logs": "console",
+ *   "logs_include": ["handleCpuboundScan", "logBufStatus"]
+ *     -> cpu worker progress + buffer/work status.
+ *
+ *   "logs_include": ["coordinatorMainMultithreaded", "scheduleWorkOnCpuPorts", "workToBeDoneForBatch"]
+ *     -> coordinator events: race count, work dispatch, batch decisions.
+ *
+ *   "logs_include": ["blocksBufferFetchLoop", "makeWorkItemsFromBlocksBuffer", "logBufStatus"]
+ *     -> block fetching, reconciliation, buffer state.
+ *
+ *   "logs_include": ["processScanResult", "processWorkItem", "processScanResultForWorkItem"]
+ *     -> result processing, cache updates, reorg detection.
+ *
+ *   "logs_include": ["handleConnectionStatusChanges", "handleScanError"]
+ *     -> connection events and scan errors.
+ *
+ *   "logs": "off"   disables all logging.
+ *   "logs": "file"  writes to `<coordinator|cpubound|mainthread>-<id>-<timestamp>.log`.
+ *   "logs": "console-and-file"  writes to file and console.
+ */
+export declare const LOGGING_FUNCTIONS: readonly ["findWorkToBeDone", "workToBeDoneForBatch", "makeWorkItemsFromBlocksBuffer", "reconcileWorkItemDone", "processScanResultForWorkItem", "processWorkItem", "logBufStatus", "coordinatorMain", "coordinatorMainMultithreaded", "scheduleWorkOnCpuPorts", "processScanResult", "handleScanError", "createWebworker", "startWebworker", "blocksBufferFetchLoop", "reduceStartHeightToTip", "handleConnectionStatusChanges", "handleCpuboundScan", "coordinatorMainWorker", "CPU_PORT_HANDLER", "atomicWrite", "multisigMainWorkerCall"];
+export type PossibleLogs = (typeof LOGGING_FUNCTIONS)[number];
+export type LogSetting = "console" | "file" | "console-and-file" | "off";
+export type FileLogMessage = {
+    timestamp: string;
+    message: any;
+};
+export declare function setupLoggingPath(scan_settings_path: string, path_prefix: string, role: "coordinator" | "cpubound" | "mainthread" | "multisig", cpu_worker_id?: number): Promise<{
+    logs: LogSetting | undefined;
+    logs_include: ("findWorkToBeDone" | "workToBeDoneForBatch" | "makeWorkItemsFromBlocksBuffer" | "reconcileWorkItemDone" | "processScanResultForWorkItem" | "processWorkItem" | "logBufStatus" | "coordinatorMain" | "coordinatorMainMultithreaded" | "scheduleWorkOnCpuPorts" | "processScanResult" | "handleScanError" | "createWebworker" | "startWebworker" | "blocksBufferFetchLoop" | "reduceStartHeightToTip" | "handleConnectionStatusChanges" | "handleCpuboundScan" | "coordinatorMainWorker" | "CPU_PORT_HANDLER" | "atomicWrite" | "multisigMainWorkerCall")[] | undefined;
+    logs_exclude: ("findWorkToBeDone" | "workToBeDoneForBatch" | "makeWorkItemsFromBlocksBuffer" | "reconcileWorkItemDone" | "processScanResultForWorkItem" | "processWorkItem" | "logBufStatus" | "coordinatorMain" | "coordinatorMainMultithreaded" | "scheduleWorkOnCpuPorts" | "processScanResult" | "handleScanError" | "createWebworker" | "startWebworker" | "blocksBufferFetchLoop" | "reduceStartHeightToTip" | "handleConnectionStatusChanges" | "handleCpuboundScan" | "coordinatorMainWorker" | "CPU_PORT_HANDLER" | "atomicWrite" | "multisigMainWorkerCall")[] | undefined;
+    file_logbuffer: FileLogMessage[];
+    global_logging_path: string;
+}>;
+export declare function log(fnname: string, message: any): void;

package/dist/io/logging.js

@@ -0,0 +1,174 @@
+import { getPathPrefix, openScanSettingsFile } from "../api";
+import { atomicWrite } from "./atomicWrite";
+/**
+ * logging function names registry.
+ *
+ * useful filter combinations for `scanSettings.json`:
+ *
+ *   "logs": "console",
+ *   "logs_include": ["handleCpuboundScan", "logBufStatus"]
+ *     -> cpu worker progress + buffer/work status.
+ *
+ *   "logs_include": ["coordinatorMainMultithreaded", "scheduleWorkOnCpuPorts", "workToBeDoneForBatch"]
+ *     -> coordinator events: race count, work dispatch, batch decisions.
+ *
+ *   "logs_include": ["blocksBufferFetchLoop", "makeWorkItemsFromBlocksBuffer", "logBufStatus"]
+ *     -> block fetching, reconciliation, buffer state.
+ *
+ *   "logs_include": ["processScanResult", "processWorkItem", "processScanResultForWorkItem"]
+ *     -> result processing, cache updates, reorg detection.
+ *
+ *   "logs_include": ["handleConnectionStatusChanges", "handleScanError"]
+ *     -> connection events and scan errors.
+ *
+ *   "logs": "off"   disables all logging.
+ *   "logs": "file"  writes to `<coordinator|cpubound|mainthread>-<id>-<timestamp>.log`.
+ *   "logs": "console-and-file"  writes to file and console.
+ */
+export const LOGGING_FUNCTIONS = [
+    // scanCoordination.ts
+    "findWorkToBeDone",
+    "workToBeDoneForBatch",
+    "makeWorkItemsFromBlocksBuffer",
+    "reconcileWorkItemDone",
+    "processScanResultForWorkItem",
+    "processWorkItem",
+    "logBufStatus",
+    "coordinatorMain",
+    "coordinatorMainMultithreaded",
+    "scheduleWorkOnCpuPorts",
+    // scanResult.ts
+    "processScanResult",
+    // scanCache.ts
+    "handleScanError",
+    // backgroundWorker.ts
+    "createWebworker",
+    "startWebworker",
+    // blocksBufferFetchLoop.ts
+    "blocksBufferFetchLoop",
+    "reduceStartHeightToTip",
+    // blocksbufferCoordination.ts
+    "handleConnectionStatusChanges",
+    // cpubound-main.ts
+    "handleCpuboundScan",
+    // coordinator-main.ts
+    "coordinatorMainWorker",
+    // worker.ts
+    "CPU_PORT_HANDLER",
+    // io/atomicWrite.ts
+    "atomicWrite",
+    // multisig-main.ts
+    "multisigMainWorkerCall",
+];
+export async function setupLoggingPath(scan_settings_path, path_prefix, role, cpu_worker_id) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
+    const logs = scanSettings?.logs;
+    const logs_include = scanSettings?.logs_include;
+    const logs_exclude = scanSettings?.logs_exclude;
+    const file_logbuffer = [];
+    const logging_path_prefix = getPathPrefix(scan_settings_path, path_prefix);
+    const timestamp = new Date().toISOString().slice(0, 19).replace("T", " ");
+    const global_logging_path = `${logging_path_prefix}${role}-${cpu_worker_id ?? ""}-${timestamp}.log`;
+    const global_log_setup = {
+        logs,
+        logs_include,
+        logs_exclude,
+        file_logbuffer,
+        global_logging_path,
+    };
+    globalThis.__global_log_setup = global_log_setup;
+    startLogFlusher(global_log_setup);
+    return global_log_setup;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value, (_key, v) => {
+            if (typeof v === "bigint")
+                return v.toString();
+            if (typeof v === "function")
+                return `fn ${v.name || "anon"}`;
+            if (v !== null && typeof v === "object") {
+                // promise or thenable
+                if (typeof v.then === "function") {
+                    try {
+                        return typeof Bun !== "undefined" && Bun.inspect
+                            ? Bun.inspect(v)
+                            : "Promise";
+                    }
+                    catch {
+                        return "Promise";
+                    }
+                }
+                // message port
+                const ctor = v.constructor;
+                if (ctor?.name === "MessagePort")
+                    return "MessagePort";
+            }
+            return v;
+        });
+    }
+    catch {
+        return String(value);
+    }
+}
+const flusherRef = new WeakMap();
+function startLogFlusher(setup) {
+    if (setup.logs !== "file" && setup.logs !== "console-and-file")
+        return;
+    if (flusherRef.has(setup))
+        return; // already running
+    let writtenIndex = 0;
+    const id = setInterval(async () => {
+        const buffer = setup.file_logbuffer;
+        if (buffer.length <= writtenIndex)
+            return; // nothing new
+        const newEntries = buffer.slice(writtenIndex);
+        writtenIndex = buffer.length;
+        if (newEntries.length === 0)
+            return;
+        const lines = newEntries
+            .map((e) => `[${e.timestamp}] ${safeStringify(e.message)}`)
+            .join("\n");
+        try {
+            const existing = await Bun.file(setup.global_logging_path)
+                .text()
+                .catch(() => "");
+            const newContent = existing ? existing + "\n" + lines : lines;
+            await atomicWrite(setup.global_logging_path, newContent);
+        }
+        catch (err) {
+            console.error("[logFlusher] write failed:", err);
+        }
+    }, 2000);
+    flusherRef.set(setup, id);
+}
+export function log(fnname, message) {
+    const setup = globalThis.__global_log_setup;
+    if (!setup)
+        return;
+    const { logs, logs_include, logs_exclude, file_logbuffer } = setup;
+    if (logs === "off")
+        return;
+    // Apply include/exclude filters
+    if (logs_include && logs_include.length > 0 && !logs_include.includes(fnname))
+        return;
+    if (logs_exclude && logs_exclude.includes(fnname))
+        return;
+    // skip messages that are about writing to the log file itself
+    // (prevents atomicWrite calls inside the flusher from feeding back)
+    const logPath = setup.global_logging_path;
+    if (logPath) {
+        const msg = message;
+        if ((typeof msg === "string" && msg.includes(logPath)) ||
+            (Array.isArray(msg) &&
+                msg.some((m) => typeof m === "string" && m.includes(logPath))))
+            return;
+    }
+    const timestamp = new Date().toISOString().slice(0, 19).replace("T", " ");
+    if (logs === "console" || logs === "console-and-file") {
+        console.log(`[${fnname}]`, ...(Array.isArray(message) ? message : [message]));
+    }
+    if (logs === "file" || logs === "console-and-file") {
+        file_logbuffer.push({ timestamp, message });
+    }
+}

package/dist/keypairs-seeds/keypairs.d.ts

@@ -48,3 +48,11 @@ export type ViewPairJson = {
  * @returns the viewkey that was derive from the spendkey
  */
 export declare function makeViewKey(spend_private_key: string): Promise<ViewPairJson>;
+/**
+ * entropy is hashed with keccak to make the view private key
+ * this is according to the convention in the monero code base,
+ * read the comment at the top of the file for more details & link to source
+ * @param entropy the spendkey the viewkey will be derived from
+ * @returns the viewkey that was derived from entropy as hex
+ */
+export declare function vk_from_entropy(entropy: Uint8Array): Promise<string>;

package/dist/keypairs-seeds/keypairs.js

@@ -60,6 +60,7 @@
 // simple wallet turns spend private key (recovery_val) into mnemonic words with this call:
 // 4849   crypto::ElectrumWords::bytes_to_words(recovery_val, electrum_words, mnemonic_language);
 // https://github.com/monero-project/monero/blob/48ad374b0d6d6e045128729534dc2508e6999afe/src/simplewallet/simplewallet.cpp#L4849
+import { monero_wallet_api_wasm } from "../wasm-processing/wasmFile";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 /**
  *  use this function to generate a keypair for testing
@@ -76,7 +77,7 @@ export async function makeTestKeyPair() {
  * @returns SpendKey
  */
 export async function makeSpendKey() {
-    const wasmProcessor = await WasmProcessor.init();
+    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     let result = undefined;
     wasmProcessor.readFromWasmMemory = (ptr, len) => {
         result = String(wasmProcessor.readString(ptr, len));
@@ -93,7 +94,7 @@ export async function makeSpendKeyFromSeed(wallet_secret) {
         throw new Error(`Invalid wallet secret length: ${wallet_secret.length}.
        Expected 128 hex characters (64 bytes).`);
     }
-    const wasmProcessor = await WasmProcessor.init();
+    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, wallet_secret);
     };
@@ -120,7 +121,7 @@ export async function makeViewKey(spend_private_key) {
         throw new Error(`Invalid spendkey length: ${spend_private_key.length}.
        Expected 64 hex characters (32 bytes).`);
     }
-    const wasmProcessor = await WasmProcessor.init();
+    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, spend_private_key);
     };
@@ -135,6 +136,33 @@ export async function makeViewKey(spend_private_key) {
     }
     return result;
 }
+/**
+ * entropy is hashed with keccak to make the view private key
+ * this is according to the convention in the monero code base,
+ * read the comment at the top of the file for more details & link to source
+ * @param entropy the spendkey the viewkey will be derived from
+ * @returns the viewkey that was derived from entropy as hex
+ */
+export async function vk_from_entropy(entropy) {
+    if (entropy.length !== 32) {
+        throw new Error(`Invalid entropy length: ${entropy.length}.
+       Expected 32 bytes array.`);
+    }
+    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
+    wasmProcessor.writeToWasmMemory = (ptr, len) => {
+        wasmProcessor.writeArray(ptr, len, entropy);
+    };
+    let result = undefined;
+    wasmProcessor.readFromWasmMemory = (ptr, len) => {
+        result = wasmProcessor.readString(ptr, len);
+    };
+    //@ts-ignore
+    wasmProcessor.tinywasi.instance.exports.vk_from_entropy(entropy.length);
+    if (!result) {
+        throw new Error("Failed to obtain view key from entropy.");
+    }
+    return result;
+}
 /**
  *
  * unlike crypto-ops.c sc_reduce32, this is not unrolled

package/dist/multisig/DistributedKeyGenerator.d.ts

@@ -0,0 +1,125 @@
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+/**
+ * get the DKG public key from a 64-byte DKG secret key
+ * @param dkgSecretKey - 64 byte Uint8Array dkg secret key
+ * @returns - dkg public key as hex string
+ */
+export declare function getDkgPublicKey(dkgSecretKey: Uint8Array): Promise<string>;
+/**
+ * derive a Monero address (mainnet, stagenet, testnet) from a DKG group key.
+ * spend_public_key is the group_key hex from dkg_verify output.
+ * view_secret_key is the 32-byte view secret key hex. (see performEscrowViewPairECDH on how to get one)
+ *
+ * @returns object with view_key, mainnet_primary, stagenet_primary, testnet_primary
+ */
+export declare function getDkgMoneroAddress(spend_public_key: string, view_secret_key: string): Promise<DkgGetMoneroAddressResult>;
+export type DkgGetPublicKeyResult = {
+    dkg_public_key: string;
+};
+export type DkgParticipateParams = {
+    dkg_secret_key: string;
+    context: string;
+    dkg_public_keys: string[];
+    t: number;
+};
+export type DkgParticipateResult = {
+    participation: string;
+};
+export type DkgVerifyParams = {
+    dkg_secret_key: string;
+    context: string;
+    t: number;
+    dkg_public_keys: string[];
+    participations: Record<string, string>;
+};
+export type DkgVerifyValidResult = {
+    group_key: string;
+    t: number;
+    n: number;
+    i: number;
+    threshold_key: string;
+};
+export type DkgVerifyInvalidResult = {
+    faulty_participants: number[];
+};
+export type DkgVerifyNotEnoughResult = {
+    message: "NotEnoughParticipants";
+};
+export type DkgVerifyResult = DkgVerifyValidResult | DkgVerifyInvalidResult | DkgVerifyNotEnoughResult;
+export type DkgErrorResponse = {
+    message: string;
+};
+export type DkgGetMoneroAddressParams = {
+    spend_public_key: string;
+    view_secret_key: string;
+};
+export type DkgGetMoneroAddressResult = {
+    view_key: string;
+    mainnet_primary: string;
+    stagenet_primary: string;
+    testnet_primary: string;
+};
+export declare class DistributedKeyGenerator extends WasmProcessor {
+    /**
+     * create distributed key generator wasm instance,
+     * without initializing generators
+     * (in case you just want to get the public dkg key from a secret dkg key)
+     *
+     * @returns  - Promise<DistributedKeyGenerator>
+     */
+    static create(): Promise<DistributedKeyGenerator>;
+    /**
+     * set up a distributed key generator with t threshold and n total participants
+     * @param t  - total number of multisig participants
+     * @param n  - threshold to sign a transaction
+     * @returns  - Promise<DistributedKeyGenerator>
+     */
+    static createAndSetupGenerators(t: number, n: number): Promise<DistributedKeyGenerator>;
+    /**
+     * setupGenerators
+     * configure the max threshold and max participants for the DKG generators.
+     * if never called, defaults to 16, 16 used automatically on first DKG operation.
+     */
+    setupGenerators(t: number, n: number): void;
+    /**
+     * derive the DKG public key from a 64-byte DKG secret key.
+     *
+     * @param dkgSecretKeyBytes 64-byte DKG secret key (from seed function)
+     * @returns the DKG public key as a hex string, or an error object
+     */
+    getPublicKey(dkgSecretKeyBytes: Uint8Array): DkgGetPublicKeyResult | DkgErrorResponse;
+    /**
+     * participate in a DKG round (nothrow).
+     *
+     * @param params dkg_secret_key as 64-byte hex string, context, dkg_public_keys array (length is n implicitly), t (threshold)
+     * @returns The participation message as hex, or an error object
+     */
+    participateNoThrow(params: DkgParticipateParams): DkgParticipateResult | DkgErrorResponse;
+    /**
+     * verify DKG participations and extract the group key (nothrow).
+     *
+     * @param params dkg_secret_key as 64-byte hex string, context, t (threshold), dkg_public_keys array (length is n implicitly),
+     *  participations [ paricipant index -> hex participation message ]
+     * @returns The group key and params, faulty participants, not-enough message, or error
+     */
+    verifyNoThrow(params: DkgVerifyParams): DkgVerifyResult | DkgErrorResponse;
+    /**
+     * derive a Monero address from a DKG group key.
+     *
+     * Input JSON keys expected by the rust wasm:
+     *   spend_public_key (hex32) - the group_key hex from dkg_verify output
+     *   view_secret_key (hex32) - 32-byte view secret key (see performEscrowViewPairECDH on how to get one)
+     *
+     * @param params - spendPublicKey and viewSecretKey as hex strings
+     * @returns object with view_key, mainnet_primary, stagenet_primary, testnet_primary
+     */
+    getMoneroAddress(params: DkgGetMoneroAddressParams): DkgGetMoneroAddressResult | DkgErrorResponse;
+    /**
+     * participate in a DKG round (throws on error).
+     */
+    participate(params: DkgParticipateParams): DkgParticipateResult;
+    /**
+     * verify DKG participations and extract the group key (throws on error).
+     */
+    verify(params: DkgVerifyParams): DkgVerifyValidResult;
+}