@spirobel/monero-wallet-api 0.5.3 → 0.5.5

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

@@ -1 +1,2 @@
+export declare function requestCoordinatorShutdown(): void;
 export declare function coordinatorMainWorker(scan_settings_path?: string, pathPrefix?: string, cpuPorts?: MessagePort[]): Promise<void>;

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

@@ -1,9 +1,16 @@
 import { coordinatorMainMultithreaded } from "../scanresult/scanCoordination";
 import { log } from "../../io/logging";
+// one controller per coordinator worker; shutdown aborts fetch + race
+let shutdownController;
+export function requestCoordinatorShutdown() {
+    log("coordinatorMainWorker", ["shutdown requested"]);
+    shutdownController?.abort();
+}
 export async function coordinatorMainWorker(scan_settings_path, pathPrefix, cpuPorts) {
     log("coordinatorMainWorker", "cpuPorts=" + cpuPorts?.length);
+    shutdownController = new AbortController();
     try {
-        const gen = coordinatorMainMultithreaded(scan_settings_path, pathPrefix, cpuPorts);
+        const gen = coordinatorMainMultithreaded(scan_settings_path, pathPrefix, cpuPorts, shutdownController.signal);
         for await (const event of gen) {
             log("coordinatorMainWorker", ["event:", event]);
             if (event.type === "scan_ready") {
@@ -15,10 +22,17 @@ export async function coordinatorMainWorker(scan_settings_path, pathPrefix, cpuP
                     },
                 });
             }
+            else if (event.type === "shutdown_done") {
+                self.postMessage({ type: "SHUTDOWN_DONE" });
+                return;
+            }
         }
+        // generator returned without shutdown_done (e.g. empty)
+        self.postMessage({ type: "SHUTDOWN_DONE" });
     }
     catch (error) {
-        console.error("[coordinatorMainWorker] error:", error);
+        // still tell main thread we stopped so terminate can proceed
+        self.postMessage({ type: "SHUTDOWN_DONE" });
         self.postMessage({ type: "ERROR", payload: error });
     }
 }

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

@@ -1,5 +1,8 @@
 import { type ScanLoopInput, type ScanLoopYield } from "../scanresult/scanLoop";
-export declare function handleCpuboundScan(msg: ScanLoopInput, port?: MessagePort): Promise<ScanLoopYield>;
-export declare function handleCpuboundScanTry(msg: ScanLoopInput, port?: MessagePort): Promise<ScanLoopYield>;
+export declare function handleCpuboundScan(msg: ScanLoopInput, cpu_worker_status: CpuWorkerStatus): Promise<ScanLoopYield>;
+export declare function handleCpuboundScanTry(msg: ScanLoopInput, cpu_worker_status: CpuWorkerStatus): Promise<ScanLoopYield>;
+export type CpuWorkerStatus = {
+    cancel: boolean;
+};
 export declare function sendFromCpuWorker(port: MessagePort, msg: ScanLoopYield): void;
 export declare function sendToCpuWorker(port: MessagePort, msg: ScanLoopInput): void;

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

@@ -6,7 +6,7 @@ import {} from "../scanresult/scanLoop";
  * logs progress every 10 blocks, then sends the final result.
  */
 let callcounter = 0;
