@spirobel/monero-wallet-api 0.6.1 → 0.6.4

package/README.md

@@ -64,12 +64,48 @@ makes it possible to easily run the [escrow test](tests/acceptance/escrow.test.t
 
 See the [acceptance test](tests/acceptance/dont_rescan.test.ts) for a full working sync example with mainnet data.
 
-## install
+## unpacked build entrypoint
 
-To install the package:
+In most cases you should use the default install / npm build entrypoint. It takes care of distributing the worker + wasm files as part of the package. When using the unpacked entrypoint via adding `/unpacked` to the end of the package import, you need to configure your build system to copy / distribute the wasm and worker urls and notify the package of those urls in your setup code via `configureUnpacked()`. 
+``` ts
+import { configureUnpacked, openWallets } from "@spirobel/monero-wallet-api/unpacked";
 
-```bash
-bun add @spirobel/monero-wallet-api
+```
+
+### build result in dist dir
+
+`bun run build` makes these files in `dist` (in addition to the packaged build `xmr3.js` and type definitions):
+
+* `xmr3_unpacked.js` (entry without worker + wasm dataurls)
+* `worker_unpacked.js` (worker source file that has to be distributed manually)
+* `monero_wallet_api.wasm` (wasm file that has to be distributed manually)
+* `frost_dkg.wasm` (wasm file that has to be distributed manually)
+
+### checklist for library consumer of unpacked entrypoint
+
+1. Install the lib.
+2. Copy the wasm files and the worker file to your dist folder.
+3. Import from `/unpacked`.
+4. Call `configureUnpacked` before `openWallets`.
+
+Copy step in `package.json`:
+
+```json
+"copyunpacked": "cp node_modules/@spirobel/monero-wallet-api/dist/*.wasm dist/chrome/ && cp node_modules/@spirobel/monero-wallet-api/dist/worker_unpacked.js dist/chrome/"
+```
+
+Code example:
+
+```ts
+import { configureUnpacked, openWallets } from "@spirobel/monero-wallet-api/unpacked";
+
+configureUnpacked({
+  workerUrl: "worker_unpacked.js",
+  moneroWasmUrl: "monero_wallet_api.wasm",
+  dkgWasmUrl: "frost_dkg.wasm",
+});
+
+const wallets = await openWallets();
 ```
 
 ## build

package/dist/actionlog/actionLogOpened.js

@@ -245,8 +245,13 @@ export class ActionLogOpened {
             }
             case "worker.changeNodeUrlAndStartHeight": {
                 const p = env.payload;
-                await this.mco?.changeNodeUrlAndStartHeight(p?.node_url, p?.start_height);
-                return {};
+                try {
+                    await this.mco?.changeNodeUrlAndStartHeight(p?.node_url, p?.start_height);
+                    return {};
+                }
+                catch (err) {
+                    return { error: err instanceof Error ? err.message : String(err) };
+                }
             }
             case "worker.buildWallets":
                 await this.mco?.buildWallets();

package/dist/io/logging.js

@@ -1,4 +1,4 @@
-import { getPathPrefix, openScanSettingsFile } from "../xmr3";
+import { getPathPrefix, openScanSettingsFile } from "../xmr3_common";
 import { atomicWrite } from "./atomicWrite";
 /**
  * logging function names registry.

package/dist/keypairs-seeds/keypairs.js

@@ -60,7 +60,7 @@
 // simple wallet turns spend private key (recovery_val) into mnemonic words with this call:
 // 4849   crypto::ElectrumWords::bytes_to_words(recovery_val, electrum_words, mnemonic_language);
 // https://github.com/monero-project/monero/blob/48ad374b0d6d6e045128729534dc2508e6999afe/src/simplewallet/simplewallet.cpp#L4849
-import { monero_wallet_api_wasm } from "../wasm-processing/wasmFile";
+import { getMoneroWasmBytes } from "../wasm-processing/wasmLoader";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 /**
  *  use this function to generate a keypair for testing
@@ -77,7 +77,7 @@ export async function makeTestKeyPair() {
  * @returns SpendKey
  */
 export async function makeSpendKey() {
-    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
+    const wasmProcessor = await WasmProcessor.init(await getMoneroWasmBytes());
     let result = undefined;
     wasmProcessor.readFromWasmMemory = (ptr, len) => {
         result = String(wasmProcessor.readString(ptr, len));
@@ -94,7 +94,7 @@ export async function makeSpendKeyFromSeed(wallet_secret) {
         throw new Error(`Invalid wallet secret length: ${wallet_secret.length}.
        Expected 128 hex characters (64 bytes).`);
     }
-    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
+    const wasmProcessor = await WasmProcessor.init(await getMoneroWasmBytes());
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, wallet_secret);
     };
@@ -121,7 +121,7 @@ export async function makeViewKey(spend_private_key) {
         throw new Error(`Invalid spendkey length: ${spend_private_key.length}.
        Expected 64 hex characters (32 bytes).`);
     }
-    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
+    const wasmProcessor = await WasmProcessor.init(await getMoneroWasmBytes());
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, spend_private_key);
     };
@@ -148,7 +148,7 @@ export async function vk_from_entropy(entropy) {
         throw new Error(`Invalid entropy length: ${entropy.length}.
        Expected 32 bytes array.`);
     }
-    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
+    const wasmProcessor = await WasmProcessor.init(await getMoneroWasmBytes());
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeArray(ptr, len, entropy);
     };

package/dist/multisig/DistributedKeyGenerator.js

@@ -1,4 +1,4 @@
-import { frost_dkg_wasm } from "../wasm-processing/wasmFile";
+import { getDkgWasmBytes } from "../wasm-processing/wasmLoader";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 /**
  * get the DKG public key from a 64-byte DKG secret key
@@ -38,7 +38,7 @@ export class DistributedKeyGenerator extends WasmProcessor {
      */
     static async create() {
         const dkg = new DistributedKeyGenerator();
-        await dkg.initWasmModule(frost_dkg_wasm);
+        await dkg.initWasmModule(await getDkgWasmBytes());
         return dkg;
     }
     /**
@@ -49,7 +49,7 @@ export class DistributedKeyGenerator extends WasmProcessor {
      */
     static async createAndSetupGenerators(t, n) {
         const dkg = new DistributedKeyGenerator();
-        await dkg.initWasmModule(frost_dkg_wasm);
+        await dkg.initWasmModule(await getDkgWasmBytes());
         dkg.setupGenerators(t, n);
         return dkg;
     }

package/dist/multisig/MultiSigTxSigner.js

@@ -1,9 +1,9 @@
-import { frost_dkg_wasm } from "../wasm-processing/wasmFile";
+import { getDkgWasmBytes } from "../wasm-processing/wasmLoader";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 export class MultiSigTxSigner extends WasmProcessor {
     static async create() {
         const signer = new MultiSigTxSigner();
-        await signer.initWasmModule(frost_dkg_wasm);
+        await signer.initWasmModule(await getDkgWasmBytes());
         return signer;
     }
     /**

package/dist/multisig/escrow.js

@@ -1,6 +1,6 @@
 import { ed25519, x25519 } from "@noble/curves/ed25519.js";
 import { blake3 } from "@noble/hashes/blake3.js";
-import { vk_from_entropy } from "../xmr3";
+import { vk_from_entropy } from "../xmr3_common";
 export function makeEscrowContext(context_index) {
     if (Number.isNaN(parseInt(String(context_index)))) {
         return { ok: false, error: `invalid context_index: "${context_index}"` };

package/dist/multisig/multisig.js

@@ -1,5 +1,6 @@
 import { log } from "../io/logging";
 import { startWebworkerReady } from "../scanning-syncing/backgroundWorker";
+import { getWasmUrls } from "../wasm-processing/wasmLoader";
 export class MultiSig {
     worker = undefined;
     /**
@@ -37,11 +38,14 @@ export class MultiSig {
                         handleUnknownMessage(msg, "startWorker");
                     }
                 };
+                const wasmUrls = getWasmUrls();
                 that.worker.postMessage({
                     type: "setup",
                     t,
                     n,
                     role: "multisig",
+                    moneroWasmUrl: wasmUrls.monero,
+                    dkgWasmUrl: wasmUrls.dkg,
                 });
             });
             return await result_promise;

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

@@ -99,8 +99,8 @@ export declare const STAGENET_GENESIS_BLOCK_HASH = "76ee3cc98646292206cd3e86f74d
  */
 export declare function getBlocksBinMakeRequest<T extends WasmProcessor>(processor: T, params: GetBlocksBinRequest): Uint8Array<ArrayBufferLike>;
 export declare function getBlocksBinExecuteRequest<T extends WasmProcessor & HasNodeUrl>(processor: T, params: GetBlocksBinRequest, stopSync?: AbortSignal): Promise<Uint8Array<ArrayBufferLike>>;
-export declare function getBlocksBinScanResponse<T extends WasmProcessor>(processor: T, getBlocksBinResponseBuffer: Uint8Array, metaCallBack?: GetBlocksBinMetaCallback): Promise<ScanResult | ErrorResponse | undefined>;
-export declare function getBlocksBinScan<T extends WasmProcessor & HasNodeUrl>(processor: T, params: GetBlocksBinRequest, metaCallBack?: GetBlocksBinMetaCallback, stopSync?: AbortSignal): Promise<ScanResult | ErrorResponse | undefined>;
+export declare function getBlocksBinScanResponse<T extends WasmProcessor>(processor: T, getBlocksBinResponseBuffer: Uint8Array, metaCallBack?: GetBlocksBinMetaCallback): Promise<ErrorResponse | ScanResult | undefined>;
+export declare function getBlocksBinScan<T extends WasmProcessor & HasNodeUrl>(processor: T, params: GetBlocksBinRequest, metaCallBack?: GetBlocksBinMetaCallback, stopSync?: AbortSignal): Promise<ErrorResponse | ScanResult | undefined>;
 /**
  * throws error on failure to create request
  * @param processor wasmprocessor
@@ -141,6 +141,6 @@ export declare function loadGetBlocksBinResponse<T extends WasmProcessor>(proces
  *   in block_parsing/mod.rs scan_block, scanner.scan(scan_block) failed
  * all errors are returned as { error: string } (ErrorResponse type)
  */
-export declare function getBlocksBinScanOneBlock<T extends WasmProcessor>(processor: T, blockIndex: number): Promise<ScanResult | ErrorResponse>;
+export declare function getBlocksBinScanOneBlock<T extends WasmProcessor>(processor: T, blockIndex: number): Promise<ErrorResponse | ScanResult>;
 export declare function binaryFetchRequest(url: string, body: Uint8Array, stopSync?: AbortSignal): Promise<Uint8Array>;
 export {};

package/dist/node-interaction/nodeUrl.js

@@ -2,7 +2,7 @@ import { getBlocksBinExecuteRequest, loadGetBlocksBinResponse, getOutsBinJson, g
 import { get_block_headers_range, get_fee_estimate, get_info, get_output_distribution, send_raw_transaction, } from "./jsonEndpoints";
 import { makeInput, sampleDecoys, } from "../send-functionality/transactionBuilding";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
-import { monero_wallet_api_wasm } from "../wasm-processing/wasmFile";
+import { getMoneroWasmBytes } from "../wasm-processing/wasmLoader";
 /**
  * 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.)
@@ -28,7 +28,7 @@ export class NodeUrl extends WasmProcessor {
     }
     static async create(node_url) {
         const nodeUrl = new NodeUrl(node_url || LOCAL_NODE_DEFAULT_URL);
-        await nodeUrl.initWasmModule(monero_wallet_api_wasm);
+        await nodeUrl.initWasmModule(await getMoneroWasmBytes());
         return nodeUrl;
     }
     /**

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

@@ -1,5 +1,8 @@
 import { type CacheChangedCallbackParameters } from "./scanresult/scanCache";
 export declare const CPU_POOL_SIZE = 4;
+export declare function setInlineWorkerCode(code: string): void;
+export declare function setWorkerUrl(url: string | undefined): void;
+export declare function getWorkerUrl(): string | undefined;
 export type WorkerSet = {
     fetchWorker: Worker;
     cpuWorkers: Worker[];

package/dist/scanning-syncing/backgroundWorker.js

@@ -1,9 +1,29 @@
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
 import {} from "./scanresult/scanCache";
-import { openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, sleep, } from "../xmr3";
+import { openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, sleep, } from "../xmr3_common";
 import { log, setupLoggingPath } from "../io/logging";
-import { workerMainCode } from "./worker-entrypoints/worker";
+import { getWasmUrls } from "../wasm-processing/wasmLoader";
 export const CPU_POOL_SIZE = 4;
+// inline worker code for packed mode, set by xmr3 entry
+let inlineWorkerCode = "";
+let blobUrl;
+// custom worker url for unpacked mode, set by consumer
+let customWorkerUrl;
+export function setInlineWorkerCode(code) {
+    inlineWorkerCode = code;
+    if (code) {
+        const blob = new Blob([code], {
+            type: "text/javascript",
+        });
+        blobUrl = URL.createObjectURL(blob);
+    }
+}
+export function setWorkerUrl(url) {
+    customWorkerUrl = url;
+}
+export function getWorkerUrl() {
+    return customWorkerUrl;
+}
 export async function createWebworker(handle_result, scan_settings_path, pathPrefix, handle_error) {
     try {
         const resolvedPath = scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT;
@@ -14,6 +34,7 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
         const cpu_worker_count = typeof scanSettings?.cpu_worker_count !== "undefined"
             ? scanSettings?.cpu_worker_count || 1
             : CPU_POOL_SIZE;
+        const wasmUrls = getWasmUrls();
         // spawn CPU workers
         const cpuWorkers = [];
         const cpuPorts = [];
@@ -26,6 +47,8 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
                 cpu_worker_id: i,
                 scan_settings_path: resolvedPath,
                 pathPrefix,
+                moneroWasmUrl: wasmUrls.monero,
+                dkgWasmUrl: wasmUrls.dkg,
             }, [channel.port1]);
             cpuWorker.onerror = (e) => {
                 if (handle_error)
@@ -41,6 +64,8 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
             scan_settings_path: resolvedPath,
             pathPrefix,
             role: "coordinator",
+            moneroWasmUrl: wasmUrls.monero,
+            dkgWasmUrl: wasmUrls.dkg,
         }, cpuPorts); // transfer CPU ports to coordination worker
         log("createWebworker", [
             "coordinator worker started, node_url=" + node_url,
@@ -161,18 +186,23 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
     }
 }
 export function makeWebworkerScript() {
-    return workerMainCode;
+    return inlineWorkerCode;
 }
-const blob = new Blob([workerMainCode], {
-    type: "text/javascript",
-});
-const url = URL.createObjectURL(blob);
 // creates a worker via startWebworker, then waits for it to signal
 // WORKER_READY (meaning self.onmessage = handleMessage has executed).
 // after that, postMessage is safe, no race between worker startup
 // and message delivery.
 export function startWebworkerReady() {
-    const worker = new Worker(url, { type: "module" });
+    let worker;
+    if (customWorkerUrl) {
+        worker = new Worker(customWorkerUrl, { type: "module" });
+    }
+    else if (blobUrl) {
+        worker = new Worker(blobUrl, { type: "module" });
+    }
+    else {
+        throw new Error("no worker url and no inline worker code, call setWorkerUrl or use packed entry");
+    }
     return new Promise((resolve) => {
         const onReady = (e) => {
             if (e.data?.type === "WORKER_READY") {

package/dist/scanning-syncing/blocksbuffer/blocksBufferFetchLoop.d.ts

@@ -1,4 +1,4 @@
-import { NodeUrl, type BlockInfo, type CacheRange, type GetBlocksResultMeta } from "../../xmr3";
+import { NodeUrl, type BlockInfo, type CacheRange, type GetBlocksResultMeta } from "../../xmr3_common";
 import { type ConnectionSatusLastPacket, type ConnectionStatus, type ConnectionStatusSync } from "../connectionStatus";
 export type GetBlocksBinBufferItem = {
     local_uuid: string;

package/dist/scanning-syncing/blocksbuffer/blocksBufferFetchLoop.js

@@ -1,4 +1,4 @@
-import { findRange, get_block_headers_range, get_info, mergeRanges, NodeUrl, sleep, } from "../../xmr3";
+import { findRange, get_block_headers_range, get_info, mergeRanges, NodeUrl, sleep, } from "../../xmr3_common";
 import {} from "../connectionStatus";
 import { log } from "../../io/logging";
 export const MAX_BLOCKS_BUFFER_SIZE = 10;

package/dist/scanning-syncing/blocksbuffer/blocksbufferCoordination.d.ts

@@ -1,4 +1,4 @@
-import { type GetBlocksBinBufferItem, type ConnectionStatus, type BlocksBufferLoopResult, type CacheRange } from "../../xmr3";
+import { type GetBlocksBinBufferItem, type ConnectionStatus, type BlocksBufferLoopResult, type CacheRange } from "../../xmr3_common";
 export type SetupBlocksBufferGeneratorParams = {
     nodeUrl: string;
     startHeight: number;

package/dist/scanning-syncing/blocksbuffer/blocksbufferCoordination.js

@@ -1,4 +1,4 @@
-import { blocksBufferFetchLoop, readWriteConnectionStatusFile, applyLastPacket, CatastrophicReorgError, readOrInitConnectionStatus, } from "../../xmr3";
+import { blocksBufferFetchLoop, readWriteConnectionStatusFile, applyLastPacket, CatastrophicReorgError, readOrInitConnectionStatus, } from "../../xmr3_common";
 import { log } from "../../io/logging";
 export async function setupBlocksBufferGenerator(params) {
     const blocksBuffer = [];

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

@@ -1,4 +1,4 @@
-import { type CacheRange, type ReorgInfo } from "../xmr3";
+import { type CacheRange, type ReorgInfo } from "../xmr3_common";
 export type ConnectionStatusOptions = "OK" | "partial_read" | "connection_failed" | "blocks_buffer_full" | "no_connection_yet" | "catastrophic_reorg";
 export type ConnectionSatusLastPacket = {
     status: ConnectionStatusOptions;

package/dist/scanning-syncing/connectionStatus.js

@@ -1,5 +1,5 @@
-import { atomicWrite, } from "../xmr3";
-import { SCAN_SETTINGS_STORE_NAME_DEFAULT } from "../xmr3";
+import { atomicWrite, } from "../xmr3_common";
+import { SCAN_SETTINGS_STORE_NAME_DEFAULT } from "../xmr3_common";
 // wallet progress write: always set scan fields; only replace eta when a new one is provided
 // so a missing eta does not wipe / flicker the previous value.
 export function applyWalletScanProgress(cs, progress) {

package/dist/scanning-syncing/openWallet.js

@@ -1,5 +1,5 @@
 import { ManyScanCachesOpened, ScanCacheOpened, } from "./scanresult/scanCacheOpened";
-import { openScanSettingsFile, writeWalletToScanSettings } from "../xmr3";
+import { openScanSettingsFile, writeWalletToScanSettings } from "../xmr3_common";
 /**
  * Opens all **non halted wallets listed in ScanSettings.json** for scanning.
  *

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

@@ -1,4 +1,4 @@
-import type { Output } from "../../xmr3";
+import type { Output } from "../../xmr3_common";
 import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
 export type KeyImage = string;
 export declare function computeKeyImage(output: Output, sender_spend_key: string, wasmProcessor?: WasmProcessor): Promise<KeyImage | undefined>;

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

@@ -1,8 +1,8 @@
-import { monero_wallet_api_wasm } from "../../wasm-processing/wasmFile";
+import { getMoneroWasmBytes } from "../../wasm-processing/wasmLoader";
 import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
 export async function computeKeyImage(output, sender_spend_key, wasmProcessor) {
     if (!wasmProcessor)
-        wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
+        wasmProcessor = await WasmProcessor.init(await getMoneroWasmBytes());
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, output.serialized);
         wasmProcessor.writeToWasmMemory = (ptr, len) => {

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

@@ -1,5 +1,5 @@
 import { type KeyImage } from "./computeKeyImage";
-import { type BlockInfo, type FeeEstimateResponse, type GetBlockHeadersRange, type GetBlockHeadersRangeParams, type Output, type SendRawTransactionResult, type ViewPair } from "../../xmr3";
+import { type BlockInfo, type FeeEstimateResponse, type GetBlockHeadersRange, type GetBlockHeadersRangeParams, type Output, type SendRawTransactionResult, type ViewPair } from "../../xmr3_common";
 import type { Payment } from "../../send-functionality/inputSelection";
 export declare function initScanCache(viewpair: ViewPair, start_height: number, scan_settings_path?: string, pathPrefix?: string): Promise<CacheRange>;
 export declare function getBlockInfoForHeight(height: number, node_url: string): Promise<BlockInfo>;

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

@@ -1,5 +1,5 @@
 import {} from "./computeKeyImage";
-import { get_block_headers_range, } from "../../xmr3";
+import { get_block_headers_range, } from "../../xmr3_common";
 import { atomicWrite } from "../../io/atomicWrite";
 import { log } from "../../io/logging";
 export async function initScanCache(viewpair, start_height, scan_settings_path, pathPrefix) {

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

@@ -1,4 +1,4 @@
-import { ViewPair, type FeeEstimateResponse, type Output, type SendRawTransactionResult } from "../../xmr3";
+import { ViewPair, type FeeEstimateResponse, type Output, type SendRawTransactionResult } from "../../xmr3_common";
 import { type Payment } from "../../send-functionality/inputSelection";
 import { ConnectionStatusOpened } from "../connectionStatusOpened";
 import { ActionLogOpened, type ActionLogBackendKind, type ExtensionMessageBus } from "../../actionlog/actionLogOpened";

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

@@ -1,8 +1,8 @@
-import { get_info, NodeUrl, signTransaction, ViewPair, } from "../../xmr3";
+import { get_info, NodeUrl, signTransaction, ViewPair, } from "../../xmr3_common";
 import { prepareInput, sumPayments, } from "../../send-functionality/inputSelection";
 import { createWebworker } from "../backgroundWorker";
 import { spendable } from "./scanResult";
-import { getPathPrefix, readPrivateSpendKeyFromEnv, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, } from "../../xmr3";
+import { getPathPrefix, readPrivateSpendKeyFromEnv, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, } from "../../xmr3_common";
 import { ScanSettingsOpened } from "../../scansettings/scanSettingsOpened";
 import { ConnectionStatusOpened } from "../connectionStatusOpened";
 import { ActionLogOpened, } from "../../actionlog/actionLogOpened";
@@ -173,14 +173,19 @@ export class ScanCacheOpened {
         return this._scanSettings.logs_exclude;
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
-        await this.stopWorker();
-        if (node_url !== undefined) {
-            await this._scanSettings.setNodeUrl(node_url);
-            this.node_url = node_url;
+        // stop first so a live worker cannot write the old file over the new url.
+        try {
+            await this.stopWorker();
         }
-        if (start_height !== undefined) {
-            await this._scanSettings.setStartHeight(start_height);
-            this._start_height = start_height;
+        catch {
+            // stop can fail. still write the new url.
+        }
+        if (node_url !== undefined || start_height !== undefined) {
+            await this._scanSettings.setNodeUrlAndStartHeight(node_url, start_height);
+            if (node_url !== undefined)
+                this.node_url = node_url;
+            if (start_height !== undefined)
+                this._start_height = start_height;
         }
         await this.unpause();
     }
@@ -751,7 +756,11 @@ export class ScanCacheOpened {
             delete this.worker;
             // drain coordinator first, then hard kill workers
             try {
-                await worker.shutdown();
+                // shutdown already races 5s. this race still returns if that promise never settles.
+                await Promise.race([
+                    worker.shutdown(),
+                    new Promise((resolve) => setTimeout(resolve, 5000)),
+                ]);
             }
             catch {
                 // still terminate below
@@ -925,17 +934,25 @@ export class ManyScanCachesOpened {
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
         if (this.actionLogOpened.extensionMessageBus === "ui") {
-            await sendToBackground("worker.changeNodeUrlAndStartHeight", {
+            // the background owns the worker. it stops, then writes. do not write here first.
+            const result = await sendToBackground("worker.changeNodeUrlAndStartHeight", {
                 node_url,
                 start_height,
-            }).catch(() => { });
+            });
+            if (result &&
+                typeof result === "object" &&
+                "error" in result &&
+                result.error) {
+                throw new Error(String(result.error));
+            }
+            if (result == null)
+                throw new Error("background did not save the node url");
             return;
         }
         if (this.wallets.length === 0) {
-            if (node_url !== undefined)
-                await this._scanSettings.setNodeUrl(node_url);
-            if (start_height !== undefined)
-                await this._scanSettings.setStartHeight(start_height);
+            if (node_url !== undefined || start_height !== undefined) {
+                await this._scanSettings.setNodeUrlAndStartHeight(node_url, start_height);
+            }
             return;
         }
         await this.wallets[0].changeNodeUrlAndStartHeight(node_url, start_height);

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

@@ -1,7 +1,7 @@
-import { type GetBlocksBinBufferItem, type BlocksBufferLoopResult, type BlocksBufferIteratorResult, type ProcessScanResult, type BlockInfo } from "../../xmr3";
+import { type GetBlocksBinBufferItem, type BlocksBufferLoopResult, type BlocksBufferIteratorResult, type ProcessScanResult, type BlockInfo } from "../../xmr3_common";
 import { type ScanLoopYield } from "./scanLoop";
 import { type WorkItem } from "./scanLoop";
-import { type ScanSettings } from "../../xmr3";
+import { type ScanSettings } from "../../xmr3_common";
 import { type CacheRange, type ScanCache } from "./scanCache";
 export type WalletConfig = {
     primary_address: string;

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

@@ -1,7 +1,7 @@
-import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResult, writeCacheToFile, sleep, findTipIndex, readWriteConnectionStatusFile, applyWalletScanProgress, } from "../../xmr3";
+import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResult, writeCacheToFile, sleep, findTipIndex, readWriteConnectionStatusFile, applyWalletScanProgress, } from "../../xmr3_common";
 import {} from "./scanLoop";
 import { makeWorkItem } from "./scanLoop";
-import { cullTooLargeScanHeight, getNonHaltedWallets, getPathPrefix, openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, } from "../../xmr3";
+import { cullTooLargeScanHeight, getNonHaltedWallets, getPathPrefix, openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, } from "../../xmr3_common";
 import { currentScanHeightFromRanges, findRange, initScanCacheFile, lastRange, makeCacheRangeForHeight, mergeRanges, } from "./scanCache";
 import { sendToCpuWorker } from "../worker-mains/cpubound-main";
 import { log } from "../../io/logging";

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

@@ -1,4 +1,4 @@
-import { type GetBlocksBinBufferItem, type ScanResult, type WalletConfig, type WalletConfigPlusCache } from "../../xmr3";
+import { type GetBlocksBinBufferItem, type ScanResult, type WalletConfig, type WalletConfigPlusCache } from "../../xmr3_common";
 export type WorkItem = {
     walletConfig: WalletConfigPlusCache;
     batch: GetBlocksBinBufferItem;

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

@@ -1,4 +1,4 @@
-import { sleep, ViewPair, } from "../../xmr3";
+import { sleep, ViewPair, } from "../../xmr3_common";
 export function makeWorkItem(walletConfig, batch, from, to) {
     if (to && to > batch.get_blocks_result_meta.block_infos.length - 1) {
         // we could throw here but we dont. Off by one errors shouldnt break the application

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

@@ -1,4 +1,4 @@
-import { type BlockInfo, type Output } from "../../xmr3";
+import { type BlockInfo, type Output } from "../../xmr3_common";
 import { type KeyImage } from "./computeKeyImage";
 import { type ErrorResponse } from "../../node-interaction/binaryEndpoints";
 import type { CacheChangedCallback, CacheRange, ChangedOutput, ScanCache } from "./scanCache";

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

@@ -1,10 +1,10 @@
-import { CatastrophicReorgError } from "../../xmr3";
+import { CatastrophicReorgError } from "../../xmr3_common";
 import { computeKeyImage } from "./computeKeyImage";
 import { log } from "../../io/logging";
 import { mergeRanges, findRange, findRangeThrows } from "./scanCache";
 import {} from "../../node-interaction/binaryEndpoints";
 import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
-import { monero_wallet_api_wasm } from "../../wasm-processing/wasmFile";
+import { getMoneroWasmBytes } from "../../wasm-processing/wasmLoader";
 export async function processScanResult(params) {
     const { result, scanCache: cache, secret_spend_key } = params;
     let changed_outputs = [];
@@ -145,7 +145,7 @@ export function makeNewRange(newRange, cache) {
 // 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 = [];
-    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
+    const wasmProcessor = await WasmProcessor.init(await getMoneroWasmBytes());
     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);

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

@@ -1,4 +1,4 @@
-import { ViewPair, type Output } from "../../xmr3";
+import { ViewPair, type Output } from "../../xmr3_common";
 import type { ScanCache, Subaddress, TxLog } from "./scanCache";
 import { type OutputStatus } from "./scanResult";
 export type WriteStatsFileParams = {

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

@@ -1,5 +1,4 @@
-import { stat } from "fs";
-import { atomicWrite, ViewPair } from "../../xmr3";
+import { atomicWrite, ViewPair } from "../../xmr3_common";
 import { outputStatus } from "./scanResult";
 export async function writeStatsFileDefaultLocation(params) {
     let stats = await readStatsFileDefaultLocation(params.primary_address, params.pathPrefix);