@spirobel/monero-wallet-api 0.5.2 → 0.5.4

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

@@ -18,7 +18,6 @@ export async function coordinatorMainWorker(scan_settings_path, pathPrefix, cpuP
         }
     }
     catch (error) {
-        console.error("[coordinatorMainWorker] error:", error);
         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) {
@@ -21,10 +21,6 @@ export async function handleCpuboundScan(msg, port) {
         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 +86,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: "Ready" };
+        }
         await sleep(10); // make sure the loop is not tight
     }
     log("handleCpuboundScan", [
@@ -105,9 +106,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

@@ -8,8 +8,13 @@ self.addEventListener("unhandledrejection", (e) => self.postMessage({ type: "ERR
 let SCAN_SETTINGS_PATH;
 let PATH_PREFIX;
 let cpuPort;
+const cpu_worker_status = { cancel: false };
 let multisig_dkg;
 export function CPU_PORT_HANDLER(pe) {
+    if (pe.data === "cancel") {
+        cpu_worker_status.cancel = true;
+        return;
+    }
     if (!cpuPort)
         throw new Error("[cpubound] cpuPort is undefined in port.onmessage");
     log("CPU_PORT_HANDLER", "new workitem msg received");
@@ -17,7 +22,7 @@ export function CPU_PORT_HANDLER(pe) {
         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");
         if (!cpuPort)
             throw new Error("[cpubound] cpuPort is undefined in port.onmessage");

package/dist/scansettings/scanSettingsOpened.d.ts

@@ -93,6 +93,17 @@ export declare class ScanSettingsOpened {
      * throws if any entry is invalid.
      */
     private static _validateLogOptions;
+    private static _validateAddress;
+    private static _validateViewKey;
+    private static _validateNodeUrl;
+    private static _validateStartHeight;
+    private static _validateCpuWorkerCount;
+    private static _validateMerchantConfirmations;
+    private static _validateWalletName;
+    private static _validateWalletSlot;
+    private static _validateSubaddressIndex;
+    private static _validateWalletRoute;
+    private static _validateHalted;
     private _settings;
     private constructor();
     /**
@@ -100,3 +111,17 @@ export declare class ScanSettingsOpened {
      */
     private _persist;
 }
+export declare function walletRouteFromString(input: string): {
+    ok: boolean;
+    error: string;
+    route?: undefined;
+} | {
+    ok: boolean;
+    route: {
+        identity: string;
+        domain: string;
+        wallet_type: string;
+        wallet_slot: string;
+    };
+    error?: undefined;
+};

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 { LOGGING_FUNCTIONS, } from "../io/logging";
+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;
@@ -55,27 +55,34 @@ export class ScanSettingsOpened {
     }
     async setNodeUrl(node_url) {
         await this.reload();
-        this._settings.node_url = node_url;
+        this._settings.node_url = ScanSettingsOpened._validateNodeUrl(node_url);
         await this._persist();
     }
     async setStartHeight(start_height) {
         await this.reload();
+        ScanSettingsOpened._validateStartHeight(start_height);
         this._settings.start_height = start_height;
         await this._persist();
     }
     async setMerchantConfirmations(merchant_confirmations) {
         await this.reload();
-        this._settings.merchant_confirmations = merchant_confirmations;
-        if (merchant_confirmations === null)
+        if (merchant_confirmations === undefined ||
+            merchant_confirmations === null) {
             delete this._settings.merchant_confirmations;
+        }
+        else {
+            ScanSettingsOpened._validateMerchantConfirmations(merchant_confirmations);
+            this._settings.merchant_confirmations = merchant_confirmations;
+        }
         await this._persist();
     }
     async setCpuWorkerCount(cpu_worker_count) {
         await this.reload();
-        if (cpu_worker_count === null) {
+        if (cpu_worker_count === null || cpu_worker_count === undefined) {
             delete this._settings.cpu_worker_count;
         }
         else {
+            ScanSettingsOpened._validateCpuWorkerCount(cpu_worker_count);
             this._settings.cpu_worker_count = cpu_worker_count;
         }
         await this._persist();
@@ -154,13 +161,20 @@ export class ScanSettingsOpened {
      * if the wallet already exists, updates it instead.
      */
     async addViewWallet(primary_address, view_key, fields) {
+        primary_address = primary_address.trim();
+        view_key = view_key.trim();
+        ScanSettingsOpened._validateAddress(primary_address);
+        ScanSettingsOpened._validateViewKey(view_key);
+        ScanSettingsOpened._validateWalletName(fields?.wallet_name);
+        ScanSettingsOpened._validateWalletSlot(fields?.wallet_slot);
+        ScanSettingsOpened._validateWalletRoute(fields?.wallet_route);
+        ScanSettingsOpened._validateSubaddressIndex(fields?.subaddress_index);
+        ScanSettingsOpened._validateHalted(fields?.halted);
         await this.reload();
         const existing = this.getWallet(primary_address);
         if (existing) {
             throw new Error(`wallet already exists: ${primary_address} in ${this._scan_settings_path}`);
         }
-        primary_address = primary_address.trim();
-        view_key = view_key.trim();
         // write view key to env first
         await writeViewKeyToDotEnv(primary_address, view_key);
         const subaddress_index = fields?.subaddress_index ?? SUB_ADDRESS_INDEX_DEFAULT_VALUE;
@@ -180,6 +194,11 @@ export class ScanSettingsOpened {
         const spend_key = await makeSpendKeyFromSeed(wallet_secret.toHex());
         const view_pair = await makeViewKey(spend_key);
         const primary_address = view_pair.mainnet_primary;
+        ScanSettingsOpened._validateWalletName(fields?.wallet_name);
+        ScanSettingsOpened._validateWalletSlot(fields?.wallet_slot);
+        ScanSettingsOpened._validateWalletRoute(fields?.wallet_route);
+        ScanSettingsOpened._validateSubaddressIndex(fields?.subaddress_index);
+        ScanSettingsOpened._validateHalted(fields?.halted);
         await this.reload();
         const existing = this.getWallet(primary_address);
         if (existing) {
@@ -214,6 +233,11 @@ export class ScanSettingsOpened {
         const wallet = this.getWallet(primary_address);
         if (!wallet)
             throw new Error(`wallet not found: ${primary_address} in ${this._scan_settings_path}`);
+        ScanSettingsOpened._validateWalletName(fields.wallet_name);
+        ScanSettingsOpened._validateWalletSlot(fields.wallet_slot);
+        ScanSettingsOpened._validateSubaddressIndex(fields.subaddress_index);
+        ScanSettingsOpened._validateWalletRoute(fields.wallet_route);
+        ScanSettingsOpened._validateHalted(fields.halted);
         wallet.wallet_name = fields.wallet_name ?? wallet.wallet_name;
         wallet.wallet_slot = fields.wallet_slot ?? wallet.wallet_slot;
         wallet.wallet_route = fields.wallet_route ?? wallet.wallet_route;
@@ -284,6 +308,90 @@ export class ScanSettingsOpened {
                 `valid options are: ${[...valid].join(", ")}`);
         }
     }
+    static _validateAddress(address) {
+        const parsed = parseAddress(address);
+        if ("error" in parsed) {
+            throw new Error(`invalid monero address: ${address}`);
+        }
+    }
+    static _validateViewKey(key) {
+        if (!isValidMoneroPrivateKey(key)) {
+            throw new Error(`invalid secret view key: ${key}`);
+        }
+    }
+    static _validateNodeUrl(url) {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new Error(`invalid node URL: ${url}`);
+        }
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+            throw new Error(`unsupported protocol: ${parsed.protocol}`);
+        }
+        if (!parsed.hostname) {
+            throw new Error(`invalid node URL, missing hostname: ${url}`);
+        }
+        return url;
+    }
+    static _validateStartHeight(start_height) {
+        if (start_height !== null &&
+            (typeof start_height !== "number" || start_height < 0)) {
+            throw new Error(`invalid start height: ${start_height}. must be null or a number >= 0`);
+        }
+    }
+    static _validateCpuWorkerCount(cpu_worker_count) {
+        if (cpu_worker_count !== null &&
+            (typeof cpu_worker_count !== "number" || cpu_worker_count < 0)) {
+            throw new Error(`invalid cpu_worker_count: ${cpu_worker_count}. must be null or a number >= 0`);
+        }
+    }
+    static _validateMerchantConfirmations(merchant_confirmations) {
+        if (merchant_confirmations !== null &&
+            (typeof merchant_confirmations !== "number" || merchant_confirmations < 0)) {
+            throw new Error(`invalid merchant_confirmations: ${merchant_confirmations}. must be null or a number >= 0`);
+        }
+    }
+    static _validateWalletName(name) {
+        if (name === undefined || name === null)
+            return;
+        if (name.length > 100) {
+            throw new Error(`wallet name must be 100 characters or less, got ${name.length}`);
+        }
+        if (!/^[a-zA-Z0-9 _.-]+$/.test(name)) {
+            throw new Error(`wallet name must be alphanumeric with spaces, hyphens, underscores, or dots, got: ${name}`);
+        }
+    }
+    static _validateWalletSlot(slot) {
+        if (slot === undefined || slot === null)
+            return;
+        if (typeof slot !== "number" || slot < 0 || !Number.isInteger(slot)) {
+            throw new Error(`wallet slot must be a number >= 0, got: ${slot}`);
+        }
+    }
+    static _validateSubaddressIndex(index) {
+        if (index === undefined || index === null)
+            return;
+        if (typeof index !== "number" || index < 0 || !Number.isInteger(index)) {
+            throw new Error(`subaddress index must be a number >= 0, got: ${index}`);
+        }
+    }
+    static _validateWalletRoute(route) {
+        if (route === undefined || route === null)
+            return;
+        const result = walletRouteFromString(route);
+        if (!result.ok) {
+            throw new Error(result.error);
+        }
+    }
+    static _validateHalted(halted) {
+        if (halted === undefined || halted === null)
+            return;
+        if (typeof halted !== "boolean") {
+            throw new Error(`halted must be a boolean, got: ${halted}`);
+        }
+    }
     _settings;
     constructor(settings, _scan_settings_path, _pathPrefix) {
         this._scan_settings_path = _scan_settings_path;
@@ -297,3 +405,68 @@ export class ScanSettingsOpened {
         await writeScanSettings(this._settings, this._scan_settings_path);
     }
 }
+function isValidMoneroPrivateKey(key) {
+    return key.length === 64 && isAlphaNumeric(key);
+}
+function isAlphaNumeric(str) {
+    return str.match(/^[a-z0-9]+$/i) !== null;
+}
+// strictly speaking according to the RFC 1035
+// there is a limit of 63 chars per label
+// and other rules like no leading or trailing hyphens, no dots in a row
+function isValidDomainName(str) {
+    if (!str || str.length === 0 || str.length > 253) {
+        return false;
+    }
+    return str.match(/^[a-z0-9.\-_]+$/i) !== null;
+}
+// copied from seedphrase package to not introduce a dependency
+export function walletRouteFromString(input) {
+    const parts = input.split("/");
+    if (parts.length < 1 || !parts[0]) {
+        return { ok: false, error: "missing identity" };
+    }
+    if (parts.length < 2 || !parts[1]) {
+        return { ok: false, error: "missing domain" };
+    }
+    if (parts.length < 3 || !parts[2]) {
+        return { ok: false, error: "missing wallet_type" };
+    }
+    if (parts.length < 4 || !parts[3]) {
+        return { ok: false, error: "missing wallet_slot" };
+    }
+    if (parts.length > 4) {
+        return {
+            ok: false,
+            error: "wallet route should only have 4 parts separated by /",
+        };
+    }
+    const [identity, domain, wallet_type, wallet_slot] = parts;
+    if (wallet_type !== "single" &&
+        wallet_type !== "sa_multi" &&
+        wallet_type !== "pl_multi") {
+        return { ok: false, error: `invalid wallet_type: "${wallet_type}"` };
+    }
+    if (Number.isNaN(parseInt(wallet_slot))) {
+        return { ok: false, error: `invalid wallet_slot: "${wallet_slot}"` };
+    }
+    if (parseInt(wallet_slot) < 0) {
+        return { ok: false, error: `invalid wallet_slot: "${wallet_slot} < 0"` };
+    }
+    if (!isAlphaNumeric(identity)) {
+        return {
+            ok: false,
+            error: `invalid identity, not alpha numeric: "${identity}"`,
+        };
+    }
+    if (!isValidDomainName(domain)) {
+        return {
+            ok: false,
+            error: `invalid domain, : "${domain}"`,
+        };
+    }
+    return {
+        ok: true,
+        route: { identity, domain, wallet_type, wallet_slot },
+    };
+}

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;
     }
     /**