@spirobel/monero-wallet-api 0.2.0 → 0.3.0

package/dist/node-interaction/jsonEndpoints.js

@@ -48,6 +48,42 @@ export const GetInfoResponseSchema = z.object({
         wide_difficulty: z.string(),
     }),
 });
+/**
+ * Response schema for the get_output_distribution method.
+ *
+ * @property id - The request ID.
+ * @property jsonrpc - The JSON-RPC version.
+ * @property result - The result object containing:
+ *   - distributions: An array of distribution objects, each with:
+ *     - amount: unsigned int Same as in the request. Use 0 to get all RingCT outputs.
+ *     - base: unsigned int; The total number of outputs of amount in the chain before, not including, the block at start_height.
+ *     - distribution: array of unsigned int
+ *     - start_height:  unsigned int; Note that this is not necessarily equal to from_height, especially for amount=0 where start_height will be no less than the height of the v4 hardfork.
+ *   - status: string; General RPC error code. "OK" means everything looks good.
+ */
+export const GetOutputDistributionResponseSchema = z.object({
+    id: z.string(),
+    jsonrpc: z.literal("2.0"),
+    result: z.object({
+        distributions: z.array(z.object({
+            amount: z.number(),
+            base: z.number(),
+            distribution: z.array(z.number()),
+            start_height: z.number(),
+        })),
+        status: z.string(),
+    }),
+});
+export function parseGetOutputDistributionResponse(data) {
+    const result = GetOutputDistributionResponseSchema.safeParse(data);
+    if (result.success) {
+        return result.data;
+    }
+    else {
+        console.error("Validation failed:", result.error);
+        return null;
+    }
+}
 export function parseGetInfoResponse(data) {
     const result = GetInfoResponseSchema.safeParse(data);
     if (result.success) {
@@ -80,3 +116,254 @@ export async function get_info(NODE_URL) {
     }
     return parsedResult.result;
 }
+export async function get_output_distribution(NODE_URL, params = {
+    amounts: [0],
+    binary: false,
+    cumulative: true,
+}) {
+    const getOutputDistributionResponse = await fetch(NODE_URL + "/json_rpc", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: "0",
+            method: "get_output_distribution",
+            params,
+        }),
+    });
+    if (!getOutputDistributionResponse.ok) {
+        throw new Error(`Failed to get output distribution (for decoy sampling): ${getOutputDistributionResponse.statusText}`);
+    }
+    const getOutputDistributionResult = await getOutputDistributionResponse.json();
+    const parsedResult = parseGetOutputDistributionResponse(getOutputDistributionResult);
+    if (parsedResult === null || !parsedResult.result) {
+        throw new Error("Failed to receive output distribution from node (get_output_distribution result)");
+    }
+    return parsedResult.result;
+}
+/**
+ * Response schema for the get_fee_estimate method.
+ *
+ * @property id - The request ID.
+ * @property jsonrpc - The JSON-RPC version.
+ * @property result - The result object containing:
+ *   - status: string; General RPC error code. "OK" means everything looks good.
+ *   - fee: unsigned int; Base fee per byte.
+ *   - fees: (Optional) Array of unsigned int; Fee estimates for priorities 1–4.
+ *   - quantization_mask: unsigned int; Mask used for fee rounding.
+ */
+export const GetFeeEstimateResponseSchema = z.object({
+    id: z.string(),
+    jsonrpc: z.literal("2.0"),
+    result: z.object({
+        status: z.string(),
+        fee: z.number(),
+        fees: z.array(z.number()).optional(),
+        quantization_mask: z.number(),
+    }),
+});
+export function parseGetFeeEstimateResponse(data) {
+    const result = GetFeeEstimateResponseSchema.safeParse(data);
+    if (result.success) {
+        return result.data;
+    }
+    else {
+        console.error("Validation failed:", result.error);
+        return null;
+    }
+}
+export async function get_fee_estimate(NODE_URL) {
+    // GRACE_BLOCKS_FOR_FEE_ESTIMATE: u64 = 10 (0xA) accoding to monero oxide
+    const GRACE_BLOCKS_FOR_FEE_ESTIMATE = 10;
+    const getFeeEstimateResponse = await fetch(NODE_URL + "/json_rpc", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: "0",
+            method: "get_fee_estimate",
+            params: { grace_blocks: GRACE_BLOCKS_FOR_FEE_ESTIMATE },
+        }),
+    });
+    if (!getFeeEstimateResponse.ok) {
+        throw new Error(`Failed to get fee estimate: ${getFeeEstimateResponse.statusText}`);
+    }
+    const getFeeEstimateResult = await getFeeEstimateResponse.json();
+    const parsedResult = parseGetFeeEstimateResponse(getFeeEstimateResult);
+    if (parsedResult === null || !parsedResult.result) {
+        throw new Error("Failed to receive fee estimate from node (get_fee_estimate result)");
+    }
+    return parsedResult.result;
+}
+export const SendRawTransactionResponseSchema = z.object({
+    double_spend: z.boolean(), // double_spend - boolean; Transaction is a double spend (true) or not (false).
+    fee_too_low: z.boolean(), // fee_too_low - boolean; Fee is too low (true) or OK (false).
+    invalid_input: z.boolean(), // invalid_input - boolean; Input is invalid (true) or valid (false).
+    invalid_output: z.boolean(), // invalid_output - boolean; Output is invalid (true) or valid (false).
+    low_mixin: z.boolean(), // low_mixin - boolean; Mixin count is too low (true) or OK (false).
+    not_rct: z.boolean().optional(), // not_rct - boolean; Transaction is a standard ring transaction (true) or a ring confidential transaction (false).
+    not_relayed: z.boolean(), // not_relayed - boolean; Transaction was not relayed (true) or relayed (false).
+    overspend: z.boolean(), // overspend - boolean; Transaction uses more money than available (true) or not (false).
+    reason: z.string(), // reason - string; Additional information. Currently empty or "Not relayed" if transaction was accepted but not relayed.
+    status: z.string(), // status - string; General RPC error code. "OK" means everything looks good. Any other value means that something went wrong.
+    too_big: z.boolean(), // too_big - boolean; Transaction size is too big (true) or OK (false).
+    untrusted: z.boolean(), // untrusted - boolean; States if the result is obtained using the bootstrap mode, and is therefore not trusted (true), or when the daemon is fully synced and thus handles the RPC locally (false)
+});
+export function parseSendRawTransactionResponse(data) {
+    const result = SendRawTransactionResponseSchema.safeParse(data);
+    if (result.success) {
+        return result.data;
+    }
+    else {
+        console.error("Validation failed:", result.error);
+        return null;
+    }
+}
+export async function send_raw_transaction(NODE_URL, tx_as_hex, // tx_as_hex - string; Full transaction information as hexadecimal string.
+do_not_relay = false) {
+    const sendRawTransactionResponse = await fetch(NODE_URL + "/send_raw_transaction", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ tx_as_hex, do_not_relay }),
+    });
+    if (!sendRawTransactionResponse.ok) {
+        throw new Error(`Failed to send raw transaction: ${sendRawTransactionResponse.statusText}`);
+    }
+    const sendRawTransactionResult = await sendRawTransactionResponse.json();
+    const parsedResult = parseSendRawTransactionResponse(sendRawTransactionResult);
+    if (parsedResult === null) {
+        throw new Error("Failed to receive response from node (send_raw_transaction result)");
+    }
+    return parsedResult;
+}
+/**
+ * Response schema for the get_block_headers_range method.
+ *
+ * @property id - The request ID.
+ * @property jsonrpc - The JSON-RPC version.
+ * @property result - The result object containing:
+ * - credits: unsigned int; If payment for RPC is enabled, the number of credits available to the requesting client. Otherwise, 0.
+ * - headers: array of block_header objects, each with:
+ *   - block_size: unsigned int
+ *   - block_weight: unsigned int
+ *   - cumulative_difficulty: unsigned int
+ *   - cumulative_difficulty_top64: unsigned int
+ *   - depth: unsigned int
+ *   - difficulty: unsigned int
+ *   - difficulty_top64: unsigned int
+ *   - hash: string
+ *   - height: unsigned int
+ *   - long_term_weight: unsigned int
+ *   - major_version: unsigned int
+ *   - miner_tx_hash: string
+ *   - minor_version: unsigned int
+ *   - nonce: unsigned int
+ *   - num_txes: unsigned int
+ *   - orphan_status: boolean
+ *   - pow_hash: string (if fill_pow_hash is true)
+ *   - prev_hash: string
+ *   - reward: unsigned int
+ *   - timestamp: unsigned int
+ *   - wide_cumulative_difficulty: string
+ *   - wide_difficulty: string
+ * - status: string; General RPC error code. "OK" means everything looks good.
+ * - top_hash: string; If payment for RPC is enabled, the hash of the highest block in the chain. Otherwise, empty.
+ * - untrusted: boolean; States if the result is obtained using the bootstrap mode (true) or not (false).
+ * @property error - Optional error object if the request failed:
+ * - code: int; Error code.
+ * - message: string; Error message.
+ */
+export const GetBlockHeadersRangeResponseSchema = z.object({
+    id: z.string(),
+    jsonrpc: z.literal("2.0"),
+    result: z
+        .object({
+        credits: z.number(),
+        headers: z.array(z.object({
+            block_size: z.number(),
+            block_weight: z.number(),
+            cumulative_difficulty: z.number(),
+            cumulative_difficulty_top64: z.number(),
+            depth: z.number(),
+            difficulty: z.number(),
+            difficulty_top64: z.number(),
+            hash: z.string(),
+            height: z.number(),
+            long_term_weight: z.number(),
+            major_version: z.number(),
+            miner_tx_hash: z.string(),
+            minor_version: z.number(),
+            nonce: z.number(),
+            num_txes: z.number(),
+            orphan_status: z.boolean(),
+            pow_hash: z.string(),
+            prev_hash: z.string(),
+            reward: z.number(),
+            timestamp: z.number(),
+            wide_cumulative_difficulty: z.string(),
+            wide_difficulty: z.string(),
+        })),
+        status: z.string(),
+        top_hash: z.string(),
+        untrusted: z.boolean(),
+    })
+        .optional(),
+    error: z
+        .object({
+        code: z.number(),
+        message: z.string(),
+    })
+        .optional(),
+});
+export function parseGetBlockHeadersRangeResponse(data) {
+    const result = GetBlockHeadersRangeResponseSchema.safeParse(data);
+    if (result.success) {
+        return result.data;
+    }
+    else {
+        console.error("Validation failed:", result.error);
+        return null;
+    }
+}
+export const RESTRICTED_BLOCK_HEADER_RANGE = 1000;
+export async function get_block_headers_range(NODE_URL, params) {
+    //https://github.com/monero-project/monero/blob/48ad374b0d6d6e045128729534dc2508e6999afe/src/rpc/core_rpc_server.cpp#L74
+    // #define RESTRICTED_BLOCK_HEADER_RANGE 1000
+    // https://github.com/monero-project/monero/blob/48ad374b0d6d6e045128729534dc2508e6999afe/src/rpc/core_rpc_server.cpp#L2612
+    if (params.end_height - params.start_height > RESTRICTED_BLOCK_HEADER_RANGE) {
+        throw new Error("Too many block headers requested. Max: " + RESTRICTED_BLOCK_HEADER_RANGE);
+    }
+    const getBlockHeadersRangeResponse = await fetch(NODE_URL + "/json_rpc", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: "0",
+            method: "get_block_headers_range",
+            params,
+        }),
+    });
+    if (!getBlockHeadersRangeResponse.ok) {
+        throw new Error(`Failed to get block headers range: ${getBlockHeadersRangeResponse.statusText}`);
+    }
+    const getBlockHeadersRangeResult = await getBlockHeadersRangeResponse.json();
+    const parsedResult = parseGetBlockHeadersRangeResponse(getBlockHeadersRangeResult);
+    if (parsedResult === null) {
+        throw new Error("Failed to parse block headers range response from node");
+    }
+    if (parsedResult.error) {
+        throw new Error(`RPC error: ${parsedResult.error.message} (code: ${parsedResult.error.code})`);
+    }
+    if (!parsedResult.result) {
+        throw new Error("Failed to receive block headers range from node (missing result)");
+    }
+    return parsedResult.result;
+}

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

