@spirobel/monero-wallet-api 0.1.0

package/README.md

@@ -0,0 +1,55 @@
+# @spirobel/monero-wallet-api
+
+To install dependencies:
+
+```bash
+cd typescript || cd ../typescript
+bun install
+```
+
+To build:
+
+```bash
+cd typescript || cd ../typescript
+bun build
+```
+
+rust release build
+
+```bash
+cd rust || cd ../rust
+cargo wasi build  --target wasm32-wasip1 --release --lib
+```
+
+## reproducible build with pinned cargo + rust + cargo wasi
+
+make the image
+
+```bash
+cd rust || cd ../rust
+docker build -t monero-wallet-api-build .
+```
+
+build the library -> find the result in target/wasm32-wasip1/release
+
+```bash
+docker run -v $(pwd):/app -it monero-wallet-api-build
+```
+
+```bash
+cd typescript || cd ../typescript
+bun run build
+bun run inlinesum
+```
+
+if the content of the checksum.txt file stays the same, the build was reproduced.
+
+to verify that the wasm file distributed on npm matches the checksum,
+add the npm package as a dependency to a project and compare the sha256sum output with the checksum.txt file in the git repo.
+
+```bash
+cd /tmp
+bun init
+bun add @spirobel/monero-wallet-api
+cat node_modules/@spirobel/monero-wallet-api/dist/wasmFile.js | sha256sum
+```

package/dist/api.d.ts

@@ -0,0 +1,55 @@
+import { type ScanResult, type ErrorResponse, type GetBlocksBinMetaCallback, type GetBlocksBinRequest } from "./node-interaction/binaryEndpoints";
+import { WasmProcessor } from "./wasm-processing/wasmProcessor";
+export * from "./node-interaction/binaryEndpoints";
+export * from "./node-interaction/jsonEndpoints";
+export type ScanResultCallback = (result: ScanResult | ErrorResponse) => void;
+/**
+ * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
+ * (similar to how you would interact with a REST api that gives you json back.)
+ * The wasm part will handle the creation of the binary requests and parse the responses and then parse them
+ * and return outputs that belong to the ViewPair.
+ * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
+ */
+export declare class ViewPair extends WasmProcessor {
+    static create(primary_address: string, secret_view_key: string, node_url?: string): Promise<ViewPair>;
+    /**
+     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param params params that will be turned into epee (moner lib that does binary serialization)
+     * @param metaCallBack contains meta information about the getBlocksbin call (new sync height = start_height param + number of blocks)
+     * @returns The difference to the same method on NodeUrl is: It returns {@link ScanResult} (outputs that belong to viewpair) and not just the blocks as json.
+     */
+    getBlocksBin(params: GetBlocksBinRequest, metaCallBack?: GetBlocksBinMetaCallback): Promise<ScanResult | ErrorResponse>;
+    /**
+     * This method will use getBlocks.bin from start height to daemon height.
+     * This is CPU bound work, so it should be executed in a seperate thread (worker).
+     * The scanner.ts worker in the standard-checkout dir shows how to keep scanning after the tip is reached.
+     * It also shows how the outputs are saved (note the unqiue requirement for the stealth_adress).
+     * @param start_height the height to start syncing from.
+     * @param callback this function will get the new outputs as they are found as a parameter
+     */
+    scan(start_height: number, callback: ScanResultCallback): Promise<void>;
+    /**
+     * This method makes an integrated Address for the Address of the Viewpair it was opened with.
+     * The network (mainnet, stagenet, testnet) is the same as the one of the Viewpairaddress.
+     * @param paymentId (u64 under the hood) you can use a random number or a primary key of an sqlite db to associate payments with customer sessions.
+     * @returns Adressstring
+     */
+    makeIntegratedAddress(paymentId: number): string;
+}
+/**
+ * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
+ * (similar to how you would interact with a REST api that gives you json back.)
+ * The wasm part will handle the creation of the binary requests and parse the responses and return them as json.
+ * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
+ */
+export declare class NodeUrl extends WasmProcessor {
+    static create(node_url?: string): Promise<NodeUrl>;
+    /**
+     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param params params that will be turned into epee (moner lib that does binary serialization)
+     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
+     */
+    getBlocksBin(params: GetBlocksBinRequest): Promise<import("./api").GetBlocksBinResponse | ErrorResponse>;
+}

