@spirobel/monero-wallet-api 0.1.2 → 0.3.0

package/dist/scanning-syncing/worker-mains/worker.d.ts

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

package/dist/scanning-syncing/worker-mains/worker.js

@@ -0,0 +1,7 @@
+import { sleep } from "../../io/sleep";
+import { scanWallets } from "../backgroundWorker";
+while (true) {
+    await scanWallets((x) => self.postMessage({ type: "RESULT", payload: x }), undefined, scan_settings_path, pathPrefix);
+    console.log("no wallets found to scan in wallet settings, trying again in 1 second");
+    await sleep(1000);
+}

package/dist/send-functionality/conversion.d.ts

@@ -0,0 +1,4 @@
+export declare function truncateDecimalString(str: string, decimals?: number): string;
+export declare function convertBigIntAmount(amount: bigint): string;
+export declare function convertAmountBigInt(amount_double: string): bigint;
+export declare function convertAmountBigIntThrows(amount_double: string): bigint;

package/dist/send-functionality/conversion.js

@@ -0,0 +1,75 @@
+export function truncateDecimalString(str, decimals = 3) {
+    if (!str.includes("."))
+        return str;
+    const [integer, fraction = ""] = str.split(".");
+    const truncatedFraction = fraction.slice(0, decimals);
+    return truncatedFraction ? `${integer}.${truncatedFraction}` : integer;
+}
+export function convertBigIntAmount(amount) {
+    if (amount < 0)
+        amount *= -1n;
+    let display_amount = "";
+    // to go from atomic units to display amount,
+    // we move from the end to the beginning and insert a dot 12 digits in
+    // https://www.getmonero.org/resources/moneropedia/atomic-units.html
+    let afterDot = amount.toString().padStart(12, "0").slice(-12);
+    let beforeDot = amount.toString().padStart(12, "0").slice(0, -12);
+    if (!beforeDot || beforeDot.startsWith("0"))
+        beforeDot = "0";
+    display_amount = beforeDot + ".";
+    display_amount += afterDot;
+    // remove trailing zeros
+    while (display_amount[display_amount.length - 1] === "0") {
+        display_amount = display_amount.slice(0, -1);
+    }
+    const last_char = display_amount.at(-1);
+    if (last_char === ".")
+        display_amount = display_amount.slice(0, -1);
+    // trailing . or , should be removed
+    return display_amount;
+}
+export function convertAmountBigInt(amount_double) {
+    // accept both dot and comma
+    amount_double = amount_double.replaceAll(",", ".");
+    const last_char = amount_double.at(-1);
+    if (last_char === ".")
+        amount_double = amount_double.slice(0, -1);
+    // trailing . or , should be removed
+    const beforeDot = amount_double.split(".")[0];
+    let afterDot = amount_double.split(".")[1];
+    if (!afterDot)
+        afterDot = "000000000000";
+    afterDot = afterDot?.padEnd(12, "0").slice(0, 12);
+    let bigIntString = afterDot;
+    if (beforeDot?.length && !beforeDot.startsWith("0"))
+        bigIntString = beforeDot + afterDot;
+    let amount = BigInt("0");
+    try {
+        amount = BigInt(bigIntString);
+    }
+    catch (error) {
+        // in case the input is not a valid number,
+        // the amount stays zero. Keeps the UI easy for copy and paste
+    }
+    return amount;
+}
+export function convertAmountBigIntThrows(amount_double) {
+    // accept both dot and comma
+    amount_double = amount_double.replaceAll(",", ".");
+    const last_char = amount_double.at(-1);
+    if (last_char === ".")
+        amount_double = amount_double.slice(0, -1);
+    // trailing . or , should be removed
+    const beforeDot = amount_double.split(".")[0];
+    let afterDot = amount_double.split(".")[1];
+    if (!afterDot)
+        afterDot = "000000000000";
+    afterDot = afterDot?.padEnd(12, "0").slice(0, 12);
+    let bigIntString = afterDot;
+    if (beforeDot?.length && !beforeDot.startsWith("0"))
+        bigIntString = beforeDot + afterDot;
+    let amount = BigInt("0");
+    amount = BigInt(bigIntString);
+    // in case the input is not a valid number, throws,
+    return amount;
+}

