From 346de0b019a1c5aadc2996d77f7486ef5efa0730 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Wed, 10 Nov 2021 14:14:23 +0000
Subject: [PATCH 01/12] Add vault history and getvaulthistory RPC call

---
 src/Makefile.am                        |   2 +
 src/init.cpp                           |  10 +-
 src/masternodes/accountshistory.cpp    |  63 +++--
 src/masternodes/accountshistory.h      |  16 +-
 src/masternodes/mn_checks.cpp          |  67 ++++--
 src/masternodes/mn_checks.h            |   7 +-
 src/masternodes/mn_rpc.cpp             |   3 +-
 src/masternodes/rpc_customtx.cpp       |   3 +-
 src/masternodes/rpc_vault.cpp          | 174 ++++++++++++++
 src/masternodes/vaulthistory.cpp       |  25 ++
 src/masternodes/vaulthistory.h         |  78 +++++++
 src/rpc/client.cpp                     |   1 +
 src/validation.cpp                     |  21 +-
 test/functional/rpc_getvaulthistory.py | 304 +++++++++++++++++++++++++
 test/functional/test_runner.py         |   1 +
 15 files changed, 732 insertions(+), 43 deletions(-)
 create mode 100644 src/masternodes/vaulthistory.cpp
 create mode 100644 src/masternodes/vaulthistory.h
 create mode 100755 test/functional/rpc_getvaulthistory.py

diff --git a/src/Makefile.am b/src/Makefile.am
index 0bc3a6518e..6ef8328c34 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -179,6 +179,7 @@ DEFI_CORE_H = \
   masternodes/undo.h \
   masternodes/undos.h \
   masternodes/vault.h \
+  masternodes/vaulthistory.h \
   memusage.h \
   merkleblock.h \
   miner.h \
@@ -404,6 +405,7 @@ libdefi_server_a_SOURCES = \
   masternodes/skipped_txs.cpp \
   masternodes/undos.cpp \
   masternodes/vault.cpp \
+  masternodes/vaulthistory.cpp \
   miner.cpp \
   net.cpp \
   net_processing.cpp \
diff --git a/src/init.cpp b/src/init.cpp
index 989450937f..bba94d87db 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -28,6 +28,7 @@
 #include <masternodes/accountshistory.h>
 #include <masternodes/anchors.h>
 #include <masternodes/masternodes.h>
+#include <masternodes/vaulthistory.h>
 #include <miner.h>
 #include <net.h>
 #include <net_permissions.h>
@@ -417,7 +418,8 @@ void SetupServerArgs()
     hidden_args.emplace_back("-sysperms");
 #endif
     gArgs.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    gArgs.AddArg("-acindex", strprintf("Maintain a full account history index, tracking all accounts balances changes. Used by the listaccounthistory and accounthistorycount rpc calls (default: %u)", false), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    gArgs.AddArg("-acindex", strprintf("Maintain a full account history index, tracking all accounts balances changes. Used by the listaccounthistory and accounthistorycount rpc calls (default: %u)", DEFAULT_ACINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    gArgs.AddArg("-vaultindex", strprintf("Maintain a full vault history index, tracking all vault changes. Used by the getvaulthistory rpc call (default: %u)", DEFAULT_VAULTINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-blockfilterindex=<type>",
                  strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
                  " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
@@ -1630,6 +1632,12 @@ bool AppInitMain(InitInterfaces& interfaces)
                 pburnHistoryDB.reset();
                 pburnHistoryDB = MakeUnique<CBurnHistoryStorage>(GetDataDir() / "burn", nCustomCacheSize, false, fReset || fReindexChainState);
 
+                // Create vault history DB
+                pvaultHistoryDB.reset();
+                if (gArgs.GetBoolArg("-vaultindex", DEFAULT_VAULTINDEX)) {
+                    pvaultHistoryDB = MakeUnique<CVaultHistoryStorage>(GetDataDir() / "vault", nCustomCacheSize, false, fReset || fReindexChainState);
+                }
+
                 // If necessary, upgrade from older database format.
                 // This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
                 if (!::ChainstateActive().CoinsDB().Upgrade()) {
diff --git a/src/masternodes/accountshistory.cpp b/src/masternodes/accountshistory.cpp
index ee08b4de7d..5a51365f7f 100644
--- a/src/masternodes/accountshistory.cpp
+++ b/src/masternodes/accountshistory.cpp
@@ -5,6 +5,7 @@
 #include <masternodes/accountshistory.h>
 #include <masternodes/accounts.h>
 #include <masternodes/masternodes.h>
+#include <masternodes/vaulthistory.h>
 #include <key_io.h>
 
 void CAccountsHistoryView::ForEachAccountHistory(std::function<bool(AccountHistoryKey const &, CLazySerialize<AccountHistoryValue>)> callback, AccountHistoryKey const & start)
@@ -34,20 +35,28 @@ CBurnHistoryStorage::CBurnHistoryStorage(const fs::path& dbName, std::size_t cac
 {
 }
 
-CAccountsHistoryWriter::CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView)
-    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn), txid(txid), type(type), historyView(historyView), burnView(burnView)
+CAccountsHistoryWriter::CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type,
+                                               CAccountsHistoryView* historyView, CAccountsHistoryView* burnView, CVaultHistoryView* vaultView, const uint256& vaultID)
+    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn),
+    txid(txid), type(type), historyView(historyView), burnView(burnView), vaultView(vaultView), vaultID(vaultID)
 {
 }
 
 Res CAccountsHistoryWriter::AddBalance(CScript const & owner, CTokenAmount amount)
 {
     auto res = CCustomCSView::AddBalance(owner, amount);
-    if (historyView && res.ok && amount.nValue != 0) {
-        diffs[owner][amount.nTokenId] += amount.nValue;
-    }
-    if (burnView && res.ok && amount.nValue != 0 && owner == Params().GetConsensus().burnAddress) {
-        burnDiffs[owner][amount.nTokenId] += amount.nValue;
+    if (amount.nValue != 0 && res.ok) {
+        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;
+        }
     }
+
     return res;
 }
 
@@ -62,12 +71,18 @@ Res CAccountsHistoryWriter::AddFeeBurn(CScript const & owner, CAmount amount)
 Res CAccountsHistoryWriter::SubBalance(CScript const & owner, CTokenAmount amount)
 {
     auto res = CCustomCSView::SubBalance(owner, amount);
-    if (historyView && res.ok && amount.nValue != 0) {
-        diffs[owner][amount.nTokenId] -= amount.nValue;
-    }
-    if (burnView && res.ok && amount.nValue != 0 && owner == Params().GetConsensus().burnAddress) {
-        burnDiffs[owner][amount.nTokenId] -= amount.nValue;
+    if (res.ok && amount.nValue != 0) {
+        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;
+        }
     }
+
     return res;
 }
 
@@ -83,11 +98,20 @@ bool CAccountsHistoryWriter::Flush()
             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({diff.first, height, txn, addresses.first}, {txid, type, addresses.second});
+            }
+        }
+    }
     return CCustomCSView::Flush();
 }
 
-CAccountsHistoryEraser::CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView)
-    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn), historyView(historyView), burnView(burnView)
+CAccountsHistoryEraser::CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView,
+                                               CAccountsHistoryView* burnView, CVaultHistoryView* vaultView, const uint256& vaultID)
+    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn),
+    historyView(historyView), burnView(burnView), vaultView(vaultView),  vaultID(vaultID)
 {
 }
 
@@ -99,6 +123,9 @@ Res CAccountsHistoryEraser::AddBalance(CScript const & owner, CTokenAmount)
     if (burnView && owner == Params().GetConsensus().burnAddress) {
         burnAccounts.insert(owner);
     }
+    if (vaultView && !vaultID.IsNull()) {
+        vaults.insert(vaultID);
+    }
     return Res::Ok();
 }
 
@@ -110,6 +137,9 @@ Res CAccountsHistoryEraser::SubBalance(CScript const & owner, CTokenAmount)
     if (burnView && owner == Params().GetConsensus().burnAddress) {
         burnAccounts.insert(owner);
     }
+    if (vaultView && !vaultID.IsNull()) {
+        vaults.insert(vaultID);
+    }
     return Res::Ok();
 }
 
@@ -133,6 +163,11 @@ bool CAccountsHistoryEraser::Flush()
             burnView->EraseAccountHistory({account, height, txn});
         }
     }
+    if (vaultView) {
+        for (const auto& vault : vaults) {
+            vaultView->EraseVaultHistory({vault, height, txn});
+        }
+    }
     return Res::Ok(); // makes sure no changes are applyed to underlaying view
 }
 
diff --git a/src/masternodes/accountshistory.h b/src/masternodes/accountshistory.h
index feda1bb4f3..bd504a0f50 100644
--- a/src/masternodes/accountshistory.h
+++ b/src/masternodes/accountshistory.h
@@ -12,6 +12,8 @@
 #include <script/script.h>
 #include <uint256.h>
 
+class CVaultHistoryView;
+
 struct AccountHistoryKey {
     CScript owner;
     uint32_t blockHeight;
@@ -85,11 +87,16 @@ class CAccountsHistoryWriter : public CCustomCSView
     const uint8_t type;
     std::map<CScript, TAmounts> diffs;
     std::map<CScript, TAmounts> burnDiffs;
+    std::map<uint256, std::map<CScript,TAmounts>> vaultDiffs;
     CAccountsHistoryView* historyView;
     CAccountsHistoryView* burnView;
+    CVaultHistoryView* vaultView;
 
 public:
-    CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView);
+    uint256 vaultID;
+
+    CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type, CAccountsHistoryView* historyView,
+                           CAccountsHistoryView* burnView, CVaultHistoryView* vaultView, const uint256& vaultID = uint256());
     Res AddBalance(CScript const & owner, CTokenAmount amount) override;
     Res SubBalance(CScript const & owner, CTokenAmount amount) override;
     Res AddFeeBurn(CScript const & owner, CAmount amount);
@@ -102,11 +109,16 @@ class CAccountsHistoryEraser : public CCustomCSView
     const uint32_t txn;
     std::set<CScript> accounts;
     std::set<CScript> burnAccounts;
+    std::set<uint256> vaults;
     CAccountsHistoryView* historyView;
     CAccountsHistoryView* burnView;
+    CVaultHistoryView* vaultView;
 
 public:
-    CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView);
+    uint256 vaultID;
+
+    CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView,
+                           CVaultHistoryView* vaultView, const uint256& vaultID = uint256());
     Res AddBalance(CScript const & owner, CTokenAmount amount) override;
     Res SubBalance(CScript const & owner, CTokenAmount amount) override;
     Res SubFeeBurn(CScript const & owner);
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index d8ef3ea7a9..62ea5ec97e 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -165,6 +165,7 @@ extern std::string ScriptToString(CScript const& script);
 class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 {
     uint32_t height;
+    uint256& vaultID;
     const Consensus::Params& consensus;
     const std::vector<unsigned char>& metadata;
 
@@ -223,8 +224,8 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 public:
     CCustomMetadataParseVisitor(uint32_t height,
                                 const Consensus::Params& consensus,
-                                const std::vector<unsigned char>& metadata)
-        : height(height), consensus(consensus), metadata(metadata) {}
+                                const std::vector<unsigned char>& metadata, uint256& vaultID)
+        : height(height), vaultID(vaultID), consensus(consensus), metadata(metadata) {}
 
     Res operator()(CCreateMasterNodeMessage& obj) const {
         return serialize(obj);
@@ -490,37 +491,65 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 
     Res operator()(CCloseVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            vaultID = obj.vaultId;
+        }
+        return res;
     }
 
     Res operator()(CUpdateVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            vaultID = obj.vaultId;
+        }
+        return res;
     }
 
     Res operator()(CDepositToVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            vaultID = obj.vaultId;
+        }
+        return res;
     }
 
     Res operator()(CWithdrawFromVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            vaultID = obj.vaultId;
+        }
+        return res;
     }
 
     Res operator()(CLoanTakeLoanMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            vaultID = obj.vaultId;
+        }
+        return res;
     }
 
     Res operator()(CLoanPaybackLoanMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            vaultID = obj.vaultId;
+        }
+        return res;
     }
 
     Res operator()(CAuctionBidMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            vaultID = obj.vaultId;
+        }
+        return res;
     }
 
     Res operator()(CCustomTxMessageNone&) const {
@@ -2981,9 +3010,9 @@ class CCustomTxRevertVisitor : public CCustomTxVisitor
     }
 };
 
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage) {
+Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID) {
     try {
-        return boost::apply_visitor(CCustomMetadataParseVisitor(height, consensus, metadata), txMessage);
+        return boost::apply_visitor(CCustomMetadataParseVisitor(height, consensus, metadata, vaultID), txMessage);
     } catch (const std::exception& e) {
         return Res::Err(e.what());
     } catch (...) {
@@ -3019,7 +3048,7 @@ bool ShouldReturnNonFatalError(const CTransaction& tx, uint32_t height) {
     return it != skippedTx.end() && it->second == tx.GetHash();
 }
 
-Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView *burnView) {
+Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView *burnView, CVaultHistoryView *vaultView) {
     if (tx.IsCoinBase() && height > 0) { // genesis contains custom coinbase txs
         return Res::Ok();
     }
@@ -3039,8 +3068,10 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
             break;
     }
     auto txMessage = customTypeToMessage(txType);
-    CAccountsHistoryEraser view(mnview, height, txn, historyView, burnView);
-    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage))) {
+    CAccountsHistoryEraser view(mnview, height, txn, historyView, burnView, vaultView);
+    uint256 vaultID;
+    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID))) {
+        view.vaultID = vaultID;
         res = CustomTxRevert(view, coins, tx, height, consensus, txMessage);
 
         // Track burn fee
@@ -3057,7 +3088,7 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
     return (view.Flush(), res);
 }
 
-Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView) {
+Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView, CVaultHistoryView *vaultView) {
     auto res = Res::Ok();
     if (tx.IsCoinBase() && height > 0) { // genesis contains custom coinbase txs
         return res;
@@ -3072,8 +3103,10 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
         return Res::ErrCode(CustomTxErrCodes::Fatal, "Invalid custom transaction");
     }
     auto txMessage = customTypeToMessage(txType);
-    CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), historyView, burnView);
-    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage))) {
+    CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), historyView, burnView, vaultView);
+    uint256 vaultID;
+    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID))) {
+        view.vaultID = vaultID;
         res = CustomTxVisit(view, coins, tx, height, consensus, txMessage, time);
 
         // Track burn fee
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index e1fdc7456c..9112b7e4c9 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -21,6 +21,7 @@ class CCoinsViewCache;
 class CCustomCSView;
 class CAccountsHistoryView;
 class CCustomTxVisitor;
+class CVaultHistoryView;
 
 static const std::vector<unsigned char> DfTxMarker = {'D', 'f', 'T', 'x'};  // 44665478
 
@@ -368,9 +369,9 @@ typedef boost::variant<
 CCustomTxMessage customTypeToMessage(CustomTxType txType);
 bool IsMempooledCustomTxCreate(const CTxMemPool& pool, const uint256& txid);
 Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& type, UniValue& results);
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage);
-Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint32_t txn = 0, CAccountsHistoryView* historyView = nullptr, CAccountsHistoryView *burnView = nullptr);
-Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint32_t txn = 0, CAccountsHistoryView* historyView = nullptr, CAccountsHistoryView *burnView = nullptr);
+Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID);
+Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint32_t txn = 0, CAccountsHistoryView* historyView = nullptr, CAccountsHistoryView *burnView = nullptr, CVaultHistoryView *vaultView = nullptr);
+Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint32_t txn = 0, CAccountsHistoryView* historyView = nullptr, CAccountsHistoryView *burnView = nullptr, CVaultHistoryView *vaultView = nullptr);
 Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time = 0);
 ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView& mnview, const CTransaction& tx, int height, const uint256& prevStakeModifier, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
 ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView& mnview, const CTransaction& tx, int height, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
diff --git a/src/masternodes/mn_rpc.cpp b/src/masternodes/mn_rpc.cpp
index b13f2c5d1b..550934f405 100644
--- a/src/masternodes/mn_rpc.cpp
+++ b/src/masternodes/mn_rpc.cpp
@@ -425,7 +425,8 @@ void execTestTx(const CTransaction& tx, uint32_t height, CTransactionRef optAuth
     std::vector<unsigned char> metadata;
     auto txType = GuessCustomTxType(tx, metadata);
     auto txMessage = customTypeToMessage(txType);
-    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage);
+    uint256 vaultID;
+    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID);
     if (res) {
         LOCK(cs_main);
         CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index e7596f46ac..81a56d417a 100644
--- a/src/masternodes/rpc_customtx.cpp
+++ b/src/masternodes/rpc_customtx.cpp
@@ -452,7 +452,8 @@ Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& txType, UniVa
         return Res::Ok();
     }
     auto txMessage = customTypeToMessage(txType);
