@spirobel/monero-wallet-api 0.1.0

package/dist/wasm-processing/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/wasmFile.d.ts

@@ -0,0 +1 @@
+export declare const monero_wallet_api_wasm: Uint8Array;

package/dist/wasm-processing/wasmFile.js

@@ -0,0 +1,3 @@
+import * as fs from "fs";
+const source = fs.readFileSync("../rust/target/wasm32-wasip1/release/monero_wallet_api.wasm");
+export const monero_wallet_api_wasm = new Uint8Array(source);

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

@@ -0,0 +1,78 @@
+import { TinyWASI } from "./wasi";
+export type MemoryCallback = (ptr: number, len: number) => void;
+export declare class WasmProcessor {
+    tinywasi: TinyWASI;
+    node_url: string;
+    /**
+     * This method is invoked whenever a Rust function expects an array or string parameter.
+     * You should use `writeArray` or `writeString` within the function assigned to this callback
+     * to write the data into WebAssembly (Wasm) memory before calling the corresponding Wasm method.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be written.
+     * @param len - The number of bytes to write starting from the specified `ptr`.
+     */
+    writeToWasmMemory: MemoryCallback;
+    /**
+     * This method is invoked whenever a Rust function wants to return an array or string.
+     * You should use `readArray` or `readString` within the function assigned to this callback
+     * to read the data from WebAssembly (Wasm) memory after the corresponding Wasm method has written it.
+     *
+     * @param ptr - The WebAssembly memory address from which the data should be read.
+     * @param len - The number of bytes to read starting from the specified `ptr`.
+     */
+    readFromWasmMemory: MemoryCallback;
+    /**
+     * Writes an array of bytes to a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within `writeToWasmMemory` to write data into Wasm memory.
+     * For more details, see {@link writeToWasmMemory}.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be written.
+     * @param len - The number of bytes to write starting from the specified `ptr`.
+     * @param arr - The array of bytes to write into WebAssembly memory.
+     *
+     * @see {@link writeToWasmMemory}
+     */
+    writeArray: (ptr: number, len: number, arr: Uint8Array) => void;
+    /**
+     * Writes a string to a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within `writeToWasmMemory` to write string data into Wasm memory.
+     * For more details, see {@link writeToWasmMemory}.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be written.
+     * @param len - The number of bytes to write starting from the specified `ptr`.
+     * @param str - The string to write into WebAssembly memory.
+     *
+     * @see {@link writeToWasmMemory}
+     */
+    writeString: (ptr: number, len: number, str: string) => void;
+    /**
+     * Reads an array of bytes from a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within the function assigned to `readFromWasmMemory`
+     * callback to read data written by Rust functions into Wasm memory.
+     *
+     * @param ptr - The WebAssembly memory address from which the data should be read.
+     * @param len - The number of bytes to read starting from the specified `ptr`.
+     * @returns A Uint8Array containing the bytes read from WebAssembly memory.
+     *
+     * @see {@link readFromWasmMemory}
+     */
+    readArray: (ptr: number, len: number) => Uint8Array;
+    /**
+     * Reads a string from a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within `readFromWasmMemory` to read string data from Wasm memory.
+     * For more details, see {@link readFromWasmMemory}.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be read from.
+     * @param len - The number of bytes to read starting from the specified `ptr`.
+     * @param str - The string to read from WebAssembly memory.
+     *
+     * @see {@link readFromWasmMemory}
+     */
+    readString: (ptr: number, len: number) => string;
+    protected constructor(tinywasi: TinyWASI, node_url: string);
+    initWasmModule(): Promise<TinyWASI>;
+}

package/dist/wasm-processing/wasmProcessor.js

