@spirobel/monero-wallet-api 0.5.4 → 0.6.0

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,9 +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) {
+        // 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.js

@@ -14,8 +14,9 @@ export async function handleCpuboundScan(msg, cpu_worker_status) {
         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));
@@ -89,7 +90,7 @@ export async function handleCpuboundScan(msg, cpu_worker_status) {
         if (cpu_worker_status.cancel) {
             cpu_worker_status.cancel = false;
             log("handleCpuboundScan", ["cpu work canceled"]);
-            return { type: "Ready" };
+            return { type: "Canceled", work_uuid: item.work_uuid };
         }
         await sleep(10); // make sure the loop is not tight
     }

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";
@@ -9,21 +9,32 @@ 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") {
-        cpu_worker_status.cancel = true;
+        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, 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;
@@ -33,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/tools/calls/001.d.ts

@@ -0,0 +1,20 @@
+import { type ToolArm } from "../globals";
+export type SendTransactionTool = {
+    tool_id: "001";
+    payload: SendTransactionToolPayload;
+};
+export type SendTransactionToolPayload = {
+    address: string;
+    amount: string;
+    no_check: boolean;
+};
+export type IsPayAddressKnown = (address: string) => boolean | Promise<boolean>;
+declare function validate_route(deps: {
+    isPayAddressKnown: IsPayAddressKnown;
+}): (req: Request) => Promise<Response>;
+export declare function amountForChainSend(amount: string): string;
+type Tool001CounterpartyExtra = {
+    validate_route: typeof validate_route;
+};
+declare const tool001: ToolArm<SendTransactionToolPayload, Tool001CounterpartyExtra>;
+export default tool001;

package/dist/tools/calls/001.js