-    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage);
+    uint256 vaultID;
+    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID);
     if (res) {
         CCustomCSView mnview(*pcustomcsview);
         boost::apply_visitor(CCustomTxRpcVisitor(tx, height, mnview, results), txMessage);
diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index 30c51cfe8e..52e3f89314 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1,6 +1,7 @@
 #include <masternodes/accountshistory.h>
 #include <masternodes/auctionhistory.h>
 #include <masternodes/mn_rpc.h>
+#include <masternodes/vaulthistory.h>
 
 extern UniValue AmountsToJSON(TAmounts const & diffs);
 extern std::string tokenAmountString(CTokenAmount const& amount);
@@ -1146,6 +1147,178 @@ UniValue listauctionhistory(const JSONRPCRequest& request) {
     return ret;
 }
 
+UniValue vaultHistoryToJSON(VaultHistoryKey const & key, VaultHistoryValue const & value) {
+    UniValue obj(UniValue::VOBJ);
+
+    obj.pushKV("vault", key.vaultID.ToString());
+    obj.pushKV("address", ScriptToString(key.address));
+    obj.pushKV("blockHeight", (uint64_t) key.blockHeight);
+    if (auto block = ::ChainActive()[key.blockHeight]) {
+        obj.pushKV("blockHash", block->GetBlockHash().GetHex());
+        obj.pushKV("blockTime", block->GetBlockTime());
+    }
+    obj.pushKV("type", ToString(CustomTxCodeToType(value.category)));
+    obj.pushKV("txn", (uint64_t) key.txn);
+    obj.pushKV("txid", value.txid.ToString());
+    obj.pushKV("amounts", AmountsToJSON(value.diff));
+    return obj;
+}
+
+UniValue getvaulthistory(const JSONRPCRequest& request) {
+    auto pwallet = GetWallet(request);
+
+    RPCHelpMan{"getvaulthistory",
+               "\nReturns the history of the specified vault.\n",
+               {
+                       {"vaultId", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Vault to get history for"},
+                       {"options", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                        {
+                                {"maxBlockHeight", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
+                                 "Optional height to iterate from (down to genesis block), (default = chaintip)."},
+                                {"depth", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
+                                 "Maximum depth, from the genesis block is the default"},
+                                {"token", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
+                                 "Filter by token"},
+                                {"txtype", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
+                                 "Filter by transaction type, supported letter from {CustomTxType}"},
+                                {"limit", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
+                                 "Maximum number of records to return, 100 by default"},
+                        },
+                       },
+               },
+               RPCResult{
+                       "[{},{}...]     (array) Objects with vault history information\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("listburnhistory", "84b22eee1964768304e624c416f29a91d78a01dc5e8e12db26bdac0670c67bb2 '{\"maxBlockHeight\":160,\"depth\":10}'")
+                       + HelpExampleRpc("listburnhistory", "84b22eee1964768304e624c416f29a91d78a01dc5e8e12db26bdac0670c67bb2, '{\"maxBlockHeight\":160,\"depth\":10}'")
+               },
+    }.Check(request);
+
+    uint256 vaultID = ParseHashV(request.params[0], "vaultId");
+    uint32_t maxBlockHeight = std::numeric_limits<uint32_t>::max();
+    uint32_t depth = maxBlockHeight;
+    std::string tokenFilter;
+    uint32_t limit = 100;
+    auto txType = CustomTxType::None;
+    bool txTypeSearch{false};
+
+    if (request.params.size() == 2) {
+        UniValue optionsObj = request.params[1].get_obj();
+        RPCTypeCheckObj(optionsObj,
+                        {
+                                {"maxBlockHeight", UniValueType(UniValue::VNUM)},
+                                {"depth", UniValueType(UniValue::VNUM)},
+                                {"token", UniValueType(UniValue::VSTR)},
+                                {"txtype", UniValueType(UniValue::VSTR)},
+                                {"limit", UniValueType(UniValue::VNUM)},
+                        }, true, true);
+
+        if (!optionsObj["maxBlockHeight"].isNull()) {
+            maxBlockHeight = (uint32_t) optionsObj["maxBlockHeight"].get_int64();
+        }
+
+        if (!optionsObj["depth"].isNull()) {
+            depth = (uint32_t) optionsObj["depth"].get_int64();
+        }
+
+        if (!optionsObj["token"].isNull()) {
+            tokenFilter = optionsObj["token"].get_str();
+        }
+
+        if (!optionsObj["txtype"].isNull()) {
+            const auto str = optionsObj["txtype"].get_str();
+            if (str.size() == 1) {
+                // Will search for type ::None if txtype not found.
+                txType = CustomTxCodeToType(str[0]);
+                txTypeSearch = true;
+            }
+        }
+
+        if (!optionsObj["limit"].isNull()) {
+            limit = (uint32_t) optionsObj["limit"].get_int64();
+        }
+
+        if (limit == 0) {
+            limit = std::numeric_limits<uint32_t>::max();
+        }
+    }
+
+    pwallet->BlockUntilSyncedToCurrentChain();
+
+    std::function<bool(uint256 const &)> isMatchVault = [&vaultID](uint256 const & id) {
+        return id == vaultID;
+    };
+
+    std::set<uint256> txs;
+
+    auto hasToken = [&tokenFilter](TAmounts const & diffs) {
+        for (auto const & diff : diffs) {
+            auto token = pcustomcsview->GetToken(diff.first);
+            auto const tokenIdStr = token->CreateSymbolKey(diff.first);
+            if(tokenIdStr == tokenFilter) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    LOCK(cs_main);
+    std::map<uint32_t, UniValue, std::greater<uint32_t>> ret;
+
+    maxBlockHeight = std::min(maxBlockHeight, uint32_t(::ChainActive().Height()));
+    depth = std::min(depth, maxBlockHeight);
+
+    const auto startBlock = maxBlockHeight - depth;
+    auto shouldSkipBlock = [startBlock, maxBlockHeight](uint32_t blockHeight) {
+        return startBlock > blockHeight || blockHeight > maxBlockHeight;
+    };
+
+    auto count = limit;
+
+    auto shouldContinue = [&](VaultHistoryKey const & key, CLazySerialize<VaultHistoryValue> valueLazy) -> bool
+    {
+        if (!isMatchVault(key.vaultID)) {
+            return false;
+        }
+
+        if (shouldSkipBlock(key.blockHeight)) {
+            return true;
+        }
+
+        const auto & value = valueLazy.get();
+
+        if (txTypeSearch && value.category != uint8_t(txType)) {
+            return true;
+        }
+
+        if(!tokenFilter.empty() && !hasToken(value.diff)) {
+            return true;
+        }
+
+        auto& array = ret.emplace(key.blockHeight, UniValue::VARR).first->second;
+        array.push_back(vaultHistoryToJSON(key, value));
+
+        --count;
+
+        return count != 0;
+    };
+
+    VaultHistoryKey startKey{vaultID, maxBlockHeight, std::numeric_limits<uint32_t>::max(), {}};
+    pvaultHistoryDB->ForEachVaultHistory(shouldContinue, startKey);
+
+    UniValue slice(UniValue::VARR);
+    for (auto it = ret.cbegin(); limit != 0 && it != ret.cend(); ++it) {
+        const auto& array = it->second.get_array();
+        for (size_t i = 0; limit != 0 && i < array.size(); ++i) {
+            slice.push_back(array[i]);
+            --limit;
+        }
+    }
+
+    return slice;
+}
+
 static const CRPCCommand commands[] =
 {
 //  category        name                         actor (function)        params
@@ -1154,6 +1327,7 @@ static const CRPCCommand commands[] =
     {"vault",        "closevault",                &closevault,            {"id", "returnAddress", "inputs"}},
     {"vault",        "listvaults",                &listvaults,            {"options", "pagination"}},
     {"vault",        "getvault",                  &getvault,              {"id"}},
+    {"vault",        "getvaulthistory",           &getvaulthistory,       {"id", "options"}},
     {"vault",        "updatevault",               &updatevault,           {"id", "parameters", "inputs"}},
     {"vault",        "deposittovault",            &deposittovault,        {"id", "from", "amount", "inputs"}},
     {"vault",        "withdrawfromvault",         &withdrawfromvault,     {"id", "to", "amount", "inputs"}},
diff --git a/src/masternodes/vaulthistory.cpp b/src/masternodes/vaulthistory.cpp
new file mode 100644
index 0000000000..c8fa6e1273
--- /dev/null
+++ b/src/masternodes/vaulthistory.cpp
@@ -0,0 +1,25 @@
+#include <masternodes/vaulthistory.h>
+
+void CVaultHistoryView::ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start)
+{
+    ForEach<ByVaultHistoryKey, VaultHistoryKey, VaultHistoryValue>(callback, start);
+}
+
+Res CVaultHistoryView::WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value) {
+    WriteBy<ByVaultHistoryKey>(key, value);
+    return Res::Ok();
+}
+
+Res CVaultHistoryView::EraseVaultHistory(const VaultHistoryKey& key)
+{
+    EraseBy<ByVaultHistoryKey>(key);
+    return Res::Ok();
+}
+
+
+CVaultHistoryStorage::CVaultHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
+        : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe))
+{
+}
+
+std::unique_ptr<CVaultHistoryStorage> pvaultHistoryDB;
diff --git a/src/masternodes/vaulthistory.h b/src/masternodes/vaulthistory.h
new file mode 100644
index 0000000000..4208243b97
--- /dev/null
+++ b/src/masternodes/vaulthistory.h
@@ -0,0 +1,78 @@
+// 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_VAULTHISTORY_H
+#define DEFI_MASTERNODES_VAULTHISTORY_H
+
+#include <amount.h>
+#include <flushablestorage.h>
+#include <masternodes/masternodes.h>
+#include <masternodes/vault.h>
+#include <script/script.h>
+
+struct VaultHistoryKey {
+    uint256 vaultID;
+    uint32_t blockHeight;
+    uint32_t txn; // for order in block
+    CScript address;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(vaultID);
+
+        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_));
+        }
+
+        READWRITE(address);
+    }
+};
+
+struct VaultHistoryValue {
+    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 CVaultHistoryView : public virtual CStorageView
+{
+public:
+    Res WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value);
+    Res EraseVaultHistory(const VaultHistoryKey& key);
+    void ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start = {});
+
+    struct ByVaultHistoryKey { static constexpr uint8_t prefix() { return 0x01; } };
+};
+
+class CVaultHistoryStorage : public CVaultHistoryView
+{
+public:
+    CVaultHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
+};
+
+extern std::unique_ptr<CVaultHistoryStorage> pvaultHistoryDB;
+
+static constexpr bool DEFAULT_VAULTINDEX = true;
+
+#endif //DEFI_MASTERNODES_VAULTHISTORY_H
\ No newline at end of file
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 951c81fc8e..173efc2324 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -256,6 +256,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "withdrawfromvault", 3, "inputs" },
     { "placeauctionbid", 1, "index" },
     { "placeauctionbid", 4, "inputs" },
+    { "getvaulthistory", 1, "options" },
     { "listvaults", 0, "options" },
     { "listvaults", 1, "pagination" },
     { "listauctions", 0, "pagination" },
diff --git a/src/validation.cpp b/src/validation.cpp
index 2ff3ad4634..880f8de9b5 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -24,6 +24,7 @@
 #include <masternodes/govvariables/lp_daily_dfi_reward.h>
 #include <masternodes/masternodes.h>
 #include <masternodes/mn_checks.h>
+#include <masternodes/vaulthistory.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -1778,7 +1779,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
 
         // process transactions revert for masternodes
         mnview.OnUndoTx(tx.GetHash(), (uint32_t) pindex->nHeight);
-        auto res = RevertCustomTx(mnview, view, tx, Params().GetConsensus(), (uint32_t) pindex->nHeight, i, paccountHistoryDB.get(), pburnHistoryDB.get());
+        auto res = RevertCustomTx(mnview, view, tx, Params().GetConsensus(), (uint32_t) pindex->nHeight, i, paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get());
         if (!res) {
             LogPrintf("%s\n", res.msg);
         }
@@ -2546,7 +2547,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                     tx.GetHash().ToString(), FormatStateMessage(state));
             }
 
-            const auto res = ApplyCustomTx(accountsView, view, tx, chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), i, paccountHistoryDB.get(), pburnHistoryDB.get());
+            const auto res = ApplyCustomTx(accountsView, view, tx, chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), i, paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get());
             if (!res.ok && (res.code & CustomTxErrCodes::Fatal)) {
                 if (pindex->nHeight >= chainparams.GetConsensus().EunosHeight) {
                     return state.Invalid(ValidationInvalidReason::CONSENSUS,
@@ -2779,7 +2780,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                     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()},
+                     pburnHistoryDB->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
@@ -3152,7 +3153,7 @@ void CChainState::ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& ca
         });
     }
 
