@spirobel/monero-wallet-api 0.2.0 → 0.3.1

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

@@ -0,0 +1,648 @@
+import { atomicWrite, NodeUrl, signTransaction, ViewPair, } from "../../api";
+import { prepareInput, sumPayments, } from "../../send-functionality/inputSelection";
+import { createWebworker } from "../backgroundWorker";
+import { spendable } from "./scanResult";
+import { openScanSettingsFile, readPrivateSpendKeyFromEnv, readWalletFromScanSettings, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, writeNodeUrlToScanSettings, writeStartHeightToScanSettings, writeWalletToScanSettings, } from "../scanSettings";
+import { findRange, lastRange, readCacheFileDefaultLocation, writeCacheFileDefaultLocationThrows, } from "./scanCache";
+import { alignScanStatsWithCache, isSelfSpent, processTxlogInputs, processTxlogPayments, writeStatsFileDefaultLocation, } from "./scanStats";
+import { readWriteConnectionStatusFile, } from "../connectionStatus";
+export class ScanCacheOpened {
+    view_pair;
+    wallet_route;
+    no_worker;
+    masterCacheChanged;
+    _start_height;
+    scan_settings_path;
+    pathPrefix;
+    workerError;
+    static async create(params) {
+        const theCatchToBeOpened = await readCacheFileDefaultLocation(params.primary_address, params.pathPrefix);
+        const walletSettings = await readWalletFromScanSettings(params.primary_address, params.scan_settings_path);
+        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: ${params.scan_settings_path}
+      Or wrong primary_address supplied params.primary_address: ${params.primary_address}`);
+        if (!params.primary_address)
+            throw new Error(`primary_address is required, potentially half filled out wallet setting in: ${params.scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT}`);
+        // read secret_view_key and secret_spend_key from env
+        const walletSettingsWithKeys = await walletSettingsPlusKeys(walletSettings);
+        // create viewpair + ScanCacheOpened instance
+        const scanCacheOpen = new ScanCacheOpened(await ViewPair.create(params.primary_address, walletSettingsWithKeys.secret_view_key, walletSettings.subaddress_index, walletSettings.node_url), walletSettings.wallet_route, params.no_worker || false, params.masterCacheChanged || null, walletSettings.start_height, params.scan_settings_path, params.pathPrefix, params.workerError);
+        if (theCatchToBeOpened)
+            scanCacheOpen._cache = theCatchToBeOpened;
+        if (!walletSettings.halted) {
+            // run webworker (respecting halted param + setting)
+            // unpause will start scanning from this.wallet_scan_settings.start_height
+            await scanCacheOpen.unpause();
+        }
+        scanCacheOpen._stats = await alignScanStatsWithCache(scanCacheOpen._cache, scanCacheOpen.view_pair, params.primary_address, params.pathPrefix, walletSettings.subaddress_index, lastRange(scanCacheOpen._cache.scanned_ranges)?.end);
+        return scanCacheOpen;
+    }
+    get start_height() {
+        return this._start_height;
+    }
+    get current_height() {
+        let current_range = findRange(this._cache.scanned_ranges, this._start_height || 0);
+        return current_range?.end || null;
+    }
+    get current_top_range_height() {
+        if (typeof this._stats === "undefined" || this._stats === null)
+            return null;
+        return this._stats.height;
+    }
+    async changeStartHeight(start_height) {
+        if (this.worker) {
+            this.worker.terminate();
+            delete this.worker;
+        }
+        await writeStartHeightToScanSettings(start_height, this.scan_settings_path);
+        this._start_height = start_height;
+        await this.unpause();
+    }
+    get cache() {
+        return this._cache;
+    }
+    get prepending_txs() {
+        const txs = [];
+        for (const txlog of this._cache.tx_logs || []) {
+            if (!txlog ||
+                !txlog.sendResult ||
+                (txlog.sendResult && txlog.sendResult.status !== "OK"))
+                continue;
+            const { inputSum, alreadyRecognizedAsSpend } = processTxlogInputs(txlog, this._cache);
+            if (alreadyRecognizedAsSpend)
+                continue;
+            const outWardPaymentSum = processTxlogPayments(txlog, this._cache);
+            const self_spent = isSelfSpent(txlog.payments[0].address, this._cache);
+            const destination_address = txlog.payments[0].address;
+            const inputs = [];
+            for (const inputId of txlog.inputs_index) {
+                const input = this._cache.outputs[inputId];
+                inputs.push(input);
+            }
+            const typical_fee = 1000000000n; // 0.001 XMR
+            const amount = -outWardPaymentSum - typical_fee;
+            const prepending_tx = {
+                amount,
+                txlog,
+                inputSum,
+                outWardPaymentSum,
+                self_spent,
+                destination_address,
+                inputs,
+            };
+            txs.push(prepending_tx);
+        }
+        return txs;
+    }
+    get transactions() {
+        if (typeof this._stats === "undefined" || this._stats === null)
+            return [];
+        const transactions = [];
+        for (const tx of this._stats?.ordered_transactions) {
+            transactions.push(this._stats.found_transactions[tx]);
+        }
+        return transactions;
+    }
+    get primary_address() {
+        return this.view_pair.primary_address;
+    }
+    get node_url() {
+        return this.view_pair.node_url;
+    }
+    set node_url(nu) {
+        this.view_pair.node_url = nu;
+    }
+    async changeNodeUrlAndStartHeight(node_url, start_height) {
+        if (this.worker) {
+            this.worker.terminate();
+            delete this.worker;
+        }
+        if (node_url !== undefined) {
+            await writeNodeUrlToScanSettings(node_url, this.scan_settings_path);
+            this.node_url = node_url;
+        }
+        if (start_height !== undefined) {
+            await writeStartHeightToScanSettings(start_height, this.scan_settings_path);
+            this._start_height = start_height;
+        }
+        await this.unpause();
+    }
+    async changeNodeUrl(node_url) {
+        if (this.worker) {
+            this.worker.terminate();
+            delete this.worker;
+        }
+        await writeNodeUrlToScanSettings(node_url, this.scan_settings_path);
+        this.node_url = node_url;
+        await this.unpause();
+    }
+    async retry() {
+        if (this.worker) {
+            this.worker.terminate();
+            delete this.worker;
+        }
+        const scan_settings = await readWalletFromScanSettings(this.primary_address, this.scan_settings_path).catch(() => false);
+        if (scan_settings) {
+            // if there is no scan settings file,
+            // the retry loop is stopped.
+            // the wallet reset happens through deleting all the scan setting + cache files
+            // we want any background retry loops to stop in this case
+            //TODO ? write connection status retry
+            await this.unpause();
+        }
+        return scan_settings ? true : false;
+    }
+    async sendTransaction(signedTx) {
+        const node = await NodeUrl.create(this.node_url);
+        return await node.sendRawTransaction(signedTx);
+    }
+    async signTransaction(unsignedTx) {
+        const privateSpendKey = readPrivateSpendKeyFromEnv(this._cache.primary_address);
+        if (!privateSpendKey)
+            throw new Error("privateSpendKey not found in env");
+        return await signTransaction(unsignedTx, privateSpendKey);
+    }
+    async calculateFeeAndSelectInputs(params) {
+        const sum = sumPayments(params.payments);
+        const node = await NodeUrl.create(this.node_url);
+        // 1. get fee estimate
+        const feeEstimate = await node.getFeeEstimate();
+        const feePerByte = BigInt(feeEstimate.fees[0]);
+        if (!params.no_fee_circuit_breaker) {
+            // default is false / undefined -> use fee circuit breaker
+            const max_plausible_fee = 20000000000n; // 0.02 XMR
+            const feeFor10kb = feePerByte * 10000n;
+            //2. check if fee is too high
+            if (feeFor10kb > max_plausible_fee) {
+                throw new Error(`fee too high: 
+          ${feeFor10kb} (fee for 10kb tx size) > ${max_plausible_fee} (0.001 XMR)
+          most likely your node is faulty. connect to another node.
+           preferably run one yourself locally.`);
+            }
+        }
+        // 3. select inputs TODO: log inputs indices
+        const selectedInputs = params.inputs || this.selectInputs(sum, feePerByte);
+        if (!selectedInputs.length)
+            throw new Error("not enough funds");
+        return { selectedInputs, feeEstimate };
+    }
+    async makeTransactionFromSelectedInputs(payments, selectedInputs, feeEstimate) {
+        // 4. get output distribution
+        const node = await NodeUrl.create(this.node_url);
+        const distibution = await node.getOutputDistribution();
+        const preparedInputs = [];
+        for (const input of selectedInputs) {
+            // 5. sample decoys & get outs from node: here is where a privacy compromising event could happen
+            preparedInputs.push(prepareInput(node, distibution, input));
+        }
+        const inputs = [];
+        for (const preparedInput of preparedInputs) {
+            // 6. make input: combine output with sampled and verified unlocked decoys
+            const input = node.makeInput(preparedInput.input, preparedInput.sample.candidates, await preparedInput.outsResponse);
+            inputs.push(input);
+        }
+        // 7. make transaction: combine inputs, payments + fee info
+        const unsignedTx = this.view_pair.makeTransaction({
+            inputs,
+            payments,
+            fee_response: feeEstimate,
+            fee_priority: "unimportant",
+        });
+        return unsignedTx;
+    }
+    /**
+     * this function returns the unsigned transaction, throws {@link SendError}
+     */
+    async makeTransaction(params) {
+        const { selectedInputs, feeEstimate } = await this.calculateFeeAndSelectInputs(params);
+        return await this.makeTransactionFromSelectedInputs(params.payments, selectedInputs, feeEstimate);
+    }
+    get daemon_height() {
+        return this._cache.daemon_height;
+    }
+    get amount() {
+        return this._stats?.total_spendable_amount || 0n;
+    }
+    get pending_amount() {
+        return this._stats?.total_pending_amount || 0n;
+    }
+    get subaddresses() {
+        return Object.values(this._stats?.subaddresses || {});
+    }
+    get tx_logs() {
+        return this._cache.tx_logs || [];
+    }
+    async makeSignSendTransaction(params) {
+        let maybeInputs = [];
+        let maybeFeeEstimate;
+        let maybeSendResult;
+        try {
+            const { selectedInputs, feeEstimate } = await this.calculateFeeAndSelectInputs(params);
+            maybeInputs = selectedInputs;
+            maybeFeeEstimate = feeEstimate;
+            const unsignedTx = await this.makeTransactionFromSelectedInputs(params.payments, selectedInputs, feeEstimate);
+            const signedTx = await this.signTransaction(unsignedTx);
+            const sendResult = await this.sendTransaction(signedTx);
+            maybeSendResult = sendResult;
+            if (sendResult.status !== "OK")
+                throw new Error("send raw transaction rpc returned error");
+            // before writing the scan cache, we stop the worker to avoid a race
+            if (this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+            }
+            // write txlog to cache + update pending_spent_utxos (affects stats + spendability)
+            await writeCacheFileDefaultLocationThrows({
+                primary_address: this.primary_address,
+                pathPrefix: this.pathPrefix,
+                writeCallback: async (cache) => {
+                    if (!cache.tx_logs)
+                        cache.tx_logs = [];
+                    if (!cache.pending_spent_utxos)
+                        cache.pending_spent_utxos = {};
+                    const inputs_index = selectedInputs.map((input) => String(input.index_on_blockchain));
+                    const txLog = {
+                        sendResult,
+                        feeEstimate,
+                        payments: params.payments,
+                        node_url: this.node_url,
+                        inputs_index,
+                        height: this.current_height,
+                        timestamp: Date.now(),
+                    };
+                    const newLen = cache.tx_logs.push(txLog);
+                    const txLogIndex = newLen - 1;
+                    for (const inputId of inputs_index) {
+                        cache.pending_spent_utxos[inputId] = txLogIndex;
+                    }
+                },
+            });
+            const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
+            if (!newCache)
+                throw new Error(`cache not found for primary address: ${this.primary_address}, and path prefix: ${this.pathPrefix}`);
+            const changed_outputs = selectedInputs.map((input) => ({
+                change_reason: "spent",
+                output: input,
+            }));
+            await this.feed({
+                newCache,
+                changed_outputs,
+            });
+            // restart the worker
+            await this.unpause();
+            return sendResult;
+        }
+        catch (e) {
+            // before writing the scan cache, we stop the worker to avoid a race
+            if (this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+            }
+            // write txlog error to cache
+            await writeCacheFileDefaultLocationThrows({
+                primary_address: this.primary_address,
+                pathPrefix: this.pathPrefix,
+                writeCallback: async (cache) => {
+                    if (!cache.tx_logs)
+                        cache.tx_logs = [];
+                    if (!cache.pending_spent_utxos)
+                        cache.pending_spent_utxos = {};
+                    const inputs_index = maybeInputs.map((input) => String(input.index_on_blockchain));
+                    const txLog = {
+                        sendResult: maybeSendResult,
+                        error: String(e || "unknown error"),
+                        feeEstimate: maybeFeeEstimate,
+                        payments: params.payments,
+                        node_url: this.node_url,
+                        inputs_index,
+                        height: this.current_height,
+                        timestamp: Date.now(),
+                    };
+                    const newLen = cache.tx_logs.push(txLog);
+                },
+            });
+            const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
+            if (!newCache)
+                throw new Error(`cache not found for primary address: ${this.primary_address}, and path prefix: ${this.pathPrefix}`);
+            const changed_outputs = maybeInputs.map((input) => ({
+                change_reason: "spent",
+                output: input,
+            }));
+            await this.feed({
+                newCache,
+                changed_outputs,
+            });
+            // restart the worker
+            await this.unpause();
+            throw e;
+        }
+    }
+    /**
+     * makeStandardTransaction
+     */
+    makeStandardTransaction(destination_address, amount) {
+        return this.makeTransaction({
+            payments: [{ address: destination_address, amount }],
+        });
+    }
+    /**
+     * makeIntegratedAddress
+     */
+    makeIntegratedAddress(paymentId) {
+        return this.view_pair.makeIntegratedAddress(paymentId);
+    }
+    /**
+     * This method makes a Subaddress for the Address of the Viewpair it was opened with.
+     * The network (mainnet, stagenet, testnet) is the same as the one of the Viewpairaddress.
+     * will increment minor by 1 on major 0 in "ScanSettings.json" subaddresses definition
+     *
+     * if there is an active scan going on, call this here on ScanCacheOpened, so the new subaddress will be scanned
+     * (and not on a viewpair / scancacheopened instance that is not conducting the scan, aka where no_worker is true)
+     *
+     * @returns Adressstring
+     */
+    async makeSubaddress() {
+        const walletSettings = await readWalletFromScanSettings(this.view_pair.primary_address, this.scan_settings_path);
+        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: ${this.scan_settings_path}
+      Or wrong primary_address supplied params.primary_address: ${this.view_pair.primary_address}`);
+        const last_subaddress_index = walletSettings.subaddress_index || 0;
+        const minor = last_subaddress_index + 1;
+        const subaddress = this.view_pair.makeSubaddress(minor);
+        await writeWalletToScanSettings({
+            primary_address: this.view_pair.primary_address,
+            subaddress_index: minor,
+            scan_settings_path: this.scan_settings_path,
+        });
+        const created_at_height = lastRange(this._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,
+        };
+        this._stats = await writeStatsFileDefaultLocation({
+            primary_address: this.primary_address,
+            pathPrefix: this.pathPrefix,
+            writeCallback: async (stats) => {
+                stats.subaddresses[minor.toString()] = new_subaddress;
+            },
+        });
+        return new_subaddress;
+    }
+    /**
+     * notify
+     *
+     * ChangeReason = "added" | "ownspend" | "reorged" | "burned";
+     */
+    //TODO PAUSE NOTIFY listner and node status / connection error
+    notify(callback) {
+        this.notifyListeners.push(callback);
+        const id = this.notifyListeners.length - 1;
+        return {
+            remove: () => (this.notifyListeners[id] = null),
+        };
+    }
+    async pause() {
+        if (this.worker)
+            this.worker.terminate();
+        return await writeWalletToScanSettings({
+            primary_address: this.view_pair.primary_address,
+            halted: true,
+            scan_settings_path: this.scan_settings_path,
+        });
+    }
+    stopWorker() {
+        if (this.worker) {
+            this.worker.terminate();
+            delete this.worker;
+        }
+    }
+    async unpause() {
+        // if worker does not exist yet, start it (if we are not slave / no_worker)
+        if (!this.worker && !this.no_worker) {
+            this.worker = createWebworker(async (params) => await this.feed(params), this.scan_settings_path, this.pathPrefix, (error) => {
+                const workerErrCB = this.workerError;
+                readWriteConnectionStatusFile((cs) => {
+                    if (cs?.last_packet.status === "catastrophic_reorg")
+                        return;
+                    const connectionStatus = {
+                        last_packet: {
+                            status: "connection_failed",
+                            bytes_read: 0,
+                            node_url: this.node_url,
+                            timestamp: new Date().toISOString(),
+                        },
+                    };
+                    return connectionStatus;
+                }).then(() => {
+                    if (workerErrCB)
+                        workerErrCB(error);
+                });
+            });
+        }
+        return await writeWalletToScanSettings({
+            primary_address: this.view_pair.primary_address,
+            halted: false,
+            scan_settings_path: this.scan_settings_path,
+        });
+    }
+    /**
+     * selectInputs returns array of inputs, whose sum is larger than amount
+     * adds approximate fee for 10kb transaction to amount if feePerByte is supplied
+     */
+    selectInputs(amount, feePerByte) {
+        if (feePerByte)
+            amount += feePerByte * 10000n; // 10kb * feePerByte; for sweeping low amounts inputs[] supplied directly
+        const oneInputIsEnough = this.selectOneInput(amount);
+        if (oneInputIsEnough)
+            return [oneInputIsEnough];
+        return this.selectMultipleInputs(amount);
+    }
+    /**
+     * selectOneInput larger than amount, (smallest one matching this amount)
+     */
+    selectOneInput(amount) {
+        return this.spendableInputs()
+            .filter((output) => output.amount >= amount)
+            .sort((a, b) => b.amount > a.amount ? -1 : b.amount < a.amount ? 1 : 0)[0];
+    }
+    /**
+     * selectMultipleInputs larger than amount, sorted from largest to smallest until total reaches amount
+     */
+    selectMultipleInputs(amount) {
+        const selected = [];
+        let total = 0n;
+        for (const output of this.spendableInputs()) {
+            selected.push(output);
+            total += output.amount;
+            if (total >= amount)
+                return selected;
+        }
+        return [];
+    }
+    /**
+     * get spendableInputs
+     */
+    spendableInputs() {
+        return Object.values(this._cache.outputs)
+            .filter((output) => spendable(output, this._cache, this.current_height || 0))
+            .sort((a, b) => (a.amount > b.amount ? -1 : a.amount < b.amount ? 1 : 0));
+    }
+    /**
+     * feed the ScanCacheOpened with new ScanCache as syncing happens
+     * if primary_address does not match, do not feed
+     * if masterCacheChanged is set, it will be called here
+     * for all primary addresses
+     */
+    async feed(params) {
+        //TODO update aggregated amount stats + height
+        if (this.masterCacheChanged)
+            this.masterCacheChanged(params);
+        if (this.view_pair.primary_address !== params.newCache.primary_address)
+            return;
+        this._cache = params.newCache;
+        this._stats = await alignScanStatsWithCache(this._cache, this.view_pair, this.primary_address, this.pathPrefix, undefined, lastRange(this._cache.scanned_ranges)?.end);
+        for (const listener of this.notifyListeners) {
+            if (listener)
+                listener(params);
+        }
+    }
+    _cache = {
+        daemon_height: 0,
+        outputs: {},
+        own_key_images: {},
+        scanned_ranges: [],
+        primary_address: "",
+    };
+    worker = undefined;
+    constructor(view_pair, wallet_route, no_worker, masterCacheChanged, _start_height, scan_settings_path, pathPrefix, workerError) {
+        this.view_pair = view_pair;
+        this.wallet_route = wallet_route;
+        this.no_worker = no_worker;
+        this.masterCacheChanged = masterCacheChanged;
+        this._start_height = _start_height;
+        this.scan_settings_path = scan_settings_path;
+        this.pathPrefix = pathPrefix;
+        this.workerError = workerError;
+    }
+    _stats = null;
+    notifyListeners = [];
+}
+export class ManyScanCachesOpened {
+    wallets;
+    get start_height() {
+        if (this.wallets.length === 0)
+            return null;
+        return this.wallets[0]?.start_height;
+    }
+    get current_height() {
+        if (this.wallets.length === 0)
+            return null;
+        return this.wallets[0]?.current_height;
+    }
+    get node_url() {
+        if (this.wallets.length === 0)
+            return "";
+        return this.wallets[0]?.node_url;
+    }
+    async changeNodeUrlAndStartHeight(node_url, start_height) {
+        if (this.wallets.length === 0)
+            throw new Error("no wallets");
+        const masterWallet = this.wallets[0];
+        return await masterWallet.changeNodeUrlAndStartHeight(node_url, start_height);
+    }
+    async retry() {
+        if (this.wallets.length === 0)
+            throw new Error("no wallets");
+        const masterWallet = this.wallets[0];
+        return await masterWallet.retry();
+    }
+    stopWorker() {
+        if (this.wallets.length === 0)
+            throw new Error("no wallets");
+        const masterWallet = this.wallets[0];
+        return masterWallet.stopWorker();
+    }
+    async changeNodeUrl(node_url) {
+        if (this.wallets.length === 0)
+            throw new Error("no wallets");
+        const masterWallet = this.wallets[0];
+        return await masterWallet.changeNodeUrl(node_url);
+    }
+    async changeStartHeight(start_height) {
+        if (this.wallets.length === 0)
+            throw new Error("no wallets");
+        const masterWallet = this.wallets[0];
+        return await masterWallet.changeStartHeight(start_height);
+    }
+    static async create({ scan_settings_path, pathPrefix, no_worker, notifyMasterChanged, no_stats, workerError, }) {
+        const scan_settings = await openScanSettingsFile(scan_settings_path);
+        if (!scan_settings?.wallets)
+            throw new Error(`no wallets in settings file. Did you supply the right path?
+     are there wallets in the default '${SCAN_SETTINGS_STORE_NAME_DEFAULT}' file?`);
+        const nonHaltedWallets = scan_settings.wallets.filter((wallet) => !wallet?.halted);
+        if (!nonHaltedWallets.length)
+            return undefined;
+        const openedWallets = [];
+        const firstNonHaltedWallet = nonHaltedWallets[0];
+        if (nonHaltedWallets.length > 1) {
+            const slaveWallets = [];
+            for (const wallet of nonHaltedWallets.slice(1)) {
+                if (!wallet || wallet.halted)
+                    continue;
+                const slaveWallet = await ScanCacheOpened.create({
+                    ...wallet,
+                    no_worker: true, // slaves depend on master worker
+                    scan_settings_path,
+                    pathPrefix,
+                    no_stats,
+                });
+                slaveWallets.push(slaveWallet);
+            }
+            const masterWallet = await ScanCacheOpened.create({
+                ...firstNonHaltedWallet,
+                masterCacheChanged: async (params) => {
+                    notifyMasterChanged?.(params);
+                    for (const slave of slaveWallets) {
+                        await slave.feed(params);
+                    }
+                },
+                scan_settings_path,
+                pathPrefix,
+                no_stats,
+                no_worker, // pass no_worker, if you want to manually feed()
+                workerError,
+            });
+            openedWallets.push(masterWallet, ...slaveWallets);
+        }
+        else {
+            const onlyWallet = await ScanCacheOpened.create({
+                masterCacheChanged: async (params) => {
+                    notifyMasterChanged?.(params);
+                },
+                ...firstNonHaltedWallet,
+                scan_settings_path,
+                pathPrefix,
+                no_stats,
+                no_worker, // pass no_worker, if you want to manually feed()
+                workerError,
+            });
+            openedWallets.push(onlyWallet);
+        }
+        return new ManyScanCachesOpened(openedWallets);
+    }
+    /**
+     * feed the master wallet and therefore all wallets
+     */
+    async feed(params) {
+        await this.wallets[0].feed(params);
+    }
+    constructor(wallets) {
+        this.wallets = wallets;
+    }
+}