@spirobel/monero-wallet-api 0.4.1 → 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/logging.d.ts

@@ -23,17 +23,17 @@
  *   "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"];
+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", cpu_worker_id?: number): Promise<{
+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")[] | 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")[] | 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;
 }>;

package/dist/io/logging.js

@@ -57,6 +57,8 @@ export const LOGGING_FUNCTIONS = [
     "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);

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;
+}

package/dist/multisig/DistributedKeyGenerator.js

@@ -0,0 +1,197 @@
+import { frost_dkg_wasm } from "../wasm-processing/wasmFile";
+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 async function getDkgPublicKey(dkgSecretKey) {
+    const dkg = await DistributedKeyGenerator.create();
+    const pubResult = dkg.getPublicKey(dkgSecretKey);
+    if ("message" in pubResult) {
+        throw new Error(`getPublicKey failed: ${pubResult.message}`);
+    }
+    return pubResult.dkg_public_key;
+}
+/**
+ * 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 async function getDkgMoneroAddress(spend_public_key, view_secret_key) {
+    const dkg = await DistributedKeyGenerator.create();
+    const result = dkg.getMoneroAddress({ spend_public_key, view_secret_key });
+    if ("message" in result) {
+        throw new Error(`getDkgMoneroAddress failed: ${result.message}`);
+    }
+    return result;
+}
+export 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 async create() {
+        const dkg = new DistributedKeyGenerator();
+        await dkg.initWasmModule(frost_dkg_wasm);
+        return dkg;
+    }
+    /**
+     * 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 async createAndSetupGenerators(t, n) {
+        const dkg = new DistributedKeyGenerator();
+        await dkg.initWasmModule(frost_dkg_wasm);
+        dkg.setupGenerators(t, n);
+        return dkg;
+    }
+    /**
+     * 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, n) {
+        //@ts-ignore
+        this.tinywasi.instance.exports.setup_generators(t, n);
+    }
+    /**
+     * 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) {
+        // set up write callback: rust will call input(64) to read the secret key bytes
+        this.writeToWasmMemory = (ptr, len) => {
+            this.writeArray(ptr, len, dkgSecretKeyBytes);
+        };
+        // set up read callback: rust will call output_string() to return the result JSON
+        let result;
+        this.readFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(this.readString(ptr, len));
+        };
+        //@ts-ignore
+        this.tinywasi.instance.exports.dkg_get_public_key();
+        if (!result) {
+            return { message: "No response from dkg_get_public_key" };
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        const jsonStr = JSON.stringify(params);
+        // set up write callback: rust will call input_string(json_len) to read the JSON
+        this.writeToWasmMemory = (ptr, len) => {
+            this.writeString(ptr, len, jsonStr);
+        };
+        // set up read callback: rust will call output_string() to return the result JSON
+        let result;
+        this.readFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(this.readString(ptr, len));
+        };
+        this.readErrorFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(this.readString(ptr, len));
+        };
+        //@ts-ignore
+        this.tinywasi.instance.exports.dkg_participate(jsonStr.length);
+        if (!result) {
+            return { message: "No response from dkg_participate" };
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        const jsonStr = JSON.stringify(params);
+        // set up write callback: rust will call input_string(json_len) to read the JSON
+        this.writeToWasmMemory = (ptr, len) => {
+            this.writeString(ptr, len, jsonStr);
+        };
+        // set up read callback: rust will call output_string() to return the result JSON
+        let result;
+        this.readFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(this.readString(ptr, len));
+        };
+        this.readErrorFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(this.readString(ptr, len));
+        };
+        //@ts-ignore
+        this.tinywasi.instance.exports.dkg_verify(jsonStr.length);
+        if (!result) {
+            return { message: "No response from dkg_verify" };
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        const jsonStr = JSON.stringify(params);
+        // set up write callback: rust calls input_string(json_len)
+        this.writeToWasmMemory = (ptr, len) => {
+            this.writeString(ptr, len, jsonStr);
+        };
+        // set up read callback: rust calls output_string()
+        let result;
+        this.readFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(this.readString(ptr, len));
+        };
+        this.readErrorFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(this.readString(ptr, len));
+        };
+        //@ts-ignore
+        this.tinywasi.instance.exports.dkg_get_monero_address(jsonStr.length);
+        if (!result) {
+            return { message: "No response from dkg_get_monero_address" };
+        }
+        return result;
+    }
+    /**
+     * participate in a DKG round (throws on error).
+     */
+    participate(params) {
+        const result = this.participateNoThrow(params);
+        if ("message" in result) {
+            throw new Error(`participate failed: ${result.message}`);
+        }
+        return result;
+    }
+    /**
+     * verify DKG participations and extract the group key (throws on error).
+     */
+    verify(params) {
+        const result = this.verifyNoThrow(params);
+        if ("message" in result) {
+            throw new Error(`verify failed: ${result.message}`);
+        }
+        if ("faulty_participants" in result) {
+            throw new Error(`verify failed: ${result.faulty_participants}`);
+        }
+        return result;
+    }
+}

package/dist/multisig/MultiSigTxSigner.d.ts

@@ -0,0 +1,68 @@
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+export type MoneroPreprocessParams = {
+    threshold_key: string;
+    unsigned_tx: string;
+};
+export type MoneroPreprocessResult = {
+    preprocess: string;
+};
+export type MoneroSignParams = {
+    preprocesses: Record<string, string>;
+};
+export type MoneroSignResult = {
+    share: string;
+};
+export type MoneroCompleteParams = {
+    shares: Record<string, string>;
+};
+export type MoneroCompleteResult = {
+    signed_tx: string;
+};
+export type MoneroErrorResponse = {
+    message: string;
+};
+export declare class MultiSigTxSigner extends WasmProcessor {
+    static create(): Promise<MultiSigTxSigner>;
+    /**
+     * preprocess
+     *
+     * @param params threshold_key hex, unsigned_tx hex
+     * @returns preprocess hex
+     */
+    preprocess(params: MoneroPreprocessParams): MoneroPreprocessResult;
+    /**
+     * preprocess -  does not throw, with return error type
+     *
+     * @param params threshold_key hex, unsigned_tx hex
+     * @returns preprocess hex
+     */
+    preprocessNoThrow(params: MoneroPreprocessParams): MoneroPreprocessResult | MoneroErrorResponse;
+    /**
+     * sign
+     *
+     * @param params preprocesses map from all signers
+     * @returns share hex
+     */
+    sign(params: MoneroSignParams): MoneroSignResult;
+    /**
+     * sign -  does not throw, with return error type
+     *
+     * @param params preprocesses map from all signers
+     * @returns share hex
+     */
+    signNoThrow(params: MoneroSignParams): MoneroSignResult | MoneroErrorResponse;
+    /**
+     * complete
+     *
+     * @param params shares map from all signers
+     * @returns signed_tx hex
+     */
+    complete(params: MoneroCompleteParams): MoneroCompleteResult;
+    /**
+     * complete -  does not throw, with return error type
+     *
+     * @param params shares map from all signers
+     * @returns signed_tx hex
+     */
+    completeNoThrow(params: MoneroCompleteParams): MoneroCompleteResult | MoneroErrorResponse;
+}