@spirobel/monero-wallet-api 0.2.0 → 0.3.1

package/README.md

@@ -18,7 +18,7 @@ rust release build
 
 ```bash
 cd rust || cd ../rust
-cargo wasi build  --target wasm32-wasip1 --release --lib
+cargo build  --target wasm32-wasip1 --release --lib
 ```
 
 prerequisite: install rust
@@ -28,8 +28,8 @@ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 ```
 
 ```bash
-rustup install 1.83.0
-rustup default 1.83.0
+rustup install 1.89.0
+rustup default 1.89.0
 rustup target add wasm32-wasip1
 ```
 

package/dist/api.d.ts

@@ -1,98 +1,27 @@
-import { type ScanResult, type ErrorResponse, type GetBlocksBinMetaCallback, type GetBlocksBinRequest } from "./node-interaction/binaryEndpoints";
-import { WasmProcessor } from "./wasm-processing/wasmProcessor";
+import "./io/indexedDB";
+export type { ScanResult, ScanResultCallback, } from "./scanning-syncing/scanresult/scanResult";
+export type { CacheChangedCallback, CacheChangedCallbackParameters, } from "./scanning-syncing/scanresult/scanCache";
+export { NodeUrl } from "./node-interaction/nodeUrl";
+export { ViewPair } from "./viewpair/ViewPair";
+export { ScanCacheOpened, ManyScanCachesOpened, } from "./scanning-syncing/scanresult/scanCacheOpened";
 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 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 (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).
-     * 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>;
-}
-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>;
-}
+export * from "./io/readDir";
+export * from "./io/atomicWrite";
+export * from "./io/sleep";
+export { writeScanSettings, readScanSettings, } from "./scanning-syncing/scanSettings";
+export { signTransaction, parseAddress, type ParsedAddress, type ParseAddressError, } from "./send-functionality/transactionBuilding";
+export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
+export { scanWallets, startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
+export { spendable } from "./scanning-syncing/scanresult/scanResult";
+export { openWallets, openWallet } from "./scanning-syncing/openWallet";
+export * from "./scanning-syncing/connectionStatus";
+export * from "./scanning-syncing/scanSettings";
+export * from "./scanning-syncing/scanresult/scanResult";
+export * from "./scanning-syncing/scanresult/scanStats";
+export * from "./scanning-syncing/scanresult/scanCache";
+export * from "./keypairs-seeds/writeKeypairs";
+export * from "./keypairs-seeds/keypairs";
+export * from "./send-functionality/conversion";
+export * from "./send-functionality/inputSelection";
+export * from "./tools/monero-tools";

package/dist/api.js

@@ -1,177 +1,25 @@
-import { getBlocksBinJson, getBlocksBinScan, getBlocksBinExecuteRequest, getBlocksBinScanResponse, } from "./node-interaction/binaryEndpoints";
-import { TinyWASI } from "./wasm-processing/wasi";
-import { WasmProcessor } from "./wasm-processing/wasmProcessor";
+import "./io/indexedDB";
+export { NodeUrl } from "./node-interaction/nodeUrl";
+export { ViewPair } from "./viewpair/ViewPair";
+export { ScanCacheOpened, ManyScanCachesOpened, } from "./scanning-syncing/scanresult/scanCacheOpened";
 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 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 (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).
-     * 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) {
-            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);
-    }
-}
-/**
- * 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);
-            }
-        }
-    }
-}
+export * from "./io/readDir";
+export * from "./io/atomicWrite";
+export * from "./io/sleep";
+export { writeScanSettings, readScanSettings, } from "./scanning-syncing/scanSettings";
+export { signTransaction, parseAddress, } from "./send-functionality/transactionBuilding";
+export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
+export { scanWallets, startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
+export { spendable } from "./scanning-syncing/scanresult/scanResult";
+export { openWallets, openWallet } from "./scanning-syncing/openWallet";
+export * from "./scanning-syncing/connectionStatus";
+export * from "./scanning-syncing/scanSettings";
+export * from "./scanning-syncing/scanresult/scanResult";
+export * from "./scanning-syncing/scanresult/scanStats";
+export * from "./scanning-syncing/scanresult/scanCache";
+export * from "./keypairs-seeds/writeKeypairs";
+export * from "./keypairs-seeds/keypairs";
+export * from "./send-functionality/conversion";
+export * from "./send-functionality/inputSelection";
+export * from "./tools/monero-tools";

package/dist/io/BunFileInterface.d.ts

@@ -0,0 +1,32 @@
+export interface Bun {
+    stdin: BunFile;
+    stdout: BunFile;
+    stderr: BunFile;
+    file(path: string | number | URL, options?: {
+        type?: string;
+    }): BunFile;
+    write(destination: string | number | BunFile | URL, input: string | Blob | ArrayBuffer | SharedArrayBuffer | TypedArray | Response): Promise<number>;
+}
+export interface BunFile {
+    readonly size: number;
+    readonly type: string;
+    text(): Promise<string>;
+    stream(): ReadableStream;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    json(): Promise<any>;
+    writer(params: {
+        highWaterMark?: number;
+    }): FileSink;
+    exists(): Promise<boolean>;
+}
+export interface FileSink {
+    write(chunk: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer): number | Promise<number>;
+    flush(): number | Promise<number>;
+    end(error?: Error): number | Promise<number>;
+    start(options?: {
+        highWaterMark?: number;
+    }): void;
+    ref(): void;
+    unref(): void;
+}
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | Uint8ClampedArray;

package/dist/io/atomicWrite.d.ts

@@ -0,0 +1,2 @@
+import type { TypedArray } from "./BunFileInterface";
+export declare function atomicWrite(targetPath: string, data: string | Blob | ArrayBuffer | SharedArrayBuffer | TypedArray | Response): Promise<number>;

package/dist/io/atomicWrite.js

@@ -0,0 +1,10 @@
+export async function atomicWrite(targetPath, data) {
+    // in the browser we don't have rename + indexedDB writes are atomic in any case
+    if (areWeInTheBrowser)
+        return await Bun.write(targetPath, data);
+    const { rename } = await import("node:fs/promises");
+    const tempPath = targetPath + ".tmp";
+    const bytesWritten = await Bun.write(tempPath, data);
+    await rename(tempPath, targetPath);
+    return bytesWritten;
+}

package/dist/io/extension.d.ts

@@ -0,0 +1,18 @@
+interface ExtensionRuntime {
+    id: string;
+    connect?: (extensionId?: string) => any;
+    sendMessage?: (message: any) => Promise<any> | ((callback: (response: any) => void) => void);
+}
+interface Chrome {
+    runtime?: ExtensionRuntime;
+}
+interface Browser {
+    runtime?: ExtensionRuntime;
+}
+declare global {
+    var chrome: Chrome | undefined;
+    var browser: Browser | undefined;
+}
+export declare function isExtensionContext(): boolean;
+export declare function getRuntime(): ExtensionRuntime | null;
+export {};

package/dist/io/extension.js

@@ -0,0 +1,11 @@
+export function isExtensionContext() {
+    return !!((typeof chrome !== "undefined" && chrome.runtime?.id) ||
+        (typeof browser !== "undefined" && browser.runtime?.id));
+}
+export function getRuntime() {
+    if (chrome?.runtime?.id)
+        return chrome.runtime;
+    if (browser?.runtime?.id)
+        return browser.runtime;
+    return null;
+}

package/dist/io/indexedDB.d.ts

@@ -0,0 +1,45 @@
+import type { BunFile, Bun, TypedArray } from "./BunFileInterface";
+export type PossibleBunFileContent = string | Blob | ArrayBuffer | SharedArrayBuffer | TypedArray | Response;
+declare class IndexedDBBun implements Bun {
+    stdin: BunFile;
+    stdout: BunFile;
+    stderr: BunFile;
+    file(path: string | number | URL, options?: {
+        type?: string;
+    }): BunFile;
+    write(destination: string | number | BunFile | URL, input: PossibleBunFileContent): Promise<number>;
+    env: BunEnv;
+}
+export type BunEnv = {
+    [key: string]: string | undefined;
+    TZ?: string | undefined;
+    NODE_ENV?: string | undefined;
+};
+export type IndexedDBItem = string | Blob | ArrayBufferLike | ArrayBuffer | SharedArrayBuffer;
+export declare function getItemLength(input: PossibleBunFileContent): Promise<[IndexedDBItem, number]>;
+export declare function putFileIntoIndexedDB(path: string, content: PossibleBunFileContent): Promise<number>;
+export declare function getFileFromIndexedDB(path: string): Promise<unknown>;
+export declare function deleteFileFromIndexedDB(path: string): Promise<void>;
+export declare const fileStoreName = "files";
+export type BrowserGlobal = {
+    filesDb?: IDBDatabase;
+    Bun: IndexedDBBun;
+    areWeInTheBrowser: boolean;
+};
+declare global {
+    var areWeInTheBrowser: boolean;
+}
+export declare function refreshEnvIndexedDB(): Promise<void>;
+export declare function writeEnvIndexedDB(key: string, value: string): Promise<void>;
+export declare function readEnvIndexedDB(): Promise<{
+    [key: string]: string;
+}>;
+/**
+ * useless function
+ * you can just do process.env[key] instead. Look at the code above.
+ * @param key
+ * @returns value
+ */
+export declare function readEnvIndexedDBLine(key: string): Promise<string>;
+export declare function readdir(dirpath: string): Promise<string[]>;
+export {};