@spirobel/monero-wallet-api 0.2.0 → 0.3.1

package/dist/scanning-syncing/scanresult/scanResult.d.ts

@@ -0,0 +1,64 @@
+import type { BlockInfo, Output } from "../../api";
+import { type KeyImage } from "./computeKeyImage";
+import { type ErrorResponse } from "../../node-interaction/binaryEndpoints";
+import type { CacheChangedCallback, CacheRange, ChangedOutput, ScanCache } from "./scanCache";
+export type ProcessScanResultParams = {
+    current_range: CacheRange;
+    result: ScanResult | ErrorResponse | undefined;
+    cacheChanged: CacheChangedCallback;
+    catastrophic_reorg_cb: () => void;
+    secret_spend_key?: string;
+    pathPrefix?: string;
+    use_master_current_range?: boolean;
+};
+export declare function processScanResult(params: ProcessScanResultParams): Promise<CacheRange>;
+export type OnchainKeyImage = {
+    key_image_hex: KeyImage;
+    relative_index: number;
+    tx_hash: string;
+    block_hash: string;
+    block_height: number;
+    block_timestamp: number;
+};
+export type ScanResult = {
+    outputs: Output[];
+    all_key_images: OnchainKeyImage[];
+    new_height: number;
+    primary_address: string;
+    block_infos: BlockInfo[];
+    daemon_height: number;
+};
+export type EmptyScanResult = {};
+export type FastForward = number;
+/**
+ * we will await async callbacks. convenient way to halt a sync + feed back the key image list,
+ * to look out for our own spends before proceeding the scan. This happens in the processScanResult function.
+ */
+export type ScanResultCallback = ((result: ScanResult | ErrorResponse | EmptyScanResult) => FastForward | void) | ((result: ScanResult | ErrorResponse | EmptyScanResult) => Promise<FastForward | void>);
+export declare function updateScanHeight(current_range: CacheRange, result: ScanResult, cache: ScanCache): [CacheRange, ChangedOutput[]];
+export declare function makeNewRange(newRange: CacheRange, cache: ScanCache): CacheRange;
+export declare function detectOutputs(result: ScanResult, cache: ScanCache, spend_private_key?: string): Promise<ChangedOutput[]>;
+export declare function detectOwnspends(result: ScanResult, cache: ScanCache): ChangedOutput[];
+export declare function unlockedAtHeight(output: Output): number;
+export type PrePending = {
+    status: "prepending";
+};
+export type Pending = {
+    status: "pending";
+    unlock_height: number;
+};
+export type Spent = {
+    status: "spent";
+};
+export type Burnt = {
+    status: "burnt";
+};
+export type Reorged = {
+    status: "reorged";
+};
+export type Spendable = {
+    status: "spendable";
+};
+export type OutputStatus = PrePending | Pending | Spent | Burnt | Reorged | Spendable;
+export declare function outputStatus(output: Output, cache: ScanCache, current_height: number): OutputStatus;
+export declare function spendable(output: Output, cache: ScanCache, current_height: number): boolean;

package/dist/scanning-syncing/scanresult/scanResult.js