@@ -0,0 +1,129 @@
+import { type GetBlocksBinRequest, type Output, type GetOutsBinRequest } from "./binaryEndpoints";
+import { type FeeEstimateResponse, type GetBlockHeadersRangeParams, type GetOutputDistributionParams, type SendRawTransactionResult } from "./jsonEndpoints";
+import { type SignedTransaction, type Input } from "../send-functionality/transactionBuilding";
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+/**
+ * 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 {
+    node_url: string;
+    protected constructor(node_url: string);
+    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("./binaryEndpoints").GetBlocksBinResponse | import("./binaryEndpoints").ErrorResponse>;
+    /**
+     * This request helps making requests to the get_outs.bin endpoint of the Monerod nodes.
+     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_outsbin
+     * @param outputIndexArrayToFetch an array of numbers that represent the output indices to be fetched. (candidates array returned from sampleDecoys for example)
+     * @returns after the request is made it will return epee serialized objects as a binary array.
+     */
+    getOutsBin(outputIndexArrayToFetch: GetOutsBinRequest): Promise<import("./binaryEndpoints").GetOutsResponseBuffer>;
+    /**
+     * This request helps making requests to the get_outs.bin endpoint of the Monerod nodes.
+     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_outsbin
+     * @param outputIndexArrayToFetch an array of numbers that represent the output indices to be fetched. (candidates array returned from sampleDecoys for example)
+     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
+     */
+    getOutsBinJson(outputIndexArrayToFetch: GetOutsBinRequest): Promise<import("./binaryEndpoints").GetOutsBinResponse>;
+    /**
+     * fetch output distribution from node (necessary to make input - also named OutputWithDecoys in Monero-oxide)
+     * @param params defaults to: { amounts: [0], binary: false }
+     * @returns returns output distribution necessary to sample input candidates
+     */
+    getOutputDistribution(params?: GetOutputDistributionParams): Promise<number[]>;
+    /**
+     * fetch fee estimate from node
+     * @returns fee estimate response
+     */
+    getFeeEstimate(): Promise<FeeEstimateResponse>;
+    /**
+     * sample decoys with distibution (cumulative)
+     * @param outputToBeSpentIndex the index of the output to be spent
+     * @param distribution cumulative distribution fetched from the node with getOutputDistribution()
+     * @param candidatesLength the amount of candidates to be sampled + 1 (the result will also contain the original index so in total the length of the resulting array will be this + 2)
+     * @returns SampledDecoys: {candidates: number[]} - an array with output indices including the spent index
+     */
+    sampleDecoys(outputToBeSpentIndex: number, distribution: number[], candidatesLength: number): import("../send-functionality/transactionBuilding").SampledDecoys;
+    /**
+     * makeInput helper that uses the wasm module to create an input for a transaction.
+     * @param outputToBeSpent the output that should be spent
+     * @param candidates array of output indices that can be used as decoys
+     * @param get_outs_Response the response from a get_outs.bin request for the candidates
+     * @returns the input serialized that can be used in transaction building
+     */
+    makeInput(outputToBeSpent: Output, candidates: number[], get_outs_Response: Uint8Array): Input;
+    /**
+     * Send a raw transaction to the node for broadcasting.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#send_raw_transaction
+     * @param tx_as_hex tx_as_hex - string; Full transaction information as hexadecimal string.
+     * @param do_not_relay (Optional) boolean; Stop relaying transaction to other nodes. Defaults to false.
+     * @returns The response indicating success or failure, with validation details.
+     */
+    sendRawTransaction(tx_as_hex: SignedTransaction, do_not_relay?: boolean): Promise<SendRawTransactionResult>;
+    /**
+     * Retrieve block headers for a specified range of heights.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_block_headers_range
+     * @param params The parameters including start_height, end_height, and optional fill_pow_hash.
+     * @returns The result object with headers, status, etc. Throws if the range is invalid:(end_height > daemonheight)
+     */
+    getBlockHeadersRange(params: GetBlockHeadersRangeParams): Promise<import("./jsonEndpoints").GetBlockHeadersRange>;
+    /**
+     * Fetch general information about the Monero daemon.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_info
+     * @returns The result object with daemon info like height, status, etc.
+     */
+    getInfo(): Promise<{
+        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;
+        status: string;
+        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 declare const LOCAL_NODE_DEFAULT_URL = "http://127.0.0.1:18081";

package/dist/node-interaction/nodeUrl.js

@@ -0,0 +1,113 @@
+import { getBlocksBinJson, getOutsBinJson, getOutsBinExecuteRequest, } from "./binaryEndpoints";
+import { get_block_headers_range, get_fee_estimate, get_info, get_output_distribution, send_raw_transaction, } from "./jsonEndpoints";
+import { makeInput, sampleDecoys, } from "../send-functionality/transactionBuilding";
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+/**
+ * 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 {
+    node_url;
+    constructor(node_url) {
+        super();
+        this.node_url = node_url;
+    }
+    static async create(node_url) {
+        const nodeUrl = new NodeUrl(node_url || LOCAL_NODE_DEFAULT_URL);
+        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);
+    }
+    /**
+     * This request helps making requests to the get_outs.bin endpoint of the Monerod nodes.
+     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_outsbin
+     * @param outputIndexArrayToFetch an array of numbers that represent the output indices to be fetched. (candidates array returned from sampleDecoys for example)
+     * @returns after the request is made it will return epee serialized objects as a binary array.
+     */
+    getOutsBin(outputIndexArrayToFetch) {
+        return getOutsBinExecuteRequest(this, outputIndexArrayToFetch);
+    }
+    /**
+     * This request helps making requests to the get_outs.bin endpoint of the Monerod nodes.
+     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_outsbin
+     * @param outputIndexArrayToFetch an array of numbers that represent the output indices to be fetched. (candidates array returned from sampleDecoys for example)
+     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
+     */
+    getOutsBinJson(outputIndexArrayToFetch) {
+        return getOutsBinJson(this, outputIndexArrayToFetch);
+    }
+    /**
+     * fetch output distribution from node (necessary to make input - also named OutputWithDecoys in Monero-oxide)
+     * @param params defaults to: { amounts: [0], binary: false }
+     * @returns returns output distribution necessary to sample input candidates
+     */
+    async getOutputDistribution(params) {
+        return (await get_output_distribution(this.node_url, params))
+            .distributions[0].distribution;
+    }
+    /**
+     * fetch fee estimate from node
+     * @returns fee estimate response
+     */
+    getFeeEstimate() {
+        return get_fee_estimate(this.node_url);
+    }
+    /**
+     * sample decoys with distibution (cumulative)
+     * @param outputToBeSpentIndex the index of the output to be spent
+     * @param distribution cumulative distribution fetched from the node with getOutputDistribution()
+     * @param candidatesLength the amount of candidates to be sampled + 1 (the result will also contain the original index so in total the length of the resulting array will be this + 2)
+     * @returns SampledDecoys: {candidates: number[]} - an array with output indices including the spent index
+     */
+    sampleDecoys(outputToBeSpentIndex, distribution, candidatesLength) {
+        return sampleDecoys(this, outputToBeSpentIndex, distribution, candidatesLength);
+    }
+    /**
+     * makeInput helper that uses the wasm module to create an input for a transaction.
+     * @param outputToBeSpent the output that should be spent
+     * @param candidates array of output indices that can be used as decoys
+     * @param get_outs_Response the response from a get_outs.bin request for the candidates
+     * @returns the input serialized that can be used in transaction building
+     */
+    makeInput(outputToBeSpent, candidates, get_outs_Response) {
+        return makeInput(this, outputToBeSpent, candidates, get_outs_Response);
+    }
+    /**
+     * Send a raw transaction to the node for broadcasting.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#send_raw_transaction
+     * @param tx_as_hex tx_as_hex - string; Full transaction information as hexadecimal string.
+     * @param do_not_relay (Optional) boolean; Stop relaying transaction to other nodes. Defaults to false.
+     * @returns The response indicating success or failure, with validation details.
+     */
+    async sendRawTransaction(tx_as_hex, do_not_relay = false) {
+        return send_raw_transaction(this.node_url, tx_as_hex, do_not_relay);
+    }
+    /**
+     * Retrieve block headers for a specified range of heights.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_block_headers_range
+     * @param params The parameters including start_height, end_height, and optional fill_pow_hash.
+     * @returns The result object with headers, status, etc. Throws if the range is invalid:(end_height > daemonheight)
+     */
+    async getBlockHeadersRange(params) {
+        return get_block_headers_range(this.node_url, params);
+    }
+    /**
+     * Fetch general information about the Monero daemon.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_info
+     * @returns The result object with daemon info like height, status, etc.
+     */
+    async getInfo() {
+        return get_info(this.node_url);
+    }
+}
+export const LOCAL_NODE_DEFAULT_URL = "http://127.0.0.1:18081";