-    CAccountsHistoryWriter view(cache, pindex->nHeight, ~0u, {}, uint8_t(CustomTxType::AuctionBid), nullptr, pburnHistoryDB.get());
+    CAccountsHistoryWriter view(cache, pindex->nHeight, ~0u, {}, uint8_t(CustomTxType::AuctionBid), nullptr, pburnHistoryDB.get(), pvaultHistoryDB.get());
 
     view.ForEachVaultAuction([&](const CVaultId& vaultId, const CAuctionData& data) {
         if (data.liquidationHeight != uint32_t(pindex->nHeight)) {
@@ -3536,6 +3537,9 @@ bool CChainState::DisconnectTip(CValidationState& state, const CChainParams& cha
             if (pburnHistoryDB) {
                 pburnHistoryDB->Discard();
             }
+            if (pvaultHistoryDB) {
+                pvaultHistoryDB->Discard();
+            }
             m_disconnectTip = false;
             return error("DisconnectTip(): DisconnectBlock %s failed", pindexDelete->GetBlockHash().ToString());
         }
@@ -3549,6 +3553,9 @@ bool CChainState::DisconnectTip(CValidationState& state, const CChainParams& cha
         if (pburnHistoryDB) {
             pburnHistoryDB->Flush();
         }
+        if (pvaultHistoryDB) {
+            pvaultHistoryDB->Flush();
+        }
 
         if (!disconnectedConfirms.empty()) {
             for (auto const & confirm : disconnectedConfirms) {
@@ -3700,6 +3707,9 @@ bool CChainState::ConnectTip(CValidationState& state, const CChainParams& chainp
             if (pburnHistoryDB) {
                 pburnHistoryDB->Discard();
             }
+            if (pvaultHistoryDB) {
+                pvaultHistoryDB->Discard();
+            }
             return error("%s: ConnectBlock %s failed, %s", __func__, pindexNew->GetBlockHash().ToString(), FormatStateMessage(state));
         }
         nTime3 = GetTimeMicros(); nTimeConnectTotal += nTime3 - nTime2;
@@ -3714,6 +3724,9 @@ bool CChainState::ConnectTip(CValidationState& state, const CChainParams& chainp
         if (pburnHistoryDB) {
             pburnHistoryDB->Flush();
         }
+        if (pvaultHistoryDB) {
+            pvaultHistoryDB->Flush();
+        }
 
         // anchor rewards re-voting etc...
         if (!rewardedAnchors.empty()) {
diff --git a/test/functional/rpc_getvaulthistory.py b/test/functional/rpc_getvaulthistory.py
new file mode 100755
index 0000000000..2d7456304e
--- /dev/null
+++ b/test/functional/rpc_getvaulthistory.py
@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2019 The Bitcoin Core developers
+# 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.
+"""Test getvaulthistory RPC."""
+
+from test_framework.test_framework import DefiTestFramework
+
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal
+from decimal import Decimal
+import calendar
+import time
+
+class TokensRPCGetVaultHistory(DefiTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-bayfrontgardensheight=50', '-dakotaheight=100', '-eunosheight=100', '-eunospayaheight=100', '-fortcanningheight=100']]
+
+    def run_test(self):
+        self.nodes[0].generate(101)
+
+        # Collateral address
+        collateral_a = self.nodes[0].getnewaddress("", "legacy")
+
+        # Appoint oracle
+        oracle_address = self.nodes[0].getnewaddress("", "legacy")
+        appoint_oracle_tx = self.nodes[0].appointoracle(oracle_address, [{"currency": "USD", "token": "DFI"},{"currency": "USD", "token": "TSLA"}], 10)
+        self.nodes[0].generate(1)
+
+        # Test set oracle data
+        oracle_prices = [{"currency": "USD", "tokenAmount": "100.00000000@DFI"},{"currency": "USD", "tokenAmount": "100.00000000@TSLA"}]
+        timestamp = calendar.timegm(time.gmtime())
+        self.nodes[0].setoracledata(appoint_oracle_tx, timestamp, oracle_prices)
+        self.nodes[0].generate(1)
+        self.sync_blocks(self.nodes[0:2])
+
+        # Create loan schemes
+        self.nodes[0].createloanscheme(150, 5, 'LOAN0001')
+        self.nodes[0].generate(1)
+
+        # Create DUSD token
+        self.nodes[0].createtoken({
+            "symbol": "DUSD",
+            "name": "DUSD",
+            "isDAT": True,
+            "collateralAddress": self.nodes[0].get_genesis_keys().ownerAuthAddress
+        })
+        self.nodes[0].generate(1)
+
+        # Set loan token
+        self.nodes[0].setloantoken({
+                                    'symbol': 'TSLA',
+                                    'name': "Tesla stock token",
+                                    'fixedIntervalPriceId': "TSLA/USD",
+                                    'mintable': True,
+                                    'interest': 1})
+        self.nodes[0].generate(1)
+
+        # Create pool pairs
+        pool_collateral = self.nodes[0].getnewaddress("", "legacy")
+        self.nodes[0].createpoolpair({
+            "tokenA": "TSLA",
+            "tokenB": "DUSD",
+            "commission": 0.001,
+            "status": True,
+            "ownerAddress": pool_collateral,
+            "pairSymbol": "TSLA-DUSD"
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].createpoolpair({
+            "tokenA": "DFI",
+            "tokenB": "DUSD",
+            "commission": 0.001,
+            "status": True,
+            "ownerAddress": pool_collateral,
+            "pairSymbol": "DFI-DUSD"
+        })
+        self.nodes[0].generate(1)
+
+        # Mint tokens
+        self.nodes[0].minttokens(["300@TSLA", "300@DUSD"])
+        self.nodes[0].generate(1)
+
+        # Fund ownerAuthAddress
+        self.nodes[0].utxostoaccount({self.nodes[0].get_genesis_keys().ownerAuthAddress: "100@DFI"})
+        self.nodes[0].generate(1)
+
+        # Add pool liquidity
+        pool_share = self.nodes[0].getnewaddress("", "legacy")
+        self.nodes[0].addpoolliquidity({
+            self.nodes[0].get_genesis_keys().ownerAuthAddress: ['100@TSLA', '100@DUSD']
+            }, pool_share)
+        self.nodes[0].generate(1)
+
+        self.nodes[0].addpoolliquidity({
+            self.nodes[0].get_genesis_keys().ownerAuthAddress: ['100@DUSD', '100@DFI']
+            }, pool_share)
+        self.nodes[0].generate(1)
+
+        # Set collateral token
+        self.nodes[0].setcollateraltoken({
+                                    'token': "DFI",
+                                    'factor': 1,
+                                    'fixedIntervalPriceId': "DFI/USD"})
+        self.nodes[0].generate(1)
+
+        # Create vault
+        vault_owner = self.nodes[0].getnewaddress("", "legacy")
+        create_vault_tx = self.nodes[0].createvault(vault_owner, 'LOAN0001')
+        self.nodes[0].generate(1)
+
+        # Deposit to vault
+        self.nodes[0].utxostoaccount({collateral_a: "100@0"})
+        self.nodes[0].generate(1)
+        deposit_tx = self.nodes[0].deposittovault(create_vault_tx, collateral_a, '10@DFI')
+        self.nodes[0].generate(1)
+
+        # Take loan
+        takeloan_tx = self.nodes[0].takeloan({'vaultId':create_vault_tx,'amounts': "1@TSLA"})
+        self.nodes[0].generate(1)
+
+        # Pay back loan
+        vault = self.nodes[0].getvault(create_vault_tx)
+        payback_tx = self.nodes[0].paybackloan({
+            'vaultId':create_vault_tx,
+            'from':self.nodes[0].get_genesis_keys().ownerAuthAddress,
+            'amounts':vault['loanAmounts']
+            })
+        self.nodes[0].generate(1)
+
+        # Withdraw from vault
+        withdraw_address = self.nodes[0].getnewaddress("", "legacy")
+        withdraw_tx = self.nodes[0].withdrawfromvault(create_vault_tx, withdraw_address, '0.5@DFI')
+        self.nodes[0].generate(1)
+
+        # Close vault
+        close_address = self.nodes[0].getnewaddress("", "legacy")
+        close_tx = self.nodes[0].closevault(create_vault_tx, close_address)
+        self.nodes[0].generate(1)
+
+        # Test getvaulthistory
+        result = self.nodes[0].getvaulthistory(create_vault_tx)
+        assert_equal(len(result), 6)
+        assert_equal(result[0]['vault'], create_vault_tx)
+        assert_equal(result[0]['type'], 'CloseVault')
+        assert_equal(result[0]['address'], close_address)
+        assert_equal(result[0]['amounts'], ['10.00000000@DFI'])
+        assert_equal(result[0]['txid'], close_tx)
+        assert_equal(result[1]['vault'], create_vault_tx)
+        assert_equal(result[1]['type'], 'WithdrawFromVault')
+        assert_equal(result[1]['address'], withdraw_address)
+        assert_equal(result[1]['amounts'], ['0.50000000@DFI'])
+        assert_equal(result[1]['txid'], withdraw_tx)
+        assert_equal(result[2]['vault'], create_vault_tx)
+        assert_equal(result[2]['type'], 'PaybackLoan')
+        assert_equal(result[2]['address'], 'mfburnZSAM7Gs1hpDeNaMotJXSGA7edosG')
+        assert_equal(result[2]['amounts'], ['0.00000114@DFI'])
+        assert_equal(result[2]['txid'], payback_tx)
+        assert_equal(result[3]['vault'], create_vault_tx)
+        assert_equal(result[3]['type'], 'PaybackLoan')
+        assert_equal(result[3]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
+        assert_equal(result[3]['amounts'], ['-1.00000114@TSLA'])
+        assert_equal(result[3]['txid'], payback_tx)
+        assert_equal(result[4]['vault'], create_vault_tx)
+        assert_equal(result[4]['type'], 'TakeLoan')
+        assert_equal(result[4]['address'], vault_owner)
+        assert_equal(result[4]['amounts'], ['1.00000000@TSLA'])
+        assert_equal(result[4]['txid'], takeloan_tx)
+        assert_equal(result[5]['vault'], create_vault_tx)
+        assert_equal(result[5]['type'], 'DepositToVault')
+        assert_equal(result[5]['address'], collateral_a)
+        assert_equal(result[5]['amounts'], ['-10.00000000@DFI'])
+        assert_equal(result[5]['txid'], deposit_tx)
+
+        # Test getvaulthistory block height and depth
+        result = self.nodes[0].getvaulthistory(create_vault_tx, {'maxBlockHeight':119,'depth':1})
+        assert_equal(len(result), 3)
+        assert_equal(result[0]['vault'], create_vault_tx)
+        assert_equal(result[0]['type'], 'WithdrawFromVault')
+        assert_equal(result[0]['address'], withdraw_address)
+        assert_equal(result[0]['amounts'], ['0.50000000@DFI'])
+        assert_equal(result[0]['txid'], withdraw_tx)
+        assert_equal(result[1]['vault'], create_vault_tx)
+        assert_equal(result[1]['type'], 'PaybackLoan')
+        assert_equal(result[1]['address'], 'mfburnZSAM7Gs1hpDeNaMotJXSGA7edosG')
+        assert_equal(result[1]['amounts'], ['0.00000114@DFI'])
+        assert_equal(result[1]['txid'], payback_tx)
+        assert_equal(result[2]['vault'], create_vault_tx)
+        assert_equal(result[2]['type'], 'PaybackLoan')
+        assert_equal(result[2]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
+        assert_equal(result[2]['amounts'], ['-1.00000114@TSLA'])
+        assert_equal(result[2]['txid'], payback_tx)
+
+        # Test getvaulthistory token type
+        result = self.nodes[0].getvaulthistory(create_vault_tx, {'token':'TSLA'})
+        assert_equal(len(result), 2)
+        assert_equal(result[0]['vault'], create_vault_tx)
+        assert_equal(result[0]['type'], 'PaybackLoan')
+        assert_equal(result[0]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
+        assert_equal(result[0]['amounts'], ['-1.00000114@TSLA'])
+        assert_equal(result[0]['txid'], payback_tx)
+        assert_equal(result[1]['vault'], create_vault_tx)
+        assert_equal(result[1]['type'], 'TakeLoan')
+        assert_equal(result[1]['address'], vault_owner)
+        assert_equal(result[1]['amounts'], ['1.00000000@TSLA'])
+        assert_equal(result[1]['txid'], takeloan_tx)
+
+        # Test getvaulthistory TX type
+        result = self.nodes[0].getvaulthistory(create_vault_tx, {'txtype':'J'})
+        assert_equal(len(result), 1)
+        assert_equal(result[0]['vault'], create_vault_tx)
+        assert_equal(result[0]['type'], 'WithdrawFromVault')
+        assert_equal(result[0]['address'], withdraw_address)
+        assert_equal(result[0]['amounts'], ['0.50000000@DFI'])
+        assert_equal(result[0]['txid'], withdraw_tx)
+
+        # Test getvaulthistory limit
+        result = self.nodes[0].getvaulthistory(create_vault_tx, {'limit':1})
+        assert_equal(len(result), 1)
+        assert_equal(result[0]['vault'], create_vault_tx)
+        assert_equal(result[0]['type'], 'CloseVault')
+        assert_equal(result[0]['address'], close_address)
+        assert_equal(result[0]['amounts'], ['10.00000000@DFI'])
+        assert_equal(result[0]['txid'], close_tx)
+
+        # Test rollback of tip to remove CloseVault TX
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        self.nodes[0].clearmempool()
+        result = self.nodes[0].getvaulthistory(create_vault_tx)
+
+        # Quick check of last entry
+        assert_equal(len(result), 5)
+        assert_equal(result[0]['type'], 'WithdrawFromVault')
+
+        # Create new vault
+        new_vault = self.nodes[0].createvault(vault_owner, 'LOAN0001')
+        self.nodes[0].generate(1)
+
+        # Fund vault owner
+        self.nodes[0].utxostoaccount({vault_owner: "100@DFI"})
+        self.nodes[0].generate(1)
+
+        # Deposit to vault
+        deposit_tx = self.nodes[0].deposittovault(new_vault, vault_owner, '10@DFI')
+        self.nodes[0].generate(1)
+
+        # Take loan
+        takeloan_tx = self.nodes[0].takeloan({'vaultId': new_vault,'amounts': '6.68896@TSLA'})
+        self.nodes[0].generate(4)
+
+        # Fund another bidding address
+        new_bidding_address = self.nodes[0].getnewaddress("", "legacy")
+        self.nodes[0].accounttoaccount(self.nodes[0].get_genesis_keys().ownerAuthAddress, {new_bidding_address: "10@TSLA"})
+        self.nodes[0].generate(1)
+
+        # Place bids
+        bid1_tx = self.nodes[0].placeauctionbid(new_vault, 0, self.nodes[0].get_genesis_keys().ownerAuthAddress, '8@TSLA')
+        self.nodes[0].generate(1)
+        bid2_tx = self.nodes[0].placeauctionbid(new_vault, 0, new_bidding_address, '9@TSLA')
+        self.nodes[0].generate(1)
+
+        # Check bids in result
+        result = self.nodes[0].getvaulthistory(new_vault)
+        assert_equal(len(result), 5)
+        assert_equal(result[0]['vault'], new_vault)
+        assert_equal(result[0]['type'], 'AuctionBid')
+        assert_equal(result[0]['txid'], bid2_tx)
+        assert_equal(result[1]['vault'], new_vault)
+        assert_equal(result[1]['type'], 'AuctionBid')
+        assert_equal(result[1]['txid'], bid2_tx)
+
+        if result[0]['address'] == new_bidding_address:
+            assert_equal(result[0]['amounts'], ['-9.00000000@TSLA'])
+            assert_equal(result[1]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
+            assert_equal(result[1]['amounts'], ['8.00000000@TSLA'])
+        elif result[0]['address'] == self.nodes[0].get_genesis_keys().ownerAuthAddress:
+            assert_equal(result[0]['amounts'], ['8.00000000@TSLA'])
+            assert_equal(result[1]['address'], new_bidding_address)
+            assert_equal(result[1]['amounts'], ['-9.00000000@TSLA'])
+        else:
+            assert('Expected address not found in results')
+
+        assert_equal(result[2]['vault'], new_vault)
+        assert_equal(result[2]['type'], 'AuctionBid')
+        assert_equal(result[2]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
+        assert_equal(result[2]['amounts'], ['-8.00000000@TSLA'])
+        assert_equal(result[2]['txid'], bid1_tx)
+        assert_equal(result[3]['vault'], new_vault)
+        assert_equal(result[3]['type'], 'TakeLoan')
+        assert_equal(result[3]['address'], vault_owner)
+        assert_equal(result[3]['amounts'], ['6.68896000@TSLA'])
+        assert_equal(result[3]['txid'], takeloan_tx)
+        assert_equal(result[4]['vault'], new_vault)
+        assert_equal(result[4]['type'], 'DepositToVault')
+        assert_equal(result[4]['address'], vault_owner)
+        assert_equal(result[4]['amounts'], ['-10.00000000@DFI'])
+        assert_equal(result[4]['txid'], deposit_tx)
+
+if __name__ == '__main__':
+    TokensRPCGetVaultHistory().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index a7a42cdb97..7517b33576 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -248,6 +248,7 @@
     'rpc_deriveaddresses.py --usecli',
     'rpc_scantxoutset.py',
     'rpc_getcustomtx.py',
+    'rpc_getvaulthistory.py',
     'feature_logging.py',
     'feature_loan_scheme.py',
     'feature_forced_reward_address.py',

From 8429892fdddd5b194227f43694f69a74fe1196bb Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Wed, 10 Nov 2021 14:18:21 +0000
Subject: [PATCH 02/12] Prevent call without pvaultHistoryDB

---
 src/masternodes/rpc_vault.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index 52e3f89314..be96c8f1b9 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1195,6 +1195,10 @@ UniValue getvaulthistory(const JSONRPCRequest& request) {
                },
     }.Check(request);
 
+    if (!pvaultHistoryDB) {
+        throw JSONRPCError(RPC_INVALID_REQUEST, "-vaultindex required for vault history");
+    }
+
     uint256 vaultID = ParseHashV(request.params[0], "vaultId");
     uint32_t maxBlockHeight = std::numeric_limits<uint32_t>::max();
     uint32_t depth = maxBlockHeight;

From b86cc3983fe053edff848f67ef38c0fa1008af03 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Wed, 10 Nov 2021 14:23:21 +0000
Subject: [PATCH 03/12] lint: fix errors

---
 test/functional/rpc_getvaulthistory.py  | 2 --
 test/lint/lint-circular-dependencies.sh | 2 ++
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/functional/rpc_getvaulthistory.py b/test/functional/rpc_getvaulthistory.py
index 2d7456304e..15e824076a 100755
--- a/test/functional/rpc_getvaulthistory.py
+++ b/test/functional/rpc_getvaulthistory.py
@@ -7,9 +7,7 @@
 
 from test_framework.test_framework import DefiTestFramework
 
-from test_framework.authproxy import JSONRPCException
 from test_framework.util import assert_equal
-from decimal import Decimal
 import calendar
 import time
 
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 9027e6955b..49c8f59e95 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -31,6 +31,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "chainparams -> masternodes/mn_checks -> validation -> wallet/wallet -> chainparams"
     "chainparams -> masternodes/mn_checks -> chainparams"
     "chainparams -> masternodes/mn_checks -> masternodes/anchors -> chainparams"
+    "chainparams -> masternodes/mn_checks -> validation -> masternodes/vaulthistory -> masternodes/vault -> chainparams"
     "consensus/tx_verify -> masternodes/masternodes -> validation -> consensus/tx_verify"
     "consensus/tx_verify -> masternodes/mn_checks -> txmempool -> consensus/tx_verify"
     "masternodes/govvariables/icx_takerfee_per_btc -> masternodes/gv -> masternodes/govvariables/icx_takerfee_per_btc"
@@ -49,6 +50,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "masternodes/masternodes -> validation -> masternodes/masternodes"
     "masternodes/masternodes -> net_processing -> masternodes/masternodes"
     "masternodes/masternodes -> wallet/wallet -> masternodes/masternodes"
+    "masternodes/masternodes -> validation -> masternodes/vaulthistory -> masternodes/masternodes"
     "masternodes/mn_checks -> txmempool -> masternodes/mn_checks"
     "masternodes/mn_checks -> validation -> masternodes/mn_checks"
     "masternodes/mn_checks -> validation -> wallet/wallet -> masternodes/mn_checks"

From 70f6fc5ecc19d4e07c3e000f242b8bbf3081cc06 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Tue, 16 Nov 2021 07:27:33 +0000
Subject: [PATCH 04/12] Add vault state to vault DB.

---
 src/init.cpp                           |   1 -
 src/masternodes/accountshistory.cpp    | 159 +++++++++++++++----------
 src/masternodes/accountshistory.h      |  58 ++++++---
 src/masternodes/masternodes.h          |  10 ++
 src/masternodes/mn_checks.cpp          |  18 +--
 src/masternodes/mn_checks.h            |   6 +-
 src/masternodes/rpc_vault.cpp          |  86 +++++++++++--
 src/masternodes/vaulthistory.cpp       |  59 ++++++++-
 src/masternodes/vaulthistory.h         |  54 ++++++++-
 src/validation.cpp                     |  27 ++++-
 test/functional/rpc_getvaulthistory.py |  70 ++++++-----
 11 files changed, 407 insertions(+), 141 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index bba94d87db..e78af93e27 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -463,7 +463,6 @@ void SetupServerArgs()
     gArgs.AddArg("-anchorquorum", "Min quorum size (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-spv", "Enable SPV to bitcoin blockchain (default: 1)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-spv_resync", "Flag to reset spv database and resync from zero block (default: 0)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    gArgs.AddArg("-spv_rescan", "Block height to rescan from (default: 0 = off)", ArgsManager::ALLOW_INT, OptionsCategory::OPTIONS);
     gArgs.AddArg("-amkheight", "AMK fork activation height (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-bayfrontheight", "Bayfront fork activation height (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-bayfrontgardensheight", "Bayfront Gardens fork activation height (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
diff --git a/src/masternodes/accountshistory.cpp b/src/masternodes/accountshistory.cpp
index 5a51365f7f..c46d63614e 100644
--- a/src/masternodes/accountshistory.cpp
+++ b/src/masternodes/accountshistory.cpp
@@ -36,51 +36,27 @@ CBurnHistoryStorage::CBurnHistoryStorage(const fs::path& dbName, std::size_t cac
 }
 
 CAccountsHistoryWriter::CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type,
-                                               CAccountsHistoryView* historyView, CAccountsHistoryView* burnView, CVaultHistoryView* vaultView, const uint256& vaultID)
+                                               CHistoryWriters* writers, const uint256& vaultID)
     : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn),
-    txid(txid), type(type), historyView(historyView), burnView(burnView), vaultView(vaultView), vaultID(vaultID)
+    txid(txid), type(type), writers(writers), vaultID(vaultID)
 {
 }
 
 Res CAccountsHistoryWriter::AddBalance(CScript const & owner, CTokenAmount amount)
 {
     auto res = CCustomCSView::AddBalance(owner, amount);
-    if (amount.nValue != 0 && res.ok) {
-        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;
-        }
+    if (writers && amount.nValue != 0 && res.ok) {
+        writers->AddBalance(owner, amount, vaultID);
     }
 
     return res;
 }
 
-Res CAccountsHistoryWriter::AddFeeBurn(CScript const & owner, CAmount amount)
-{
-    if (burnView && amount != 0) {
-        burnDiffs[owner][DCT_ID{0}] += amount;
-    }
-    return Res::Ok();
-}
-
 Res CAccountsHistoryWriter::SubBalance(CScript const & owner, CTokenAmount amount)
 {
     auto res = CCustomCSView::SubBalance(owner, amount);
-    if (res.ok && amount.nValue != 0) {
-        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;
-        }
+    if (writers && res.ok && amount.nValue != 0) {
+        writers->SubBalance(owner, amount, vaultID);
     }
 
     return res;
@@ -88,34 +64,40 @@ Res CAccountsHistoryWriter::SubBalance(CScript const & owner, CTokenAmount amoun
 
 bool CAccountsHistoryWriter::Flush()
 {
-    if (historyView) {
-        for (const auto& diff : diffs) {
-            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({diff.first, height, txn, addresses.first}, {txid, type, addresses.second});
-            }
-        }
+    if (writers) {
+        writers->Flush(height, txid, txn, type);
     }
     return CCustomCSView::Flush();
 }
 
-CAccountsHistoryEraser::CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView,
-                                               CAccountsHistoryView* burnView, CVaultHistoryView* vaultView, const uint256& vaultID)
+CAccountsHistoryEraser::CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CHistoryErasers& erasers, const uint256& vaultID)
     : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn),
-    historyView(historyView), burnView(burnView), vaultView(vaultView),  vaultID(vaultID)
+      erasers(erasers),  vaultID(vaultID)
 {
 }
 
 Res CAccountsHistoryEraser::AddBalance(CScript const & owner, CTokenAmount)
+{
+    erasers.AddBalance(owner, vaultID);
+    return Res::Ok();
+}
+
+Res CAccountsHistoryEraser::SubBalance(CScript const & owner, CTokenAmount)
+{
+    erasers.SubBalance(owner, vaultID);
+    return Res::Ok();
+}
+
+bool CAccountsHistoryEraser::Flush()
+{
+    erasers.Flush(height, txn);
+    return Res::Ok(); // makes sure no changes are applyed to underlaying view
+}
+
+CHistoryErasers::CHistoryErasers(CAccountHistoryStorage* historyView, CBurnHistoryStorage* burnView, CVaultHistoryStorage* vaultView)
+    : historyView(historyView), burnView(burnView), vaultView(vaultView) {}
+
+void CHistoryErasers::AddBalance(const CScript& owner, const uint256& vaultID)
 {
     if (historyView) {
         accounts.insert(owner);
@@ -126,10 +108,16 @@ Res CAccountsHistoryEraser::AddBalance(CScript const & owner, CTokenAmount)
     if (vaultView && !vaultID.IsNull()) {
         vaults.insert(vaultID);
     }
-    return Res::Ok();
 }
 
-Res CAccountsHistoryEraser::SubBalance(CScript const & owner, CTokenAmount)
+void CHistoryErasers::SubFeeBurn(const CScript& owner)
+{
+    if (burnView) {
+        burnAccounts.insert(owner);
+    }
+}
+
+void CHistoryErasers::SubBalance(const CScript& owner, const uint256& vaultID)
 {
     if (historyView) {
         accounts.insert(owner);
@@ -140,18 +128,9 @@ Res CAccountsHistoryEraser::SubBalance(CScript const & owner, CTokenAmount)
     if (vaultView && !vaultID.IsNull()) {
         vaults.insert(vaultID);
     }
-    return Res::Ok();
 }
 
-Res CAccountsHistoryEraser::SubFeeBurn(CScript const & owner)
-{
-    if (burnView) {
-        burnAccounts.insert(owner);
-    }
-    return Res::Ok();
-}
-
-bool CAccountsHistoryEraser::Flush()
+void CHistoryErasers::Flush(const uint32_t height, const uint32_t txn)
 {
     if (historyView) {
         for (const auto& account : accounts) {
@@ -168,7 +147,63 @@ bool CAccountsHistoryEraser::Flush()
             vaultView->EraseVaultHistory({vault, height, txn});
         }
     }
-    return Res::Ok(); // makes sure no changes are applyed to underlaying view
+}
+
+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)
+{
+    if (historyView) {
+        for (const auto& diff : diffs) {
+            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({diff.first, height, txn, addresses.first}, {txid, type, addresses.second});
+            }
+        }
+    }
 }
 
 std::unique_ptr<CAccountHistoryStorage> paccountHistoryDB;
diff --git a/src/masternodes/accountshistory.h b/src/masternodes/accountshistory.h
index bd504a0f50..46b2056fae 100644
--- a/src/masternodes/accountshistory.h
+++ b/src/masternodes/accountshistory.h
@@ -13,6 +13,7 @@
 #include <uint256.h>
 
 class CVaultHistoryView;
+class CVaultHistoryStorage;
 
 struct AccountHistoryKey {
     CScript owner;
@@ -79,27 +80,55 @@ 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;
+    CVaultHistoryStorage* vaultView;
+    std::map<CScript, TAmounts> diffs;
+    std::map<CScript, TAmounts> burnDiffs;
+    std::map<uint256, std::map<CScript,TAmounts>> vaultDiffs;
+
+public:
+    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 Flush(const uint32_t height, const uint256& txid, const uint32_t txn, const uint8_t type);
+};
+
+class CHistoryErasers {
+    CAccountHistoryStorage* historyView;
+    CBurnHistoryStorage* burnView;
+    CVaultHistoryStorage* vaultView;
+    std::set<CScript> accounts;
+    std::set<CScript> burnAccounts;
+    std::set<uint256> vaults;
+
+public:
+    CHistoryErasers(CAccountHistoryStorage* historyView, CBurnHistoryStorage* burnView, CVaultHistoryStorage* vaultView);
+
+    void AddBalance(const CScript& owner, const uint256& vaultID);
+    void SubFeeBurn(const CScript& owner);
+    void SubBalance(const CScript& owner, const uint256& vaultID);
+    void Flush(const uint32_t height, const uint32_t txn);
+};
+
 class CAccountsHistoryWriter : public CCustomCSView
 {
     const uint32_t height;
     const uint32_t txn;
     const uint256 txid;
     const uint8_t type;
-    std::map<CScript, TAmounts> diffs;
-    std::map<CScript, TAmounts> burnDiffs;
-    std::map<uint256, std::map<CScript,TAmounts>> vaultDiffs;
-    CAccountsHistoryView* historyView;
-    CAccountsHistoryView* burnView;
-    CVaultHistoryView* vaultView;
+    CHistoryWriters* writers;
 
 public:
     uint256 vaultID;
 
-    CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type, CAccountsHistoryView* historyView,
-                           CAccountsHistoryView* burnView, CVaultHistoryView* vaultView, const uint256& vaultID = uint256());
+    CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type,
+                           CHistoryWriters* writers, const uint256& vaultID = uint256());
     Res AddBalance(CScript const & owner, CTokenAmount amount) override;
     Res SubBalance(CScript const & owner, CTokenAmount amount) override;
-    Res AddFeeBurn(CScript const & owner, CAmount amount);
     bool Flush();
 };
 
@@ -107,21 +136,14 @@ class CAccountsHistoryEraser : public CCustomCSView
 {
     const uint32_t height;
     const uint32_t txn;
-    std::set<CScript> accounts;
-    std::set<CScript> burnAccounts;
-    std::set<uint256> vaults;
-    CAccountsHistoryView* historyView;
-    CAccountsHistoryView* burnView;
-    CVaultHistoryView* vaultView;
+    CHistoryErasers& erasers;
 
 public:
     uint256 vaultID;
 
-    CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView,
-                           CVaultHistoryView* vaultView, const uint256& vaultID = uint256());
+    CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CHistoryErasers& erasers, const uint256& vaultID = uint256());
     Res AddBalance(CScript const & owner, CTokenAmount amount) override;
     Res SubBalance(CScript const & owner, CTokenAmount amount) override;
-    Res SubFeeBurn(CScript const & owner);
     bool Flush();
 };
 
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 33bef92061..b946d7d62e 100644
--- a/src/masternodes/masternodes.h
+++ b/src/masternodes/masternodes.h
@@ -313,6 +313,16 @@ class CCollateralLoans { // in USD
 
     uint32_t ratio() const;
     CAmount precisionRatio() const;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(totalCollaterals);
+        READWRITE(totalLoans);
+        READWRITE(collaterals);
+        READWRITE(loans);
+    }
 };
 
 template<typename T>
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 62ea5ec97e..8577052adc 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -3048,7 +3048,7 @@ bool ShouldReturnNonFatalError(const CTransaction& tx, uint32_t height) {
     return it != skippedTx.end() && it->second == tx.GetHash();
 }
 
-Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView *burnView, CVaultHistoryView *vaultView) {
+Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, CHistoryErasers& erasers, uint32_t txn) {
     if (tx.IsCoinBase() && height > 0) { // genesis contains custom coinbase txs
         return Res::Ok();
     }
@@ -3068,7 +3068,7 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
             break;
     }
     auto txMessage = customTypeToMessage(txType);
-    CAccountsHistoryEraser view(mnview, height, txn, historyView, burnView, vaultView);
+    CAccountsHistoryEraser view(mnview, height, txn, erasers);
     uint256 vaultID;
     if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID))) {
         view.vaultID = vaultID;
@@ -3078,7 +3078,7 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
         if (txType == CustomTxType::CreateToken
         || txType == CustomTxType::CreateMasternode
         || txType == CustomTxType::Vault) {
-            view.SubFeeBurn(tx.vout[0].scriptPubKey);
+            erasers.SubFeeBurn(tx.vout[0].scriptPubKey);
         }
     }
     if (!res) {
@@ -3088,7 +3088,7 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
     return (view.Flush(), res);
 }
 
-Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time, uint32_t txn, CAccountsHistoryView* historyView, CAccountsHistoryView* burnView, CVaultHistoryView *vaultView) {
+Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time, uint32_t txn, CHistoryWriters* writers) {
     auto res = Res::Ok();
     if (tx.IsCoinBase() && height > 0) { // genesis contains custom coinbase txs
         return res;
@@ -3103,7 +3103,7 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
         return Res::ErrCode(CustomTxErrCodes::Fatal, "Invalid custom transaction");
     }
     auto txMessage = customTypeToMessage(txType);
-    CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), historyView, burnView, vaultView);
+    CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), writers);
     uint256 vaultID;
     if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID))) {
         view.vaultID = vaultID;
@@ -3111,12 +3111,16 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
 
         // Track burn fee
         if (txType == CustomTxType::CreateToken || txType == CustomTxType::CreateMasternode) {
-            view.AddFeeBurn(tx.vout[0].scriptPubKey, tx.vout[0].nValue);
+            if (writers) {
+                writers->AddFeeBurn(tx.vout[0].scriptPubKey, tx.vout[0].nValue);
+            }
         }
         if (txType == CustomTxType::Vault) {
             // burn the half, the rest is returned on close vault
             auto burnFee = tx.vout[0].nValue / 2;
-            view.AddFeeBurn(tx.vout[0].scriptPubKey, burnFee);
+            if (writers) {
+                writers->AddFeeBurn(tx.vout[0].scriptPubKey, burnFee);
+            }
         }
     }
     // list of transactions which aren't allowed to fail:
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index 9112b7e4c9..cdfa3849a2 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -22,6 +22,8 @@ class CCustomCSView;
 class CAccountsHistoryView;
 class CCustomTxVisitor;
 class CVaultHistoryView;
+class CHistoryWriters;
+class CHistoryErasers;
 
 static const std::vector<unsigned char> DfTxMarker = {'D', 'f', 'T', 'x'};  // 44665478
 
@@ -370,8 +372,8 @@ CCustomTxMessage customTypeToMessage(CustomTxType txType);
 bool IsMempooledCustomTxCreate(const CTxMemPool& pool, const uint256& txid);
 Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& type, UniValue& results);
 Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID);
-Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint32_t txn = 0, CAccountsHistoryView* historyView = nullptr, CAccountsHistoryView *burnView = nullptr, CVaultHistoryView *vaultView = nullptr);
-Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint32_t txn = 0, CAccountsHistoryView* historyView = nullptr, CAccountsHistoryView *burnView = nullptr, CVaultHistoryView *vaultView = nullptr);
+Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint32_t txn = 0, CHistoryWriters* writers = nullptr);
+Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, CHistoryErasers& erasers, uint32_t txn = 0);
 Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time = 0);
 ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView& mnview, const CTransaction& tx, int height, const uint256& prevStakeModifier, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
 ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView& mnview, const CTransaction& tx, int height, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index be96c8f1b9..a013d791a5 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1147,23 +1147,58 @@ UniValue listauctionhistory(const JSONRPCRequest& request) {
     return ret;
 }
 