@@ -0,0 +1,213 @@
+import { computeKeyImage } from "./computeKeyImage";
+import { mergeRanges, findRange, readCacheFileDefaultLocation, lastRange, writeCacheToFile, } from "./scanCache";
+import {} from "../../node-interaction/binaryEndpoints";
+import { handleReorg } from "./reorg";
+export async function processScanResult(params) {
+    let current_range = params.current_range;
+    const { result, cacheChanged, secret_spend_key, pathPrefix, use_master_current_range, } = params;
+    if (!(result && "primary_address" in result))
+        return current_range;
+    const cache = await readCacheFileDefaultLocation(result.primary_address, pathPrefix);
+    if (!cache)
+        throw new Error(`cache not found for primary address: ${result.primary_address} and path prefix: ${pathPrefix}`);
+    if (result && "daemon_height" in result)
+        cache.daemon_height = result.daemon_height;
+    if (use_master_current_range) {
+        const last = lastRange(cache.scanned_ranges);
+        if (last) {
+            last.block_hashes = current_range.block_hashes;
+            last.end = current_range.end;
+        }
+        else {
+            cache.scanned_ranges.push(current_range);
+        }
+    }
+    try {
+        if (result && "new_height" in result) {
+            const [new_range, changed_outputs] = updateScanHeight(current_range, result, cache);
+            current_range = new_range;
+            changed_outputs.push(...(await detectOutputs(result, cache, secret_spend_key)));
+            if (secret_spend_key)
+                changed_outputs.push(...detectOwnspends(result, cache));
+            // write to cache
+            await writeCacheToFile(cache, params.pathPrefix);
+            await cacheChanged({
+                newCache: cache,
+                changed_outputs,
+            });
+        }
+        return current_range;
+    }
+    catch (e) {
+        params.catastrophic_reorg_cb();
+        throw e;
+    }
+}
+export function updateScanHeight(current_range, result, cache) {
+    let last_block_hash_of_result = result.block_infos.at(-1);
+    let current_blockhash = current_range?.block_hashes.at(0);
+    if (!current_blockhash)
+        throw new Error("current_range passed to updateScanHeight was malformed. block_hashes is empty");
+    if (!last_block_hash_of_result)
+        return [current_range, []]; // block_infos empty, no change (we are at tip and there was no new block)
+    // if last blockhash is undefined it means there was not reorg, we are at tip, block_infos is empty ( no new blocks )
+    const oldRange = findRange(cache.scanned_ranges, current_blockhash.block_height);
+    if (!oldRange)
+        throw new Error(`could not find scan range for height ${current_blockhash.block_height},
+       that means the blocks in the response from getBlocks.bin do not overlap
+       with the scanned ranges in the cache. This should not happen, as even if 
+       we are starting from a new start_height that has been supplied to scanWithCache,
+       it has been found as an existing range in the cache, or it has been
+       added as a new range before we started scannning.`);
+    // now we need to find the block_infos of old range in the new geblocksbin response result block_infos
+    // if we cant find the new range, there was a reorg and we need to clean all outputs after that and log what happened
+    let first_block_hash = result.block_infos.at(0);
+    if (!first_block_hash)
+        return [current_range, []]; // should never happen, if there is last_block_hash there should be first_block_hash
+    // if the first block hash in the response is not the same as the last block hash in the old range, there was a reorg
+    if (!(first_block_hash.block_hash === current_blockhash.block_hash)) {
+        return handleReorg(current_range, result, cache, oldRange);
+    }
+    // scan only happens in one direction,
+    // to scan earlier ranges: abort and recall with smaller start_height
+    // getblocksbin will return up to 1000 blocks at once
+    // so this should never happen, except if we just popped a block (but that case is handled above in the reorg case)
+    if (current_blockhash.block_height > last_block_hash_of_result.block_height)
+        throw new Error(`current scan height was larger than block height of last block from latest scan result. 
+       Most likely connected to faulty node / catastrophic reorg.
+       current height: ${current_blockhash.block_height}, new height: ${last_block_hash_of_result.block_height}`);
+    // 1. add new scanned range
+    let anchor = undefined;
+    let anchor_candidate = undefined;
+    if (oldRange.block_hashes.length >= 3) {
+        const old_anchor = oldRange.block_hashes.at(-1);
+        const old_anchor_candidate = oldRange.block_hashes.at(-2);
+        anchor = old_anchor;
+        anchor_candidate = old_anchor_candidate;
+        if (
+        // if the old range has an anchor, and the anchor is more than 200 blocks old
+        typeof old_anchor?.block_height === "number" &&
+            current_blockhash.block_height - old_anchor.block_height > 200) {
+            anchor = old_anchor_candidate; // use the anchor_candidate as anchor
+            // new anchor_candidate: is the one 100 blocks in, or the old scan tip
+            anchor_candidate =
+                result.block_infos.slice(-100)[0] || oldRange?.block_hashes.at(0); // use  use the old scan tip as anchor candidate
+        }
+    }
+    // if there is no old anchor, use the one 100 blocks in, or the last block hash
+    anchor =
+        anchor || result.block_infos.slice(-100)[0] || last_block_hash_of_result;
+    // carry over the old anchor candidate or use the last block
+    anchor_candidate = anchor_candidate || last_block_hash_of_result;
+    const newRange = {
+        start: current_blockhash.block_height,
+        end: last_block_hash_of_result.block_height,
+        block_hashes: [last_block_hash_of_result, anchor_candidate, anchor],
+    };
+    return [makeNewRange(newRange, cache), []];
+}
+export function makeNewRange(newRange, cache) {
+    cache.scanned_ranges.push(newRange);
+    // merge existing ranges & find end of current range
+    cache.scanned_ranges = mergeRanges(cache.scanned_ranges);
+    // if we hit the end of a range we already scanned, move scan tip to the end
+    const fastForward = findRange(cache.scanned_ranges, newRange.end);
+    if (fastForward)
+        return fastForward;
+    return newRange;
+}
+// Assumption: result is new, cache is still old. (this + detectOwnspends() turns the catch new, based on the scan result)
+export async function detectOutputs(result, cache, spend_private_key) {
+    let changed_outputs = [];
+    for (const output of result.outputs) {
+        // 0. prevent burning bug and avoid overwriting earlier found outputs
+        const duplicate = Object.values(cache.outputs).find((ex) => ex.stealth_address === output.stealth_address && !ex.burned);
+        let burned = false;
+        if (duplicate?.index_on_blockchain !== output.index_on_blockchain) {
+            burned = true;
+        }
+        if (duplicate && burned) {
+            //mark burned output
+            const existingIndex = duplicate.index_on_blockchain;
+            const liveIndex = Math.min(existingIndex, output.index_on_blockchain);
+            if (liveIndex === existingIndex) {
+                output.burned = existingIndex;
+            }
+            else {
+                duplicate.burned = output.index_on_blockchain;
+            }
+            // here we add to changed_outputs with reason burned
+            changed_outputs.push({ output, change_reason: "burned" });
+        }
+        else if (duplicate && !burned) {
+            continue; // if it is just a duplicate we continue the loop to avoid overwriting (ereasing spent status)
+        }
+        // 1. add to outputs cache 2. add to added array for cacheChanged callback
+        const globalId = output.index_on_blockchain.toString();
+        cache.outputs[globalId] = output;
+        //here we add to changed_outputs with reason added
+        changed_outputs.push({ output, change_reason: "added" });
+        // 3. if this is not view only, add the key image to the cache, to find transactions spent by this wallet
+        if (spend_private_key) {
+            let keyImage = await computeKeyImage(output, spend_private_key);
+            if (keyImage) {
+                cache.own_key_images[keyImage] = globalId;
+            }
+        }
+    }
+    return changed_outputs;
+}
+// Assumption: result is new, cache is still old. (this + detectOutputs() turns the catch new, based on the scan result)
+export function detectOwnspends(result, cache) {
+    let changed_outputs = [];
+    for (const onchainKeyImage of result.all_key_images) {
+        if (onchainKeyImage.key_image_hex in cache.own_key_images) {
+            // this is one of ours
+            const globalId = cache.own_key_images[onchainKeyImage.key_image_hex];
+            // add the information where we spent it to the output
+            cache.outputs[globalId].spent_relative_index =
+                onchainKeyImage.relative_index;
+            cache.outputs[globalId].spent_in_tx_hash = onchainKeyImage.tx_hash;
+            cache.outputs[globalId].spent_block_height = onchainKeyImage.block_height;
+            cache.outputs[globalId].spent_block_timestamp =
+                onchainKeyImage.block_timestamp;
+            //here we add to changed_outputs with reason ownspend
+            changed_outputs.push({
+                output: cache.outputs[globalId],
+                change_reason: "ownspend",
+            });
+        }
+    }
+    return changed_outputs;
+}
+export function unlockedAtHeight(output) {
+    if (output.is_miner_tx) {
+        return output.block_height + 60;
+    }
+    else {
+        return output.block_height + 10;
+    }
+}
+export function outputStatus(output, cache, current_height) {
+    if (
+    // order matters, check this before "spent" check + "pending" check
+    cache.pending_spent_utxos &&
+        cache.pending_spent_utxos[output.index_on_blockchain.toString()]) {
+        return { status: "prepending" };
+    }
+    if (typeof output.burned === "number") {
+        return { status: "burnt" };
+    }
+    if (typeof output.spent_in_tx_hash === "string") {
+        return { status: "spent" };
+    }
+    const unlock_height = unlockedAtHeight(output);
+    if (unlock_height > current_height) {
+        return { status: "pending", unlock_height };
+    }
+    return { status: "spendable" };
+}
+export function spendable(output, cache, current_height) {
+    const status = outputStatus(output, cache, current_height);
+    return status.status === "spendable";
+}

