@spirobel/monero-wallet-api 0.5.4 → 0.6.0

package/dist/actionlog/actionLogTypes.js

@@ -0,0 +1,198 @@
+export class Invocation {
+    invocationId;
+    toolId;
+    stage;
+    lastType;
+    valid;
+    amount;
+    address;
+    no_check;
+    wallet_slot;
+    context_domain;
+    destination_domain;
+    context_href;
+    found_in;
+    link;
+    linkText;
+    timestamp;
+    wallet_to_send_from_pa;
+    ok;
+    error;
+    events;
+    /** an Invocation from stored fields or from advanceInvo. */
+    constructor(init) {
+        this.invocationId = init.invocationId;
+        this.toolId = init.toolId;
+        this.stage = init.stage;
+        this.lastType = init.lastType;
+        this.events = init.events ?? [];
+        if (init.valid !== undefined)
+            this.valid = init.valid;
+        if (init.amount !== undefined)
+            this.amount = init.amount;
+        if (init.address !== undefined)
+            this.address = init.address;
+        if (init.no_check !== undefined)
+            this.no_check = init.no_check;
+        if (init.wallet_slot !== undefined)
+            this.wallet_slot = init.wallet_slot;
+        if (init.context_domain !== undefined)
+            this.context_domain = init.context_domain;
+        if (init.destination_domain !== undefined)
+            this.destination_domain = init.destination_domain;
+        if (init.context_href !== undefined)
+            this.context_href = init.context_href;
+        if (init.found_in !== undefined)
+            this.found_in = init.found_in;
+        if (init.link !== undefined)
+            this.link = init.link;
+        if (init.linkText !== undefined)
+            this.linkText = init.linkText;
+        if (init.timestamp !== undefined)
+            this.timestamp = init.timestamp;
+        if (init.wallet_to_send_from_pa !== undefined)
+            this.wallet_to_send_from_pa = init.wallet_to_send_from_pa;
+        if (init.ok !== undefined)
+            this.ok = init.ok;
+        if (init.error !== undefined)
+            this.error = init.error;
+    }
+    /** the label on the list and detail pages. a failed send is failed, not done. */
+    get status() {
+        if (this.lastType === "execute_result")
+            return this.ok === false ? "failed" : "done";
+        if (this.lastType === "dismiss")
+            return "dismissed";
+        if (this.lastType === "aborted")
+            return "aborted";
+        if (this.lastType === "execute_error")
+            return "failed";
+        return "in progress";
+    }
+}
+export const TERMINAL_EVENT_TYPES = new Set([
+    "dismiss",
+    "execute_result",
+    "aborted",
+]);
+// dismiss, execute_result, and aborted end the invocation.
+export function isTerminalEventType(type) {
+    return TERMINAL_EVENT_TYPES.has(type);
+}
+export function newEventId() {
+    return crypto.randomUUID();
+}
+export function nowTimestamp() {
+    return new Date().toISOString();
+}
+/** apply one event to the current invocation state. advances invocation state. */
+export function advanceInvo(prev, event) {
+    const next = new Invocation({
+        ...(prev ?? {
+            invocationId: event.invocationId,
+            toolId: event.toolId,
+            stage: event.stage,
+            lastType: event.type,
+            events: [],
+        }),
+        invocationId: event.invocationId,
+        toolId: event.toolId,
+        stage: event.stage,
+        lastType: event.type,
+        timestamp: event.timestamp,
+        events: [...(prev?.events ?? []), event],
+    });
+    if (event.valid !== undefined)
+        next.valid = event.valid;
+    if (event.amount !== undefined)
+        next.amount = event.amount;
+    if (event.address !== undefined)
+        next.address = event.address;
+    if (event.no_check !== undefined)
+        next.no_check = event.no_check;
+    if (event.wallet_slot !== undefined)
+        next.wallet_slot = event.wallet_slot;
+    if (event.context_domain !== undefined)
+        next.context_domain = event.context_domain;
+    if (event.destination_domain !== undefined)
+        next.destination_domain = event.destination_domain;
+    if (event.context_href !== undefined)
+        next.context_href = event.context_href;
+    if (event.found_in !== undefined)
+        next.found_in = event.found_in;
+    if (event.link !== undefined)
+        next.link = event.link;
+    if (event.linkText !== undefined)
+        next.linkText = event.linkText;
+    if (event.wallet_to_send_from_pa !== undefined)
+        next.wallet_to_send_from_pa = event.wallet_to_send_from_pa;
+    if (event.ok !== undefined)
+        next.ok = event.ok;
+    if (event.error !== undefined)
+        next.error = event.error;
+    return next;
+}
+/** still live. false for dismiss, execute_result, aborted. */
+export function isActive(state) {
+    return !isTerminalEventType(state.lastType);
+}
+/** the status column: active, or lastType when the invocation ended. */
+export function invocationStatus(state) {
+    return isActive(state) ? "active" : state.lastType;
+}
+// current invos in memory. mininext reads this once per frame.
+export class ActiveInvocations {
+    byInvocation = new Map();
+    byTool = new Map();
+    /** update the invo for this event. byTool keeps one live invo per tool. */
+    apply(event) {
+        const prev = this.byInvocation.get(event.invocationId) ?? null;
+        const next = advanceInvo(prev, event);
+        this.byInvocation.set(event.invocationId, next);
+        if (isActive(next)) {
+            this.byTool.set(event.toolId, event.invocationId);
+            return next;
+        }
+        if (this.byTool.get(event.toolId) === event.invocationId) {
+            this.byTool.delete(event.toolId);
+        }
+        return next;
+    }
+    /** invocations from sqlite or idb into byInvocation and byTool. */
+    loadStates(states) {
+        this.clear();
+        for (const state of states) {
+            const invo = new Invocation({
+                ...state,
+                events: state.events ?? [],
+            });
+            this.byInvocation.set(invo.invocationId, invo);
+            if (isActive(invo))
+                this.byTool.set(invo.toolId, invo.invocationId);
+        }
+    }
+    clear() {
+        this.byInvocation.clear();
+        this.byTool.clear();
+    }
+    /** the invocation for this id. */
+    invocation(invocationId) {
+        return this.byInvocation.get(invocationId) ?? null;
+    }
+    /** all invocations, or filter. active reads byTool (one live invo per tool). */
+    invocations(status) {
+        if (status === "active") {
+            const out = [];
+            for (const id of this.byTool.values()) {
+                const s = this.byInvocation.get(id);
+                if (s)
+                    out.push(s);
+            }
+            return out;
+        }
+        const all = [...this.byInvocation.values()];
+        if (!status)
+            return all;
+        return all.filter((s) => invocationStatus(s) === status);
+    }
+}

