@spirobel/monero-wallet-api 0.1.0

package/dist/node-interaction/jsonEndpoints.d.ts

@@ -0,0 +1,281 @@
+import { z } from "zod";
+export declare const GetInfoResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: z.ZodObject<{
+        adjusted_time: z.ZodNumber;
+        alt_blocks_count: z.ZodNumber;
+        block_size_limit: z.ZodNumber;
+        block_size_median: z.ZodNumber;
+        block_weight_limit: z.ZodNumber;
+        block_weight_median: z.ZodNumber;
+        bootstrap_daemon_address: z.ZodString;
+        busy_syncing: z.ZodBoolean;
+        credits: z.ZodNumber;
+        cumulative_difficulty: z.ZodNumber;
+        cumulative_difficulty_top64: z.ZodNumber;
+        database_size: z.ZodNumber;
+        difficulty: z.ZodNumber;
+        difficulty_top64: z.ZodNumber;
+        free_space: z.ZodNumber;
+        grey_peerlist_size: z.ZodNumber;
+        height: z.ZodNumber;
+        height_without_bootstrap: z.ZodNumber;
+        incoming_connections_count: z.ZodNumber;
+        mainnet: z.ZodBoolean;
+        nettype: z.ZodString;
+        offline: z.ZodBoolean;
+        outgoing_connections_count: z.ZodNumber;
+        restricted: z.ZodBoolean;
+        rpc_connections_count: z.ZodNumber;
+        stagenet: z.ZodBoolean;
+        start_time: z.ZodNumber;
+        status: z.ZodString;
+        synchronized: z.ZodBoolean;
+        target: z.ZodNumber;
+        target_height: z.ZodNumber;
+        testnet: z.ZodBoolean;
+        top_block_hash: z.ZodString;
+        top_hash: z.ZodString;
+        tx_count: z.ZodNumber;
+        tx_pool_size: z.ZodNumber;
+        untrusted: z.ZodBoolean;
+        update_available: z.ZodBoolean;
+        version: z.ZodString;
+        was_bootstrap_ever_used: z.ZodBoolean;
+        white_peerlist_size: z.ZodNumber;
+        wide_cumulative_difficulty: z.ZodString;
+        wide_difficulty: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        adjusted_time: number;
+        alt_blocks_count: number;
+        block_size_limit: number;
+        block_size_median: number;
+        block_weight_limit: number;
+        block_weight_median: number;
+        bootstrap_daemon_address: string;
+        busy_syncing: boolean;
+        credits: number;
+        cumulative_difficulty: number;
+        cumulative_difficulty_top64: number;
+        database_size: number;
+        difficulty: number;
+        difficulty_top64: number;
+        free_space: number;
+        grey_peerlist_size: number;
+        height: number;
+        height_without_bootstrap: number;
+        incoming_connections_count: number;
+        mainnet: boolean;
+        nettype: string;
+        offline: boolean;
+        outgoing_connections_count: number;
+        restricted: boolean;
+        rpc_connections_count: number;
+        stagenet: boolean;
+        start_time: number;
+        synchronized: boolean;
+        target: number;
+        target_height: number;
+        testnet: boolean;
+        top_block_hash: string;
+        top_hash: string;
+        tx_count: number;
+        tx_pool_size: number;
+        untrusted: boolean;
+        update_available: boolean;
+        version: string;
+        was_bootstrap_ever_used: boolean;
+        white_peerlist_size: number;
+        wide_cumulative_difficulty: string;
+        wide_difficulty: string;
+    }, {
+        status: string;
+        adjusted_time: number;
+        alt_blocks_count: number;
+        block_size_limit: number;
+        block_size_median: number;
+        block_weight_limit: number;
+        block_weight_median: number;
+        bootstrap_daemon_address: string;
+        busy_syncing: boolean;
+        credits: number;
+        cumulative_difficulty: number;
+        cumulative_difficulty_top64: number;
+        database_size: number;
+        difficulty: number;
+        difficulty_top64: number;
+        free_space: number;
+        grey_peerlist_size: number;
+        height: number;
+        height_without_bootstrap: number;
+        incoming_connections_count: number;
+        mainnet: boolean;
+        nettype: string;
+        offline: boolean;
+        outgoing_connections_count: number;
+        restricted: boolean;
+        rpc_connections_count: number;
+        stagenet: boolean;
+        start_time: number;
+        synchronized: boolean;
+        target: number;
+        target_height: number;
+        testnet: boolean;
+        top_block_hash: string;
+        top_hash: string;
+        tx_count: number;
+        tx_pool_size: number;
+        untrusted: boolean;
+        update_available: boolean;
+        version: string;
+        was_bootstrap_ever_used: boolean;
+        white_peerlist_size: number;
+        wide_cumulative_difficulty: string;
+        wide_difficulty: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    jsonrpc: "2.0";
+    result: {
+        status: string;
+        adjusted_time: number;
+        alt_blocks_count: number;
+        block_size_limit: number;
+        block_size_median: number;
+        block_weight_limit: number;
+        block_weight_median: number;
+        bootstrap_daemon_address: string;
+        busy_syncing: boolean;
+        credits: number;
+        cumulative_difficulty: number;
+        cumulative_difficulty_top64: number;
+        database_size: number;
+        difficulty: number;
+        difficulty_top64: number;
+        free_space: number;
+        grey_peerlist_size: number;
+        height: number;
+        height_without_bootstrap: number;
+        incoming_connections_count: number;
+        mainnet: boolean;
+        nettype: string;
+        offline: boolean;
+        outgoing_connections_count: number;
+        restricted: boolean;
+        rpc_connections_count: number;
+        stagenet: boolean;
+        start_time: number;
+        synchronized: boolean;
+        target: number;
+        target_height: number;
+        testnet: boolean;
+        top_block_hash: string;
+        top_hash: string;
+        tx_count: number;
+        tx_pool_size: number;
+        untrusted: boolean;
+        update_available: boolean;
+        version: string;
+        was_bootstrap_ever_used: boolean;
+        white_peerlist_size: number;
+        wide_cumulative_difficulty: string;
+        wide_difficulty: string;
+    };
+}, {
+    id: string;
+    jsonrpc: "2.0";
+    result: {
+        status: string;
+        adjusted_time: number;
+        alt_blocks_count: number;
+        block_size_limit: number;
+        block_size_median: number;
+        block_weight_limit: number;
+        block_weight_median: number;
+        bootstrap_daemon_address: string;
+        busy_syncing: boolean;
+        credits: number;
+        cumulative_difficulty: number;
+        cumulative_difficulty_top64: number;
+        database_size: number;
+        difficulty: number;
+        difficulty_top64: number;
+        free_space: number;
+        grey_peerlist_size: number;
+        height: number;
+        height_without_bootstrap: number;
+        incoming_connections_count: number;
+        mainnet: boolean;
+        nettype: string;
+        offline: boolean;
+        outgoing_connections_count: number;
+        restricted: boolean;
+        rpc_connections_count: number;
+        stagenet: boolean;
+        start_time: number;
+        synchronized: boolean;
+        target: number;
+        target_height: number;
+        testnet: boolean;
+        top_block_hash: string;
+        top_hash: string;
+        tx_count: number;
+        tx_pool_size: number;
+        untrusted: boolean;
+        update_available: boolean;
+        version: string;
+        was_bootstrap_ever_used: boolean;
+        white_peerlist_size: number;
+        wide_cumulative_difficulty: string;
+        wide_difficulty: string;
+    };
+}>;
+export type GetInfoResponse = z.infer<typeof GetInfoResponseSchema>;
+export declare function parseGetInfoResponse(data: unknown): GetInfoResponse | null;
+export declare function get_info(NODE_URL: string): Promise<{
+    status: string;
+    adjusted_time: number;
+    alt_blocks_count: number;
+    block_size_limit: number;
+    block_size_median: number;
+    block_weight_limit: number;
+    block_weight_median: number;
+    bootstrap_daemon_address: string;
+    busy_syncing: boolean;
+    credits: number;
+    cumulative_difficulty: number;
+    cumulative_difficulty_top64: number;
+    database_size: number;
+    difficulty: number;
+    difficulty_top64: number;
+    free_space: number;
+    grey_peerlist_size: number;
+    height: number;
+    height_without_bootstrap: number;
+    incoming_connections_count: number;
+    mainnet: boolean;
+    nettype: string;
+    offline: boolean;
+    outgoing_connections_count: number;
+    restricted: boolean;
+    rpc_connections_count: number;
+    stagenet: boolean;
+    start_time: number;
+    synchronized: boolean;
+    target: number;
+    target_height: number;
+    testnet: boolean;
+    top_block_hash: string;
+    top_hash: string;
+    tx_count: number;
+    tx_pool_size: number;
+    untrusted: boolean;
+    update_available: boolean;
+    version: string;
+    was_bootstrap_ever_used: boolean;
+    white_peerlist_size: number;
+    wide_cumulative_difficulty: string;
+    wide_difficulty: string;
+}>;