package/dist/api.js

@@ -0,0 +1,103 @@
+import { getBlocksBinJson, getBlocksBinScan, } from "./node-interaction/binaryEndpoints";
+import { TinyWASI } from "./wasm-processing/wasi";
+import { WasmProcessor } from "./wasm-processing/wasmProcessor";
+export * from "./node-interaction/binaryEndpoints";
+export * from "./node-interaction/jsonEndpoints";
+/**
+ * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
+ * (similar to how you would interact with a REST api that gives you json back.)
+ * The wasm part will handle the creation of the binary requests and parse the responses and then parse them
+ * and return outputs that belong to the ViewPair.
+ * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
+ */
+export class ViewPair extends WasmProcessor {
+    static async create(primary_address, secret_view_key, node_url) {
+        const viewPair = new ViewPair(new TinyWASI(), node_url || "http://localhost:38081");
+        const tinywasi = await viewPair.initWasmModule();
+        viewPair.writeToWasmMemory = (ptr, len) => {
+            viewPair.writeString(ptr, len, primary_address);
+            viewPair.writeToWasmMemory = (ptr, len) => {
+                viewPair.writeString(ptr, len, secret_view_key);
+            };
+        };
+        //@ts-ignore
+        tinywasi.instance.exports.init_viewpair(primary_address.length, secret_view_key.length);
+        return viewPair;
+    }
+    /**
+     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param params params that will be turned into epee (moner lib that does binary serialization)
+     * @param metaCallBack contains meta information about the getBlocksbin call (new sync height = start_height param + number of blocks)
+     * @returns The difference to the same method on NodeUrl is: It returns {@link ScanResult} (outputs that belong to viewpair) and not just the blocks as json.
+     */
+    getBlocksBin(params, metaCallBack) {
+        return getBlocksBinScan(this, params, metaCallBack);
+    }
+    /**
+     * This method will use getBlocks.bin from start height to daemon height.
+     * This is CPU bound work, so it should be executed in a seperate thread (worker).
+     * The scanner.ts worker in the standard-checkout dir shows how to keep scanning after the tip is reached.
+     * It also shows how the outputs are saved (note the unqiue requirement for the stealth_adress).
+     * @param start_height the height to start syncing from.
+     * @param callback this function will get the new outputs as they are found as a parameter
+     */
+    async scan(start_height, callback) {
+        let latest_meta = {
+            new_height: start_height,
+            daemon_height: start_height + 1,
+            status: "",
+        };
+        while (latest_meta.new_height < latest_meta.daemon_height) {
+            const res = await this.getBlocksBin({
+                start_height: latest_meta.new_height - 1,
+            }, (meta) => {
+                latest_meta = meta;
+            });
+            callback(res);
+        }
+    }
+    /**
+     * This method makes an integrated Address for the Address of the Viewpair it was opened with.
+     * The network (mainnet, stagenet, testnet) is the same as the one of the Viewpairaddress.
+     * @param paymentId (u64 under the hood) you can use a random number or a primary key of an sqlite db to associate payments with customer sessions.
+     * @returns Adressstring
+     */
+    makeIntegratedAddress(paymentId) {
+        let address = "";
+        this.readFromWasmMemory = (ptr, len) => {
+            address = this.readString(ptr, len);
+        };
+        //@ts-ignore
+        this.tinywasi.instance.exports.make_integrated_address(BigInt(paymentId));
+        return address;
+    }
+}
+/**
+ * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
+ * (similar to how you would interact with a REST api that gives you json back.)
+ * The wasm part will handle the creation of the binary requests and parse the responses and return them as json.
+ * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
+ */
+export class NodeUrl extends WasmProcessor {
+    static async create(node_url) {
+        const nodeUrl = new NodeUrl(new TinyWASI(), node_url || "http://localhost:38081");
+        await nodeUrl.initWasmModule();
+        return nodeUrl;
+    }
+    /**
+     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param params params that will be turned into epee (moner lib that does binary serialization)
+     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
+     */
+    getBlocksBin(params) {
+        return getBlocksBinJson(this, params);
+    }
+}
+// const nodeurl = await NodeUrl.create("http://stagenet.community.rino.io:38081");
+// nodeurl.getBlocksBin({ start_height: 1731707 });
+// const viewpair = await ViewPair.create(
+//   "5B5ieVKGSyfAyh68X6AFB48Gnx9diT8jPbWN6UcZHJUZVQSLRhaaHuHQz3dGuxxZDXPYgCXzrkerK3m6Q1tHoougR7VYyd9",
+//   "10b9885324933ee6055b001a3ee4b70f6832b866db389ad023b51fe7e2e7ca01"
+// );