package/dist/send-functionality/inputSelection.d.ts

@@ -0,0 +1,13 @@
+import type { GetOutsResponseBuffer, NodeUrl, Output } from "../api";
+import type { SampledDecoys } from "./transactionBuilding";
+export type Payment = {
+    address: string;
+    amount: string;
+};
+export declare function sumPayments(payments: Payment[]): bigint;
+export type PreparedInput = {
+    input: Output;
+    sample: SampledDecoys;
+    outsResponse: Promise<GetOutsResponseBuffer>;
+};
+export declare function prepareInput(node: NodeUrl, distibution: number[], input: Output, how_many_to_sample?: number): PreparedInput;

package/dist/send-functionality/inputSelection.js

@@ -0,0 +1,8 @@
+export function sumPayments(payments) {
+    return payments.reduce((sum, payment) => sum + BigInt(payment.amount), 0n);
+}
+export function prepareInput(node, distibution, input, how_many_to_sample = 20) {
+    const sample = node.sampleDecoys(input.index_on_blockchain, distibution, how_many_to_sample);
+    const outsResponse = node.getOutsBin(sample.candidates);
+    return { input, sample, outsResponse };
+}

package/dist/send-functionality/transactionBuilding.d.ts

@@ -0,0 +1,51 @@
+import type { GetFeeEstimateResult, Output } from "../api";
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+export type Input = string;
+export type UnsignedTransaction = string;
+export type SignedTransaction = string;
+export declare function makeInput<T extends WasmProcessor>(processor: T, outputToBeSpent: Output, candidates: number[], get_outs_Response: Uint8Array): Input;
+export type SampledDecoys = {
+    candidates: number[];
+};
+export declare function sampleDecoys<T extends WasmProcessor>(processor: T, outputToBeSpentIndex: number, distribution: number[], candidatesLength: number): SampledDecoys;
+export type MakeTransactionParams = {
+    inputs: Input[];
+    payments: {
+        address: string;
+        amount: string;
+    }[];
+    fee_response: GetFeeEstimateResult;
+    fee_priority: string;
+    outgoing_view_key?: string;
+    data?: number[][];
+};
+export type NotEnoughFundsError = {
+    inputs: number;
+    necessary_fee: number;
+    outputs: number;
+};
+export type ErrorDetail = {
+    NotEnoughFunds: NotEnoughFundsError;
+};
+export type SendError = {
+    error: ErrorDetail;
+    message: string;
+};
+/**
+ *  this function returns the unsigned transaction, throws {@link SendError}
+ * @param processor
+ * @param params
+ * @returns
+ */
+export declare function makeTransaction<T extends WasmProcessor>(processor: T, params: MakeTransactionParams): UnsignedTransaction;
+export declare function signTransaction(tx: UnsignedTransaction, sender_spend_key: string): Promise<SignedTransaction>;
+export type ParsedAddress = {
+    address: string;
+    kind: "primary" | "subaddress" | "integrated" | "featured";
+    network: "mainnet" | "stagenet" | "testnet";
+    payment_id?: string;
+};
+export type ParseAddressError = {
+    error: string;
+};
+export declare function parseAddress(address: string): Promise<ParsedAddress | ParseAddressError>;

package/dist/send-functionality/transactionBuilding.js