package/dist/scanning-syncing/scanresult/scanStats.d.ts

@@ -0,0 +1,60 @@
+import { ViewPair, type Output } from "../../api";
+import type { ScanCache, Subaddress, TxLog } from "./scanCache";
+import { type OutputStatus } from "./scanResult";
+export type WriteStatsFileParams = {
+    primary_address: string;
+    pathPrefix?: string | undefined;
+    writeCallback: (stats: ScanStats) => void | Promise<void>;
+};
+export declare function writeStatsFileDefaultLocation(params: WriteStatsFileParams): Promise<ScanStats>;
+export declare function statsFileDefaultLocation(primary_address: string, pathPrefix?: string): string;
+export declare function readStatsFile(cacheFilePath: string): Promise<ScanStats | undefined>;
+export declare function readStatsFileDefaultLocation(primary_address: string, pathPrefix?: string): Promise<ScanStats | undefined>;
+export declare function addSpentAmount(scan_stats: ScanStats, output: Output): void;
+export declare function addSpendableAmount(scan_stats: ScanStats, output: Output): void;
+export declare function addPendingAmount(scan_stats: ScanStats, output: Output): void;
+export type SubaddressMinorIndex = string;
+export type Amount = bigint;
+export type FoundTransaction = {
+    amount: bigint;
+    inputs: Output[];
+    outputs: Output[];
+    tx_hash: string;
+    status: OutputStatus;
+    txlog?: TxLog;
+};
+export type TxHash = string;
+export type ScanStats = {
+    height: number;
+    total_spendable_amount: bigint;
+    total_pending_amount: bigint;
+    primary_address: string;
+    primary_address_received_amount?: bigint;
+    primary_address_pending_amount?: bigint;
+    subaddresses: Record<SubaddressMinorIndex, Subaddress>;
+    found_transactions: Record<TxHash, FoundTransaction>;
+    ordered_transactions: TxHash[];
+};
+export declare function processFoundTransactions(cache: ScanCache, stats: ScanStats, current_height: number): void;
+export declare function removeChangeFromPrimaddressAmounts(stats: ScanStats): void;
+export declare function addSubAddressesFromCacheToScanStats(cache: ScanCache, stats: ScanStats): void;
+export declare function addMissingSubAddressesToScanStats(stats: ScanStats, view_pair: ViewPair, highestSubaddressMinor?: number, created_at_height?: number): void;
+export declare function isSelfSpent(address: string, cache: ScanCache): boolean;
+export declare function removeChangeFromPrimAddressReceivedAmounts(stats: ScanStats): void;
+export type PrePendingTx = {
+    amount: bigint;
+    inputs: Output[];
+    txlog: TxLog;
+    inputSum: bigint;
+    outWardPaymentSum: bigint;
+    self_spent: boolean;
+    destination_address: string;
+};
+export declare function processTxlogPayments(txlog: TxLog, cache: ScanCache): bigint;
+export declare function processTxlogInputs(txlog: TxLog, cache: ScanCache): {
+    inputSum: bigint;
+    alreadyRecognizedAsSpend: boolean;
+};
+export declare function processTxlogs(cache: ScanCache, stats: ScanStats): void;
+export declare function alignScanStatsWithCache(cache: ScanCache, view_pair: ViewPair, primary_address: string, pathPrefix?: string, highestSubaddressMinor?: number, current_scan_tip_height?: number): Promise<ScanStats>;
+export declare function resetStats(stats: ScanStats): void;

