diff --git a/.gitignore b/.gitignore
index 8d4f18b260971..3141961d149c7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -45,6 +45,7 @@ src/config/bitcoin-config.h
 src/config/bitcoin-config.h.in
 src/config/stamp-h1
 src/obj
+src/omnicore/res/omnicore-setup-win.nsi
 share/setup.nsi
 share/qt/Info.plist
 
@@ -171,3 +172,7 @@ dist/
 /guix-build-*
 
 /ci/scratch/
+
+# clangd language server
+compile_commands.json
+./cache/clangd/*
diff --git a/src/Makefile.omnicore.include b/src/Makefile.omnicore.include
index a468b1a897ab8..f6f38a2a81035 100644
--- a/src/Makefile.omnicore.include
+++ b/src/Makefile.omnicore.include
@@ -1,9 +1,11 @@
 OMNICORE_H = \
   omnicore/activation.h \
+  omnicore/coinscache.h \
   omnicore/consensushash.h \
   omnicore/convert.h \
   omnicore/createpayload.h \
   omnicore/createtx.h \
+  omnicore/dbaddress.h \
   omnicore/dbbase.h \
   omnicore/dbfees.h \
   omnicore/dbspinfo.h \
@@ -16,6 +18,7 @@ OMNICORE_H = \
   omnicore/errors.h \
   omnicore/log.h \
   omnicore/mdex.h \
+  omnicore/mempool.h \
   omnicore/nftdb.h \
   omnicore/notifications.h \
   omnicore/omnicore.h \
@@ -38,6 +41,7 @@ OMNICORE_H = \
   omnicore/uint256_extensions.h \
   omnicore/utilsbitcoin.h \
   omnicore/utilsui.h \
+  omnicore/validationinterface.h \
   omnicore/version.h \
   omnicore/walletfetchtxs.h \
   omnicore/wallettxbuilder.h \
@@ -45,10 +49,12 @@ OMNICORE_H = \
 
 OMNICORE_CPP = \
   omnicore/activation.cpp \
+  omnicore/coinscache.cpp \
   omnicore/consensushash.cpp \
   omnicore/convert.cpp \
   omnicore/createpayload.cpp \
   omnicore/createtx.cpp \
+  omnicore/dbaddress.cpp \
   omnicore/dbbase.cpp \
   omnicore/dbfees.cpp \
   omnicore/dbspinfo.cpp \
@@ -60,6 +66,7 @@ OMNICORE_CPP = \
   omnicore/encoding.cpp \
   omnicore/log.cpp \
   omnicore/mdex.cpp \
+  omnicore/mempool.cpp \
   omnicore/nftdb.cpp \
   omnicore/notifications.cpp \
   omnicore/misc.cpp \
@@ -84,6 +91,7 @@ OMNICORE_CPP = \
   omnicore/tx.cpp \
   omnicore/utilsbitcoin.cpp \
   omnicore/utilsui.cpp \
+  omnicore/validationinterface.cpp \
   omnicore/version.cpp \
   omnicore/walletfetchtxs.cpp \
   omnicore/wallettxbuilder.cpp \
diff --git a/src/Makefile.omnitest.include b/src/Makefile.omnitest.include
index 8cb2c01322bc3..9ff3ba7442de0 100644
--- a/src/Makefile.omnitest.include
+++ b/src/Makefile.omnitest.include
@@ -12,6 +12,7 @@ OMNICORE_TEST_CPP = \
   omnicore/test/encoding_b_tests.cpp \
   omnicore/test/encoding_c_tests.cpp \
   omnicore/test/exodus_tests.cpp \
+  omnicore/test/iterator_tests.cpp \
   omnicore/test/lock_tests.cpp \
   omnicore/test/marker_tests.cpp \
   omnicore/test/mbstring_tests.cpp \
diff --git a/src/coins.h b/src/coins.h
index 4370b805a157d..f590050b65e43 100644
--- a/src/coins.h
+++ b/src/coins.h
@@ -20,69 +20,6 @@
 #include <functional>
 #include <unordered_map>
 
-struct CSpentIndexKey {
-    uint256 txid;
-    unsigned int outputIndex;
-
-    SERIALIZE_METHODS(CSpentIndexKey, obj) {
-        READWRITE(obj.txid, obj.outputIndex);
-    }
-
-    CSpentIndexKey(uint256 t, unsigned int i) {
-        txid = t;
-        outputIndex = i;
-    }
-
-    CSpentIndexKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        txid.SetNull();
-        outputIndex = 0;
-    }
-};
-
-struct CSpentIndexValue {
-    uint256 txid;
-    unsigned int inputIndex;
-    int blockHeight;
-    CAmount satoshis;
-    int addressType;
-    uint256 addressHash;
-
-    SERIALIZE_METHODS(CSpentIndexValue, obj) {
-        READWRITE(obj.txid, obj.inputIndex, obj.blockHeight,
-                  obj.satoshis, obj.addressType, obj.addressHash);
-    }
-
-    CSpentIndexValue(uint256 t, unsigned int i, int h, CAmount s, int type, uint256 a) {
-        txid = t;
-        inputIndex = i;
-        blockHeight = h;
-        satoshis = s;
-        addressType = type;
-        addressHash = a;
-    }
-
-    CSpentIndexValue() {
-        SetNull();
-    }
-
-    void SetNull() {
-        txid.SetNull();
-        inputIndex = 0;
-        blockHeight = 0;
-        satoshis = 0;
-        addressType = 0;
-        addressHash.SetNull();
-    }
-
-    bool IsNull() const {
-        return txid.IsNull();
-    }
-};
-
 /**
  * A UTXO entry.
  *
diff --git a/src/dbwrapper.h b/src/dbwrapper.h
index 665eaa0e98673..d0482fae25936 100644
--- a/src/dbwrapper.h
+++ b/src/dbwrapper.h
@@ -182,6 +182,7 @@ class CDBIterator
 
 class CDBWrapper
 {
+    friend class COmniCoinsCache;
     friend const std::vector<unsigned char>& dbwrapper_private::GetObfuscateKey(const CDBWrapper &w);
 private:
     //! custom environment this database is using (may be nullptr in case of default environment)
@@ -235,15 +236,18 @@ class CDBWrapper
     CDBWrapper& operator=(const CDBWrapper&) = delete;
 
     template <typename K, typename V>
-    bool Read(const K& key, V& value) const
+    bool Read(const K& key, V& value, const leveldb::Snapshot* snapshot = nullptr) const
     {
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
         ssKey << key;
         leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
 
+        auto options = readoptions;
+        options.snapshot = snapshot;
+
         std::string strValue;
-        leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
+        leveldb::Status status = pdb->Get(options, slKey, &strValue);
         if (!status.ok()) {
             if (status.IsNotFound())
                 return false;
diff --git a/src/httprpc.cpp b/src/httprpc.cpp
index 07f6c68a279aa..2a73450f87798 100644
--- a/src/httprpc.cpp
+++ b/src/httprpc.cpp
@@ -13,8 +13,6 @@
 #include <util/system.h>
 #include <walletinitinterface.h>
 
-#include <omnicore/rpcmbstring.h> // SanitizeInvalidUTF8
-
 #include <algorithm>
 #include <iterator>
 #include <map>
@@ -23,9 +21,6 @@
 #include <string>
 #include <vector>
 
-/** Sanitize UTF-8 encoded strings in RPC responses */
-static bool fSanitizeResponse = true;
-
 /** WWW-Authenticate to present with 401 Unauthorized response */
 static const char* WWW_AUTH_HEADER_DATA = "Basic realm=\"jsonrpc\"";
 
@@ -148,6 +143,10 @@ static bool RPCAuthorized(const std::string& strAuth, std::string& strAuthUserna
     return multiUserAuthorized(strUserPass);
 }
 
+namespace mastercore {
+    extern std::string SanitizeInvalidUTF8(const std::string&);
+}
+
 static bool HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
 {
     // JSONRPC handles only POST
@@ -207,10 +206,6 @@ static bool HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
 
             // Send reply
             strReply = JSONRPCReply(result, NullUniValue, jreq.id);
-            if (fSanitizeResponse) {
-                strReply = mastercore::SanitizeInvalidUTF8(strReply);
-            }
-
         // array of requests
         } else if (valRequest.isArray()) {
             if (user_has_whitelist) {
@@ -235,7 +230,7 @@ static bool HTTPReq_JSONRPC(const std::any& context, HTTPRequest* req)
             throw JSONRPCError(RPC_PARSE_ERROR, "Top-level object parse error");
 
         req->WriteHeader("Content-Type", "application/json");
-        req->WriteReply(HTTP_OK, strReply);
+        req->WriteReply(HTTP_OK, mastercore::SanitizeInvalidUTF8(strReply));
     } catch (const UniValue& objError) {
         JSONErrorReply(req, objError, jreq.id);
         return false;
diff --git a/src/init.cpp b/src/init.cpp
index ebeab21dd5b63..f3dc1f8412173 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -143,10 +143,8 @@ static const bool DEFAULT_REST_ENABLE = false;
 static const char* DEFAULT_ASMAP_FILENAME="ip_asn.map";
 
 // Omni Core initialization and shutdown handlers
-extern int mastercore_init();
+extern int mastercore_init(node::NodeContext&);
 extern int mastercore_shutdown();
-extern int CheckWalletUpdate();
-extern std::optional<std::reference_wrapper<node::NodeContext>> g_context;
 
 /**
  * The PID file facilities.
@@ -333,7 +331,6 @@ void Shutdown(NodeContext& node)
     node.fee_estimator.reset();
     node.chainman.reset();
     node.scheduler.reset();
-    g_context.reset();
 
     try {
         if (!fs::remove(GetPidFile(*node.args))) {
@@ -360,7 +357,6 @@ static void HandleSIGTERM(int)
 static void HandleSIGHUP(int)
 {
     LogInstance().m_reopen_file = true;
-    fReopenOmniCoreLog = true;
 }
 #else
 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
@@ -610,7 +606,6 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
     argsman.AddArg("-startclean", "Clear all persistence files on startup; triggers reparsing of Omni transactions (default: 0)", false, OptionsCategory::OMNI);
-    argsman.AddArg("-omnitxcache", "The maximum number of transactions in the input transaction cache (default: 500000)", false, OptionsCategory::OMNI);
     argsman.AddArg("-omniprogressfrequency", "Time in seconds after which the initial scanning progress is reported (default: 30)", false, OptionsCategory::OMNI);
     argsman.AddArg("-omniseedblockfilter", "Set skipping of blocks without Omni transactions during initial scan (default: 1)", false, OptionsCategory::OMNI);
     argsman.AddArg("-omniskipstoringstate", "Don't store state during initial synchronization until block n (faster, but may have to restart syncing after a shutdown)(default: 770000)", false, OptionsCategory::OMNI);
@@ -912,44 +907,6 @@ bool AppInitParameterInteraction(const ArgsManager& args, bool use_syscall_sandb
         nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS);
     }
 
-    if (!gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
-        const fs::path configPathInfo = GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME).c_str());
-        // ask the user if they would like us to modify their config file for them
-        auto msg = _("Disabled transaction index detected.\n\n"
-                    "Omni Core requires an enabled transaction index. To enable "
-                    "transaction indexing, please use the \"-txindex\" option as "
-                    "command line argument or add \"txindex=1\" to your client "
-                    "configuration file within your data directory.\n\n"
-                    "Configuration file: "); // allow translation of main text body while still allowing differing config file string
-        msg += _((configPathInfo.string() + "\n\n").c_str());
-        msg += _("Would you like Omni Core to attempt to update your configuration file accordingly?");
-        bool fRet = uiInterface.ThreadSafeMessageBox(msg, "", CClientUIInterface::MSG_INFORMATION | CClientUIInterface::BTN_OK | CClientUIInterface::MODAL | CClientUIInterface::BTN_ABORT);
-        if (fRet) {
-            // add txindex=1 to config file in GetConfigFile()
-            FILE *fp = fopen(configPathInfo.string().c_str(), "at");
-            if (!fp) {
-                auto failMsg = _("Unable to update configuration file at:\n");
-                failMsg += _((configPathInfo.string() + "\n\n").c_str());
-                failMsg += _("The file may be write protected or you may not have the required permissions to edit it.\n");
-                failMsg += _("Please add txindex=1 to your configuration file manually.\n\nOmni Core will now shutdown.");
-                return InitError(failMsg);
-            }
-            fprintf(fp, "\ntxindex=1\n");
-            fflush(fp);
-            fclose(fp);
-            auto strUpdated = _("Your configuration file has been updated.\n\n"
-                                "Omni Core will now shutdown - please restart the client for your new configuration to take effect.");
-            uiInterface.ThreadSafeMessageBox(strUpdated, "", CClientUIInterface::MSG_INFORMATION | CClientUIInterface::BTN_OK | CClientUIInterface::MODAL);
-            return false;
-        } else {
-            return InitError(_("Please add txindex=1 to your configuration file manually.\n\nOmni Core will now shutdown."));
-        }
-    }
-
-    if (args.GetIntArg("-prune", 0) || args.GetBoolArg("-reindex-chainstate", false)) {
-        gArgs.SoftSetBoolArg("-txindex", false);
-    }
-
     if (args.GetIntArg("-prune", 0)) {
         if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
             return InitError(_("Prune mode is incompatible with -txindex."));
@@ -1469,9 +1426,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     }
 #endif
 
-    // restore txindex
-    gArgs.SoftSetBoolArg("-txindex", true);
-
     // ********************************************************* Step 7: load block chain
 
     fReindex = args.GetBoolArg("-reindex", false);
@@ -1589,10 +1543,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         return false;
     }
 
-    if (fAddressIndex != args.GetBoolArg("-experimental-btc-balances", DEFAULT_ADDRINDEX)) {
-        return InitError(_("You need to rebuild the database using -reindex-chainstate to change -experimental-btc-balances"));
-    }
-
     ChainstateManager& chainman = *Assert(node.chainman);
 
     assert(!node.peerman);
@@ -1626,12 +1576,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
     }
 
-    g_context = std::ref(node);
-
-    uiInterface.InitMessage(_("Parsing Omni Layer transactions...").translated);
-
-    mastercore_init();
-
     // ********************************************************* Step 9: load wallet
     for (const auto& client : node.chain_clients) {
         if (!client->load()) {
@@ -1639,8 +1583,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
     }
 
-    // Omni Core code should be initialized and wallet should now be loaded, perform an initial populat$
-    CheckWalletUpdate();
+    mastercore_init(node);
 
     // ********************************************************* Step 10: data directory maintenance
 
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 5b375e267bafd..d77829e04669e 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -306,42 +306,3 @@ bool IsValidDestinationString(const std::string& str)
 {
     return IsValidDestinationString(str, Params());
 }
-
-bool DecodeIndexKey(const std::string &str, uint256 &hashBytes, int &type)
-{
-    CTxDestination dest = DecodeDestination(str);
-    if (IsValidDestination(dest))
-    {
-        const PKHash *keyID = std::get_if<PKHash>(&dest);
-        if(keyID)
-        {
-            memcpy(&hashBytes, keyID, 20);
-            type = 1;
-            return true;
-        }
-
-        const ScriptHash *scriptID = std::get_if<ScriptHash>(&dest);
-        if(scriptID)
-        {
-            memcpy(&hashBytes, scriptID, 20);
-            type = 2;
-            return true;
-        }
-
-        const WitnessV0ScriptHash *witnessV0ScriptID = std::get_if<WitnessV0ScriptHash>(&dest);
-        if (witnessV0ScriptID) {
-            memcpy(&hashBytes, witnessV0ScriptID, 32);
-            type = 3;
-            return true;
-        }
-
-        const WitnessV0KeyHash *witnessV0KeyID = std::get_if<WitnessV0KeyHash>(&dest);
-        if (witnessV0KeyID) {
-            memcpy(&hashBytes, witnessV0KeyID, 20);
-            type = 4;
-            return true;
-        }
-    }
-
-    return false;
-}
diff --git a/src/key_io.h b/src/key_io.h
index 53294453f8bd3..07b80c4b859fe 100644
--- a/src/key_io.h
+++ b/src/key_io.h
@@ -27,6 +27,4 @@ CTxDestination DecodeDestination(const std::string& str, std::string& error_msg,
 bool IsValidDestinationString(const std::string& str);
 bool IsValidDestinationString(const std::string& str, const CChainParams& params);
 
-bool DecodeIndexKey(const std::string& str, uint256& hashBytes, int& type);
-
 #endif // BITCOIN_KEY_IO_H
diff --git a/src/logging.cpp b/src/logging.cpp
index 8e7162926bc0c..f979ff83ec5cd 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -40,12 +40,6 @@ BCLog::Logger& LogInstance()
 
 bool fLogIPs = DEFAULT_LOGIPS;
 
-/** Flag to indicate, whether the Omni Core log file should be reopened. */
-std::atomic<bool> fReopenOmniCoreLog(false);
-
-/** override to print to omni log to console */
-std::atomic<bool> fOmniCoreConsoleLog(false);
-
 static int FileWriteStr(const std::string &str, FILE *fp)
 {
     return fwrite(str.data(), 1, str.size(), fp);
@@ -290,8 +284,6 @@ std::string LogCategoryToStr(BCLog::LogFlags category)
     case BCLog::LogFlags::LOCK:
         return "lock";
 #endif
-    case BCLog::HANDLER:
-        return "handler";
     case BCLog::LogFlags::UTIL:
         return "util";
     case BCLog::LogFlags::BLOCKSTORE:
diff --git a/src/logging.h b/src/logging.h
index 7c96280b48f76..fe91ee43a5805 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -34,12 +34,6 @@ struct LogCategory {
     bool active;
 };
 
-/** Flag to indicate, whether the Omni Core log file should be reopened. */
-extern std::atomic<bool> fReopenOmniCoreLog;
-
-/** override to print to omni log to console */
-extern std::atomic<bool> fOmniCoreConsoleLog;
-
 namespace BCLog {
     enum LogFlags : uint32_t {
         NONE        = 0,
@@ -72,7 +66,6 @@ namespace BCLog {
 #endif
         UTIL        = (1 << 25),
         BLOCKSTORE  = (1 << 26),
-        HANDLER     = (1 << 27),
         ALL         = ~(uint32_t)0,
     };
     enum class Level {
diff --git a/src/omnicore/activation.cpp b/src/omnicore/activation.cpp
index cd3d6cf53a8a7..1466972940c75 100644
--- a/src/omnicore/activation.cpp
+++ b/src/omnicore/activation.cpp
@@ -9,10 +9,10 @@
 #include <omnicore/activation.h>
 
 #include <omnicore/log.h>
+#include <omnicore/utilsbitcoin.h>
 #include <omnicore/version.h>
 
 #include <fs.h>
-#include <validation.h>
 #include <node/interface_ui.h>
 
 #include <stdint.h>
@@ -89,12 +89,7 @@ void CheckLiveActivations(int blockHeight)
             std::string msgText = strprintf("Shutting down due to unsupported feature activation (%d: %s)", liveActivation.featureId, liveActivation.featureName);
             PrintToLog(msgText);
             PrintToConsole(msgText);
-            if (!gArgs.GetBoolArg("-overrideforcedshutdown", false)) {
-                fs::path persistPath = gArgs.GetDataDirNet() / "MP_persist";
-                if (fs::exists(persistPath)) fs::remove_all(persistPath); // prevent the node being restarted without a reparse after forced shutdown
-                BlockValidationState state;
-                AbortNode(state, msgText);
-            }
+            MayAbortNode(msgText);
         }
         PendingActivationCompleted(liveActivation);
     }
diff --git a/src/omnicore/coinscache.cpp b/src/omnicore/coinscache.cpp
new file mode 100644
index 0000000000000..e239905af43b5
--- /dev/null
+++ b/src/omnicore/coinscache.cpp
@@ -0,0 +1,111 @@
+
+#include <chain.h>
+#include <primitives/transaction.h>
+#include <txdb.h>
+
+#include <omnicore/coinscache.h>
+#include <omnicore/log.h>
+
+COmniCoinsCache::COmniCoinsCache(CCoinsViewDB& db, const fs::path& path, bool fWipe) : coinsDB(db)
+{
+    UpdateSnapshot();
+    leveldb::Status status = Open(path, fWipe);
+    PrintToConsole("Loading coins cache database: %s\n", status.ToString());
+}
+
+void COmniCoinsCache::UpdateSnapshot()
+{
+    if (snapshot) {
+        coinsDB.m_db->pdb->ReleaseSnapshot(snapshot);
+    }
+    snapshot = coinsDB.m_db->pdb->GetSnapshot();
+}
+
+COmniCoinsCache::~COmniCoinsCache()
+{
+    // coinsDB is already closed here, snapshot is released
+    if (msc_debug_persistence) PrintToLog("COmniCoinsCache closed\n");
+}
+
+struct CCoinKey {
+    const COutPoint& outpoint;
+    static constexpr uint8_t prefix = 'c';
+    SERIALIZE_METHODS(CCoinKey, obj) {
+        READWRITE(obj.outpoint.hash);
+        READWRITE(VARINT(obj.outpoint.n));
+    }
+};
+
+/** Stores inputs to the database. */
+void COmniCoinsCache::AddInputs(const std::vector<CTxIn>& vin)
+{
+    Coin coin;
+    CDBWriteBatch batch;
+    for (auto& txin : vin) {
+        if (GetCoin(txin.prevout, coin)) {
+            batch.Write(CCoinKey{txin.prevout}, coin);
+        }
+    }
+    WriteBatch(batch);
+}
+
+/** Stores coins to the cache. */
+void COmniCoinsCache::AddCoins(const CTransaction& tx, int block)
+{
+    for (auto& txin : tx.vin) {
+        Uncache(txin.prevout);
+    }
+    for (auto i = 0u; i < tx.vout.size(); ++i) {
+        AddCoin({tx.GetHash(), i}, Coin(tx.vout[i], block, false));
+    }
+}
+
+/** Stores coin to the cache. */
+void COmniCoinsCache::AddCoin(const COutPoint& outpoint, Coin&& coin)
+{
+    cacheCoins.insert_or_assign(outpoint, std::move(coin));
+}
+
+/** Deletes coins from the cache. */
+void COmniCoinsCache::Uncache(const COutPoint& outpoint)
+{
+    cacheCoins.erase(outpoint);
+}
+
+struct CCoinEntry {
+    const COutPoint& outpoint;
+    static constexpr uint8_t DB_COIN{'C'}; // txdb.cpp
+    SERIALIZE_METHODS(CCoinEntry, obj) {
+        READWRITE(DB_COIN, obj.outpoint.hash);
+        READWRITE(VARINT(obj.outpoint.n));
+    }
+};
+
+/** Returns coin for given outpoint. */
+bool COmniCoinsCache::GetCoin(const COutPoint& outpoint, Coin& coin) const
+{
+    auto it = cacheCoins.find(outpoint);
+    if (it != cacheCoins.end() && !it->second.IsSpent()) {
+        coin = it->second;
+        return true;
+    }
+    return Read(CCoinKey{outpoint}, coin)
+        || coinsDB.m_db->Read(CCoinEntry{outpoint}, coin, snapshot);
+}
+
+/** Block is added to the cache. */
+void COmniCoinsCache::BlockCached(const CBlockIndex* pindex)
+{
+    if (pindex->GetBlockHash() == coinsDB.GetBestBlock()) {
+        UpdateSnapshot();
+        cacheCoins.clear();
+    }
+}
+
+/** Deletes all entries of the database and the cache. */
+void COmniCoinsCache::Clear()
+{
+    CDBBase::Clear();
+    UpdateSnapshot();
+    cacheCoins.clear();
+}
diff --git a/src/omnicore/coinscache.h b/src/omnicore/coinscache.h
new file mode 100644
index 0000000000000..8e13b927813a8
--- /dev/null
+++ b/src/omnicore/coinscache.h
@@ -0,0 +1,60 @@
+#ifndef BITCOIN_OMNICORE_COINSCACHE_H
+#define BITCOIN_OMNICORE_COINSCACHE_H
+
+#include <omnicore/dbbase.h>
+
+#include <util/hasher.h>
+
+#include <unordered_map>
+
+class CBlockIndex;
+class CCoinsViewDB;
+class Coin;
+class COutPoint;
+class CTransaction;
+
+/** LevelDB snapshot based storage for storing coins cache.
+ */
+class COmniCoinsCache : public CDBBase
+{
+    CCoinsViewDB& coinsDB;
+    const leveldb::Snapshot* snapshot = nullptr;
+    std::unordered_map<COutPoint, Coin, SaltedOutpointHasher> cacheCoins;
+
+    /** Release old snapshot and take new one. */
+    void UpdateSnapshot();
+
+public:
+    COmniCoinsCache(CCoinsViewDB& db, const fs::path& path, bool fWipe);
+    virtual ~COmniCoinsCache();
+
+    /** Deletes all entries of the database and the cache. */
+    void Clear();
+
+    /** Stores inputs to the database. */
+    void AddInputs(const std::vector<CTxIn>& vin);
+
+    /** Stores coins to the cache. */
+    void AddCoins(const CTransaction& tx, int block);
+
+    /** Stores coin to the cache. */
+    void AddCoin(const COutPoint& outpoint, Coin&& coin);
+
+    /** Deletes coins from the cache. */
+    void Uncache(const COutPoint& outpoint);
+
+    /** Returns coin for given outpoint. */
+    bool GetCoin(const COutPoint& outpoint, Coin& coin) const;
+
+    /** Block is added to the cache. */
+    void BlockCached(const CBlockIndex* pindex);
+};
+
+namespace mastercore
+{
+    //! LevelDB snapshot based storage for storing coins cache.
+    extern COmniCoinsCache* pCoinsCache;
+}
+
+#endif // BITCOIN_OMNICORE_COINSCACHE_H
+
diff --git a/src/omnicore/consensushash.cpp b/src/omnicore/consensushash.cpp
index 172b2f946d7e3..40db4107494bb 100644
--- a/src/omnicore/consensushash.cpp
+++ b/src/omnicore/consensushash.cpp
@@ -27,20 +27,17 @@ bool ShouldConsensusHashBlock(int block) {
         return true;
     }
 
-    if (!gArgs.IsArgSet("-omnishowblockconsensushash")) {
-        return false;
-    }
-
-    const std::vector<std::string>& vecBlocks = gArgs.GetArgs("-omnishowblockconsensushash");
-    for (std::vector<std::string>::const_iterator it = vecBlocks.begin(); it != vecBlocks.end(); ++it) {
-        int64_t paramBlock = StrToInt64(*it, false);
-        if (paramBlock < 1) continue; // ignore non numeric values
-        if (paramBlock == block) {
-            return true;
+    static const auto vecBlocks = []() {
+        std::set<int> vblocks;
+        for (auto& block : gArgs.GetArgs("-omnishowblockconsensushash")) {
+            auto paramBlock = StrToInt64(block, false);
+            if (paramBlock < 1) continue; // ignore non numeric values
+            vblocks.insert(paramBlock);
         }
-    }
+        return vblocks;
+    }();
 
-    return false;
+    return vecBlocks.count(block);
 }
 
 // Generates a consensus string for hashing based on a tally object
@@ -158,7 +155,7 @@ uint256 GetConsensusHash()
     // Sort alphabetically first
     std::map<std::string, CMPTally> tallyMapSorted;
     for (std::unordered_map<std::string, CMPTally>::iterator uoit = mp_tally_map.begin(); uoit != mp_tally_map.end(); ++uoit) {
-        tallyMapSorted.insert(std::make_pair(uoit->first,uoit->second));
+        tallyMapSorted.emplace(uoit->first, uoit->second);
     }
     for (std::map<std::string, CMPTally>::iterator my_it = tallyMapSorted.begin(); my_it != tallyMapSorted.end(); ++my_it) {
         const std::string& address = my_it->first;
@@ -181,7 +178,7 @@ uint256 GetConsensusHash()
         const std::string& sellCombo = it->first;
         std::string seller = sellCombo.substr(0, sellCombo.size() - 2);
         std::string dataStr = GenerateConsensusString(selloffer, seller);
-        vecDExOffers.push_back(std::make_pair(arith_uint256(selloffer.getHash().ToString()), dataStr));
+        vecDExOffers.emplace_back(UintToArith256(selloffer.getHash()), dataStr);
     }
     std::sort (vecDExOffers.begin(), vecDExOffers.end());
     for (std::vector<std::pair<arith_uint256, std::string> >::iterator it = vecDExOffers.begin(); it != vecDExOffers.end(); ++it) {
@@ -199,7 +196,7 @@ uint256 GetConsensusHash()
         std::string buyer = acceptCombo.substr((acceptCombo.find("+") + 1), (acceptCombo.size()-(acceptCombo.find("+") + 1)));
         std::string dataStr = GenerateConsensusString(accept, buyer);
         std::string sortKey = strprintf("%s-%s", accept.getHash().GetHex(), buyer);
-        vecAccepts.push_back(std::make_pair(sortKey, dataStr));
+        vecAccepts.emplace_back(sortKey, dataStr);
     }
     std::sort (vecAccepts.begin(), vecAccepts.end());
     for (std::vector<std::pair<std::string, std::string> >::iterator it = vecAccepts.begin(); it != vecAccepts.end(); ++it) {
@@ -218,7 +215,7 @@ uint256 GetConsensusHash()
             for (md_Set::const_iterator it = indexes.begin(); it != indexes.end(); ++it) {
                 const CMPMetaDEx& obj = *it;
                 std::string dataStr = GenerateConsensusString(obj);
-                vecMetaDExTrades.push_back(std::make_pair(arith_uint256(obj.getHash().ToString()), dataStr));
+                vecMetaDExTrades.emplace_back(UintToArith256(obj.getHash()), dataStr);
             }
         }
     }
@@ -238,7 +235,7 @@ uint256 GetConsensusHash()
         const CMPCrowd& crowd = it->second;
         uint32_t propertyId = crowd.getPropertyId();
         std::string dataStr = GenerateConsensusString(crowd);
-        vecCrowds.push_back(std::make_pair(propertyId, dataStr));
+        vecCrowds.emplace_back(propertyId, dataStr);
     }
     std::sort (vecCrowds.begin(), vecCrowds.end());
     for (std::vector<std::pair<uint32_t, std::string> >::iterator it = vecCrowds.begin(); it != vecCrowds.end(); ++it) {
@@ -288,7 +285,7 @@ uint256 GetMetaDExHash(const uint32_t propertyId)
                 for (md_Set::const_iterator it = indexes.begin(); it != indexes.end(); ++it) {
                     const CMPMetaDEx& obj = *it;
                     std::string dataStr = GenerateConsensusString(obj);
-                    vecMetaDExTrades.push_back(std::make_pair(arith_uint256(obj.getHash().ToString()), dataStr));
+                    vecMetaDExTrades.emplace_back(UintToArith256(obj.getHash()), dataStr);
                 }
             }
         }
@@ -314,7 +311,7 @@ uint256 GetBalancesHash(const uint32_t hashPropertyId)
 
     std::map<std::string, CMPTally> tallyMapSorted;
     for (std::unordered_map<std::string, CMPTally>::iterator uoit = mp_tally_map.begin(); uoit != mp_tally_map.end(); ++uoit) {
-        tallyMapSorted.insert(std::make_pair(uoit->first,uoit->second));
+        tallyMapSorted.emplace(uoit->first, uoit->second);
     }
     for (std::map<std::string, CMPTally>::iterator my_it = tallyMapSorted.begin(); my_it != tallyMapSorted.end(); ++my_it) {
         const std::string& address = my_it->first;
diff --git a/src/omnicore/dbaddress.cpp b/src/omnicore/dbaddress.cpp
new file mode 100644
index 0000000000000..04aba1cd7960a
--- /dev/null
+++ b/src/omnicore/dbaddress.cpp
@@ -0,0 +1,170 @@
+
+#include <omnicore/dbaddress.h>
+#include <omnicore/dbbase.h>
+#include <omnicore/utilsbitcoin.h>
+
+#include <omnicore/errors.h>
+#include <omnicore/log.h>
+
+#include <fs.h>
+#include <uint256.h>
+#include <tinyformat.h>
+
+#include <leveldb/status.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+COmniAddressDB::COmniAddressDB(const fs::path& path, bool fWipe)
+{
+    leveldb::Status status = Open(path, fWipe);
+    PrintToConsole("Loading address index database: %s\n", status.ToString());
+}
+
+COmniAddressDB::~COmniAddressDB()
+{
+    if (msc_debug_persistence) PrintToLog("COmniAddressDB closed\n");
+}
+
+bool COmniAddressDB::WriteAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount>>& vect)
+{
+    CDBWriteBatch batch;
+    for (auto it = vect.begin(); it != vect.end(); it++)
+        batch.Write(it->first, it->second);
+    return WriteBatch(batch);
+}
+
+bool COmniAddressDB::EraseAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount>>& vect)
+{
+    CDBWriteBatch batch;
+    for (auto it = vect.begin(); it != vect.end(); it++)
+        batch.Delete(it->first);
+    return WriteBatch(batch);
+}
+
+bool COmniAddressDB::ReadAddressIndex(const uint256& addressHash, unsigned int type,
+                                    std::vector<std::pair<CAddressIndexKey, CAmount>>& addressIndex,
+                                    int start, int end)
+{
+    if (start < 0) start = 0;
+    const auto checkAddress = !addressHash.IsNull();
+    CDBaseIterator it{NewIterator(), CAddressIndexKey{type, addressHash, start}};
+    for (; it; ++it) {
+        auto key = it.Key<CAddressIndexKey>();
+        if (key.type != type) break;
+        if (end > 0 && key.blockHeight > end) break;
+        if (checkAddress && key.hashBytes != addressHash) break;
+        if (key.blockHeight >= start) {
+            addressIndex.emplace_back(key, it.Value<CAmount>());
+        }
+    }
+    return true;
+}
+
+bool COmniAddressDB::UpdateAddressUnspentIndex(const std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue>>& vect)
+{
+    CDBWriteBatch batch;
+    for (auto it = vect.begin(); it != vect.end(); it++) {
+        if (it->second.IsNull()) {
+            batch.Delete(it->first);
+        } else {
+            batch.Write(it->first, it->second);
+        }
+    }
+    return WriteBatch(batch);
+}
+
+bool COmniAddressDB::ReadAddressUnspentIndex(const uint256& addressHash, unsigned int type,
+                                           std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue>>& unspentOutputs)
+{
+    const auto checkAddress = !addressHash.IsNull();
+
+    CDBaseIterator it{NewIterator(), CAddressUnspentKey{type, addressHash}};
+    for (; it; ++it) {
+        auto key = it.Key<CAddressUnspentKey>();
+        if (key.type != type) break;
+        if (checkAddress && key.hashBytes != addressHash) break;
+        unspentOutputs.emplace_back(key, it.Value<CAddressUnspentValue>());
+    }
+    return true;
+}
+
+bool COmniAddressDB::WriteTimestampIndex(const CTimestampIndexKey& timestampIndex)
+{
+    return Write(timestampIndex, "");
+}
+
+bool COmniAddressDB::ReadTimestampIndex(const unsigned int high, const unsigned int low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int>>& hashes)
+{
+    CDBaseIterator it{NewIterator(), CTimestampIndexKey{low}};
+    for (; it; ++it) {
+        auto key = it.Key<CTimestampIndexKey>();
+        if (key.timestamp > high) {
+            break;
+        }
+        hashes.emplace_back(key.blockHash, key.timestamp);
+    }
+    return true;
+}
+
+struct CTimestampBlockIndexKey {
+    static constexpr uint8_t prefix = 'z';
+    const uint256& hash;
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ::Serialize(s, hash);
+    }
+};
+
+bool COmniAddressDB::WriteTimestampBlockIndex(const uint256& hash, unsigned int logicalts)
+{
+    return Write(CTimestampBlockIndexKey{hash}, logicalts);
+}
+
+bool COmniAddressDB::ReadTimestampBlockIndex(const uint256& hash, unsigned int& ltimestamp)
+{
+    return Read(CTimestampBlockIndexKey{hash}, ltimestamp);
+}
+
+bool COmniAddressDB::ReadSpentIndex(const CSpentIndexKey& key, CSpentIndexValue& value)
+{
+    return Read(key, value);
+}
+
+bool COmniAddressDB::UpdateSpentIndex(const std::vector<std::pair<CSpentIndexKey, CSpentIndexValue>>& vect)
+{
+    CDBWriteBatch batch;
+    for (auto it = vect.begin(); it != vect.end(); it++) {
+        if (it->second.IsNull()) {
+            batch.Delete(it->first);
+        } else {
+            batch.Write(it->first, it->second);
+        }
+    }
+    return WriteBatch(batch);
+}
+
+struct CFlagKey {
+    static constexpr uint8_t prefix = 'F';
+    const std::string& name;
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ::Serialize(s, name);
+    }
+};
+
+bool COmniAddressDB::WriteFlag(const std::string& name, bool fValue)
+{
+    return Write(CFlagKey{name}, fValue ? uint8_t{1} : uint8_t{0});
+}
+
+bool COmniAddressDB::ReadFlag(const std::string& name, bool& fValue) {
+    uint8_t ch;
+    if (!Read(CFlagKey{name}, ch))
+        return false;
+    fValue = ch == uint8_t{1};
+    return true;
+}
diff --git a/src/omnicore/dbaddress.h b/src/omnicore/dbaddress.h
new file mode 100644
index 0000000000000..af0c968cba68c
--- /dev/null
+++ b/src/omnicore/dbaddress.h
@@ -0,0 +1,185 @@
+#ifndef BITCOIN_OMNICORE_DBADDRESS_H
+#define BITCOIN_OMNICORE_DBADDRESS_H
+
+#include <omnicore/dbbase.h>
+
+#include <fs.h>
+#include <script/standard.h>
+#include <uint256.h>
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+struct CTimestampIndexKey {
+    static constexpr uint8_t prefix = 'S';
+    unsigned int timestamp = 0;
+    uint256 blockHash;
+
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 36;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata32be(s, timestamp);
+        blockHash.Serialize(s);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        timestamp = ser_readdata32be(s);
+        blockHash.Unserialize(s);
+    }
+};
+
+struct CAddressUnspentKey {
+    static constexpr uint8_t prefix = 'u';
+    unsigned int type = 0;
+    uint256 hashBytes;
+    uint256 txhash;
+    size_t index = 0;
+
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 69;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata8(s, type);
+        hashBytes.Serialize(s);
+        txhash.Serialize(s);
+        ser_writedata32(s, index);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        type = ser_readdata8(s);
+        hashBytes.Unserialize(s);
+        txhash.Unserialize(s);
+        index = ser_readdata32(s);
+    }
+};
+
+struct CAddressUnspentValue {
+    CAmount satoshis = -1;
+    CScript script;
+    int blockHeight = 0;
+    bool coinBase = false;
+
+    SERIALIZE_METHODS(CAddressUnspentValue, obj) {
+        READWRITE(obj.satoshis);
+        READWRITEAS(CScriptBase, obj.script);
+        READWRITE(obj.blockHeight);
+        READWRITE(obj.coinBase);
+    }
+
+    bool IsNull() const {
+        return (satoshis == -1);
+    }
+};
+
+struct CAddressIndexKey {
+    static constexpr uint8_t prefix = 'a';
+    unsigned int type = 0;
+    uint256 hashBytes;
+    int blockHeight = 0;
+    unsigned int txindex = 0;
+    uint256 txhash;
+    size_t index = 0;
+    bool spending = false;
+
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 78;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata8(s, type);
+        hashBytes.Serialize(s);
+        // Heights are stored big-endian for key sorting in LevelDB
+        ser_writedata32be(s, blockHeight);
+        ser_writedata32be(s, txindex);
+        txhash.Serialize(s);
+        ser_writedata32(s, index);
+        uint8_t f = spending;
+        ser_writedata8(s, f);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        type = ser_readdata8(s);
+        hashBytes.Unserialize(s);
+        blockHeight = ser_readdata32be(s);
+        txindex = ser_readdata32be(s);
+        txhash.Unserialize(s);
+        index = ser_readdata32(s);
+        uint8_t f = ser_readdata8(s);
+        spending = f;
+    }
+};
+
+struct CSpentIndexKey {
+    static constexpr uint8_t prefix = 'p';
+    uint256 txid;
+    unsigned int outputIndex = 0;
+
+    SERIALIZE_METHODS(CSpentIndexKey, obj) {
+        READWRITE(obj.txid, obj.outputIndex);
+    }
+};
+
+struct CSpentIndexValue {
+    uint256 txid;
+    unsigned int inputIndex = 0;
+    int blockHeight = 0;
+    CAmount satoshis = 0;
+    unsigned int addressType = 0;
+    uint256 addressHash;
+
+    SERIALIZE_METHODS(CSpentIndexValue, obj) {
+        READWRITE(obj.txid, obj.inputIndex, obj.blockHeight,
+                  obj.satoshis, obj.addressType, obj.addressHash);
+    }
+
+    bool IsNull() const {
+        return txid.IsNull();
+    }
+};
+
+/** LevelDB based storage for storing Omni address index data.
+ */
+class COmniAddressDB : public CDBBase
+{
+public:
+    COmniAddressDB(const fs::path& path, bool fWipe);
+    virtual ~COmniAddressDB();
+
+    // Block explorer database functions
+    bool WriteFlag(const std::string& name, bool fValue);
+    bool ReadFlag(const std::string& name, bool& fValue);
+    bool WriteAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount>>& vect);
+    bool EraseAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount>>& vect);
+    bool ReadAddressIndex(const uint256& addressHash, unsigned int type,
+                          std::vector<std::pair<CAddressIndexKey, CAmount>>& addressIndex,
+                          int start = 0, int end = 0);
+    bool UpdateAddressUnspentIndex(const std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue>>& vect);
+    bool ReadAddressUnspentIndex(const uint256& addressHash, unsigned int type,
+                                 std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue>>& vect);
+    bool WriteTimestampIndex(const CTimestampIndexKey& timestampIndex);
+    bool ReadTimestampIndex(const unsigned int high, const unsigned int low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int>>& vect);
+    bool WriteTimestampBlockIndex(const uint256& blockhashIndex, unsigned int logicalts);
+    bool ReadTimestampBlockIndex(const uint256& hash, unsigned int& logicalTS);
+    bool ReadSpentIndex(const CSpentIndexKey& key, CSpentIndexValue& value);
+    bool UpdateSpentIndex(const std::vector<std::pair<CSpentIndexKey, CSpentIndexValue>>& vect);
+};
+
+namespace mastercore
+{
+    //! LevelDB based storage for storing Omni transaction validation and position in block data
+    extern COmniAddressDB* pDbAddress;
+}
+
+#endif // BITCOIN_OMNICORE_DBADDRESS_H
+
diff --git a/src/omnicore/dbbase.cpp b/src/omnicore/dbbase.cpp
index bf417ed708a7d..9f9501717c48b 100644
--- a/src/omnicore/dbbase.cpp
+++ b/src/omnicore/dbbase.cpp
@@ -5,10 +5,24 @@
 #include <util/system.h>
 
 #include <leveldb/db.h>
+#include <leveldb/filter_policy.h>
 #include <leveldb/write_batch.h>
 
 #include <stdint.h>
 
+CDBBase::CDBBase()
+{
+    options.paranoid_checks = true;
+    options.create_if_missing = true;
+    options.compression = leveldb::kNoCompression;
+    options.max_open_files = 64;
+    options.filter_policy = leveldb::NewBloomFilterPolicy(10);
+    readoptions.verify_checksums = true;
+    iteroptions.verify_checksums = true;
+    iteroptions.fill_cache = false;
+    syncoptions.sync = true;
+}
+
 /**
  * Opens or creates a LevelDB based database.
  */
@@ -21,7 +35,12 @@ leveldb::Status CDBBase::Open(const fs::path& path, bool fWipe)
     TryCreateDirectories(path);
     if (msc_debug_persistence) PrintToLog("Opening LevelDB in %s\n", path.string());
 
-    return leveldb::DB::Open(options, path.string(), &pdb);
+    leveldb::DB* db;
+    auto status = leveldb::DB::Open(options, path.string(), &db);
+    if (status.ok()) {
+        pdb.reset(db);
+    }
+    return status;
 }
 
 /**
@@ -29,24 +48,24 @@ leveldb::Status CDBBase::Open(const fs::path& path, bool fWipe)
  */
 void CDBBase::Clear()
 {
-    int64_t nTimeStart = GetTimeMicros();
     unsigned int n = 0;
-    leveldb::WriteBatch batch;
+    CDBWriteBatch batch;
     CDBaseIterator it{NewIterator()};
+    int64_t nTimeStart = GetTimeMicros();
 
     for (; it; ++it) {
         batch.Delete(it.Key());
         ++n;
     }
 
-    leveldb::Status status = pdb->Write(writeoptions, &batch);
     nRead = 0;
     nWritten = 0;
+    bool status = WriteBatch(batch);
 
     int64_t nTime = GetTimeMicros() - nTimeStart;
     if (msc_debug_persistence)
         PrintToLog("Removed %d entries: %s [%.3f ms/entry, %.3f ms total]\n",
-            n, status.ToString(), (n > 0 ? (0.001 * nTime / n) : 0), 0.001 * nTime);
+            n, status ? "OK" : "NOK", (n > 0 ? (0.001 * nTime / n) : 0), 0.001 * nTime);
 }
 
 /**
@@ -54,10 +73,7 @@ void CDBBase::Clear()
  */
 void CDBBase::Close()
 {
-    if (pdb) {
-        delete pdb;
-        pdb = nullptr;
-    }
+    pdb.reset();
 }
 
 
diff --git a/src/omnicore/dbbase.h b/src/omnicore/dbbase.h
index 36c9ac7d188ec..89553a1219856 100644
--- a/src/omnicore/dbbase.h
+++ b/src/omnicore/dbbase.h
@@ -5,56 +5,212 @@
 #include <cstdint>
 #include <iterator>
 #include <leveldb/db.h>
+#include <leveldb/slice.h>
+#include <leveldb/write_batch.h>
 
 #include <clientversion.h>
 #include <fs.h>
 #include <streams.h>
 
 #include <assert.h>
+#include <functional>
 #include <memory>
 #include <stddef.h>
+#include <string_view>
+#include <type_traits>
+#include <variant>
+
+template<typename BaseFormatter>
+struct CustomUintInvFormatter : private BaseFormatter
+{
+    template<typename Stream, typename T> void Ser(Stream &s, const T& v)
+    {
+        static_assert(std::is_unsigned_v<std::decay_t<T>>);
+        BaseFormatter::Ser(s, ~v);
+    }
+
+    template<typename Stream, typename T> void Unser(Stream& s, T& v)
+    {
+        static_assert(std::is_unsigned_v<std::decay_t<T>>);
+        BaseFormatter::Unser(s, v);
+        v = ~v;
+    }
+};
+
+using Enum8 = CustomUintFormatter<1>;
+using BigEndian32 = BigEndianFormatter<4>;
+using BigEndian64 = BigEndianFormatter<8>;
+using Varint = VarIntFormatter<VarIntMode::DEFAULT>;
+using VarintInv = CustomUintInvFormatter<Varint>;
+using BigEndian32Inv = CustomUintInvFormatter<BigEndian32>;
+using BigEndian64Inv = CustomUintInvFormatter<BigEndian64>;
+using VarintSigned = VarIntFormatter<VarIntMode::NONNEGATIVE_SIGNED>;
+
+class CStringWriter
+{
+    const int m_type;
+    const int m_version;
+    std::string& m_data;
+
+public:
+    CStringWriter(int type, int version, std::string& s)
+        : m_type(type), m_version(version), m_data(s) {}
+
+    template<typename T>
+    CStringWriter& operator<<(const T& obj)
+    {
+        ::Serialize(*this, obj);
+        return *this;
+    }
+
+    void write(Span<const std::byte> src)
+    {
+        m_data.append((const char*)src.data(), src.size());
+    }
+
+    int GetVersion() const { return m_version; }
+    int GetType() const { return m_version; }
+    size_t size() const { return m_data.size(); }
+};
+
+class CStringReader
+{
+    const int m_type;
+    const int m_version;
+    Span<const char> m_data;
+
+public:
+    CStringReader(int type, int version, Span<const char> data)
+        : m_type(type), m_version(version), m_data(data) {}
+
+    template<typename T>
+    CStringReader& operator>>(T&& obj)
+    {
+        ::Unserialize(*this, obj);
+        return (*this);
+    }
+
+    void read(Span<std::byte> dst)
+    {
+        if (dst.size() == 0) {
+            return;
+        }
+        if (dst.size() > m_data.size()) {
+            throw std::ios_base::failure("CStringReader::read(): end of data");
+        }
+        memcpy(dst.data(), m_data.data(), dst.size());
+        m_data = m_data.subspan(dst.size());
+    }
+
+    void ignore(int num_ignore)
+    {
+        if (num_ignore <= 0) {
+            return;
+        }
+        if (num_ignore > m_data.size()) {
+            throw std::ios_base::failure("CStringReader::ignore(): end of data");
+        }
+        m_data = m_data.subspan(num_ignore);
+    }
+
+    int GetVersion() const { return m_version; }
+    int GetType() const { return m_type; }
+    size_t size() const { return m_data.size(); }
+    bool empty() const { return m_data.empty(); }
+};
 
 template<typename T>
-bool StringToValue(std::string&& s, T& value)
+bool StringToValue(const std::string_view& s, T& value)
 {
     try {
-        CDataStream ssValue(s.data(), s.data() + s.size(), SER_DISK, CLIENT_VERSION);
-        ssValue >> value;
+        CStringReader{SER_DISK, CLIENT_VERSION, s} >> value;
     } catch (const std::exception&) {
         return false;
     }
     return true;
 }
 
-inline bool StringToValue(std::string&& s, std::string& value)
+template<typename T>
+std::string ValueToString(const T& value)
 {
-    value = std::move(s);
-    return true;
+    if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
+        return value;
+    } else {
+        std::string s;
+        CStringWriter{SER_DISK, CLIENT_VERSION, s} << value;
+        return s;
+    }
 }
 
 template<typename T>
-std::string ValueToString(const T& value)
+std::string KeyToString(const T& key)
 {
-    std::vector<uint8_t> v;
-    CVectorWriter writer(SER_DISK, CLIENT_VERSION, v, 0);
-    writer << value;
-    return {v.begin(), v.end()};
+    if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
+        return key;
+    } else {
+        std::string s;
+        static_assert(sizeof(T::prefix) == 1, "Prefix needs to be 1 byte");
+        CStringWriter{SER_DISK, CLIENT_VERSION, s} << T::prefix << key;
+        return s;
+    }
 }
 
-inline std::string ValueToString(const std::string& value)
+template<typename T>
+bool StringToKey(const std::string_view& s, T& key)
 {
-    return value;
+    auto prefix = T::prefix;
+    static_assert(sizeof(T::prefix) == 1, "Prefix needs to be 1 byte");
+    try {
+        CStringReader{SER_DISK, CLIENT_VERSION, s} >> prefix >> key;
+    } catch (const std::exception&) {
+        return false;
+    }
+    return prefix == T::prefix;
 }
 
+class CDBWriteBatch
+{
+    friend class CDBBase;
+    leveldb::WriteBatch batch;
+
+public:
+    CDBWriteBatch() = default;
+
+    template<typename K, typename V>
+    void Write(const K& key, const V& value)
+    {
+        batch.Put(KeyToString(key), ValueToString(value));
+    }
+
+    template<typename K>
+    void Delete(const K& key)
+    {
+        batch.Delete(KeyToString(key));
+    }
+
+    void Write(const leveldb::Slice& key, const leveldb::Slice& value)
+    {
+        batch.Put(key, value);
+    }
+
+    void Delete(const leveldb::Slice& key)
+    {
+        batch.Delete(key);
+    }
+
+    size_t Size() const
+    {
+        return batch.ApproximateSize();
+    }
+};
+
 /** Base class for LevelDB based storage.
  */
 class CDBBase
 {
-private:
     //! Options used when iterating over values of the database
     leveldb::ReadOptions iteroptions;
 
-protected:
     //! Database options used
     leveldb::Options options;
 
@@ -68,25 +224,16 @@ class CDBBase
     leveldb::WriteOptions syncoptions;
 
     //! The database itself
-    leveldb::DB* pdb = nullptr;
+    std::unique_ptr<leveldb::DB> pdb;
 
+protected:
     //! Number of entries read
     unsigned int nRead = 0;
 
     //! Number of entries written
     unsigned int nWritten = 0;
 
-    CDBBase()
-    {
-        options.paranoid_checks = true;
-        options.create_if_missing = true;
-        options.compression = leveldb::kNoCompression;
-        options.max_open_files = 64;
-        readoptions.verify_checksums = true;
-        iteroptions.verify_checksums = true;
-        iteroptions.fill_cache = false;
-        syncoptions.sync = true;
-    }
+    CDBBase();
 
     virtual ~CDBBase()
     {
@@ -101,42 +248,62 @@ class CDBBase
      *
      * @return A new LevelDB iterator
      */
-    leveldb::Iterator* NewIterator() const
+    std::unique_ptr<leveldb::Iterator> NewIterator() const
     {
-        assert(pdb != nullptr);
-        return pdb->NewIterator(iteroptions);
+        assert(pdb);
+        return std::unique_ptr<leveldb::Iterator>{pdb->NewIterator(iteroptions)};
     }
 
     template<typename K, typename V>
     bool Write(const K& key, const V& value)
     {
-        static_assert(sizeof(K::prefix) == 1, "Prefix needs to be 1 byte");
-        CDataStream ssKey(SER_DISK, CLIENT_VERSION, K::prefix, key);
-        leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
-        assert(pdb);
-        return pdb->Put(writeoptions, slKey, ValueToString(value)).ok();
+        auto skey = KeyToString(key);
+        auto svalue = ValueToString(value);
+        return Write(leveldb::Slice{skey}, leveldb::Slice{svalue});
     }
 
     template<typename K, typename V>
-    bool Read(const K& key, V& value) const
+    bool Read(const K& key, V&& value) const
     {
-        static_assert(sizeof(K::prefix) == 1, "Prefix needs to be 1 byte");
-        CDataStream ssKey(SER_DISK, CLIENT_VERSION, K::prefix, key);
-        leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
-        std::string strValue;
-        assert(pdb);
-        return pdb->Get(readoptions, slKey, &strValue).ok()
-            && StringToValue(std::move(strValue), value);
+        auto skey = KeyToString(key);
+        if constexpr (std::is_same_v<std::string, std::decay_t<V>>) {
+            return Read(leveldb::Slice{skey}, value);
+        } else {
+            std::string strValue;
+            return Read(leveldb::Slice{skey}, strValue)
+                && StringToValue(strValue, value);
+        }
     }
 
     template<typename K>
     bool Delete(const K& key)
     {
-        static_assert(sizeof(K::prefix) == 1, "Prefix needs to be 1 byte");
-        CDataStream ssKey(SER_DISK, CLIENT_VERSION, K::prefix, key);
-        leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
+        auto skey = KeyToString(key);
+        return Delete(leveldb::Slice{skey});
+    }
+
+    bool Write(const leveldb::Slice& key, const leveldb::Slice& value)
+    {
+        assert(pdb);
+        return pdb->Put(writeoptions, key, value).ok();
+    }
+
+    bool Read(const leveldb::Slice& key, std::string& value) const
+    {
         assert(pdb);
-        return pdb->Delete(leveldb::WriteOptions(), slKey).ok();
+        return pdb->Get(readoptions, key, &value).ok();
+    }
+
+    bool Delete(const leveldb::Slice& key)
+    {
+        assert(pdb);
+        return pdb->Delete(writeoptions, key).ok();
+    }
+
+    bool WriteBatch(CDBWriteBatch& batch)
+    {
+        assert(pdb);
+        return pdb->Write(writeoptions, &batch.batch).ok();
     }
 
     /**
@@ -163,60 +330,88 @@ class CDBBase
     void Clear();
 };
 
-template<typename T>
-std::string KeyToString(const T& key)
-{
-    std::vector<uint8_t> v;
-    static_assert(sizeof(T::prefix) == 1, "Prefix needs to be 1 byte");
-    CVectorWriter writer(SER_DISK, CLIENT_VERSION, v, 0);
-    writer << T::prefix << key;
-    return {v.begin(), v.end()};
-}
+class CPartialKey {
+    std::string data;
+public:
+    CPartialKey() = default;
+    explicit CPartialKey(uint8_t prefix) : data(1, prefix) {}
+    explicit CPartialKey(std::string s) : data(std::move(s)) {}
 
-template<typename T>
-bool StringToKey(const std::string& s, T& key)
-{
-    auto prefix = T::prefix;
-    static_assert(sizeof(T::prefix) == 1, "Prefix needs to be 1 byte");
-    try {
-        std::vector<uint8_t> v{s.begin(), s.end()};
-        SpanReader reader(SER_DISK, CLIENT_VERSION, v);
-        reader >> prefix >> key;
-    } catch (const std::exception&) {
-        return false;
+    operator leveldb::Slice() const {
+        return data;
     }
-    return prefix == T::prefix;
+};
+
+template<typename T, typename S>
+CPartialKey PartialKey(S&& subkey)
+{
+    std::string s;
+    CStringWriter{SER_DISK, CLIENT_VERSION, s} << T::prefix << std::forward<S>(subkey);
+    return CPartialKey{std::move(s)};
 }
 
 class CDBaseIterator
 {
 private:
-    const uint8_t prefix = 0;
-    const bool use_prefix = false;
+    bool valid = false;
+    CPartialKey partialKey;
     std::unique_ptr<leveldb::Iterator> it;
 
+    void SetValid()
+    {
+        valid = it->Valid() && it->key().starts_with(partialKey);
+    }
+
 public:
-    explicit CDBaseIterator(leveldb::Iterator* i, const std::string& first = {}) : it(i)
+    explicit CDBaseIterator(std::unique_ptr<leveldb::Iterator> i, const std::string_view& first = {}) : it(std::move(i))
     {
         assert(it);
-        first.empty() ? it->SeekToFirst() : it->Seek(first);
+        Seek(first);
     }
 
     template<typename T>
-    explicit CDBaseIterator(leveldb::Iterator* i, const T& key) : prefix(T::prefix), use_prefix(true), it(i)
+    explicit CDBaseIterator(std::unique_ptr<leveldb::Iterator> i, const T& key) : partialKey{T::prefix}, it(std::move(i))
     {
         assert(it);
-        static_assert(sizeof(T::prefix) == 1, "Prefix needs to be 1 byte");
-        CDataStream ssKey(SER_DISK, CLIENT_VERSION, prefix, key);
-        it->Seek({(const char*)ssKey.data(), ssKey.size()});
+        Seek(key);
+    }
+
+    explicit CDBaseIterator(std::unique_ptr<leveldb::Iterator> i, CPartialKey key) : it(std::move(i))
+    {
+        assert(it);
+        Seek(std::move(key));
     }
 
     CDBaseIterator(CDBaseIterator&&) = default;
+    CDBaseIterator& operator=(CDBaseIterator&&) = default;
+
+    void Seek(const std::string_view& key)
+    {
+        partialKey = CPartialKey{};
+        it->Seek({key.data(), key.size()});
+        SetValid();
+    }
+
+    void Seek(CPartialKey key)
+    {
+        partialKey = std::move(key);
+        it->Seek(partialKey);
+        SetValid();
+    }
+
+    template<typename T>
+    void Seek(const T& key)
+    {
+        partialKey = CPartialKey{T::prefix};
+        it->Seek(KeyToString(key));
+        SetValid();
+    }
 
     CDBaseIterator& operator++()
     {
         assert(Valid());
         it->Next();
+        SetValid();
         return *this;
     }
 
@@ -224,17 +419,18 @@ class CDBaseIterator
     {
         assert(Valid());
         it->Prev();
+        SetValid();
         return *this;
     }
 
     operator bool() const
     {
-        return Valid();
+        return valid;
     }
 
     bool Valid() const
     {
-        return it->Valid() && (!use_prefix || it->key()[0] == prefix);
+        return valid;
     }
 
     leveldb::Slice Key() const
@@ -243,20 +439,20 @@ class CDBaseIterator
         return it->key();
     }
 
+    template<typename T>
+    bool Key(T&& key) const
+    {
+        assert(Valid());
+        auto slKey = it->key();
+        return StringToKey({slKey.data(), slKey.size()}, key);
+    }
+
     template<typename T>
     T Key() const
     {
         assert(Valid());
         T key;
-        try {
-            uint8_t prefix;
-            auto slKey = it->key();
-            CDataStream ssKey(slKey.data(), slKey.data() + slKey.size(), SER_DISK, CLIENT_VERSION);
-            ssKey >> prefix >> key;
-        } catch (const std::exception&) {
-            return {};
-        }
-        return key;
+        return Key(key) ? key : T{};
     }
 
     leveldb::Slice Value() const
@@ -269,14 +465,58 @@ class CDBaseIterator
     bool Value(T&& value) const
     {
         assert(Valid());
-        try {
-            auto slValue = it->value();
-            CDataStream ssValue(slValue.data(), slValue.data() + slValue.size(), SER_DISK, CLIENT_VERSION);
-            ssValue >> value;
-        } catch (const std::exception&) {
-            return false;
-        }
-        return true;
+        auto slValue = it->value();
+        return StringToValue({slValue.data(), slValue.size()}, value);
+    }
+
+    template<typename T>
+    T Value() const
+    {
+        T value;
+        return Value(value) ? value : T{};
+    }
+
+    template<typename T>
+    T ValueOr(T default_ = {}) const
+    {
+        return Valid() ? Value<T>() : default_;
+    }
+};
+
+template<typename T>
+class CRef {
+    using ref = std::reference_wrapper<T>;
+    using cref = std::reference_wrapper<const T>;
+    std::variant<ref, cref> value;
+
+public:
+    CRef(T& ref) : value(std::ref(ref)) {}
+    CRef(const T& ref) : value(ref) {}
+    CRef(T&&) = delete;
+    CRef(const T&&) = delete;
+    CRef(const CRef&) = delete;
+    CRef(CRef&&) = default;
+
+    T& get()
+    {
+        return std::get<ref>(value).get();
+    }
+
+    const T& get() const
+    {
+        return std::visit([](auto& v) -> const T& { return v.get(); }, value);
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const
+    {
+        ::Serialize(s, get());
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s)
+    {
+        ::Unserialize(s, get());
     }
 };
 
diff --git a/src/omnicore/dbfees.cpp b/src/omnicore/dbfees.cpp
index bec953987887b..c5521a958d60f 100644
--- a/src/omnicore/dbfees.cpp
+++ b/src/omnicore/dbfees.cpp
@@ -10,16 +10,13 @@
 #include <omnicore/rules.h>
 #include <omnicore/sp.h>
 #include <omnicore/sto.h>
+#include <omnicore/utilsbitcoin.h>
 
 #include <validation.h>
 
 #include <leveldb/db.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stdint.h>
-
 #include <limits>
 #include <map>
 #include <string>
@@ -27,8 +24,6 @@
 
 using namespace mastercore;
 
-std::map<uint32_t, int64_t> distributionThresholds;
-
 COmniFeeCache::COmniFeeCache(const fs::path& path, bool fWipe)
 {
     leveldb::Status status = Open(path, fWipe);
@@ -40,10 +35,37 @@ COmniFeeCache::~COmniFeeCache()
     if (msc_debug_fees) PrintToLog("COmniFeeCache closed\n");
 }
 
+struct CPropertyBaseKey {
+    uint32_t propertyId = 0;
+
+    SERIALIZE_METHODS(CPropertyBaseKey, obj) {
+        READWRITE(Using<Varint>(obj.propertyId));
+    }
+};
+
+struct CDisTresholdKey : CPropertyBaseKey {
+    static constexpr uint8_t prefix = 'd';
+
+    SERIALIZE_METHODS(CDisTresholdKey, obj) {
+        READWRITEAS(CPropertyBaseKey, obj);
+    }
+};
+
+struct CCacheAmountKey : CPropertyBaseKey {
+    static constexpr uint8_t prefix = 'c';
+    uint32_t block = ~0u;
+
+    SERIALIZE_METHODS(CCacheAmountKey, obj) {
+        READWRITEAS(CPropertyBaseKey, obj);
+        READWRITE(Using<BigEndian32Inv>(obj.block));
+    }
+};
+
 // Returns the distribution threshold for a property
 int64_t COmniFeeCache::GetDistributionThreshold(const uint32_t &propertyId)
 {
-    return distributionThresholds[propertyId];
+    int64_t distributionThreshold;
+    return Read(CDisTresholdKey{propertyId}, distributionThreshold) ? distributionThreshold : 0;
 }
 
 // Sets the distribution thresholds to total tokens for a property / OMNI_FEE_THRESHOLD
@@ -54,52 +76,22 @@ void COmniFeeCache::UpdateDistributionThresholds(uint32_t propertyId)
         // protect against zero valued thresholds for low token count properties
         distributionThreshold = 1;
     }
-    distributionThresholds[propertyId] = distributionThreshold;
+    Write(CDisTresholdKey{propertyId}, distributionThreshold);
 }
 
 // Gets the current amount of the fee cache for a property
 int64_t COmniFeeCache::GetCachedAmount(const uint32_t &propertyId)
 {
-    assert(pdb);
-    // Get the fee history, set is sorted by block so last entry is most recent
-    std::set<feeCacheItem> sCacheHistoryItems = GetCacheHistory(propertyId);
-    if (!sCacheHistoryItems.empty()) {
-        std::set<feeCacheItem>::iterator endIt = sCacheHistoryItems.end();
-        --endIt;
-        feeCacheItem mostRecentItem = *endIt;
-        return mostRecentItem.second;
-    } else {
-        return 0; // property has never generated a fee
-    }
+    // Get the fee history, set is sorted by block so first entry is most recent
+    CDBaseIterator it{NewIterator(), PartialKey<CCacheAmountKey>(CPropertyBaseKey{propertyId})};
+    return it.ValueOr<int64_t>(0);
 }
 
 // Zeros a property in the fee cache
 void COmniFeeCache::ClearCache(const uint32_t &propertyId, int block)
 {
     if (msc_debug_fees) PrintToLog("ClearCache starting (block %d, property ID %d)...\n", block, propertyId);
-    const std::string key = strprintf("%010d", propertyId);
-    std::set<feeCacheItem> sCacheHistoryItems = GetCacheHistory(propertyId);
-    if (msc_debug_fees) PrintToLog("   Iterating cache history (%d items)...\n",sCacheHistoryItems.size());
-    std::string newValue;
-    if (!sCacheHistoryItems.empty()) {
-        for (std::set<feeCacheItem>::iterator it = sCacheHistoryItems.begin(); it != sCacheHistoryItems.end(); it++) {
-            feeCacheItem tempItem = *it;
-            if (tempItem.first == block) continue;
-            if (!newValue.empty()) newValue += ",";
-            newValue += strprintf("%d:%d", tempItem.first, tempItem.second);
-            if (msc_debug_fees) PrintToLog("      Readding entry: block %d amount %d\n", tempItem.first, tempItem.second);
-        }
-        if (!newValue.empty()) newValue += ",";
-    }
-    if (msc_debug_fees) PrintToLog("   Adding zero valued entry: block %d\n", block);
-    newValue += strprintf("%d:%d", block, 0);
-    leveldb::Status status = pdb->Put(writeoptions, key, newValue);
-    assert(status.ok());
-    ++nWritten;
-
-    PruneCache(propertyId, block);
-
-    if (msc_debug_fees) PrintToLog("Cleared cache for property %d block %d [%s]\n", propertyId, block, status.ToString());
+    PruneCache(propertyId, block + 1);
 }
 
 // Adds a fee to the cache (eg on a completed trade)
@@ -116,36 +108,14 @@ void COmniFeeCache::AddFee(const uint32_t &propertyId, int block, const int64_t
         // overflow - there is no way the fee cache should exceed the maximum possible number of tokens, not safe to continue
         const std::string& msg = strprintf("Shutting down due to fee cache overflow (block %d property %d current %d amount %d)\n", block, propertyId, currentCachedAmount, amount);
         PrintToLog(msg);
-        if (!gArgs.GetBoolArg("-overrideforcedshutdown", false)) {
-            fs::path persistPath = gArgs.GetDataDirNet() / "MP_persist";
-            if (fs::exists(persistPath)) fs::remove_all(persistPath); // prevent the node being restarted without a reparse after forced shutdown
-            BlockValidationState state;
-            AbortNode(state, msg);
-        }
+        MayAbortNode(msg);
     }
     int64_t newCachedAmount = currentCachedAmount + amount;
 
     if (msc_debug_fees) PrintToLog("   New cached amount %d\n", newCachedAmount);
-    const std::string key = strprintf("%010d", propertyId);
-    std::set<feeCacheItem> sCacheHistoryItems = GetCacheHistory(propertyId);
-    if (msc_debug_fees) PrintToLog("   Iterating cache history (%d items)...\n",sCacheHistoryItems.size());
-    std::string newValue;
-    if (!sCacheHistoryItems.empty()) {
-        for (std::set<feeCacheItem>::iterator it = sCacheHistoryItems.begin(); it != sCacheHistoryItems.end(); it++) {
-            feeCacheItem tempItem = *it;
-            if (tempItem.first == block) continue; // this is an older entry for the same block, discard it
-            if (!newValue.empty()) newValue += ",";
-            newValue += strprintf("%d:%d", tempItem.first, tempItem.second);
-            if (msc_debug_fees) PrintToLog("      Readding entry: block %d amount %d\n", tempItem.first, tempItem.second);
-        }
-        if (!newValue.empty()) newValue += ",";
-    }
-    if (msc_debug_fees) PrintToLog("   Adding requested entry: block %d new amount %d\n", block, newCachedAmount);
-    newValue += strprintf("%d:%d", block, newCachedAmount);
-    leveldb::Status status = pdb->Put(writeoptions, key, newValue);
-    assert(status.ok());
+    bool status = Write(CCacheAmountKey{propertyId, uint32_t(block)}, newCachedAmount);
     ++nWritten;
-    if (msc_debug_fees) PrintToLog("AddFee completed for property %d (new=%s [%s])\n", propertyId, newValue, status.ToString());
+    if (msc_debug_fees) PrintToLog("AddFee completed for property %d [%s]\n", propertyId, status ? "OK" : "NOK");
 
     // Call for pruning (we only prune when we update a record)
     PruneCache(propertyId, block);
@@ -159,36 +129,28 @@ void COmniFeeCache::AddFee(const uint32_t &propertyId, int block, const int64_t
 // Rolls back the cache to an earlier state (eg in event of a reorg) - block is *inclusive* (ie entries=block will get deleted)
 void COmniFeeCache::RollBackCache(int block)
 {
-    assert(pdb);
+    CDBWriteBatch batch;
+    uint32_t startBlock = block;
+    CDBaseIterator it{NewIterator()};
     for (uint8_t ecosystem = 1; ecosystem <= 2; ecosystem++) {
         uint32_t startPropertyId = (ecosystem == 1) ? 1 : TEST_ECO_PROPERTY_1;
-        for (uint32_t propertyId = startPropertyId; propertyId < mastercore::pDbSpInfo->peekNextSPID(ecosystem); propertyId++) {
-            const std::string key = strprintf("%010d", propertyId);
-            std::set<feeCacheItem> sCacheHistoryItems = GetCacheHistory(propertyId);
-            if (!sCacheHistoryItems.empty()) {
-                std::set<feeCacheItem>::iterator mostRecentIt = sCacheHistoryItems.end();
-                std::string newValue;
-                --mostRecentIt;
-                feeCacheItem mostRecentItem = *mostRecentIt;
-                if (mostRecentItem.first < block) continue; // all entries are unaffected by this rollback, nothing to do
-                for (std::set<feeCacheItem>::iterator it = sCacheHistoryItems.begin(); it != sCacheHistoryItems.end(); it++) {
-                    feeCacheItem tempItem = *it;
-                    if (tempItem.first >= block) continue; // discard this entry
-                    if (!newValue.empty()) newValue += ",";
-                    newValue += strprintf("%d:%d", tempItem.first, tempItem.second);
-                }
-                leveldb::Status status = pdb->Put(writeoptions, key, newValue);
-                assert(status.ok());
-                PrintToLog("Rolling back fee cache for property %d, new=%s [%s])\n", propertyId, newValue, status.ToString());
+        auto lastPropertyId = mastercore::pDbSpInfo->peekNextSPID(ecosystem);
+        for (uint32_t propertyId = startPropertyId; propertyId < lastPropertyId; propertyId++) {
+            for (it.Seek(PartialKey<CCacheAmountKey>(CPropertyBaseKey{propertyId})); it; ++it) {
+                auto key = it.Key<CCacheAmountKey>();
+                if (key.block < startBlock) break;
+                batch.Delete(it.Key());
+                PrintToLog("Rolling back fee cache for property %d [block: %d])\n", propertyId, key.block);
             }
         }
     }
+    WriteBatch(batch);
 }
 
 // Evaluates fee caches for the property against threshold and executes distribution if threshold met
 void COmniFeeCache::EvalCache(const uint32_t &propertyId, int block)
 {
-    if (GetCachedAmount(propertyId) >= distributionThresholds[propertyId]) {
+    if (GetCachedAmount(propertyId) >= GetDistributionThreshold(propertyId)) {
         DistributeCache(propertyId, block);
     }
 }
@@ -240,47 +202,23 @@ void COmniFeeCache::DistributeCache(const uint32_t &propertyId, int block)
 void COmniFeeCache::PruneCache(const uint32_t &propertyId, int block)
 {
     if (msc_debug_fees) PrintToLog("Starting PruneCache for prop %d block %d...\n", propertyId, block);
-    assert(pdb);
 
-    int pruneBlock = block;
+    CDBWriteBatch batch;
+    uint32_t pruneBlock = block - 1; // prune all lower than
     if (msc_debug_fees) PrintToLog("Removing entries prior to block %d...\n", pruneBlock);
-    const std::string key = strprintf("%010d", propertyId);
-    std::set<feeCacheItem> sCacheHistoryItems = GetCacheHistory(propertyId);
-    if (msc_debug_fees) PrintToLog("   Iterating cache history (%d items)...\n",sCacheHistoryItems.size());
-    if (!sCacheHistoryItems.empty()) {
-        std::set<feeCacheItem>::iterator startIt = sCacheHistoryItems.begin();
-        feeCacheItem firstItem = *startIt;
-        if (firstItem.first >= pruneBlock) {
-            if (msc_debug_fees) PrintToLog("Ending PruneCache - no matured entries found.\n");
-            return; // all entries are above supplied block value, nothing to do
-        }
-        std::string newValue;
-        for (std::set<feeCacheItem>::iterator it = sCacheHistoryItems.begin(); it != sCacheHistoryItems.end(); it++) {
-            feeCacheItem tempItem = *it;
-            if (tempItem.first < pruneBlock) {
-                if (msc_debug_fees) {
-                    PrintToLog("      Skipping matured entry: block %d amount %d\n", tempItem.first, tempItem.second);
-                    continue; // discard this entry
-                }
-            }
-            if (!newValue.empty()) newValue += ",";
-            newValue += strprintf("%d:%d", tempItem.first, tempItem.second);
-            if (msc_debug_fees) PrintToLog("      Readding immature entry: block %d amount %d\n", tempItem.first, tempItem.second);
-        }
-        // make sure the pruned cache isn't completely empty, if it is, prune down to just the most recent entry
-        if (newValue.empty()) {
-            std::set<feeCacheItem>::iterator mostRecentIt = sCacheHistoryItems.end();
-            --mostRecentIt;
-            feeCacheItem mostRecentItem = *mostRecentIt;
-            newValue = strprintf("%d:%d", mostRecentItem.first, mostRecentItem.second);
-            if (msc_debug_fees) PrintToLog("   All entries matured and pruned - readding most recent entry: block %d amount %d\n", mostRecentItem.first, mostRecentItem.second);
-        }
-        leveldb::Status status = pdb->Put(writeoptions, key, newValue);
-        assert(status.ok());
-        if (msc_debug_fees) PrintToLog("PruneCache completed for property %d (new=%s [%s])\n", propertyId, newValue, status.ToString());
-    } else {
-        return; // nothing to do
+    CDBaseIterator it{NewIterator(), CCacheAmountKey{propertyId, pruneBlock}};
+    for (; it; ++it) {
+        auto key = it.Key<CCacheAmountKey>();
+        if (key.propertyId != propertyId) break;
+        batch.Delete(it.Key());
+        if (msc_debug_fees) PrintToLog("%s: delete entry block: %d\n", __func__, key.block);
+    }
+    if (batch.Size() == 0) {
+        if (msc_debug_fees) PrintToLog("Ending PruneCache - no matured entries found.\n");
+        return;
     }
+    bool status = WriteBatch(batch);
+    if (msc_debug_fees) PrintToLog("PruneCache completed for property %d [%s]\n", propertyId, status ? "OK" : "NOK");
 }
 
 // Show Fee Cache DB statistics
@@ -293,43 +231,23 @@ void COmniFeeCache::printStats()
 void COmniFeeCache::printAll()
 {
     int count = 0;
-    leveldb::Iterator* it = NewIterator();
-    for(it->SeekToFirst(); it->Valid(); it->Next()) {
+    CDBaseIterator it {NewIterator(), CCacheAmountKey{}};
+    for(; it; ++it) {
         ++count;
-        PrintToConsole("entry #%8d= %s:%s\n", count, it->key().ToString(), it->value().ToString());
+        auto key = it.Key<CCacheAmountKey>();
+        PrintToConsole("entry #%8d= %d:%d\n", count, key.propertyId, key.block, it.Value<int64_t>());
     }
-    delete it;
 }
 
 // Return a set containing fee cache history items
 std::set<feeCacheItem> COmniFeeCache::GetCacheHistory(const uint32_t &propertyId)
 {
-    assert(pdb);
-
-    const std::string key = strprintf("%010d", propertyId);
-
     std::set<feeCacheItem> sCacheHistoryItems;
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, key, &strValue);
-    if (status.IsNotFound()) {
-        return sCacheHistoryItems; // no cache, return empty set
+    CDBaseIterator it {NewIterator(), PartialKey<CCacheAmountKey>(CPropertyBaseKey{propertyId})};
+    for (; it; ++it) {
+        auto key = it.Key<CCacheAmountKey>();
+        sCacheHistoryItems.emplace(key.block, it.Value<int64_t>());
     }
-    assert(status.ok());
-    std::vector<std::string> vCacheHistoryItems;
-    boost::split(vCacheHistoryItems, strValue, boost::is_any_of(","), boost::token_compress_on);
-    for (std::vector<std::string>::iterator it = vCacheHistoryItems.begin(); it != vCacheHistoryItems.end(); ++it) {
-        std::vector<std::string> vCacheHistoryItem;
-        boost::split(vCacheHistoryItem, *it, boost::is_any_of(":"), boost::token_compress_on);
-        if (2 != vCacheHistoryItem.size()) {
-            PrintToConsole("ERROR: vCacheHistoryItem has unexpected number of elements: %d (raw %s)!\n", vCacheHistoryItem.size(), *it);
-            printAll();
-            continue;
-        }
-        int64_t cacheItemBlock = boost::lexical_cast<int64_t>(vCacheHistoryItem[0]);
-        int64_t cacheItemAmount = boost::lexical_cast<int64_t>(vCacheHistoryItem[1]);
-        sCacheHistoryItems.insert(std::make_pair(cacheItemBlock, cacheItemAmount));
-    }
-
     return sCacheHistoryItems;
 }
 
@@ -350,166 +268,100 @@ void COmniFeeHistory::printStats()
     PrintToConsole("COmniFeeHistory stats: nWritten= %d , nRead= %d\n", nWritten, nRead);
 }
 
-// Show Fee History DB records
-void COmniFeeHistory::printAll()
-{
-    int count = 0;
-    leveldb::Iterator* it = NewIterator();
-    for(it->SeekToFirst(); it->Valid(); it->Next()) {
-        ++count;
-        PrintToConsole("entry #%8d= %s-%s\n", count, it->key().ToString(), it->value().ToString());
-        PrintToLog("entry #%8d= %s-%s\n", count, it->key().ToString(), it->value().ToString());
+struct CDistributionKey {
+    static constexpr uint8_t prefix = 'd';
+    uint32_t id = ~0u;
+    uint32_t block = ~0u;
+    uint32_t propertyId = 0;
+    int64_t total = 0;
+
+    SERIALIZE_METHODS(CDistributionKey, obj) {
+        READWRITE(Using<BigEndian32Inv>(obj.id));
+        READWRITE(Using<BigEndian32Inv>(obj.block));
+        READWRITE(Using<Varint>(obj.propertyId));
+        READWRITE(obj.total);
     }
-    delete it;
-}
+};
 
-// Count Fee History DB records
-int COmniFeeHistory::CountRecords()
+struct CDistributionPropertyKey : CPropertyBaseKey {
+    static constexpr uint8_t prefix = 'p';
+    uint32_t id = 0;
+
+    SERIALIZE_METHODS(CDistributionPropertyKey, obj) {
+        READWRITEAS(CPropertyBaseKey, obj);
+        READWRITE(Using<Varint>(obj.id));
+    }
+};
+
+// Show Fee History DB records
+void COmniFeeHistory::printAll()
 {
-    // No faster way to count than to iterate - "There is no way to implement Count more efficiently inside leveldb than outside."
-    int count = 0;
-    leveldb::Iterator* it = NewIterator();
-    for(it->SeekToFirst(); it->Valid(); it->Next()) {
-        ++count;
+    CDBaseIterator it{NewIterator(), CDistributionKey{}};
+    for(; it; ++it) {
+        std::string svalue;
+        for (const auto& rec : it.Value<std::set<feeHistoryItem>>()) {
+            svalue += strprintf("[%s=%d]", rec.first, rec.second);
+        }
+        auto key = it.Key<CDistributionKey>();
+        auto skey = strprintf("%d,%d,%d", key.propertyId, key.block, key.total);
+        PrintToConsole("entry #%8d= %s-%s\n", key.id, skey, svalue);
     }
-    delete it;
-    return count;
 }
 
 // Roll back history in event of reorg, block is inclusive
 void COmniFeeHistory::RollBackHistory(int block)
 {
-    assert(pdb);
-
-    std::set<int> sDistributions;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string strValue = it->value().ToString();
-        std::string strKey = it->key().ToString();
-        std::vector<std::string> vFeeHistoryDetail;
-        boost::split(vFeeHistoryDetail, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 != vFeeHistoryDetail.size()) {
-            PrintToLog("ERROR: vFeeHistoryDetail has unexpected number of elements: %d !\n", vFeeHistoryDetail.size());
-            continue; // bad data
-        }
-        int feeBlock = boost::lexical_cast<int>(vFeeHistoryDetail[0]);
-        if (feeBlock >= block) {
-            PrintToLog("%s() deleting from fee history DB: %s %s\n", __FUNCTION__, strKey, strValue);
-            pdb->Delete(writeoptions, strKey);
-        }
+    CDBWriteBatch batch;
+    CDBaseIterator it{NewIterator(), CDistributionKey{}};
+    for (; it; ++it) {
+        auto key = it.Key<CDistributionKey>();
+        if (key.block < block) break;
+        PrintToLog("%s() deleting from fee history DB: (%d, %d, %d)\n", __func__, key.id, key.block, key.propertyId);
+        batch.Delete(it.Key());
+        batch.Delete(CDistributionPropertyKey{key.propertyId, key.id});
     }
-    delete it;
+    WriteBatch(batch);
 }
 
 // Retrieve fee distributions for a property
 std::set<int> COmniFeeHistory::GetDistributionsForProperty(const uint32_t &propertyId)
 {
-    assert(pdb);
-
     std::set<int> sDistributions;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string strValue = it->value().ToString();
-        std::vector<std::string> vFeeHistoryDetail;
-        boost::split(vFeeHistoryDetail, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 != vFeeHistoryDetail.size()) {
-            PrintToConsole("ERROR: vFeeHistoryDetail has unexpected number of elements: %d !\n", vFeeHistoryDetail.size());
-            printAll();
-            continue; // bad data
-        }
-        uint32_t prop = boost::lexical_cast<uint32_t>(vFeeHistoryDetail[1]);
-        if (prop == propertyId) {
-            std::string key = it->key().ToString();
-            int id = boost::lexical_cast<int>(key);
-            sDistributions.insert(id);
-        }
+    CDBaseIterator it{NewIterator(), PartialKey<CDistributionPropertyKey>(CPropertyBaseKey{propertyId})};
+    for (; it; ++it) {
+        auto key = it.Key<CDistributionPropertyKey>();
+        sDistributions.insert(key.id);
     }
-    delete it;
     return sDistributions;
 }
 
 // Populate data about a fee distribution
 bool COmniFeeHistory::GetDistributionData(int id, uint32_t *propertyId, int *block, int64_t *total)
 {
-    assert(pdb);
-
-    const std::string key = strprintf("%d", id);
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, key, &strValue);
-    if (status.IsNotFound()) {
-        return false; // fee distribution not found
-    }
-    assert(status.ok());
-    std::vector<std::string> vFeeHistoryDetail;
-    boost::split(vFeeHistoryDetail, strValue, boost::is_any_of(":"), boost::token_compress_on);
-    if (4 != vFeeHistoryDetail.size()) {
-        PrintToConsole("ERROR: vFeeHistoryDetail has unexpected number of elements: %d !\n", vFeeHistoryDetail.size());
-        printAll();
-        return false; // bad data
-    }
-    *block = boost::lexical_cast<int>(vFeeHistoryDetail[0]);
-    *propertyId = boost::lexical_cast<uint32_t>(vFeeHistoryDetail[1]);
-    *total = boost::lexical_cast<int64_t>(vFeeHistoryDetail[2]);
+    CDBaseIterator it{NewIterator(), CDistributionKey{uint32_t(id)}};
+    if (!it) return false;
+    auto key = it.Key<CDistributionKey>();
+    if (key.id != id) return false;
+    *block = key.block;
+    *propertyId = key.propertyId;
+    *total = key.total;
     return true;
 }
 
 // Retrieve the recipients for a fee distribution
 std::set<feeHistoryItem> COmniFeeHistory::GetFeeDistribution(int id)
 {
-    assert(pdb);
-
-    const std::string key = strprintf("%d", id);
-    std::set<feeHistoryItem> sFeeHistoryItems;
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, key, &strValue);
-    if (status.IsNotFound()) {
-        return sFeeHistoryItems; // fee distribution not found, return empty set
-    }
-    assert(status.ok());
-    std::vector<std::string> vFeeHistoryDetail;
-    boost::split(vFeeHistoryDetail, strValue, boost::is_any_of(":"), boost::token_compress_on);
-    if (4 != vFeeHistoryDetail.size()) {
-        PrintToConsole("ERROR: vFeeHistoryDetail has unexpected number of elements: %d !\n", vFeeHistoryDetail.size());
-        printAll();
-        return sFeeHistoryItems; // bad data, return empty set
-    }
-    std::vector<std::string> vFeeHistoryItems;
-    boost::split(vFeeHistoryItems, vFeeHistoryDetail[3], boost::is_any_of(","), boost::token_compress_on);
-    for (std::vector<std::string>::iterator it = vFeeHistoryItems.begin(); it != vFeeHistoryItems.end(); ++it) {
-        std::vector<std::string> vFeeHistoryItem;
-        boost::split(vFeeHistoryItem, *it, boost::is_any_of("="), boost::token_compress_on);
-        if (2 != vFeeHistoryItem.size()) {
-            PrintToConsole("ERROR: vFeeHistoryItem has unexpected number of elements: %d (raw %s)!\n", vFeeHistoryItem.size(), *it);
-            printAll();
-            continue;
-        }
-        int64_t feeHistoryItemAmount = boost::lexical_cast<int64_t>(vFeeHistoryItem[1]);
-        sFeeHistoryItems.insert(std::make_pair(vFeeHistoryItem[0], feeHistoryItemAmount));
-    }
-
-    return sFeeHistoryItems;
+    CDBaseIterator it{NewIterator(), CDistributionKey{uint32_t(id)}};
+    if (!it.Valid() || it.Key<CDistributionKey>().id != id) return {};
+    return it.ValueOr<std::set<feeHistoryItem>>();
 }
 
 // Record a fee distribution
-void COmniFeeHistory::RecordFeeDistribution(const uint32_t &propertyId, int block, int64_t total, std::set<feeHistoryItem> feeRecipients)
+void COmniFeeHistory::RecordFeeDistribution(const uint32_t &propertyId, int block, int64_t total, const std::set<feeHistoryItem>& feeRecipients)
 {
-    assert(pdb);
-
-    int count = CountRecords() + 1;
-    std::string key = strprintf("%d", count);
-    std::string feeRecipientsStr;
-
-    if (!feeRecipients.empty()) {
-        for (std::set<feeHistoryItem>::iterator it = feeRecipients.begin(); it != feeRecipients.end(); it++) {
-            feeHistoryItem tempRecipient = *it;
-            feeRecipientsStr += strprintf("%s=%d,", tempRecipient.first, tempRecipient.second);
-        }
-        if (feeRecipientsStr.size() > 0) {
-            feeRecipientsStr.resize(feeRecipientsStr.size() - 1);
-        }
-    }
-
-    std::string value = strprintf("%d:%d:%d:%s", block, propertyId, total, feeRecipientsStr);
-    leveldb::Status status = pdb->Put(writeoptions, key, value);
-    if (msc_debug_fees) PrintToLog("Added fee distribution to feeCacheHistory - key=%s value=%s [%s]\n", key, value, status.ToString());
+    CDBaseIterator it{NewIterator(), CDistributionKey{}};
+    auto id = it.ValueOr<CDistributionKey>({0}).id + 1;
+    bool status = Write(CDistributionPropertyKey{propertyId, id}, "")
+        && Write(CDistributionKey{id, uint32_t(block), propertyId, total}, feeRecipients);
+    if (msc_debug_fees) PrintToLog("Added fee distribution to feeCacheHistory - key=%d, property=%d, block=%d, total=%d, [%s]\n", id, propertyId, block, total, status ? "OK" : "NOK");
 }
diff --git a/src/omnicore/dbfees.h b/src/omnicore/dbfees.h
index 8052437f9279d..6a7d369e91db8 100644
--- a/src/omnicore/dbfees.h
+++ b/src/omnicore/dbfees.h
@@ -63,10 +63,8 @@ class COmniFeeHistory : public CDBBase
 
     /** Roll back history in event of reorg */
     void RollBackHistory(int block);
-    /** Count Fee History DB records */
-    int CountRecords();
     /** Record a fee distribution */
-    void RecordFeeDistribution(const uint32_t &propertyId, int block, int64_t total, std::set<feeHistoryItem> feeRecipients);
+    void RecordFeeDistribution(const uint32_t &propertyId, int block, int64_t total, const std::set<feeHistoryItem>& feeRecipients);
     /** Retrieve the recipients for a fee distribution */
     std::set<feeHistoryItem> GetFeeDistribution(int id);
     /** Retrieve fee distributions for a property */
diff --git a/src/omnicore/dbspinfo.cpp b/src/omnicore/dbspinfo.cpp
index 3c59750338730..9393a41b70897 100644
--- a/src/omnicore/dbspinfo.cpp
+++ b/src/omnicore/dbspinfo.cpp
@@ -15,12 +15,12 @@
 #include <leveldb/db.h>
 #include <leveldb/write_batch.h>
 
-#include <boost/lexical_cast.hpp>
-
-#include <stdint.h>
-
+#include <cstdint>
+#include <functional>
 #include <string>
-
+#include <string_view>
+#include <utility>
+#include <variant>
 
 CMPSPInfo::Entry::Entry()
   : prop_type(0), prev_prop_id(0), num_tokens(0), property_desired(0),
@@ -41,7 +41,7 @@ bool CMPSPInfo::Entry::isDivisible() const
 
 void CMPSPInfo::Entry::print() const
 {
-    PrintToConsole("%s:%s(Fixed=%s,Divisible=%s):%d:%s/%s, %s %s\n",
+    PrintToLog("%s:%s(Fixed=%s;Manual=%s;Unique=%s;Divisible=%s):%d:%s/%s, %s %s\n",
             issuer,
             name,
             fixed ? "Yes" : "No",
@@ -72,20 +72,8 @@ void CMPSPInfo::Entry::updateIssuer(int block, int idx, const std::string& newIs
  */
 std::string CMPSPInfo::Entry::getIssuer(int block) const
 {
-    std::string _issuer = issuer;
-
-    for (auto const& entry : historicalIssuers) {
-        int currentBlock = entry.first.first;
-        std::string currentIssuer = entry.second;
-
-        if (currentBlock > block) {
-            break;
-        }
-
-        _issuer = currentIssuer;
-    }
-
-    return _issuer;
+    auto it = historicalIssuers.upper_bound(std::make_pair(block, INT_MAX));
+    return it != historicalIssuers.begin() ? (--it)->second : issuer;
 }
 
 /**
@@ -120,49 +108,45 @@ void CMPSPInfo::Entry::removeDelegate(int block, int idx)
  */
 std::string CMPSPInfo::Entry::getDelegate(int block) const
 {
-    std::string _delegate = delegate;
-
-    for (auto const& entry : historicalDelegates) {
-        int currentBlock = entry.first.first;
-        std::string currentDelegate = entry.second;
-
-        if (currentBlock > block) {
-            break;
-        }
-
-        _delegate = currentDelegate;
-    }
+    auto it = historicalDelegates.upper_bound(std::make_pair(block, INT_MAX));
+    return it != historicalDelegates.begin() ? (--it)->second : delegate;
+}
 
-    return _delegate;
+static CMPSPInfo::Entry CreateOmniToken()
+{
+    CMPSPInfo::Entry omni;
+    // special cases for constant SPs OMN and TOMN
+    omni.issuer = EncodeDestination(ExodusAddress());
+    omni.updateIssuer(0, 0, omni.issuer);
+    omni.prop_type = MSC_PROPERTY_TYPE_DIVISIBLE;
+    omni.num_tokens = 700000;
+    omni.category = "N/A";
+    omni.subcategory = "N/A";
+    omni.name = "Omni tokens";
+    omni.url = "http://www.omnilayer.org";
+    omni.data = "Omni tokens serve as the binding between Bitcoin, smart properties and contracts created on the Omni Layer.";
+    return omni;
 }
 
+static CMPSPInfo::Entry CreateTestOmniToken()
+{
+    CMPSPInfo::Entry tomni;
+    tomni.issuer = EncodeDestination(ExodusAddress());
+    tomni.updateIssuer(0, 0, tomni.issuer);
+    tomni.prop_type = MSC_PROPERTY_TYPE_DIVISIBLE;
+    tomni.num_tokens = 700000;
+    tomni.category = "N/A";
+    tomni.subcategory = "N/A";
+    tomni.name = "Test Omni tokens";
+    tomni.url = "http://www.omnilayer.org";
+    tomni.data = "Test Omni tokens serve as the binding between Bitcoin, smart properties and contracts created on the Omni Layer.";
+    return tomni;
+}
 
-CMPSPInfo::CMPSPInfo(const fs::path& path, bool fWipe)
+CMPSPInfo::CMPSPInfo(const fs::path& path, bool fWipe) : implied_omni(CreateOmniToken()), implied_tomni(CreateTestOmniToken())
 {
     leveldb::Status status = Open(path, fWipe);
     PrintToConsole("Loading smart property database: %s\n", status.ToString());
-
-    // special cases for constant SPs OMN and TOMN
-    implied_omni.issuer = EncodeDestination(ExodusAddress());
-    implied_omni.updateIssuer(0, 0, implied_omni.issuer);
-    implied_omni.prop_type = MSC_PROPERTY_TYPE_DIVISIBLE;
-    implied_omni.num_tokens = 700000;
-    implied_omni.category = "N/A";
-    implied_omni.subcategory = "N/A";
-    implied_omni.name = "Omni tokens";
-    implied_omni.url = "http://www.omnilayer.org";
-    implied_omni.data = "Omni tokens serve as the binding between Bitcoin, smart properties and contracts created on the Omni Layer.";
-
-    implied_tomni.issuer = EncodeDestination(ExodusAddress());
-    implied_tomni.updateIssuer(0, 0, implied_tomni.issuer);
-    implied_tomni.prop_type = MSC_PROPERTY_TYPE_DIVISIBLE;
-    implied_tomni.num_tokens = 700000;
-    implied_tomni.category = "N/A";
-    implied_tomni.subcategory = "N/A";
-    implied_tomni.name = "Test Omni tokens";
-    implied_tomni.url = "http://www.omnilayer.org";
-    implied_tomni.data = "Test Omni tokens serve as the binding between Bitcoin, smart properties and contracts created on the Omni Layer.";
-
     init();
 }
 
@@ -203,7 +187,34 @@ uint32_t CMPSPInfo::peekNextSPID(uint8_t ecosystem) const
     return nextId;
 }
 
-bool CMPSPInfo::updateSP(uint32_t propertyId, const Entry& info)
+struct CBasePropertyKey {
+    uint32_t propertyId = 0;
+
+    SERIALIZE_METHODS(CBasePropertyKey, obj) {
+        READWRITE(Using<Varint>(obj.propertyId));
+    }
+};
+
+struct CUpdatePropertyKey : CBasePropertyKey {
+    static constexpr uint8_t prefix = 's';
+    uint32_t block = ~0u;
+
+    SERIALIZE_METHODS(CUpdatePropertyKey, obj) {
+        READWRITEAS(CBasePropertyKey, obj);
+        READWRITE(Using<BigEndian32Inv>(obj.block));
+    }
+};
+
+struct CLookupTxKey {
+    static constexpr uint8_t prefix = 't';
+    const uint256& txid;
+
+    SERIALIZE_METHODS(CLookupTxKey, obj) {
+        READWRITE(obj.txid);
+    }
+};
+
+bool CMPSPInfo::updateSP(uint32_t propertyId, const Entry& info, int block)
 {
     // cannot update implied SP
     if (OMNI_PROPERTY_MSC == propertyId || OMNI_PROPERTY_TMSC == propertyId) {
@@ -211,55 +222,23 @@ bool CMPSPInfo::updateSP(uint32_t propertyId, const Entry& info)
     }
 
     // DB key for property entry
-    CDataStream ssSpKey(SER_DISK, CLIENT_VERSION);
-    ssSpKey << std::make_pair(uint8_t('s'), propertyId);
-    leveldb::Slice slSpKey((const char*)&ssSpKey[0], ssSpKey.size());
+    auto sKey = KeyToString(CUpdatePropertyKey{propertyId, uint32_t(block)});
 
     // DB value for property entry
-    CDataStream ssSpValue(SER_DISK, CLIENT_VERSION);
-    ssSpValue.reserve(::GetSerializeSize(info, CLIENT_VERSION));
-    ssSpValue << info;
-    leveldb::Slice slSpValue((const char*)&ssSpValue[0], ssSpValue.size());
-
-    // DB key for historical property entry
-    CDataStream ssSpPrevKey(SER_DISK, CLIENT_VERSION);
-    ssSpPrevKey << uint8_t('b');
-    ssSpPrevKey << info.update_block;
-    ssSpPrevKey << propertyId;
-    leveldb::Slice slSpPrevKey((const char*)&ssSpPrevKey[0], ssSpPrevKey.size());
-
-    leveldb::WriteBatch batch;
-    std::string strSpPrevValue;
-
-    // if a value exists move it to the old key
-    if (!pdb->Get(readoptions, slSpKey, &strSpPrevValue).IsNotFound()) {
-        batch.Put(slSpPrevKey, strSpPrevValue);
-    }
-    batch.Put(slSpKey, slSpValue);
-
-    // Update delegate info if set
-    if (!info.historicalDelegates.empty()) {
-        std::string delegateKey = strprintf("DE-%d", propertyId);
-        CDataStream ssDelegateValue(SER_DISK, CLIENT_VERSION);
-        ssDelegateValue << info.delegate;
-        ssDelegateValue << info.historicalDelegates;
-        leveldb::Slice slDelegateValue((const char*)&ssDelegateValue[0], ssDelegateValue.size());
-        batch.Put(delegateKey, slDelegateValue);
-    }
+    auto sValue = ValueToString(info);
 
-    leveldb::Status status = pdb->Write(syncoptions, &batch);
-
-    if (!status.ok()) {
-        PrintToLog("%s(): ERROR for SP %d: %s\n", __func__, propertyId, status.ToString());
-        return false;
+    // sanity checking
+    std::string existingEntry;
+    if (Read(sKey, existingEntry) && sValue.compare(existingEntry) != 0) {
+        std::string strError = strprintf("writing SP %d to DB, when a different SP already exists for that identifier", propertyId);
+        PrintToLog("%s() ERROR: %s\n", __func__, strError);
     }
 
-    PrintToLog("%s(): updated entry for SP %d successfully\n", __func__, propertyId);
-    return true;
+    return Write(sKey, sValue);
 }
 
 
-uint32_t CMPSPInfo::putSP(uint8_t ecosystem, const Entry& info)
+uint32_t CMPSPInfo::putSP(uint8_t ecosystem, const Entry& info, int block)
 {
     uint32_t propertyId = 0;
     switch (ecosystem) {
@@ -273,61 +252,10 @@ uint32_t CMPSPInfo::putSP(uint8_t ecosystem, const Entry& info)
             propertyId = 0;
     }
 
-    // DB key for property entry
-    CDataStream ssSpKey(SER_DISK, CLIENT_VERSION);
-    ssSpKey << std::make_pair(uint8_t('s'), propertyId);
-    leveldb::Slice slSpKey((const char*)&ssSpKey[0], ssSpKey.size());
-
-    // DB value for property entry
-    CDataStream ssSpValue(SER_DISK, CLIENT_VERSION);
-    ssSpValue.reserve(::GetSerializeSize(info, CLIENT_VERSION));
-    ssSpValue << info;
-    leveldb::Slice slSpValue((const char*)&ssSpValue[0], ssSpValue.size());
-
-    // DB key for identifier lookup entry
-    CDataStream ssTxIndexKey(SER_DISK, CLIENT_VERSION);
-    ssTxIndexKey << std::make_pair(uint8_t('t'), info.txid);
-    leveldb::Slice slTxIndexKey((const char*)&ssTxIndexKey[0], ssTxIndexKey.size());
-
-    // DB value for identifier
-    CDataStream ssTxValue(SER_DISK, CLIENT_VERSION);
-    ssTxValue.reserve(::GetSerializeSize(propertyId, CLIENT_VERSION));
-    ssTxValue << propertyId;
-    leveldb::Slice slTxValue((const char*)&ssTxValue[0], ssTxValue.size());
-
-    // sanity checking
-    std::string existingEntry;
-    if (!pdb->Get(readoptions, slSpKey, &existingEntry).IsNotFound() && slSpValue.compare(existingEntry) != 0) {
-        std::string strError = strprintf("writing SP %d to DB, when a different SP already exists for that identifier", propertyId);
-        PrintToLog("%s() ERROR: %s\n", __func__, strError);
-    } else if (!pdb->Get(readoptions, slTxIndexKey, &existingEntry).IsNotFound() && slTxValue.compare(existingEntry) != 0) {
-        std::string strError = strprintf("writing index txid %s : SP %d is overwriting a different value", info.txid.ToString(), propertyId);
-        PrintToLog("%s() ERROR: %s\n", __func__, strError);
-    }
-
-    // Create and check unique field
-    std::string uniqueKey = strprintf("UE-%d", propertyId);
-    if (info.unique) {
-        // sanity checking
-        if (!pdb->Get(readoptions, uniqueKey, &existingEntry).IsNotFound() && existingEntry != strprintf("%d", info.unique)) {
-            std::string strError = strprintf("writing SP %d unique field to DB, when a different SP already exists for that identifier", propertyId);
-            PrintToLog("%s() ERROR: %s\n", __func__, strError);
-        }
-    }
-
-    // atomically write both the the SP and the index to the database
-    leveldb::WriteBatch batch;
-    batch.Put(slSpKey, slSpValue);
-    batch.Put(slTxIndexKey, slTxValue);
-
-    if (info.unique) {
-        batch.Put(uniqueKey, strprintf("%d", info.unique));
-    }
-
-    leveldb::Status status = pdb->Write(syncoptions, &batch);
+    updateSP(propertyId, info, block);
 
-    if (!status.ok()) {
-        PrintToLog("%s(): ERROR for SP %d: %s\n", __func__, propertyId, status.ToString());
+    if (!Write(CLookupTxKey{info.txid}, propertyId)) {
+        PrintToLog("%s(): ERROR for SP %d: NOK\n", __func__, propertyId);
     }
 
     return propertyId;
@@ -344,58 +272,13 @@ bool CMPSPInfo::getSP(uint32_t propertyId, Entry& info) const
         return true;
     }
 
-    // DB key for property entry
-    CDataStream ssSpKey(SER_DISK, CLIENT_VERSION);
-    ssSpKey << std::make_pair(uint8_t('s'), propertyId);
-    leveldb::Slice slSpKey((const char*)&ssSpKey[0], ssSpKey.size());
-
     // DB value for property entry
-    std::string strSpValue;
-    leveldb::Status status = pdb->Get(readoptions, slSpKey, &strSpValue);
-    if (!status.ok()) {
-        if (!status.IsNotFound()) {
-            PrintToLog("%s(): ERROR for SP %d: %s\n", __func__, propertyId, status.ToString());
-        }
-        return false;
-    }
-
-    try {
-        CDataStream ssSpValue(strSpValue.data(), strSpValue.data() + strSpValue.size(), SER_DISK, CLIENT_VERSION);
-        ssSpValue >> info;
-    } catch (const std::exception& e) {
-        PrintToLog("%s(): ERROR for SP %d: %s\n", __func__, propertyId, e.what());
-        return false;
-    }
-
-    // Check for unique entry
-    std::string uniqueKey = strprintf("UE-%d", propertyId);
-    std::string uniqueValue;
-    leveldb::Status statusUnique = pdb->Get(readoptions, uniqueKey, &uniqueValue);
-    if (statusUnique.ok() && !statusUnique.IsNotFound()) {
-        try {
-            info.unique = boost::lexical_cast<bool>(uniqueValue);
-        } catch (boost::bad_lexical_cast const &e) {
-            PrintToLog("%s(): ERROR for SP unique field %d: %s\n", __func__, propertyId, e.what());
-            return false;
-        }
+    CDBaseIterator it{NewIterator(), PartialKey<CUpdatePropertyKey>(CBasePropertyKey{propertyId})};
+    auto status = it.Valid() && it.Value(info);
+    if (!status) {
+        PrintToLog("%s(): ERROR for SP %d: not found\n", __func__, propertyId);
     }
-
-    // Check for delegate entry
-    std::string delegateKey = strprintf("DE-%d", propertyId);
-    std::string delegateValue;
-    leveldb::Status statusDelegate = pdb->Get(readoptions, delegateKey, &delegateValue);
-    if (statusDelegate.ok() && !statusDelegate.IsNotFound()) {
-        try {
-            CDataStream ssDelegateValue(delegateValue.data(), delegateValue.data() + delegateValue.size(), SER_DISK, CLIENT_VERSION);
-            ssDelegateValue >> info.delegate;
-            ssDelegateValue >> info.historicalDelegates;
-        } catch (const std::exception& e) {
-            PrintToLog("%s(): ERROR for SP delegates %d: %s\n", __func__, propertyId, e.what());
-            return false;
-        }
-    }
-
-    return true;
+    return status;
 }
 
 bool CMPSPInfo::hasSP(uint32_t propertyId) const
@@ -404,172 +287,63 @@ bool CMPSPInfo::hasSP(uint32_t propertyId) const
     if (OMNI_PROPERTY_MSC == propertyId || OMNI_PROPERTY_TMSC == propertyId) {
         return true;
     }
-
-    // DB key for property entry
-    CDataStream ssSpKey(SER_DISK, CLIENT_VERSION);
-    ssSpKey << std::make_pair(uint8_t('s'), propertyId);
-    leveldb::Slice slSpKey((const char*)&ssSpKey[0], ssSpKey.size());
-
-    // DB value for property entry
-    std::string strSpValue;
-    leveldb::Status status = pdb->Get(readoptions, slSpKey, &strSpValue);
-
-    return status.ok();
+    Entry info;
+    return getSP(propertyId, info);
 }
 
 uint32_t CMPSPInfo::findSPByTX(const uint256& txid) const
 {
-    uint32_t propertyId = 0;
-
     // DB key for identifier lookup entry
-    CDataStream ssTxIndexKey(SER_DISK, CLIENT_VERSION);
-    ssTxIndexKey << std::make_pair(uint8_t('t'), txid);
-    leveldb::Slice slTxIndexKey((const char*)&ssTxIndexKey[0], ssTxIndexKey.size());
-
-    // DB value for identifier
-    std::string strTxIndexValue;
-    if (!pdb->Get(readoptions, slTxIndexKey, &strTxIndexValue).ok()) {
-        std::string strError = strprintf("failed to find property created with %s", txid.GetHex());
-        PrintToLog("%s(): ERROR: %s", __func__, strError);
-        return 0;
-    }
-
-    try {
-        CDataStream ssValue(strTxIndexValue.data(), strTxIndexValue.data() + strTxIndexValue.size(), SER_DISK, CLIENT_VERSION);
-        ssValue >> propertyId;
-    } catch (const std::exception& e) {
-        PrintToLog("%s(): ERROR: %s\n", __func__, e.what());
-        return 0;
-    }
-
-    return propertyId;
+    uint32_t propertyId;
+    return Read(CLookupTxKey{txid}, propertyId) ? propertyId : 0;
 }
 
-int64_t CMPSPInfo::popBlock(const uint256& block_hash)
+void CMPSPInfo::deleteSPAboveBlock(int block)
 {
-    int64_t remainingSPs = 0;
-    leveldb::WriteBatch commitBatch;
-    leveldb::Iterator* iter = NewIterator();
-
-    CDataStream ssSpKeyPrefix(SER_DISK, CLIENT_VERSION);
-    ssSpKeyPrefix << uint8_t('s');
-    leveldb::Slice slSpKeyPrefix((const char*)&ssSpKeyPrefix[0], ssSpKeyPrefix.size());
-
-    for (iter->Seek(slSpKeyPrefix); iter->Valid() && iter->key().starts_with(slSpKeyPrefix); iter->Next()) {
-        // deserialize the persisted value
-        leveldb::Slice slSpValue = iter->value();
-        Entry info;
-        try {
-            CDataStream ssValue(slSpValue.data(), slSpValue.data() + slSpValue.size(), SER_DISK, CLIENT_VERSION);
-            ssValue >> info;
-        } catch (const std::exception& e) {
-            PrintToLog("%s(): ERROR: %s\n", __func__, e.what());
-            return -1;
-        }
-        // pop the block
-        if (info.update_block == block_hash) {
-            leveldb::Slice slSpKey = iter->key();
-
-            // need to roll this SP back
-            if (info.update_block == info.creation_block) {
-                // this is the block that created this SP, so delete the SP and the tx index entry
-                CDataStream ssTxIndexKey(SER_DISK, CLIENT_VERSION);
-                ssTxIndexKey << std::make_pair(uint8_t('t'), info.txid);
-                leveldb::Slice slTxIndexKey((const char*)&ssTxIndexKey[0], ssTxIndexKey.size());
-                commitBatch.Delete(slSpKey);
-                commitBatch.Delete(slTxIndexKey);
-            } else {
-                uint32_t propertyId = 0;
-                try {
-                    CDataStream ssValue(1+slSpKey.data(), 1+slSpKey.data()+slSpKey.size(), SER_DISK, CLIENT_VERSION);
-                    ssValue >> propertyId;
-                } catch (const std::exception& e) {
-                    PrintToLog("%s(): ERROR: %s\n", __func__, e.what());
-                    return -2;
-                }
-
-                CDataStream ssSpPrevKey(SER_DISK, CLIENT_VERSION);
-                ssSpPrevKey << uint8_t('b');
-                ssSpPrevKey << info.update_block;
-                ssSpPrevKey << propertyId;
-                leveldb::Slice slSpPrevKey((const char*)&ssSpPrevKey[0], ssSpPrevKey.size());
-
-                std::string strSpPrevValue;
-                if (!pdb->Get(readoptions, slSpPrevKey, &strSpPrevValue).IsNotFound()) {
-                    // copy the prev state to the current state and delete the old state
-                    commitBatch.Put(slSpKey, strSpPrevValue);
-                    commitBatch.Delete(slSpPrevKey);
-                    ++remainingSPs;
-                } else {
-                    // failed to find a previous SP entry, trigger reparse
-                    PrintToLog("%s(): ERROR: failed to retrieve previous SP entry\n", __func__);
-                    return -3;
+    CDBWriteBatch batch;
+    uint32_t startBlock = block;
+    CDBaseIterator it{NewIterator()};
+    for (uint8_t ecosystem = 1; ecosystem <= 2; ecosystem++) {
+        uint32_t startPropertyId = (ecosystem == 1) ? 1 : TEST_ECO_PROPERTY_1;
+        auto lastPropertyId = peekNextSPID(ecosystem);
+        for (uint32_t propertyId = startPropertyId; propertyId < lastPropertyId; propertyId++) {
+            for (it.Seek(PartialKey<CUpdatePropertyKey>(CBasePropertyKey{propertyId})); it; ++it) {
+                auto key = it.Key<CUpdatePropertyKey>();
+                if (key.block < startBlock) break;
+                auto info = it.Value<Entry>();
+                if (info.creation_block == info.update_block) {
+                    batch.Delete(CLookupTxKey{info.txid});
                 }
+                batch.Delete(it.Key());
             }
-        } else {
-            ++remainingSPs;
         }
     }
+    WriteBatch(batch);
+}
 
-    // clean up the iterator
-    delete iter;
+struct CWattermarkKey {
+    static constexpr uint8_t prefix = 'B';
+    SERIALIZE_METHODS(CWattermarkKey, obj) {}
+};
 
-    leveldb::Status status = pdb->Write(syncoptions, &commitBatch);
+struct CWattermarkValue {
+    CRef<uint256> blockHash;
+    CRef<int> blockHeight;
 
-    if (!status.ok()) {
-        PrintToLog("%s(): ERROR: %s\n", __func__, status.ToString());
-        return -4;
+    SERIALIZE_METHODS(CWattermarkValue, obj) {
+        READWRITE(obj.blockHash);
+        READWRITE(obj.blockHeight);
     }
+};
 
-    return remainingSPs;
-}
-
-void CMPSPInfo::setWatermark(const uint256& watermark)
+void CMPSPInfo::setWatermark(const uint256& watermark, int block)
 {
-    leveldb::WriteBatch batch;
-
-    CDataStream ssKey(SER_DISK, CLIENT_VERSION);
-    ssKey << uint8_t('B');
-    leveldb::Slice slKey((const char*)&ssKey[0], ssKey.size());
-
-    CDataStream ssValue(SER_DISK, CLIENT_VERSION);
-    ssValue.reserve(::GetSerializeSize(watermark, CLIENT_VERSION));
-    ssValue << watermark;
-    leveldb::Slice slValue((const char*)&ssValue[0], ssValue.size());
-
-    batch.Delete(slKey);
-    batch.Put(slKey, slValue);
-
-    leveldb::Status status = pdb->Write(syncoptions, &batch);
-    if (!status.ok()) {
-        PrintToLog("%s(): ERROR: failed to write watermark: %s\n", __func__, status.ToString());
-    }
+    Write(CWattermarkKey{}, CWattermarkValue{watermark, block});
 }
 
-bool CMPSPInfo::getWatermark(uint256& watermark) const
+bool CMPSPInfo::getWatermark(uint256& watermark, int& block) const
 {
-    CDataStream ssKey(SER_DISK, CLIENT_VERSION);
-    ssKey << uint8_t('B');
-    leveldb::Slice slKey((const char*)&ssKey[0], ssKey.size());
-
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
-    if (!status.ok()) {
-        if (!status.IsNotFound()) {
-            PrintToLog("%s(): ERROR: failed to retrieve watermark: %s\n", __func__, status.ToString());
-        }
-        return false;
-    }
-
-    try {
-        CDataStream ssValue(strValue.data(), strValue.data() + strValue.size(), SER_DISK, CLIENT_VERSION);
-        ssValue >> watermark;
-    } catch (const std::exception& e) {
-        PrintToLog("%s(): ERROR: failed to deserialize watermark: %s\n", __func__, e.what());
-        return false;
-    }
-
-    return true;
+    return Read(CWattermarkKey{}, CWattermarkValue{watermark, block});
 }
 
 void CMPSPInfo::printAll() const
@@ -585,39 +359,13 @@ void CMPSPInfo::printAll() const
         }
     }
 
-    leveldb::Iterator* iter = NewIterator();
-
-    CDataStream ssSpKeyPrefix(SER_DISK, CLIENT_VERSION);
-    ssSpKeyPrefix << uint8_t('s');
-    leveldb::Slice slSpKeyPrefix((const char*)&ssSpKeyPrefix[0], ssSpKeyPrefix.size());
-
-    for (iter->Seek(slSpKeyPrefix); iter->Valid() && iter->key().starts_with(slSpKeyPrefix); iter->Next()) {
-        leveldb::Slice slSpKey = iter->key();
-        uint32_t propertyId = 0;
-        try {
-            CDataStream ssValue(1+slSpKey.data(), 1+slSpKey.data()+slSpKey.size(), SER_DISK, CLIENT_VERSION);
-            ssValue >> propertyId;
-        } catch (const std::exception& e) {
-            PrintToLog("%s(): ERROR: %s\n", __func__, e.what());
-            PrintToConsole("<Malformed key in DB>\n");
-            continue;
-        }
+    for (CDBaseIterator it{NewIterator(), CLookupTxKey{{}}}; it; ++it) {
+        auto propertyId = it.Value<uint32_t>();
         PrintToConsole("%10s => ", propertyId);
-
         // deserialize the persisted data
-        leveldb::Slice slSpValue = iter->value();
         Entry info;
-        try {
-            CDataStream ssSpValue(slSpValue.data(), slSpValue.data() + slSpValue.size(), SER_DISK, CLIENT_VERSION);
-            ssSpValue >> info;
-        } catch (const std::exception& e) {
-            PrintToConsole("<Malformed value in DB>\n");
-            PrintToLog("%s(): ERROR: %s\n", __func__, e.what());
-            continue;
+        if (getSP(propertyId, info)) {
+            info.print();
         }
-        info.print();
     }
-
-    // clean up the iterator
-    delete iter;
 }
diff --git a/src/omnicore/dbspinfo.h b/src/omnicore/dbspinfo.h
index b15380691f33f..8b5f5ab811ad4 100644
--- a/src/omnicore/dbspinfo.h
+++ b/src/omnicore/dbspinfo.h
@@ -97,15 +97,16 @@ class CMPSPInfo : public CDBBase
 
         SERIALIZE_METHODS(Entry, obj) {
             READWRITE(obj.issuer);
-            READWRITE(obj.prop_type);
-            READWRITE(obj.prev_prop_id);
+            READWRITE(obj.delegate);
+            READWRITE(VARINT(obj.prop_type));
+            READWRITE(VARINT(obj.prev_prop_id));
             READWRITE(obj.category);
             READWRITE(obj.subcategory);
             READWRITE(obj.name);
             READWRITE(obj.url);
             READWRITE(obj.data);
             READWRITE(obj.num_tokens);
-            READWRITE(obj.property_desired);
+            READWRITE(VARINT(obj.property_desired));
             READWRITE(obj.deadline);
             READWRITE(obj.early_bird);
             READWRITE(obj.percentage);
@@ -119,8 +120,10 @@ class CMPSPInfo : public CDBBase
             READWRITE(obj.update_block);
             READWRITE(obj.fixed);
             READWRITE(obj.manual);
+            READWRITE(obj.unique);
             READWRITE(obj.historicalData);
             READWRITE(obj.historicalIssuers);
+            READWRITE(obj.historicalDelegates);
         }
 
         bool isDivisible() const;
@@ -144,11 +147,11 @@ class CMPSPInfo : public CDBBase
 
 private:
     // implied version of OMN and TOMN so they don't hit the leveldb
-    Entry implied_omni;
-    Entry implied_tomni;
+    const Entry implied_omni;
+    const Entry implied_tomni;
 
-    uint32_t next_spid;
-    uint32_t next_test_spid;
+    std::atomic<uint32_t> next_spid;
+    std::atomic<uint32_t> next_test_spid;
 
 public:
     CMPSPInfo(const fs::path& path, bool fWipe);
@@ -160,16 +163,16 @@ class CMPSPInfo : public CDBBase
     void init(uint32_t nextSPID = 0x3UL, uint32_t nextTestSPID = TEST_ECO_PROPERTY_1);
 
     uint32_t peekNextSPID(uint8_t ecosystem) const;
-    bool updateSP(uint32_t propertyId, const Entry& info);
-    uint32_t putSP(uint8_t ecosystem, const Entry& info);
+    bool updateSP(uint32_t propertyId, const Entry& info, int block);
+    uint32_t putSP(uint8_t ecosystem, const Entry& info, int block);
     bool getSP(uint32_t propertyId, Entry& info) const;
     bool hasSP(uint32_t propertyId) const;
     uint32_t findSPByTX(const uint256& txid) const;
 
-    int64_t popBlock(const uint256& block_hash);
+    void deleteSPAboveBlock(int block);
 
-    void setWatermark(const uint256& watermark);
-    bool getWatermark(uint256& watermark) const;
+    void setWatermark(const uint256& watermark, int block);
+    bool getWatermark(uint256& watermark, int& block) const;
 
     void printAll() const;
 };
diff --git a/src/omnicore/dbstolist.cpp b/src/omnicore/dbstolist.cpp
index 1c2cd6145d37f..6ee56df6b2614 100644
--- a/src/omnicore/dbstolist.cpp
+++ b/src/omnicore/dbstolist.cpp
@@ -4,6 +4,7 @@
 #include <omnicore/log.h>
 #include <omnicore/script.h>
 #include <omnicore/sp.h>
+#include <omnicore/uint256_extensions.h>
 #include <omnicore/walletutils.h>
 
 #include <fs.h>
@@ -18,16 +19,11 @@
 #include <leveldb/slice.h>
 #include <leveldb/status.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stddef.h>
 #include <stdint.h>
-
 #include <string>
 #include <vector>
 
-using mastercore::atoi;
 using mastercore::IsMyAddress;
 
 CMPSTOList::CMPSTOList(const fs::path& path, bool fWipe)
@@ -41,16 +37,29 @@ CMPSTOList::~CMPSTOList()
     if (msc_debug_persistence) PrintToLog("CMPSTOList closed\n");
 }
 
-void CMPSTOList::getRecipients(const uint256 txid, std::string filterAddress, UniValue* recipientArray, uint64_t* total, uint64_t* numRecipients, interfaces::Wallet* iWallet)
-{
-    if (!pdb) return;
+struct CTxAddressKey {
+    static constexpr uint8_t prefix = 'h';
+    uint256 hash;
+    std::string address;
+    int block = 0;
+    uint32_t propertyId = 0;
+
+    SERIALIZE_METHODS(CTxAddressKey, obj) {
+        READWRITE(obj.hash);
+        READWRITE(obj.address);
+        READWRITE(Using<VarintSigned>(obj.block));
+        READWRITE(Using<Varint>(obj.propertyId));
+    }
+};
 
+void CMPSTOList::getRecipients(const uint256& txid, const std::string& filterAddress, UniValue* recipientArray, uint64_t* total, uint64_t* numRecipients, interfaces::Wallet* iWallet)
+{
     bool filter = true; //default
     bool filterByWallet = true; //default
     bool filterByAddress = false; //default
 
     if (filterAddress == "*") filter = false;
-    if ((filterAddress != "") && (filterAddress != "*")) {
+    if (!filterAddress.empty() && filter) {
         filterByWallet = false;
         filterByAddress = true;
     }
@@ -58,87 +67,36 @@ void CMPSTOList::getRecipients(const uint256 txid, std::string filterAddress, Un
     // the fee is variable based on version of STO - provide number of recipients and allow calling function to work out fee
     *numRecipients = 0;
 
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        std::string recipientAddress = skey.ToString();
-        svalue = it->value();
-        std::string strValue = svalue.ToString();
+    CDBaseIterator it{NewIterator(), CTxAddressKey{txid, filterByAddress ? filterAddress : ""}};
+    for (; it; ++it) {
+        auto key = it.Key<CTxAddressKey>();
+        if (key.hash != txid) break;
+        auto& recipientAddress = key.address;
         // see if txid is in the data
-        size_t txidMatch = strValue.find(txid.ToString());
-        if (txidMatch != std::string::npos) {
-            ++*numRecipients;
-            // the txid exists inside the data, this address was a recipient of this STO, check filter and add the details
-            if (filter) {
-                if (((filterByAddress) && (filterAddress == recipientAddress)) || ((filterByWallet) && (IsMyAddress(recipientAddress, iWallet)))) {
-                } else {
-                    continue;
-                } // move on if no filter match (but counter still increased for fee)
-            }
-            std::vector<std::string> vstr;
-            boost::split(vstr, strValue, boost::is_any_of(","), boost::token_compress_on);
-            for (uint32_t i = 0; i < vstr.size(); i++) {
-                std::vector<std::string> svstr;
-                boost::split(svstr, vstr[i], boost::is_any_of(":"), boost::token_compress_on);
-                if (4 == svstr.size()) {
-                    if (svstr[0] == txid.ToString()) {
-                        //add data to array
-                        uint64_t amount = 0;
-                        uint64_t propertyId = 0;
-                        try {
-                            amount = boost::lexical_cast<uint64_t>(svstr[3]);
-                            propertyId = boost::lexical_cast<uint64_t>(svstr[2]);
-                        } catch (const boost::bad_lexical_cast &e) {
-                            PrintToLog("DEBUG STO - error in converting values from leveldb\n");
-                            delete it;
-                            return; //(something went wrong)
-                        }
-                        UniValue recipient(UniValue::VOBJ);
-                        recipient.pushKV("address", TryEncodeOmniAddress(recipientAddress));
-                        recipient.pushKV("amount", FormatMP(propertyId, amount));
-                        *total += amount;
-                        recipientArray->push_back(recipient);
-                    }
-                }
-            }
-        }
+        ++(*numRecipients);
+        // the txid exists inside the data, this address was a recipient of this STO, check filter and add the details
+        if (filter && filterByAddress && filterAddress != recipientAddress) continue;
+        if (filter && filterByWallet && !IsMyAddress(recipientAddress, iWallet)) continue;
+        UniValue recipient(UniValue::VOBJ);
+        auto amount = it.Value<uint64_t>();
+        recipient.pushKV("address", TryEncodeOmniAddress(recipientAddress));
+        recipient.pushKV("amount", FormatMP(key.propertyId, amount));
+        *total += amount;
+        recipientArray->push_back(recipient);
     }
-
-    delete it;
-    return;
 }
 
-std::string CMPSTOList::getMySTOReceipts(std::string filterAddress, interfaces::Wallet &iWallet)
+std::unordered_map<int, uint256> CMPSTOList::getMySTOReceipts(const std::string& filterAddress, int startBlock, int endBlock, interfaces::Wallet &iWallet)
 {
-    if (!pdb) return "";
-    std::string mySTOReceipts;
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        std::string recipientAddress = skey.ToString();
-        if (!IsMyAddress(recipientAddress, &iWallet)) continue; // not ours, not interested
-        if ((!filterAddress.empty()) && (filterAddress != recipientAddress)) continue; // not the filtered address
-        // ours, get info
-        svalue = it->value();
-        std::string strValue = svalue.ToString();
-        // break into individual receipts
-        std::vector<std::string> vstr;
-        boost::split(vstr, strValue, boost::is_any_of(","), boost::token_compress_on);
-        for (uint32_t i = 0; i < vstr.size(); i++) {
-            // add to array
-            std::vector<std::string> svstr;
-            boost::split(svstr, vstr[i], boost::is_any_of(":"), boost::token_compress_on);
-            if (4 == svstr.size()) {
-                size_t txidMatch = mySTOReceipts.find(svstr[0]);
-                if (txidMatch == std::string::npos) mySTOReceipts += svstr[0] + ":" + svstr[1] + ":" + recipientAddress + ":" + svstr[2] + ",";
-            }
-        }
+    std::unordered_map<int, uint256> mySTOReceipts;
+    for (CDBaseIterator it{NewIterator(), CTxAddressKey{}}; it; ++it) {
+        auto key = it.Key<CTxAddressKey>();
+        if (key.block > endBlock) continue;
+        if (key.block < startBlock) continue;
+        if (!filterAddress.empty() && key.address != filterAddress) continue;
+        if (!IsMyAddress(key.address, &iWallet)) continue;
+        mySTOReceipts.emplace(key.block, key.hash);
     }
-    delete it;
-    // above code will leave a trailing comma - strip it
-    if (mySTOReceipts.size() > 0) mySTOReceipts.resize(mySTOReceipts.size() - 1);
     return mySTOReceipts;
 }
 
@@ -149,37 +107,18 @@ std::string CMPSTOList::getMySTOReceipts(std::string filterAddress, interfaces::
  */
 int CMPSTOList::deleteAboveBlock(int blockNum)
 {
+    CDBWriteBatch batch;
     unsigned int n_found = 0;
     std::vector<std::string> vecSTORecords;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string newValue;
-        std::string oldValue = it->value().ToString();
-        bool needsUpdate = false;
-        boost::split(vecSTORecords, oldValue, boost::is_any_of(","), boost::token_compress_on);
-        for (uint32_t i = 0; i < vecSTORecords.size(); i++) {
-            std::vector<std::string> vecSTORecordFields;
-            boost::split(vecSTORecordFields, vecSTORecords[i], boost::is_any_of(":"), boost::token_compress_on);
-            if (4 != vecSTORecordFields.size()) continue;
-            if (atoi(vecSTORecordFields[1]) < blockNum) {
-                newValue += vecSTORecords[i].append(","); // STO before the reorg, add data back to new value string
-            } else {
-                needsUpdate = true;
-            }
-        }
-        if (needsUpdate) { // rewrite record with existing key and new value
-            ++n_found;
-            leveldb::Status status = pdb->Put(writeoptions, it->key().ToString(), newValue);
-            PrintToLog("DEBUG STO - rewriting STO data after reorg\n");
-            PrintToLog("STODBDEBUG : %s(): %s, line %d, file: %s\n", __FUNCTION__, status.ToString(), __LINE__, __FILE__);
-        }
+    for (CDBaseIterator it{NewIterator(), CTxAddressKey{}}; it; ++it) {
+        auto key = it.Key<CTxAddressKey>();
+        if (key.block < blockNum) continue;
+        ++n_found;
+        batch.Delete(it.Key());
     }
-
-    PrintToLog("%s(%d); stodb updated records= %d\n", __FUNCTION__, blockNum, n_found);
-
-    delete it;
-
-    return (n_found);
+    WriteBatch(batch);
+    PrintToLog("%s(%d); stodb updated records= %d\n", __func__, blockNum, n_found);
+    return n_found;
 }
 
 void CMPSTOList::printStats()
@@ -190,66 +129,17 @@ void CMPSTOList::printStats()
 void CMPSTOList::printAll()
 {
     int count = 0;
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        svalue = it->value();
+    for (CDBaseIterator it {NewIterator(), CTxAddressKey{}}; it; ++it) {
         ++count;
-        PrintToConsole("entry #%8d= %s:%s\n", count, skey.ToString(), svalue.ToString());
+        auto key = it.Key<CTxAddressKey>();
+        auto amount = it.Value<uint64_t>();
+        auto value = strprintf("%s:%d:%d:%d", key.hash.ToString(), key.block, key.propertyId, amount);
+        PrintToConsole("entry #%8d= %s:%s\n", count, key.address, value);
     }
-
-    delete it;
 }
 
-bool CMPSTOList::exists(std::string address)
+void CMPSTOList::recordSTOReceive(const std::string& address, const uint256 &txid, int nBlock, uint32_t propertyId, uint64_t amount)
 {
-    if (!pdb) return false;
-
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, address, &strValue);
-
-    if (!status.ok()) {
-        if (status.IsNotFound()) return false;
-    }
-
-    return true;
-}
-
-void CMPSTOList::recordSTOReceive(std::string address, const uint256 &txid, int nBlock, unsigned int propertyId, uint64_t amount)
-{
-    if (!pdb) return;
-
-    bool addressExists = exists(address);
-    if (addressExists) {
-        // retrieve existing record
-        std::vector<std::string> vstr;
-        std::string strValue;
-        leveldb::Status status = pdb->Get(readoptions, address, &strValue);
-        if (status.ok()) {
-            // add details to record
-            // see if we are overwriting (check)
-            size_t txidMatch = strValue.find(txid.ToString());
-            if (txidMatch != std::string::npos) PrintToLog("STODEBUG : Duplicating entry for %s : %s\n", address, txid.ToString());
-
-            const std::string& key = address;
-            const std::string newValue = strprintf("%s:%d:%u:%lu,", txid.ToString(), nBlock, propertyId, amount);
-            strValue += newValue;
-            // write updated record
-            leveldb::Status status;
-            if (pdb) {
-                status = pdb->Put(writeoptions, key, strValue);
-                PrintToLog("STODBDEBUG : %s(): %s, line %d, file: %s\n", __FUNCTION__, status.ToString(), __LINE__, __FILE__);
-            }
-        }
-    } else {
-        const std::string& key = address;
-        const std::string value = strprintf("%s:%d:%u:%lu,", txid.ToString(), nBlock, propertyId, amount);
-        leveldb::Status status;
-        if (pdb) {
-            status = pdb->Put(writeoptions, key, value);
-            PrintToLog("STODBDEBUG : %s(): %s, line %d, file: %s\n", __FUNCTION__, status.ToString(), __LINE__, __FILE__);
-        }
-    }
+    bool status = Write(CTxAddressKey{txid, address, nBlock, propertyId}, amount);
+    PrintToLog("%s(%d): add record: (%s) \n", __func__, nBlock, status ? "OK" : "NOK");
 }
diff --git a/src/omnicore/dbstolist.h b/src/omnicore/dbstolist.h
index 0ba41dfb09840..6e7628ecf03e5 100644
--- a/src/omnicore/dbstolist.h
+++ b/src/omnicore/dbstolist.h
@@ -11,6 +11,7 @@
 #include <stdint.h>
 
 #include <string>
+#include <unordered_map>
 
 namespace interfaces {
 class Wallet;
@@ -24,9 +25,9 @@ class CMPSTOList : public CDBBase
     CMPSTOList(const fs::path& path, bool fWipe);
     virtual ~CMPSTOList();
 
-    void getRecipients(const uint256 txid, std::string filterAddress, UniValue* recipientArray, uint64_t* total, uint64_t* numRecipients, interfaces::Wallet* iWallet = nullptr);
-    std::string getMySTOReceipts(std::string filterAddress, interfaces::Wallet& iWallet);
-    
+    void getRecipients(const uint256& txid, const std::string& filterAddress, UniValue* recipientArray, uint64_t* total, uint64_t* numRecipients, interfaces::Wallet* iWallet = nullptr);
+    std::unordered_map<int, uint256> getMySTOReceipts(const std::string& filterAddress, int startBlock, int endBlock, interfaces::Wallet& iWallet);
+
     /**
      * This function deletes records of STO receivers above/equal to a specific block from the STO database.
      *
@@ -35,8 +36,7 @@ class CMPSTOList : public CDBBase
     int deleteAboveBlock(int blockNum);
     void printStats();
     void printAll();
-    bool exists(std::string address);
-    void recordSTOReceive(std::string, const uint256&, int, unsigned int, uint64_t);
+    void recordSTOReceive(const std::string&, const uint256&, int, uint32_t, uint64_t);
 };
 
 namespace mastercore
diff --git a/src/omnicore/dbtradelist.cpp b/src/omnicore/dbtradelist.cpp
index 2e85666b31595..4981d561e3040 100644
--- a/src/omnicore/dbtradelist.cpp
+++ b/src/omnicore/dbtradelist.cpp
@@ -1,10 +1,13 @@
 
 #include <omnicore/convert.h>
 #include <omnicore/dbtradelist.h>
+#include <omnicore/dbtransaction.h>
 #include <omnicore/log.h>
 #include <omnicore/mdex.h>
 #include <omnicore/script.h>
 #include <omnicore/sp.h>
+#include <omnicore/utilsbitcoin.h>
+#include <omnicore/uint256_extensions.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -22,18 +25,16 @@
 #include <leveldb/slice.h>
 #include <leveldb/status.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
-using mastercore::atoi;
+using mastercore::GetActiveChain;
 using mastercore::isPropertyDivisible;
 
 CMPTradeList::CMPTradeList(const fs::path& path, bool fWipe)
@@ -47,23 +48,62 @@ CMPTradeList::~CMPTradeList()
     if (msc_debug_persistence) PrintToLog("CMPTradeList closed\n");
 }
 
-void CMPTradeList::recordMatchedTrade(const uint256& txid1, const uint256& txid2, const std::string& address1, const std::string& address2, uint32_t prop1, uint32_t prop2, int64_t amount1, int64_t amount2, int blockNum, int64_t fee)
+struct CTradeMatchKey {
+    static constexpr uint8_t prefix = 'm';
+    uint32_t block = ~0u;
+    uint256 txid1;
+    uint256 txid2;
+
+    SERIALIZE_METHODS(CTradeMatchKey, obj) {
+        READWRITE(Using<BigEndian32Inv>(obj.block));
+        READWRITE(obj.txid1);
+        READWRITE(obj.txid2);
+    }
+};
+
+struct CTradeMatchValue {
+    int64_t amount1;
+    int64_t amount2;
+    int64_t fee;
+
+    SERIALIZE_METHODS(CTradeMatchValue, obj) {
+        READWRITE(obj.amount1);
+        READWRITE(obj.amount2);
+        READWRITE(obj.fee);
+    }
+};
+
+void CMPTradeList::recordMatchedTrade(const uint256& txid1, const uint256& txid2, int block, int64_t amount1, int64_t amount2, int64_t fee)
 {
-    if (!pdb) return;
-    const std::string key = txid1.ToString() + "+" + txid2.ToString();
-    const std::string value = strprintf("%s:%s:%u:%u:%lu:%lu:%d:%d", address1, address2, prop1, prop2, amount1, amount2, blockNum, fee);
-    leveldb::Status status = pdb->Put(writeoptions, key, value);
+    bool status = Write(CTradeMatchKey{uint32_t(block), txid1, txid2}, CTradeMatchValue{amount1, amount2, fee});
     ++nWritten;
-    if (msc_debug_tradedb) PrintToLog("%s: %s\n", __func__, status.ToString());
+    if (msc_debug_tradedb) PrintToLog("%s: %s\n", __func__, status ? "OK" : "NOK");
 }
 
+struct CTxTradeKey {
+    static constexpr uint8_t prefix = 't';
+    uint256 txid;
+    std::string address;
+    uint32_t propertyIdForSale = 0;
+    uint32_t propertyIdDesired = 0;
+    int block = 0;
+    uint32_t blockIndex = 0;
+
+    SERIALIZE_METHODS(CTxTradeKey, obj) {
+        READWRITE(obj.txid);
+        READWRITE(obj.address);
+        READWRITE(Using<Varint>(obj.propertyIdForSale));
+        READWRITE(Using<Varint>(obj.propertyIdDesired));
+        READWRITE(Using<VarintSigned>(obj.block));
+        READWRITE(Using<Varint>(obj.blockIndex));
+    }
+};
+
 void CMPTradeList::recordNewTrade(const uint256& txid, const std::string& address, uint32_t propertyIdForSale, uint32_t propertyIdDesired, int blockNum, int blockIndex)
 {
-    if (!pdb) return;
-    std::string strValue = strprintf("%s:%d:%d:%d:%d", address, propertyIdForSale, propertyIdDesired, blockNum, blockIndex);
-    leveldb::Status status = pdb->Put(writeoptions, txid.ToString(), strValue);
+    bool status = Write(CTxTradeKey{txid, address, propertyIdForSale, propertyIdDesired, blockNum, uint32_t(blockIndex)}, "");
     ++nWritten;
-    if (msc_debug_tradedb) PrintToLog("%s: %s\n", __func__, status.ToString());
+    if (msc_debug_tradedb) PrintToLog("%s: %s\n", __func__, status ? "OK" : "NOK");
 }
 
 /**
@@ -71,31 +111,27 @@ void CMPTradeList::recordNewTrade(const uint256& txid, const std::string& addres
  *
  * Returns the number of records changed.
  */
-int CMPTradeList::deleteAboveBlock(int blockNum)
+int CMPTradeList::deleteTransactions(const std::set<uint256>& txs, int block)
 {
-    leveldb::Slice skey, svalue;
-    std::vector<std::string> vstr;
-    int block = 0;
+    CDBWriteBatch batch;
     unsigned int n_found = 0;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        svalue = it->value();
-        std::string strvalue = it->value().ToString();
-        boost::split(vstr, strvalue, boost::is_any_of(":"), boost::token_compress_on);
-        if (7 == vstr.size()) block = atoi(vstr[6]); // trade matches have 7 tokens, key is txid+txid, only care about block
-        if (5 == vstr.size()) block = atoi(vstr[3]); // trades have 5 tokens, key is txid, only care about block
-        if (block >= blockNum) {
-            ++n_found;
-            PrintToLog("%s() DELETING FROM TRADEDB: %s=%s\n", __func__, skey.ToString(), svalue.ToString());
-            pdb->Delete(writeoptions, skey);
+    std::vector<std::string> vecSTORecords;
+    CDBaseIterator it{NewIterator()};
+    for (const auto& txid : txs) {
+        auto found = n_found;
+        for (it.Seek(PartialKey<CTxTradeKey>(txid)); it; ++it) {
+            batch.Delete(it.Key());
+            n_found++;
         }
     }
-
-    delete it;
-
-    PrintToLog("%s(%d); tradedb n_found= %d\n", __func__, blockNum, n_found);
-
+    for (it.Seek(CTradeMatchKey{}); it; ++it) {
+        auto key = it.Key<CTradeMatchKey>();
+        if (key.block < block) break;
+        batch.Delete(it.Key());
+        n_found++;
+    }
+    WriteBatch(batch);
+    PrintToLog("%s: tradedb n_found= %d\n", __func__, n_found);
     return n_found;
 }
 
@@ -107,103 +143,71 @@ void CMPTradeList::printStats()
 void CMPTradeList::printAll()
 {
     int count = 0;
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        svalue = it->value();
-        ++count;
-        PrintToConsole("entry #%8d= %s:%s\n", count, skey.ToString(), svalue.ToString());
+    for (CDBaseIterator it{NewIterator()}; it; ++it) {
+        std::string skey, svalue;
+        switch(it.Key()[0]) {
+            case CTxTradeKey::prefix: {
+                auto key = it.Key<CTxTradeKey>();
+                skey = key.txid.ToString();
+                svalue = strprintf("%s:%d:%d:%d:%d", key.address, key.propertyIdForSale, key.propertyIdDesired, key.block, key.blockIndex);
+            } break;
+            case CTradeMatchKey::prefix: {
+                auto key = it.Key<CTradeMatchKey>();
+                skey = strprintf("%s:%s", key.txid1.ToString(), key.txid2.ToString());
+                auto [amount1, amount2, fee] = it.Value<CTradeMatchValue>();
+                svalue = strprintf("%d:%d:%d", amount1, amount2, fee);
+            } break;
+            default: continue;
+        }
+        PrintToConsole("entry #%8d= %s:%s\n", ++count, skey, svalue);
     }
-
-    delete it;
 }
 
 bool CMPTradeList::getMatchingTrades(const uint256& txid, uint32_t propertyId, UniValue& tradeArray, int64_t& totalSold, int64_t& totalReceived)
 {
-    if (!pdb) return false;
-
     int count = 0;
-    totalReceived = 0;
-    totalSold = 0;
-
-    std::vector<std::string> vstr;
-    std::string txidStr = txid.ToString();
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
+    totalReceived = totalSold = 0;
+    CDBaseIterator tx_it{NewIterator(), PartialKey<CTxTradeKey>(txid)};
+    if (!tx_it.Valid()) return false;
+    auto tx1key = tx_it.Key<CTxTradeKey>();
+    for (CDBaseIterator it{NewIterator(), CTradeMatchKey{}}; it; ++it) {
         // search key to see if this is a matching trade
-        std::string strKey = it->key().ToString();
-        std::string strValue = it->value().ToString();
-        std::string matchTxid;
-        size_t txidMatch = strKey.find(txidStr);
-        if (txidMatch == std::string::npos) continue; // no match
-
-        // sanity check key is the correct length for a matched trade
-        if (strKey.length() != 129) continue;
-
-        // obtain the txid of the match
-        if (txidMatch == 0) {
-            matchTxid = strKey.substr(65, 64);
-        } else {
-            matchTxid = strKey.substr(0, 64);
-        }
-
-        // ensure correct amount of tokens in value string
-        boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (vstr.size() != 8) {
-            PrintToLog("TRADEDB error - unexpected number of tokens in value (%s)\n", strValue);
-            continue;
-        }
-
-        // decode the details from the value string
-        std::string address1 = vstr[0];
-        std::string address2 = vstr[1];
-        uint32_t prop1 = boost::lexical_cast<uint32_t>(vstr[2]);
-        uint32_t prop2 = boost::lexical_cast<uint32_t>(vstr[3]);
-        int64_t amount1 = boost::lexical_cast<int64_t>(vstr[4]);
-        int64_t amount2 = boost::lexical_cast<int64_t>(vstr[5]);
-        int blockNum = atoi(vstr[6]);
-        int64_t tradingFee = boost::lexical_cast<int64_t>(vstr[7]);
-
-        std::string strAmount1 = FormatMP(prop1, amount1);
-        std::string strAmount2 = FormatMP(prop2, amount2);
-        std::string strTradingFee = FormatMP(prop2, tradingFee);
-        std::string strAmount2PlusFee = FormatMP(prop2, amount2 + tradingFee);
-
+        auto key = it.Key<CTradeMatchKey>();
+        auto mtxid = key.txid1 == txid ? &key.txid2 : key.txid2 == txid ? &key.txid1 : nullptr;
+        if (!mtxid) continue;
+        auto [amount1, amount2, tradingFee] = it.Value<CTradeMatchValue>();
+
+        tx_it.Seek(PartialKey<CTxTradeKey>(*mtxid));
+        if (!tx_it.Valid()) continue;
+        auto tx2key = tx_it.Key<CTxTradeKey>();
+        const auto& t1key = mtxid == &key.txid2 ? tx1key : tx2key;
+        const auto& t2key = mtxid == &key.txid2 ? tx2key : tx1key;
         // populate trade object and add to the trade array, correcting for orientation of trade
         UniValue trade(UniValue::VOBJ);
-        trade.pushKV("txid", matchTxid);
-        trade.pushKV("block", blockNum);
-        if (auto pBlockIndex = WITH_LOCK(cs_main, return ::ChainActive()[blockNum])) {
+        trade.pushKV("txid", mtxid->ToString());
+        trade.pushKV("block", key.block);
+        if (auto pBlockIndex = GetActiveChain()[key.block]) {
             trade.pushKV("blocktime", pBlockIndex->GetBlockTime());
         }
-        if (prop1 == propertyId) {
-            trade.pushKV("address", TryEncodeOmniAddress(address1));
-            trade.pushKV("amountsold", strAmount1);
-            trade.pushKV("amountreceived", strAmount2);
-            trade.pushKV("tradingfee", strTradingFee);
+        if (t1key.propertyIdDesired == propertyId) {
+            trade.pushKV("address", TryEncodeOmniAddress(t1key.address));
+            trade.pushKV("amountsold", FormatMP(t1key.propertyIdDesired, amount1));
+            trade.pushKV("amountreceived", FormatMP(t1key.propertyIdForSale, amount2));
+            trade.pushKV("tradingfee", FormatMP(t1key.propertyIdForSale, tradingFee));
             totalReceived += amount2;
             totalSold += amount1;
         } else {
-            trade.pushKV("address", TryEncodeOmniAddress(address2));
-            trade.pushKV("amountsold", strAmount2PlusFee);
-            trade.pushKV("amountreceived", strAmount1);
-            trade.pushKV("tradingfee", FormatMP(prop1, 0)); // not the liquidity taker so no fee for this participant - include attribute for standardness
+            trade.pushKV("address", TryEncodeOmniAddress(t2key.address));
+            trade.pushKV("amountsold", FormatMP(t2key.propertyIdDesired, amount2 + tradingFee));
+            trade.pushKV("amountreceived", FormatMP(t2key.propertyIdForSale, amount1));
+            trade.pushKV("tradingfee", FormatMP(t2key.propertyIdForSale, 0)); // not the liquidity taker so no fee for this participant - include attribute for standardness
             totalReceived += amount1;
             totalSold += amount2;
         }
         tradeArray.push_back(trade);
         ++count;
     }
-
-    // clean up
-    delete it;
-    if (count) {
-        return true;
-    } else {
-        return false;
-    }
+    return count > 0;
 }
 
 
@@ -212,77 +216,53 @@ bool CMPTradeList::getMatchingTrades(const uint256& txid, uint32_t propertyId, U
 // sorted by block then index
 void CMPTradeList::getTradesForAddress(const std::string& address, std::vector<uint256>& vecTransactions, uint32_t propertyIdFilter)
 {
-    if (!pdb) return;
-
-    std::map<std::string, uint256> mapTrades;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string strKey = it->key().ToString();
-        std::string strValue = it->value().ToString();
-        std::vector<std::string> vecValues;
-        if (strKey.size() != 64) continue; // only interested in trades
-        uint256 txid = uint256S(strKey);
-        size_t addressMatch = strValue.find(address);
-        if (addressMatch == std::string::npos) continue;
-        boost::split(vecValues, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (vecValues.size() != 5) {
-            PrintToLog("TRADEDB error - unexpected number of tokens in value (%s)\n", strValue);
-            continue;
-        }
-        uint32_t propertyIdForSale = boost::lexical_cast<uint32_t>(vecValues[1]);
-        uint32_t propertyIdDesired = boost::lexical_cast<uint32_t>(vecValues[2]);
-        int64_t blockNum = boost::lexical_cast<uint32_t>(vecValues[3]);
-        int64_t txIndex = boost::lexical_cast<uint32_t>(vecValues[4]);
-        if (propertyIdFilter != 0 && propertyIdFilter != propertyIdForSale && propertyIdFilter != propertyIdDesired) continue;
-        std::string sortKey = strprintf("%06d%010d", blockNum, txIndex);
-        mapTrades.insert(std::make_pair(sortKey, txid));
+    std::map<std::pair<int, int>, uint256> mapTrades;
+    for (CDBaseIterator it{NewIterator(), CTxTradeKey{}}; it; ++it) {
+        auto key = it.Key<CTxTradeKey>();
+        if (key.address != address) continue;
+        if (propertyIdFilter != 0 && propertyIdFilter != key.propertyIdForSale && propertyIdFilter != key.propertyIdDesired) continue;
+        mapTrades.emplace(std::make_pair(key.block, key.blockIndex), key.txid);
     }
-    delete it;
 
-    for (std::map<std::string, uint256>::iterator it = mapTrades.begin(); it != mapTrades.end(); it++) {
-        vecTransactions.push_back(it->second);
+    for (auto& [_, txid] : mapTrades) {
+        vecTransactions.push_back(txid);
     }
 }
 
 // obtains an array of matching trades with pricing and volume details for a pair sorted by blocknumber
 void CMPTradeList::getTradesForPair(uint32_t propertyIdSideA, uint32_t propertyIdSideB, UniValue& responseArray, uint64_t count)
 {
-    if (!pdb || !count) return;
-    leveldb::Iterator* it = NewIterator();
+    if (!count) return;
     std::vector<std::pair<int64_t, UniValue> > vecResponse;
+    CDBaseIterator tx1_it{NewIterator()}, tx2_it{NewIterator()};
     bool propertyIdSideAIsDivisible = isPropertyDivisible(propertyIdSideA);
     bool propertyIdSideBIsDivisible = isPropertyDivisible(propertyIdSideB);
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string strKey = it->key().ToString();
-        std::string strValue = it->value().ToString();
-        std::vector<std::string> vecKeys;
-        std::vector<std::string> vecValues;
+    for (CDBaseIterator it{NewIterator(), CTradeMatchKey{}}; it; ++it) {
+        auto key = it.Key<CTradeMatchKey>();
+        tx1_it.Seek(PartialKey<CTxTradeKey>(key.txid1));
+        tx2_it.Seek(PartialKey<CTxTradeKey>(key.txid2));
+        if (!tx1_it || !tx2_it) continue;
+        auto tx1_key = tx1_it.Key<CTxTradeKey>();
+        auto tx2_key = tx2_it.Key<CTxTradeKey>();
         uint256 sellerTxid, matchingTxid;
         std::string sellerAddress, matchingAddress;
         int64_t amountReceived = 0, amountSold = 0;
-        if (strKey.size() != 129) continue; // only interested in matches
-        boost::split(vecKeys, strKey, boost::is_any_of("+"), boost::token_compress_on);
-        boost::split(vecValues, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (vecKeys.size() != 2 || vecValues.size() != 8) {
-            PrintToLog("TRADEDB error - unexpected number of tokens (%s:%s)\n", strKey, strValue);
-            continue;
-        }
-        uint32_t tradePropertyIdSideA = boost::lexical_cast<uint32_t>(vecValues[2]);
-        uint32_t tradePropertyIdSideB = boost::lexical_cast<uint32_t>(vecValues[3]);
-        if (tradePropertyIdSideA == propertyIdSideA && tradePropertyIdSideB == propertyIdSideB) {
-            sellerTxid.SetHex(vecKeys[1]);
-            sellerAddress = vecValues[1];
-            amountSold = boost::lexical_cast<int64_t>(vecValues[4]);
-            matchingTxid.SetHex(vecKeys[0]);
-            matchingAddress = vecValues[0];
-            amountReceived = boost::lexical_cast<int64_t>(vecValues[5]);
-        } else if (tradePropertyIdSideB == propertyIdSideA && tradePropertyIdSideA == propertyIdSideB) {
-            sellerTxid.SetHex(vecKeys[0]);
-            sellerAddress = vecValues[0];
-            amountSold = boost::lexical_cast<int64_t>(vecValues[5]);
-            matchingTxid.SetHex(vecKeys[1]);
-            matchingAddress = vecValues[1];
-            amountReceived = boost::lexical_cast<int64_t>(vecValues[4]);
+        if (tx1_key.propertyIdDesired == propertyIdSideA && tx1_key.propertyIdForSale == propertyIdSideB) {
+            sellerTxid = key.txid2;
+            sellerAddress = tx2_key.address;
+            matchingTxid = key.txid1;
+            matchingAddress = tx1_key.address;
+            auto value = it.Value<CTradeMatchValue>();
+            amountSold = value.amount1;
+            amountReceived = value.amount2;
+        } else if (tx1_key.propertyIdDesired == propertyIdSideB && tx1_key.propertyIdForSale == propertyIdSideA) {
+            sellerTxid = key.txid1;
+            sellerAddress = tx1_key.address;
+            matchingTxid = key.txid2;
+            matchingAddress = tx2_key.address;
+            auto value = it.Value<CTradeMatchValue>();
+            amountSold = value.amount2;
+            amountReceived = value.amount1;
         } else {
             continue;
         }
@@ -300,11 +280,11 @@ void CMPTradeList::getTradesForPair(uint32_t propertyIdSideA, uint32_t propertyI
         std::string unitPriceStr = xToString(unitPrice); // TODO: not here!
         std::string inversePriceStr = xToString(inversePrice);
 
-        int64_t blockNum = boost::lexical_cast<int64_t>(vecValues[6]);
+        int64_t blockNum = key.block;
 
         UniValue trade(UniValue::VOBJ);
         trade.pushKV("block", blockNum);
-        if (auto pBlockIndex = WITH_LOCK(cs_main, return ::ChainActive()[blockNum])) {
+        if (auto pBlockIndex = GetActiveChain()[blockNum]) {
             trade.pushKV("blocktime", pBlockIndex->GetBlockTime());
         }
         trade.pushKV("unitprice", unitPriceStr);
@@ -315,7 +295,7 @@ void CMPTradeList::getTradesForPair(uint32_t propertyIdSideA, uint32_t propertyI
         trade.pushKV("amountreceived", FormatMP(propertyIdSideB, amountReceived));
         trade.pushKV("matchingtxid", matchingTxid.GetHex());
         trade.pushKV("matchingaddress", TryEncodeOmniAddress(matchingAddress));
-        vecResponse.push_back(std::make_pair(blockNum, trade));
+        vecResponse.emplace_back(blockNum, trade);
     }
 
     std::sort(vecResponse.begin(), vecResponse.end(), [](auto& lhs, auto& rhs) {
@@ -327,16 +307,13 @@ void CMPTradeList::getTradesForPair(uint32_t propertyIdSideA, uint32_t propertyI
     for (auto& [_, value] : reverse_iterate(vecResponse)) {
         responseArray.push_back(std::move(value));
     }
-    delete it;
 }
 
 int CMPTradeList::getMPTradeCountTotal()
 {
     int count = 0;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
+    for (CDBaseIterator it{NewIterator(), CTxTradeKey{}}; it; ++it) {
         ++count;
     }
-    delete it;
     return count;
 }
diff --git a/src/omnicore/dbtradelist.h b/src/omnicore/dbtradelist.h
index bad144976de7a..e99b5b213460c 100644
--- a/src/omnicore/dbtradelist.h
+++ b/src/omnicore/dbtradelist.h
@@ -21,10 +21,9 @@ class CMPTradeList : public CDBBase
     CMPTradeList(const fs::path& path, bool fWipe);
     virtual ~CMPTradeList();
 
-    void recordMatchedTrade(const uint256& txid1, const uint256& txid2, const std::string& address1, const std::string& address2, uint32_t prop1, uint32_t prop2, int64_t amount1, int64_t amount2, int blockNum, int64_t fee);
+    void recordMatchedTrade(const uint256& txid1, const uint256& txid2, int block, int64_t amount1, int64_t amount2, int64_t fee);
     void recordNewTrade(const uint256& txid, const std::string& address, uint32_t propertyIdForSale, uint32_t propertyIdDesired, int blockNum, int blockIndex);
-    int deleteAboveBlock(int blockNum);
-    bool exists(const uint256 &txid);
+    int deleteTransactions(const std::set<uint256>& txs, int block);
     void printStats();
     void printAll();
     bool getMatchingTrades(const uint256& txid, uint32_t propertyId, UniValue& tradeArray, int64_t& totalSold, int64_t& totalBought);
diff --git a/src/omnicore/dbtransaction.cpp b/src/omnicore/dbtransaction.cpp
index dfa981475dc96..5e9376ec5e367 100644
--- a/src/omnicore/dbtransaction.cpp
+++ b/src/omnicore/dbtransaction.cpp
@@ -1,17 +1,16 @@
-#include <omnicore/dbtransaction.h>
 
+#include <cstdint>
+#include <omnicore/dbtransaction.h>
 #include <omnicore/errors.h>
 #include <omnicore/log.h>
 
 #include <fs.h>
+#include <primitives/transaction.h>
 #include <uint256.h>
 #include <tinyformat.h>
 
 #include <leveldb/status.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -29,59 +28,94 @@ COmniTransactionDB::~COmniTransactionDB()
     if (msc_debug_persistence) PrintToLog("COmniTransactionDB closed\n");
 }
 
-/**
- * Retrieves the serialized transaction details from the DB. 
- */
-std::vector<std::string> COmniTransactionDB::FetchTransactionDetails(const uint256& txid)
-{
-    assert(pdb);
-    std::string strValue;
-    std::vector<std::string> vTransactionDetails;
-
-    leveldb::Status status = pdb->Get(readoptions, txid.ToString(), &strValue);
-    if (status.ok()) {
-        std::vector<std::string> vStr;
-        boost::split(vStr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (vStr.size() == 2) {
-            vTransactionDetails.push_back(vStr[0]);
-            vTransactionDetails.push_back(vStr[1]);
-        } else {
-            PrintToLog("ERROR: Entry (%s) found in OmniTXDB with unexpected number of attributes!\n", txid.GetHex());
-        }
-    } else {
-        PrintToLog("ERROR: Entry (%s) could not be loaded from OmniTXDB!\n", txid.GetHex());
+struct CTxInfoKey {
+    static constexpr uint8_t prefix = 't';
+    const uint256& txid;
+
+    SERIALIZE_METHODS(CTxInfoKey, obj) {
+        READWRITE(obj.txid);
     }
+};
 
-    return vTransactionDetails;
-}
+struct COutPointCompression {
+    FORMATTER_METHODS(COutPoint, obj) {
+        READWRITE(obj.hash);
+        READWRITE(Using<Varint>(obj.n));
+    }
+};
+
+struct TxInCompression {
+    // scriptWitness isn't serialized to save space
+    FORMATTER_METHODS(CTxIn, obj) {
+        READWRITE(Using<COutPointCompression>(obj.prevout));
+        READWRITE(Using<ScriptCompression>(obj.scriptSig));
+        READWRITE(Using<VarintInv>(obj.nSequence));
+    }
+};
+
+struct CMutableTransactionCompression {
+    FORMATTER_METHODS(CMutableTransaction, obj) {
+        READWRITE(Using<VectorFormatter<TxInCompression>>(obj.vin));
+        READWRITE(Using<VectorFormatter<TxOutCompression>>(obj.vout));
+        READWRITE(Using<VarintSigned>(obj.nVersion));
+        READWRITE(Using<Varint>(obj.nLockTime));
+    }
+};
+
+struct CTxBlockValue {
+    int blockHeight;
+    uint32_t posInBlock;
+    uint32_t processResult;
+
+    SERIALIZE_METHODS(CTxBlockValue, obj) {
+        READWRITE(Using<VarintSigned>(obj.blockHeight));
+        READWRITE(Using<Varint>(obj.posInBlock));
+        READWRITE(Using<Varint>(obj.processResult));
+    }
+};
+
+struct CTxInfoValue : CTxBlockValue {
+    CMutableTransaction tx;
+
+    SERIALIZE_METHODS(CTxInfoValue, obj) {
+        READWRITEAS(CTxBlockValue, obj);
+        READWRITE(Using<CMutableTransactionCompression>(obj.tx));
+    }
+};
 
 /**
  * Stores position in block and validation result for a transaction.
  */
-void COmniTransactionDB::RecordTransaction(const uint256& txid, uint32_t posInBlock, int processingResult)
+void COmniTransactionDB::RecordTransaction(const CTransaction& tx, int block, uint32_t posInBlock, int processingResult)
 {
-    assert(pdb);
-
-    const std::string key = txid.ToString();
-    const std::string value = strprintf("%d:%d", posInBlock, processingResult);
-
-    leveldb::Status status = pdb->Put(writeoptions, key, value);
+    // invert negative values to compressed it
+    uint32_t processResult = processingResult < 0 ? -processingResult : 0;
+    CTxInfoValue value{block, posInBlock, processResult, CMutableTransaction{tx}};
+    Write(CTxInfoKey{tx.GetHash()}, value);
     ++nWritten;
 }
 
 /**
- * Returns the position of a transaction in a block.
+ * Deletes transactions in case of rollback.
  */
-uint32_t COmniTransactionDB::FetchTransactionPosition(const uint256& txid)
+void COmniTransactionDB::DeleteTransactions(const std::set<uint256>& txs)
 {
-    uint32_t posInBlock = 999999; // setting an initial arbitrarily high value will ensure transaction is always "last" in event of bug/exploit
-
-    std::vector<std::string> vTransactionDetails = FetchTransactionDetails(txid);
-    if (vTransactionDetails.size() == 2) {
-        posInBlock = boost::lexical_cast<uint32_t>(vTransactionDetails[0]);
+    CDBWriteBatch batch;
+    CDBaseIterator it{NewIterator()};
+    for (auto& txid : txs) {
+        batch.Delete(CTxInfoKey{txid});
     }
+    WriteBatch(batch);
+}
 
-    return posInBlock;
+/**
+ * Returns the position of a transaction in a block.
+ */
+uint32_t COmniTransactionDB::FetchTransactionPosition(const uint256& txid)
+{
+    constexpr uint32_t posInBlock = 999999; // setting an initial arbitrarily high value will ensure transaction is always "last" in event of bug/exploit
+    CTxBlockValue value;
+    return Read(CTxInfoKey{txid}, value) ? value.posInBlock : posInBlock;
 }
 
 /**
@@ -90,11 +124,24 @@ uint32_t COmniTransactionDB::FetchTransactionPosition(const uint256& txid)
 std::string COmniTransactionDB::FetchInvalidReason(const uint256& txid)
 {
     int processingResult = -999999;
-
-    std::vector<std::string> vTransactionDetails = FetchTransactionDetails(txid);
-    if (vTransactionDetails.size() == 2) {
-        processingResult = boost::lexical_cast<int>(vTransactionDetails[1]);
+    CTxBlockValue value;
+    if (Read(CTxInfoKey{txid}, value) && value.processResult) {
+        processingResult = -int(value.processResult);
     }
-
     return error_str(processingResult);
 }
+
+/**
+ *Returns transaction, block and blockTime.
+ */
+bool COmniTransactionDB::GetTransaction(const uint256& txid, CTransactionRef& tx, int& blockHeight)
+{
+    CTxInfoValue value;
+    if (!Read(CTxInfoKey{txid}, value)) {
+        return false;
+    }
+    blockHeight = value.blockHeight;
+    tx = MakeTransactionRef(std::move(value.tx));
+    assert(txid == tx->GetHash());
+    return true;
+}
diff --git a/src/omnicore/dbtransaction.h b/src/omnicore/dbtransaction.h
index 85e61e550a20d..d3a34ea32c3e3 100644
--- a/src/omnicore/dbtransaction.h
+++ b/src/omnicore/dbtransaction.h
@@ -4,6 +4,7 @@
 #include <omnicore/dbbase.h>
 
 #include <fs.h>
+#include <primitives/transaction.h>
 #include <uint256.h>
 
 #include <stdint.h>
@@ -19,8 +20,11 @@ class COmniTransactionDB : public CDBBase
     COmniTransactionDB(const fs::path& path, bool fWipe);
     virtual ~COmniTransactionDB();
 
-    /** Stores position in block and validation result for a transaction. */
-    void RecordTransaction(const uint256& txid, uint32_t posInBlock, int processingResult);
+    /** Stores block height, position in block, block time and validation result for a transaction. */
+    void RecordTransaction(const CTransaction& tx, int block, uint32_t posInBlock, int processingResult);
+
+    /** Deletes transactions in case of rollback. */
+    void DeleteTransactions(const std::set<uint256>& txs);
 
     /** Returns the position of a transaction in a block. */
     uint32_t FetchTransactionPosition(const uint256& txid);
@@ -28,9 +32,8 @@ class COmniTransactionDB : public CDBBase
     /** Returns the reason why a transaction is invalid. */
     std::string FetchInvalidReason(const uint256& txid);
 
-private:
-    /** Retrieves the serialized transaction details from the DB. */
-    std::vector<std::string> FetchTransactionDetails(const uint256& txid);
+    /** Returns transaction, block and blockTime. */
+    bool GetTransaction(const uint256& txid, CTransactionRef& tx, int& block);
 };
 
 namespace mastercore
diff --git a/src/omnicore/dbtxlist.cpp b/src/omnicore/dbtxlist.cpp
index e8e658fc0ae80..78a50ce18fb57 100644
--- a/src/omnicore/dbtxlist.cpp
+++ b/src/omnicore/dbtxlist.cpp
@@ -1,8 +1,8 @@
 
+#include <cstdint>
 #include <omnicore/activation.h>
 #include <omnicore/convert.h>
 #include <omnicore/dbtxlist.h>
-#include <omnicore/dbtransaction.h>
 #include <omnicore/dex.h>
 #include <omnicore/log.h>
 #include <omnicore/notifications.h>
@@ -24,27 +24,15 @@
 #include <leveldb/slice.h>
 #include <leveldb/status.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
-using mastercore::atoi;
-using mastercore::AddAlert;
-using mastercore::CheckAlertAuthorization;
-using mastercore::CheckExpiredAlerts;
-using mastercore::CheckLiveActivations;
-using mastercore::DeleteAlerts;
-using mastercore::GetBlockIndex;
-using mastercore::isNonMainNet;
-using mastercore::pDbTransaction;
-
 CMPTxList::CMPTxList(const fs::path& path, bool fWipe)
 {
     leveldb::Status status = Open(path, fWipe);
@@ -56,167 +44,210 @@ CMPTxList::~CMPTxList()
     if (msc_debug_persistence) PrintToLog("CMPTxList closed\n");
 }
 
+struct CBlockTxKey {
+    static constexpr uint8_t prefix = 'b';
+    uint32_t block = ~0u;
+    uint256 txid;
+
+    SERIALIZE_METHODS(CBlockTxKey, obj) {
+        READWRITE(Using<BigEndian32Inv>(obj.block));
+        READWRITE(obj.txid);
+    }
+};
+
+struct CMPTxList::CTxKey {
+    static constexpr uint8_t prefix = 't';
+    uint256 txid;
+    int block = 0;
+    uint8_t valid = 0;
+    uint32_t type = 0;
+
+    SERIALIZE_METHODS(CTxKey, obj) {
+        READWRITE(obj.txid);
+        READWRITE(Using<VarintSigned>(obj.block));
+        READWRITE(obj.valid);
+        READWRITE(Using<Varint>(obj.type));
+    }
+
+    bool operator==(const CTxKey& other) const {
+        return txid == other.txid
+            && block == other.block
+            && valid == other.valid
+            && type == other.type;
+    }
+
+    bool operator!=(const CTxKey& other) const {
+        return !(*this == other);
+    }
+};
+
 void CMPTxList::recordTX(const uint256 &txid, bool fValid, int nBlock, unsigned int type, uint64_t nValue)
 {
-    if (!pdb) return;
-
     // overwrite detection, we should never be overwriting a tx, as that means we have redone something a second time
     // reorgs delete all txs from levelDB above reorg_chain_height
-    if (exists(txid)) PrintToLog("LEVELDB TX OVERWRITE DETECTION - %s\n", txid.ToString());
-
-    const std::string key = txid.ToString();
-    const std::string value = strprintf("%u:%d:%u:%lu", fValid ? 1 : 0, nBlock, type, nValue);
-    leveldb::Status status;
+    int64_t old_value;
+    CTxKey old_key, key{txid, nBlock, fValid, type};
+    if (getTX(txid, old_key, old_value) && (old_key == key && old_value == nValue)) {
+        PrintToLog("LEVELDB TX OVERWRITE DETECTION - %s\n", txid.ToString());
+    }
 
     PrintToLog("%s(%s, valid=%s, block= %d, type= %d, value= %lu)\n",
             __func__, txid.ToString(), fValid ? "YES" : "NO", nBlock, type, nValue);
 
-    status = pdb->Put(writeoptions, key, value);
+    Write(CBlockTxKey{uint32_t(nBlock), txid}, "");
+    Write(key, nValue);
     ++nWritten;
 }
 
-void CMPTxList::recordPaymentTX(const uint256& txid, bool fValid, int nBlock, unsigned int vout, unsigned int propertyId, uint64_t nValue, std::string buyer, std::string seller)
+struct CPaymentTxKey {
+    static constexpr uint8_t prefix = 'p';
+    uint256 txid;
+    uint32_t payments = ~0u;
+    int block = 0;
+    uint8_t valid = 0;
+
+    SERIALIZE_METHODS(CPaymentTxKey, obj) {
+        READWRITE(obj.txid);
+        READWRITE(Using<BigEndian32Inv>(obj.payments));
+        READWRITE(Using<VarintSigned>(obj.block));
+        READWRITE(obj.valid);
+    }
+};
+
+struct CPaymentTxValue {
+    uint32_t vout;
+    std::string buyer;
+    std::string seller;
+    uint32_t propertyId;
+    uint64_t amount;
+
+    SERIALIZE_METHODS(CPaymentTxValue, obj) {
+        READWRITE(Using<Varint>(obj.vout));
+        READWRITE(obj.buyer);
+        READWRITE(obj.seller);
+        READWRITE(Using<Varint>(obj.propertyId));
+        READWRITE(obj.amount);
+    }
+};
+
+void CMPTxList::recordPaymentTX(const uint256& txid, bool fValid, int nBlock, unsigned int vout, unsigned int propertyId, uint64_t nValue, const std::string& buyer, const std::string& seller)
 {
-    if (!pdb) return;
-
     // Prep - setup vars
-    unsigned int type = 99999999;
-    uint64_t numberOfPayments = 1;
-    unsigned int paymentNumber = 1;
-    uint64_t existingNumberOfPayments = 0;
-
-    // Step 1 - Check TXList to see if this payment TXID exists
-    bool paymentEntryExists = exists(txid);
-
-    // Step 2a - If doesn't exist leave number of payments & paymentNumber set to 1
-    // Step 2b - If does exist add +1 to existing number of payments and set this paymentNumber as new numberOfPayments
-    if (paymentEntryExists) {
-        //retrieve old numberOfPayments
-        std::vector<std::string> vstr;
-        std::string strValue;
-        leveldb::Status status = pdb->Get(readoptions, txid.ToString(), &strValue);
-        if (status.ok()) {
-            // parse the string returned
-            boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-
-            // obtain the existing number of payments
-            if (4 <= vstr.size()) {
-                existingNumberOfPayments = atoi(vstr[3]);
-                paymentNumber = existingNumberOfPayments + 1;
-                numberOfPayments = existingNumberOfPayments + 1;
-            }
-        }
+    uint32_t numberOfPayments = 1;
+
+    // Step 1 - Check TXList to see if this cancel TXID exists
+    // Step 2a - If doesn't exist leave number of affected txs & ref set to 1
+    // Step 2b - If does exist add +1 to existing ref and set this ref as new number of affected
+    CDBaseIterator it{NewIterator(), PartialKey<CPaymentTxKey>(txid)};
+    if (it.Valid()) {
+        numberOfPayments = it.Key<CPaymentTxKey>().payments + 1;
     }
 
     // Step 3 - Create new/update master record for payment tx in TXList
-    const std::string key = txid.ToString();
-    const std::string value = strprintf("%u:%d:%u:%lu", fValid ? 1 : 0, nBlock, type, numberOfPayments);
-    leveldb::Status status;
-    PrintToLog("DEXPAYDEBUG : Writing master record %s(%s, valid=%s, block= %d, type= %d, number of payments= %lu)\n", __func__, txid.ToString(), fValid ? "YES" : "NO", nBlock, type, numberOfPayments);
-    status = pdb->Put(writeoptions, key, value);
+    Write(CBlockTxKey{uint32_t(nBlock), txid}, "");
+    PrintToLog("DEXPAYDEBUG : Writing master record %s(%s, valid=%s, block= %d, number of payments= %d)\n", __func__, txid.ToString(), fValid ? "YES" : "NO", nBlock, numberOfPayments);
 
     // Step 4 - Write sub-record with payment details
-    const std::string txidStr = txid.ToString();
-    const std::string subKey = STR_PAYMENT_SUBKEY_TXID_PAYMENT_COMBO(txidStr, paymentNumber);
-    const std::string subValue = strprintf("%d:%s:%s:%d:%lu", vout, buyer, seller, propertyId, nValue);
-    leveldb::Status subStatus;
-    PrintToLog("DEXPAYDEBUG : Writing sub-record %s with value %s\n", subKey, subValue);
-    subStatus = pdb->Put(writeoptions, subKey, subValue);
+    CPaymentTxKey key{txid, numberOfPayments, nBlock, fValid};
+    CPaymentTxValue value{vout, buyer, seller, propertyId, nValue};
+    Write(key, value);
+    PrintToLog("DEXPAYDEBUG : Writing sub-record %s-%d with value %d:%s:%s:%d:%d\n", txid.ToString(), numberOfPayments, vout, buyer, seller, propertyId, nValue);
 }
 
-void CMPTxList::recordMetaDExCancelTX(const uint256& txidMaster, const uint256& txidSub, bool fValid, int nBlock, unsigned int propertyId, uint64_t nValue)
-{
-    if (!pdb) return;
+struct CDexCancelTxKey {
+    static constexpr uint8_t prefix = 'c';
+    uint256 txid;
+    uint32_t affected = ~0u;
+    int block = 0;
+    uint8_t valid = 0;
+
+    SERIALIZE_METHODS(CDexCancelTxKey, obj) {
+        READWRITE(obj.txid);
+        READWRITE(Using<BigEndian32Inv>(obj.affected));
+        READWRITE(Using<VarintSigned>(obj.block));
+        READWRITE(obj.valid);
+    }
+};
 
+struct CDexCancelTxValue {
+    uint32_t propertyId;
+    uint64_t amount;
+
+    SERIALIZE_METHODS(CDexCancelTxValue, obj) {
+        READWRITE(Using<Varint>(obj.propertyId));
+        READWRITE(obj.amount);
+    }
+};
+
+struct CDexTxToCancelKey {
+    static constexpr uint8_t prefix = 'e';
+    const uint256& txid;
+
+    SERIALIZE_METHODS(CDexTxToCancelKey, obj) {
+        READWRITE(obj.txid);
+    }
+};
+
+void CMPTxList::recordMetaDExCancelTX(const uint256& txid, const uint256& txidSub, bool fValid, int nBlock, unsigned int propertyId, uint64_t nValue)
+{
     // Prep - setup vars
-    unsigned int type = 99992104;
-    unsigned int refNumber = 1;
-    uint64_t existingAffectedTXCount = 0;
-    std::string txidMasterStr = txidMaster.ToString() + "-C";
+    uint32_t numerOfAffected = 1;
 
     // Step 1 - Check TXList to see if this cancel TXID exists
     // Step 2a - If doesn't exist leave number of affected txs & ref set to 1
     // Step 2b - If does exist add +1 to existing ref and set this ref as new number of affected
-    std::vector<std::string> vstr;
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, txidMasterStr, &strValue);
-    if (status.ok()) {
-        // parse the string returned
-        boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-
-        // obtain the existing affected tx count
-        if (4 <= vstr.size()) {
-            existingAffectedTXCount = atoi(vstr[3]);
-            refNumber = existingAffectedTXCount + 1;
-        }
+    CDBaseIterator it{NewIterator(), PartialKey<CDexCancelTxKey>(txid)};
+    if (it.Valid()) {
+        numerOfAffected = it.Key<CDexCancelTxKey>().affected + 1;
     }
 
     // Step 3 - Create new/update master record for cancel tx in TXList
-    const std::string& key = txidMasterStr;
-    const std::string value = strprintf("%u:%d:%u:%lu", fValid ? 1 : 0, nBlock, type, refNumber);
-    PrintToLog("METADEXCANCELDEBUG : Writing master record %s(%s, valid=%s, block= %d, type= %d, number of affected transactions= %d)\n", __func__, txidMaster.ToString(), fValid ? "YES" : "NO", nBlock, type, refNumber);
-    status = pdb->Put(writeoptions, key, value);
+    Write(CBlockTxKey{uint32_t(nBlock), txid}, "");
+    PrintToLog("METADEXCANCELDEBUG : Writing master record %s(%s, valid=%s, block= %d, number of affected transactions= %d)\n", __func__, txid.ToString(), fValid ? "YES" : "NO", nBlock, numerOfAffected);
 
+    Write(CDexTxToCancelKey{txidSub}, txid);
     // Step 4 - Write sub-record with cancel details
-    const std::string txidStr = txidMaster.ToString() + "-C";
-    const std::string subKey = STR_REF_SUBKEY_TXID_REF_COMBO(txidStr, refNumber);
-    const std::string subValue = strprintf("%s:%d:%lu", txidSub.ToString(), propertyId, nValue);
-    PrintToLog("METADEXCANCELDEBUG : Writing sub-record %s with value %s\n", subKey, subValue);
-    status = pdb->Put(writeoptions, subKey, subValue);
-    if (msc_debug_txdb) PrintToLog("%s(): store: %s=%s, status: %s\n", __func__, subKey, subValue, status.ToString());
+    CDexCancelTxValue value{propertyId, nValue};
+    Write(CDexCancelTxKey{txid, numerOfAffected, nBlock, fValid}, value);
+    PrintToLog("METADEXCANCELDEBUG : Writing sub-record %d-%d with value %s:%d:%d\n", txid.ToString(), numerOfAffected, txidSub.ToString(), propertyId, nValue);
 }
 
+struct CSendAllTxKey {
+    static constexpr uint8_t prefix = 's';
+    uint256 txid;
+    uint32_t num = ~0u;
+
+    SERIALIZE_METHODS(CSendAllTxKey, obj) {
+        READWRITE(obj.txid);
+        READWRITE(Using<BigEndian32Inv>(obj.num));
+    }
+};
+
+struct CSendAllTxValue {
+    uint32_t propertyId;
+    int64_t amount;
+
+    SERIALIZE_METHODS(CSendAllTxValue, obj) {
+        READWRITE(Using<Varint>(obj.propertyId));
+        READWRITE(obj.amount);
+    }
+};
 
 /**
  * Records a "send all" sub record.
  */
-void CMPTxList::recordSendAllSubRecord(const uint256& txid, int subRecordNumber, uint32_t propertyId, int64_t nValue)
+void CMPTxList::recordSendAllSubRecord(const uint256& txid, int nBlock, int subRecordNumber, uint32_t propertyId, int64_t nValue)
 {
-    std::string strKey = strprintf("%s-%d", txid.ToString(), subRecordNumber);
-    std::string strValue = strprintf("%d:%d", propertyId, nValue);
-
-    leveldb::Status status = pdb->Put(writeoptions, strKey, strValue);
+    bool status = Write(CSendAllTxKey{txid, uint32_t(subRecordNumber)}, CSendAllTxValue{propertyId, nValue});
+    Write(CBlockTxKey{uint32_t(nBlock), txid}, "");
     ++nWritten;
-    if (msc_debug_txdb) PrintToLog("%s(): store: %s=%s, status: %s\n", __func__, strKey, strValue, status.ToString());
-}
-
-
-std::string CMPTxList::getKeyValue(std::string key)
-{
-    if (!pdb) return "";
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, key, &strValue);
-    if (status.ok()) {
-        return strValue;
-    } else {
-        return "";
-    }
+    if (msc_debug_txdb) PrintToLog("%s(): store: %s:%d=%d:%d, status: %s\n", __func__, txid.ToString(), subRecordNumber, propertyId, nValue, status ? "OK" : "NOK");
 }
 
-uint256 CMPTxList::findMetaDExCancel(const uint256 txid)
+uint256 CMPTxList::findMetaDExCancel(const uint256& txid)
 {
-    std::vector<std::string> vstr;
-    std::string txidStr = txid.ToString();
-    leveldb::Slice skey, svalue;
-    uint256 cancelTxid;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        svalue = it->value();
-        std::string svalueStr = svalue.ToString();
-        boost::split(vstr, svalueStr, boost::is_any_of(":"), boost::token_compress_on);
-        // obtain the existing affected tx count
-        if (3 <= vstr.size()) {
-            if (vstr[0] == txidStr) {
-                delete it;
-                cancelTxid.SetHex(skey.ToString());
-                return cancelTxid;
-            }
-        }
-    }
-
-    delete it;
-    return uint256();
+    uint256 cancelTxId;
+    return Read(CDexTxToCancelKey{txid}, cancelTxId) ? cancelTxId : uint256{};
 }
 
 /**
@@ -224,57 +255,44 @@ uint256 CMPTxList::findMetaDExCancel(const uint256 txid)
  */
 int CMPTxList::getNumberOfSubRecords(const uint256& txid)
 {
-    int numberOfSubRecords = 0;
-
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, txid.ToString(), &strValue);
-    if (status.ok()) {
-        std::vector<std::string> vstr;
-        boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 <= vstr.size()) {
-            numberOfSubRecords = boost::lexical_cast<int>(vstr[3]);
-        }
-    }
+    CDBaseIterator it{NewIterator(), PartialKey<CPaymentTxKey>(txid)};
+    if (it.Valid()) return it.Key<CPaymentTxKey>().payments;
+    it.Seek(PartialKey<CSendAllTxKey>(txid));
+    return it.Valid() ? it.Key<CSendAllTxKey>().num : 0;
+}
 
-    return numberOfSubRecords;
+int CMPTxList::getNumberOfMetaDExCancels(const uint256& txid)
+{
+    CDBaseIterator it{NewIterator(), PartialKey<CDexCancelTxKey>(txid)};
+    return it.ValueOr<uint32_t>(0);
 }
 
-int CMPTxList::getNumberOfMetaDExCancels(const uint256 txid)
+bool CMPTxList::getPurchaseDetails(const uint256& txid, int purchaseNumber, std::string* buyer, std::string* seller, uint64_t* vout, uint64_t* propertyId, uint64_t* nValue)
 {
-    if (!pdb) return 0;
-    int numberOfCancels = 0;
-    std::vector<std::string> vstr;
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, txid.ToString() + "-C", &strValue);
-    if (status.ok()) {
-        // parse the string returned
-        boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        // obtain the number of cancels
-        if (4 <= vstr.size()) {
-            numberOfCancels = atoi(vstr[3]);
-        }
+    CDBaseIterator it{NewIterator(), PartialKey<CPaymentTxKey>(txid)};
+    for (; it; ++it) {
+        if (it.Key<CPaymentTxKey>().payments != purchaseNumber) continue;
+        auto value = it.Value<CPaymentTxValue>();
+        *vout = value.vout;
+        *buyer = value.buyer;
+        *seller = value.seller;
+        *propertyId = value.propertyId;
+        *nValue = value.amount;
+        return true;
     }
-    return numberOfCancels;
+    return false;
 }
 
-bool CMPTxList::getPurchaseDetails(const uint256 txid, int purchaseNumber, std::string* buyer, std::string* seller, uint64_t* vout, uint64_t* propertyId, uint64_t* nValue)
+/**
+ * Retrieves details about a "metadex cancel" record.
+ */
+bool CMPTxList::getMetaDExCancelDetails(const uint256& txid, int subSend, uint32_t& propertyId, int64_t& amount)
 {
-    if (!pdb) return 0;
-    std::vector<std::string> vstr;
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, txid.ToString() + "-" + std::to_string(purchaseNumber), &strValue);
-    if (status.ok()) {
-        // parse the string returned
-        boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        // obtain the requisite details
-        if (5 == vstr.size()) {
-            *vout = atoi(vstr[0]);
-            *buyer = vstr[1];
-            *seller = vstr[2];
-            *propertyId = boost::lexical_cast<uint64_t>(vstr[3]);
-            *nValue = boost::lexical_cast<boost::uint64_t>(vstr[4]);
-            return true;
-        }
+    CDexCancelTxValue value;
+    if (Read(CDexCancelTxKey{txid, uint32_t(subSend)}, value)) {
+        propertyId = value.propertyId;
+        amount = value.amount;
+        return true;
     }
     return false;
 }
@@ -284,17 +302,11 @@ bool CMPTxList::getPurchaseDetails(const uint256 txid, int purchaseNumber, std::
  */
 bool CMPTxList::getSendAllDetails(const uint256& txid, int subSend, uint32_t& propertyId, int64_t& amount)
 {
-    std::string strKey = strprintf("%s-%d", txid.ToString(), subSend);
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, strKey, &strValue);
-    if (status.ok()) {
-        std::vector<std::string> vstr;
-        boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (2 == vstr.size()) {
-            propertyId = boost::lexical_cast<uint32_t>(vstr[0]);
-            amount = boost::lexical_cast<int64_t>(vstr[1]);
-            return true;
-        }
+    CSendAllTxValue value;
+    if (Read(CSendAllTxKey{txid, uint32_t(subSend)}, value)) {
+        propertyId = value.propertyId;
+        amount = value.amount;
+        return true;
     }
     return false;
 }
@@ -302,69 +314,48 @@ bool CMPTxList::getSendAllDetails(const uint256& txid, int subSend, uint32_t& pr
 int CMPTxList::getMPTransactionCountTotal()
 {
     int count = 0;
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        if (skey.ToString().length() == 64) {
-            ++count;
-        } //extra entries for cancels and purchases are more than 64 chars long
+    for (CDBaseIterator it{NewIterator()}; it; ++it) {
+        switch(it.Key()[0]) {
+            case CTxKey::prefix:
+            case CPaymentTxKey::prefix:
+            case CDexCancelTxKey::prefix:
+            case CSendAllTxKey::prefix:
+                ++count;
+            break;
+        }
     }
-    delete it;
     return count;
 }
 
 int CMPTxList::getMPTransactionCountBlock(int block)
 {
     int count = 0;
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        svalue = it->value();
-        if (skey.ToString().length() == 64) {
-            std::string strValue = svalue.ToString();
-            std::vector<std::string> vstr;
-            boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-            if (4 == vstr.size()) {
-                if (atoi(vstr[1]) == block) {
-                    ++count;
-                }
-            }
-        }
+    CDBaseIterator it{NewIterator(), CBlockTxKey{uint32_t(block)}};
+    for (; it; ++it) {
+        auto key = it.Key<CBlockTxKey>();
+        if (key.block != block) break;
+        ++count;
     }
-    delete it;
     return count;
 }
 
 /** Returns a list of all Omni transactions in the given block range. */
 int CMPTxList::GetOmniTxsInBlockRange(int blockFirst, int blockLast, std::set<uint256>& retTxs)
 {
-    int count = 0;
-    leveldb::Iterator* it = NewIterator();
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        const leveldb::Slice& sKey = it->key();
-        const leveldb::Slice& sValue = it->value();
-
-        if (sKey.ToString().length() == 64) {
-            const std::string& strValue = sValue.ToString();
-            std::vector<std::string> vStr;
-            boost::split(vStr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-            if (4 == vStr.size()) {
-                int blockCurrent = atoi(vStr[1]);
-                if (blockCurrent >= blockFirst && blockCurrent <= blockLast) {
-                    retTxs.insert(uint256S(sKey.ToString()));
-                    ++count;
-                }
-            }
-        }
+    CDBaseIterator it{NewIterator(), CBlockTxKey{uint32_t(blockLast)}};
+    for (; it; ++it) {
+        auto key = it.Key<CBlockTxKey>();
+        if (key.block < blockFirst) break;
+        retTxs.insert(key.txid);
     }
-
-    delete it;
-    return count;
+    return retTxs.size();
 }
 
+struct CDBVersionKey {
+    static constexpr uint8_t prefix = 'D';
+    SERIALIZE_METHODS(CDBVersionKey, obj) {}
+};
+
 /*
  * Gets the DB version from txlistdb
  *
@@ -372,17 +363,10 @@ int CMPTxList::GetOmniTxsInBlockRange(int blockFirst, int blockLast, std::set<ui
  */
 int CMPTxList::getDBVersion()
 {
-    std::string strValue;
-    int verDB = 0;
-
-    leveldb::Status status = pdb->Get(readoptions, "dbversion", &strValue);
-    if (status.ok()) {
-        verDB = boost::lexical_cast<uint64_t>(strValue);
-    }
-
-    if (msc_debug_txdb) PrintToLog("%s(): dbversion %s status %s, line %d, file: %s\n", __func__, strValue, status.ToString(), __LINE__, __FILE__);
-
-    return verDB;
+    uint8_t version;
+    bool status = Read(CDBVersionKey{}, version);
+    if (msc_debug_txdb) PrintToLog("%s(): dbversion %d status %s\n", __func__, version, status ? "OK" : "NOK");
+    return status ? version : 0;
 }
 
 /*
@@ -392,64 +376,45 @@ int CMPTxList::getDBVersion()
  */
 int CMPTxList::setDBVersion()
 {
-    std::string verStr = boost::lexical_cast<std::string>(DB_VERSION);
-    leveldb::Status status = pdb->Put(writeoptions, "dbversion", verStr);
-
-    if (msc_debug_txdb) PrintToLog("%s(): dbversion %s status %s, line %d, file: %s\n", __func__, verStr, status.ToString(), __LINE__, __FILE__);
-
+    bool status = Write(CDBVersionKey{}, uint8_t(DB_VERSION));
+    if (msc_debug_txdb) PrintToLog("%s(): dbversion %d status %s\n", __func__, DB_VERSION, status ? "OK" : "NOK");
     return getDBVersion();
 }
 
+struct CNonFugibleKey {
+    static constexpr uint8_t prefix = 'n';
+    uint256 txid;
+
+    SERIALIZE_METHODS(CNonFugibleKey, obj) {
+        READWRITE(obj.txid);
+    }
+};
+
 std::pair<int64_t,int64_t> CMPTxList::GetNonFungibleGrant(const uint256& txid)
 {
-    std::string strKey = strprintf("%s-UG", txid.ToString());
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, strKey, &strValue);
-    if (status.ok()) {
-        std::vector<std::string> vstr;
-        boost::split(vstr, strValue, boost::is_any_of("-"), boost::token_compress_on);
-        if (2 == vstr.size()) {
-            return std::make_pair(boost::lexical_cast<int64_t>(vstr[0]), boost::lexical_cast<int64_t>(vstr[1]));
-        }
-    }
-    return std::make_pair(0,0);
+    std::pair<int64_t, int64_t> value;
+    return Read(CNonFugibleKey{txid}, value) ? value : std::pair<int64_t, int64_t>{0, 0};
 }
 
 void CMPTxList::RecordNonFungibleGrant(const uint256& txid, int64_t start, int64_t end)
 {
-    assert(pdb);
-
-    const std::string key = txid.ToString() + "-UG";
-    const std::string value = strprintf("%d-%d", start, end);
-
-    leveldb::Status status = pdb->Put(writeoptions, key, value);
-    PrintToLog("%s(): Writing Non-Fungible Grant range %s:%d-%d (%s), line %d, file: %s\n", __FUNCTION__, key, start, end, status.ToString(), __LINE__, __FILE__);
+    bool status = Write(CNonFugibleKey{txid}, std::make_pair(start, end));
+    PrintToLog("%s(): Writing Non-Fungible Grant range %s:%d-%d (%s)\n", __FUNCTION__, txid.ToString(), start, end, status ? "OK" : "NOK");
 }
 
-bool CMPTxList::exists(const uint256 &txid)
+bool CMPTxList::getTX(const uint256& txid, CTxKey& key, int64_t& value)
 {
-    if (!pdb) return false;
-
-    std::string strValue;
-    leveldb::Status status = pdb->Get(readoptions, txid.ToString(), &strValue);
-
-    if (!status.ok()) {
-        if (status.IsNotFound()) return false;
-    }
-
-    return true;
+    CDBaseIterator it{NewIterator(), PartialKey<CTxKey>(txid)};
+    bool status = it.Valid() && it.Key(key) && it.Value(value);
+    ++nRead;
+    return status;
 }
 
-bool CMPTxList::getTX(const uint256 &txid, std::string& value)
+bool CMPTxList::existsMPTX(const uint256& txid)
 {
-    leveldb::Status status = pdb->Get(readoptions, txid.ToString(), &value);
-    ++nRead;
-
-    if (status.ok()) {
-        return true;
-    }
-
-    return false;
+    CDBaseIterator it{NewIterator()};
+    return (it.Seek(PartialKey<CTxKey>(txid)), it)
+        || (it.Seek(PartialKey<CPaymentTxKey>(txid)), it);
 }
 
 // call it like so (variable # of parameters):
@@ -461,318 +426,67 @@ bool CMPTxList::getTX(const uint256 &txid, std::string& value)
 //
 bool CMPTxList::getValidMPTX(const uint256& txid, int* block, unsigned int* type, uint64_t* nAmended)
 {
-    std::string result;
-    int validity = 0;
-
     if (msc_debug_txdb) PrintToLog("%s()\n", __func__);
 
-    if (!pdb) return false;
-
-    if (!getTX(txid, result)) return false;
-
-    // parse the string returned, find the validity flag/bit & other parameters
-    std::vector<std::string> vstr;
-    boost::split(vstr, result, boost::is_any_of(":"), boost::token_compress_on);
-
-    if (msc_debug_txdb) PrintToLog("%s() size=%lu : %s\n", __func__, vstr.size(), result);
-
-    if (1 <= vstr.size()) validity = atoi(vstr[0]);
-
-    if (block) {
-        if (2 <= vstr.size()) *block = atoi(vstr[1]);
-        else *block = 0;
-    }
-
-    if (type) {
-        if (3 <= vstr.size()) *type = atoi(vstr[2]);
-        else *type = 0;
-    }
-
-    if (nAmended) {
-        if (4 <= vstr.size()) *nAmended = boost::lexical_cast<boost::uint64_t>(vstr[3]);
-        else *nAmended = 0;
+    CTxKey key;
+    int64_t value = 0;
+    bool validity = false;
+    if (getTX(txid, key, value)) {
+        // parse the string returned, find the validity flag/bit & other parameters
+        validity = key.valid > 0;
+        block && (*block = key.block);
+        type && (*type = key.type);
+        nAmended && (*nAmended = value);
+    } else {
+        CPaymentTxKey key;
+        CDBaseIterator it{NewIterator(), PartialKey<CPaymentTxKey>(txid)};
+        if (it.Valid() && it.Key(key) && it.Value(value)) {
+            validity = key.valid > 0;
+            block && (*block = key.block);
+            type && (*type = 0);
+            nAmended && (*nAmended = value);
+        }
     }
-
     if (msc_debug_txdb) printStats();
-
-    if ((int) 0 == validity) return false;
-
-    return true;
+    return validity;
 }
 
 std::set<int> CMPTxList::GetSeedBlocks(int startHeight, int endHeight)
 {
     std::set<int> setSeedBlocks;
-
-    if (!pdb) return setSeedBlocks;
-
-    leveldb::Iterator* it = NewIterator();
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string itData = it->value().ToString();
-        std::vector<std::string> vstr;
-        boost::split(vstr, itData, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 != vstr.size()) continue; // unexpected number of tokens
-        int block = atoi(vstr[1]);
-        if (block >= startHeight && block <= endHeight) {
-            setSeedBlocks.insert(block);
-        }
+    CDBaseIterator it{NewIterator(), CBlockTxKey{uint32_t(endHeight)}};
+    for (; it; ++it) {
+        auto key = it.Key<CBlockTxKey>();
+        if (key.block < startHeight) break;
+        setSeedBlocks.insert(key.block);
     }
-
-    delete it;
-
     return setSeedBlocks;
 }
 
-void CMPTxList::LoadAlerts(int blockHeight)
+std::map<uint256, int> CMPTxList::LoadValidTxs(int blockHeight, const std::set<int>& txtypes)
 {
-    if (!pdb) return;
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-
-    std::vector<std::pair<int64_t, uint256> > loadOrder;
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string itData = it->value().ToString();
-        std::vector<std::string> vstr;
-        boost::split(vstr, itData, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 != vstr.size()) continue; // unexpected number of tokens
-        if (atoi(vstr[2]) != OMNICORE_MESSAGE_TYPE_ALERT || atoi(vstr[0]) != 1) continue; // not a valid alert
-        uint256 txid = uint256S(it->key().ToString());
-        loadOrder.push_back(std::make_pair(atoi(vstr[1]), txid));
-    }
-
-    std::sort(loadOrder.begin(), loadOrder.end());
-
-    for (std::vector<std::pair<int64_t, uint256> >::iterator it = loadOrder.begin(); it != loadOrder.end(); ++it) {
-        uint256 txid = (*it).second;
-        uint256 blockHash;
-        CTransactionRef wtx;
-        CMPTransaction mp_obj;
-        if (!GetTransaction(txid, wtx, Params().GetConsensus(), blockHash)) {
-            PrintToLog("ERROR: While loading alert %s: tx in levelDB but does not exist.\n", txid.GetHex());
-            continue;
-        }
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        int currentBlockHeight = pBlockIndex->nHeight;
-        if (currentBlockHeight > blockHeight) {
-            // skipping, because it's in the future
-            continue;
-        }
-        if (0 != ParseTransaction(*wtx, blockHeight, 0, mp_obj)) {
-            PrintToLog("ERROR: While loading alert %s: failed ParseTransaction.\n", txid.GetHex());
-            continue;
-        }
-        if (!mp_obj.interpret_Transaction()) {
-            PrintToLog("ERROR: While loading alert %s: failed interpret_Transaction.\n", txid.GetHex());
-            continue;
-        }
-        if (OMNICORE_MESSAGE_TYPE_ALERT != mp_obj.getType()) {
-            PrintToLog("ERROR: While loading alert %s: levelDB type mismatch, not an alert.\n", txid.GetHex());
-            continue;
-        }
-        if (!CheckAlertAuthorization(mp_obj.getSender())) {
-            PrintToLog("ERROR: While loading alert %s: sender is not authorized to send alerts.\n", txid.GetHex());
-            continue;
-        }
-
-        if (mp_obj.getAlertType() == 65535) { // set alert type to FFFF to clear previously sent alerts
-            DeleteAlerts(mp_obj.getSender());
-        } else {
-            AddAlert(mp_obj.getSender(), mp_obj.getAlertType(), mp_obj.getAlertExpiry(), mp_obj.getAlertMessage());
-        }
-    }
-
-    delete it;
-    int64_t blockTime = 0;
-    {
-        LOCK(cs_main);
-        CBlockIndex* pBlockIndex = ::ChainActive()[blockHeight - 1];
-        if (pBlockIndex != nullptr) {
-            blockTime = pBlockIndex->GetBlockTime();
-        }
-    }
-    if (blockTime > 0) {
-        CheckExpiredAlerts(blockHeight, blockTime);
-    }
-}
-
-void CMPTxList::LoadActivations(int blockHeight)
-{
-    if (!pdb) return;
-
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
-
-    PrintToLog("Loading feature activations from levelDB\n");
-
-    std::vector<std::pair<int64_t, uint256> > loadOrder;
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string itData = it->value().ToString();
-        std::vector<std::string> vstr;
-        boost::split(vstr, itData, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 != vstr.size()) continue; // unexpected number of tokens
-        if (atoi(vstr[2]) != OMNICORE_MESSAGE_TYPE_ACTIVATION || atoi(vstr[0]) != 1) continue; // we only care about valid activations
-        uint256 txid = uint256S(it->key().ToString());
-        loadOrder.push_back(std::make_pair(atoi(vstr[1]), txid));
-    }
-
-    std::sort(loadOrder.begin(), loadOrder.end());
-
-    for (std::vector<std::pair<int64_t, uint256> >::iterator it = loadOrder.begin(); it != loadOrder.end(); ++it) {
-        uint256 hash = (*it).second;
-        uint256 blockHash;
-        CTransactionRef wtx;
-        CMPTransaction mp_obj;
-
-        if (!GetTransaction(hash, wtx, Params().GetConsensus(), blockHash)) {
-            PrintToLog("ERROR: While loading activation transaction %s: tx in levelDB but does not exist.\n", hash.GetHex());
-            continue;
-        }
-        if (blockHash.IsNull() || (nullptr == GetBlockIndex(blockHash))) {
-            PrintToLog("ERROR: While loading activation transaction %s: failed to retrieve block hash.\n", hash.GetHex());
-            continue;
-        }
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        if (nullptr == pBlockIndex) {
-            PrintToLog("ERROR: While loading activation transaction %s: failed to retrieve block index.\n", hash.GetHex());
-            continue;
-        }
-        int currentBlockHeight = pBlockIndex->nHeight;
-        if (currentBlockHeight > blockHeight) {
-            // skipping, because it's in the future
-            continue;
-        }
-        if (0 != ParseTransaction(*wtx, currentBlockHeight, 0, mp_obj)) {
-            PrintToLog("ERROR: While loading activation transaction %s: failed ParseTransaction.\n", hash.GetHex());
-            continue;
-        }
-        if (!mp_obj.interpret_Transaction()) {
-            PrintToLog("ERROR: While loading activation transaction %s: failed interpret_Transaction.\n", hash.GetHex());
-            continue;
-        }
-        if (OMNICORE_MESSAGE_TYPE_ACTIVATION != mp_obj.getType()) {
-            PrintToLog("ERROR: While loading activation transaction %s: levelDB type mismatch, not an activation.\n", hash.GetHex());
-            continue;
-        }
-        mp_obj.unlockLogic();
-        if (0 != mp_obj.interpretPacket()) {
-            PrintToLog("ERROR: While loading activation transaction %s: non-zero return from interpretPacket\n", hash.GetHex());
-            continue;
-        }
-    }
-    delete it;
-    CheckLiveActivations(blockHeight);
-
-    // This alert never expires as long as custom activations are used
-    if (gArgs.IsArgSet("-omniactivationallowsender") || gArgs.IsArgSet("-omniactivationignoresender")) {
-        AddAlert("omnicore", ALERT_CLIENT_VERSION_EXPIRY, std::numeric_limits<uint32_t>::max(),
-                "Authorization for feature activation has been modified.  Data provided by this client should not be trusted.");
-    }
-}
-
-bool CMPTxList::LoadFreezeState(int blockHeight)
-{
-    assert(pdb);
-
-    std::vector<std::pair<std::string, uint256> > loadOrder;
-    int txnsLoaded = 0;
-    leveldb::Iterator* it = NewIterator();
-    PrintToLog("Loading freeze state from levelDB\n");
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string itData = it->value().ToString();
-        std::vector<std::string> vstr;
-        boost::split(vstr, itData, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 != vstr.size()) continue;
-        uint16_t txtype = atoi(vstr[2]);
-        if (txtype != MSC_TYPE_FREEZE_PROPERTY_TOKENS && txtype != MSC_TYPE_UNFREEZE_PROPERTY_TOKENS &&
-                txtype != MSC_TYPE_ENABLE_FREEZING && txtype != MSC_TYPE_DISABLE_FREEZING) continue;
-        if (atoi(vstr[0]) != 1) continue; // invalid, ignore
-        uint256 txid = uint256S(it->key().ToString());
-        int txPosition = pDbTransaction->FetchTransactionPosition(txid);
-        std::string sortKey = strprintf("%06d%010d", atoi(vstr[1]), txPosition);
-        loadOrder.push_back(std::make_pair(sortKey, txid));
-    }
-
-    delete it;
-
-    std::sort(loadOrder.begin(), loadOrder.end());
-
-    for (std::vector<std::pair<std::string, uint256> >::iterator it = loadOrder.begin(); it != loadOrder.end(); ++it) {
-        uint256 hash = (*it).second;
-        uint256 blockHash;
-        CTransactionRef wtx;
-        CMPTransaction mp_obj;
-        if (!GetTransaction(hash, wtx, Params().GetConsensus(), blockHash)) {
-            PrintToLog("ERROR: While loading freeze transaction %s: tx in levelDB but does not exist.\n", hash.GetHex());
-            return false;
-        }
-        if (blockHash.IsNull() || (nullptr == GetBlockIndex(blockHash))) {
-            PrintToLog("ERROR: While loading freeze transaction %s: failed to retrieve block hash.\n", hash.GetHex());
-            return false;
-        }
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        if (nullptr == pBlockIndex) {
-            PrintToLog("ERROR: While loading freeze transaction %s: failed to retrieve block index.\n", hash.GetHex());
-            return false;
-        }
-        int currentBlockHeight = pBlockIndex->nHeight;
-        if (currentBlockHeight > blockHeight) {
-            // skipping, because it's in the future
-            continue;
-        }
-        if (0 != ParseTransaction(*wtx, currentBlockHeight, 0, mp_obj)) {
-            PrintToLog("ERROR: While loading freeze transaction %s: failed ParseTransaction.\n", hash.GetHex());
-            return false;
-        }
-        if (!mp_obj.interpret_Transaction()) {
-            PrintToLog("ERROR: While loading freeze transaction %s: failed interpret_Transaction.\n", hash.GetHex());
-            return false;
-        }
-        if (MSC_TYPE_FREEZE_PROPERTY_TOKENS != mp_obj.getType() && MSC_TYPE_UNFREEZE_PROPERTY_TOKENS != mp_obj.getType() &&
-                MSC_TYPE_ENABLE_FREEZING != mp_obj.getType() && MSC_TYPE_DISABLE_FREEZING != mp_obj.getType()) {
-            PrintToLog("ERROR: While loading freeze transaction %s: levelDB type mismatch, not a freeze transaction.\n", hash.GetHex());
-            return false;
-        }
-        mp_obj.unlockLogic();
-        if (0 != mp_obj.interpretPacket()) {
-            PrintToLog("ERROR: While loading freeze transaction %s: non-zero return from interpretPacket\n", hash.GetHex());
-            return false;
-        }
-        txnsLoaded++;
-    }
-
-    if (blockHeight > 497000 && !isNonMainNet()) {
-        assert(txnsLoaded >= 2); // sanity check against a failure to properly load the freeze state
-    }
-
-    return true;
+    std::map<uint256, int> txs;
+    for (CDBaseIterator it{NewIterator(), CTxKey{}}; it; ++it) {
+        auto key = it.Key<CTxKey>();
+        if (!key.valid) continue;
+        if (key.block > blockHeight) continue;
+        if (!txtypes.empty() && !txtypes.count(key.type)) continue;
+        txs.emplace(key.txid, key.block);
+    }
+    return txs;
 }
 
 bool CMPTxList::CheckForFreezeTxs(int blockHeight)
 {
-    assert(pdb);
-
-    leveldb::Iterator* it = NewIterator();
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        std::string itData = it->value().ToString();
-        std::vector<std::string> vstr;
-        boost::split(vstr, itData, boost::is_any_of(":"), boost::token_compress_on);
-        if (4 != vstr.size()) continue;
-        int block = atoi(vstr[1]);
-        if (block < blockHeight) continue;
-        uint16_t txtype = atoi(vstr[2]);
+    for (CDBaseIterator it{NewIterator(), CTxKey{}}; it; ++it) {
+        auto key = it.Key<CTxKey>();
+        if (key.block < blockHeight) continue;
+        auto txtype = key.type;
         if (txtype == MSC_TYPE_FREEZE_PROPERTY_TOKENS || txtype == MSC_TYPE_UNFREEZE_PROPERTY_TOKENS ||
-                txtype == MSC_TYPE_ENABLE_FREEZING || txtype == MSC_TYPE_DISABLE_FREEZING) {
-            delete it;
+            txtype == MSC_TYPE_ENABLE_FREEZING || txtype == MSC_TYPE_DISABLE_FREEZING) {
             return true;
         }
     }
-
-    delete it;
     return false;
 }
 
@@ -784,55 +498,92 @@ void CMPTxList::printStats()
 void CMPTxList::printAll()
 {
     int count = 0;
-    leveldb::Slice skey, svalue;
-    leveldb::Iterator* it = NewIterator();
+    std::string skey, svalue;
+    for (CDBaseIterator it{NewIterator()}; it; ++it) {
+        switch(it.Key()[0]) {
+            case CTxKey::prefix: {
+                auto key = it.Key<CTxKey>();
+                skey = key.txid.ToString();
+                auto value = it.Value<int64_t>();
+                svalue = strprintf("%d:%d:%d:%d", key.block, key.valid, key.type, value);
+            } break;
+            case CPaymentTxKey::prefix: {
+                auto key = it.Key<CPaymentTxKey>();
+                skey = strprintf("%s-%d", key.txid.ToString(), key.payments);
+                auto value = it.Value<CPaymentTxValue>();
+                svalue = strprintf("%d:%d:%d:%s:%s:%d:%d", key.block, key.valid, value.vout, value.buyer, value.seller, value.propertyId, value.amount);
+            } break;
+            case CDexCancelTxKey::prefix: {
+                auto key = it.Key<CDexCancelTxKey>();
+                skey = strprintf("%s-%d", key.txid.ToString(), key.affected);
+                auto value = it.Value<CDexCancelTxValue>();
+                svalue = strprintf("%d:%d:%d:%d", key.block, key.valid, value.propertyId, value.amount);
+            } break;
+            case CSendAllTxKey::prefix: {
+                auto key = it.Key<CSendAllTxKey>();
+                skey = strprintf("%s-%d", key.txid.ToString(), key.num);
+                auto value = it.Value<CSendAllTxValue>();
+                svalue = strprintf("%d:%d", value.propertyId, value.amount);
+            } break;
+            default:
+                continue;
+        }
+        PrintToConsole("entry #%8d= %s:%s\n", ++count, skey, svalue);
+    }
+}
 
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        svalue = it->value();
-        ++count;
-        PrintToConsole("entry #%8d= %s:%s\n", count, skey.ToString(), svalue.ToString());
+template<typename T>
+bool DeleteToBatch(CDBWriteBatch& batch, CDBaseIterator& it, const uint256& txid)
+{
+    bool found = false;
+    for (it.Seek(PartialKey<T>(txid)); it; ++it) {
+        found = true;
+        batch.Delete(it.Key());
     }
+    return found;
+}
 
-    delete it;
+void CMPTxList::deleteTransactions(const std::set<uint256>& txs, int block)
+{
+    CDBWriteBatch batch;
+    CDBaseIterator it{NewIterator()};
+    std::set<uint256> cancelTxs;
+    for (it.Seek(CBlockTxKey{}); it; ++it) {
+        if (it.Key<CBlockTxKey>().block < block) break;
+        batch.Delete(it.Key());
+    }
+    for (auto& txid : txs) {
+        bool deleted = DeleteToBatch<CTxKey>(batch, it, txid) ||
+                       DeleteToBatch<CPaymentTxKey>(batch, it, txid) ||
+                       (DeleteToBatch<CDexCancelTxKey>(batch, it, txid) &&
+                       cancelTxs.insert(txid).second);
+        deleted |= DeleteToBatch<CSendAllTxKey>(batch, it, txid);
+        deleted |= DeleteToBatch<CDexTxToCancelKey>(batch, it, txid);
+        if (deleted) {
+            PrintToLog("%s() DELETING: %s\n", __func__, txid.ToString());
+        }
+    }
+    for (it.Seek(CDexTxToCancelKey{{}}); it && !cancelTxs.empty(); ++it) {
+        auto txid = it.Value<uint256>();
+        // if both cancel and payment txs are reverted don't put back payment one
+        if (cancelTxs.erase(txid)) {
+            batch.Delete(it.Key());
+        }
+    }
+    WriteBatch(batch);
 }
 
 // figure out if there was at least 1 Master Protocol transaction within the block range, or a block if starting equals ending
 // block numbers are inclusive
-// pass in bDeleteFound = true to erase each entry found within the block range
-bool CMPTxList::isMPinBlockRange(int starting_block, int ending_block, bool bDeleteFound)
+bool CMPTxList::isMPinBlockRange(int starting_block, int ending_block)
 {
-    leveldb::Slice skey, svalue;
-    std::vector<std::string> vstr;
-    int block;
     unsigned int n_found = 0;
-
-    leveldb::Iterator* it = NewIterator();
-
-    for (it->SeekToFirst(); it->Valid(); it->Next()) {
-        skey = it->key();
-        svalue = it->value();
-
-        std::string strvalue = it->value().ToString();
-
-        // parse the string returned, find the validity flag/bit & other parameters
-        boost::split(vstr, strvalue, boost::is_any_of(":"), boost::token_compress_on);
-
-        // only care about the block number/height here
-        if (2 <= vstr.size()) {
-            block = atoi(vstr[1]);
-
-            if ((starting_block <= block) && (block <= ending_block)) {
-                ++n_found;
-                PrintToLog("%s() DELETING: %s=%s\n", __func__, skey.ToString(), svalue.ToString());
-                if (bDeleteFound) pdb->Delete(writeoptions, skey);
-            }
-        }
+    CDBaseIterator it{NewIterator(), CBlockTxKey{uint32_t(ending_block)}};
+    for (; it; ++it) {
+        auto key = it.Key<CBlockTxKey>();
+        if (key.block < starting_block) break;
+        ++n_found;
     }
-
     PrintToLog("%s(%d, %d); n_found= %d\n", __func__, starting_block, ending_block, n_found);
-
-    delete it;
-
     return (n_found);
 }
diff --git a/src/omnicore/dbtxlist.h b/src/omnicore/dbtxlist.h
index 09f08a190cc69..c3b9839510825 100644
--- a/src/omnicore/dbtxlist.h
+++ b/src/omnicore/dbtxlist.h
@@ -1,6 +1,7 @@
 #ifndef BITCOIN_OMNICORE_DBTXLIST_H
 #define BITCOIN_OMNICORE_DBTXLIST_H
 
+#include <cstdint>
 #include <omnicore/dbbase.h>
 #include <omnicore/nftdb.h>
 
@@ -16,24 +17,29 @@
  */
 class CMPTxList : public CDBBase
 {
+    struct CTxKey;
+    bool getTX(const uint256& txid, CTxKey& key, int64_t& value);
 public:
     CMPTxList(const fs::path& path, bool fWipe);
     virtual ~CMPTxList();
 
     void recordTX(const uint256& txid, bool fValid, int nBlock, unsigned int type, uint64_t nValue);
-    void recordPaymentTX(const uint256& txid, bool fValid, int nBlock, unsigned int vout, unsigned int propertyId, uint64_t nValue, std::string buyer, std::string seller);
+    void recordPaymentTX(const uint256& txid, bool fValid, int nBlock, unsigned int vout, unsigned int propertyId, uint64_t nValue, const std::string& buyer, const std::string& seller);
     void recordMetaDExCancelTX(const uint256 &txidMaster, const uint256& txidSub, bool fValid, int nBlock, unsigned int propertyId, uint64_t nValue);
     /** Records a "send all" sub record. */
-    void recordSendAllSubRecord(const uint256& txid, int subRecordNumber, uint32_t propertyId, int64_t nvalue);
+    void recordSendAllSubRecord(const uint256& txid, int nBlock, int subRecordNumber, uint32_t propertyId, int64_t nvalue);
     /** Records the range awarded in a grant applied to a non-fungible property. */
     void RecordNonFungibleGrant(const uint256 &txid, int64_t start, int64_t end);
 
-    std::string getKeyValue(std::string key);
-    uint256 findMetaDExCancel(const uint256 txid);
+    void deleteTransactions(const std::set<uint256>& txs, int block);
+
+    uint256 findMetaDExCancel(const uint256& txid);
     /** Returns the number of sub records. */
     int getNumberOfSubRecords(const uint256& txid);
-    int getNumberOfMetaDExCancels(const uint256 txid);
-    bool getPurchaseDetails(const uint256 txid, int purchaseNumber, std::string* buyer, std::string* seller, uint64_t* vout, uint64_t *propertyId, uint64_t* nValue);
+    int getNumberOfMetaDExCancels(const uint256& txid);
+    bool getPurchaseDetails(const uint256& txid, int purchaseNumber, std::string* buyer, std::string* seller, uint64_t* vout, uint64_t *propertyId, uint64_t* nValue);
+    /** Retrieves details about a "metadex cancel" record. */
+    bool getMetaDExCancelDetails(const uint256& txid, int subSend, uint32_t& propertyId, int64_t& amount);
     /** Retrieves details about a "send all" record. */
     bool getSendAllDetails(const uint256& txid, int subSend, uint32_t& propertyId, int64_t& amount);
     /** Retrieves details about the range awarded in a grant to a non-fungible property. */
@@ -47,20 +53,17 @@ class CMPTxList : public CDBBase
     int getDBVersion();
     int setDBVersion();
 
-    bool exists(const uint256& txid);
-    bool getTX(const uint256& txid, std::string& value);
+    bool existsMPTX(const uint256& txid);
     bool getValidMPTX(const uint256& txid, int* block = nullptr, unsigned int* type = nullptr, uint64_t* nAmended = nullptr);
 
     std::set<int> GetSeedBlocks(int startHeight, int endHeight);
-    void LoadAlerts(int blockHeight);
-    void LoadActivations(int blockHeight);
-    bool LoadFreezeState(int blockHeight);
+    std::map<uint256, int> LoadValidTxs(int blockHeight, const std::set<int>& txtypes = {});
     bool CheckForFreezeTxs(int blockHeight);
 
     void printStats();
     void printAll();
 
-    bool isMPinBlockRange(int, int, bool);
+    bool isMPinBlockRange(int, int);
 };
 
 namespace mastercore
diff --git a/src/omnicore/dex.h b/src/omnicore/dex.h
index 8d3d91b1cb28c..5f9dacba7fefd 100644
--- a/src/omnicore/dex.h
+++ b/src/omnicore/dex.h
@@ -25,17 +25,6 @@ inline std::string STR_ACCEPT_ADDR_PROP_ADDR_COMBO(const std::string& seller, co
 {
     return strprintf("%s-%d+%s", seller, propertyId, buyer);
 }
-/** Lookup key to find DEx payments. */
-inline std::string STR_PAYMENT_SUBKEY_TXID_PAYMENT_COMBO(const std::string& txidStr, unsigned int paymentNumber)
-{
-    return strprintf("%s-%d", txidStr, paymentNumber);
-}
-/** Lookup key to find MetaDEx sub-records. TODO: not here! */
-inline std::string STR_REF_SUBKEY_TXID_REF_COMBO(const std::string& txidStr, unsigned int refNumber)
-{
-    return strprintf("%s%d", txidStr, refNumber);
-}
-
 /** A single outstanding offer, from one seller of one property.
  *
  * There many be more than one accepted offers.
diff --git a/src/omnicore/doc/configuration.md b/src/omnicore/doc/configuration.md
index 008ae3a80e174..1e87df7dca1c8 100644
--- a/src/omnicore/doc/configuration.md
+++ b/src/omnicore/doc/configuration.md
@@ -40,7 +40,6 @@ More information about the general configuration and Bitcoin Core specific optio
 | Name                         | Type         | Default        | Description                                                                     |
 |------------------------------|--------------|----------------|---------------------------------------------------------------------------------|
 | `startclean`                 | boolean      | `0`            | clear all persistence files on startup; triggers reparsing of Omni transactions |
-| `omnitxcache`                | number       | `500000`       | the maximum number of transactions in the input transaction cache               |
 | `omniprogressfrequency`      | number       | `30`           | time in seconds after which the initial scanning progress is reported           |
 | `omniseedblockfilter`        | boolean      | `1`            | set skipping of blocks without Omni transactions during initial scan            |
 | `omniskipstoringstate`       | number       | `770000`       | don't store state during initial synchronization until block n (faster, but may have to restart syncing after a shutdown) |
diff --git a/src/omnicore/errors.h b/src/omnicore/errors.h
index 08fcfc55d9044..8fffb65e73b89 100644
--- a/src/omnicore/errors.h
+++ b/src/omnicore/errors.h
@@ -378,6 +378,9 @@ inline std::string error_str(int ec) {
       case PKT_ERROR_NFT -33:
           ec_str = "Sender %s does not own the range being sent";
           break;
+      case MP_TX_IS_NOT_OMNI_PROTOCOL:
+          ec_str = "No Omni layer transaction";
+          break;
 
       default:
           ec_str = "Unknown error";
diff --git a/src/omnicore/log.cpp b/src/omnicore/log.cpp
index ed885c73dff80..8cb83be5a6ddc 100644
--- a/src/omnicore/log.cpp
+++ b/src/omnicore/log.cpp
@@ -1,8 +1,11 @@
+#include <cstdint>
 #include <omnicore/log.h>
 
 #include <chainparamsbase.h>
 #include <fs.h>
 #include <logging.h>
+#include <optional>
+#include <streams.h>
 #include <util/system.h>
 #include <util/time.h>
 
@@ -66,25 +69,29 @@ bool msc_debug_fees               = 1;
 //! Debug the non-fungible tokens database
 bool msc_debug_nftdb              = 0;
 
-/**
- * LogPrintf has been broken a couple of times now
- * by well-meaning people adding mutexes in the most straightforward way.
- * It breaks because it may be called by global destructors during shutdown.
- * Since the order of destruction of static/global objects is undefined,
- * defining a mutex as a global object doesn't work (the mutex gets
- * destroyed, and then some later destructor calls OutputDebugStringF,
- * maybe indirectly, and you get a core dump at shutdown trying to lock
- * the mutex).
- */
-static std::once_flag debugLogInitFlag;
 /**
  * We use std::call_once() to make sure these are initialized
  * in a thread-safe manner the first time called:
  */
 static FILE* fileout = nullptr;
-static std::mutex* mutexDebugLog = nullptr;
+std::recursive_mutex mutexDebugLog;
+
 /** Flag to indicate, whether the Omni Core log file should be reopened. */
-extern std::atomic<bool> fReopenOmniCoreLog;
+std::atomic<bool> fReopenOmniCoreLog{false};
+
+/** override to print to omni log to console */
+std::atomic<bool> fOmniCoreConsoleLog{false};
+
+void CloseLogFile()
+{
+    std::lock_guard lock(mutexDebugLog);
+    if (fileout) {
+        fclose(fileout);
+        fileout = nullptr;
+    }
+    fReopenOmniCoreLog = false;
+}
+
 /**
  * Returns path for debug log file.
  *
@@ -111,8 +118,8 @@ static fs::path GetLogPath()
  */
 static void DebugLogInit()
 {
+    std::lock_guard lock(mutexDebugLog);
     assert(fileout == nullptr);
-    assert(mutexDebugLog == nullptr);
 
     fs::path pathDebug = GetLogPath();
     fileout = fopen(pathDebug.string().c_str(), "a");
@@ -122,8 +129,6 @@ static void DebugLogInit()
     } else {
         PrintToConsole("Failed to open debug log file: %s\n", pathDebug.string());
     }
-
-    mutexDebugLog = new std::mutex();
 }
 
 /**
@@ -134,6 +139,16 @@ static std::string GetTimestamp()
     return FormatISO8601DateTime(GetTime());
 }
 
+int LogWriteLine(const std::string& str, FILE* file)
+{
+    int ret = 0; // Number of characters written
+    static std::atomic_bool fStartedNewLine = true;
+    // Printing log timestamps can be useful for profiling
+    fStartedNewLine && (ret += fprintf(file, "%s ", GetTimestamp().c_str()));
+    fStartedNewLine = !str.empty() && str.back() == '\n';
+    return ret + fwrite(str.data(), 1, str.size(), file);
+}
+
 /**
  * Prints to log file.
  *
@@ -148,42 +163,17 @@ static std::string GetTimestamp()
  */
 int LogFilePrint(const std::string& str)
 {
-    int ret = 0; // Number of characters written
-    if (LogInstance().m_print_to_console || fOmniCoreConsoleLog) {
-        // Print to console
-        ret = ConsolePrint(str);
+    if (auto ret = ConsolePrint(str)) {
+        return ret;
     }
-    else if (LogInstance().m_print_to_file) {
-        static bool fStartedNewLine = true;
-        std::call_once(debugLogInitFlag, &DebugLogInit);
 
-        if (fileout == nullptr) {
-            return ret;
-        }
-        std::lock_guard<std::mutex> lock(*mutexDebugLog);
-
-        // Reopen the log file, if requested
-        if (fReopenOmniCoreLog) {
-            fReopenOmniCoreLog = false;
-            fs::path pathDebug = GetLogPath();
-            if (freopen(pathDebug.string().c_str(), "a", fileout) != nullptr) {
-                setbuf(fileout, nullptr); // Unbuffered
-            }
-        }
-
-        // Printing log timestamps can be useful for profiling
-        if (LogInstance().m_log_timestamps && fStartedNewLine) {
-            ret += fprintf(fileout, "%s ", GetTimestamp().c_str());
-        }
-        if (!str.empty() && str[str.size()-1] == '\n') {
-            fStartedNewLine = true;
-        } else {
-            fStartedNewLine = false;
-        }
-        ret += fwrite(str.data(), 1, str.size(), fileout);
+    std::lock_guard lock(mutexDebugLog);
+    // Reopen the log file, if requested
+    if (fReopenOmniCoreLog) {
+        CloseLogFile();
+        DebugLogInit();
     }
-
-    return ret;
+    return fileout ? LogWriteLine(str, fileout) : 0;
 }
 
 /**
@@ -197,26 +187,11 @@ int LogFilePrint(const std::string& str)
  */
 int ConsolePrint(const std::string& str)
 {
-    int ret = 0; // Number of characters written
-    static bool fStartedNewLine = true;
-
-    static const bool print = gArgs.GetBoolArg("-printtoconsole", true);
-    if (!print) {
-        return 0;
+    int ret = 0;
+    if (fOmniCoreConsoleLog) {
+        ret = LogWriteLine(str, stdout);
+        fflush(stdout);
     }
-
-    if (LogInstance().m_log_timestamps && fStartedNewLine) {
-        ret = fprintf(stdout, "%s %s", GetTimestamp().c_str(), str.c_str());
-    } else {
-        ret = fwrite(str.data(), 1, str.size(), stdout);
-    }
-    if (!str.empty() && str[str.size()-1] == '\n') {
-        fStartedNewLine = true;
-    } else {
-        fStartedNewLine = false;
-    }
-    fflush(stdout);
-
     return ret;
 }
 
@@ -228,85 +203,74 @@ int ConsolePrint(const std::string& str)
  * Example usage (disable all debugging)  : --omnidebug=none
  * Example usage (disable all except XYZ) : --omnidebug=none --omnidebug=parser --omnidebug=sto
  */
+
+#ifndef WIN32
+#include <signal.h>
+static void handleSIGUP(int)
+{
+    fReopenOmniCoreLog = true;
+}
+#endif
+
 void InitDebugLogLevels()
 {
+    fOmniCoreConsoleLog = gArgs.GetBoolArg("-printtoconsole", false);
+    if (!fOmniCoreConsoleLog) {
+        DebugLogInit();
+    }
+
+#ifndef WIN32
+    // Reopen omnicore.log on SIGHUP
+    struct sigaction sa{};
+    sa.sa_handler = handleSIGUP;
+    sigemptyset(&sa.sa_mask);
+    sigaction(SIGHUP, &sa, nullptr);
+#endif
+
     if (!gArgs.IsArgSet("-omnidebug")) {
         return;
     }
 
     const std::vector<std::string>& debugLevels = gArgs.GetArgs("-omnidebug");
 
-    for (std::vector<std::string>::const_iterator it = debugLevels.begin(); it != debugLevels.end(); ++it) {
-        if (*it == "parser_data") msc_debug_parser_data = true;
-        if (*it == "parser_readonly") msc_debug_parser_readonly = true;
-        if (*it == "parser_dex") msc_debug_parser_dex = true;
-        if (*it == "parser") msc_debug_parser = true;
-        if (*it == "verbose") msc_debug_verbose = true;
-        if (*it == "verbose2") msc_debug_verbose2 = true;
-        if (*it == "verbose3") msc_debug_verbose3 = true;
-        if (*it == "vin") msc_debug_vin = true;
-        if (*it == "script") msc_debug_script = true;
-        if (*it == "dex") msc_debug_dex = true;
-        if (*it == "send") msc_debug_send = true;
-        if (*it == "tokens") msc_debug_tokens = true;
-        if (*it == "spec") msc_debug_spec = true;
-        if (*it == "exo") msc_debug_exo = true;
-        if (*it == "tally") msc_debug_tally = true;
-        if (*it == "sp") msc_debug_sp = true;
-        if (*it == "sto") msc_debug_sto = true;
-        if (*it == "txdb") msc_debug_txdb = true;
-        if (*it == "tradedb") msc_debug_tradedb = true;
-        if (*it == "persistence") msc_debug_persistence = true;
-        if (*it == "ui") msc_debug_ui = true;
-        if (*it == "pending") msc_debug_pending = true;
-        if (*it == "metadex1") msc_debug_metadex1 = true;
-        if (*it == "metadex2") msc_debug_metadex2 = true;
-        if (*it == "metadex3") msc_debug_metadex3 = true;
-        if (*it == "packets") msc_debug_packets = true;
-        if (*it == "packets_readonly") msc_debug_packets_readonly = true;
-        if (*it == "consensus_hash") msc_debug_consensus_hash = true;
-        if (*it == "consensus_hash_every_block") msc_debug_consensus_hash_every_block = true;
-        if (*it == "alerts") msc_debug_alerts = true;
-        if (*it == "consensus_hash_every_transaction") msc_debug_consensus_hash_every_transaction = true;
-        if (*it == "fees") msc_debug_fees = true;
-        if (*it == "nftdb") msc_debug_nftdb = true;
-        if (*it == "none" || *it == "all") {
-            bool allDebugState = false;
-            if (*it == "all") allDebugState = true;
-            msc_debug_parser_data = allDebugState;
-            msc_debug_parser_readonly = allDebugState;
-            msc_debug_parser_dex = allDebugState;
-            msc_debug_parser = allDebugState;
-            msc_debug_verbose = allDebugState;
-            msc_debug_verbose2 = allDebugState;
-            msc_debug_verbose3 = allDebugState;
-            msc_debug_vin = allDebugState;
-            msc_debug_script = allDebugState;
-            msc_debug_dex = allDebugState;
-            msc_debug_send = allDebugState;
-            msc_debug_tokens = allDebugState;
-            msc_debug_spec = allDebugState;
-            msc_debug_exo = allDebugState;
-            msc_debug_tally = allDebugState;
-            msc_debug_sp = allDebugState;
-            msc_debug_sto = allDebugState;
-            msc_debug_txdb = allDebugState;
-            msc_debug_tradedb = allDebugState;
-            msc_debug_persistence = allDebugState;
-            msc_debug_ui = allDebugState;
-            msc_debug_pending = allDebugState;
-            msc_debug_metadex1 = allDebugState;
-            msc_debug_metadex2 = allDebugState;
-            msc_debug_metadex3 = allDebugState;
-            msc_debug_packets =  allDebugState;
-            msc_debug_packets_readonly =  allDebugState;
-            msc_debug_consensus_hash = allDebugState;
-            msc_debug_consensus_hash_every_block = allDebugState;
-            msc_debug_alerts = allDebugState;
-            msc_debug_consensus_hash_every_transaction = allDebugState;
-            msc_debug_fees = allDebugState;
-            msc_debug_nftdb = allDebugState;
-        }
+    for (const auto& d : debugLevels) {
+        auto none = d == "none";
+        auto all = d == "all";
+#define ENABLE_LOG(x) msc_debug_##x = none ? false : (all || d == #x)
+        ENABLE_LOG(parser_data);
+        ENABLE_LOG(parser_readonly);
+        ENABLE_LOG(parser_dex);
+        ENABLE_LOG(parser);
+        ENABLE_LOG(verbose);
+        ENABLE_LOG(verbose2);
+        ENABLE_LOG(verbose3);
+        ENABLE_LOG(vin);
+        ENABLE_LOG(script);
+        ENABLE_LOG(dex);
+        ENABLE_LOG(send);
+        ENABLE_LOG(tokens);
+        ENABLE_LOG(spec);
+        ENABLE_LOG(exo);
+        ENABLE_LOG(tally);
+        ENABLE_LOG(sp);
+        ENABLE_LOG(sto);
+        ENABLE_LOG(txdb);
+        ENABLE_LOG(tradedb);
+        ENABLE_LOG(persistence);
+        ENABLE_LOG(ui);
+        ENABLE_LOG(pending);
+        ENABLE_LOG(metadex1);
+        ENABLE_LOG(metadex2);
+        ENABLE_LOG(metadex3);
+        ENABLE_LOG(packets);
+        ENABLE_LOG(packets_readonly);
+        ENABLE_LOG(consensus_hash);
+        ENABLE_LOG(consensus_hash_every_block);
+        ENABLE_LOG(alerts);
+        ENABLE_LOG(consensus_hash_every_transaction);
+        ENABLE_LOG(fees);
+        ENABLE_LOG(nftdb);
+#undef ENABLE_LOG
     }
 }
 
@@ -315,29 +279,23 @@ void InitDebugLogLevels()
  */
 void ShrinkDebugLog()
 {
-    fs::path pathLog = GetLogPath();
-    FILE* file = fopen(pathLog.string().c_str(), "r");
-
-    if (file && fs::file_size(pathLog) > LOG_SHRINKSIZE) {
+    const fs::path pathLog = GetLogPath();
+    if (!fs::exists(pathLog) || fs::file_size(pathLog) <= LOG_SHRINKSIZE) {
+        return;
+    }
+    const auto fileStr = pathLog.string();
+    AutoFile autoFile(fopen(fileStr.c_str(), "r"));
+    if (auto file = autoFile.Get()) {
         // Restart the file with some of the end
-        char* pch = new char[LOG_BUFFERSIZE];
-        if (nullptr != pch) {
-            fseek(file, -LOG_BUFFERSIZE, SEEK_END);
-            int nBytes = fread(pch, 1, LOG_BUFFERSIZE, file);
-            fclose(file);
-            file = nullptr;
+        std::string pch;
+        pch.resize(LOG_BUFFERSIZE);
+        fseek(file, -LOG_BUFFERSIZE, SEEK_END);
+        int nBytes = fread(pch.data(), 1, LOG_BUFFERSIZE, file);
+        autoFile.fclose();
 
-            file = fopen(pathLog.string().c_str(), "w");
-            if (file) {
-                fwrite(pch, 1, nBytes, file);
-                fclose(file);
-                file = nullptr;
-            }
-            delete[] pch;
+        AutoFile reOpen(fopen(fileStr.c_str(), "w"));
+        if (auto file = reOpen.Get()) {
+            fwrite(pch.data(), 1, nBytes, file);
         }
-    } else if (nullptr != file) {
-        fclose(file);
-        file = nullptr;
     }
 }
-
diff --git a/src/omnicore/log.h b/src/omnicore/log.h
index 50c492f9e7637..a209de251219a 100644
--- a/src/omnicore/log.h
+++ b/src/omnicore/log.h
@@ -18,6 +18,15 @@ void InitDebugLogLevels();
 /** Scrolls log file, if it's getting too big. */
 void ShrinkDebugLog();
 
+/** Closes log file */
+void CloseLogFile();
+
+/** Flag to indicate, whether the Omni Core log file should be reopened. */
+extern std::atomic<bool> fReopenOmniCoreLog;
+
+/** override to print to omni log to console */
+extern std::atomic<bool> fOmniCoreConsoleLog;
+
 // Debug flags
 extern bool msc_debug_parser_data;
 extern bool msc_debug_parser_readonly;
diff --git a/src/omnicore/mdex.cpp b/src/omnicore/mdex.cpp
index 88bcfcfe6db11..25753405c1329 100644
--- a/src/omnicore/mdex.cpp
+++ b/src/omnicore/mdex.cpp
@@ -308,8 +308,7 @@ static MatchReturnType x_Trade(CMPMetaDEx* const pnew)
             if (msc_debug_metadex1) PrintToLog("==== TRADED !!! %u=%s\n", NewReturn, getTradeReturnType(NewReturn));
 
             // record the trade in MPTradeList
-            pDbTradeList->recordMatchedTrade(pold->getHash(), pnew->getHash(), // < might just pass pold, pnew
-                pold->getAddr(), pnew->getAddr(), pold->getDesProperty(), pnew->getDesProperty(), seller_amountGot, buyer_amountGotAfterFee, pnew->getBlock(), tradingFee);
+            pDbTradeList->recordMatchedTrade(pold->getHash(), pnew->getHash(), pnew->getBlock(), seller_amountGot, buyer_amountGotAfterFee, tradingFee);
 
             if (msc_debug_metadex1) PrintToLog("++ erased old: %s\n", offerIt->ToString());
             // erase the old seller element
@@ -405,11 +404,6 @@ int64_t CMPMetaDEx::getAmountToFill() const
     return nAmountNeededToFill;
 }
 
-int64_t CMPMetaDEx::getBlockTime() const
-{
-    return WITH_LOCK(cs_main, return ::ChainActive()[block]->GetBlockTime());
-}
-
 void CMPMetaDEx::setAmountRemaining(int64_t amount, const std::string& label)
 {
     amount_remaining = amount;
@@ -742,7 +736,7 @@ bool mastercore::MetaDEx_isOpen(const uint256& txid, uint32_t propertyIdForSale)
         for (md_PricesMap::iterator it = prices.begin(); it != prices.end(); ++it) {
             md_Set & indexes = (it->second);
             for (md_Set::iterator it = indexes.begin(); it != indexes.end(); ++it) {
-                CMPMetaDEx obj = *it;
+                const CMPMetaDEx& obj = *it;
                 if( obj.getHash().GetHex() == txid.GetHex() ) return true;
             }
         }
diff --git a/src/omnicore/mdex.h b/src/omnicore/mdex.h
index 6ad285ae3f0a1..eea8b685bdee2 100644
--- a/src/omnicore/mdex.h
+++ b/src/omnicore/mdex.h
@@ -5,7 +5,6 @@
 
 #include <uint256.h>
 
-#include <boost/lexical_cast.hpp>
 #include <boost/multiprecision/cpp_dec_float.hpp>
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/rational.hpp>
@@ -68,8 +67,6 @@ class CMPMetaDEx
     int getBlock() const { return block; }
     unsigned int getIdx() const { return idx; }
 
-    int64_t getBlockTime() const;
-
     CMPMetaDEx()
       : block(0), idx(0), property(0), amount_forsale(0), desired_property(0), amount_desired(0),
         amount_remaining(0), subaction(0) {}
@@ -111,7 +108,7 @@ struct MetaDEx_compare
 
 // ---------------
 //! Set of objects sorted by block+idx
-typedef std::set<CMPMetaDEx, MetaDEx_compare> md_Set; 
+typedef std::set<CMPMetaDEx, MetaDEx_compare> md_Set;
 //! Map of prices; there is a set of sorted objects for each price
 typedef std::map<rational_t, md_Set> md_PricesMap;
 //! Map of properties; there is a map of prices for each property
diff --git a/src/omnicore/mempool.cpp b/src/omnicore/mempool.cpp
new file mode 100644
index 0000000000000..ffc8e6859b6ed
--- /dev/null
+++ b/src/omnicore/mempool.cpp
@@ -0,0 +1,242 @@
+
+#include <omnicore/dbaddress.h>
+#include <omnicore/mempool.h>
+#include <omnicore/omnicore.h>
+#include <omnicore/parsing.h>
+#include <omnicore/utilsbitcoin.h>
+
+#include <txmempool.h>
+
+#include <map>
+
+namespace mastercore {
+
+struct CMempoolAddressDeltaKeyCompare
+{
+    bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const {
+        if (a.type != b.type) {
+            return a.type < b.type;
+        }
+        if (a.addressBytes != b.addressBytes) {
+            return a.addressBytes < b.addressBytes;
+        }
+        if (a.txhash != b.txhash) {
+            return a.txhash < b.txhash;
+        }
+        if (a.index != b.index) {
+            return a.index < b.index;
+        }
+        return a.spending < b.spending;
+    }
+};
+
+struct CSpentIndexKeyCompare
+{
+    bool operator()(const CSpentIndexKey& a, const CSpentIndexKey& b) const {
+        if (a.txid == b.txid) {
+            return a.outputIndex < b.outputIndex;
+        }
+        return a.txid < b.txid;
+    }
+};
+
+RecursiveMutex cs_mempool;
+
+std::map<uint256, CTransactionRef> mapMempool GUARDED_BY(cs_mempool);
+
+typedef std::map<CMempoolAddressDeltaKey, CMempoolAddressDelta, CMempoolAddressDeltaKeyCompare> addressDeltaMap;
+addressDeltaMap mapAddress GUARDED_BY(cs_mempool);
+
+typedef std::map<uint256, std::vector<addressDeltaMap::iterator>> addressDeltaMapInserted;
+addressDeltaMapInserted mapAddressInserted GUARDED_BY(cs_mempool);
+
+typedef std::map<CSpentIndexKey, CSpentIndexValue, CSpentIndexKeyCompare> mapSpentIndex;
+mapSpentIndex mapSpent GUARDED_BY(cs_mempool);
+
+typedef std::map<uint256, std::vector<mapSpentIndex::iterator>> mapSpentIndexInserted;
+mapSpentIndexInserted mapSpentInserted GUARDED_BY(cs_mempool);
+
+static void AddAddressIndexToMempool(CTransactionRef tx, CCoinsViewCache& view)
+{
+    LOCK(cs_mempool);
+    auto time = GetTime();
+    std::vector<addressDeltaMap::iterator> inserted;
+
+    const uint256& txhash = tx->GetHash();
+    for (unsigned int j = 0; j < tx->vin.size(); j++) {
+        const auto& prevout = tx->vin[j].prevout;
+        const auto& output = view.GetOutputFor(tx->vin[j]);
+        if (auto result = ScriptToUint(output.scriptPubKey)) {
+            auto& [index, address] = *result;
+            CMempoolAddressDeltaKey key{index, address, txhash, j, 1};
+            CMempoolAddressDelta delta{time, output.nValue * -1, prevout.hash, prevout.n};
+            if (auto [it, ins] = mapAddress.emplace(key, delta); ins) {
+                inserted.push_back(it);
+            }
+        }
+    }
+
+    for (unsigned int k = 0; k < tx->vout.size(); k++) {
+        const CTxOut &out = tx->vout[k];
+        if (auto result = ScriptToUint(out.scriptPubKey)) {
+            auto& [index, address] = *result;
+            CMempoolAddressDeltaKey key{index, address, txhash, k};
+            CMempoolAddressDelta delta{time, out.nValue};
+            if (auto [it, ins] = mapAddress.emplace(key, delta); ins) {
+                inserted.push_back(it);
+            }
+        }
+    }
+    mapAddressInserted.emplace(txhash, inserted);
+}
+
+static void RemoveAddressIndexFromMempool(const uint256& txhash)
+{
+    LOCK(cs_mempool);
+    auto it = mapAddressInserted.find(txhash);
+    if (it != mapAddressInserted.end()) {
+        auto& keys = (*it).second;
+        for (auto mit = keys.begin(); mit != keys.end(); mit++) {
+            mapAddress.erase(*mit);
+        }
+        mapAddressInserted.erase(it);
+    }
+}
+
+static void AddSpentIndexToMempool(CTransactionRef tx, CCoinsViewCache& view)
+{
+    LOCK(cs_mempool);
+    std::vector<mapSpentIndex::iterator> inserted;
+
+    const uint256& txhash = tx->GetHash();
+    for (unsigned int j = 0; j < tx->vin.size(); j++) {
+        const auto& prevout = tx->vin[j].prevout;
+        const auto& output = view.GetOutputFor(tx->vin[j]);
+        const auto& outValue = output.nValue;
+        const auto& scriptPubKey = output.scriptPubKey;
+        uint256 addressHash;
+        int version;
+        unsigned int addressType;
+        std::vector<unsigned char> addressBytes(32);
+
+        if (scriptPubKey.IsPayToScriptHash()) {
+            std::copy(scriptPubKey.begin() + 2, scriptPubKey.begin() + 22, addressBytes.begin());
+            addressHash = uint256(addressBytes);
+            addressType = 2;
+        } else if (scriptPubKey.IsPayToPubkeyHash()) {
+            std::copy(scriptPubKey.begin() + 3, scriptPubKey.begin() + 23, addressBytes.begin());
+            addressHash = uint256(addressBytes);
+            addressType = 1;
+        } else if (scriptPubKey.IsPayToPubkey()) {
+            std::vector<unsigned char> pubkeyBytes(scriptPubKey.begin() + 1, scriptPubKey.end()-1);
+            uint160 hashBytes = Hash160(pubkeyBytes);
+            std::copy(hashBytes.begin(), hashBytes.end(), addressBytes.begin());
+            addressHash = uint256(addressBytes);
+            addressType = 1;
+        } else if (scriptPubKey.IsPayToWitnessPubkeyHash()) {
+            std::copy(scriptPubKey.begin() + 2, scriptPubKey.end(), addressBytes.begin());
+            addressHash = uint256(addressBytes);
+            addressType = 4;
+        } else if (scriptPubKey.IsWitnessProgram(version, addressBytes)) {
+            addressHash = uint256(addressBytes);
+            addressType = version == 0 ? 3 : 5;
+        } else {
+            addressHash.SetNull();
+            addressType = 0;
+        }
+
+        CSpentIndexKey key = CSpentIndexKey{prevout.hash, prevout.n};
+        CSpentIndexValue value = CSpentIndexValue{txhash, j, -1, outValue, addressType, addressHash};
+
+        if (auto [it, ins] = mapSpent.emplace(key, value); ins) {
+            inserted.push_back(it);
+        }
+    }
+    mapSpentInserted.emplace(txhash, inserted);
+}
+
+static void RemoveSpentIndexFromMempool(const uint256& txhash)
+{
+    LOCK(cs_mempool);
+    auto it = mapSpentInserted.find(txhash);
+    if (it != mapSpentInserted.end()) {
+        auto& keys = (*it).second;
+        for (auto mit = keys.begin(); mit != keys.end(); mit++) {
+            mapSpent.erase(*mit);
+        }
+        mapSpentInserted.erase(it);
+    }
+}
+
+bool GetSpentIndexFromMempool(const CSpentIndexKey &key, CSpentIndexValue &value)
+{
+    LOCK(cs_mempool);
+    auto it = mapSpent.find(key);
+    if (it != mapSpent.end()) {
+        value = it->second;
+        return true;
+    }
+    return false;
+}
+
+bool GetAddressIndexFromMempool(const std::vector<std::pair<uint256, unsigned>>& addresses, std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta>>& results)
+{
+    LOCK(cs_mempool);
+    for (auto it = addresses.begin(); it != addresses.end(); it++) {
+        auto ait = mapAddress.lower_bound(CMempoolAddressDeltaKey{(*it).second, (*it).first});
+        while (ait != mapAddress.end() && (*ait).first.addressBytes == (*it).first && (*ait).first.type == (*it).second) {
+            results.push_back(*ait);
+            ait++;
+        }
+    }
+    return true;
+}
+
+void AddTransactionToMempool(const CTransactionRef& tx)
+{
+    LOCK(cs_mempool);
+    mapMempool.insert_or_assign(tx->GetHash(), tx);
+    if (fAddressIndex) {
+        CCoinsViewCacheOnly view;
+        FillTxInputCache(*tx, view);
+        AddSpentIndexToMempool(tx, view);
+        AddAddressIndexToMempool(tx, view);
+    }
+}
+
+void RemoveTransactionFromMempool(const CTransactionRef& tx)
+{
+    LOCK(cs_mempool);
+    mapMempool.erase(tx->GetHash());
+    if (fAddressIndex) {
+        RemoveSpentIndexFromMempool(tx->GetHash());
+        RemoveAddressIndexFromMempool(tx->GetHash());
+    }
+}
+
+std::vector<uint256> ClearMempool()
+{
+    LOCK(cs_mempool);
+    std::vector<uint256> hashes;
+    MempoolQueryHashes(hashes);
+    mapMempool.clear();
+    return hashes;
+}
+
+void MempoolQueryHashes(std::vector<uint256>& hashes)
+{
+    LOCK(cs_mempool);
+    hashes.clear();
+    hashes.reserve(mapMempool.size());
+    for (auto& [hash, _] : mapMempool)
+        hashes.push_back(hash);
+}
+
+CTransactionRef GetMempoolTransaction(const uint256& hash)
+{
+    LOCK(cs_mempool);
+    auto it = mapMempool.find(hash);
+    return it != mapMempool.end() ? it->second : nullptr;
+}
+
+}
diff --git a/src/omnicore/mempool.h b/src/omnicore/mempool.h
new file mode 100644
index 0000000000000..de9ae9863f226
--- /dev/null
+++ b/src/omnicore/mempool.h
@@ -0,0 +1,44 @@
+#ifndef BITCOIN_OMNICORE_MEMPOOL_H
+#define BITCOIN_OMNICORE_MEMPOOL_H
+
+#include <coins.h>
+#include <script/standard.h>
+#include <uint256.h>
+
+#include <stdint.h>
+#include <vector>
+
+class CSpentIndexKey;
+class CSpentIndexValue;
+
+namespace mastercore
+{
+
+struct CMempoolAddressDelta
+{
+    int64_t time = 0;
+    CAmount amount = 0;
+    uint256 prevhash;
+    unsigned int prevout = 0;
+};
+
+struct CMempoolAddressDeltaKey
+{
+    unsigned int type = 0;
+    uint256 addressBytes;
+    uint256 txhash;
+    unsigned int index = 0;
+    int spending = 0;
+};
+
+std::vector<uint256> ClearMempool();
+void MempoolQueryHashes(std::vector<uint256>& hashes);
+CTransactionRef GetMempoolTransaction(const uint256& hash);
+void AddTransactionToMempool(const CTransactionRef& tx);
+void RemoveTransactionFromMempool(const CTransactionRef& tx);
+bool GetSpentIndexFromMempool(const CSpentIndexKey& key, CSpentIndexValue& value);
+bool GetAddressIndexFromMempool(const std::vector<std::pair<uint256, unsigned>>& addresses, std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta>>& results);
+
+}
+
+#endif // BITCOIN_OMNICORE_MEMPOOL_H
diff --git a/src/omnicore/misc.cpp b/src/omnicore/misc.cpp
index 6a4290eba5ce0..e8622e7148703 100644
--- a/src/omnicore/misc.cpp
+++ b/src/omnicore/misc.cpp
@@ -6,12 +6,16 @@
 #include <httpserver.h>
 #include <key_io.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <validation.h>
 #include <util/strencodings.h>
 
+#include <omnicore/dbaddress.h>
+#include <omnicore/mempool.h>
 #include <omnicore/omnicore.h>
+#include <omnicore/rpc.h>
 #include <omnicore/script.h>
 #include <omnicore/utilsbitcoin.h>
 
@@ -22,15 +26,16 @@
 
 #include <univalue.h>
 
-bool getAddressesFromParams(const UniValue& params, std::vector<std::pair<uint256, int> > &addresses)
+using namespace mastercore;
+
+bool getAddressesFromParams(const UniValue& params, std::vector<std::pair<uint256, unsigned> > &addresses)
 {
     if (params[0].isStr()) {
-        uint256 hashBytes;
-        int type = 0;
-        if (!DecodeIndexKey(params[0].get_str(), hashBytes, type)) {
+        auto result = AddressToUint(params[0].get_str());
+        if (!result) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
         }
-        addresses.push_back(std::make_pair(hashBytes, type));
+        addresses.emplace_back(result->second, result->first);
     } else if (params[0].isObject()) {
 
         UniValue addressValues = find_value(params[0].get_obj(), "addresses");
@@ -41,13 +46,11 @@ bool getAddressesFromParams(const UniValue& params, std::vector<std::pair<uint25
         std::vector<UniValue> values = addressValues.getValues();
 
         for (std::vector<UniValue>::iterator it = values.begin(); it != values.end(); ++it) {
-
-            uint256 hashBytes;
-            int type = 0;
-            if (!DecodeIndexKey(it->get_str(), hashBytes, type)) {
+            auto result = AddressToUint(it->get_str());
+            if (!result) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
             }
-            addresses.push_back(std::make_pair(hashBytes, type));
+            addresses.emplace_back(result->second, result->first);
         }
     } else {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -154,21 +157,22 @@ UniValue getaddressdeltas(const JSONRPCRequest& request)
         }
     }
 
-    std::vector<std::pair<uint256, int> > addresses;
+    EnsureNotProcessingBlock();
+    std::vector<std::pair<uint256, unsigned>> addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
 
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    std::vector<std::pair<CAddressIndexKey, CAmount>> addressIndex;
 
-    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
+    for (auto it = addresses.begin(); it != addresses.end(); it++) {
         if (start > 0 && end > 0) {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex, start, end)) {
+            if (!pDbAddress->ReadAddressIndex((*it).first, (*it).second, addressIndex, start, end)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         } else {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex)) {
+            if (!pDbAddress->ReadAddressIndex((*it).first, (*it).second, addressIndex)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         }
@@ -195,32 +199,32 @@ UniValue getaddressdeltas(const JSONRPCRequest& request)
     UniValue result(UniValue::VOBJ);
 
     if (includeChainInfo && start > 0 && end > 0) {
-        LOCK(cs_main);
 
-        if (start > ::ChainActive().Height() || end > ::ChainActive().Height()) {
+        auto height = GetHeight();
+        if (start > height || end > height) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Start or end is outside chain range");
         }
 
-        CBlockIndex* startIndex = ::ChainActive()[start];
-        CBlockIndex* endIndex = ::ChainActive()[end];
-
-        UniValue startInfo(UniValue::VOBJ);
-        UniValue endInfo(UniValue::VOBJ);
+        auto* startIndex = GetActiveChain()[start];
+        auto* endIndex = GetActiveChain()[end];
 
-        startInfo.pushKV("hash", startIndex->GetBlockHash().GetHex());
-        startInfo.pushKV("height", start);
+        if (startIndex && endIndex) {
+            UniValue startInfo(UniValue::VOBJ);
+            UniValue endInfo(UniValue::VOBJ);
 
-        endInfo.pushKV("hash", endIndex->GetBlockHash().GetHex());
-        endInfo.pushKV("height", end);
+            startInfo.pushKV("hash", startIndex->GetBlockHash().GetHex());
+            startInfo.pushKV("height", start);
 
-        result.pushKV("deltas", deltas);
-        result.pushKV("start", startInfo);
-        result.pushKV("end", endInfo);
+            endInfo.pushKV("hash", endIndex->GetBlockHash().GetHex());
+            endInfo.pushKV("height", end);
 
-        return result;
-    } else {
-        return deltas;
+            result.pushKV("deltas", deltas);
+            result.pushKV("start", startInfo);
+            result.pushKV("end", endInfo);
+            return result;
+        }
     }
+    return deltas;
 }
 
 UniValue getaddressbalance(const JSONRPCRequest& request)
@@ -251,7 +255,8 @@ UniValue getaddressbalance(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_MISC_ERROR, "Address index not enabled");
     }
 
-    std::vector<std::pair<uint256, int> > addresses;
+    EnsureNotProcessingBlock();
+    std::vector<std::pair<uint256, unsigned>> addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -259,8 +264,8 @@ UniValue getaddressbalance(const JSONRPCRequest& request)
 
     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
 
-    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
-        if (!GetAddressIndex((*it).first, (*it).second, addressIndex)) {
+    for (auto it = addresses.begin(); it != addresses.end(); it++) {
+        if (!pDbAddress->ReadAddressIndex((*it).first, (*it).second, addressIndex)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
     }
@@ -338,7 +343,8 @@ UniValue getaddressutxos(const JSONRPCRequest& request)
         }
     }
 
-    std::vector<std::pair<uint256, int> > addresses;
+    EnsureNotProcessingBlock();
+    std::vector<std::pair<uint256, unsigned>> addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -346,8 +352,8 @@ UniValue getaddressutxos(const JSONRPCRequest& request)
 
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
 
-    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
-        if (!GetAddressUnspent((*it).first, (*it).second, unspentOutputs)) {
+    for (auto it = addresses.begin(); it != addresses.end(); it++) {
+        if (!pDbAddress->ReadAddressUnspentIndex((*it).first, (*it).second, unspentOutputs)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
     }
@@ -377,9 +383,9 @@ UniValue getaddressutxos(const JSONRPCRequest& request)
         UniValue result(UniValue::VOBJ);
         result.pushKV("utxos", utxos);
 
-        LOCK(cs_main);
-        result.pushKV("hash", ::ChainActive().Tip()->GetBlockHash().GetHex());
-        result.pushKV("height", (int)::ChainActive().Height());
+        auto blockIndex = GetActiveChain().Tip();
+        result.pushKV("hash", blockIndex->GetBlockHash().GetHex());
+        result.pushKV("height", blockIndex->nHeight);
         return result;
     } else {
         return utxos;
@@ -422,19 +428,15 @@ UniValue getaddressmempool(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_MISC_ERROR, "Address index not enabled");
     }
 
-    std::vector<std::pair<uint256, int> > addresses;
+    EnsureNotProcessingBlock();
+    std::vector<std::pair<uint256, unsigned>> addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
 
-    auto mempool = ::ChainstateActive().GetMempool();
-    if (!mempool) {
-        throw JSONRPCError(RPC_MISC_ERROR, "No mempool available");
-    }
-
-    std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> > indexes;
-    if (!mempool->getAddressIndex(addresses, indexes)) {
+    std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta>> indexes;
+    if (!GetAddressIndexFromMempool(addresses, indexes)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
     }
 
@@ -516,9 +518,10 @@ UniValue getblockhashes(const JSONRPCRequest& request)
         }
     }
 
+    EnsureNotProcessingBlock();
     std::vector<std::pair<uint256, unsigned int> > blockHashes;
 
-    if (!GetTimestampIndex(high, low, fActiveOnly, blockHashes)) {
+    if (!pDbAddress->ReadTimestampIndex(high, low, fActiveOnly, blockHashes)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for block hashes");
     }
 
@@ -575,13 +578,10 @@ UniValue getspentinfo(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid txid or index");
     }
 
-    uint256 txid = ParseHashV(txidValue, "txid");
-    int outputIndex = indexValue.getInt<int>();
-
-    CSpentIndexKey key(txid, outputIndex);
+    CSpentIndexKey key{ParseHashV(txidValue, "txid"), indexValue.getInt<unsigned>()};
     CSpentIndexValue value;
 
-    if (!GetSpentIndex(key, value)) {
+    if (!GetSpentIndexFromMempool(key, value) && !pDbAddress->ReadSpentIndex(key, value)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unable to get spent info");
     }
 
@@ -629,7 +629,8 @@ UniValue getaddresstxids(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_MISC_ERROR, "Address index not enabled");
     }
 
-    std::vector<std::pair<uint256, int> > addresses;
+    EnsureNotProcessingBlock();
+    std::vector<std::pair<uint256, unsigned>> addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -648,13 +649,13 @@ UniValue getaddresstxids(const JSONRPCRequest& request)
 
     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
 
-    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
+    for (auto it = addresses.begin(); it != addresses.end(); it++) {
         if (start > 0 && end > 0) {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex, start, end)) {
+            if (!pDbAddress->ReadAddressIndex((*it).first, (*it).second, addressIndex, start, end)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         } else {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex)) {
+            if (!pDbAddress->ReadAddressIndex((*it).first, (*it).second, addressIndex)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         }
@@ -703,19 +704,16 @@ static UniValue clearmempool(const JSONRPCRequest& request)
         }
     ).Check(request);
 
-    auto mempool = ::ChainstateActive().GetMempool();
-    if (!mempool)
-        throw JSONRPCError(RPC_MISC_ERROR, "No mempool available");
-
-    std::vector<uint256> vtxid;
-    mempool->queryHashes(vtxid);
+    auto& context = EnsureAnyNodeContext(request.context);
+    if (auto& mempool = context.mempool) {
+        mempool->clear();
+    }
 
+    auto vtxid = ClearMempool();
     UniValue removed(UniValue::VARR);
     for (const uint256& hash : vtxid)
         removed.push_back(hash.ToString());
 
-    mempool->clear();
-
     return removed;
 }
 
diff --git a/src/omnicore/nftdb.cpp b/src/omnicore/nftdb.cpp
index 390ca29af44b6..595af6a3290ef 100644
--- a/src/omnicore/nftdb.cpp
+++ b/src/omnicore/nftdb.cpp
@@ -8,6 +8,7 @@
 #include <omnicore/omnicore.h>
 #include <omnicore/errors.h>
 #include <omnicore/log.h>
+#include <omnicore/utilsbitcoin.h>
 
 #include <unordered_map>
 #include <utility>
@@ -18,63 +19,44 @@
 #include <stdint.h>
 #include <tuple>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
+struct BaseKey {
+    uint32_t propertyId = 0;
+    NonFungibleStorage type = NonFungibleStorage::None;
 
-typedef std::underlying_type<NonFungibleStorage>::type StorageType;
+    SERIALIZE_METHODS(BaseKey, obj) {
+        READWRITE(Using<BigEndian32>(obj.propertyId));
+        READWRITE(Using<Enum8>(obj.type));
+    }
+};
 
-struct NFTKey {
+struct NFTKey : BaseKey {
     static constexpr uint8_t prefix = 'A';
-    uint32_t propertyId = 0;
-    NonFungibleStorage type = NonFungibleStorage::None;
     int64_t tokenIdStart = 0;
     int64_t tokenIdEnd = 0;
 
-    template<typename Stream>
-    void Serialize(Stream& s) const
-    {
-        ser_writedata32be(s, propertyId);
-        ser_writedata8(s, static_cast<StorageType>(type));
-        ser_writedata64(s, tokenIdStart);
-        ser_writedata64(s, tokenIdEnd);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s)
-    {
-        propertyId = ser_readdata32be(s);
-        type = static_cast<NonFungibleStorage>(ser_readdata8(s));
-        tokenIdStart = ser_readdata64(s);
-        tokenIdEnd = ser_readdata64(s);
+    SERIALIZE_METHODS(NFTKey, obj) {
+        READWRITEAS(BaseKey, obj);
+        READWRITE(obj.tokenIdStart);
+        READWRITE(obj.tokenIdEnd);
     }
 
     std::string ToString() const
     {
-        return strprintf("%010d_%u_%020d-%020d", propertyId, static_cast<StorageType>(type), tokenIdStart, tokenIdEnd);
+        return strprintf("%010d_%u_%020d-%020d", propertyId, type, tokenIdStart, tokenIdEnd);
     }
 };
 
-inline bool Equal(const NFTKey& key, uint32_t propertyId, NonFungibleStorage type)
-{
-    return std::make_pair(key.propertyId, key.type) == std::make_pair(propertyId, type);
-}
-
 /* Gets the range a non-fungible token is in
  */
 std::pair<int64_t,int64_t> CMPNonFungibleTokensDB::GetRange(const uint32_t &propertyId, const int64_t &tokenId, const NonFungibleStorage type)
 {
-    CDBaseIterator it{NewIterator(), NFTKey{propertyId, type}};
-
+    CDBaseIterator it{NewIterator(), PartialKey<NFTKey>(BaseKey{propertyId, type})};
     for (; it; ++it) {
         auto nkey = it.Key<NFTKey>();
-        if (!Equal(nkey, propertyId, type)) {
-            break;
-        }
         if (tokenId >= nkey.tokenIdStart && tokenId <= nkey.tokenIdEnd) {
             return {nkey.tokenIdStart, nkey.tokenIdEnd};
         }
     }
-
     return std::make_pair(0, 0); // token not found, return zero'd range
 }
 
@@ -83,17 +65,13 @@ std::pair<int64_t,int64_t> CMPNonFungibleTokensDB::GetRange(const uint32_t &prop
 std::string CMPNonFungibleTokensDB::GetNonFungibleTokenValueInRange(const uint32_t &propertyId, const int64_t &rangeStart, const int64_t &rangeEnd)
 {
     auto rangeIndex = NonFungibleStorage::RangeIndex;
-    CDBaseIterator it{NewIterator(), NFTKey{propertyId, rangeIndex}};
+    CDBaseIterator it{NewIterator(), PartialKey<NFTKey>(BaseKey{propertyId, rangeIndex})};
     for (; it; ++it) {
         auto nkey = it.Key<NFTKey>();
-        if (!Equal(nkey, propertyId, rangeIndex)) {
-            break;
-        }
         if (rangeStart >= nkey.tokenIdStart && rangeEnd <= nkey.tokenIdEnd) {
             return it.Value().ToString();
         }
     }
-
     return {}; // range doesn't exist
 }
 
@@ -214,13 +192,9 @@ int64_t CMPNonFungibleTokensDB::GetHighestRangeEnd(const uint32_t &propertyId)
 {
     int64_t tokenCount = 0;
     auto rangeIndex = NonFungibleStorage::RangeIndex;
-    CDBaseIterator it{NewIterator(), NFTKey{propertyId, rangeIndex}};
-
+    CDBaseIterator it{NewIterator(), PartialKey<NFTKey>(BaseKey{propertyId, rangeIndex})};
     for (; it; ++it) {
         auto nkey = it.Key<NFTKey>();
-        if (!Equal(nkey, propertyId, rangeIndex)) {
-            break;
-        }
         tokenCount = std::max(tokenCount, std::max(nkey.tokenIdStart, nkey.tokenIdEnd));
     }
     return tokenCount;
@@ -230,16 +204,8 @@ struct DBHeightKey {
     static constexpr uint8_t prefix = 'H';
     int height;
 
-    template<typename Stream>
-    void Serialize(Stream& s) const
-    {
-        ser_writedata32be(s, height);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s)
-    {
-        height = ser_readdata32be(s);
+    SERIALIZE_METHODS(DBHeightKey, obj) {
+        READWRITE(Using<BigEndian32>(obj.height));
     }
 };
 
@@ -279,7 +245,7 @@ void CMPNonFungibleTokensDB::WriteBlockCache(int height, bool sanityCheck)
 
 void CMPNonFungibleTokensDB::RollBackAboveBlock(int height)
 {
-    leveldb::WriteBatch batch;
+    CDBWriteBatch batch;
     std::unordered_map<std::string, CRollbackData> changes;
     CDBaseIterator it{NewIterator(), DBHeightKey{height}};
     for (; it; ++it) {
@@ -293,19 +259,17 @@ void CMPNonFungibleTokensDB::RollBackAboveBlock(int height)
         if (m_it->second.type == CRollbackData::DELETE_KEY) {
             batch.Delete(m_it->first);
         } else {
-            batch.Put(m_it->first, m_it->second.data);
+            batch.Write(m_it->first, m_it->second.data);
         }
     }
-    assert(pdb);
-    pdb->Write(writeoptions, &batch);
+    WriteBatch(batch);
 }
 
 void CMPNonFungibleTokensDB::StoreBlockCache(const std::string& key)
 {
     if (blockData.find(key) == blockData.end()) {
         CRollbackData rollback{CRollbackData::PERSIST_KEY, {}};
-        leveldb::Status status = pdb->Get(readoptions, key, &rollback.data);
-        if (status.IsNotFound()) {
+        if (!Read(key, rollback.data)) {
             rollback.type = CRollbackData::DELETE_KEY;
         }
         blockData.emplace(key, std::move(rollback));
@@ -376,18 +340,13 @@ std::pair<int64_t,int64_t> CMPNonFungibleTokensDB::CreateNonFungibleTokens(const
  */
 std::string CMPNonFungibleTokensDB::GetNonFungibleTokenValue(const uint32_t &propertyId, const int64_t &tokenId, const NonFungibleStorage type)
 {
-    CDBaseIterator it{NewIterator(), NFTKey{propertyId, type}};
-
+    CDBaseIterator it{NewIterator(), PartialKey<NFTKey>(BaseKey{propertyId, type})};
     for (; it; ++it) {
         auto nkey = it.Key<NFTKey>();
-        if (!Equal(nkey, propertyId, type)) {
-            break;
-        }
         if (tokenId >= nkey.tokenIdStart && tokenId <= nkey.tokenIdEnd) {
             return it.Value().ToString();
         }
     }
-
     return {}; // not found
 }
 
@@ -396,23 +355,14 @@ std::string CMPNonFungibleTokensDB::GetNonFungibleTokenValue(const uint32_t &pro
 std::map<uint32_t, std::vector<std::pair<int64_t, int64_t>>> CMPNonFungibleTokensDB::GetAddressNonFungibleTokens(const uint32_t &propertyId, const std::string &address)
 {
     std::map<uint32_t, std::vector<std::pair<int64_t, int64_t>>> uniqueMap;
-
     auto rangeIndex = NonFungibleStorage::RangeIndex;
-    CDBaseIterator it{NewIterator(), NFTKey{propertyId, rangeIndex}};
-
+    CDBaseIterator it{NewIterator()};
+    if (propertyId) it.Seek(PartialKey<NFTKey>(BaseKey{propertyId, rangeIndex}));
     for (; it; ++it) {
         auto nkey = it.Key<NFTKey>();
-        if (propertyId != 0 && !Equal(nkey, propertyId, rangeIndex)) {
-            break;
-        }
-        if (nkey.type != rangeIndex) {
-            continue;
-        }
-        if (it.Value() != address) continue;
-
+        if (nkey.type != rangeIndex || it.Value() != address) continue;
         uniqueMap[nkey.propertyId].emplace_back(nkey.tokenIdStart, nkey.tokenIdEnd);
     }
-
     return uniqueMap;
 }
 
@@ -421,18 +371,12 @@ std::map<uint32_t, std::vector<std::pair<int64_t, int64_t>>> CMPNonFungibleToken
 std::vector<std::pair<std::string,std::pair<int64_t,int64_t>>> CMPNonFungibleTokensDB::GetNonFungibleTokenRanges(const uint32_t &propertyId)
 {
     std::vector<std::pair<std::string,std::pair<int64_t,int64_t>>> rangeMap;
-
     auto rangeIndex = NonFungibleStorage::RangeIndex;
-    CDBaseIterator it{NewIterator(), NFTKey{propertyId, rangeIndex}};
-
+    CDBaseIterator it{NewIterator(), PartialKey<NFTKey>(BaseKey{propertyId, rangeIndex})};
     for (; it; ++it) {
         auto nkey = it.Key<NFTKey>();
-        if (!Equal(nkey, propertyId, rangeIndex)) {
-            break;
-        }
         rangeMap.emplace_back(it.Value().ToString(), std::make_pair(nkey.tokenIdStart, nkey.tokenIdEnd));
     }
-
     return rangeMap;
 }
 
@@ -447,12 +391,9 @@ void CMPNonFungibleTokensDB::SanityCheck()
         assert(StringToKey(data.first, key));
         if (key.type != NonFungibleStorage::RangeIndex) continue;
         if (totals.count(key.propertyId)) continue;
-        CDBaseIterator it{NewIterator(), NFTKey{key.propertyId, key.type}};
+        CDBaseIterator it{NewIterator(), PartialKey<NFTKey>(BaseKey{key.propertyId, key.type})};
         for (; it; ++it) {
             auto nkey = it.Key<NFTKey>();
-            if (!Equal(nkey, key.propertyId, key.type)) {
-                break;
-            }
             auto& prop = totals[nkey.propertyId];
             prop = std::max(prop, nkey.tokenIdEnd);
         }
@@ -461,8 +402,7 @@ void CMPNonFungibleTokensDB::SanityCheck()
     for (std::map<uint32_t,int64_t>::iterator it = totals.begin(); it != totals.end(); ++it) {
         auto total = mastercore::getTotalTokens(it->first);
         if (total != it->second) {
-            BlockValidationState state;
-            AbortNode(state, strprintf("Failed sanity check on property %d (%d != %d)\n", it->first, total, it->second));
+            mastercore::MayAbortNode(strprintf("Failed sanity check on property %d (%d != %d)\n", it->first, total, it->second));
         } else if (msc_debug_nftdb) {
             result += strprintf("%d:%d=%d,", it->first, total, it->second);
         }
@@ -480,7 +420,6 @@ void CMPNonFungibleTokensDB::printAll()
 {
     int count = 0;
     CDBaseIterator it{NewIterator(), NFTKey{0}};
-
     for(; it; ++it) {
         auto skey = it.Key<NFTKey>();
         auto svalue = it.Value();
@@ -489,4 +428,3 @@ void CMPNonFungibleTokensDB::printAll()
 //      PrintToLog("entry #%8d= %s:%s\n", count, skey.ToString(), svalue.ToString());
     }
 }
-
diff --git a/src/omnicore/nftdb.h b/src/omnicore/nftdb.h
index c1a286ef7c3d9..7525e8c63e8b0 100644
--- a/src/omnicore/nftdb.h
+++ b/src/omnicore/nftdb.h
@@ -9,7 +9,7 @@
 #include <fs.h>
 #include <stdint.h>
 
-enum class NonFungibleStorage : unsigned char
+enum NonFungibleStorage : uint8_t
 {
     None       = 0,
     RangeIndex = 'R',
diff --git a/src/omnicore/notifications.cpp b/src/omnicore/notifications.cpp
index 778890e3fbd45..d4feade929b58 100644
--- a/src/omnicore/notifications.cpp
+++ b/src/omnicore/notifications.cpp
@@ -8,9 +8,6 @@
 #include <util/system.h>
 #include <node/interface_ui.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stdint.h>
 #include <string>
 #include <vector>
diff --git a/src/omnicore/omnicore.cpp b/src/omnicore/omnicore.cpp
index a17478db5019b..7f0000a9fc7ea 100644
--- a/src/omnicore/omnicore.cpp
+++ b/src/omnicore/omnicore.cpp
@@ -4,11 +4,16 @@
  * This file contains the core of Omni Core.
  */
 
+#include <atomic>
+#include <cstdint>
+#include <memory>
 #include <omnicore/omnicore.h>
 
 #include <omnicore/activation.h>
+#include <omnicore/coinscache.h>
 #include <omnicore/consensushash.h>
 #include <omnicore/convert.h>
+#include <omnicore/dbaddress.h>
 #include <omnicore/dbbase.h>
 #include <omnicore/dbfees.h>
 #include <omnicore/dbspinfo.h>
@@ -17,8 +22,10 @@
 #include <omnicore/dbtransaction.h>
 #include <omnicore/dbtxlist.h>
 #include <omnicore/dex.h>
+#include <omnicore/errors.h>
 #include <omnicore/log.h>
 #include <omnicore/mdex.h>
+#include <omnicore/mempool.h>
 #include <omnicore/notifications.h>
 #include <omnicore/parsing.h>
 #include <omnicore/pending.h>
@@ -40,7 +47,6 @@
 #include <core_io.h>
 #include <fs.h>
 #include <key_io.h>
-#include <index/txindex.h>
 #include <init.h>
 #include <validation.h>
 #include <primitives/block.h>
@@ -57,20 +63,16 @@
 #include <util/system.h>
 #include <util/strencodings.h>
 #include <util/time.h>
+#include <validationinterface.h>
 #ifdef ENABLE_WALLET
 #include <wallet/ismine.h>
 #include <wallet/wallet.h>
 #endif
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <assert.h>
 #include <stdint.h>
 #include <stdio.h>
 
-#include <functional>
-#include <optional>
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -78,6 +80,8 @@
 
 using namespace mastercore;
 
+bool fAddressIndex = false;
+
 //! Global lock for state objects
 RecursiveMutex cs_tally;
 
@@ -102,11 +106,6 @@ static const int64_t all_reward = 5631623576222;
 //! Seconds per year used for Dev OMNI calculations
 static const double seconds_in_one_year = 31556926;
 
-static int nWaterlineBlock = 0;
-
-//! Last processed block
-static int lastProcessedBlock = 0;
-
 /**
  * Used to indicate, whether to automatically commit created transactions.
  *
@@ -115,16 +114,11 @@ static int lastProcessedBlock = 0;
 bool autoCommit = true;
 
 //! Number of "Dev Omni" of the last processed block
-int64_t exodus_prev = 0;
+std::atomic<int64_t> exodus_prev = 0;
 
 //! Path for file based persistence
 fs::path pathStateFiles;
 
-//! Flag to indicate whether there was a block reorganisatzion
-static int reorgRecoveryMode = 0;
-//! Block height to recover from after a block reorganization
-static int reorgRecoveryMaxHeight = 0;
-
 //! LevelDB based storage for currencies, smart properties and tokens
 CMPSPInfo* mastercore::pDbSpInfo;
 //! LevelDB based storage for transactions, with txid as key and validity bit, and other data as value
@@ -140,7 +134,11 @@ COmniFeeCache* mastercore::pDbFeeCache;
 //! LevelDB based storage for the MetaDEx fee distributions
 COmniFeeHistory* mastercore::pDbFeeHistory;
 //! LevelDB based storage for UITs
-CMPNonFungibleTokensDB *mastercore::pDbNFT;
+CMPNonFungibleTokensDB* mastercore::pDbNFT;
+//! LevelDB based storage fo experimental btc addresses
+COmniAddressDB* mastercore::pDbAddress;
+//! LevelDB snapshot based storage for coins cache
+COmniCoinsCache* mastercore::pCoinsCache;
 
 //! In-memory collection of DEx offers
 OfferMap mastercore::my_offers;
@@ -357,24 +355,19 @@ void mastercore::enableFreezing(uint32_t propertyId, int liveBlock)
 void mastercore::disableFreezing(uint32_t propertyId)
 {
     int liveBlock = 0;
-    for (std::set<std::pair<uint32_t,int> >::iterator it = setFreezingEnabledProperties.begin(); it != setFreezingEnabledProperties.end(); it++) {
-        if (propertyId == (*it).first) {
-            liveBlock = (*it).second;
-        }
+    auto it = setFreezingEnabledProperties.lower_bound(std::make_pair(propertyId, 0));
+    if (it != setFreezingEnabledProperties.end() && it->first == propertyId) {
+        liveBlock = it->second;
+        setFreezingEnabledProperties.erase(it);
     }
     assert(liveBlock > 0);
-
-    setFreezingEnabledProperties.erase(std::make_pair(propertyId, liveBlock));
     PrintToLog("Freezing for property %d has been disabled.\n", propertyId);
 
     // When disabling freezing for a property, all frozen addresses for that property will be unfrozen!
-    for (std::set<std::pair<std::string,uint32_t> >::iterator it = setFrozenAddresses.begin(); it != setFrozenAddresses.end(); ) {
+    for (auto it = setFrozenAddresses.begin(); it != setFrozenAddresses.end(); ) {
         if ((*it).second == propertyId) {
             PrintToLog("Address %s has been unfrozen for property %d.\n", (*it).first, propertyId);
             it = setFrozenAddresses.erase(it);
-            if (it != setFrozenAddresses.end()) {
-                assert(!isAddressFrozen((*it).first, (*it).second));
-            }
         } else {
             it++;
         }
@@ -385,14 +378,8 @@ void mastercore::disableFreezing(uint32_t propertyId)
 
 bool mastercore::isFreezingEnabled(uint32_t propertyId, int block)
 {
-    for (std::set<std::pair<uint32_t,int> >::iterator it = setFreezingEnabledProperties.begin(); it != setFreezingEnabledProperties.end(); it++) {
-        uint32_t itemPropertyId = (*it).first;
-        int itemBlock = (*it).second;
-        if (propertyId == itemPropertyId && block >= itemBlock) {
-            return true;
-        }
-    }
-    return false;
+    auto it = setFreezingEnabledProperties.lower_bound(std::make_pair(propertyId, 0));
+    return it != setFreezingEnabledProperties.end() && it->first == propertyId && block >= it->second;
 }
 
 void mastercore::freezeAddress(const std::string& address, uint32_t propertyId)
@@ -411,10 +398,7 @@ void mastercore::unfreezeAddress(const std::string& address, uint32_t propertyId
 
 bool mastercore::isAddressFrozen(const std::string& address, uint32_t propertyId)
 {
-    if (setFrozenAddresses.find(std::make_pair(address, propertyId)) != setFrozenAddresses.end()) {
-        return true;
-    }
-    return false;
+    return setFrozenAddresses.count(std::make_pair(address, propertyId));
 }
 
 std::string mastercore::getTokenLabel(uint32_t propertyId)
@@ -500,7 +484,7 @@ bool mastercore::update_tally_map(const std::string& who, uint32_t propertyId, i
     if (my_it == mp_tally_map.end()) {
         // insert an empty element
         my_it = (mp_tally_map.insert(std::make_pair(who, CMPTally()))).first;
-        if (fQtMode && IsMyAddressAllWallets(who, false, wallet::ISMINE_SPENDABLE)) {
+        if (fQtMode && IsMyAddressAllWallets(who)) {
             wallet_addresses.insert(who);
         }
     }
@@ -563,7 +547,7 @@ static int64_t calculate_devmsc(unsigned int nTime)
  * @param nTime  The timestamp of the block to update the "Dev MSC" for
  * @return The number of "Dev MSC" generated
  */
-static int64_t calculate_and_update_devmsc(unsigned int nTime, int block)
+int64_t calculate_and_update_devmsc(unsigned int nTime, int block)
 {
     // Allow disable of Dev MSC for fee cache test on regtest only
     if (Params().NetworkIDString() == CBaseChainParams::REGTEST && gArgs.GetBoolArg("-disabledevmsc", false)) {
@@ -621,12 +605,6 @@ void NotifyTotalTokensChanged(uint32_t propertyId, int block)
 
 void CheckWalletUpdate()
 {
-#ifdef ENABLE_WALLET
-    if (!HasWallets()) {
-        return;
-    }
-#endif
-
     // because the wallet balance cache is *only* used by the UI, it's not needed,
     // when the daemon is running without UI.
     if (!fQtMode) {
@@ -659,8 +637,7 @@ void CheckWalletUpdate()
         wallet_addresses.clear();
         // populate global balance totals and wallet property list - note global balances do not include additional balances from watch-only addresses
         for (std::unordered_map<std::string, CMPTally>::iterator my_it = mp_tally_map.begin(); my_it != mp_tally_map.end(); ++my_it) {
-            int addressIsMine = IsMyAddressAllWallets(my_it->first, false, wallet::ISMINE_SPENDABLE);
-            if (!addressIsMine) continue;
+            if (!IsMyAddressAllWallets(my_it->first)) continue;
             wallet_addresses.insert(my_it->first);
             update_tally(my_it->first, my_it->second);
         }
@@ -712,68 +689,6 @@ static std::set<uint256> setMarkerCache;
 //! Guards marker cache
 static RecursiveMutex cs_marker_cache;
 
-/**
- * Checks, if transaction has any Omni marker.
- *
- * Note: this may include invalid or malformed Omni Layer transactions!
- *
- * MUST NOT BE USED FOR CONSENSUS CRITICAL STUFF!
- */
-static bool HasMarkerUnsafe(const CTransactionRef& tx)
-{
-    const std::string strClassC("6f6d6e69");
-    const std::string strClassAB("76a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac");
-    const std::string strClassABTest("76a914643ce12b1590633077b8620316f43a9362ef18e588ac");
-    const std::string strClassMoney("76a9145ab93563a289b74c355a9b9258b86f12bb84affb88ac");
-
-    for (unsigned int n = 0; n < tx->vout.size(); ++n) {
-        const CTxOut& out = tx->vout[n];
-        std::string str = HexStr(out.scriptPubKey.begin(), out.scriptPubKey.end());
-
-        if (str.find(strClassC) != std::string::npos) {
-            return true;
-        }
-
-        if (MainNet()) {
-            if (str == strClassAB) {
-                return true;
-            }
-        } else {
-            if (str == strClassABTest) {
-                return true;
-            }
-            if (str == strClassMoney) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-/** Scans for marker and if one is found, add transaction to marker cache. */
-void TryToAddToMarkerCache(const CTransactionRef &tx)
-{
-    if (HasMarkerUnsafe(tx)) {
-        LOCK(cs_marker_cache);
-        setMarkerCache.insert(tx->GetHash());
-    }
-}
-
-/** Removes transaction from marker cache. */
-void RemoveFromMarkerCache(const uint256& txHash)
-{
-    LOCK(cs_marker_cache);
-    setMarkerCache.erase(txHash);
-}
-
-/** Checks, if transaction is in marker cache. */
-bool IsInMarkerCache(const uint256& txHash)
-{
-    LOCK(cs_marker_cache);
-    return (setMarkerCache.find(txHash) != setMarkerCache.end());
-}
-
 /**
  * Returns the encoding class, used to embed a payload.
  *
@@ -879,58 +794,23 @@ int mastercore::GetEncodingClass(const CTransaction& tx, int nBlock)
     return NO_MARKER;
 }
 
-// TODO: move
-CCoinsView mastercore::viewDummy;
-CCoinsViewCache mastercore::view(&viewDummy);
-
-//! Guards coins view cache
-RecursiveMutex mastercore::cs_tx_cache;
-
-static unsigned int nCacheHits = 0;
-static unsigned int nCacheMiss = 0;
-
 /**
  * Fetches transaction inputs and adds them to the coins view cache.
  *
- * Note: cs_tx_cache should be locked, when adding and accessing inputs!
- *
  * @param tx[in]  The transaction to fetch inputs for
  * @return True, if all inputs were successfully added to the cache
  */
-static bool FillTxInputCache(const CTransaction& tx, const std::shared_ptr<std::map<COutPoint, Coin>> removedCoins)
+bool FillTxInputCache(const CTransaction& tx, CCoinsViewCache& view)
 {
-    static const unsigned int nCacheSize = gArgs.GetIntArg("-omnitxcache", 500000);
-
-    if (view.GetCacheSize() > nCacheSize) {
-        PrintToLog("%s(): clearing cache before insertion [size=%d, hit=%d, miss=%d]\n",
-                __func__, view.GetCacheSize(), nCacheHits, nCacheMiss);
-        view.Flush();
-    }
-
-    for (std::vector<CTxIn>::const_iterator it = tx.vin.begin(); it != tx.vin.end(); ++it) {
-        const CTxIn& txIn = *it;
-        unsigned int nOut = txIn.prevout.n;
+    for (auto& txIn : tx.vin) {
         const Coin& coin = view.AccessCoin(txIn.prevout);
 
         if (!coin.IsSpent()) {
-            ++nCacheHits;
             continue;
-        } else {
-            ++nCacheMiss;
         }
 
-        CTransactionRef txPrev;
-        uint256 hashBlock;
         Coin newcoin;
-        std::map<COutPoint, Coin>::const_iterator rm_it;
-        if (removedCoins && ((rm_it = removedCoins->find(txIn.prevout)) != removedCoins->end())) {
-            newcoin = rm_it->second;
-        } else if (GetTransaction(txIn.prevout.hash, txPrev, Params().GetConsensus(), hashBlock)) {
-            newcoin.out.scriptPubKey = txPrev->vout[nOut].scriptPubKey;
-            newcoin.out.nValue = txPrev->vout[nOut].nValue;
-            auto index = ::GetBlockIndex(hashBlock);
-            newcoin.nHeight = index ? index->nHeight : 1;
-        } else {
+        if (!GetCoin(txIn.prevout, newcoin)) {
             return false;
         }
 
@@ -946,38 +826,35 @@ static bool FillTxInputCache(const CTransaction& tx, const std::shared_ptr<std::
 // RETURNS: 0 if parsed a MP TX
 // RETURNS: < 0 if a non-MP-TX or invalid
 // RETURNS: >0 if 1 or more payments have been made
-static int parseTransaction(bool bRPConly, const CTransaction& wtx, int nBlock, unsigned int idx, CMPTransaction& mp_tx, unsigned int nTime, const std::shared_ptr<std::map<COutPoint, Coin>> removedCoins = nullptr)
+static int parseTransaction(bool bRPConly, CCoinsViewCache& view, const CTransaction& wtx, int nBlock, unsigned int idx, CMPTransaction& mp_tx, unsigned int nTime)
 {
     assert(bRPConly == mp_tx.isRpcOnly());
-    mp_tx.Set(wtx.GetHash(), nBlock, idx, nTime);
 
     // ### CLASS IDENTIFICATION AND MARKER CHECK ###
     int omniClass = GetEncodingClass(wtx, nBlock);
-
     if (omniClass == NO_MARKER) {
         return -1; // No Exodus/Omni marker, thus not a valid Omni transaction
     }
 
+    mp_tx.Set(wtx.GetHash(), nBlock, idx, nTime);
+
     if (!bRPConly || msc_debug_parser_readonly) {
         PrintToLog("____________________________________________________________________________________________________________________________________\n");
-        PrintToLog("%s(block=%d, %s idx= %d); txid: %s\n", __FUNCTION__, nBlock, FormatISO8601DateTime(nTime), idx, wtx.GetHash().GetHex());
+        PrintToLog("%s(block=%d, %s idx= %d); txid: %s\n", __func__, nBlock, FormatISO8601DateTime(nTime), idx, wtx.GetHash().GetHex());
     }
 
     // ### SENDER IDENTIFICATION ###
     std::string strSender;
     int64_t inAll = 0;
 
-    { // needed to ensure the cache isn't cleared in the meantime when doing parallel queries
-    // To avoid potential dead lock warning
-    // cs_main for FillTxInputCache() > GetTransaction()
-    // mempool.cs for FillTxInputCache() > GetTransaction() > mempool.get()
-    auto mempool = ::ChainstateActive().GetMempool();
-    assert(mempool);
-    LOCK2(cs_main, mempool->cs);
-    LOCK(cs_tx_cache);
+    bool forceOverride = true;
+    bool isCoinbase = wtx.IsCoinBase();
+    const uint256& txid = wtx.GetHash();
+    for (size_t i = 0; i < wtx.vout.size(); ++i)
+        view.AddCoin(COutPoint(txid, i), Coin(wtx.vout[i], nBlock, isCoinbase), forceOverride);
 
     // Add previous transaction inputs to the cache
-    if (!FillTxInputCache(wtx, removedCoins)) {
+    if (!FillTxInputCache(wtx, view)) {
         PrintToLog("%s() ERROR: failed to get inputs for %s\n", __func__, wtx.GetHash().GetHex());
         return -101;
     }
@@ -1054,8 +931,6 @@ static int parseTransaction(bool bRPConly, const CTransaction& wtx, int nBlock,
 
     inAll = view.GetValueIn(wtx);
 
-    } // end of LOCK(cs_tx_cache)
-
     int64_t outAll = wtx.GetValueOut();
     int64_t txFee = inAll - outAll; // miner fee
 
@@ -1386,9 +1261,9 @@ static int parseTransaction(bool bRPConly, const CTransaction& wtx, int nBlock,
 /**
  * Provides access to parseTransaction in read-only mode.
  */
-int ParseTransaction(const CTransaction& tx, int nBlock, unsigned int idx, CMPTransaction& mptx, unsigned int nTime)
+int ParseTransaction(CCoinsViewCache& view, const CTransaction& tx, int nBlock, unsigned int idx, CMPTransaction& mptx, unsigned int nTime)
 {
-    return parseTransaction(true, tx, nBlock, idx, mptx, nTime);
+    return parseTransaction(true, view, tx, nBlock, idx, mptx, nTime);
 }
 
 /**
@@ -1449,179 +1324,6 @@ static bool HandleExodusPurchase(const CTransaction& tx, int nBlock, const std::
     return false;
 }
 
-/**
- * Reports the progress of the initial transaction scanning.
- *
- * The progress is printed to the console, written to the debug log file, and
- * the RPC status, as well as the splash screen progress label, are updated.
- *
- * @see msc_initial_scan()
- */
-class ProgressReporter
-{
-private:
-    const CBlockIndex* m_pblockFirst;
-    const CBlockIndex* m_pblockLast;
-    const int64_t m_timeStart;
-
-    /** Returns the estimated remaining time in milliseconds. */
-    int64_t estimateRemainingTime(double progress) const
-    {
-        int64_t timeSinceStart = GetTimeMillis() - m_timeStart;
-
-        double timeRemaining = 3600000.0; // 1 hour
-        if (progress > 0.0 && timeSinceStart > 0) {
-            timeRemaining = (100.0 - progress) / progress * timeSinceStart;
-        }
-
-        return static_cast<int64_t>(timeRemaining);
-    }
-
-    /** Converts a time span to a human readable string. */
-    std::string remainingTimeAsString(int64_t remainingTime) const
-    {
-        int64_t secondsTotal = 0.001 * remainingTime;
-        int64_t hours = secondsTotal / 3600;
-        int64_t minutes = (secondsTotal / 60) % 60;
-        int64_t seconds = secondsTotal % 60;
-
-        if (hours > 0) {
-            return strprintf("%d:%02d:%02d hours", hours, minutes, seconds);
-        } else if (minutes > 0) {
-            return strprintf("%d:%02d minutes", minutes, seconds);
-        } else {
-            return strprintf("%d seconds", seconds);
-        }
-    }
-
-public:
-    ProgressReporter(const CBlockIndex* pblockFirst, const CBlockIndex* pblockLast)
-    : m_pblockFirst(pblockFirst), m_pblockLast(pblockLast), m_timeStart(GetTimeMillis())
-    {
-    }
-
-    /** Prints the current progress to the console and notifies the UI. */
-    void update(const CBlockIndex* pblockNow) const
-    {
-        int nLastBlock = m_pblockLast->nHeight;
-        int nCurrentBlock = pblockNow->nHeight;
-        unsigned int nFirst = m_pblockFirst->nChainTx;
-        unsigned int nCurrent = pblockNow->nChainTx;
-        unsigned int nLast = m_pblockLast->nChainTx;
-
-        double dProgress = 100.0 * (nCurrent - nFirst) / (nLast - nFirst);
-        int64_t nRemainingTime = estimateRemainingTime(dProgress);
-
-        std::string strProgress = strprintf(
-                "Still scanning.. at block %d of %d. Progress: %.2f %%, about %s remaining..\n",
-                nCurrentBlock, nLastBlock, dProgress, remainingTimeAsString(nRemainingTime));
-        std::string strProgressUI = strprintf(
-                "Still scanning.. at block %d of %d.\nProgress: %.2f %% (about %s remaining)",
-                nCurrentBlock, nLastBlock, dProgress, remainingTimeAsString(nRemainingTime));
-
-        PrintToConsole(strProgress);
-        uiInterface.InitMessage(strProgressUI);
-    }
-};
-
-/**
- * Scans the blockchain for meta transactions.
- *
- * It scans the blockchain, starting at the given block index, to the current
- * tip, much like as if new block were arriving and being processed on the fly.
- *
- * Every 30 seconds the progress of the scan is reported.
- *
- * In case the current block being processed is not part of the active chain, or
- * if a block could not be retrieved from the disk, then the scan stops early.
- * Likewise, global shutdown requests are honored, and stop the scan progress.
- *
- * @see mastercore_handler_block_begin()
- * @see mastercore_handler_tx()
- * @see mastercore_handler_block_end()
- *
- * @param nFirstBlock[in]  The index of the first block to scan
- * @return An exit code, indicating success or failure
- */
-static int msc_initial_scan(int nFirstBlock)
-{
-    int nTimeBetweenProgressReports = gArgs.GetIntArg("-omniprogressfrequency", 30);  // seconds
-    int64_t nNow = GetTime();
-    unsigned int nTxsTotal = 0;
-    unsigned int nTxsFoundTotal = 0;
-    int nBlock = 999999;
-    const int nLastBlock = GetHeight();
-
-    // this function is useless if there are not enough blocks in the blockchain yet!
-    if (nFirstBlock < 0 || nLastBlock < nFirstBlock) return -1;
-    PrintToConsole("Scanning for transactions in block %d to block %d..\n", nFirstBlock, nLastBlock);
-
-    const CBlockIndex* pFirstBlock;
-    const CBlockIndex* pLastBlock;
-    {
-        LOCK(cs_main);
-        // used to print the progress to the console and notifies the UI
-        pFirstBlock = ::ChainActive()[nFirstBlock];
-        pLastBlock = ::ChainActive()[nLastBlock];
-    }
-
-    ProgressReporter progressReporter(pFirstBlock, pLastBlock);
-
-    // check if using seed block filter should be disabled
-    bool seedBlockFilterEnabled = gArgs.GetBoolArg("-omniseedblockfilter", true);
-
-    for (nBlock = nFirstBlock; nBlock <= nLastBlock; ++nBlock)
-    {
-        if (ShutdownRequested()) {
-            PrintToLog("Shutdown requested, stop scan at block %d of %d\n", nBlock, nLastBlock);
-            break;
-        }
-
-        CBlockIndex* pblockindex;
-        {
-            LOCK(cs_main);
-            pblockindex = ::ChainActive()[nBlock];
-        }
-
-        if (nullptr == pblockindex) break;
-        std::string strBlockHash = pblockindex->GetBlockHash().GetHex();
-
-        if (msc_debug_exo) PrintToLog("%s(%d; max=%d):%s, line %d, file: %s\n",
-            __FUNCTION__, nBlock, nLastBlock, strBlockHash, __LINE__, __FILE__);
-
-        if (GetTime() >= nNow + nTimeBetweenProgressReports) {
-            progressReporter.update(pblockindex);
-            nNow = GetTime();
-        }
-
-        unsigned int nTxNum = 0;
-        unsigned int nTxsFoundInBlock = 0;
-        mastercore_handler_block_begin(nBlock, pblockindex);
-
-        if (!seedBlockFilterEnabled || !SkipBlock(nBlock)) {
-            CBlock block;
-            if (!node::ReadBlockFromDisk(block, pblockindex, Params().GetConsensus())) break;
-
-            for(const auto& tx : block.vtx) {
-                if (mastercore_handler_tx(*tx, nBlock, nTxNum, pblockindex, nullptr)) ++nTxsFoundInBlock;
-                ++nTxNum;
-            }
-        }
-
-        nTxsFoundTotal += nTxsFoundInBlock;
-        nTxsTotal += nTxNum;
-        mastercore_handler_block_end(nBlock, pblockindex, nTxsFoundInBlock);
-    }
-
-    if (nBlock < nLastBlock) {
-        PrintToConsole("Scan stopped early at block %d of block %d\n", nBlock, nLastBlock);
-    }
-
-    PrintToConsole("%d new transactions processed, %d meta transactions found\n", nTxsTotal, nTxsFoundTotal);
-
-    return 0;
-}
-
 /**
  * Clears the state of the system.
  */
@@ -1651,56 +1353,85 @@ void clear_all_state()
     pDbFeeCache->Clear();
     pDbFeeHistory->Clear();
     pDbNFT->Clear();
+    pDbAddress->Clear();
+    pCoinsCache->Clear();
     assert(pDbTransactionList->setDBVersion() == DB_VERSION); // new set of databases, set DB version
     exodus_prev = 0;
 }
 
-void RewindDBsAndState(int nHeight, int nBlockPrev = 0, bool fInitialParse = false)
-{
-    int nWaterline;
-    bool reorgContainsFreeze;
-    {
-        LOCK(cs_tally);
-        // Check if any freeze related transactions would be rolled back - if so wipe the state and startclean
-        reorgContainsFreeze = pDbTransactionList->CheckForFreezeTxs(nHeight);
+using activation = std::pair<std::pair<int, uint32_t>, uint256>;
 
-        // NOTE: The blockNum parameter is inclusive, so deleteAboveBlock(1000) will delete records in block 1000 and above.
-        pDbTransactionList->isMPinBlockRange(nHeight, reorgRecoveryMaxHeight, true);
-        pDbTradeList->deleteAboveBlock(nHeight);
-        pDbStoList->deleteAboveBlock(nHeight);
-        pDbFeeCache->RollBackCache(nHeight);
-        pDbFeeHistory->RollBackHistory(nHeight);
-        pDbNFT->RollBackAboveBlock(nHeight);
-        reorgRecoveryMaxHeight = 0;
+static void ProcessActivations(int blockHeight, const std::vector<activation>& activations)
+{
+    int txnsLoaded = 0;
+    CCoinsViewCacheOnly view;
+    for (const auto& [_, hash] : activations) {
+        int wtxBlock;
+        CTransactionRef wtx;
+        CMPTransaction mp_obj;
 
-        nWaterline = ConsensusParams().GENESIS_BLOCK - 1;
+        if (!GetTransaction(hash, wtx, wtxBlock)) {
+            PrintToLog("ERROR: While loading activation transaction %s: tx in levelDB but does not exist.\n", hash.GetHex());
+            continue;
+        }
+        if (wtxBlock > blockHeight) {
+            continue;
+        }
+        if (0 != ParseTransaction(view, *wtx, wtxBlock, 0, mp_obj)) {
+            PrintToLog("ERROR: While loading activation transaction %s: failed ParseTransaction.\n", hash.GetHex());
+            continue;
+        }
+        if (!mp_obj.interpret_Transaction()) {
+            PrintToLog("ERROR: While loading activation transaction %s: failed interpret_Transaction.\n", hash.GetHex());
+            continue;
+        }
+        // alert
+        if (OMNICORE_MESSAGE_TYPE_ALERT == mp_obj.getType()) {
+            if (!CheckAlertAuthorization(mp_obj.getSender())) {
+                PrintToLog("ERROR: While loading alert %s: sender is not authorized to send alerts.\n", mp_obj.getHash().GetHex());
+                continue;
+            }
+            if (mp_obj.getAlertType() == 65535) { // set alert type to FFFF to clear previously sent alerts
+                DeleteAlerts(mp_obj.getSender());
+            } else {
+                AddAlert(mp_obj.getSender(), mp_obj.getAlertType(), mp_obj.getAlertExpiry(), mp_obj.getAlertMessage());
+            }
+            continue;
+        }
+        // activations
+        if (OMNICORE_MESSAGE_TYPE_ACTIVATION == mp_obj.getType()) {
+            mp_obj.unlockLogic();
+            if (0 != mp_obj.interpretPacket()) {
+                PrintToLog("ERROR: While loading activation transaction %s: non-zero return from interpretPacket\n", mp_obj.getHash().GetHex());
+            }
+            continue;
+        }
+        //freezes
+        if (MSC_TYPE_FREEZE_PROPERTY_TOKENS == mp_obj.getType() || MSC_TYPE_UNFREEZE_PROPERTY_TOKENS == mp_obj.getType()
+        || MSC_TYPE_ENABLE_FREEZING == mp_obj.getType() || MSC_TYPE_DISABLE_FREEZING == mp_obj.getType()) {
+            mp_obj.unlockLogic();
+            if (0 != mp_obj.interpretPacket()) {
+                PrintToLog("ERROR: While loading freeze transaction %s: non-zero return from interpretPacket\n", mp_obj.getHash().GetHex());
+            } else {
+                txnsLoaded++;
+            }
+        }
     }
 
-    if (reorgContainsFreeze && !fInitialParse) {
-       PrintToConsole("Reorganization containing freeze related transactions detected, forcing a reparse...\n");
-       clear_all_state(); // unable to reorg freezes safely, clear state and reparse
-    } else {
-        int best_state_block = LoadMostRelevantInMemoryState();
-        if (best_state_block < 0) {
-            // unable to recover easily, remove stale stale state bits and reparse from the beginning.
-            clear_all_state();
-        } else {
-            nWaterline = best_state_block;
-        }
+    if (auto pBlockIndex = GetActiveChain()[blockHeight - 1]) {
+        CheckExpiredAlerts(blockHeight, pBlockIndex->GetBlockTime());
     }
 
-    {
-        LOCK(cs_tally);
-        // clear the global wallet property list, perform a forced wallet update and tell the UI that state is no longer valid, and UI views need to be reinit
-        global_wallet_property_list.clear();
-        CheckWalletUpdate();
-        uiInterface.OmniStateInvalidated();
-        nWaterlineBlock = nWaterline;
+    CheckLiveActivations(blockHeight);
+
+    // This alert never expires as long as custom activations are used
+    if (gArgs.IsArgSet("-omniactivationallowsender") || gArgs.IsArgSet("-omniactivationignoresender")) {
+        AddAlert("omnicore", ALERT_CLIENT_VERSION_EXPIRY, std::numeric_limits<uint32_t>::max(),
+                 "Authorization for feature activation has been modified.  Data provided by this client should not be trusted.");
     }
 
-    if (nWaterline < nBlockPrev) {
-        // scan from the block after the best active block to catch up to the active chain
-        msc_initial_scan(nWaterline + 1);
+    if (blockHeight > 497000 && !isNonMainNet()) {
+        assert(txnsLoaded >= 2); // sanity check against a failure to properly load the freeze state
     }
 }
 
@@ -1709,115 +1440,113 @@ void RewindDBsAndState(int nHeight, int nBlockPrev = 0, bool fInitialParse = fal
  *
  * @return An exit code, indicating success or failure
  */
-int mastercore_init()
+int mastercore_init(node::NodeContext& node)
 {
-    bool wrongDBVersion, startClean = false;
+    LOCK(cs_tally);
 
-    {
-        LOCK(cs_tally);
+    PrintToConsole("Initializing Omni Core v%s [%s]\n", OmniCoreVersion(), Params().NetworkIDString());
+    PrintToLog("\nInitializing Omni Core v%s [%s]\n", OmniCoreVersion(), Params().NetworkIDString());
+    PrintToLog("Startup time: %s\n", FormatISO8601DateTime(GetTime()));
 
-        PrintToConsole("Initializing Omni Core v%s [%s]\n", OmniCoreVersion(), Params().NetworkIDString());
+    InitDebugLogLevels();
+    ShrinkDebugLog();
 
-        PrintToLog("\nInitializing Omni Core v%s [%s]\n", OmniCoreVersion(), Params().NetworkIDString());
-        PrintToLog("Startup time: %s\n", FormatISO8601DateTime(GetTime()));
+    if (isNonMainNet()) {
+        exodus_address = exodus_testnet;
+    }
 
-        InitDebugLogLevels();
-        ShrinkDebugLog();
+    // check for --autocommit option and set transaction commit flag accordingly
+    if (!gArgs.GetBoolArg("-autocommit", true)) {
+        PrintToLog("Process was started with --autocommit set to false. "
+                   "Created Omni transactions will not be committed to wallet or broadcast.\n");
+        autoCommit = false;
+    }
 
-        if (isNonMainNet()) {
-            exodus_address = exodus_testnet;
+    bool startClean = false;
+    bool fWipe = node::fReindex;
+    const auto& data_dir = gArgs.GetDataDirNet();
+    // check for --startclean option and delete MP_ folders if present
+    if (gArgs.GetBoolArg("-startclean", false)) {
+        PrintToLog("Process was started with --startclean option, attempting to clear persistence files..\n");
+        try {
+            fs::path persistPath = data_dir / "MP_persist";
+            if (fs::exists(persistPath)) fs::remove_all(persistPath);
+            fWipe = startClean = true;
+        } catch (const fs::filesystem_error& e) {
+            PrintToLog("Failed to delete persistence folders: %s\n", e.what());
+            PrintToConsole("Failed to delete persistence folders: %s\n", e.what());
         }
+    }
 
-        // check for --autocommit option and set transaction commit flag accordingly
-        if (!gArgs.GetBoolArg("-autocommit", true)) {
-            PrintToLog("Process was started with --autocommit set to false. "
-                    "Created Omni transactions will not be committed to wallet or broadcast.\n");
-            autoCommit = false;
-        }
+    pDbTradeList = new CMPTradeList(data_dir / "MP_tradelist", fWipe);
+    pDbStoList = new CMPSTOList(data_dir / "MP_stolist", fWipe);
+    pDbTransactionList = new CMPTxList(data_dir / "MP_txlist", fWipe);
+    pDbSpInfo = new CMPSPInfo(data_dir / "MP_spinfo", fWipe);
+    pDbTransaction = new COmniTransactionDB(data_dir / "Omni_TXDB", fWipe);
+    pDbFeeCache = new COmniFeeCache(data_dir / "OMNI_feecache", fWipe);
+    pDbFeeHistory = new COmniFeeHistory(data_dir / "OMNI_feehistory", fWipe);
+    pDbNFT = new CMPNonFungibleTokensDB(data_dir / "OMNI_nftdb", fWipe);
+    pDbAddress = new COmniAddressDB(data_dir / "OMNI_addressindex", fWipe);
 
-        const auto& data_dir = gArgs.GetDataDirNet();
-        // check for --startclean option and delete MP_ folders if present
-        if (gArgs.GetBoolArg("-startclean", false)) {
-            PrintToLog("Process was started with --startclean option, attempting to clear persistence files..\n");
-            try {
-                fs::path persistPath = data_dir / "MP_persist";
-                fs::path txlistPath = data_dir / "MP_txlist";
-                fs::path tradePath = data_dir / "MP_tradelist";
-                fs::path spPath = data_dir / "MP_spinfo";
-                fs::path stoPath = data_dir / "MP_stolist";
-                fs::path omniTXDBPath = data_dir / "Omni_TXDB";
-                fs::path feesPath = data_dir / "OMNI_feecache";
-                fs::path feeHistoryPath = data_dir / "OMNI_feehistory";
-                fs::path nftdbPath = data_dir / "OMNI_nftdb";
-                if (fs::exists(persistPath)) fs::remove_all(persistPath);
-                if (fs::exists(txlistPath)) fs::remove_all(txlistPath);
-                if (fs::exists(tradePath)) fs::remove_all(tradePath);
-                if (fs::exists(spPath)) fs::remove_all(spPath);
-                if (fs::exists(stoPath)) fs::remove_all(stoPath);
-                if (fs::exists(omniTXDBPath)) fs::remove_all(omniTXDBPath);
-                if (fs::exists(feesPath)) fs::remove_all(feesPath);
-                if (fs::exists(feeHistoryPath)) fs::remove_all(feeHistoryPath);
-                if (fs::exists(nftdbPath)) fs::remove_all(nftdbPath);
-                PrintToLog("Success clearing persistence files in datadir %s\n", data_dir.string());
-                startClean = true;
-            } catch (const fs::filesystem_error& e) {
-                PrintToLog("Failed to delete persistence folders: %s\n", e.what());
-                PrintToConsole("Failed to delete persistence folders: %s\n", e.what());
-            }
-        }
+    pathStateFiles = data_dir / "MP_persist";
+    TryCreateDirectories(pathStateFiles);
 
-        pDbTradeList = new CMPTradeList(data_dir / "MP_tradelist", node::fReindex);
-        pDbStoList = new CMPSTOList(data_dir / "MP_stolist", node::fReindex);
-        pDbTransactionList = new CMPTxList(data_dir / "MP_txlist", node::fReindex);
-        pDbSpInfo = new CMPSPInfo(data_dir / "MP_spinfo", node::fReindex);
-        pDbTransaction = new COmniTransactionDB(data_dir / "Omni_TXDB", node::fReindex);
-        pDbFeeCache = new COmniFeeCache(data_dir / "OMNI_feecache", node::fReindex);
-        pDbFeeHistory = new COmniFeeHistory(data_dir / "OMNI_feehistory", node::fReindex);
-        pDbNFT = new CMPNonFungibleTokensDB(data_dir / "OMNI_nftdb", node::fReindex);
+    if (!pDbAddress->ReadFlag("addressindex", fAddressIndex)) {
+        fAddressIndex = gArgs.GetBoolArg("-experimental-btc-balances", DEFAULT_ADDRINDEX);
+        pDbAddress->WriteFlag("addressindex", fAddressIndex);
+    }
 
-        pathStateFiles = data_dir / "MP_persist";
-        TryCreateDirectories(pathStateFiles);
+    if (fAddressIndex != gArgs.GetBoolArg("-experimental-btc-balances", DEFAULT_ADDRINDEX)) {
+        PrintToConsole("You need to rebuild the database using -reindex-chainstate to change -experimental-btc-balances\n");
+    }
 
-        wrongDBVersion = (pDbTransactionList->getDBVersion() != DB_VERSION);
+    // db version isn't set
+    if (startClean || pDbTransactionList->getDBVersion() == 0) {
+        assert(pDbTransactionList->setDBVersion() == DB_VERSION); // new set of databases, set DB version
     }
 
-    int nWaterline = LoadMostRelevantInMemoryState();
+    auto wrongDBVersion = pDbTransactionList->getDBVersion() != DB_VERSION;
+    int nWaterlineBlock = wrongDBVersion ? -1 : LoadMostRelevantInMemoryState();
+    bool noPreviousState = (nWaterlineBlock <= 0);
 
-    if (!startClean && nWaterline > 0 && nWaterline < GetHeight()) {
-        RewindDBsAndState(nWaterline + 1, 0, true);
+    // consistency check
+    bool inconsistentDb = !VerifyTransactionExistence(nWaterlineBlock);
+    if (inconsistentDb || wrongDBVersion || noPreviousState) {
+        nWaterlineBlock = -1; // force a clear_all_state and parse from start
     }
 
-    {
-        LOCK(cs_tally);
-        nWaterlineBlock = nWaterline;
-
-        bool noPreviousState = (nWaterlineBlock <= 0);
+    if (nWaterlineBlock > 0) {
+        PrintToConsole("Loading persistent state: OK [block %d]\n", nWaterlineBlock);
+    } else {
+        std::string strReason = "unknown";
+        if (wrongDBVersion) strReason = "client version changed";
+        if (noPreviousState) strReason = "no usable previous state found";
+        if (startClean) strReason = "-startclean parameter used";
+        if (inconsistentDb) strReason = "INCONSISTENT DB DETECTED!\n"
+                                        "\n!!! WARNING !!!\n\n"
+                                        "IF YOU ARE USING AN OVERLAY DB, YOU MAY NEED TO REPROCESS\n"
+                                        "ALL OMNI LAYER TRANSACTIONS TO AVOID INCONSISTENCIES!\n"
+                                        "\n!!! WARNING !!!";
+        PrintToConsole("Loading persistent state: NONE (%s)\n", strReason);
+    }
 
-        if (startClean) {
-            assert(pDbTransactionList->setDBVersion() == DB_VERSION); // new set of databases, set DB version
-        } else if (wrongDBVersion) {
-            nWaterlineBlock = -1; // force a clear_all_state and parse from start
-        }
+    if (inconsistentDb) {
+        std::string strAlert("INCONSISTENT DB DETECTED! IF YOU ARE USING AN OVERLAY DB, YOU MAY NEED TO REPROCESS"
+                             "ALL OMNI LAYER TRANSACTIONS TO AVOID INCONSISTENCIES!");
+        AddAlert("omnicore", ALERT_CLIENT_VERSION_EXPIRY, std::numeric_limits<uint32_t>::max(), strAlert);
+        DoWarning({strAlert, strAlert});
+    }
 
-        // consistency check
-        bool inconsistentDb = !VerifyTransactionExistence(nWaterlineBlock);
-        if (inconsistentDb) {
-            nWaterlineBlock = -1; // force a clear_all_state and parse from start
-        }
+    {
+        LOCK(node.chainman->GetMutex());
+        auto& activeChain = node.chainman->ActiveChainstate();
+        pCoinsCache = new COmniCoinsCache(activeChain.CoinsDB(), data_dir / "OMNI_coinscache", fWipe);
+        omniValidationInterface = std::make_shared<COmniValidationInterface>();
 
-        if (nWaterlineBlock > 0) {
-            PrintToConsole("Loading persistent state: OK [block %d]\n", nWaterlineBlock);
-        } else {
-            std::string strReason = "unknown";
-            if (wrongDBVersion) strReason = "client version changed";
-            if (noPreviousState) strReason = "no usable previous state found";
-            if (startClean) strReason = "-startclean parameter used";
-            if (inconsistentDb) strReason = "INCONSISTENT DB DETECTED!\n"
-                    "\n!!! WARNING !!!\n\n"
-                    "IF YOU ARE USING AN OVERLAY DB, YOU MAY NEED TO REPROCESS\n"
-                    "ALL OMNI LAYER TRANSACTIONS TO AVOID INCONSISTENCIES!\n"
-                    "\n!!! WARNING !!!";
-            PrintToConsole("Loading persistent state: NONE (%s)\n", strReason);
+        // empty blockchain or prior last record
+        auto tip = activeChain.m_chain.Tip();
+        if (!tip || tip->nHeight < nWaterlineBlock) {
+            nWaterlineBlock = -1;
         }
 
         if (nWaterlineBlock < 0) {
@@ -1825,21 +1554,12 @@ int mastercore_init()
             clear_all_state();
         }
 
-        if (inconsistentDb) {
-            std::string strAlert("INCONSISTENT DB DETECTED! IF YOU ARE USING AN OVERLAY DB, YOU MAY NEED TO REPROCESS"
-                    "ALL OMNI LAYER TRANSACTIONS TO AVOID INCONSISTENCIES!");
-            AddAlert("omnicore", ALERT_CLIENT_VERSION_EXPIRY, std::numeric_limits<uint32_t>::max(), strAlert);
-            DoWarning({strAlert, strAlert});
-        }
-
-        // legacy code, setting to pre-genesis-block
-        int snapshotHeight = ConsensusParams().GENESIS_BLOCK - 1;
-
-        if (nWaterlineBlock < snapshotHeight) {
-            nWaterlineBlock = snapshotHeight;
-            exodus_prev = 0;
+        if (tip) {
+            omniValidationInterface->Init(tip, nWaterlineBlock);
         }
+    }
 
+    if (nWaterlineBlock >= ConsensusParams().GENESIS_BLOCK - 1) {
         // advance the waterline so that we start on the next unaccounted for block
         nWaterlineBlock += 1;
 
@@ -1849,50 +1569,39 @@ int mastercore_init()
             int64_t exodus_balance = GetTokenBalance(exodus_address, OMNI_PROPERTY_MSC, BALANCE);
             PrintToLog("Exodus balance at start: %s\n", FormatDivisibleMP(exodus_balance));
         }
-    }
 
-    {
-        // To avoid potential dead lock warning
-        // Lock cs_main here for Load***() > GetTransaction()
-        // Lock mempool here for Load***() > GetTransaction() > mempool.Get()
-        auto mempool = ::ChainstateActive().GetMempool();
-        assert(mempool);
-        LOCK2(cs_main, mempool->cs);
-        LOCK(cs_tally);
         // load feature activation messages from txlistdb and process them accordingly
-        pDbTransactionList->LoadActivations(nWaterlineBlock);
-
-        // load all alerts from levelDB (and immediately expire old ones)
-        pDbTransactionList->LoadAlerts(nWaterlineBlock);
-
-        // load the state of any freeable properties and frozen addresses from levelDB
-        if (!pDbTransactionList->LoadFreezeState(nWaterlineBlock)) {
-            std::string strShutdownReason = "Failed to load freeze state from levelDB.  It is unsafe to continue.\n";
-            PrintToLog(strShutdownReason);
-            if (!gArgs.GetBoolArg("-overrideforcedshutdown", false)) {
-                BlockValidationState state;
-                AbortNode(state, strShutdownReason);
-            }
-        }
-
-        nWaterline = nWaterlineBlock;
-    }
+        // load allerts and freeable properties
+        std::vector<activation> activations;
+        auto txs = pDbTransactionList->LoadValidTxs(nWaterlineBlock, {
+                                                    MSC_TYPE_ENABLE_FREEZING,
+                                                    MSC_TYPE_DISABLE_FREEZING,
+                                                    MSC_TYPE_FREEZE_PROPERTY_TOKENS,
+                                                    MSC_TYPE_UNFREEZE_PROPERTY_TOKENS,
+                                                    OMNICORE_MESSAGE_TYPE_ACTIVATION,
+                                                    OMNICORE_MESSAGE_TYPE_ALERT});
+        for (auto& [txid, block] : txs) {
+            auto txpos = pDbTransaction->FetchTransactionPosition(txid);
+            activations.emplace_back(std::make_pair(block, txpos), txid);
+        }
+        std::sort(activations.begin(), activations.end());
+        ProcessActivations(nWaterlineBlock, activations);
 
-    // initial scan
-    msc_initial_scan(nWaterline);
-
-    {
-        LOCK(cs_tally);
         // display Exodus balance
         int64_t exodus_balance = GetTokenBalance(exodus_address, OMNI_PROPERTY_MSC, BALANCE);
-
         PrintToLog("Exodus balance after initialization: %s\n", FormatDivisibleMP(exodus_balance));
     }
 
     fOmniSafeAddresses = gArgs.GetBoolArg("-omnisafeaddresses", MainNet());
 
+    RegisterSharedValidationInterface(omniValidationInterface);
+
     PrintToConsole("Omni Core initialization completed\n");
 
+    InitWallets(node);
+
+    CheckWalletUpdate();
+
     return 0;
 }
 
@@ -1906,13 +1615,12 @@ int mastercore_init()
  */
 int mastercore_shutdown()
 {
-    LOCK2(cs_main, cs_tally);
-
-    if (lastProcessedBlock > 0) {
-        if (auto blockIndex = ChainActive()[lastProcessedBlock]) {
+    if (omniValidationInterface) {
+        auto blockIndex = GetActiveChain().Tip();
+        if (blockIndex && blockIndex->nHeight > ConsensusParams().GENESIS_BLOCK) {
             PersistInMemoryState(blockIndex);
         }
-        lastProcessedBlock = 0;
+        omniValidationInterface.reset();
     }
     if (pDbTransactionList) {
         delete pDbTransactionList;
@@ -1946,84 +1654,86 @@ int mastercore_shutdown()
         delete pDbNFT;
         pDbNFT = nullptr;
     }
+    if (pDbAddress) {
+        delete pDbAddress;
+        pDbAddress = nullptr;
+    }
+    if (pCoinsCache) {
+        delete pCoinsCache;
+        pCoinsCache = nullptr;
+    }
 
     PrintToLog("\nOmni Core shutdown completed\n");
     PrintToLog("Shutdown time: %s\n", FormatISO8601DateTime(GetTime()));
 
     PrintToConsole("Omni Core shutdown completed\n");
 
+    CloseLogFile();
+
     return 0;
 }
 
+namespace mastercore {
+extern std::atomic_bool pendingAdded;
+}
+
 /**
  * This handler is called for every new transaction that comes in (actually in block parsing loop).
  *
  * @return True, if the transaction was an Exodus purchase, DEx payment or a valid Omni transaction
  */
-bool mastercore_handler_tx(const CTransaction& tx, int nBlock, unsigned int idx, const CBlockIndex* pBlockIndex, const std::shared_ptr<std::map<COutPoint, Coin> > removedCoins)
+bool ProcessTransaction(CCoinsViewCache& view, const CTransaction& tx, unsigned int idx, const CBlockIndex* pBlockIndex)
 {
-    int pop_ret;
-    {
-        LOCK(cs_tally);
-
+    if (pendingAdded.load(std::memory_order_consume)) {
         // clear pending, if any
         // NOTE1: Every incoming TX is checked, not just MP-ones because:
         // if for some reason the incoming TX doesn't pass our parser validation steps successfully, I'd still want to clear pending amounts for that TX.
         // NOTE2: Plus I wanna clear the amount before that TX is parsed by our protocol, in case we ever consider pending amounts in internal calculations.
         PendingDelete(tx.GetHash());
-
-        // we do not care about parsing blocks prior to our waterline (empty blockchain defense)
-        if (nBlock < nWaterlineBlock) return false;
     }
 
+    int nBlock = pBlockIndex->nHeight;
     int64_t nBlockTime = pBlockIndex->GetBlockTime();
     CMPTransaction mp_obj;
     mp_obj.unlockLogic();
     bool fFoundTx = false;
 
-    {
-        LOCK2(cs_main, cs_tally);
-        pop_ret = parseTransaction(false, tx, nBlock, idx, mp_obj, nBlockTime, removedCoins);
-    }
-
-    {
-        LOCK(cs_tally);
-
-        if (pop_ret >= 0) {
-            assert(mp_obj.getEncodingClass() != NO_MARKER);
-            assert(mp_obj.getSender().empty() == false);
+    int pop_ret = parseTransaction(false, view, tx, nBlock, idx, mp_obj, nBlockTime);
+    if (pop_ret >= 0) {
+        assert(mp_obj.getEncodingClass() != NO_MARKER);
+        assert(mp_obj.getSender().empty() == false);
 
-            // extra iteration of the outputs for every transaction, not needed on mainnet after Exodus closed
-            const CConsensusParams& params = ConsensusParams();
-            if (isNonMainNet() || nBlock <= params.LAST_EXODUS_BLOCK) {
-                fFoundTx |= HandleExodusPurchase(tx, nBlock, mp_obj.getSender(), nBlockTime);
-            }
+        // extra iteration of the outputs for every transaction, not needed on mainnet after Exodus closed
+        const CConsensusParams& params = ConsensusParams();
+        if (isNonMainNet() || nBlock <= params.LAST_EXODUS_BLOCK) {
+            fFoundTx |= HandleExodusPurchase(tx, nBlock, mp_obj.getSender(), nBlockTime);
         }
 
         if (pop_ret > 0) {
             assert(mp_obj.getEncodingClass() == OMNI_CLASS_A);
             assert(mp_obj.getPayload().empty() == true);
 
+            pCoinsCache->AddInputs(tx.vin);
             fFoundTx |= HandleDExPayments(tx, nBlock, mp_obj.getSender());
+            pDbTransaction->RecordTransaction(tx, nBlock, idx, pop_ret);
+        } else {
+            int interp_ret = mp_obj.interpretPacket();
+            if (interp_ret) PrintToLog("!!! interpretPacket() returned %d !!!\n", interp_ret);
+
+            // Only structurally valid transactions get recorded in levelDB
+            // PKT_ERROR - 2 = interpret_Transaction failed, structurally invalid payload
+            if (interp_ret != PKT_ERROR - 2) {
+                pCoinsCache->AddInputs(tx.vin);
+                bool bValid = (0 <= interp_ret);
+                pDbTransactionList->recordTX(tx.GetHash(), bValid, nBlock, mp_obj.getType(), mp_obj.getNewAmount());
+                pDbTransaction->RecordTransaction(tx, nBlock, idx, interp_ret);
+            }
+            fFoundTx |= (interp_ret == 0);
         }
     }
 
-    if (0 == pop_ret) {
-        int interp_ret = mp_obj.interpretPacket();
-        if (interp_ret) PrintToLog("!!! interpretPacket() returned %d !!!\n", interp_ret);
-
-        // Only structurally valid transactions get recorded in levelDB
-        // PKT_ERROR - 2 = interpret_Transaction failed, structurally invalid payload
-        if (interp_ret != PKT_ERROR - 2) {
-            LOCK(cs_tally);
-            bool bValid = (0 <= interp_ret);
-            pDbTransactionList->recordTX(tx.GetHash(), bValid, nBlock, mp_obj.getType(), mp_obj.getNewAmount());
-            pDbTransaction->RecordTransaction(tx.GetHash(), idx, interp_ret);
-        }
-        fFoundTx |= (interp_ret == 0);
-    }
+    pCoinsCache->AddCoins(tx, nBlock);
 
-    LOCK(cs_tally);
     if (fFoundTx && msc_debug_consensus_hash_every_transaction) {
         uint256 consensusHash = GetConsensusHash();
         PrintToLog("Consensus hash for transaction %s: %s\n", tx.GetHash().GetHex(), consensusHash.GetHex());
@@ -2049,123 +1759,6 @@ bool mastercore::UseEncodingClassC(size_t nDataSize)
     return nTotalSize <= nMaxDatacarrierBytes && fDataEnabled;
 }
 
-int mastercore_handler_block_begin(int nBlockPrev, CBlockIndex const * pBlockIndex)
-{
-    bool bRecoveryMode{false};
-    {
-        LOCK(cs_tally);
-
-        if (reorgRecoveryMode > 0) {
-            reorgRecoveryMode = 0; // clear reorgRecovery here as this is likely re-entrant
-            bRecoveryMode = true;
-        }
-    }
-
-    if (bRecoveryMode) {
-        RewindDBsAndState(pBlockIndex->nHeight, nBlockPrev);
-    }
-
-    {
-        LOCK(cs_tally);
-
-        // handle any features that go live with this block
-        CheckLiveActivations(pBlockIndex->nHeight);
-
-        eraseExpiredCrowdsale(pBlockIndex);
-    }
-
-    return 0;
-}
-
-// called once per block, after the block has been processed
-// TODO: consolidate into *handler_block_begin() << need to adjust Accept expiry check.............
-// it performs cleanup and other functions
-int mastercore_handler_block_end(int nBlockNow, CBlockIndex const * pBlockIndex,
-        unsigned int countMP)
-{
-    bool checkpointValid;
-    {
-        LOCK(cs_tally);
-
-        // for every new received block must do:
-        // 1) remove expired entries from the accept list (per spec accept entries are
-        //    valid until their blocklimit expiration; because the customer can keep
-        //    paying BTC for the offer in several installments)
-        // 2) update the amount in the Exodus address
-        int64_t devmsc = 0;
-        unsigned int how_many_erased = eraseExpiredAccepts(nBlockNow);
-
-        if (how_many_erased) {
-            PrintToLog("%s(%d); erased %u accepts this block, line %d, file: %s\n",
-                __FUNCTION__, how_many_erased, nBlockNow, __LINE__, __FILE__);
-        }
-
-        // calculate devmsc as of this block and update the Exodus' balance
-        devmsc = calculate_and_update_devmsc(pBlockIndex->GetBlockTime(), nBlockNow);
-
-        if (msc_debug_exo) {
-            int64_t balance = GetTokenBalance(exodus_address, OMNI_PROPERTY_MSC, BALANCE);
-            PrintToLog("devmsc for block %d: %d, Exodus balance: %d\n", nBlockNow, devmsc, FormatDivisibleMP(balance));
-        }
-
-        // check the alert status, do we need to do anything else here?
-        CheckExpiredAlerts(nBlockNow, pBlockIndex->GetBlockTime());
-
-        // check that pending transactions are still in the mempool
-        PendingCheck();
-
-        // transactions were found in the block, signal the UI accordingly
-        if (countMP > 0) CheckWalletUpdate();
-
-        // calculate and print a consensus hash if required
-        if (ShouldConsensusHashBlock(nBlockNow)) {
-            uint256 consensusHash = GetConsensusHash();
-            PrintToLog("Consensus hash for block %d: %s\n", nBlockNow, consensusHash.GetHex());
-        }
-
-        // request nftdb sanity check
-        bool sanityCheck = true;
-        pDbNFT->WriteBlockCache(nBlockNow, sanityCheck);
-
-        // request checkpoint verification
-        checkpointValid = VerifyCheckpoint(nBlockNow, pBlockIndex->GetBlockHash());
-        if (!checkpointValid) {
-            // failed checkpoint, can't be trusted to provide valid data - shutdown client
-            const std::string& msg = strprintf(
-                    "Shutting down due to failed checkpoint for block %d (hash %s). "
-                    "Please restart with -startclean flag and if this doesn't work, please reach out to the support.\n",
-                    nBlockNow, pBlockIndex->GetBlockHash().GetHex());
-            PrintToLog(msg);
-            if (!gArgs.GetBoolArg("-overrideforcedshutdown", false)) {
-                const auto& data_dir = gArgs.GetDataDirNet();
-                fs::path persistPath = data_dir / "MP_persist";
-                if (fs::exists(persistPath)) fs::remove_all(persistPath); // prevent the node being restarted without a reparse after forced shutdown
-                BlockValidationState state;
-                AbortNode(state, msg);
-            }
-        }
-    }
-
-    LOCK2(cs_main, cs_tally);
-    if (checkpointValid && nBlockNow >= ConsensusParams().GENESIS_BLOCK) {
-        // save out the state after this block
-        if (IsPersistenceEnabled(nBlockNow)) {
-            PersistInMemoryState(pBlockIndex);
-        }
-        lastProcessedBlock = nBlockNow;
-    }
-
-    return 0;
-}
-
-void mastercore_handler_disc_begin(const int nHeight)
-{
-    LOCK(cs_tally);
-
-    reorgRecoveryMode = 1;
-    reorgRecoveryMaxHeight = (nHeight > reorgRecoveryMaxHeight) ? nHeight: reorgRecoveryMaxHeight;
-}
-
 /**
  * Returns the Exodus address.
  *
@@ -2219,129 +1812,36 @@ const CTxDestination ExodusCrowdsaleAddress(int nBlock)
  */
 const std::vector<unsigned char> GetOmMarker()
 {
-    static unsigned char pch[] = {0x6f, 0x6d, 0x6e, 0x69}; // Hex-encoded: "omni"
-
-    return std::vector<unsigned char>(pch, pch + sizeof(pch) / sizeof(pch[0]));
-}
-
-std::optional<std::reference_wrapper<node::NodeContext>> g_context;
-
-static ChainstateManager& ChainManager()
-{
-    LOCK(cs_main);
-    assert(g_context && g_context->get().chainman);
-    return *(g_context->get().chainman);
-}
-
-static node::BlockManager& BlockManager()
-{
-    return ChainManager().m_blockman;
-}
-
-/** @returns the most-work valid chainstate. */
-Chainstate& ChainstateActive()
-{
-    return ChainManager().ActiveChainstate();
-}
-
-/** @returns the most-work chain. */
-CChain& ChainActive()
-{
-    return ChainManager().ActiveChain();
-}
-
-/** @returns the global block index map. */
-node::BlockMap& BlockIndex()
-{
-    return ChainManager().BlockIndex();
+    static std::vector<unsigned char> pch{0x6f, 0x6d, 0x6e, 0x69}; // Hex-encoded: "omni"
+    return pch;
 }
 
 /**
  * Return transaction in txOut, and if it was found inside a block, its hash is placed in hashBlock.
  * If blockIndex is provided, the transaction is fetched from the corresponding block.
  */
-bool GetTransaction(const uint256& hash, CTransactionRef& txOut, const Consensus::Params& consensusParams, uint256& hashBlock, const CBlockIndex* const block_index)
+bool GetTransaction(const uint256& hash, CTransactionRef& txOut, int& blockHeight)
 {
-    LOCK(cs_main);
+    blockHeight = 0;
+    txOut = mastercore::GetMempoolTransaction(hash);
+    return txOut || pDbTransaction->GetTransaction(hash, txOut, blockHeight);
+}
 
-    if (!block_index) {
-        auto mempool = ::ChainstateActive().GetMempool();
-        CTransactionRef ptx = mempool ? mempool->get(hash) : nullptr;
-        if (ptx) {
-            txOut = ptx;
+bool GetCoin(const COutPoint& outpoint, Coin& coin)
+{
+    if (WITH_LOCK(cs_tally, return pCoinsCache->GetCoin(outpoint, coin))) {
+        return true;
+    }
+    int blockHeight;
+    CTransactionRef tx;
+    if (GetTransaction(outpoint.hash, tx, blockHeight)) {
+        if (tx->vout.size() > outpoint.n) {
+            coin = Coin{tx->vout[outpoint.n], blockHeight, false};
+            coin.nHeight == 0 && (coin.nHeight = MEMPOOL_HEIGHT);
             return true;
         }
-
-        if (g_txindex) {
-            return g_txindex->FindTx(hash, hashBlock, txOut);
-        }
-    } else {
-        CBlock block;
-        if (node::ReadBlockFromDisk(block, block_index, consensusParams)) {
-            for (const auto& tx : block.vtx) {
-                if (tx->GetHash() == hash) {
-                    txOut = tx;
-                    hashBlock = block_index->GetBlockHash();
-                    return true;
-                }
-            }
-        }
     }
-
     return false;
 }
 
-bool GetSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value)
-{
-    if (!fAddressIndex)
-        return false;
-
-    auto mempool = ::ChainstateActive().GetMempool();
-    if (!mempool)
-        return false;
-
-    if (mempool->getSpentIndex(key, value))
-        return true;
-
-    auto& pblocktree{::BlockManager().m_block_tree_db};
-    if (!pblocktree->ReadSpentIndex(key, value))
-        return false;
-
-    return true;
-}
-
-bool GetAddressIndex(uint256 addressHash, int type, std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex, int start, int end)
-{
-    if (!fAddressIndex)
-        return error("address index not enabled");
-
-    auto& pblocktree{::BlockManager().m_block_tree_db};
-    if (!pblocktree->ReadAddressIndex(addressHash, type, addressIndex, start, end))
-        return error("unable to get txids for address");
-
-    return true;
-}
-
-bool GetAddressUnspent(uint256 addressHash, int type, std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs)
-{
-    if (!fAddressIndex)
-        return error("address index not enabled");
-
-    auto& pblocktree{::BlockManager().m_block_tree_db};
-    if (!pblocktree->ReadAddressUnspentIndex(addressHash, type, unspentOutputs))
-        return error("unable to get txids for address");
-
-    return true;
-}
-
-bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &hashes)
-{
-    if (!fAddressIndex)
-        return error("Timestamp index not enabled");
-
-    auto& pblocktree{::BlockManager().m_block_tree_db};
-    if (!pblocktree->ReadTimestampIndex(high, low, fActiveOnly, hashes))
-        return error("Unable to get hashes for timestamps");
-
-    return true;
-}
+CCoinsView CCoinsViewCacheOnly::noBase;
diff --git a/src/omnicore/omnicore.h b/src/omnicore/omnicore.h
index d2de9bdc2755c..c52644e264334 100644
--- a/src/omnicore/omnicore.h
+++ b/src/omnicore/omnicore.h
@@ -1,11 +1,7 @@
 #ifndef BITCOIN_OMNICORE_OMNICORE_H
 #define BITCOIN_OMNICORE_OMNICORE_H
 
-class CBlockIndex;
-class CCoinsView;
-class CCoinsViewCache;
 class CTransaction;
-class Coin;
 
 #include <omnicore/log.h>
 #include <omnicore/tally.h>
@@ -39,7 +35,7 @@ int const DONT_STORE_MAINNET_STATE_UNTIL = 770000;
 #define TEST_ECO_PROPERTY_1 (0x80000003UL)
 
 // increment this value to force a refresh of the state (similar to --startclean)
-#define DB_VERSION 8
+#define DB_VERSION 9
 
 // could probably also use: int64_t maxInt64 = std::numeric_limits<int64_t>::max();
 // maximum numeric values from the spec:
@@ -153,6 +149,8 @@ extern bool autoCommit;
 //! Global lock for state objects
 extern RecursiveMutex cs_tally;
 
+extern bool fAddressIndex;
+
 //! Available balances of wallet properties
 extern std::map<uint32_t, int64_t> global_balance_money;
 //! Reserved balances of wallet propertiess
@@ -166,424 +164,50 @@ extern CFeeRate minRelayTxFee;
 
 extern bool fOmniSafeAddresses;
 
-extern std::optional<std::reference_wrapper<node::NodeContext>> g_context;
-
 int64_t GetTokenBalance(const std::string& address, uint32_t propertyId, TallyType ttype);
 int64_t GetAvailableTokenBalance(const std::string& address, uint32_t propertyId);
 int64_t GetReservedTokenBalance(const std::string& address, uint32_t propertyId);
 int64_t GetFrozenTokenBalance(const std::string& address, uint32_t propertyId);
 
+namespace node {
+class NodeContext;
+};
 /** Global handler to initialize Omni Core. */
-int mastercore_init();
+int mastercore_init(node::NodeContext& node);
 
 /** Global handler to shut down Omni Core. */
 int mastercore_shutdown();
 
-/** Block and transaction handlers. */
-void mastercore_handler_disc_begin(const int nHeight);
-int mastercore_handler_block_begin(int nBlockNow, CBlockIndex const * pBlockIndex);
-int mastercore_handler_block_end(int nBlockNow, CBlockIndex const * pBlockIndex, unsigned int);
-bool mastercore_handler_tx(const CTransaction& tx, int nBlock, unsigned int idx, const CBlockIndex* pBlockIndex, const std::shared_ptr<std::map<COutPoint, Coin>> removedCoins);
-
-/** Scans for marker and if one is found, add transaction to marker cache. */
-void TryToAddToMarkerCache(const CTransactionRef& tx);
-/** Removes transaction from marker cache. */
-void RemoveFromMarkerCache(const uint256& txHash);
-/** Checks, if transaction is in marker cache. */
-bool IsInMarkerCache(const uint256& txHash);
-
 /** Global handler to total wallet balances. */
 void CheckWalletUpdate();
 
 /** Used to notify that the number of tokens for a property has changed. */
 void NotifyTotalTokensChanged(uint32_t propertyId, int block);
 
-bool GetAddressIndex(uint256 addressHash, int type,
-                     std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,
-                     int start = 0, int end = 0);
-
-bool GetSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
-
-bool GetAddressUnspent(uint256 addressHash, int type,
-                       std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs);
-
-bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &hashes);
-
-class Chainstate;
-/** @returns the most-work valid chainstate. */
-Chainstate& ChainstateActive();
-
-class CChain;
-/** @returns the most-work chain. */
-CChain& ChainActive();
-
-/** @returns the global block index map. */
-node::BlockMap& BlockIndex();
+/** Process every new transaction */
+bool ProcessTransaction(CCoinsViewCache& view, const CTransaction& tx, unsigned int idx, const CBlockIndex* pBlockIndex);
 
-namespace Consensus {
-struct Params;
-}
+/** Retrieve a coin for a giving input */
+bool GetCoin(const COutPoint& outpoint, Coin& coin);
 
 /** Retrieve a transaction (from memory pool, or from disk, if possible) */
-bool GetTransaction(const uint256& hash, CTransactionRef& tx, const Consensus::Params& params, uint256& hashBlock, const CBlockIndex* const blockIndex = nullptr);
-
-struct CTimestampIndexIteratorKey {
-    unsigned int timestamp;
-
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 4;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, timestamp);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        timestamp = ser_readdata32be(s);
-    }
-
-    CTimestampIndexIteratorKey(unsigned int time) {
-        timestamp = time;
-    }
-
-    CTimestampIndexIteratorKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        timestamp = 0;
-    }
-};
-
-struct CTimestampIndexKey {
-    unsigned int timestamp;
-    uint256 blockHash;
-
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 36;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, timestamp);
-        blockHash.Serialize(s);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        timestamp = ser_readdata32be(s);
-        blockHash.Unserialize(s);
-    }
-
-    CTimestampIndexKey(unsigned int time, uint256 hash) {
-        timestamp = time;
-        blockHash = hash;
-    }
-
-    CTimestampIndexKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        timestamp = 0;
-        blockHash.SetNull();
-    }
-};
+bool GetTransaction(const uint256& hash, CTransactionRef& tx, int& blockHeight);
 
-struct CTimestampBlockIndexKey {
-    uint256 blockHash;
+/** Fill cache with transaction inputs */
+bool FillTxInputCache(const CTransaction& tx, CCoinsViewCache& view);
 
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 32;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        blockHash.Serialize(s);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        blockHash.Unserialize(s);
-    }
-
-    CTimestampBlockIndexKey(uint256 hash) {
-        blockHash = hash;
-    }
-
-    CTimestampBlockIndexKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        blockHash.SetNull();
-    }
-};
-
-struct CTimestampBlockIndexValue {
-    unsigned int ltimestamp;
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 4;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, ltimestamp);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        ltimestamp = ser_readdata32be(s);
-    }
-
-    CTimestampBlockIndexValue (unsigned int time) {
-        ltimestamp = time;
-    }
-
-    CTimestampBlockIndexValue() {
-        SetNull();
-    }
-
-    void SetNull() {
-        ltimestamp = 0;
-    }
-};
-
-struct CAddressUnspentKey {
-    unsigned int type;
-    uint256 hashBytes;
-    uint256 txhash;
-    size_t index;
-
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 69;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-        txhash.Serialize(s);
-        ser_writedata32(s, index);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        txhash.Unserialize(s);
-        index = ser_readdata32(s);
-    }
-
-    CAddressUnspentKey(unsigned int addressType, uint256 addressHash, uint256 txid, size_t indexValue) {
-        type = addressType;
-        hashBytes = addressHash;
-        txhash = txid;
-        index = indexValue;
-    }
-
-    CAddressUnspentKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        type = 0;
-        hashBytes.SetNull();
-        txhash.SetNull();
-        index = 0;
-    }
-};
-
-struct CAddressUnspentValue {
-    CAmount satoshis;
-    CScript script;
-    int blockHeight;
-    bool coinBase;
-
-    SERIALIZE_METHODS(CAddressUnspentValue, obj) {
-        READWRITE(obj.satoshis);
-        READWRITE(*(CScriptBase*)(&obj.script));
-        READWRITE(obj.blockHeight);
-        READWRITE(obj.coinBase);
-    }
-
-    CAddressUnspentValue(CAmount sats, CScript scriptPubKey, int height, bool coinbase) {
-        satoshis = sats;
-        script = scriptPubKey;
-        blockHeight = height;
-        coinBase = coinbase;
-    }
-
-    CAddressUnspentValue() {
-        SetNull();
-    }
-
-    void SetNull() {
-        satoshis = -1;
-        script.clear();
-        blockHeight = 0;
-        coinBase = false;
-    }
-
-    bool IsNull() const {
-        return (satoshis == -1);
-    }
-};
-
-struct CAddressIndexKey {
-    unsigned int type;
-    uint256 hashBytes;
-    int blockHeight;
-    unsigned int txindex;
-    uint256 txhash;
-    size_t index;
-    bool spending;
-
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 78;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-        // Heights are stored big-endian for key sorting in LevelDB
-        ser_writedata32be(s, blockHeight);
-        ser_writedata32be(s, txindex);
-        txhash.Serialize(s);
-        ser_writedata32(s, index);
-        uint8_t f = spending;
-        ser_writedata8(s, f);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        blockHeight = ser_readdata32be(s);
-        txindex = ser_readdata32be(s);
-        txhash.Unserialize(s);
-        index = ser_readdata32(s);
-        uint8_t f = ser_readdata8(s);
-        spending = f;
-    }
-
-    CAddressIndexKey(unsigned int addressType, uint256 addressHash, int height, int blockindex,
-                     uint256 txid, size_t indexValue, bool isSpending) {
-        type = addressType;
-        hashBytes = addressHash;
-        blockHeight = height;
-        txindex = blockindex;
-        txhash = txid;
-        index = indexValue;
-        spending = isSpending;
-    }
-
-    CAddressIndexKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        type = 0;
-        hashBytes.SetNull();
-        blockHeight = 0;
-        txindex = 0;
-        txhash.SetNull();
-        index = 0;
-        spending = false;
-    }
-
-};
-
-struct CAddressIndexIteratorHeightKey {
-    unsigned int type;
-    uint256 hashBytes;
-    int blockHeight;
-
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 37;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-        ser_writedata32be(s, blockHeight);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        blockHeight = ser_readdata32be(s);
-    }
-
-    CAddressIndexIteratorHeightKey(unsigned int addressType, uint256 addressHash, int height) {
-        type = addressType;
-        hashBytes = addressHash;
-        blockHeight = height;
-    }
-
-    CAddressIndexIteratorHeightKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        type = 0;
-        hashBytes.SetNull();
-        blockHeight = 0;
-    }
-};
-
-struct CAddressIndexIteratorKey {
-    unsigned int type;
-    uint256 hashBytes;
-
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 33;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-    }
-
-    CAddressIndexIteratorKey(unsigned int addressType, uint256 addressHash) {
-        type = addressType;
-        hashBytes = addressHash;
-    }
-
-    CAddressIndexIteratorKey() {
-        SetNull();
-    }
-
-    void SetNull() {
-        type = 0;
-        hashBytes.SetNull();
-    }
+class CCoinsViewCacheOnly : public CCoinsViewCache
+{
+    static CCoinsView noBase;
+public:
+    CCoinsViewCacheOnly() : CCoinsViewCache(&noBase) {}
 };
 
-
 namespace mastercore
 {
 //! In-memory collection of all amounts for all addresses for all properties
 extern std::unordered_map<std::string, CMPTally> mp_tally_map;
 
-// TODO: move, rename
-extern CCoinsView viewDummy;
-extern CCoinsViewCache view;
-//! Guards coins view cache
-extern RecursiveMutex cs_tx_cache;
-
 /** Returns the encoding class, used to embed a payload. */
 int GetEncodingClass(const CTransaction& tx, int nBlock);
 
diff --git a/src/omnicore/parsing.h b/src/omnicore/parsing.h
index 9d7a60e050a7b..9709ba8e24bb3 100644
--- a/src/omnicore/parsing.h
+++ b/src/omnicore/parsing.h
@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 
+class CCoinsViewCache;
 class CTransaction;
 class CMPTransaction;
 class uint160;
@@ -21,7 +22,7 @@ class uint160;
 #define MAX_SHA256_OBFUSCATION_TIMES  255
 
 /**
- * Swaps byte order on little-endian systems and does nothing 
+ * Swaps byte order on little-endian systems and does nothing
  * otherwise. SwapByteOrder cycles on LE systems.
  */
 void SwapByteOrder16(uint16_t&);
@@ -35,7 +36,7 @@ std::string HashToAddress(unsigned char version, const uint160& hash);
 void PrepareObfuscatedHashes(const std::string& strSeed, int hashCount, std::string(&vstrHashes)[1+MAX_SHA256_OBFUSCATION_TIMES]);
 
 /** Parses a transaction and populates the CMPTransaction object. */
-int ParseTransaction(const CTransaction& tx, int nBlock, unsigned int idx, CMPTransaction& mptx, unsigned int nTime=0);
+int ParseTransaction(CCoinsViewCache& view, const CTransaction& tx, int nBlock, unsigned int idx, CMPTransaction& mptx, unsigned int nTime=0);
 
 
 #endif // BITCOIN_OMNICORE_PARSING_H
diff --git a/src/omnicore/pending.cpp b/src/omnicore/pending.cpp
index dc403dbfb6ddf..457160eb2719c 100644
--- a/src/omnicore/pending.cpp
+++ b/src/omnicore/pending.cpp
@@ -1,5 +1,7 @@
+
 #include <omnicore/pending.h>
 
+#include <omnicore/mempool.h>
 #include <omnicore/log.h>
 #include <omnicore/sp.h>
 
@@ -10,6 +12,7 @@
 #include <uint256.h>
 #include <node/interface_ui.h>
 
+#include <atomic>
 #include <string>
 
 namespace mastercore
@@ -20,6 +23,8 @@ RecursiveMutex cs_pending;
 //! Global map of pending transaction objects
 PendingMap my_pending;
 
+std::atomic_bool pendingAdded = false;
+
 /**
  * Adds a transaction to the pending map using supplied parameters.
  */
@@ -45,6 +50,7 @@ void PendingAdd(const uint256& txid, const std::string& sendingAddress, uint16_t
         LOCK(cs_pending);
         my_pending.insert(std::make_pair(txid, pending));
     }
+    pendingAdded.store(true, std::memory_order_release);
     // after adding a transaction to pending the available balance may now be reduced, refresh wallet totals
     CheckWalletUpdate(); // force an update since some outbound pending (eg MetaDEx cancel) may not change balances
     uiInterface.OmniPendingChanged(true);
@@ -57,18 +63,23 @@ void PendingAdd(const uint256& txid, const std::string& sendingAddress, uint16_t
  */
 void PendingDelete(const uint256& txid)
 {
-    LOCK(cs_pending);
-
-    PendingMap::iterator it = my_pending.find(txid);
-    if (it != my_pending.end()) {
-        const CMPPending& pending = it->second;
-        int64_t src_amount = GetTokenBalance(pending.src, pending.prop, PENDING);
-        if (msc_debug_pending) PrintToLog("%s(%s): amount=%d\n", __FUNCTION__, txid.GetHex(), src_amount);
-        if (src_amount) update_tally_map(pending.src, pending.prop, pending.amount, PENDING);
-        my_pending.erase(it);
-
+    bool pending_empty = false;
+    {
+        LOCK(cs_pending);
+        PendingMap::iterator it = my_pending.find(txid);
+        if (it != my_pending.end()) {
+            const CMPPending& pending = it->second;
+            int64_t src_amount = GetTokenBalance(pending.src, pending.prop, PENDING);
+            if (msc_debug_pending) PrintToLog("%s(%s): amount=%d\n", __FUNCTION__, txid.GetHex(), src_amount);
+            if (src_amount) update_tally_map(pending.src, pending.prop, pending.amount, PENDING);
+            my_pending.erase(it);
+            pending_empty = my_pending.empty();
+        }
+    }
+    if (pending_empty) {
+        pendingAdded.store(false, std::memory_order_release);
         // if pending map is now empty following deletion, trigger a status change
-        if (my_pending.empty()) uiInterface.OmniPendingChanged(false);
+        uiInterface.OmniPendingChanged(false);
     }
 }
 
@@ -84,9 +95,7 @@ void PendingCheck()
 
     std::vector<uint256> vecMemPoolTxids;
     std::vector<uint256> txidsForDeletion;
-    if (auto mempool = ::ChainstateActive().GetMempool()) {
-        mempool->queryHashes(vecMemPoolTxids);
-    }
+    MempoolQueryHashes(vecMemPoolTxids);
 
     for (PendingMap::iterator it = my_pending.begin(); it != my_pending.end(); ++it) {
         const uint256& txid = it->first;
diff --git a/src/omnicore/persistence.cpp b/src/omnicore/persistence.cpp
index 34ea86b14551c..6cdbe06db7f5a 100644
--- a/src/omnicore/persistence.cpp
+++ b/src/omnicore/persistence.cpp
@@ -38,7 +38,7 @@
 using namespace mastercore;
 
 //! Number of "Dev Omni" of the last processed block (needed to save global state)
-extern int64_t exodus_prev;
+extern std::atomic<int64_t> exodus_prev;
 
 //! Path for file based persistence
 extern fs::path pathStateFiles;
@@ -457,7 +457,7 @@ static void prune_state_files(const CBlockIndex* topIndex)
     fs::directory_iterator endIter;
     for (; dIter != endIter; ++dIter) {
         std::string fName = dIter->path().empty() ? "<invalid>" : (*--dIter->path().end()).string();
-        if (false == fs::is_regular_file(dIter->status())) {
+        if (!fs::is_regular_file(dIter->status())) {
             // skip funny business
             PrintToLog("Non-regular file found in persistence directory : %s\n", fName);
             continue;
@@ -465,9 +465,7 @@ static void prune_state_files(const CBlockIndex* topIndex)
 
         std::vector<std::string> vstr;
         boost::split(vstr, fName, boost::is_any_of("-."), boost::token_compress_on);
-        if (vstr.size() == 3 &&
-                is_state_prefix(vstr[0]) &&
-                boost::equals(vstr[2], "dat")) {
+        if (vstr.size() == 3 && is_state_prefix(vstr[0]) && boost::equals(vstr[2], "dat")) {
             uint256 blockHash;
             blockHash.SetHex(vstr[1]);
             statefulBlockHashes.insert(blockHash);
@@ -477,23 +475,14 @@ static void prune_state_files(const CBlockIndex* topIndex)
     }
 
     // for each blockHash in the set, determine the distance from the given block
-    std::set<uint256>::const_iterator iter;
-    for (iter = statefulBlockHashes.begin(); iter != statefulBlockHashes.end(); ++iter) {
-        // look up the CBlockIndex for height info
-        CBlockIndex const *curIndex = GetBlockIndex(*iter);
-
+    for (const auto& blockHash : statefulBlockHashes) {
         // if we have nothing int the index, or this block is too old..
-        if (nullptr == curIndex || topIndex->nHeight > curIndex->nHeight) {
+        if (topIndex->GetBlockHash() != blockHash) {
             if (msc_debug_persistence) {
-                if (curIndex) {
-                    PrintToLog("State from Block:%s is no longer need, removing files (age-from-tip: %d)\n", (*iter).ToString(), topIndex->nHeight - curIndex->nHeight);
-                } else {
-                    PrintToLog("State from Block:%s is no longer need, removing files (not in index)\n", (*iter).ToString());
-                }
+                PrintToLog("State from Block:%s is no longer need, removing files (not in index)\n", blockHash.ToString());
             }
-
             // destroy the associated files!
-            std::string strBlockHash = iter->ToString();
+            std::string strBlockHash = blockHash.ToString();
             for (int i = 0; i < NUM_FILETYPES; ++i) {
                 auto fileName = strprintf("%s-%s.dat", statePrefix[i], strBlockHash);
                 fs::path path = pathStateFiles / fileName.c_str();
@@ -508,7 +497,7 @@ static void prune_state_files(const CBlockIndex* topIndex)
  */
 static int GetWrapModeHeight()
 {
-    static const int nSkipBlocksUntil = gArgs.GetIntArg("-omniskipstoringstate", DONT_STORE_MAINNET_STATE_UNTIL);
+    static const int nSkipBlocksUntil = gArgs.GetIntArg("-omniskipstoringstate", MainNet() ? DONT_STORE_MAINNET_STATE_UNTIL : 0);
     return nSkipBlocksUntil;
 }
 
@@ -517,13 +506,8 @@ static int GetWrapModeHeight()
  */
 bool IsPersistenceEnabled(int blockHeight)
 {
-    // do not store on any network different from main
-    if (!MainNet()) {
-        return false;
-    }
-
     int nMinHeight = GetWrapModeHeight();
-    int nStoreEveryBlock = ::ChainstateActive().IsInitialBlockDownload() ?
+    int nStoreEveryBlock = IsInitialBlockDownload() ?
                             STORE_EVERY_N_BLOCK_IDB : STORE_EVERY_N_BLOCK;
     // if too far away from the top -- do not write
     return blockHeight > nMinHeight && (blockHeight % nStoreEveryBlock == 0);
@@ -545,7 +529,7 @@ int PersistInMemoryState(const CBlockIndex* pBlockIndex)
     // clean-up the directory
     prune_state_files(pBlockIndex);
 
-    pDbSpInfo->setWatermark(pBlockIndex->GetBlockHash());
+    pDbSpInfo->setWatermark(pBlockIndex->GetBlockHash(), pBlockIndex->nHeight);
 
     return 0;
 }
@@ -666,171 +650,26 @@ int RestoreInMemoryState(const std::string& filename, int what, bool verifyHash)
  */
 int LoadMostRelevantInMemoryState()
 {
-    int res = -1;
+    int block = -1;
     uint256 spWatermark;
-    {
-        LOCK(cs_tally);
-        PrintToLog("Trying to load most relevant state into memory..\n");
-        // check the SP database and roll it back to its latest valid state
-        // according to the active chain
-        if (!pDbSpInfo->getWatermark(spWatermark)) {
-            // trigger a full reparse, if the SP database has no watermark
-            PrintToLog("Failed to load historical state: SP database has no watermark\n");
-            return -1;
-        }
-
+    PrintToLog("Trying to load most relevant state into memory..\n");
+    // check the SP database and roll it back to its latest valid state
+    // according to the active chain
+    if (!pDbSpInfo->getWatermark(spWatermark, block)) {
+        // trigger a full reparse, if the SP database has no watermark
+        PrintToLog("Failed to load historical state: SP database has no watermark\n");
+        return -1;
     }
 
-    // Try and get watermark block
-    CBlockIndex const *spBlockIndex = GetBlockIndex(spWatermark);
-
-    // Watermark block not found.
-    if (nullptr == spBlockIndex)
-    {
-        PrintToLog("spWatermark not found: %s\n", spWatermark.ToString());
-
-        // Try and load an historical state
-        fs::directory_iterator dIter(pathStateFiles);
-        fs::directory_iterator endIter;
-        std::map<int, const CBlockIndex*> foundBlocks;
-
-        for (; dIter != endIter; ++dIter) {
-            if (false == fs::is_regular_file(dIter->status()) || dIter->path().empty()) {
-                // skip funny business
-                continue;
-            }
-
-            std::string fName = (*--dIter->path().end()).string();
-            std::vector<std::string> vstr;
-            boost::split(vstr, fName, boost::is_any_of("-."), boost::token_compress_on);
-            if (vstr.size() == 3 && boost::equals(vstr[2], "dat")) {
-                uint256 blockHash;
-                blockHash.SetHex(vstr[1]);
-                CBlockIndex *pBlockIndex = GetBlockIndex(blockHash);
-                if (pBlockIndex == nullptr) {
-                    continue;
-                }
-
-                // Add to found blocks
-                foundBlocks.emplace(pBlockIndex->nHeight, pBlockIndex);
-            }
-        }
-
-        // Was unable to find valid previous state, full reparse required.
-        if (foundBlocks.empty()) {
-            PrintToLog("Failed to load historical state: watermark isn't a real block\n");
+    for (int i = 0; i < NUM_FILETYPES; ++i) {
+        auto fileName = strprintf("%s-%s.dat", statePrefix[i], spWatermark.ToString());
+        fs::path path = pathStateFiles / fileName.c_str();
+        if (RestoreInMemoryState(path.string(), i, true) < 0) {
+            PrintToConsole("Found a state inconsistency, reindex is needed...\n");
             return -1;
         }
-
-        spBlockIndex = foundBlocks.rbegin()->second;
-        pDbSpInfo->setWatermark(spBlockIndex->GetBlockHash());
-
-        PrintToLog("Watermark not found. New one set from state files: %s\n", spBlockIndex->GetBlockHash().ToString());
-    }
-
-    std::set<uint256> persistedBlocks;
-    {
-        LOCK2(cs_main, cs_tally);
-
-        PrintToLog("Rolling back blocks to active chain.\n");
-
-        while (nullptr != spBlockIndex && false == ::ChainActive().Contains(spBlockIndex)) {
-            int remainingSPs = pDbSpInfo->popBlock(spBlockIndex->GetBlockHash());
-            if (remainingSPs < 0) {
-                // trigger a full reparse, if the levelDB cannot roll back
-                PrintToLog("Failed to load historical state: no valid state found after rolling back SP database\n");
-                return -1;
-            }
-
-            spBlockIndex = spBlockIndex->pprev;
-            if (spBlockIndex != nullptr) {
-                pDbSpInfo->setWatermark(spBlockIndex->GetBlockHash());
-            }
-        }
-
-        // prepare a set of available files by block hash pruning any that are
-        // not in the active chain
-        fs::directory_iterator dIter(pathStateFiles);
-        fs::directory_iterator endIter;
-        for (; dIter != endIter; ++dIter) {
-            if (false == fs::is_regular_file(dIter->status()) || dIter->path().empty()) {
-                // skip funny business
-                continue;
-            }
-
-            std::string fName = (*--dIter->path().end()).string();
-            std::vector<std::string> vstr;
-            boost::split(vstr, fName, boost::is_any_of("-."), boost::token_compress_on);
-            if (vstr.size() == 3 &&
-                    boost::equals(vstr[2], "dat")) {
-                uint256 blockHash;
-                blockHash.SetHex(vstr[1]);
-                CBlockIndex *pBlockIndex = GetBlockIndex(blockHash);
-                if (pBlockIndex == nullptr || false == ::ChainActive().Contains(pBlockIndex)) {
-                    continue;
-                }
-
-                // this is a valid block in the active chain, store it
-                persistedBlocks.insert(blockHash);
-            }
-        }
-    }
-
-    {
-        LOCK(cs_tally);
-        // using the SP's watermark after its fixed-up as the tip
-        // walk backwards until we find a valid and full set of persisted state files
-        // for each block we discard, roll back the SP database
-        CBlockIndex const *curTip = spBlockIndex;
-        int abortRollBackBlock = 9999999;
-        if (curTip != nullptr) {
-            abortRollBackBlock = ConsensusParams().GENESIS_BLOCK - 1;
-        }
-        while (nullptr != curTip && persistedBlocks.size() > 0 && curTip->nHeight > abortRollBackBlock ) {
-            if (persistedBlocks.find(curTip->GetBlockHash()) != persistedBlocks.end()) {
-                int success = -1;
-                for (int i = 0; i < NUM_FILETYPES; ++i) {
-                    auto fileName = strprintf("%s-%s.dat", statePrefix[i], curTip->GetBlockHash().ToString());
-                    fs::path path = pathStateFiles / fileName.c_str();
-                    const std::string strFile = path.string();
-                    success = RestoreInMemoryState(strFile, i, true);
-                    if (success < 0) {
-                        PrintToConsole("Found a state inconsistency at block height %d. "
-                                "Reverting up to %d blocks.. this may take a few minutes.\n",
-                                curTip->nHeight, (curTip->nHeight - abortRollBackBlock - 1));
-                        break;
-                    }
-                }
-
-                if (success >= 0) {
-                    res = curTip->nHeight;
-                    break;
-                }
-
-                // remove this from the persistedBlock Set
-                persistedBlocks.erase(spBlockIndex->GetBlockHash());
-            }
-
-            // go to the previous block
-            if (pDbSpInfo->popBlock(curTip->GetBlockHash()) <= 0) {
-                // trigger a full reparse, if the levelDB cannot roll back
-                PrintToLog("Failed to load historical state: no valid state found after rolling back SP database (2)\n");
-                return -1;
-            }
-            curTip = curTip->pprev;
-            spBlockIndex = curTip;
-            if (curTip != nullptr) {
-                pDbSpInfo->setWatermark(curTip->GetBlockHash());
-            }
-        }
-    }
-
-    if (persistedBlocks.size() == 0) {
-        // trigger a reparse if we exhausted the persistence files without success
-        PrintToLog("Failed to load historical state: no valid state found after exhausting persistence files\n");
-        return -1;
     }
 
     // return the height of the block we settled at
-    return res;
+    return block;
 }
diff --git a/src/omnicore/rpc.cpp b/src/omnicore/rpc.cpp
index e7349c6517ee1..ab84fd01df42a 100644
--- a/src/omnicore/rpc.cpp
+++ b/src/omnicore/rpc.cpp
@@ -18,6 +18,7 @@
 #include <omnicore/errors.h>
 #include <omnicore/log.h>
 #include <omnicore/mdex.h>
+#include <omnicore/mempool.h>
 #include <omnicore/notifications.h>
 #include <omnicore/omnicore.h>
 #include <omnicore/parsing.h>
@@ -29,6 +30,7 @@
 #include <omnicore/sp.h>
 #include <omnicore/sto.h>
 #include <omnicore/tally.h>
+#include <omnicore/dbtransaction.h>
 #include <omnicore/tx.h>
 #include <omnicore/nftdb.h>
 #include <omnicore/utilsbitcoin.h>
@@ -40,7 +42,6 @@
 #include <base58.h>
 #include <chainparams.h>
 #include <init.h>
-#include <index/txindex.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
 #include <key_io.h>
@@ -65,6 +66,7 @@ using namespace wallet;
 #include <map>
 #include <stdexcept>
 #include <string>
+#include <thread>
 #include <tuple>
 
 #include <boost/algorithm/string.hpp> // boost::split
@@ -103,6 +105,15 @@ void PopulateFailure(int error)
     throw JSONRPCError(RPC_INTERNAL_ERROR, "Generic transaction population failure");
 }
 
+/**
+ * Lock isn't held, rpc method should do it on demand
+ */
+void EnsureNotProcessingBlock()
+{
+    while (IsProcessingBlock())
+        std::this_thread::yield();
+}
+
 void PropertyToJSON(const CMPSPInfo::Entry& sProperty, UniValue& property_obj)
 {
     property_obj.pushKV("name", sProperty.name);
@@ -137,7 +148,9 @@ void MetaDexObjectToJSON(const CMPMetaDEx& obj, UniValue& metadex_obj)
     metadex_obj.pushKV("amounttofill", FormatMP(obj.getDesProperty(), obj.getAmountToFill()));
     metadex_obj.pushKV("action", (int) obj.getAction());
     metadex_obj.pushKV("block", obj.getBlock());
-    metadex_obj.pushKV("blocktime", obj.getBlockTime());
+    if (auto blockIndex = GetActiveChain()[obj.getBlock()]) {
+        metadex_obj.pushKV("blocktime", blockIndex->GetBlockTime());
+    }
 }
 
 void MetaDexObjectsToJSON(std::vector<CMPMetaDEx>& vMetaDexObjs, UniValue& response)
@@ -150,7 +163,6 @@ void MetaDexObjectsToJSON(std::vector<CMPMetaDEx>& vMetaDexObjs, UniValue& respo
     for (std::vector<CMPMetaDEx>::const_iterator it = vMetaDexObjs.begin(); it != vMetaDexObjs.end(); ++it) {
         UniValue metadex_obj(UniValue::VOBJ);
         MetaDexObjectToJSON(*it, metadex_obj);
-
         response.push_back(metadex_obj);
     }
 }
@@ -208,6 +220,7 @@ UniValue omni_getnonfungibletokens(const JSONRPCRequest& request)
        }
     }.Check(request);
 
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_NFTS, GetHeight())) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "NFTs not activated");
     }
@@ -274,6 +287,7 @@ UniValue omni_getnonfungibletokendata(const JSONRPCRequest& request)
        }
     }.Check(request);
 
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_NFTS, GetHeight())) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "NFTs not activated");
     }
@@ -366,6 +380,7 @@ UniValue omni_getnonfungibletokenranges(const JSONRPCRequest& request)
        }
     }.Check(request);
 
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_NFTS, GetHeight())) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "NFTs not activated");
     }
@@ -434,8 +449,9 @@ static UniValue omni_getfeedistribution(const JSONRPCRequest& request)
     uint32_t propertyId = 0;
     int64_t total = 0;
 
-    UniValue response(UniValue::VOBJ);
+    EnsureNotProcessingBlock();
 
+    UniValue response(UniValue::VOBJ);
     bool found = pDbFeeHistory->GetDistributionData(id, &propertyId, &block, &total);
     if (!found) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Fee distribution ID does not exist");
@@ -495,43 +511,42 @@ static UniValue omni_getfeedistributions(const JSONRPCRequest& request)
        }
     }.Check(request);
 
+    EnsureNotProcessingBlock();
     uint32_t prop = ParsePropertyId(request.params[0]);
     RequireExistingProperty(prop);
 
     UniValue response(UniValue::VARR);
 
     std::set<int> sDistributions = pDbFeeHistory->GetDistributionsForProperty(prop);
-    if (!sDistributions.empty()) {
-        for (std::set<int>::iterator it = sDistributions.begin(); it != sDistributions.end(); it++) {
-            int id = *it;
-            int block = 0;
-            uint32_t propertyId = 0;
-            int64_t total = 0;
-            UniValue responseObj(UniValue::VOBJ);
-            bool found = pDbFeeHistory->GetDistributionData(id, &propertyId, &block, &total);
-            if (!found) {
-                PrintToLog("Fee History Error - Distribution data not found for distribution ID %d but it was included in GetDistributionsForProperty(prop %d)\n", id, prop);
-                continue;
-            }
-            responseObj.pushKV("distributionid", id);
-            responseObj.pushKV("propertyid", (uint64_t)propertyId);
-            responseObj.pushKV("block", block);
-            responseObj.pushKV("amount", FormatMP(propertyId, total));
-            UniValue recipients(UniValue::VARR);
-            std::set<std::pair<std::string,int64_t> > sRecipients = pDbFeeHistory->GetFeeDistribution(id);
-            if (!sRecipients.empty()) {
-                for (std::set<std::pair<std::string,int64_t> >::iterator it = sRecipients.begin(); it != sRecipients.end(); it++) {
-                    std::string address = (*it).first;
-                    int64_t amount = (*it).second;
-                    UniValue recipient(UniValue::VOBJ);
-                    recipient.pushKV("address", TryEncodeOmniAddress(address));
-                    recipient.pushKV("amount", FormatMP(propertyId, amount));
-                    recipients.push_back(recipient);
-                }
-            }
+    for (std::set<int>::iterator it = sDistributions.begin(); it != sDistributions.end(); it++) {
+        int id = *it;
+        int block = 0;
+        uint32_t propertyId = 0;
+        int64_t total = 0;
+        UniValue responseObj(UniValue::VOBJ);
+        bool found = pDbFeeHistory->GetDistributionData(id, &propertyId, &block, &total);
+        if (!found) {
+            PrintToLog("Fee History Error - Distribution data not found for distribution ID %d but it was included in GetDistributionsForProperty(prop %d)\n", id, prop);
+            continue;
+        }
+        responseObj.pushKV("distributionid", id);
+        responseObj.pushKV("propertyid", (uint64_t)propertyId);
+        responseObj.pushKV("block", block);
+        responseObj.pushKV("amount", FormatMP(propertyId, total));
+        UniValue recipients(UniValue::VARR);
+        std::set<std::pair<std::string,int64_t> > sRecipients = pDbFeeHistory->GetFeeDistribution(id);
+        for (std::set<std::pair<std::string,int64_t> >::iterator it = sRecipients.begin(); it != sRecipients.end(); it++) {
+            std::string address = (*it).first;
+            int64_t amount = (*it).second;
+            UniValue recipient(UniValue::VOBJ);
+            recipient.pushKV("address", TryEncodeOmniAddress(address));
+            recipient.pushKV("amount", FormatMP(propertyId, amount));
+            recipients.push_back(recipient);
+        }
+        if (!recipients.empty()) {
             responseObj.pushKV("recipients", recipients);
-            response.push_back(responseObj);
         }
+        response.push_back(responseObj);
     }
     return response;
 }
@@ -565,6 +580,7 @@ static UniValue omni_getfeetrigger(const JSONRPCRequest& request)
         propertyId = ParsePropertyId(request.params[0]);
     }
 
+    EnsureNotProcessingBlock();
     if (propertyId > 0) {
         RequireExistingProperty(propertyId);
     }
@@ -636,6 +652,8 @@ static UniValue omni_getfeeshare(const JSONRPCRequest& request)
     UniValue response(UniValue::VARR);
     bool addObj = false;
 
+    EnsureNotProcessingBlock();
+
     OwnerAddrType receiversSet;
     if (ecosystem == 1) {
         receiversSet = STO_GetReceivers("FEEDISTRIBUTION", OMNI_PROPERTY_MSC, COIN);
@@ -698,6 +716,8 @@ static UniValue omni_getfeecache(const JSONRPCRequest& request)
         propertyId = ParsePropertyId(request.params[0]);
     }
 
+    EnsureNotProcessingBlock();
+
     if (propertyId > 0) {
         RequireExistingProperty(propertyId);
     }
@@ -749,17 +769,14 @@ static UniValue omni_getseedblocks(const JSONRPCRequest& request)
     int startHeight = request.params[0].getInt<int>();
     int endHeight = request.params[1].getInt<int>();
 
+    EnsureNotProcessingBlock();
     RequireHeightInChain(startHeight);
     RequireHeightInChain(endHeight);
 
     UniValue response(UniValue::VARR);
-
-    {
-        LOCK(cs_tally);
-        std::set<int> setSeedBlocks = pDbTransactionList->GetSeedBlocks(startHeight, endHeight);
-        for (std::set<int>::const_iterator it = setSeedBlocks.begin(); it != setSeedBlocks.end(); ++it) {
-            response.push_back(*it);
-        }
+    std::set<int> setSeedBlocks = pDbTransactionList->GetSeedBlocks(startHeight, endHeight);
+    for (std::set<int>::const_iterator it = setSeedBlocks.begin(); it != setSeedBlocks.end(); ++it) {
+        response.push_back(*it);
     }
 
     return response;
@@ -788,33 +805,17 @@ static UniValue omni_getpayload(const JSONRPCRequest& request)
 
     uint256 txid = ParseHashV(request.params[0], "txid");
 
-    bool f_txindex_ready = false;
-    if (g_txindex) {
-        f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
-    }
+    EnsureNotProcessingBlock();
 
     CTransactionRef tx;
-    uint256 blockHash;
-    if (!GetTransaction(txid, tx, Params().GetConsensus(), blockHash)) {
-        if (!f_txindex_ready) {
-            PopulateFailure(MP_TXINDEX_STILL_SYNCING);
-        } else {
-            PopulateFailure(MP_TX_NOT_FOUND);
-        }
-    }
-
-    int blockTime = 0;
-    int blockHeight = GetHeight();
-    if (!blockHash.IsNull()) {
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        if (nullptr != pBlockIndex) {
-            blockTime = pBlockIndex->nTime;
-            blockHeight = pBlockIndex->nHeight;
-        }
+    int blockHeight;
+    if (!GetTransaction(txid, tx, blockHeight)) {
+        PopulateFailure(MP_TX_NOT_FOUND);
     }
 
     CMPTransaction mp_obj;
-    int parseRC = ParseTransaction(*tx, blockHeight, 0, mp_obj, blockTime);
+    CCoinsViewCacheOnly view;
+    int parseRC = ParseTransaction(view, *tx, blockHeight, 0, mp_obj, 0);
     if (parseRC < 0) PopulateFailure(MP_TX_IS_NOT_OMNI_PROTOCOL);
 
     UniValue payloadObj(UniValue::VOBJ);
@@ -841,8 +842,6 @@ static UniValue omni_setautocommit(const JSONRPCRequest& request)
        }
     }.Check(request);
 
-    LOCK(cs_tally);
-
     autoCommit = request.params[0].get_bool();
     return autoCommit;
 }
@@ -892,7 +891,6 @@ static UniValue mscrpc(const JSONRPCRequest& request)
         }
         case 1:
         {
-            LOCK(cs_tally);
             // display the whole CMPTxList (leveldb)
             pDbTransactionList->printAll();
             pDbTransactionList->printStats();
@@ -900,7 +898,6 @@ static UniValue mscrpc(const JSONRPCRequest& request)
         }
         case 2:
         {
-            LOCK(cs_tally);
             // display smart properties
             pDbSpInfo->printAll();
             break;
@@ -931,8 +928,7 @@ static UniValue mscrpc(const JSONRPCRequest& request)
         }
         case 5:
         {
-            LOCK(cs_tally);
-            PrintToConsole("isMPinBlockRange(%d,%d)=%s\n", extra2, extra3, pDbTransactionList->isMPinBlockRange(extra2, extra3, false) ? "YES" : "NO");
+            PrintToConsole("isMPinBlockRange(%d,%d)=%s\n", extra2, extra3, pDbTransactionList->isMPinBlockRange(extra2, extra3) ? "YES" : "NO");
             break;
         }
         case 6:
@@ -943,7 +939,6 @@ static UniValue mscrpc(const JSONRPCRequest& request)
         }
         case 7:
         {
-            LOCK(cs_tally);
             // display the whole CMPTradeList (leveldb)
             pDbTradeList->printAll();
             pDbTradeList->printStats();
@@ -951,7 +946,6 @@ static UniValue mscrpc(const JSONRPCRequest& request)
         }
         case 8:
         {
-            LOCK(cs_tally);
             // display the STO receive list
             pDbStoList->printAll();
             pDbStoList->printStats();
@@ -992,7 +986,6 @@ static UniValue mscrpc(const JSONRPCRequest& request)
         }
         case 14:
         {
-            LOCK(cs_tally);
             pDbFeeCache->printAll();
             pDbFeeCache->printStats();
 
@@ -1051,6 +1044,7 @@ static UniValue omni_getbalance(const JSONRPCRequest& request)
     std::string address = ParseAddress(request.params[0]);
     uint32_t propertyId = ParsePropertyId(request.params[1]);
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
 
     UniValue balanceObj(UniValue::VOBJ);
@@ -1086,13 +1080,13 @@ static UniValue omni_getallbalancesforid(const JSONRPCRequest& request)
 
     uint32_t propertyId = ParsePropertyId(request.params[0]);
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
 
     UniValue response(UniValue::VARR);
     bool isDivisible = isPropertyDivisible(propertyId); // we want to check this BEFORE the loop
 
     LOCK(cs_tally);
-
     for (std::unordered_map<std::string, CMPTally>::iterator it = mp_tally_map.begin(); it != mp_tally_map.end(); ++it) {
         uint32_t id = 0;
         bool includeAddress = false;
@@ -1150,7 +1144,6 @@ static UniValue omni_getallbalancesforaddress(const JSONRPCRequest& request)
     UniValue response(UniValue::VARR);
 
     LOCK(cs_tally);
-
     CMPTally* addressTally = getTally(address);
 
     if (nullptr == addressTally) { // addressTally object does not exist
@@ -1439,14 +1432,12 @@ static UniValue omni_getproperty(const JSONRPCRequest& request)
 
     uint32_t propertyId = ParsePropertyId(request.params[0]);
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
 
     CMPSPInfo::Entry sp;
-    {
-        LOCK(cs_tally);
-        if (!pDbSpInfo->getSP(propertyId, sp)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
-        }
+    if (!pDbSpInfo->getSP(propertyId, sp)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
     }
     int64_t nTotalTokens = getTotalTokens(propertyId);
     std::string strTotalTokens = FormatMP(propertyId, nTotalTokens);
@@ -1495,34 +1486,22 @@ static UniValue omni_listproperties(const JSONRPCRequest& request)
        }
     }.Check(request);
 
-    UniValue response(UniValue::VARR);
-
-    LOCK(cs_tally);
+    EnsureNotProcessingBlock();
 
-    uint32_t nextSPID = pDbSpInfo->peekNextSPID(1);
-    for (uint32_t propertyId = 1; propertyId < nextSPID; propertyId++) {
-        CMPSPInfo::Entry sp;
-        if (pDbSpInfo->getSP(propertyId, sp)) {
-            UniValue propertyObj(UniValue::VOBJ);
-            propertyObj.pushKV("propertyid", (uint64_t) propertyId);
-            PropertyToJSON(sp, propertyObj); // name, category, subcategory, ...
-
-            response.push_back(propertyObj);
-        }
-    }
-
-    uint32_t nextTestSPID = pDbSpInfo->peekNextSPID(2);
-    for (uint32_t propertyId = TEST_ECO_PROPERTY_1; propertyId < nextTestSPID; propertyId++) {
-        CMPSPInfo::Entry sp;
-        if (pDbSpInfo->getSP(propertyId, sp)) {
-            UniValue propertyObj(UniValue::VOBJ);
-            propertyObj.pushKV("propertyid", (uint64_t) propertyId);
-            PropertyToJSON(sp, propertyObj); // name, category, subcategory, ...
-
-            response.push_back(propertyObj);
+    UniValue response(UniValue::VARR);
+    for (uint8_t ecosystem = 1; ecosystem <= 2; ecosystem++) {
+        uint32_t propertyId = (ecosystem == 1) ? 1 : TEST_ECO_PROPERTY_1;
+        auto nextSPID = pDbSpInfo->peekNextSPID(ecosystem);
+        for (; propertyId < nextSPID; propertyId++) {
+            CMPSPInfo::Entry sp;
+            if (pDbSpInfo->getSP(propertyId, sp)) {
+                UniValue propertyObj(UniValue::VOBJ);
+                propertyObj.pushKV("propertyid", (uint64_t) propertyId);
+                PropertyToJSON(sp, propertyObj); // name, category, subcategory, ...
+                response.push_back(propertyObj);
+            }
         }
     }
-
     return response;
 }
 
@@ -1576,32 +1555,21 @@ static UniValue omni_getcrowdsale(const JSONRPCRequest& request)
     uint32_t propertyId = ParsePropertyId(request.params[0]);
     bool showVerbose = (request.params.size() > 1) ? request.params[1].get_bool() : false;
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireCrowdsale(propertyId);
 
     CMPSPInfo::Entry sp;
-    {
-        LOCK(cs_tally);
-        if (!pDbSpInfo->getSP(propertyId, sp)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
-        }
+    if (!pDbSpInfo->getSP(propertyId, sp)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
     }
 
     const uint256& creationHash = sp.txid;
 
-    bool f_txindex_ready = false;
-    if (g_txindex) {
-        f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
-    }
-
     CTransactionRef tx;
-    uint256 hashBlock;
-    if (!GetTransaction(creationHash, tx, Params().GetConsensus(), hashBlock)) {
-        if (!f_txindex_ready) {
-            PopulateFailure(MP_TXINDEX_STILL_SYNCING);
-        } else {
-            PopulateFailure(MP_TX_NOT_FOUND);
-        }
+    int blockHeight;
+    if (!GetTransaction(creationHash, tx, blockHeight)) {
+        PopulateFailure(MP_TX_NOT_FOUND);
     }
 
     UniValue response(UniValue::VOBJ);
@@ -1612,7 +1580,6 @@ static UniValue omni_getcrowdsale(const JSONRPCRequest& request)
         bool crowdFound = false;
 
         LOCK(cs_tally);
-
         for (CrowdMap::const_iterator it = my_crowds.begin(); it != my_crowds.end(); ++it) {
             const CMPCrowd& crowd = it->second;
             if (propertyId == crowd.getPropertyId()) {
@@ -1630,9 +1597,9 @@ static UniValue omni_getcrowdsale(const JSONRPCRequest& request)
     int64_t tokensIssued = getTotalTokens(propertyId);
     const std::string& txidClosed = sp.txid_close.GetHex();
 
-    int64_t startTime = -1;
-    if (!hashBlock.IsNull() && GetBlockIndex(hashBlock)) {
-        startTime = GetBlockIndex(hashBlock)->nTime;
+    int64_t startTime = 0;
+    if (auto blockIndex = GetActiveChain()[blockHeight]) {
+        startTime = blockIndex->GetBlockTime();
     }
 
     // note the database is already deserialized here and there is minimal performance penalty to iterate recipients to calculate amountRaised
@@ -1716,8 +1683,7 @@ static UniValue omni_getactivecrowdsales(const JSONRPCRequest& request)
 
     UniValue response(UniValue::VARR);
 
-    LOCK2(cs_main, cs_tally);
-
+    LOCK(cs_tally);
     for (CrowdMap::const_iterator it = my_crowds.begin(); it != my_crowds.end(); ++it) {
         const CMPCrowd& crowd = it->second;
         uint32_t propertyId = crowd.getPropertyId();
@@ -1729,24 +1695,15 @@ static UniValue omni_getactivecrowdsales(const JSONRPCRequest& request)
 
         const uint256& creationHash = sp.txid;
 
-        bool f_txindex_ready = false;
-        if (g_txindex) {
-            f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
-        }
-
         CTransactionRef tx;
-        uint256 hashBlock;
-        if (!GetTransaction(creationHash, tx, Params().GetConsensus(), hashBlock)) {
-            if (!f_txindex_ready) {
-                PopulateFailure(MP_TXINDEX_STILL_SYNCING);
-            } else {
-                PopulateFailure(MP_TX_NOT_FOUND);
-            }
+        int blockHeight;
+        if (!GetTransaction(creationHash, tx, blockHeight)) {
+            PopulateFailure(MP_TX_NOT_FOUND);
         }
 
-        int64_t startTime = -1;
-        if (!hashBlock.IsNull() && GetBlockIndex(hashBlock)) {
-            startTime = GetBlockIndex(hashBlock)->nTime;
+        int64_t startTime = 0;
+        if (auto blockIndex = GetActiveChain()[blockHeight]) {
+            startTime = blockIndex->GetBlockTime();
         }
 
         UniValue responseObj(UniValue::VOBJ);
@@ -1803,15 +1760,13 @@ static UniValue omni_getgrants(const JSONRPCRequest& request)
 
     uint32_t propertyId = ParsePropertyId(request.params[0]);
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
 
     CMPSPInfo::Entry sp;
-    {
-        LOCK(cs_tally);
-        if (false == pDbSpInfo->getSP(propertyId, sp)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
-        }
+    if (false == pDbSpInfo->getSP(propertyId, sp)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
     }
     UniValue response(UniValue::VOBJ);
     const uint256& creationHash = sp.txid;
@@ -1891,6 +1846,7 @@ static UniValue omni_getorderbook(const JSONRPCRequest& request)
     uint32_t propertyIdForSale = ParsePropertyId(request.params[0]);
     uint32_t propertyIdDesired = 0;
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyIdForSale);
 
     if (filterDesired) {
@@ -1988,6 +1944,7 @@ static UniValue omni_gettradehistoryforaddress(const JSONRPCRequest& request)
     uint64_t count = (request.params.size() > 1) ? request.params[1].getInt<int64_t>() : 10;
     uint32_t propertyId = 0;
 
+    EnsureNotProcessingBlock();
     if (request.params.size() > 2) {
         propertyId = ParsePropertyId(request.params[2]);
         RequireExistingProperty(propertyId);
@@ -1995,10 +1952,7 @@ static UniValue omni_gettradehistoryforaddress(const JSONRPCRequest& request)
 
     // Obtain a sorted vector of txids for the address trade history
     std::vector<uint256> vecTransactions;
-    {
-        LOCK(cs_tally);
-        pDbTradeList->getTradesForAddress(address, vecTransactions, propertyId);
-    }
+    pDbTradeList->getTradesForAddress(address, vecTransactions, propertyId);
 
 #ifdef ENABLE_WALLET
     if (wallet && !vecTransactions.empty()) {
@@ -2060,6 +2014,7 @@ static UniValue omni_gettradehistoryforpair(const JSONRPCRequest& request)
     uint32_t propertyIdSideB = ParsePropertyId(request.params[1]);
     uint64_t count = (request.params.size() > 2) ? request.params[2].getInt<int64_t>() : 10;
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyIdSideA);
     RequireExistingProperty(propertyIdSideB);
     RequireSameEcosystem(propertyIdSideA, propertyIdSideB);
@@ -2067,7 +2022,6 @@ static UniValue omni_gettradehistoryforpair(const JSONRPCRequest& request)
 
     // request pair trade history from trade db
     UniValue response(UniValue::VARR);
-    LOCK(cs_tally);
     pDbTradeList->getTradesForPair(propertyIdSideA, propertyIdSideB, response, count);
     return response;
 }
@@ -2124,7 +2078,6 @@ static UniValue omni_getactivedexsells(const JSONRPCRequest& request)
     int curBlock = GetHeight();
 
     LOCK(cs_tally);
-
     for (OfferMap::iterator it = my_offers.begin(); it != my_offers.end(); ++it) {
         const CMPOffer& selloffer = it->second;
         std::vector<std::string> vstr;
@@ -2223,15 +2176,14 @@ static UniValue omni_listblocktransactions(const JSONRPCRequest& request)
 
     int blockHeight = request.params[0].getInt<int>();
 
+    EnsureNotProcessingBlock();
     RequireHeightInChain(blockHeight);
 
     // next let's obtain the block for this height
     CBlock block;
     {
-        LOCK(cs_main);
-        CBlockIndex* pBlockIndex = ::ChainActive()[blockHeight];
-
-        if (!node::ReadBlockFromDisk(block, pBlockIndex, Params().GetConsensus())) {
+        auto* pBlockIndex = GetActiveChain()[blockHeight];
+        if (!pBlockIndex || !node::ReadBlockFromDisk(block, pBlockIndex, Params().GetConsensus())) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Failed to read block from disk");
         }
     }
@@ -2240,11 +2192,8 @@ static UniValue omni_listblocktransactions(const JSONRPCRequest& request)
 
     // now we want to loop through each of the transactions in the block and run against CMPTxList::exists
     // those that return positive add to our response array
-
-    LOCK(cs_tally);
-
     for(const auto& tx : block.vtx) {
-        if (pDbTransactionList->exists(tx->GetHash())) {
+        if (pDbTransactionList->existsMPTX(tx->GetHash())) {
             // later we can add a verbose flag to decode here, but for now callers can send returned txids into gettransaction_MP
             // add the txid into the response as it's an MP transaction
             response.push_back(tx->GetHash().GetHex());
@@ -2279,11 +2228,7 @@ static UniValue omni_listblockstransactions(const JSONRPCRequest& request)
 
     std::set<uint256> txs;
     UniValue response(UniValue::VARR);
-
-    LOCK(cs_tally);
-    {
-        pDbTransactionList->GetOmniTxsInBlockRange(blockFirst, blockLast, txs);
-    }
+    pDbTransactionList->GetOmniTxsInBlockRange(blockFirst, blockLast, txs);
 
     for(const uint256& tx : txs) {
         response.push_back(tx.GetHex());
@@ -2473,16 +2418,10 @@ static UniValue omni_listpendingtransactions(const JSONRPCRequest& request)
     }
 
     std::vector<uint256> vTxid;
-    if (auto mempool = ::ChainstateActive().GetMempool()) {
-        mempool->queryHashes(vTxid);
-    }
+    MempoolQueryHashes(vTxid);
 
     UniValue result(UniValue::VARR);
     for(const uint256& hash : vTxid) {
-        if (!IsInMarkerCache(hash)) {
-            continue;
-        }
-
         UniValue txObj(UniValue::VOBJ);
         if (populateRPCTransactionObject(hash, txObj, filterAddress, false, "", pWallet.get()) == 0) {
             result.push_back(txObj);
@@ -2535,11 +2474,10 @@ static UniValue omni_getinfo(const JSONRPCRequest& request)
     infoResponse.pushKV("bitcoincoreversion", BitcoinCoreVersion());
 
     // provide the current block details
+    EnsureNotProcessingBlock();
     int block = GetHeight();
     int64_t blockTime = GetLatestBlockTime();
 
-    LOCK(cs_tally);
-
     int blockMPTransactions = pDbTransactionList->getMPTransactionCountBlock(block);
     int totalMPTransactions = pDbTransactionList->getMPTransactionCountTotal();
     int totalMPTrades = pDbTradeList->getMPTradeCountTotal();
@@ -2553,6 +2491,7 @@ static UniValue omni_getinfo(const JSONRPCRequest& request)
     infoResponse.pushKV("totaltransactions", totalMPTransactions);
 
     // handle alerts
+    LOCK(cs_tally);
     UniValue alerts(UniValue::VARR);
     std::vector<AlertData> omniAlerts = GetOmniCoreAlerts();
     for (std::vector<AlertData>::iterator it = omniAlerts.begin(); it != omniAlerts.end(); it++) {
@@ -2617,6 +2556,7 @@ static UniValue omni_getactivations(const JSONRPCRequest& request)
 
     UniValue response(UniValue::VOBJ);
 
+    LOCK(cs_tally);
     UniValue arrayPendingActivations(UniValue::VARR);
     std::vector<FeatureActivation> vecPendingActivations = GetPendingActivations();
     for (std::vector<FeatureActivation>::iterator it = vecPendingActivations.begin(); it != vecPendingActivations.end(); ++it) {
@@ -2802,17 +2742,12 @@ static UniValue omni_getcurrentconsensushash(const JSONRPCRequest& request)
        }
     }.Check(request);
 
-    LOCK(cs_main); // TODO - will this ensure we don't take in a new block in the couple of ms it takes to calculate the consensus hash?
-
-    int block = GetHeight();
-
-    CBlockIndex* pblockindex = ::ChainActive()[block];
+    auto* pblockindex = GetActiveChain().Tip();
     uint256 blockHash = pblockindex->GetBlockHash();
-
     uint256 consensusHash = GetConsensusHash();
 
     UniValue response(UniValue::VOBJ);
-    response.pushKV("block", block);
+    response.pushKV("block", pblockindex->nHeight);
     response.pushKV("blockhash", blockHash.GetHex());
     response.pushKV("consensushash", consensusHash.GetHex());
 
@@ -2841,22 +2776,19 @@ static UniValue omni_getmetadexhash(const JSONRPCRequest& request)
        }
     }.Check(request);
 
-    LOCK(cs_main);
-
     uint32_t propertyId = 0;
+    EnsureNotProcessingBlock();
     if (request.params.size() > 0) {
         propertyId = ParsePropertyId(request.params[0]);
         RequireExistingProperty(propertyId);
     }
 
-    int block = GetHeight();
-    CBlockIndex* pblockindex = ::ChainActive()[block];
+    auto* pblockindex = GetActiveChain().Tip();
     uint256 blockHash = pblockindex->GetBlockHash();
-
     uint256 metadexHash = GetMetaDExHash(propertyId);
 
     UniValue response(UniValue::VOBJ);
-    response.pushKV("block", block);
+    response.pushKV("block", pblockindex->nHeight);
     response.pushKV("blockhash", blockHash.GetHex());
     response.pushKV("propertyid", (uint64_t)propertyId);
     response.pushKV("metadexhash", metadexHash.GetHex());
@@ -2886,19 +2818,16 @@ static UniValue omni_getbalanceshash(const JSONRPCRequest& request)
         }
     }.Check(request);
 
-    LOCK(cs_main);
-
     uint32_t propertyId = ParsePropertyId(request.params[0]);
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
 
-    int block = GetHeight();
-    CBlockIndex* pblockindex = ::ChainActive()[block];
+    auto* pblockindex = GetActiveChain().Tip();
     uint256 blockHash = pblockindex->GetBlockHash();
-
     uint256 balancesHash = GetBalancesHash(propertyId);
 
     UniValue response(UniValue::VOBJ);
-    response.pushKV("block", block);
+    response.pushKV("block", pblockindex->nHeight);
     response.pushKV("blockhash", blockHash.GetHex());
     response.pushKV("propertyid", (uint64_t)propertyId);
     response.pushKV("balanceshash", balancesHash.GetHex());
diff --git a/src/omnicore/rpc.h b/src/omnicore/rpc.h
index 47df56d2e2036..03ee2360ee7c6 100644
--- a/src/omnicore/rpc.h
+++ b/src/omnicore/rpc.h
@@ -17,4 +17,7 @@
 /** Throws a JSONRPCError, depending on error code. */
 void PopulateFailure(int error);
 
+/** Ensures interface isn't in the middle of block processing. */
+void EnsureNotProcessingBlock();
+
 #endif // BITCOIN_OMNICORE_RPC_H
diff --git a/src/omnicore/rpcpayload.cpp b/src/omnicore/rpcpayload.cpp
index 932cac8dfa3c6..1b0f95ad0a9a0 100644
--- a/src/omnicore/rpcpayload.cpp
+++ b/src/omnicore/rpcpayload.cpp
@@ -14,7 +14,6 @@
 
 #include <stdint.h>
 
-using std::runtime_error;
 using namespace mastercore;
 
 static UniValue omni_createpayload_simplesend(const JSONRPCRequest& request)
diff --git a/src/omnicore/rpcrawtx.cpp b/src/omnicore/rpcrawtx.cpp
index 7569fd243df7a..a4823c5e4bdbf 100644
--- a/src/omnicore/rpcrawtx.cpp
+++ b/src/omnicore/rpcrawtx.cpp
@@ -26,12 +26,6 @@ using namespace wallet;
 #include <stdexcept>
 #include <string>
 
-extern RecursiveMutex cs_main;
-
-using mastercore::cs_tx_cache;
-using mastercore::view;
-using mastercore::viewDummy;
-
 #ifdef ENABLE_WALLET
 extern std::pair<std::shared_ptr<CWallet>, std::unique_ptr<interfaces::Wallet>> GetWalletFromContextForJSONRPCRequest(const JSONRPCRequest& request);
 #endif
@@ -85,15 +79,11 @@ static UniValue omni_decodetransaction(const JSONRPCRequest& request)
        }
     }.Check(request);
 
+    std::vector<PrevTxsEntry> prevTxsParsed;
     CTransaction tx = ParseTransaction(request.params[0]);
 
-    // use a dummy coins view to store the user provided transaction inputs
-    CCoinsView viewDummyTemp;
-    CCoinsViewCache viewTemp(&viewDummyTemp);
-
     if (request.params.size() > 1) {
-        std::vector<PrevTxsEntry> prevTxsParsed = ParsePrevTxs(request.params[1]);
-        InputsToView(prevTxsParsed, viewTemp);
+        prevTxsParsed = ParsePrevTxs(request.params[1]);
     }
 
     int blockHeight = 0;
@@ -102,16 +92,7 @@ static UniValue omni_decodetransaction(const JSONRPCRequest& request)
     }
 
     UniValue txObj(UniValue::VOBJ);
-    int populateResult = -3331;
-    {
-        LOCK2(cs_main, cs_tx_cache);
-        // temporarily switch global coins view cache for transaction inputs
-        view.SetBackend(viewTemp);
-        // then get the results
-        populateResult = populateRPCTransactionObject(tx, uint256(), txObj, "", false, "", blockHeight, pWallet.get());
-        // and restore the original, unpolluted coins view cache
-        view.SetBackend(viewDummy);
-    }
+    int populateResult = populateRPCTransactionObject(tx, std::move(prevTxsParsed), txObj, "", false, "", blockHeight, pWallet.get());
 
     if (populateResult != 0) PopulateFailure(populateResult);
 
@@ -298,8 +279,7 @@ static UniValue omni_createrawtx_change(const JSONRPCRequest& request)
     uint32_t nOut = request.params.size() > 4 ? request.params[4].getInt<int64_t>() : 0;
 
     // use a dummy coins view to store the user provided transaction inputs
-    CCoinsView viewDummy;
-    CCoinsViewCache viewTemp(&viewDummy);
+    CCoinsViewCacheOnly viewTemp;
     InputsToView(prevTxsParsed, viewTemp);
 
     // extend the transaction
diff --git a/src/omnicore/rpcrequirements.cpp b/src/omnicore/rpcrequirements.cpp
index a45f5509f8850..34dd155bf072d 100644
--- a/src/omnicore/rpcrequirements.cpp
+++ b/src/omnicore/rpcrequirements.cpp
@@ -45,7 +45,6 @@ void RequirePropertyName(const std::string& name)
 
 void RequireExistingProperty(uint32_t propertyId)
 {
-    LOCK(cs_tally);
     if (!mastercore::IsPropertyIdValid(propertyId)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
     }
@@ -53,7 +52,6 @@ void RequireExistingProperty(uint32_t propertyId)
 
 void RequireExistingDelegate(uint32_t propertyId)
 {
-    LOCK(cs_tally);
     if (!mastercore::HasDelegate(propertyId)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Property does not have a delegate");
     }
@@ -61,7 +59,6 @@ void RequireExistingDelegate(uint32_t propertyId)
 
 void RequireEmptyDelegate(uint32_t propertyId)
 {
-    LOCK(cs_tally);
     if (mastercore::HasDelegate(propertyId)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Property already has a delegate " + mastercore::GetDelegate(propertyId));
     }
@@ -69,7 +66,6 @@ void RequireEmptyDelegate(uint32_t propertyId)
 
 void RequireSenderDelegateBeforeIssuer(uint32_t propertyId, const std::string& address)
 {
-    LOCK(cs_tally);
     CMPSPInfo::Entry sp;
     if (!mastercore::pDbSpInfo->getSP(propertyId, sp)) {
         throw JSONRPCError(RPC_DATABASE_ERROR, "Failed to retrieve property");
@@ -87,7 +83,6 @@ void RequireSenderDelegateBeforeIssuer(uint32_t propertyId, const std::string& a
 
 void RequireSenderDelegateOrIssuer(uint32_t propertyId, const std::string& address)
 {
-    LOCK(cs_tally);
     CMPSPInfo::Entry sp;
     if (!mastercore::pDbSpInfo->getSP(propertyId, sp)) {
         throw JSONRPCError(RPC_DATABASE_ERROR, "Failed to retrieve property");
@@ -99,7 +94,6 @@ void RequireSenderDelegateOrIssuer(uint32_t propertyId, const std::string& addre
 
 void RequireMatchingDelegate(uint32_t propertyId, const std::string& address)
 {
-    LOCK(cs_tally);
     CMPSPInfo::Entry sp;
     if (!mastercore::pDbSpInfo->getSP(propertyId, sp)) {
         throw JSONRPCError(RPC_DATABASE_ERROR, "Failed to retrieve property");
@@ -125,7 +119,6 @@ void RequireDifferentIds(uint32_t propertyId, uint32_t otherId)
 
 void RequireCrowdsale(uint32_t propertyId)
 {
-    LOCK(cs_tally);
     CMPSPInfo::Entry sp;
     if (!mastercore::pDbSpInfo->getSP(propertyId, sp)) {
         throw JSONRPCError(RPC_DATABASE_ERROR, "Failed to retrieve property");
@@ -145,7 +138,6 @@ void RequireActiveCrowdsale(uint32_t propertyId)
 
 void RequireManagedProperty(uint32_t propertyId)
 {
-    LOCK(cs_tally);
     CMPSPInfo::Entry sp;
     if (!mastercore::pDbSpInfo->getSP(propertyId, sp)) {
         throw JSONRPCError(RPC_DATABASE_ERROR, "Failed to retrieve property");
@@ -157,7 +149,6 @@ void RequireManagedProperty(uint32_t propertyId)
 
 void RequireNonFungibleProperty(uint32_t propertyId)
 {
-    LOCK(cs_tally);
     CMPSPInfo::Entry sp;
     if (!mastercore::pDbSpInfo->getSP(propertyId, sp)) {
         throw JSONRPCError(RPC_DATABASE_ERROR, "Failed to retrieve property");
@@ -169,7 +160,6 @@ void RequireNonFungibleProperty(uint32_t propertyId)
 
 void RequireTokenIssuer(const std::string& address, uint32_t propertyId)
 {
-    LOCK(cs_tally);
     CMPSPInfo::Entry sp;
     if (!mastercore::pDbSpInfo->getSP(propertyId, sp)) {
         throw JSONRPCError(RPC_DATABASE_ERROR, "Failed to retrieve property");
diff --git a/src/omnicore/rpctx.cpp b/src/omnicore/rpctx.cpp
index 0765ac62c8654..d4026cc960a27 100644
--- a/src/omnicore/rpctx.cpp
+++ b/src/omnicore/rpctx.cpp
@@ -11,6 +11,7 @@
 #include <omnicore/nftdb.h>
 #include <omnicore/omnicore.h>
 #include <omnicore/pending.h>
+#include <omnicore/rpc.h>
 #include <omnicore/rpcrequirements.h>
 #include <omnicore/rpcvalues.h>
 #include <omnicore/rules.h>
@@ -91,6 +92,7 @@ static UniValue omni_funded_send(const JSONRPCRequest& request)
     std::string feeAddress = ParseOmniAddress(request.params[4]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireBalance(fromAddress, propertyId, amount);
 
@@ -103,7 +105,7 @@ static UniValue omni_funded_send(const JSONRPCRequest& request)
 
     // create the raw transaction
     uint256 retTxid;
-    int result = CreateFundedTransaction(fromAddress, toAddress, feeAddress, payload, retTxid, pwallet.get(), g_context->get());
+    int result = CreateFundedTransaction(fromAddress, toAddress, feeAddress, payload, retTxid, pwallet.get());
     if (result != 0) {
         throw JSONRPCError(result, error_str(result));
     }
@@ -148,7 +150,7 @@ static UniValue omni_funded_sendall(const JSONRPCRequest& request)
 
     // create the raw transaction
     uint256 retTxid;
-    int result = CreateFundedTransaction(fromAddress, toAddress, feeAddress, payload, retTxid, pwallet.get(), g_context->get());
+    int result = CreateFundedTransaction(fromAddress, toAddress, feeAddress, payload, retTxid, pwallet.get());
     if (result != 0) {
         throw JSONRPCError(result, error_str(result));
     }
@@ -237,6 +239,7 @@ static UniValue omni_send(const JSONRPCRequest& request)
     int64_t referenceAmount = (request.params.size() > 5) ? ParseAmount(request.params[5], true): 0;
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireBalance(fromAddress, propertyId, amount);
     RequireSaneReferenceAmount(referenceAmount);
@@ -296,6 +299,7 @@ static UniValue omni_sendall(const JSONRPCRequest& request)
     int64_t referenceAmount = (request.params.size() > 4) ? ParseAmount(request.params[4], true): 0;
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireSaneReferenceAmount(referenceAmount);
 
     // create a payload for the transaction
@@ -361,6 +365,7 @@ static UniValue omni_sendnonfungible(const JSONRPCRequest& request)
     int64_t referenceAmount = (request.params.size() > 6) ? ParseAmount(request.params[6], true): 0;
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireBalance(fromAddress, propertyId, uniqueTokenAmount);
     RequireNonFungibleTokenOwner(fromAddress, propertyId, tokenStart, tokenEnd);
@@ -426,6 +431,7 @@ static UniValue omni_setnonfungibledata(const JSONRPCRequest& request)
     bool issuer = request.params[3].isNum() ? (request.params[3].getInt<int>() != 0) : request.params[3].get_bool();
     std::string data = ParseText(request.params[4]);
 
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireNonFungibleProperty(propertyId);
     RequireSaneNonFungibleRange(tokenStart, tokenEnd);
@@ -438,13 +444,10 @@ static UniValue omni_setnonfungibledata(const JSONRPCRequest& request)
 
     if (issuer) {
         CMPSPInfo::Entry sp;
-        {
-            LOCK(cs_tally);
-            if (!pDbSpInfo->getSP(propertyId, sp)) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
-            }
-            fromAddress = sp.issuer;
+        if (!pDbSpInfo->getSP(propertyId, sp)) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Property identifier does not exist");
         }
+        fromAddress = sp.issuer;
     }
 
     // create a payload for the transaction
@@ -544,6 +547,7 @@ static UniValue omni_sendtomany(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_TYPE_ERROR, "Error creating send-to-many payload");
     }
     // actual check with proper payload count
+    EnsureNotProcessingBlock();
     RequireBoundedStmReceiverNumber(payloadOutputCount + dummyOutputCount);
     RequireExistingProperty(propertyId);
     RequireBalance(fromAddress, propertyId, amountToSend);
@@ -640,6 +644,7 @@ static UniValue omni_senddexsell(const JSONRPCRequest& request)
     }
 
     // perform checks
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_FREEDEX, GetHeight())) {
         RequirePrimaryToken(propertyIdForSale);
     }
@@ -720,6 +725,7 @@ static UniValue omni_senddexaccept(const JSONRPCRequest& request)
     bool override = (request.params.size() > 4) ? request.params[4].get_bool(): false;
 
     // perform checks
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_FREEDEX, GetHeight())) {
         RequirePrimaryToken(propertyId);
     }
@@ -796,6 +802,7 @@ static UniValue omni_sendnewdexorder(const JSONRPCRequest& request)
     uint8_t action = CMPTransaction::NEW;
 
     // perform checks
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_FREEDEX, GetHeight())) {
         RequirePrimaryToken(propertyIdForSale);
     }
@@ -865,6 +872,7 @@ static UniValue omni_sendupdatedexorder(const JSONRPCRequest& request)
     uint8_t action = CMPTransaction::UPDATE;
 
     // perform checks
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_FREEDEX, GetHeight())) {
         RequirePrimaryToken(propertyIdForSale);
     }
@@ -930,6 +938,7 @@ static UniValue omni_sendcanceldexorder(const JSONRPCRequest& request)
     uint8_t action = CMPTransaction::CANCEL;
 
     // perform checks
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_FREEDEX, GetHeight())) {
         RequirePrimaryToken(propertyIdForSale);
     }
@@ -996,6 +1005,7 @@ static UniValue omni_senddexpay(const JSONRPCRequest& request)
     if (nAmount <= 0)
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount for send");
 
+    EnsureNotProcessingBlock();
     if (!IsFeatureActivated(FEATURE_FREEDEX, GetHeight())) {
         RequirePrimaryToken(propertyId);
     }
@@ -1083,6 +1093,7 @@ static UniValue omni_sendissuancecrowdsale(const JSONRPCRequest& request)
     uint8_t issuerPercentage = ParseIssuerBonus(request.params[13]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequirePropertyName(name);
     RequireExistingProperty(propertyIdDesired);
     RequireSameEcosystem(ecosystem, propertyIdDesired);
@@ -1214,8 +1225,11 @@ static UniValue omni_sendissuancemanaged(const JSONRPCRequest& request)
     std::string url = ParseText(request.params[7]);
     std::string data = ParseText(request.params[8]);
 
-    if (type == 5 && !IsFeatureActivated(FEATURE_NFTS, GetHeight())) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "NFTs not activated");
+    if (type == 5) {
+        EnsureNotProcessingBlock();
+        if (!IsFeatureActivated(FEATURE_NFTS, GetHeight())) {
+            throw JSONRPCError(RPC_INTERNAL_ERROR, "NFTs not activated");
+        }
     }
 
     // perform checks
@@ -1275,6 +1289,7 @@ static UniValue omni_sendsto(const JSONRPCRequest& request)
     uint32_t distributionPropertyId = (request.params.size() > 4) ? ParsePropertyId(request.params[4]) : propertyId;
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireBalance(fromAddress, propertyId, amount);
 
     // create a payload for the transaction
@@ -1332,6 +1347,7 @@ static UniValue omni_sendgrant(const JSONRPCRequest& request)
     std::string info = (request.params.size() > 4) ? ParseText(request.params[4]) : "";
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireSenderDelegateBeforeIssuer(propertyId, fromAddress);
@@ -1388,6 +1404,7 @@ static UniValue omni_sendrevoke(const JSONRPCRequest& request)
     std::string memo = (request.params.size() > 3) ? ParseText(request.params[3]): "";
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireBalance(fromAddress, propertyId, amount);
@@ -1440,6 +1457,7 @@ static UniValue omni_sendclosecrowdsale(const JSONRPCRequest& request)
     uint32_t propertyId = ParsePropertyId(request.params[1]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireCrowdsale(propertyId);
     RequireActiveCrowdsale(propertyId);
@@ -1499,6 +1517,7 @@ static UniValue omni_sendtrade(const JSONRPCRequest& request)
     int64_t amountDesired = ParseAmount(request.params[4], isPropertyDivisible(propertyIdDesired));
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyIdForSale);
     RequireExistingProperty(propertyIdDesired);
     RequireBalance(fromAddress, propertyIdForSale, amountForSale);
@@ -1560,6 +1579,7 @@ static UniValue omni_sendcanceltradesbyprice(const JSONRPCRequest& request)
     int64_t amountDesired = ParseAmount(request.params[4], isPropertyDivisible(propertyIdDesired));
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyIdForSale);
     RequireExistingProperty(propertyIdDesired);
     RequireSameEcosystem(propertyIdForSale, propertyIdDesired);
@@ -1617,6 +1637,7 @@ static UniValue omni_sendcanceltradesbypair(const JSONRPCRequest& request)
     uint32_t propertyIdDesired = ParsePropertyId(request.params[2]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyIdForSale);
     RequireExistingProperty(propertyIdDesired);
     RequireSameEcosystem(propertyIdForSale, propertyIdDesired);
@@ -1725,6 +1746,7 @@ static UniValue omni_sendchangeissuer(const JSONRPCRequest& request)
     uint32_t propertyId = ParsePropertyId(request.params[2]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireTokenIssuer(fromAddress, propertyId);
 
@@ -1776,6 +1798,7 @@ static UniValue omni_sendenablefreezing(const JSONRPCRequest& request)
     uint32_t propertyId = ParsePropertyId(request.params[1]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireTokenIssuer(fromAddress, propertyId);
@@ -1829,6 +1852,7 @@ static UniValue omni_senddisablefreezing(const JSONRPCRequest& request)
     uint32_t propertyId = ParsePropertyId(request.params[1]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireTokenIssuer(fromAddress, propertyId);
@@ -1886,6 +1910,7 @@ static UniValue omni_sendfreeze(const JSONRPCRequest& request)
     int64_t amount = ParseAmount(request.params[3], isPropertyDivisible(propertyId));
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireSenderDelegateBeforeIssuer(propertyId, fromAddress);
@@ -1944,6 +1969,7 @@ static UniValue omni_sendunfreeze(const JSONRPCRequest& request)
     int64_t amount = ParseAmount(request.params[3], isPropertyDivisible(propertyId));
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireSenderDelegateBeforeIssuer(propertyId, fromAddress);
@@ -1999,6 +2025,7 @@ static UniValue omni_sendadddelegate(const JSONRPCRequest& request)
     std::string delegateAddress = ParseOmniAddress(request.params[2]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireTokenIssuer(fromAddress, propertyId);
@@ -2053,6 +2080,7 @@ static UniValue omni_sendremovedelegate(const JSONRPCRequest& request)
     std::string delegateAddress = ParseOmniAddress(request.params[2]);
 
     // perform checks
+    EnsureNotProcessingBlock();
     RequireExistingProperty(propertyId);
     RequireManagedProperty(propertyId);
     RequireExistingDelegate(propertyId);
diff --git a/src/omnicore/rpctxobject.cpp b/src/omnicore/rpctxobject.cpp
index 16d64a9fd47c9..d26586dfa63f4 100644
--- a/src/omnicore/rpctxobject.cpp
+++ b/src/omnicore/rpctxobject.cpp
@@ -6,6 +6,7 @@
 
 #include <omnicore/rpctxobject.h>
 
+#include <omnicore/createtx.h>
 #include <omnicore/dbspinfo.h>
 #include <omnicore/dbstolist.h>
 #include <omnicore/dbtradelist.h>
@@ -25,7 +26,6 @@
 #include <omnicore/walletutils.h>
 
 #include <chainparams.h>
-#include <index/txindex.h>
 #include <validation.h>
 #include <primitives/transaction.h>
 #include <sync.h>
@@ -33,9 +33,6 @@
 
 #include <univalue.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stdint.h>
 #include <string>
 #include <vector>
@@ -52,49 +49,28 @@ using namespace mastercore;
  *
  * DEx payments and the extended mode are only available for confirmed transactions.
  */
-int populateRPCTransactionObject(const uint256& txid, UniValue& txobj, std::string filterAddress, bool extendedDetails, std::string extendedDetailsFilter, interfaces::Wallet* iWallet)
+int populateRPCTransactionObject(const uint256& txid, UniValue& txobj, const std::string& filterAddress, bool extendedDetails, const std::string& extendedDetailsFilter, interfaces::Wallet* iWallet)
 {
-    bool f_txindex_ready = false;
-    if (g_txindex) {
-        f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
-    }
-
     // retrieve the transaction from the blockchain and obtain it's height/confs/time
     CTransactionRef tx;
-    uint256 blockHash;
-    if (!GetTransaction(txid, tx, Params().GetConsensus(), blockHash)) {
-        if (!f_txindex_ready) {
-            return MP_TXINDEX_STILL_SYNCING;
-        } else {
-            return MP_TX_NOT_FOUND;
-        }
+    int blockHeight;
+    if (!GetTransaction(txid, tx, blockHeight)) {
+        return MP_TX_NOT_FOUND;
     }
 
-    return populateRPCTransactionObject(*tx, blockHash, txobj, filterAddress, extendedDetails, extendedDetailsFilter, 0, iWallet);
+    return populateRPCTransactionObject(*tx, {}, txobj, filterAddress, extendedDetails, extendedDetailsFilter, blockHeight, iWallet);
 }
 
-int populateRPCTransactionObject(const CTransaction& tx, const uint256& blockHash, UniValue& txobj, std::string filterAddress, bool extendedDetails, std::string extendedDetailsFilter, int blockHeight, interfaces::Wallet* iWallet)
+int populateRPCTransactionObject(const CTransaction& tx, std::vector<PrevTxsEntry> inputs, UniValue& txobj, const std::string& filterAddress, bool extendedDetails, const std::string& extendedDetailsFilter, int blockHeight, interfaces::Wallet* iWallet)
 {
     int confirmations = 0;
-    int64_t blockTime = 0;
     int positionInBlock = 0;
 
-    if (blockHeight == 0) {
-        blockHeight = GetHeight();
-    }
-
-    if (!blockHash.IsNull()) {
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        if (nullptr != pBlockIndex) {
-            confirmations = 1 + blockHeight - pBlockIndex->nHeight;
-            blockTime = pBlockIndex->nTime;
-            blockHeight = pBlockIndex->nHeight;
-        }
-    }
-
     // attempt to parse the transaction
     CMPTransaction mp_obj;
-    int parseRC = ParseTransaction(tx, blockHeight, 0, mp_obj, blockTime);
+    CCoinsViewCacheOnly view;
+    InputsToView(inputs, view);
+    int parseRC = ParseTransaction(view, tx, blockHeight, 0, mp_obj, 0);
     if (parseRC == -101) {
         return MP_RPC_DECODE_INPUTS_MISSING;
     }
@@ -103,6 +79,7 @@ int populateRPCTransactionObject(const CTransaction& tx, const uint256& blockHas
     }
 
     const uint256& txid = tx.GetHash();
+    confirmations = 1 + GetHeight() - blockHeight;
 
     // DEx BTC payment needs special handling since it's not actually an Omni message - handle and return
     if (parseRC > 0) {
@@ -112,18 +89,16 @@ int populateRPCTransactionObject(const CTransaction& tx, const uint256& blockHas
         }
         std::string tmpBuyer, tmpSeller;
         uint64_t tmpVout, tmpNValue, tmpPropertyId;
-        {
-            LOCK(cs_tally);
-            pDbTransactionList->getPurchaseDetails(txid, 1, &tmpBuyer, &tmpSeller, &tmpVout, &tmpPropertyId, &tmpNValue);
-        }
+        pDbTransactionList->getPurchaseDetails(txid, 1, &tmpBuyer, &tmpSeller, &tmpVout, &tmpPropertyId, &tmpNValue);
         UniValue purchases(UniValue::VARR);
         if (populateRPCDExPurchases(tx, purchases, filterAddress, iWallet) <= 0) return -1;
         txobj.pushKV("txid", txid.GetHex());
         txobj.pushKV("type", "DEx Purchase");
         txobj.pushKV("sendingaddress", TryEncodeOmniAddress(tmpBuyer));
         txobj.pushKV("purchases", purchases);
-        txobj.pushKV("blockhash", blockHash.GetHex());
-        txobj.pushKV("blocktime", blockTime);
+        auto blockIndex = GetActiveChain()[blockHeight];
+        txobj.pushKV("blockhash", blockIndex->GetBlockHash().GetHex());
+        txobj.pushKV("blocktime", blockIndex->GetBlockTime());
         txobj.pushKV("block", blockHeight);
         txobj.pushKV("confirmations", confirmations);
         return 0;
@@ -138,7 +113,6 @@ int populateRPCTransactionObject(const CTransaction& tx, const uint256& blockHas
     // obtain validity - only confirmed transactions can be valid
     bool valid = false;
     if (confirmations > 0) {
-        LOCK(cs_tally);
         valid = pDbTransactionList->getValidMPTX(txid);
         positionInBlock = pDbTransaction->FetchTransactionPosition(txid);
     }
@@ -164,13 +138,14 @@ int populateRPCTransactionObject(const CTransaction& tx, const uint256& blockHas
     populateRPCTypeInfo(mp_obj, txobj, mp_obj.getType(), extendedDetails, extendedDetailsFilter, confirmations, iWallet);
 
     // state and chain related information
-    if (confirmations != 0 && !blockHash.IsNull()) {
+    if (confirmations != 0 && blockHeight != 0) {
         txobj.pushKV("valid", valid);
         if (!valid) {
             txobj.pushKV("invalidreason", pDbTransaction->FetchInvalidReason(txid));
         }
-        txobj.pushKV("blockhash", blockHash.GetHex());
-        txobj.pushKV("blocktime", blockTime);
+        auto blockIndex = GetActiveChain()[blockHeight];
+        txobj.pushKV("blockhash", blockIndex->GetBlockHash().GetHex());
+        txobj.pushKV("blocktime", blockIndex->GetBlockTime());
         txobj.pushKV("positioninblock", positionInBlock);
     }
     if (confirmations != 0) {
@@ -409,7 +384,6 @@ void populateRPCTypeTradeOffer(CMPTransaction& omniObj, UniValue& txobj)
         int tmpblock = 0;
         unsigned int tmptype = 0;
         uint64_t amountNew = 0;
-        LOCK(cs_tally);
         bool tmpValid = pDbTransactionList->getValidMPTX(omniObj.getHash(), &tmpblock, &tmptype, &amountNew);
         if (tmpValid && amountNew > 0) {
             amountDesired = calculateDesiredBTC(amountOffered, amountDesired, amountNew);
@@ -494,7 +468,6 @@ void populateRPCTypeAcceptOffer(CMPTransaction& omniObj, UniValue& txobj)
     uint32_t tmptype = 0;
     uint64_t amountNew = 0;
 
-    LOCK(cs_tally);
     bool tmpValid = pDbTransactionList->getValidMPTX(omniObj.getHash(), &tmpblock, &tmptype, &amountNew);
     if (tmpValid && amountNew > 0) amount = amountNew;
 
@@ -505,7 +478,6 @@ void populateRPCTypeAcceptOffer(CMPTransaction& omniObj, UniValue& txobj)
 
 void populateRPCTypeCreatePropertyFixed(CMPTransaction& omniObj, UniValue& txobj, int confirmations)
 {
-    LOCK(cs_tally);
     if (confirmations > 0) {
         uint32_t propertyId = pDbSpInfo->findSPByTX(omniObj.getHash());
         if (propertyId > 0) {
@@ -526,7 +498,6 @@ void populateRPCTypeCreatePropertyFixed(CMPTransaction& omniObj, UniValue& txobj
 
 void populateRPCTypeCreatePropertyVariable(CMPTransaction& omniObj, UniValue& txobj, int confirmations)
 {
-    LOCK(cs_tally);
     if (confirmations > 0) {
         uint32_t propertyId = pDbSpInfo->findSPByTX(omniObj.getHash());
         if (propertyId > 0) {
@@ -553,7 +524,6 @@ void populateRPCTypeCreatePropertyVariable(CMPTransaction& omniObj, UniValue& tx
 
 void populateRPCTypeCreatePropertyManual(CMPTransaction& omniObj, UniValue& txobj, int confirmations)
 {
-    LOCK(cs_tally);
     if (confirmations > 0) {
         uint32_t propertyId = pDbSpInfo->findSPByTX(omniObj.getHash());
         if (propertyId > 0) {
@@ -586,11 +556,8 @@ void populateRPCTypeGrant(CMPTransaction& omniObj, UniValue& txobj)
     txobj.pushKV("divisible", isPropertyDivisible(propertyId));
     txobj.pushKV("amount", FormatMP(propertyId, omniObj.getAmount()));
     CMPSPInfo::Entry sp;
-    {
-        LOCK(cs_tally);
-        if (!pDbSpInfo->getSP(propertyId, sp)) {
-            return; // TODO : handle error
-        }
+    if (!pDbSpInfo->getSP(propertyId, sp)) {
+        return; // TODO : handle error
     }
     if (sp.unique) {
         populateRPCExtendedTypeGrantNonFungible(omniObj, txobj);
@@ -677,7 +644,6 @@ void populateRPCExtendedTypeSendToOwners(const uint256 txid, std::string extende
 {
     UniValue receiveArray(UniValue::VARR);
     uint64_t tmpAmount = 0, stoFee = 0, numRecipients = 0;
-    LOCK(cs_tally);
     pDbStoList->getRecipients(txid, extendedDetailsFilter, &receiveArray, &tmpAmount, &numRecipients, iWallet);
     if (version == MP_TX_PKT_V0) {
         stoFee = numRecipients * TRANSFER_FEE_PER_OWNER;
@@ -690,7 +656,6 @@ void populateRPCExtendedTypeSendToOwners(const uint256 txid, std::string extende
 
 void populateRPCExtendedTypeGrantNonFungible(CMPTransaction& omniObj, UniValue& txobj)
 {
-    LOCK(cs_tally);
     std::pair<int64_t,int64_t> grantedRange = pDbTransactionList->GetNonFungibleGrant(omniObj.getHash());
     txobj.pushKV("tokenstart", FormatIndivisibleMP(grantedRange.first));
     txobj.pushKV("tokenend", FormatIndivisibleMP(grantedRange.second));
@@ -721,22 +686,13 @@ void populateRPCExtendedTypeMetaDExTrade(const uint256& txid, uint32_t propertyI
 void populateRPCExtendedTypeMetaDExCancel(const uint256& txid, UniValue& txobj)
 {
     UniValue cancelArray(UniValue::VARR);
-    LOCK(cs_tally);
     int numberOfCancels = pDbTransactionList->getNumberOfMetaDExCancels(txid);
     if (0<numberOfCancels) {
         for(int refNumber = 1; refNumber <= numberOfCancels; refNumber++) {
             UniValue cancelTx(UniValue::VOBJ);
-            std::string strValue = pDbTransactionList->getKeyValue(txid.ToString() + "-C" + strprintf("%d",refNumber));
-            if (strValue.empty()) continue;
-            std::vector<std::string> vstr;
-            boost::split(vstr, strValue, boost::is_any_of(":"), boost::token_compress_on);
-            if (vstr.size() != 3) {
-                PrintToLog("TXListDB Error - trade cancel number of tokens is not as expected (%s)\n", strValue);
-                continue;
-            }
-            uint32_t propId = boost::lexical_cast<uint32_t>(vstr[1]);
-            int64_t amountUnreserved = boost::lexical_cast<int64_t>(vstr[2]);
-            cancelTx.pushKV("txid", vstr[0]);
+            uint32_t propId; int64_t amountUnreserved;
+            if (!pDbTransactionList->getMetaDExCancelDetails(txid, refNumber, propId, amountUnreserved)) continue;
+            cancelTx.pushKV("txid", txid.ToString());
             cancelTx.pushKV("propertyid", (uint64_t) propId);
             cancelTx.pushKV("amountunreserved", FormatMP(propId, amountUnreserved));
             cancelArray.push_back(cancelTx);
@@ -750,11 +706,7 @@ void populateRPCExtendedTypeMetaDExCancel(const uint256& txid, UniValue& txobj)
  */
 int populateRPCSendAllSubSends(const uint256& txid, UniValue& subSends)
 {
-    int numberOfSubSends = 0;
-    {
-        LOCK(cs_tally);
-        numberOfSubSends = pDbTransactionList->getNumberOfSubRecords(txid);
-    }
+    int numberOfSubSends = pDbTransactionList->getNumberOfSubRecords(txid);
     if (numberOfSubSends <= 0) {
         PrintToLog("TXLISTDB Error: Transaction %s parsed as a send all but could not locate sub sends in txlistdb.\n", txid.GetHex());
         return -1;
@@ -763,10 +715,7 @@ int populateRPCSendAllSubSends(const uint256& txid, UniValue& subSends)
         UniValue subSendObj(UniValue::VOBJ);
         uint32_t propertyId;
         int64_t amount;
-        {
-            LOCK(cs_tally);
-            pDbTransactionList->getSendAllDetails(txid, subSend, propertyId, amount);
-        }
+        pDbTransactionList->getSendAllDetails(txid, subSend, propertyId, amount);
         subSendObj.pushKV("propertyid", (uint64_t)propertyId);
         subSendObj.pushKV("divisible", isPropertyDivisible(propertyId));
         subSendObj.pushKV("amount", FormatMP(propertyId, amount));
@@ -781,11 +730,7 @@ int populateRPCSendAllSubSends(const uint256& txid, UniValue& subSends)
  */
 int populateRPCDExPurchases(const CTransaction& wtx, UniValue& purchases, std::string filterAddress, interfaces::Wallet *iWallet)
 {
-    int numberOfPurchases = 0;
-    {
-        LOCK(cs_tally);
-        numberOfPurchases = pDbTransactionList->getNumberOfSubRecords(wtx.GetHash());
-    }
+    int numberOfPurchases = pDbTransactionList->getNumberOfSubRecords(wtx.GetHash());
     if (numberOfPurchases <= 0) {
         PrintToLog("TXLISTDB Error: Transaction %s parsed as a DEx payment but could not locate purchases in txlistdb.\n", wtx.GetHash().GetHex());
         return -1;
@@ -794,10 +739,7 @@ int populateRPCDExPurchases(const CTransaction& wtx, UniValue& purchases, std::s
         UniValue purchaseObj(UniValue::VOBJ);
         std::string buyer, seller;
         uint64_t vout, nValue, propertyId;
-        {
-            LOCK(cs_tally);
-            pDbTransactionList->getPurchaseDetails(wtx.GetHash(), purchaseNumber, &buyer, &seller, &vout, &propertyId, &nValue);
-        }
+        pDbTransactionList->getPurchaseDetails(wtx.GetHash(), purchaseNumber, &buyer, &seller, &vout, &propertyId, &nValue);
         if (!filterAddress.empty() && buyer != filterAddress && seller != filterAddress) continue; // filter requested & doesn't match
         bool bIsMine = false;
         if (IsMyAddress(buyer, iWallet) || IsMyAddress(seller, iWallet)) bIsMine = true;
diff --git a/src/omnicore/rpctxobject.h b/src/omnicore/rpctxobject.h
index 71617eb55a9a9..299a2ab37a549 100644
--- a/src/omnicore/rpctxobject.h
+++ b/src/omnicore/rpctxobject.h
@@ -13,8 +13,10 @@ namespace interfaces {
 class Wallet;
 } // namespace interfaces
 
-int populateRPCTransactionObject(const uint256& txid, UniValue& txobj, std::string filterAddress = "", bool extendedDetails = false, std::string extendedDetailsFilter = "", interfaces::Wallet* iWallet = nullptr);
-int populateRPCTransactionObject(const CTransaction& tx, const uint256& blockHash, UniValue& txobj, std::string filterAddress = "", bool extendedDetails = false, std::string extendedDetailsFilter = "", int blockHeight = 0, interfaces::Wallet* iWallet = nullptr);
+class PrevTxsEntry;
+
+int populateRPCTransactionObject(const uint256& txid, UniValue& txobj, const std::string& filterAddress = {}, bool extendedDetails = false, const std::string& extendedDetailsFilter = {}, interfaces::Wallet* iWallet = nullptr);
+int populateRPCTransactionObject(const CTransaction& tx, std::vector<PrevTxsEntry> inputs, UniValue& txobj, const std::string& filterAddress = {}, bool extendedDetails = false, const std::string& extendedDetailsFilter = {}, int blockHeight = 0, interfaces::Wallet* iWallet = nullptr);
 
 void populateRPCTypeInfo(CMPTransaction& mp_obj, UniValue& txobj, uint32_t txType, bool extendedDetails, std::string extendedDetailsFilter, int confirmations, interfaces::Wallet* iWallet = nullptr);
 
diff --git a/src/omnicore/rpcvalues.cpp b/src/omnicore/rpcvalues.cpp
index d6288f6caaf7d..5d19f96d5aec7 100644
--- a/src/omnicore/rpcvalues.cpp
+++ b/src/omnicore/rpcvalues.cpp
@@ -252,7 +252,7 @@ uint32_t ParseOutputIndex(const UniValue& value)
 /** Parses previous transaction outputs. */
 std::vector<PrevTxsEntry> ParsePrevTxs(const UniValue& value)
 {
-    UniValue prevTxs = value.get_array();
+    const UniValue& prevTxs = value.get_array();
 
     std::vector<PrevTxsEntry> prevTxsParsed;
     prevTxsParsed.reserve(prevTxs.size());
@@ -262,7 +262,7 @@ std::vector<PrevTxsEntry> ParsePrevTxs(const UniValue& value)
         if (p.type() != UniValue::VOBJ) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "expected object with {\"txid\",\"vout\",\"scriptPubKey\",\"value\":n.nnnnnnnn}");
         }
-        UniValue prevOut = p.get_obj();
+        const UniValue& prevOut = p.get_obj();
 
         uint256 txid = ParseHashO(prevOut, "txid");
         UniValue outputIndex = find_value(prevOut, "vout");
diff --git a/src/omnicore/rules.cpp b/src/omnicore/rules.cpp
index 44a073785208c..1a07cc4790ce2 100644
--- a/src/omnicore/rules.cpp
+++ b/src/omnicore/rules.cpp
@@ -852,7 +852,7 @@ bool VerifyTransactionExistence(int block)
             continue;
         }
 
-        if (!mastercore::pDbTransactionList->exists(checkpoint.txHash)) {
+        if (!mastercore::pDbTransactionList->existsMPTX(checkpoint.txHash)) {
             PrintToLog("%s: ERROR: failed to find historical transaction %s in block %d\n",
                     __func__, checkpoint.txHash.GetHex(), checkpoint.blockHeight);
             return false;
diff --git a/src/omnicore/seedblocks.cpp b/src/omnicore/seedblocks.cpp
index ba077eb7cf495..a5539eb6d16cb 100644
--- a/src/omnicore/seedblocks.cpp
+++ b/src/omnicore/seedblocks.cpp
@@ -5,9 +5,6 @@
 #include <chainparams.h>
 #include <util/time.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stdint.h>
 #include <set>
 #include <string>
@@ -17,6 +14,7 @@ const int MAX_SEED_BLOCK = 490000;
 
 static std::set<int> GetBlockList()
 {
+    constexpr
     int blocks[] = {249498, 249536, 249559, 249560, 249571, 249590, 249595, 249601, 249603, 249611, 249638, 249639, 249682, 249689, 249704,
                     249716, 249731, 249757, 249763, 249895, 249998, 250039, 250243, 250364, 250471, 250771, 250779, 250780, 250836, 250850,
                     250911, 250939, 250946, 250966, 250988, 251192, 251196, 251201, 251335, 251358, 251391, 251411, 251778, 251807, 251911,
diff --git a/src/omnicore/sp.cpp b/src/omnicore/sp.cpp
index e6ce9b5384f73..4222ba34095ea 100644
--- a/src/omnicore/sp.cpp
+++ b/src/omnicore/sp.cpp
@@ -13,9 +13,6 @@
 #include <uint256.h>
 #include <util/time.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stdint.h>
 
 #include <map>
@@ -152,7 +149,6 @@ std::string mastercore::GetDelegate(uint32_t propertyId)
 
 bool mastercore::isPropertyDivisible(uint32_t propertyId)
 {
-    // TODO: is a lock here needed
     CMPSPInfo::Entry sp;
 
     if (pDbSpInfo->getSP(propertyId, sp)) return sp.isDivisible();
@@ -323,18 +319,14 @@ bool mastercore::isCrowdsalePurchase(const uint256& txid, const std::string& add
     // 2. loop those crowdsales for that address and check their participant txs in database
 
     // check for an active crowdsale to this address
-    CMPCrowd* pcrowdsale = getCrowd(address);
-    if (pcrowdsale) {
-        std::map<uint256, std::vector<int64_t> >::const_iterator it;
-        const std::map<uint256, std::vector<int64_t> >& database = pcrowdsale->getDatabase();
-        for (it = database.begin(); it != database.end(); it++) {
-            const uint256& tmpTxid = it->first;
-            if (tmpTxid == txid) {
-                *propertyId = pcrowdsale->getPropertyId();
-                *userTokens = it->second.at(2);
-                *issuerTokens = it->second.at(3);
-                return true;
-            }
+    if (CMPCrowd* pcrowdsale = getCrowd(address)) {
+        const auto& database = pcrowdsale->getDatabase();
+        auto it = database.find(txid);
+        if (it != database.end()) {
+            *propertyId = pcrowdsale->getPropertyId();
+            *userTokens = it->second.at(2);
+            *issuerTokens = it->second.at(3);
+            return true;
         }
     }
 
@@ -344,13 +336,12 @@ bool mastercore::isCrowdsalePurchase(const uint256& txid, const std::string& add
         for (uint32_t loopPropertyId = startPropertyId; loopPropertyId < pDbSpInfo->peekNextSPID(ecosystem); loopPropertyId++) {
             CMPSPInfo::Entry sp;
             if (!pDbSpInfo->getSP(loopPropertyId, sp)) continue;
-            for (std::map<uint256, std::vector<int64_t> >::const_iterator it = sp.historicalData.begin(); it != sp.historicalData.end(); it++) {
-                if (it->first == txid) {
-                    *propertyId = loopPropertyId;
-                    *userTokens = it->second.at(2);
-                    *issuerTokens = it->second.at(3);
-                    return true;
-                }
+            auto it = sp.historicalData.find(txid);
+            if (it != sp.historicalData.end()) {
+                *propertyId = loopPropertyId;
+                *userTokens = it->second.at(2);
+                *issuerTokens = it->second.at(3);
+                return true;
             }
         }
     }
@@ -359,7 +350,7 @@ bool mastercore::isCrowdsalePurchase(const uint256& txid, const std::string& add
     return false;
 }
 
-void mastercore::eraseMaxedCrowdsale(const std::string& address, int64_t blockTime, int block, uint256& blockHash)
+void mastercore::eraseMaxedCrowdsale(const std::string& address, int64_t blockTime, int block, const uint256& blockHash)
 {
     CrowdMap::iterator it = my_crowds.find(address);
 
@@ -385,7 +376,7 @@ void mastercore::eraseMaxedCrowdsale(const std::string& address, int64_t blockTi
         sp.timeclosed = blockTime;
         sp.update_block = blockHash;
 
-        assert(pDbSpInfo->updateSP(crowdsale.getPropertyId(), sp));
+        assert(pDbSpInfo->updateSP(crowdsale.getPropertyId(), sp, block));
 
         // no calculate fractional calls here, no more tokens (at MAX)
         my_crowds.erase(it);
@@ -427,7 +418,7 @@ unsigned int mastercore::eraseExpiredCrowdsale(const CBlockIndex* pBlockIndex)
 
             // update SP with this data
             sp.update_block = pBlockIndex->GetBlockHash();
-            assert(pDbSpInfo->updateSP(crowdsale.getPropertyId(), sp));
+            assert(pDbSpInfo->updateSP(crowdsale.getPropertyId(), sp, blockHeight));
 
             // update values
             if (missedTokens > 0) {
diff --git a/src/omnicore/sp.h b/src/omnicore/sp.h
index 5e5be2bf564a5..24d02e510276b 100644
--- a/src/omnicore/sp.h
+++ b/src/omnicore/sp.h
@@ -39,7 +39,7 @@ class CMPCrowd
 
     // Schema:
     //   txid -> amount invested, crowdsale deadline, user issued tokens, issuer issued tokens
-    std::map<uint256, std::vector<int64_t> > txFundraiserData;
+    std::map<uint256, std::vector<int64_t>> txFundraiserData;
 
 public:
     CMPCrowd();
@@ -57,7 +57,7 @@ class CMPCrowd
     int64_t getIssuerCreated() const { return i_created; }
 
     void insertDatabase(const uint256& txHash, const std::vector<int64_t>& txData);
-    std::map<uint256, std::vector<int64_t> > getDatabase() const { return txFundraiserData; }
+    const auto& getDatabase() const { return txFundraiserData; }
 
     std::string toString(const std::string& address) const;
     void print(const std::string& address, FILE* fp = stdout) const;
@@ -96,7 +96,7 @@ void calculateFundraiser(bool inflateAmount, int64_t amtTransfer, uint8_t bonusP
         int64_t fundraiserSecs, int64_t currentSecs, int64_t numProps, uint8_t issuerPerc, int64_t totalTokens,
         std::pair<int64_t, int64_t>& tokens, bool& close_crowdsale);
 
-void eraseMaxedCrowdsale(const std::string& address, int64_t blockTime, int block, uint256& blockHash);
+void eraseMaxedCrowdsale(const std::string& address, int64_t blockTime, int block, const uint256& blockHash);
 
 unsigned int eraseExpiredCrowdsale(const CBlockIndex* pBlockIndex);
 }
diff --git a/src/omnicore/test/create_tx_tests.cpp b/src/omnicore/test/create_tx_tests.cpp
index 1eec470524def..864a25278727b 100644
--- a/src/omnicore/test/create_tx_tests.cpp
+++ b/src/omnicore/test/create_tx_tests.cpp
@@ -1,4 +1,5 @@
 #include <omnicore/createtx.h>
+#include <omnicore/omnicore.h>
 
 #include <base58.h>
 #include <coins.h>
@@ -19,7 +20,6 @@
 #include <vector>
 
 // Is reset after the last test
-extern CFeeRate minRelayTxFee;
 static CFeeRate minRelayTxFeeOriginal = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE);
 
 BOOST_FIXTURE_TEST_SUITE(omnicore_create_tx_tests, BasicTestingSetup)
@@ -137,12 +137,11 @@ BOOST_AUTO_TEST_CASE(txbuilder_add_change)
         0,
         78825000LL,
         CScript(scriptB.begin(), scriptB.end())));
-    
+
     CTxDestination addrA = DecodeDestination("174TgzbFFWiKg1VWt8Z55EVP7rJ54jQSar");
     CTxDestination addrB = DecodeDestination("12gxzZL9g6tWsX6ut8srcgcUTQ4c9wWuGS");
 
-    CCoinsView viewDummy;
-    CCoinsViewCache viewTemp(&viewDummy);
+    CCoinsViewCacheOnly viewTemp;
     InputsToView(prevTxs, viewTemp);
 
     CMutableTransaction tx = TxBuilder()
@@ -183,8 +182,7 @@ BOOST_AUTO_TEST_CASE(txbuilder_add_change_position)
     CMutableTransaction txBasis;
     BOOST_CHECK(DecodeHexTx(txBasis, rawTxBasis));
 
-    CCoinsView viewDummy;
-    CCoinsViewCache viewTemp(&viewDummy);
+    CCoinsViewCacheOnly viewTemp;
     InputsToView(prevTxs, viewTemp);
     BOOST_CHECK(viewTemp.HaveInputs(CTransaction(txBasis)));
 
@@ -243,8 +241,7 @@ BOOST_AUTO_TEST_CASE(omnitxbuilder_op_return)
         99989454LL,
         CScript(scriptB.begin(), scriptB.end())));
 
-    CCoinsView viewDummy;
-    CCoinsViewCache viewTemp(&viewDummy);
+    CCoinsViewCacheOnly viewTemp;
     InputsToView(prevTxs, viewTemp);
 
     CMutableTransaction tx = OmniTxBuilder()
diff --git a/src/omnicore/test/funded_send_tests.cpp b/src/omnicore/test/funded_send_tests.cpp
index 3b430a1aceb9f..b9552eadc8157 100644
--- a/src/omnicore/test/funded_send_tests.cpp
+++ b/src/omnicore/test/funded_send_tests.cpp
@@ -1,3 +1,4 @@
+
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
@@ -5,6 +6,7 @@
 #include <omnicore/createpayload.h>
 #include <omnicore/omnicore.h>
 #include <omnicore/script.h>
+#include <omnicore/utilsbitcoin.h>
 #include <omnicore/wallettxbuilder.h>
 
 #include <consensus/validation.h>
@@ -12,6 +14,7 @@
 #include <interfaces/wallet.h>
 #include <key_io.h>
 #include <script/standard.h>
+#include <thread>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/spend.h>
@@ -19,17 +22,28 @@
 
 #include <vector>
 
+using namespace mastercore;
+
 class FundedSendTestingSetup : public TestChain100Setup
 {
 public:
+    void ProccessAndSyncBlocks(const std::vector<CMutableTransaction>& txns)
+    {
+        auto height = GetActiveChain().Height();
+        CreateAndProcessBlock(txns, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+        for (int i = 0; i < 100 && GetActiveChain().Height() != height + 1; i++) {
+            std::this_thread::sleep_for(1ms);
+        }
+    }
     FundedSendTestingSetup()
     {
-        CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
         m_wallet_loader = interfaces::MakeWalletLoader(*m_node.chain, *Assert(m_node.args));
         wallet = std::make_shared<wallet::CWallet>(m_node.chain.get(), "", m_args, wallet::CreateMockWalletDatabase());
+        interface_wallet = interfaces::MakeWallet(*m_wallet_loader->context(), wallet);
+        ProccessAndSyncBlocks({});
         {
             LOCK(wallet->cs_wallet);
-            wallet->SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
+            wallet->SetLastBlockProcessed(GetActiveChain().Height(), GetActiveChain().Tip()->GetBlockHash());
         }
         wallet->LoadWallet();
         auto spk_man = wallet->GetOrCreateLegacyScriptPubKeyMan();
@@ -39,8 +53,7 @@ class FundedSendTestingSetup : public TestChain100Setup
         }
         wallet::WalletRescanReserver reserver(*wallet);
         reserver.reserve();
-        wallet->ScanForWalletTransactions(::ChainActive().Genesis()->GetBlockHash(), 0, {}, reserver, false, false);
-        interface_wallet = interfaces::MakeWallet(*m_wallet_loader->context(), wallet);
+        wallet->ScanForWalletTransactions(GetActiveChain().Genesis()->GetBlockHash(), 0, {}, reserver, false, false);
         wallet->m_fallback_fee = CFeeRate(1000);
     }
 
@@ -62,7 +75,7 @@ class FundedSendTestingSetup : public TestChain100Setup
             LOCK(wallet->cs_wallet);
             blocktx = CMutableTransaction(*wallet->mapWallet.at(tx->GetHash()).tx);
         }
-        CreateAndProcessBlock({CMutableTransaction(blocktx)}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+        ProccessAndSyncBlocks({blocktx});
 
         std::unordered_map<uint256, wallet::CWalletTx, SaltedTxidHasher>::iterator it;
         {
@@ -70,10 +83,10 @@ class FundedSendTestingSetup : public TestChain100Setup
             it = wallet->mapWallet.find(tx->GetHash());
         }
 
-        it->second.m_state = wallet::TxStateConfirmed{::ChainActive().Tip()->GetBlockHash(), ::ChainActive().Height(), 1};
+        it->second.m_state = wallet::TxStateConfirmed{GetActiveChain().Tip()->GetBlockHash(), GetActiveChain().Height(), 1};
         {
             LOCK(wallet->cs_wallet);
-            wallet->SetLastBlockProcessed(::ChainActive().Height(), ::ChainActive().Tip()->GetBlockHash());
+            wallet->SetLastBlockProcessed(GetActiveChain().Height(), GetActiveChain().Tip()->GetBlockHash());
         }
     }
 
@@ -112,8 +125,13 @@ static std::vector<unsigned char> dummy_payload() {
 
 static void check_outputs(uint256& hash, int expected_number) {
     CTransactionRef tx;
-    uint256 hash_block;
-    BOOST_CHECK(GetTransaction(hash, tx, Params().GetConsensus(), hash_block, nullptr));
+    int blockHeight;
+    bool tx_succeed = false;
+    for (int i = 0; i < 100 && !tx_succeed; i++) {
+        std::this_thread::sleep_for(1ms);
+        tx_succeed = GetTransaction(hash, tx, blockHeight);
+    }
+    BOOST_REQUIRE(tx_succeed);
     BOOST_CHECK_EQUAL(tx->vout.size(), expected_number);
 }
 
@@ -124,7 +142,8 @@ BOOST_AUTO_TEST_CASE(create_token_funded_by_source)
     std::vector<CTxDestination> destinations = CreateDestinations({1 * COIN, 0});
 
     uint256 hash;
-    BOOST_CHECK_EQUAL(CreateFundedTransaction(EncodeDestination(destinations[0] /* source */), EncodeDestination(destinations[1] /* receiver */), EncodeDestination(destinations[1] /* receiver */), dummy_payload(), hash, interface_wallet.get(), m_node), 0);
+    wallet->SetBroadcastTransactions(true);
+    BOOST_CHECK_EQUAL(CreateFundedTransaction(EncodeDestination(destinations[0] /* source */), EncodeDestination(destinations[1] /* receiver */), EncodeDestination(destinations[1] /* receiver */), dummy_payload(), hash, interface_wallet.get()), 0);
 
     // Expect two outputs
     check_outputs(hash, 2);
@@ -135,7 +154,8 @@ BOOST_AUTO_TEST_CASE(create_token_funded_by_receiver_address)
     std::vector<CTxDestination> destinations = CreateDestinations({-1 /* Dust */, 1 * COIN});
 
     uint256 hash;
-    BOOST_CHECK_EQUAL(CreateFundedTransaction(EncodeDestination(destinations[0] /* source */), EncodeDestination(destinations[1] /* receiver */), EncodeDestination(destinations[1] /* receiver */), dummy_payload(), hash, interface_wallet.get(), m_node), 0);
+    wallet->SetBroadcastTransactions(true);
+    BOOST_CHECK_EQUAL(CreateFundedTransaction(EncodeDestination(destinations[0] /* source */), EncodeDestination(destinations[1] /* receiver */), EncodeDestination(destinations[1] /* receiver */), dummy_payload(), hash, interface_wallet.get()), 0);
 
     // Expect two outputs
     check_outputs(hash, 2);
@@ -146,7 +166,8 @@ BOOST_AUTO_TEST_CASE(create_token_funded_by_fee_address)
     std::vector<CTxDestination> destinations = CreateDestinations({-1 /* Dust */, 0, 1 * COIN});
 
     uint256 hash;
-    BOOST_CHECK_EQUAL(CreateFundedTransaction(EncodeDestination(destinations[0] /* source */), EncodeDestination(destinations[1] /* receiver */), EncodeDestination(destinations[2] /* fee */), dummy_payload(), hash, interface_wallet.get(), m_node), 0);
+    wallet->SetBroadcastTransactions(true);
+    BOOST_CHECK_EQUAL(CreateFundedTransaction(EncodeDestination(destinations[0] /* source */), EncodeDestination(destinations[1] /* receiver */), EncodeDestination(destinations[2] /* fee */), dummy_payload(), hash, interface_wallet.get()), 0);
 
     // Expect three outputs
     check_outputs(hash, 3);
diff --git a/src/omnicore/test/iterator_tests.cpp b/src/omnicore/test/iterator_tests.cpp
new file mode 100644
index 0000000000000..a5263881c6dbe
--- /dev/null
+++ b/src/omnicore/test/iterator_tests.cpp
@@ -0,0 +1,158 @@
+
+#include <cstdint>
+#include <omnicore/dbbase.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+struct CTestDB : public CDBBase {
+    CTestDB(const fs::path& path) {
+        BOOST_REQUIRE(Open(path, true).ok());
+    }
+    using CDBBase::Write;
+    template<typename T>
+    CDBaseIterator CreateIterator(const T& key) {
+        return CDBaseIterator{NewIterator(), key};
+    }
+};
+
+struct CTestAscKey {
+    uint32_t idx = 0; // asc
+
+    SERIALIZE_METHODS(CTestAscKey, obj) {
+        READWRITE(Using<BigEndian32>(obj.idx));
+    }
+};
+
+struct CTestAscOrder : CTestAscKey {
+    static constexpr uint8_t prefix = 'A';
+    uint32_t i2 = ~0u; // desc
+
+    SERIALIZE_METHODS(CTestAscOrder, obj) {
+        READWRITEAS(CTestAscKey, obj);
+        READWRITE(Using<BigEndian32Inv>(obj.i2));
+    }
+};
+
+struct CTestDescKey {
+    uint32_t idx = ~0u; // desc
+
+    SERIALIZE_METHODS(CTestDescKey, obj) {
+        READWRITE(Using<BigEndian32Inv>(obj.idx));
+    }
+};
+
+struct CTestDescOrder : CTestDescKey {
+    static constexpr uint8_t prefix = 'A';
+    uint32_t i2 = 0; // asc
+
+    SERIALIZE_METHODS(CTestDescOrder, obj) {
+        READWRITEAS(CTestDescKey, obj);
+        READWRITE(Using<BigEndian32>(obj.i2));
+    }
+};
+
+BOOST_FIXTURE_TEST_SUITE(omnicore_iterator_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(iterator_asc_order)
+{
+    auto testdb = std::make_shared<CTestDB>(gArgs.GetDataDirNet() / "OMNI_testdb");
+    testdb->Write(CTestAscOrder{10, 2}, "");
+    testdb->Write(CTestAscOrder{6, 3}, "");
+    testdb->Write(CTestAscOrder{6, 8}, "");
+    testdb->Write(CTestAscOrder{5, 4}, "");
+    testdb->Write(CTestAscOrder{1, 2}, "");
+    testdb->Write(CTestAscOrder{4, 3}, "");
+
+    int i;
+    CTestAscOrder ordered[] = {{1, 2}, {4, 3}, {5, 4}, {6, 8}, {6, 3}, {10, 2}};
+    auto it = testdb->CreateIterator(CTestAscOrder{});
+    for (i = 0; it; ++it, ++i) {
+        auto key = it.Key<CTestAscOrder>();
+        BOOST_CHECK_EQUAL(key.idx, ordered[i].idx);
+        BOOST_CHECK_EQUAL(key.i2, ordered[i].i2);
+    }
+    BOOST_REQUIRE_EQUAL(i, 6);
+    BOOST_REQUIRE(!it.Valid());
+
+    // get iterator to element equal or greater than
+    it = testdb->CreateIterator(CTestAscOrder{3});
+    BOOST_REQUIRE(it.Valid());
+    auto key = it.Key<CTestAscOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 4);
+    BOOST_CHECK_EQUAL(key.i2, 3);
+
+    // i2 is in desc order it seek to next
+    it = testdb->CreateIterator(CTestAscOrder{6, 0});
+    BOOST_REQUIRE(it.Valid());
+    key = it.Key<CTestAscOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 10);
+    BOOST_CHECK_EQUAL(key.i2, 2);
+
+    // parial key iterate over keys start with '6'
+    it = testdb->CreateIterator(PartialKey<CTestAscOrder>(CTestAscKey{6u}));
+    BOOST_REQUIRE(it.Valid());
+    key = it.Key<CTestAscOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 6);
+    BOOST_CHECK_EQUAL(key.i2, 8);
+    ++it;
+    BOOST_REQUIRE(it.Valid());
+    key = it.Key<CTestAscOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 6);
+    BOOST_CHECK_EQUAL(key.i2, 3);
+    ++it;
+    BOOST_REQUIRE(!it.Valid());
+}
+
+BOOST_AUTO_TEST_CASE(iterator_desc_order)
+{
+    auto testdb = std::make_shared<CTestDB>(gArgs.GetDataDirNet() / "OMNI_testdb");
+    testdb->Write(CTestDescOrder{2, 5}, "");
+    testdb->Write(CTestDescOrder{2, 4}, "");
+    testdb->Write(CTestDescOrder{6, 1}, "");
+    testdb->Write(CTestDescOrder{5, 3}, "");
+    testdb->Write(CTestDescOrder{1, 2}, "");
+    testdb->Write(CTestDescOrder{4, 6}, "");
+
+    int i;
+    CTestDescOrder ordered[] = {{6, 1}, {5, 3}, {4, 6}, {2, 4}, {2, 5}, {1, 2}};
+    auto it = testdb->CreateIterator(CTestDescOrder{});
+    for (i = 0; it; ++it, ++i) {
+        auto key = it.Key<CTestDescOrder>();
+        BOOST_CHECK_EQUAL(key.idx, ordered[i].idx);
+        BOOST_CHECK_EQUAL(key.i2, ordered[i].i2);
+    }
+    BOOST_REQUIRE_EQUAL(i, 6);
+    BOOST_REQUIRE(!it.Valid());
+
+    // get iterator to element equal or lower than
+    it = testdb->CreateIterator(CTestDescOrder{3});
+    BOOST_REQUIRE(it.Valid());
+    auto key = it.Key<CTestDescOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 2);
+    BOOST_CHECK_EQUAL(key.i2, 4);
+
+    // i2 is in asc order it seek to first
+    it = testdb->CreateIterator(CTestDescOrder{2, 0});
+    BOOST_REQUIRE(it.Valid());
+    key = it.Key<CTestDescOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 2);
+    BOOST_CHECK_EQUAL(key.i2, 4);
+
+    // parial key iterate over keys start with '2'
+    it = testdb->CreateIterator(PartialKey<CTestDescOrder>(CTestDescKey{2u}));
+    BOOST_REQUIRE(it.Valid());
+    key = it.Key<CTestDescOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 2);
+    BOOST_CHECK_EQUAL(key.i2, 4);
+    ++it;
+    BOOST_REQUIRE(it.Valid());
+    key = it.Key<CTestDescOrder>();
+    BOOST_CHECK_EQUAL(key.idx, 2);
+    BOOST_CHECK_EQUAL(key.i2, 5);
+    ++it;
+    BOOST_REQUIRE(!it.Valid());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/omnicore/test/nftdb_tests.cpp b/src/omnicore/test/nftdb_tests.cpp
index c49731a5a7d64..5279d091f2dec 100644
--- a/src/omnicore/test/nftdb_tests.cpp
+++ b/src/omnicore/test/nftdb_tests.cpp
@@ -15,7 +15,6 @@ BOOST_FIXTURE_TEST_SUITE(omnicore_nftdb_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(nftdb_test_sequence)
 {
-    LOCK(cs_tally);
     std::unique_ptr<CMPNonFungibleTokensDB> UITDb{new CMPNonFungibleTokensDB(gArgs.GetDataDirNet() / "OMNI_nftdb", true)};
 
     /* Test A:
diff --git a/src/omnicore/test/parsing_a_tests.cpp b/src/omnicore/test/parsing_a_tests.cpp
index 7332a5f201049..4fe8112815c12 100644
--- a/src/omnicore/test/parsing_a_tests.cpp
+++ b/src/omnicore/test/parsing_a_tests.cpp
@@ -27,7 +27,7 @@ using namespace mastercore;
 BOOST_FIXTURE_TEST_SUITE(omnicore_parsing_a_tests, TestingSetup)
 
 /** Creates a dummy transaction with the given inputs and outputs. */
-static CTransaction TxClassA(const std::vector<CTxOut>& txInputs, const std::vector<CTxOut>& txOuts)
+static CTransaction TxClassA(CCoinsViewCache& view, const std::vector<CTxOut>& txInputs, const std::vector<CTxOut>& txOuts)
 {
     CMutableTransaction mutableTx;
 
@@ -67,6 +67,7 @@ static CTxOut createTxOut(int64_t amount, const std::string& dest)
 
 BOOST_AUTO_TEST_CASE(valid_class_a)
 {
+    CCoinsViewCacheOnly view;
     {
         int nBlock = 0;
 
@@ -80,10 +81,10 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
         txOutputs.push_back(createTxOut(6000, "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq"));
         txOutputs.push_back(createTxOut(1747000, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getFeePaid(), 50000);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq");
@@ -102,10 +103,10 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
         txOutputs.push_back(createTxOut(1747000, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
         txOutputs.push_back(createTxOut(6000, "1EXoDusjGwvnjZUyKkxZ4UHEf77z6A5S4P"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getFeePaid(), 50000);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq");
@@ -135,10 +136,10 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
         txOutputs.push_back(createTxOut(6000, "1CVE9Au1XEm3MkYxeAhUDVqWvaHrP98iUt"));
         txOutputs.push_back(createTxOut(1747000, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view,txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq");
         BOOST_CHECK_EQUAL(metaTx.getPayload(), "000000000000000100000002540be400000000");
@@ -156,10 +157,10 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
         txOutputs.push_back(createTxOut(7000, "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq"));
         txOutputs.push_back(createTxOut(7000, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getFeePaid(), 55000);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk");
@@ -182,10 +183,10 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
         txOutputs.push_back(createTxOut(6001, "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq"));
         txOutputs.push_back(createTxOut(665999, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getFeePaid(), 10000);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "1HQkdXiA2mWmoQkrknyxrHTfeBoKhthq23");
@@ -202,10 +203,10 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
         txOutputs.push_back(createTxOut(9001, "1e1jLtDvEetgwJ6jB3DuCf27sXcjA8qQ2"));
         txOutputs.push_back(createTxOut(9001, "1e1jLtDvEethgGWJCWWZPVBdZWNM3zVYP"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1e1jLtDvEetgwJ6jB3DuCf27sXcjA8qQ2");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "1e1jLtDvEethgGWJCWWZPVBdZWNM3zVYP");
         BOOST_CHECK_EQUAL(metaTx.getPayload(), "00000000000000010000000777777700000000");
@@ -222,10 +223,10 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
         txOutputs.push_back(createTxOut(6002, "34CxDzguRHnxA6fwccVBfC3wCZfvwmHAxV"));
         txOutputs.push_back(createTxOut(6003, "3J7F31dxvHXWqTse4rjzS7XayWJnr5fZqW"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "3Kpeeo8MVoYnx7PeNb5FUus8bkJsZFPbw7");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "34CxDzguRHnxA6fwccVBfC3wCZfvwmHAxV");
         BOOST_CHECK_EQUAL(metaTx.getPayload(), "000000000000000200000002540be400000000");
@@ -234,6 +235,7 @@ BOOST_AUTO_TEST_CASE(valid_class_a)
 
 BOOST_AUTO_TEST_CASE(invalid_class_a)
 {
+    CCoinsViewCacheOnly view;
     // More than one data packet
     {
         int nBlock = 0;
@@ -248,10 +250,10 @@ BOOST_AUTO_TEST_CASE(invalid_class_a)
         txOutputs.push_back(createTxOut(6000, "1CVE9Au1XEm3MkYxeAhUDVqWvaHrP98iUt"));
         txOutputs.push_back(createTxOut(1747000, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) != 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) != 0);
     }
     // Not MSC or TMSC
     {
@@ -266,10 +268,10 @@ BOOST_AUTO_TEST_CASE(invalid_class_a)
         txOutputs.push_back(createTxOut(6000, "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq"));
         txOutputs.push_back(createTxOut(1747000, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) != 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) != 0);
     }
     // Seq collision
     {
@@ -285,10 +287,10 @@ BOOST_AUTO_TEST_CASE(invalid_class_a)
         txOutputs.push_back(createTxOut(6000, "1CcJFxoEW5PUwesMVxGrq6kAPJ1TJsSVqq"));
         txOutputs.push_back(createTxOut(1747000, "1HRE7U9XNPD8kJBCwm5Q1VAepz25GBXnVk"));
 
-        CTransaction dummyTx = TxClassA(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassA(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) != 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) != 0);
     }
 }
 
diff --git a/src/omnicore/test/parsing_b_tests.cpp b/src/omnicore/test/parsing_b_tests.cpp
index 3ce9c7b62aeec..c5587c843a7e0 100644
--- a/src/omnicore/test/parsing_b_tests.cpp
+++ b/src/omnicore/test/parsing_b_tests.cpp
@@ -28,7 +28,7 @@ using namespace mastercore;
 BOOST_FIXTURE_TEST_SUITE(omnicore_parsing_b_tests, TestingSetup)
 
 /** Creates a dummy transaction with the given inputs and outputs. */
-static CTransaction TxClassB(const std::vector<CTxOut>& txInputs, const std::vector<CTxOut>& txOuts)
+static CTransaction TxClassB(CCoinsViewCache& view, const std::vector<CTxOut>& txInputs, const std::vector<CTxOut>& txOuts)
 {
     CMutableTransaction mutableTx;
 
@@ -77,7 +77,7 @@ static size_t getPayloadSize(unsigned int nPackets)
 BOOST_AUTO_TEST_CASE(valid_common_class_b)
 {
     int nBlock = 0;
-
+    CCoinsViewCacheOnly view;
     std::vector<CTxOut> txInputs;
     txInputs.push_back(createTxOut(1000000, "1BxtgEa8UcrMzVZaW32zVyJh4Sg4KGFzxA"));
     txInputs.push_back(createTxOut(1000000, "1HG3s4Ext3sTqBTHrgftyUzG3cvx5ZbPCj"));
@@ -90,10 +90,10 @@ BOOST_AUTO_TEST_CASE(valid_common_class_b)
     txOutputs.push_back(PayToBareMultisig_3of5());
     txOutputs.push_back(PayToPubKeyHash_Unrelated());
 
-    CTransaction dummyTx = TxClassB(txInputs, txOutputs);
+    CTransaction dummyTx = TxClassB(view, txInputs, txOutputs);
 
     CMPTransaction metaTx;
-    BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+    BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
     BOOST_CHECK_EQUAL(metaTx.getSender(), "1Pa6zyqnhL6LDJtrkCMi9XmEDNHJ23ffEr");
     BOOST_CHECK_EQUAL(metaTx.getPayload().size(), getPayloadSize(10));
 }
@@ -123,11 +123,12 @@ BOOST_AUTO_TEST_CASE(valid_arbitrary_output_number_class_b)
     std::mt19937 g(rd());
     std::shuffle(txOutputs.begin(), txOutputs.end(), g);
 
-    CTransaction dummyTx = TxClassB(txInputs, txOutputs);
+    CCoinsViewCacheOnly view;
+    CTransaction dummyTx = TxClassB(view, txInputs, txOutputs);
     BOOST_CHECK_EQUAL(dummyTx.vout.size(), nOutputs);
 
     CMPTransaction metaTx;
-    BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+    BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
     BOOST_CHECK_EQUAL(metaTx.getSender(), "3QHw8qKf1vQkMnSVXarq7N4PYzz1G3mAK4");
     BOOST_CHECK_EQUAL(metaTx.getPayload().size(), getPayloadSize(MAX_PACKETS));
 }
diff --git a/src/omnicore/test/parsing_c_tests.cpp b/src/omnicore/test/parsing_c_tests.cpp
index 30531d98c01b2..8646364b4eb4d 100644
--- a/src/omnicore/test/parsing_c_tests.cpp
+++ b/src/omnicore/test/parsing_c_tests.cpp
@@ -28,7 +28,7 @@ using namespace mastercore;
 BOOST_FIXTURE_TEST_SUITE(omnicore_parsing_c_tests, TestingSetup)
 
 /** Creates a dummy transaction with the given inputs and outputs. */
-static CTransaction TxClassC(const std::vector<CTxOut>& txInputs, const std::vector<CTxOut>& txOuts)
+static CTransaction TxClassC(CCoinsViewCache& view, const std::vector<CTxOut>& txInputs, const std::vector<CTxOut>& txOuts)
 {
     CMutableTransaction mutableTx;
 
@@ -67,6 +67,7 @@ static CTxOut createTxOut(int64_t amount, const std::string& dest)
 
 BOOST_AUTO_TEST_CASE(reference_identification)
 {
+    CCoinsViewCacheOnly view;
     {
         int nBlock = ConsensusParams().NULLDATA_BLOCK;
 
@@ -77,10 +78,10 @@ BOOST_AUTO_TEST_CASE(reference_identification)
         txOutputs.push_back(OpReturn_SimpleSend());
         txOutputs.push_back(createTxOut(2700000, EncodeDestination(ExodusAddress())));
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK(metaTx.getReceiver().empty());
         BOOST_CHECK_EQUAL(metaTx.getFeePaid(), 2300000);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1NNQKWM8mC35pBNPxV1noWFZEw7A5X6zXz");
@@ -96,10 +97,10 @@ BOOST_AUTO_TEST_CASE(reference_identification)
         txOutputs.push_back(OpReturn_SimpleSend());
         txOutputs.push_back(createTxOut(6000, "3QHw8qKf1vQkMnSVXarq7N4PYzz1G3mAK4"));
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getFeePaid(), 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "3NfRfUekDSzgSyohRro9jXD1AqDALN321P");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "3QHw8qKf1vQkMnSVXarq7N4PYzz1G3mAK4");
@@ -115,10 +116,10 @@ BOOST_AUTO_TEST_CASE(reference_identification)
         txOutputs.push_back(OpReturn_SimpleSend());
         txOutputs.push_back(createTxOut(6000, "1M773vkrQDtBpkorfHTdctRo6kHxb4fXuT"));
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getFeePaid(), 74000);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "1M773vkrQDtBpkorfHTdctRo6kHxb4fXuT");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "1M773vkrQDtBpkorfHTdctRo6kHxb4fXuT");
@@ -139,10 +140,10 @@ BOOST_AUTO_TEST_CASE(reference_identification)
         txOutputs.push_back(PayToBareMultisig_1of3());
         txOutputs.push_back(createTxOut(6000, "19NNUnwsKZK5dCnDCZ7pqeruL2syA8hSVh"));
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "19NNUnwsKZK5dCnDCZ7pqeruL2syA8hSVh");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "37pwWHk1oFaWxVsnYKfGs7Lyt5yJEVomTH");
     }
@@ -161,10 +162,10 @@ BOOST_AUTO_TEST_CASE(reference_identification)
         txOutputs.push_back(PayToPubKeyHash_Exodus());
         txOutputs.push_back(OpReturn_SimpleSend());
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "35iqJySouevicrYzMhjKSsqokSGwGovGov");
         BOOST_CHECK_EQUAL(metaTx.getReceiver(), "35iqJySouevicrYzMhjKSsqokSGwGovGov");
     }
@@ -172,6 +173,7 @@ BOOST_AUTO_TEST_CASE(reference_identification)
 
 BOOST_AUTO_TEST_CASE(empty_op_return)
 {
+    CCoinsViewCacheOnly view;
     {
         int nBlock = std::numeric_limits<int>::max();
 
@@ -182,10 +184,10 @@ BOOST_AUTO_TEST_CASE(empty_op_return)
         txOutputs.push_back(OpReturn_PlainMarker());
         txOutputs.push_back(PayToPubKeyHash_Unrelated());
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK(metaTx.getPayload().empty());
         BOOST_CHECK_EQUAL(metaTx.getSender(), "35iqJySouevicrYzMhjKSsqokSGwGovGov");
         // via PayToPubKeyHash_Unrelated:
@@ -219,10 +221,11 @@ BOOST_AUTO_TEST_CASE(trimmed_op_return)
         CTxOut txOut = CTxOut(0, scriptPubKey);
         txOutputs.push_back(txOut);
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CCoinsViewCacheOnly view;
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "3LzuqJs1deHYeFyJz5JXqrZXpuMk3GBEX2");
         BOOST_CHECK_EQUAL(metaTx.getPayload(), HexStr(vchFiller.begin(), vchFiller.end()));
         BOOST_CHECK_EQUAL(metaTx.getPayload().size() / 2, MAX_PACKETS * PACKET_SIZE);
@@ -262,10 +265,11 @@ BOOST_AUTO_TEST_CASE(multiple_op_return_short)
             CTxOut txOut = CTxOut(0, scriptPubKey);
             txOutputs.push_back(txOut);
         }
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CCoinsViewCacheOnly view;
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "13ZXjcDDUY3cRTPFXVfwmFR9Mz2WpnF5PP");
         BOOST_CHECK_EQUAL(metaTx.getPayload(), "00001111222233330001000200030004");
     }
@@ -314,10 +318,11 @@ BOOST_AUTO_TEST_CASE(multiple_op_return)
             txOutputs.push_back(txOut);
         }
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CCoinsViewCacheOnly view;
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "3LzuqJs1deHYeFyJz5JXqrZXpuMk3GBEX2");
         BOOST_CHECK_EQUAL(metaTx.getPayload(), "12222222222222222222222222234555555"
                 "555555555555555555556788888888889ffff11111111111111111111111111111"
@@ -329,6 +334,7 @@ BOOST_AUTO_TEST_CASE(multiple_op_return)
 
 BOOST_AUTO_TEST_CASE(multiple_op_return_pushes)
 {
+    CCoinsViewCacheOnly view;
     {
         int nBlock = std::numeric_limits<int>::max();
 
@@ -341,10 +347,10 @@ BOOST_AUTO_TEST_CASE(multiple_op_return_pushes)
         txOutputs.push_back(PayToScriptHash_Unrelated());
         txOutputs.push_back(OpReturn_MultiSimpleSend());
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "3LzuqJs1deHYeFyJz5JXqrZXpuMk3GBEX2");
         BOOST_CHECK_EQUAL(metaTx.getPayload(),
                 // OpReturn_SimpleSend (without marker):
@@ -371,10 +377,10 @@ BOOST_AUTO_TEST_CASE(multiple_op_return_pushes)
             txOutputs.push_back(txOut);
         }
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getSender(), "3LzuqJs1deHYeFyJz5JXqrZXpuMk3GBEX2");
         BOOST_CHECK_EQUAL(metaTx.getPayload(),
                 "00000000000000010000000006dac2c000000000000000030000000000000d48");
@@ -395,10 +401,10 @@ BOOST_AUTO_TEST_CASE(multiple_op_return_pushes)
           txOutputs.push_back(txOut);
         }
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0);
         BOOST_CHECK_EQUAL(metaTx.getPayload(), "00000000000000010000000006dac2c0");
     }
     {
@@ -422,10 +428,10 @@ BOOST_AUTO_TEST_CASE(multiple_op_return_pushes)
             txOutputs.push_back(txOut);
         }
 
-        CTransaction dummyTx = TxClassC(txInputs, txOutputs);
+        CTransaction dummyTx = TxClassC(view, txInputs, txOutputs);
 
         CMPTransaction metaTx;
-        BOOST_CHECK(ParseTransaction(dummyTx, nBlock, 1, metaTx) != 0);
+        BOOST_CHECK(ParseTransaction(view, dummyTx, nBlock, 1, metaTx) != 0);
     }
 }
 
diff --git a/src/omnicore/test/sender_bycontribution_tests.cpp b/src/omnicore/test/sender_bycontribution_tests.cpp
index b54ac910833d6..0d0b1d16425d4 100644
--- a/src/omnicore/test/sender_bycontribution_tests.cpp
+++ b/src/omnicore/test/sender_bycontribution_tests.cpp
@@ -350,7 +350,7 @@ BOOST_AUTO_TEST_CASE(sender_selection_mixed_test)
 }
 
 /** Creates a dummy class B transaction with the given inputs. */
-static CTransaction TxClassB(const std::vector<CTxOut>& txInputs)
+static CTransaction TxClassB(CCoinsViewCache& view, const std::vector<CTxOut>& txInputs)
 {
     CMutableTransaction mutableTx;
 
@@ -386,10 +386,12 @@ static bool GetSenderByContribution(const std::vector<CTxOut>& vouts, std::strin
 {
     int nBlock = std::numeric_limits<int>::max();
 
+
     CMPTransaction metaTx;
-    CTransaction dummyTx = TxClassB(vouts);
+    CCoinsViewCacheOnly view;
+    CTransaction dummyTx = TxClassB(view, vouts);
 
-    if (ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0) {
+    if (ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0) {
         strSender = metaTx.getSender();
         return true;
     }
diff --git a/src/omnicore/test/sender_firstin_tests.cpp b/src/omnicore/test/sender_firstin_tests.cpp
index 63d0bd1535a65..0e21762070aee 100644
--- a/src/omnicore/test/sender_firstin_tests.cpp
+++ b/src/omnicore/test/sender_firstin_tests.cpp
@@ -26,7 +26,7 @@ using namespace mastercore;
 BOOST_FIXTURE_TEST_SUITE(omnicore_sender_firstin_tests, TestingSetup)
 
 /** Creates a dummy class C transaction with the given inputs. */
-static CTransaction TxClassC(const std::vector<CTxOut>& txInputs)
+static CTransaction TxClassC(CCoinsViewCache& view, const std::vector<CTxOut>& txInputs)
 {
     CMutableTransaction mutableTx;
 
@@ -75,9 +75,10 @@ static bool GetFirstSender(const std::vector<CTxOut>& txInputs, std::string& str
     int nBlock = std::numeric_limits<int>::max();
 
     CMPTransaction metaTx;
-    CTransaction dummyTx = TxClassC(txInputs);
+    CCoinsViewCacheOnly view;
+    CTransaction dummyTx = TxClassC(view, txInputs);
 
-    if (ParseTransaction(dummyTx, nBlock, 1, metaTx) == 0) {
+    if (ParseTransaction(view, dummyTx, nBlock, 1, metaTx) == 0) {
         strSender = metaTx.getSender();
         return true;
     }
diff --git a/src/omnicore/tx.cpp b/src/omnicore/tx.cpp
index aa05c04c76643..77067a1f04bc4 100644
--- a/src/omnicore/tx.cpp
+++ b/src/omnicore/tx.cpp
@@ -28,17 +28,11 @@
 #include <sync.h>
 #include <util/time.h>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-
-#include <stdio.h>
-#include <string.h>
-
 #include <algorithm>
 #include <limits>
+#include <tuple>
 #include <utility>
 #include <vector>
-#include <tuple>
 
 using namespace mastercore;
 
@@ -1130,25 +1124,18 @@ int CMPTransaction::interpretPacket()
         return (PKT_ERROR -2);
     }
 
-    // Use ::ChainActive()[block] here to avoid locking cs_main after cs_tally below
-    CBlockIndex* pindex;
-    uint256 blockHash;
-    {
-        LOCK(cs_main);
-        pindex = ::ChainActive()[block];
-        blockHash = ::ChainActive()[block]->GetBlockHash();
-    }
-
     LOCK(cs_tally);
-
     if (isAddressFrozen(sender, property)) {
         PrintToLog("%s(): REJECTED: address %s is frozen for property %d\n", __func__, sender, property);
         return (PKT_ERROR -3);
     }
 
+    // pindex is not initialized
+    pindex = GetActiveChain()[block];
+
     switch (type) {
         case MSC_TYPE_SIMPLE_SEND:
-            return logicMath_SimpleSend(blockHash);
+            return logicMath_SimpleSend();
 
         case MSC_TYPE_SEND_TO_OWNERS:
             return logicMath_SendToOwners();
@@ -1181,43 +1168,43 @@ int CMPTransaction::interpretPacket()
             return logicMath_MetaDExCancelEcosystem();
 
         case MSC_TYPE_CREATE_PROPERTY_FIXED:
-            return logicMath_CreatePropertyFixed(pindex);
+            return logicMath_CreatePropertyFixed();
 
         case MSC_TYPE_CREATE_PROPERTY_VARIABLE:
-            return logicMath_CreatePropertyVariable(pindex);
+            return logicMath_CreatePropertyVariable();
 
         case MSC_TYPE_CLOSE_CROWDSALE:
-            return logicMath_CloseCrowdsale(pindex);
+            return logicMath_CloseCrowdsale();
 
         case MSC_TYPE_CREATE_PROPERTY_MANUAL:
-            return logicMath_CreatePropertyManaged(pindex);
+            return logicMath_CreatePropertyManaged();
 
         case MSC_TYPE_GRANT_PROPERTY_TOKENS:
-            return logicMath_GrantTokens(pindex, blockHash);
+            return logicMath_GrantTokens();
 
         case MSC_TYPE_REVOKE_PROPERTY_TOKENS:
-            return logicMath_RevokeTokens(pindex);
+            return logicMath_RevokeTokens();
 
         case MSC_TYPE_CHANGE_ISSUER_ADDRESS:
-            return logicMath_ChangeIssuer(pindex);
+            return logicMath_ChangeIssuer();
 
         case MSC_TYPE_ENABLE_FREEZING:
-            return logicMath_EnableFreezing(pindex);
+            return logicMath_EnableFreezing();
 
         case MSC_TYPE_DISABLE_FREEZING:
-            return logicMath_DisableFreezing(pindex);
+            return logicMath_DisableFreezing();
 
         case MSC_TYPE_FREEZE_PROPERTY_TOKENS:
-            return logicMath_FreezeTokens(pindex);
+            return logicMath_FreezeTokens();
 
         case MSC_TYPE_UNFREEZE_PROPERTY_TOKENS:
-            return logicMath_UnfreezeTokens(pindex);
+            return logicMath_UnfreezeTokens();
 
         case MSC_TYPE_ADD_DELEGATE:
-            return logicMath_AddDelegate(pindex);
+            return logicMath_AddDelegate();
 
         case MSC_TYPE_REMOVE_DELEGATE:
-            return logicMath_RemoveDelegate(pindex);
+            return logicMath_RemoveDelegate();
 
         case MSC_TYPE_ANYDATA:
             return logicMath_AnyData();
@@ -1239,7 +1226,7 @@ int CMPTransaction::interpretPacket()
 }
 
 /** Passive effect of crowdsale participation. */
-int CMPTransaction::logicHelper_CrowdsaleParticipation(uint256& blockHash)
+int CMPTransaction::logicHelper_CrowdsaleParticipation()
 {
     CMPCrowd* pcrowdsale = getCrowd(receiver);
 
@@ -1306,7 +1293,7 @@ int CMPTransaction::logicHelper_CrowdsaleParticipation(uint256& blockHash)
 
     // Close crowdsale, if we hit MAX_TOKENS
     if (close_crowdsale) {
-        eraseMaxedCrowdsale(receiver, blockTime, block, blockHash);
+        eraseMaxedCrowdsale(receiver, blockTime, block, pindex->GetBlockHash());
     }
 
     // Indicate, if no tokens were transferred
@@ -1318,7 +1305,7 @@ int CMPTransaction::logicHelper_CrowdsaleParticipation(uint256& blockHash)
 }
 
 /** Tx 0 */
-int CMPTransaction::logicMath_SimpleSend(uint256& blockHash)
+int CMPTransaction::logicMath_SimpleSend()
 {
     if (!IsTransactionTypeAllowed(block, property, type, version)) {
         PrintToLog("%s(): rejected: type %d or version %d not permitted for property %d at block %d\n",
@@ -1363,7 +1350,7 @@ int CMPTransaction::logicMath_SimpleSend(uint256& blockHash)
     assert(update_tally_map(receiver, property, nValue, BALANCE));
 
     // Is there an active crowdsale running from this recipient?
-    logicHelper_CrowdsaleParticipation(blockHash);
+    logicHelper_CrowdsaleParticipation();
 
     return 0;
 }
@@ -1559,7 +1546,7 @@ int CMPTransaction::logicMath_SendAll()
             ++numberOfPropertiesSent;
             assert(update_tally_map(sender, propertyId, -moneyAvailable, BALANCE));
             assert(update_tally_map(receiver, propertyId, moneyAvailable, BALANCE));
-            pDbTransactionList->recordSendAllSubRecord(txid, numberOfPropertiesSent, propertyId, moneyAvailable);
+            pDbTransactionList->recordSendAllSubRecord(txid, block, numberOfPropertiesSent, propertyId, moneyAvailable);
         }
     }
 
@@ -2092,7 +2079,7 @@ int CMPTransaction::logicMath_MetaDExCancelEcosystem()
 }
 
 /** Tx 50 */
-int CMPTransaction::logicMath_CreatePropertyFixed(CBlockIndex* pindex)
+int CMPTransaction::logicMath_CreatePropertyFixed()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2147,7 +2134,7 @@ int CMPTransaction::logicMath_CreatePropertyFixed(CBlockIndex* pindex)
     newSP.creation_block = blockHash;
     newSP.update_block = newSP.creation_block;
 
-    const uint32_t propertyId = pDbSpInfo->putSP(ecosystem, newSP);
+    const uint32_t propertyId = pDbSpInfo->putSP(ecosystem, newSP, block);
     assert(propertyId > 0);
     assert(update_tally_map(sender, propertyId, nValue, BALANCE));
 
@@ -2157,7 +2144,7 @@ int CMPTransaction::logicMath_CreatePropertyFixed(CBlockIndex* pindex)
 }
 
 /** Tx 51 */
-int CMPTransaction::logicMath_CreatePropertyVariable(CBlockIndex* pindex)
+int CMPTransaction::logicMath_CreatePropertyVariable()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2244,7 +2231,7 @@ int CMPTransaction::logicMath_CreatePropertyVariable(CBlockIndex* pindex)
     newSP.creation_block = blockHash;
     newSP.update_block = newSP.creation_block;
 
-    const uint32_t propertyId = pDbSpInfo->putSP(ecosystem, newSP);
+    const uint32_t propertyId = pDbSpInfo->putSP(ecosystem, newSP, block);
     assert(propertyId > 0);
     my_crowds.insert(std::make_pair(sender, CMPCrowd(propertyId, nValue, property, deadline, early_bird, percentage, 0, 0)));
 
@@ -2254,7 +2241,7 @@ int CMPTransaction::logicMath_CreatePropertyVariable(CBlockIndex* pindex)
 }
 
 /** Tx 53 */
-int CMPTransaction::logicMath_CloseCrowdsale(CBlockIndex* pindex)
+int CMPTransaction::logicMath_CloseCrowdsale()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2308,7 +2295,7 @@ int CMPTransaction::logicMath_CloseCrowdsale(CBlockIndex* pindex)
     sp.txid_close = txid;
     sp.missedTokens = missedTokens;
 
-    assert(pDbSpInfo->updateSP(property, sp));
+    assert(pDbSpInfo->updateSP(property, sp, block));
     if (missedTokens > 0) {
         assert(update_tally_map(sp.issuer, property, missedTokens, BALANCE));
     }
@@ -2320,7 +2307,7 @@ int CMPTransaction::logicMath_CloseCrowdsale(CBlockIndex* pindex)
 }
 
 /** Tx 54 */
-int CMPTransaction::logicMath_CreatePropertyManaged(CBlockIndex* pindex)
+int CMPTransaction::logicMath_CreatePropertyManaged()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2380,7 +2367,7 @@ int CMPTransaction::logicMath_CreatePropertyManaged(CBlockIndex* pindex)
     newSP.creation_block = blockHash;
     newSP.update_block = newSP.creation_block;
 
-    uint32_t propertyId = pDbSpInfo->putSP(ecosystem, newSP);
+    uint32_t propertyId = pDbSpInfo->putSP(ecosystem, newSP, block);
     assert(propertyId > 0);
 
     if (prop_type != MSC_PROPERTY_TYPE_NONFUNGIBLE) {
@@ -2393,13 +2380,13 @@ int CMPTransaction::logicMath_CreatePropertyManaged(CBlockIndex* pindex)
 }
 
 /** Tx 55 */
-int CMPTransaction::logicMath_GrantTokens(CBlockIndex* pindex, uint256& blockHash)
+int CMPTransaction::logicMath_GrantTokens()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
         return (PKT_ERROR_SP -20);
     }
-    uint256 pindexBlockHash = pindex->GetBlockHash();
+    uint256 blockHash = pindex->GetBlockHash();
 
     if (!IsTransactionTypeAllowed(block, property, type, version)) {
         PrintToLog("%s(): rejected: type %d or version %d not permitted for property %d at block %d\n",
@@ -2464,10 +2451,10 @@ int CMPTransaction::logicMath_GrantTokens(CBlockIndex* pindex, uint256& blockHas
     dataPt.push_back(nValue);
     dataPt.push_back(0);
     sp.historicalData.insert(std::make_pair(txid, dataPt));
-    sp.update_block = pindexBlockHash;
+    sp.update_block = blockHash;
 
     // Persist the number of granted tokens
-    assert(pDbSpInfo->updateSP(property, sp));
+    assert(pDbSpInfo->updateSP(property, sp, block));
 
     // Move the tokens
     if (sp.unique) {
@@ -2486,7 +2473,7 @@ int CMPTransaction::logicMath_GrantTokens(CBlockIndex* pindex, uint256& blockHas
      */
     if (!IsFeatureActivated(FEATURE_GRANTEFFECTS, block)) {
         // Is there an active crowdsale running from this recipient?
-        logicHelper_CrowdsaleParticipation(blockHash);
+        logicHelper_CrowdsaleParticipation();
     }
 
     NotifyTotalTokensChanged(property, block);
@@ -2495,7 +2482,7 @@ int CMPTransaction::logicMath_GrantTokens(CBlockIndex* pindex, uint256& blockHas
 }
 
 /** Tx 56 */
-int CMPTransaction::logicMath_RevokeTokens(CBlockIndex* pindex)
+int CMPTransaction::logicMath_RevokeTokens()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2556,7 +2543,7 @@ int CMPTransaction::logicMath_RevokeTokens(CBlockIndex* pindex)
     sp.update_block = blockHash;
 
     assert(update_tally_map(sender, property, -nValue, BALANCE));
-    assert(pDbSpInfo->updateSP(property, sp));
+    assert(pDbSpInfo->updateSP(property, sp, block));
 
     NotifyTotalTokensChanged(property, block);
 
@@ -2564,7 +2551,7 @@ int CMPTransaction::logicMath_RevokeTokens(CBlockIndex* pindex)
 }
 
 /** Tx 70 */
-int CMPTransaction::logicMath_ChangeIssuer(CBlockIndex* pindex)
+int CMPTransaction::logicMath_ChangeIssuer()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2622,13 +2609,13 @@ int CMPTransaction::logicMath_ChangeIssuer(CBlockIndex* pindex)
     sp.issuer = receiver;
     sp.update_block = blockHash;
 
-    assert(pDbSpInfo->updateSP(property, sp));
+    assert(pDbSpInfo->updateSP(property, sp, block));
 
     return 0;
 }
 
 /** Tx 71 */
-int CMPTransaction::logicMath_EnableFreezing(CBlockIndex* pindex)
+int CMPTransaction::logicMath_EnableFreezing()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2682,7 +2669,7 @@ int CMPTransaction::logicMath_EnableFreezing(CBlockIndex* pindex)
 }
 
 /** Tx 72 */
-int CMPTransaction::logicMath_DisableFreezing(CBlockIndex* pindex)
+int CMPTransaction::logicMath_DisableFreezing()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2728,7 +2715,7 @@ int CMPTransaction::logicMath_DisableFreezing(CBlockIndex* pindex)
 }
 
 /** Tx 185 */
-int CMPTransaction::logicMath_FreezeTokens(CBlockIndex* pindex)
+int CMPTransaction::logicMath_FreezeTokens()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2792,7 +2779,7 @@ int CMPTransaction::logicMath_FreezeTokens(CBlockIndex* pindex)
 }
 
 /** Tx 186 */
-int CMPTransaction::logicMath_UnfreezeTokens(CBlockIndex* pindex)
+int CMPTransaction::logicMath_UnfreezeTokens()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2856,7 +2843,7 @@ int CMPTransaction::logicMath_UnfreezeTokens(CBlockIndex* pindex)
 }
 
 /** Tx 73 */
-int CMPTransaction::logicMath_AddDelegate(CBlockIndex* pindex)
+int CMPTransaction::logicMath_AddDelegate()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2904,13 +2891,13 @@ int CMPTransaction::logicMath_AddDelegate(CBlockIndex* pindex)
     sp.delegate = receiver;
     sp.update_block = blockHash;
 
-    assert(pDbSpInfo->updateSP(property, sp));
+    assert(pDbSpInfo->updateSP(property, sp, block));
 
     return 0;
 }
 
 /** Tx 74 */
-int CMPTransaction::logicMath_RemoveDelegate(CBlockIndex* pindex)
+int CMPTransaction::logicMath_RemoveDelegate()
 {
     if (pindex == nullptr) {
         PrintToLog("%s(): ERROR: block %d not in the active chain\n", __func__, block);
@@ -2961,10 +2948,10 @@ int CMPTransaction::logicMath_RemoveDelegate(CBlockIndex* pindex)
 
     sp.removeDelegate(block, tx_idx);
 
-    sp.delegate = "";
+    sp.delegate.clear();
     sp.update_block = blockHash;
 
-    assert(pDbSpInfo->updateSP(property, sp));
+    assert(pDbSpInfo->updateSP(property, sp, block));
 
     return 0;
 }
@@ -3173,12 +3160,7 @@ int CMPTransaction::logicMath_Alert()
             std::string msgText = "Client upgrade is required!  Shutting down due to unsupported consensus state!";
             PrintToLog(msgText);
             PrintToConsole(msgText);
-            if (!gArgs.GetBoolArg("-overrideforcedshutdown", false)) {
-                fs::path persistPath = gArgs.GetDataDirNet() / "MP_persist";
-                if (fs::exists(persistPath)) fs::remove_all(persistPath); // prevent the node being restarted without a reparse after forced shutdown
-                BlockValidationState state;
-                AbortNode(state, msgText);
-            }
+            MayAbortNode(msgText);
         }
     }
 
diff --git a/src/omnicore/tx.h b/src/omnicore/tx.h
index 880543dbb7794..61b9b78a9e736 100644
--- a/src/omnicore/tx.h
+++ b/src/omnicore/tx.h
@@ -33,6 +33,7 @@ class CMPTransaction
 private:
     uint256 txid;
     int block;
+    const CBlockIndex* pindex;
     int64_t blockTime;  // internally nTime is still an "unsigned int"
     unsigned int tx_idx;  // tx # within the block, 0-based
     uint64_t tx_fee_paid;
@@ -152,7 +153,7 @@ class CMPTransaction
     /**
      * Logic and "effects"
      */
-    int logicMath_SimpleSend(uint256& blockHash);
+    int logicMath_SimpleSend();
     int logicMath_SendToOwners();
     int logicMath_SendAll();
     int logicMath_SendNonFungible();
@@ -163,19 +164,19 @@ class CMPTransaction
     int logicMath_MetaDExCancelPrice();
     int logicMath_MetaDExCancelPair();
     int logicMath_MetaDExCancelEcosystem();
-    int logicMath_CreatePropertyFixed(CBlockIndex *pindex);
-    int logicMath_CreatePropertyVariable(CBlockIndex *pindex);
-    int logicMath_CloseCrowdsale(CBlockIndex *pindex);
-    int logicMath_CreatePropertyManaged(CBlockIndex* pindex);
-    int logicMath_GrantTokens(CBlockIndex* pindex, uint256 &blockHash);
-    int logicMath_RevokeTokens(CBlockIndex *pindex);
-    int logicMath_ChangeIssuer(CBlockIndex *pindex);
-    int logicMath_EnableFreezing(CBlockIndex *pindex);
-    int logicMath_DisableFreezing(CBlockIndex *pindex);
-    int logicMath_FreezeTokens(CBlockIndex *pindex);
-    int logicMath_UnfreezeTokens(CBlockIndex *pindex);
-    int logicMath_AddDelegate(CBlockIndex *pindex);
-    int logicMath_RemoveDelegate(CBlockIndex *pindex);
+    int logicMath_CreatePropertyFixed();
+    int logicMath_CreatePropertyVariable();
+    int logicMath_CloseCrowdsale();
+    int logicMath_CreatePropertyManaged();
+    int logicMath_GrantTokens();
+    int logicMath_RevokeTokens();
+    int logicMath_ChangeIssuer();
+    int logicMath_EnableFreezing();
+    int logicMath_DisableFreezing();
+    int logicMath_FreezeTokens();
+    int logicMath_UnfreezeTokens();
+    int logicMath_AddDelegate();
+    int logicMath_RemoveDelegate();
     int logicMath_AnyData();
     int logicMath_NonFungibleData();
     int logicMath_Activation();
@@ -185,7 +186,7 @@ class CMPTransaction
     /**
      * Logic helpers
      */
-    int logicHelper_CrowdsaleParticipation(uint256& blockHash);
+    int logicHelper_CrowdsaleParticipation();
 
 public:
     //! DEx and MetaDEx action values
@@ -268,6 +269,7 @@ class CMPTransaction
     {
         txid.SetNull();
         block = -1;
+        pindex = nullptr;
         blockTime = 0;
         tx_idx = 0;
         tx_fee_paid = 0;
diff --git a/src/omnicore/uint256_extensions.h b/src/omnicore/uint256_extensions.h
index 6ef8be82dede5..0e3afd87ebc83 100644
--- a/src/omnicore/uint256_extensions.h
+++ b/src/omnicore/uint256_extensions.h
@@ -8,8 +8,10 @@
 #define BITCOIN_OMNICORE_UINT256_EXTENSIONS_H
 
 #include <arith_uint256.h>
+#include <uint256.h>
 
 #include <assert.h>
+#include <cstdint>
 #include <stdint.h>
 #include <limits>
 
@@ -21,6 +23,15 @@ static const arith_uint256 one(static_cast<uint64_t>(1));
 static const arith_uint256 max_int64(static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
 }
 
+inline uint256 Uint256(Span<const uint8_t> src)
+{
+    uint256 dest;
+    if (dest.size() >= src.size()) {
+        std::copy(src.begin(), src.end(), dest.begin());
+    }
+    return dest;
+}
+
 /**
  * Returns a mod n.
  */
diff --git a/src/omnicore/utilsbitcoin.cpp b/src/omnicore/utilsbitcoin.cpp
index f65f9b1233a26..d0bed0bb3dd5e 100644
--- a/src/omnicore/utilsbitcoin.cpp
+++ b/src/omnicore/utilsbitcoin.cpp
@@ -5,10 +5,14 @@
  */
 
 #include <omnicore/omnicore.h>
+#include <omnicore/validationinterface.h>
+#include <omnicore/utilsbitcoin.h>
 
 #include <chain.h>
 #include <chainparams.h>
-#include <validation.h>
+#include <key_io.h>
+#include <stdexcept>
+#include <shutdown.h>
 #include <sync.h>
 
 #include <stdint.h>
@@ -16,40 +20,87 @@
 
 namespace mastercore
 {
-/**
- * @return The current chain length.
- */
+static const COmniValidationInterface& EnsureValidationInterface()
+{
+    if (omniValidationInterface) {
+        return *omniValidationInterface;
+    }
+    throw std::logic_error("COmniValidationInterface isn't initialized");
+}
+
 int GetHeight()
 {
-    LOCK(cs_main);
-    return ::ChainActive().Height();
+    return EnsureValidationInterface().LastBlockHeight();
+}
+
+const CChainIndex& GetActiveChain()
+{
+    return EnsureValidationInterface().GetActiveChain();
 }
 
-/**
- * @return The timestamp of the latest block.
- */
 uint32_t GetLatestBlockTime()
 {
-    LOCK(cs_main);
-    if (::ChainActive().Tip())
-        return ::ChainActive().Tip()->GetBlockTime();
-    else
-        return Params().GenesisBlock().nTime;
+    return EnsureValidationInterface().LastBlockTime();
 }
 
-/**
- * @return The CBlockIndex, or nullptr, if the block isn't available.
- */
-CBlockIndex* GetBlockIndex(const uint256& hash)
+bool IsInitialBlockDownload()
+{
+    return EnsureValidationInterface().IsInitialBlockDownload();
+}
+
+bool IsProcessingBlock()
+{
+    return EnsureValidationInterface().IsProcessingBlock();
+}
+
+void MayAbortNode(const std::string& message)
 {
-    CBlockIndex* pBlockIndex = nullptr;
-    LOCK(cs_main);
-    auto it = ::BlockIndex().find(hash);
-    if (it != ::BlockIndex().end()) {
-        pBlockIndex = &it->second;
+    if (!gArgs.GetBoolArg("-overrideforcedshutdown", false)) {
+        fs::path persistPath = gArgs.GetDataDirNet() / "MP_persist";
+        if (fs::exists(persistPath)) fs::remove_all(persistPath); // prevent the node being restarted without a reparse after forced shutdown
+        AbortNode(message);
     }
+}
+
+struct DataVisitor
+{
+    std::vector<unsigned char> operator()(const CNoDestination& noDest) const { return {}; }
+    std::vector<unsigned char> operator()(const PKHash& hash) const { return {hash.begin(), hash.end()}; }
+    std::vector<unsigned char> operator()(const ScriptHash& scriptHash) const { return {scriptHash.begin(), scriptHash.end()}; }
+    std::vector<unsigned char> operator()(const WitnessV0ScriptHash& witnessScriptHash) const { return {witnessScriptHash.begin(), witnessScriptHash.end()}; }
+    std::vector<unsigned char> operator()(const WitnessV0KeyHash& witnessKeyHash) const { return {witnessKeyHash.begin(), witnessKeyHash.end()}; }
+    std::vector<unsigned char> operator()(const WitnessV1Taproot& witnessTaproot) const { return {witnessTaproot.begin(), witnessTaproot.end()}; }
+    std::vector<unsigned char> operator()(const WitnessUnknown& witnessUnknown) const { return {}; }
+};
 
-    return pBlockIndex;
+std::optional<std::pair<unsigned int, uint256>> ScriptToUint(const CScript& scriptPubKey)
+{
+    CTxDestination dest;
+    if (!ExtractDestination(scriptPubKey, dest)) {
+        return {};
+    }
+    auto bytes = std::visit(DataVisitor{}, dest);
+    if (bytes.empty() || bytes.size() > uint256::size()) {
+        return {};
+    }
+    uint256 addressBytes;
+    std::copy(bytes.begin(), bytes.end(), addressBytes.begin());
+    return std::make_pair(dest.index(), addressBytes);
+}
+
+std::optional<std::pair<unsigned int, uint256>> AddressToUint(const std::string& address)
+{
+    auto dest = DecodeDestination(address);
+    if (!IsValidDestination(dest)) {
+        return {};
+    }
+    auto bytes = std::visit(DataVisitor{}, dest);
+    if (bytes.empty() || bytes.size() > uint256::size()) {
+        return {};
+    }
+    uint256 addressBytes;
+    std::copy(bytes.begin(), bytes.end(), addressBytes.begin());
+    return std::make_pair(dest.index(), addressBytes);
 }
 
 bool MainNet()
diff --git a/src/omnicore/utilsbitcoin.h b/src/omnicore/utilsbitcoin.h
index 364e950c07ee4..25c75e7539f7d 100644
--- a/src/omnicore/utilsbitcoin.h
+++ b/src/omnicore/utilsbitcoin.h
@@ -1,10 +1,14 @@
 #ifndef BITCOIN_OMNICORE_UTILSBITCOIN_H
 #define BITCOIN_OMNICORE_UTILSBITCOIN_H
 
-class CBlockIndex;
-class uint256;
+#include <omnicore/validationinterface.h>
 
 #include <stdint.h>
+#include <optional>
+
+#include <uint256.h>
+
+class CScript;
 
 namespace mastercore
 {
@@ -12,8 +16,17 @@ namespace mastercore
 int GetHeight();
 /** Returns the timestamp of the latest block. */
 uint32_t GetLatestBlockTime();
-/** Returns the CBlockIndex for a given block hash, or NULL. */
-CBlockIndex* GetBlockIndex(const uint256& hash);
+/** Used to inform the node is in initial block download. */
+bool IsInitialBlockDownload();
+/** Used to inform the node is in processing a block. */
+bool IsProcessingBlock();
+/** Returns the active chain. */
+const CChainIndex& GetActiveChain();
+/** Abort the node. */
+void MayAbortNode(const std::string& message);
+
+std::optional<std::pair<unsigned int, uint256>> AddressToUint(const std::string& address);
+std::optional<std::pair<unsigned int, uint256>> ScriptToUint(const CScript& scriptPubKey);
 
 bool MainNet();
 bool TestNet();
diff --git a/src/omnicore/validationinterface.cpp b/src/omnicore/validationinterface.cpp
new file mode 100644
index 0000000000000..5df8a10594d81
--- /dev/null
+++ b/src/omnicore/validationinterface.cpp
@@ -0,0 +1,611 @@
+
+#include <atomic>
+
+#include <chain.h>
+#include <key_io.h>
+#include <node/interface_ui.h>
+#include <shutdown.h>
+#include <undo.h>
+#include <validation.h>
+
+#include <omnicore/activation.h>
+#include <omnicore/coinscache.h>
+#include <omnicore/consensushash.h>
+#include <omnicore/convert.h>
+#include <omnicore/dbaddress.h>
+#include <omnicore/dbbase.h>
+#include <omnicore/dbfees.h>
+#include <omnicore/dbspinfo.h>
+#include <omnicore/dbstolist.h>
+#include <omnicore/dbtradelist.h>
+#include <omnicore/dbtransaction.h>
+#include <omnicore/dbtxlist.h>
+#include <omnicore/dex.h>
+#include <omnicore/log.h>
+#include <omnicore/notifications.h>
+#include <omnicore/mempool.h>
+#include <omnicore/pending.h>
+#include <omnicore/rules.h>
+#include <omnicore/seedblocks.h>
+#include <omnicore/sp.h>
+#include <omnicore/tx.h>
+#include <omnicore/utilsbitcoin.h>
+#include <omnicore/validationinterface.h>
+
+using namespace mastercore;
+
+const CBlockIndex* CChainIndex::Genesis() const
+{
+    LOCK(cs_chain);
+    return !vChain.empty() ? vChain.front() : nullptr;
+}
+
+const CBlockIndex* CChainIndex::Tip() const
+{
+    return aTip.load(std::memory_order_relaxed);
+}
+
+const CBlockIndex* CChainIndex::operator[](int nHeight) const
+{
+    LOCK(cs_chain);
+    return nHeight < 0 || nHeight > Height() ? nullptr : vChain[nHeight];
+}
+
+bool CChainIndex::Contains(const CBlockIndex* pindex) const
+{
+    LOCK(cs_chain);
+    return (*this)[pindex->nHeight] == pindex;
+}
+
+const CBlockIndex* CChainIndex::Next(const CBlockIndex* pindex) const
+{
+    LOCK(cs_chain);
+    return Contains(pindex) ? (*this)[pindex->nHeight + 1] : nullptr;
+}
+
+int CChainIndex::Height() const
+{
+    auto tip = Tip();
+    return tip ? tip->nHeight : 0;
+}
+
+void CChainIndex::SetTip(const CBlockIndex* pindex)
+{
+    LOCK(cs_chain);
+    vChain.resize(pindex->nHeight + 1);
+    aTip.store(pindex, std::memory_order_release);
+    while (pindex && !Contains(pindex)) {
+        vChain[pindex->nHeight] = pindex;
+        pindex = pindex->pprev;
+    }
+}
+
+/**
+ * Reports the progress of the initial transaction scanning.
+ *
+ * The progress is printed to the console, written to the debug log file, and
+ * the RPC status, as well as the splash screen progress label, are updated.
+ *
+ * @see msc_initial_scan()
+ */
+class ProgressReporter
+{
+private:
+    const CBlockIndex* m_pblockFirst;
+    const CBlockIndex* m_pblockLast;
+    const int64_t m_timeStart;
+
+    /** Returns the estimated remaining time in milliseconds. */
+    int64_t estimateRemainingTime(double progress) const
+    {
+        int64_t timeSinceStart = GetTimeMillis() - m_timeStart;
+
+        double timeRemaining = 3600000.0; // 1 hour
+        if (progress > 0.0 && timeSinceStart > 0) {
+            timeRemaining = (100.0 - progress) / progress * timeSinceStart;
+        }
+
+        return static_cast<int64_t>(timeRemaining);
+    }
+
+    /** Converts a time span to a human readable string. */
+    std::string remainingTimeAsString(int64_t remainingTime) const
+    {
+        int64_t secondsTotal = 0.001 * remainingTime;
+        int64_t hours = secondsTotal / 3600;
+        int64_t minutes = (secondsTotal / 60) % 60;
+        int64_t seconds = secondsTotal % 60;
+
+        if (hours > 0) {
+            return strprintf("%d:%02d:%02d hours", hours, minutes, seconds);
+        } else if (minutes > 0) {
+            return strprintf("%d:%02d minutes", minutes, seconds);
+        } else {
+            return strprintf("%d seconds", seconds);
+        }
+    }
+
+public:
+    ProgressReporter(const CBlockIndex* pblockFirst, const CBlockIndex* pblockLast)
+        : m_pblockFirst(pblockFirst), m_pblockLast(pblockLast), m_timeStart(GetTimeMillis())
+    {
+    }
+
+    /** Prints the current progress to the console and notifies the UI. */
+    void update(const CBlockIndex* pblockNow) const
+    {
+        int nLastBlock = m_pblockLast->nHeight;
+        int nCurrentBlock = pblockNow->nHeight;
+        unsigned int nFirst = m_pblockFirst->nChainTx;
+        unsigned int nCurrent = pblockNow->nChainTx;
+        unsigned int nLast = m_pblockLast->nChainTx;
+
+        double dProgress = 100.0 * (nCurrent - nFirst) / (nLast - nFirst);
+        int64_t nRemainingTime = estimateRemainingTime(dProgress);
+
+        std::string strProgress = strprintf(
+                "Still scanning.. at block %d of %d. Progress: %.2f %%, about %s remaining..\n",
+                nCurrentBlock, nLastBlock, dProgress, remainingTimeAsString(nRemainingTime));
+        std::string strProgressUI = strprintf(
+                "Still scanning.. at block %d of %d.\nProgress: %.2f %% (about %s remaining)",
+                nCurrentBlock, nLastBlock, dProgress, remainingTimeAsString(nRemainingTime));
+
+        PrintToConsole(strProgress);
+        uiInterface.InitMessage(strProgressUI);
+    }
+};
+
+void COmniValidationInterface::RewindDBsState(const CBlockIndex* pindex)
+{
+    // Check if any freeze related transactions would be rolled back - if so wipe the state and startclean
+    auto nHeight = pindex->nHeight - 1;
+    bool reorgContainsFreeze = pDbTransactionList->CheckForFreezeTxs(nHeight);
+    if (reorgContainsFreeze) {
+        PrintToConsole("Reorganization containing freeze related transactions detected, forcing a rescan...\n");
+    }
+
+    int best_state_block = 0;
+    if (reorgContainsFreeze
+    || (best_state_block = LoadMostRelevantInMemoryState()) < 0
+    || best_state_block > nHeight) {
+        extern void clear_all_state();
+        clear_all_state();
+        best_state_block = -1; // start from genesis block
+    } else {
+        auto block = best_state_block + 1; // revert to block inclusive
+        auto pblock = std::make_shared<CBlock>();
+        // sync txsToDelete to best_state_block
+        while (pindex && pindex->nHeight >= block) {
+            if (!node::ReadBlockFromDisk(*pblock, pindex, Params().GetConsensus())) {
+                throw std::runtime_error("RewindDBsState: Cannot read block to rewind");
+            }
+            BlockDisconnected(pblock, pindex);
+            disconnectInitiated = false;
+            pindex = pindex->pprev;
+        }
+        pDbStoList->deleteAboveBlock(block);
+        pDbSpInfo->deleteSPAboveBlock(block);
+        pDbFeeCache->RollBackCache(block);
+        pDbFeeHistory->RollBackHistory(block);
+        pDbNFT->RollBackAboveBlock(block);
+        pDbTransaction->DeleteTransactions(txsToDelete);
+        pDbTradeList->deleteTransactions(txsToDelete, block);
+        pDbTransactionList->deleteTransactions(txsToDelete, block);
+        if (fAddressIndex) {
+            pDbAddress->UpdateSpentIndex(spentIndexToUdpdate);
+            pDbAddress->EraseAddressIndex(addressIndexToDelete);
+            pDbAddress->UpdateAddressUnspentIndex(addressUnspentIndexToUpdate);
+        }
+    }
+
+    txsToDelete.clear();
+    spentIndexToUdpdate.clear();
+    addressIndexToDelete.clear();
+    addressUnspentIndexToUpdate.clear();
+
+    // clear the global wallet property list, perform a forced wallet update and tell the UI that state is no longer valid, and UI views need to be reinit
+    global_wallet_property_list.clear();
+    CheckWalletUpdate();
+    uiInterface.OmniStateInvalidated();
+    SyncToTip(best_state_block);
+}
+
+void COmniValidationInterface::SyncToTip(int loadedBlock)
+{
+    int nTimeBetweenProgressReports = gArgs.GetIntArg("-omniprogressfrequency", 30);  // seconds
+    int64_t nNow = GetTime();
+    unsigned int nTxsTotal = 0;
+    unsigned int nTxsFoundTotal = 0;
+
+    const CBlockIndex* pFirstBlock = chain[loadedBlock + 1];
+    const CBlockIndex* pLastBlock = chain.Tip();
+
+    if (!pFirstBlock || !pLastBlock) return;
+
+    auto nFirstBlock = pFirstBlock->nHeight;
+    auto nLastBlock = pLastBlock->nHeight;
+
+    if (node::fPruneMode && nLastBlock - nFirstBlock >= MIN_BLOCKS_TO_KEEP) {
+        throw std::runtime_error("Cannot recover in prune mode, needs restart with -reindex");
+    }
+
+    PrintToConsole("Scanning for transactions in block %d to block %d..\n", nFirstBlock, nLastBlock);
+
+    ProgressReporter progressReporter(pFirstBlock, pLastBlock);
+
+    int nBlock = 0;
+    CCoinsViewCacheOnly view;
+    // check if using seed block filter should be disabled
+    bool seedBlockFilterEnabled = gArgs.GetBoolArg("-omniseedblockfilter", MainNet());
+
+    for (nBlock = nFirstBlock; nBlock <= nLastBlock; ++nBlock)
+    {
+        if (ShutdownRequested()) {
+            PrintToLog("Shutdown requested, stop scan at block %d of %d\n", nBlock, nLastBlock);
+            break;
+        }
+
+        const CBlockIndex* pblockindex = chain[nBlock];
+        if (!pblockindex) break;
+
+        if (msc_debug_exo) {
+            auto strBlockHash = pblockindex->GetBlockHash().GetHex();
+            PrintToLog("%s(%d; max=%d):%s\n", __func__, nBlock, nLastBlock, strBlockHash);
+        }
+
+        if (GetTime() >= nNow + nTimeBetweenProgressReports) {
+            progressReporter.update(pblockindex);
+            nNow = GetTime();
+        }
+
+        unsigned int nTxNum = 0;
+        unsigned int nTxsFoundInBlock = 0;
+        BeginProcessTx(pblockindex);
+
+        if (!seedBlockFilterEnabled || !SkipBlock(nBlock)) {
+            CBlock block;
+            if (!node::ReadBlockFromDisk(block, pblockindex, Params().GetConsensus())) break;
+
+            for(const auto& tx : block.vtx) {
+                if (ProcessTransaction(view, *tx, nTxNum, pblockindex)) ++nTxsFoundInBlock;
+                ++nTxNum;
+            }
+        }
+
+        nTxsFoundTotal += nTxsFoundInBlock;
+        nTxsTotal += nTxNum;
+        EndProcessTx(pblockindex, nTxsFoundInBlock);
+    }
+
+    if (nBlock < nLastBlock) {
+        PrintToConsole("Scan stopped early at block %d of block %d\n", nBlock, nLastBlock);
+    }
+
+    PrintToConsole("%d new transactions processed, %d meta transactions found\n", nTxsTotal, nTxsFoundTotal);
+}
+
+/**
+ * Scans the blockchain for meta transactions.
+ *
+ * It scans the blockchain, starting at the given block index, to the current
+ * tip, much like as if new block were arriving and being processed on the fly.
+ *
+ * Every 30 seconds the progress of the scan is reported.
+ *
+ * In case the current block being processed is not part of the active chain, or
+ * if a block could not be retrieved from the disk, then the scan stops early.
+ * Likewise, global shutdown requests are honored, and stop the scan progress.
+ *
+ * @param loadedBlock[in]  The index of the first block to scan
+ * @return An exit code, indicating success or failure
+ */
+void COmniValidationInterface::Init(const CBlockIndex* pindex, int loadedBlock)
+{
+    chain.SetTip(pindex);
+    disconnectInitiated = false;
+    UpdatedBlockTip(pindex, nullptr, true);
+    SyncToTip(loadedBlock);
+}
+
+void COmniValidationInterface::BeginProcessTx(const CBlockIndex* pindex)
+{
+    if (disconnectInitiated) {
+        chain.SetTip(pindex->pprev);
+        disconnectInitiated = false;
+        RewindDBsState(pindex);
+    }
+
+    // handle any features that go live with this block
+    CheckLiveActivations(pindex->nHeight);
+    eraseExpiredCrowdsale(pindex);
+}
+
+// it performs cleanup and other functions
+void COmniValidationInterface::EndProcessTx(const CBlockIndex* pindex, unsigned int countMP)
+{
+    // for every new received block must do:
+    // 1) remove expired entries from the accept list (per spec accept entries are
+    //    valid until their blocklimit expiration; because the customer can keep
+    //    paying BTC for the offer in several installments)
+    // 2) update the amount in the Exodus address
+    int64_t devmsc = 0;
+    auto nBlockNow = pindex->nHeight;
+    unsigned int how_many_erased = eraseExpiredAccepts(nBlockNow);
+
+    if (how_many_erased) {
+        PrintToLog("%s(%d); erased %u accepts this block, line %d, file: %s\n",
+                    __func__, how_many_erased, nBlockNow, __LINE__, __FILE__);
+    }
+
+    extern int64_t calculate_and_update_devmsc(unsigned int nTime, int block);
+    // calculate devmsc as of this block and update the Exodus' balance
+    devmsc = calculate_and_update_devmsc(pindex->GetBlockTime(), nBlockNow);
+
+    if (msc_debug_exo) {
+        auto exodus = ExodusAddress();
+        int64_t balance = GetTokenBalance(EncodeDestination(exodus), OMNI_PROPERTY_MSC, BALANCE);
+        PrintToLog("devmsc for block %d: %d, Exodus balance: %d\n", nBlockNow, devmsc, FormatDivisibleMP(balance));
+    }
+
+    // check the alert status, do we need to do anything else here?
+    CheckExpiredAlerts(nBlockNow, pindex->GetBlockTime());
+
+    // check that pending transactions are still in the mempool
+    PendingCheck();
+
+    // transactions were found in the block, signal the UI accordingly
+    if (countMP > 0) CheckWalletUpdate();
+
+    // calculate and print a consensus hash if required
+    if (ShouldConsensusHashBlock(nBlockNow)) {
+        uint256 consensusHash = GetConsensusHash();
+        PrintToLog("Consensus hash for block %d: %s\n", nBlockNow, consensusHash.GetHex());
+    }
+
+    // request nftdb sanity check
+    bool sanityCheck = true;
+    pDbNFT->WriteBlockCache(nBlockNow, sanityCheck);
+
+    // request checkpoint verification
+    bool checkpointValid = VerifyCheckpoint(nBlockNow, pindex->GetBlockHash());
+    if (!checkpointValid) {
+        // failed checkpoint, can't be trusted to provide valid data - shutdown client
+        const std::string& msg = strprintf(
+            "Shutting down due to failed checkpoint for block %d (hash %s). "
+            "Please restart with -startclean flag and if this doesn't work, please reach out to the support.\n",
+            nBlockNow, pindex->GetBlockHash().GetHex());
+        PrintToLog(msg);
+        MayAbortNode(msg);
+    }
+
+    if (checkpointValid && nBlockNow >= ConsensusParams().GENESIS_BLOCK) {
+        // save out the state after this block
+        if (IsPersistenceEnabled(nBlockNow)) {
+            PersistInMemoryState(pindex);
+        }
+    }
+}
+
+static uint160 Uint160(const uint256& uint_256)
+{
+    uint160 uint_160;
+    std::copy(uint_256.begin(), uint_256.begin() + uint160::size(), uint_160.begin());
+    return uint_160;
+}
+
+static CScript GetScriptFromIndex(size_t type, const uint256 &hash)
+{
+    switch (type) {
+        case 1: return GetScriptForDestination(PKHash(Uint160(hash)));
+        case 2: return GetScriptForDestination(ScriptHash(Uint160(hash)));
+        case 3: return GetScriptForDestination(WitnessV0ScriptHash(hash));
+        case 4: return GetScriptForDestination(WitnessV0KeyHash(Uint160(hash)));
+        case 5: return GetScriptForDestination(WitnessV1Taproot(XOnlyPubKey{hash}));
+    }
+    return {};
+}
+
+void COmniValidationInterface::UpdatedBlockTip(const CBlockIndex* , const CBlockIndex*, bool fInitialDownload)
+{
+    initialBlockDownload.store(fInitialDownload, std::memory_order_release);
+}
+
+void COmniValidationInterface::TransactionAddedToMempool(const CTransactionRef& tx, uint64_t mempool_sequence)
+{
+    AddTransactionToMempool(tx);
+}
+
+void COmniValidationInterface::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence)
+{
+    RemoveTransactionFromMempool(tx);
+}
+
+void COmniValidationInterface::BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
+{
+    LOCK(cs_tally);
+
+    processingBlock.store(true, std::memory_order_release);
+
+    BeginProcessTx(pindex);
+
+    chain.SetTip(pindex);
+
+    //! transaction position within the block
+    unsigned int nTxIdx = 0;
+
+    //! number of meta transactions found
+    unsigned int nNumMetaTxs = 0;
+
+    CCoinsViewCacheOnly view;
+    for (auto& tx : block->vtx) {
+        //! Omni Core: new confirmed transaction notification
+        if (ProcessTransaction(view, *tx, nTxIdx, pindex)) {
+            PrintToLog("%s: new confirmed transaction [height: %d, idx: %u]\n", __func__, pindex->nHeight, nTxIdx);
+            ++nNumMetaTxs;
+        }
+        ++nTxIdx;
+    }
+
+    //! Omni Core: end of block connect notification
+    if (nNumMetaTxs)
+        PrintToLog("%s: block connect end [new height: %d, found: %u txs]\n", __func__, pindex->nHeight, nNumMetaTxs);
+
+    EndProcessTx(pindex, nNumMetaTxs);
+
+    if (fAddressIndex) {
+        std::vector<std::pair<CAddressIndexKey, CAmount>> addressIndex;
+        std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue>> addressUnspentIndex;
+        std::vector<std::pair<CSpentIndexKey, CSpentIndexValue>> spentIndex;
+
+        for (unsigned int i = 0; i < block->vtx.size(); i++) {
+            const CTransaction &tx = *(block->vtx[i]);
+            for (unsigned int j = 0; j < tx.vin.size(); j++) {
+                const CTxIn& input = tx.vin[j];
+                const CTxOut& prevout = view.GetOutputFor(input);
+
+                if (auto result = ScriptToUint(prevout.scriptPubKey)) {
+                    auto& [index, address] = *result;
+                    addressIndex.emplace_back(CAddressIndexKey{index, address, pindex->nHeight, i, tx.GetHash(), j, true}, prevout.nValue * -1);
+
+                    // remove address from unspent index
+                    addressUnspentIndex.emplace_back(CAddressUnspentKey{index, address, input.prevout.hash, input.prevout.n}, CAddressUnspentValue{});
+                    spentIndex.emplace_back(CSpentIndexKey{input.prevout.hash, input.prevout.n}, CSpentIndexValue{tx.GetHash(), j, pindex->nHeight, prevout.nValue, index, address});
+                }
+            }
+
+            for (unsigned int k = 0; k < tx.vout.size(); k++) {
+                const CTxOut &out = tx.vout[k];
+                const bool isTxCoinBase = tx.IsCoinBase();
+
+                if (auto result = ScriptToUint(out.scriptPubKey)) {
+                    auto& [index, address] = *result;
+                    // record receiving activity
+                    addressIndex.emplace_back(CAddressIndexKey{index, address, pindex->nHeight, i, tx.GetHash(), k}, out.nValue);
+                    // record unspent output
+                    addressUnspentIndex.emplace_back(CAddressUnspentKey{index, address, tx.GetHash(), k}, CAddressUnspentValue{out.nValue, out.scriptPubKey, pindex->nHeight, isTxCoinBase});
+                }
+            }
+        }
+
+        if (!pDbAddress->WriteAddressIndex(addressIndex))
+            PrintToLog("%s: Failed to write address index\n", __func__);
+
+        if (!pDbAddress->UpdateAddressUnspentIndex(addressUnspentIndex))
+            PrintToLog("%s: Failed to write address unspent index\n", __func__);
+
+        if (!pDbAddress->UpdateSpentIndex(spentIndex))
+            PrintToLog("%s: Failed to write transaction index\n", __func__);
+
+        unsigned int logicalTS = pindex->nTime;
+        unsigned int prevLogicalTS = 0;
+
+        // retrieve logical timestamp of the previous block
+        if (pindex->pprev && !pDbAddress->ReadTimestampBlockIndex(pindex->pprev->GetBlockHash(), prevLogicalTS))
+            PrintToLog("%s: Failed to read previous block's logical timestamp\n", __func__);
+
+        if (logicalTS <= prevLogicalTS) {
+            logicalTS = prevLogicalTS + 1;
+            PrintToLog("%s: Previous logical timestamp is newer Actual[%d] prevLogical[%d] Logical[%d]\n", __func__, pindex->nTime, prevLogicalTS, logicalTS);
+        }
+
+        if (!pDbAddress->WriteTimestampIndex(CTimestampIndexKey{logicalTS, pindex->GetBlockHash()}))
+            PrintToLog("%s: Failed to write timestamp index\n", __func__);
+
+        if (!pDbAddress->WriteTimestampBlockIndex(pindex->GetBlockHash(), logicalTS))
+            PrintToLog("%s: Failed to write blockhash index\n", __func__);
+    }
+
+    processingBlock.store(false, std::memory_order_release);
+
+    pCoinsCache->BlockCached(pindex);
+
+    for (auto& tx : block->vtx)
+        RemoveTransactionFromMempool(tx);
+}
+
+void COmniValidationInterface::BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
+{
+    //! Omni Core: begin block disconnect notification
+    PrintToLog("%s Omni Core handler: height: %d\n", __func__, pindex->nHeight);
+
+    LOCK(cs_tally);
+
+    for (auto i = 0u; i < block->vtx.size(); ++i) {
+        auto& tx = block->vtx[i];
+        txsToDelete.insert(tx->GetHash());
+        pCoinsCache->Uncache({tx->GetHash(), i});
+    }
+
+    CBlockUndo blockUndo;
+    if (node::UndoReadFromDisk(blockUndo, pindex)) {
+        for (auto i = 1u; i < block->vtx.size(); i++) {
+            const CTransaction &tx = *(block->vtx[i]);
+            CTxUndo &txundo = blockUndo.vtxundo.at(i - 1);
+            for (auto j = tx.vin.size(); j-- > 0;) {
+                pCoinsCache->AddCoin(tx.vin[j].prevout, std::move(txundo.vprevout.at(j)));
+            }
+        }
+    }
+
+    disconnectInitiated = true;
+
+    if (!fAddressIndex) {
+        return;
+    }
+
+    for (int i = block->vtx.size() - 1; i >= 0; i--) {
+        const CTransaction &tx = *(block->vtx[i]);
+        for (int k = tx.vout.size() - 1; k >= 0; k--) {
+            const CTxOut &out = tx.vout[k];
+            if (auto result = ScriptToUint(out.scriptPubKey)) {
+                auto& [index, address] = *result;
+                // undo receiving activity
+                addressIndexToDelete.emplace_back(CAddressIndexKey{index, address, pindex->nHeight, unsigned(i), tx.GetHash(), unsigned(k), false}, 0);
+                // undo unspent index
+                addressUnspentIndexToUpdate.emplace_back(CAddressUnspentKey{index, address, tx.GetHash(), unsigned(k)}, CAddressUnspentValue{});
+            }
+        }
+        const bool isTxCoinBase = tx.IsCoinBase();
+        for (int j = tx.vin.size() - 1; j >= 0; j--) {
+            const CTxIn& input = tx.vin[j];
+            CSpentIndexValue spend;
+            if (pDbAddress->ReadSpentIndex({input.prevout.hash, input.prevout.n}, spend)) {
+                // undo spending activity
+                addressIndexToDelete.emplace_back(CAddressIndexKey{spend.addressType, spend.addressHash, pindex->nHeight, unsigned(i), tx.GetHash(), unsigned(j), true}, 0);
+                // restore unspent index
+                addressUnspentIndexToUpdate.emplace_back(CAddressUnspentKey{spend.addressType, spend.addressHash, input.prevout.hash, input.prevout.n},
+                                                        CAddressUnspentValue{spend.satoshis, GetScriptFromIndex(spend.addressType, spend.addressHash), spend.blockHeight, isTxCoinBase});
+            }
+            spentIndexToUdpdate.emplace_back(CSpentIndexKey{input.prevout.hash, input.prevout.n}, CSpentIndexValue{});
+        }
+    }
+}
+
+int COmniValidationInterface::LastBlockHeight() const
+{
+    auto tip = chain.Tip();
+    return tip ? tip->nHeight : 0;
+}
+
+uint32_t COmniValidationInterface::LastBlockTime() const
+{
+    auto tip = chain.Tip();
+    return tip ? tip->nTime : 0;
+}
+
+const CChainIndex& COmniValidationInterface::GetActiveChain() const
+{
+    return chain;
+}
+
+bool COmniValidationInterface::IsInitialBlockDownload() const
+{
+    return initialBlockDownload.load(std::memory_order_relaxed);
+}
+
+bool COmniValidationInterface::IsProcessingBlock() const
+{
+    return processingBlock.load(std::memory_order_relaxed);
+}
+
+std::shared_ptr<COmniValidationInterface> omniValidationInterface;
diff --git a/src/omnicore/validationinterface.h b/src/omnicore/validationinterface.h
new file mode 100644
index 0000000000000..05ad13e23fa1a
--- /dev/null
+++ b/src/omnicore/validationinterface.h
@@ -0,0 +1,135 @@
+#ifndef BITCOIN_OMNICORE_VALIDATIONINTERFACE_H
+#define BITCOIN_OMNICORE_VALIDATIONINTERFACE_H
+
+#include <omnicore/dbaddress.h>
+#include <omnicore/omnicore.h>
+
+#include <cstdint>
+#include <primitives/block.h>
+#include <sync.h>
+#include <validationinterface.h>
+
+#include <atomic>
+#include <vector>
+
+class CBlockIndex;
+
+class CChainIndex
+{
+    mutable RecursiveMutex cs_chain;
+    std::vector<const CBlockIndex*> vChain;
+    std::atomic<const CBlockIndex*> aTip;
+
+public:
+    CChainIndex() = default;
+    CChainIndex(const CChainIndex&) = delete;
+
+    /** Returns the index entry for the genesis block of this chain, or nullptr if none. */
+    const CBlockIndex* Genesis() const;
+
+    /** Returns the index entry for the tip of this chain, or nullptr if none. */
+    const CBlockIndex* Tip() const;
+
+    /** Returns the index entry at a particular height in this chain, or nullptr if no such height exists. */
+    const CBlockIndex* operator[](int nHeight) const;
+
+    /** Efficiently check whether a block is present in this chain. */
+    bool Contains(const CBlockIndex* pindex) const;
+
+    /** Find the successor of a block in this chain, or nullptr if the given index is not found or is the tip. */
+    const CBlockIndex* Next(const CBlockIndex* pindex) const;
+
+    /** Return the maximal height in the chain. Is equal to chain.Tip() ? chain.Tip()->nHeight : -1. */
+    int Height() const;
+
+    /** Set/initialize a chain with a given tip. */
+    void SetTip(const CBlockIndex* pindex);
+};
+
+class COmniValidationInterface : public CValidationInterface {
+    CChainIndex chain;
+    std::set<uint256> txsToDelete;
+    bool disconnectInitiated = false;
+    std::atomic_bool initialBlockDownload = false, processingBlock = false;
+    std::vector<std::pair<CAddressIndexKey, CAmount>> addressIndexToDelete;
+    std::vector<std::pair<CSpentIndexKey, CSpentIndexValue>> spentIndexToUdpdate;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue>> addressUnspentIndexToUpdate;
+
+    void SyncToTip(int loadedBlock);
+    void RewindDBsState(const CBlockIndex* pindex);
+    void BeginProcessTx(const CBlockIndex* pindex);
+    void EndProcessTx(const CBlockIndex* pindex, unsigned int countMP);
+
+public:
+    /**
+     * Initialize tip and sync to it if needed
+     */
+    void Init(const CBlockIndex* pindex, int loadedBlock);
+    /**
+     * Notifies listeners when the block chain tip advances.
+     *
+     * When multiple blocks are connected at once, UpdatedBlockTip will be called on the final tip
+     * but may not be called on every intermediate tip. If the latter behavior is desired,
+     * subscribe to BlockConnected() instead.
+     *
+     * Called on a background thread.
+     */
+    void UpdatedBlockTip(const CBlockIndex*, const CBlockIndex*, bool fInitialDownload) override;
+    /**
+     * Notifies listeners of a transaction having been added to mempool.
+     *
+     * Called on a background thread.
+     */
+    void TransactionAddedToMempool(const CTransactionRef& tx, uint64_t mempool_sequence) override;
+    /**
+     * Notifies listeners of a transaction leaving mempool.
+     * - TransactionRemovedFromMempool(tx1 from block A)
+     * - TransactionRemovedFromMempool(tx2 from block A)
+     * - TransactionRemovedFromMempool(tx1 from block B)
+     * - TransactionRemovedFromMempool(tx2 from block B)
+     * - BlockConnected(A)
+     * - BlockConnected(B)
+     *
+     * Called on a background thread.
+     */
+    void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override;
+    /**
+     * Notifies listeners of a block being connected.
+     * Called on a background thread.
+     */
+    void BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
+    /**
+     * Notifies listeners of a block being disconnected
+     *
+     * Called on a background thread.
+     */
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
+    /**
+     * Returns tip height
+     */
+    int LastBlockHeight() const;
+
+    /**
+     * Returns tip time
+     */
+    uint32_t LastBlockTime() const;
+
+    /**
+     * Returns active chain
+     */
+    const CChainIndex& GetActiveChain() const;
+
+    /**
+     * Returns whether node is in initial block download
+     */
+    bool IsInitialBlockDownload() const;
+
+    /**
+     * Returns whether interface is processing a block
+     */
+    bool IsProcessingBlock() const;
+};
+
+extern std::shared_ptr<COmniValidationInterface> omniValidationInterface;
+
+#endif // BITCOIN_OMNICORE_VALIDATIONINTERFACE_H
diff --git a/src/omnicore/walletfetchtxs.cpp b/src/omnicore/walletfetchtxs.cpp
index 17dc7fe3fedf0..6c9fe131a046a 100644
--- a/src/omnicore/walletfetchtxs.cpp
+++ b/src/omnicore/walletfetchtxs.cpp
@@ -9,6 +9,7 @@
 
 #include <omnicore/convert.h>
 #include <omnicore/dbstolist.h>
+#include <omnicore/dbtransaction.h>
 #include <omnicore/dbtxlist.h>
 #include <omnicore/log.h>
 #include <omnicore/omnicore.h>
@@ -20,7 +21,6 @@
 #include <validation.h>
 #include <sync.h>
 #include <tinyformat.h>
-#include <index/txindex.h>
 #ifdef ENABLE_WALLET
 #include <omnicore/walletutils.h>
 #include <wallet/wallet.h>
@@ -38,19 +38,6 @@
 
 namespace mastercore
 {
-/**
- * Gets the byte offset of a transaction from the transaction index.
- */
-static unsigned int GetTransactionByteOffset(const uint256& txid)
-{
-    LOCK(cs_main);
-
-    if (g_txindex) {
-        return g_txindex->ReadTxPos(txid);
-    }
-
-    return 0;
-}
 
 /**
  * Returns an ordered list of Omni transactions including STO receipts that are relevant to the wallet.
@@ -61,77 +48,33 @@ std::map<std::string, uint256> FetchWalletOmniTransactions(interfaces::Wallet& i
 {
     std::map<std::string, uint256> mapResponse;
 #ifdef ENABLE_WALLET
-    if (!HasWallets()) {
-        return mapResponse;
-    }
     std::set<uint256> seenHashes;
     std::multimap<int64_t, const interfaces::WalletTx*> txOrdered;
     const auto& transactions = iWallet.getWalletTxs();
     for (const auto& transaction : transactions)
-        txOrdered.insert(std::make_pair(transaction.order_position, &transaction));
+        txOrdered.emplace(transaction.order_position, &transaction);
 
     // Iterate backwards through wallet transactions until we have count items to return:
     for (std::multimap<int64_t, const interfaces::WalletTx*>::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
         const interfaces::WalletTx* pwtx = it->second;
         const uint256& txHash = pwtx->tx->GetHash();
-        {
-            LOCK(cs_tally);
-            if (!pDbTransactionList->exists(txHash)) continue;
-        }
-        const uint256& blockHash = pwtx->block_hash;
-        if (blockHash.IsNull()) continue;
-        const CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        if (pBlockIndex == nullptr) continue;
-        int blockHeight = pBlockIndex->nHeight;
+        int blockHeight = 0;
+        if (!pDbTransactionList->getValidMPTX(txHash, &blockHeight)) continue;
         if (blockHeight < startBlock || blockHeight > endBlock) continue;
-        int blockPosition = GetTransactionByteOffset(txHash);
+        int blockPosition = pDbTransaction->FetchTransactionPosition(txHash);
         std::string sortKey = strprintf("%06d%010d", blockHeight, blockPosition);
-        mapResponse.insert(std::make_pair(sortKey, txHash));
+        mapResponse.emplace(sortKey, txHash);
         seenHashes.insert(txHash);
         if (mapResponse.size() >= count) break;
     }
 
     // Insert STO receipts - receiving an STO has no inbound transaction to the wallet, so we will insert these manually into the response
-    std::string mySTOReceipts;
-    {
-        LOCK(cs_tally);
-        mySTOReceipts = pDbStoList->getMySTOReceipts("", iWallet);
-    }
-    std::vector<std::string> vecReceipts;
-    if (!mySTOReceipts.empty()) {
-        boost::split(vecReceipts, mySTOReceipts, boost::is_any_of(","), boost::token_compress_on);
-    }
-    for (size_t i = 0; i < vecReceipts.size(); i++) {
-        std::vector<std::string> svstr;
-        boost::split(svstr, vecReceipts[i], boost::is_any_of(":"), boost::token_compress_on);
-        if (svstr.size() != 4) {
-            PrintToLog("STODB Error - number of tokens is not as expected (%s)\n", vecReceipts[i]);
-            continue;
-        }
-        int blockHeight = atoi(svstr[1]);
-        if (blockHeight < startBlock || blockHeight > endBlock) continue;
-        uint256 txHash = uint256S(svstr[0]);
+    auto mySTOReceipts = pDbStoList->getMySTOReceipts({}, startBlock, endBlock, iWallet);
+    for (const auto& [blockHeight, txHash] : mySTOReceipts) {
         if (seenHashes.find(txHash) != seenHashes.end()) continue; // an STO may already be in the wallet if we sent it
-        int blockPosition = GetTransactionByteOffset(txHash);
-        std::string sortKey = strprintf("%06d%010d", blockHeight, blockPosition);
-        mapResponse.insert(std::make_pair(sortKey, txHash));
-    }
-
-    // Insert pending transactions (sets block as 999999 and position as wallet position)
-    // TODO: resolve potential deadlock caused by cs_wallet, cs_pending
-    // LOCK(cs_pending);
-    for (PendingMap::const_iterator it = my_pending.begin(); it != my_pending.end(); ++it) {
-        const uint256& txHash = it->first;
-        int blockHeight = 999999;
-        if (blockHeight < startBlock || blockHeight > endBlock) continue;
-        int blockPosition = 0;
-        {
-            for (const auto& transaction : transactions)
-                if (transaction.tx->GetHash() == txHash)
-                    blockPosition = transaction.order_position;
-        }
+        int blockPosition = pDbTransaction->FetchTransactionPosition(txHash);
         std::string sortKey = strprintf("%06d%010d", blockHeight, blockPosition);
-        mapResponse.insert(std::make_pair(sortKey, txHash));
+        mapResponse.emplace(sortKey, txHash);
     }
 #endif
     return mapResponse;
diff --git a/src/omnicore/wallettxbuilder.cpp b/src/omnicore/wallettxbuilder.cpp
index 267e03126f5e4..b554c1c209c62 100644
--- a/src/omnicore/wallettxbuilder.cpp
+++ b/src/omnicore/wallettxbuilder.cpp
@@ -3,9 +3,11 @@
 #include <omnicore/encoding.h>
 #include <omnicore/errors.h>
 #include <omnicore/log.h>
+#include <omnicore/mempool.h>
 #include <omnicore/omnicore.h>
 #include <omnicore/parsing.h>
 #include <omnicore/script.h>
+#include <omnicore/dbtransaction.h>
 #include <omnicore/walletutils.h>
 
 #include <consensus/amount.h>
@@ -255,8 +257,6 @@ static void LockUnrelatedCoins(
         return;
     }
 
-    // NOTE: require: LOCK2(cs_main, pwallet->cs_wallet);
-
     // lock any other output
     std::vector<COutput> vCoins;
     iWallet->availableCoins(vCoins, nullptr, 0);
@@ -282,8 +282,6 @@ static void UnlockCoins(
         interfaces::Wallet* iWallet,
         const std::vector<COutPoint>& vToUnlock)
 {
-    // NOTE: require: LOCK2(cs_main, pwallet->cs_wallet);
-
     for (const COutPoint& output : vToUnlock) {
         iWallet->unlockCoin(output);
     }
@@ -299,8 +297,7 @@ int CreateFundedTransaction(
         const std::string& feeAddress,
         const std::vector<unsigned char>& payload,
         uint256& retTxid,
-        interfaces::Wallet* iWallet,
-        node::NodeContext& node)
+        interfaces::Wallet* iWallet)
 {
     if (!iWallet) {
         return MP_ERR_WALLET_ACCESS;
@@ -422,67 +419,34 @@ int CreateFundedTransaction(
     }
 
     // sign the transaction
+    int nHashType = SIGHASH_ALL;
 
-    // fetch previous transactions (inputs):
-    CCoinsView viewDummy;
-    CCoinsViewCache view(&viewDummy);
     {
-        auto mempool = ::ChainstateActive().GetMempool();
-        assert(mempool);
-        LOCK2(cs_main, mempool->cs);
-        CCoinsViewCache &viewChain = ::ChainstateActive().CoinsTip();
-        CCoinsViewMemPool viewMempool(&viewChain, *mempool);
-        view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view
-
-        for(const CTxIn& txin : tx.vin) {
-            const auto& prevout = txin.prevout;
-            view.AccessCoin(prevout); // this is certainly allowed to fail
-        }
+        bool fCoinbase = false;
+        for (size_t i = 0; i < tx.vin.size(); i++) {
+            auto& txin = tx.vin[i];
+            Coin coin;
+            if (!GetCoin(txin.prevout, coin)) {
+                PrintToLog("%s: ERROR: wallet transaction signing failed: input not found or already spent\n", __func__);
+                continue;
+            }
 
-        view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long
-    }
+            const auto& out = coin.out;
 
-    int nHashType = SIGHASH_ALL;
-
-    for (unsigned int i = 0; i < tx.vin.size(); i++) {
-        CTxIn& txin = tx.vin[i];
-        const Coin& coin = view.AccessCoin(txin.prevout);
-        if (coin.IsSpent()) {
-            PrintToLog("%s: ERROR: wallet transaction signing failed: input not found or already spent\n", __func__);
-            continue;
-        }
-        const CScript& prevPubKey = coin.out.scriptPubKey;
-        const CAmount& amount = coin.out.nValue;
+            SignatureData sigdata;
+            if (!iWallet->produceSignature(MutableTransactionSignatureCreator(tx, i, out.nValue, nHashType), out.scriptPubKey, sigdata)) {
+                PrintToLog("%s: ERROR: wallet transaction signing failed\n", __func__);
+                return MP_ERR_CREATE_TX;
+            }
 
-        SignatureData sigdata;
-        if (!iWallet->produceSignature(MutableTransactionSignatureCreator(tx, i, amount, nHashType), prevPubKey, sigdata)) {
-            PrintToLog("%s: ERROR: wallet transaction signing failed\n", __func__);
-            return MP_ERR_CREATE_TX;
+            UpdateInput(txin, sigdata);
         }
-
-        UpdateInput(txin, sigdata);
     }
 
     // send the transaction
 
     CTransactionRef ctx(MakeTransactionRef(std::move(tx)));
-
-    {
-        LOCK(cs_main);
-        auto result = AcceptToMemoryPool(ChainstateActive(), ctx, GetTime(), false, false);
-        if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {
-            PrintToLog("%s: ERROR: failed to broadcast transaction: %s\n", __func__, result.m_state.GetRejectReason());
-            return MP_ERR_COMMIT_TX;
-        }
-    }
-
-    std::string err_string;
-
-    const TransactionError err = node::BroadcastTransaction(node, ctx, err_string, iWallet->getDefaultMaxTxFee(), true, false);
-    if (TransactionError::OK != err) {
-        LogPrintf("%s: BroadcastTransaction failed error: %s\n", __func__, err_string);
-    }
-
+    iWallet->commitTransaction(ctx, {}, {});
     retTxid = ctx->GetHash();
 
     return 0;
diff --git a/src/omnicore/wallettxbuilder.h b/src/omnicore/wallettxbuilder.h
index 1a2d396d5c238..ad0805ebf24c2 100644
--- a/src/omnicore/wallettxbuilder.h
+++ b/src/omnicore/wallettxbuilder.h
@@ -7,10 +7,6 @@
 
 class uint256;
 
-namespace node {
-struct NodeContext;
-}
-
 namespace interfaces {
 class Wallet;
 } // namespace interfaces
@@ -71,8 +67,7 @@ int CreateFundedTransaction(const std::string& senderAddress,
         const std::string& feeAddress,
         const std::vector<unsigned char>& payload,
         uint256& retTxid,
-        interfaces::Wallet* iWallet,
-        node::NodeContext &node);
+        interfaces::Wallet* iWallet);
 
 int CreateDExTransaction(interfaces::Wallet* pwallet, const std::string& buyerAddress, const std::string& sellerAddress, const CAmount& nAmount, uint256& txid);
 #endif
diff --git a/src/omnicore/walletutils.cpp b/src/omnicore/walletutils.cpp
index 8994a5d67d110..8ed91848c3345 100644
--- a/src/omnicore/walletutils.cpp
+++ b/src/omnicore/walletutils.cpp
@@ -1,6 +1,7 @@
 #include <omnicore/walletutils.h>
 
 #include <omnicore/log.h>
+#include <omnicore/mempool.h>
 #include <omnicore/omnicore.h>
 #include <omnicore/rules.h>
 #include <omnicore/script.h>
@@ -13,6 +14,7 @@
 #include <node/context.h>
 #include <key_io.h>
 #include <validation.h>
+#include <policy/fees_args.h>
 #include <policy/policy.h>
 #include <pubkey.h>
 #include <script/standard.h>
@@ -85,10 +87,8 @@ bool CheckFee(interfaces::Wallet& iWallet, const std::string& fromAddress, size_
 
     // calculate the estimated fee per KB based on the currently set confirm target
     FeeCalculation feeCalc;
-    assert(g_context);
-    auto& feeEstimator = g_context->get().fee_estimator;
-    assert(feeEstimator);
-    CFeeRate feeRate = feeEstimator->estimateSmartFee(iWallet.getConfirmTarget(), &feeCalc, true /* FeeEstimateMode::CONSERVATIVE */);
+    static const CBlockPolicyEstimator feeEstimator(FeeestPath(gArgs));
+    CFeeRate feeRate = feeEstimator.estimateSmartFee(iWallet.getConfirmTarget(), &feeCalc, true /* FeeEstimateMode::CONSERVATIVE */);
 
     // if there is not enough data (and zero is estimated) then base minimum on a fairly high/safe 50,000 satoshi fee per KB
     if (feeRate == CFeeRate(0)) {
@@ -147,25 +147,34 @@ int IsMyAddress(const std::string& address, interfaces::Wallet* iWallet)
     return 0;
 }
 
+#if ENABLE_WALLET
+static std::function<std::vector<std::shared_ptr<wallet::CWallet>>()> GetWallets;
+#endif
+
+void InitWallets(node::NodeContext& node)
+{
+#if ENABLE_WALLET
+    if (auto loader = node.wallet_loader) {
+        if (auto context = loader->context()) {
+            GetWallets = std::bind(wallet::GetWallets, std::ref(*context));
+        }
+    }
+#endif
+}
+
 /**
  * IsMine wrapper to determine whether the address is in the wallet.
  */
-int IsMyAddressAllWallets(const std::string& address, const bool matchAny, const wallet::isminefilter& filter)
+bool IsMyAddressAllWallets(const std::string& address)
 {
 #ifdef ENABLE_WALLET
-    if (!HasWallets())
-        return 0;
-
+    if (!GetWallets) return false;
     CTxDestination destination = DecodeDestination(address);
-    for(const std::shared_ptr<CWallet>& wallet : GetWallets()) {
-        isminetype ismine = WITH_LOCK(wallet->cs_wallet, return wallet->IsMine(destination));
-        if (matchAny && ismine != ISMINE_NO)
-            return static_cast<int>(ismine);
-        else if (ismine & filter)
-            return static_cast<int>(ismine);
-    }
+    for(auto& wallet : GetWallets())
+        if (wallet->IsMine(destination))
+            return true;
 #endif
-    return 0;
+    return false;
 }
 
 /**
@@ -228,8 +237,7 @@ int64_t SelectCoins(interfaces::Wallet& iWallet, const std::string& fromAddress,
                 continue;
             }
             if (wtx.depth_in_main_chain == 0) {
-                auto mempool = ::ChainstateActive().GetMempool();
-                if (!mempool || !mempool->exists(GenTxid::Txid(txid))) {
+                if (!GetMempoolTransaction(txid)) {
                     continue;
                 }
             }
@@ -290,94 +298,8 @@ int64_t SelectCoins(interfaces::Wallet& iWallet, const std::string& fromAddress,
 
 int64_t SelectAllCoins(interfaces::Wallet& iWallet, const std::string& fromAddress, CCoinControl& coinControl)
 {
-    // total output funds collected
-    int64_t nTotal = 0;
-    int nHeight = mastercore::GetHeight();
-
-    std::map<uint256, interfaces::WalletTxStatus> tx_status;
-    const std::vector<interfaces::WalletTx>& transactions = iWallet.getWalletTxsDetails(tx_status);
-
-    // iterate over the wallet
-    for (std::vector<interfaces::WalletTx>::const_iterator it = transactions.begin(); it != transactions.end(); ++it) {
-        const CTransactionRef tx = it->tx;
-        const uint256& txid = tx->GetHash();
-
-        auto status = tx_status.find(txid);
-        if (status != tx_status.end()) {
-            const auto& wtx = status->second;
-            if (!wtx.is_trusted) {
-                continue;
-            }
-            if (wtx.is_coinbase && wtx.blocks_to_maturity > 0) {
-                continue;
-            }
-        }
-
-        for (unsigned int n = 0; n < tx->vout.size(); n++) {
-            const CTxOut& txOut = tx->vout[n];
-
-            CTxDestination dest;
-            if (!CheckInput(txOut, nHeight, dest)) {
-                continue;
-            }
-            if (!iWallet.isSpendable(dest)) {
-                continue;
-            }
-            if (iWallet.isSpent(txid, n)) {
-                continue;
-            }
-            if (iWallet.isLockedCoin(COutPoint(txid, n))) {
-                continue;
-            }
-
-            std::string sAddress = EncodeDestination(dest);
-            if (msc_debug_tokens) {
-                PrintToLog("%s: sender: %s, outpoint: %s:%d, value: %d\n", __func__, sAddress, txid.GetHex(), n, txOut.nValue);
-            }
-
-            // only use funds from the sender's address
-            if (fromAddress == sAddress) {
-                COutPoint outpoint(txid, n);
-                coinControl.Select(outpoint);
-
-                nTotal += txOut.nValue;
-            }
-        }
-    }
-
-    return nTotal;
+    return SelectCoins(iWallet, fromAddress, coinControl, INT64_MAX);
 }
 #endif
 
 } // namespace mastercore
-
-#ifdef ENABLE_WALLET
-static wallet::WalletContext* GetWalletContext()
-{
-    assert(g_context);
-    if (auto walletLoader = g_context->get().wallet_loader) {
-        return walletLoader->context();
-    }
-    return nullptr;
-}
-#endif
-
-bool HasWallets()
-{
-#ifdef ENABLE_WALLET
-    if (auto walletContext = GetWalletContext()) {
-        return WITH_LOCK(walletContext->wallets_mutex, return !walletContext->wallets.empty());
-    }
-#endif
-    return false;
-}
-
-std::vector<std::shared_ptr<wallet::CWallet>> GetWallets()
-{
-#ifdef ENABLE_WALLET
-    if (auto walletContext = GetWalletContext()) {
-        return WITH_LOCK(walletContext->wallets_mutex, return walletContext->wallets);
-    }
-#endif
-    return {};
-}
diff --git a/src/omnicore/walletutils.h b/src/omnicore/walletutils.h
index be03390a592d0..17ae865633037 100644
--- a/src/omnicore/walletutils.h
+++ b/src/omnicore/walletutils.h
@@ -7,10 +7,8 @@ namespace interfaces {
 class Wallet;
 } // namespace interfaces
 
-#include <wallet/ismine.h>             // For isminefilter, isminetype
 #include <script/standard.h>
 
-#include <stdint.h>
 #include <string>
 
 namespace wallet {
@@ -18,6 +16,10 @@ class CWallet;
 class CCoinControl;
 }
 
+namespace node {
+class NodeContext;
+}
+
 namespace mastercore
 {
 /** Retrieves a public key from the wallet, or converts a hex-string to a public key. */
@@ -33,7 +35,7 @@ bool CheckInput(const CTxOut& txOut, int nHeight, CTxDestination& dest);
 int IsMyAddress(const std::string& address, interfaces::Wallet* iWallet);
 
 /** IsMine wrapper to determine whether the address is in the wallet. */
-int IsMyAddressAllWallets(const std::string& address, const bool matchAny = false, const wallet::isminefilter& filter = wallet::ISMINE_SPENDABLE);
+bool IsMyAddressAllWallets(const std::string& address);
 
 /** Estimate the minimum fee considering user set parameters and the required fee. */
 CAmount GetEstimatedFeePerKb(interfaces::Wallet& iWallet);
@@ -42,6 +44,9 @@ CAmount GetEstimatedFeePerKb(interfaces::Wallet& iWallet);
 * require more fees to pay than the output is worth. */
 int64_t GetEconomicThreshold(interfaces::Wallet& iWallet, const CTxOut& txOut);
 
+/** Init wallets based on node context */
+void InitWallets(node::NodeContext& node);
+
 #ifdef ENABLE_WALLET
 /** Selects spendable outputs to create a transaction. */
 int64_t SelectCoins(interfaces::Wallet& iWallet, const std::string& fromAddress, wallet::CCoinControl& coinControl, int64_t amountRequired = 0);
@@ -51,7 +56,4 @@ int64_t SelectAllCoins(interfaces::Wallet& iWallet, const std::string& fromAddre
 #endif
 }
 
-bool HasWallets();
-std::vector<std::shared_ptr<wallet::CWallet>> GetWallets();
-
 #endif // BITCOIN_OMNICORE_WALLETUTILS_H
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
index 24545f9ede4ad..3b5da76551c45 100644
--- a/src/qt/overviewpage.cpp
+++ b/src/qt/overviewpage.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <cstdint>
 #include <qt/overviewpage.h>
 #include <qt/forms/ui_overviewpage.h>
 
@@ -126,7 +127,6 @@ class TxViewDelegate : public QAbstractItemDelegate
         // check pending
         {
             LOCK(cs_pending);
-
             PendingMap::iterator it = my_pending.find(hash);
             if (it != my_pending.end()) {
                 omniOverride = true;
@@ -153,74 +153,65 @@ class TxViewDelegate : public QAbstractItemDelegate
             omniAmountStr = txEntry.amount;
             omniOverride = true;
             amount = 0;
-        } else { // cache miss, check database
-            if (pDbTransactionList->exists(hash)) {
-                omniOverride = true;
-                amount = 0;
-                CTransactionRef wtx;
-                uint256 blockHash;
-                if (GetTransaction(hash, wtx, Params().GetConsensus(), blockHash)) {
-                    if (!blockHash.IsNull() || nullptr == GetBlockIndex(blockHash)) {
-                        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-                        if (nullptr != pBlockIndex) {
-                            int blockHeight = pBlockIndex->nHeight;
-                            CMPTransaction mp_obj;
-                            int parseRC = ParseTransaction(*wtx, blockHeight, 0, mp_obj);
-                            if (0 < parseRC) { //positive RC means DEx payment
-                                valid = true;
-                                std::string tmpBuyer, tmpSeller;
-                                uint64_t total = 0, tmpVout = 0, tmpNValue = 0, tmpPropertyId = 0;
-                                pDbTransactionList->getPurchaseDetails(hash,1,&tmpBuyer,&tmpSeller,&tmpVout,&tmpPropertyId,&tmpNValue);
-                                bool bIsBuy = IsMyAddress(tmpBuyer, &walletModel->wallet());
-                                int numberOfPurchases = pDbTransactionList->getNumberOfSubRecords(hash);
-                                if (0<numberOfPurchases) { // calculate total bought/sold
-                                    for(int purchaseNumber = 1; purchaseNumber <= numberOfPurchases; purchaseNumber++) {
-                                        pDbTransactionList->getPurchaseDetails(hash,purchaseNumber,&tmpBuyer,&tmpSeller,&tmpVout,&tmpPropertyId,&tmpNValue);
-                                        total += tmpNValue;
-                                    }
-                                    if (!bIsBuy) {
-                                        address = QString::fromStdString(tmpSeller);
-                                    } else {
-                                        address = QString::fromStdString(tmpBuyer);
-                                        omniOutbound = false;
-                                    }
-                                    omniAmountStr = QString::fromStdString(FormatDivisibleMP(total));
-                                }
-                            } else if (0 == parseRC) {
-                                if (mp_obj.interpret_Transaction()) {
-                                    valid = pDbTransactionList->getValidMPTX(hash);
-                                    uint32_t omniPropertyId = mp_obj.getProperty();
-                                    int64_t omniAmount = mp_obj.getAmount();
-                                    omniAmountStr = QString::fromStdString(FormatShortMP(omniPropertyId, omniAmount) + ' ' + getTokenLabel(omniPropertyId));
-                                    if (!mp_obj.getReceiver().empty()) {
-                                        if (IsMyAddress(mp_obj.getReceiver(), &walletModel->wallet())) {
-                                            omniOutbound = false;
-                                            if (IsMyAddress(mp_obj.getSender(), &walletModel->wallet())) omniSendToSelf = true;
-                                        }
-                                        address = QString::fromStdString(mp_obj.getReceiver());
-                                    } else {
-                                        address = QString::fromStdString(mp_obj.getSender());
-                                    }
-                                }
-                            }
-
-                            // override amount for cancels
-                            if (mp_obj.getType() == MSC_TYPE_METADEX_CANCEL_PRICE || mp_obj.getType() == MSC_TYPE_METADEX_CANCEL_PAIR ||
-                                mp_obj.getType() == MSC_TYPE_METADEX_CANCEL_ECOSYSTEM || mp_obj.getType() == MSC_TYPE_SEND_ALL) {
-                                omniAmountStr = QString::fromStdString("N/A");
-                            }
-
-                            // insert into cache
-                            OverviewCacheEntry newEntry;
-                            newEntry.valid = valid;
-                            newEntry.sendToSelf = omniSendToSelf;
-                            newEntry.outbound = omniOutbound;
-                            newEntry.address = address;
-                            newEntry.amount = omniAmountStr;
-                            recentCache.insert(std::make_pair(hash, newEntry));
+        } else if (pDbTransactionList->getValidMPTX(hash)) {
+            omniOverride = true;
+            amount = 0;
+            CTransactionRef wtx;
+            int blockHeight;
+            if (GetTransaction(hash, wtx, blockHeight)) {
+                CMPTransaction mp_obj;
+                CCoinsViewCacheOnly view;
+                int parseRC = ParseTransaction(view, *wtx, blockHeight, 0, mp_obj);
+                if (0 < parseRC) { //positive RC means DEx payment
+                    valid = true;
+                    std::string tmpBuyer, tmpSeller;
+                    uint64_t total = 0, tmpVout = 0, tmpNValue = 0, tmpPropertyId = 0;
+                    pDbTransactionList->getPurchaseDetails(hash,1,&tmpBuyer,&tmpSeller,&tmpVout,&tmpPropertyId,&tmpNValue);
+                    bool bIsBuy = IsMyAddress(tmpBuyer, &walletModel->wallet());
+                    int numberOfPurchases = pDbTransactionList->getNumberOfSubRecords(hash);
+                    if (0<numberOfPurchases) { // calculate total bought/sold
+                        for(int purchaseNumber = 1; purchaseNumber <= numberOfPurchases; purchaseNumber++) {
+                            pDbTransactionList->getPurchaseDetails(hash,purchaseNumber,&tmpBuyer,&tmpSeller,&tmpVout,&tmpPropertyId,&tmpNValue);
+                            total += tmpNValue;
+                        }
+                        if (!bIsBuy) {
+                            address = QString::fromStdString(tmpSeller);
+                        } else {
+                            address = QString::fromStdString(tmpBuyer);
+                            omniOutbound = false;
                         }
+                        omniAmountStr = QString::fromStdString(FormatDivisibleMP(total));
                     }
+                } else if (0 == parseRC && mp_obj.interpret_Transaction()) {
+                    valid = pDbTransactionList->getValidMPTX(hash);
+                    uint32_t omniPropertyId = mp_obj.getProperty();
+                    int64_t omniAmount = mp_obj.getAmount();
+                    omniAmountStr = QString::fromStdString(FormatShortMP(omniPropertyId, omniAmount) + ' ' + getTokenLabel(omniPropertyId));
+                    if (!mp_obj.getReceiver().empty()) {
+                        if (IsMyAddress(mp_obj.getReceiver(), &walletModel->wallet())) {
+                            omniOutbound = false;
+                            if (IsMyAddress(mp_obj.getSender(), &walletModel->wallet())) omniSendToSelf = true;
+                        }
+                        address = QString::fromStdString(mp_obj.getReceiver());
+                    } else {
+                        address = QString::fromStdString(mp_obj.getSender());
+                    }
+                }
+
+                // override amount for cancels
+                if (mp_obj.getType() == MSC_TYPE_METADEX_CANCEL_PRICE || mp_obj.getType() == MSC_TYPE_METADEX_CANCEL_PAIR ||
+                    mp_obj.getType() == MSC_TYPE_METADEX_CANCEL_ECOSYSTEM || mp_obj.getType() == MSC_TYPE_SEND_ALL) {
+                    omniAmountStr = QString::fromStdString("N/A");
                 }
+
+                // insert into cache
+                OverviewCacheEntry newEntry;
+                newEntry.valid = valid;
+                newEntry.sendToSelf = omniSendToSelf;
+                newEntry.outbound = omniOutbound;
+                newEntry.address = address;
+                newEntry.amount = omniAmountStr;
+                recentCache.insert(std::make_pair(hash, newEntry));
             }
         }
 
@@ -238,8 +229,7 @@ class TxViewDelegate : public QAbstractItemDelegate
         icon.paint(painter, decorationRect);
 
         QColor foreground = option.palette.color(QPalette::Text);
-        if(value.canConvert<QBrush>())
-        {
+        if(value.canConvert<QBrush>()) {
             QBrush brush = qvariant_cast<QBrush>(value);
             foreground = brush.color();
         }
@@ -259,16 +249,11 @@ class TxViewDelegate : public QAbstractItemDelegate
 
         painter->drawText(addressRect, Qt::AlignLeft | Qt::AlignVCenter, address, &boundingRect);
 
-        if(amount < 0)
-        {
+        if(amount < 0) {
             foreground = COLOR_NEGATIVE;
-        }
-        else if(!confirmed)
-        {
+        } else if (!confirmed) {
             foreground = COLOR_UNCONFIRMED;
-        }
-        else
-        {
+        } else {
             foreground = option.palette.color(QPalette::Text);
         }
         painter->setPen(foreground);
@@ -278,8 +263,7 @@ class TxViewDelegate : public QAbstractItemDelegate
         } else {
             amountText = omniAmountStr;
         }
-        if(!confirmed)
-        {
+        if (!confirmed) {
             amountText = QString("[") + amountText + QString("]");
         }
 
diff --git a/src/qt/tradehistorydialog.cpp b/src/qt/tradehistorydialog.cpp
index 182e314bb6b5c..a97500a93775c 100644
--- a/src/qt/tradehistorydialog.cpp
+++ b/src/qt/tradehistorydialog.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <cstdint>
 #include <qt/tradehistorydialog.h>
 #include <qt/forms/ui_tradehistorydialog.h>
 
@@ -198,8 +199,7 @@ void TradeHistoryDialog::UpdateTradeHistoryTable(bool forceUpdate)
             QTableWidgetItem *dateCell = new QTableWidgetItem;
             QDateTime txTime;
             if (objTH.blockHeight > 0) {
-                LOCK(cs_main);
-                CBlockIndex* pBlkIdx = ::ChainActive()[objTH.blockHeight];
+                auto* pBlkIdx = GetActiveChain()[objTH.blockHeight];
                 if (nullptr != pBlkIdx) txTime.setTime_t(pBlkIdx->GetBlockTime());
                 dateCell->setData(Qt::DisplayRole, txTime);
             } else {
@@ -299,19 +299,15 @@ int TradeHistoryDialog::PopulateTradeHistoryMap()
     if (walletModel)
         walletTransactions = FetchWalletOmniTransactions(walletModel->wallet(), gArgs.GetIntArg("-omniuiwalletscope", 65535L));
 
+    CCoinsViewCacheOnly view;
     // reverse iterate over (now ordered) transactions and populate history map for each one
     for (std::map<std::string,uint256>::reverse_iterator it = walletTransactions.rbegin(); it != walletTransactions.rend(); it++) {
         uint256 hash = it->second;
 
         // use levelDB to perform a fast check on whether it's a bitcoin or Omni tx and whether it's a trade
-        std::string tempStrValue;
-        if (!pDbTransactionList->getTX(hash, tempStrValue)) continue;
-
-        std::vector<std::string> vstr;
-        boost::split(vstr, tempStrValue, boost::is_any_of(":"), boost::token_compress_on);
-        if (vstr.size() > 2) {
-            if (atoi(vstr[2]) != MSC_TYPE_METADEX_TRADE) continue;
-        }
+        uint32_t type;
+        if (!pDbTransactionList->getValidMPTX(hash, nullptr, &type)) continue;
+        if (type != MSC_TYPE_METADEX_TRADE) continue;
 
         // check historyMap, if this tx exists don't waste resources doing anymore work on it
         TradeHistoryMap::iterator hIter = tradeHistoryMap.find(hash);
@@ -336,12 +332,8 @@ int TradeHistoryDialog::PopulateTradeHistoryMap()
 
         // tx not in historyMap, retrieve the transaction object
         CTransactionRef wtx;
-        uint256 blockHash;
-        if (!GetTransaction(hash, wtx, Params().GetConsensus(), blockHash)) continue;
-        if (blockHash.IsNull() || nullptr == GetBlockIndex(blockHash)) continue;
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        if (nullptr == pBlockIndex) continue;
-        int blockHeight = pBlockIndex->nHeight;
+        int blockHeight;
+        if (!GetTransaction(hash, wtx, blockHeight)) continue;
 
         // setup some variables
         CMPTransaction mp_obj;
@@ -357,7 +349,7 @@ int TradeHistoryDialog::PopulateTradeHistoryMap()
         bool valid = false;
 
         // parse the transaction
-        if (0 != ParseTransaction(*wtx, blockHeight, 0, mp_obj)) continue;
+        if (0 != ParseTransaction(view, *wtx, blockHeight, 0, mp_obj)) continue;
         if (mp_obj.interpret_Transaction()) {
             valid = pDbTransactionList->getValidMPTX(hash);
             propertyIdForSale = mp_obj.getProperty();
diff --git a/src/qt/txhistorydialog.cpp b/src/qt/txhistorydialog.cpp
index a648a75c867ff..3359893477fae 100644
--- a/src/qt/txhistorydialog.cpp
+++ b/src/qt/txhistorydialog.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <cstdint>
 #include <qt/txhistorydialog.h>
 #include <qt/forms/ui_txhistorydialog.h>
 
@@ -195,6 +196,7 @@ int TXHistoryDialog::PopulateHistoryMap()
     if (walletModel)
         walletTransactions = FetchWalletOmniTransactions(walletModel->wallet(), gArgs.GetIntArg("-omniuiwalletscope", 65535L));
 
+    CCoinsViewCacheOnly view;
     // reverse iterate over (now ordered) transactions and populate history map for each one
     for (std::map<std::string,uint256>::reverse_iterator it = walletTransactions.rbegin(); it != walletTransactions.rend(); it++) {
         uint256 txHash = it->second;
@@ -223,9 +225,9 @@ int TXHistoryDialog::PopulateHistoryMap()
         }
 
         CTransactionRef wtx;
-        uint256 blockHash;
-        if (!GetTransaction(txHash, wtx, Params().GetConsensus(), blockHash)) continue;
-        if (blockHash.IsNull() || nullptr == GetBlockIndex(blockHash)) {
+        int blockHeight;
+        if (!GetTransaction(txHash, wtx, blockHeight)) continue;
+        if (blockHeight == 0) {
             // this transaction is unconfirmed, should be one of our pending transactions
             LOCK(cs_pending);
             PendingMap::iterator pending_it = my_pending.find(txHash);
@@ -248,12 +250,8 @@ int TXHistoryDialog::PopulateHistoryMap()
             continue;
         }
 
-        // parse the transaction and setup the new history object
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
-        if (nullptr == pBlockIndex) continue;
-        int blockHeight = pBlockIndex->nHeight;
         CMPTransaction mp_obj;
-        int parseRC = ParseTransaction(*wtx, blockHeight, 0, mp_obj);
+        int parseRC = ParseTransaction(view, *wtx, blockHeight, 0, mp_obj);
         HistoryTXObject htxo;
         if (it->first.length() == 16) {
             htxo.blockHeight = atoi(it->first.substr(0,6));
@@ -403,7 +401,7 @@ void TXHistoryDialog::UpdateHistory()
                 QTableWidgetItem *dateCell = new QTableWidgetItem;
                 if (htxo.blockHeight>0) {
                     LOCK(cs_main);
-                    CBlockIndex* pBlkIdx = ::ChainActive()[htxo.blockHeight];
+                    auto* pBlkIdx = GetActiveChain()[htxo.blockHeight];
                     if (nullptr != pBlkIdx) txTime.setTime_t(pBlkIdx->GetBlockTime());
                     dateCell->setData(Qt::DisplayRole, txTime);
                 } else {
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index e72feb97cb4bb..84cebbcffe6a6 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -698,12 +698,3 @@ std::vector<std::tuple<uint8_t, uint8_t, CScript>> TaprootBuilder::GetTreeTuples
     }
     return tuples;
 }
-
-
-valtype DataVisitor::operator()(const CNoDestination& noDest) const { return valtype(); }
-valtype DataVisitor::operator()(const PKHash& hash) const { return valtype(hash.begin(), hash.end()); }
-valtype DataVisitor::operator()(const ScriptHash& scriptHash) const { return valtype(scriptHash.begin(), scriptHash.end()); }
-valtype DataVisitor::operator()(const WitnessV0ScriptHash& witnessScriptHash) const { return valtype(witnessScriptHash.begin(), witnessScriptHash.end()); }
-valtype DataVisitor::operator()(const WitnessV0KeyHash& witnessKeyHash) const { return valtype(witnessKeyHash.begin(), witnessKeyHash.end()); }
-valtype DataVisitor::operator()(const WitnessV1Taproot& witnessTaproot) const { return valtype(witnessTaproot.begin(), witnessTaproot.end()); }
-valtype DataVisitor::operator()(const WitnessUnknown&) const { return valtype(); }
diff --git a/src/script/standard.h b/src/script/standard.h
index 01497466a829f..1604581a4ce02 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -343,15 +343,4 @@ class TaprootBuilder
  */
 std::optional<std::vector<std::tuple<int, CScript, int>>> InferTaprootTree(const TaprootSpendData& spenddata, const XOnlyPubKey& output);
 
-struct DataVisitor
-{
-    std::vector<unsigned char> operator()(const CNoDestination& noDest) const;
-    std::vector<unsigned char> operator()(const PKHash& hash) const;
-    std::vector<unsigned char> operator()(const ScriptHash& scriptHash) const;
-    std::vector<unsigned char> operator()(const WitnessV0ScriptHash& witnessScriptHash) const;
-    std::vector<unsigned char> operator()(const WitnessV0KeyHash& witnessKeyHash) const;
-    std::vector<unsigned char> operator()(const WitnessV1Taproot& witnessTaproot) const;
-    std::vector<unsigned char> operator()(const WitnessUnknown& witnessUnknown) const;
-};
-
 #endif // BITCOIN_SCRIPT_STANDARD_H
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
index 097d508f04a83..b333a9f72d16c 100644
--- a/src/test/coins_tests.cpp
+++ b/src/test/coins_tests.cpp
@@ -18,7 +18,7 @@
 #include <boost/test/unit_test.hpp>
 
 int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out);
-void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight, std::shared_ptr<std::map<COutPoint, Coin>> removedCoins);
+void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight);
 
 namespace
 {
@@ -396,7 +396,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
 
             // Call UpdateCoins on the top cache
             CTxUndo undo;
-            UpdateCoins(CTransaction{tx}, *(stack.back()), undo, height, nullptr);
+            UpdateCoins(CTransaction{tx}, *(stack.back()), undo, height);
 
             // Update the utxo set for future spends
             utxoset.insert(outpoint);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 7daa465434d20..9720ecfca2b7c 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -64,9 +64,8 @@ using node::NodeContext;
 using node::RegenerateCommitments;
 using node::VerifyLoadedChainstate;
 
-extern int mastercore_init();
+extern int mastercore_init(node::NodeContext&);
 extern int mastercore_shutdown();
-extern std::optional<std::reference_wrapper<node::NodeContext>> g_context;
 
 const std::function<std::string(const char*)> G_TRANSLATION_FUN = nullptr;
 UrlDecodeFn* const URL_DECODE = nullptr;
@@ -136,9 +135,6 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     }
     SelectParams(chainName);
     SeedInsecureRand();
-#ifdef WIN32
-    fOmniCoreConsoleLog = true;
-#endif
     if (G_TEST_LOG_FUN) LogInstance().PushBackCallback(G_TEST_LOG_FUN);
     InitLogging(*m_node.args);
     AppInitParameterInteraction(*m_node.args);
@@ -159,7 +155,6 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
         noui_connect();
         noui_connected = true;
     }
-    g_context = std::ref(m_node);
 }
 
 BasicTestingSetup::~BasicTestingSetup()
@@ -227,7 +222,6 @@ ChainTestingSetup::~ChainTestingSetup()
     m_node.mempool.reset();
     m_node.scheduler.reset();
     m_node.chainman.reset();
-    g_context.reset();
 }
 
 TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const char*>& extra_args)
@@ -253,7 +247,7 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
     assert(status == node::ChainstateLoadStatus::SUCCESS);
 
     // initialize Omni after chainstate
-    mastercore_init();
+    mastercore_init(m_node);
 
     BlockValidationState state;
     if (!m_node.chainman->ActiveChainstate().ActivateBestChain(state)) {
diff --git a/src/test/validation_chainstatemanager_tests.cpp b/src/test/validation_chainstatemanager_tests.cpp
index 145f8638999ad..1459fcdb55327 100644
--- a/src/test/validation_chainstatemanager_tests.cpp
+++ b/src/test/validation_chainstatemanager_tests.cpp
@@ -20,7 +20,7 @@
 
 #include <boost/test/unit_test.hpp>
 
-extern int mastercore_init();
+extern int mastercore_init(node::NodeContext&);
 using node::SnapshotMetadata;
 
 BOOST_FIXTURE_TEST_SUITE(validation_chainstatemanager_tests, ChainTestingSetup)
@@ -76,9 +76,9 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
     // Unlike c1, which doesn't have any blocks. Gets us different tip, height.
     c2.LoadGenesisBlock();
     BlockValidationState _;
-    // call mastercore init efore ActivateBestChain
-    mastercore_init();
     BOOST_CHECK(c2.ActivateBestChain(_, nullptr));
+    // call mastercore init efore ActivateBestChain
+    mastercore_init(m_node);
 
     BOOST_CHECK(manager.IsSnapshotActive());
     BOOST_CHECK(WITH_LOCK(::cs_main, return !manager.IsSnapshotValidated()));
diff --git a/src/txdb.cpp b/src/txdb.cpp
index a787ba43521c4..e02fff3e6b98a 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -15,8 +15,6 @@
 #include <util/vector.h>
 #include <validation.h>
 
-#include <omnicore/omnicore.h>
-
 #include <stdint.h>
 
 static constexpr uint8_t DB_COIN{'C'};
@@ -61,12 +59,6 @@ bool CCoinsViewDB::NeedsUpgrade()
     return cursor->Valid();
 }
 
-static const uint8_t DB_ADDRESSINDEX = 'a';
-static const uint8_t DB_ADDRESSUNSPENTINDEX = 'u';
-static const uint8_t DB_TIMESTAMPINDEX = 'S';
-static const uint8_t DB_BLOCKHASHINDEX = 'z';
-static const uint8_t DB_SPENTINDEX = 'p';
-
 namespace {
 
 struct CoinEntry {
@@ -305,169 +297,6 @@ bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
     return true;
 }
 
-bool CBlockTreeDB::WriteAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount > >&vect) {
-    CDBBatch batch(*this);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
-        batch.Write(std::make_pair(DB_ADDRESSINDEX, it->first), it->second);
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::EraseAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount > >&vect) {
-    CDBBatch batch(*this);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
-        batch.Erase(std::make_pair(DB_ADDRESSINDEX, it->first));
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::ReadAddressIndex(uint256 addressHash, int type,
-                                    std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,
-                                    int start, int end) {
-
-    std::unique_ptr<CDBIterator> pcursor(NewIterator());
-
-    if (start > 0 && end > 0) {
-        pcursor->Seek(std::make_pair(DB_ADDRESSINDEX, CAddressIndexIteratorHeightKey(type, addressHash, start)));
-    } else {
-        pcursor->Seek(std::make_pair(DB_ADDRESSINDEX, CAddressIndexIteratorKey(type, addressHash)));
-    }
-
-    while (pcursor->Valid()) {
-        if (ShutdownRequested()) return false;
-        std::pair<uint8_t, CAddressIndexKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_ADDRESSINDEX && key.second.hashBytes == addressHash) {
-            if (end > 0 && key.second.blockHeight > end) {
-                break;
-            }
-            CAmount nValue;
-            if (pcursor->GetValue(nValue)) {
-                addressIndex.push_back(std::make_pair(key.second, nValue));
-                pcursor->Next();
-            } else {
-                return error("failed to get address index value");
-            }
-        } else {
-            break;
-        }
-    }
-
-    return true;
-}
-
-bool CBlockTreeDB::UpdateAddressUnspentIndex(const std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue > >&vect) {
-    CDBBatch batch(*this);
-    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=vect.begin(); it!=vect.end(); it++) {
-        if (it->second.IsNull()) {
-            batch.Erase(std::make_pair(DB_ADDRESSUNSPENTINDEX, it->first));
-        } else {
-            batch.Write(std::make_pair(DB_ADDRESSUNSPENTINDEX, it->first), it->second);
-        }
-    }
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::ReadAddressUnspentIndex(uint256 addressHash, int type,
-                                           std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs) {
-
-    std::unique_ptr<CDBIterator> pcursor(NewIterator());
-    pcursor->Seek(std::make_pair(DB_ADDRESSUNSPENTINDEX, CAddressIndexIteratorKey(type, addressHash)));
-
-    while (pcursor->Valid()) {
-        if (ShutdownRequested()) return false;
-        std::pair<uint8_t, CAddressUnspentKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_ADDRESSUNSPENTINDEX && key.second.hashBytes == addressHash) {
-            CAddressUnspentValue nValue;
-            if (pcursor->GetValue(nValue)) {
-                unspentOutputs.push_back(std::make_pair(key.second, nValue));
-                pcursor->Next();
-            } else {
-                return error("failed to get address unspent value");
-            }
-        } else {
-            break;
-        }
-    }
-
-    return true;
-}
-
-bool CBlockTreeDB::WriteTimestampIndex(const CTimestampIndexKey &timestampIndex) {
-    CDBBatch batch(*this);
-    batch.Write(std::make_pair(DB_TIMESTAMPINDEX, timestampIndex), 0);
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::ReadTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &hashes) {
-
-    std::unique_ptr<CDBIterator> pcursor(NewIterator());
-
-    pcursor->Seek(std::make_pair(DB_TIMESTAMPINDEX, CTimestampIndexIteratorKey(low)));
-
-    while (pcursor->Valid()) {
-        if (ShutdownRequested()) return false;
-        std::pair<uint8_t, CTimestampIndexKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_TIMESTAMPINDEX && key.second.timestamp < high) {
-            if (fActiveOnly) {
-                if (blockOnchainActive(key.second.blockHash)) {
-                    hashes.push_back(std::make_pair(key.second.blockHash, key.second.timestamp));
-                }
-            } else {
-                hashes.push_back(std::make_pair(key.second.blockHash, key.second.timestamp));
-            }
-
-            pcursor->Next();
-        } else {
-            break;
-        }
-    }
-
-    return true;
-}
-
-bool CBlockTreeDB::WriteTimestampBlockIndex(const CTimestampBlockIndexKey &blockhashIndex, const CTimestampBlockIndexValue &logicalts) {
-    CDBBatch batch(*this);
-    batch.Write(std::make_pair(DB_BLOCKHASHINDEX, blockhashIndex), logicalts);
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::ReadTimestampBlockIndex(const uint256 &hash, unsigned int &ltimestamp) {
-
-    CTimestampBlockIndexValue lts;
-    if (!Read(std::make_pair(DB_BLOCKHASHINDEX, hash), lts))
-       return false;
-
-    ltimestamp = lts.ltimestamp;
-    return true;
-}
-
-bool CBlockTreeDB::ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) {
-    return Read(std::make_pair(DB_SPENTINDEX, key), value);
-}
-
-bool CBlockTreeDB::UpdateSpentIndex(const std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> >&vect) {
-    CDBBatch batch(*this);
-    for (std::vector<std::pair<CSpentIndexKey,CSpentIndexValue> >::const_iterator it=vect.begin(); it!=vect.end(); it++) {
-        if (it->second.IsNull()) {
-            batch.Erase(std::make_pair(DB_SPENTINDEX, it->first));
-        } else {
-            batch.Write(std::make_pair(DB_SPENTINDEX, it->first), it->second);
-        }
-    }
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::blockOnchainActive(const uint256 &hash) {
-    LOCK(cs_main);
-    auto bit = ::BlockIndex().find(hash);
-
-    if (bit != ::BlockIndex().end()) {
-        if (::ChainActive().Contains(&bit->second)) {
-           return true;
-        }
-    }
-
-    return false;
-}
-
 bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex)
 {
     AssertLockHeld(::cs_main);
diff --git a/src/txdb.h b/src/txdb.h
index 29bb47b87c8d0..ce18825c4002d 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -19,13 +19,6 @@
 class CBlockFileInfo;
 class CBlockIndex;
 class uint256;
-struct CAddressIndexKey;
-struct CAddressUnspentKey;
-struct CAddressUnspentValue;
-struct CMempoolAddressDeltaKey;
-struct CTimestampIndexKey;
-struct CTimestampBlockIndexKey;
-struct CTimestampBlockIndexValue;
 
 namespace Consensus {
 struct Params;
@@ -57,6 +50,7 @@ extern RecursiveMutex cs_main;
 /** CCoinsView backed by the coin database (chainstate/) */
 class CCoinsViewDB final : public CCoinsView
 {
+    friend class COmniCoinsCache;
 protected:
     std::unique_ptr<CDBWrapper> m_db;
     fs::path m_ldb_path;
@@ -97,23 +91,6 @@ class CBlockTreeDB : public CDBWrapper
     bool ReadFlag(const std::string &name, bool &fValue);
     bool LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-
-    // Block explorer database functions
-    bool WriteAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount> > &vect);
-    bool EraseAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount> > &vect);
-    bool ReadAddressIndex(uint256 addressHash, int type,
-                        std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,
-                        int start = 0, int end = 0);
-    bool UpdateAddressUnspentIndex(const std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue > >&vect);
-    bool ReadAddressUnspentIndex(uint256 addressHash, int type,
-                                std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &vect);
-    bool WriteTimestampIndex(const CTimestampIndexKey &timestampIndex);
-    bool ReadTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &vect);
-    bool WriteTimestampBlockIndex(const CTimestampBlockIndexKey &blockhashIndex, const CTimestampBlockIndexValue &logicalts);
-    bool ReadTimestampBlockIndex(const uint256 &hash, unsigned int &logicalTS);
-    bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
-    bool UpdateSpentIndex(const std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> >&vect);
-    bool blockOnchainActive(const uint256 &hash);
 };
 
 std::optional<bilingual_str> CheckLegacyTxindex(CBlockTreeDB& block_tree_db);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 9cc539edff4b3..d03ab755460c1 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -670,8 +670,6 @@ void CTxMemPool::removeForBlock(const std::vector<CTransactionRef>& vtx, unsigne
         }
         removeConflicts(*tx);
         ClearPrioritisation(tx->GetHash());
-        removeAddressIndex(tx->GetHash());
-        removeSpentIndex(tx->GetHash());
     }
     lastRollingFeeUpdate = GetTime();
     blockSinceLastRollingFeeBump = true;
@@ -1204,159 +1202,3 @@ void CTxMemPool::SetLoadTried(bool load_tried)
     LOCK(cs);
     m_load_tried = load_tried;
 }
-
-void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewCache &view)
-{
-    LOCK(cs);
-    const CTransaction& tx = entry.GetTx();
-    std::vector<CMempoolAddressDeltaKey> inserted;
-
-    uint256 txhash = tx.GetHash();
-    for (unsigned int j = 0; j < tx.vin.size(); j++) {
-        const CTxIn input = tx.vin[j];
-        const CTxOut &prevout = view.GetOutputFor(input);
-
-        CTxDestination dest;
-        if (ExtractDestination(prevout.scriptPubKey, dest)) {
-            auto bytesID = std::visit(DataVisitor{}, dest);
-            if(bytesID.empty()) {
-                continue;
-            }
-            std::vector<unsigned char> addressBytes(32);
-            std::copy(bytesID.begin(), bytesID.end(), addressBytes.begin());
-            CMempoolAddressDeltaKey key(dest.index(), uint256(addressBytes), txhash, j, 1);
-            CMempoolAddressDelta delta(entry.GetTime().count(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
-            mapAddress.insert(std::make_pair(key, delta));
-            inserted.push_back(key);
-        }
-    }
-
-    for (unsigned int k = 0; k < tx.vout.size(); k++) {
-        const CTxOut &out = tx.vout[k];
-
-        CTxDestination dest;
-        if (ExtractDestination(out.scriptPubKey, dest)) {
-            auto bytesID = std::visit(DataVisitor{}, dest);
-            if(bytesID.empty()) {
-                continue;
-            }
-            std::vector<unsigned char> addressBytes(32);
-            std::copy(bytesID.begin(), bytesID.end(), addressBytes.begin());
-            CMempoolAddressDeltaKey key(dest.index(), uint256(addressBytes), txhash, k, 0);
-            mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime().count(), out.nValue)));
-            inserted.push_back(key);
-        }
-    }
-
-    mapAddressInserted.insert(std::make_pair(txhash, inserted));
-}
-
-bool CTxMemPool::getAddressIndex(std::vector<std::pair<uint256, int> > &addresses, std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> > &results)
-{
-    LOCK(cs);
-    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
-        addressDeltaMap::iterator ait = mapAddress.lower_bound(CMempoolAddressDeltaKey((*it).second, (*it).first));
-        while (ait != mapAddress.end() && (*ait).first.addressBytes == (*it).first && (*ait).first.type == (*it).second) {
-            results.push_back(*ait);
-            ait++;
-        }
-    }
-    return true;
-}
-
-bool CTxMemPool::removeAddressIndex(const uint256 txhash)
-{
-    LOCK(cs);
-    addressDeltaMapInserted::iterator it = mapAddressInserted.find(txhash);
-
-    if (it != mapAddressInserted.end()) {
-        std::vector<CMempoolAddressDeltaKey> keys = (*it).second;
-        for (std::vector<CMempoolAddressDeltaKey>::iterator mit = keys.begin(); mit != keys.end(); mit++) {
-            mapAddress.erase(*mit);
-        }
-        mapAddressInserted.erase(it);
-    }
-
-    return true;
-}
-
-void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCache &view)
-{
-    LOCK(cs);
-
-    const CTransaction& tx = entry.GetTx();
-    std::vector<CSpentIndexKey> inserted;
-
-    uint256 txhash = tx.GetHash();
-    for (unsigned int j = 0; j < tx.vin.size(); j++) {
-        const CTxIn input = tx.vin[j];
-        const CTxOut &prevout = view.GetOutputFor(input);
-        uint256 addressHash;
-        int addressType;
-        std::vector<unsigned char> addressBytes(32);
-
-        if (prevout.scriptPubKey.IsPayToScriptHash()) {
-            std::copy(prevout.scriptPubKey.begin() + 2, prevout.scriptPubKey.begin() + 22, addressBytes.begin());
-            addressHash = uint256(addressBytes);
-            addressType = 2;
-        } else if (prevout.scriptPubKey.IsPayToPubkeyHash()) {
-            std::copy(prevout.scriptPubKey.begin() + 3, prevout.scriptPubKey.begin() + 23, addressBytes.begin());
-            addressHash = uint256(addressBytes);
-            addressType = 1;
-        } else if (prevout.scriptPubKey.IsPayToPubkey()) {
-            std::vector<unsigned char> pubkeyBytes(prevout.scriptPubKey.begin() + 1, prevout.scriptPubKey.end()-1);
-            uint160 hashBytes = Hash160(pubkeyBytes);
-            std::copy(hashBytes.begin(), hashBytes.end(), addressBytes.begin());
-            addressHash = uint256(addressBytes);
-            addressType = 1;
-        } else if (prevout.scriptPubKey.IsPayToWitnessPubkeyHash()) {
-            std::copy(prevout.scriptPubKey.begin() + 2, prevout.scriptPubKey.end(), addressBytes.begin());
-            addressHash = uint256(addressBytes);
-            addressType = 4;
-        } else if (prevout.scriptPubKey.IsWitnessProgram(addressType, addressBytes)) {
-            addressHash = uint256(addressBytes);
-            addressType = addressType == 0 ? 3 : 5;
-        } else {
-            addressHash.SetNull();
-            addressType = 0;
-        }
-
-        CSpentIndexKey key = CSpentIndexKey(input.prevout.hash, input.prevout.n);
-        CSpentIndexValue value = CSpentIndexValue(txhash, j, -1, prevout.nValue, addressType, addressHash);
-
-        mapSpent.insert(std::make_pair(key, value));
-        inserted.push_back(key);
-    }
-
-    mapSpentInserted.insert(std::make_pair(txhash, inserted));
-}
-
-bool CTxMemPool::getSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value)
-{
-    LOCK(cs);
-    mapSpentIndex::iterator it;
-
-    it = mapSpent.find(key);
-    if (it != mapSpent.end()) {
-        value = it->second;
-        return true;
-    }
-    return false;
-}
-
-bool CTxMemPool::removeSpentIndex(const uint256 txhash)
-{
-    LOCK(cs);
-    mapSpentIndexInserted::iterator it = mapSpentInserted.find(txhash);
-
-    if (it != mapSpentInserted.end()) {
-        std::vector<CSpentIndexKey> keys = (*it).second;
-        for (std::vector<CSpentIndexKey>::iterator mit = keys.begin(); mit != keys.end(); mit++) {
-            mapSpent.erase(*mit);
-        }
-        mapSpentInserted.erase(it);
-    }
-
-    return true;
-}
-
diff --git a/src/txmempool.h b/src/txmempool.h
index 3559529389ab5..e9d3e75e9d1fe 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -73,88 +73,6 @@ struct CompareIteratorByHash {
     }
 };
 
-struct CSpentIndexKeyCompare
-{
-    bool operator()(const CSpentIndexKey& a, const CSpentIndexKey& b) const {
-        if (a.txid == b.txid) {
-            return a.outputIndex < b.outputIndex;
-        } else {
-            return a.txid < b.txid;
-        }
-    }
-};
-
-struct CMempoolAddressDelta
-{
-    int64_t time;
-    CAmount amount;
-    uint256 prevhash;
-    unsigned int prevout;
-
-    CMempoolAddressDelta(int64_t t, CAmount a, uint256 hash, unsigned int out) {
-        time = t;
-        amount = a;
-        prevhash = hash;
-        prevout = out;
-    }
-
-    CMempoolAddressDelta(int64_t t, CAmount a) {
-        time = t;
-        amount = a;
-        prevhash.SetNull();
-        prevout = 0;
-    }
-};
-
-struct CMempoolAddressDeltaKey
-{
-    int type;
-    uint256 addressBytes;
-    uint256 txhash;
-    unsigned int index;
-    int spending;
-
-    CMempoolAddressDeltaKey(int addressType, uint256 addressHash, uint256 hash, unsigned int i, int s) {
-        type = addressType;
-        addressBytes = addressHash;
-        txhash = hash;
-        index = i;
-        spending = s;
-    }
-
-    CMempoolAddressDeltaKey(int addressType, uint256 addressHash) {
-        type = addressType;
-        addressBytes = addressHash;
-        txhash.SetNull();
-        index = 0;
-        spending = 0;
-    }
-};
-
-struct CMempoolAddressDeltaKeyCompare
-{
-    bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const {
-        if (a.type == b.type) {
-            if (a.addressBytes == b.addressBytes) {
-                if (a.txhash == b.txhash) {
-                    if (a.index == b.index) {
-                        return a.spending < b.spending;
-                    } else {
-                        return a.index < b.index;
-                    }
-                } else {
-                    return a.txhash < b.txhash;
-                }
-            } else {
-                return a.addressBytes < b.addressBytes;
-            }
-        } else {
-            return a.type < b.type;
-        }
-    }
-};
-
-
 /** \class CTxMemPoolEntry
  *
  * CTxMemPoolEntry stores data about the corresponding transaction, as well
@@ -620,18 +538,6 @@ class CTxMemPool
     typedef std::map<txiter, TxLinks, CompareIteratorByHash> txlinksMap;
     txlinksMap mapLinks;
 
-    typedef std::map<CMempoolAddressDeltaKey, CMempoolAddressDelta, CMempoolAddressDeltaKeyCompare> addressDeltaMap;
-    addressDeltaMap mapAddress;
-
-    typedef std::map<uint256, std::vector<CMempoolAddressDeltaKey> > addressDeltaMapInserted;
-    addressDeltaMapInserted mapAddressInserted;
-
-    typedef std::map<CSpentIndexKey, CSpentIndexValue, CSpentIndexKeyCompare> mapSpentIndex;
-    mapSpentIndex mapSpent;
-
-    typedef std::map<uint256, std::vector<CSpentIndexKey> > mapSpentIndexInserted;
-    mapSpentIndexInserted mapSpentInserted;
-
     void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
@@ -706,15 +612,6 @@ class CTxMemPool
     void addUnchecked(const CTxMemPoolEntry& entry, bool validFeeEstimate = true) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
     void addUnchecked(const CTxMemPoolEntry& entry, setEntries& setAncestors, bool validFeeEstimate = true) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
 
-    void addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewCache &view);
-    bool getAddressIndex(std::vector<std::pair<uint256, int> > &addresses,
-                         std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> > &results);
-    bool removeAddressIndex(const uint256 txhash);
-
-    void addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCache &view);
-    bool getSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
-    bool removeSpentIndex(const uint256 txhash);
-
     void removeRecursive(const CTransaction& tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** After reorg, filter the entries that would no longer be valid in the next block, and update
      * the entries' cached LockPoints if needed.  The mempool does not have any knowledge of
diff --git a/src/validation.cpp b/src/validation.cpp
index 703291ff59397..2fbd7db57c6be 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -57,8 +57,6 @@
 #include <validationinterface.h>
 #include <warnings.h>
 
-#include <omnicore/omnicore.h>
-
 #include <algorithm>
 #include <cassert>
 #include <chrono>
@@ -128,7 +126,6 @@ std::condition_variable g_best_block_cv;
 uint256 g_best_block;
 bool g_parallel_script_checks{false};
 bool fCheckBlockIndex = false;
-bool fAddressIndex = false;
 bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;
 int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
 
@@ -1080,13 +1077,6 @@ bool MemPoolAccept::Finalize(const ATMPArgs& args, Workspace& ws)
     // transaction has not necessarily been accepted to miners' mempools.
     bool validForFeeEstimation = !bypass_limits && !args.m_package_submission && IsCurrentForFeeEstimation(m_active_chainstate) && m_pool.HasNoInputsOf(tx);
 
-    // Add memory address index
-    if (fAddressIndex)
-    {
-        m_pool.addAddressIndex(*entry, m_view);
-        m_pool.addSpentIndex(*entry, m_view);
-    }
-
     // Store transaction in memory
     m_pool.addUnchecked(*entry, ws.m_ancestors, validForFeeEstimation);
 
@@ -1204,8 +1194,6 @@ MempoolAcceptResult MemPoolAccept::AcceptSingleTransaction(const CTransactionRef
 
     GetMainSignals().TransactionAddedToMempool(ptx, m_pool.GetAndIncrementSequence());
 
-    TryToAddToMarkerCache(ptx);
-
     return MempoolAcceptResult::Success(std::move(ws.m_replaced_transactions), ws.m_vsize, ws.m_base_fees);
 }
 
@@ -1644,14 +1632,12 @@ void Chainstate::InvalidBlockFound(CBlockIndex* pindex, const BlockValidationSta
     }
 }
 
-void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight, std::shared_ptr<std::map<COutPoint, Coin>> removedCoins)
+void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight)
 {
     // mark inputs spent
     if (!tx.IsCoinBase()) {
         txundo.vprevout.reserve(tx.vin.size());
         for (const CTxIn &txin : tx.vin) {
-            if (removedCoins)
-                removedCoins->emplace(txin.prevout, inputs.AccessCoin(txin.prevout));
             txundo.vprevout.emplace_back();
             bool is_spent = inputs.SpendCoin(txin.prevout, &txundo.vprevout.back());
             assert(is_spent);
@@ -1855,9 +1841,6 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
         return DISCONNECT_FAILED;
     }
 
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
-    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > addressUnspentIndex;
-
     // undo transactions in reverse order
     for (int i = block.vtx.size() - 1; i >= 0; i--) {
         const CTransaction &tx = *(block.vtx[i]);
@@ -1877,27 +1860,6 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
             }
         }
 
-        if (!fClean && fAddressIndex) {
-
-            for (unsigned int k = tx.vout.size(); k-- > 0;) {
-                const CTxOut &out = tx.vout[k];
-
-                CTxDestination dest;
-                if (ExtractDestination(out.scriptPubKey, dest)) {
-                    auto bytesID = std::visit(DataVisitor{}, dest);
-                    if(bytesID.empty()) {
-                        continue;
-                    }
-                    std::vector<unsigned char> addressBytes(32);
-                    std::copy(bytesID.begin(), bytesID.end(), addressBytes.begin());
-                    // undo receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(dest.index(), uint256(addressBytes), pindex->nHeight, i, hash, k, false), out.nValue));
-                    // undo unspent index
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(dest.index(), uint256(addressBytes), hash, k), CAddressUnspentValue()));
-                }
-            }
-        }
-
         // restore inputs
         if (i > 0) { // not coinbases
             CTxUndo &txundo = blockUndo.vtxundo[i-1];
@@ -1911,27 +1873,6 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
                 int res = ApplyTxInUndo(std::move(txundo.vprevout[j]), view, out);
                 if (res == DISCONNECT_FAILED) return DISCONNECT_FAILED;
                 fClean = fClean && res != DISCONNECT_UNCLEAN;
-
-                const auto &undo = txundo.vprevout[j];
-                const bool isTxCoinBase = tx.IsCoinBase();
-                const CTxIn input = tx.vin[j];
-                if (!fClean && fAddressIndex) {
-                    const CTxOut &prevout = view.GetOutputFor(input);
-
-                    CTxDestination dest;
-                    if (ExtractDestination(prevout.scriptPubKey, dest)) {
-                        auto bytesID = std::visit(DataVisitor{}, dest);
-                        if(bytesID.empty()) {
-                            continue;
-                        }
-                        std::vector<unsigned char> addressBytes(32);
-                        std::copy(bytesID.begin(), bytesID.end(), addressBytes.begin());
-                        // undo spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(dest.index(), uint256(addressBytes), pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
-                        // restore unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(dest.index(), uint256(addressBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undo.nHeight, isTxCoinBase)));
-                    }
-                }
             }
             // At this point, all of txundo.vprevout should have been moved out.
         }
@@ -1940,18 +1881,6 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
     // move best block pointer to prevout block
     view.SetBestBlock(pindex->pprev->GetBlockHash());
 
-    if (!fClean && fAddressIndex) {
-        auto& pblocktree{m_blockman.m_block_tree_db};
-        if (!pblocktree->EraseAddressIndex(addressIndex)) {
-            error("Failed to delete address index");
-            return DISCONNECT_FAILED;
-        }
-        if (!pblocktree->UpdateAddressUnspentIndex(addressUnspentIndex)) {
-            error("Failed to write address unspent index");
-            return DISCONNECT_FAILED;
-        }
-    }
-
     return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
 }
 
@@ -2050,7 +1979,7 @@ static int64_t nBlocksTotal = 0;
  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
  *  can fail if those validity checks fail (among other reasons). */
 bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
-                               CCoinsViewCache& view, bool fJustCheck, std::shared_ptr<std::map<COutPoint, Coin>> removedCoins)
+                               CCoinsViewCache& view, bool fJustCheck)
 {
     AssertLockHeld(cs_main);
     assert(pindex);
@@ -2232,10 +2161,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     CBlockUndo blockundo;
 
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
-    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > addressUnspentIndex;
-    std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> > spentIndex;
-
     // Precomputed transaction data pointers must not be invalidated
     // until after `control` has run the script checks (potentially
     // in multiple threads). Preallocate the vector size so a new allocation
@@ -2283,29 +2208,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
                 LogPrintf("ERROR: %s: contains a non-BIP68-final transaction\n", __func__);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal");
             }
-
-            if (fAddressIndex)
-            {
-                for (size_t j = 0; j < tx.vin.size(); j++) {
-                    const CTxIn input = tx.vin[j];
-                    const CTxOut &prevout = view.GetOutputFor(tx.vin[j]);
-
-                    CTxDestination dest;
-                    if (ExtractDestination(prevout.scriptPubKey, dest)) {
-                        auto bytesID = std::visit(DataVisitor{}, dest);
-                        if(bytesID.empty()) {
-                            continue;
-                        }
-                        std::vector<unsigned char> addressBytes(32);
-                        std::copy(bytesID.begin(), bytesID.end(), addressBytes.begin());
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(dest.index(), uint256(addressBytes), pindex->nHeight, i, tx.GetHash(), j, true), prevout.nValue * -1));
-
-                        // remove address from unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(dest.index(), uint256(addressBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
-                        spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(tx.GetHash(), j, pindex->nHeight, prevout.nValue, dest.index(), uint256(addressBytes))));
-                    }
-                }
-            }
         }
 
         // GetTransactionSigOpCost counts 3 types of sigops:
@@ -2333,33 +2235,11 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
             control.Add(vChecks);
         }
 
-        if (fAddressIndex) {
-
-            for (unsigned int k = 0; k < tx.vout.size(); k++) {
-                const CTxOut &out = tx.vout[k];
-                const bool isTxCoinBase = tx.IsCoinBase();
-
-                CTxDestination dest;
-                if (ExtractDestination(out.scriptPubKey, dest)) {
-                    auto bytesID = std::visit(DataVisitor{}, dest);
-                    if(bytesID.empty()) {
-                        continue;
-                    }
-                    std::vector<unsigned char> addressBytes(32);
-                    std::copy(bytesID.begin(), bytesID.end(), addressBytes.begin());
-                    // record receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(dest.index(), uint256(addressBytes), pindex->nHeight, i, tx.GetHash(), k, false), out.nValue));
-                    // record unspent output
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(dest.index(), uint256(addressBytes), tx.GetHash(), k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight, isTxCoinBase)));
-                }
-            }
-        }
-
         CTxUndo undoDummy;
         if (i > 0) {
             blockundo.vtxundo.push_back(CTxUndo());
         }
-        UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight, removedCoins);
+        UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
     }
     int64_t nTime3 = GetTimeMicros(); nTimeConnect += nTime3 - nTime2;
     LogPrint(BCLog::BENCH, "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(), MILLI * (nTime3 - nTime2), MILLI * (nTime3 - nTime2) / block.vtx.size(), nInputs <= 1 ? 0 : MILLI * (nTime3 - nTime2) / (nInputs-1), nTimeConnect * MICRO, nTimeConnect * MILLI / nBlocksTotal);
@@ -2392,38 +2272,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         m_blockman.m_dirty_blockindex.insert(pindex);
     }
 
-    if (fAddressIndex) {
-        auto& pblocktree{m_blockman.m_block_tree_db};
-        if (!pblocktree->WriteAddressIndex(addressIndex)) {
-            return AbortNode(state, "Failed to write address index");
-        }
-        if (!pblocktree->UpdateAddressUnspentIndex(addressUnspentIndex)) {
-            return AbortNode(state, "Failed to write address unspent index");
-        }
-
-        if (!pblocktree->UpdateSpentIndex(spentIndex))
-            return AbortNode(state, "Failed to write transaction index");
-
-        unsigned int logicalTS = pindex->nTime;
-        unsigned int prevLogicalTS = 0;
-
-        // retrieve logical timestamp of the previous block
-        if (pindex->pprev)
-            if (!pblocktree->ReadTimestampBlockIndex(pindex->pprev->GetBlockHash(), prevLogicalTS))
-                LogPrintf("%s: Failed to read previous block's logical timestamp\n", __func__);
-
-        if (logicalTS <= prevLogicalTS) {
-            logicalTS = prevLogicalTS + 1;
-            LogPrintf("%s: Previous logical timestamp is newer Actual[%d] prevLogical[%d] Logical[%d]\n", __func__, pindex->nTime, prevLogicalTS, logicalTS);
-        }
-
-        if (!pblocktree->WriteTimestampIndex(CTimestampIndexKey(logicalTS, pindex->GetBlockHash())))
-            return AbortNode(state, "Failed to write timestamp index");
-
-        if (!pblocktree->WriteTimestampBlockIndex(CTimestampBlockIndexKey(pindex->GetBlockHash()), CTimestampBlockIndexValue(logicalTS)))
-            return AbortNode(state, "Failed to write blockhash index");
-    }
-
     // add this block to the view's block chain
     view.SetBestBlock(pindex->GetBlockHash());
 
@@ -2787,21 +2635,10 @@ bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTra
 
     UpdateTip(pindexDelete->pprev);
 
-    //! Omni Core: begin block disconnect notification
-    LogPrint(BCLog::HANDLER, "Omni Core handler: block disconnect begin [height: %d, reindex: %d]\n", ::ChainActive().Height(), (int)fReindex);
-    mastercore_handler_disc_begin(pindexDelete->nHeight);
-
     // Let wallets know transactions went from 1-confirmed to
     // 0-confirmed or conflicted:
     GetMainSignals().BlockDisconnected(pblock, pindexDelete);
 
-    for (const CTransactionRef& ptx : pblock->vtx) {
-        TryToAddToMarkerCache(ptx);
-    }
-
-    //! Omni Core: end of block disconnect notification
-    LogPrint(BCLog::HANDLER, "Omni Core handler: block disconnect end [height: %d, reindex: %d]\n", ::ChainActive().Height(), (int)fReindex);
-
     return true;
 }
 
@@ -2877,15 +2714,13 @@ bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew,
         pthisBlock = pblock;
     }
     const CBlock& blockConnecting = *pthisBlock;
-    // Map used by Omni to track removals from the UTXO DB for this block.
-    std::shared_ptr<std::map<COutPoint, Coin>> removedCoins = std::make_shared<std::map<COutPoint, Coin>>();
     // Apply the block atomically to the chain state.
     int64_t nTime2 = GetTimeMicros(); nTimeReadFromDiskTotal += nTime2 - nTime1;
     int64_t nTime3;
     LogPrint(BCLog::BENCH, "  - Load block from disk: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime2 - nTime1) * MILLI, nTimeReadFromDiskTotal * MICRO, nTimeReadFromDiskTotal * MILLI / nBlocksTotal);
     {
         CCoinsViewCache view(&CoinsTip());
-        bool rv = ConnectBlock(blockConnecting, state, pindexNew, view, false, removedCoins);
+        bool rv = ConnectBlock(blockConnecting, state, pindexNew, view, false);
         GetMainSignals().BlockChecked(blockConnecting, state);
         if (!rv) {
             if (state.IsInvalid())
@@ -2907,11 +2742,6 @@ bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew,
     int64_t nTime5 = GetTimeMicros(); nTimeChainState += nTime5 - nTime4;
     LogPrint(BCLog::BENCH, "  - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime5 - nTime4) * MILLI, nTimeChainState * MICRO, nTimeChainState * MILLI / nBlocksTotal);
 
-    //! Omni Core: begin block connect notification
-    const auto height = m_chain.Height();
-    LogPrint(BCLog::HANDLER, "Omni Core handler: block connect begin [height: %d]\n", height);
-    mastercore_handler_block_begin(height, pindexNew);
-
     // Remove conflicting transactions from the mempool.;
     if (m_mempool) {
         m_mempool->removeForBlock(blockConnecting.vtx, pindexNew->nHeight);
@@ -2925,22 +2755,6 @@ bool Chainstate::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew,
     LogPrint(BCLog::BENCH, "  - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime6 - nTime5) * MILLI, nTimePostConnect * MICRO, nTimePostConnect * MILLI / nBlocksTotal);
     LogPrint(BCLog::BENCH, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime6 - nTime1) * MILLI, nTimeTotal * MICRO, nTimeTotal * MILLI / nBlocksTotal);
 
-    //! Omni Core: transaction position within the block
-    unsigned int nTxIdx = 0;
-
-    //! Omni Core: number of meta transactions found
-    unsigned int nNumMetaTxs = 0;
-
-    for (size_t i = 0; i < blockConnecting.vtx.size(); i++) {
-        //! Omni Core: new confirmed transaction notification
-        LogPrint(BCLog::HANDLER, "Omni Core handler: new confirmed transaction [height: %d, idx: %u]\n", pindexNew->nHeight, nTxIdx);
-        if (mastercore_handler_tx(*blockConnecting.vtx[i], pindexNew->nHeight, nTxIdx++, pindexNew, removedCoins)) ++nNumMetaTxs;
-    }
-
-    //! Omni Core: end of block connect notification
-    LogPrint(BCLog::HANDLER, "Omni Core handler: block connect end [new height: %d, found: %u txs]\n", pindexNew->nHeight, nNumMetaTxs);
-    mastercore_handler_block_end(pindexNew->nHeight, pindexNew, nNumMetaTxs);
-
     connectTrace.BlockConnected(pindexNew, std::move(pthisBlock));
     return true;
 }
@@ -3212,9 +3026,6 @@ bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<
                 for (const PerBlockConnectTrace& trace : connectTrace.GetBlocksConnected()) {
                     assert(trace.pblock && trace.pindex);
                     GetMainSignals().BlockConnected(trace.pblock, trace.pindex);
-                    for (size_t i = 0; i < trace.pblock->vtx.size(); i++) {
-                        RemoveFromMarkerCache(trace.pblock->vtx[i]->GetHash());
-                    }
                 }
             } while (!m_chain.Tip() || (starting_tip && CBlockIndexWorkComparator()(m_chain.Tip(), starting_tip)));
             if (!blocks_connected) return true;
@@ -4464,19 +4275,6 @@ bool ChainstateManager::LoadBlockIndex()
         needs_init = m_blockman.m_block_index.empty();
     }
 
-    if (needs_init) {
-        // Everything here is for *new* reindex/DBs. Thus, though
-        // LoadBlockIndexDB may have set fReindex if we shut down
-        // mid-reindex previously, we don't check fReindex and
-        // instead only check it prior to LoadBlockIndexDB to set
-        // needs_init.
-
-        LogPrintf("Initializing databases...\n");
-
-        fAddressIndex = gArgs.GetBoolArg("-experimental-btc-balances", DEFAULT_ADDRINDEX);
-        auto& pblocktree{m_blockman.m_block_tree_db};
-        pblocktree->WriteFlag("addressindex", fAddressIndex);
-    }
     return true;
 }
 
@@ -5215,9 +5013,6 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
 
     snapshot_chainstate.m_chain.SetTip(*snapshot_start_block);
 
-    // invalidate all blocks above current best one
-    mastercore_handler_disc_begin(snapshot_start_block->nHeight + 1);
-
     // The remainder of this function requires modifying data protected by cs_main.
     LOCK(::cs_main);
 
diff --git a/src/validation.h b/src/validation.h
index 2667d30e49116..a8af7fba9fd67 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -66,7 +66,7 @@ static const int MAX_SCRIPTCHECK_THREADS = 15;
 static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
 static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
 static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
-static const bool DEFAULT_TXINDEX = true;
+static const bool DEFAULT_TXINDEX = false;
 static const bool DEFAULT_ADDRINDEX = false;
 static constexpr bool DEFAULT_COINSTATSINDEX{false};
 static const char* const DEFAULT_BLOCKFILTERINDEX = "0";
@@ -104,7 +104,6 @@ extern uint256 g_best_block;
 extern bool g_parallel_script_checks;
 extern bool fCheckBlockIndex;
 extern bool fCheckpointsEnabled;
-extern bool fAddressIndex;
 /** If the tip is older than this (in seconds), the node is considered to be in initial block download. */
 extern int64_t nMaxTipAge;
 
@@ -665,7 +664,7 @@ class Chainstate
     DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
     bool ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
-                      CCoinsViewCache& view, bool fJustCheck = false, std::shared_ptr<std::map<COutPoint, Coin>> removedCoins = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+                      CCoinsViewCache& view, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Apply the effects of a block disconnection on the UTXO set.
     bool DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
diff --git a/test/functional/omni_calculate_fee.py b/test/functional/omni_calculate_fee.py
index 060b1fe61b815..5e3acdd61fadf 100755
--- a/test/functional/omni_calculate_fee.py
+++ b/test/functional/omni_calculate_fee.py
@@ -11,7 +11,7 @@ class OmniFeeCalculation(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
-        self.extra_args = [[], ["-omnidebug=all", "-paytxfee=0.00003"]] # 3,000 Sats per KB
+        self.extra_args = [[], ["-omnidebug=all", "-paytxfee=0.00003", "-txindex"]] # 3,000 Sats per KB
 
     def run_test(self):
         self.log.info("test fee calculation")
diff --git a/test/functional/omni_clientexpiry.py b/test/functional/omni_clientexpiry.py
index a480c4a3125d4..0de9dfb5a75fb 100755
--- a/test/functional/omni_clientexpiry.py
+++ b/test/functional/omni_clientexpiry.py
@@ -5,7 +5,7 @@
 """Test client expiry."""
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_raises_rpc_error
+from test_framework.util import assert_raises
 
 class OmniClientExpiry(BitcoinTestFramework):
     def set_test_params(self):
@@ -31,8 +31,9 @@ def run_test(self):
         # Sending an alert with client expiry version of 999999999
         self.nodes[0].omni_sendalert(address, 3, 999999999, "Client version out of date test.")
 
+        self.options.noshutdown = True
         # Generating a block should make the client shutdown
-        assert_raises_rpc_error(-1, "MP_persist", self.generatetoaddress, self.nodes[0], 10, coinbase_address)
+        assert_raises(ConnectionRefusedError, self.generatetoaddress, self.nodes[0], 10, coinbase_address)
 
 if __name__ == '__main__':
     # We expect the client to shutdown during this test, this will raise an AssertionError, if no
diff --git a/test/functional/omni_feecache.py b/test/functional/omni_feecache.py
index b8b0eb34fa2d4..3df51459f6482 100755
--- a/test/functional/omni_feecache.py
+++ b/test/functional/omni_feecache.py
@@ -386,6 +386,11 @@ def run_test(self):
         result = node.omni_getbalance(address, 6)
         assert_equal(result['balance'], "9999.95000000")
 
+        result = node.omni_getfeecache(3)
+        assert_equal(result[0]['cachedfees'], "6")
+        result = node.omni_getfeecache(6)
+        assert_equal(result[0]['cachedfees'], "0.00000000")
+
         # Rolling back the chain to test ability to roll back a distribution during reorg (disconnecting 1 block from tip and mining a replacement)
         block = node.getblockcount()
         blockhash = node.getblockhash(block)
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index e92309487b1f7..55d70a242ddf9 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -813,6 +813,8 @@ def cache_path(*paths):
             os.rmdir(cache_path('wallets'))  # Remove empty wallets dir
 
             # Remove Omni specific dirs
+            shutil.rmtree(cache_path('OMNI_addressindex'))
+            shutil.rmtree(cache_path('OMNI_coinscache'))
             shutil.rmtree(cache_path('OMNI_feecache'))
             shutil.rmtree(cache_path('OMNI_feehistory'))
             shutil.rmtree(cache_path('Omni_TXDB'))
@@ -822,7 +824,6 @@ def cache_path(*paths):
             shutil.rmtree(cache_path('MP_stolist'))
             shutil.rmtree(cache_path('MP_tradelist'))
             shutil.rmtree(cache_path('MP_txlist'))
-            shutil.rmtree(cache_path('indexes')) # for txindex enabled by default in Omni
 
             for entry in os.listdir(cache_path()):
                 if entry not in ['chainstate', 'blocks']:  # Only keep chainstate and blocks folder
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 28f29018f1bc4..03b53e4651c3d 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -23,49 +23,59 @@
     "wallet/wallet -> wallet/walletdb -> wallet/wallet",
     "kernel/coinstats -> validation -> kernel/coinstats",
     "kernel/mempool_persist -> validation -> kernel/mempool_persist",
+    "index/base -> node/context -> net_processing -> index/blockfilterindex -> index/base",
+    "txdb -> validation -> txdb",
 
     # omnicore
+    "omnicore/activation -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/activation",
+    "omnicore/consensushash -> omnicore/dbspinfo -> omnicore/omnicore -> omnicore/consensushash",
+    "omnicore/consensushash -> omnicore/dex -> omnicore/rules -> omnicore/consensushash",
+    "omnicore/consensushash -> omnicore/mdex -> omnicore/dbfees -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/consensushash",
+    "omnicore/dbaddress -> omnicore/errors -> omnicore/omnicore -> omnicore/dbaddress",
+    "omnicore/dbaddress -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dbaddress",
+    "omnicore/dbfees -> omnicore/sto -> omnicore/omnicore -> omnicore/dbfees",
+    "omnicore/dbfees -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dbfees",
     "omnicore/dbspinfo -> omnicore/omnicore -> omnicore/dbspinfo",
+    "omnicore/dbspinfo -> omnicore/omnicore -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dbspinfo",
+    "omnicore/dbspinfo -> omnicore/omnicore -> omnicore/sp -> omnicore/dbspinfo",
+    "omnicore/dbspinfo -> omnicore/omnicore -> omnicore/tx -> omnicore/dbspinfo",
+    "omnicore/dbstolist -> omnicore/walletutils -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dbstolist",
+    "omnicore/dbtradelist -> omnicore/dbtransaction -> omnicore/errors -> omnicore/omnicore -> omnicore/dbtradelist",
     "omnicore/dbtradelist -> omnicore/mdex -> omnicore/dbtradelist",
+    "omnicore/dbtradelist -> omnicore/mdex -> omnicore/tx -> omnicore/dbtradelist",
+    "omnicore/dbtradelist -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dbtradelist",
+    "omnicore/dbtransaction -> omnicore/errors -> omnicore/omnicore -> omnicore/dbtransaction",
+    "omnicore/dbtransaction -> omnicore/errors -> omnicore/omnicore -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dbtransaction",
+    "omnicore/dbtxlist -> omnicore/dex -> omnicore/rules -> omnicore/dbtxlist",
+    "omnicore/dbtxlist -> omnicore/omnicore -> omnicore/mdex -> omnicore/dbtxlist",
     "omnicore/dbtxlist -> omnicore/dex -> omnicore/dbtxlist",
     "omnicore/dbtxlist -> omnicore/omnicore -> omnicore/dbtxlist",
     "omnicore/dbtxlist -> omnicore/tx -> omnicore/dbtxlist",
+    "omnicore/dbtxlist -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dbtxlist",
     "omnicore/dex -> omnicore/omnicore -> omnicore/dex",
+    "omnicore/dex -> omnicore/omnicore -> omnicore/persistence -> omnicore/dex",
+    "omnicore/dex -> omnicore/omnicore -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/dex",
     "omnicore/dex -> omnicore/tx -> omnicore/dex",
+    "omnicore/errors -> omnicore/omnicore -> omnicore/errors",
     "omnicore/mdex -> omnicore/tx -> omnicore/mdex",
+    "omnicore/mempool -> omnicore/omnicore -> omnicore/mempool",
+    "omnicore/mempool -> omnicore/omnicore -> omnicore/pending -> omnicore/mempool",
+    "omnicore/mempool -> omnicore/omnicore -> omnicore/walletutils -> omnicore/mempool",
+    "omnicore/mempool -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/mempool",
+    "omnicore/nftdb -> omnicore/omnicore -> omnicore/tx -> omnicore/nftdb",
+    "omnicore/notifications -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/notifications",
     "omnicore/omnicore -> omnicore/rules -> omnicore/omnicore",
     "omnicore/omnicore -> omnicore/script -> omnicore/omnicore",
     "omnicore/omnicore -> omnicore/sp -> omnicore/omnicore",
     "omnicore/omnicore -> omnicore/tally -> omnicore/omnicore",
     "omnicore/omnicore -> omnicore/tx -> omnicore/omnicore",
+    "omnicore/omnicore -> omnicore/tx -> omnicore/sto -> omnicore/omnicore",
     "omnicore/omnicore -> omnicore/utilsbitcoin -> omnicore/omnicore",
+    "omnicore/omnicore -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/omnicore",
     "omnicore/omnicore -> omnicore/walletutils -> omnicore/omnicore",
-    "omnicore/omnicore -> validation -> omnicore/omnicore",
-    "txdb -> validation -> txdb",
-    "init -> txdb -> omnicore/omnicore -> init",
-    "node/blockstorage -> txdb -> omnicore/omnicore -> node/blockstorage",
-    "omnicore/consensushash -> omnicore/dbspinfo -> omnicore/omnicore -> omnicore/consensushash",
-    "omnicore/consensushash -> omnicore/dex -> omnicore/rules -> omnicore/consensushash",
-    "omnicore/dbfees -> omnicore/sto -> omnicore/omnicore -> omnicore/dbfees",
-    "omnicore/dbspinfo -> omnicore/omnicore -> omnicore/sp -> omnicore/dbspinfo",
-    "omnicore/dbspinfo -> omnicore/omnicore -> omnicore/tx -> omnicore/dbspinfo",
-    "omnicore/dbtradelist -> omnicore/mdex -> omnicore/tx -> omnicore/dbtradelist",
-    "omnicore/dbtransaction -> omnicore/errors -> omnicore/omnicore -> omnicore/dbtransaction",
-    "omnicore/dbtxlist -> omnicore/omnicore -> omnicore/mdex -> omnicore/dbtxlist",
-    "omnicore/dbtxlist -> omnicore/dex -> omnicore/rules -> omnicore/dbtxlist",
-    "omnicore/dex -> omnicore/omnicore -> omnicore/persistence -> omnicore/dex",
-    "omnicore/nftdb -> omnicore/omnicore -> omnicore/tx -> omnicore/nftdb",
-    "omnicore/omnicore -> omnicore/tx -> omnicore/sto -> omnicore/omnicore",
-    "index/base -> node/context -> net_processing -> index/blockfilterindex -> index/base",
-    "index/txindex -> node/blockstorage -> txdb -> omnicore/omnicore -> index/txindex",
-    "init -> txdb -> omnicore/omnicore -> omnicore/walletutils -> init",
-    "net_processing -> node/blockstorage -> txdb -> omnicore/omnicore -> node/context -> net_processing",
-    "node/blockstorage -> txdb -> omnicore/omnicore -> wallet/wallet -> psbt -> node/transaction -> node/blockstorage",
-    "index/txindex -> node/blockstorage -> txdb -> omnicore/omnicore -> wallet/wallet -> psbt -> node/transaction -> index/txindex",
-    "net_processing -> node/blockstorage -> txdb -> omnicore/omnicore -> wallet/wallet -> psbt -> node/transaction -> net_processing",
-
-    # Temporary, removed in followup https://github.com/bitcoin/bitcoin/pull/24230
-    "index/base -> node/context -> net_processing -> index/blockfilterindex -> index/base",
+    "omnicore/rules -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/rules",
+    "omnicore/tx -> omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/tx",
+    "omnicore/utilsbitcoin -> omnicore/validationinterface -> omnicore/utilsbitcoin",
 )
 
 CODE_DIR = "src"
@@ -98,7 +108,7 @@ def main():
         if dependency not in EXPECTED_CIRCULAR_DEPENDENCIES:
             exit_code = 1
             print(
-                f'A new circular dependency in the form of "{dependency}" appears to have been introduced.\n',
+                f'A new circular dependency in the form of "{dependency}",\n',
                 file=sys.stderr,
             )