@spirobel/monero-wallet-api 0.5.4 → 0.6.0

package/dist/actionlog/actionLogOpened.d.ts

@@ -1 +1,96 @@
-export {};
+import { type ActionLogBackend, type ActionLogEvent, type InvocationState, type InvocationStatus, type ToolPermission } from "./actionLogTypes";
+import type { ParsedMoneroToolInvocation } from "../tools/monero-tools";
+import { type ExtensionPort, type ToolNotice } from "../tools/globals";
+export type ActionLogBackendKind = "sqlite" | "idb";
+export type ExtensionMessageBus = "worker" | "ui";
+export type ActionLogOpenedCreateOptions = {
+    path?: string;
+    backend?: ActionLogBackendKind;
+    backendInstance?: ActionLogBackend;
+    onChange?: (() => void) | null;
+    extensionMessageBus?: ExtensionMessageBus;
+};
+type BoundMco = {
+    feed: (params: any) => Promise<void>;
+    wallets?: unknown;
+    changeNodeUrl: (node_url: string) => Promise<void>;
+    changeStartHeight: (start_height: number | null) => Promise<void>;
+    changeNodeUrlAndStartHeight: (node_url?: string, start_height?: number | null) => Promise<void>;
+    buildWallets: () => Promise<void>;
+    stopWorker: () => Promise<void>;
+    makeSignSend: (params: {
+        primary_address: string;
+        payments: {
+            address: string;
+            amount: string;
+        }[];
+        input_indexes: string[];
+    }) => Promise<unknown>;
+    sweepSignSend: (params: {
+        primary_address: string;
+        address: string;
+        input_indexes: string[];
+    }) => Promise<unknown>;
+    rebroadcastTx: (params: {
+        primary_address: string;
+        tx_log_index: number;
+    }) => Promise<unknown>;
+    dismissSendPlate: (params: {
+        primary_address: string;
+    }) => Promise<unknown>;
+    setLogSettings: (logs?: "console" | "file" | "console-and-file" | "off" | null, logs_include?: string[] | null, logs_exclude?: string[] | null) => Promise<unknown>;
+};
+export declare class ActionLogOpened {
+    private backend;
+    private _onChange;
+    private ports;
+    private runtimeInstalled;
+    private bus;
+    private mco;
+    private invocationsCache;
+    private activeCache;
+    private noticeList;
+    private toolCallTail;
+    private constructor();
+    static create(options?: ActionLogOpenedCreateOptions): Promise<ActionLogOpened>;
+    setOnChange(cb: (() => void) | null): void;
+    bindMco(mco: BoundMco): void;
+    /** after a write, the invocation lists that the plates read. */
+    private refreshUiCache;
+    private toolCtx;
+    get extensionMessageBus(): ExtensionMessageBus | null;
+    private isUiBus;
+    private broadcastActionLogChanged;
+    append(partial: Omit<ActionLogEvent, "id" | "timestamp"> & Partial<Pick<ActionLogEvent, "id" | "timestamp">>): Promise<ActionLogEvent>;
+    /** one invocation by id. sqlite and idb select by primary key. */
+    invocation(invocationId: string): Promise<InvocationState | null>;
+    /** all invocations, or the active ones. */
+    invocations(status?: InvocationStatus): InvocationState[];
+    /** invoke and validate for one invocation id, in order. */
+    toolCall(invo: ParsedMoneroToolInvocation): Promise<void>;
+    /** first toolCall state transition: session_start invoked when no row. second state transition: validate_result validated if valid is not unverified. */
+    private applyToolCall;
+    /** only the newest active call per permission category stays open. */
+    private dismissOthersOfSamePermission;
+    /** open invocations for these permissions. the send and wallets plates show these. */
+    getActiveByPermissions(permissions: ToolPermission[]): InvocationState[];
+    getNoticesByPermissions(permissions: ToolPermission[]): ToolNotice[];
+    dismissNotice(noticeId: string): Promise<void>;
+    dismiss(invocationId: string): Promise<void>;
+    execute(invocationId: string, args?: Record<string, unknown>): Promise<void>;
+    getPort(invocationId: string): ExtensionPort | undefined;
+    private listenOnMessage;
+    installExtensionMessagebus(): void;
+    private installUiMessagebus;
+    private installWorkerMessagebus;
+    private handleUiMessage;
+    private handleWorkerMessage;
+    private dismissLocal;
+    private executeLocal;
+    private dismissNoticeLocal;
+    private openWalletUi;
+    private dispatchPortDisconnect;
+}
+export type { ActionLogBackend, ActionLogEvent, ActionLogEventType, ActionLogStage, InvocationDisplayStatus, InvocationState, ToolPermission, ToolWorkerContext, } from "./actionLogTypes";
+export { Invocation } from "./actionLogTypes";
+export type { ToolNotice, ToolUiCopy } from "../tools/globals";

