@spirobel/monero-wallet-api 0.5.1 → 0.5.2

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

@@ -1,9 +1,8 @@
 import { coordinatorMainWorker } from "./coordinator-main";
 import { handleCpuboundScanTry, sendFromCpuWorker } from "./cpubound-main";
 import { log, setupLoggingPath } from "../../io/logging";
-import { SCAN_SETTINGS_STORE_NAME_DEFAULT } from "../scanSettings";
 import { multisigMainWorkerCall } from "./multisig-main";
-import { DistributedKeyGenerator } from "../../api";
+import { DistributedKeyGenerator, SCAN_SETTINGS_STORE_NAME_DEFAULT, } from "../../api";
 self.onerror = (e) => self.postMessage({ type: "ERROR", payload: e });
 self.addEventListener("unhandledrejection", (e) => self.postMessage({ type: "ERROR", payload: e.reason }));
 let SCAN_SETTINGS_PATH;

package/dist/scansettings/scanSettings.d.ts

@@ -0,0 +1,165 @@
+import type { LogSetting, PossibleLogs } from "../io/logging";
+export declare const SCAN_SETTINGS_STORE_NAME_DEFAULT = "ScanSettings.json";
+export declare const SUB_ADDRESS_INDEX_DEFAULT_VALUE = 1;
+export type ScanSetting = {
+    primary_address: string;
+    subaddress_index?: number;
+    halted?: boolean;
+    wallet_route?: string;
+    wallet_name?: string;
+    wallet_slot?: number;
+};
+export type WriteScanSettingParams = {
+    primary_address: string;
+    start_height?: number | null;
+    subaddress_index?: number;
+    halted?: boolean;
+    scan_settings_path?: string;
+    node_url?: string;
+    wallet_route?: string;
+    wallet_name?: string;
+    wallet_slot?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
+};
+export type ScanSettingOpened = {
+    primary_address: string;
+    start_height: number | null;
+    node_url: string;
+    subaddress_index?: number;
+    secret_view_key?: string;
+    halted?: boolean;
+    secret_spend_key?: string;
+    wallet_route?: string;
+    wallet_name?: string;
+    wallet_slot?: number;
+};
+export type ScanSettings = {
+    wallets: ScanSetting[];
+    node_url: string;
+    start_height: number | null;
+    merchant_confirmations?: number | null;
+    cpu_worker_count?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
+};
+export type ScanSettingsOpened = {
+    wallets: (ScanSettingOpened | undefined)[];
+    node_url: string;
+    start_height: number | null;
+    merchant_confirmations?: number | null;
+    cpu_worker_count?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
+};
+/**
+ * Writes scan settings to the default or specified storage file in json.
+ *
+ * @example
+ * ```
+ * const settings: ScanSettings = {
+ *   wallets: [{
+ *     primary_address: "5dsf...",
+ *     start_height: 1741707,
+ *   }],
+ *   node_urls: ["https://monerooo.roooo"]
+ * };
+ * await writeScanSettings(settings);
+ * ```
+ *
+ * @param scan_settings - The complete {@link ScanSettings} configuration to persist.
+ * @param scan_settings_path - Optional path for the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns A promise that resolves when the file is successfully written.
+ * @throws Will throw if file writing fails (e.g., permissions, disk space).
+ */
+export declare function writeScanSettings(scan_settings: ScanSettings, scan_settings_path?: string): Promise<number>;
+export type WriteScanSettingsFileParams = {
+    scan_settings_path?: string;
+    writeCallback: (settings: ScanSettings) => void | Promise<void>;
+};
+export declare function writeScanSettingsFileDefaultLocation(params: WriteScanSettingsFileParams): Promise<void>;
+export declare function writeStartHeightToScanSettings(start_height: number | null, scan_settings_path?: string): Promise<number>;
+export declare function writeDaemonHeightAsStartHeightToScanSettings(node_url: string, scan_settings_path?: string): Promise<number>;
+export declare function cullTooLargeScanHeight(node_url: string, scan_settings_path?: string): Promise<number>;
+export declare function writeNodeUrlToScanSettings(node_url: string, scan_settings_path?: string): Promise<number>;
+export declare function readNodeUrlFromScanSettings(scan_settings_path?: string): Promise<string | undefined>;
+/**
+ * Writes the merchant confirmation threshold to scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param merchant_confirmations - Number of confirmations required before
+ *   accepting a payment, or `null` to leave it unset.
+ * @param scan_settings_path - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns A promise that resolves when the file is successfully written.
+ */
+export declare function writeMerchantConfirmationsToScanSettings(merchant_confirmations: number | null, scan_settings_path?: string): Promise<number>;
+/**
+ * Reads the merchant confirmation threshold from scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ *
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param scan_settings_path - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns The configured number of confirmations, null, or `undefined`
+ *   if the setting has not been persisted yet.
+ */
+export declare function readMerchantConfirmationsFromScanSettings(scan_settings_path?: string): Promise<number | null | undefined>;
+/**
+ * Reads scan settings from the default or specified storage file.
+ * secret_view_key and spend_private_key are read from environment variables
+ *
+ * @example
+ * ```
+ * const settings = await readScanSettings();
+ * if (settings) {
+ *   console.log(settings.wallets?.primary_address);
+ * }
+ * ```
+ *
+ * @param scan_settings_path - Path to the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns The parsed {@link ScanSettings} object if file exists and is valid JSON, otherwise `undefined`.
+ */
+export declare function readScanSettings(scan_settings_path?: string): Promise<ScanSettingsOpened | undefined>;
+export declare function readPrivateSpendKeyFromEnv(primary_address: string): string | undefined;
+export declare function readPrivateViewKeyFromEnv(primary_address: string): string | undefined;
+export declare function readWalletFromScanSettings(primary_address: string, scan_settings_path?: string): Promise<ScanSettingOpened | undefined>;
+export declare function readWalletsFromScanSettings(scan_settings_path?: string): Promise<ScanSettingOpened[]>;
+export declare function walletSettingsPlusKeys(wallet_settings: ScanSettingOpened, secret_view_key?: string, secret_spend_key?: string): Promise<{
+    secret_view_key: string;
+    secret_spend_key: string | undefined;
+    primary_address: string;
+    start_height: number | null;
+    node_url: string;
+    subaddress_index?: number;
+    halted?: boolean;
+    wallet_route?: string;
+    wallet_name?: string;
+    wallet_slot?: number;
+}>;
+export declare function writeWalletToScanSettings(params: WriteScanSettingParams): Promise<number>;
+export declare function openScanSettingsFile(scan_settings_path?: string): Promise<ScanSettings | undefined>;
+export declare function openNonHaltedWallets(scan_settings_path?: string): Promise<ScanSettingOpened[]>;
+export declare function getNonHaltedWallets(scan_settings?: ScanSettings): ScanSetting[];
+export declare function doesScanSettingsFileExist(scan_settings_path?: string): Promise<boolean>;
+/**
+ * Either 1. the consumer explicitly sets a pathprefix, we extract it from the scan_settings_path
+ * or we pick the default which is nothing
+ * @param scan_settings_path optional scan settings path
+ * @param pathPrefix optional path prefix
+ * @returns definite path prefix
+ */
+export declare function getPathPrefix(scan_settings_path?: string, pathPrefix?: string): string;