-UniValue vaultHistoryToJSON(VaultHistoryKey const & key, VaultHistoryValue const & value) {
+UniValue vaultToJSON(const uint256& vaultID, const std::string& address, const uint64_t blockHeight, const std::string& type,
+                     const uint64_t txn, const std::string& txid, const TAmounts& amounts) {
     UniValue obj(UniValue::VOBJ);
 
-    obj.pushKV("vault", key.vaultID.ToString());
-    obj.pushKV("address", ScriptToString(key.address));
-    obj.pushKV("blockHeight", (uint64_t) key.blockHeight);
-    if (auto block = ::ChainActive()[key.blockHeight]) {
+    obj.pushKV("vault", vaultID.ToString());
+    obj.pushKV("address", address);
+    obj.pushKV("blockHeight", blockHeight);
+    if (auto block = ::ChainActive()[blockHeight]) {
         obj.pushKV("blockHash", block->GetBlockHash().GetHex());
         obj.pushKV("blockTime", block->GetBlockTime());
     }
-    obj.pushKV("type", ToString(CustomTxCodeToType(value.category)));
-    obj.pushKV("txn", (uint64_t) key.txn);
-    obj.pushKV("txid", value.txid.ToString());
-    obj.pushKV("amounts", AmountsToJSON(value.diff));
+    obj.pushKV("type", type);
+    obj.pushKV("txn", txn);
+    obj.pushKV("txid", txid);
+    obj.pushKV("amounts", AmountsToJSON(amounts));
+
     return obj;
 }
 
+UniValue BatchToJSON(const std::vector<CAuctionBatch> batches) {
+    UniValue batchArray{UniValue::VARR};
+    for (std::vector<CAuctionBatch>::size_type i{0}; i < batches.size(); ++i) {
+        UniValue batchObj{UniValue::VOBJ};
+        batchObj.pushKV("index", i);
+        batchObj.pushKV("collaterals", AmountsToJSON(batches[i].collaterals.balances));
+        batchObj.pushKV("loan", tokenAmountString(batches[i].loanAmount));
+        batchArray.push_back(batchObj);
+    }
+    return batchArray;
+}
+
+UniValue stateToJSON(VaultStateKey const & key, VaultStateValue const & value) {
+    auto obj = vaultToJSON(key.vaultID, "", key.blockHeight, "", 0, "", {});
+
+    UniValue snapshot(UniValue::VOBJ);
+    snapshot.pushKV("state", value.isUnderLiquidation ? "inLiquidation" : "active");
+    snapshot.pushKV("collateralAmounts", AmountsToJSON(value.collaterals));
+    snapshot.pushKV("collateralValue", ValueFromUint(value.collateralsValues.totalCollaterals));
+    snapshot.pushKV("collateralRatio", static_cast<int>(value.ratio));
+    snapshot.pushKV("schemeID", value.schemeID);
+    snapshot.pushKV("batches", BatchToJSON(value.auctionBatches));
+
+    obj.pushKV("vaultSnapshot", snapshot);
+
+    return obj;
+}
+
+UniValue historyToJSON(VaultHistoryKey const & key, VaultHistoryValue const & value) {
+    return vaultToJSON(key.vaultID, ScriptToString(key.address), key.blockHeight, ToString(CustomTxCodeToType(value.category)),
+                       key.txn, value.txid.ToString(), value.diff);
+}
+
 UniValue getvaulthistory(const JSONRPCRequest& request) {
     auto pwallet = GetWallet(request);
 
@@ -1278,6 +1313,7 @@ UniValue getvaulthistory(const JSONRPCRequest& request) {
         return startBlock > blockHeight || blockHeight > maxBlockHeight;
     };
 
+    // Get vault TXs
     auto count = limit;
 
     auto shouldContinue = [&](VaultHistoryKey const & key, CLazySerialize<VaultHistoryValue> valueLazy) -> bool
@@ -1301,16 +1337,40 @@ UniValue getvaulthistory(const JSONRPCRequest& request) {
         }
 
         auto& array = ret.emplace(key.blockHeight, UniValue::VARR).first->second;
-        array.push_back(vaultHistoryToJSON(key, value));
-
-        --count;
+        array.push_back(historyToJSON(key, value));
 
-        return count != 0;
+        return --count != 0;
     };
 
     VaultHistoryKey startKey{vaultID, maxBlockHeight, std::numeric_limits<uint32_t>::max(), {}};
     pvaultHistoryDB->ForEachVaultHistory(shouldContinue, startKey);
 
+    // Get vault state changes
+    count = limit;
+
+    auto shouldContinueState = [&](VaultStateKey const & key, CLazySerialize<VaultStateValue> valueLazy) -> bool
+    {
+        if (!isMatchVault(key.vaultID)) {
+            return false;
+        }
+
+        if (shouldSkipBlock(key.blockHeight)) {
+            return true;
+        }
+
+        const auto & value = valueLazy.get();
+
+        auto& array = ret.emplace(key.blockHeight, UniValue::VARR).first->second;
+        array.push_back(stateToJSON(key, value));
+
+        return --count != 0;
+    };
+
+    if (!txTypeSearch) {
+        VaultStateKey stateKey{vaultID, maxBlockHeight};
+        pvaultHistoryDB->ForEachVaultState(shouldContinueState, stateKey);
+    }
+
     UniValue slice(UniValue::VARR);
     for (auto it = ret.cbegin(); limit != 0 && it != ret.cend(); ++it) {
         const auto& array = it->second.get_array();
diff --git a/src/masternodes/vaulthistory.cpp b/src/masternodes/vaulthistory.cpp
index c8fa6e1273..614d948639 100644
--- a/src/masternodes/vaulthistory.cpp
+++ b/src/masternodes/vaulthistory.cpp
@@ -1,21 +1,72 @@
 #include <masternodes/vaulthistory.h>
 
+#include <chain.h>
+
 void CVaultHistoryView::ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start)
 {
     ForEach<ByVaultHistoryKey, VaultHistoryKey, VaultHistoryValue>(callback, start);
 }
 
-Res CVaultHistoryView::WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value) {
+void CVaultHistoryView::WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value) {
     WriteBy<ByVaultHistoryKey>(key, value);
-    return Res::Ok();
 }
 
-Res CVaultHistoryView::EraseVaultHistory(const VaultHistoryKey& key)
+void CVaultHistoryView::EraseVaultHistory(const VaultHistoryKey& key)
 {
     EraseBy<ByVaultHistoryKey>(key);
-    return Res::Ok();
 }
 
+void CVaultHistoryView::ForEachVaultState(std::function<bool(VaultStateKey const &, CLazySerialize<VaultStateValue>)> callback, VaultStateKey const & start)
+{
+    ForEach<ByVaultStateKey, VaultStateKey, VaultStateValue>(callback, start);
+}
+
+void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex& pindex, const uint256& vaultID, const uint32_t ratio)
+{
+    const auto vault = mnview.GetVault(vaultID);
+    assert(vault);
+
+    auto collaterals = mnview.GetVaultCollaterals(vaultID);
+    if (!collaterals) {
+        collaterals = CBalances{};
+    }
+
+    bool useNextPrice = false, requireLivePrice = false;
+    auto rate = mnview.GetLoanCollaterals(vaultID, *collaterals, pindex.nHeight, pindex.nTime, useNextPrice, requireLivePrice);
+
+    CCollateralLoans collateralLoans{0, 0, {}, {}};
+    if (rate) {
+        collateralLoans = *rate.val;
+    }
+
+    std::vector<CAuctionBatch> batches;
+    if (auto data = mnview.GetAuction(vaultID, pindex.nHeight)) {
+        for (uint32_t i{0}; i < data->batchCount; ++i) {
+            if (auto batch = mnview.GetAuctionBatch(vaultID, i)) {
+                batches.push_back(*batch);
+            }
+        }
+    }
+
+    VaultStateValue value{vault->isUnderLiquidation, collaterals->balances, collateralLoans, batches, ratio, vault->schemeId};
+    WriteBy<ByVaultStateKey>(VaultStateKey{vaultID, static_cast<uint32_t>(pindex.nHeight)}, value);
+}
+
+void CVaultHistoryView::EraseVaultState(const uint32_t height)
+{
+    std::vector<uint256> vaultIDs;
+    ForEachVaultState([&](VaultStateKey const & key, CLazySerialize<VaultStateValue> value) {
+        if (key.blockHeight != height) {
+            return false;
+        }
+        vaultIDs.push_back(key.vaultID);
+        return true;
+    }, {{}, height});
+
+    for (const auto id : vaultIDs) {
+        EraseBy<ByVaultStateKey>(VaultStateKey{id, height});
+    }
+}
 
 CVaultHistoryStorage::CVaultHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
         : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe))
diff --git a/src/masternodes/vaulthistory.h b/src/masternodes/vaulthistory.h
index 4208243b97..ad46d25413 100644
--- a/src/masternodes/vaulthistory.h
+++ b/src/masternodes/vaulthistory.h
@@ -55,14 +55,62 @@ struct VaultHistoryValue {
     }
 };
 
+struct VaultStateKey {
+    uint256 vaultID;
+    uint32_t blockHeight;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(vaultID);
+
+        if (ser_action.ForRead()) {
+            READWRITE(WrapBigEndian(blockHeight));
+            blockHeight = ~blockHeight;
+        }
+        else {
+            uint32_t blockHeight_ = ~blockHeight;
+            READWRITE(WrapBigEndian(blockHeight_));
+        }
+    }
+};
+
+struct VaultStateValue {
+    bool isUnderLiquidation;
+    TAmounts collaterals;
+    CCollateralLoans collateralsValues;
+    std::vector<CAuctionBatch> auctionBatches;
+    uint32_t ratio;
+    std::string schemeID;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(isUnderLiquidation);
+        READWRITE(collaterals);
+        READWRITE(collateralsValues);
+        READWRITE(auctionBatches);
+        READWRITE(ratio);
+        READWRITE(schemeID);
+    }
+};
+
 class CVaultHistoryView : public virtual CStorageView
 {
 public:
-    Res WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value);
-    Res EraseVaultHistory(const VaultHistoryKey& key);
+    void WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value);
+    void WriteVaultState(CCustomCSView& mnview, const CBlockIndex& pindex, const uint256& vaultID, const uint32_t ratio = 0);
+
+    void EraseVaultHistory(const VaultHistoryKey& key);
+    void EraseVaultState(const uint32_t height);
+
     void ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start = {});
+    void ForEachVaultState(std::function<bool(VaultStateKey const &, CLazySerialize<VaultStateValue>)> callback, VaultStateKey const & start = {});
 
     struct ByVaultHistoryKey { static constexpr uint8_t prefix() { return 0x01; } };
+    struct ByVaultStateKey { static constexpr uint8_t prefix() { return 0x02; } };
 };
 
 class CVaultHistoryStorage : public CVaultHistoryView
@@ -73,6 +121,6 @@ class CVaultHistoryStorage : public CVaultHistoryView
 
 extern std::unique_ptr<CVaultHistoryStorage> pvaultHistoryDB;
 
-static constexpr bool DEFAULT_VAULTINDEX = true;
+static constexpr bool DEFAULT_VAULTINDEX = false;
 
 #endif //DEFI_MASTERNODES_VAULTHISTORY_H
\ No newline at end of file
diff --git a/src/validation.cpp b/src/validation.cpp
index 880f8de9b5..6272e7fd61 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1670,6 +1670,9 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
         if (paccountHistoryDB) {
             paccountHistoryDB->EraseAuctionHistoryHeight(pindex->nHeight);
         }
+        if (pvaultHistoryDB) {
+            pvaultHistoryDB->EraseVaultState(pindex->nHeight);
+        }
     }
 
     // Undo community balance increments
@@ -1779,7 +1782,8 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
 
         // process transactions revert for masternodes
         mnview.OnUndoTx(tx.GetHash(), (uint32_t) pindex->nHeight);
-        auto res = RevertCustomTx(mnview, view, tx, Params().GetConsensus(), (uint32_t) pindex->nHeight, i, paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get());
+        CHistoryErasers erasers{paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get()};
+        auto res = RevertCustomTx(mnview, view, tx, Params().GetConsensus(), (uint32_t) pindex->nHeight, erasers, i);
         if (!res) {
             LogPrintf("%s\n", res.msg);
         }
@@ -2290,7 +2294,8 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
             pcustomcsview->CreateDFIToken();
             // init view|db with genesis here
             for (size_t i = 0; i < block.vtx.size(); ++i) {
-                const auto res = ApplyCustomTx(mnview, view, *block.vtx[i], chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), i, paccountHistoryDB.get());
+                CHistoryWriters writers{paccountHistoryDB.get(), nullptr, nullptr};
+                const auto res = ApplyCustomTx(mnview, view, *block.vtx[i], chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), i, &writers);
                 if (!res.ok) {
                     return error("%s: Genesis block ApplyCustomTx failed. TX: %s Error: %s",
                                  __func__, block.vtx[i]->GetHash().ToString(), res.msg);
@@ -2547,7 +2552,8 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                     tx.GetHash().ToString(), FormatStateMessage(state));
             }
 
-            const auto res = ApplyCustomTx(accountsView, view, tx, chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), i, paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get());
+            CHistoryWriters writers{paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get()};
+            const auto res = ApplyCustomTx(accountsView, view, tx, chainparams.GetConsensus(), pindex->nHeight, pindex->GetBlockTime(), i, &writers);
             if (!res.ok && (res.code & CustomTxErrCodes::Fatal)) {
                 if (pindex->nHeight >= chainparams.GetConsensus().EunosHeight) {
                     return state.Invalid(ValidationInvalidReason::CONSENSUS,
@@ -3149,11 +3155,18 @@ void CChainState::ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& ca
                                             pindex->nHeight + chainparams.GetConsensus().blocksCollateralAuction(),
                                             cache.GetLoanLiquidationPenalty()
             });
+
+            // Store state in vault DB
+            if (pvaultHistoryDB) {
+                pvaultHistoryDB->WriteVaultState(cache, *pindex, vaultId, collateral.val->ratio());
+            }
+
             return true;
         });
     }
 