@@ -0,0 +1,236 @@
+import { convertAmountBigInt, convertAmountBigIntThrows, } from "../../send-functionality/conversion";
+import { TOOL_MAGIC_STRING, } from "../globals";
+function recognize_parse(args) {
+    const amount = args[1];
+    const address = args[3];
+    // trailing _no_check splits into ["no", "check"] after underscore split
+    const no_check = args.length >= 6 &&
+        args[args.length - 2] === "no" &&
+        args[args.length - 1] === "check";
+    try {
+        convertAmountBigIntThrows(amount);
+    }
+    catch {
+        return null;
+    }
+    if (address && amount) {
+        return {
+            tool_id: "001",
+            payload: { address, amount, no_check },
+        };
+    }
+    return null;
+}
+function make(payload) {
+    convertAmountBigIntThrows(payload.amount);
+    const base = `${TOOL_MAGIC_STRING}001_amount_${payload.amount}_address_${payload.address}`;
+    return payload.no_check ? `${base}_no_check` : base;
+}
+async function validate_check(invo) {
+    const tool = invo.tool;
+    if (tool.tool_id !== "001")
+        return "unverified";
+    if (tool.payload.no_check)
+        return "unverified";
+    const link = invo[invo.found_in];
+    const invo_link = new URL(link);
+    const checkUrl = `${invo_link.origin}/monerochan001/${tool.payload.address}`;
+    try {
+        const result = (await (await fetch(checkUrl)).json());
+        if (result &&
+            typeof result === "object" &&
+            "valid_address" in result &&
+            result.valid_address === true) {
+            return "valid";
+        }
+        return "invalid";
+    }
+    catch {
+        return "invalid";
+    }
+}
+const ADDRESS_VALID_RESPONSE = {
+    valid_address: true,
+};
+const ADDRESS_INVALID_RESPONSE = {
+    valid_address: false,
+};
+function addressFromMonerochan001Req(req) {
+    const r = req;
+    if (r.params?.address)
+        return decodeURIComponent(r.params.address);
+    const m = new URL(req.url).pathname.match(/monerochan001\/([^/]+)\/?$/);
+    return m?.[1] ? decodeURIComponent(m[1]) : "";
+}
+async function handleAddressCheck(req, deps) {
+    const address = addressFromMonerochan001Req(req);
+    if (!address)
+        return Response.json(ADDRESS_INVALID_RESPONSE);
+    const known = await deps.isPayAddressKnown(address);
+    return Response.json(known ? ADDRESS_VALID_RESPONSE : ADDRESS_INVALID_RESPONSE);
+}
+function validate_route(deps) {
+    return (req) => handleAddressCheck(req, deps);
+}
+function flatFromParsed(invo) {
+    const p = invo.tool.payload;
+    return {
+        invocationId: invo.invocation_id,
+        toolId: "001",
+        amount: p.amount,
+        address: p.address,
+        no_check: p.no_check,
+        context_domain: invo.context_domain,
+        destination_domain: invo.destination_domain,
+        context_href: invo.context_href,
+        found_in: invo.found_in,
+        link: invo.link,
+        linkText: invo.linkText,
+    };
+}
+/** first toolCall state transition: session_start invoked. */
+async function invoke_write(ctx, invo) {
+    if (invo.tool.tool_id !== "001")
+        return;
+    const flat = flatFromParsed(invo);
+    await ctx.log.append({
+        type: "session_start",
+        stage: "invoked",
+        ...flat,
+    });
+}
+/** second toolCall state transition: validate_result validated. */
+async function validate_write(ctx, invo) {
+    if (invo.tool.tool_id !== "001")
+        return;
+    const flat = flatFromParsed(invo);
+    await ctx.log.append({
+        type: "validate_result",
+        stage: "validated",
+        ...flat,
+        valid: invo.valid,
+    });
+}
+export function amountForChainSend(amount) {
+    return convertAmountBigInt(amount).toString();
+}
+function alreadyAccepted(type) {
+    return (type === "accept" ||
+        type === "execute_start" ||
+        type === "execute_error" ||
+        type === "execute_result" ||
+        type === "dismiss" ||
+        type === "aborted");
+}
+/** third toolCall state transition: accept accepted. */
+async function accept_yes(ctx, invocationId, args) {
+    const invo = await ctx.log.invocation(invocationId);
+    if (!invo || alreadyAccepted(invo.lastType))
+        return;
+    const address = String(args.address ?? invo.address ?? "");
+    const amount = String(args.amount ?? invo.amount ?? "");
+    const wallet_to_send_from_pa = String(args.wallet_to_send_from_pa ?? "");
+    await ctx.log.append({
+        type: "accept",
+        stage: "accepted",
+        invocationId,
+        toolId: "001",
+        address,
+        amount,
+        wallet_to_send_from_pa,
+    });
+}
+/** fourth toolCall state transition: execute_start executed. fifth: execute_result executed. */
+async function execute_run(ctx, invocationId, args) {
+    const invo = await ctx.log.invocation(invocationId);
+    if (!invo) {
+        console.error("send with no invocation");
+        return;
+    }
+    const address = String(args.address ?? invo.address ?? "");
+    const amount = String(args.amount ?? invo.amount ?? "");
+    const wallet_to_send_from_pa = String(args.wallet_to_send_from_pa ?? invo.wallet_to_send_from_pa ?? "");
+    const toolId = "001";
+    await ctx.log.append({
+        type: "execute_start",
+        stage: "executed",
+        invocationId,
+        toolId,
+        address,
+        amount,
+        wallet_to_send_from_pa,
+    });
+    let ok = false;
+    let error;
+    try {
+        const wallets = ctx.getWallets?.();
+        const wallet = wallets?.wallets?.find((w) => w.primary_address === wallet_to_send_from_pa);
+        if (!wallet)
+            throw new Error("wallet not found");
+        await wallet.makeSignSendTransaction({
+            payments: [{ address, amount: amountForChainSend(amount) }],
+            invocationId,
+        });
+        ok = true;
+    }
+    catch (e) {
+        console.error(e);
+        ok = false;
+        error = e instanceof Error ? e.message : String(e);
+    }
+    await ctx.log.append({
+        type: "execute_result",
+        stage: "executed",
+        invocationId,
+        toolId,
+        ok,
+        ...(error ? { error } : {}),
+        address,
+        amount,
+        wallet_to_send_from_pa,
+    });
+}
+/** toolCall state transition: dismiss accepted. */
+async function accept_no(ctx, invocationId) {
+    const invo = await ctx.log.invocation(invocationId);
+    // once the user accepted, execution is in flight. a late dismiss (the send
+    // plate clears the form right after execute) must not flip the entry to dismissed
+    if (!invo ||
+        invo.lastType === "dismiss" ||
+        invo.lastType === "accept" ||
+        invo.lastType === "execute_start" ||
+        invo.lastType === "execute_result" ||
+        invo.lastType === "aborted") {
+        return;
+    }
+    await ctx.log.append({
+        type: "dismiss",
+        stage: "accepted",
+        invocationId,
+        toolId: "001",
+    });
+}
+const tool001 = {
+    permissions: ["spend"],
+    ui: {
+        openTitle: "payment link",
+        acceptLabel: "SEND",
+        dismissLabel: "DISMISS",
+    },
+    content: {
+        recognize_parse,
+        validate_check,
+    },
+    worker: {
+        invoke_write,
+        validate_write,
+        accept_yes,
+        accept_no,
+        execute_run,
+    },
+    counterparty: {
+        make,
+        validate_route,
+    },
+};
+export default tool001;

package/dist/tools/calls/002-content.d.ts