package/dist/scanning-syncing/scanresult/scanStats.js

@@ -0,0 +1,273 @@
+import { stat } from "fs";
+import { atomicWrite, ViewPair } from "../../api";
+import { outputStatus } from "./scanResult";
+export async function writeStatsFileDefaultLocation(params) {
+    let stats = await readStatsFileDefaultLocation(params.primary_address, params.pathPrefix);
+    if (!stats)
+        stats = {
+            height: 0,
+            total_spendable_amount: 0n,
+            total_pending_amount: 0n,
+            primary_address: params.primary_address,
+            found_transactions: {},
+            ordered_transactions: [],
+            subaddresses: {},
+        };
+    await params.writeCallback(stats);
+    await atomicWrite(statsFileDefaultLocation(stats.primary_address, params.pathPrefix), JSON.stringify(stats, (key, value) => (typeof value === "bigint" ? value.toString() : value), 2));
+    return stats;
+}
+export function statsFileDefaultLocation(primary_address, pathPrefix) {
+    return `${pathPrefix ?? ""}${primary_address}_stats.json`;
+}
+// amount | total_amount | total_pending_amount | pending_amount  :->  all bigint keys
+export async function readStatsFile(cacheFilePath) {
+    const jsonString = await Bun.file(cacheFilePath)
+        .text()
+        .catch(() => undefined);
+    return jsonString
+        ? JSON.parse(jsonString, (key, value) => {
+            if (key === "amount" ||
+                key === "pending_amount" ||
+                key === "total_amount" ||
+                key === "total_pending_amount")
+                return BigInt(value);
+            return value;
+        })
+        : undefined;
+}
+export async function readStatsFileDefaultLocation(primary_address, pathPrefix) {
+    return await readStatsFile(statsFileDefaultLocation(primary_address, pathPrefix));
+}
+export function addSpentAmount(scan_stats, output) {
+    if (!output.subaddress_index) {
+        if (!scan_stats.primary_address_received_amount)
+            scan_stats.primary_address_received_amount = 0n;
+        scan_stats.primary_address_received_amount += output.amount;
+        return;
+    }
+    const statsSubaddress = scan_stats.subaddresses[output.subaddress_index.toString()];
+    if (!statsSubaddress)
+        return;
+    if (typeof statsSubaddress.received_amount === "undefined")
+        statsSubaddress.received_amount = 0n;
+    statsSubaddress.received_amount += output.amount;
+}
+export function addSpendableAmount(scan_stats, output) {
+    scan_stats.total_spendable_amount += output.amount;
+    if (!output.subaddress_index) {
+        if (!scan_stats.primary_address_received_amount)
+            scan_stats.primary_address_received_amount = 0n;
+        scan_stats.primary_address_received_amount += output.amount;
+        return;
+    }
+    const statsSubaddress = scan_stats.subaddresses[output.subaddress_index.toString()];
+    if (!statsSubaddress)
+        return;
+    if (typeof statsSubaddress.received_amount === "undefined")
+        statsSubaddress.received_amount = 0n;
+    statsSubaddress.received_amount += output.amount;
+}
+export function addPendingAmount(scan_stats, output) {
+    scan_stats.total_pending_amount += output.amount;
+    if (!output.subaddress_index) {
+        if (!scan_stats.primary_address_pending_amount)
+            scan_stats.primary_address_pending_amount = 0n;
+        scan_stats.primary_address_pending_amount += output.amount;
+        return;
+    }
+    const statsSubaddress = scan_stats.subaddresses[output.subaddress_index.toString()];
+    if (!statsSubaddress)
+        return;
+    if (typeof statsSubaddress.pending_amount === "undefined")
+        statsSubaddress.pending_amount = 0n;
+    statsSubaddress.pending_amount += output.amount;
+}
+export function processFoundTransactions(cache, stats, current_height) {
+    stats.found_transactions = {};
+    stats.ordered_transactions = [];
+    Object.entries(cache.outputs).forEach(([_, output]) => {
+        const status = outputStatus(output, cache, current_height || 0);
+        const in_ordered_transactions = stats.ordered_transactions.includes(output.tx_hash);
+        if (!in_ordered_transactions)
+            stats.ordered_transactions.push(output.tx_hash);
+        const receivedTx = stats.found_transactions[output.tx_hash];
+        if (receivedTx) {
+            receivedTx.outputs.push(output);
+            receivedTx.amount += output.amount;
+            // we possibly first added the tx_hash when we found a spent output
+            // placehodler pending status that we added in "handle spent case"
+            // needs to be updated
+            receivedTx.status = status;
+        }
+        else {
+            stats.found_transactions[output.tx_hash] = {
+                status,
+                inputs: [],
+                amount: output.amount,
+                outputs: [output],
+                tx_hash: output.tx_hash,
+            };
+        }
+        // handle spent case
+        if (output.spent_in_tx_hash) {
+            const spent_utxo_value = cache.pending_spent_utxos
+                ? cache.pending_spent_utxos[output.index_on_blockchain]
+                : null;
+            const txlog = cache.tx_logs && spent_utxo_value
+                ? cache.tx_logs[spent_utxo_value]
+                : undefined;
+            const spentTx = stats.found_transactions[output.spent_in_tx_hash];
+            if (spentTx) {
+                spentTx.amount -= output.amount;
+                spentTx.inputs.push(output);
+            }
+            else {
+                stats.found_transactions[output.spent_in_tx_hash] = {
+                    status: { status: "pending", unlock_height: 0 },
+                    inputs: [output],
+                    amount: -output.amount,
+                    outputs: [],
+                    tx_hash: output.spent_in_tx_hash,
+                    txlog,
+                };
+            }
+        }
+        if (status.status === "spendable")
+            addSpendableAmount(stats, output);
+        else if (status.status === "pending")
+            addPendingAmount(stats, output);
+        else if (status.status === "spent")
+            addSpentAmount(stats, output);
+    });
+}
+export function removeChangeFromPrimaddressAmounts(stats) { }
+export function addSubAddressesFromCacheToScanStats(cache, stats) {
+    // add cache subaddresses to statsfile
+    for (const cacheSub of cache.subaddresses || []) {
+        //if (!stats.subaddresses[cacheSub.minor.toString()]) <-- uncommented to overwrite existing
+        stats.subaddresses[cacheSub.minor.toString()] = {
+            minor: cacheSub.minor,
+            address: cacheSub.address,
+            created_at_height: cacheSub.created_at_height,
+            created_at_timestamp: cacheSub.created_at_timestamp,
+            received_amount: 0n,
+            pending_amount: 0n,
+        };
+    }
+}
+export function addMissingSubAddressesToScanStats(stats, view_pair, highestSubaddressMinor = 1, created_at_height = 0) {
+    // add subaddresses to statsfile that are not in the cache
+    let minor = 1;
+    //const highestSubaddressMinor = walletSettings.subaddress_index || 1;
+    while (minor <= highestSubaddressMinor) {
+        if (stats.subaddresses[minor.toString()]) {
+            minor++;
+            continue;
+        }
+        const subaddress = view_pair.makeSubaddress(minor);
+        //const created_at_height =
+        //   lastRange(scanCacheOpen._cache.scanned_ranges)?.end || 0;
+        const created_at_timestamp = new Date().getTime();
+        const new_subaddress = {
+            minor,
+            address: subaddress,
+            created_at_height,
+            created_at_timestamp,
+            not_yet_included: true,
+            received_amount: 0n,
+            pending_amount: 0n,
+        };
+        stats.subaddresses[minor.toString()] = new_subaddress;
+        minor++;
+    }
+}
+export function isSelfSpent(address, cache) {
+    if (address === cache.primary_address)
+        return true;
+    for (const subaddress of cache.subaddresses || []) {
+        if (subaddress.address === address)
+            return true;
+    }
+    return false;
+}
+export function removeChangeFromPrimAddressReceivedAmounts(stats) {
+    if (!stats.primary_address_pending_amount)
+        stats.primary_address_pending_amount = 0n;
+    if (!stats.primary_address_received_amount)
+        stats.primary_address_received_amount = 0n;
+    for (const tx of stats.ordered_transactions) {
+        const transaction = stats.found_transactions[tx];
+        if (transaction.status.status === "pending" ||
+            transaction.status.status === "prepending")
+            stats.primary_address_pending_amount -= transaction.amount;
+        else if (transaction.status.status === "spendable" ||
+            transaction.status.status === "spent")
+            stats.primary_address_received_amount -= transaction.amount;
+    }
+}
+export function processTxlogPayments(txlog, cache) {
+    let outWardPaymentSum = 0n;
+    for (const payment of txlog.payments) {
+        if (!isSelfSpent(payment.address, cache)) {
+            outWardPaymentSum += BigInt(payment.amount);
+        }
+    }
+    return outWardPaymentSum;
+}
+export function processTxlogInputs(txlog, cache) {
+    let alreadyRecognizedAsSpend = false;
+    let inputSum = 0n;
+    for (const inputId of txlog.inputs_index) {
+        const input = cache.outputs[inputId];
+        if (typeof input.spent_in_tx_hash === "string") {
+            alreadyRecognizedAsSpend = true;
+            continue;
+        }
+        inputSum += input.amount;
+    }
+    return { inputSum, alreadyRecognizedAsSpend };
+}
+export function processTxlogs(cache, stats) {
+    for (const txlog of cache.tx_logs || []) {
+        if (!txlog ||
+            !txlog.sendResult ||
+            (txlog.sendResult && txlog.sendResult.status !== "OK"))
+            continue;
+        const { inputSum, alreadyRecognizedAsSpend } = processTxlogInputs(txlog, cache);
+        if (alreadyRecognizedAsSpend)
+            continue;
+        const outWardPaymentSum = processTxlogPayments(txlog, cache);
+        stats.total_spendable_amount -= inputSum;
+        const newPending = inputSum - outWardPaymentSum;
+        stats.total_pending_amount += newPending;
+    }
+}
+export async function alignScanStatsWithCache(cache, view_pair, primary_address, pathPrefix, highestSubaddressMinor = 1, current_scan_tip_height = 0) {
+    return await writeStatsFileDefaultLocation({
+        primary_address,
+        pathPrefix,
+        writeCallback: async (stats) => {
+            resetStats(stats);
+            // this condition misses reorgs
+            // it seems wasteful to re read the cache on every wallet open
+            // not doing it is premature optimization.
+            // This is not computationally expensive + memory bandwith is tens of gb per second
+            //if (!current_scan_tip_height || current_scan_tip_height > stats.height) {
+            addSubAddressesFromCacheToScanStats(cache, stats);
+            addMissingSubAddressesToScanStats(stats, view_pair, highestSubaddressMinor, current_scan_tip_height);
+            processFoundTransactions(cache, stats, current_scan_tip_height);
+            processTxlogs(cache, stats);
+            stats.height = current_scan_tip_height;
+            //}
+        },
+    });
+}
+export function resetStats(stats) {
+    stats.height = 0;
+    stats.total_spendable_amount = 0n;
+    stats.total_pending_amount = 0n;
+    stats.found_transactions = {};
+    stats.ordered_transactions = [];
+    stats.subaddresses = {};
+}

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

@@ -0,0 +1 @@
+export declare const workerMainCode = "";