-    CAccountsHistoryWriter view(cache, pindex->nHeight, ~0u, {}, uint8_t(CustomTxType::AuctionBid), nullptr, pburnHistoryDB.get(), pvaultHistoryDB.get());
+    CHistoryWriters writers{nullptr, pburnHistoryDB.get(), pvaultHistoryDB.get()};
+    CAccountsHistoryWriter view(cache, pindex->nHeight, ~0u, {}, uint8_t(CustomTxType::AuctionBid), &writers);
 
     view.ForEachVaultAuction([&](const CVaultId& vaultId, const CAuctionData& data) {
         if (data.liquidationHeight != uint32_t(pindex->nHeight)) {
@@ -3225,6 +3238,12 @@ void CChainState::ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& ca
         vault->isUnderLiquidation = false;
         view.StoreVault(vaultId, *vault);
         view.EraseAuction(vaultId, pindex->nHeight);
+
+        // Store state in vault DB
+        if (pvaultHistoryDB) {
+            pvaultHistoryDB->WriteVaultState(view, *pindex, vaultId);
+        }
+
         return true;
     }, pindex->nHeight);
 
diff --git a/test/functional/rpc_getvaulthistory.py b/test/functional/rpc_getvaulthistory.py
index 15e824076a..c248ae8fdf 100755
--- a/test/functional/rpc_getvaulthistory.py
+++ b/test/functional/rpc_getvaulthistory.py
@@ -8,14 +8,14 @@
 from test_framework.test_framework import DefiTestFramework
 
 from test_framework.util import assert_equal
-import calendar
+from decimal import Decimal
 import time
 
 class TokensRPCGetVaultHistory(DefiTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
-        self.extra_args = [['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-bayfrontgardensheight=50', '-dakotaheight=100', '-eunosheight=100', '-eunospayaheight=100', '-fortcanningheight=100']]
+        self.extra_args = [['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-bayfrontgardensheight=50', '-dakotaheight=100', '-eunosheight=100', '-eunospayaheight=100', '-fortcanningheight=100', '-vaultindex=1']]
 
     def run_test(self):
         self.nodes[0].generate(101)
@@ -30,8 +30,7 @@ def run_test(self):
 
         # Test set oracle data
         oracle_prices = [{"currency": "USD", "tokenAmount": "100.00000000@DFI"},{"currency": "USD", "tokenAmount": "100.00000000@TSLA"}]
-        timestamp = calendar.timegm(time.gmtime())
-        self.nodes[0].setoracledata(appoint_oracle_tx, timestamp, oracle_prices)
+        self.nodes[0].setoracledata(appoint_oracle_tx, int(time.time()), oracle_prices)
         self.nodes[0].generate(1)
         self.sync_blocks(self.nodes[0:2])
 
@@ -259,44 +258,61 @@ def run_test(self):
         bid1_tx = self.nodes[0].placeauctionbid(new_vault, 0, self.nodes[0].get_genesis_keys().ownerAuthAddress, '8@TSLA')
         self.nodes[0].generate(1)
         bid2_tx = self.nodes[0].placeauctionbid(new_vault, 0, new_bidding_address, '9@TSLA')
-        self.nodes[0].generate(1)
+        self.nodes[0].generate(33)
 
         # Check bids in result
         result = self.nodes[0].getvaulthistory(new_vault)
-        assert_equal(len(result), 5)
+        assert_equal(len(result), 7)
         assert_equal(result[0]['vault'], new_vault)
-        assert_equal(result[0]['type'], 'AuctionBid')
-        assert_equal(result[0]['txid'], bid2_tx)
+        assert_equal(result[0]['vaultSnapshot']['state'], 'active')
+        assert_equal(result[0]['vaultSnapshot']['collateralAmounts'], ['1.87309846@DFI'])
+        assert_equal(result[0]['vaultSnapshot']['collateralValue'], Decimal('187.30984600'))
+        assert_equal(result[0]['vaultSnapshot']['collateralRatio'], 0)
+        assert_equal(result[0]['vaultSnapshot']['schemeID'], 'LOAN0001')
+        assert_equal(result[0]['vaultSnapshot']['batches'], [])
         assert_equal(result[1]['vault'], new_vault)
         assert_equal(result[1]['type'], 'AuctionBid')
         assert_equal(result[1]['txid'], bid2_tx)
+        assert_equal(result[2]['vault'], new_vault)
+        assert_equal(result[2]['type'], 'AuctionBid')
+        assert_equal(result[2]['txid'], bid2_tx)
 
         if result[0]['address'] == new_bidding_address:
-            assert_equal(result[0]['amounts'], ['-9.00000000@TSLA'])
-            assert_equal(result[1]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
-            assert_equal(result[1]['amounts'], ['8.00000000@TSLA'])
-        elif result[0]['address'] == self.nodes[0].get_genesis_keys().ownerAuthAddress:
-            assert_equal(result[0]['amounts'], ['8.00000000@TSLA'])
-            assert_equal(result[1]['address'], new_bidding_address)
             assert_equal(result[1]['amounts'], ['-9.00000000@TSLA'])
+            assert_equal(result[2]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
+            assert_equal(result[2]['amounts'], ['8.00000000@TSLA'])
+        elif result[0]['address'] == self.nodes[0].get_genesis_keys().ownerAuthAddress:
+            assert_equal(result[1]['amounts'], ['8.00000000@TSLA'])
+            assert_equal(result[2]['address'], new_bidding_address)
+            assert_equal(result[2]['amounts'], ['-9.00000000@TSLA'])
         else:
             assert('Expected address not found in results')
 
-        assert_equal(result[2]['vault'], new_vault)
-        assert_equal(result[2]['type'], 'AuctionBid')
-        assert_equal(result[2]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
-        assert_equal(result[2]['amounts'], ['-8.00000000@TSLA'])
-        assert_equal(result[2]['txid'], bid1_tx)
         assert_equal(result[3]['vault'], new_vault)
-        assert_equal(result[3]['type'], 'TakeLoan')
-        assert_equal(result[3]['address'], vault_owner)
-        assert_equal(result[3]['amounts'], ['6.68896000@TSLA'])
-        assert_equal(result[3]['txid'], takeloan_tx)
+        assert_equal(result[3]['type'], 'AuctionBid')
+        assert_equal(result[3]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
+        assert_equal(result[3]['amounts'], ['-8.00000000@TSLA'])
+        assert_equal(result[3]['txid'], bid1_tx)
         assert_equal(result[4]['vault'], new_vault)
-        assert_equal(result[4]['type'], 'DepositToVault')
-        assert_equal(result[4]['address'], vault_owner)
-        assert_equal(result[4]['amounts'], ['-10.00000000@DFI'])
-        assert_equal(result[4]['txid'], deposit_tx)
+        assert_equal(result[4]['vaultSnapshot']['state'], 'inLiquidation')
+        assert_equal(result[4]['vaultSnapshot']['collateralAmounts'], [])
+        assert_equal(result[4]['vaultSnapshot']['collateralValue'], Decimal('0.00000000'))
+        assert_equal(result[4]['vaultSnapshot']['collateralRatio'], 149)
+        assert_equal(result[4]['vaultSnapshot']['schemeID'], 'LOAN0001')
+        assert_equal(len(result[4]['vaultSnapshot']['batches']), 1)
+        assert_equal(result[4]['vaultSnapshot']['batches'][0]['index'], 0)
+        assert_equal(result[4]['vaultSnapshot']['batches'][0]['collaterals'], ['10.00000000@DFI'])
+        assert_equal(result[4]['vaultSnapshot']['batches'][0]['loan'], '6.68896763@TSLA')
+        assert_equal(result[5]['vault'], new_vault)
+        assert_equal(result[5]['type'], 'TakeLoan')
+        assert_equal(result[5]['address'], vault_owner)
+        assert_equal(result[5]['amounts'], ['6.68896000@TSLA'])
+        assert_equal(result[5]['txid'], takeloan_tx)
+        assert_equal(result[6]['vault'], new_vault)
+        assert_equal(result[6]['type'], 'DepositToVault')
+        assert_equal(result[6]['address'], vault_owner)
+        assert_equal(result[6]['amounts'], ['-10.00000000@DFI'])
+        assert_equal(result[6]['txid'], deposit_tx)
 
 if __name__ == '__main__':
     TokensRPCGetVaultHistory().main()

From 2dc3439a3248549762e192be8ff4ad8e0ab04728 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Tue, 16 Nov 2021 07:53:37 +0000
Subject: [PATCH 05/12] Lint and maOS compilation fix

---
 src/masternodes/rpc_vault.cpp           | 2 +-
 test/lint/lint-circular-dependencies.sh | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index a013d791a5..600b1cff23 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1168,7 +1168,7 @@ UniValue vaultToJSON(const uint256& vaultID, const std::string& address, const u
 
 UniValue BatchToJSON(const std::vector<CAuctionBatch> batches) {
     UniValue batchArray{UniValue::VARR};
-    for (std::vector<CAuctionBatch>::size_type i{0}; i < batches.size(); ++i) {
+    for (uint64_t i{0}; i < batches.size(); ++i) {
         UniValue batchObj{UniValue::VOBJ};
         batchObj.pushKV("index", i);
         batchObj.pushKV("collaterals", AmountsToJSON(batches[i].collaterals.balances));
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 49c8f59e95..4745a32f98 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -24,6 +24,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "chain -> chainparams -> masternodes/mn_checks -> index/txindex -> txdb -> chain"
     "chain -> chainparams -> masternodes/mn_checks -> validation -> versionbits -> chain"
     "chain -> chainparams -> masternodes/mn_checks -> validation -> wallet/wallet -> chain"
+    "chain -> chainparams -> masternodes/mn_checks -> validation -> masternodes/vaulthistory -> chain"
     "chainparams -> key_io -> chainparams"
     "chainparams -> masternodes/mn_checks -> validation -> chainparams"
     "chainparams -> masternodes/mn_checks -> index/txindex -> index/base -> chainparams"

From 1268a69165bdb4b4d66aeddd1b0e250da5b23b87 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Tue, 16 Nov 2021 10:58:21 +0000
Subject: [PATCH 06/12] Infer inLiquidation state

---
 src/masternodes/rpc_vault.cpp    | 2 +-
 src/masternodes/vaulthistory.cpp | 2 +-
 src/masternodes/vaulthistory.h   | 2 --
 3 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index 600b1cff23..975ba4d7ee 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1182,7 +1182,7 @@ UniValue stateToJSON(VaultStateKey const & key, VaultStateValue const & value) {
     auto obj = vaultToJSON(key.vaultID, "", key.blockHeight, "", 0, "", {});
 
     UniValue snapshot(UniValue::VOBJ);
-    snapshot.pushKV("state", value.isUnderLiquidation ? "inLiquidation" : "active");
+    snapshot.pushKV("state", !value.auctionBatches.empty() ? "inLiquidation" : "active");
     snapshot.pushKV("collateralAmounts", AmountsToJSON(value.collaterals));
     snapshot.pushKV("collateralValue", ValueFromUint(value.collateralsValues.totalCollaterals));
     snapshot.pushKV("collateralRatio", static_cast<int>(value.ratio));
diff --git a/src/masternodes/vaulthistory.cpp b/src/masternodes/vaulthistory.cpp
index 614d948639..d4f49d643d 100644
--- a/src/masternodes/vaulthistory.cpp
+++ b/src/masternodes/vaulthistory.cpp
@@ -48,7 +48,7 @@ void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex
         }
     }
 
-    VaultStateValue value{vault->isUnderLiquidation, collaterals->balances, collateralLoans, batches, ratio, vault->schemeId};
+    VaultStateValue value{collaterals->balances, collateralLoans, batches, ratio, vault->schemeId};
     WriteBy<ByVaultStateKey>(VaultStateKey{vaultID, static_cast<uint32_t>(pindex.nHeight)}, value);
 }
 
diff --git a/src/masternodes/vaulthistory.h b/src/masternodes/vaulthistory.h
index ad46d25413..32065e4b12 100644
--- a/src/masternodes/vaulthistory.h
+++ b/src/masternodes/vaulthistory.h
@@ -77,7 +77,6 @@ struct VaultStateKey {
 };
 
 struct VaultStateValue {
-    bool isUnderLiquidation;
     TAmounts collaterals;
     CCollateralLoans collateralsValues;
     std::vector<CAuctionBatch> auctionBatches;
@@ -88,7 +87,6 @@ struct VaultStateValue {
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(isUnderLiquidation);
         READWRITE(collaterals);
         READWRITE(collateralsValues);
         READWRITE(auctionBatches);

From 507c8be6e52f49164aa885e5dc4df68c23cf84a5 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Thu, 18 Nov 2021 13:53:07 +0000
Subject: [PATCH 07/12] Track loan schemes in vault history DB

---
 src/init.cpp                                  |   2 +-
 src/masternodes/accountshistory.cpp           |  29 ++-
 src/masternodes/accountshistory.h             |  19 +-
 src/masternodes/loan.h                        |   6 +
 src/masternodes/mn_checks.cpp                 |  88 +++++++--
 src/masternodes/mn_checks.h                   |   4 +-
 src/masternodes/mn_rpc.cpp                    |   4 +-
 src/masternodes/rpc_customtx.cpp              |   4 +-
 src/masternodes/rpc_vault.cpp                 | 128 +++++++++++--
 src/masternodes/vaulthistory.cpp              |  32 +++-
 src/masternodes/vaulthistory.h                |  71 ++++++-
 src/rpc/client.cpp                            |   2 +-
 src/validation.cpp                            |   2 +-
 ...aulthistory.py => rpc_listvaulthistory.py} | 175 ++++++++++++------
 test/functional/test_runner.py                |   2 +-
 15 files changed, 463 insertions(+), 105 deletions(-)
 rename test/functional/{rpc_getvaulthistory.py => rpc_listvaulthistory.py} (67%)
 mode change 100755 => 100644

diff --git a/src/init.cpp b/src/init.cpp
index e78af93e27..478db91ae7 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -419,7 +419,7 @@ void SetupServerArgs()
 #endif
     gArgs.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-acindex", strprintf("Maintain a full account history index, tracking all accounts balances changes. Used by the listaccounthistory and accounthistorycount rpc calls (default: %u)", DEFAULT_ACINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    gArgs.AddArg("-vaultindex", strprintf("Maintain a full vault history index, tracking all vault changes. Used by the getvaulthistory rpc call (default: %u)", DEFAULT_VAULTINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    gArgs.AddArg("-vaultindex", strprintf("Maintain a full vault history index, tracking all vault changes. Used by the listvaulthistory rpc call (default: %u)", DEFAULT_VAULTINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-blockfilterindex=<type>",
                  strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
                  " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
diff --git a/src/masternodes/accountshistory.cpp b/src/masternodes/accountshistory.cpp
index c46d63614e..5890979dd5 100644
--- a/src/masternodes/accountshistory.cpp
+++ b/src/masternodes/accountshistory.cpp
@@ -36,9 +36,9 @@ CBurnHistoryStorage::CBurnHistoryStorage(const fs::path& dbName, std::size_t cac
 }
 
 CAccountsHistoryWriter::CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type,
-                                               CHistoryWriters* writers, const uint256& vaultID)
+                                               CHistoryWriters* writers)
     : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn),
-    txid(txid), type(type), writers(writers), vaultID(vaultID)
+    txid(txid), type(type), writers(writers)
 {
 }
 
@@ -65,14 +65,13 @@ Res CAccountsHistoryWriter::SubBalance(CScript const & owner, CTokenAmount amoun
 bool CAccountsHistoryWriter::Flush()
 {
     if (writers) {
-        writers->Flush(height, txid, txn, type);
+        writers->Flush(height, txid, txn, type, vaultID);
     }
     return CCustomCSView::Flush();
 }
 
-CAccountsHistoryEraser::CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CHistoryErasers& erasers, const uint256& vaultID)
-    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn),
-      erasers(erasers),  vaultID(vaultID)
+CAccountsHistoryEraser::CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CHistoryErasers& erasers)
+    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn), erasers(erasers)
 {
 }
 
@@ -90,7 +89,7 @@ Res CAccountsHistoryEraser::SubBalance(CScript const & owner, CTokenAmount)
 
 bool CAccountsHistoryEraser::Flush()
 {
-    erasers.Flush(height, txn);
+    erasers.Flush(height, txn, vaultID);
     return Res::Ok(); // makes sure no changes are applyed to underlaying view
 }
 
@@ -130,7 +129,7 @@ void CHistoryErasers::SubBalance(const CScript& owner, const uint256& vaultID)
     }
 }
 
-void CHistoryErasers::Flush(const uint32_t height, const uint32_t txn)
+void CHistoryErasers::Flush(const uint32_t height, const uint32_t txn, const uint256& vaultID)
 {
     if (historyView) {
         for (const auto& account : accounts) {
@@ -146,6 +145,12 @@ void CHistoryErasers::Flush(const uint32_t height, const uint32_t txn)
         for (const auto& vault : vaults) {
             vaultView->EraseVaultHistory({vault, height, txn});
         }
+        if (removeLoanScheme) {
+            vaultView->EraseVaultScheme({vaultID, height});
+        }
+        if (!schemeCreationTxid.IsNull()) {
+            vaultView->EraseGlobalScheme({height, txn, schemeCreationTxid});
+        }
     }
 }
 
@@ -185,7 +190,7 @@ void CHistoryWriters::SubBalance(const CScript& owner, const CTokenAmount amount
     }
 }
 
-void CHistoryWriters::Flush(const uint32_t height, const uint256& txid, const uint32_t txn, const uint8_t type)
+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) {
@@ -203,6 +208,12 @@ void CHistoryWriters::Flush(const uint32_t height, const uint256& txid, const ui
                 vaultView->WriteVaultHistory({diff.first, height, 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});
+        }
     }
 }
 
diff --git a/src/masternodes/accountshistory.h b/src/masternodes/accountshistory.h
index 46b2056fae..3ca89d7d1e 100644
--- a/src/masternodes/accountshistory.h
+++ b/src/masternodes/accountshistory.h
@@ -83,35 +83,41 @@ class CBurnHistoryStorage : public CAccountsHistoryView
 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:
+    CVaultHistoryStorage* vaultView;
+    CLoanSchemeCreation globalLoanScheme;
+    std::string schemeID;
+
     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 Flush(const uint32_t height, const uint256& txid, const uint32_t txn, const uint8_t type);
+    void Flush(const uint32_t height, const uint256& txid, const uint32_t txn, const uint8_t type, const uint256& vaultID);
 };
 
 class CHistoryErasers {
     CAccountHistoryStorage* historyView;
     CBurnHistoryStorage* burnView;
-    CVaultHistoryStorage* vaultView;
     std::set<CScript> accounts;
     std::set<CScript> burnAccounts;
     std::set<uint256> vaults;
 
 public:
+    CVaultHistoryStorage* vaultView;
+    bool removeLoanScheme{false};
+    uint256 schemeCreationTxid;
+
     CHistoryErasers(CAccountHistoryStorage* historyView, CBurnHistoryStorage* burnView, CVaultHistoryStorage* vaultView);
 
     void AddBalance(const CScript& owner, const uint256& vaultID);
     void SubFeeBurn(const CScript& owner);
     void SubBalance(const CScript& owner, const uint256& vaultID);
-    void Flush(const uint32_t height, const uint32_t txn);
+    void Flush(const uint32_t height, const uint32_t txn, const uint256& vaultID);
 };
 
 class CAccountsHistoryWriter : public CCustomCSView
@@ -125,8 +131,7 @@ class CAccountsHistoryWriter : public CCustomCSView
 public:
     uint256 vaultID;
 
-    CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type,
-                           CHistoryWriters* writers, const uint256& vaultID = uint256());
+    CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type, CHistoryWriters* writers);
     Res AddBalance(CScript const & owner, CTokenAmount amount) override;
     Res SubBalance(CScript const & owner, CTokenAmount amount) override;
     bool Flush();
@@ -141,7 +146,7 @@ class CAccountsHistoryEraser : public CCustomCSView
 public:
     uint256 vaultID;
 
-    CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CHistoryErasers& erasers, const uint256& vaultID = uint256());
+    CAccountsHistoryEraser(CCustomCSView & storage, uint32_t height, uint32_t txn, CHistoryErasers& erasers);
     Res AddBalance(CScript const & owner, CTokenAmount amount) override;
     Res SubBalance(CScript const & owner, CTokenAmount amount) override;
     bool Flush();
diff --git a/src/masternodes/loan.h b/src/masternodes/loan.h
index 7301f85b54..a3947af301 100644
--- a/src/masternodes/loan.h
+++ b/src/masternodes/loan.h
@@ -164,6 +164,12 @@ struct CLoanScheme : public CLoanSchemeData
     }
 };
 
+struct CLoanSchemeCreation : public CLoanScheme
+{
+    uint256 schemeCreationTxid;
+    bool creation{false};
+};
+
 struct CLoanSchemeMessage : public CLoanScheme
 {
     uint64_t updateHeight{0};
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 8577052adc..03684932d1 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -23,6 +23,7 @@
 #include <validation.h>
 
 #include <algorithm>
+#include "vaulthistory.h"
 
 std::string ToString(CustomTxType type) {
     switch (type)
@@ -166,6 +167,8 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 {
     uint32_t height;
     uint256& vaultID;
+    std::string& schemeID;
+    CLoanSchemeCreation& globalScheme;
     const Consensus::Params& consensus;
     const std::vector<unsigned char>& metadata;
 
@@ -224,8 +227,11 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 public:
     CCustomMetadataParseVisitor(uint32_t height,
                                 const Consensus::Params& consensus,
-                                const std::vector<unsigned char>& metadata, uint256& vaultID)
-        : height(height), vaultID(vaultID), consensus(consensus), metadata(metadata) {}
+                                const std::vector<unsigned char>& metadata,
+                                uint256& vaultID,
+                                std::string& schemeID,
+                                CLoanSchemeCreation& globalScheme)
+        : height(height), vaultID(vaultID), schemeID(schemeID), consensus(consensus), metadata(metadata), globalScheme(globalScheme) {}
 
     Res operator()(CCreateMasterNodeMessage& obj) const {
         return serialize(obj);
@@ -471,7 +477,16 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 
     Res operator()(CLoanSchemeMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            globalScheme.identifier = obj.identifier;
+            globalScheme.ratio = obj.ratio;
+            globalScheme.rate = obj.rate;
+            if (!obj.updateHeight) {
+                globalScheme.creation = true;
+            }
+        }
+        return res;
     }
 
     Res operator()(CDefaultLoanSchemeMessage& obj) const {
@@ -486,7 +501,11 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 
     Res operator()(CVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (res) {
+            res = serialize(obj);
+            schemeID = obj.schemeId;
+        }
+        return res;
     }
 
     Res operator()(CCloseVaultMessage& obj) const {
@@ -503,6 +522,9 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
         if (res) {
             res = serialize(obj);
             vaultID = obj.vaultId;
+            if (!obj.schemeId.empty()) {
+                schemeID = obj.schemeId;
+            }
         }
         return res;
     }
@@ -3010,9 +3032,9 @@ class CCustomTxRevertVisitor : public CCustomTxVisitor
     }
 };
 
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID) {
+Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID, std::string& schemeID, CLoanSchemeCreation& globalScheme) {
     try {
-        return boost::apply_visitor(CCustomMetadataParseVisitor(height, consensus, metadata, vaultID), txMessage);
+        return boost::apply_visitor(CCustomMetadataParseVisitor(height, consensus, metadata, vaultID, schemeID, globalScheme), txMessage);
     } catch (const std::exception& e) {
         return Res::Err(e.what());
     } catch (...) {
@@ -3048,7 +3070,7 @@ bool ShouldReturnNonFatalError(const CTransaction& tx, uint32_t height) {
     return it != skippedTx.end() && it->second == tx.GetHash();
 }
 
-Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, CHistoryErasers& erasers, uint32_t txn) {
+Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint32_t txn, CHistoryErasers& erasers) {
     if (tx.IsCoinBase() && height > 0) { // genesis contains custom coinbase txs
         return Res::Ok();
     }
@@ -3070,8 +3092,27 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
     auto txMessage = customTypeToMessage(txType);
     CAccountsHistoryEraser view(mnview, height, txn, erasers);
     uint256 vaultID;
-    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID))) {
-        view.vaultID = vaultID;
+    std::string schemeID;
+    CLoanSchemeCreation globalScheme;
+    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID, schemeID, globalScheme))) {
+        if (pvaultHistoryDB) {
+            view.vaultID = vaultID;
+            if (!schemeID.empty()) {
+                erasers.removeLoanScheme = true;
+            } else if (!globalScheme.identifier.empty()) {
+                if (globalScheme.creation) {
+                    erasers.schemeCreationTxid = tx.GetHash();
+                } else {
+                    erasers.vaultView->ForEachGlobalScheme([&erasers, &globalScheme](VaultGlobalSchemeKey const & key, CLazySerialize<VaultGlobalSchemeValue> value) {
+                        if (value.get().loanScheme.identifier != globalScheme.identifier) {
+                            return true;
+                        }
+                        erasers.schemeCreationTxid = key.schemeCreationTxid;
+                        return false;
+                    }, {height, txn, {}});
+                }
+            }
+        }
         res = CustomTxRevert(view, coins, tx, height, consensus, txMessage);
 
         // Track burn fee
@@ -3105,8 +3146,33 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
     auto txMessage = customTypeToMessage(txType);
     CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), writers);
     uint256 vaultID;
-    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID))) {
-        view.vaultID = vaultID;
+    std::string schemeID;
+    CLoanSchemeCreation globalScheme;
+    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID, schemeID, globalScheme))) {
+        if (pvaultHistoryDB && writers) {
+            view.vaultID = vaultID;
+            if (!schemeID.empty()) {
+                writers->schemeID = schemeID;
+
+                // ID null on vault creation
+                if (vaultID.IsNull()) {
+                    view.vaultID = tx.GetHash();
+                }
+            } else if (!globalScheme.identifier.empty()) {
+                if (globalScheme.creation) {
+                    globalScheme.schemeCreationTxid = tx.GetHash();
+                } else {
+                    writers->vaultView->ForEachGlobalScheme([&globalScheme](VaultGlobalSchemeKey const & key, CLazySerialize<VaultGlobalSchemeValue> value) {
+                        if (value.get().loanScheme.identifier != globalScheme.identifier) {
+                            return true;
+                        }
+                        globalScheme.schemeCreationTxid = key.schemeCreationTxid;
+                        return false;
+                    }, {height, txn, {}});
+                }
+                writers->globalLoanScheme = globalScheme;
+            }
+        }
         res = CustomTxVisit(view, coins, tx, height, consensus, txMessage, time);
 
         // Track burn fee
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index cdfa3849a2..e22784122a 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -371,9 +371,9 @@ typedef boost::variant<
 CCustomTxMessage customTypeToMessage(CustomTxType txType);
 bool IsMempooledCustomTxCreate(const CTxMemPool& pool, const uint256& txid);
 Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& type, UniValue& results);
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID);
+Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID, std::string& schemeID, CLoanSchemeCreation& globalScheme);
 Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint32_t txn = 0, CHistoryWriters* writers = nullptr);
-Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, CHistoryErasers& erasers, uint32_t txn = 0);
+Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height,  uint32_t txn, CHistoryErasers& erasers);
 Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time = 0);
 ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView& mnview, const CTransaction& tx, int height, const uint256& prevStakeModifier, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
 ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView& mnview, const CTransaction& tx, int height, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
diff --git a/src/masternodes/mn_rpc.cpp b/src/masternodes/mn_rpc.cpp
index 550934f405..beb1f1fc3e 100644
--- a/src/masternodes/mn_rpc.cpp
+++ b/src/masternodes/mn_rpc.cpp
@@ -426,7 +426,9 @@ void execTestTx(const CTransaction& tx, uint32_t height, CTransactionRef optAuth
     auto txType = GuessCustomTxType(tx, metadata);
     auto txMessage = customTypeToMessage(txType);
     uint256 vaultID;
-    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID);
+    std::string schemeID;
+    CLoanSchemeCreation globalScheme;
+    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID, schemeID, globalScheme);
     if (res) {
         LOCK(cs_main);
         CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index 81a56d417a..2b7a4f8cb9 100644
--- a/src/masternodes/rpc_customtx.cpp
+++ b/src/masternodes/rpc_customtx.cpp
@@ -453,7 +453,9 @@ Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& txType, UniVa
     }
     auto txMessage = customTypeToMessage(txType);
     uint256 vaultID;