@@ -0,0 +1,116 @@
+import { TinyWASI } from "./wasi";
+import { monero_wallet_api_wasm } from "./wasmFile";
+export class WasmProcessor {
+    tinywasi;
+    node_url;
+    /**
+     * This method is invoked whenever a Rust function expects an array or string parameter.
+     * You should use `writeArray` or `writeString` within the function assigned to this callback
+     * to write the data into WebAssembly (Wasm) memory before calling the corresponding Wasm method.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be written.
+     * @param len - The number of bytes to write starting from the specified `ptr`.
+     */
+    writeToWasmMemory = (ptr, len) => { };
+    /**
+     * This method is invoked whenever a Rust function wants to return an array or string.
+     * You should use `readArray` or `readString` within the function assigned to this callback
+     * to read the data from WebAssembly (Wasm) memory after the corresponding Wasm method has written it.
+     *
+     * @param ptr - The WebAssembly memory address from which the data should be read.
+     * @param len - The number of bytes to read starting from the specified `ptr`.
+     */
+    readFromWasmMemory = (ptr, len) => { };
+    /**
+     * Writes an array of bytes to a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within `writeToWasmMemory` to write data into Wasm memory.
+     * For more details, see {@link writeToWasmMemory}.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be written.
+     * @param len - The number of bytes to write starting from the specified `ptr`.
+     * @param arr - The array of bytes to write into WebAssembly memory.
+     *
+     * @see {@link writeToWasmMemory}
+     */
+    writeArray = (ptr, len, arr) => {
+        const view = this.tinywasi.getDataView();
+        for (let i = 0; i < arr.length; i++) {
+            const offset = i + ptr;
+            view.setUint8(offset, arr[i]);
+        }
+    };
+    /**
+     * Writes a string to a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within `writeToWasmMemory` to write string data into Wasm memory.
+     * For more details, see {@link writeToWasmMemory}.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be written.
+     * @param len - The number of bytes to write starting from the specified `ptr`.
+     * @param str - The string to write into WebAssembly memory.
+     *
+     * @see {@link writeToWasmMemory}
+     */
+    writeString = (ptr, len, str) => {
+        const encoder = new TextEncoder();
+        const arr = encoder.encode(str);
+        this.writeArray(ptr, len, arr);
+    };
+    /**
+     * Reads an array of bytes from a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within the function assigned to `readFromWasmMemory`
+     * callback to read data written by Rust functions into Wasm memory.
+     *
+     * @param ptr - The WebAssembly memory address from which the data should be read.
+     * @param len - The number of bytes to read starting from the specified `ptr`.
+     * @returns A Uint8Array containing the bytes read from WebAssembly memory.
+     *
+     * @see {@link readFromWasmMemory}
+     */
+    readArray = (ptr, len) => {
+        const memory = this.tinywasi.getMemory();
+        return new Uint8Array(memory.buffer, ptr, len);
+    };
+    /**
+     * Reads a string from a specified offset in WebAssembly memory.
+     *
+     * This method is typically used within `readFromWasmMemory` to read string data from Wasm memory.
+     * For more details, see {@link readFromWasmMemory}.
+     *
+     * @param ptr - The WebAssembly memory address where the data should be read from.
+     * @param len - The number of bytes to read starting from the specified `ptr`.
+     * @param str - The string to read from WebAssembly memory.
+     *
+     * @see {@link readFromWasmMemory}
+     */
+    readString = (ptr, len) => {
+        const array = this.readArray(ptr, len);
+        const decoder = new TextDecoder();
+        const str = decoder.decode(array);
+        return str;
+    };
+    constructor(tinywasi, node_url) {
+        this.tinywasi = tinywasi;
+        this.node_url = node_url;
+    }
+    async initWasmModule() {
+        const tinywasi = new TinyWASI();
+        this.tinywasi = tinywasi;
+        const imports = {
+            env: {
+                input: (ptr, len) => {
+                    this.writeToWasmMemory(ptr, len);
+                },
+                output: (ptr, len) => {
+                    this.readFromWasmMemory(ptr, len);
+                },
+            },
+            ...tinywasi.imports,
+        };
+        const { module, instance } = await WebAssembly.instantiate(monero_wallet_api_wasm, imports);
+        tinywasi.initialize(instance);
+        return tinywasi;
+    }
+}

package/dist/wasmFile.d.ts

@@ -0,0 +1 @@
+export declare const monero_wallet_api_wasm: Uint8Array;