@spirobel/monero-wallet-api 0.5.5 → 0.6.1

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

@@ -1,4 +1,4 @@
-import { sleep, ViewPair } from "../../api";
+import { sleep, ViewPair } from "../../xmr3";
 import { log } from "../../io/logging";
 import {} from "../scanresult/scanLoop";
 /**

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

@@ -1,4 +1,4 @@
-import { DistributedKeyGenerator, type DkgParticipateParams, type DkgVerifyParams } from "../../api";
+import { DistributedKeyGenerator, type DkgParticipateParams, type DkgVerifyParams } from "../../xmr3";
 export type MultiSigParticipateCall = {
     type: "multisig-call";
     functionName: "participate";

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

@@ -1,4 +1,4 @@
-import { DistributedKeyGenerator, } from "../../api";
+import { DistributedKeyGenerator, } from "../../xmr3";
 import { log } from "../../io/logging";
 export function multisigMainWorkerCall(msg, dkg) {
     if (!dkg) {

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

@@ -2,7 +2,7 @@ import { coordinatorMainWorker, requestCoordinatorShutdown, } from "./coordinato
 import { handleCpuboundScanTry, sendFromCpuWorker } from "./cpubound-main";
 import { log, setupLoggingPath } from "../../io/logging";
 import { multisigMainWorkerCall } from "./multisig-main";
-import { DistributedKeyGenerator, SCAN_SETTINGS_STORE_NAME_DEFAULT, } from "../../api";
+import { DistributedKeyGenerator, SCAN_SETTINGS_STORE_NAME_DEFAULT, } from "../../xmr3";
 self.onerror = (e) => self.postMessage({ type: "ERROR", payload: e });
 self.addEventListener("unhandledrejection", (e) => self.postMessage({ type: "ERROR", payload: e.reason }));
 let SCAN_SETTINGS_PATH;

package/dist/scansettings/scanSettings.js

@@ -1,4 +1,4 @@
-import { get_info } from "../api";
+import { get_info } from "../xmr3";
 import { atomicWrite } from "../io/atomicWrite";
 import { refreshEnvIndexedDB } from "../io/indexedDB";
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";

package/dist/scansettings/scanSettingsOpened.d.ts

@@ -1,5 +1,5 @@
 import { type LogSetting, type PossibleLogs } from "../io/logging";
-import { type ScanSetting, type ScanSettingOpened } from "../api";
+import { type ScanSetting, type ScanSettingOpened } from "../xmr3";
 export declare class ScanSettingsOpened {
     private _scan_settings_path;
     private _pathPrefix;

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, parseAddress, 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 "../xmr3";
 export class ScanSettingsOpened {
     _scan_settings_path;
     _pathPrefix;

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

@@ -1,4 +1,4 @@
-import type { GetOutsResponseBuffer, NodeUrl, Output } from "../api";
+import type { GetOutsResponseBuffer, NodeUrl, Output } from "../xmr3";
 import type { SampledDecoys } from "./transactionBuilding";
 export type Payment = {
     address: string;

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

@@ -1,4 +1,4 @@
-import type { GetFeeEstimateResult, Output } from "../api";
+import type { GetFeeEstimateResult, Output } from "../xmr3";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 export type Input = string;
 export type UnsignedTransaction = string;

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
+    }
+}

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

@@ -0,0 +1,64 @@
+import { type PortMessageByKind, type ToolArm } from "../globals";
+export type CreateAndShareViewOnlyWalletTool = {
+    tool_id: "002";
+    payload: CreateAndShareViewOnlyWalletToolPayload;
+};
+export type CreateAndShareViewOnlyWalletToolPayload = {
+    wallet_slot: number;
+};
+export type ShareViewkeyPayload = PortMessageByKind["shareViewkey"];
+export type ShareViewkeyResult = {
+    ok: boolean;
+    successUrl: string | null;
+    error?: string;
+};
+export type ShareViewkey002Pruned = {
+    viewkey: string;
+    primary_address: string;
+    wallet_slot: number;
+};
+/** mco surface used to save view wallet on share success */
+export type ShareViewMco = {
+    wallets: {
+        primary_address: string;
+        wallet_slot?: number;
+        wallet_name?: string;
+    }[];
+    addViewWallet: (primary_address: string, view_key: string, fields?: {
+        wallet_name?: string;
+        wallet_slot?: number;
+    }) => Promise<void>;
+    setWalletName: (primary_address: string, name?: string) => Promise<void>;
+    setWalletSlot: (primary_address: string, slot?: number) => Promise<void>;
+};
+export type HandleShareOpts = {
+    successUrl?: string;
+};
+declare function execute_route(mco: ShareViewMco, opts?: HandleShareOpts): (req: Request) => Promise<Response>;
+export type FailedShareViewRestore = {
+    viewkey: string;
+    primary_address: string;
+    error?: 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;
+            };
+        };
+    };
+};
+type Tool002CounterpartyExtra = {
+    execute_route: typeof execute_route;
+};
+declare const tool002: ToolArm<CreateAndShareViewOnlyWalletToolPayload, Tool002CounterpartyExtra>;
+export default tool002;