package/dist/cli.js

@@ -0,0 +1,2 @@
+// cli.tsx
+console.log(`Your random number is ${0.7962579739535381}`);

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,23 @@
+import * as fs from "fs";
+import { TinyWASI } from "./wasi";
+const source = fs.readFileSync("../rust/target/wasm32-wasip1/release/monero_wallet_api.wasm");
+const typedArray = new Uint8Array(source);
+let ffiRegister = (ptr, len) => { };
+export async function init() {
+    const tinywasi = new TinyWASI();
+    const imports = {
+        env: {
+            input: (ptr, len) => {
+                console.log("input", ptr, len);
+                ffiRegister(ptr, len);
+            },
+        },
+        ...tinywasi.imports,
+    };
+    const { module, instance } = await WebAssembly.instantiate(typedArray, imports);
+    tinywasi.initialize(instance);
+    console.log(instance.exports);
+    //@ts-ignore
+    instance.exports.init_viewpair(1, 3);
+}
+init();

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

@@ -0,0 +1,60 @@
+import type { WasmProcessor } from "../wasm-processing/wasmProcessor";
+export type GetBlocksBinRequest = {
+    requested_info?: "BLOCKS_ONLY" | "BLOCKS_AND_POOL" | "POOL_ONLY";
+    start_height: number;
+    prune?: boolean;
+    no_miner_tx?: boolean;
+    pool_info_since?: number;
+};
+export type PoolInfo = {};
+export type Transaction = {};
+export type Block = {
+    pruned: boolean;
+    block: number[];
+    block_weight: number;
+    txs: "None" | Transaction[];
+};
+export type OutputIndex = {
+    indices: {
+        indices: number[];
+    }[];
+};
+export type GetBlocksBinResponse = {
+    status: "OK";
+    untrusted: false;
+    credits: number;
+    top_hash: string;
+    blocks: Block[];
+    start_height: number;
+    current_height: number;
+    output_indices: OutputIndex[];
+    daemon_time: number;
+    pool_info: "None" | PoolInfo;
+    new_height: number;
+};
+export type Status = "OK" | "BUSY" | "NOT MINING" | "PAYMENT REQUIRED" | "Failed." | string;
+export type GetBlocksResultMeta = {
+    new_height: number;
+    daemon_height: number;
+    status: Status;
+};
+export type Output = {
+    amount: number;
+    block_height: number;
+    index_in_transaction: number;
+    index_on_blockchain: number;
+    payment_id: number;
+    stealth_address: string;
+    tx_hash: string;
+};
+export type ScanResult = {
+    outputs: Output[];
+    new_height: number;
+};
+export type ErrorResponse = {
+    error: string;
+};
+export type GetBlocksBinMetaCallback = (meta: GetBlocksResultMeta) => void;
+export declare function getBlocksBinScan<T extends WasmProcessor>(processor: T, params: GetBlocksBinRequest, metaCallBack?: GetBlocksBinMetaCallback): Promise<ScanResult | ErrorResponse>;
+export declare function getBlocksBinJson<T extends WasmProcessor>(processor: T, params: GetBlocksBinRequest): Promise<GetBlocksBinResponse | ErrorResponse>;
+export declare function binaryFetchRequest(url: string, body: Uint8Array): Promise<Uint8Array>;

package/dist/node-interaction/binaryEndpoints.js