package/dist/node-interaction/jsonEndpoints.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export const GetInfoResponseSchema = z.object({
+    id: z.string(),
+    jsonrpc: z.literal("2.0"),
+    result: z.object({
+        adjusted_time: z.number(),
+        alt_blocks_count: z.number(),
+        block_size_limit: z.number(),
+        block_size_median: z.number(),
+        block_weight_limit: z.number(),
+        block_weight_median: z.number(),
+        bootstrap_daemon_address: z.string(),
+        busy_syncing: z.boolean(),
+        credits: z.number(),
+        cumulative_difficulty: z.number(),
+        cumulative_difficulty_top64: z.number(),
+        database_size: z.number(),
+        difficulty: z.number(),
+        difficulty_top64: z.number(),
+        free_space: z.number(),
+        grey_peerlist_size: z.number(),
+        height: z.number(),
+        height_without_bootstrap: z.number(),
+        incoming_connections_count: z.number(),
+        mainnet: z.boolean(),
+        nettype: z.string(),
+        offline: z.boolean(),
+        outgoing_connections_count: z.number(),
+        restricted: z.boolean(),
+        rpc_connections_count: z.number(),
+        stagenet: z.boolean(),
+        start_time: z.number(),
+        status: z.string(),
+        synchronized: z.boolean(),
+        target: z.number(),
+        target_height: z.number(),
+        testnet: z.boolean(),
+        top_block_hash: z.string(),
+        top_hash: z.string(),
+        tx_count: z.number(),
+        tx_pool_size: z.number(),
+        untrusted: z.boolean(),
+        update_available: z.boolean(),
+        version: z.string(),
+        was_bootstrap_ever_used: z.boolean(),
+        white_peerlist_size: z.number(),
+        wide_cumulative_difficulty: z.string(),
+        wide_difficulty: z.string(),
+    }),
+});
+export function parseGetInfoResponse(data) {
+    const result = GetInfoResponseSchema.safeParse(data);
+    if (result.success) {
+        return result.data;
+    }
+    else {
+        console.error("Validation failed:", result.error);
+        return null;
+    }
+}
+export async function get_info(NODE_URL) {
+    const getInfoResponse = await fetch(NODE_URL + "/json_rpc", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: "0",
+            method: "get_info",
+        }),
+    });
+    if (!getInfoResponse.ok) {
+        throw new Error(`Failed to get info: ${getInfoResponse.statusText}`);
+    }
+    const getInfoResult = await getInfoResponse.json();
+    const parsedResult = parseGetInfoResponse(getInfoResult);
+    if (parsedResult === null || !parsedResult.result?.height) {
+        throw new Error("Failed to get height from get_info result");
+    }
+    return parsedResult.result;
+}