-    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID);
+    std::string schemeID;
+    CLoanSchemeCreation globalScheme;
+    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID, schemeID, globalScheme);
     if (res) {
         CCustomCSView mnview(*pcustomcsview);
         boost::apply_visitor(CCustomTxRpcVisitor(tx, height, mnview, results), txMessage);
diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index 975ba4d7ee..80320cac75 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1151,17 +1151,25 @@ UniValue vaultToJSON(const uint256& vaultID, const std::string& address, const u
                      const uint64_t txn, const std::string& txid, const TAmounts& amounts) {
     UniValue obj(UniValue::VOBJ);
 
-    obj.pushKV("vault", vaultID.ToString());
-    obj.pushKV("address", address);
+    if (!address.empty()) {
+        obj.pushKV("address", address);
+    }
     obj.pushKV("blockHeight", blockHeight);
     if (auto block = ::ChainActive()[blockHeight]) {
         obj.pushKV("blockHash", block->GetBlockHash().GetHex());
         obj.pushKV("blockTime", block->GetBlockTime());
     }
-    obj.pushKV("type", type);
-    obj.pushKV("txn", txn);
+    if (!type.empty()) {
+        obj.pushKV("type", type);
+    }
+    // No address no txn
+    if (!address.empty()) {
+        obj.pushKV("txn", txn);
+    }
     obj.pushKV("txid", txid);
-    obj.pushKV("amounts", AmountsToJSON(amounts));
+    if (!amounts.empty()) {
+        obj.pushKV("amounts", AmountsToJSON(amounts));
+    }
 
     return obj;
 }
@@ -1186,8 +1194,9 @@ UniValue stateToJSON(VaultStateKey const & key, VaultStateValue const & value) {
     snapshot.pushKV("collateralAmounts", AmountsToJSON(value.collaterals));
     snapshot.pushKV("collateralValue", ValueFromUint(value.collateralsValues.totalCollaterals));
     snapshot.pushKV("collateralRatio", static_cast<int>(value.ratio));
-    snapshot.pushKV("schemeID", value.schemeID);
-    snapshot.pushKV("batches", BatchToJSON(value.auctionBatches));
+    if (!value.auctionBatches.empty()) {
+        snapshot.pushKV("batches", BatchToJSON(value.auctionBatches));
+    }
 
     obj.pushKV("vaultSnapshot", snapshot);
 
@@ -1199,10 +1208,23 @@ UniValue historyToJSON(VaultHistoryKey const & key, VaultHistoryValue const & va
                        key.txn, value.txid.ToString(), value.diff);
 }
 
-UniValue getvaulthistory(const JSONRPCRequest& request) {
+UniValue schemeToJSON(VaultSchemeKey const & key, const VaultGlobalSchemeValue& value) {
+    auto obj = vaultToJSON(key.vaultID, "", key.blockHeight, ToString(CustomTxCodeToType(value.category)), 0, value.txid.ToString(), {});
+
+    UniValue scheme(UniValue::VOBJ);
+    scheme.pushKV("id", value.loanScheme.identifier);
+    scheme.pushKV("rate", value.loanScheme.rate);
+    scheme.pushKV("ratio", static_cast<uint64_t>(value.loanScheme.ratio));
+
+    obj.pushKV("loanScheme", scheme);
+
+    return obj;
+}
+
+UniValue listvaulthistory(const JSONRPCRequest& request) {
     auto pwallet = GetWallet(request);
 
-    RPCHelpMan{"getvaulthistory",
+    RPCHelpMan{"listvaulthistory",
                "\nReturns the history of the specified vault.\n",
                {
                        {"vaultId", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Vault to get history for"},
@@ -1366,11 +1388,95 @@ UniValue getvaulthistory(const JSONRPCRequest& request) {
         return --count != 0;
     };
 
+    VaultStateKey stateKey{vaultID, maxBlockHeight};
     if (!txTypeSearch) {
-        VaultStateKey stateKey{vaultID, maxBlockHeight};
         pvaultHistoryDB->ForEachVaultState(shouldContinueState, stateKey);
     }
 
+    // Get vault schemes
+    count = limit;
+
+    std::map<uint32_t, uint256> schemes;
+
+    auto shouldContinueScheme = [&](VaultSchemeKey const & key, CLazySerialize<VaultSchemeValue> valueLazy) -> bool
+    {
+        if (!isMatchVault(key.vaultID)) {
+            return false;
+        }
+
+        if (shouldSkipBlock(key.blockHeight)) {
+            return true;
+        }
+
+        const auto & value = valueLazy.get();
+
+        if (txTypeSearch && value.category != uint8_t(txType)) {
+            return true;
+        }
+
+        CLoanScheme loanScheme;
+        pvaultHistoryDB->ForEachGlobalScheme([&](VaultGlobalSchemeKey const & schemeKey, CLazySerialize<VaultGlobalSchemeValue> lazyValue) {
+            if (lazyValue.get().loanScheme.identifier != value.schemeID) {
+                return true;
+            }
+            loanScheme = lazyValue.get().loanScheme;
+            schemes.emplace(key.blockHeight, schemeKey.schemeCreationTxid);
+            return false;
+        }, {key.blockHeight, value.txn});
+
+        auto& array = ret.emplace(key.blockHeight, UniValue::VARR).first->second;
+        array.push_back(schemeToJSON(key, {loanScheme, value.category, value.txid}));
+
+        return --count != 0;
+    };
+
+    if (tokenFilter.empty()) {
+        pvaultHistoryDB->ForEachVaultScheme(shouldContinueScheme, stateKey);
+    }
+
+    // Get vault global scheme changes
+
+    if (!schemes.empty()) {
+        auto lastScheme = schemes.cbegin()->second;
+        for (auto it = ++schemes.cbegin(); it != schemes.cend(); ) {
+            if (lastScheme == it->second) {
+                schemes.erase(it++);
+            } else {
+                ++it;
+            }
+        }
+
+        auto minHeight = schemes.cbegin()->first;
+        for (auto it = schemes.cbegin(); it != schemes.cend(); ++it) {
+            auto nit = std::next(it);
+            uint32_t endHeight = nit != schemes.cend() ? nit->first - 1 : std::numeric_limits<uint32_t>::max();
+            pvaultHistoryDB->ForEachGlobalScheme([&](VaultGlobalSchemeKey const & key, CLazySerialize<VaultGlobalSchemeValue> valueLazy){
+                if (key.blockHeight < minHeight) {
+                    return false;
+                }
+
+                if (it->second != key.schemeCreationTxid) {
+                    return true;
+                }
+
+                if (shouldSkipBlock(key.blockHeight)) {
+                    return true;
+                }
+
+                const auto & value = valueLazy.get();
+
+                if (txTypeSearch && value.category != uint8_t(txType)) {
+                    return true;
+                }
+
+                auto& array = ret.emplace(key.blockHeight, UniValue::VARR).first->second;
+                array.push_back(schemeToJSON({vaultID, key.blockHeight}, value));
+
+                return --count != 0;
+            }, {endHeight, std::numeric_limits<uint32_t>::max(), it->second});
+        }
+    }
+
     UniValue slice(UniValue::VARR);
     for (auto it = ret.cbegin(); limit != 0 && it != ret.cend(); ++it) {
         const auto& array = it->second.get_array();
@@ -1391,7 +1497,7 @@ static const CRPCCommand commands[] =
     {"vault",        "closevault",                &closevault,            {"id", "returnAddress", "inputs"}},
     {"vault",        "listvaults",                &listvaults,            {"options", "pagination"}},
     {"vault",        "getvault",                  &getvault,              {"id"}},
-    {"vault",        "getvaulthistory",           &getvaulthistory,       {"id", "options"}},
+    {"vault",        "listvaulthistory",          &listvaulthistory,      {"id", "options"}},
     {"vault",        "updatevault",               &updatevault,           {"id", "parameters", "inputs"}},
     {"vault",        "deposittovault",            &deposittovault,        {"id", "from", "amount", "inputs"}},
     {"vault",        "withdrawfromvault",         &withdrawfromvault,     {"id", "to", "amount", "inputs"}},
diff --git a/src/masternodes/vaulthistory.cpp b/src/masternodes/vaulthistory.cpp
index d4f49d643d..3b6d348f05 100644
--- a/src/masternodes/vaulthistory.cpp
+++ b/src/masternodes/vaulthistory.cpp
@@ -11,16 +11,36 @@ void CVaultHistoryView::WriteVaultHistory(VaultHistoryKey const & key, VaultHist
     WriteBy<ByVaultHistoryKey>(key, value);
 }
 
+void CVaultHistoryView::WriteVaultScheme(VaultSchemeKey const & key, const VaultSchemeValue& value)
+{
+    WriteBy<ByVaultSchemeKey>(key, value);
+}
+
+void CVaultHistoryView::WriteGlobalScheme(VaultGlobalSchemeKey const & key, const VaultGlobalSchemeValue& value)
+{
+    WriteBy<ByVaultGlobalSchemeKey>(key, value);
+}
+
 void CVaultHistoryView::EraseVaultHistory(const VaultHistoryKey& key)
 {
     EraseBy<ByVaultHistoryKey>(key);
 }
 
+void CVaultHistoryView::ForEachVaultScheme(std::function<bool(VaultSchemeKey const &, CLazySerialize<VaultSchemeValue>)> callback, VaultSchemeKey const & start)
+{
+    ForEach<ByVaultSchemeKey, VaultSchemeKey, VaultSchemeValue>(callback, start);
+}
+
 void CVaultHistoryView::ForEachVaultState(std::function<bool(VaultStateKey const &, CLazySerialize<VaultStateValue>)> callback, VaultStateKey const & start)
 {
     ForEach<ByVaultStateKey, VaultStateKey, VaultStateValue>(callback, start);
 }
 
+void CVaultHistoryView::ForEachGlobalScheme(std::function<bool(VaultGlobalSchemeKey const &, CLazySerialize<VaultGlobalSchemeValue>)> callback, VaultGlobalSchemeKey const & start)
+{
+    ForEach<ByVaultGlobalSchemeKey, VaultGlobalSchemeKey, VaultGlobalSchemeValue>(callback, start);
+}
+
 void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex& pindex, const uint256& vaultID, const uint32_t ratio)
 {
     const auto vault = mnview.GetVault(vaultID);
@@ -48,10 +68,20 @@ void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex
         }
     }
 
-    VaultStateValue value{collaterals->balances, collateralLoans, batches, ratio, vault->schemeId};
+    VaultStateValue value{collaterals->balances, collateralLoans, batches, ratio};
     WriteBy<ByVaultStateKey>(VaultStateKey{vaultID, static_cast<uint32_t>(pindex.nHeight)}, value);
 }
 
+void CVaultHistoryView::EraseVaultScheme(const VaultSchemeKey& key)
+{
+    EraseBy<ByVaultSchemeKey>(key);
+}
+
+void CVaultHistoryView::EraseGlobalScheme(const VaultGlobalSchemeKey& key)
+{
+    EraseBy<ByVaultGlobalSchemeKey>(key);
+}
+
 void CVaultHistoryView::EraseVaultState(const uint32_t height)
 {
     std::vector<uint256> vaultIDs;
diff --git a/src/masternodes/vaulthistory.h b/src/masternodes/vaulthistory.h
index 32065e4b12..05cdc10c9f 100644
--- a/src/masternodes/vaulthistory.h
+++ b/src/masternodes/vaulthistory.h
@@ -81,7 +81,6 @@ struct VaultStateValue {
     CCollateralLoans collateralsValues;
     std::vector<CAuctionBatch> auctionBatches;
     uint32_t ratio;
-    std::string schemeID;
 
     ADD_SERIALIZE_METHODS;
 
@@ -91,7 +90,67 @@ struct VaultStateValue {
         READWRITE(collateralsValues);
         READWRITE(auctionBatches);
         READWRITE(ratio);
+    }
+};
+
+using VaultSchemeKey = VaultStateKey;
+
+struct VaultSchemeValue {
+    unsigned char category;
+    uint256 txid;
+    std::string schemeID;
+    uint32_t txn; // For looking up global scheme from specific place in the block
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(category);
+        READWRITE(txid);
         READWRITE(schemeID);
+        READWRITE(txn);
+    }
+};
+
+struct VaultGlobalSchemeKey {
+    uint32_t blockHeight;
+    uint32_t txn;
+    uint256 schemeCreationTxid;
+
+    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;
+            READWRITE(WrapBigEndian(txn));
+            txn = ~txn;
+        }
+        else {
+            uint32_t blockHeight_ = ~blockHeight;
+            READWRITE(WrapBigEndian(blockHeight_));
+            uint32_t txn_ = ~txn;
+            READWRITE(WrapBigEndian(txn_));
+        }
+
+        READWRITE(schemeCreationTxid);
+    }
+};
+
+struct VaultGlobalSchemeValue {
+    CLoanScheme loanScheme;
+    unsigned char category;
+    uint256 txid;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(loanScheme);
+        READWRITE(category);
+        READWRITE(txid);
     }
 };
 
@@ -99,16 +158,26 @@ class CVaultHistoryView : public virtual CStorageView
 {
 public:
     void WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value);
+    void WriteVaultScheme(VaultSchemeKey const & key, const VaultSchemeValue& value);
     void WriteVaultState(CCustomCSView& mnview, const CBlockIndex& pindex, const uint256& vaultID, const uint32_t ratio = 0);
 
     void EraseVaultHistory(const VaultHistoryKey& key);
+    void EraseVaultScheme(const VaultSchemeKey& key);
     void EraseVaultState(const uint32_t height);
 
     void ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start = {});
+    void ForEachVaultScheme(std::function<bool(VaultSchemeKey const &, CLazySerialize<VaultSchemeValue>)> callback, VaultSchemeKey const & start = {});
     void ForEachVaultState(std::function<bool(VaultStateKey const &, CLazySerialize<VaultStateValue>)> callback, VaultStateKey const & start = {});
 
+    // Loan Scheme storage
+    void WriteGlobalScheme(VaultGlobalSchemeKey const & key, const VaultGlobalSchemeValue& value);
+    void EraseGlobalScheme(const VaultGlobalSchemeKey& key);
+    void ForEachGlobalScheme(std::function<bool(VaultGlobalSchemeKey const &, CLazySerialize<VaultGlobalSchemeValue>)> callback, VaultGlobalSchemeKey const & start = {});
+
     struct ByVaultHistoryKey { static constexpr uint8_t prefix() { return 0x01; } };
     struct ByVaultStateKey { static constexpr uint8_t prefix() { return 0x02; } };
+    struct ByVaultSchemeKey { static constexpr uint8_t prefix() { return 0x03; } };
+    struct ByVaultGlobalSchemeKey { static constexpr uint8_t prefix() { return 0x04; } };
 };
 
 class CVaultHistoryStorage : public CVaultHistoryView
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 173efc2324..592daa21b2 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -256,7 +256,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "withdrawfromvault", 3, "inputs" },
     { "placeauctionbid", 1, "index" },
     { "placeauctionbid", 4, "inputs" },
-    { "getvaulthistory", 1, "options" },
+    { "listvaulthistory", 1, "options" },
     { "listvaults", 0, "options" },
     { "listvaults", 1, "pagination" },
     { "listauctions", 0, "pagination" },
diff --git a/src/validation.cpp b/src/validation.cpp
index 6272e7fd61..3349f9007d 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1783,7 +1783,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
         // process transactions revert for masternodes
         mnview.OnUndoTx(tx.GetHash(), (uint32_t) pindex->nHeight);
         CHistoryErasers erasers{paccountHistoryDB.get(), pburnHistoryDB.get(), pvaultHistoryDB.get()};
-        auto res = RevertCustomTx(mnview, view, tx, Params().GetConsensus(), (uint32_t) pindex->nHeight, erasers, i);
+        auto res = RevertCustomTx(mnview, view, tx, Params().GetConsensus(), (uint32_t) pindex->nHeight, i, erasers);
         if (!res) {
             LogPrintf("%s\n", res.msg);
         }
diff --git a/test/functional/rpc_getvaulthistory.py b/test/functional/rpc_listvaulthistory.py
old mode 100755
new mode 100644
similarity index 67%
rename from test/functional/rpc_getvaulthistory.py
rename to test/functional/rpc_listvaulthistory.py
index c248ae8fdf..240148bab5
--- a/test/functional/rpc_getvaulthistory.py
+++ b/test/functional/rpc_listvaulthistory.py
@@ -3,7 +3,7 @@
 # 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.
-"""Test getvaulthistory RPC."""
+"""Test listvaulthistory RPC."""
 
 from test_framework.test_framework import DefiTestFramework
 
@@ -37,6 +37,8 @@ def run_test(self):
         # Create loan schemes
         self.nodes[0].createloanscheme(150, 5, 'LOAN0001')
         self.nodes[0].generate(1)