package/dist/actionlog/actionLogOpened.js

@@ -1 +1,386 @@
-export {};
+import { newEventId, nowTimestamp, } from "./actionLogTypes";
+import { tools } from "../tools/monero-tools";
+import { getExtensionRuntime, sendToBackground, } from "../tools/globals";
+function armWorker(toolId) {
+    return tools[toolId]?.worker;
+}
+export class ActionLogOpened {
+    backend;
+    _onChange;
+    ports = new Map();
+    runtimeInstalled = false;
+    bus = null;
+    mco = null;
+    invocationsCache = [];
+    activeCache = [];
+    noticeList = [];
+    toolCallTail = new Map();
+    constructor(backend, _onChange) {
+        this.backend = backend;
+        this._onChange = _onChange;
+    }
+    static async create(options = {}) {
+        const backend = await openBackend(options);
+        const log = new ActionLogOpened(backend, options.onChange ?? null);
+        log.bus = options.extensionMessageBus ?? null;
+        if (log.bus)
+            log.installExtensionMessagebus();
+        await log.refreshUiCache();
+        return log;
+    }
+    setOnChange(cb) {
+        this._onChange = cb;
+    }
+    // mco wires itself after create
+    bindMco(mco) {
+        this.mco = mco;
+    }
+    /** after a write, the invocation lists that the plates read. */
+    async refreshUiCache() {
+        this.invocationsCache = await this.backend.invocations();
+        this.activeCache = await this.backend.invocations("active");
+        this.noticeList = [];
+        this._onChange?.();
+    }
+    toolCtx() {
+        return {
+            log: this,
+            getWallets: () => this.mco,
+            reloadWallets: () => this.mco?.buildWallets(),
+            getPort: (id) => this.ports.get(id),
+        };
+    }
+    get extensionMessageBus() {
+        return this.bus;
+    }
+    isUiBus() {
+        return this.bus === "ui";
+    }
+    broadcastActionLogChanged() {
+        void sendToBackground("actionLogChanged", null).catch(() => { });
+    }
+    async append(partial) {
+        const event = {
+            ...partial,
+            id: partial.id ?? newEventId(),
+            timestamp: partial.timestamp ?? nowTimestamp(),
+        };
+        await this.backend.append(event);
+        await this.refreshUiCache();
+        this.broadcastActionLogChanged();
+        return event;
+    }
+    /** one invocation by id. sqlite and idb select by primary key. */
+    async invocation(invocationId) {
+        return this.backend.invocation(invocationId);
+    }
+    /** all invocations, or the active ones. */
+    invocations(status) {
+        if (!status)
+            return [...this.invocationsCache];
+        if (status === "active")
+            return [...this.activeCache];
+        return this.invocationsCache.filter((s) => s.lastType === status);
+    }
+    /** invoke and validate for one invocation id, in order. */
+    async toolCall(invo) {
+        const id = invo.invocation_id;
+        const prev = this.toolCallTail.get(id) ?? Promise.resolve();
+        const next = prev.then(() => this.applyToolCall(invo));
+        this.toolCallTail.set(id, next.catch(() => { }));
+        await next;
+    }
+    /** first toolCall state transition: session_start invoked when no row. second state transition: validate_result validated if valid is not unverified. */
+    async applyToolCall(invo) {
+        const w = armWorker(invo.tool.tool_id);
+        const ctx = this.toolCtx();
+        const isNew = !(await this.invocation(invo.invocation_id));
+        if (isNew) {
+            // a new call takes over its permission category. older active calls of the same permission are dismissed
+            await this.dismissOthersOfSamePermission(invo);
+            await w?.invoke_write?.(ctx, invo);
+        }
+        if (invo.valid !== "unverified")
+            await w?.validate_write?.(ctx, invo);
+    }
+    /** only the newest active call per permission category stays open. */
+    async dismissOthersOfSamePermission(invo) {
+        const id = invo.tool.tool_id;
+        const perms = tools[id]?.permissions ?? [];
+        if (!perms.length)
+            return;
+        await this.refreshUiCache();
+        const open = this.getActiveByPermissions(perms);
+        for (const row of open) {
+            if (row.invocationId === invo.invocation_id)
+                continue;
+            await this.dismiss(row.invocationId);
+        }
+    }
+    /** open invocations for these permissions. the send and wallets plates show these. */
+    getActiveByPermissions(permissions) {
+        const want = new Set(permissions);
+        const toolIds = Object.keys(tools).filter((id) => tools[id].permissions.some((p) => want.has(p)));
+        const idSet = new Set(toolIds);
+        return this.invocations("active").filter((o) => idSet.has(o.toolId));
+    }
+    getNoticesByPermissions(permissions) {
+        const want = new Set(permissions);
+        return this.noticeList.filter((n) => want.has(n.permission));
+    }
+    async dismissNotice(noticeId) {
+        if (this.isUiBus()) {
+            await sendToBackground("dismissNotice", { noticeId }).catch(() => { });
+            await this.refreshUiCache();
+            return;
+        }
+        await this.dismissNoticeLocal(noticeId);
+    }
+    async dismiss(invocationId) {
+        if (this.isUiBus()) {
+            await sendToBackground("dismiss", { invocationId }).catch(() => { });
+            return;
+        }
+        await this.dismissLocal(invocationId);
+    }
+    async execute(invocationId, args = {}) {
+        if (this.isUiBus()) {
+            await sendToBackground("execute", { invocationId, args }).catch(() => { });
+            return;
+        }
+        await this.executeLocal(invocationId, args);
+    }
+    getPort(invocationId) {
+        return this.ports.get(invocationId);
+    }
+    listenOnMessage(handle) {
+        const rt = getExtensionRuntime();
+        if (!rt)
+            return;
+        rt.onMessage.addListener((msg, sender, sendResponse) => {
+            const done = handle(msg, sender).then((result) => {
+                if (result !== undefined)
+                    sendResponse?.(result);
+                return result;
+            });
+            void done;
+            return true;
+        });
+    }
+    installExtensionMessagebus() {
+        if (this.runtimeInstalled)
+            return;
+        if (this.bus === "worker")
+            this.installWorkerMessagebus();
+        else if (this.bus === "ui")
+            this.installUiMessagebus();
+    }
+    installUiMessagebus() {
+        this.runtimeInstalled = true;
+        this.listenOnMessage((env) => this.handleUiMessage(env));
+    }
+    installWorkerMessagebus() {
+        const rt = getExtensionRuntime();
+        if (!rt)
+            return;
+        this.runtimeInstalled = true;
+        this.listenOnMessage((env, sender) => this.handleWorkerMessage(env, sender));
+        rt.onConnect.addListener((port) => {
+            const invocationId = port.name;
+            const existing = this.ports.get(invocationId);
+            if (existing)
+                existing.disconnect();
+            this.ports.set(invocationId, port);
+            port.onDisconnect.addListener(() => {
+                this.ports.delete(invocationId);
+                void this.dispatchPortDisconnect(invocationId);
+            });
+        });
+    }
+    async handleUiMessage(env) {
+        if (!env?.kind)
+            return {};
+        if (env.kind === "actionLogChanged") {
+            if (this.backend.reload) {
+                await this.backend.reload();
+                await this.refreshUiCache();
+            }
+            return {};
+        }
+        if (env.kind === "walletCacheChanged") {
+            const raw = typeof env.payload === "string"
+                ? JSON.parse(env.payload, (key, value) => {
+                    if (key === "amount")
+                        return BigInt(value);
+                    return value;
+                })
+                : env.payload;
+            await this.mco?.feed(raw);
+            return {};
+        }
+        // Unhandled kinds (worker.* queries especially) get no answer here.
+        // The worker answers, and the first answer wins. A local {} would win
+        // the race and hide the worker response.
+        return;
+    }
+    async handleWorkerMessage(env, sender) {
+        if (!env?.kind)
+            return {};
+        const ctx = this.toolCtx();
+        switch (env.kind) {
+            case "openSidebar":
+                this.openWalletUi(sender);
+                return {};
+            case "worker.setNodeUrl": {
+                const p = env.payload;
+                if (p?.node_url != null)
+                    await this.mco?.changeNodeUrl(p.node_url);
+                return {};
+            }
+            case "worker.setStartHeight": {
+                const p = env.payload;
+                if (p && "start_height" in p)
+                    await this.mco?.changeStartHeight(p.start_height ?? null);
+                return {};
+            }
+            case "worker.changeNodeUrlAndStartHeight": {
+                const p = env.payload;
+                await this.mco?.changeNodeUrlAndStartHeight(p?.node_url, p?.start_height);
+                return {};
+            }
+            case "worker.buildWallets":
+                await this.mco?.buildWallets();
+                return {};
+            case "worker.stopWorker":
+                await this.mco?.stopWorker();
+                return {};
+            case "worker.makeSignSend": {
+                const p = env.payload;
+                await this.mco?.makeSignSend(p);
+                return {};
+            }
+            case "worker.sweepSignSend": {
+                const p = env.payload;
+                await this.mco?.sweepSignSend(p);
+                return {};
+            }
+            case "worker.rebroadcastTx": {
+                const p = env.payload;
+                await this.mco?.rebroadcastTx(p);
+                return {};
+            }
+            case "worker.dismissSendPlate": {
+                const p = env.payload;
+                await this.mco?.dismissSendPlate(p);
+                return {};
+            }
+            case "worker.setLogSettings": {
+                const p = env.payload;
+                await this.mco?.setLogSettings(p?.logs, p?.logs_include, p?.logs_exclude);
+                return {};
+            }
+            case "worker.getTxLogs": {
+                const wallets = this.mco?.wallets;
+                const rows = (wallets ?? []).map((w) => ({
+                    primary_address: w.primary_address,
+                    tx_logs: (w.tx_logs ?? []).map((t, index) => {
+                        const out = { ...t, index };
+                        delete out.signed_tx;
+                        return out;
+                    }),
+                }));
+                // chrome messages must be plain JSON. cache rows can hold bigints.
+                const clean = JSON.parse(JSON.stringify(rows, (_k, v) => typeof v === "bigint" ? v.toString() : v));
+                return { tx_logs: clean };
+            }
+            case "toolCall": {
+                await this.toolCall(env.payload);
+                return {};
+            }
+            case "dismiss": {
+                const p = env.payload;
+                await this.dismissLocal(p.invocationId);
+                return {};
+            }
+            case "execute": {
+                const p = env.payload;
+                await this.executeLocal(p.invocationId, p.args ?? {});
+                return {};
+            }
+            case "dismissNotice": {
+                const p = env.payload;
+                await this.dismissNoticeLocal(p.noticeId);
+                return {};
+            }
+            case "shareViewkeyOK": {
+                const p = env.payload;
+                for (const id of Object.keys(tools)) {
+                    await armWorker(id)?.execute_ok?.(ctx, p);
+                }
+                return {};
+            }
+            case "shareViewkeyFAILED": {
+                for (const id of Object.keys(tools)) {
+                    await armWorker(id)?.execute_fail?.(ctx, env.payload);
+                }
+                return {};
+            }
+            default:
+                return {};
+        }
+    }
+    async dismissLocal(invocationId) {
+        const invo = await this.invocation(invocationId);
+        if (!invo)
+            return;
+        await armWorker(invo.toolId)?.accept_no?.(this.toolCtx(), invocationId);
+    }
+    async executeLocal(invocationId, args) {
+        const invo = await this.invocation(invocationId);
+        if (!invo)
+            return;
+        const w = armWorker(invo.toolId);
+        const ctx = this.toolCtx();
+        await w?.accept_yes?.(ctx, invocationId, args);
+        await w?.execute_run?.(ctx, invocationId, args);
+    }
+    async dismissNoticeLocal(_noticeId) {
+        await this.refreshUiCache();
+    }
+    openWalletUi(sender) {
+        const g = globalThis;
+        const api = g.browser ?? g.chrome;
+        void api?.sidebarAction?.open?.().catch(() => { });
+        const windowId = sender?.tab?.windowId;
+        if (windowId != null) {
+            void api?.sidePanel?.open?.({ windowId }).catch(() => { });
+        }
+    }
+    async dispatchPortDisconnect(invocationId) {
+        const invo = await this.invocation(invocationId);
+        if (!invo)
+            return;
+        await armWorker(invo.toolId)?.execute_abort?.(this.toolCtx(), invocationId);
+    }
+}
+function defaultBackendKind() {
+    // indexedDB shim sets this. unset means bun/node.
+    return globalThis.areWeInTheBrowser === true ? "idb" : "sqlite";
+}
+async function openBackend(options) {
+    if (options.backendInstance)
+        return options.backendInstance;
+    const kind = options.backend ?? defaultBackendKind();
+    if (kind === "idb") {
+        const { ActionLogIdbBackend } = await import("./backend/idbBackend");
+        const path = options.path ?? "actionlog";
+        return ActionLogIdbBackend.open(path);
+    }
+    if (kind === "sqlite") {
+        const { ActionLogSqliteBackend } = await import("./backend/sqliteBackend");
+        const path = options.path ?? "actionlog.sqlite";
+        return ActionLogSqliteBackend.open(path);
+    }
+    throw new Error(`unknown action log backend: ${kind}`);
+}
+export { Invocation } from "./actionLogTypes";

