@spirobel/monero-wallet-api 0.5.4 → 0.6.0

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;

package/dist/tools/calls/002.js

@@ -0,0 +1,353 @@
+import { getExtensionRuntime, sendToBackground, sendToPort, TOOL_MAGIC_STRING, } from "../globals";
+function recognize_parse(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;
+}
+function make(payload) {
+    const wallet_slot = Number(payload.wallet_slot) || 0;
+    return `${TOOL_MAGIC_STRING}002_create_and_share_viewkey_slot_${wallet_slot}`;
+}
+/** valid if both domains are the same. */
+function validate_check(invo) {
+    if (invo.tool.tool_id !== "002")
+        return "unverified";
+    if (invo.context_domain == invo.destination_domain)
+        return "valid";
+    return "invalid";
+}
+/** posts the viewkey. the invocation must be valid. */
+async function shareViewKey002(payload) {
+    const invo = payload.tool_invo;
+    if (invo.tool.tool_id !== "002")
+        return { ok: false, successUrl: null, error: "not 002" };
+    if (invo.valid !== "valid")
+        return { ok: false, successUrl: null, error: "invocation not valid" };
+    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" || data.ok !== true) {
+                return {
+                    ok: false,
+                    successUrl: null,
+                    error: "counterparty rejected share",
+                };
+            }
+            const successUrl = typeof data.successUrl === "string" && data.successUrl.length
+                ? data.successUrl
+                : null;
+            return { ok: true, successUrl };
+        }
+        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),
+        };
+    }
+}
+async function potentialSuccessRedirect002(payload) {
+    const shareVKresult = await shareViewKey002(payload);
+    if (shareVKresult.ok) {
+        if (shareVKresult.successUrl) {
+            window.location.href = shareVKresult.successUrl;
+            window.location.reload();
+        }
+        return;
+    }
+    return shareVKresult;
+}
+function execute_deliver(invo) {
+    const rt = getExtensionRuntime();
+    if (!rt)
+        return;
+    const port = rt.connect({ name: invo.invocation_id });
+    port.onMessage.addListener((msg) => {
+        const m = msg;
+        if (m.kind !== "shareViewkey" || !m.payload)
+            return;
+        const payload = m.payload;
+        void (async () => {
+            try {
+                const result = await potentialSuccessRedirect002(payload);
+                if (result) {
+                    void sendToBackground("shareViewkeyFAILED", {
+                        ...payload,
+                        error: result.error,
+                    }).catch(() => { });
+                }
+                else {
+                    void sendToBackground("shareViewkeyOK", {
+                        invocationId: invo.invocation_id,
+                    }).catch(() => { });
+                }
+            }
+            catch (e) {
+                void sendToBackground("shareViewkeyFAILED", {
+                    ...payload,
+                    error: e instanceof Error ? e.message : String(e),
+                }).catch(() => { });
+            }
+        })();
+    });
+}
+async function handle002ShareRequest(req, wallets, parsed_cb, successUrl) {
+    try {
+        const json_body = await req.json();
+        const { viewkey, primary_address, wallet_slot } = json_body;
+        if (typeof viewkey !== "string" ||
+            viewkey.trim().length === 0 ||
+            typeof primary_address !== "string" ||
+            primary_address.trim().length === 0 ||
+            typeof wallet_slot !== "number") {
+            return { ok: false, successUrl: null };
+        }
+        const foundSlot = wallets.find((wallet) => wallet.wallet_slot === wallet_slot);
+        if (foundSlot) {
+            if (foundSlot.primary_address !== primary_address) {
+                return { ok: false, successUrl: null };
+            }
+        }
+        await parsed_cb({ viewkey, primary_address, wallet_slot });
+        return {
+            ok: true,
+            successUrl: successUrl ?? null,
+        };
+    }
+    catch {
+        return { ok: false, successUrl: null };
+    }
+}
+async function handleShare(req, mco, opts) {
+    const res = await handle002ShareRequest(req, mco.wallets, async ({ primary_address, viewkey, wallet_slot }) => {
+        const pa = primary_address.trim();
+        const vk = viewkey.trim();
+        const existing = mco.wallets.find((w) => w.primary_address === pa);
+        const wallet_name = existing?.wallet_name ?? "unnamed wallet " + wallet_slot;
+        if (existing) {
+            await mco.setWalletName(pa, wallet_name);
+            await mco.setWalletSlot(pa, wallet_slot);
+        }
+        else {
+            await mco.addViewWallet(pa, vk, { wallet_name, wallet_slot });
+        }
+    }, opts?.successUrl);
+    return Response.json(res);
+}
+function execute_route(mco, opts) {
+    return (req) => handleShare(req, mco, opts);
+}
+function flatFromParsed(invo) {
+    const p = invo.tool.payload;
+    return {
+        invocationId: invo.invocation_id,
+        toolId: "002",
+        wallet_slot: p.wallet_slot,
+        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 !== "002")
+        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 !== "002")
+        return;
+    const flat = flatFromParsed(invo);
+    await ctx.log.append({
+        type: "validate_result",
+        stage: "validated",
+        ...flat,
+        valid: invo.valid,
+    });
+}
+function alreadyAccepted(type) {
+    return (type === "accept" ||
+        type === "execute_start" ||
+        type === "execute_error" ||
+        type === "execute_result" ||
+        type === "dismiss" ||
+        type === "aborted");
+}
+function isTerminalTipType(type) {
+    // accept and execute_start count as terminal for dismiss: the user accepted,
+    // execution is in flight, a late dismiss must not flip the entry
+    return (type === "dismiss" ||
+        type === "accept" ||
+        type === "execute_start" ||
+        type === "execute_result" ||
+        type === "aborted");
+}
+/** the content payload from this invocation. missing valid is unverified. */
+function invoFromOpen(invocationId, open) {
+    return {
+        tool: {
+            tool_id: "002",
+            payload: { wallet_slot: open.wallet_slot ?? 0 },
+        },
+        destination_domain: open.destination_domain ?? "",
+        context_domain: open.context_domain ?? "",
+        found_in: open.found_in ?? "link",
+        link: open.link ?? "",
+        linkText: open.linkText ?? "",
+        timestamp: Date.now(),
+        invocation_id: invocationId,
+        context_href: open.context_href ?? "",
+        valid: open.valid ?? "unverified",
+    };
+}
+/** 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 open = ctx.log.invocations("active").find((o) => o.invocationId === invocationId) ?? null;
+    if (!open)
+        return;
+    await ctx.log.append({
+        type: "accept",
+        stage: "accepted",
+        ...flatFromParsed(invoFromOpen(invocationId, open)),
+    });
+}
+/** fourth toolCall state transition: execute_start executed. execute_error executed if no port. */
+async function execute_run(ctx, invocationId, args) {
+    const open = ctx.log.invocations("active").find((o) => o.invocationId === invocationId) ?? null;
+    if (!open)
+        return;
+    const tool_invo = invoFromOpen(invocationId, open);
+    const flat = flatFromParsed(tool_invo);
+    const port = ctx.getPort(invocationId);
+    if (!port) {
+        await ctx.log.append({
+            type: "execute_error",
+            stage: "executed",
+            ...flat,
+            ok: false,
+            error: "no content script port",
+        });
+        return;
+    }
+    sendToPort(port, "shareViewkey", {
+        viewkey: String(args.viewkey ?? ""),
+        primary_address: String(args.primary_address ?? ""),
+        tool_invo,
+    });
+    await ctx.log.append({
+        type: "execute_start",
+        stage: "executed",
+        ...flat,
+    });
+}
+/** fifth toolCall state transition: execute_error executed. */
+async function execute_fail(ctx, payload) {
+    const p = payload;
+    await ctx.log.append({
+        type: "execute_error",
+        stage: "executed",
+        ...flatFromParsed(p.tool_invo),
+        ok: false,
+        error: p.error ?? "share failed",
+    });
+}
+/** fifth toolCall state transition: execute_result executed. */
+async function execute_ok(ctx, payload) {
+    const invo = await ctx.log.invocation(payload.invocationId);
+    if (!invo)
+        return;
+    await ctx.log.append({
+        type: "execute_result",
+        stage: "executed",
+        invocationId: payload.invocationId,
+        toolId: "002",
+        ok: true,
+    });
+}
+/** toolCall state transition: dismiss accepted. */
+async function accept_no(ctx, invocationId) {
+    const invo = await ctx.log.invocation(invocationId);
+    if (!invo || isTerminalTipType(invo.lastType))
+        return;
+    await ctx.log.append({
+        type: "dismiss",
+        stage: "accepted",
+        invocationId,
+        toolId: "002",
+    });
+}
+/** toolCall state transition: aborted. */
+async function execute_abort(ctx, invocationId) {
+    const invo = await ctx.log.invocation(invocationId);
+    if (!invo || isTerminalTipType(invo.lastType))
+        return;
+    await ctx.log.append({
+        type: "aborted",
+        stage: invo.stage,
+        invocationId,
+        toolId: "002",
+    });
+}
+const tool002 = {
+    permissions: ["share_view"],
+    ui: {
+        openTitle: "view-only wallet share",
+        acceptLabel: "ACCEPT",
+        dismissLabel: "DISMISS",
+    },
+    content: {
+        recognize_parse,
+        validate_check,
+        execute_deliver,
+    },
+    worker: {
+        invoke_write,
+        validate_write,
+        accept_yes,
+        accept_no,
+        execute_run,
+        execute_abort,
+        execute_ok,
+        execute_fail,
+    },
+    counterparty: {
+        make,
+        execute_route,
+    },
+};
+export default tool002;

