From eff68541d7adb01e4947ad67c57235bf521766ad Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Thu, 26 Jan 2023 15:34:33 +0000
Subject: [PATCH] Make CHistoryWriter a member of CCuscomCSView

---
 src/Makefile.am                             |   2 +
 src/consensus/tx_verify.cpp                 |   2 +-
 src/masternodes/accountshistory.cpp         | 136 ++-----------
 src/masternodes/accountshistory.h           |  82 +-------
 src/masternodes/govvariables/attributes.cpp |  19 +-
 src/masternodes/historywriter.cpp           | 212 ++++++++++++++++++++
 src/masternodes/historywriter.h             | 133 ++++++++++++
 src/masternodes/masternodes.cpp             |  36 +---
 src/masternodes/masternodes.h               |  19 +-
 src/masternodes/mn_checks.cpp               |  83 ++++----
 src/masternodes/mn_checks.h                 |   6 +-
 src/masternodes/rpc_tokens.cpp              |   7 +-
 src/masternodes/validation.cpp              |  79 +++-----
 src/validation.cpp                          | 135 ++-----------
 test/lint/lint-circular-dependencies.sh     |   7 +-
 15 files changed, 493 insertions(+), 465 deletions(-)
 create mode 100644 src/masternodes/historywriter.cpp
 create mode 100644 src/masternodes/historywriter.h

diff --git a/src/Makefile.am b/src/Makefile.am
index b47b23bac9..6e346a9b93 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -167,6 +167,7 @@ DEFI_CORE_H = \
   masternodes/govvariables/oracle_block_interval.h \
   masternodes/govvariables/oracle_deviation.h \
   masternodes/gv.h \
+  masternodes/historywriter.h \
   masternodes/icxorder.h \
   masternodes/incentivefunding.h \
   masternodes/loan.h \
@@ -389,6 +390,7 @@ libdefi_server_a_SOURCES = \
   masternodes/govvariables/oracle_block_interval.cpp \
   masternodes/govvariables/oracle_deviation.cpp \
   masternodes/gv.cpp \
+  masternodes/historywriter.cpp \
   masternodes/icxorder.cpp \
   masternodes/incentivefunding.cpp \
   masternodes/loan.cpp \
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 3ed6dd187e..3beafe4a54 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -175,7 +175,7 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, c
     const auto txType = GuessCustomTxType(tx, dummy);
 
     if (NotAllowedToFail(txType, nSpendHeight) || (nSpendHeight >= chainparams.GetConsensus().GrandCentralHeight && txType == CustomTxType::UpdateMasternode)) {
-        CCustomCSView discardCache(mnview);
+        CCustomCSView discardCache(mnview, nullptr, nullptr, nullptr);
         auto res = ApplyCustomTx(discardCache, inputs, tx, chainparams.GetConsensus(), nSpendHeight, 0, &canSpend);
         if (!res.ok && (res.code & CustomTxErrCodes::Fatal)) {
             return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-customtx", res.msg);
diff --git a/src/masternodes/accountshistory.cpp b/src/masternodes/accountshistory.cpp
index 607dfd6a57..56a1caa874 100644
--- a/src/masternodes/accountshistory.cpp
+++ b/src/masternodes/accountshistory.cpp
@@ -5,38 +5,9 @@
 #include <key_io.h>
 #include <masternodes/accounts.h>
 #include <masternodes/accountshistory.h>
-#include <masternodes/masternodes.h>
+#include <masternodes/historywriter.h>
 #include <masternodes/vaulthistory.h>
 
-struct AccountHistoryKeyNew {
-    uint32_t blockHeight;
-    CScript owner;
-    uint32_t txn;  // for order in block
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream &s, Operation ser_action) {
-        if (ser_action.ForRead()) {
-            READWRITE(WrapBigEndian(blockHeight));
-            blockHeight = ~blockHeight;
-        } else {
-            uint32_t blockHeight_ = ~blockHeight;
-            READWRITE(WrapBigEndian(blockHeight_));
-        }
-
-        READWRITE(owner);
-
-        if (ser_action.ForRead()) {
-            READWRITE(WrapBigEndian(txn));
-            txn = ~txn;
-        } else {
-            uint32_t txn_ = ~txn;
-            READWRITE(WrapBigEndian(txn_));
-        }
-    }
-};
-
 static AccountHistoryKeyNew Convert(const AccountHistoryKey &key) {
     return {key.blockHeight, key.owner, key.txn};
 }
@@ -90,10 +61,9 @@ std::optional<AccountHistoryValue> CAccountsHistoryView::ReadAccountHistory(cons
     return ReadBy<ByAccountHistoryKey, AccountHistoryValue>(key);
 }
 
-Res CAccountsHistoryView::WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value) {
+void CAccountsHistoryView::WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value) {
     WriteBy<ByAccountHistoryKey>(key, value);
     WriteBy<ByAccountHistoryKeyNew>(Convert(key), '\0');
-    return Res::Ok();
 }
 
 Res CAccountsHistoryView::EraseAccountHistory(const AccountHistoryKey &key) {
@@ -126,19 +96,23 @@ CAccountsHistoryWriter::CAccountsHistoryWriter(CCustomCSView &storage,
                                                uint32_t height,
                                                uint32_t txn,
                                                const uint256 &txid,
-                                               uint8_t type,
-                                               CHistoryWriters *writers)
+                                               uint8_t type)
     : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV &>(storage.GetStorage()))),
       height(height),
       txn(txn),
       txid(txid),
       type(type),