package/dist/scanning-syncing/backgroundWorker.d.ts

@@ -0,0 +1,6 @@
+import { type CacheChangedCallback, type CacheChangedCallbackParameters } from "./scanresult/scanCache";
+export declare function scanWallets(cacheChanged?: CacheChangedCallback, stopSync?: AbortSignal, scan_settings_path?: string, pathPrefix?: string): Promise<void>;
+export declare function createWebworker(handle_result?: (result: CacheChangedCallbackParameters) => void, scan_settings_path?: string, pathPrefix?: string, handle_error?: (error: unknown) => void): Worker;
+export declare function makeWebworkerScript(scan_settings_path?: string, pathPrefix?: string): string;
+export declare function startWebworker(worker_script: string, handle_result?: (result: unknown) => void, handle_error?: (error: unknown) => void): Worker;
+export declare const WW_ERROR_FORWARDING_SNIPPET = "\n\nself.onerror = (e) => self.postMessage({ type: 'ERROR', payload: e });\nself.addEventListener('unhandledrejection', (e) => \n  self.postMessage({ type: 'ERROR', payload: e.reason })\n); \n";

package/dist/scanning-syncing/backgroundWorker.js

@@ -0,0 +1,56 @@
+import { ViewPair } from "../api";
+import {} from "./scanresult/scanCache";
+import { openNonHaltedWallets, walletSettingsPlusKeys } from "./scanSettings";
+import { workerMainCode } from "./worker-entrypoints/worker";
+export async function scanWallets(cacheChanged = (params) => console.log(params), stopSync, scan_settings_path, pathPrefix) {
+    const nonHaltedWallets = await openNonHaltedWallets(scan_settings_path);
+    const masterWalletSettings = nonHaltedWallets[0];
+    if (!masterWalletSettings)
+        return;
+    const masterWithKeys = await walletSettingsPlusKeys(masterWalletSettings);
+    const masterViewPair = await ViewPair.create(masterWalletSettings.primary_address, masterWithKeys.secret_view_key, masterWalletSettings.subaddress_index, masterWalletSettings.node_url);
+    await masterViewPair.scan(cacheChanged, stopSync, scan_settings_path, pathPrefix);
+}
+export function createWebworker(handle_result, scan_settings_path, pathPrefix, handle_error) {
+    const worker_script = makeWebworkerScript(scan_settings_path, pathPrefix);
+    return startWebworker(worker_script, handle_result, handle_error);
+}
+export function makeWebworkerScript(scan_settings_path, pathPrefix) {
+    const settingsPathLine = scan_settings_path
+        ? `const scan_settings_path = '${scan_settings_path}';`
+        : "const scan_settings_path = undefined;";
+    const pathPrefixLine = pathPrefix
+        ? `const pathPrefix = '${pathPrefix}';`
+        : "const pathPrefix = undefined;";
+    return `\n
+      ${settingsPathLine}
+      ${pathPrefixLine}
+      ${workerMainCode}
+      `;
+}
+export function startWebworker(worker_script, handle_result, handle_error) {
+    const blob = new Blob([WW_ERROR_FORWARDING_SNIPPET + worker_script], {
+        type: "text/javascript",
+    });
+    const url = URL.createObjectURL(blob);
+    const worker = new Worker(url, { type: "module" });
+    worker.onmessage = (event) => {
+        switch (event.data.type) {
+            case "RESULT": // Handle normal messages
+                if (handle_result)
+                    handle_result(event.data.payload);
+                break;
+            case "ERROR":
+                if (handle_error)
+                    handle_error(event.data.payload);
+                break;
+        }
+    };
+    return worker;
+}
+// Autoforward ALL errors with error type (global handlers)
+export const WW_ERROR_FORWARDING_SNIPPET = `\n
+self.onerror = (e) => self.postMessage({ type: 'ERROR', payload: e });
+self.addEventListener('unhandledrejection', (e) => 
+  self.postMessage({ type: 'ERROR', payload: e.reason })
+); \n`;

