@spirobel/monero-wallet-api 0.3.16 → 0.4.0

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

@@ -0,0 +1 @@
+export declare function coordinatorMainWorker(scan_settings_path?: string, pathPrefix?: string, cpuPorts?: MessagePort[]): Promise<void>;

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

@@ -0,0 +1,23 @@
+import { coordinatorMainMultithreaded } from "../scanresult/scanCoordination";
+export async function coordinatorMainWorker(scan_settings_path, pathPrefix, cpuPorts) {
+    console.log("[coordinatorMainWorker] cpuPorts=" + cpuPorts?.length);
+    try {
+        const gen = coordinatorMainMultithreaded(scan_settings_path, pathPrefix, cpuPorts);
+        for await (const event of gen) {
+            // console.log("event:", event);
+            if (event.type === "scan_ready") {
+                self.postMessage({
+                    type: "SCAN_RESULT",
+                    payload: {
+                        newCache: event.newCache,
+                        changed_outputs: event.changed_outputs,
+                    },
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error("[coordinatorMainWorker] error:", error);
+        self.postMessage({ type: "ERROR", payload: error });
+    }
+}

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

@@ -0,0 +1,5 @@
+import { type ScanLoopInput, type ScanLoopYield } from "../scanresult/scanLoop";
+export declare function handleCpuboundScan(msg: ScanLoopInput, port?: MessagePort): Promise<ScanLoopYield>;
+export declare function handleCpuboundScanTry(msg: ScanLoopInput, port?: MessagePort): Promise<ScanLoopYield>;
+export declare function sendFromCpuWorker(port: MessagePort, msg: ScanLoopYield): void;
+export declare function sendToCpuWorker(port: MessagePort, msg: ScanLoopInput): void;

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

@@ -0,0 +1,112 @@
+import { sleep, ViewPair } from "../../api";
+import {} from "../scanresult/scanLoop";
+/**
+ * handle a single scan work item dispatched from the coordinator.
+ * logs progress every 10 blocks, then sends the final result.
+ */
+let callcounter = 0;
+export async function handleCpuboundScan(msg, port) {
+    callcounter++;
+    console.log("[cpubound] callcounter=" + callcounter);
+    if (!msg) {
+        console.log("[cpubound] no content msg! ( ScanLoopInput = undefined )");
+        throw new Error("[cpubound] no content msg! ( ScanLoopInput = undefined )");
+    }
+    if (msg === "cancel") {
+        console.log("[cpubound] cancel msg! ( ScanLoopInput = cancel )");
+        throw new Error("[cpubound] no content msg! ( ScanLoopInput = undefined )");
+    }
+    console.log("[cpubound] got scan msg, walletConfig=" +
+        msg.walletConfig?.primary_address?.slice(0, 6));
+    const walletConfig = msg.walletConfig;
+    const item = msg;
+    if (!port) {
+        console.log("[cpubound] no port!");
+        throw new Error("[cpubound] no port");
+    }
+    console.log("[cpubound] primed, feeding workItem uuid=" +
+        (item && typeof item === "object"
+            ? item.work_uuid?.slice(0, 8)
+            : "cancel"));
+    // feed work item, get first InProgress yield
+    let blockCount = 0;
+    const heighfrom = item.batch.get_blocks_result_meta.block_infos[item.from].block_height;
+    const heightto = item.batch.get_blocks_result_meta.block_infos[item.to].block_height;
+    const viewpair = await ViewPair.create(item.walletConfig.primary_address, item.walletConfig.secret_view_key, item.walletConfig.subaddress_index);
+    await viewpair.loadGetBlocksBinResponse(item.batch.data);
+    const first_block_meta = item.batch.get_blocks_result_meta.block_infos[0];
+    if (!first_block_meta)
+        throw new Error("no first block meta");
+    const scanResult = {
+        outputs: [],
+        all_key_images: [],
+        new_height: first_block_meta.block_height + item.from,
+        primary_address: walletConfig.primary_address,
+        block_infos: item.batch.get_blocks_result_meta.block_infos,
+        daemon_height: item.batch.get_blocks_result_meta.daemon_height,
+    };
+    if (!(item.to >= item.from))
+        throw new Error("to must be >= from");
+    for (let i = item.from; i <= item.to; i++) {
+        // 2.call getBlocksBinScanOneBlock
+        const blockResult = await viewpair.getBlocksBinScanOneBlock(i);
+        if ("error" in blockResult)
+            throw new Error(blockResult.error);
+        //3. accumulate the scanresult
+        scanResult.outputs.push(...blockResult.outputs);
+        scanResult.all_key_images.push(...blockResult.all_key_images);
+        scanResult.new_height = first_block_meta.block_height + i;
+        //       //  update item.scanCache in memory will be done by the consumer
+        // it is saved on the workitem, but the workitemBuffer is managed by the consumer
+        // the consumer will reconcile the workitemBuffer on blocksbuffer changed yields from the fetchloop
+        // it will also reconcile the blocksbuffer with the workitembuffer when work was done,
+        // processScanResult will be called by the consumer and the scanresult will
+        // be persisted to disk by the consumer.
+        // if the workitem is at the left end of the workitemBuffer it will be shifted (popped from the left)
+        // if it is removed like this from the workItemBuffer and eventually no items in the workItemBuffer
+        // refercence the getBlocksBinBufferItem in the blocksbuffer, the blocksbufferitem is removed from the blocksbuffer
+        // this is how the reconiliaton workitembuffer -> blocksbuffer happens.
+        //
+        // the reconciliation in blocksbuffer -> workitembuffer starts in the fetchloop before it sends a yield blocksbuffer changed
+        // it is finished by the consumer of this generator after the yield blocksbuffer changed
+        // this happens through checking all workitemBuffer items,
+        //  if their GetBlocksBinBufferItem is in the blocksbuffer (via the local_uuid)
+        // if they are not in the blocksbuffer they are removed from the workitemBuffer
+        // then for all the blocksbuffer items that are not yet referenced by workbuffer items
+        // they need to be silced into workitems and added to the workitembuffer
+        //the reconciliation blocksbuffer -> workitembuffer is done on every blocks buffer changed event from the fetchloop
+        // the reconciliation workitembuffer -> blocksbuffer is done on every workitembuffer marked done at the end of the workbuffer (left end)
+        blockCount++;
+        if (blockCount % 10 === 0) {
+            console.log("[cpubound] scanned " +
+                blockCount +
+                " " +
+                walletConfig.primary_address.slice(0, 6), "@", heighfrom, "-", heightto);
+        }
+        await sleep(10); // make sure the loop is not tight
+    }
+    console.log("[cpubound] scan done " +
+        blockCount +
+        " " +
+        walletConfig.primary_address.slice(0, 6), "@", heighfrom, "-", heightto);
+    return {
+        type: "Ready",
+        work_uuid: item.work_uuid,
+        result: scanResult,
+    };
+}
+export function handleCpuboundScanTry(msg, port) {
+    try {
+        return handleCpuboundScan(msg, port);
+    }
+    catch (err) {
+        console.error("[cpubound] error", err);
+        throw err;
+    }
+}
+export function sendFromCpuWorker(port, msg) {
+    port.postMessage(msg);
+}
+export function sendToCpuWorker(port, msg) {
+    port.postMessage(msg);
+}

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

@@ -1 +1 @@
-export {};
+export declare function CPU_PORT_HANDLER(pe: MessageEvent): void;

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

@@ -1,12 +1,64 @@
-import { sleep } from "../../io/sleep";
-import { scanWallets } from "../backgroundWorker";
-while (true) {
+import { coordinatorMainWorker } from "./coordinator-main";
+import { handleCpuboundScan, handleCpuboundScanTry, sendFromCpuWorker, } from "./cpubound-main";
+self.onerror = (e) => self.postMessage({ type: "ERROR", payload: e });
+self.addEventListener("unhandledrejection", (e) => self.postMessage({ type: "ERROR", payload: e.reason }));
+let SCAN_SETTINGS_PATH;
+let PATH_PREFIX;
+let cpuPort;
+export function CPU_PORT_HANDLER(pe) {
+    if (!cpuPort)
+        throw new Error("[cpubound] cpuPort is undefined in port.onmessage");
+    console.log("[cpubound] new workitem msg received");
+    cpuPort.postMessage({
+        type: "WORKSTART",
+        work_uuid: pe.data.work_uuid,
+    });
+    handleCpuboundScanTry(pe.data, cpuPort).then((result) => {
+        console.log("[cpubound] work finished, sending result");
+        if (!cpuPort)
+            throw new Error("[cpubound] cpuPort is undefined in port.onmessage");
+        cpuPort.onmessage = CPU_PORT_HANDLER;
+        sendFromCpuWorker(cpuPort, result);
+    });
+}
+const handleMessage = async (e) => {
+    const msg = e.data;
+    console.log("[worker] msg received", msg);
+    if (msg.type === "setup") {
+        SCAN_SETTINGS_PATH = msg.scan_settings_path;
+        PATH_PREFIX = msg.pathPrefix;
+        if (msg.role === "cpubound") {
+            cpuPort = e.ports[0];
+            if (cpuPort) {
+                cpuPort.onmessage = CPU_PORT_HANDLER;
+                cpuPort.addEventListener("message", (e) => {
+                    console.log("[cpubound] message received", e);
+                });
+                cpuPort.addEventListener("messageerror", (e) => {
+                    console.log("[cpubound] messageerror received", e);
+                });
+            }
+        }
+        else if (msg.role === "coordinator") {
+            const cpuPorts = [...e.ports];
+            coordinatorMainWorker(SCAN_SETTINGS_PATH, PATH_PREFIX, cpuPorts).catch((err) => {
+                self.postMessage({
+                    type: "ERROR",
+                    payload: err?.message ?? String(err),
+                });
+            });
+        }
+    }
+};
+function handleMessageTry(e) {
     try {
-        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);
+        handleMessage(e);
     }
     catch (error) {
+        console.error("[worker] error:", error);
         self.postMessage({ type: "ERROR", payload: error });
     }
 }
+self.onmessage = handleMessageTry;
+// signal main thread that onmessage handler is installed
+self.postMessage({ type: "WORKER_READY" });

package/dist/viewpair/ViewPair.d.ts

@@ -1,13 +1,12 @@
 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 GetBlocksBinMetaCallback, type GetBlocksBinRequest, type ErrorResponse } 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 NETWORKS } from "../node-interaction/nodeUrl";
 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.)
@@ -36,7 +35,7 @@ export declare class ViewPair extends WasmProcessor {
      * @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>;
+    getBlocksBin(params: GetBlocksBinRequest, metaCallBack?: GetBlocksBinMetaCallback, stopSync?: AbortSignal): Promise<ScanResult | ErrorResponse | undefined>;
     addGenesisHashToBlockIds(params: GetBlocksBinRequest): Promise<GetBlocksBinRequest>;
     /**
      * This function helps with making requests to the get_blocks.bin endpoint of the Monerod nodes.
@@ -59,11 +58,35 @@ export declare class ViewPair extends WasmProcessor {
      * @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>;
+    getBlocksBinScanResponse(getBlocksBinResponseBuffer: Uint8Array, metaCallBack?: GetBlocksBinMetaCallback): Promise<any>;
     /**
-     * scan
+     * Loads a getBlocks.bin response into the WASM module without scanning for outputs.
+     * The stored response can later be used to scan individual blocks. Subsequent calls
+     * overwrite the previously stored response.
+     * @param getBlocksBinResponseBuffer the raw binary response from the get_blocks.bin endpoint
+     * @returns metadata about the loaded blocks (new_height, daemon_height, status, block_infos)
      */
-    scan(cacheChanged?: CacheChangedCallback, stopSync?: AbortSignal, scan_settings_path?: string, pathPrefix?: string): Promise<void>;
+    loadGetBlocksBinResponse(getBlocksBinResponseBuffer: Uint8Array): Promise<import("../api").GetBlocksResultMeta>;
+    /**
+     * scan one block from a getblocks.bin response that was loaded into wasm memory.
+     * call loadGetBlocksBinResponse first to populate the response in the wasm module.
+     * call this in a loop over blockIndex 0..meta.block_infos.length-1 to scan all blocks.
+     * @param blockIndex index of the block within the loaded response (0-based)
+     * @returns scan result with outputs and all key images for that one block.
+     *          returns ErrorResponse (`{ error: string }`) if scanning fails.
+     *          check `if ("error" in result)` before accessing outputs/key_images.
+     *
+     * error cases from the rust wasm (search these strings in rust/src/):
+     * - "Block index {} out of bounds (total blocks: {})"
+     *   blockIndex >= number of blocks in the loaded response
+     * - "No getBlocks.bin response loaded. Call loadGetBlocksBinResponse first."
+     *   forgot to call loadGetBlocksBinResponse before this method
+     * - "Error scanning miner transaction: {}"
+     *   the miner tx of the block could not be scanned
+     * - "Error scanning block: {}"
+     *   the block could not be scanned
+     */
+    getBlocksBinScanOneBlock(blockIndex: number): Promise<ScanResult | ErrorResponse>;
     /**
      * 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.

package/dist/viewpair/ViewPair.js

@@ -1,13 +1,13 @@
-import { processScanResult, } from "../scanning-syncing/scanresult/scanResult";
+import {} from "../scanning-syncing/scanresult/scanResult";
 export {};
 export { NodeUrl } from "../node-interaction/nodeUrl";
-import { getBlocksBinScan, getBlocksBinExecuteRequest, getBlocksBinScanResponse, MAINNET_GENESIS_BLOCK_HASH, STAGENET_GENESIS_BLOCK_HASH, } from "../node-interaction/binaryEndpoints";
+import { getBlocksBinScan, getBlocksBinExecuteRequest, getBlocksBinScanOneBlock, loadGetBlocksBinResponse, MAINNET_GENESIS_BLOCK_HASH, STAGENET_GENESIS_BLOCK_HASH, } from "../node-interaction/binaryEndpoints";
 import { handleScanError, lastRange, writeCacheFileDefaultLocationThrows, } from "../scanning-syncing/scanresult/scanCache";
 import { makeTransaction, } from "../send-functionality/transactionBuilding";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
-import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
+import { LOCAL_NODE_DEFAULT_URL, } from "../node-interaction/nodeUrl";
 import { atomicWrite, get_block_headers_range, get_info, } from "../api";
-import { readGetblocksBinBuffer, trimGetBlocksBinBuffer, writeGetblocksBinBuffer, } from "../scanning-syncing/scanresult/getBlocksbinBuffer";
+import { readGetblocksBinBuffer, trimGetBlocksBinBuffer, writeGetblocksBinBuffer, } from "../scanning-syncing/blocksbuffer/getBlocksbinBuffer";
 import { initScanCache, readCacheFileDefaultLocation, } from "../scanning-syncing/scanresult/scanCache";
 import { cullTooLargeScanHeight, openNonHaltedWallets, readWalletFromScanSettings, walletSettingsPlusKeys, } from "../scanning-syncing/scanSettings";
 import { sleep } from "../io/sleep";
@@ -120,123 +120,61 @@ export class ViewPair extends WasmProcessor {
      * @param metaCallBack contains meta information about the getBlocksbin call (new sync height = start_height param + number of blocks)
      * @returns It returns {@link ScanResult} (outputs that belong to viewpair)
      */
-    getBlocksBinScanResponse(getBlocksBinResponseBuffer, metaCallBack) {
-        return getBlocksBinScanResponse(this, getBlocksBinResponseBuffer, metaCallBack);
+    async getBlocksBinScanResponse(getBlocksBinResponseBuffer, metaCallBack) {
+        const meta = await this.loadGetBlocksBinResponse(getBlocksBinResponseBuffer);
+        if ("error" in meta)
+            return meta;
+        if (metaCallBack)
+            metaCallBack(meta);
+        const result = {
+            outputs: [],
+            all_key_images: [],
+            new_height: meta.new_height,
+            primary_address: this.primary_address,
+            block_infos: meta.block_infos,
+            daemon_height: meta.daemon_height,
+        };
+        for (let i = 0; i < meta.block_infos.length; i++) {
+            const blockResult = await getBlocksBinScanOneBlock(this, i);
+            if ("error" in blockResult)
+                return blockResult;
+            result.outputs.push(...blockResult.outputs);
+            result.all_key_images.push(...blockResult.all_key_images);
+            await sleep(10);
+        }
+        return result;
     }
     /**
-     * scan
+     * Loads a getBlocks.bin response into the WASM module without scanning for outputs.
+     * The stored response can later be used to scan individual blocks. Subsequent calls
+     * overwrite the previously stored response.
+     * @param getBlocksBinResponseBuffer the raw binary response from the get_blocks.bin endpoint
+     * @returns metadata about the loaded blocks (new_height, daemon_height, status, block_infos)
      */
-    async scan(cacheChanged = (params) => console.log(params), stopSync, scan_settings_path, pathPrefix) {
-        try {
-            const processor = this;
-            const nonHaltedWallets = await openNonHaltedWallets(scan_settings_path);
-            const masterWalletSettings = nonHaltedWallets[0];
-            if (masterWalletSettings.primary_address !== this.primary_address)
-                throw new Error("master wallet should be the first of the non halted wallets");
-            let masterStartHeight = await cullTooLargeScanHeight(processor.node_url, scan_settings_path);
-            let current_range = await initScanCache(processor, masterStartHeight, scan_settings_path, pathPrefix);
-            const blockGenerator = (async function* () {
-                while (true) {
-                    if (stopSync?.aborted)
-                        return;
-                    const firstResponse = await processor.getBlocksBinExecuteRequest({ block_ids: current_range.block_hashes.map((b) => b.block_hash) }, stopSync);
-                    await readWriteConnectionStatusFile((cs) => {
-                        if (cs?.last_packet.status === "catastrophic_reorg")
-                            return;
-                        const connectionStatus = {
-                            last_packet: {
-                                status: "OK",
-                                bytes_read: firstResponse.length,
-                                node_url: processor.node_url,
-                                timestamp: new Date().toISOString(),
-                            },
-                        };
-                        return connectionStatus;
-                    });
-                    yield firstResponse;
-                }
-            })();
-            const masterWithKeys = await walletSettingsPlusKeys(masterWalletSettings);
-            const slaveViewPairs = [];
-            if (nonHaltedWallets.length > 1) {
-                for (const slaveWallet of nonHaltedWallets.slice(1)) {
-                    const slaveWithKeys = await walletSettingsPlusKeys(slaveWallet);
-                    const viewpair = await ViewPair.create(slaveWallet.primary_address, slaveWithKeys.secret_view_key, slaveWallet.subaddress_index, masterWalletSettings.node_url);
-                    slaveViewPairs.push({
-                        viewpair,
-                        current_range: await initScanCache(viewpair, masterStartHeight, scan_settings_path, pathPrefix),
-                        secret_spend_key: slaveWithKeys.secret_spend_key,
-                    });
-                }
-            }
-            const catastrophic_reorg_cb = async () => {
-                writeConnectionStatusFile("catastrophic_reorg", processor.node_url, undefined, scan_settings_path);
-            };
-            for await (const firstResponse of blockGenerator) {
-                if (!firstResponse)
-                    continue;
-                await this.writeSubaddressesToScanCache(scan_settings_path, pathPrefix);
-                const result = await processor.getBlocksBinScanResponse(firstResponse);
-                const oldMasterCurrentRange = structuredClone(current_range);
-                current_range = await processScanResult({
-                    current_range,
-                    result,
-                    cacheChanged,
-                    secret_spend_key: masterWithKeys.secret_spend_key,
-                    pathPrefix,
-                    catastrophic_reorg_cb,
-                });
-                if (slaveViewPairs.length > 0) {
-                    if (result && "block_infos" in result)
-                        await writeGetblocksBinBuffer(firstResponse, result.block_infos, pathPrefix); // feed the slaves
-                    for (const slave of slaveViewPairs) {
-                        let blocksBinItems = await readGetblocksBinBuffer(slave.current_range.end, pathPrefix);
-                        let use_master_current_range = false;
-                        if (!blocksBinItems.length) {
-                            blocksBinItems = await readGetblocksBinBuffer(current_range.end, // we use the new current range end to find the blocks
-                            pathPrefix);
-                            slave.current_range = structuredClone(oldMasterCurrentRange); // but we use the old master current range to scan with slaves
-                            use_master_current_range = true;
-                        }
-                        for (const blocksBinItem of blocksBinItems) {
-                            const blocksbin = new Uint8Array(await Bun.file(`${pathPrefix ?? ""}getblocksbinbuffer/${blocksBinItem.filename}`).arrayBuffer());
-                            await slave.viewpair.writeSubaddressesToScanCache(scan_settings_path, pathPrefix);
-                            const slaveResult = await slave.viewpair.getBlocksBinScanResponse(blocksbin);
-                            slave.current_range = await processScanResult({
-                                current_range: slave.current_range,
-                                result: slaveResult,
-                                cacheChanged,
-                                secret_spend_key: slave.secret_spend_key,
-                                pathPrefix,
-                                use_master_current_range,
-                                catastrophic_reorg_cb,
-                            });
-                        }
-                    } // scan the slaves
-                    await trimGetBlocksBinBuffer(nonHaltedWallets, pathPrefix);
-                }
-                if (!result ||
-                    (result && "block_infos" in result && result.block_infos.length === 0)) {
-                    // we are at the tip, and there are no new blocks
-                    // sleep for 1 second before sending another
-                    // getBlocks.bin request
-                    //
-                    await sleep(1000);
-                }
-            }
-        }
-        catch (error) {
-            handleScanError(error);
-            const processor = this;
-            const cache = await readCacheFileDefaultLocation(processor.primary_address, pathPrefix);
-            if (!cache)
-                throw new Error(`${error} in scan() + cache not found for primary address: ${processor.primary_address} and path prefix: ${pathPrefix}`);
-            await cacheChanged({
-                newCache: cache,
-                changed_outputs: [],
-            });
-            throw error;
-        }
+    loadGetBlocksBinResponse(getBlocksBinResponseBuffer) {
+        return loadGetBlocksBinResponse(this, getBlocksBinResponseBuffer);
+    }
+    /**
+     * scan one block from a getblocks.bin response that was loaded into wasm memory.
+     * call loadGetBlocksBinResponse first to populate the response in the wasm module.
+     * call this in a loop over blockIndex 0..meta.block_infos.length-1 to scan all blocks.
+     * @param blockIndex index of the block within the loaded response (0-based)
+     * @returns scan result with outputs and all key images for that one block.
+     *          returns ErrorResponse (`{ error: string }`) if scanning fails.
+     *          check `if ("error" in result)` before accessing outputs/key_images.
+     *
+     * error cases from the rust wasm (search these strings in rust/src/):
+     * - "Block index {} out of bounds (total blocks: {})"
+     *   blockIndex >= number of blocks in the loaded response
+     * - "No getBlocks.bin response loaded. Call loadGetBlocksBinResponse first."
+     *   forgot to call loadGetBlocksBinResponse before this method
+     * - "Error scanning miner transaction: {}"
+     *   the miner tx of the block could not be scanned
+     * - "Error scanning block: {}"
+     *   the block could not be scanned
+     */
+    getBlocksBinScanOneBlock(blockIndex) {
+        return getBlocksBinScanOneBlock(this, blockIndex);
     }
     /**
      * This method makes an integrated Address for the Address of the Viewpair it was opened with.