@spirobel/monero-wallet-api 0.4.0 → 0.5.0

package/dist/multisig/multisig.js

@@ -0,0 +1,140 @@
+import { log } from "../io/logging";
+import { startWebworkerReady } from "../scanning-syncing/backgroundWorker";
+export class MultiSig {
+    worker = undefined;
+    /**
+     * 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 MultiSig();
+        await dkg.startWorker(t, n);
+        return dkg;
+    }
+    stopWorker() {
+        if (this.worker) {
+            this.worker.terminate();
+            delete this.worker;
+        }
+    }
+    async startWorker(t, n) {
+        if (!this.worker) {
+            this.worker = await startWebworkerReady();
+            const that = this;
+            const result_promise = new Promise((resolve) => {
+                if (!that.worker) {
+                    resolve();
+                    return;
+                }
+                that.worker.onmessage = (e) => {
+                    const msg = e.data;
+                    if (msg.type === "multisig-ready") {
+                        resolve();
+                    }
+                    else {
+                        handleUnknownMessage(msg, "startWorker");
+                    }
+                };
+                that.worker.postMessage({
+                    type: "setup",
+                    t,
+                    n,
+                    role: "multisig",
+                });
+            });
+            return await result_promise;
+        }
+        else {
+            this.stopWorker();
+            this.startWorker(t, n);
+        }
+    }
+    /**
+     * 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 msg = { type: "multisig-call", functionName: "participate", params };
+        const that = this;
+        const result_promise = new Promise((resolve) => {
+            if (!that.worker) {
+                handleNoWorkerButMethodCalled("participate");
+                return;
+            }
+            that.worker.onmessage = (e) => {
+                const msg = e.data;
+                if (msg.type === "multisig-call-result") {
+                    resolve(msg.result);
+                }
+                else {
+                    handleUnknownMessage(msg, "participate");
+                }
+            };
+            that.worker.postMessage(msg);
+        });
+        return result_promise;
+    }
+    /**
+     * 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 msg = { type: "multisig-call", functionName: "verify", params };
+        const that = this;
+        const result_promise = new Promise((resolve) => {
+            if (!that.worker) {
+                handleNoWorkerButMethodCalled("participate");
+                return;
+            }
+            that.worker.onmessage = (e) => {
+                const msg = e.data;
+                if (msg.type === "multisig-call-result") {
+                    resolve(msg.result);
+                }
+                else {
+                    handleUnknownMessage(msg, "participate");
+                }
+            };
+            that.worker.postMessage(msg);
+        });
+        return result_promise;
+    }
+    /**
+     * participate in a DKG round (throws on error).
+     */
+    async participate(params) {
+        const result = await 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).
+     */
+    async verify(params) {
+        const result = await 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;
+    }
+}
+function handleUnknownMessage(msg, functionName) {
+    log("multisig", [`${functionName}(): unknown message type:  ${msg.type}`]);
+    throw new Error(`[multisig] ${functionName}(): unknown message type:  ${msg.type}`);
+}
+function handleNoWorkerButMethodCalled(functionName) {
+    log("multisig", [`${functionName}(): no worker`]);
+    throw new Error(`[multisig] ${functionName}(): no worker`);
+}

package/dist/node-interaction/nodeUrl.js