-      writers(writers) {}
+      writers(storage.GetHistoryWriters()) {
+}
+
+CAccountsHistoryWriter::~CAccountsHistoryWriter() {
+    writers.ClearState();
+}
 
 Res CAccountsHistoryWriter::AddBalance(const CScript &owner, CTokenAmount amount) {
     auto res = CCustomCSView::AddBalance(owner, amount);
-    if (writers && amount.nValue != 0 && res.ok) {
-        writers->AddBalance(owner, amount, vaultID);
+    if (amount.nValue != 0 && res.ok) {
+        writers.AddBalance(owner, amount, vaultID);
     }
 
     return res;
@@ -146,99 +120,17 @@ Res CAccountsHistoryWriter::AddBalance(const CScript &owner, CTokenAmount amount
 
 Res CAccountsHistoryWriter::SubBalance(const CScript &owner, CTokenAmount amount) {
     auto res = CCustomCSView::SubBalance(owner, amount);
-    if (writers && res.ok && amount.nValue != 0) {
-        writers->SubBalance(owner, amount, vaultID);
+    if (res.ok && amount.nValue != 0) {
+        writers.SubBalance(owner, amount, vaultID);
     }
 
     return res;
 }
 
 bool CAccountsHistoryWriter::Flush() {
-    if (writers) {
-        writers->Flush(height, txid, txn, type, vaultID);
-    }
+    writers.Flush(height, txid, txn, type, vaultID);
     return CCustomCSView::Flush();
 }
 
-CAccountHistoryStorage *CAccountsHistoryWriter::GetAccountHistoryStore() {
-    return writers ? writers->GetAccountHistoryStore() : nullptr;
-};
-
-CHistoryWriters::CHistoryWriters(CAccountHistoryStorage *historyView,
-                                 CBurnHistoryStorage *burnView,
-                                 CVaultHistoryStorage *vaultView)
-    : historyView(historyView),
-      burnView(burnView),
-      vaultView(vaultView) {}
-
-extern std::string ScriptToString(const CScript &script);
-
-void CHistoryWriters::AddBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID) {
-    if (historyView) {
-        diffs[owner][amount.nTokenId] += amount.nValue;
-    }
-    if (burnView && owner == Params().GetConsensus().burnAddress) {
-        burnDiffs[owner][amount.nTokenId] += amount.nValue;
-    }
-    if (vaultView && !vaultID.IsNull()) {
-        vaultDiffs[vaultID][owner][amount.nTokenId] += amount.nValue;
-    }
-}
-
-void CHistoryWriters::AddFeeBurn(const CScript &owner, const CAmount amount) {
-    if (burnView && amount != 0) {
-        burnDiffs[owner][DCT_ID{0}] += amount;
-    }
-}
-
-void CHistoryWriters::SubBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID) {
-    if (historyView) {
-        diffs[owner][amount.nTokenId] -= amount.nValue;
-    }
-    if (burnView && owner == Params().GetConsensus().burnAddress) {
-        burnDiffs[owner][amount.nTokenId] -= amount.nValue;
-    }
-    if (vaultView && !vaultID.IsNull()) {
-        vaultDiffs[vaultID][owner][amount.nTokenId] -= amount.nValue;
-    }
-}
-
-void CHistoryWriters::Flush(const uint32_t height,
-                            const uint256 &txid,
-                            const uint32_t txn,
-                            const uint8_t type,
-                            const uint256 &vaultID) {
-    if (historyView) {
-        for (const auto &diff : diffs) {
-            LogPrint(BCLog::ACCOUNTCHANGE,
-                     "AccountChange: txid=%s addr=%s change=%s\n",
-                     txid.GetHex(),
-                     ScriptToString(diff.first),
-                     (CBalances{diff.second}.ToString()));
-            historyView->WriteAccountHistory({diff.first, height, txn}, {txid, type, diff.second});
-        }
-    }
-    if (burnView) {
-        for (const auto &diff : burnDiffs) {
-            burnView->WriteAccountHistory({diff.first, height, txn}, {txid, type, diff.second});
-        }
-    }
-    if (vaultView) {
-        for (const auto &diff : vaultDiffs) {
-            for (const auto &addresses : diff.second) {
-                vaultView->WriteVaultHistory({height, diff.first, txn, addresses.first},
-                                             {txid, type, addresses.second});
-            }
-        }
-        if (!schemeID.empty()) {
-            vaultView->WriteVaultScheme({vaultID, height}, {type, txid, schemeID, txn});
-        }
-        if (!globalLoanScheme.identifier.empty()) {
-            vaultView->WriteGlobalScheme({height, txn, globalLoanScheme.schemeCreationTxid},
-                                         {globalLoanScheme, type, txid});
-        }
-    }
-}
-
 std::unique_ptr<CAccountHistoryStorage> paccountHistoryDB;
 std::unique_ptr<CBurnHistoryStorage> pburnHistoryDB;
diff --git a/src/masternodes/accountshistory.h b/src/masternodes/accountshistory.h
index 4e5c53343f..c04fb1a93a 100644
--- a/src/masternodes/accountshistory.h
+++ b/src/masternodes/accountshistory.h
@@ -12,55 +12,18 @@
 #include <script/script.h>
 #include <uint256.h>
 
+class CHistoryWriters;
 class CVaultHistoryView;
 class CVaultHistoryStorage;
-
-struct AccountHistoryKey {
-    CScript owner;
-    uint32_t blockHeight;
-    uint32_t txn;  // for order in block
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream &s, Operation ser_action) {
-        READWRITE(owner);
-
-        if (ser_action.ForRead()) {
-            READWRITE(WrapBigEndian(blockHeight));
-            blockHeight = ~blockHeight;
-            READWRITE(WrapBigEndian(txn));
-            txn = ~txn;
-        } else {
-            uint32_t blockHeight_ = ~blockHeight;
-            READWRITE(WrapBigEndian(blockHeight_));
-            uint32_t txn_ = ~txn;
-            READWRITE(WrapBigEndian(txn_));
-        }
-    }
-};
-
-struct AccountHistoryValue {
-    uint256 txid;
-    unsigned char category;
-    TAmounts diff;
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream &s, Operation ser_action) {
-        READWRITE(txid);
-        READWRITE(category);
-        READWRITE(diff);
-    }
-};
+struct VaultHistoryKey;
+struct VaultHistoryValue;
 
 class CAccountsHistoryView : public virtual CStorageView {
 public:
     void CreateMultiIndexIfNeeded();
     Res EraseAccountHistoryHeight(uint32_t height);
     [[nodiscard]] std::optional<AccountHistoryValue> ReadAccountHistory(const AccountHistoryKey &key) const;
-    Res WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value);
+    void WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value);
     Res EraseAccountHistory(const AccountHistoryKey &key);
     void ForEachAccountHistory(std::function<bool(const AccountHistoryKey &, AccountHistoryValue)> callback,
                                const CScript &owner = {},
@@ -88,40 +51,12 @@ class CBurnHistoryStorage : public CAccountsHistoryView {
     CBurnHistoryStorage(const fs::path &dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
 };
 
-class CHistoryWriters {
-    CAccountHistoryStorage *historyView{};
-    CBurnHistoryStorage *burnView{};
-    std::map<CScript, TAmounts> diffs;
-    std::map<CScript, TAmounts> burnDiffs;
-    std::map<uint256, std::map<CScript, TAmounts>> vaultDiffs;
-
-public:
-    CVaultHistoryStorage *vaultView{};
-    CLoanSchemeCreation globalLoanScheme;
-    std::string schemeID;
-
-    CHistoryWriters(CAccountHistoryStorage *historyView,
-                    CBurnHistoryStorage *burnView,
-                    CVaultHistoryStorage *vaultView);
-
-    CAccountHistoryStorage *GetAccountHistoryStore() { return historyView; };
-
-    void AddBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID);
-    void AddFeeBurn(const CScript &owner, const CAmount amount);
-    void SubBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID);
-    void Flush(const uint32_t height,
-               const uint256 &txid,
-               const uint32_t txn,
-               const uint8_t type,
-               const uint256 &vaultID);
-};
-
 class CAccountsHistoryWriter : public CCustomCSView {
     const uint32_t height;
     const uint32_t txn;
     const uint256 txid;
     const uint8_t type;
-    CHistoryWriters *writers{};
+    CHistoryWriters& writers;
 
 public:
     uint256 vaultID;
@@ -130,13 +65,12 @@ class CAccountsHistoryWriter : public CCustomCSView {
                            uint32_t height,
                            uint32_t txn,
                            const uint256 &txid,
-                           uint8_t type,
-                           CHistoryWriters *writers);
+                           uint8_t type);
+    ~CAccountsHistoryWriter() override;
     Res AddBalance(const CScript &owner, CTokenAmount amount) override;
     Res SubBalance(const CScript &owner, CTokenAmount amount) override;
     bool Flush() override;
-
-    CAccountHistoryStorage *GetAccountHistoryStore() override;
+    CHistoryWriters& GetHistoryWriters() override { return writers; }
 };
 
 extern std::unique_ptr<CAccountHistoryStorage> paccountHistoryDB;
diff --git a/src/masternodes/govvariables/attributes.cpp b/src/masternodes/govvariables/attributes.cpp
index fa4c593833..91b3f2f798 100644
--- a/src/masternodes/govvariables/attributes.cpp
+++ b/src/masternodes/govvariables/attributes.cpp
@@ -6,6 +6,7 @@
 #include <masternodes/mn_rpc.h>
 
 #include <masternodes/accountshistory.h>  /// CAccountsHistoryWriter
+#include <masternodes/historywriter.h>    /// CHiistoryWriter
 #include <masternodes/masternodes.h>      /// CCustomCSView
 #include <masternodes/mn_checks.h>        /// GetAggregatePrice / CustomTxType
 #include <validation.h>                   /// GetNextAccPosition
@@ -878,22 +879,16 @@ Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t hei
     CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2203Current};
     auto balances = GetValue(liveKey, CBalances{});
 
