@spirobel/monero-wallet-api 0.5.4 → 0.6.0

package/dist/tools/globals.d.ts

@@ -0,0 +1,196 @@
+import type { ToolWorkerContext } from "../actionlog/actionLogTypes";
+export declare const TOOL_MAGIC_STRING = "monerochan";
+export type ToolInvocationValidity = "valid" | "invalid" | "unverified";
+export type ExtensionMessageByKind = {
+    toolCall: {
+        tool: {
+            tool_id: string;
+            payload: unknown;
+        };
+        destination_domain: string;
+        context_domain: string;
+        found_in: "link" | "linkText";
+        link: string;
+        linkText: string;
+        timestamp: number;
+        invocation_id: string;
+        context_href: string;
+        valid: ToolInvocationValidity;
+    };
+    execute: {
+        invocationId: string;
+        args?: Record<string, unknown>;
+    };
+    dismiss: {
+        invocationId: string;
+    };
+    dismissNotice: {
+        noticeId: string;
+    };
+    openSidebar: null;
+    actionLogChanged: null;
+    walletCacheChanged: string;
+    "worker.setNodeUrl": {
+        node_url?: string;
+    };
+    "worker.setStartHeight": {
+        start_height?: number | null;
+    };
+    "worker.changeNodeUrlAndStartHeight": {
+        node_url?: string;
+        start_height?: number | null;
+    };
+    "worker.buildWallets": null;
+    "worker.stopWorker": null;
+    "worker.makeSignSend": {
+        primary_address: string;
+        payments: {
+            address: string;
+            amount: string;
+        }[];
+        input_indexes: string[];
+    };
+    "worker.sweepSignSend": {
+        primary_address: string;
+        address: string;
+        input_indexes: string[];
+    };
+    "worker.rebroadcastTx": {
+        primary_address: string;
+        tx_log_index: number;
+    };
+    "worker.dismissSendPlate": {
+        primary_address: string;
+    };
+    "worker.setLogSettings": {
+        logs?: "console" | "file" | "console-and-file" | "off" | null;
+        logs_include?: string[] | null;
+        logs_exclude?: string[] | null;
+    };
+    "worker.getTxLogs": null;
+    shareViewkeyOK: {
+        invocationId: string;
+    };
+    shareViewkeyFAILED: {
+        viewkey: string;
+        primary_address: string;
+        error?: string;
+        tool_invo: {
+            tool: {
+                tool_id: string;
+                payload: unknown;
+            };
+            found_in: "link" | "linkText";
+            link: string;
+            linkText: string;
+            valid: ToolInvocationValidity;
+        };
+    };
+};
+export type ExtensionMessageKind = keyof ExtensionMessageByKind;
+export type ToolPermission = "spend" | "share_view";
+export type ToolNotice = {
+    id: string;
+    permission: ToolPermission;
+    title: string;
+    message: string;
+    context_domain?: string;
+    context_href?: string;
+    wallet_slot?: number;
+    timestamp?: number | string;
+};
+export type ToolUiCopy = {
+    openTitle: string;
+    acceptLabel?: string;
+    dismissLabel?: string;
+};
+export type ExtensionPort = {
+    name: string;
+    postMessage: (msg: unknown) => void;
+    disconnect: () => void;
+    onMessage: {
+        addListener: (cb: (msg: unknown) => void) => void;
+    };
+    onDisconnect: {
+        addListener: (cb: () => void) => void;
+    };
+};
+export type ExtensionRuntime = {
+    sendMessage: (msg: unknown) => Promise<unknown>;
+    connect: (info: {
+        name: string;
+    }) => ExtensionPort;
+    onMessage: {
+        addListener: (cb: (msg: unknown, sender: unknown) => void) => void;
+    };
+    onConnect: {
+        addListener: (cb: (port: ExtensionPort) => void) => void;
+    };
+};
+export declare function getExtensionRuntime(): ExtensionRuntime | null;
+export declare function sendToBackground<K extends ExtensionMessageKind>(kind: K, payload: ExtensionMessageByKind[K]): Promise<unknown>;
+export type PortMessageByKind = {
+    shareViewkey: {
+        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 PortMessageKind = keyof PortMessageByKind;
+export declare function sendToPort<K extends PortMessageKind>(port: ExtensionPort, kind: K, payload: PortMessageByKind[K]): void;
+export type ToolInvocationForValidate = {
+    tool: {
+        tool_id: string;
+        payload: unknown;
+    };
+    destination_domain: string;
+    context_domain: string;
+    found_in: "link" | "linkText";
+    link: string;
+    linkText: string;
+    timestamp: number;
+    invocation_id: string;
+    context_href: string;
+    valid: ToolInvocationValidity;
+};
+export type ToolContentZone<TPayload = unknown> = {
+    recognize_parse: (args: string[]) => {
+        tool_id: string;
+        payload: TPayload;
+    } | null;
+    validate_check?: (invo: ToolInvocationForValidate) => Promise<ToolInvocationValidity> | ToolInvocationValidity;
+    execute_deliver?: (invo: ToolInvocationForValidate) => void;
+};
+export type ToolWorkerZone = {
+    invoke_write?: (ctx: ToolWorkerContext, invo: ToolInvocationForValidate) => Promise<void>;
+    validate_write?: (ctx: ToolWorkerContext, invo: ToolInvocationForValidate) => Promise<void>;
+    accept_yes?: (ctx: ToolWorkerContext, invocationId: string, args: Record<string, unknown>) => Promise<void>;
+    accept_no?: (ctx: ToolWorkerContext, invocationId: string) => Promise<void>;
+    execute_run?: (ctx: ToolWorkerContext, invocationId: string, args: Record<string, unknown>) => Promise<void>;
+    execute_abort?: (ctx: ToolWorkerContext, invocationId: string) => Promise<void>;
+    execute_ok?: (ctx: ToolWorkerContext, payload: {
+        invocationId: string;
+    }) => Promise<void>;
+    execute_fail?: (ctx: ToolWorkerContext, payload: unknown) => Promise<void>;
+};
+export type ToolCounterpartyZone<TPayload = unknown, TExtra extends object = {}> = {
+    make: (payload: TPayload) => string;
+} & TExtra;
+export type ToolArm<TPayload = unknown, TCounterpartyExtra extends object = {}> = {
+    permissions: readonly ToolPermission[];
+    ui: ToolUiCopy;
+    content: ToolContentZone<TPayload>;
+    worker: ToolWorkerZone;
+    counterparty: ToolCounterpartyZone<TPayload, TCounterpartyExtra>;
+};

package/dist/tools/globals.js

@@ -0,0 +1,14 @@
+export const TOOL_MAGIC_STRING = "monerochan";
+export function getExtensionRuntime() {
+    const g = globalThis;
+    return g.browser?.runtime ?? g.chrome?.runtime ?? null;
+}
+export function sendToBackground(kind, payload) {
+    const rt = getExtensionRuntime();
+    if (!rt?.sendMessage)
+        return Promise.resolve(null);
+    return rt.sendMessage({ kind, payload });
+}
+export function sendToPort(port, kind, payload) {
+    port.postMessage({ kind, payload });
+}

package/dist/tools/monero-tools-content.d.ts

@@ -0,0 +1,29 @@
+/**
+ * content-script entry graph only. do not import api.ts (indexedDB top-level await).
+ */
+import { type ToolInvocationValidity } from "./globals";
+import { type SendTransactionTool } from "./calls/001";
+import { type CreateAndShareViewOnlyWalletTool } from "./calls/002";
+export type MoneroTool = SendTransactionTool | CreateAndShareViewOnlyWalletTool;
+export type ToolId = "001" | "002";
+export type ParsedMoneroToolInvocation = {
+    tool: MoneroTool;
+    destination_domain: string;
+    context_domain: string;
+    found_in: "link" | "linkText";
+    link: string;
+    linkText: string;
+    timestamp: number;
+    invocation_id: string;
+    context_href: string;
+    valid: ToolInvocationValidity;
+};
+export declare const tools: {
+    readonly "001": import("./toolArm").ToolArm<import("./monero-tools").SendTransactionToolPayload>;
+    readonly "002": import("./toolArm").ToolArm<import("./monero-tools").CreateAndShareViewOnlyWalletToolPayload>;
+};
+export declare function getDomainWithTLD(hostname: string): string;
+export declare function parseDestination(destination: string): string;
+export declare function parseToolLink(link: string): MoneroTool | null;
+export declare function parseToolInvocation(link: string, linkText: string, context_location: Location): ParsedMoneroToolInvocation | null;
+export declare function checkToolInvocationValidity(invo: ParsedMoneroToolInvocation): Promise<ToolInvocationValidity>;

package/dist/tools/monero-tools-content.js

@@ -0,0 +1,80 @@
+/**
+ * content-script entry graph only. do not import api.ts (indexedDB top-level await).
+ */
+import { TOOL_MAGIC_STRING, } from "./globals";
+import { parseSendTransactionToolArgs, } from "./calls/001";
+import tool001 from "./calls/001";
+import tool002, { parseCreateAndShareViewOnlyWalletToolArgs, } from "./calls/002";
+export const tools = {
+    "001": tool001,
+    "002": tool002,
+};
+export function getDomainWithTLD(hostname) {
+    const parts = hostname.split(".");
+    if (parts.length <= 1)
+        return hostname;
+    return parts.slice(-2).join(".");
+}
+export function parseDestination(destination) {
+    const url = new URL(destination);
+    return getDomainWithTLD(url.hostname);
+}
+export function parseToolLink(link) {
+    const magic_str_index = link.lastIndexOf(TOOL_MAGIC_STRING);
+    if (magic_str_index === -1)
+        return null;
+    const link_start_index = magic_str_index + TOOL_MAGIC_STRING.length;
+    const tool_id = link.substring(link_start_index, link_start_index + 3);
+    const args = link
+        .substring(link_start_index + 3)
+        .split("_")
+        .slice(1);
+    if (tool_id === "001")
+        return parseSendTransactionToolArgs(args);
+    if (tool_id === "002")
+        return parseCreateAndShareViewOnlyWalletToolArgs(args);
+    return null;
+}
+export function parseToolInvocation(link, linkText, context_location) {
+    const context_domain = getDomainWithTLD(context_location.hostname);
+    const context_href = context_location.href;
+    const link_parse = parseToolLink(link);
+    if (link_parse) {
+        return {
+            tool: link_parse,
+            destination_domain: parseDestination(link),
+            context_domain,
+            found_in: "link",
+            link,
+            linkText,
+            timestamp: Date.now(),
+            invocation_id: crypto.randomUUID(),
+            context_href,
+            valid: "unverified",
+        };
+    }
+    const linkText_parse = parseToolLink(linkText);
+    if (linkText_parse) {
+        return {
+            tool: linkText_parse,
+            destination_domain: parseDestination(linkText),
+            context_domain,
+            found_in: "linkText",
+            link,
+            linkText,
+            timestamp: Date.now(),
+            invocation_id: crypto.randomUUID(),
+            context_href,
+            valid: "unverified",
+        };
+    }
+    return null;
+}
+export async function checkToolInvocationValidity(invo) {
+    const id = invo.tool.tool_id;
+    const arm = tools[id];
+    const validate = arm?.content?.validate;
+    if (!validate)
+        return "unverified";
+    return validate(invo);
+}

package/dist/tools/monero-tools.d.ts

@@ -1,7 +1,27 @@
-import type { ScanSettingOpened } from "../api";
-export declare const TOOL_MAGIC_STRING = "monerochan";
-export declare function parseToolLink(link: string): MoneroTool | null;
-export type ToolInvocationValidity = "valid" | "invalid" | "unverified";
+import { TOOL_MAGIC_STRING, type ToolArm, type ToolInvocationValidity, type ToolPermission, type ToolUiCopy } from "./globals";
+export { TOOL_MAGIC_STRING, type ToolInvocationValidity };
+export type { ToolArm, ToolContentZone, ToolCounterpartyZone, ToolInvocationForValidate, ToolWorkerZone, } from "./globals";
+export type { ToolUiCopy, ToolNotice, ToolPermission, } from "./globals";
+export declare const tools: {
+    readonly "001": ToolArm<import("./calls/001").SendTransactionToolPayload, {
+        validate_route: (deps: {
+            isPayAddressKnown: import("./calls/001").IsPayAddressKnown;
+        }) => (req: Request) => Promise<Response>;
+    }>;
+    readonly "002": ToolArm<import("./calls/002").CreateAndShareViewOnlyWalletToolPayload, {
+        execute_route: (mco: import("./calls/002").ShareViewMco, opts?: import("./calls/002").HandleShareOpts) => (req: Request) => Promise<Response>;
+    }>;
+};
+export type ToolId = keyof typeof tools;
+export declare const TOOL_IDS: ToolId[];
+export declare function getToolUiByPermissions(permissions: ToolPermission[]): ToolUiCopy | null;
+type PayloadOf<A> = A extends ToolArm<infer P, infer _E> ? P : never;
+export type MoneroTool = {
+    [K in ToolId]: {
+        tool_id: K;
+        payload: PayloadOf<(typeof tools)[K]>;
+    };
+}[ToolId];
 export type ParsedMoneroToolInvocation = {
     tool: MoneroTool;
     destination_domain: string;
@@ -14,54 +34,9 @@ export type ParsedMoneroToolInvocation = {
     context_href: string;
     valid: ToolInvocationValidity;
 };
-export declare function parseToolInvocation(link: string, linkText: string, context_location: Location): ParsedMoneroToolInvocation | null;
-export type SendTransactionTool = {
-    tool_id: "001";
-    payload: SendTransactionToolPayload;
-};
-export type SendTransactionToolPayload = {
-    address: string;
-    amount: string;
-};
-export declare function parseSendTransactionToolArgs(args: string[]): SendTransactionTool | null;
-export declare function createSendTransactionToolLink(address: string, amount: string): string;
-export declare function make001ToolLink(address: string, amount: string): string;
-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 type MoneroTool = SendTransactionTool | CreateAndShareViewOnlyWalletTool;
+export declare function parseToolLink(link: string): MoneroTool | null;
 export declare function createToolLink(tool: MoneroTool): string;
+export declare function parseToolInvocation(link: string, linkText: string, context_location: Location): ParsedMoneroToolInvocation | null;
+export declare function checkToolInvocationValidity(invo: ParsedMoneroToolInvocation): Promise<ToolInvocationValidity>;
 export declare function getDomainWithTLD(hostname: string): string;
 export declare function parseDestination(destination: string): string;
-export declare const OPEN_DOMAINS: string[];
-export declare function checkToolInvocationValidity(invo: ParsedMoneroToolInvocation): Promise<ToolInvocationValidity>;
-export declare const ADDRESS_VALID_RESPONSE: {
-    readonly valid_address: true;
-};
-export declare const ADDRESS_INVALID_RESPONSE: {
-    readonly valid_address: false;
-};
-export type ShareViewkeyPayload = {
-    viewkey: string;
-    primary_address: string;
-    tool_invo: ParsedMoneroToolInvocation;
-};
-export type ShareViewkeyResult = {
-    ok: boolean;
-    successUrl: string | null;
-};
-export declare function shareViewKey002(payload: ShareViewkeyPayload): Promise<ShareViewkeyResult>;
-export type ShareViewkey002Pruned = {
-    viewkey: string;
-    primary_address: string;
-    wallet_slot: number;
-};
-export declare function potentialSuccessRedirect002(payload: ShareViewkeyPayload): Promise<ShareViewkeyResult | undefined>;
-export declare function handle002ShareRequest(req: Request, wallets: ScanSettingOpened[], parsed_cb: (parsed_body: ShareViewkey002Pruned) => Promise<void>, successUrl?: string): Promise<ShareViewkeyResult>;