diff --git a/scripts/composables/use_settings.js b/scripts/composables/use_settings.js
index 0717bdb62..d20498d2c 100644
--- a/scripts/composables/use_settings.js
+++ b/scripts/composables/use_settings.js
@@ -46,7 +46,7 @@ export function useSettings() {
     getEventEmitter().on('advanced-mode', (fAdvancedMode) => {
         advancedMode.value = fAdvancedMode;
     });
-    getEventEmitter().on('balance-update', async () => {
+    getEventEmitter().on('price-update', async () => {
         displayDecimals.value = nDisplayDecimals;
     });
     getEventEmitter().on('auto-lock-wallet', (fAutoLockWallet) => {
diff --git a/scripts/composables/use_wallet.js b/scripts/composables/use_wallet.js
index 8faeac520..15f1a5fa6 100644
--- a/scripts/composables/use_wallet.js
+++ b/scripts/composables/use_wallet.js
@@ -134,10 +134,12 @@ export const useWallet = defineStore('wallet', () => {
     getEventEmitter().on('balance-update', async () => {
         balance.value = wallet.balance;
         immatureBalance.value = wallet.immatureBalance;
-        currency.value = strCurrency.toUpperCase();
         shieldBalance.value = await wallet.getShieldBalance();
         pendingShieldBalance.value = await wallet.getPendingShieldBalance();
         coldBalance.value = wallet.coldBalance;
+    });
+    getEventEmitter().on('price-update', async () => {
+        currency.value = strCurrency.toUpperCase();
         price.value = cOracle.getCachedPrice(strCurrency);
     });
 
diff --git a/scripts/dashboard/Activity.vue b/scripts/dashboard/Activity.vue
index 6cf402253..8c92da0ba 100644
--- a/scripts/dashboard/Activity.vue
+++ b/scripts/dashboard/Activity.vue
@@ -11,6 +11,7 @@ import { getEventEmitter } from '../event_bus';
 
 import iCheck from '../../assets/icons/icon-check.svg';
 import iHourglass from '../../assets/icons/icon-hourglass.svg';
+import { blockCount } from '../global.js';
 
 const props = defineProps({
     title: String,
@@ -117,47 +118,40 @@ async function update(txToAdd = 0) {
     // If there are less than 10 txs loaded, append rather than update the list
     if (txCount < 10 && txToAdd == 0) txToAdd = 10;
 
-    let found = 0;
-    // Since ECMAScript 2019 .sort is stable.
-    // https://caniuse.com/mdn-javascript_builtins_array_sort_stable
-    const orderedTxs = Array.from(wallet.getTransactions()).sort(
-        (a, b) => a.blockHeight - b.blockHeight
-    );
+    const historicalTxs = wallet.getHistoricalTxs();
 
     // For Rewards: aggregate the total amount
     if (props.rewards) {
-        for (const tx of orderedTxs) {
+        for (const tx of historicalTxs) {
             // If this Tx Height is under our last scanned height, we stop
             if (tx.blockHeight <= nRewardUpdateHeight) break;
             // Only compute rewards
-            if (!tx.isCoinStake()) continue;
+            if (tx.type != HistoricalTxType.STAKE) continue;
             // Aggregate the total rewards
-            rewardAmount.value += (
-                await wallet.toHistoricalTXs([tx])
-            )[0].amount;
+            rewardAmount.value += tx.amount;
         }
         // Keep track of the scan block height
-        if (orderedTxs.length) {
-            nRewardUpdateHeight = orderedTxs[0].blockHeight;
+        if (historicalTxs.length) {
+            nRewardUpdateHeight = historicalTxs[0].blockHeight;
         }
     }
 
-    // Prepare the Tx History list
+    let i = 0;
+    let found = 0;
     while (found < txCount + txToAdd) {
-        if (orderedTxs.length == 0) {
+        if (i === historicalTxs.length) {
             isHistorySynced.value = true;
             break;
         }
-        const tx = orderedTxs.pop();
-        if (props.rewards && !tx.isCoinStake()) continue;
+        const tx = historicalTxs[i];
+        i += 1;
+        if (props.rewards && tx.type != HistoricalTxType.STAKE) continue;
         newTxs.push(tx);
         found++;
     }
 
-    // Convert to MPW's Activity format and render it
-    const arrTXs = await wallet.toHistoricalTXs(newTxs);
-    await parseTXs(arrTXs);
     txCount = found;
+    await parseTXs(newTxs);
     updating.value = false;
 }
 
@@ -215,6 +209,13 @@ async function parseTXs(arrTXs) {
 
         let amountToShow = Math.abs(cTx.amount + cTx.shieldAmount);
 
+        // Coinbase Transactions (rewards) require coinbaseMaturity confs
+        const fConfirmed =
+            blockCount - cTx.blockHeight >=
+            (cTx.type === HistoricalTxType.STAKE
+                ? cChainParams.current.coinbaseMaturity
+                : 6);
+
         // Take the icon, colour and content based on the type of the transaction
         let { icon, colour, content } = txMap.value[cTx.type];
         const match = content.match(/{(.)}/);
@@ -277,7 +278,7 @@ async function parseTXs(arrTXs) {
             content: props.rewards ? cTx.id : content,
             formattedAmt,
             amount: amountToShow,
-            confirmed: cTx.isConfirmed,
+            confirmed: fConfirmed,
             icon,
             colour,
         });
diff --git a/scripts/dashboard/Dashboard.vue b/scripts/dashboard/Dashboard.vue
index a9b881e82..1e2006e8c 100644
--- a/scripts/dashboard/Dashboard.vue
+++ b/scripts/dashboard/Dashboard.vue
@@ -935,7 +935,6 @@ defineExpose({
             :publicMode="wallet.publicMode"
             :price="price"
             :currency="currency"
-            :shieldEnabled="hasShield"
             v-model:amount="transferAmount"
             :desc="transferDescription"
             v-model:address="transferAddress"
diff --git a/scripts/dashboard/TransferMenu.vue b/scripts/dashboard/TransferMenu.vue
index 787ba95cd..81a79a83b 100644
--- a/scripts/dashboard/TransferMenu.vue
+++ b/scripts/dashboard/TransferMenu.vue
@@ -1,10 +1,9 @@
 <script setup>
 import { translation } from '../i18n.js';
-import { ref, watch, computed } from 'vue';
+import { ref, watch } from 'vue';
 import { getAddressColor } from '../contacts-book';
 import { promptForContact } from '../contacts-book';
 import { sanitizeHTML } from '../misc';
-import { useWallet } from '../composables/use_wallet.js';
 import BottomPopup from '../BottomPopup.vue';
 import qrIcon from '../../assets/icons/icon-qr-code.svg';
 import addressbookIcon from '../../assets/icons/icon-address-book.svg';
@@ -21,8 +20,6 @@ const emit = defineEmits([
 const amountCurrency = ref('');
 const color = ref('');
 
-const wallet = useWallet();
-
 const props = defineProps({
     show: Boolean,
     price: Number,
@@ -30,7 +27,6 @@ const props = defineProps({
     amount: String,
     desc: String,
     address: String,
-    shieldEnabled: Boolean,
     publicMode: Boolean,
 });
 
@@ -40,6 +36,13 @@ watch(address, (value) =>
     getAddressColor(value).then((c) => (color.value = `${c} !important`))
 );
 
+watch(
+    () => props.price,
+    () => {
+        syncAmountCurrency();
+    }
+);
+
 const amount = defineModel('amount', {
     set(value) {
         return value.toString();
@@ -56,7 +59,7 @@ function send() {
             'send',
             sanitizeHTML(address.value),
             amount.value,
-            !wallet.publicMode
+            !props.publicMode
         );
 }
 
diff --git a/scripts/global.js b/scripts/global.js
index b5f7fb605..a4bb6d7c6 100644
--- a/scripts/global.js
+++ b/scripts/global.js
@@ -287,7 +287,7 @@ export async function start() {
 
 async function refreshPriceDisplay() {
     await cOracle.getPrice(strCurrency);
-    getEventEmitter().emit('balance-update');
+    getEventEmitter().emit('price-update');
 }
 
 function subscribeToNetworkEvents() {
@@ -777,19 +777,19 @@ export async function updateGovernanceTab() {
 
     // Update governance counter when testnet/mainnet has been switched
     if (!governanceFlipdown && blockCount > 0) {
-        Masternode.getNextSuperblock().then((nSuperblock) => {
-            // The estimated time to the superblock (using the block target and remaining blocks)
-            const nTimestamp =
-                Date.now() / 1000 + (nSuperblock - blockCount) * 60;
-            governanceFlipdown = new FlipDown(nTimestamp).start();
-        });
+        getNetwork()
+            .getNextSuperblock()
+            .then((nSuperblock) => {
+                // The estimated time to the superblock (using the block target and remaining blocks)
+                const nTimestamp =
+                    Date.now() / 1000 + (nSuperblock - blockCount) * 60;
+                governanceFlipdown = new FlipDown(nTimestamp).start();
+            });
         isTestnetLastState = cChainParams.current.isTestnet;
     }
 
     // Fetch all proposals from the network
-    const arrProposals = await Masternode.getProposals({
-        fAllowFinished: false,
-    });
+    const arrProposals = await getNetwork().getProposals();
 
     /* Sort proposals into two categories
         - Standard (Proposal is either new with <100 votes, or has a healthy vote count)
@@ -979,7 +979,7 @@ async function renderProposals(arrProposals, fContested) {
     );
 
     // Fetch the Masternode count for proposal status calculations
-    const cMasternodes = await Masternode.getMasternodeCount();
+    const cMasternodes = await getNetwork().getMasternodeCount();
 
     let totalAllocatedAmount = 0;
 
@@ -1654,7 +1654,7 @@ export async function createProposal() {
     const strAddress =
         document.getElementById('proposalAddress').value.trim() ||
         wallet.getNewAddress(1)[0];
-    const nextSuperblock = await Masternode.getNextSuperblock();
+    const nextSuperblock = await getNetwork().getNextSuperblock();
     const proposal = {
         name: strTitle,
         url: strUrl,
diff --git a/scripts/historical_tx.js b/scripts/historical_tx.js
index 1663f1df6..868d42d47 100644
--- a/scripts/historical_tx.js
+++ b/scripts/historical_tx.js
@@ -9,10 +9,14 @@ export class HistoricalTx {
      * @param {Array<string>} shieldReceivers - The list of decrypted 'shield output addresses'.
      * @param {number} time - The block time of the transaction.
      * @param {number} blockHeight - The block height of the transaction.
+<<<<<<< HEAD
      * @param {number} amount - The transparent amount transacted, in coins.
      * @param {number} shieldAmount - The shielded amount transacted, in coins.
      * @param {boolean} isToSelf - If the transaction is to self.
      * @param {boolean} isConfirmed - Whether the transaction has been confirmed.
+=======
+     * @param {number} amount - The amount transacted, in coins.
+>>>>>>> upstream/master
      */
     constructor(
         type,
@@ -23,8 +27,7 @@ export class HistoricalTx {
         blockHeight,
         amount,
         shieldAmount,
-        isToSelf,
-        isConfirmed
+        isToSelf
     ) {
         this.type = type;
         this.id = id;
@@ -35,7 +38,6 @@ export class HistoricalTx {
         this.amount = amount;
         this.shieldAmount = shieldAmount;
         this.isToSelf = isToSelf;
-        this.isConfirmed = isConfirmed;
     }
 }
 
diff --git a/scripts/masternode.js b/scripts/masternode.js
index eefd6e942..90b8f737b 100644
--- a/scripts/masternode.js
+++ b/scripts/masternode.js
@@ -50,20 +50,14 @@ export default class Masternode {
        @return {Promise<Object>} The object containing masternode information for this masternode
      */
     async getFullData() {
-        const strURL = `/listmasternodes?params=${this.collateralTxId}`;
-        try {
-            const cMasternodes = (await getNetwork().callRPC(strURL)).filter(
-                (m) => m.outidx === this.outidx
-            );
-            if (cMasternodes.length > 0) {
-                return cMasternodes[0];
-            } else {
-                return { status: 'MISSING' };
-            }
-        } catch (e) {
-            //this is the unfortunate state in which the node is not reachable
-            debugError(DebugTopics.MASTERNODE, e);
-            return 'EXPLORER_DOWN';
+        const cMasternodes = await getNetwork().getMasternodeInfo(
+            this.collateralTxId,
+            this.outidx
+        );
+        if (cMasternodes.length > 0) {
+            return cMasternodes[0];
+        } else {
+            return { status: 'MISSING' };
         }
     }
 
@@ -334,28 +328,9 @@ export default class Masternode {
      */
     async start() {
         const message = await this.broadcastMessageToHex();
-        const url = `/relaymasternodebroadcast?params=${message}`;
-        const response = await getNetwork().callRPC(url, true);
-        return response.includes('Masternode broadcast sent');
-    }
-
-    /**
-     *
-     * @param {object} options
-     * @param {bool} options.fAllowFinished - Pass `true` to stop filtering proposals if finished
-     * @return {Promise<Array<object>} A list of currently active proposal
-     */
-    static async getProposals({ fAllowFinished = false } = {}) {
-        const url = `/getbudgetinfo`;
-        let arrProposals = await getNetwork().callRPC(url);
-
-        // Apply optional filters
-        if (!fAllowFinished) {
-            arrProposals = arrProposals.filter(
-                (a) => a.RemainingPaymentCount > 0
-            );
-        }
-        return arrProposals;
+        return (await getNetwork().start(message)).includes(
+            'Masternode broadcast sent'
+        );
     }
 
     /**
@@ -396,19 +371,17 @@ export default class Masternode {
             //Found it! return the vote
             return Masternode.sessionVotes[index][1];
         }
-        //Haven't voted yet, fetch the result from Duddino's node
-        const filterString = `.[] | select(.mnId=="`;
-        const filter =
-            `${encodeURI(filterString)}` +
-            `${this.collateralTxId}-${this.outidx}")`;
-        const url = `/getbudgetvotes?params=${proposalName}&filter=${filter}`;
-        try {
-            const { Vote: vote } = await getNetwork().callRPC(url);
-            return vote === 'YES' ? 1 : 2;
-        } catch (e) {
-            //Cannot parse JSON! This means that you did not vote hence return null
+        const vote = (
+            await getNetwork().getProposalVote(
+                proposalName,
+                this.collateralTxId,
+                this.outidx
+            )
+        ).Vote;
+        if (!vote) {
             return null;
         }
+        return vote === 'YES' ? 1 : 2;
     }
     /**
      * Stores a vote for the current session
@@ -433,18 +406,17 @@ export default class Masternode {
      */
     async vote(hash, voteCode) {
         const sigTime = Math.round(Date.now() / 1000);
-        const signature = await this.getSignedVoteMessage(
+        const signature = encodeURI(
+            await this.getSignedVoteMessage(hash, voteCode, sigTime)
+        ).replaceAll('+', '%2b');
+        return await getNetwork().voteProposal(
+            this.collateralTxId,
+            this.outidx,
             hash,
             voteCode,
-            sigTime
-        );
-        const url = `/mnbudgetrawvote?params=${this.collateralTxId},${
-            this.outidx
-        },${hash},${voteCode === 1 ? 'yes' : 'no'},${sigTime},${encodeURI(
+            sigTime,
             signature
-        ).replaceAll('+', '%2b')}`;
-        const text = await getNetwork().callRPC(url, true);
-        return text;
+        );
     }
 
     /**
@@ -513,14 +485,15 @@ export default class Masternode {
         txid,
     }) {
         try {
-            const res = await getNetwork().callRPC(
-                `/submitbudget?params=${encodeURI(name)},${encodeURI(
-                    url
-                )},${nPayments},${start},${encodeURI(address)},${
-                    monthlyPayment / COIN
-                },${txid}`,
-                true
-            );
+            const res = await getNetwork().submitProposal({
+                name,
+                url,
+                nPayments,
+                start,
+                address,
+                monthlyPayment: monthlyPayment / COIN,
+                txid,
+            });
 
             if (/^"[a-f0-9]"$/ && res.length === 64 + 2) {
                 return { ok: true, hash: res };
@@ -543,18 +516,6 @@ export default class Masternode {
         }
     }
 
-    static async getNextSuperblock() {
-        return parseInt(await getNetwork().callRPC(`/getnextsuperblock`, true));
-    }
-
-    /**
-     * Fetches the masternode count object, containing each status and network.
-     * @returns {Promise<{total:number, stable:number, enabled:number, inqueue:number, ipv4:number, ipv6:number, onion:number}>} - The masternode count object
-     */
-    static async getMasternodeCount() {
-        return await getNetwork().callRPC('/getmasternodecount');
-    }
-
     /**
      * @param {Object} options
      * @param {String} options.name - Name of the proposal
diff --git a/scripts/mempool.js b/scripts/mempool.js
index a25d72f8a..462651aeb 100644
--- a/scripts/mempool.js
+++ b/scripts/mempool.js
@@ -247,6 +247,14 @@ export class Mempool {
         return Array.from(this.#txmap.values());
     }
 
+    /**
+     * @param {string} txid - transaction id
+     * @returns {import('./transaction.js').Transaction | undefined}
+     */
+    getTransaction(txid) {
+        return this.#txmap.get(txid);
+    }
+
     /**
      * @param blockCount - chain height
      */
diff --git a/scripts/network/network.js b/scripts/network/network.js
index 5e9a383cb..219cf3114 100644
--- a/scripts/network/network.js
+++ b/scripts/network/network.js
@@ -41,23 +41,23 @@ export class Network {
         }
     }
 
-    async getBlock(blockHeight) {
+    async getBlock(_blockHeight) {
         throw new Error('getBlockCount must be implemented');
     }
 
-    async getTxPage(nStartHeight, addr, n) {
+    async getTxPage(_nStartHeight, _addr, _n) {
         throw new Error('getTxPage must be implemented');
     }
 
-    async getNumPages(nStartHeight, addr) {
+    async getNumPages(_nStartHeight, _addr) {
         throw new Error('getNumPages must be implemented');
     }
 
-    async getUTXOs(strAddress) {
+    async getUTXOs(_strAddress) {
         throw new Error('getUTXOs must be implemented');
     }
 
-    async getXPubInfo(strXPUB) {
+    async getXPubInfo(_strXPUB) {
         throw new Error('getXPubInfo must be implemented');
     }
 
@@ -73,7 +73,7 @@ export class Network {
         throw new Error('getBestBlockHash must be implemented');
     }
 
-    async sendTransaction(hex) {
+    async sendTransaction(_hex) {
         throw new Error('sendTransaction must be implemented');
     }
 
@@ -81,10 +81,51 @@ export class Network {
         throw new Error('getTxInfo must be implemented');
     }
 
-    // TODO: this should be just a private function of RPCNodeNetwork
-    // However we use this in masternode.js, let's solve this in a future refactor
-    async callRPC(api, isText = false) {
-        throw new Error('callRPC must be implemented');
+    async getMasternodeInfo(_collateralTxId) {
+        throw new Error('getMasternodeInfo must be implemented');
+    }
+
+    async getMasternodeCount() {
+        throw new Error('getMasternodeCount must be implemented');
+    }
+
+    async getNextSuperblock() {
+        throw new Error('getNextSuperblock must be implemented');
+    }
+
+    async startMasternode(_broadcastMsg) {
+        throw new Error('startMasternode must be implemented');
+    }
+
+    async getProposals() {
+        throw new Error('getProposals must be implemented');
+    }
+
+    async getProposalVote(_proposalName, _collateralTxId, _outidx) {
+        throw new Error('getProposalVote must be implemented');
+    }
+
+    async voteProposal(
+        _collateralTxId,
+        _outidx,
+        _hash,
+        _voteCode,
+        _sigTime,
+        _signature
+    ) {
+        throw new Error('voteProposal must be implemented');
+    }
+
+    async submitProposal({
+        name,
+        url,
+        nPayments,
+        start,
+        address,
+        monthlyPayment,
+        txid,
+    }) {
+        throw new Error('submitProposal must be implemented');
     }
 }
 
@@ -110,9 +151,16 @@ export class RPCNodeNetwork extends Network {
         return fetch(this.strUrl + api, options);
     }
 
-    async callRPC(api, isText = false) {
+    async #callRPC(api, isText = false) {
         const cRes = await this.#fetchNode(api);
-        return isText ? await cRes.text() : await cRes.json();
+        const cResTxt = await cRes.text();
+        if (isText) return cResTxt;
+        // RPC calls with filters might return empty string instead of empty JSON,
+        // In that case return an empty object
+        if (cResTxt.length === 0) {
+            return {};
+        }
+        return await JSON.parse(cResTxt);
     }
 
     /**
@@ -123,7 +171,7 @@ export class RPCNodeNetwork extends Network {
     async getBlock(blockHeight) {
         // First we fetch the blockhash (and strip RPC's quotes)
         const strHash = (
-            await this.callRPC(`/getblockhash?params=${blockHeight}`, true)
+            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 =
@@ -132,7 +180,7 @@ export class RPCNodeNetwork extends Network {
                 `. | .txs = [.tx[] | { hex: .hex, txid: .txid}] | del(.tx)`
             );
         // Fetch the full block (verbose)
-        return await this.callRPC(`/getblock?params=${strHash},2${strFilter}`);
+        return await this.#callRPC(`/getblock?params=${strHash},2${strFilter}`);
     }
 
     /**
@@ -140,16 +188,16 @@ export class RPCNodeNetwork extends Network {
      * @returns {Promise<number>} - Block height
      */
     async getBlockCount() {
-        return parseInt(await this.callRPC('/getblockcount', true));
+        return parseInt(await this.#callRPC('/getblockcount', true));
     }
 
     async getBestBlockHash() {
-        return await this.callRPC('/getbestblockhash', true);
+        return await this.#callRPC('/getbestblockhash', true);
     }
 
     async sendTransaction(hex) {
         // Use Nodes as a fallback
-        let strTXID = await this.callRPC(
+        let strTXID = await this.#callRPC(
             '/sendrawtransaction?params=' + hex,
             true
         );
@@ -161,7 +209,111 @@ export class RPCNodeNetwork extends Network {
      * @return {Promise<Number[]>} The list of blocks which have at least one shield transaction
      */
     async getShieldBlockList() {
-        return await this.callRPC('/getshieldblocks');
+        return await this.#callRPC('/getshieldblocks');
+    }
+
+    /**
+     * @param{string} collateralTxId - masternode collateral transaction id
+     * @param{number} outidx - masternode collateral output index
+     */
+    async getMasternodeInfo(collateralTxId, outidx) {
+        return (
+            await this.#callRPC(`/listmasternodes?params=${collateralTxId}`)
+        ).filter((m) => m.outidx === outidx);
+    }
+
+    async getMasternodeCount() {
+        return await this.#callRPC('/getmasternodecount');
+    }
+
+    /**
+     * @returns {Promise<number>} the block height of the next superblock
+     */
+    async getNextSuperblock() {
+        return parseInt(await this.#callRPC(`/getnextsuperblock`, true));
+    }
+
+    /**
+     * @param {string} broadcastMsg
+     */
+    async startMasternode(broadcastMsg) {
+        return await this.#callRPC(
+            `/relaymasternodebroadcast?params=${broadcastMsg}`,
+            true
+        );
+    }
+
+    async getProposals() {
+        return (await this.#callRPC(`/getbudgetinfo`)).filter(
+            (a) => a.RemainingPaymentCount > 0
+        );
+    }
+
+    /**
+     * Returns the proposal vote of a given masternode
+     * @param {string} proposalName - name of the proposal
+     * @param{string} collateralTxId - masternode collateral transaction id
+     * @param{number} outidx - masternode collateral output index
+     */
+    async getProposalVote(proposalName, collateralTxId, outidx) {
+        const filterString = `.[] | select(.mnId=="`;
+        const filter =
+            `${encodeURI(filterString)}` + `${collateralTxId}-${outidx}")`;
+        return await this.#callRPC(
+            `/getbudgetvotes?params=${proposalName}&filter=${filter}`
+        );
+    }
+
+    /**
+     * @param {string} collateralTxId - masternode collateral transaction id
+     * @param {number} outidx - masternode collateral output index
+     * @param {string} hash - the hash of the proposal to vote
+     * @param {number} voteCode - the vote code. "Yes" is 1, "No" is 2
+     * @param {number} sigTime - vote signature time
+     * @param {string} signature - vote signature
+     */
+    async voteProposal(
+        collateralTxId,
+        outidx,
+        hash,
+        voteCode,
+        sigTime,
+        signature
+    ) {
+        const url = `/mnbudgetrawvote?params=${collateralTxId},${outidx},${hash},${
+            voteCode === 1 ? 'yes' : 'no'
+        },${sigTime},${signature}`;
+        return await this.#callRPC(url, true);
+    }
+
+    /**
+     * Submit a proposal
+     * @param {Object} options
+     * @param {String} options.name - Name of the proposal
+     * @param {String} options.url - Url of the proposal
+     * @param {Number} options.nPayments - Number of cycles this proposal is gonna last
+     * @param {Number} options.start - Superblock of when the proposal is going to start
+     * @param {String} options.address - Base58 encoded PIVX address
+     * @param {Number} options.monthlyPayment - Payment amount per cycle in satoshi
+     * @param {String} options.txid - Transaction id of the proposal fee
+     */
+    async submitProposal({
+        name,
+        url,
+        nPayments,
+        start,
+        address,
+        monthlyPayment,
+        txid,
+    }) {
+        return await this.#callRPC(
+            `/submitbudget?params=${encodeURI(name)},${encodeURI(
+                url
+            )},${nPayments},${start},${encodeURI(
+                address
+            )},${monthlyPayment},${txid}`,
+            true
+        );
     }
 }
 
diff --git a/scripts/network/network_manager.js b/scripts/network/network_manager.js
index 6a2a37f6b..c12981b0b 100644
--- a/scripts/network/network_manager.js
+++ b/scripts/network/network_manager.js
@@ -87,7 +87,11 @@ class NetworkManager {
             } catch (error) {
                 debugLog(
                     DebugTopics.NET,
-                    attemptNet.strUrl + ' failed on ' + funcName
+                    attemptNet.strUrl +
+                        ' failed on ' +
+                        funcName +
+                        ' with error ' +
+                        error
                 );
                 // If allowed, switch instances
                 if (!fAutoSwitch || attempts === nMaxTries) {
@@ -174,12 +178,112 @@ class NetworkManager {
         }
     }
 
-    async getTxInfo(_txHash) {
-        return await this.#retryWrapper('getTxInfo', false, _txHash);
+    async getTxInfo(txHash) {
+        return await this.#retryWrapper('getTxInfo', false, txHash);
     }
 
-    async callRPC(api, isText = false) {
-        return await this.#retryWrapper('callRPC', true, api, isText);
+    /**
+     * @param{string} collateralTxId - masternode collateral transaction id
+     * @param{number} outidx - masternode collateral output index
+     */
+    async getMasternodeInfo(collateralTxId, outidx) {
+        return await this.#retryWrapper(
+            'getMasternodeInfo',
+            true,
+            collateralTxId,
+            outidx
+        );
+    }
+
+    async getMasternodeCount() {
+        return await this.#retryWrapper('getMasternodeCount', true);
+    }
+
+    async getNextSuperblock() {
+        return await this.#retryWrapper('getNextSuperblock', true);
+    }
+
+    async startMasternode(broadcastMsg) {
+        return await this.#retryWrapper('startMasternode', true, broadcastMsg);
+    }
+
+    async getProposals() {
+        return await this.#retryWrapper('getProposals', true);
+    }
+
+    /**
+     * Returns the proposal vote of a given masternode
+     * @param {string} proposalName - name of the proposal
+     * @param{string} collateralTxId - masternode collateral transaction id
+     * @param{number} outidx - masternode collateral output index
+     */
+    async getProposalVote(proposalName, collateralTxId, outidx) {
+        return await this.#retryWrapper(
+            'getProposalVote',
+            true,
+            proposalName,
+            collateralTxId,
+            outidx
+        );
+    }
+
+    /**
+     * @param {string} collateralTxId - masternode collateral transaction id
+     * @param {number} outidx - masternode collateral output index
+     * @param {string} hash - the hash of the proposal to vote
+     * @param {number} voteCode - the vote code. "Yes" is 1, "No" is 2
+     * @param {number} sigTime - vote signature time
+     * @param {string} signature - vote signature
+     */
+    async voteProposal(
+        collateralTxId,
+        outidx,
+        hash,
+        voteCode,
+        sigTime,
+        signature
+    ) {
+        return await this.#retryWrapper(
+            'voteProposal',
+            true,
+            collateralTxId,
+            outidx,
+            hash,
+            voteCode,
+            sigTime,
+            signature
+        );
+    }
+
+    /**
+     * Submit a proposal
+     * @param {Object} options
+     * @param {String} options.name - Name of the proposal
+     * @param {String} options.url - Url of the proposal
+     * @param {Number} options.nPayments - Number of cycles this proposal is gonna last
+     * @param {Number} options.start - Superblock of when the proposal is going to start
+     * @param {String} options.address - Base58 encoded PIVX address
+     * @param {Number} options.monthlyPayment - Payment amount per cycle in satoshi
+     * @param {String} options.txid - Transaction id of the proposal fee
+     */
+    async submitProposal({
+        name,
+        url,
+        nPayments,
+        start,
+        address,
+        monthlyPayment,
+        txid,
+    }) {
+        return await this.#retryWrapper('submitProposal', true, {
+            name,
+            url,
+            nPayments,
+            start,
+            address,
+            monthlyPayment,
+            txid,
+        });
     }
 
     static #instance = new NetworkManager();
diff --git a/scripts/prices.js b/scripts/prices.js
index 3cf0b3305..c21406107 100644
--- a/scripts/prices.js
+++ b/scripts/prices.js
@@ -125,7 +125,7 @@ export class Oracle {
         // Update any listeners for the full currency list (Settings, etc)
         getEventEmitter().emit('currency-loaded', this.mapCurrencies);
         // Update the balance to render the price instantly
-        getEventEmitter().emit('balance-update');
+        getEventEmitter().emit('price-update');
     }
 }
 
diff --git a/scripts/settings.js b/scripts/settings.js
index b21a712f0..eb042ba69 100644
--- a/scripts/settings.js
+++ b/scripts/settings.js
@@ -265,7 +265,7 @@ async function setCurrency(currency) {
     const database = await Database.getInstance();
     database.setSettings({ displayCurrency: strCurrency });
     // Update the UI to reflect the new currency
-    getEventEmitter().emit('balance-update');
+    getEventEmitter().emit('price-update');
 }
 
 /**
@@ -277,7 +277,7 @@ async function setDecimals(decimals) {
     const database = await Database.getInstance();
     database.setSettings({ displayDecimals: nDisplayDecimals });
     // Update the UI to reflect the new decimals
-    getEventEmitter().emit('balance-update');
+    getEventEmitter().emit('price-update');
 }
 
 /**
diff --git a/scripts/wallet.js b/scripts/wallet.js
index b7411504f..b098633cc 100644
--- a/scripts/wallet.js
+++ b/scripts/wallet.js
@@ -105,6 +105,12 @@ export class Wallet {
      * @type {number}
      */
     #lastProcessedBlock = 0;
+    /**
+     * Array of historical txs, ordered by block height
+     * @type HistoricalTx[]
+     */
+    #historicalTxs;
+
     constructor({ nAccount, masterKey, shield, mempool = new Mempool() }) {
         this.#nAccount = nAccount;
         this.#mempool = mempool;
@@ -253,6 +259,7 @@ export class Wallet {
         }
         this.#mempool = new Mempool();
         this.#lastProcessedBlock = 0;
+        this.#historicalTxs = [];
     }
 
     /**
@@ -680,10 +687,6 @@ export class Wallet {
             } else if (nAmount + nShieldAmount < 0) {
                 type = HistoricalTxType.SENT;
             }
-            const isCoinSpecial = tx.isCoinStake() || tx.isCoinBase();
-            const isConfirmed =
-                blockCount - tx.blockHeight >=
-                (isCoinSpecial ? cChainParams.current.coinbaseMaturity : 6);
 
             histTXs.push(
                 new HistoricalTx(
@@ -695,8 +698,7 @@ export class Wallet {
                     tx.blockHeight,
                     nAmount,
                     nShieldAmount,
-                    ownAllVin && ownAllVout && ownAllShield,
-                    isConfirmed
+                    ownAllVin && ownAllVout && ownAllShield
                 )
             );
         }
@@ -731,6 +733,31 @@ export class Wallet {
         }
         return { shieldCredit, shieldDebit, arrShieldReceivers };
     }
+    /*
+     * @param {Transaction} tx
+     */
+    async #pushToHistoricalTx(tx) {
+        const historicalTx = (await this.toHistoricalTXs([tx]))[0];
+        let prevHeight = Number.POSITIVE_INFINITY;
+        for (const [i, hTx] of this.#historicalTxs.entries()) {
+            if (
+                historicalTx.blockHeight <= prevHeight &&
+                historicalTx.blockHeight >= hTx.blockHeight
+            ) {
+                this.#historicalTxs.splice(i, 0, historicalTx);
+                return;
+            }
+            prevHeight = hTx.blockHeight;
+        }
+        this.#historicalTxs.push(historicalTx);
+    }
+
+    /**
+     * @returns {HistoricalTx[]}
+     */
+    getHistoricalTxs() {
+        return this.#historicalTxs;
+    }
     sync = lockableFunction(async () => {
         if (this.#isSynced) {
             throw new Error('Attempting to sync when already synced');
@@ -750,6 +777,9 @@ export class Wallet {
             await this.#syncShield();
         }
         this.#isSynced = true;
+        // At this point download the last missing blocks in the range (blockCount -5, blockCount]
+        await this.getLatestBlocks(blockCount);
+
         // Update both activities post sync
         getEventEmitter().enableEvent('balance-update');
         getEventEmitter().emit('balance-update');
@@ -761,7 +791,7 @@ export class Wallet {
         const cNet = getNetwork();
         const addr = this.getKeyToExport();
         let nStartHeight = Math.max(
-            ...this.getTransactions().map((tx) => tx.blockHeight)
+            ...this.#mempool.getTransactions().map((tx) => tx.blockHeight)
         );
         // Compute the total pages and iterate through them until we've synced everything
         const totalPages = await cNet.getNumPages(nStartHeight, addr);
@@ -882,9 +912,9 @@ export class Wallet {
     subscribeToNetworkEvents() {
         getEventEmitter().on('new-block', async (block) => {
             if (this.#isSynced) {
+                await this.getLatestBlocks(block);
                 // Invalidate the balance cache to keep immature balance updated
                 this.#mempool.invalidateBalanceCache();
-                await this.getLatestBlocks(block);
                 getEventEmitter().emit('new-tx');
             }
         });
@@ -897,11 +927,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;
+                blockHeight <= blockCount;
                 blockHeight++
             ) {
                 try {
@@ -1201,6 +1229,7 @@ export class Wallet {
      * @param {import('./transaction.js').Transaction} transaction
      */
     async addTransaction(transaction, skipDatabase = false) {
+        const tx = this.#mempool.getTransaction(transaction.txid);
         this.#mempool.addTransaction(transaction);
         let i = 0;
         for (const out of transaction.vout) {
@@ -1226,6 +1255,11 @@ export class Wallet {
             const db = await Database.getInstance();
             await db.storeTx(transaction);
         }
+        if (!tx || tx.blockHeight === -1) {
+            // Do not add unconfirmed txs to history
+            if (transaction.blockHeight !== -1)
+                await this.#pushToHistoricalTx(transaction);
+        }
     }
 
     /**
@@ -1295,13 +1329,6 @@ export class Wallet {
             .filter((u) => u.value === collateralValue);
     }
 
-    /**
-     * @returns {import('./transaction.js').Transaction[]} a list of all transactions
-     */
-    getTransactions() {
-        return this.#mempool.getTransactions();
-    }
-
     get balance() {
         return this.#mempool.getBalance(blockCount);
     }
diff --git a/tests/components/TransferMenu.test.js b/tests/components/TransferMenu.test.js
index 14e6439e8..ef81c4201 100644
--- a/tests/components/TransferMenu.test.js
+++ b/tests/components/TransferMenu.test.js
@@ -1,6 +1,6 @@
 import 'fake-indexeddb/auto';
 import { mount } from '@vue/test-utils';
-import { nextTick, ref } from 'vue';
+import { nextTick } from 'vue';
 import { expect, describe, vi } from 'vitest';
 import TransferMenu from '../../scripts/dashboard/TransferMenu.vue';
 const price = 0.4;
@@ -14,7 +14,7 @@ const mountTM = (amount = '123', address = '') => {
             address,
 
             'onUpdate:amount': (e) => wrapper.setProps({ amount: e }),
-            shieldEnabled: true,
+            publicMode: true,
         },
     });
     return wrapper;
diff --git a/tests/integration/wallet/sync.spec.js b/tests/integration/wallet/sync.spec.js
index 158820453..f8b646769 100644
--- a/tests/integration/wallet/sync.spec.js
+++ b/tests/integration/wallet/sync.spec.js
@@ -76,11 +76,7 @@ describe('Wallet sync tests', () => {
         );
         // Mint the block with the transaction
         await mineAndSync();
-        // getLatestBlocks sync up until chain tip - 1 block,
-        // so at this point walletHD doesn't still know about the UTXO he received
-        expect(walletHD.balance).toBe(1 * 10 ** 8);
-        // mine an empty block and verify that the tx arrived
-        await mineAndSync();
+        // getLatestBlocks sync up until the actual chain tip
         expect(walletHD.balance).toBe((1 + 0.05) * 10 ** 8);
 
         // Sends funds back to the legacy wallet and verify that he also correctly receives funds
@@ -102,7 +98,7 @@ describe('Wallet sync tests', () => {
         let nAddress = 0;
         // So according to BIP32 standard
         // wallets must be aware of addresses up to nAddress + MAX_ACCOUNT_GAP
-        for (let i = 0; i < 5; i++) {
+        for (let i = 1; i <= 5; i++) {
             nAddress += 20;
             let newAddress = walletHD.getAddressFromPath(
                 path.slice(0, -1) + String(nAddress)
@@ -114,10 +110,7 @@ describe('Wallet sync tests', () => {
                 0.01 * 10 ** 8
             );
             await mineAndSync();
-            // Validate the balance of the HD wallet pre-tx-confirm
             expect(walletHD.balance).toBe((1 + 0.01 * i) * 10 ** 8);
-            // Mine a block with the Tx
-            await mineAndSync();
         }
     });
     it('recognizes immature balance', async () => {