+        self.nodes[0].createloanscheme(300, 2.5, 'LOAN0002')
+        self.nodes[0].generate(1)
 
         # Create DUSD token
         self.nodes[0].createtoken({
@@ -107,7 +109,7 @@ def run_test(self):
 
         # Create vault
         vault_owner = self.nodes[0].getnewaddress("", "legacy")
-        create_vault_tx = self.nodes[0].createvault(vault_owner, 'LOAN0001')
+        create_vault_tx = self.nodes[0].createvault(vault_owner, 'LOAN0002')
         self.nodes[0].generate(1)
 
         # Deposit to vault
@@ -116,10 +118,58 @@ def run_test(self):
         deposit_tx = self.nodes[0].deposittovault(create_vault_tx, collateral_a, '10@DFI')
         self.nodes[0].generate(1)
 
+        # Update global loan scheme change
+        update_002_tx = self.nodes[0].updateloanscheme(600, 1, 'LOAN0002')
+        self.nodes[0].generate(1)
+
+        # Make sure last entry is update vault
+        result = self.nodes[0].listvaulthistory(create_vault_tx)
+        assert_equal(len(result), 3)
+        assert_equal(result[0]['type'], 'LoanScheme')
+
+        # Test rollback of global loan scheme
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        result = self.nodes[0].listvaulthistory(create_vault_tx)
+        assert_equal(len(result), 2)
+        assert_equal(result[0]['type'], 'DepositToVault')
+        self.nodes[0].generate(1)
+
+        # Change loan scheme
+        update_tx = self.nodes[0].updatevault(create_vault_tx, {'loanSchemeId': 'LOAN0001'})
+        self.nodes[0].generate(1)
+
+        # Make sure last entry is update vault
+        result = self.nodes[0].listvaulthistory(create_vault_tx)
+        assert_equal(len(result), 4)
+        assert_equal(result[0]['type'], 'UpdateVault')
+
+        # Test rollback of loan scheme
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        result = self.nodes[0].listvaulthistory(create_vault_tx)
+        assert_equal(len(result), 3)
+        assert_equal(result[0]['type'], 'LoanScheme')
+        self.nodes[0].generate(1)
+
+        # Destroy old loan scheme
+        self.nodes[0].destroyloanscheme('LOAN0002')
+        self.nodes[0].generate(1)
+
+        # Create replacement. Should not show up in vault history.
+        self.nodes[0].createloanscheme(100, 1, 'LOAN0002')
+        self.nodes[0].generate(1)
+
+        # Update loan scheme. Should not show up in vault history.
+        self.nodes[0].updateloanscheme(200, 2, 'LOAN0002')
+        self.nodes[0].generate(1)
+
         # Take loan
         takeloan_tx = self.nodes[0].takeloan({'vaultId':create_vault_tx,'amounts': "1@TSLA"})
         self.nodes[0].generate(1)
 
+        # Update loan scheme
+        update_001_tx = self.nodes[0].updateloanscheme(200, 6, 'LOAN0001')
+        self.nodes[0].generate(1)
+
         # Pay back loan
         vault = self.nodes[0].getvault(create_vault_tx)
         payback_tx = self.nodes[0].paybackloan({
@@ -139,86 +189,93 @@ def run_test(self):
         close_tx = self.nodes[0].closevault(create_vault_tx, close_address)
         self.nodes[0].generate(1)
 
-        # Test getvaulthistory
-        result = self.nodes[0].getvaulthistory(create_vault_tx)
-        assert_equal(len(result), 6)
-        assert_equal(result[0]['vault'], create_vault_tx)
+        # Test listvaulthistory
+        result = self.nodes[0].listvaulthistory(create_vault_tx)
+        assert_equal(len(result), 10)
         assert_equal(result[0]['type'], 'CloseVault')
         assert_equal(result[0]['address'], close_address)
         assert_equal(result[0]['amounts'], ['10.00000000@DFI'])
         assert_equal(result[0]['txid'], close_tx)
-        assert_equal(result[1]['vault'], create_vault_tx)
         assert_equal(result[1]['type'], 'WithdrawFromVault')
         assert_equal(result[1]['address'], withdraw_address)
         assert_equal(result[1]['amounts'], ['0.50000000@DFI'])
         assert_equal(result[1]['txid'], withdraw_tx)
-        assert_equal(result[2]['vault'], create_vault_tx)
         assert_equal(result[2]['type'], 'PaybackLoan')
         assert_equal(result[2]['address'], 'mfburnZSAM7Gs1hpDeNaMotJXSGA7edosG')
-        assert_equal(result[2]['amounts'], ['0.00000114@DFI'])
+        assert_equal(result[2]['amounts'], ['0.00000228@DFI'])
         assert_equal(result[2]['txid'], payback_tx)
-        assert_equal(result[3]['vault'], create_vault_tx)
         assert_equal(result[3]['type'], 'PaybackLoan')
         assert_equal(result[3]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
-        assert_equal(result[3]['amounts'], ['-1.00000114@TSLA'])
+        assert_equal(result[3]['amounts'], ['-1.00000228@TSLA'])
         assert_equal(result[3]['txid'], payback_tx)
-        assert_equal(result[4]['vault'], create_vault_tx)
-        assert_equal(result[4]['type'], 'TakeLoan')
-        assert_equal(result[4]['address'], vault_owner)
-        assert_equal(result[4]['amounts'], ['1.00000000@TSLA'])
-        assert_equal(result[4]['txid'], takeloan_tx)
-        assert_equal(result[5]['vault'], create_vault_tx)
-        assert_equal(result[5]['type'], 'DepositToVault')
-        assert_equal(result[5]['address'], collateral_a)
-        assert_equal(result[5]['amounts'], ['-10.00000000@DFI'])
-        assert_equal(result[5]['txid'], deposit_tx)
-
-        # Test getvaulthistory block height and depth
-        result = self.nodes[0].getvaulthistory(create_vault_tx, {'maxBlockHeight':119,'depth':1})
+        assert_equal(result[4]['type'], 'LoanScheme')
+        assert_equal(result[4]['loanScheme']['id'], 'LOAN0001')
+        assert_equal(result[4]['loanScheme']['rate'], 600000000)
+        assert_equal(result[4]['loanScheme']['ratio'], 200)
+        assert_equal(result[4]['txid'], update_001_tx)
+        assert_equal(result[5]['type'], 'TakeLoan')
+        assert_equal(result[5]['address'], vault_owner)
+        assert_equal(result[5]['amounts'], ['1.00000000@TSLA'])
+        assert_equal(result[5]['txid'], takeloan_tx)
+        assert_equal(result[6]['type'], 'UpdateVault')
+        assert_equal(result[6]['loanScheme']['id'], 'LOAN0001')
+        assert_equal(result[6]['loanScheme']['rate'], 500000000)
+        assert_equal(result[6]['loanScheme']['ratio'], 150)
+        assert_equal(result[6]['txid'], update_tx)
+        assert_equal(result[7]['type'], 'LoanScheme')
+        assert_equal(result[7]['loanScheme']['id'], 'LOAN0002')
+        assert_equal(result[7]['loanScheme']['rate'], 100000000)
+        assert_equal(result[7]['loanScheme']['ratio'], 600)
+        assert_equal(result[7]['txid'], update_002_tx)
+        assert_equal(result[8]['type'], 'DepositToVault')
+        assert_equal(result[8]['address'], collateral_a)
+        assert_equal(result[8]['amounts'], ['-10.00000000@DFI'])
+        assert_equal(result[8]['txid'], deposit_tx)
+        assert_equal(result[9]['type'], 'Vault')
+        assert_equal(result[9]['loanScheme']['id'], 'LOAN0002')
+        assert_equal(result[9]['loanScheme']['rate'], 250000000)
+        assert_equal(result[9]['loanScheme']['ratio'], 300)
+        assert_equal(result[9]['txid'], create_vault_tx)
+
+        # Test listvaulthistory block height and depth
+        result = self.nodes[0].listvaulthistory(create_vault_tx, {'maxBlockHeight':126,'depth':1})
         assert_equal(len(result), 3)
-        assert_equal(result[0]['vault'], create_vault_tx)
         assert_equal(result[0]['type'], 'WithdrawFromVault')
         assert_equal(result[0]['address'], withdraw_address)
         assert_equal(result[0]['amounts'], ['0.50000000@DFI'])
         assert_equal(result[0]['txid'], withdraw_tx)
-        assert_equal(result[1]['vault'], create_vault_tx)
         assert_equal(result[1]['type'], 'PaybackLoan')
         assert_equal(result[1]['address'], 'mfburnZSAM7Gs1hpDeNaMotJXSGA7edosG')
-        assert_equal(result[1]['amounts'], ['0.00000114@DFI'])
+        assert_equal(result[1]['amounts'], ['0.00000228@DFI'])
         assert_equal(result[1]['txid'], payback_tx)
-        assert_equal(result[2]['vault'], create_vault_tx)
         assert_equal(result[2]['type'], 'PaybackLoan')
         assert_equal(result[2]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
-        assert_equal(result[2]['amounts'], ['-1.00000114@TSLA'])
+        assert_equal(result[2]['amounts'], ['-1.00000228@TSLA'])
         assert_equal(result[2]['txid'], payback_tx)
 
-        # Test getvaulthistory token type
-        result = self.nodes[0].getvaulthistory(create_vault_tx, {'token':'TSLA'})
+        # Test listvaulthistory token type
+        result = self.nodes[0].listvaulthistory(create_vault_tx, {'token':'TSLA'})
         assert_equal(len(result), 2)
-        assert_equal(result[0]['vault'], create_vault_tx)
         assert_equal(result[0]['type'], 'PaybackLoan')
         assert_equal(result[0]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
-        assert_equal(result[0]['amounts'], ['-1.00000114@TSLA'])
+        assert_equal(result[0]['amounts'], ['-1.00000228@TSLA'])
         assert_equal(result[0]['txid'], payback_tx)
-        assert_equal(result[1]['vault'], create_vault_tx)
         assert_equal(result[1]['type'], 'TakeLoan')
         assert_equal(result[1]['address'], vault_owner)
         assert_equal(result[1]['amounts'], ['1.00000000@TSLA'])
         assert_equal(result[1]['txid'], takeloan_tx)
 
-        # Test getvaulthistory TX type
-        result = self.nodes[0].getvaulthistory(create_vault_tx, {'txtype':'J'})
+        # Test listvaulthistory TX type
+        result = self.nodes[0].listvaulthistory(create_vault_tx, {'txtype':'J'})
         assert_equal(len(result), 1)
-        assert_equal(result[0]['vault'], create_vault_tx)
         assert_equal(result[0]['type'], 'WithdrawFromVault')
         assert_equal(result[0]['address'], withdraw_address)
         assert_equal(result[0]['amounts'], ['0.50000000@DFI'])
         assert_equal(result[0]['txid'], withdraw_tx)
 
-        # Test getvaulthistory limit
-        result = self.nodes[0].getvaulthistory(create_vault_tx, {'limit':1})
+        # Test listvaulthistory limit
+        result = self.nodes[0].listvaulthistory(create_vault_tx, {'limit':1})
         assert_equal(len(result), 1)
-        assert_equal(result[0]['vault'], create_vault_tx)
         assert_equal(result[0]['type'], 'CloseVault')
         assert_equal(result[0]['address'], close_address)
         assert_equal(result[0]['amounts'], ['10.00000000@DFI'])
@@ -227,12 +284,16 @@ def run_test(self):
         # Test rollback of tip to remove CloseVault TX
         self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
         self.nodes[0].clearmempool()
-        result = self.nodes[0].getvaulthistory(create_vault_tx)
+        result = self.nodes[0].listvaulthistory(create_vault_tx)
 
         # Quick check of last entry
-        assert_equal(len(result), 5)
+        assert_equal(len(result), 9)
         assert_equal(result[0]['type'], 'WithdrawFromVault')
 
+        # Restore original scheme values
+        self.nodes[0].updateloanscheme(150, 5, 'LOAN0001')
+        self.nodes[0].generate(1)
+
         # Create new vault
         new_vault = self.nodes[0].createvault(vault_owner, 'LOAN0001')
         self.nodes[0].generate(1)
@@ -261,58 +322,58 @@ def run_test(self):
         self.nodes[0].generate(33)
 
         # Check bids in result
-        result = self.nodes[0].getvaulthistory(new_vault)
-        assert_equal(len(result), 7)
-        assert_equal(result[0]['vault'], new_vault)
+        result = self.nodes[0].listvaulthistory(new_vault)
+        assert_equal(len(result), 8)
         assert_equal(result[0]['vaultSnapshot']['state'], 'active')
-        assert_equal(result[0]['vaultSnapshot']['collateralAmounts'], ['1.87309846@DFI'])
-        assert_equal(result[0]['vaultSnapshot']['collateralValue'], Decimal('187.30984600'))
+        assert_equal(result[0]['vaultSnapshot']['collateralAmounts'], ['1.87309837@DFI'])
+        assert_equal(result[0]['vaultSnapshot']['collateralValue'], Decimal('187.30983700'))
         assert_equal(result[0]['vaultSnapshot']['collateralRatio'], 0)
-        assert_equal(result[0]['vaultSnapshot']['schemeID'], 'LOAN0001')
         assert_equal(result[0]['vaultSnapshot']['batches'], [])
-        assert_equal(result[1]['vault'], new_vault)
         assert_equal(result[1]['type'], 'AuctionBid')
         assert_equal(result[1]['txid'], bid2_tx)
-        assert_equal(result[2]['vault'], new_vault)
         assert_equal(result[2]['type'], 'AuctionBid')
         assert_equal(result[2]['txid'], bid2_tx)
 
-        if result[0]['address'] == new_bidding_address:
+        if result[1]['address'] == new_bidding_address:
             assert_equal(result[1]['amounts'], ['-9.00000000@TSLA'])
             assert_equal(result[2]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
             assert_equal(result[2]['amounts'], ['8.00000000@TSLA'])
-        elif result[0]['address'] == self.nodes[0].get_genesis_keys().ownerAuthAddress:
+        elif result[1]['address'] == self.nodes[0].get_genesis_keys().ownerAuthAddress:
             assert_equal(result[1]['amounts'], ['8.00000000@TSLA'])
             assert_equal(result[2]['address'], new_bidding_address)
             assert_equal(result[2]['amounts'], ['-9.00000000@TSLA'])
         else:
             assert('Expected address not found in results')
 
-        assert_equal(result[3]['vault'], new_vault)
         assert_equal(result[3]['type'], 'AuctionBid')
         assert_equal(result[3]['address'], self.nodes[0].get_genesis_keys().ownerAuthAddress)
         assert_equal(result[3]['amounts'], ['-8.00000000@TSLA'])
         assert_equal(result[3]['txid'], bid1_tx)
-        assert_equal(result[4]['vault'], new_vault)
         assert_equal(result[4]['vaultSnapshot']['state'], 'inLiquidation')
         assert_equal(result[4]['vaultSnapshot']['collateralAmounts'], [])
         assert_equal(result[4]['vaultSnapshot']['collateralValue'], Decimal('0.00000000'))
         assert_equal(result[4]['vaultSnapshot']['collateralRatio'], 149)
-        assert_equal(result[4]['vaultSnapshot']['schemeID'], 'LOAN0001')
         assert_equal(len(result[4]['vaultSnapshot']['batches']), 1)
         assert_equal(result[4]['vaultSnapshot']['batches'][0]['index'], 0)
         assert_equal(result[4]['vaultSnapshot']['batches'][0]['collaterals'], ['10.00000000@DFI'])
         assert_equal(result[4]['vaultSnapshot']['batches'][0]['loan'], '6.68896763@TSLA')
-        assert_equal(result[5]['vault'], new_vault)
         assert_equal(result[5]['type'], 'TakeLoan')
         assert_equal(result[5]['address'], vault_owner)
         assert_equal(result[5]['amounts'], ['6.68896000@TSLA'])
         assert_equal(result[5]['txid'], takeloan_tx)
-        assert_equal(result[6]['vault'], new_vault)
         assert_equal(result[6]['type'], 'DepositToVault')
         assert_equal(result[6]['address'], vault_owner)
         assert_equal(result[6]['amounts'], ['-10.00000000@DFI'])
         assert_equal(result[6]['txid'], deposit_tx)
+        assert_equal(result[7]['type'], 'Vault')
+        assert_equal(result[7]['loanScheme']['id'], 'LOAN0001')
+        assert_equal(result[7]['loanScheme']['rate'], 500000000)
+        assert_equal(result[7]['loanScheme']['ratio'], 150)
+        assert_equal(result[7]['txid'], new_vault)
+
+        print(create_vault_tx)
+        print(new_vault)
+        assert(False)
 
 if __name__ == '__main__':
     TokensRPCGetVaultHistory().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 7517b33576..01b4522ef7 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -248,7 +248,7 @@
     'rpc_deriveaddresses.py --usecli',
     'rpc_scantxoutset.py',
     'rpc_getcustomtx.py',
-    'rpc_getvaulthistory.py',
+    'rpc_listvaulthistory.py',
     'feature_logging.py',
     'feature_loan_scheme.py',
     'feature_forced_reward_address.py',

From 3ecd592ee69fcc40e6c51d0e42a42fa7a48207f0 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Thu, 18 Nov 2021 13:58:25 +0000
Subject: [PATCH 08/12] lint: Correct IDE added include to use <>

---
 src/masternodes/mn_checks.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 03684932d1..658cf6f16c 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -8,6 +8,7 @@
 #include <masternodes/mn_checks.h>
 #include <masternodes/oracles.h>
 #include <masternodes/res.h>
+#include <masternodes/vaulthistory.h>
 
 #include <arith_uint256.h>
 #include <chainparams.h>
@@ -23,7 +24,6 @@
 #include <validation.h>
 
 #include <algorithm>
-#include "vaulthistory.h"
 
 std::string ToString(CustomTxType type) {
     switch (type)

From f8182e6a189eedac5df25a4d9a8170f5cd808af2 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Thu, 18 Nov 2021 15:12:45 +0000
Subject: [PATCH 09/12] Toggle txid in results. Minor lint/test updates

---
 src/masternodes/rpc_vault.cpp           | 4 +++-
 test/functional/rpc_listvaulthistory.py | 5 -----
 test/lint/lint-circular-dependencies.sh | 6 +++---
 3 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index 80320cac75..d4eff5c2df 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1166,7 +1166,9 @@ UniValue vaultToJSON(const uint256& vaultID, const std::string& address, const u
     if (!address.empty()) {
         obj.pushKV("txn", txn);
     }
-    obj.pushKV("txid", txid);
+    if (!txid.empty()) {
+        obj.pushKV("txid", txid);
+    }
     if (!amounts.empty()) {
         obj.pushKV("amounts", AmountsToJSON(amounts));
     }
diff --git a/test/functional/rpc_listvaulthistory.py b/test/functional/rpc_listvaulthistory.py
index 240148bab5..2e34083297 100644
--- a/test/functional/rpc_listvaulthistory.py
+++ b/test/functional/rpc_listvaulthistory.py
@@ -328,7 +328,6 @@ def run_test(self):
         assert_equal(result[0]['vaultSnapshot']['collateralAmounts'], ['1.87309837@DFI'])
         assert_equal(result[0]['vaultSnapshot']['collateralValue'], Decimal('187.30983700'))
         assert_equal(result[0]['vaultSnapshot']['collateralRatio'], 0)
-        assert_equal(result[0]['vaultSnapshot']['batches'], [])
         assert_equal(result[1]['type'], 'AuctionBid')
         assert_equal(result[1]['txid'], bid2_tx)
         assert_equal(result[2]['type'], 'AuctionBid')
@@ -371,9 +370,5 @@ def run_test(self):
         assert_equal(result[7]['loanScheme']['ratio'], 150)
         assert_equal(result[7]['txid'], new_vault)
 
-        print(create_vault_tx)
-        print(new_vault)
-        assert(False)
-
 if __name__ == '__main__':
     TokensRPCGetVaultHistory().main()
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 4745a32f98..ed0e8b269a 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -24,7 +24,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "chain -> chainparams -> masternodes/mn_checks -> index/txindex -> txdb -> chain"
     "chain -> chainparams -> masternodes/mn_checks -> validation -> versionbits -> chain"
     "chain -> chainparams -> masternodes/mn_checks -> validation -> wallet/wallet -> chain"
-    "chain -> chainparams -> masternodes/mn_checks -> validation -> masternodes/vaulthistory -> chain"
+    "chain -> chainparams -> masternodes/mn_checks -> masternodes/vaulthistory -> chain"
     "chainparams -> key_io -> chainparams"
     "chainparams -> masternodes/mn_checks -> validation -> chainparams"
     "chainparams -> masternodes/mn_checks -> index/txindex -> index/base -> chainparams"
@@ -32,7 +32,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "chainparams -> masternodes/mn_checks -> validation -> wallet/wallet -> chainparams"
     "chainparams -> masternodes/mn_checks -> chainparams"
     "chainparams -> masternodes/mn_checks -> masternodes/anchors -> chainparams"
-    "chainparams -> masternodes/mn_checks -> validation -> masternodes/vaulthistory -> masternodes/vault -> chainparams"
+    "chainparams -> masternodes/mn_checks -> masternodes/vaulthistory -> masternodes/vault -> chainparams"
     "consensus/tx_verify -> masternodes/masternodes -> validation -> consensus/tx_verify"
     "consensus/tx_verify -> masternodes/mn_checks -> txmempool -> consensus/tx_verify"
     "masternodes/govvariables/icx_takerfee_per_btc -> masternodes/gv -> masternodes/govvariables/icx_takerfee_per_btc"
@@ -51,10 +51,10 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "masternodes/masternodes -> validation -> masternodes/masternodes"
     "masternodes/masternodes -> net_processing -> masternodes/masternodes"
     "masternodes/masternodes -> wallet/wallet -> masternodes/masternodes"
-    "masternodes/masternodes -> validation -> masternodes/vaulthistory -> masternodes/masternodes"
     "masternodes/mn_checks -> txmempool -> masternodes/mn_checks"
     "masternodes/mn_checks -> validation -> masternodes/mn_checks"
     "masternodes/mn_checks -> validation -> wallet/wallet -> masternodes/mn_checks"
+    "masternodes/masternodes -> masternodes/mn_checks -> masternodes/vaulthistory -> masternodes/masternodes"
     "masternodes/anchors -> spv/spv_wrapper -> masternodes/anchors"
     "masternodes/anchors -> validation -> masternodes/anchors"
     "masternodes/anchors -> masternodes/masternodes -> masternodes/anchors"

From 8c1e5af1f5665df189160e4f20a23334501c2284 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Fri, 19 Nov 2021 07:52:35 +0000
Subject: [PATCH 10/12] Display vault ratio when coming out of auction without
 bids

---
 src/masternodes/rpc_vault.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index d4eff5c2df..9aa2e63930 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1195,7 +1195,7 @@ UniValue stateToJSON(VaultStateKey const & key, VaultStateValue const & value) {
     snapshot.pushKV("state", !value.auctionBatches.empty() ? "inLiquidation" : "active");
     snapshot.pushKV("collateralAmounts", AmountsToJSON(value.collaterals));
     snapshot.pushKV("collateralValue", ValueFromUint(value.collateralsValues.totalCollaterals));
-    snapshot.pushKV("collateralRatio", static_cast<int>(value.ratio));
+    snapshot.pushKV("collateralRatio", value.ratio != -1 ? static_cast<int>(value.ratio) : static_cast<int>(value.collateralsValues.ratio()));
     if (!value.auctionBatches.empty()) {
         snapshot.pushKV("batches", BatchToJSON(value.auctionBatches));
     }

From 1c2f0da68b1fb69c9edce5d8b2d557c4b8bc1e41 Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Fri, 19 Nov 2021 13:49:06 +0000
Subject: [PATCH 11/12] Simplify vault history TX parsing

---
 src/masternodes/accountshistory.cpp     |  13 +-
 src/masternodes/loan.h                  |   1 -
 src/masternodes/mn_checks.cpp           | 172 +++++++++---------------
 src/masternodes/mn_checks.h             |   2 +-
 src/masternodes/mn_rpc.cpp              |   5 +-
 src/masternodes/rpc_customtx.cpp        |   5 +-
 src/masternodes/rpc_vault.cpp           |   4 +-
 src/masternodes/vaulthistory.cpp        |  35 ++---
 src/masternodes/vaulthistory.h          |   6 +-
 src/validation.cpp                      |   2 +-
 test/functional/rpc_listvaulthistory.py |  28 +++-
 11 files changed, 110 insertions(+), 163 deletions(-)

diff --git a/src/masternodes/accountshistory.cpp b/src/masternodes/accountshistory.cpp
index 5890979dd5..ed08c6c732 100644
--- a/src/masternodes/accountshistory.cpp
+++ b/src/masternodes/accountshistory.cpp
@@ -141,17 +141,6 @@ void CHistoryErasers::Flush(const uint32_t height, const uint32_t txn, const uin
             burnView->EraseAccountHistory({account, height, txn});
         }
     }
-    if (vaultView) {
-        for (const auto& vault : vaults) {
-            vaultView->EraseVaultHistory({vault, height, txn});
-        }
-        if (removeLoanScheme) {
-            vaultView->EraseVaultScheme({vaultID, height});
-        }
-        if (!schemeCreationTxid.IsNull()) {
-            vaultView->EraseGlobalScheme({height, txn, schemeCreationTxid});
-        }
-    }
 }
 
 CHistoryWriters::CHistoryWriters(CAccountHistoryStorage* historyView, CBurnHistoryStorage* burnView, CVaultHistoryStorage* vaultView)
@@ -205,7 +194,7 @@ void CHistoryWriters::Flush(const uint32_t height, const uint256& txid, const ui
     if (vaultView) {
         for (const auto& diff : vaultDiffs) {
             for (const auto& addresses : diff.second) {
-                vaultView->WriteVaultHistory({diff.first, height, txn, addresses.first}, {txid, type, addresses.second});
+                vaultView->WriteVaultHistory({height, diff.first, txn, addresses.first}, {txid, type, addresses.second});
             }
         }
         if (!schemeID.empty()) {
diff --git a/src/masternodes/loan.h b/src/masternodes/loan.h
index a3947af301..e7a9527156 100644
--- a/src/masternodes/loan.h
+++ b/src/masternodes/loan.h
@@ -167,7 +167,6 @@ struct CLoanScheme : public CLoanSchemeData
 struct CLoanSchemeCreation : public CLoanScheme
 {
     uint256 schemeCreationTxid;
-    bool creation{false};
 };
 
 struct CLoanSchemeMessage : public CLoanScheme
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 658cf6f16c..de9180b8a8 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -166,9 +166,6 @@ extern std::string ScriptToString(CScript const& script);
 class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 {
     uint32_t height;
-    uint256& vaultID;
-    std::string& schemeID;
-    CLoanSchemeCreation& globalScheme;
     const Consensus::Params& consensus;
     const std::vector<unsigned char>& metadata;
 
@@ -227,11 +224,8 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 public:
     CCustomMetadataParseVisitor(uint32_t height,
                                 const Consensus::Params& consensus,
-                                const std::vector<unsigned char>& metadata,
-                                uint256& vaultID,
-                                std::string& schemeID,
-                                CLoanSchemeCreation& globalScheme)
-        : height(height), vaultID(vaultID), schemeID(schemeID), consensus(consensus), metadata(metadata), globalScheme(globalScheme) {}
+                                const std::vector<unsigned char>& metadata)
+        : height(height), consensus(consensus), metadata(metadata) {}
 
     Res operator()(CCreateMasterNodeMessage& obj) const {
         return serialize(obj);
@@ -477,16 +471,7 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 
     Res operator()(CLoanSchemeMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            globalScheme.identifier = obj.identifier;
-            globalScheme.ratio = obj.ratio;
-            globalScheme.rate = obj.rate;
-            if (!obj.updateHeight) {
-                globalScheme.creation = true;
-            }
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CDefaultLoanSchemeMessage& obj) const {
@@ -501,77 +486,42 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 
     Res operator()(CVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            schemeID = obj.schemeId;
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CCloseVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            vaultID = obj.vaultId;
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CUpdateVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            vaultID = obj.vaultId;
-            if (!obj.schemeId.empty()) {
-                schemeID = obj.schemeId;
-            }
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CDepositToVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            vaultID = obj.vaultId;
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CWithdrawFromVaultMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            vaultID = obj.vaultId;
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CLoanTakeLoanMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            vaultID = obj.vaultId;
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CLoanPaybackLoanMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            vaultID = obj.vaultId;
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CAuctionBidMessage& obj) const {
         auto res = isPostFortCanningFork();
-        if (res) {
-            res = serialize(obj);
-            vaultID = obj.vaultId;
-        }
-        return res;
+        return !res ? res : serialize(obj);
     }
 
     Res operator()(CCustomTxMessageNone&) const {
@@ -3032,9 +2982,9 @@ class CCustomTxRevertVisitor : public CCustomTxVisitor
     }
 };
 
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID, std::string& schemeID, CLoanSchemeCreation& globalScheme) {
+Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage) {
     try {
-        return boost::apply_visitor(CCustomMetadataParseVisitor(height, consensus, metadata, vaultID, schemeID, globalScheme), txMessage);
+        return boost::apply_visitor(CCustomMetadataParseVisitor(height, consensus, metadata), txMessage);
     } catch (const std::exception& e) {
         return Res::Err(e.what());
     } catch (...) {
@@ -3094,25 +3044,7 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
     uint256 vaultID;
     std::string schemeID;
     CLoanSchemeCreation globalScheme;
-    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID, schemeID, globalScheme))) {
-        if (pvaultHistoryDB) {
-            view.vaultID = vaultID;
-            if (!schemeID.empty()) {
-                erasers.removeLoanScheme = true;
-            } else if (!globalScheme.identifier.empty()) {
-                if (globalScheme.creation) {
-                    erasers.schemeCreationTxid = tx.GetHash();
-                } else {
-                    erasers.vaultView->ForEachGlobalScheme([&erasers, &globalScheme](VaultGlobalSchemeKey const & key, CLazySerialize<VaultGlobalSchemeValue> value) {
-                        if (value.get().loanScheme.identifier != globalScheme.identifier) {
-                            return true;
-                        }
-                        erasers.schemeCreationTxid = key.schemeCreationTxid;
-                        return false;
-                    }, {height, txn, {}});
-                }
-            }
-        }
+    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage))) {
         res = CustomTxRevert(view, coins, tx, height, consensus, txMessage);
 
         // Track burn fee
@@ -3129,6 +3061,54 @@ Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CT
     return (view.Flush(), res);
 }
 
+void PopulateVaultHistoryData(CHistoryWriters* writers, CAccountsHistoryWriter& view, const CCustomTxMessage& txMessage, const CustomTxType txType, const uint32_t height, const uint32_t txn, const uint256& txid) {
+    if (txType == CustomTxType::Vault) {
+        auto obj = boost::get<CVaultMessage>(txMessage);
+        writers->schemeID = obj.schemeId;
+        view.vaultID = txid;
+    } else if (txType == CustomTxType::CloseVault) {
+        auto obj = boost::get<CCloseVaultMessage>(txMessage);
+        view.vaultID = obj.vaultId;
+    } else if (txType == CustomTxType::UpdateVault) {
+        auto obj = boost::get<CUpdateVaultMessage>(txMessage);
+        view.vaultID = obj.vaultId;
+        if (!obj.schemeId.empty()) {
+            writers->schemeID = obj.schemeId;
+        }
+    } else if (txType == CustomTxType::DepositToVault) {
+        auto obj = boost::get<CDepositToVaultMessage>(txMessage);
+        view.vaultID = obj.vaultId;
+    } else if (txType == CustomTxType::WithdrawFromVault) {
+        auto obj = boost::get<CWithdrawFromVaultMessage>(txMessage);
+        view.vaultID = obj.vaultId;
+    } else if (txType == CustomTxType::TakeLoan) {
+        auto obj = boost::get<CLoanTakeLoanMessage>(txMessage);
+        view.vaultID = obj.vaultId;
+    } else if (txType == CustomTxType::PaybackLoan) {
+        auto obj = boost::get<CLoanPaybackLoanMessage>(txMessage);
+        view.vaultID = obj.vaultId;
+    } else if (txType == CustomTxType::AuctionBid) {
+        auto obj = boost::get<CAuctionBidMessage>(txMessage);
+        view.vaultID = obj.vaultId;
+    } else if (txType == CustomTxType::LoanScheme) {
+        auto obj = boost::get<CLoanSchemeMessage>(txMessage);
+        writers->globalLoanScheme.identifier = obj.identifier;
+        writers->globalLoanScheme.ratio = obj.ratio;
+        writers->globalLoanScheme.rate = obj.rate;
+        if (!obj.updateHeight) {
+            writers->globalLoanScheme.schemeCreationTxid = txid;
+        } else {
+            writers->vaultView->ForEachGlobalScheme([&writers](VaultGlobalSchemeKey const & key, CLazySerialize<VaultGlobalSchemeValue> value) {
+                if (value.get().loanScheme.identifier != writers->globalLoanScheme.identifier) {
+                    return true;
+                }
+                writers->globalLoanScheme.schemeCreationTxid = key.schemeCreationTxid;
+                return false;
+            }, {height, txn, {}});
+        }
+    }
+}
+
 Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time, uint32_t txn, CHistoryWriters* writers) {
     auto res = Res::Ok();
     if (tx.IsCoinBase() && height > 0) { // genesis contains custom coinbase txs
@@ -3145,33 +3125,9 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
     }
     auto txMessage = customTypeToMessage(txType);
     CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), writers);
-    uint256 vaultID;
-    std::string schemeID;
-    CLoanSchemeCreation globalScheme;
-    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage, vaultID, schemeID, globalScheme))) {
+    if ((res = CustomMetadataParse(height, consensus, metadata, txMessage))) {
         if (pvaultHistoryDB && writers) {
-            view.vaultID = vaultID;
-            if (!schemeID.empty()) {
-                writers->schemeID = schemeID;
-
-                // ID null on vault creation
-                if (vaultID.IsNull()) {
-                    view.vaultID = tx.GetHash();
-                }
-            } else if (!globalScheme.identifier.empty()) {
-                if (globalScheme.creation) {
-                    globalScheme.schemeCreationTxid = tx.GetHash();
-                } else {
-                    writers->vaultView->ForEachGlobalScheme([&globalScheme](VaultGlobalSchemeKey const & key, CLazySerialize<VaultGlobalSchemeValue> value) {
-                        if (value.get().loanScheme.identifier != globalScheme.identifier) {
-                            return true;
-                        }
-                        globalScheme.schemeCreationTxid = key.schemeCreationTxid;
-                        return false;
-                    }, {height, txn, {}});
-                }
-                writers->globalLoanScheme = globalScheme;
-            }
+           PopulateVaultHistoryData(writers, view, txMessage, txType, height, txn, tx.GetHash());
         }
         res = CustomTxVisit(view, coins, tx, height, consensus, txMessage, time);
 
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index e22784122a..3f37050036 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -371,7 +371,7 @@ typedef boost::variant<
 CCustomTxMessage customTypeToMessage(CustomTxType txType);
 bool IsMempooledCustomTxCreate(const CTxMemPool& pool, const uint256& txid);
 Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& type, UniValue& results);
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage, uint256& vaultID, std::string& schemeID, CLoanSchemeCreation& globalScheme);
+Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage);
 Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint32_t txn = 0, CHistoryWriters* writers = nullptr);
 Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height,  uint32_t txn, CHistoryErasers& erasers);
 Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time = 0);