@@ -0,0 +1,46 @@
+/**
+ * content-script-safe 002 surface (no scansettings / atomicWrite / indexedDB).
+ */
+import { type ToolInvocationValidity } from "../globals";
+import type { ToolInvocationForValidate } from "../toolArm";
+export type CreateAndShareViewOnlyWalletTool = {
+    tool_id: "002";
+    payload: CreateAndShareViewOnlyWalletToolPayload;
+};
+export type CreateAndShareViewOnlyWalletToolPayload = {
+    wallet_slot: number;
+};
+export declare function parseCreateAndShareViewOnlyWalletToolArgs(args: string[]): CreateAndShareViewOnlyWalletTool | null;
+export declare function createCreateAndShareViewOnlyWalletToolLink(wallet_slot?: number): string;
+export declare function make002ToolLink(wallet_slot?: number): string;
+export declare function makeFromPayload(payload: CreateAndShareViewOnlyWalletToolPayload): string;
+export declare function validate(invo: ToolInvocationForValidate): ToolInvocationValidity;
+export type ShareViewkeyPayload = {
+    viewkey: string;
+    primary_address: string;
+    tool_invo: {
+        tool: {
+            tool_id: string;
+            payload: {
+                wallet_slot: number;
+            };
+        };
+        found_in: "link" | "linkText";
+        link: string;
+        linkText: string;
+        valid: ToolInvocationValidity;
+    };
+};
+export type ShareViewkeyResult = {
+    ok: boolean;
+    successUrl: string | null;
+    error?: string;
+};
+export type ShareViewkey002Pruned = {
+    viewkey: string;
+    primary_address: string;
+    wallet_slot: number;
+};
+export declare function shareViewKey002(payload: ShareViewkeyPayload): Promise<ShareViewkeyResult>;
+export declare function potentialSuccessRedirect002(payload: ShareViewkeyPayload): Promise<ShareViewkeyResult | undefined>;
+export declare function afterValidate(invo: ToolInvocationForValidate): void;

package/dist/tools/calls/002-content.js

