@spirobel/monero-wallet-api 0.4.0 → 0.5.0

package/dist/scanning-syncing/worker-mains/coordinator-main.js

@@ -1,10 +1,11 @@
 import { coordinatorMainMultithreaded } from "../scanresult/scanCoordination";
+import { log } from "../../io/logging";
 export async function coordinatorMainWorker(scan_settings_path, pathPrefix, cpuPorts) {
-    console.log("[coordinatorMainWorker] cpuPorts=" + cpuPorts?.length);
+    log("coordinatorMainWorker", "cpuPorts=" + cpuPorts?.length);
     try {
         const gen = coordinatorMainMultithreaded(scan_settings_path, pathPrefix, cpuPorts);
         for await (const event of gen) {
-            // console.log("event:", event);
+            log("coordinatorMainWorker", ["event:", event]);
             if (event.type === "scan_ready") {
                 self.postMessage({
                     type: "SCAN_RESULT",

package/dist/scanning-syncing/worker-mains/cpubound-main.js

@@ -1,4 +1,5 @@
 import { sleep, ViewPair } from "../../api";
+import { log } from "../../io/logging";
 import {} from "../scanresult/scanLoop";
 /**
  * handle a single scan work item dispatched from the coordinator.
@@ -7,24 +8,24 @@ import {} from "../scanresult/scanLoop";
 let callcounter = 0;
 export async function handleCpuboundScan(msg, port) {
     callcounter++;
-    console.log("[cpubound] callcounter=" + callcounter);
+    log("handleCpuboundScan", "callcounter=" + callcounter);
     if (!msg) {
-        console.log("[cpubound] no content msg! ( ScanLoopInput = undefined )");
+        log("handleCpuboundScan", "no content msg! ( ScanLoopInput = undefined )");
         throw new Error("[cpubound] no content msg! ( ScanLoopInput = undefined )");
     }
     if (msg === "cancel") {
-        console.log("[cpubound] cancel msg! ( ScanLoopInput = cancel )");
+        log("handleCpuboundScan", "cancel msg! ( ScanLoopInput = cancel )");
         throw new Error("[cpubound] no content msg! ( ScanLoopInput = undefined )");
     }
-    console.log("[cpubound] got scan msg, walletConfig=" +
+    log("handleCpuboundScan", "got scan msg, walletConfig=" +
         msg.walletConfig?.primary_address?.slice(0, 6));
     const walletConfig = msg.walletConfig;
     const item = msg;
     if (!port) {
-        console.log("[cpubound] no port!");
+        log("handleCpuboundScan", "no port!");
         throw new Error("[cpubound] no port");
     }
-    console.log("[cpubound] primed, feeding workItem uuid=" +
+    log("handleCpuboundScan", "primed, feeding workItem uuid=" +
         (item && typeof item === "object"
             ? item.work_uuid?.slice(0, 8)
             : "cancel"));
@@ -78,17 +79,26 @@ export async function handleCpuboundScan(msg, port) {
         // the reconciliation workitembuffer -> blocksbuffer is done on every workitembuffer marked done at the end of the workbuffer (left end)
         blockCount++;
         if (blockCount % 10 === 0) {
-            console.log("[cpubound] scanned " +
-                blockCount +
-                " " +
-                walletConfig.primary_address.slice(0, 6), "@", heighfrom, "-", heightto);
+            log("handleCpuboundScan", [
+                "scanned " +
+                    blockCount +
+                    " " +
+                    walletConfig.primary_address.slice(0, 6),
+                "@",
+                heighfrom,
+                "-",
+                heightto,
+            ]);
         }
         await sleep(10); // make sure the loop is not tight
     }
-    console.log("[cpubound] scan done " +
-        blockCount +
-        " " +
-        walletConfig.primary_address.slice(0, 6), "@", heighfrom, "-", heightto);
+    log("handleCpuboundScan", [
+        "scan done " + blockCount + " " + walletConfig.primary_address.slice(0, 6),
+        "@",
+        heighfrom,
+        "-",
+        heightto,
+    ]);
     return {
         type: "Ready",
         work_uuid: item.work_uuid,

package/dist/scanning-syncing/worker-mains/multisig-main.d.ts

@@ -0,0 +1,13 @@
+import { DistributedKeyGenerator, type DkgParticipateParams, type DkgVerifyParams } from "../../api";
+export type MultiSigParticipateCall = {
+    type: "multisig-call";
+    functionName: "participate";
+    params: DkgParticipateParams;
+};
+export type MultiSigVerifyCallMsg = {
+    type: "multisig-call";
+    functionName: "verify";
+    params: DkgVerifyParams;
+};
+export type MultiSigWorkerCallMsg = MultiSigParticipateCall | MultiSigVerifyCallMsg;
+export declare function multisigMainWorkerCall(msg: MultiSigWorkerCallMsg, dkg?: DistributedKeyGenerator): void;

package/dist/scanning-syncing/worker-mains/multisig-main.js

@@ -0,0 +1,31 @@
+import { DistributedKeyGenerator, } from "../../api";
+import { log } from "../../io/logging";
+export function multisigMainWorkerCall(msg, dkg) {
+    if (!dkg) {
+        const error = new Error("multisigMainWorkerCall called without setup DistributedKeyGenerator first");
+        console.error("[multisigMainWorkerCall] error:", error);
+        log("multisigMainWorkerCall", ["error:", error]);
+        self.postMessage({ type: "ERROR", payload: error });
+    }
+    else if (msg.type === "multisig-call") {
+        const functionName = msg.functionName;
+        const params = msg.params;
+        log("multisigMainWorkerCall", [
+            `received call to ${functionName}() with params:`,
+            params,
+        ]);
+        let result;
+        if (functionName === "participate") {
+            result = dkg.participateNoThrow(params);
+        }
+        else if (functionName === "verify") {
+            result = dkg.verifyNoThrow(params);
+        }
+        log("multisigMainWorkerCall", [
+            `received call to ${functionName}() with params, got result`,
+            params,
+            result,
+        ]);
+        self.postMessage({ type: "multisig-call-result", result });
+    }
+}

package/dist/scanning-syncing/worker-mains/worker.js

@@ -1,20 +1,25 @@
 import { coordinatorMainWorker } from "./coordinator-main";
-import { handleCpuboundScan, handleCpuboundScanTry, sendFromCpuWorker, } from "./cpubound-main";
+import { handleCpuboundScanTry, sendFromCpuWorker } from "./cpubound-main";
+import { log, setupLoggingPath } from "../../io/logging";
+import { SCAN_SETTINGS_STORE_NAME_DEFAULT } from "../scanSettings";
+import { multisigMainWorkerCall } from "./multisig-main";
+import { DistributedKeyGenerator } from "../../api";
 self.onerror = (e) => self.postMessage({ type: "ERROR", payload: e });
 self.addEventListener("unhandledrejection", (e) => self.postMessage({ type: "ERROR", payload: e.reason }));
 let SCAN_SETTINGS_PATH;
 let PATH_PREFIX;
 let cpuPort;
+let multisig_dkg;
 export function CPU_PORT_HANDLER(pe) {
     if (!cpuPort)
         throw new Error("[cpubound] cpuPort is undefined in port.onmessage");
-    console.log("[cpubound] new workitem msg received");
+    log("CPU_PORT_HANDLER", "new workitem msg received");
     cpuPort.postMessage({
         type: "WORKSTART",
         work_uuid: pe.data.work_uuid,
     });
     handleCpuboundScanTry(pe.data, cpuPort).then((result) => {
-        console.log("[cpubound] work finished, sending result");
+        log("CPU_PORT_HANDLER", "work finished, sending result");
         if (!cpuPort)
             throw new Error("[cpubound] cpuPort is undefined in port.onmessage");
         cpuPort.onmessage = CPU_PORT_HANDLER;
@@ -23,19 +28,21 @@ export function CPU_PORT_HANDLER(pe) {
 }
 const handleMessage = async (e) => {
     const msg = e.data;
-    console.log("[worker] msg received", msg);
+    log("handleMessage", ["msg received", msg]);
     if (msg.type === "setup") {
-        SCAN_SETTINGS_PATH = msg.scan_settings_path;
+        const settingsPath = msg.scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT;
+        SCAN_SETTINGS_PATH = settingsPath;
         PATH_PREFIX = msg.pathPrefix;
+        await setupLoggingPath(settingsPath, msg.pathPrefix ?? "", msg.role, msg.cpu_worker_id);
         if (msg.role === "cpubound") {
             cpuPort = e.ports[0];
             if (cpuPort) {
                 cpuPort.onmessage = CPU_PORT_HANDLER;
                 cpuPort.addEventListener("message", (e) => {
-                    console.log("[cpubound] message received", e);
+                    log("handleMessage", ["message received", e]);
                 });
                 cpuPort.addEventListener("messageerror", (e) => {
-                    console.log("[cpubound] messageerror received", e);
+                    log("handleMessage", ["messageerror received", e]);
                 });
             }
         }
@@ -48,6 +55,15 @@ const handleMessage = async (e) => {
                 });
             });
         }
+        else if (msg.role === "multisig") {
+            DistributedKeyGenerator.createAndSetupGenerators(msg.t, msg.n).then((dkg) => {
+                multisig_dkg = dkg;
+                self.postMessage({ type: "multisig-ready" });
+            });
+        }
+    }
+    else if (msg.type === "multisig-call") {
+        multisigMainWorkerCall(msg, multisig_dkg);
     }
 };
 function handleMessageTry(e) {

package/dist/send-functionality/multisig.d.ts

@@ -0,0 +1,72 @@
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+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;
+};
+export type DkgVerifyInvalidResult = {
+    faulty_participants: number[];
+};
+export type DkgVerifyNotEnoughResult = {
+    message: "NotEnoughParticipants";
+};
+export type DkgVerifyResult = DkgVerifyValidResult | DkgVerifyInvalidResult | DkgVerifyNotEnoughResult;
+export type DkgErrorResponse = {
+    message: string;
+};
+export declare class DistributedKeyGenerator extends WasmProcessor {
+    /**
+     * 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
+     */
+    static create(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.
+     *
+     * @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
+     */
+    participate(params: DkgParticipateParams): DkgParticipateResult | DkgErrorResponse;
+    /**
+     * verify DKG participations and extract the group key.
+     *
+     * @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
+     */
+    verify(params: DkgVerifyParams): DkgVerifyResult | DkgErrorResponse;
+}

package/dist/send-functionality/multisig.js

@@ -0,0 +1,97 @@
+import { frost_dkg_wasm } from "../wasm-processing/wasmFile";
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+export class DistributedKeyGenerator extends WasmProcessor {
+    /**
+     * 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
+     */
+    static async create(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.
+     *
+     * @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
+     */
+    participate(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));
+        };
+        //@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.
+     *
+     * @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
+     */
+    verify(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));
+        };
+        //@ts-ignore
+        this.tinywasi.instance.exports.dkg_verify(jsonStr.length);
+        if (!result) {
+            return { message: "No response from dkg_verify" };
+        }
+        return result;
+    }
+}

package/dist/send-functionality/transactionBuilding.d.ts

@@ -31,6 +31,7 @@ export type SendError = {
     error: ErrorDetail;
     message: string;
 };
+export declare function makeSweepTransaction<T extends WasmProcessor>(processor: T, params: MakeTransactionParams): UnsignedTransaction;
 /**
  *  this function returns the unsigned transaction, throws {@link SendError}
  * @param processor

package/dist/send-functionality/transactionBuilding.js

@@ -1,3 +1,4 @@
+import { monero_wallet_api_wasm } from "../wasm-processing/wasmFile";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 export function makeInput(processor, outputToBeSpent, candidates, get_outs_Response) {
     const makeInputArgs = JSON.stringify({
@@ -41,6 +42,26 @@ export function sampleDecoys(processor, outputToBeSpentIndex, distribution, cand
     }
     return result;
 }
+export function makeSweepTransaction(processor, params) {
+    const jsonParams = JSON.stringify(params);
+    processor.writeToWasmMemory = (ptr, len) => {
+        processor.writeString(ptr, len, jsonParams);
+    };
+    let result = null;
+    let error = null;
+    processor.readFromWasmMemory = (ptr, len) => {
+        result = JSON.parse(processor.readString(ptr, len));
+    };
+    processor.readErrorFromWasmMemory = (ptr, len) => {
+        error = JSON.parse(processor.readString(ptr, len));
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.make_external_sweep_transaction(jsonParams.length);
+    if (!result) {
+        throw error;
+    }
+    return result["signable_transaction"];
+}
 /**
  *  this function returns the unsigned transaction, throws {@link SendError}
  * @param processor
@@ -68,7 +89,7 @@ export function makeTransaction(processor, params) {
     return result["signable_transaction"];
 }
 export async function signTransaction(tx, sender_spend_key) {
-    const wasmProcessor = await WasmProcessor.init();
+    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, tx);
         wasmProcessor.writeToWasmMemory = (ptr, len) => {
@@ -87,7 +108,7 @@ export async function signTransaction(tx, sender_spend_key) {
     return result["signed_transaction"];
 }
 export async function parseAddress(address) {
-    const wasmProcessor = await WasmProcessor.init();
+    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, address);
     };

package/dist/viewpair/ViewPair.d.ts

@@ -120,6 +120,14 @@ export declare class ViewPair extends WasmProcessor {
      * @returns The serialized transaction as an array of numbers.
      */
     makeTransaction(params: MakeTransactionParams): UnsignedTransaction;
+    /**
+     * makeSweepTransaction
+     * @param params - The transaction parameters. Must have exactly one payment,
+     *  the amount will be overwritten by the total amount of the inputs - the necessary fee
+     *
+     * @returns The serialized transaction as an array of numbers
+     */
+    makeSweepTransaction(params: MakeTransactionParams): string;
     /**
      * Retrieve block headers for a specified range of heights.
      * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_block_headers_range

package/dist/viewpair/ViewPair.js

@@ -2,16 +2,14 @@ import {} from "../scanning-syncing/scanresult/scanResult";
 export {};
 export { NodeUrl } from "../node-interaction/nodeUrl";
 import { getBlocksBinScan, getBlocksBinExecuteRequest, getBlocksBinScanOneBlock, loadGetBlocksBinResponse, MAINNET_GENESIS_BLOCK_HASH, STAGENET_GENESIS_BLOCK_HASH, } from "../node-interaction/binaryEndpoints";
-import { handleScanError, lastRange, writeCacheFileDefaultLocationThrows, } from "../scanning-syncing/scanresult/scanCache";
-import { makeTransaction, } from "../send-functionality/transactionBuilding";
+import { lastRange, writeCacheFileDefaultLocationThrows, } from "../scanning-syncing/scanresult/scanCache";
+import { makeSweepTransaction, makeTransaction, } from "../send-functionality/transactionBuilding";
+import { monero_wallet_api_wasm } from "../wasm-processing/wasmFile";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 import { LOCAL_NODE_DEFAULT_URL, } from "../node-interaction/nodeUrl";
-import { atomicWrite, get_block_headers_range, get_info, } from "../api";
-import { readGetblocksBinBuffer, trimGetBlocksBinBuffer, writeGetblocksBinBuffer, } from "../scanning-syncing/blocksbuffer/getBlocksbinBuffer";
-import { initScanCache, readCacheFileDefaultLocation, } from "../scanning-syncing/scanresult/scanCache";
-import { cullTooLargeScanHeight, openNonHaltedWallets, readWalletFromScanSettings, walletSettingsPlusKeys, } from "../scanning-syncing/scanSettings";
+import { get_block_headers_range, get_info, } from "../api";
+import { readWalletFromScanSettings } from "../scanning-syncing/scanSettings";
 import { sleep } from "../io/sleep";
-import { readWriteConnectionStatusFile, writeConnectionStatusFile, } from "../scanning-syncing/connectionStatus";
 /**
  * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
  * (similar to how you would interact with a REST api that gives you json back.)
@@ -40,7 +38,7 @@ export class ViewPair extends WasmProcessor {
     }
     static async create(primary_address, secret_view_key, subaddress_index = 0, node_url) {
         const viewPair = new ViewPair(node_url || LOCAL_NODE_DEFAULT_URL, primary_address);
-        const tinywasi = await viewPair.initWasmModule();
+        const tinywasi = await viewPair.initWasmModule(monero_wallet_api_wasm);
         viewPair.writeToWasmMemory = (ptr, len) => {
             viewPair.writeString(ptr, len, primary_address);
             viewPair.writeToWasmMemory = (ptr, len) => {
@@ -266,6 +264,16 @@ export class ViewPair extends WasmProcessor {
     makeTransaction(params) {
         return makeTransaction(this, params);
     }
+    /**
+     * makeSweepTransaction
+     * @param params - The transaction parameters. Must have exactly one payment,
+     *  the amount will be overwritten by the total amount of the inputs - the necessary fee
+     *
+     * @returns The serialized transaction as an array of numbers
+     */
+    makeSweepTransaction(params) {
+        return makeSweepTransaction(this, params);
+    }
     /**
      * Retrieve block headers for a specified range of heights.
      * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_block_headers_range

package/dist/wasm-processing/wasmFile.d.ts

@@ -1 +1,2 @@
 export declare const monero_wallet_api_wasm: Uint8Array<ArrayBuffer>;
+export declare const frost_dkg_wasm: Uint8Array<ArrayBuffer>;