package/dist/tools/content.d.ts

@@ -0,0 +1,22 @@
+type ExtensionRuntime = {
+    sendMessage: (msg: unknown) => Promise<unknown>;
+    connect: (info: {
+        name: string;
+    }) => {
+        onMessage: {
+            addListener: (cb: (msg: unknown) => void) => void;
+        };
+    };
+};
+type ExtensionBrowser = {
+    runtime: ExtensionRuntime;
+};
+declare global {
+    var browser: ExtensionBrowser;
+    var chrome: ExtensionBrowser;
+}
+/** send toolCall and openSidebar to worker. after the check, toolCall message to worker again to persist validity status,
+ * potential second round of communication with backend. */
+export declare function interceptToolLinkCallback(e: Event): void;
+export declare function installToolLinkEventInterception(): void;
+export {};

package/dist/tools/content.js

@@ -0,0 +1,41 @@
+// do not import api.ts (indexedDB top-level await). tools/monero-tools.ts is 001+002 only.
+import { checkToolInvocationValidity, parseToolInvocation, tools, } from "./monero-tools";
+import { sendToBackground } from "./globals";
+if (typeof chrome !== "undefined" && typeof browser === "undefined") {
+    globalThis.browser = chrome;
+}
+function processTargetLink(element) {
+    if (!element || element.tagName !== "A")
+        return false;
+    const href = element.href || element.getAttribute("href") || "";
+    const text = element.textContent || element.innerText || "";
+    //invo id created here 
+    return parseToolInvocation(href, text, location);
+}
+/** send toolCall and openSidebar to worker. after the check, toolCall message to worker again to persist validity status,
+ * potential second round of communication with backend. */
+export function interceptToolLinkCallback(e) {
+    if (!(e.target instanceof Element))
+        return;
+    const link = e.target.closest("a");
+    const monerotoolLink = processTargetLink(link);
+    if (!link || !monerotoolLink)
+        return;
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    void sendToBackground("toolCall", monerotoolLink).catch(() => { });
+    void sendToBackground("openSidebar", null).catch(() => { });
+    checkToolInvocationValidity(monerotoolLink).then((result) => {
+        monerotoolLink.valid = result;
+        // save validity status, invo id still the same so event added to this same invo id
+        void sendToBackground("toolCall", monerotoolLink).catch(() => { });
+        const id = monerotoolLink.tool.tool_id;
+        // if there is a second stage communication with the backend it happens here via the message port (same tab / circuit compartmentalization)
+        tools[id]?.content.execute_deliver?.(monerotoolLink);
+    });
+}
+export function installToolLinkEventInterception() {
+    document.addEventListener("click", interceptToolLinkCallback, true);
+    document.addEventListener("touchend", interceptToolLinkCallback, true);
+    document.addEventListener("keydown", interceptToolLinkCallback, true);
+}