-export async function handleCpuboundScan(msg, port) {
+export async function handleCpuboundScan(msg, cpu_worker_status) {
     callcounter++;
     log("handleCpuboundScan", "callcounter=" + callcounter);
     if (!msg) {
@@ -14,17 +14,14 @@ export async function handleCpuboundScan(msg, port) {
         throw new Error("[cpubound] no content msg! ( ScanLoopInput = undefined )");
     }
     if (msg === "cancel") {
+        // idle cancel: nothing in flight, just ack
         log("handleCpuboundScan", "cancel msg! ( ScanLoopInput = cancel )");
-        throw new Error("[cpubound] no content msg! ( ScanLoopInput = undefined )");
+        return { type: "Canceled" };
     }
     log("handleCpuboundScan", "got scan msg, walletConfig=" +
         msg.walletConfig?.primary_address?.slice(0, 6));
     const walletConfig = msg.walletConfig;
     const item = msg;
-    if (!port) {
-        log("handleCpuboundScan", "no port!");
-        throw new Error("[cpubound] no port");
-    }
     log("handleCpuboundScan", "primed, feeding workItem uuid=" +
         (item && typeof item === "object"
             ? item.work_uuid?.slice(0, 8)
@@ -90,6 +87,11 @@ export async function handleCpuboundScan(msg, port) {
                 heightto,
             ]);
         }
+        if (cpu_worker_status.cancel) {
+            cpu_worker_status.cancel = false;
+            log("handleCpuboundScan", ["cpu work canceled"]);
+            return { type: "Canceled", work_uuid: item.work_uuid };
+        }
         await sleep(10); // make sure the loop is not tight
     }
     log("handleCpuboundScan", [
@@ -105,9 +107,9 @@ export async function handleCpuboundScan(msg, port) {
         result: scanResult,
     };
 }
-export function handleCpuboundScanTry(msg, port) {
+export function handleCpuboundScanTry(msg, cpu_worker_status) {
     try {
-        return handleCpuboundScan(msg, port);
+        return handleCpuboundScan(msg, cpu_worker_status);
     }
     catch (err) {
         console.error("[cpubound] error", err);

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

@@ -1,4 +1,4 @@
-import { coordinatorMainWorker } from "./coordinator-main";
+import { coordinatorMainWorker, requestCoordinatorShutdown, } from "./coordinator-main";
 import { handleCpuboundScanTry, sendFromCpuWorker } from "./cpubound-main";
 import { log, setupLoggingPath } from "../../io/logging";
 import { multisigMainWorkerCall } from "./multisig-main";
@@ -8,17 +8,33 @@ self.addEventListener("unhandledrejection", (e) => self.postMessage({ type: "ERR
 let SCAN_SETTINGS_PATH;
 let PATH_PREFIX;
 let cpuPort;
+const cpu_worker_status = { cancel: false };
+// true while a scan is running so idle cancel can ack immediately
+let cpu_work_in_flight = false;
 let multisig_dkg;
 export function CPU_PORT_HANDLER(pe) {
+    if (pe.data === "cancel") {
+        if (cpu_work_in_flight) {
+            cpu_worker_status.cancel = true;
+            return;
+        }
+        // idle cancel: ack right away so coordinator drain does not hang
+        if (cpuPort) {
+            sendFromCpuWorker(cpuPort, { type: "Canceled" });
+        }
+        return;
+    }
     if (!cpuPort)
         throw new Error("[cpubound] cpuPort is undefined in port.onmessage");
     log("CPU_PORT_HANDLER", "new workitem msg received");
+    cpu_work_in_flight = true;
     cpuPort.postMessage({
         type: "WORKSTART",
         work_uuid: pe.data.work_uuid,
     });
-    handleCpuboundScanTry(pe.data, cpuPort).then((result) => {
+    handleCpuboundScanTry(pe.data, cpu_worker_status).then((result) => {
         log("CPU_PORT_HANDLER", "work finished, sending result");
+        cpu_work_in_flight = false;
         if (!cpuPort)
             throw new Error("[cpubound] cpuPort is undefined in port.onmessage");
         cpuPort.onmessage = CPU_PORT_HANDLER;
@@ -28,6 +44,38 @@ export function CPU_PORT_HANDLER(pe) {
 const handleMessage = async (e) => {
     const msg = e.data;
     log("handleMessage", ["msg received", msg]);
+    if (msg.type === "shutdown") {
+        // only coordinator listens for this; abort fetch + race loop
+        requestCoordinatorShutdown();
+        return;
+    }
+    if (msg.type === "heap_snapshot") {
+        try {
+            const path = typeof msg.path === "string" && msg.path.length > 0
+                ? msg.path
+                : `worker-heap-${Date.now()}.heapsnapshot`;
+            // @ts-ignore bun has generateHeapSnapshot; node has v8.writeHeapSnapshot
+            let out;
+            if (typeof Bun !== "undefined" && typeof Bun.generateHeapSnapshot === "function") {
+                const snap = Bun.generateHeapSnapshot("v8");
+                await Bun.write(path, typeof snap === "string" ? snap : JSON.stringify(snap));
+                out = path;
+            }
+            else {
+                throw Error("in the browser use the inspector directly to observe worker memory growth");
+                // const v8 = await import("node:v8");
+                // out = v8.writeHeapSnapshot(path);
+            }
+            self.postMessage({ type: "HEAP_SNAPSHOT_DONE", path: out ?? path });
+        }
+        catch (err) {
+            self.postMessage({
+                type: "HEAP_SNAPSHOT_ERROR",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return;
+    }
     if (msg.type === "setup") {
         const settingsPath = msg.scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT;
         SCAN_SETTINGS_PATH = settingsPath;

package/dist/scansettings/scanSettingsOpened.js

@@ -1,6 +1,6 @@
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
 import { LOGGING_FUNCTIONS, } from "../io/logging";
-import { getPathPrefix, makeSpendKeyFromSeed, makeViewKey, openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, writeEnvLineToDotEnvRefresh, writeScanSettings, writeViewKeyToDotEnv, } from "../api";
+import { getPathPrefix, makeSpendKeyFromSeed, makeViewKey, openScanSettingsFile, parseAddress, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, writeEnvLineToDotEnvRefresh, writeScanSettings, writeViewKeyToDotEnv, } from "../api";
 export class ScanSettingsOpened {
     _scan_settings_path;
     _pathPrefix;
@@ -309,7 +309,8 @@ export class ScanSettingsOpened {
         }
     }
     static _validateAddress(address) {
-        if (!isValidMoneroAddress(address)) {
+        const parsed = parseAddress(address);
+        if ("error" in parsed) {
             throw new Error(`invalid monero address: ${address}`);
         }
     }
@@ -404,10 +405,6 @@ export class ScanSettingsOpened {
         await writeScanSettings(this._settings, this._scan_settings_path);
     }
 }
-function isValidMoneroAddress(address) {
-    // basic sanity check
-    return (address.length >= 95 && address.length <= 106 && isAlphaNumeric(address));
-}
 function isValidMoneroPrivateKey(key) {
     return key.length === 64 && isAlphaNumeric(key);
 }

package/dist/tools/monero-tools.js

@@ -122,7 +122,7 @@ export function parseDestination(destination) {
     const url = new URL(destination);
     return getDomainWithTLD(url.hostname);
 }
-export const OPEN_DOMAINS = ["monerochan.city"];
+export const OPEN_DOMAINS = ["monerochan.cash"];
 // this validity check should happen in the contentscript when the link is clicked,
 // not in the background script
 // -> tor circuit is separated & compartmentalized

package/dist/viewpair/ViewPair.js

@@ -46,18 +46,23 @@ export class ViewPair extends WasmProcessor {
             };
         };
         let init_viewpair_result = undefined;
+        let init_viewpair_error = undefined;
         viewPair.readFromWasmMemory = (ptr, len) => {
             init_viewpair_result = JSON.parse(viewPair.readString(ptr, len));
         };
+        viewPair.readErrorFromWasmMemory = (ptr, len) => {
+            init_viewpair_error = JSON.parse(viewPair.readString(ptr, len));
+        };
         //@ts-ignore
         tinywasi.instance.exports.init_viewpair(primary_address.length, secret_view_key.length, subaddress_index);
+        if (init_viewpair_error && "error" in init_viewpair_error) {
+            throw new Error(`primary-address-not-valid (${primary_address.slice(0, 8)}...${primary_address.slice(-8)})`);
+        }
         if (!init_viewpair_result) {
             throw new Error("Failed to init viewpair");
         }
-        else {
-            //@ts-ignore
-            viewPair._network = init_viewpair_result.network;
-        }
+        //@ts-ignore
+        viewPair._network = init_viewpair_result.network;
         return viewPair;
     }
     /**