package/dist/actionlog/actionLogTypes.d.ts

@@ -0,0 +1,114 @@
+import type { ToolId } from "../tools/monero-tools";
+import type { ExtensionPort, ToolInvocationValidity, ToolPermission } from "../tools/globals";
+import type { ActionLogOpened } from "./actionLogOpened";
+export type { ToolPermission };
+export type ActionLogEventType = "session_start" | "validate_start" | "validate_result" | "accept" | "dismiss" | "execute_start" | "execute_error" | "execute_result" | "aborted";
+export type ActionLogStage = "recognized" | "invoked" | "validated" | "accepted" | "executed";
+export type ActionLogEvent = {
+    type: ActionLogEventType;
+    id: string;
+    timestamp: string;
+    invocationId: string;
+    stage: ActionLogStage;
+    toolId: ToolId;
+    valid?: ToolInvocationValidity;
+    amount?: string;
+    address?: string;
+    no_check?: boolean;
+    wallet_slot?: number;
+    context_domain?: string;
+    destination_domain?: string;
+    context_href?: string;
+    found_in?: "link" | "linkText";
+    link?: string;
+    linkText?: string;
+    wallet_to_send_from_pa?: string;
+    ok?: boolean;
+    error?: string;
+    [key: string]: unknown;
+};
+export type InvocationDisplayStatus = "done" | "dismissed" | "aborted" | "failed" | "in progress";
+export declare class Invocation {
+    invocationId: string;
+    toolId: ToolId;
+    stage: ActionLogStage;
+    lastType: ActionLogEventType;
+    valid?: ToolInvocationValidity;
+    amount?: string;
+    address?: string;
+    no_check?: boolean;
+    wallet_slot?: number;
+    context_domain?: string;
+    destination_domain?: string;
+    context_href?: string;
+    found_in?: "link" | "linkText";
+    link?: string;
+    linkText?: string;
+    timestamp?: string;
+    wallet_to_send_from_pa?: string;
+    ok?: boolean;
+    error?: string;
+    events: ActionLogEvent[];
+    /** an Invocation from stored fields or from advanceInvo. */
+    constructor(init: {
+        invocationId: string;
+        toolId: ToolId;
+        stage: ActionLogStage;
+        lastType: ActionLogEventType;
+        events?: ActionLogEvent[];
+        valid?: ToolInvocationValidity;
+        amount?: string;
+        address?: string;
+        no_check?: boolean;
+        wallet_slot?: number;
+        context_domain?: string;
+        destination_domain?: string;
+        context_href?: string;
+        found_in?: "link" | "linkText";
+        link?: string;
+        linkText?: string;
+        timestamp?: string;
+        wallet_to_send_from_pa?: string;
+        ok?: boolean;
+        error?: string;
+    });
+    /** the label on the list and detail pages. a failed send is failed, not done. */
+    get status(): InvocationDisplayStatus;
+}
+export type InvocationState = Invocation;
+export declare const TERMINAL_EVENT_TYPES: ReadonlySet<ActionLogEventType>;
+export declare function isTerminalEventType(type: ActionLogEventType): boolean;
+export declare function newEventId(): string;
+export declare function nowTimestamp(): string;
+export type ToolWorkerContext = {
+    log: ActionLogOpened;
+    getWallets?: () => unknown;
+    reloadWallets?: () => void | Promise<void>;
+    getPort: (invocationId: string) => ExtensionPort | undefined;
+};
+/** apply one event to the current invocation state. advances invocation state. */
+export declare function advanceInvo(prev: InvocationState | null, event: ActionLogEvent): InvocationState;
+/** still live. false for dismiss, execute_result, aborted. */
+export declare function isActive(state: InvocationState): boolean;
+export type InvocationStatus = "active" | ActionLogEventType;
+/** the status column: active, or lastType when the invocation ended. */
+export declare function invocationStatus(state: InvocationState): InvocationStatus;
+export type ActionLogBackend = {
+    append(event: ActionLogEvent): Promise<void>;
+    invocation(invocationId: string): Promise<InvocationState | null>;
+    invocations(status?: InvocationStatus): Promise<InvocationState[]>;
+    reload?(): Promise<void>;
+};
+export declare class ActiveInvocations {
+    byInvocation: Map<string, Invocation>;
+    byTool: Map<"001" | "002", string>;
+    /** update the invo for this event. byTool keeps one live invo per tool. */
+    apply(event: ActionLogEvent): Invocation;
+    /** invocations from sqlite or idb into byInvocation and byTool. */
+    loadStates(states: InvocationState[]): void;
+    clear(): void;
+    /** the invocation for this id. */
+    invocation(invocationId: string): InvocationState | null;
+    /** all invocations, or filter. active reads byTool (one live invo per tool). */
+    invocations(status?: InvocationStatus): InvocationState[];
+}