Add ability for MPW to run explorer-less

scripts/dashboard/WalletBalance.vue

@@ -1,6 +1,6 @@
 <script setup>
 import { cChainParams, COIN } from '../chain_params.js';
-import { translation } from '../i18n';
+import { translation, tr } from '../i18n';
 import { ref, computed, toRefs } from 'vue';
 import { beautifyNumber } from '../misc';
 import { getEventEmitter } from '../event_bus';
@@ -130,11 +130,13 @@ const emit = defineEmits([
 
 getEventEmitter().on(
     'transparent-sync-status-update',
-    (i, totalPages, finished) => {
-        const str = tr(translation.syncStatusHistoryProgress, [
-            { current: totalPages - i + 1 },
-            { total: totalPages },
-        ]);
+    (i, totalPages, finished, message) => {
+        const str =
+            message ||
+            tr(translation.syncStatusHistoryProgress, [
+                { current: totalPages - i + 1 },
+                { total: totalPages },
+            ]);
         const progress = ((totalPages - i) / totalPages) * 100;
         syncTStr.value = str;
         transparentProgressSyncing.value = progress;
@@ -510,16 +512,16 @@ function restoreWallet() {
                 </div>
                 <div style="width: 100%">
                     {{
-                        transparentSyncing
-                            ? syncTStr
-                            : `Syncing ${shieldBlockRemainingSyncing} Blocks...`
+                        shieldSyncing
+                            ? `Syncing ${shieldBlockRemainingSyncing} Blocks...`
+                            : syncTStr
                     }}
                     <LoadingBar
                         :show="true"
                         :percentage="
-                            transparentSyncing
-                                ? transparentProgressSyncing
-                                : shieldPercentageSyncing
+                            shieldSyncing
+                                ? shieldPercentageSyncing
+                                : transparentProgressSyncing
                         "
                         style="
                             border: 1px solid #932ecd;

scripts/network.js

@@ -98,52 +98,48 @@ export class ExplorerNetwork extends Network {
      * @returns {Promise<Object>} the block fetched from explorer
      */
     async getBlock(blockHeight, skipCoinstake = false) {
-        const block = await this.safeFetchFromExplorer(
-            `/api/v2/block/${blockHeight}`
+        // First we fetch the blockhash (and strip RPC's quotes)
+        const strHash = (
+            await this.callRPC(`/getblockhash?params=${blockHeight}`, true)
+        ).replace(/"/g, '');
+        // Craft a filter to retrieve only raw Tx hex and txid, also change "tx" to "txs"
+        const strFilter =
+            '&filter=' +
+            encodeURI(`. | .txs = [.tx[] | { hex: .hex, txid: .txid}]`);
+        // Fetch the full block (verbose)
+        const block = await this.callRPC(
+            `/getblock?params=${strHash},2${strFilter}`
         );
-        const newTxs = [];
-        // This is bad. We're making so many requests
-        // This is a quick fix to try to be compliant with the blockbook
-        // API, and not the PIVX extension.
-        // In the Blockbook API /block doesn't have any chain specific information
-        // Like hex, shield info or what not.
-        // We could change /getshieldblocks to /getshieldtxs?
-        // In addition, always skip the coinbase transaction and in case the coinstake one
+        // Always skip the coinbase transaction and in case the coinstake one
         // TODO: once v6.0 and shield stake is activated we might need to change this optimization
-        for (const tx of block.txs.slice(skipCoinstake ? 2 : 1)) {
-            const r = await fetch(
-                `${this.strUrl}/api/v2/tx-specific/${tx.txid}`
-            );
-            if (!r.ok) throw new Error('failed');
-            const newTx = await r.json();
-            newTxs.push(newTx);
-        }
-        block.txs = newTxs;
+        block.txs = block.txs.slice(skipCoinstake ? 2 : 1);
         return block;
     }
 
     /**
-     * Fetch the block height of the current explorer
+     * Fetch the block height of the current node
      * @returns {Promise<number>} - Block height
      */
     async getBlockCount() {
-        const { backend } = await (
-            await retryWrapper(fetchBlockbook, true, `/api/v2/api`)
-        ).json();
-
-        return backend.blocks;
+        return parseInt(await this.callRPC('/getblockcount', true));
     }
 
     /**
-     * Fetch the latest block hash of the current explorer
+     * Fetch the latest block hash of the current explorer or fallback node
      * @returns {Promise<string>} - Block hash
      */
     async getBestBlockHash() {
-        const { backend } = await (
-            await retryWrapper(fetchBlockbook, true, `/api/v2/api`)
-        ).json();
+        try {
+            // Attempt via Explorer first
+            const { backend } = await (
+                await retryWrapper(fetchBlockbook, true, `/api/v2/api`)
+            ).json();
 
-        return backend.bestBlockHash;
+            return backend.bestBlockHash;
+        } catch {
+            // Use Nodes as a fallback
+            return await this.callRPC('/getbestblockhash', true);
+        }
     }
 
     /**
@@ -272,19 +268,38 @@ export class ExplorerNetwork extends Network {
 
     async sendTransaction(hex) {
         try {
-            const data = await (
-                await retryWrapper(fetchBlockbook, true, '/api/v2/sendtx/', {
-                    method: 'post',
-                    body: hex,
-                })
-            ).json();
+            // Attempt via Explorer first
+            let strTXID = '';
+            try {
+                const cData = await (
+                    await retryWrapper(
+                        fetchBlockbook,
+                        true,
+                        '/api/v2/sendtx/',
+                        {
+                            method: 'post',
+                            body: hex,
+                        }
+                    )
+                ).json();
+                // If there's no TXID, we throw any potential Blockbook errors
+                if (!cData.result || cData.result.length !== 64) throw cData;
+                strTXID = cData.result;
+            } catch {
+                // Use Nodes as a fallback
+                strTXID = await this.callRPC(
+                    '/sendrawtransaction?params=' + hex,
+                    true
+                );
+                strTXID = strTXID.replace(/"/g, '');
+            }
 
-            // Throw and catch if the data is not a TXID
-            if (!data.result || data.result.length !== 64) throw data;
+            // Throw and catch if there's no TXID
+            if (!strTXID || strTXID.length !== 64) throw strTXID;
 
-            debugLog(DebugTopics.NET, 'Transaction sent! ' + data.result);
-            getEventEmitter().emit('transaction-sent', true, data.result);
-            return data.result;
+            debugLog(DebugTopics.NET, 'Transaction sent! ' + strTXID);
+            getEventEmitter().emit('transaction-sent', true, strTXID);
+            return strTXID;
         } catch (e) {
             getEventEmitter().emit('transaction-sent', false, e);
             return false;

scripts/wallet.js

@@ -701,7 +701,29 @@ export class Wallet {
         // This is just to be sure since blockbook (as we know)
         // usually does not return txs of the actual last block.
         this.#lastProcessedBlock = blockCount - 5;
-        await this.#transparentSync();
+        // Transparent sync is inherently less stable than Shield since it requires heavy
+        // explorer indexing, so we'll attempt once asynchronously, and if it fails, set a
+        // recurring "background" sync interval until it's finally successful.
+        try {
+            await this.#transparentSync();
+        } catch {
+            // We'll set a 5s interval sync until it's finally successful, then nuke the 'thread'.
+            const cThread = new AsyncInterval(async () => {
+                try {
+                    await this.#transparentSync(true);
+                    cThread.clearInterval();
+                } catch {
+                    // Emit a transparent sync warning
+                    getEventEmitter().emit(
+                        'transparent-sync-status-update',
+                        0,
+                        0,
+                        false,
+                        'Explorers are unreachable, your wallet may not be fully synced!'
+                    );
+                }
+            }, 5000);
+        }
         if (this.hasShield()) {
             await this.#syncShield();
         }
@@ -712,8 +734,12 @@ export class Wallet {
         getEventEmitter().emit('new-tx');
     });
 
-    async #transparentSync() {
-        if (!this.isLoaded() || this.#isSynced) return;
+    /**
+     * Synchronise UTXOs via xpub/address from the current explorer.
+     * @param {boolean} [force=false] - Force transparent sync, regardless of state
+     */
+    async #transparentSync(force = false) {
+        if ((!this.isLoaded() || this.#isSynced) && !force) return;
         const cNet = getNetwork();
         const addr = this.getKeyToExport();
         let nStartHeight = Math.max(
@@ -850,11 +876,9 @@ export class Wallet {
         async (blockCount) => {
             const cNet = getNetwork();
             let block;
-            // Don't ask for the exact last block that arrived,
-            // since it takes around 1 minute for blockbook to make it API available
             for (
-                let blockHeight = this.#lastProcessedBlock + 1;
-                blockHeight < blockCount;
+                let blockHeight = this.#lastProcessedBlock;
+                blockHeight <= blockCount;
                 blockHeight++
             ) {
                 try {