@@ -0,0 +1,135 @@
+/**
+ * content-script-safe 002 surface (no scansettings / atomicWrite / indexedDB).
+ */
+import { TOOL_MAGIC_STRING, } from "../globals";
+export function parseCreateAndShareViewOnlyWalletToolArgs(args) {
+    const wallet_slot = args[5];
+    if (wallet_slot && !isNaN(parseInt(wallet_slot))) {
+        return {
+            tool_id: "002",
+            payload: {
+                wallet_slot: parseInt(wallet_slot),
+            },
+        };
+    }
+    return null;
+}
+export function createCreateAndShareViewOnlyWalletToolLink(wallet_slot) {
+    wallet_slot = Number(wallet_slot) || 0;
+    return `${TOOL_MAGIC_STRING}002_create_and_share_viewkey_slot_${wallet_slot}`;
+}
+export function make002ToolLink(wallet_slot) {
+    return createCreateAndShareViewOnlyWalletToolLink(wallet_slot);
+}
+export function makeFromPayload(payload) {
+    return createCreateAndShareViewOnlyWalletToolLink(payload.wallet_slot);
+}
+export function validate(invo) {
+    if (invo.tool.tool_id !== "002")
+        return "unverified";
+    if (invo.context_domain == invo.destination_domain)
+        return "valid";
+    return "invalid";
+}
+export async function shareViewKey002(payload) {
+    const invo = payload.tool_invo;
+    if (invo.tool.tool_id !== "002")
+        return {
+            ok: false,
+            successUrl: null,
+        };
+    if (invo.valid !== "valid")
+        return {
+            ok: false,
+            successUrl: null,
+        };
+    const link = invo[invo.found_in];
+    const invo_link = new URL(link);
+    const shareVKUrl = `${invo_link.origin}/monerochan002/`;
+    try {
+        const result = await fetch(shareVKUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                viewkey: payload.viewkey,
+                primary_address: payload.primary_address,
+                wallet_slot: invo.tool.payload.wallet_slot,
+            }),
+        });
+        if (result.ok) {
+            const data = (await result.json());
+            if (data && typeof data === "object" && "ok" in data && data.ok === true) {
+                return {
+                    ok: true,
+                    successUrl: data.successUrl ?? null,
+                };
+            }
+            return {
+                ok: false,
+                successUrl: null,
+                error: "counterparty rejected share",
+            };
+        }
+        return {
+            ok: false,
+            successUrl: null,
+            error: `share post failed ${result.status}`,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            successUrl: null,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+export async function potentialSuccessRedirect002(payload) {
+    const shareVKresult = await shareViewKey002(payload);
+    if (shareVKresult.ok && shareVKresult.successUrl) {
+        window.location.href = shareVKresult.successUrl;
+        window.location.reload();
+    }
+    else {
+        return shareVKresult;
+    }
+}
+export function afterValidate(invo) {
+    const g = globalThis;
+    const rt = g.browser?.runtime ?? g.chrome?.runtime;
+    if (!rt)
+        return;
+    const port = rt.connect({ name: invo.invocation_id });
+    port.onMessage.addListener((msg) => {
+        const m = msg;
+        const k = m.kind ?? m.type;
+        if (k !== "shareViewkey" || !m.payload)
+            return;
+        void (async () => {
+            try {
+                const result = await potentialSuccessRedirect002(m.payload);
+                if (result) {
+                    rt.sendMessage({
+                        kind: "shareViewkeyFAILED",
+                        payload: { ...m.payload, error: result.error },
+                    }).catch(() => { });
+                }
+                else {
+                    rt.sendMessage({
+                        kind: "shareViewkeyOK",
+                        payload: { invocationId: invo.invocation_id },
+                    }).catch(() => { });
+                }
+            }
+            catch (e) {
+                rt.sendMessage({
+                    kind: "shareViewkeyFAILED",
+                    payload: {
+                        ...m.payload,
+                        error: e instanceof Error ? e.message : String(e),
+                    },
+                }).catch(() => { });
+            }
+        })();
+    });
+}

package/dist/tools/calls/002-fail-cleanup.d.ts

@@ -0,0 +1,27 @@
+/** tool-owned path; host must not hardcode this name */
+export declare const FAILED_SHARE_VIEW_RESTORE_PATH = "failed_share_view_restore.json";
+export type FailedShareViewRestore = {
+    viewkey: string;
+    primary_address: string;
+    tool_invo: {
+        invocation_id: string;
+        context_domain: string;
+        context_href: string;
+        destination_domain: string;
+        found_in: "link" | "linkText";
+        link: string;
+        linkText: string;
+        timestamp: number;
+        valid: "valid" | "invalid" | "unverified";
+        tool: {
+            tool_id: string;
+            payload: {
+                wallet_slot?: number;
+            };
+        };
+    };
+};
+export declare function readFailedShareViewRestore(): Promise<FailedShareViewRestore | null>;
+export declare function clearFailedShareViewRestore(): Promise<void>;
+export declare function removeWalletAfterShareFail(primary_address: string): Promise<void>;
+export declare function persistFailedShareViewRestore(payload: FailedShareViewRestore): Promise<void>;

package/dist/tools/calls/002-fail-cleanup.js

@@ -0,0 +1,60 @@
+import { atomicWrite } from "../../io/atomicWrite";
+import { writeScanSettingsFileDefaultLocation } from "../../scansettings/scanSettings";
+/** tool-owned path; host must not hardcode this name */
+export const FAILED_SHARE_VIEW_RESTORE_PATH = "failed_share_view_restore.json";
+const LEGACY_FAILED_SHARE_VIEW_RESTORE_PATH = "failed_wallet_restore_002.json";
+export async function readFailedShareViewRestore() {
+    for (const path of [
+        FAILED_SHARE_VIEW_RESTORE_PATH,
+        LEGACY_FAILED_SHARE_VIEW_RESTORE_PATH,
+    ]) {
+        try {
+            const text = await Bun.file(path).text().catch(() => undefined);
+            if (!text)
+                continue;
+            return JSON.parse(text);
+        }
+        catch {
+            // try next path
+        }
+    }
+    return null;
+}
+export async function clearFailedShareViewRestore() {
+    for (const path of [
+        FAILED_SHARE_VIEW_RESTORE_PATH,
+        LEGACY_FAILED_SHARE_VIEW_RESTORE_PATH,
+    ]) {
+        try {
+            await Bun.file(path).delete();
+        }
+        catch {
+            // missing
+        }
+    }
+}
+export async function removeWalletAfterShareFail(primary_address) {
+    await writeScanSettingsFileDefaultLocation({
+        async writeCallback(settings) {
+            const matching = settings.wallets.find((w) => w.primary_address === primary_address);
+            if (matching) {
+                await Bun.file(`${matching.primary_address}_cache.json`)
+                    .delete()
+                    .catch(() => { });
+                await Bun.file(`${matching.primary_address}_stats.json`)
+                    .delete()
+                    .catch(() => { });
+            }
+            settings.wallets = settings.wallets.filter((w) => w.primary_address !== primary_address);
+        },
+    });
+}
+export async function persistFailedShareViewRestore(payload) {
+    await atomicWrite(FAILED_SHARE_VIEW_RESTORE_PATH, JSON.stringify(payload, null, 2));
+    try {
+        await Bun.file(LEGACY_FAILED_SHARE_VIEW_RESTORE_PATH).delete();
+    }
+    catch {
+        // missing
+    }
+}