@@ -2,6 +2,7 @@ import { getBlocksBinExecuteRequest, loadGetBlocksBinResponse, getOutsBinJson, g
 import { get_block_headers_range, get_fee_estimate, get_info, get_output_distribution, send_raw_transaction, } from "./jsonEndpoints";
 import { makeInput, sampleDecoys, } from "../send-functionality/transactionBuilding";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+import { monero_wallet_api_wasm } from "../wasm-processing/wasmFile";
 /**
  * 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.)
@@ -27,7 +28,7 @@ export class NodeUrl extends WasmProcessor {
     }
     static async create(node_url) {
         const nodeUrl = new NodeUrl(node_url || LOCAL_NODE_DEFAULT_URL);
-        await nodeUrl.initWasmModule();
+        await nodeUrl.initWasmModule(monero_wallet_api_wasm);
         return nodeUrl;
     }
     /**

package/dist/scanning-syncing/backgroundWorker.d.ts

@@ -1,4 +1,5 @@
 import { type CacheChangedCallbackParameters } from "./scanresult/scanCache";
+export declare const CPU_POOL_SIZE = 4;
 export type WorkerSet = {
     fetchWorker: Worker;
     cpuWorkers: Worker[];
@@ -7,3 +8,4 @@ export type WorkerSet = {
 export declare function createWebworker(handle_result?: (result: CacheChangedCallbackParameters) => void, scan_settings_path?: string, pathPrefix?: string, handle_error?: (error: unknown) => void): Promise<WorkerSet | undefined>;
 export declare function makeWebworkerScript(): string;
 export declare function startWebworker(handle_result?: (result: unknown) => void, handle_error?: (error: unknown) => void): Worker;
+export declare function startWebworkerReady(): Promise<Worker>;

package/dist/scanning-syncing/backgroundWorker.js

@@ -1,11 +1,14 @@
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
 import {} from "./scanresult/scanCache";
-import { openScanSettingsFile } from "./scanSettings";
+import { openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, } from "./scanSettings";
+import { log, setupLoggingPath } from "../io/logging";
 import { workerMainCode } from "./worker-entrypoints/worker";
-const CPU_POOL_SIZE = 4;
+export const CPU_POOL_SIZE = 4;
 export async function createWebworker(handle_result, scan_settings_path, pathPrefix, handle_error) {
     try {
-        const scanSettings = await openScanSettingsFile(scan_settings_path);
+        const resolvedPath = scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT;
+        const scanSettings = await openScanSettingsFile(resolvedPath);
+        await setupLoggingPath(resolvedPath, pathPrefix ?? "", "mainthread");
         const node_url = scanSettings?.node_url || LOCAL_NODE_DEFAULT_URL;
         const cpu_worker_count = typeof scanSettings?.cpu_worker_count !== "undefined"
             ? scanSettings?.cpu_worker_count
@@ -16,7 +19,13 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
         for (let i = 0; i < cpu_worker_count; i++) {
             const channel = new MessageChannel();
             const cpuWorker = await startWebworkerReady();
-            cpuWorker.postMessage({ type: "setup", role: "cpubound", cpu_worker_id: i }, [channel.port1]);
+            cpuWorker.postMessage({
+                type: "setup",
+                role: "cpubound",
+                cpu_worker_id: i,
+                scan_settings_path: resolvedPath,
+                pathPrefix,
+            }, [channel.port1]);
             cpuWorker.onerror = (e) => {
                 if (handle_error)
                     handle_error("cpu worker " + i + " error: " + (e.message ?? String(e)));
@@ -27,13 +36,16 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
         const coordinationWorker = await startWebworkerReady();
         coordinationWorker.postMessage({
             type: "setup",
-            scan_settings_path,
+            scan_settings_path: resolvedPath,
             pathPrefix,
             role: "coordinator",
             node_url,
             start_height: 0,
         }, cpuPorts); // transfer CPU port2s to coordination worker
-        console.log("[createWebworker] coordinator worker started, node_url=" + node_url, ", cpuPorts=" + cpuPorts.length);
+        log("createWebworker", [
+            "coordinator worker started, node_url=" + node_url,
+            ", cpuPorts=" + cpuPorts.length,
+        ]);
         coordinationWorker.onmessage = (event) => {
             if (event.data.type === "ERROR") {
                 if (handle_error)
@@ -79,7 +91,7 @@ export function startWebworker(handle_result, handle_error) {
                     handle_error(event.data.payload ?? event.data.error);
                 break;
             case "DEBUG":
-                console.log("worker debug:", event.data.payload);
+                log("startWebworker", ["worker debug:", event.data.payload]);
                 break;
         }
     };
@@ -89,7 +101,7 @@ export function startWebworker(handle_result, handle_error) {
 // WORKER_READY (meaning self.onmessage = handleMessage has executed).
 // after that, postMessage is safe, no race between worker startup
 // and message delivery.
-function startWebworkerReady() {
+export function startWebworkerReady() {
     const worker = startWebworker();
     return new Promise((resolve) => {
         const onReady = (e) => {

package/dist/scanning-syncing/blocksbuffer/blocksBufferFetchLoop.js

@@ -1,5 +1,6 @@
 import { findRange, get_block_headers_range, get_info, mergeRanges, NodeUrl, sleep, } from "../../api";
 import {} from "../connectionStatus";
+import { log } from "../../io/logging";
 export const MAX_BLOCKS_BUFFER_SIZE = 10;
 // runs forever, fetching blocks from the node.
 // handles scan level reorg detection and catastrophic reorg
@@ -8,7 +9,7 @@ connection_status, // we make a local copy of this and pass last_packet and sync
 max_blocks_buffer_size = MAX_BLOCKS_BUFFER_SIZE, anchor_range, stopSync) {
     connection_status = structuredClone(connection_status);
     const nodeUrl = await NodeUrl.create(node_url);
-    console.log("[blocksBufferFetchLoop] NodeUrl created, fetching info...");
+    log("blocksBufferFetchLoop", ["NodeUrl:", nodeUrl.node_url, "start:", start_height]);
     start_height = await reduceStartHeightToTip(start_height, nodeUrl.node_url);
     // initialise ranges on first call
     let { current_range, scanned_ranges } = await initScannedRanges(nodeUrl.node_url, start_height, anchor_range ? [anchor_range] : []);
@@ -38,12 +39,10 @@ max_blocks_buffer_size = MAX_BLOCKS_BUFFER_SIZE, anchor_range, stopSync) {
             await sleep(5000);
             continue;
         }
-        console.log("[blocksBufferFetchLoop] fetching from current_range...");
+        log("blocksBufferFetchLoop", ["fetching", nodeUrl.node_url, current_range.start, "->", current_range.end]);
         const get_blocks_bin = await doRPCrequest(nodeUrl, current_range, stopSync);
         const result_meta = await nodeUrl.loadGetBlocksBinResponse(get_blocks_bin);
-        console.log("[blocksBufferFetchLoop] response: " +
-            result_meta.block_infos.length +
-            " blocks");
+        log("blocksBufferFetchLoop", "response: " + result_meta.block_infos.length + " blocks");
         connection_status.last_packet = {
             status: "OK",
             bytes_read: get_blocks_bin.length,
@@ -343,8 +342,11 @@ export async function reduceStartHeightToTip(start_height, node_url) {
     if (start_height > getInfo.height - 1) {
         const oldStartHeight = start_height;
         start_height = getInfo.height - 1;
-        console.log("[reduceStartHeightToTip] start height was larger than daemon height, setting start_height=" +
-            start_height, " oldStartHeight=" + oldStartHeight);
+        log("reduceStartHeightToTip", [
+            "start height was larger than daemon height, setting start_height=" +
+                start_height,
+            " oldStartHeight=" + oldStartHeight,
+        ]);
     }
     return start_height;
 }

package/dist/scanning-syncing/blocksbuffer/blocksbufferCoordination.js

@@ -1,4 +1,5 @@
 import { blocksBufferFetchLoop, readWriteConnectionStatusFile, CatastrophicReorgError, readOrInitConnectionStatus, } from "../../api";
+import { log } from "../../io/logging";
 export async function setupBlocksBufferGenerator(params) {
     const blocksBuffer = [];
     const connection_status = await readOrInitConnectionStatus(params.scanSettingsPath);
@@ -13,7 +14,7 @@ export async function handleConnectionStatusChanges(event, scanSettingsPath) {
             cs2.last_packet = event;
         }, scanSettingsPath);
         if (event.status === "catastrophic_reorg") {
-            console.log("[blocksbufferCoordinator] catastrophic reorg, stopping");
+            log("handleConnectionStatusChanges", "catastrophic reorg, stopping");
             throw new CatastrophicReorgError("[blocksbufferCoordinator] catastrophic reorg, stopping");
         }
     }

package/dist/scanning-syncing/scanSettings.d.ts

@@ -1,4 +1,6 @@
+import type { LogSetting, PossibleLogs } from "../io/logging";
 export declare const SCAN_SETTINGS_STORE_NAME_DEFAULT = "ScanSettings.json";
+export declare const SUB_ADDRESS_INDEX_DEFAULT_VALUE = 1;
 export type ScanSetting = {
     primary_address: string;
     subaddress_index?: number;
@@ -17,6 +19,9 @@ export type WriteScanSettingParams = {
     wallet_route?: string;
     wallet_name?: string;
     wallet_slot?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
 };
 export type ScanSettingOpened = {
     primary_address: string;
@@ -36,6 +41,9 @@ export type ScanSettings = {
     start_height: number | null;
     merchant_confirmations?: number | null;
     cpu_worker_count?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
 };
 export type ScanSettingsOpened = {
     wallets: (ScanSettingOpened | undefined)[];
@@ -43,6 +51,9 @@ export type ScanSettingsOpened = {
     start_height: number | null;
     merchant_confirmations?: number | null;
     cpu_worker_count?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
 };
 /**
  * Writes scan settings to the default or specified storage file in json.

package/dist/scanning-syncing/scanSettings.js

@@ -3,6 +3,10 @@ import { atomicWrite } from "../io/atomicWrite";
 import { refreshEnvIndexedDB } from "../io/indexedDB";
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
 export const SCAN_SETTINGS_STORE_NAME_DEFAULT = "ScanSettings.json";
+// default value for subaddress highest minor index eg up to which minor index,
+// to add subaddresses to the scanner
+// (we never touch major index, having two values is just too confusing)
+export const SUB_ADDRESS_INDEX_DEFAULT_VALUE = 1;
 /**
  * Writes scan settings to the default or specified storage file in json.
  *
@@ -231,7 +235,7 @@ export async function writeWalletToScanSettings(params) {
             wallets: [
                 {
                     primary_address: params.primary_address,
-                    subaddress_index: params.subaddress_index || 1,
+                    subaddress_index: params.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE,
                     halted: params.halted,
                     wallet_route: params.wallet_route,
                     wallet_name: params.wallet_name,
@@ -239,10 +243,19 @@ export async function writeWalletToScanSettings(params) {
                 },
             ],
             node_url: params.node_url,
+            logs: params.logs,
+            logs_include: params.logs_include,
+            logs_exclude: params.logs_exclude,
             start_height: params.start_height || null,
         }, params.scan_settings_path);
     }
     scanSettings.node_url = params.node_url || scanSettings.node_url;
+    if (params.logs)
+        scanSettings.logs = params.logs;
+    if (params.logs_include)
+        scanSettings.logs_include = params.logs_include;
+    if (params.logs_exclude)
+        scanSettings.logs_exclude = params.logs_exclude;
     scanSettings.start_height =
         params.start_height === undefined
             ? scanSettings.start_height
@@ -252,7 +265,7 @@ export async function writeWalletToScanSettings(params) {
         // wallet does not exist yet in settings
         scanSettings.wallets.push({
             primary_address: params.primary_address,
-            subaddress_index: params.subaddress_index || 1,
+            subaddress_index: params.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE,
             halted: params.halted,
             wallet_route: params.wallet_route,
             wallet_name: params.wallet_name,
@@ -264,7 +277,9 @@ export async function writeWalletToScanSettings(params) {
         const wallet = scanSettings.wallets[already_has_settings];
         if (wallet) {
             wallet.subaddress_index =
-                params.subaddress_index || wallet.subaddress_index || 1;
+                params.subaddress_index ||
+                    wallet.subaddress_index ||
+                    SUB_ADDRESS_INDEX_DEFAULT_VALUE;
             wallet.halted = params.halted || wallet.halted;
             wallet.wallet_route = params.wallet_route || wallet.wallet_route;
             wallet.wallet_name = params.wallet_name || wallet.wallet_name;

package/dist/scanning-syncing/scanresult/computeKeyImage.d.ts

@@ -1,3 +1,4 @@
 import type { Output } from "../../api";
+import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
 export type KeyImage = string;
-export declare function computeKeyImage(output: Output, sender_spend_key: string): Promise<KeyImage | undefined>;
+export declare function computeKeyImage(output: Output, sender_spend_key: string, wasmProcessor?: WasmProcessor): Promise<KeyImage | undefined>;

package/dist/scanning-syncing/scanresult/computeKeyImage.js

@@ -1,6 +1,8 @@
+import { monero_wallet_api_wasm } from "../../wasm-processing/wasmFile";
 import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
-export async function computeKeyImage(output, sender_spend_key) {
-    const wasmProcessor = await WasmProcessor.init();
+export async function computeKeyImage(output, sender_spend_key, wasmProcessor) {
+    if (!wasmProcessor)
+        wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, output.serialized);
         wasmProcessor.writeToWasmMemory = (ptr, len) => {

package/dist/scanning-syncing/scanresult/scanCache.js

@@ -1,6 +1,7 @@
 import {} from "./computeKeyImage";
 import { get_block_headers_range, } from "../../api";
 import { atomicWrite } from "../../io/atomicWrite";
+import { log } from "../../io/logging";
 export async function initScanCache(viewpair, start_height, scan_settings_path, pathPrefix) {
     const initialCache = await readCacheFileDefaultLocation(viewpair.primary_address, pathPrefix);
     let cache = {
@@ -161,7 +162,7 @@ export function handleScanError(error) {
     // treat errno 0 code "ConnectionRefused" as non fatal outcome, and rethrow,
     // so that UI can be informed after catching it higher up
     if (isConnectionError(error)) {
-        console.log("Scan stopped. node might be offline. Connection Refused");
+        log("handleScanError", "Scan stopped. node might be offline. Connection Refused");
         throw error;
     }
     // Treat AbortError as a normal, non-fatal outcome
@@ -169,11 +170,14 @@ export function handleScanError(error) {
         typeof error === "object" &&
         (("name" in error && error.name === "AbortError") ||
             ("code" in error && error.code === 20))) {
-        console.log("Scan was aborted.");
+        log("handleScanError", "Scan was aborted.");
         return;
     }
     else {
-        console.log(error, "\n, scanWithCache in scanning-syncing/scanWithCache.ts`");
+        log("handleScanError", [
+            error,
+            "\n, scanWithCache in scanning-syncing/scanWithCache.ts`",
+        ]);
         throw error;
     }
 }

package/dist/scanning-syncing/scanresult/scanCacheOpened.d.ts

@@ -46,6 +46,7 @@ export declare class ScanCacheOpened {
     readonly decoyRetrySizes: number[];
     static create(params: ScanCacheOpenedCreateParams): Promise<ScanCacheOpened>;
     get start_height(): number | null;
+    get subaddress_index(): number;
     get current_height(): number | null;
     get current_top_range_height(): number | null;
     changeStartHeight(start_height: number | null): Promise<void>;
@@ -60,6 +61,7 @@ export declare class ScanCacheOpened {
     retry(): Promise<boolean>;
     sendTransaction(signedTx: string): Promise<SendRawTransactionResult>;
     signTransaction(unsignedTx: string): Promise<string>;
+    getFeeEstimate(): Promise<FeeEstimateResponse>;
     calculateFeeAndSelectInputs(params: CreateTransactionParams): Promise<{
         selectedInputs: Output[];
         feeEstimate: {
@@ -70,10 +72,16 @@ export declare class ScanCacheOpened {
         };
     }>;
     makeTransactionFromSelectedInputs(payments: Payment[], selectedInputs: Output[], feeEstimate: FeeEstimateResponse): Promise<string>;
+    makeSweepTransactionFromSelectedInputs(destination_address: string, selectedInputs: Output[], feeEstimate: FeeEstimateResponse): Promise<string>;
     /**
      * this function returns the unsigned transaction, throws {@link SendError}
      */
     makeTransaction(params: CreateTransactionParams): Promise<string>;
+    /**
+     * sweep inputs to external wallet address (the wallet will receive input amount - fee)
+     * @param inputs     use spendableInputs() to find inputs to put in
+     */
+    sweepToExternalWallet(destination_address: string, inputs: Output[]): Promise<string>;
     get daemon_height(): number;
     get amount(): bigint;
     get pending_amount(): bigint;
@@ -134,6 +142,9 @@ export declare class ScanCacheOpened {
      * for all primary addresses
      */
     feed(params: CacheChangedCallbackParameters): Promise<void>;
+    private _highest_subaddress_index;
+    private _no_stats;
+    get no_stats(): boolean;
     private _cache;
     private worker?;
     private last_eta_height;