@@ -0,0 +1,111 @@
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+export function makeInput(processor, outputToBeSpent, candidates, get_outs_Response) {
+    const makeInputArgs = JSON.stringify({
+        serialized_input: outputToBeSpent.serialized,
+        candidates,
+    });
+    processor.writeToWasmMemory = (ptr, len) => {
+        processor.writeString(ptr, len, makeInputArgs);
+        processor.writeToWasmMemory = (ptr, len) => {
+            processor.writeArray(ptr, len, get_outs_Response);
+        };
+    };
+    let result = null;
+    processor.readFromWasmMemory = (ptr, len) => {
+        result = JSON.parse(processor.readString(ptr, len));
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.make_input(makeInputArgs.length, get_outs_Response.length);
+    if (!result) {
+        throw new Error("Failed to make Input (combine output with sampled and verified unlocked decoys)");
+    }
+    return result["input"];
+}
+export function sampleDecoys(processor, outputToBeSpentIndex, distribution, candidatesLength) {
+    const sampleDecoyArgs = JSON.stringify({
+        output_being_spent_index: outputToBeSpentIndex,
+        distribution,
+        candidates_len: candidatesLength,
+    });
+    processor.writeToWasmMemory = (ptr, len) => {
+        processor.writeString(ptr, len, sampleDecoyArgs);
+    };
+    let result;
+    processor.readFromWasmMemory = (ptr, len) => {
+        result = JSON.parse(processor.readString(ptr, len));
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.sample_decoys(sampleDecoyArgs.length);
+    if (!result) {
+        throw new Error("Failed to sample decoys");
+    }
+    return result;
+}
+/**
+ *  this function returns the unsigned transaction, throws {@link SendError}
+ * @param processor
+ * @param params
+ * @returns
+ */
+export function makeTransaction(processor, params) {
+    const jsonParams = JSON.stringify(params);
+    processor.writeToWasmMemory = (ptr, len) => {
+        processor.writeString(ptr, len, jsonParams);
+    };
+    let result = null;
+    let error = null;
+    processor.readFromWasmMemory = (ptr, len) => {
+        result = JSON.parse(processor.readString(ptr, len));
+    };
+    processor.readErrorFromWasmMemory = (ptr, len) => {
+        error = JSON.parse(processor.readString(ptr, len));
+    };
+    //@ts-ignore
+    processor.tinywasi.instance.exports.make_transaction(jsonParams.length);
+    if (!result) {
+        throw error;
+    }
+    return result["signable_transaction"];
+}
+export async function signTransaction(tx, sender_spend_key) {
+    const wasmProcessor = await WasmProcessor.init();
+    wasmProcessor.writeToWasmMemory = (ptr, len) => {
+        wasmProcessor.writeString(ptr, len, tx);
+        wasmProcessor.writeToWasmMemory = (ptr, len) => {
+            wasmProcessor.writeString(ptr, len, sender_spend_key);
+        };
+    };
+    let result = null;
+    wasmProcessor.readFromWasmMemory = (ptr, len) => {
+        result = JSON.parse(wasmProcessor.readString(ptr, len));
+    };
+    //@ts-ignore
+    wasmProcessor.tinywasi.instance.exports.sign_transaction(tx.length, sender_spend_key.length);
+    if (!result) {
+        throw new Error("Failed to sign transaction");
+    }
+    return result["signed_transaction"];
+}
+export async function parseAddress(address) {
+    const wasmProcessor = await WasmProcessor.init();
+    wasmProcessor.writeToWasmMemory = (ptr, len) => {
+        wasmProcessor.writeString(ptr, len, address);
+    };
+    let result = null;
+    wasmProcessor.readFromWasmMemory = (ptr, len) => {
+        result = JSON.parse(wasmProcessor.readString(ptr, len));
+    };
+    let error = null;
+    wasmProcessor.readErrorFromWasmMemory = (ptr, len) => {
+        error = JSON.parse(wasmProcessor.readString(ptr, len));
+    };
+    //@ts-ignore
+    wasmProcessor.tinywasi.instance.exports.parse_address(address.length);
+    if (!result) {
+        if (!error) {
+            throw new Error("Failed to parse address");
+        }
+        return error;
+    }
+    return result;
+}

package/dist/tools/monero-tools.d.ts

@@ -0,0 +1,46 @@
+export declare const TOOL_MAGIC_STRING = "monerochan";
+export declare function parseToolLink(link: string): MoneroTool | null;
+export type ToolInvocationValidity = "valid" | "invalid" | "unverified";
+export type ParsedMoneroToolInvocation = {
+    tool: MoneroTool;
+    destination_domain: string;
+    context_domain: string;
+    found_in: "link" | "linkText";
+    link: string;
+    linkText: string;
+    timestamp: number;
+    invocation_id: string;
+    context_href: string;
+    valid: ToolInvocationValidity;
+};
+export declare function parseToolInvocation(link: string, linkText: string, context_location: Location): ParsedMoneroToolInvocation | null;
+export type SendTransactionTool = {
+    tool_id: "001";
+    payload: SendTransactionToolPayload;
+};
+export type SendTransactionToolPayload = {
+    address: string;
+    amount: string;
+};
+export declare function parseSendTransactionToolArgs(args: string[]): SendTransactionTool | null;
+export declare function createSendTransactionToolLink(address: string, amount: string): string;
+export declare function make001ToolLink(address: string, amount: string): string;
+export type CreateAndShareViewOnlyWalletTool = {
+    tool_id: "002";
+    payload: CreateAndShareViewOnlyWalletToolPayload;
+};
+export type CreateAndShareViewOnlyWalletToolPayload = {
+    wallet_slot: number;
+};
+export declare function parseCreateAndShareViewOnlyWalletToolArgs(args: string[]): CreateAndShareViewOnlyWalletTool | null;
+export declare function createCreateAndShareViewOnlyWalletToolLink(wallet_slot?: number): string;
+export declare function make002ToolLink(wallet_slot?: number): string;
+export type MoneroTool = SendTransactionTool | CreateAndShareViewOnlyWalletTool;
+export declare function createToolLink(tool: MoneroTool): string;
+export declare function getDomainWithTLD(hostname: string): string;
+export declare function parseDestination(destination: string): string;
+export declare const OPEN_DOMAINS: string[];
+export declare function checkToolInvocationValidity(invo: ParsedMoneroToolInvocation): Promise<ToolInvocationValidity>;
+export declare const ADDRESS_VALID_RESPONSE: {
+    valid_address: boolean;
+};

package/dist/tools/monero-tools.js

@@ -0,0 +1,165 @@
+import { convertAmountBigIntThrows } from "../send-functionality/conversion";
+export const TOOL_MAGIC_STRING = "monerochan";
+export function parseToolLink(link) {
+    const magic_str_index = link.lastIndexOf(TOOL_MAGIC_STRING);
+    if (magic_str_index !== -1) {
+        const link_start_index = magic_str_index + TOOL_MAGIC_STRING.length;
+        const tool_id = link.substring(link_start_index, link_start_index + 3);
+        const args = link
+            .substring(link_start_index + 3)
+            .split("_")
+            .slice(1);
+        if (tool_id === "001")
+            return parseSendTransactionToolArgs(args);
+        if (tool_id === "002")
+            return parseCreateAndShareViewOnlyWalletToolArgs(args);
+    }
+    return null;
+}
+export function parseToolInvocation(link, linkText, context_location) {
+    const context_domain = getDomainWithTLD(context_location.hostname);
+    const context_href = context_location.href;
+    const link_parse = parseToolLink(link);
+    if (link_parse) {
+        const destination_domain = parseDestination(link);
+        return {
+            tool: link_parse,
+            destination_domain,
+            context_domain,
+            found_in: "link",
+            link,
+            linkText,
+            timestamp: Date.now(),
+            invocation_id: crypto.randomUUID(),
+            context_href,
+            valid: "unverified",
+        };
+    }
+    else {
+        const linkText_parse = parseToolLink(linkText);
+        if (linkText_parse) {
+            const destination_domain = parseDestination(linkText);
+            return {
+                tool: linkText_parse,
+                destination_domain,
+                context_domain,
+                found_in: "linkText",
+                link,
+                linkText,
+                timestamp: Date.now(),
+                invocation_id: crypto.randomUUID(),
+                context_href,
+                valid: "unverified",
+            };
+        }
+    }
+    return null;
+}
+export function parseSendTransactionToolArgs(args) {
+    const amount = args[1];
+    const address = args[3];
+    try {
+        convertAmountBigIntThrows(amount);
+    }
+    catch (e) {
+        return null;
+    }
+    if (address && amount) {
+        return {
+            tool_id: "001",
+            payload: {
+                address,
+                amount,
+            },
+        };
+    }
+    return null;
+}
+export function createSendTransactionToolLink(address, amount) {
+    convertAmountBigIntThrows(amount);
+    return `${TOOL_MAGIC_STRING}001_amount_${amount}_address_${address}`;
+}
+export function make001ToolLink(address, amount) {
+    return createSendTransactionToolLink(address, amount);
+}
+export function parseCreateAndShareViewOnlyWalletToolArgs(args) {
+    const wallet_slot = args[5];
+    if (wallet_slot && !isNaN(parseInt(wallet_slot))) {
+        return {
+            tool_id: "002",
+            payload: {
+                wallet_slot: parseInt(wallet_slot),
+            },
+        };
+    }
+    return null;
+}
+export function createCreateAndShareViewOnlyWalletToolLink(wallet_slot) {
+    wallet_slot = Number(wallet_slot) || 0;
+    return `${TOOL_MAGIC_STRING}002_create_and_share_viewkey_slot_${wallet_slot}`;
+}
+export function make002ToolLink(wallet_slot) {
+    return createCreateAndShareViewOnlyWalletToolLink(wallet_slot);
+}
+export function createToolLink(tool) {
+    if (tool.tool_id === "001") {
+        return createSendTransactionToolLink(tool.payload.address, tool.payload.amount);
+    }
+    if (tool.tool_id === "002") {
+        return createCreateAndShareViewOnlyWalletToolLink(tool.payload.wallet_slot);
+    }
+    throw new Error("unknown tool");
+}
+export function getDomainWithTLD(hostname) {
+    const parts = hostname.split(".");
+    // For localhost or single-part hostnames, return as-is
+    if (parts.length <= 1)
+        return hostname;
+    // Take the last 2 parts (domain + tld).
+    return parts.slice(-2).join(".");
+}
+export function parseDestination(destination) {
+    const url = new URL(destination);
+    return getDomainWithTLD(url.hostname);
+}
+export const OPEN_DOMAINS = ["monerochan.city"];
+// this validity check should happen in the contentscript when the link is clicked,
+// not in the background script
+// -> tor circuit is separated & compartmentalized
+export async function checkToolInvocationValidity(invo) {
+    // send 001 fetch from destination domain to check if the address is valid
+    if (invo.tool.tool_id == "001") {
+        const checkUrl = `${invo.destination_domain}/monerochan001/${invo.tool.payload.address}`;
+        try {
+            if (invo.destination_domain === OPEN_DOMAINS[0]) {
+                return "unverified";
+            }
+            const result = (await (await fetch(checkUrl)).json());
+            if (result &&
+                typeof result === "object" &&
+                "valid_address" in result &&
+                result.valid_address === true) {
+                return "valid";
+            }
+            else {
+                return "invalid";
+            }
+        }
+        catch {
+            return "invalid";
+        }
+    }
+    // create view only wallet 002 make sure context + destination domain is the same
+    if (invo.tool.tool_id == "002") {
+        if (invo.context_domain == invo.destination_domain) {
+            return "valid";
+        }
+        else {
+            return "invalid";
+        }
+    }
+    return "unverified";
+}
+export const ADDRESS_VALID_RESPONSE = {
+    valid_address: true,
+};

package/dist/viewpair/ViewPair.d.ts

@@ -0,0 +1,157 @@
+import { type ScanResult } from "../scanning-syncing/scanresult/scanResult";
+export { type ScanResult };
+export { NodeUrl } from "../node-interaction/nodeUrl";
+import { type GetBlocksBinMetaCallback, type GetBlocksBinRequest } from "../node-interaction/binaryEndpoints";
+import { type ScanCache } from "../scanning-syncing/scanresult/scanCache";
+import { type MakeTransactionParams, type UnsignedTransaction } from "../send-functionality/transactionBuilding";
+import { WasmProcessor } from "../wasm-processing/wasmProcessor";
+import { type GetBlockHeadersRangeParams } from "../api";
+import { type CacheChangedCallback } from "../scanning-syncing/scanresult/scanCache";
+export type NETWORKS = "mainnet" | "stagenet" | "testnet";
+/**
+ * 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 {
+    node_url: string;
+    primary_address: string;
+    private _network;
+    get network(): NETWORKS;
+    private _genesis_hash;
+    get genesis_hash(): string;
+    protected constructor(node_url: string, primary_address: string);
+    static create(primary_address: string, secret_view_key: string, subaddress_index?: number, 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)
+     *
+     * if params.block_ids is supplied, it will add the genesis hash to the end of the block_ids array.
+     * (so you can just supply the block_id you want to start fetching from)
+     * @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)
+     * @param stopSync optional AbortSignal to stop the syncing process
+     * @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, stopSync?: AbortSignal): Promise<ScanResult | import("../api").ErrorResponse | undefined>;
+    addGenesisHashToBlockIds(params: GetBlocksBinRequest): Promise<GetBlocksBinRequest>;
+    /**
+     * This function helps with making requests to the get_blocks.bin endpoint of the Monerod nodes.
+     * if params.block_ids is supplied, it will add the genesis hash to the end of the block_ids array.
+     * (so you can just supply the block_id you want to start fetching from)
+     *
+     * 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)
+     * @param stopSync optional AbortSignal to stop the syncing process
+     * @returns This method will return a Uint8Array that can subsequently be scanned for outputs with the getBlocksBinScanResponse method.
+     */
+    getBlocksBinExecuteRequest(params: GetBlocksBinRequest, stopSync?: AbortSignal): Promise<Uint8Array<ArrayBufferLike>>;
+    /**
+     * 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 | import("../api").ErrorResponse | undefined>;
+    /**
+     * scan
+     */
+    scan(cacheChanged?: CacheChangedCallback, stopSync?: AbortSignal, scan_settings_path?: string, pathPrefix?: string): 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 method makes a Subaddress for the Address of the Viewpair it was opened with.
+     * The network (mainnet, stagenet, testnet) is the same as the one of the Viewpairaddress.
+     * if there is an active scan going on, call this on ScanCacheOpened, so the new subaddress will be scanned
+     *
+     * @param minor address index, we always set major (also called account index) to 0
+     * @returns Adressstring
+     */
+    makeSubaddress(minor: number): string;
+    private writeSubaddressesToScanCache;
+    addSubaddressesToScanCache(cache: ScanCache, scan_settings_path?: string): Promise<void>;
+    /**
+     * This method makes a Subaddress 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 major account index should be set to 0 in most cases
+     * @param minor address index starting at 1
+     * @returns Adressstring
+     */
+    private makeSubaddressRaw;
+    /**
+     * Creates a signable transaction using the provided parameters.
+     * @param params - The transaction parameters.
+     * @returns The serialized transaction as an array of numbers.
+     */
+    makeTransaction(params: MakeTransactionParams): UnsignedTransaction;
+    /**
+     * 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("../api").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;
+    }>;
+}