@@ -0,0 +1,109 @@
+export async function getBlocksBinScan(processor, params, metaCallBack) {
+    // https://github.com/monero-project/monero/blob/941ecefab21db382e88065c16659864cb8e763ae/src/rpc/core_rpc_server_commands_defs.h#L178
+    //    enum REQUESTED_INFO
+    //   {
+    //     BLOCKS_ONLY = 0,
+    //     BLOCKS_AND_POOL = 1,
+    //     POOL_ONLY = 2
+    //   };
+    let requested_info = 0;
+    if (params.requested_info === "BLOCKS_AND_POOL") {
+        requested_info = 1;
+    }
+    else if (params.requested_info === "POOL_ONLY") {
+        requested_info = 2;
+    }
+    let prune_num = 1;
+    if (params.prune === false) {
+        prune_num = 0;
+    }
+    let no_miner_tx_num = 0;
+    if (params.no_miner_tx) {
+        no_miner_tx_num = 1;
+    }
+    let getBlocksArray;
+    processor.readFromWasmMemory = (ptr, len) => {
+        getBlocksArray = processor.readArray(ptr, len);
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.build_getblocksbin_request(requested_info, BigInt(params.start_height), prune_num, no_miner_tx_num, BigInt(params.pool_info_since || 0));
+    const getBlocksBinResponseBuffer = await binaryFetchRequest(processor.node_url + "/getblocks.bin", getBlocksArray // written in build_getblocksbin_request call to readFromWasmMemory
+    );
+    processor.writeToWasmMemory = (ptr, len) => {
+        processor.writeArray(ptr, len, getBlocksBinResponseBuffer);
+    };
+    let resultMeta;
+    let result;
+    processor.readFromWasmMemory = (ptr, len) => {
+        resultMeta = JSON.parse(processor.readString(ptr, len));
+        if (metaCallBack)
+            metaCallBack(resultMeta);
+        processor.readFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(processor.readString(ptr, len));
+            if (!("error" in result)) {
+                result.new_height = resultMeta.new_height;
+            }
+        };
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.scan_blocks_with_get_blocks_bin(getBlocksBinResponseBuffer.length);
+    return result; //result written in scan_blocks_with_get_blocks_bin
+}
+export async function getBlocksBinJson(processor, params) {
+    // https://github.com/monero-project/monero/blob/941ecefab21db382e88065c16659864cb8e763ae/src/rpc/core_rpc_server_commands_defs.h#L178
+    //    enum REQUESTED_INFO
+    //   {
+    //     BLOCKS_ONLY = 0,
+    //     BLOCKS_AND_POOL = 1,
+    //     POOL_ONLY = 2
+    //   };
+    let requested_info = 0;
+    if (params.requested_info === "BLOCKS_AND_POOL") {
+        requested_info = 1;
+    }
+    else if (params.requested_info === "POOL_ONLY") {
+        requested_info = 2;
+    }
+    let prune_num = 1;
+    if (params.prune === false) {
+        prune_num = 0;
+    }
+    let no_miner_tx_num = 0;
+    if (params.no_miner_tx) {
+        no_miner_tx_num = 1;
+    }
+    let getBlocksArray;
+    processor.readFromWasmMemory = (ptr, len) => {
+        getBlocksArray = processor.readArray(ptr, len);
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.build_getblocksbin_request(requested_info, BigInt(params.start_height), prune_num, no_miner_tx_num, BigInt(params.pool_info_since || 0));
+    const getBlocksBinResponseBuffer = await binaryFetchRequest(processor.node_url + "/getblocks.bin", getBlocksArray // written in build_getblocksbin_request call to readFromWasmMemory
+    );
+    processor.writeToWasmMemory = (ptr, len) => {
+        processor.writeArray(ptr, len, getBlocksBinResponseBuffer);
+    };
+    let resultMeta;
+    let result;
+    processor.readFromWasmMemory = (ptr, len) => {
+        resultMeta = JSON.parse(processor.readString(ptr, len));
+        processor.readFromWasmMemory = (ptr, len) => {
+            result = JSON.parse(processor.readString(ptr, len));
+            if (!("error" in result)) {
+                result.new_height = resultMeta.new_height;
+            }
+        };
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.convert_get_blocks_bin_response_to_json(getBlocksBinResponseBuffer.length);
+    return result; //result written in convert_get_blocks_bin_response_to_json
+}
+export async function binaryFetchRequest(url, body) {
+    const response = await fetch(url, {
+        body,
+        method: "POST",
+    })
+        .then((result) => result.blob())
+        .then((blob) => blob.arrayBuffer());
+    return new Uint8Array(response);
+}