diff --git a/src/masternodes/mn_rpc.cpp b/src/masternodes/mn_rpc.cpp
index beb1f1fc3e..b13f2c5d1b 100644
--- a/src/masternodes/mn_rpc.cpp
+++ b/src/masternodes/mn_rpc.cpp
@@ -425,10 +425,7 @@ void execTestTx(const CTransaction& tx, uint32_t height, CTransactionRef optAuth
     std::vector<unsigned char> metadata;
     auto txType = GuessCustomTxType(tx, metadata);
     auto txMessage = customTypeToMessage(txType);
-    uint256 vaultID;
-    std::string schemeID;
-    CLoanSchemeCreation globalScheme;
-    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID, schemeID, globalScheme);
+    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage);
     if (res) {
         LOCK(cs_main);
         CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index 2b7a4f8cb9..e7596f46ac 100644
--- a/src/masternodes/rpc_customtx.cpp
+++ b/src/masternodes/rpc_customtx.cpp
@@ -452,10 +452,7 @@ Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& txType, UniVa
         return Res::Ok();
     }
     auto txMessage = customTypeToMessage(txType);
-    uint256 vaultID;
-    std::string schemeID;
-    CLoanSchemeCreation globalScheme;
-    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage, vaultID, schemeID, globalScheme);
+    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage);
     if (res) {
         CCustomCSView mnview(*pcustomcsview);
         boost::apply_visitor(CCustomTxRpcVisitor(tx, height, mnview, results), txMessage);
diff --git a/src/masternodes/rpc_vault.cpp b/src/masternodes/rpc_vault.cpp
index 9aa2e63930..2b0989958a 100644
--- a/src/masternodes/rpc_vault.cpp
+++ b/src/masternodes/rpc_vault.cpp
@@ -1343,7 +1343,7 @@ UniValue listvaulthistory(const JSONRPCRequest& request) {
     auto shouldContinue = [&](VaultHistoryKey const & key, CLazySerialize<VaultHistoryValue> valueLazy) -> bool
     {
         if (!isMatchVault(key.vaultID)) {
-            return false;
+            return true;
         }
 
         if (shouldSkipBlock(key.blockHeight)) {
@@ -1366,7 +1366,7 @@ UniValue listvaulthistory(const JSONRPCRequest& request) {
         return --count != 0;
     };
 
-    VaultHistoryKey startKey{vaultID, maxBlockHeight, std::numeric_limits<uint32_t>::max(), {}};
+    VaultHistoryKey startKey{maxBlockHeight, vaultID, std::numeric_limits<uint32_t>::max(), {}};
     pvaultHistoryDB->ForEachVaultHistory(shouldContinue, startKey);
 
     // Get vault state changes
diff --git a/src/masternodes/vaulthistory.cpp b/src/masternodes/vaulthistory.cpp
index 3b6d348f05..5d07ab7684 100644
--- a/src/masternodes/vaulthistory.cpp
+++ b/src/masternodes/vaulthistory.cpp
@@ -21,9 +21,19 @@ void CVaultHistoryView::WriteGlobalScheme(VaultGlobalSchemeKey const & key, cons
     WriteBy<ByVaultGlobalSchemeKey>(key, value);
 }
 
-void CVaultHistoryView::EraseVaultHistory(const VaultHistoryKey& key)
+void CVaultHistoryView::EraseVaultHistory(const uint32_t height)
 {
-    EraseBy<ByVaultHistoryKey>(key);
+    std::vector<VaultHistoryKey> keys;
+    auto historyIt = LowerBound<ByVaultHistoryKey>(VaultHistoryKey{height});
+    for (; historyIt.Valid() && historyIt.Key().blockHeight == height; historyIt.Next()) {
+        keys.push_back(historyIt.Key());
+    }
+    for (auto& key : keys) {
+        EraseBy<ByVaultHistoryKey>(key);
+        const auto stateKey = VaultStateKey{key.vaultID, key.blockHeight};
+        EraseBy<ByVaultStateKey>(stateKey);
+        EraseBy<ByVaultSchemeKey>(stateKey);
+    }
 }
 
 void CVaultHistoryView::ForEachVaultScheme(std::function<bool(VaultSchemeKey const &, CLazySerialize<VaultSchemeValue>)> callback, VaultSchemeKey const & start)
@@ -72,32 +82,11 @@ void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex
     WriteBy<ByVaultStateKey>(VaultStateKey{vaultID, static_cast<uint32_t>(pindex.nHeight)}, value);
 }
 
-void CVaultHistoryView::EraseVaultScheme(const VaultSchemeKey& key)
-{
-    EraseBy<ByVaultSchemeKey>(key);
-}
-
 void CVaultHistoryView::EraseGlobalScheme(const VaultGlobalSchemeKey& key)
 {
     EraseBy<ByVaultGlobalSchemeKey>(key);
 }
 
-void CVaultHistoryView::EraseVaultState(const uint32_t height)
-{
-    std::vector<uint256> vaultIDs;
-    ForEachVaultState([&](VaultStateKey const & key, CLazySerialize<VaultStateValue> value) {
-        if (key.blockHeight != height) {
-            return false;
-        }
-        vaultIDs.push_back(key.vaultID);
-        return true;
-    }, {{}, height});
-
-    for (const auto id : vaultIDs) {
-        EraseBy<ByVaultStateKey>(VaultStateKey{id, height});
-    }
-}
-
 CVaultHistoryStorage::CVaultHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
         : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe))
 {
diff --git a/src/masternodes/vaulthistory.h b/src/masternodes/vaulthistory.h
index 05cdc10c9f..0a8a96279d 100644
--- a/src/masternodes/vaulthistory.h
+++ b/src/masternodes/vaulthistory.h
@@ -12,8 +12,8 @@
 #include <script/script.h>
 
 struct VaultHistoryKey {
-    uint256 vaultID;
     uint32_t blockHeight;
+    uint256 vaultID;
     uint32_t txn; // for order in block
     CScript address;
 
@@ -161,9 +161,7 @@ class CVaultHistoryView : public virtual CStorageView
     void WriteVaultScheme(VaultSchemeKey const & key, const VaultSchemeValue& value);
     void WriteVaultState(CCustomCSView& mnview, const CBlockIndex& pindex, const uint256& vaultID, const uint32_t ratio = 0);
 
-    void EraseVaultHistory(const VaultHistoryKey& key);
-    void EraseVaultScheme(const VaultSchemeKey& key);
-    void EraseVaultState(const uint32_t height);
+    void EraseVaultHistory(const uint32_t height);
 
     void ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start = {});
     void ForEachVaultScheme(std::function<bool(VaultSchemeKey const &, CLazySerialize<VaultSchemeValue>)> callback, VaultSchemeKey const & start = {});
diff --git a/src/validation.cpp b/src/validation.cpp
index 3349f9007d..a7b1c762fc 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1671,7 +1671,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
             paccountHistoryDB->EraseAuctionHistoryHeight(pindex->nHeight);
         }
         if (pvaultHistoryDB) {
-            pvaultHistoryDB->EraseVaultState(pindex->nHeight);
+            pvaultHistoryDB->EraseVaultHistory(pindex->nHeight);
         }
     }
 
diff --git a/test/functional/rpc_listvaulthistory.py b/test/functional/rpc_listvaulthistory.py
index 2e34083297..a90fcfdac3 100644
--- a/test/functional/rpc_listvaulthistory.py
+++ b/test/functional/rpc_listvaulthistory.py
@@ -118,6 +118,11 @@ def run_test(self):
         deposit_tx = self.nodes[0].deposittovault(create_vault_tx, collateral_a, '10@DFI')
         self.nodes[0].generate(1)
 
+        # Create new vault, make sure records do not get mixed up
+        another_owner = self.nodes[0].getnewaddress("", "legacy")
+        create_another_tx = self.nodes[0].createvault(another_owner, 'LOAN0002')
+        self.nodes[0].generate(1)
+
         # Update global loan scheme change
         update_002_tx = self.nodes[0].updateloanscheme(600, 1, 'LOAN0002')
         self.nodes[0].generate(1)
@@ -134,6 +139,10 @@ def run_test(self):
         assert_equal(result[0]['type'], 'DepositToVault')
         self.nodes[0].generate(1)
 
+        # Update other vault's loan scheme
+        update_tx = self.nodes[0].updatevault(create_another_tx, {'loanSchemeId': 'LOAN0001'})
+        self.nodes[0].generate(1)
+
         # Change loan scheme
         update_tx = self.nodes[0].updatevault(create_vault_tx, {'loanSchemeId': 'LOAN0001'})
         self.nodes[0].generate(1)
@@ -183,6 +192,7 @@ def run_test(self):
         withdraw_address = self.nodes[0].getnewaddress("", "legacy")
         withdraw_tx = self.nodes[0].withdrawfromvault(create_vault_tx, withdraw_address, '0.5@DFI')
         self.nodes[0].generate(1)
+        withdraw_height = self.nodes[0].getblockcount()
 
         # Close vault
         close_address = self.nodes[0].getnewaddress("", "legacy")
@@ -238,7 +248,7 @@ def run_test(self):
         assert_equal(result[9]['txid'], create_vault_tx)
 
         # Test listvaulthistory block height and depth
-        result = self.nodes[0].listvaulthistory(create_vault_tx, {'maxBlockHeight':126,'depth':1})
+        result = self.nodes[0].listvaulthistory(create_vault_tx, {'maxBlockHeight':withdraw_height,'depth':1})
         assert_equal(len(result), 3)
         assert_equal(result[0]['type'], 'WithdrawFromVault')
         assert_equal(result[0]['address'], withdraw_address)
@@ -308,7 +318,19 @@ def run_test(self):
 
         # Take loan
         takeloan_tx = self.nodes[0].takeloan({'vaultId': new_vault,'amounts': '6.68896@TSLA'})
-        self.nodes[0].generate(4)
+        self.nodes[0].generate(2)
+
+        # Test state change
+        result = self.nodes[0].listvaulthistory(new_vault)
+        assert_equal(len(result), 4)
+        assert_equal(result[0]['vaultSnapshot']['state'], 'inLiquidation')
+
+        # Test rollback of state change
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        result = self.nodes[0].listvaulthistory(new_vault)
+        assert_equal(len(result), 3)
+        assert_equal(result[0]['type'], 'TakeLoan')
+        self.nodes[0].generate(1)
 
         # Fund another bidding address
         new_bidding_address = self.nodes[0].getnewaddress("", "legacy")
@@ -319,7 +341,7 @@ def run_test(self):
         bid1_tx = self.nodes[0].placeauctionbid(new_vault, 0, self.nodes[0].get_genesis_keys().ownerAuthAddress, '8@TSLA')
         self.nodes[0].generate(1)
         bid2_tx = self.nodes[0].placeauctionbid(new_vault, 0, new_bidding_address, '9@TSLA')
-        self.nodes[0].generate(33)
+        self.nodes[0].generate(35)
 
         # Check bids in result
         result = self.nodes[0].listvaulthistory(new_vault)

From 7a86d4dd1992cf6d3d9e5e449725aa2b031eafcb Mon Sep 17 00:00:00 2001
From: Peter Bushnell <bushsolo@gmail.com>
Date: Fri, 19 Nov 2021 14:37:18 +0000
Subject: [PATCH 12/12] Update serialisation order to be the same as member
 definition order

---
 src/masternodes/vaulthistory.h          | 12 +++++++-----
 test/functional/rpc_listvaulthistory.py |  2 --
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/masternodes/vaulthistory.h b/src/masternodes/vaulthistory.h
index 0a8a96279d..07751e5f75 100644
--- a/src/masternodes/vaulthistory.h
+++ b/src/masternodes/vaulthistory.h
@@ -21,21 +21,23 @@ struct VaultHistoryKey {
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(vaultID);
-
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(blockHeight));
             blockHeight = ~blockHeight;
-            READWRITE(WrapBigEndian(txn));
-            txn = ~txn;
         }
         else {
             uint32_t blockHeight_ = ~blockHeight;
             READWRITE(WrapBigEndian(blockHeight_));
+        }
+        READWRITE(vaultID);
+        if (ser_action.ForRead()) {
+            READWRITE(WrapBigEndian(txn));
+            txn = ~txn;
+        }
+        else {
             uint32_t txn_ = ~txn;
             READWRITE(WrapBigEndian(txn_));
         }
-
         READWRITE(address);
     }
 };
diff --git a/test/functional/rpc_listvaulthistory.py b/test/functional/rpc_listvaulthistory.py
index a90fcfdac3..930695f5b9 100644
--- a/test/functional/rpc_listvaulthistory.py
+++ b/test/functional/rpc_listvaulthistory.py
@@ -116,7 +116,6 @@ def run_test(self):
         self.nodes[0].utxostoaccount({collateral_a: "100@0"})
         self.nodes[0].generate(1)
         deposit_tx = self.nodes[0].deposittovault(create_vault_tx, collateral_a, '10@DFI')
-        self.nodes[0].generate(1)
 
         # Create new vault, make sure records do not get mixed up
         another_owner = self.nodes[0].getnewaddress("", "legacy")
@@ -141,7 +140,6 @@ def run_test(self):
 
         # Update other vault's loan scheme
         update_tx = self.nodes[0].updatevault(create_another_tx, {'loanSchemeId': 'LOAN0001'})
-        self.nodes[0].generate(1)
 
         # Change loan scheme
         update_tx = self.nodes[0].updatevault(create_vault_tx, {'loanSchemeId': 'LOAN0001'})