package/dist/wasi.d.ts

@@ -0,0 +1,26 @@
+export declare class TinyWASI {
+    private instance?;
+    private WASI_ERRNO_SUCCESS;
+    private WASI_ERRNO_BADF;
+    private WASI_ERRNO_NOSYS;
+    private WASI_ERRNO_INVAL;
+    private WASI_FILETYPE_CHARACTER_DEVICE;
+    private WASI_RIGHTS_FD_SYNC;
+    private WASI_RIGHTS_FD_WRITE;
+    private WASI_RIGHTS_FD_FILESTAT_GET;
+    private WASI_FDFLAGS_APPEND;
+    private nameSpaces;
+    constructor(trace?: boolean);
+    initialize(instance: WebAssembly.Instance): void;
+    get imports(): WebAssembly.Imports;
+    getMemory(): WebAssembly.Memory;
+    getDataView(): DataView;
+    private trace;
+    private nosys;
+    private clock_res_get;
+    private clock_time_get;
+    private fd_fdstat_get;
+    private fd_write;
+    private random_get;
+    private environ_sizes_get;
+}

package/dist/wasi.js

@@ -0,0 +1,174 @@
+import * as crypto from "crypto";
+//vendored from https://github.com/qrdate/tinywasi/blob/main/src/TinyWASI.ts
+export class TinyWASI {
+    instance = undefined;
+    WASI_ERRNO_SUCCESS = 0;
+    WASI_ERRNO_BADF = 8;
+    WASI_ERRNO_NOSYS = 52;
+    WASI_ERRNO_INVAL = 28;
+    WASI_FILETYPE_CHARACTER_DEVICE = 2;
+    WASI_RIGHTS_FD_SYNC = 1 << 4;
+    WASI_RIGHTS_FD_WRITE = 1 << 6;
+    WASI_RIGHTS_FD_FILESTAT_GET = 1 << 21;
+    WASI_FDFLAGS_APPEND = 1 << 0;
+    nameSpaces = {
+        wasi_snapshot_preview1: {
+            args_get: undefined, // ((param i32 i32) (result i32))
+            args_sizes_get: undefined, // ((param i32 i32) (result i32))
+            clock_res_get: this.clock_res_get, // ((param i32 i32) (result i32))
+            clock_time_get: this.clock_time_get, // ((param i32 i64 i32) (result i32))
+            environ_get: undefined, // ((param i32 i32) (result i32))
+            environ_sizes_get: this.environ_sizes_get, // ((param i32 i32) (result i32))
+            fd_advise: undefined, // ((param i32 i64 i64 i32) (result i32))
+            fd_allocate: undefined, // ((param i32 i64 i64) (result i32))
+            fd_close: undefined, // ((param i32) (result i32))
+            fd_datasync: undefined, // ((param i32) (result i32))
+            fd_fdstat_get: this.fd_fdstat_get, // ((param i32 i32) (result i32))
+            fd_fdstat_set_flags: undefined, // ((param i32 i32) (result i32))
+            fd_fdstat_set_rights: undefined, // ((param i32 i64 i64) (result i32))
+            fd_filestat_get: undefined, // ((param i32 i32) (result i32))
+            fd_filestat_set_size: undefined, // ((param i32 i64) (result i32))
+            fd_filestat_set_times: undefined, // ((param i32 i64 i64 i32) (result i32))
+            fd_pread: undefined, // ((param i32 i32 i32 i64 i32) (result i32))
+            fd_prestat_dir_name: undefined, // ((param i32 i32 i32) (result i32))
+            fd_prestat_get: undefined, // ((param i32 i32) (result i32))
+            fd_pwrite: undefined, // ((param i32 i32 i32 i64 i32) (result i32))
+            fd_read: undefined, // ((param i32 i32 i32 i32) (result i32))
+            fd_readdir: undefined, // ((param i32 i32 i32 i64 i32) (result i32))
+            fd_renumber: undefined, // ((param i32 i32) (result i32))
+            fd_seek: undefined, // ((param i32 i64 i32 i32) (result i32))
+            fd_sync: undefined, // ((param i32) (result i32))
+            fd_tell: undefined, // ((param i32 i32) (result i32))
+            fd_write: this.fd_write, // ((param i32 i32 i32 i32) (result i32))
+            path_create_directory: undefined, // ((param i32 i32 i32) (result i32))
+            path_filestat_get: undefined, // ((param i32 i32 i32 i32 i32) (result i32))
+            path_filestat_set_times: undefined, // ((param i32 i32 i32 i32 i64 i64 i32) (result i32))
+            path_link: undefined, // ((param i32 i32 i32 i32 i32 i32 i32) (result i32))
+            path_open: undefined, // ((param i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i32))
+            path_readlink: undefined, // ((param i32 i32 i32 i32 i32 i32) (result i32))
+            path_remove_directory: undefined, // ((param i32 i32 i32) (result i32))
+            path_rename: undefined, // ((param i32 i32 i32 i32 i32 i32) (result i32))
+            path_symlink: undefined, // ((param i32 i32 i32 i32 i32) (result i32))
+            path_unlink_file: undefined, // ((param i32 i32 i32) (result i32))
+            poll_oneoff: undefined, // ((param i32 i32 i32 i32) (result i32))
+            proc_exit: undefined, // ((param i32))
+            proc_raise: undefined, // ((param i32) (result i32))
+            random_get: this.random_get, // ((param i32 i32) (result i32))
+            sched_yield: undefined, // ((result i32))
+            sock_recv: undefined, // ((param i32 i32 i32 i32 i32 i32) (result i32))
+            sock_send: undefined, // ((param i32 i32 i32 i32 i32) (result i32))
+            sock_shutdown: undefined, // ((param i32 i32) (result i32))
+        },
+    };
+    constructor(trace) {
+        for (const ns of Object.keys(this.nameSpaces)) {
+            const nameSpace = this.nameSpaces[ns];
+            for (const fn of Object.keys(nameSpace)) {
+                let func = nameSpace[fn] || this.nosys(fn);
+                func = func.bind(this);
+                if (trace)
+                    func = this.trace(fn, func).bind(this);
+                nameSpace[fn] = func;
+            }
+        }
+    }
+    initialize(instance) {
+        this.instance = instance;
+    }
+    get imports() {
+        return this.nameSpaces;
+    }
+    getMemory() {
+        if (this.instance)
+            return this.instance.exports.memory;
+        else
+            throw new Error("Attempt to access instance before initialisation!");
+    }
+    getDataView() {
+        if (this.instance)
+            return new DataView(this.instance.exports.memory.buffer);
+        else
+            throw new Error("Attempt to access instance before initialisation!");
+    }
+    trace(name, origFunc) {
+        return (...args) => {
+            const result = origFunc(...args);
+            console.log(`Trace: ${name}(${args.toString()}) -> ${result}`);
+            return result;
+        };
+    }
+    nosys(name) {
+        return (...args) => {
+            console.error(`Unimplemented call to ${name}(${args.toString()})`);
+            return this.WASI_ERRNO_NOSYS;
+        };
+    }
+    clock_res_get(id, resOut) {
+        if (id !== 0)
+            return this.WASI_ERRNO_INVAL;
+        const view = this.getDataView();
+        view.setUint32(resOut, 1000000.0 % 0x100000000, true);
+        view.setUint32(resOut + 4, 1000000.0 / 0x100000000, true);
+        return this.WASI_ERRNO_SUCCESS;
+    }
+    clock_time_get(id, precision, timeOut) {
+        if (id !== 0)
+            return this.WASI_ERRNO_INVAL;
+        const view = this.getDataView();
+        const now = new Date().getTime();
+        view.setUint32(timeOut, (now * 1000000.0) % 0x100000000, true);
+        view.setUint32(timeOut + 4, (now * 1000000.0) / 0x100000000, true);
+        return this.WASI_ERRNO_SUCCESS;
+    }
+    fd_fdstat_get(fd, fdstat) {
+        if (fd > 2)
+            return this.WASI_ERRNO_BADF;
+        const view = this.getDataView();
+        view.setUint8(fdstat, this.WASI_FILETYPE_CHARACTER_DEVICE);
+        view.setUint16(fdstat + 2, this.WASI_FDFLAGS_APPEND, true);
+        view.setUint16(fdstat + 8, this.WASI_RIGHTS_FD_SYNC |
+            this.WASI_RIGHTS_FD_WRITE |
+            this.WASI_RIGHTS_FD_FILESTAT_GET, true);
+        view.setUint16(fdstat + 16, 0, true);
+        return this.WASI_ERRNO_SUCCESS;
+    }
+    fd_write(fd, iovs, iovsLen, nwritten) {
+        if (fd > 2)
+            return this.WASI_ERRNO_BADF;
+        const view = this.getDataView();
+        const memory = this.getMemory();
+        const buffers = [];
+        for (let i = 0; i < iovsLen; i++) {
+            const iov = iovs + i * 8;
+            const offset = view.getUint32(iov, true);
+            const len = view.getUint32(iov + 4, true);
+            buffers.push(new Uint8Array(memory.buffer, offset, len));
+        }
+        const length = buffers.reduce((s, b) => s + b.length, 0);
+        const buffer = new Uint8Array(length);
+        let offset = 0;
+        buffers.forEach((b) => {
+            buffer.set(b, offset);
+            offset += b.length;
+        });
+        const string = new TextDecoder("utf-8").decode(buffer).replace(/\n$/, "");
+        if (fd === 1)
+            console.log(string);
+        else
+            console.error(string);
+        view.setUint32(nwritten, buffer.length, true);
+        return this.WASI_ERRNO_SUCCESS;
+    }
+    random_get(pointer, size) {
+        const memory = this.getMemory();
+        const buffer = new Uint8Array(memory.buffer, pointer, size);
+        crypto.randomFillSync(buffer);
+        return this.WASI_ERRNO_SUCCESS;
+    }
+    environ_sizes_get(environCount, environBufSize) {
+        var view = this.getDataView();
+        view.setUint32(environCount, 0, !0);
+        view.setUint32(environBufSize, 0, !0);
+        return this.WASI_ERRNO_SUCCESS;
+    }
+}

package/dist/wasm-processing/wasi.d.ts

@@ -0,0 +1,26 @@
+export declare class TinyWASI {
+    instance?: WebAssembly.Instance;
+    private WASI_ERRNO_SUCCESS;
+    private WASI_ERRNO_BADF;
+    private WASI_ERRNO_NOSYS;
+    private WASI_ERRNO_INVAL;
+    private WASI_FILETYPE_CHARACTER_DEVICE;
+    private WASI_RIGHTS_FD_SYNC;
+    private WASI_RIGHTS_FD_WRITE;
+    private WASI_RIGHTS_FD_FILESTAT_GET;
+    private WASI_FDFLAGS_APPEND;
+    private nameSpaces;
+    constructor(trace?: boolean);
+    initialize(instance: WebAssembly.Instance): void;
+    get imports(): WebAssembly.Imports;
+    getMemory(): WebAssembly.Memory;
+    getDataView(): DataView;
+    private trace;
+    private nosys;
+    private clock_res_get;
+    private clock_time_get;
+    private fd_fdstat_get;
+    private fd_write;
+    private random_get;
+    private environ_sizes_get;
+}