package/dist/actionlog/backend/idbBackend.d.ts

@@ -0,0 +1,13 @@
+import { type ActionLogBackend, type ActionLogEvent, type InvocationState, type InvocationStatus } from "../actionLogTypes";
+export declare class ActionLogIdbBackend implements ActionLogBackend {
+    private readonly db;
+    private active;
+    private constructor();
+    static open(dbName?: string): Promise<ActionLogIdbBackend>;
+    private loadInvocations;
+    private readInvocations;
+    append(event: ActionLogEvent): Promise<void>;
+    invocation(invocationId: string): Promise<InvocationState | null>;
+    invocations(status?: InvocationStatus): Promise<InvocationState[]>;
+    reload(): Promise<void>;
+}

package/dist/actionlog/backend/idbBackend.js

@@ -0,0 +1,109 @@
+import { ActiveInvocations, Invocation, invocationStatus, } from "../actionLogTypes";
+const DB_NAME_DEFAULT = "actionlog";
+const STORE_INVOCATIONS = "invocations";
+const DB_VERSION = 1;
+export class ActionLogIdbBackend {
+    db;
+    active = new ActiveInvocations();
+    constructor(db) {
+        this.db = db;
+    }
+    static async open(dbName = DB_NAME_DEFAULT) {
+        if (typeof indexedDB === "undefined") {
+            throw new Error("IndexedDB not available");
+        }
+        const db = await openDb(dbName);
+        const backend = new ActionLogIdbBackend(db);
+        await backend.loadInvocations();
+        return backend;
+    }
+    async loadInvocations() {
+        const rows = await this.readInvocations();
+        if (!rows.length) {
+            this.active.clear();
+            return;
+        }
+        this.active.loadStates(rows);
+    }
+    readInvocations() {
+        return new Promise((resolve, reject) => {
+            if (!this.db.objectStoreNames.contains(STORE_INVOCATIONS)) {
+                resolve([]);
+                return;
+            }
+            const tx = this.db.transaction(STORE_INVOCATIONS, "readonly");
+            const req = tx.objectStore(STORE_INVOCATIONS).getAll();
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => {
+                resolve(req.result ?? []);
+            };
+        });
+    }
+    async append(event) {
+        const next = this.active.apply(event);
+        await new Promise((resolve, reject) => {
+            const tx = this.db.transaction(STORE_INVOCATIONS, "readwrite");
+            tx.objectStore(STORE_INVOCATIONS).put({
+                ...next,
+                status: invocationStatus(next),
+            });
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async invocation(invocationId) {
+        return new Promise((resolve, reject) => {
+            if (!this.db.objectStoreNames.contains(STORE_INVOCATIONS)) {
+                resolve(this.active.invocation(invocationId));
+                return;
+            }
+            const tx = this.db.transaction(STORE_INVOCATIONS, "readonly");
+            const req = tx.objectStore(STORE_INVOCATIONS).get(invocationId);
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => {
+                const row = req.result;
+                resolve(row ? new Invocation({ ...row, events: row.events ?? [] }) : null);
+            };
+        });
+    }
+    async invocations(status) {
+        return new Promise((resolve, reject) => {
+            if (!this.db.objectStoreNames.contains(STORE_INVOCATIONS)) {
+                resolve(this.active.invocations(status));
+                return;
+            }
+            const tx = this.db.transaction(STORE_INVOCATIONS, "readonly");
+            const store = tx.objectStore(STORE_INVOCATIONS);
+            const req = status
+                ? store.index("status").getAll(status)
+                : store.getAll();
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => {
+                const rows = req.result ?? [];
+                resolve(rows.map((s) => new Invocation({
+                    ...s,
+                    events: s.events ?? [],
+                })));
+            };
+        });
+    }
+    async reload() {
+        await this.loadInvocations();
+    }
+}
+function openDb(name) {
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(name, DB_VERSION);
+        req.onerror = () => reject(req.error);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (!db.objectStoreNames.contains(STORE_INVOCATIONS)) {
+                const inv = db.createObjectStore(STORE_INVOCATIONS, {
+                    keyPath: "invocationId",
+                });
+                inv.createIndex("status", "status", { unique: false });
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+    });
+}

package/dist/actionlog/backend/jsonlBackend.d.ts

@@ -0,0 +1,19 @@
+import { type ActionLogBackend, type ActionLogEvent, type InvocationState, type InvocationStatus } from "../actionLogTypes";
+export declare class ActionLogJsonlBackend implements ActionLogBackend {
+    private readonly path;
+    private eventLog;
+    private active;
+    constructor(path: string);
+    static open(path: string): Promise<ActionLogJsonlBackend>;
+    private invocationsPath;
+    private load;
+    private loadInvocationsFile;
+    private persistEvents;
+    private persistInvocations;
+    append(event: ActionLogEvent): Promise<void>;
+    events(invocationId: string): Promise<ActionLogEvent[]>;
+    invocation(invocationId: string): Promise<InvocationState | null>;
+    invocations(status?: InvocationStatus): Promise<InvocationState[]>;
+    feed(events: ActionLogEvent[]): Promise<void>;
+    reload(): Promise<void>;
+}

package/dist/actionlog/backend/jsonlBackend.js

@@ -0,0 +1,110 @@
+import { atomicWrite } from "../../io/atomicWrite";
+import { ActiveInvocations, invocationStatus, } from "../actionLogTypes";
+export class ActionLogJsonlBackend {
+    path;
+    eventLog = [];
+    active = new ActiveInvocations();
+    constructor(path) {
+        this.path = path;
+    }
+    static async open(path) {
+        const backend = new ActionLogJsonlBackend(path);
+        await backend.load();
+        return backend;
+    }
+    invocationsPath() {
+        const p = this.path;
+        const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+        const dir = i >= 0 ? p.slice(0, i) : ".";
+        return `${dir}/invocations.jsonl`;
+    }
+    async load() {
+        const loaded = await this.loadInvocationsFile();
+        const text = await Bun.file(this.path)
+            .text()
+            .catch(() => "");
+        this.eventLog = [];
+        if (text.trim()) {
+            for (const line of text.split("\n")) {
+                const t = line.trim();
+                if (!t)
+                    continue;
+                try {
+                    this.eventLog.push(JSON.parse(t));
+                }
+                catch {
+                    // skip bad line
+                }
+            }
+        }
+        if (loaded)
+            return;
+        this.active.clear();
+        for (const event of this.eventLog)
+            this.active.apply(event);
+        await this.persistInvocations();
+    }
+    async loadInvocationsFile() {
+        const text = await Bun.file(this.invocationsPath())
+            .text()
+            .catch(() => "");
+        if (!text.trim())
+            return false;
+        const states = [];
+        for (const line of text.split("\n")) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            try {
+                states.push(JSON.parse(t));
+            }
+            catch {
+                // skip bad line
+            }
+        }
+        if (!states.length)
+            return false;
+        this.active.loadStates(states);
+        return true;
+    }
+    async persistEvents() {
+        const body = this.eventLog.map((e) => JSON.stringify(e)).join("\n") +
+            (this.eventLog.length ? "\n" : "");
+        await atomicWrite(this.path, body);
+    }
+    async persistInvocations() {
+        const rows = this.active.invocations();
+        const body = rows
+            .map((s) => JSON.stringify({ ...s, status: invocationStatus(s) }))
+            .join("\n") + (rows.length ? "\n" : "");
+        await atomicWrite(this.invocationsPath(), body);
+    }
+    async append(event) {
+        this.eventLog.push(event);
+        this.active.apply(event);
+        await this.persistEvents();
+        await this.persistInvocations();
+    }
+    async events(invocationId) {
+        return this.eventLog.filter((e) => e.invocationId === invocationId);
+    }
+    async invocation(invocationId) {
+        return this.active.invocation(invocationId);
+    }
+    async invocations(status) {
+        return this.active.invocations(status);
+    }
+    async feed(events) {
+        for (const event of events) {
+            if (this.eventLog.some((e) => e.id === event.id))
+                continue;
+            this.eventLog.push(event);
+            this.active.apply(event);
+        }
+        await this.persistEvents();
+        await this.persistInvocations();
+    }
+    async reload() {
+        await this.load();
+    }
+}

package/dist/actionlog/backend/memoryBackend.d.ts

@@ -0,0 +1,11 @@
+import { type ActionLogBackend, type ActionLogEvent, type InvocationState, type InvocationStatus } from "../actionLogTypes";
+export declare class ActionLogMemoryBackend implements ActionLogBackend {
+    private eventLog;
+    private active;
+    append(event: ActionLogEvent): Promise<void>;
+    events(invocationId: string): Promise<ActionLogEvent[]>;
+    invocation(invocationId: string): Promise<InvocationState | null>;
+    invocations(status?: InvocationStatus): Promise<InvocationState[]>;
+    feed(events: ActionLogEvent[]): Promise<void>;
+    reload(): Promise<void>;
+}

package/dist/actionlog/backend/memoryBackend.js

@@ -0,0 +1,31 @@
+import { ActiveInvocations, } from "../actionLogTypes";
+export class ActionLogMemoryBackend {
+    eventLog = [];
+    active = new ActiveInvocations();
+    async append(event) {
+        this.eventLog.push(event);
+        this.active.apply(event);
+    }
+    async events(invocationId) {
+        return this.eventLog.filter((e) => e.invocationId === invocationId);
+    }
+    async invocation(invocationId) {
+        return this.active.invocation(invocationId);
+    }
+    async invocations(status) {
+        return this.active.invocations(status);
+    }
+    async feed(events) {
+        for (const event of events) {
+            if (this.eventLog.some((e) => e.id === event.id))
+                continue;
+            this.eventLog.push(event);
+            this.active.apply(event);
+        }
+    }
+    async reload() {
+        this.active.clear();
+        for (const event of this.eventLog)
+            this.active.apply(event);
+    }
+}

package/dist/actionlog/backend/sqliteBackend.d.ts

@@ -0,0 +1,14 @@
+import { type ActionLogBackend, type ActionLogEvent, type InvocationState, type InvocationStatus } from "../actionLogTypes";
+export declare class ActionLogSqliteBackend implements ActionLogBackend {
+    private active;
+    private sql;
+    private constructor();
+    static open(filename: string): Promise<ActionLogSqliteBackend>;
+    private loadInvocations;
+    /** body is the invocation as json. events[] is the state transitions. */
+    private upsertInvocation;
+    append(event: ActionLogEvent): Promise<void>;
+    invocation(invocationId: string): Promise<InvocationState | null>;
+    invocations(status?: InvocationStatus): Promise<InvocationState[]>;
+    reload(): Promise<void>;
+}

package/dist/actionlog/backend/sqliteBackend.js

@@ -0,0 +1,96 @@
+import { ActiveInvocations, Invocation, invocationStatus, } from "../actionLogTypes";
+export class ActionLogSqliteBackend {
+    active = new ActiveInvocations();
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    static async open(filename) {
+        // specifier is not a literal so browser bun build does not fail on builtin bun
+        const spec = "bun";
+        const { SQL: SqlCtor } = (await import(spec));
+        const sql = new SqlCtor({
+            adapter: "sqlite",
+            filename,
+            create: true,
+        });
+        await sql `PRAGMA journal_mode = WAL`;
+        await sql `
+      CREATE TABLE IF NOT EXISTS actionlog_invocations (
+        invocationId TEXT PRIMARY KEY,
+        status TEXT NOT NULL,
+        timestamp TEXT,
+        toolId TEXT NOT NULL,
+        body TEXT NOT NULL
+      )
+    `;
+        await sql `
+      CREATE INDEX IF NOT EXISTS idx_actionlog_invo_status
+      ON actionlog_invocations (status)
+    `;
+        const backend = new ActionLogSqliteBackend(sql);
+        await backend.loadInvocations();
+        return backend;
+    }
+    async loadInvocations() {
+        const rows = (await this.sql `
+      SELECT body FROM actionlog_invocations
+    `);
+        if (!Array.isArray(rows) || !rows.length) {
+            this.active.clear();
+            return;
+        }
+        this.active.loadStates(rows.map((r) => JSON.parse(r.body)));
+    }
+    /** body is the invocation as json. events[] is the state transitions. */
+    async upsertInvocation(state) {
+        const body = JSON.stringify(state);
+        const status = invocationStatus(state);
+        await this.sql `
+      INSERT INTO actionlog_invocations (invocationId, status, timestamp, toolId, body)
+      VALUES (
+        ${state.invocationId},
+        ${status},
+        ${state.timestamp ?? ""},
+        ${state.toolId},
+        ${body}
+      )
+      ON CONFLICT(invocationId) DO UPDATE SET
+        status = ${status},
+        timestamp = ${state.timestamp ?? ""},
+        toolId = ${state.toolId},
+        body = ${body}
+    `;
+    }
+    async append(event) {
+        const next = this.active.apply(event);
+        await this.upsertInvocation(next);
+    }
+    async invocation(invocationId) {
+        const rows = (await this.sql `
+      SELECT body FROM actionlog_invocations
+      WHERE invocationId = ${invocationId}
+    `);
+        if (!Array.isArray(rows) || !rows[0])
+            return null;
+        const s = JSON.parse(rows[0].body);
+        return new Invocation({ ...s, events: s.events ?? [] });
+    }
+    async invocations(status) {
+        const rows = (status
+            ? await this.sql `
+            SELECT body FROM actionlog_invocations
+            WHERE status = ${status}
+          `
+            : await this.sql `SELECT body FROM actionlog_invocations`);
+        if (!Array.isArray(rows))
+            return [];
+        return rows.map((r) => {
+            const s = JSON.parse(r.body);
+            return new Invocation({ ...s, events: s.events ?? [] });
+        });
+    }
+    async reload() {
+        await this.loadInvocations();
+    }
+}

package/dist/actionlog/backend.d.ts

@@ -0,0 +1,12 @@
+import type { ToolId } from "../tools/monero-tools";
+import type { ActionLogEvent, OpenInvocationState } from "./types";
+export type ActionLogBackend = {
+    append(event: ActionLogEvent): Promise<void>;
+    getBranch(invocationId: string): Promise<ActionLogEvent[]>;
+    getTip(invocationId: string): Promise<ActionLogEvent | null>;
+    getOpenByToolId(toolId: ToolId): Promise<OpenInvocationState | null>;
+    getOpenInvocations(): Promise<OpenInvocationState[]>;
+    feed?(events: ActionLogEvent[]): Promise<void>;
+    reload?(): Promise<void>;
+    close?(): Promise<void>;
+};

package/dist/actionlog/backend.js

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

package/dist/actionlog/idbBackend.d.ts

@@ -0,0 +1,19 @@
+import type { ActionLogBackend } from "./backend";
+import type { ActionLogEvent, OpenInvocationState } from "./types";
+import type { ToolId } from "../tools/monero-tools";
+export declare class ActionLogIdbBackend implements ActionLogBackend {
+    private readonly db;
+    private open;
+    private constructor();
+    static open(dbName?: string): Promise<ActionLogIdbBackend>;
+    private rebuildOpenMaps;
+    private getAllEventsOrdered;
+    append(event: ActionLogEvent): Promise<void>;
+    getBranch(invocationId: string): Promise<ActionLogEvent[]>;
+    getTip(invocationId: string): Promise<ActionLogEvent | null>;
+    getOpenByToolId(toolId: ToolId): Promise<OpenInvocationState | null>;
+    getOpenInvocations(): Promise<OpenInvocationState[]>;
+    feed(events: ActionLogEvent[]): Promise<void>;
+    reload(): Promise<void>;
+    close(): Promise<void>;
+}