@spirobel/monero-wallet-api 0.1.1 → 0.2.0

package/README.md

@@ -21,6 +21,18 @@ cd rust || cd ../rust
 cargo wasi build  --target wasm32-wasip1 --release --lib
 ```
 
+prerequisite: install rust
+
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+```bash
+rustup install 1.83.0
+rustup default 1.83.0
+rustup target add wasm32-wasip1
+```
+
 ## reproducible build with pinned cargo + rust + cargo wasi
 
 make the image

package/dist/api.d.ts

@@ -13,13 +13,32 @@ export type ScanResultCallback = (result: ScanResult | ErrorResponse) => void;
 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.
+     * This function helps with making requests to the get_blocks.bin endpoint of the Monerod nodes. It does the Request and returns the outputs that belong to the ViewPair.
+     * (if outputs are found in the blocks that are returned)
      * @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 params params that will be turned into epee (monero 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 function helps with making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     * The difference compared to the getBlocksBin method is that it returns a Uint8Array that still has to be scanned for outputs.
+     * This is useful if you want to scan multiple viewpairs at once. You can take the Uint8Array and pass it to another ViewPair to scan for outputs.
+     * @param params params that will be turned into epee (monero lib that does binary serialization)
+     * @returns This method will return a Uint8Array that can subsequently be scanned for outputs with the getBlocksBinScanResponse method.
+     */
+    getBlocksBinExecuteRequest(params: GetBlocksBinRequest): Promise<Uint8Array>;
+    /**
+     * This function helps with scanning the response of the getBlocksBinExecuteRequest method.
+     * It will parse the Uint8Array and return the outputs that belong to the ViewPair.
+     * (if outputs are found in the blocks that are contained in the Uint8Array that was returned by the getBlocksBinExecuteRequest method)
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param getBlocksBinResponseBuffer the Uint8Array that was returned by the getBlocksBinExecuteRequest method.(which contains the blocks in binary format, returned from the Monerod node)
+     * @param metaCallBack contains meta information about the getBlocksbin call (new sync height = start_height param + number of blocks)
+     * @returns It returns {@link ScanResult} (outputs that belong to viewpair)
+     */
+    getBlocksBinScanResponse(getBlocksBinResponseBuffer: Uint8Array, 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).
@@ -53,3 +72,27 @@ export declare class NodeUrl extends WasmProcessor {
      */
     getBlocksBin(params: GetBlocksBinRequest): Promise<import("./api").GetBlocksBinResponse | ErrorResponse>;
 }
+export type AddressAndViewKey = {
+    primary_address: string;
+    secret_view_key: string;
+};
+/**
+ * The ViewPairs class contains a set of ViewPair objects that can be used to scan multiple addresses at once.
+ * (while only retrieving the blocks from the node once)
+ */
+export declare class ViewPairs {
+    private viewPairs;
+    protected constructor();
+    static create(pairs: AddressAndViewKey[], node_url?: string): Promise<ViewPairs>;
+    addViewPair(primary_address: string, secret_view_key: string, node_url?: string): Promise<ViewPair>;
+    getViewPair(primary_address: string): ViewPair | undefined;
+    /**
+     * 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>;
+}

package/dist/api.js

@@ -1,4 +1,4 @@
-import { getBlocksBinJson, getBlocksBinScan, } from "./node-interaction/binaryEndpoints";
+import { getBlocksBinJson, getBlocksBinScan, getBlocksBinExecuteRequest, getBlocksBinScanResponse, } from "./node-interaction/binaryEndpoints";
 import { TinyWASI } from "./wasm-processing/wasi";
 import { WasmProcessor } from "./wasm-processing/wasmProcessor";
 export * from "./node-interaction/binaryEndpoints";
@@ -25,15 +25,38 @@ export class ViewPair extends WasmProcessor {
         return viewPair;
     }
     /**
-     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     * This function helps with making requests to the get_blocks.bin endpoint of the Monerod nodes. It does the Request and returns the outputs that belong to the ViewPair.
+     * (if outputs are found in the blocks that are returned)
      * @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 params params that will be turned into epee (monero 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 function helps with making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     * The difference compared to the getBlocksBin method is that it returns a Uint8Array that still has to be scanned for outputs.
+     * This is useful if you want to scan multiple viewpairs at once. You can take the Uint8Array and pass it to another ViewPair to scan for outputs.
+     * @param params params that will be turned into epee (monero lib that does binary serialization)
+     * @returns This method will return a Uint8Array that can subsequently be scanned for outputs with the getBlocksBinScanResponse method.
+     */
+    async getBlocksBinExecuteRequest(params) {
+        return await getBlocksBinExecuteRequest(this, params);
+    }
+    /**
+     * This function helps with scanning the response of the getBlocksBinExecuteRequest method.
+     * It will parse the Uint8Array and return the outputs that belong to the ViewPair.
+     * (if outputs are found in the blocks that are contained in the Uint8Array that was returned by the getBlocksBinExecuteRequest method)
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param getBlocksBinResponseBuffer the Uint8Array that was returned by the getBlocksBinExecuteRequest method.(which contains the blocks in binary format, returned from the Monerod node)
+     * @param metaCallBack contains meta information about the getBlocksbin call (new sync height = start_height param + number of blocks)
+     * @returns It returns {@link ScanResult} (outputs that belong to viewpair)
+     */
+    getBlocksBinScanResponse(getBlocksBinResponseBuffer, metaCallBack) {
+        return getBlocksBinScanResponse(this, getBlocksBinResponseBuffer, 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).
@@ -47,6 +70,7 @@ export class ViewPair extends WasmProcessor {
             new_height: start_height,
             daemon_height: start_height + 1,
             status: "",
+            primary_address: "",
         };
         while (latest_meta.new_height < latest_meta.daemon_height) {
             const res = await this.getBlocksBin({
@@ -95,9 +119,59 @@ export class NodeUrl extends WasmProcessor {
         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"
-// );
+/**
+ * The ViewPairs class contains a set of ViewPair objects that can be used to scan multiple addresses at once.
+ * (while only retrieving the blocks from the node once)
+ */
+export class ViewPairs {
+    viewPairs;
+    constructor() {
+        this.viewPairs = new Map();
+    }
+    static async create(pairs, node_url) {
+        const viewPairs = new ViewPairs();
+        for (const element of pairs) {
+            const viewPair = await ViewPair.create(element.primary_address, element.secret_view_key, node_url);
+            viewPairs.viewPairs.set(element.primary_address, viewPair);
+        }
+        return viewPairs;
+    }
+    async addViewPair(primary_address, secret_view_key, node_url) {
+        const viewPair = await ViewPair.create(primary_address, secret_view_key, node_url);
+        this.viewPairs.set(primary_address, viewPair);
+        return viewPair;
+    }
+    getViewPair(primary_address) {
+        return this.viewPairs.get(primary_address);
+    }
+    /**
+     * 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: "",
+            primary_address: "",
+        };
+        while (latest_meta.new_height < latest_meta.daemon_height) {
+            let firstResponse;
+            for (const [key, value] of this.viewPairs) {
+                if (!firstResponse) {
+                    firstResponse = await value.getBlocksBinExecuteRequest({
+                        start_height: latest_meta.new_height - 1,
+                    });
+                }
+                const res = await value.getBlocksBinScanResponse(firstResponse, (meta) => {
+                    latest_meta = meta;
+                });
+                callback(res);
+            }
+        }
+    }
+}

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

@@ -37,6 +37,7 @@ export type GetBlocksResultMeta = {
     new_height: number;
     daemon_height: number;
     status: Status;
+    primary_address: "parsing-monerod-response-without-wallet" | "error-address-not-set" | string;
 };
 export type Output = {
     amount: number;
@@ -46,15 +47,26 @@ export type Output = {
     payment_id: number;
     stealth_address: string;
     tx_hash: string;
+    primary_address: string;
 };
 export type ScanResult = {
     outputs: Output[];
     new_height: number;
+    primary_address: string;
 };
 export type ErrorResponse = {
     error: string;
 };
 export type GetBlocksBinMetaCallback = (meta: GetBlocksResultMeta) => void;
+/**
+ *  This function creates a binary request to the get_blocks.bin endpoint of the Monerod node.
+ * @param processor it uses the wasm module to build the request and parse the response.
+ * @param params params that will be turned into epee (moner lib that does binary serialization)
+ * @returns a Uint8Array that can be used to make a fetch request to the get_blocks.bin endpoint.
+ */
+export declare function getBlocksBinMakeRequest<T extends WasmProcessor>(processor: T, params: GetBlocksBinRequest): Uint8Array;
+export declare function getBlocksBinExecuteRequest<T extends WasmProcessor>(processor: T, params: GetBlocksBinRequest): Promise<Uint8Array>;
+export declare function getBlocksBinScanResponse<T extends WasmProcessor>(processor: T, getBlocksBinResponseBuffer: Uint8Array, metaCallBack?: GetBlocksBinMetaCallback): Promise<ScanResult | ErrorResponse>;
 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

@@ -1,4 +1,10 @@
-export async function getBlocksBinScan(processor, params, metaCallBack) {
+/**
+ *  This function creates a binary request to the get_blocks.bin endpoint of the Monerod node.
+ * @param processor it uses the wasm module to build the request and parse the response.
+ * @param params params that will be turned into epee (moner lib that does binary serialization)
+ * @returns a Uint8Array that can be used to make a fetch request to the get_blocks.bin endpoint.
+ */
+export function getBlocksBinMakeRequest(processor, params) {
     // https://github.com/monero-project/monero/blob/941ecefab21db382e88065c16659864cb8e763ae/src/rpc/core_rpc_server_commands_defs.h#L178
     //    enum REQUESTED_INFO
     //   {
@@ -21,14 +27,21 @@ export async function getBlocksBinScan(processor, params, metaCallBack) {
     if (params.no_miner_tx) {
         no_miner_tx_num = 1;
     }
-    let getBlocksArray;
+    let getBlocksRequestArray;
     processor.readFromWasmMemory = (ptr, len) => {
-        getBlocksArray = processor.readArray(ptr, len);
+        getBlocksRequestArray = 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
+    return getBlocksRequestArray; // written in build_getblocksbin_request call to readFromWasmMemory
+}
+export async function getBlocksBinExecuteRequest(processor, params) {
+    const getBlocksRequestArray = getBlocksBinMakeRequest(processor, params);
+    const getBlocksBinResponseBuffer = await binaryFetchRequest(processor.node_url + "/getblocks.bin", getBlocksRequestArray // written in build_getblocksbin_request call to readFromWasmMemory
     );
+    return getBlocksBinResponseBuffer;
+}
+export async function getBlocksBinScanResponse(processor, getBlocksBinResponseBuffer, metaCallBack) {
     processor.writeToWasmMemory = (ptr, len) => {
         processor.writeArray(ptr, len, getBlocksBinResponseBuffer);
     };
@@ -42,6 +55,7 @@ export async function getBlocksBinScan(processor, params, metaCallBack) {
             result = JSON.parse(processor.readString(ptr, len));
             if (!("error" in result)) {
                 result.new_height = resultMeta.new_height;
+                result.primary_address = resultMeta.primary_address;
             }
         };
     };
@@ -49,6 +63,10 @@ export async function getBlocksBinScan(processor, params, metaCallBack) {
     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 getBlocksBinScan(processor, params, metaCallBack) {
+    const getBlocksBinResponseBuffer = await getBlocksBinExecuteRequest(processor, params);
+    return getBlocksBinScanResponse(processor, getBlocksBinResponseBuffer, metaCallBack);
+}
 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

package/dist/testscrap.d.ts

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

package/dist/testscrap.js

@@ -0,0 +1,36 @@
+//57wmxQgZugZRrsaZ2mhcVtZqrUxAB6nXdEj4pnQ975Te2J2djFbBEubUFxTwxurF4cYE1oF8m26BkA9QcZZXLkf3FM7qX9U
+//8e4fe64233b5a0213e06ef4662582f72d47f7304502654485050c8ac06ee0309
+// const viewpairs = await ViewPairs.create([
+//   {
+//     primary_address:
+//       "5B5ieVKGSyfAyh68X6AFB48Gnx9diT8jPbWN6UcZHJUZVQSLRhaaHuHQz3dGuxxZDXPYgCXzrkerK3m6Q1tHoougR7VYyd9",
+//     secret_view_key:
+//       "10b9885324933ee6055b001a3ee4b70f6832b866db389ad023b51fe7e2e7ca01",
+//   },
+//   {
+//     primary_address:
+//       "57wmxQgZugZRrsaZ2mhcVtZqrUxAB6nXdEj4pnQ975Te2J2djFbBEubUFxTwxurF4cYE1oF8m26BkA9QcZZXLkf3FM7qX9U",
+//     secret_view_key:
+//       "8e4fe64233b5a0213e06ef4662582f72d47f7304502654485050c8ac06ee0309",
+//   },
+// ]);
+// viewpairs.scan(1731707, (result) => {
+//   if ("error" in result) {
+//     console.error("Error during scan:", result.error);
+//   } else {
+//     console.log("Scan result:", result);
+//     // Here you can handle the scan result, e.g., save outputs to a database
+//   }
+// });
+// console.log(viewpairs);
+import { ViewPair } from "./api";
+const viewpair = await ViewPair.create("5B5ieVKGSyfAyh68X6AFB48Gnx9diT8jPbWN6UcZHJUZVQSLRhaaHuHQz3dGuxxZDXPYgCXzrkerK3m6Q1tHoougR7VYyd9", "10b9885324933ee6055b001a3ee4b70f6832b866db389ad023b51fe7e2e7ca01");
+console.log(viewpair.makeIntegratedAddress(0));
+// viewpair.scan(1731707, (result) => {
+//   if ("error" in result) {
+//     console.error("Error during scan:", result.error);
+//   } else {
+//     console.log("Scan result:", result);
+//     // Here you can handle the scan result, e.g., save outputs to a database
+//   }
+// });