package/dist/tools/counterparty.d.ts

@@ -0,0 +1,3 @@
+export { tools, createToolLink, TOOL_IDS, type ToolId } from "./monero-tools";
+export type { IsPayAddressKnown } from "./calls/001";
+export type { ShareViewMco, HandleShareOpts } from "./calls/002";

package/dist/tools/counterparty.js

@@ -0,0 +1 @@
+export { tools, createToolLink, TOOL_IDS } from "./monero-tools";

package/dist/tools/download-public-suffix.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/download-public-suffix.js

@@ -0,0 +1,20 @@
+const listUrl = "https://publicsuffix.org/list/public_suffix_list.dat";
+const outPath = new URL("./public-suffix-list.ts", import.meta.url);
+const response = await fetch(listUrl);
+if (!response.ok) {
+    throw new Error(`download failed: ${response.status}`);
+}
+const rules = [];
+for (const raw of (await response.text()).split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("//"))
+        continue;
+    if (line.includes("===BEGIN"))
+        continue;
+    rules.push(line);
+}
+const body = rules.map((rule) => `  ${JSON.stringify(rule)},`).join("\n");
+const source = `// generated by download-public-suffix.ts\nexport const publicSuffixRules = [\n${body}\n] as const;\n`;
+await Bun.write(outPath, source);
+console.log(`${rules.length} rules -> ${outPath.pathname}`);
+export {};