package/dist/scansettings/scanSettings.js

@@ -0,0 +1,338 @@
+import { get_info } from "../api";
+import { atomicWrite } from "../io/atomicWrite";
+import { refreshEnvIndexedDB } from "../io/indexedDB";
+import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
+export const SCAN_SETTINGS_STORE_NAME_DEFAULT = "ScanSettings.json";
+// default value for subaddress highest minor index eg up to which minor index,
+// to add subaddresses to the scanner
+// (we never touch major index, having two values is just too confusing)
+export const SUB_ADDRESS_INDEX_DEFAULT_VALUE = 1;
+/**
+ * Writes scan settings to the default or specified storage file in json.
+ *
+ * @example
+ * ```
+ * const settings: ScanSettings = {
+ *   wallets: [{
+ *     primary_address: "5dsf...",
+ *     start_height: 1741707,
+ *   }],
+ *   node_urls: ["https://monerooo.roooo"]
+ * };
+ * await writeScanSettings(settings);
+ * ```
+ *
+ * @param scan_settings - The complete {@link ScanSettings} configuration to persist.
+ * @param scan_settings_path - Optional path for the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns A promise that resolves when the file is successfully written.
+ * @throws Will throw if file writing fails (e.g., permissions, disk space).
+ */
+export async function writeScanSettings(scan_settings, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    return await atomicWrite(scan_settings_path, JSON.stringify(scan_settings, null, 2));
+}
+export async function writeScanSettingsFileDefaultLocation(params) {
+    let settings = await openScanSettingsFile(params.scan_settings_path);
+    if (!settings) {
+        // Create empty ScanSettings object with default values
+        settings = {
+            node_url: LOCAL_NODE_DEFAULT_URL,
+            wallets: [],
+            start_height: null,
+        };
+    }
+    await params.writeCallback(settings);
+    // write to settings file
+    await writeScanSettings(settings, params.scan_settings_path);
+}
+export async function writeStartHeightToScanSettings(start_height, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
+        node_url: LOCAL_NODE_DEFAULT_URL,
+        wallets: [],
+        start_height: null,
+    };
+    scanSettings.start_height = start_height;
+    return await atomicWrite(SCAN_SETTINGS_STORE_NAME_DEFAULT, JSON.stringify(scanSettings, null, 2));
+}
+export async function writeDaemonHeightAsStartHeightToScanSettings(node_url, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const getInfo = await get_info(node_url);
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
+        node_url: LOCAL_NODE_DEFAULT_URL,
+        wallets: [],
+        start_height: null,
+    };
+    scanSettings.start_height = getInfo.height - 1;
+    await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
+    return getInfo.height;
+}
+export async function cullTooLargeScanHeight(node_url, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const getInfo = await get_info(node_url);
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
+        node_url: LOCAL_NODE_DEFAULT_URL,
+        wallets: [],
+        start_height: null,
+    };
+    if (scanSettings.start_height === null ||
+        scanSettings.start_height > getInfo.height - 1) {
+        scanSettings.start_height = getInfo.height - 1;
+        await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
+    }
+    return scanSettings.start_height;
+}
+export async function writeNodeUrlToScanSettings(node_url, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
+        node_url: LOCAL_NODE_DEFAULT_URL,
+        wallets: [],
+        start_height: null,
+    };
+    scanSettings.node_url = node_url;
+    return await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
+}
+export async function readNodeUrlFromScanSettings(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
+    return scanSettings?.node_url;
+}
+/**
+ * Writes the merchant confirmation threshold to scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param merchant_confirmations - Number of confirmations required before
+ *   accepting a payment, or `null` to leave it unset.
+ * @param scan_settings_path - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns A promise that resolves when the file is successfully written.
+ */
+export async function writeMerchantConfirmationsToScanSettings(merchant_confirmations, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
+        node_url: LOCAL_NODE_DEFAULT_URL,
+        wallets: [],
+        start_height: null,
+    };
+    scanSettings.merchant_confirmations = merchant_confirmations;
+    return await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
+}
+/**
+ * Reads the merchant confirmation threshold from scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ *
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param scan_settings_path - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns The configured number of confirmations, null, or `undefined`
+ *   if the setting has not been persisted yet.
+ */
+export async function readMerchantConfirmationsFromScanSettings(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
+    return scanSettings?.merchant_confirmations;
+}
+/**
+ * Reads scan settings from the default or specified storage file.
+ * secret_view_key and spend_private_key are read from environment variables
+ *
+ * @example
+ * ```
+ * const settings = await readScanSettings();
+ * if (settings) {
+ *   console.log(settings.wallets?.primary_address);
+ * }
+ * ```
+ *
+ * @param scan_settings_path - Path to the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns The parsed {@link ScanSettings} object if file exists and is valid JSON, otherwise `undefined`.
+ */
+export async function readScanSettings(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
+    if (!scanSettings)
+        return undefined;
+    const openScanSettings = Object.assign({}, scanSettings);
+    for (const [i, wallet] of scanSettings.wallets.entries()) {
+        if (!wallet.primary_address)
+            throw new Error("The entry ${i} in the wallet settings list in ${scan_settings_path} has no primary address");
+        const walletWithKeys = await walletSettingsPlusKeys({
+            ...wallet,
+            node_url: scanSettings.node_url,
+            start_height: scanSettings.start_height,
+        });
+        openScanSettings.wallets[i].secret_view_key =
+            walletWithKeys.secret_view_key;
+        openScanSettings.wallets[i].secret_spend_key =
+            walletWithKeys.secret_spend_key;
+    }
+    return openScanSettings;
+}
+export function readPrivateSpendKeyFromEnv(primary_address) {
+    return Bun.env["sk" + primary_address];
+}
+export function readPrivateViewKeyFromEnv(primary_address) {
+    return Bun.env["vk" + primary_address];
+}
+export async function readWalletFromScanSettings(primary_address, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
+    if (!scanSettings)
+        return undefined;
+    const walletSettings = scanSettings.wallets.find((wallet) => wallet?.primary_address === primary_address);
+    if (!walletSettings)
+        throw new Error(`wallet not found in settings. did you call openwallet with the right params?
+      Either wrong file name supplied to params.scan_settings_path: ${scan_settings_path}
+      Or wrong primary_address supplied params.primary_address: ${primary_address}`);
+    return {
+        ...walletSettings,
+        node_url: scanSettings.node_url,
+        start_height: scanSettings.start_height,
+    };
+}
+export async function readWalletsFromScanSettings(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
+    const scanSettingsOpened = [];
+    for (const wallet of scanSettings?.wallets || []) {
+        scanSettingsOpened.push({
+            ...wallet,
+            node_url: scanSettings?.node_url || LOCAL_NODE_DEFAULT_URL,
+            start_height: scanSettings?.start_height || null,
+        });
+    }
+    return scanSettingsOpened;
+}
+export async function walletSettingsPlusKeys(wallet_settings, secret_view_key, secret_spend_key) {
+    // read secret_view_key and secret_spend_key from env
+    if (!secret_view_key)
+        secret_view_key = Bun.env[`vk${wallet_settings.primary_address}`];
+    if (!secret_view_key) {
+        await refreshEnvIndexedDB();
+        secret_view_key = Bun.env[`vk${wallet_settings.primary_address}`];
+    }
+    if (!secret_view_key)
+        throw ("no secret_view_key provided and not found in env for address: " +
+            wallet_settings.primary_address);
+    if (!secret_spend_key)
+        secret_spend_key = Bun.env[`sk${wallet_settings.primary_address}`];
+    return {
+        ...wallet_settings,
+        secret_view_key,
+        secret_spend_key,
+    };
+}
+export async function writeWalletToScanSettings(params) {
+    if (!params.scan_settings_path)
+        params.scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT;
+    if (!params.primary_address)
+        throw new Error("no primary address provided to writeWalletToScanSettings()");
+    const scanSettings = await openScanSettingsFile(params.scan_settings_path);
+    if (!scanSettings) {
+        if (!params.node_url)
+            params.node_url = LOCAL_NODE_DEFAULT_URL;
+        // case: no scan settings exist yet
+        return await writeScanSettings({
+            wallets: [
+                {
+                    primary_address: params.primary_address,
+                    subaddress_index: params.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE,
+                    halted: params.halted,
+                    wallet_route: params.wallet_route,
+                    wallet_name: params.wallet_name,
+                    wallet_slot: params.wallet_slot,
+                },
+            ],
+            node_url: params.node_url,
+            logs: params.logs,
+            logs_include: params.logs_include,
+            logs_exclude: params.logs_exclude,
+            start_height: params.start_height || null,
+        }, params.scan_settings_path);
+    }
+    scanSettings.node_url = params.node_url || scanSettings.node_url;
+    if (params.logs)
+        scanSettings.logs = params.logs;
+    if (params.logs_include)
+        scanSettings.logs_include = params.logs_include;
+    if (params.logs_exclude)
+        scanSettings.logs_exclude = params.logs_exclude;
+    scanSettings.start_height =
+        params.start_height === undefined
+            ? scanSettings.start_height
+            : params.start_height;
+    const already_has_settings = scanSettings.wallets.findIndex((wallet) => wallet?.primary_address === params.primary_address);
+    if (already_has_settings === -1) {
+        // wallet does not exist yet in settings
+        scanSettings.wallets.push({
+            primary_address: params.primary_address,
+            subaddress_index: params.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE,
+            halted: params.halted,
+            wallet_route: params.wallet_route,
+            wallet_name: params.wallet_name,
+            wallet_slot: params.wallet_slot,
+        });
+    }
+    else {
+        // wallet already exists
+        const wallet = scanSettings.wallets[already_has_settings];
+        if (wallet) {
+            wallet.subaddress_index =
+                params.subaddress_index ||
+                    wallet.subaddress_index ||
+                    SUB_ADDRESS_INDEX_DEFAULT_VALUE;
+            wallet.halted = params.halted || wallet.halted;
+            wallet.wallet_route = params.wallet_route || wallet.wallet_route;
+            wallet.wallet_name = params.wallet_name || wallet.wallet_name;
+            wallet.wallet_slot = params.wallet_slot || wallet.wallet_slot;
+        }
+    }
+    return await atomicWrite(params.scan_settings_path, JSON.stringify(scanSettings, null, 2));
+}
+export async function openScanSettingsFile(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const jsonString = await Bun.file(scan_settings_path)
+        .text()
+        .catch(() => undefined);
+    return jsonString ? JSON.parse(jsonString) : undefined;
+}
+export async function openNonHaltedWallets(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scan_settings = await readWalletsFromScanSettings(scan_settings_path);
+    if (!scan_settings)
+        throw new Error("no scan settings file found at path: " + scan_settings_path);
+    if (!scan_settings)
+        throw new Error("no wallets in scan settings");
+    const nonHaltedWallets = scan_settings.filter((wallet) => !wallet?.halted);
+    if (!nonHaltedWallets.length)
+        throw new Error("no non halted wallets in scan settings");
+    return nonHaltedWallets;
+}
+export function getNonHaltedWallets(scan_settings) {
+    if (!scan_settings)
+        return [];
+    const nonHaltedWallets = scan_settings.wallets.filter((wallet) => !wallet?.halted);
+    return nonHaltedWallets;
+}
+export async function doesScanSettingsFileExist(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scan_settings_file_content = await Bun.file(scan_settings_path)
+        .text()
+        .catch(() => "");
+    if (scan_settings_file_content.length) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Either 1. the consumer explicitly sets a pathprefix, we extract it from the scan_settings_path
+ * or we pick the default which is nothing
+ * @param scan_settings_path optional scan settings path
+ * @param pathPrefix optional path prefix
+ * @returns definite path prefix
+ */
+export function getPathPrefix(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT, pathPrefix) {
+    const parts = scan_settings_path.split("/");
+    const basename = parts.pop();
+    const dir = parts.join("/");
+    const prefix = dir ? `${dir}/` : "";
+    return pathPrefix ?? prefix;
+}

package/dist/scansettings/scanSettingsOpened.d.ts

@@ -0,0 +1,102 @@
+import { type LogSetting, type PossibleLogs } from "../io/logging";
+import { type ScanSetting, type ScanSettingOpened } from "../api";
+export declare class ScanSettingsOpened {
+    private _scan_settings_path;
+    private _pathPrefix;
+    /**
+     * open the settings file and return a new ScanSettingsOpened instance.
+     * if the file does not exist, creates one with defaults.
+     */
+    static create(scan_settings_path?: string, pathPrefix?: string): Promise<ScanSettingsOpened>;
+    get node_url(): string;
+    get start_height(): number | null;
+    get merchant_confirmations(): number | null | undefined;
+    get cpu_worker_count(): number | undefined;
+    get logs(): LogSetting | undefined;
+    get logs_include(): PossibleLogs[] | undefined;
+    get logs_exclude(): PossibleLogs[] | undefined;
+    get wallets(): ScanSetting[];
+    get scan_settings_path(): string;
+    get pathPrefix(): string;
+    setNodeUrl(node_url: string): Promise<void>;
+    setStartHeight(start_height: number | null): Promise<void>;
+    setMerchantConfirmations(merchant_confirmations: number | undefined | null): Promise<void>;
+    setCpuWorkerCount(cpu_worker_count: number | undefined | null): Promise<void>;
+    setLogSettings(logs?: LogSetting | null, logs_include?: PossibleLogs[] | null, logs_exclude?: PossibleLogs[] | null): Promise<void>;
+    /**
+     * get a wallet's settings (without env keys).
+     * returns undefined if not found.
+     */
+    getWallet(primary_address: string): ScanSetting | undefined;
+    /**
+     * get a wallet's settings merged with env keys.
+     * throws if not found or view key missing.
+     */
+    getWalletOpened(primary_address: string): Promise<ScanSettingOpened>;
+    /**
+     * get all wallets merged with env keys.
+     * wallets missing env keys are skipped.
+     */
+    getWalletsOpened(): Promise<ScanSettingOpened[]>;
+    walletExists(primary_address: string): boolean;
+    /**
+     * add a new view wallet to settings and write its view key to env.
+     * if the wallet already exists, updates it instead.
+     */
+    addViewWallet(primary_address: string, view_key: string, fields?: {
+        wallet_name?: string;
+        wallet_slot?: number;
+        wallet_route?: string;
+        subaddress_index?: number;
+        halted?: boolean;
+    }): Promise<void>;
+    /**
+     * add a new view wallet to settings and write its view key to env.
+     * if the wallet already exists, updates it instead.
+     */
+    addSpendWallet(wallet_secret: Uint8Array, fields?: {
+        wallet_name?: string;
+        wallet_slot?: number;
+        wallet_route?: string;
+        subaddress_index?: number;
+        halted?: boolean;
+    }): Promise<void>;
+    /**
+     * remove a wallet from settings by primary address.
+     * does not remove the view key from env.
+     */
+    removeWallet(primary_address: string): Promise<void>;
+    /**
+     * update specific fields on an existing wallet.
+     * set a field to null to unset it.
+     */
+    updateWallet(primary_address: string, fields: {
+        wallet_name?: string | null;
+        wallet_slot?: number | null;
+        wallet_route?: string | null;
+        subaddress_index?: number | null;
+        halted?: boolean | null;
+    }): Promise<void>;
+    haltWallet(primary_address: string): Promise<void>;
+    unhaltWallet(primary_address: string): Promise<void>;
+    setWalletName(primary_address: string, name?: string): Promise<void>;
+    setWalletSlot(primary_address: string, slot?: number): Promise<void>;
+    setWalletRoute(primary_address: string, route?: string): Promise<void>;
+    setSubaddressIndex(primary_address: string, index?: number): Promise<void>;
+    /**
+     * reread the settings file from disk and replace inmemory state.
+     */
+    reload(): Promise<void>;
+    /**
+     * validate that all entries in logs_include and logs_exclude
+     * are valid function names from LOGGING_FUNCTIONS.
+     * throws if any entry is invalid.
+     */
+    private static _validateLogOptions;
+    private _settings;
+    private constructor();
+    /**
+     * write current in memory state to disk.
+     */
+    private _persist;
+}