-    CAccountHistoryStorage *historyStore{mnview.GetAccountHistoryStore()};
     const auto currentHeight = mnview.GetLastHeight() + 1;
 
     for (const auto &[key, value] : userFuturesValues) {
         mnview.EraseFuturesUserValues(key);
-
-        CHistoryWriters subWriters{historyStore, nullptr, nullptr};
-        CAccountsHistoryWriter subView(
-            mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
+        CAccountsHistoryWriter subView(mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
 
         Require(subView.SubBalance(*contractAddressValue, value.source));
         subView.Flush();
 
-        CHistoryWriters addWriters{historyStore, nullptr, nullptr};
-        CAccountsHistoryWriter addView(
-            mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
+        CAccountsHistoryWriter addView(mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
 
         Require(addView.AddBalance(key.owner, value.source));
         addView.Flush();
@@ -933,18 +928,14 @@ Res ATTRIBUTES::RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height)
     for (const auto &[key, amount] : userFuturesValues) {
         mnview.EraseFuturesDUSD(key);
 
-        CHistoryWriters subWriters{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter subView(
-            mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
+        CAccountsHistoryWriter subView(mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
         auto res = subView.SubBalance(*contractAddressValue, {DCT_ID{}, amount});
         if (!res) {
             return res;
         }
         subView.Flush();
 
-        CHistoryWriters addWriters{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter addView(
-            mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
+        CAccountsHistoryWriter addView(mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
         res = addView.AddBalance(key.owner, {DCT_ID{}, amount});
         if (!res) {
             return res;
diff --git a/src/masternodes/historywriter.cpp b/src/masternodes/historywriter.cpp
new file mode 100644
index 0000000000..0783f4bdb3
--- /dev/null
+++ b/src/masternodes/historywriter.cpp
@@ -0,0 +1,212 @@
+// Copyright (c) DeFi Blockchain Developers
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+#include <masternodes/accountshistory.h>
+#include <masternodes/historywriter.h>
+#include <masternodes/masternodes.h>
+#include <masternodes/vaulthistory.h>
+
+extern std::string ScriptToString(const CScript &script);
+
+
+CHistoryWriters::CHistoryWriters(CAccountHistoryStorage *historyView,
+                                 CBurnHistoryStorage *burnView,
+                                 CVaultHistoryStorage *vaultView)
+        : historyView(historyView),
+          burnView(burnView),
+          vaultView(vaultView) {}
+
+
+
+void CHistoryWriters::AddBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID) {
+    if (historyView) {
+        diffs[owner][amount.nTokenId] += amount.nValue;
+    }
+    if (burnView && owner == Params().GetConsensus().burnAddress) {
+        burnDiffs[owner][amount.nTokenId] += amount.nValue;
+    }
+    if (vaultView && !vaultID.IsNull()) {
+        vaultDiffs[vaultID][owner][amount.nTokenId] += amount.nValue;
+    }
+}
+
+void CHistoryWriters::AddFeeBurn(const CScript &owner, const CAmount amount) {
+    if (burnView && amount != 0) {
+        burnDiffs[owner][DCT_ID{0}] += amount;
+    }
+}
+
+void CHistoryWriters::SubBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID) {
+    if (historyView) {
+        diffs[owner][amount.nTokenId] -= amount.nValue;
+    }
+    if (burnView && owner == Params().GetConsensus().burnAddress) {
+        burnDiffs[owner][amount.nTokenId] -= amount.nValue;
+    }
+    if (vaultView && !vaultID.IsNull()) {
+        vaultDiffs[vaultID][owner][amount.nTokenId] -= amount.nValue;
+    }
+}
+
+void CHistoryWriters::Flush(const uint32_t height,
+                            const uint256 &txid,
+                            const uint32_t txn,
+                            const uint8_t type,
+                            const uint256 &vaultID) {
+    if (historyView) {
+        for (const auto& [owner, amounts] : diffs) {
+            LogPrint(BCLog::ACCOUNTCHANGE,
+                     "AccountChange: txid=%s addr=%s change=%s\n",
+                     txid.GetHex(),
+                     ScriptToString(owner),
+                     (CBalances{amounts}.ToString()));
+            historyView->WriteAccountHistory({owner, height, txn}, {txid, type, amounts});
+        }
+    }
+    if (burnView) {
+        for (const auto& [owner, amounts] : burnDiffs) {
+            burnView->WriteAccountHistory({owner, height, txn}, {txid, type, amounts});
+        }
+    }
+    if (vaultView) {
+        for (const auto& [vaultID, ownerMap] : vaultDiffs) {
+            for (const auto& [owner, amounts] : ownerMap) {
+                vaultView->WriteVaultHistory({height, vaultID, txn, owner},
+                                             {txid, type, amounts});
+            }
+        }
+        if (!schemeID.empty()) {
+            vaultView->WriteVaultScheme({vaultID, height}, {type, txid, schemeID, txn});
+        }
+        if (!globalLoanScheme.identifier.empty()) {
+            vaultView->WriteGlobalScheme({height, txn, globalLoanScheme.schemeCreationTxid},
+                                         {globalLoanScheme, type, txid});
+        }
+    }
+
+    // Wipe state after flushing
+    ClearState();
+}
+
+void CHistoryWriters::ClearState() {
+    burnDiffs.clear();
+    diffs.clear();
+    globalLoanScheme.identifier.clear();
+    schemeID.clear();
+    vaultDiffs.clear();
+}
+
+void CHistoryWriters::EraseHistory(uint32_t height, std::vector<AccountHistoryKey> &eraseBurnEntries) {
+    if (historyView) {
+        historyView->EraseAccountHistoryHeight(height);
+    }
+
+    if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHeight)) {
+        // erase auction fee history
+        if (historyView) {
+            historyView->EraseAuctionHistoryHeight(height);
+        }
+        if (vaultView) {
+            vaultView->EraseVaultHistory(height);
+        }
+    }
+
+    // Remove burn balance transfers
+    if (burnView) {
+        burnView->EraseAccountHistoryHeight(height);
+
+        // Erase any UTXO burns
+        for (const auto& entries : eraseBurnEntries) {
+            burnView->EraseAccountHistory(entries);
+        }
+
+        if (height == static_cast<uint32_t>(Params().GetConsensus().EunosHeight)) {
+            // Make sure to initialize lastTxOut, otherwise it never finds the block and
+            // ends up looping through uninitialized garbage value.
+            uint32_t firstTxOut{}, lastTxOut{};
+            auto shouldContinueToNextAccountHistory = [&](AccountHistoryKey const & key, AccountHistoryValue const &) -> bool
+            {
+                if (key.owner != Params().GetConsensus().burnAddress || key.blockHeight != static_cast<uint32_t>(Params().GetConsensus().EunosHeight)) {
+                    return false;
+                }
+
+                firstTxOut = key.txn;
+                if (!lastTxOut) {
+                    lastTxOut = key.txn;
+                }
+
+                return true;
+            };
+
+            AccountHistoryKey startKey({Params().GetConsensus().burnAddress, static_cast<uint32_t>(Params().GetConsensus().EunosHeight), std::numeric_limits<uint32_t>::max()});
+            burnView->ForEachAccountHistory(shouldContinueToNextAccountHistory,
+                                            Params().GetConsensus().burnAddress,
+                                            Params().GetConsensus().EunosHeight);
+
+            for (auto i = firstTxOut; i <= lastTxOut; ++i) {
+                burnView->EraseAccountHistory({Params().GetConsensus().burnAddress, static_cast<uint32_t>(Params().GetConsensus().EunosHeight), i});
+            }
+        }
+    }
+}
+
+CBurnHistoryStorage*& CHistoryWriters::GetBurnView() {
+    return burnView;
+}
+
+CVaultHistoryStorage*& CHistoryWriters::GetVaultView() {
+    return vaultView;
+}
+
+CAccountHistoryStorage*& CHistoryWriters::GetHistoryView() {
+    return historyView;
+}
+
+void CHistoryWriters::WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value) {
+    if (burnView) {
+        burnView->WriteAccountHistory(key, value);
+    }
+}
+
+void CHistoryWriters::WriteAuctionHistory(const AuctionHistoryKey &key, const AuctionHistoryValue &value) {
+    if (historyView) {
+        historyView->WriteAuctionHistory(key, value);
+    }
+}
+
+void CHistoryWriters::WriteVaultHistory(const VaultHistoryKey &key, const VaultHistoryValue &value) {
+    if (vaultView) {
+        vaultView->WriteVaultHistory(key, value);
+    }
+}
+
+void CHistoryWriters::WriteVaultState(CCustomCSView &mnview, const CBlockIndex &pindex, const uint256 &vaultID, const uint32_t ratio) {
+    if (vaultView) {
+        vaultView->WriteVaultState(mnview, pindex, vaultID, ratio);
+    }
+}
+
+void CHistoryWriters::FlushDB() {
+    if (historyView) {
+        historyView->Flush();
+    }
+    if (burnView) {
+        burnView->Flush();
+    }
+    if (vaultView) {
+        vaultView->Flush();
+    }
+}
+
+void CHistoryWriters::DiscardDB() {
+    if (historyView) {
+        historyView->Discard();
+    }
+    if (burnView) {
+        burnView->Discard();
+    }
+    if (vaultView) {
+        vaultView->Discard();
+    }
+}
diff --git a/src/masternodes/historywriter.h b/src/masternodes/historywriter.h
new file mode 100644
index 0000000000..1e9d34e4b3
--- /dev/null
+++ b/src/masternodes/historywriter.h
@@ -0,0 +1,133 @@
+// Copyright (c) DeFi Blockchain Developers
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef DEFI_MASTERNODES_HISTORYWRITER_H
+#define DEFI_MASTERNODES_HISTORYWRITER_H
+
+#include <amount.h>
+#include <masternodes/loan.h>
+#include <script/script.h>
+#include <uint256.h>
+
+class CAccountHistoryStorage;
+struct AuctionHistoryKey;
+struct AuctionHistoryValue;
+class CBurnHistoryStorage;
+class CVaultHistoryStorage;
+struct VaultHistoryKey;
+struct VaultHistoryValue;
+
+struct AccountHistoryKey {
+    CScript owner;
+    uint32_t blockHeight;
+    uint32_t txn;  // for order in block
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        READWRITE(owner);
+
+        if (ser_action.ForRead()) {
+            READWRITE(WrapBigEndian(blockHeight));
+            blockHeight = ~blockHeight;
+            READWRITE(WrapBigEndian(txn));
+            txn = ~txn;
+        } else {
+            uint32_t blockHeight_ = ~blockHeight;
+            READWRITE(WrapBigEndian(blockHeight_));
+            uint32_t txn_ = ~txn;
+            READWRITE(WrapBigEndian(txn_));
+        }
+    }
+};
+
+struct AccountHistoryKeyNew {
+    uint32_t blockHeight;
+    CScript owner;
+    uint32_t txn;  // for order in block
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        if (ser_action.ForRead()) {
+            READWRITE(WrapBigEndian(blockHeight));
+            blockHeight = ~blockHeight;
+        } else {
+            uint32_t blockHeight_ = ~blockHeight;
+            READWRITE(WrapBigEndian(blockHeight_));
+        }
+
+        READWRITE(owner);
+
+        if (ser_action.ForRead()) {
+            READWRITE(WrapBigEndian(txn));
+            txn = ~txn;
+        } else {
+            uint32_t txn_ = ~txn;
+            READWRITE(WrapBigEndian(txn_));
+        }
+    }
+};
+
+struct AccountHistoryValue {
+    uint256 txid;
+    unsigned char category;
+    TAmounts diff;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        READWRITE(txid);
+        READWRITE(category);
+        READWRITE(diff);
+    }
+};
+
+class CHistoryWriters {
+    CAccountHistoryStorage *historyView{};
+    CBurnHistoryStorage *burnView{};
+    CVaultHistoryStorage *vaultView{};
+
+    std::map<CScript, TAmounts> diffs;
+    std::map<CScript, TAmounts> burnDiffs;
+    std::map<uint256, std::map<CScript, TAmounts>> vaultDiffs;
+
+public:
+    CLoanSchemeCreation globalLoanScheme;
+    std::string schemeID;
+
+    CHistoryWriters() = default;
+    CHistoryWriters(const CHistoryWriters &writers) = default;
+    CHistoryWriters(CAccountHistoryStorage *historyView,
+                    CBurnHistoryStorage *burnView,
+                    CVaultHistoryStorage *vaultView);
+
+    void AddBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID);
+    void AddFeeBurn(const CScript &owner, const CAmount amount);
+    void SubBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID);
+
+    void ClearState();
+    void FlushDB();
+    void DiscardDB();
+    void Flush(const uint32_t height,
+               const uint256 &txid,
+               const uint32_t txn,
+               const uint8_t type,
+               const uint256 &vaultID);
+
+    CBurnHistoryStorage*& GetBurnView();
+    CVaultHistoryStorage*& GetVaultView();
+    CAccountHistoryStorage*& GetHistoryView();
+
+    void WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value);
+    void WriteAuctionHistory(const AuctionHistoryKey &key, const AuctionHistoryValue &value);
+    void WriteVaultHistory(const VaultHistoryKey &key, const VaultHistoryValue &value);
+    void WriteVaultState(CCustomCSView &mnview, const CBlockIndex &pindex, const uint256 &vaultID, const uint32_t ratio = 0);
+    void EraseHistory(uint32_t height, std::vector<AccountHistoryKey> &eraseBurnEntries);
+};
+
+#endif  // DEFI_MASTERNODES_HISTORYWRITER_H
\ No newline at end of file
diff --git a/src/masternodes/masternodes.cpp b/src/masternodes/masternodes.cpp
index b62fe889f6..e17d40346b 100644
--- a/src/masternodes/masternodes.cpp
+++ b/src/masternodes/masternodes.cpp
@@ -754,8 +754,6 @@ CCustomCSView::CCustomCSView() {
     CheckPrefixes();
 }
 
-CCustomCSView::~CCustomCSView() = default;
-
 CCustomCSView::CCustomCSView(CStorageKV &st)
     : CStorageView(new CFlushableStorageKV(st)) {
     CheckPrefixes();
@@ -763,7 +761,17 @@ CCustomCSView::CCustomCSView(CStorageKV &st)
 
 // cache-upon-a-cache (not a copy!) constructor
 CCustomCSView::CCustomCSView(CCustomCSView &other)
-    : CStorageView(new CFlushableStorageKV(other.DB())) {
+    : CStorageView(new CFlushableStorageKV(other.DB())),
+      writers(other.GetHistoryWriters()) {
+    CheckPrefixes();
+}
+
+CCustomCSView::CCustomCSView(CCustomCSView &other,
+                             CAccountHistoryStorage *historyView,
+                             CBurnHistoryStorage *burnView,
+                             CVaultHistoryStorage *vaultView)
+        : CStorageView(new CFlushableStorageKV(other.DB())),
+          writers(historyView, burnView, vaultView) {
     CheckPrefixes();
 }
 
@@ -1251,28 +1259,6 @@ std::optional<CLoanView::CLoanSetCollateralTokenImpl> CCustomCSView::GetCollater
     return {};
 }
 
-CAccountHistoryStorage *CCustomCSView::GetAccountHistoryStore() {
-    return accHistoryStore.get();
-}
-
-CVaultHistoryStorage *CCustomCSView::GetVaultHistoryStore() {
-    return vauHistoryStore.get();
-}
-
-void CCustomCSView::SetAccountHistoryStore() {
-    if (paccountHistoryDB) {
-        accHistoryStore.reset();
-        accHistoryStore = std::make_unique<CAccountHistoryStorage>(*paccountHistoryDB);
-    }
-}
-
-void CCustomCSView::SetVaultHistoryStore() {
-    if (pvaultHistoryDB) {
-        vauHistoryStore.reset();
-        vauHistoryStore = std::make_unique<CVaultHistoryStorage>(*pvaultHistoryDB);
-    }
-}
-
 uint32_t CCustomCSView::GetVotingPeriodFromAttributes() const {
     auto attributes = GetAttributes();
     assert(attributes);
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 2591e10aa7..80e4871fe6 100644
--- a/src/masternodes/masternodes.h
+++ b/src/masternodes/masternodes.h
@@ -10,6 +10,7 @@
 #include <masternodes/accounts.h>
 #include <masternodes/anchors.h>
 #include <masternodes/gv.h>
+#include <masternodes/historywriter.h>
 #include <masternodes/icxorder.h>
 #include <masternodes/incentivefunding.h>
 #include <masternodes/loan.h>
@@ -487,8 +488,8 @@ class CCustomCSView : public CMasternodesView,
                                bool useNextPrice,
                                bool requireLivePrice);
 
-    std::unique_ptr<CAccountHistoryStorage> accHistoryStore;
-    std::unique_ptr<CVaultHistoryStorage> vauHistoryStore;
+protected:
+    CHistoryWriters writers;
 
 public:
     // Increase version when underlaying tables are changed
@@ -499,8 +500,12 @@ class CCustomCSView : public CMasternodesView,
 
     // cache-upon-a-cache (not a copy!) constructor
     CCustomCSView(CCustomCSView &other);
+    CCustomCSView(CCustomCSView &other,
+                  CAccountHistoryStorage *historyView,
+                  CBurnHistoryStorage *burnView,
+                  CVaultHistoryStorage *vaultView);
 
-    ~CCustomCSView();
+    ~CCustomCSView() = default;
 
     // cause depends on current mns:
     CTeamView::CTeam CalcNextTeam(int height, const uint256 &stakeModifier);
@@ -550,14 +555,12 @@ class CCustomCSView : public CMasternodesView,
 
     uint256 MerkleRoot();
 
+    //virtual CHistoryWriters& GetHistoryWriters() { return writers; }
+    virtual CHistoryWriters& GetHistoryWriters() { return writers; }
+
     // we construct it as it
     CFlushableStorageKV &GetStorage() { return static_cast<CFlushableStorageKV &>(DB()); }
 
-    virtual CAccountHistoryStorage *GetAccountHistoryStore();
-    CVaultHistoryStorage *GetVaultHistoryStore();
-    void SetAccountHistoryStore();
-    void SetVaultHistoryStore();
-
     uint32_t GetVotingPeriodFromAttributes() const override;
     uint32_t GetEmergencyPeriodFromAttributes(const CProposalType &type) const override;
     CAmount GetApprovalThresholdFromAttributes(const CProposalType &type) const override;
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 0108510642..e191f0e211 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -4,6 +4,7 @@
 
 #include <masternodes/accountshistory.h>
 #include <masternodes/govvariables/attributes.h>
+#include <masternodes/historywriter.h>
 #include <masternodes/mn_checks.h>
 #include <masternodes/vaulthistory.h>
 
@@ -3849,7 +3850,7 @@ bool ShouldReturnNonFatalError(const CTransaction &tx, uint32_t height) {
     return it != skippedTx.end() && it->second == tx.GetHash();
 }
 
-void PopulateVaultHistoryData(CHistoryWriters *writers,
+void PopulateVaultHistoryData(CHistoryWriters &writers,
                               CAccountsHistoryWriter &view,
                               const CCustomTxMessage &txMessage,
                               const CustomTxType txType,
@@ -3858,7 +3859,7 @@ void PopulateVaultHistoryData(CHistoryWriters *writers,
                               const uint256 &txid) {
     if (txType == CustomTxType::Vault) {
         auto obj          = std::get<CVaultMessage>(txMessage);
-        writers->schemeID = obj.schemeId;
+        writers.schemeID = obj.schemeId;
         view.vaultID      = txid;
     } else if (txType == CustomTxType::CloseVault) {
         auto obj     = std::get<CCloseVaultMessage>(txMessage);
@@ -3867,7 +3868,7 @@ void PopulateVaultHistoryData(CHistoryWriters *writers,
         auto obj     = std::get<CUpdateVaultMessage>(txMessage);
         view.vaultID = obj.vaultId;
         if (!obj.schemeId.empty()) {
-            writers->schemeID = obj.schemeId;
+            writers.schemeID = obj.schemeId;
         }
     } else if (txType == CustomTxType::DepositToVault) {
         auto obj     = std::get<CDepositToVaultMessage>(txMessage);
@@ -3892,18 +3893,18 @@ void PopulateVaultHistoryData(CHistoryWriters *writers,
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::LoanScheme) {
         auto obj                             = std::get<CLoanSchemeMessage>(txMessage);
-        writers->globalLoanScheme.identifier = obj.identifier;
-        writers->globalLoanScheme.ratio      = obj.ratio;
-        writers->globalLoanScheme.rate       = obj.rate;
+        writers.globalLoanScheme.identifier = obj.identifier;
+        writers.globalLoanScheme.ratio      = obj.ratio;
+        writers.globalLoanScheme.rate       = obj.rate;
         if (!obj.updateHeight) {
-            writers->globalLoanScheme.schemeCreationTxid = txid;
+            writers.globalLoanScheme.schemeCreationTxid = txid;
         } else {
-            writers->vaultView->ForEachGlobalScheme(
+            writers.GetVaultView()->ForEachGlobalScheme(
                 [&writers](const VaultGlobalSchemeKey &key, CLazySerialize<VaultGlobalSchemeValue> value) {
-                    if (value.get().loanScheme.identifier != writers->globalLoanScheme.identifier) {
+                    if (value.get().loanScheme.identifier != writers.globalLoanScheme.identifier) {
                         return true;
                     }
-                    writers->globalLoanScheme.schemeCreationTxid = key.schemeCreationTxid;
+                    writers.globalLoanScheme.schemeCreationTxid = key.schemeCreationTxid;
                     return false;
                 },
                 {height, txn, {}});
@@ -3918,8 +3919,7 @@ Res ApplyCustomTx(CCustomCSView &mnview,
                   uint32_t height,
                   uint64_t time,
                   uint256 *canSpend,
-                  uint32_t txn,
-                  CHistoryWriters *writers) {
+                  uint32_t txn) {
     auto res = Res::Ok();
     if (tx.IsCoinBase() && height > 0) {  // genesis contains custom coinbase txs
         return res;
@@ -3937,51 +3937,48 @@ Res ApplyCustomTx(CCustomCSView &mnview,
     }
 
     auto txMessage = customTypeToMessage(txType);
-    CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), writers);
+    CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType));
     if ((res = CustomMetadataParse(height, consensus, metadata, txMessage))) {
-        if (pvaultHistoryDB && writers) {
-            PopulateVaultHistoryData(writers, view, txMessage, txType, height, txn, tx.GetHash());
+        if (mnview.GetHistoryWriters().GetVaultView()) {
+            PopulateVaultHistoryData(mnview.GetHistoryWriters(), view, txMessage, txType, height, txn, tx.GetHash());
         }
+
         res = CustomTxVisit(view, coins, tx, height, consensus, txMessage, time, txn);
 
-        if (res && canSpend && txType == CustomTxType::UpdateMasternode) {
-            auto obj = std::get<CUpdateMasterNodeMessage>(txMessage);
-            for (const auto &item : obj.updates) {
-                if (item.first == static_cast<uint8_t>(UpdateMasternodeType::OwnerAddress)) {
-                    if (const auto node = mnview.GetMasternode(obj.mnId)) {
-                        *canSpend = node->collateralTx.IsNull() ? obj.mnId : node->collateralTx;
+        if (res) {
+            if (canSpend && txType == CustomTxType::UpdateMasternode) {
+                auto obj = std::get<CUpdateMasterNodeMessage>(txMessage);
+                for (const auto &item : obj.updates) {
+                    if (item.first == static_cast<uint8_t>(UpdateMasternodeType::OwnerAddress)) {
+                        if (const auto node = mnview.GetMasternode(obj.mnId)) {
+                            *canSpend = node->collateralTx.IsNull() ? obj.mnId : node->collateralTx;
+                        }
+                        break;
                     }
-                    break;
                 }
             }
-        }
 
-        // Track burn fee
-        if (txType == CustomTxType::CreateToken || txType == CustomTxType::CreateMasternode) {
-            if (writers) {
-                writers->AddFeeBurn(tx.vout[0].scriptPubKey, tx.vout[0].nValue);
+            // Track burn fee
+            if (txType == CustomTxType::CreateToken || txType == CustomTxType::CreateMasternode) {
+                mnview.GetHistoryWriters().AddFeeBurn(tx.vout[0].scriptPubKey, tx.vout[0].nValue);
             }
-        }
 
-        if (txType == CustomTxType::CreateCfp || txType == CustomTxType::CreateVoc) {
-            // burn fee_burn_pct of creation fee, the rest is distributed among voting masternodes
-            CDataStructureV0 burnPctKey{
-                AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::FeeBurnPct};
+            if (txType == CustomTxType::CreateCfp || txType == CustomTxType::CreateVoc) {
+                // burn fee_burn_pct of creation fee, the rest is distributed among voting masternodes
+                CDataStructureV0 burnPctKey{
+                        AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::FeeBurnPct};
 
-            auto attributes = view.GetAttributes();
-            assert(attributes);
+                auto attributes = view.GetAttributes();
+                assert(attributes);
 
-            auto burnFee = MultiplyAmounts(tx.vout[0].nValue, attributes->GetValue(burnPctKey, COIN / 2));
-            if (writers) {
-                writers->AddFeeBurn(tx.vout[0].scriptPubKey, burnFee);
+                auto burnFee = MultiplyAmounts(tx.vout[0].nValue, attributes->GetValue(burnPctKey, COIN / 2));
+                mnview.GetHistoryWriters().AddFeeBurn(tx.vout[0].scriptPubKey, burnFee);
             }
-        }
 
-        if (txType == CustomTxType::Vault) {
-            // burn the half, the rest is returned on close vault
-            auto burnFee = tx.vout[0].nValue / 2;
-            if (writers) {
-                writers->AddFeeBurn(tx.vout[0].scriptPubKey, burnFee);
+            if (txType == CustomTxType::Vault) {
+                // burn the half, the rest is returned on close vault
+                auto burnFee = tx.vout[0].nValue / 2;
+                mnview.GetHistoryWriters().AddFeeBurn(tx.vout[0].scriptPubKey, burnFee);
             }
         }
     }
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index 6a62495980..db613a8717 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -19,7 +19,6 @@ class CTxMemPool;
 class CCoinsViewCache;
 
 class CCustomCSView;
-class CAccountsHistoryView;
 class CCustomTxVisitor {
 protected:
     uint32_t height;
@@ -60,8 +59,6 @@ class CCustomTxVisitor {
     bool IsTokensMigratedToGovVar() const;
     Res IsOnChainGovernanceEnabled() const;
 };
-class CVaultHistoryView;
-class CHistoryWriters;
 
 constexpr uint8_t MAX_POOL_SWAPS = 3;
 
@@ -462,8 +459,7 @@ Res ApplyCustomTx(CCustomCSView &mnview,
                   uint32_t height,
                   uint64_t time            = 0,
                   uint256 *canSpend        = nullptr,
-                  uint32_t txn             = 0,
-                  CHistoryWriters *writers = nullptr);
+                  uint32_t txn             = 0);
 Res CustomTxVisit(CCustomCSView &mnview,
                   const CCoinsViewCache &coins,
                   const CTransaction &tx,
diff --git a/src/masternodes/rpc_tokens.cpp b/src/masternodes/rpc_tokens.cpp
index 4dc9a9bf07..2d7ed94eae 100644
--- a/src/masternodes/rpc_tokens.cpp
+++ b/src/masternodes/rpc_tokens.cpp
@@ -957,7 +957,6 @@ UniValue decodecustomtx(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
-    int nHeight{0};
     CustomTxType guess;
     UniValue txResults(UniValue::VOBJ);
     Res res{};
@@ -967,16 +966,14 @@ UniValue decodecustomtx(const JSONRPCRequest& request)
     if (tx)
     {
         LOCK(cs_main);
-        // Default to INT_MAX
-        nHeight = std::numeric_limits<int>::max();
 
         // Skip coinbase TXs except for genesis block
-        if ((tx->IsCoinBase() && nHeight > 0)) {
+        if (tx->IsCoinBase()) {
             return "Coinbase transaction. Not a custom transaction.";
         }
         //get custom tx info. We pass nHeight INT_MAX,
         //just to get over hardfork validations. txResults are based on transaction metadata.
-        res = RpcInfo(*tx, nHeight, guess, txResults);
+        res = RpcInfo(*tx, std::numeric_limits<int>::max(), guess, txResults);
         if (guess == CustomTxType::None) {
             return "Not a custom transaction";
         }
diff --git a/src/masternodes/validation.cpp b/src/masternodes/validation.cpp
index 302b6ec061..3210f88521 100644
--- a/src/masternodes/validation.cpp
+++ b/src/masternodes/validation.cpp
@@ -9,6 +9,7 @@
 #include <masternodes/govvariables/lp_daily_dfi_reward.h>
 #include <masternodes/govvariables/lp_splits.h>
 #include <masternodes/govvariables/loan_splits.h>
+#include <masternodes/historywriter.h>
 #include <masternodes/masternodes.h>
 #include <masternodes/mn_checks.h>
 #include <masternodes/mn_rpc.h>
@@ -307,7 +308,7 @@ static void ProcessEunosEvents(const CBlockIndex* pindex, CCustomCSView& cache,
                 cache.AddBalance(chainparams.GetConsensus().burnAddress, {subItem.first, subItem.second});
 
                 // Add transfer as additional TX in block
-                pburnHistoryDB->WriteAccountHistory({Params().GetConsensus().burnAddress, static_cast<uint32_t>(pindex->nHeight), GetNextBurnPosition()},
+                cache.GetHistoryWriters().WriteAccountHistory({Params().GetConsensus().burnAddress, static_cast<uint32_t>(pindex->nHeight), GetNextBurnPosition()},
                                                     {uint256{}, static_cast<uint8_t>(CustomTxType::AccountToAccount), {{subItem.first, subItem.second}}});
             }
             else // Log burn failure
@@ -615,8 +616,7 @@ static void ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& cache, c
         });
     }
 
-    CHistoryWriters writers{nullptr, pburnHistoryDB.get(), pvaultHistoryDB.get()};
-    CAccountsHistoryWriter view(cache, pindex->nHeight, ~0u, {}, uint8_t(CustomTxType::AuctionBid), &writers);
+    CAccountsHistoryWriter view(cache, pindex->nHeight, ~0u, {}, uint8_t(CustomTxType::AuctionBid));
 
     view.ForEachVaultAuction([&](const CVaultId& vaultId, const CAuctionData& data) {
         if (data.liquidationHeight != uint32_t(pindex->nHeight)) {
@@ -674,11 +674,9 @@ static void ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& cache, c
                     LogPrintf("AuctionBid: SubMintedTokens failed: %s\n", res.msg);
                 }
 
-                if (paccountHistoryDB) {
-                    AuctionHistoryKey key{data.liquidationHeight, bidOwner, vaultId, i};
-                    AuctionHistoryValue value{bidTokenAmount, batch->collaterals.balances};
-                    paccountHistoryDB->WriteAuctionHistory(key, value);
-                }
+                AuctionHistoryKey key{data.liquidationHeight, bidOwner, vaultId, i};
+                AuctionHistoryValue value{bidTokenAmount, batch->collaterals.balances};
+                cache.GetHistoryWriters().WriteAuctionHistory(key, value);
 
             } else {
                 // we should return loan including interest
@@ -711,18 +709,12 @@ static void ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& cache, c
         view.EraseAuction(vaultId, pindex->nHeight);
 
         // Store state in vault DB
-        if (pvaultHistoryDB) {
-            pvaultHistoryDB->WriteVaultState(view, *pindex, vaultId);
-        }
+        cache.GetHistoryWriters().WriteVaultState(view, *pindex, vaultId);
 
         return true;
     }, pindex->nHeight);
 
     view.Flush();
-    pburnHistoryDB->Flush();
-    if (paccountHistoryDB) {
-        paccountHistoryDB->Flush();
-    }
 }
 
 static void ProcessFutures(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams)
@@ -829,8 +821,7 @@ static void ProcessFutures(const CBlockIndex* pindex, CCustomCSView& cache, cons
 
     cache.ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues){
 
-        CHistoryWriters writers{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter view(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapExecution), &writers);
+        CAccountsHistoryWriter view(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapExecution));
 
         deletionPending.insert(key);
 
@@ -895,13 +886,11 @@ static void ProcessFutures(const CBlockIndex* pindex, CCustomCSView& cache, cons
     // Refund unpaid contracts
     for (const auto& [key, value] : unpaidContracts) {
 
-        CHistoryWriters subWriters{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter subView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
+        CAccountsHistoryWriter subView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
         subView.SubBalance(*contractAddressValue, value.source);
         subView.Flush();
 
-        CHistoryWriters addWriters{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter addView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
+        CAccountsHistoryWriter addView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
         addView.AddBalance(key.owner, value.source);
         addView.Flush();
 
@@ -1278,8 +1267,7 @@ static Res PoolSplits(CCustomCSView& view, CAmount& totalBalance, ATTRIBUTES& at
 
             for (auto& [owner, amount] : balancesToMigrate) {
                 if (owner != Params().GetConsensus().burnAddress) {
-                    CHistoryWriters subWriters{view.GetAccountHistoryStore(), nullptr, nullptr};
-                    CAccountsHistoryWriter subView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit), &subWriters);
+                    CAccountsHistoryWriter subView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit));
 
                     res = subView.SubBalance(owner, CTokenAmount{oldPoolId, amount});
                     if (!res.ok) {
@@ -1315,8 +1303,7 @@ static Res PoolSplits(CCustomCSView& view, CAmount& totalBalance, ATTRIBUTES& at
                     totalBalance += amountB;
                 }
 
-                CHistoryWriters addWriters{view.GetAccountHistoryStore(), nullptr, nullptr};
-                CAccountsHistoryWriter addView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit), &addWriters);
+                CAccountsHistoryWriter addView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit));
 
                 auto refundBalances = [&, owner = owner]() {
                     addView.AddBalance(owner, {newPoolPair.idTokenA, amountA});
@@ -1515,16 +1502,14 @@ static Res VaultSplits(CCustomCSView& view, ATTRIBUTES& attributes, const DCT_ID
 
         Require(view.AddLoanToken(vaultId, newTokenAmount));
 
-        if (view.GetVaultHistoryStore()) {
-            if (const auto vault = view.GetVault(vaultId)) {
-                VaultHistoryKey subKey{static_cast<uint32_t>(height), vaultId, GetNextAccPosition(), vault->ownerAddress};
-                VaultHistoryValue subValue{uint256{}, static_cast<uint8_t>(CustomTxType::TokenSplit), {{oldTokenId, -amount}}};
-                view.GetVaultHistoryStore()->WriteVaultHistory(subKey, subValue);
+        if (const auto vault = view.GetVault(vaultId)) {
+            VaultHistoryKey subKey{static_cast<uint32_t>(height), vaultId, GetNextAccPosition(), vault->ownerAddress};
+            VaultHistoryValue subValue{uint256{}, static_cast<uint8_t>(CustomTxType::TokenSplit), {{oldTokenId, -amount}}};
+            view.GetHistoryWriters().WriteVaultHistory(subKey, subValue);
 
-                VaultHistoryKey addKey{static_cast<uint32_t>(height), vaultId, GetNextAccPosition(), vault->ownerAddress};
-                VaultHistoryValue addValue{uint256{}, static_cast<uint8_t>(CustomTxType::TokenSplit), {{newTokenId, newAmount}}};
-                view.GetVaultHistoryStore()->WriteVaultHistory(addKey, addValue);
-            }
+            VaultHistoryKey addKey{static_cast<uint32_t>(height), vaultId, GetNextAccPosition(), vault->ownerAddress};
+            VaultHistoryValue addValue{uint256{}, static_cast<uint8_t>(CustomTxType::TokenSplit), {{newTokenId, newAmount}}};
+            view.GetHistoryWriters().WriteVaultHistory(addKey, addValue);
         }
     }
 
@@ -1712,8 +1697,6 @@ static void ProcessTokenSplits(const CBlock& block, const CBlockIndex* pindex, C
         }
 
         auto view{cache};
-        view.SetAccountHistoryStore();
-        view.SetVaultHistoryStore();
 
         // Refund affected future swaps
         auto res = attributes->RefundFuturesContracts(view, std::numeric_limits<uint32_t>::max(), id);
@@ -1843,8 +1826,7 @@ static void ProcessTokenSplits(const CBlock& block, const CBlockIndex* pindex, C
 
             for (const auto& [owner, balances] : balanceUpdates) {
 
-                CHistoryWriters subWriters{view.GetAccountHistoryStore(), nullptr, nullptr};
-                CAccountsHistoryWriter subView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit), &subWriters);
+                CAccountsHistoryWriter subView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit));
 
                 res = subView.SubBalance(owner, balances.second);
                 if (!res) {
@@ -1852,8 +1834,7 @@ static void ProcessTokenSplits(const CBlock& block, const CBlockIndex* pindex, C
                 }
                 subView.Flush();
 
-                CHistoryWriters addWriters{view.GetAccountHistoryStore(), nullptr, nullptr};
-                CAccountsHistoryWriter addView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit), &addWriters);
+                CAccountsHistoryWriter addView(view, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::TokenSplit));
 
                 res = addView.AddBalance(owner, balances.first);
                 if (!res) {
@@ -1934,12 +1915,6 @@ static void ProcessTokenSplits(const CBlock& block, const CBlockIndex* pindex, C
         }
 
         view.Flush();
-        if (auto accountHistory = view.GetAccountHistoryStore()) {
-            accountHistory->Flush();
-        }
-        if (auto vaultHistory = view.GetVaultHistoryStore()) {
-            vaultHistory->Flush();
-        }
         LogPrintf("Token split completed: (id: %d, mul: %d, time: %dms)\n", id, multiplier, GetTimeMillis() - time);
     }
 }
@@ -2005,13 +1980,11 @@ static void ProcessFuturesDUSD(const CBlockIndex* pindex, CCustomCSView& cache,
 
             const CTokenAmount source{dfiID, amount};
 
-            CHistoryWriters subWriters{paccountHistoryDB.get(), nullptr, nullptr};
-            CAccountsHistoryWriter subView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
+            CAccountsHistoryWriter subView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
             subView.SubBalance(*contractAddressValue, source);
             subView.Flush();
 
-            CHistoryWriters addWriters{paccountHistoryDB.get(), nullptr, nullptr};
-            CAccountsHistoryWriter addView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
+            CAccountsHistoryWriter addView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund));
             addView.AddBalance(key.owner, source);
             addView.Flush();
 
@@ -2044,8 +2017,7 @@ static void ProcessFuturesDUSD(const CBlockIndex* pindex, CCustomCSView& cache,
 
     cache.ForEachFuturesDUSD([&](const CFuturesUserKey& key, const CAmount& amount){
 
-        CHistoryWriters writers{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter view(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapExecution), &writers);
+        CAccountsHistoryWriter view(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapExecution));
 
         deletionPending.insert(key);
 
@@ -2206,8 +2178,7 @@ static void ProcessProposalEvents(const CBlockIndex* pindex, CCustomCSView& cach
                     );
                 }
 
-                CHistoryWriters subWriters{paccountHistoryDB.get(), nullptr, nullptr};
-                CAccountsHistoryWriter subView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::ProposalFeeRedistribution), &subWriters);
+                CAccountsHistoryWriter subView(cache, pindex->nHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::ProposalFeeRedistribution));
 
                 auto res = subView.AddBalance(scriptPubKey, {DCT_ID{0}, amountPerVoter});
                 if (!res) {
diff --git a/src/validation.cpp b/src/validation.cpp
index 58213c83c9..c587f94fd2 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -21,6 +21,7 @@
 #include <index/txindex.h>
 #include <masternodes/accountshistory.h>
 #include <masternodes/govvariables/attributes.h>
+#include <masternodes/historywriter.h>
 #include <masternodes/mn_checks.h>
 #include <masternodes/validation.h>
 #include <masternodes/vaulthistory.h>
@@ -1712,21 +1713,6 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
     // special case: possible undo (first) of custom 'complex changes' for the whole block (expired orders and/or prices)
     mnview.OnUndoTx(uint256(), (uint32_t) pindex->nHeight); // undo for "zero hash"
 
-    pburnHistoryDB->EraseAccountHistoryHeight(pindex->nHeight);
-    if (paccountHistoryDB) {
-        paccountHistoryDB->EraseAccountHistoryHeight(pindex->nHeight);
-    }
-
-    if (pindex->nHeight >= Params().GetConsensus().FortCanningHeight) {
-        // erase auction fee history
-        if (paccountHistoryDB) {
-            paccountHistoryDB->EraseAuctionHistoryHeight(pindex->nHeight);
-        }
-        if (pvaultHistoryDB) {
-            pvaultHistoryDB->EraseVaultHistory(pindex->nHeight);
-        }
-    }
-
     // Undo community balance increments
     ReverseGeneralCoinbaseTx(mnview, pindex->nHeight, Params().GetConsensus());
 
@@ -1851,42 +1837,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
         LogPrint(BCLog::BENCH, "    - Interest rate reverting took: %dms\n", GetTimeMillis() - time);
     }
 
-    // Remove burn balance transfers
-    if (pindex->nHeight == Params().GetConsensus().EunosHeight)
-    {
-        // Make sure to initialize lastTxOut, otherwise it never finds the block and
-        // ends up looping through uninitialized garbage value.
-        uint32_t lastTxOut = 0;
-        auto shouldContinueToNextAccountHistory = [&lastTxOut, block](AccountHistoryKey const & key, AccountHistoryValue const &) -> bool
-        {
-            if (key.owner != Params().GetConsensus().burnAddress) {
-                return false;
-            }
-
-            if (key.blockHeight != static_cast<uint32_t>(Params().GetConsensus().EunosHeight)) {
-                return false;
-            }
-
-            lastTxOut = key.txn;
-
-            return false;
-        };
-
-        AccountHistoryKey startKey({Params().GetConsensus().burnAddress, static_cast<uint32_t>(Params().GetConsensus().EunosHeight), std::numeric_limits<uint32_t>::max()});
-        pburnHistoryDB->ForEachAccountHistory(shouldContinueToNextAccountHistory,
-                                              Params().GetConsensus().burnAddress,
-                                              Params().GetConsensus().EunosHeight);
-
-        for (uint32_t i = block.vtx.size(); i <= lastTxOut; ++i) {
-            pburnHistoryDB->EraseAccountHistory({Params().GetConsensus().burnAddress, static_cast<uint32_t>(Params().GetConsensus().EunosHeight), i});
-        }
-    }
-
-    // Erase any UTXO burns
-    for (const auto& entries : eraseBurnEntries)
-    {
-        pburnHistoryDB->EraseAccountHistory(entries);
-    }
+    mnview.GetHistoryWriters().EraseHistory(pindex->nHeight, eraseBurnEntries);
 
     // move best block pointer to prevout block
     view.SetBestBlock(pindex->pprev->GetBlockHash());
@@ -2396,11 +2347,11 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     if (block.GetHash() == chainparams.GetConsensus().hashGenesisBlock) {
         if (!fJustCheck) {
             view.SetBestBlock(pindex->GetBlockHash());
-            pcustomcsview->CreateDFIToken();
-            // init view|db with genesis here
+            mnview.CreateDFIToken();
+            // Do not track burns in genesis
+            mnview.GetHistoryWriters().GetBurnView() = nullptr;
             for (size_t i = 0; i < block.vtx.size(); ++i) {
-                CHistoryWriters writers{paccountHistoryDB.get(), nullptr, nullptr};
-                const auto res = ApplyCustomTx(mnview, view, *block.vtx[i], chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), nullptr, i, &writers);
+                const auto res = ApplyCustomTx(mnview, view, *block.vtx[i], chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), nullptr, i);
                 if (!res.ok) {
                     return error("%s: Genesis block ApplyCustomTx failed. TX: %s Error: %s",
                                  __func__, block.vtx[i]->GetHash().ToString(), res.msg);
@@ -2675,9 +2626,8 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                     __func__, tx.GetHash().ToString(), FormatStateMessage(state));
             }
 
-            CHistoryWriters writers{paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get()};
             const auto applyCustomTxTime = GetTimeMicros();
-            const auto res = ApplyCustomTx(accountsView, view, tx, chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), nullptr, i, &writers);
+            const auto res = ApplyCustomTx(accountsView, view, tx, chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), nullptr, i);
             LogApplyCustomTx(tx, applyCustomTxTime);
             if (!res.ok && (res.code & CustomTxErrCodes::Fatal)) {
                 if (pindex->nHeight >= chainparams.GetConsensus().EunosHeight) {
@@ -2860,9 +2810,9 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     ProcessDeFiEvent(block, pindex, mnview, view, chainparams, creationTxs);
 
     // Write any UTXO burns
-    for (const auto& entries : writeBurnEntries)
+    for (const auto& [key, value] : writeBurnEntries)
     {
-        pburnHistoryDB->WriteAccountHistory(entries.first, entries.second);
+        mnview.GetHistoryWriters().WriteAccountHistory(key, value);
     }
 
     if (!fIsFakeNet) {
@@ -3170,36 +3120,17 @@ bool CChainState::DisconnectTip(CValidationState& state, const CChainParams& cha
     int64_t nStart = GetTimeMicros();
     {
         CCoinsViewCache view(&CoinsTip());
-        CCustomCSView mnview(*pcustomcsview);
+        CCustomCSView mnview(*pcustomcsview, paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get());
         assert(view.GetBestBlock() == pindexDelete->GetBlockHash());
         std::vector<CAnchorConfirmMessage> disconnectedConfirms;
         if (DisconnectBlock(block, pindexDelete, view, mnview, disconnectedConfirms) != DISCONNECT_OK) {
-            // no usable history
-            if (paccountHistoryDB) {
-                paccountHistoryDB->Discard();
-            }
-            if (pburnHistoryDB) {
-                pburnHistoryDB->Discard();
-            }
-            if (pvaultHistoryDB) {
-                pvaultHistoryDB->Discard();
-            }
             m_disconnectTip = false;
+            mnview.GetHistoryWriters().DiscardDB();
             return error("DisconnectTip(): DisconnectBlock %s failed", pindexDelete->GetBlockHash().ToString());
         }
         bool flushed = view.Flush() && mnview.Flush();
         assert(flushed);
-
-        // flush history
-        if (paccountHistoryDB) {
-            paccountHistoryDB->Flush();
-        }
-        if (pburnHistoryDB) {
-            pburnHistoryDB->Flush();
-        }
-        if (pvaultHistoryDB) {
-            pvaultHistoryDB->Flush();
-        }
+        mnview.GetHistoryWriters().FlushDB();
 
         if (!disconnectedConfirms.empty()) {
             for (auto const & confirm : disconnectedConfirms) {
@@ -3336,7 +3267,7 @@ bool CChainState::ConnectTip(CValidationState& state, const CChainParams& chainp
     LogPrint(BCLog::BENCH, "  - Load block from disk: %.2fms [%.2fs]\n", (nTime2 - nTime1) * MILLI, nTimeReadFromDisk * MICRO);
     {
         CCoinsViewCache view(&CoinsTip());
-        CCustomCSView mnview(*pcustomcsview);
+        CCustomCSView mnview(*pcustomcsview, paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get());
         bool rewardedAnchors{};
         bool rv = ConnectBlock(blockConnecting, state, pindexNew, view, mnview, chainparams, rewardedAnchors);
         GetMainSignals().BlockChecked(blockConnecting, state);
@@ -3344,33 +3275,14 @@ bool CChainState::ConnectTip(CValidationState& state, const CChainParams& chainp
             if (state.IsInvalid()) {
                 InvalidBlockFound(pindexNew, state);
             }
-            // no usable history
-            if (paccountHistoryDB) {
-                paccountHistoryDB->Discard();
-            }
-            if (pburnHistoryDB) {
-                pburnHistoryDB->Discard();
-            }
-            if (pvaultHistoryDB) {
-                pvaultHistoryDB->Discard();
-            }
+            mnview.GetHistoryWriters().DiscardDB();
             return error("%s: ConnectBlock %s failed, %s", __func__, pindexNew->GetBlockHash().ToString(), FormatStateMessage(state));
         }
         nTime3 = GetTimeMicros(); nTimeConnectTotal += nTime3 - nTime2;
         LogPrint(BCLog::BENCH, "  - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime3 - nTime2) * MILLI, nTimeConnectTotal * MICRO, nTimeConnectTotal * MILLI / nBlocksTotal);
         bool flushed = view.Flush() && mnview.Flush();
         assert(flushed);
-
-        // flush history
-        if (paccountHistoryDB) {
-            paccountHistoryDB->Flush();
-        }
-        if (pburnHistoryDB) {
-            pburnHistoryDB->Flush();
-        }
-        if (pvaultHistoryDB) {
-            pvaultHistoryDB->Flush();
-        }
+        mnview.GetHistoryWriters().FlushDB();
 
         // Delete all other confirms from memory
         if (rewardedAnchors) {
@@ -5326,14 +5238,6 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
             assert(coins.GetBestBlock() == pindex->GetBlockHash());
             std::vector<CAnchorConfirmMessage> disconnectedConfirms; // dummy
             DisconnectResult res = ::ChainstateActive().DisconnectBlock(block, pindex, coins, mnview, disconnectedConfirms);
-            // Discard results from bespoke DBs
-            pburnHistoryDB->Discard();
-            if (paccountHistoryDB) {
-                paccountHistoryDB->Discard();
-            }
-            if (pvaultHistoryDB) {
-                pvaultHistoryDB->Discard();
-            }
             if (res == DISCONNECT_FAILED) {
                 return error("VerifyDB(): *** irrecoverable inconsistency in block data at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
             }
@@ -5409,7 +5313,7 @@ bool CChainState::ReplayBlocks(const CChainParams& params, CCoinsView* view, CCu
     LOCK(cs_main);
 
     CCoinsViewCache cache(view);
-    CCustomCSView mncache(*mnview);
+    CCustomCSView mncache(*mnview, paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get());
 
     std::vector<uint256> hashHeads = view->GetHeadBlocks();
     if (hashHeads.empty()) return true; // We're already in a consistent state.
@@ -5450,6 +5354,7 @@ bool CChainState::ReplayBlocks(const CChainParams& params, CCoinsView* view, CCu
             std::vector<CAnchorConfirmMessage> disconnectedConfirms; // dummy
             DisconnectResult res = DisconnectBlock(block, pindexOld, cache, mncache, disconnectedConfirms);
             if (res == DISCONNECT_FAILED) {
+                mncache.GetHistoryWriters().DiscardDB();
                 return error("RollbackBlock(): DisconnectBlock failed at %d, hash=%s", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
             }
             // If DISCONNECT_UNCLEAN is returned, it means a non-existing UTXO was deleted, or an existing UTXO was
@@ -5466,12 +5371,16 @@ bool CChainState::ReplayBlocks(const CChainParams& params, CCoinsView* view, CCu
         const CBlockIndex* pindex = pindexNew->GetAncestor(nHeight);
         LogPrintf("Rolling forward %s (%i)\n", pindex->GetBlockHash().ToString(), nHeight);
         uiInterface.ShowProgress(_("Replaying blocks...").translated, (int) ((nHeight - nForkHeight) * 100.0 / (pindexNew->nHeight - nForkHeight)) , false);
-        if (!RollforwardBlock(pindex, cache, mncache, params)) return false;
+        if (!RollforwardBlock(pindex, cache, mncache, params)) {
+            mncache.GetHistoryWriters().DiscardDB();
+            return false;
+        }
     }
 
     cache.SetBestBlock(pindexNew->GetBlockHash());
     cache.Flush();
     mncache.Flush();
+    mncache.GetHistoryWriters().FlushDB();
     uiInterface.ShowProgress("", 100, false);
     return true;
 }
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index adae04cdb7..a9c87ececc 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -27,13 +27,15 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "consensus/tx_verify -> masternodes/mn_checks -> txmempool -> consensus/tx_verify"
     "index/txindex -> validation -> index/txindex"
     "init -> masternodes/govvariables/attributes -> masternodes/mn_rpc -> wallet/rpcwallet -> init"
+    "masternodes/accountshistory -> masternodes/historywriter -> masternodes/accountshistory"
     "masternodes/accountshistory -> masternodes/masternodes -> masternodes/accountshistory"
-    "masternodes/accountshistory -> masternodes/masternodes -> masternodes/mn_checks -> masternodes/accountshistory"
     "masternodes/accountshistory -> masternodes/masternodes -> validation -> masternodes/accountshistory"
+    "masternodes/accountshistory -> masternodes/mn_checks -> masternodes/accountshistory"
     "masternodes/anchors -> masternodes/masternodes -> masternodes/anchors"
     "masternodes/anchors -> masternodes/masternodes -> net_processing -> masternodes/anchors"
     "masternodes/anchors -> spv/spv_wrapper -> masternodes/anchors"
     "masternodes/govvariables/attributes -> masternodes/gv -> masternodes/govvariables/attributes"
+    "masternodes/govvariables/attributes -> masternodes/historywriter -> masternodes/loan -> masternodes/govvariables/attributes"
     "masternodes/govvariables/attributes -> masternodes/masternodes -> masternodes/govvariables/attributes"
     "masternodes/govvariables/attributes -> masternodes/masternodes -> masternodes/poolpairs -> masternodes/govvariables/attributes"
     "masternodes/govvariables/attributes -> masternodes/mn_checks -> masternodes/govvariables/attributes"
@@ -47,6 +49,9 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "masternodes/govvariables/lp_splits -> masternodes/gv -> masternodes/govvariables/lp_splits"
     "masternodes/govvariables/oracle_block_interval -> masternodes/gv -> masternodes/govvariables/oracle_block_interval"
     "masternodes/govvariables/oracle_deviation -> masternodes/gv -> masternodes/govvariables/oracle_deviation"
+    "masternodes/historywriter -> masternodes/masternodes -> masternodes/historywriter"
+    "masternodes/historywriter -> masternodes/masternodes -> masternodes/mn_checks -> masternodes/historywriter"
+    "masternodes/historywriter -> masternodes/masternodes -> validation -> masternodes/historywriter"
     "masternodes/loan -> masternodes/masternodes -> masternodes/loan"
     "masternodes/masternodes -> masternodes/mn_checks -> masternodes/masternodes"
     "masternodes/masternodes -> masternodes/oracles -> masternodes/masternodes"