package/dist/scanning-syncing/connectionStatus.d.ts

@@ -0,0 +1,15 @@
+export type ConnectionStatusOptions = "OK" | "partial_read" | "connection_failed" | "no_connection_yet" | "catastrophic_reorg";
+export type ConnectionStatus = {
+    last_packet: {
+        status: ConnectionStatusOptions;
+        bytes_read: number;
+        node_url: string;
+        timestamp: string;
+    };
+};
+export declare const DEFAULT_CONNECTION_STATUS_PREFIX = "ConnectionStatus-";
+export declare function connectionStatusFilePath(scan_settings_path?: string): string;
+export declare function readConnectionStatusDefaultLocation(scan_settings_path?: string): Promise<ConnectionStatus | undefined>;
+export declare function readConnectionStatusFile(connectionStatusFilePath: string): Promise<ConnectionStatus | undefined>;
+export declare function writeConnectionStatusFile(status: ConnectionStatusOptions, node_url: string, bytes_read?: number, scan_settings_path?: string): Promise<number>;
+export declare function readWriteConnectionStatusFile(writeCB: (cs: ConnectionStatus | undefined) => ConnectionStatus | undefined, scan_settings_path?: string): Promise<number | undefined>;

package/dist/scanning-syncing/connectionStatus.js

@@ -0,0 +1,35 @@
+import { atomicWrite } from "../api";
+import { SCAN_SETTINGS_STORE_NAME_DEFAULT } from "./scanSettings";
+export const DEFAULT_CONNECTION_STATUS_PREFIX = "ConnectionStatus-";
+export function connectionStatusFilePath(scan_settings_path) {
+    if (!scan_settings_path)
+        scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT;
+    return `${DEFAULT_CONNECTION_STATUS_PREFIX}${scan_settings_path}`;
+}
+export async function readConnectionStatusDefaultLocation(scan_settings_path) {
+    return await readConnectionStatusFile(connectionStatusFilePath(scan_settings_path));
+}
+export async function readConnectionStatusFile(connectionStatusFilePath) {
+    const jsonString = await Bun.file(connectionStatusFilePath)
+        .text()
+        .catch(() => undefined);
+    return jsonString ? JSON.parse(jsonString) : undefined;
+}
+export async function writeConnectionStatusFile(status, node_url, bytes_read = 0, scan_settings_path) {
+    const connectionStatus = {
+        last_packet: {
+            status,
+            bytes_read,
+            node_url,
+            timestamp: new Date().toISOString(),
+        },
+    };
+    return await atomicWrite(connectionStatusFilePath(scan_settings_path), JSON.stringify(connectionStatus, null, 2));
+}
+export async function readWriteConnectionStatusFile(writeCB, scan_settings_path) {
+    const connectionStatus = await readConnectionStatusDefaultLocation(scan_settings_path);
+    const cb = await writeCB(connectionStatus);
+    if (typeof cb === "undefined")
+        return;
+    return await writeConnectionStatusFile(cb.last_packet.status, cb.last_packet.node_url, cb.last_packet.bytes_read, scan_settings_path);
+}