diff --git a/.gitignore b/.gitignore
index 8c13e82b2289..efa7ab526448 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,6 +13,7 @@ src/dash-gui
 src/dash-node
 src/dash-tx
 src/dash-util
+src/dash-chainstate
 src/dash-wallet
 src/test/fuzz/fuzz
 src/test/test_dash
diff --git a/ci/dash/matrix.sh b/ci/dash/matrix.sh
index 6e249fc476d1..de01eaf6d6c7 100755
--- a/ci/dash/matrix.sh
+++ b/ci/dash/matrix.sh
@@ -27,7 +27,7 @@ elif [ "$BUILD_TARGET" = "linux64_fuzz" ]; then
 elif [ "$BUILD_TARGET" = "linux64_multiprocess" ]; then
   source ./ci/test/00_setup_env_native_multiprocess.sh
 elif [ "$BUILD_TARGET" = "linux64_nowallet" ]; then
-  source ./ci/test/00_setup_env_native_nowallet.sh
+  source ./ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
 elif [ "$BUILD_TARGET" = "linux64_sqlite" ]; then
   source ./ci/test/00_setup_env_native_sqlite.sh
 elif [ "$BUILD_TARGET" = "linux64_tsan" ]; then
diff --git a/ci/test/00_setup_env_native_nowallet.sh b/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
similarity index 81%
rename from ci/test/00_setup_env_native_nowallet.sh
rename to ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
index 3e083c3d4d62..ef228c677fef 100755
--- a/ci/test/00_setup_env_native_nowallet.sh
+++ b/ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
@@ -6,9 +6,9 @@
 
 export LC_ALL=C.UTF-8
 
-export CONTAINER_NAME=ci_native_nowallet
+export CONTAINER_NAME=ci_native_nowallet_libbitcoinkernel
 export HOST=x86_64-pc-linux-gnu
 export PACKAGES="python3-zmq"
 export DEP_OPTS="NO_WALLET=1 CC=gcc-14 CXX=g++-14"
 export GOAL="install"
-export BITCOIN_CONFIG="--enable-reduce-exports CC=gcc-14 CXX=g++-14"
+export BITCOIN_CONFIG="--enable-reduce-exports CC=gcc-14 CXX=g++-14 --enable-experimental-util-chainstate"
diff --git a/configure.ac b/configure.ac
index 31951e1f7c47..371000a95312 100644
--- a/configure.ac
+++ b/configure.ac
@@ -35,6 +35,7 @@ BITCOIN_TEST_NAME=test_dash
 BITCOIN_CLI_NAME=dash-cli
 BITCOIN_TX_NAME=dash-tx
 BITCOIN_UTIL_NAME=dash-util
+BITCOIN_CHAINSTATE_NAME=dash-chainstate
 BITCOIN_WALLET_TOOL_NAME=dash-wallet
 dnl Multi Process
 BITCOIN_MP_NODE_NAME=dash-node
@@ -769,6 +770,13 @@ AC_ARG_ENABLE([util-util],
   [build_bitcoin_util=$enableval],
   [build_bitcoin_util=$build_bitcoin_utils])
 
+AC_ARG_ENABLE([experimental-util-chainstate],
+  [AS_HELP_STRING([--enable-experimental-util-chainstate],
+  [build experimental dash-chainstate executable (default=no)])],
+  [build_bitcoin_chainstate=$enableval],
+  [build_bitcoin_chainstate=no])
+
+
 AC_ARG_WITH([libs],
   [AS_HELP_STRING([--with-libs],
   [build libraries (default=yes)])],
@@ -1443,6 +1451,7 @@ if test "$enable_fuzz" = "yes"; then
   build_bitcoin_cli=no
   build_bitcoin_tx=no
   build_bitcoin_util=no
+  build_bitcoin_chainstate=no
   build_bitcoin_wallet=no
   build_bitcoind=no
   build_bitcoin_libs=no
@@ -1781,6 +1790,10 @@ AC_MSG_CHECKING([whether to build dash-util])
 AM_CONDITIONAL([BUILD_BITCOIN_UTIL], [test $build_bitcoin_util = "yes"])
 AC_MSG_RESULT($build_bitcoin_util)
 
+AC_MSG_CHECKING([whether to build experimental dash-chainstate])
+AM_CONDITIONAL([BUILD_BITCOIN_CHAINSTATE], [test $build_bitcoin_chainstate = "yes"])
+AC_MSG_RESULT($build_bitcoin_chainstate)
+
 AC_MSG_CHECKING([whether to build libraries])
 AM_CONDITIONAL([BUILD_BITCOIN_LIBS], [test $build_bitcoin_libs = "yes"])
 if test "$build_bitcoin_libs" = "yes"; then
@@ -1995,6 +2008,7 @@ AC_SUBST(BITCOIN_TEST_NAME)
 AC_SUBST(BITCOIN_CLI_NAME)
 AC_SUBST(BITCOIN_TX_NAME)
 AC_SUBST(BITCOIN_UTIL_NAME)
+AC_SUBST(BITCOIN_CHAINSTATE_NAME)
 AC_SUBST(BITCOIN_WALLET_TOOL_NAME)
 AC_SUBST(BITCOIN_MP_NODE_NAME)
 AC_SUBST(BITCOIN_MP_GUI_NAME)
diff --git a/src/Makefile.am b/src/Makefile.am
index a36f08be79c5..e11917845b35 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -148,6 +148,10 @@ if BUILD_BITCOIN_UTIL
   bin_PROGRAMS += dash-util
 endif
 
+if BUILD_BITCOIN_CHAINSTATE
+  bin_PROGRAMS += dash-chainstate
+endif
+
 .PHONY: FORCE check-symbols check-security
 # dash core #
 BITCOIN_CORE_H = \
@@ -1157,6 +1161,163 @@ dash_util_LDADD = \
   $(BACKTRACE_LIBS)
 
 dash_util_LDADD += $(BOOST_LIBS)
+
+# dash-chainstate binary #
+dash_chainstate_SOURCES = \
+  bitcoin-chainstate.cpp \
+  addressindex.cpp \
+  arith_uint256.cpp \
+  base58.cpp \
+  batchedlogger.cpp \
+  blockfilter.cpp \
+  bls/bls.cpp \
+  bls/bls_worker.cpp \
+  chain.cpp \
+  chainparamsbase.cpp \
+  chainparams.cpp \
+  clientversion.cpp \
+  coins.cpp \
+  compressor.cpp \
+  chainlock/clsig.cpp \
+  chainlock/chainlock.cpp \
+  consensus/merkle.cpp \
+  consensus/tx_check.cpp \
+  consensus/tx_verify.cpp \
+  common/bloom.cpp \
+  core_read.cpp \
+  dbwrapper.cpp \
+  deploymentinfo.cpp \
+  deploymentstatus.cpp \
+  evo/assetlocktx.cpp \
+  evo/cbtx.cpp \
+  evo/creditpool.cpp \
+  evo/chainhelper.cpp \
+  evo/deterministicmns.cpp \
+  evo/dmnstate.cpp \
+  evo/evodb.cpp \
+  evo/netinfo.cpp \
+  evo/mnhftx.cpp \
+  evo/providertx.cpp \
+  evo/simplifiedmns.cpp \
+  evo/smldiff.cpp \
+  evo/specialtx.cpp \
+  evo/specialtx_filter.cpp \
+  evo/specialtxman.cpp \
+  flatfile.cpp \
+  fs.cpp \
+  governance/classes.cpp \
+  governance/common.cpp \
+  governance/exceptions.cpp \
+  governance/governance.cpp \
+  governance/object.cpp \
+  governance/validators.cpp \
+  governance/vote.cpp \
+  governance/votedb.cpp \
+  gsl/assert.cpp \
+  hash.cpp \
+  index/base.cpp \
+  index/blockfilterindex.cpp \
+  index/coinstatsindex.cpp \
+  index/txindex.cpp \
+  instantsend/db.cpp \
+  instantsend/instantsend.cpp \
+  init/common.cpp \
+  key.cpp \
+  key_io.cpp \
+  llmq/blockprocessor.cpp \
+  llmq/commitment.cpp \
+  llmq/context.cpp \
+  llmq/debug.cpp \
+  llmq/dkgsession.cpp \
+  llmq/dkgsessionhandler.cpp \
+  llmq/dkgsessionmgr.cpp \
+  llmq/options.cpp \
+  llmq/quorums.cpp \
+  llmq/quorumsman.cpp \
+  llmq/signhash.cpp \
+  llmq/signing.cpp \
+  llmq/snapshot.cpp \
+  llmq/utils.cpp \
+  logging.cpp \
+  netaddress.cpp \
+  netbase.cpp \
+  node/blockstorage.cpp \
+  node/chainstate.cpp \
+  node/transaction.cpp \
+  kernel/coinstats.cpp \
+  masternode/meta.cpp \
+  masternode/payments.cpp \
+  masternode/sync.cpp \
+  messagesigner.cpp \
+  merkleblock.cpp \
+  node/interface_ui.cpp \
+  policy/feerate.cpp \
+  policy/fees.cpp \
+  policy/packages.cpp \
+  policy/policy.cpp \
+  policy/settings.cpp \
+  pow.cpp \
+  protocol.cpp \
+  primitives/block.cpp \
+  primitives/transaction.cpp \
+  pubkey.cpp \
+  random.cpp \
+  randomenv.cpp \
+  saltedhasher.cpp \
+  scheduler.cpp \
+  script/interpreter.cpp \
+  script/script.cpp \
+  script/script_error.cpp \
+  script/sigcache.cpp \
+  script/standard.cpp \
+  spork.cpp \
+  shutdown.cpp \
+  support/cleanse.cpp \
+  support/lockedpool.cpp \
+  sync.cpp \
+  timedata.cpp \
+  txdb.cpp \
+  txmempool.cpp \
+  uint256.cpp \
+  util/asmap.cpp \
+  util/bytevectorhash.cpp \
+  util/check.cpp \
+  util/getuniquepath.cpp \
+  util/hasher.cpp \
+  util/message.cpp \
+  util/moneystr.cpp \
+  util/ranges_set.cpp \
+  util/serfloat.cpp \
+  util/settings.cpp \
+  util/sock.cpp \
+  util/string.cpp \
+  util/strencodings.cpp \
+  util/syserror.cpp \
+  util/system.cpp \
+  util/thread.cpp \
+  util/threadinterrupt.cpp \
+  util/threadnames.cpp \
+  util/time.cpp \
+  util/tokenpipe.cpp \
+  validation.cpp \
+  validationinterface.cpp \
+  versionbits.cpp \
+  warnings.cpp
+dash_chainstate_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+dash_chainstate_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+dash_chainstate_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) $(PTHREAD_FLAGS)
+dash_chainstate_LDADD = \
+  $(LIBBITCOIN_CRYPTO) \
+  $(LIBUNIVALUE) \
+  $(LIBSECP256K1) \
+  $(LIBDASHBLS) \
+  $(LIBLEVELDB) \
+  $(LIBLEVELDB_SSE42) \
+  $(LIBMEMENV)
+
+# Required for obj/build.h to be generated first.
+# More details: https://www.gnu.org/software/automake/manual/html_node/Built-Sources-Example.html
+bitcoin_chainstate-clientversion.$(OBJEXT): obj/build.h
 #
 
 # dashconsensus library #
diff --git a/src/active/context.cpp b/src/active/context.cpp
index 831a1b4ccc67..bca4df5a8316 100644
--- a/src/active/context.cpp
+++ b/src/active/context.cpp
@@ -32,7 +32,6 @@ ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman
                              const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
                              const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
                              bool quorums_recovery, bool quorums_watch) :
-    m_isman{isman},
     m_qman{qman},
     nodeman{std::make_unique<CActiveMasternodeManager>(connman, dmnman, operator_sk)},
     dkgdbgman{std::make_unique<llmq::CDKGDebugManager>(dmnman, qsnapman, chainman)},
@@ -53,14 +52,12 @@ ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman
                                                                qblockman, qsnapman, *nodeman, chainman, sporkman,
                                                                llmq_params, quorums_watch, quorum_idx);
     });
-    m_isman.ConnectSigner(is_signer.get());
     m_qman.ConnectManagers(qman_handler.get(), qdkgsman.get());
 }
 
 ActiveContext::~ActiveContext()
 {
     m_qman.DisconnectManagers();
-    m_isman.DisconnectSigner();
 }
 
 void ActiveContext::Start(CConnman& connman, PeerManager& peerman, int16_t worker_count)
diff --git a/src/active/context.h b/src/active/context.h
index c93690c4bc4a..e0d774f6e923 100644
--- a/src/active/context.h
+++ b/src/active/context.h
@@ -54,7 +54,6 @@ struct DbWrapperParams;
 
 struct ActiveContext final : public CValidationInterface {
 private:
-    llmq::CInstantSendManager& m_isman;
     llmq::CQuorumManager& m_qman;
 
 public:
@@ -97,8 +96,11 @@ struct ActiveContext final : public CValidationInterface {
     const std::unique_ptr<llmq::CEHFSignalsHandler> ehf_sighandler;
     const std::unique_ptr<llmq::QuorumParticipant> qman_handler;
     const std::unique_ptr<chainlock::ChainLockSigner> cl_signer;
+
+public:
     const std::unique_ptr<instantsend::InstantSendSigner> is_signer;
 
+public:
     /** Owned by PeerManager, use GetCJServer() */
     CCoinJoinServer* m_cj_server{nullptr};
 };
diff --git a/src/active/quorums.cpp b/src/active/quorums.cpp
index 0472ebe70f9d..b47efd9db6fc 100644
--- a/src/active/quorums.cpp
+++ b/src/active/quorums.cpp
@@ -14,6 +14,7 @@
 #include <llmq/quorums.h>
 #include <llmq/utils.h>
 #include <masternode/sync.h>
+#include <msg_result.h>
 #include <util/helpers.h>
 
 #include <chain.h>
diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
new file mode 100644
index 000000000000..c5a0e0f1d59e
--- /dev/null
+++ b/src/bitcoin-chainstate.cpp
@@ -0,0 +1,366 @@
+// Copyright (c) 2022 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+//
+// The bitcoin-chainstate executable serves to surface the dependencies required
+// by a program wishing to use Bitcoin Core's consensus engine as it is right
+// now.
+//
+// DEVELOPER NOTE: Since this is a "demo-only", experimental, etc. executable,
+//                 it may diverge from Bitcoin Core's coding style.
+//
+// It is part of the libbitcoinkernel project.
+
+#include <chainparams.h>
+#include <consensus/validation.h>
+#include <chainlock/chainlock.h>
+#include <core_io.h>
+#include <init/common.h>
+#include <node/blockstorage.h>
+#include <node/chainstate.h>
+#include <scheduler.h>
+#include <script/sigcache.h>
+#include <util/system.h>
+#include <util/thread.h>
+#include <validation.h>
+#include <validationinterface.h>
+
+// Temporary added, filter & clean-up:
+#include <evo/chainhelper.h>
+#include <evo/creditpool.h>
+#include <evo/deterministicmns.h>
+#include <evo/evodb.h>
+#include <governance/governance.h>
+#include <llmq/context.h>
+#include <masternode/meta.h>
+#include <masternode/sync.h>
+#include <netfulfilledman.h>
+#include <spork.h>
+// ----------
+
+#include <filesystem>
+#include <functional>
+#include <iosfwd>
+
+const std::function<std::string(const char*)> G_TRANSLATION_FUN = nullptr;
+
+
+//----------------
+// TODO: probably remove all there
+#include <stats/client.h>
+std::unique_ptr<StatsdClient> g_stats_client{std::make_unique<StatsdClient>()};
+
+UniValue ValueFromAmount(const CAmount amount)
+{
+    static_assert(COIN > 1);
+    int64_t quotient = amount / COIN;
+    int64_t remainder = amount % COIN;
+    if (amount < 0) {
+        quotient = -quotient;
+        remainder = -remainder;
+    }
+    return UniValue(UniValue::VNUM,
+            strprintf("%s%d.%08d", amount < 0 ? "-" : "", quotient, remainder));
+}
+std::string GetPrettyExceptionStr(const std::exception_ptr& e)
+{
+    try {
+        // rethrow and catch the exception as there is no other way to reliably cast to the real type (not possible with RTTI)
+        std::rethrow_exception(e);
+    } catch (const std::exception& e2) {
+        return e2.what();
+    } catch (...) {
+        throw;
+    }
+}
+
+//////////////////////
+
+int main(int argc, char* argv[])
+{
+    // SETUP: Argument parsing and handling
+    if (argc != 2) {
+        std::cerr
+            << "Usage: " << argv[0] << " DATADIR" << std::endl
+            << "Display DATADIR information, and process hex-encoded blocks on standard input." << std::endl
+            << std::endl
+            << "IMPORTANT: THIS EXECUTABLE IS EXPERIMENTAL, FOR TESTING ONLY, AND EXPECTED TO" << std::endl
+            << "           BREAK IN FUTURE VERSIONS. DO NOT USE ON YOUR ACTUAL DATADIR." << std::endl;
+        return 1;
+    }
+    std::filesystem::path abs_datadir = std::filesystem::absolute(argv[1]);
+    std::filesystem::create_directories(abs_datadir);
+    gArgs.ForceSetArg("-datadir", abs_datadir.string());
+
+
+    // SETUP: Misc Globals
+    SelectParams(CBaseChainParams::MAIN);
+    const CChainParams& chainparams = Params();
+
+    init::SetGlobals(); // ECC_Start, etc.
+
+    // Necessary for CheckInputScripts (eventually called by ProcessNewBlock),
+    // which will try the script cache first and fall back to actually
+    // performing the check with the signature cache.
+    InitSignatureCache();
+    InitScriptExecutionCache();
+
+
+    // SETUP: Scheduling and Background Signals
+    CScheduler scheduler{};
+    // Start the lightweight task scheduler thread
+    scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); });
+
+    // Gather some entropy once per minute.
+    scheduler.scheduleEvery(RandAddPeriodic, std::chrono::minutes{1});
+
+    GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
+
+
+    // SETUP: Chainstate
+    ChainstateManager chainman{chainparams};
+
+    // DASH SPECIFIC; maybe remove some
+    CMasternodeMetaMan metaman;
+    bool dash_dbs_in_memory = false;
+    bool fReset = false;
+    bool fReindexChainState = false;
+/*    CEvoDB evodb(util::DbWrapperParams{.path = gArgs.GetDataDirNet(),
+        .memory = dash_dbs_in_memory, .wipe = fReset || fReindexChainState});
+    std::unique_ptr<CDeterministicMNManager> dmnman = std::make_unique<CDeterministicMNManager>(evodb, metaman);
+    CGovernanceManager govman(metaman, chainman, dmnman, mn_sync);
+    */
+
+    std::unique_ptr<CEvoDB> evodb;
+    std::unique_ptr<CDeterministicMNManager> dmnman;
+    CMasternodeSync mn_sync{std::make_unique<NullNodeSyncNotifier>()};
+    CGovernanceManager govman(metaman, chainman, dmnman, mn_sync);
+
+
+    CSporkManager sporkman;
+    chainlock::Chainlocks chainlocks(sporkman);
+
+    // try to drop govman, mn_payment, mempool
+    int bls_threads = 1;
+    int max_sigs_age = 1;
+    int worker_count = 1;
+    const auto data_dir = gArgs.GetDataDirNet();
+    /*
+    util::DbWrapperParams db_params{.path = data_dir, .memory = llmq_dbs_in_memory, .wipe = llmq_dbs_wipe};
+    */
+//    LLMQContext llmq_ctx{*dmnman, evodb, sporkman, chainman, mn_sync, db_params, bls_threads, max_sigs_age, worker_count};
+//    CChainstateHelper chain_helper(evodb, *dmnman, govman, *llmq_ctx.isman, *llmq_ctx.quorum_block_processor, *llmq_ctx.qsnapman, chainman, chanparams.GetConsensus(), mn_sync, sporkman, chainlocks, *llmq_ctx.qman);
+    // --- DASH
+
+    std::unique_ptr<LLMQContext> llmq_ctx;
+    std::unique_ptr<CChainstateHelper> chain_helper;
+    auto rv = node::LoadChainstate(fReset,
+                                   std::ref(chainman),
+                                   govman,
+                                   metaman,
+                                   sporkman,
+                                   chainlocks,
+                                   chain_helper,
+                                   dmnman,
+                                   evodb,
+                                   llmq_ctx,
+                                   nullptr, // mempool
+                                   gArgs.GetDataDirNet(),
+                                   false, // fPruneMode
+                                   false, // index
+                                   false, // index
+                                   false, // index
+                                   chainparams.GetConsensus(),
+                                   fReindexChainState,
+                                   2 << 20,
+                                   2 << 22,
+                                   (450 << 20) - (2 << 20) - (2 << 22),
+                                   false,
+                                   false,
+                                   dash_dbs_in_memory,
+                                   bls_threads, // bls threads
+                                   worker_count,
+                                   max_sigs_age,
+                                   []() { return false; }, // shutdown_requested
+                                   []() { return false; }); // this corner case be added to
+    if (rv.has_value()) {
+        std::cerr << "Failed to load Chain state from your datadir." << std::endl;
+        goto epilogue;
+    } else {
+        auto maybe_verify_error = node::VerifyLoadedChainstate(std::ref(chainman),
+                                                               *evodb,
+                                                               false,
+                                                               false,
+                                                               chainparams.GetConsensus(),
+                                                               DEFAULT_CHECKBLOCKS,
+                                                               DEFAULT_CHECKLEVEL,
+                                                               /*get_unix_time_seconds=*/static_cast<int64_t (*)()>(GetTime));
+        if (maybe_verify_error.has_value()) {
+            std::cerr << "Failed to verify loaded Chain state from your datadir." << std::endl;
+            goto epilogue;
+        }
+    }
+
+    for (CChainState* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
+        BlockValidationState state;
+        if (!chainstate->ActivateBestChain(state, nullptr)) {
+            std::cerr << "Failed to connect best block (" << state.ToString() << ")" << std::endl;
+            goto epilogue;
+        }
+    }
+
+    // Main program logic starts here
+    std::cout
+        << "Hello! I'm going to print out some information about your datadir." << std::endl
+        << "\t" << "Path: " << gArgs.GetDataDirNet() << std::endl
+        << "\t" << "Reindexing: " << std::boolalpha << node::fReindex.load() << std::noboolalpha << std::endl
+        << "\t" << "Snapshot Active: " << std::boolalpha << chainman.IsSnapshotActive() << std::noboolalpha << std::endl
+        << "\t" << "Active Height: " << chainman.ActiveHeight() << std::endl
+        << "\t" << "Active IBD: " << std::boolalpha << chainman.ActiveChainstate().IsInitialBlockDownload() << std::noboolalpha << std::endl;
+    {
+        CBlockIndex* tip = chainman.ActiveTip();
+        if (tip) {
+            std::cout << "\t" << tip->ToString() << std::endl;
+        }
+    }
+
+    for (std::string line; std::getline(std::cin, line);) {
+        if (line.empty()) {
+            std::cerr << "Empty line found" << std::endl;
+            break;
+        }
+
+        std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
+        CBlock& block = *blockptr;
+
+        if (!DecodeHexBlk(block, line)) {
+            std::cerr << "Block decode failed" << std::endl;
+            break;
+        }
+
+        if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
+            std::cerr << "Block does not start with a coinbase" << std::endl;
+            break;
+        }
+
+        uint256 hash = block.GetHash();
+        {
+            LOCK(cs_main);
+            const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
+            if (pindex) {
+                if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
+                    std::cerr << "duplicate" << std::endl;
+                    break;
+                }
+                if (pindex->nStatus & BLOCK_FAILED_MASK) {
+                    std::cerr << "duplicate-invalid" << std::endl;
+                    break;
+                }
+            }
+        }
+
+        if constexpr (false) { // it's for segwit
+                               /*
+            LOCK(cs_main);
+            const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
+            if (pindex) {
+                UpdateUncommittedBlockStructures(block, pindex, chainparams.GetConsensus());
+            }
+            */
+        }
+
+        // Adapted from rpc/mining.cpp
+        class submitblock_StateCatcher final : public CValidationInterface
+        {
+        public:
+            uint256 hash;
+            bool found;
+            BlockValidationState state;
+
+            explicit submitblock_StateCatcher(const uint256& hashIn) : hash(hashIn), found(false), state() {}
+
+        protected:
+            void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override
+            {
+                if (block.GetHash() != hash)
+                    return;
+                found = true;
+                state = stateIn;
+            }
+        };
+
+        bool new_block;
+        auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
+        RegisterSharedValidationInterface(sc);
+        bool accepted = chainman.ProcessNewBlock(blockptr, /*force_processing=*/true, /*new_block=*/&new_block);
+        UnregisterSharedValidationInterface(sc);
+        if (!new_block && accepted) {
+            std::cerr << "duplicate" << std::endl;
+            break;
+        }
+        if (!sc->found) {
+            std::cerr << "inconclusive" << std::endl;
+            break;
+        }
+        std::cout << sc->state.ToString() << std::endl;
+        switch (sc->state.GetResult()) {
+        case BlockValidationResult::BLOCK_RESULT_UNSET:
+            std::cerr << "initial value. Block has not yet been rejected" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_CONSENSUS:
+            std::cerr << "invalid by consensus rules (excluding any below reasons)" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_RECENT_CONSENSUS_CHANGE:
+            std::cerr << "Invalid by a change to consensus rules more recent than SegWit." << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_CACHED_INVALID:
+            std::cerr << "this block was cached as being invalid and we didn't store the reason why" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_INVALID_HEADER:
+            std::cerr << "invalid proof of work or time too old" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_MUTATED:
+            std::cerr << "the block's data didn't match the data committed to by the PoW" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_MISSING_PREV:
+            std::cerr << "We don't have the previous block the checked one is built on" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_INVALID_PREV:
+            std::cerr << "A block this one builds on is invalid" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_TIME_FUTURE:
+            std::cerr << "block timestamp was > 2 hours in the future (or our clock is bad)" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_CHECKPOINT:
+            std::cerr << "the block failed to meet one of our checkpoints" << std::endl;
+            break;
+        case BlockValidationResult::BLOCK_CHAINLOCK:
+            std::cerr << "the block conflicts with the ChainLock" << std::endl;
+            break;
+        }
+    }
+
+epilogue:
+    // Without this precise shutdown sequence, there will be a lot of nullptr
+    // dereferencing and UB.
+    scheduler.stop();
+    if (chainman.m_load_block.joinable()) chainman.m_load_block.join();
+    StopScriptCheckWorkerThreads();
+
+    GetMainSignals().FlushBackgroundCallbacks();
+    {
+        LOCK(cs_main);
+        for (CChainState* chainstate : chainman.GetAll()) {
+            if (chainstate->CanFlushToDisk()) {
+                chainstate->ForceFlushStateToDisk();
+                chainstate->ResetCoinsViews();
+            }
+        }
+    }
+    GetMainSignals().UnregisterBackgroundSignalScheduler();
+
+    // removed by 22564
+//    chainman.UnloadBlockIndex();
+
+    init::UnsetGlobals();
+}
diff --git a/src/chainlock/clsig.cpp b/src/chainlock/clsig.cpp
index 573331bba610..16438a0c76c8 100644
--- a/src/chainlock/clsig.cpp
+++ b/src/chainlock/clsig.cpp
@@ -4,6 +4,8 @@
 
 #include <chainlock/clsig.h>
 
+#include <chainparams.h>
+#include <llmq/quorumsman.h>
 #include <tinyformat.h>
 
 #include <string_view>
@@ -30,4 +32,14 @@ uint256 GenSigRequestId(const int32_t nHeight)
 {
     return ::SerializeHash(std::make_pair(CLSIG_REQUESTID_PREFIX, nHeight));
 }
+
+llmq::VerifyRecSigStatus VerifyChainLock(const Consensus::Params& params, const CChain& chain,
+                                         const llmq::CQuorumManager& qman, const chainlock::ChainLockSig& clsig)
+{
+    const auto llmqType = params.llmqTypeChainLocks;
+    const uint256 request_id = GenSigRequestId(clsig.getHeight());
+
+    return llmq::VerifyRecoveredSig(llmqType, chain, qman, clsig.getHeight(), request_id, clsig.getBlockHash(),
+                                    clsig.getSig());
+}
 } // namespace chainlock
diff --git a/src/chainlock/clsig.h b/src/chainlock/clsig.h
index 3800f2f813cb..62f86db68e67 100644
--- a/src/chainlock/clsig.h
+++ b/src/chainlock/clsig.h
@@ -5,13 +5,23 @@
 #ifndef BITCOIN_CHAINLOCK_CLSIG_H
 #define BITCOIN_CHAINLOCK_CLSIG_H
 
+#include <bls/bls.h>
 #include <serialize.h>
 #include <uint256.h>
 
-#include <bls/bls.h>
-
 #include <cstdint>
 
+class CChain;
+
+namespace Consensus {
+struct Params;
+} // namespace Consensus
+
+namespace llmq {
+class CQuorumManager;
+enum class VerifyRecSigStatus : uint8_t;
+} // namespace llmq
+
 namespace chainlock {
 struct ChainLockSig {
 private:
@@ -39,6 +49,9 @@ struct ChainLockSig {
 
 //! Generate clsig request ID with block height
 uint256 GenSigRequestId(const int32_t nHeight);
+
+llmq::VerifyRecSigStatus VerifyChainLock(const Consensus::Params& params, const CChain& chain,
+                                         const llmq::CQuorumManager& qman, const ChainLockSig& clsig);
 } // namespace chainlock
 
 #endif // BITCOIN_CHAINLOCK_CLSIG_H
diff --git a/src/chainlock/handler.cpp b/src/chainlock/handler.cpp
index ddb7bf1ff59a..aea039f39f65 100644
--- a/src/chainlock/handler.cpp
+++ b/src/chainlock/handler.cpp
@@ -4,19 +4,19 @@
 
 #include <chainlock/handler.h>
 
+#include <chain.h>
 #include <chainlock/chainlock.h>
+#include <chainparams.h>
+#include <consensus/validation.h>
 #include <instantsend/instantsend.h>
 #include <llmq/quorumsman.h>
 #include <masternode/sync.h>
-#include <stats/client.h>
-#include <util/std23.h>
-
-#include <chain.h>
-#include <chainparams.h>
-#include <consensus/validation.h>
+#include <msg_result.h>
 #include <node/interface_ui.h>
 #include <scheduler.h>
+#include <stats/client.h>
 #include <txmempool.h>
+#include <util/std23.h>
 #include <util/thread.h>
 #include <util/time.h>
 #include <validation.h>
@@ -324,13 +324,4 @@ void ChainlockHandler::Cleanup()
     }
 }
 
-llmq::VerifyRecSigStatus VerifyChainLock(const Consensus::Params& params, const CChain& chain,
-                                         const llmq::CQuorumManager& qman, const chainlock::ChainLockSig& clsig)
-{
-    const auto llmqType = params.llmqTypeChainLocks;
-    const uint256 request_id = chainlock::GenSigRequestId(clsig.getHeight());
-
-    return llmq::VerifyRecoveredSig(llmqType, chain, qman, clsig.getHeight(), request_id, clsig.getBlockHash(),
-                                    clsig.getSig());
-}
 } // namespace chainlock
diff --git a/src/chainlock/handler.h b/src/chainlock/handler.h
index e024ca539876..140325c007c6 100644
--- a/src/chainlock/handler.h
+++ b/src/chainlock/handler.h
@@ -24,20 +24,14 @@
 
 class CBlock;
 class CBlockIndex;
-class CChain;
 class CMasternodeSync;
 class ChainstateManager;
 class CScheduler;
 class CTxMemPool;
 struct MessageProcessingResult;
 
-namespace Consensus {
-struct Params;
-} // namespace Consensus
-
 namespace llmq {
 class CQuorumManager;
-enum class VerifyRecSigStatus : uint8_t;
 } // namespace llmq
 
 namespace chainlock {
@@ -107,9 +101,6 @@ class ChainlockHandler final : public CValidationInterface
 private:
     void Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs);
 };
-
-llmq::VerifyRecSigStatus VerifyChainLock(const Consensus::Params& params, const CChain& chain,
-                                         const llmq::CQuorumManager& qman, const chainlock::ChainLockSig& clsig);
 } // namespace chainlock
 
 #endif // BITCOIN_CHAINLOCK_HANDLER_H
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
index f2566970adc3..271ce2daa752 100644
--- a/src/dsnotificationinterface.cpp
+++ b/src/dsnotificationinterface.cpp
@@ -5,34 +5,25 @@
 
 #include <dsnotificationinterface.h>
 
-#include <util/check.h>
-#include <validation.h>
-
 #include <coinjoin/coinjoin.h>
 #include <evo/deterministicmns.h>
 #include <evo/mnauth.h>
 #include <governance/governance.h>
 #include <instantsend/instantsend.h>
-#include <llmq/context.h>
-#include <llmq/dkgsessionmgr.h>
-#include <llmq/ehf_signals.h>
-#include <llmq/quorumsman.h>
 #include <masternode/sync.h>
+#include <util/check.h>
+#include <validation.h>
 
-CDSNotificationInterface::CDSNotificationInterface(CConnman& connman,
-                                                   CDSTXManager& dstxman,
-                                                   CMasternodeSync& mn_sync,
-                                                   CGovernanceManager& govman,
-                                                   const ChainstateManager& chainman,
-                                                   const std::unique_ptr<CDeterministicMNManager>& dmnman,
-                                                   const std::unique_ptr<LLMQContext>& llmq_ctx) :
+
+CDSNotificationInterface::CDSNotificationInterface(CConnman& connman, CDSTXManager& dstxman, CMasternodeSync& mn_sync,
+                                                   CGovernanceManager& govman, const ChainstateManager& chainman,
+                                                   const std::unique_ptr<CDeterministicMNManager>& dmnman) :
     m_connman{connman},
     m_dstxman{dstxman},
     m_mn_sync{mn_sync},
     m_govman{govman},
     m_chainman{chainman},
-    m_dmnman{dmnman},
-    m_llmq_ctx{llmq_ctx}
+    m_dmnman{dmnman}
 {
 }
 
@@ -76,7 +67,6 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
         m_dstxman.UpdatedBlockTip(pindexNew);
     }
 
-    m_llmq_ctx->isman->UpdatedBlockTip(pindexNew);
     if (m_govman.IsValid()) {
         m_govman.UpdatedBlockTip(pindexNew);
     }
@@ -85,25 +75,16 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
 void CDSNotificationInterface::TransactionAddedToMempool(const CTransactionRef& ptx, int64_t nAcceptTime,
                                                          uint64_t mempool_sequence)
 {
-    Assert(m_llmq_ctx)->isman->TransactionAddedToMempool(ptx);
     m_dstxman.TransactionAddedToMempool(ptx);
 }
 
-void CDSNotificationInterface::TransactionRemovedFromMempool(const CTransactionRef& ptx, MemPoolRemovalReason reason,
-                                                             uint64_t mempool_sequence)
-{
-    Assert(m_llmq_ctx)->isman->TransactionRemovedFromMempool(ptx);
-}
-
 void CDSNotificationInterface::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
 {
-    Assert(m_llmq_ctx)->isman->BlockConnected(pblock, pindex);
     m_dstxman.BlockConnected(pblock, pindex);
 }
 
 void CDSNotificationInterface::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected)
 {
-    Assert(m_llmq_ctx)->isman->BlockDisconnected(pblock, pindexDisconnected);
     m_dstxman.BlockDisconnected(pblock, pindexDisconnected);
 }
 
@@ -118,7 +99,6 @@ void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDet
 void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex,
                                                const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
 {
-    Assert(m_llmq_ctx)->isman->NotifyChainLock(pindex);
     if (m_mn_sync.IsBlockchainSynced()) {
         m_dstxman.NotifyChainLock(pindex);
     }
diff --git a/src/dsnotificationinterface.h b/src/dsnotificationinterface.h
index f8ae3b02560e..07d49332fd60 100644
--- a/src/dsnotificationinterface.h
+++ b/src/dsnotificationinterface.h
@@ -13,7 +13,6 @@ class CDeterministicMNManager;
 class CGovernanceManager;
 class ChainstateManager;
 class CMasternodeSync;
-struct LLMQContext;
 
 class CDSNotificationInterface : public CValidationInterface
 {
@@ -21,13 +20,9 @@ class CDSNotificationInterface : public CValidationInterface
     CDSNotificationInterface() = delete;
     CDSNotificationInterface(const CDSNotificationInterface&) = delete;
     CDSNotificationInterface& operator=(const CDSNotificationInterface&) = delete;
-    explicit CDSNotificationInterface(CConnman& connman,
-                                      CDSTXManager& dstxman,
-                                      CMasternodeSync& mn_sync,
-                                      CGovernanceManager& govman,
-                                      const ChainstateManager& chainman,
-                                      const std::unique_ptr<CDeterministicMNManager>& dmnman,
-                                      const std::unique_ptr<LLMQContext>& llmq_ctx);
+    explicit CDSNotificationInterface(CConnman& connman, CDSTXManager& dstxman, CMasternodeSync& mn_sync,
+                                      CGovernanceManager& govman, const ChainstateManager& chainman,
+                                      const std::unique_ptr<CDeterministicMNManager>& dmnman);
     virtual ~CDSNotificationInterface();
 
     // a small helper to initialize current block height in sub-modules on startup
@@ -40,8 +35,6 @@ class CDSNotificationInterface : public CValidationInterface
     void SynchronousUpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
     void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
     void TransactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime, uint64_t mempool_sequence) override;
-    void TransactionRemovedFromMempool(const CTransactionRef& ptx, MemPoolRemovalReason reason,
-                                       uint64_t mempool_sequence) override;
     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) override;
     void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected) override;
     void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff) override;
@@ -54,7 +47,6 @@ class CDSNotificationInterface : public CValidationInterface
     CGovernanceManager& m_govman;
     const ChainstateManager& m_chainman;
     const std::unique_ptr<CDeterministicMNManager>& m_dmnman;
-    const std::unique_ptr<LLMQContext>& m_llmq_ctx;
 };
 
 extern std::unique_ptr<CDSNotificationInterface> g_ds_notification_interface;
diff --git a/src/evo/chainhelper.cpp b/src/evo/chainhelper.cpp
index 5c1f19a508d0..8794fceabbc7 100644
--- a/src/evo/chainhelper.cpp
+++ b/src/evo/chainhelper.cpp
@@ -17,14 +17,13 @@
 CChainstateHelper::CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, CGovernanceManager& govman,
                                      llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
                                      llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                                     const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync,
-                                     const CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks,
-                                     const llmq::CQuorumManager& qman) :
+                                     const Consensus::Params& consensus_params, const CSporkManager& sporkman,
+                                     const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman) :
     isman{isman},
     credit_pool_manager{std::make_unique<CCreditPoolManager>(evodb, chainman)},
     m_chainlocks{chainlocks},
     ehf_manager{std::make_unique<CMNHFManager>(evodb, chainman, qman)},
-    mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, govman, chainman, consensus_params, mn_sync, sporkman)},
+    mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, govman, chainman, consensus_params, sporkman)},
     special_tx{std::make_unique<CSpecialTxProcessor>(*credit_pool_manager, dmnman, *ehf_manager, qblockman, qsnapman,
                                                      chainman, consensus_params, chainlocks, qman)}
 {}
diff --git a/src/evo/chainhelper.h b/src/evo/chainhelper.h
index 69a229d93cad..eb69e8cfd679 100644
--- a/src/evo/chainhelper.h
+++ b/src/evo/chainhelper.h
@@ -15,7 +15,6 @@ class CDeterministicMNManager;
 class CEvoDB;
 class CGovernanceManager;
 class ChainstateManager;
-class CMasternodeSync;
 class CMNHFManager;
 class CMNPaymentsProcessor;
 class CSpecialTxProcessor;
@@ -60,9 +59,8 @@ class CChainstateHelper
     explicit CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, CGovernanceManager& govman,
                                llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
                                llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                               const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync,
-                               const CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks,
-                               const llmq::CQuorumManager& qman);
+                               const Consensus::Params& consensus_params, const CSporkManager& sporkman,
+                               const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman);
     ~CChainstateHelper();
 
     /** Passthrough functions to chainlock::Chainlocks */
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 55b86c240647..9c70869382c3 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -4,6 +4,10 @@
 
 #include <evo/deterministicmns.h>
 
+#include <chainparams.h>
+#include <coins.h>
+#include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <evo/dmn_types.h>
 #include <evo/dmnstate.h>
 #include <evo/evodb.h>
@@ -11,25 +15,19 @@
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
 #include <masternode/meta.h>
-#include <stats/client.h>
-#include <util/helpers.h>
-
-#include <chainparams.h>
-#include <coins.h>
-#include <consensus/validation.h>
-#include <deploymentstatus.h>
-#include <index/txindex.h>
 #include <node/blockstorage.h>
 #include <script/standard.h>
+#include <stats/client.h>
 #include <uint256.h>
+#include <util/helpers.h>
+
+#include <univalue.h>
 
 #include <functional>
 #include <optional>
 #include <memory>
 #include <ranges>
 
-#include <univalue.h>
-
 static const std::string DB_LIST_SNAPSHOT = "dmn_S3";
 static const std::string DB_LIST_DIFF = "dmn_D4";        // Bumped for nVersion-first format
 static const std::string DB_LIST_DIFF_LEGACY = "dmn_D3"; // Legacy format key
@@ -55,31 +53,6 @@ std::string CDeterministicMN::ToString() const
     return strprintf("CDeterministicMN(proTxHash=%s, collateralOutpoint=%s, nOperatorReward=%f, state=%s", proTxHash.ToString(), collateralOutpoint.ToStringShort(), (double)nOperatorReward / 100, pdmnState->ToString());
 }
 
-UniValue CDeterministicMN::ToJson() const
-{
-    UniValue obj(UniValue::VOBJ);
-    obj.pushKV("type", std::string(GetMnType(nType).description));
-    obj.pushKV("proTxHash", proTxHash.ToString());
-    obj.pushKV("collateralHash", collateralOutpoint.hash.ToString());
-    obj.pushKV("collateralIndex", collateralOutpoint.n);
-
-    if (g_txindex) {
-        CTransactionRef collateralTx;
-        uint256 nBlockHash;
-        g_txindex->FindTx(collateralOutpoint.hash, nBlockHash, collateralTx);
-        if (collateralTx) {
-            CTxDestination dest;
-            if (ExtractDestination(collateralTx->vout[collateralOutpoint.n].scriptPubKey, dest)) {
-                obj.pushKV("collateralAddress", EncodeDestination(dest));
-            }
-        }
-    }
-
-    obj.pushKV("operatorReward", (double)nOperatorReward / 100);
-    obj.pushKV("state", pdmnState->ToJson(nType));
-    return obj;
-}
-
 bool CDeterministicMNList::IsMNValid(const uint256& proTxHash) const
 {
     auto p = mnMap.find(proTxHash);
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index f72c8d837846..fc1d9539da73 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -96,6 +96,8 @@ bool CGovernanceManager::LoadCache(bool load_cache)
     return is_valid;
 }
 
+bool CGovernanceManager::IsValidAndSynced() const { return is_valid && m_mn_sync.IsSynced(); }
+
 void CGovernanceManager::RelayObject(const CGovernanceObject& obj)
 {
     AssertLockNotHeld(cs_relay);
@@ -180,7 +182,7 @@ void CGovernanceManager::AddPostponedObjectInternal(const CGovernanceObject& gov
     mapPostponedObjects.emplace(govobj.GetHash(), std::make_shared<CGovernanceObject>(govobj));
 }
 
-bool CGovernanceManager::ProcessObject(const CNode& peer, const uint256& nHash, CGovernanceObject& govobj)
+bool CGovernanceManager::ProcessObject(const std::string& peer_str, const uint256& nHash, CGovernanceObject& govobj)
 {
     std::string strHash = nHash.ToString();
 
@@ -226,7 +228,7 @@ bool CGovernanceManager::ProcessObject(const CNode& peer, const uint256& nHash,
         }
     }
 
-    AddGovernanceObjectInternal(govobj, &peer);
+    AddGovernanceObjectInternal(govobj, peer_str);
     return true;
 }
 
@@ -259,7 +261,7 @@ void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj)
     }
 }
 
-void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_obj, const CNode* pfrom)
+void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_obj, const std::string& peer_str)
 {
     AssertLockHeld(::cs_main);
     AssertLockHeld(cs_store);
@@ -307,7 +309,7 @@ void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_o
         return;
     }
 
-    LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- %s new, received from peer %s\n", strHash, pfrom ? pfrom->GetLogString() : "nullptr");
+    LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- %s new, received from peer %s\n", strHash, peer_str);
     RelayObject(*govobj);
 
     // Update the rate buffer
@@ -324,10 +326,10 @@ void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_o
     uiInterface.NotifyGovernanceChanged();
 }
 
-void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, const CNode* pfrom)
+void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, const std::string& peer_str)
 {
     LOCK2(::cs_main, cs_store);
-    AddGovernanceObjectInternal(govobj, pfrom);
+    AddGovernanceObjectInternal(govobj, peer_str);
 }
 
 void CGovernanceManager::CheckAndRemove()
@@ -751,14 +753,14 @@ bool CGovernanceManager::ProcessVoteAndRelay(const CGovernanceVote& vote, CGover
     AssertLockNotHeld(cs_store);
     AssertLockNotHeld(cs_relay);
     uint256 hashToRequest; // Ignored for local votes (no peer to request from)
-    bool fOK = ProcessVote(/*pfrom=*/nullptr, vote, exception, hashToRequest);
+    bool fOK = ProcessVote(vote, exception, hashToRequest);
     if (fOK) {
         RelayVote(vote);
     }
     return fOK;
 }
 
-bool CGovernanceManager::ProcessVote(CNode* pfrom, const CGovernanceVote& vote, CGovernanceException& exception,
+bool CGovernanceManager::ProcessVote(const CGovernanceVote& vote, CGovernanceException& exception,
                                      uint256& hashToRequest)
 {
     AssertLockNotHeld(cs_store);
@@ -830,7 +832,7 @@ void CGovernanceManager::CheckPostponedObjects()
         bool fMissingConfirmations;
         if (govobj.IsCollateralValid(m_chainman, strError, fMissingConfirmations)) {
             if (govobj.IsValidLocally(Assert(m_dmnman)->GetListAtChainTip(), m_chainman, strError, false)) {
-                AddGovernanceObjectInternal(govobj);
+                AddGovernanceObjectInternal(govobj, "nullptr");
             } else {
                 LogPrint(BCLog::GOBJECT, "CGovernanceManager::CheckPostponedObjects -- %s invalid\n", nHash.ToString());
             }
diff --git a/src/governance/governance.h b/src/governance/governance.h
index fa048b40d9d2..e1368b9f52ba 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -273,6 +273,7 @@ class CGovernanceManager : public GovernanceStore, public GovernanceSignerParent
 
     // Basic initialization and querying
     bool IsValid() const override { return is_valid; }
+    bool IsValidAndSynced() const;
     bool LoadCache(bool load_cache)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
@@ -322,7 +323,7 @@ class CGovernanceManager : public GovernanceStore, public GovernanceSignerParent
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
     std::vector<std::shared_ptr<const CGovernanceObject>> GetApprovedProposals(const CDeterministicMNList& tip_mn_list) override
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
-    void AddGovernanceObject(CGovernanceObject& govobj, const CNode* pfrom = nullptr) override
+    void AddGovernanceObject(CGovernanceObject& govobj, const std::string& peer_str = "nullptr") override
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store, !cs_relay);
 
     // Superblocks
@@ -376,13 +377,13 @@ class CGovernanceManager : public GovernanceStore, public GovernanceSignerParent
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
     /// Called to indicate a requested object or vote has been received
     bool AcceptMessage(const uint256& nHash) EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
-    bool ProcessObject(const CNode& peer, const uint256& hash, CGovernanceObject& govobj)
+    bool ProcessObject(const std::string& peer_str, const uint256& hash, CGovernanceObject& govobj)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_store, !cs_relay);
 
     CDeterministicMNManager& GetMNManager();
     /** Process a governance vote. Returns true on success.
      *  If the vote is for an unknown object (orphan), hashToRequest is set to the object hash. */
-    bool ProcessVote(CNode* pfrom, const CGovernanceVote& vote, CGovernanceException& exception, uint256& hashToRequest)
+    bool ProcessVote(const CGovernanceVote& vote, CGovernanceException& exception, uint256& hashToRequest)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
 
 
@@ -402,7 +403,7 @@ class CGovernanceManager : public GovernanceStore, public GovernanceSignerParent
         EXCLUSIVE_LOCKS_REQUIRED(cs_store);
 
     // Internal counterpart to "Signer interface"
-    void AddGovernanceObjectInternal(CGovernanceObject& govobj, const CNode* pfrom = nullptr)
+    void AddGovernanceObjectInternal(CGovernanceObject& govobj, const std::string& peer_str)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main, cs_store, !cs_relay);
 
     // ...
diff --git a/src/governance/net_governance.cpp b/src/governance/net_governance.cpp
index 7849ff91544e..852175d05b36 100644
--- a/src/governance/net_governance.cpp
+++ b/src/governance/net_governance.cpp
@@ -134,7 +134,7 @@ void NetGovernance::ProcessMessage(CNode& peer, const std::string& msg_type, CDa
             return;
         }
 
-        if (!WITH_LOCK(::cs_main, return m_gov_manager.ProcessObject(peer, nHash, govobj))) {
+        if (!WITH_LOCK(::cs_main, return m_gov_manager.ProcessObject(peer.GetLogString(), nHash, govobj))) {
             // apply node's ban score
             m_peer_manager->PeerMisbehaving(peer.GetId(), 20);
         }
@@ -169,7 +169,7 @@ void NetGovernance::ProcessMessage(CNode& peer, const std::string& msg_type, CDa
 
         CGovernanceException exception;
         uint256 hashToRequest;
-        if (m_gov_manager.ProcessVote(&peer, vote, exception, hashToRequest)) {
+        if (m_gov_manager.ProcessVote(vote, exception, hashToRequest)) {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECTVOTE -- %s new\n", strHash);
             m_node_sync.BumpAssetLastTime("MNGOVERNANCEOBJECTVOTE");
 
diff --git a/src/governance/object.cpp b/src/governance/object.cpp
index d05e5b021e99..86431439196f 100644
--- a/src/governance/object.cpp
+++ b/src/governance/object.cpp
@@ -12,11 +12,11 @@
 #include <masternode/sync.h>
 
 #include <chainparams.h>
-#include <core_io.h>
 #include <index/txindex.h>
 #include <logging.h>
 #include <node/interface_ui.h>
 #include <timedata.h>
+#include <util/strencodings.h>
 #include <util/time.h>
 #include <validation.h>
 #include <validationinterface.h>
@@ -491,12 +491,12 @@ bool CGovernanceObject::IsCollateralValid(const ChainstateManager& chainman, std
     CAmount nMinFee = GetMinCollateralFee();
 
     LogPrint(BCLog::GOBJECT, "CGovernanceObject::IsCollateralValid -- txCollateral->vout.size() = %s, findScript = %s, nMinFee = %lld\n",
-                txCollateral->vout.size(), ScriptToAsmStr(findScript, false), nMinFee);
+                txCollateral->vout.size(), HexStr(findScript), nMinFee);
 
     bool foundOpReturn = false;
     for (const auto& output : txCollateral->vout) {
         LogPrint(BCLog::GOBJECT, "CGovernanceObject::IsCollateralValid -- txout = %s, output.nValue = %lld, output.scriptPubKey = %s\n",
-                    output.ToString(), output.nValue, ScriptToAsmStr(output.scriptPubKey, false));
+                    output.ToString(), output.nValue, HexStr(output.scriptPubKey));
         if (!output.scriptPubKey.IsPayToPublicKeyHash() && !output.scriptPubKey.IsUnspendable()) {
             strError = strprintf("Invalid Script %s", txCollateral->ToString());
             LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError);
diff --git a/src/governance/signing.cpp b/src/governance/signing.cpp
index 1aec5e818073..ad9bc5cdc8d0 100644
--- a/src/governance/signing.cpp
+++ b/src/governance/signing.cpp
@@ -163,7 +163,7 @@ std::optional<const CGovernanceObject> GovernanceSigner::CreateGovernanceTrigger
     }
 
     // The trigger we just created looks good, submit it
-    m_govman.AddGovernanceObject(gov_sb);
+    m_govman.AddGovernanceObject(gov_sb, "nullptr");
     return std::make_optional<CGovernanceObject>(gov_sb);
 }
 
diff --git a/src/governance/signing.h b/src/governance/signing.h
index f03aec29096d..6f4d3884bd09 100644
--- a/src/governance/signing.h
+++ b/src/governance/signing.h
@@ -23,7 +23,6 @@ class CGovernanceException;
 class CGovernanceVote;
 class ChainstateManager;
 class CMasternodeSync;
-class CNode;
 enum vote_outcome_enum_t : int;
 
 class GovernanceSignerParent
@@ -42,7 +41,7 @@ class GovernanceSignerParent
     virtual std::vector<std::shared_ptr<CSuperblock>> GetActiveTriggers() const = 0;
     virtual std::vector<std::shared_ptr<const CGovernanceObject>> GetApprovedProposals(
         const CDeterministicMNList& tip_mn_list) = 0;
-    virtual void AddGovernanceObject(CGovernanceObject& govobj, const CNode* pfrom = nullptr) = 0;
+    virtual void AddGovernanceObject(CGovernanceObject& govobj, const std::string& peer_str) = 0;
 };
 
 class GovernanceSigner
diff --git a/src/init.cpp b/src/init.cpp
index 5c2a0bcf0ec2..6b55dacdad78 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -97,6 +97,7 @@
 #include <instantsend/net_instantsend.h>
 #include <llmq/context.h>
 #include <llmq/dkgsessionmgr.h>
+#include <llmq/signing.h>
 #include <llmq/net_signing.h>
 #include <llmq/options.h>
 #include <llmq/observer/context.h>
@@ -1987,7 +1988,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                               chainman,
                                               *node.govman,
                                               *node.mn_metaman,
-                                              *node.mn_sync,
                                               *node.sporkman,
                                               *node.chainlocks,
                                               node.chain_helper,
@@ -2176,7 +2176,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     RegisterValidationInterface(node.peerman.get());
 
     g_ds_notification_interface = std::make_unique<CDSNotificationInterface>(
-        *node.connman, *node.dstxman, *node.mn_sync, *node.govman, chainman, node.dmnman, node.llmq_ctx
+        *node.connman, *node.dstxman, *node.mn_sync, *node.govman, chainman, node.dmnman // todo: replace unique_ptr for dmnman to reference
     );
     RegisterValidationInterface(g_ds_notification_interface.get());
 
@@ -2208,7 +2208,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     // ********************************************************* Step 7d: Setup other Dash services
 
-    node.peerman->AddExtraHandler(std::make_unique<NetInstantSend>(node.peerman.get(), *node.llmq_ctx->isman, *node.llmq_ctx->qman, chainman.ActiveChainstate()));
+    node.peerman->AddExtraHandler(std::make_unique<NetInstantSend>(node.peerman.get(), *node.llmq_ctx->isman, node.active_ctx ? node.active_ctx->is_signer.get() : nullptr, *node.llmq_ctx->sigman, *node.llmq_ctx->qman, *node.chainlocks, chainman.ActiveChainstate(), *node.mempool, *node.mn_sync));
     node.peerman->AddExtraHandler(std::make_unique<llmq::NetSigning>(node.peerman.get(), *node.llmq_ctx->sigman, node.active_ctx ? node.active_ctx->shareman.get() : nullptr, *node.sporkman));
 
     if (node.active_ctx) {
diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp
index 0726da6911e3..615669121ab0 100644
--- a/src/instantsend/instantsend.cpp
+++ b/src/instantsend/instantsend.cpp
@@ -4,60 +4,19 @@
 
 #include <instantsend/instantsend.h>
 
-#include <chainlock/chainlock.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
-#include <instantsend/signing.h>
-#include <masternode/sync.h>
 #include <node/blockstorage.h>
 #include <spork.h>
 #include <stats/client.h>
-#include <txmempool.h>
-#include <validation.h>
-#include <validationinterface.h>
-
-// Forward declaration to break dependency over node/transaction.h
-namespace node {
-CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool,
-                               const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
-} // namespace node
 
 using node::fImporting;
 using node::fReindex;
-using node::GetTransaction;
 
 namespace llmq {
-namespace {
-template <typename T>
-    requires std::same_as<T, CTxIn> || std::same_as<T, COutPoint>
-Uint256HashSet GetIdsFromLockable(const std::vector<T>& vec)
-{
-    Uint256HashSet ret{};
-    if (vec.empty()) return ret;
-    ret.reserve(vec.size());
-    for (const auto& in : vec) {
-        if constexpr (std::is_same_v<T, COutPoint>) {
-            ret.emplace(instantsend::GenInputLockRequestId(in));
-        } else if constexpr (std::is_same_v<T, CTxIn>) {
-            ret.emplace(instantsend::GenInputLockRequestId(in.prevout));
-        } else {
-            assert(false);
-        }
-    }
-    return ret;
-}
-} // anonymous namespace
-
-CInstantSendManager::CInstantSendManager(const chainlock::Chainlocks& chainlocks, CChainState& chainstate,
-                                         CSigningManager& _sigman, CSporkManager& sporkman, CTxMemPool& _mempool,
-                                         const CMasternodeSync& mn_sync, const util::DbWrapperParams& db_params) :
+CInstantSendManager::CInstantSendManager(CSporkManager& sporkman, const util::DbWrapperParams& db_params) :
     db{db_params},
-    m_chainlocks{chainlocks},
-    m_chainstate{chainstate},
-    sigman{_sigman},
-    spork_manager{sporkman},
-    mempool{_mempool},
-    m_mn_sync{mn_sync}
+    spork_manager{sporkman}
 {
 }
 
@@ -118,22 +77,15 @@ instantsend::PendingState CInstantSendManager::FetchPendingLocks()
     return ret;
 }
 
-std::variant<uint256, CTransactionRef, std::monostate> CInstantSendManager::ProcessInstantSendLock(
-    NodeId from, const uint256& hash, const instantsend::InstantSendLockPtr& islock)
+bool CInstantSendManager::PreVerifyIsLock(const uint256& hash, const instantsend::InstantSendLockPtr& islock, NodeId from) const
 {
-    LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s: processing islock, peer=%d\n",
-             __func__, islock->txid.ToString(), hash.ToString(), from);
-
-    if (auto signer = m_signer.load(std::memory_order_acquire); signer) {
-        signer->ClearLockFromQueue(islock);
-    }
     if (db.KnownInstantSendLock(hash)) {
-        return std::monostate{};
+        return false;
     }
 
     if (const auto sameTxIsLock = db.GetInstantSendLockByTxid(islock->txid)) {
         // can happen, nothing to do
-        return std::monostate{};
+        return false;
     }
     for (const auto& in : islock->inputs) {
         const auto sameOutpointIsLock = db.GetInstantSendLockByInput(in);
@@ -142,106 +94,32 @@ std::variant<uint256, CTransactionRef, std::monostate> CInstantSendManager::Proc
                       islock->txid.ToString(), hash.ToString(), in.ToStringShort(), ::SerializeHash(*sameOutpointIsLock).ToString(), from);
         }
     }
-
-    uint256 hashBlock{};
-    auto tx = GetTransaction(nullptr, &mempool, islock->txid, Params().GetConsensus(), hashBlock);
-    const bool found_transaction{tx != nullptr};
-    // we ignore failure here as we must be able to propagate the lock even if we don't have the TX locally
-    std::optional<int> minedHeight = GetBlockHeight(hashBlock);
-    if (found_transaction) {
-        if (!minedHeight.has_value()) {
-            const CBlockIndex* pindexMined = WITH_LOCK(::cs_main, return m_chainstate.m_blockman.LookupBlockIndex(hashBlock));
-            if (pindexMined != nullptr) {
-                CacheBlockHeight(pindexMined);
-                minedHeight = pindexMined->nHeight;
-            }
-        }
-        // Let's see if the TX that was locked by this islock is already mined in a ChainLocked block. If yes,
-        // we can simply ignore the islock, as the ChainLock implies locking of all TXs in that chain
-        if (minedHeight.has_value() && m_chainlocks.HasChainLock(*minedHeight, hashBlock)) {
-            LogPrint(BCLog::INSTANTSEND, /* Continued */
-                     "CInstantSendManager::%s -- txlock=%s, islock=%s: dropping islock as it already got a "
-                     "ChainLock in block %s, peer=%d\n",
-                     __func__, islock->txid.ToString(), hash.ToString(), hashBlock.ToString(), from);
-            return std::monostate{};
-        }
-    }
-
-    if (found_transaction) {
-        db.WriteNewInstantSendLock(hash, islock);
-        if (minedHeight.has_value()) {
-            db.WriteInstantSendLockMined(hash, *minedHeight);
-        }
-    } else {
-        // put it in a separate pending map and try again later
-        LOCK(cs_pendingLocks);
-        pendingNoTxInstantSendLocks.try_emplace(hash, instantsend::PendingISLockFromPeer{from, islock});
-    }
-
-    // This will also add children TXs to pendingRetryTxs
-    RemoveNonLockedTx(islock->txid, true);
-    // We don't need the recovered sigs for the inputs anymore. This prevents unnecessary propagation of these sigs.
-    // We only need the ISLOCK from now on to detect conflicts
-    TruncateRecoveredSigsForInputs(*islock);
-    ResolveBlockConflicts(hash, *islock);
-
-    if (found_transaction) {
-        RemoveMempoolConflictsForLock(hash, *islock);
-        LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- notify about lock %s for tx %s\n", __func__,
-                 hash.ToString(), tx->GetHash().ToString());
-        GetMainSignals().NotifyTransactionLock(tx, islock);
-        // bump mempool counter to make sure newly locked txes are picked up by getblocktemplate
-        mempool.AddTransactionsUpdated(1);
-    }
-
-    if (found_transaction) {
-        return tx;
-    }
-    return islock->txid;
+    return true;
 }
 
-void CInstantSendManager::TransactionAddedToMempool(const CTransactionRef& tx)
+void CInstantSendManager::WriteNewISLock(const uint256& hash, const instantsend::InstantSendLockPtr& islock,
+                                         std::optional<int> minedHeight)
 {
-    if (!IsInstantSendEnabled() || !m_mn_sync.IsBlockchainSynced() || tx->vin.empty()) {
-        return;
-    }
-
-    instantsend::InstantSendLockPtr islock{nullptr};
-    {
-        LOCK(cs_pendingLocks);
-        auto it = pendingNoTxInstantSendLocks.begin();
-        while (it != pendingNoTxInstantSendLocks.end()) {
-            if (it->second.islock->txid == tx->GetHash()) {
-                // we received an islock earlier
-                LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s\n", __func__,
-                         tx->GetHash().ToString(), it->first.ToString());
-                islock = it->second.islock;
-                pendingInstantSendLocks.try_emplace(it->first, it->second);
-                pendingNoTxInstantSendLocks.erase(it);
-                break;
-            }
-            ++it;
-        }
+    db.WriteNewInstantSendLock(hash, islock);
+    if (minedHeight.has_value()) {
+        db.WriteInstantSendLockMined(hash, *minedHeight);
     }
+}
 
-    if (islock == nullptr) {
-        if (auto signer = m_signer.load(std::memory_order_acquire); signer) {
-            signer->ProcessTx(*tx, false, Params().GetConsensus());
-        }
-        // TX is not locked, so make sure it is tracked
-        AddNonLockedTx(tx, nullptr);
-    } else {
-        RemoveMempoolConflictsForLock(::SerializeHash(*islock), *islock);
-    }
+void CInstantSendManager::AddPendingISLock(const uint256& hash, const instantsend::InstantSendLockPtr& islock, NodeId from)
+{
+    // put it in a separate pending map and try again later
+    LOCK(cs_pendingLocks);
+    pendingNoTxInstantSendLocks.try_emplace(hash, instantsend::PendingISLockFromPeer{from, islock});
 }
 
-void CInstantSendManager::TransactionRemovedFromMempool(const CTransactionRef& tx)
+void CInstantSendManager::TransactionIsRemoved(const CTransactionRef& tx)
 {
     if (tx->vin.empty()) {
         return;
     }
 
-    instantsend::InstantSendLockPtr islock = db.GetInstantSendLockByTxid(tx->GetHash());
+    instantsend::InstantSendLockPtr islock = GetInstantSendLockByTxid(tx->GetHash());
 
     if (islock == nullptr) {
         return;
@@ -252,49 +130,31 @@ void CInstantSendManager::TransactionRemovedFromMempool(const CTransactionRef& t
     RemoveConflictingLock(::SerializeHash(*islock), *islock);
 }
 
-void CInstantSendManager::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
+void CInstantSendManager::WriteBlockISLocks(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
 {
-    if (!IsInstantSendEnabled()) {
-        return;
-    }
-
-    CacheTipHeight(pindex);
-
-    if (m_mn_sync.IsBlockchainSynced()) {
-        const bool has_chainlock = m_chainlocks.HasChainLock(pindex->nHeight, pindex->GetBlockHash());
-        for (const auto& tx : pblock->vtx) {
-            if (tx->IsCoinBase() || tx->vin.empty()) {
-                // coinbase and TXs with no inputs can't be locked
-                continue;
-            }
-
-            if (!IsLocked(tx->GetHash()) && !has_chainlock) {
-                if (auto signer = m_signer.load(std::memory_order_acquire); signer) {
-                    signer->ProcessTx(*tx, true, Params().GetConsensus());
-                }
-                // TX is not locked, so make sure it is tracked
-                AddNonLockedTx(tx, pindex);
-            } else {
-                // TX is locked, so make sure we don't track it anymore
-                RemoveNonLockedTx(tx->GetHash(), true);
-            }
-        }
-    }
-
     db.WriteBlockInstantSendLocks(pblock, pindex);
 }
 
-void CInstantSendManager::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock,
-                                            const CBlockIndex* pindexDisconnected)
+void CInstantSendManager::RemoveBlockISLocks(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
 {
-    {
-        LOCK(cs_height_cache);
-        m_cached_block_heights.erase(pindexDisconnected->GetBlockHash());
-    }
+    db.RemoveBlockInstantSendLocks(pblock, pindex);
+}
 
-    CacheTipHeight(pindexDisconnected->pprev);
+instantsend::InstantSendLockPtr CInstantSendManager::AttachISLockToTx(const CTransactionRef& tx)
+{
+    LOCK(cs_pendingLocks);
+    for (auto it = pendingNoTxInstantSendLocks.begin(); it != pendingNoTxInstantSendLocks.end(); ++it) {
+        if (it->second.islock->txid != tx->GetHash()) continue;
 
-    db.RemoveBlockInstantSendLocks(pblock, pindexDisconnected);
+        // we received an islock earlier, let's put it back into pending and verify/lock
+        LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s\n", __func__,
+                 tx->GetHash().ToString(), it->first.ToString());
+        auto islock = it->second.islock;
+        pendingInstantSendLocks.try_emplace(it->first, it->second);
+        pendingNoTxInstantSendLocks.erase(it);
+        return islock;
+    }
+    return nullptr;
 }
 
 void CInstantSendManager::AddNonLockedTx(const CTransactionRef& tx, const CBlockIndex* pindexMined)
@@ -313,22 +173,7 @@ void CInstantSendManager::AddNonLockedTx(const CTransactionRef& tx, const CBlock
             }
         }
     }
-    {
-        LOCK(cs_pendingLocks);
-        auto it = pendingNoTxInstantSendLocks.begin();
-        while (it != pendingNoTxInstantSendLocks.end()) {
-            if (it->second.islock->txid == tx->GetHash()) {
-                // we received an islock earlier, let's put it back into pending and verify/lock
-                LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s\n", __func__,
-                         tx->GetHash().ToString(), it->first.ToString());
-                pendingInstantSendLocks.try_emplace(it->first, it->second);
-                pendingNoTxInstantSendLocks.erase(it);
-                break;
-            }
-            ++it;
-        }
-    }
-
+    AttachISLockToTx(tx);
     if (ShouldReportISLockTiming()) {
         LOCK(cs_timingsTxSeen);
         // Only insert the time the first time we see the tx, as we sometimes try to resign
@@ -397,25 +242,6 @@ std::vector<CTransactionRef> CInstantSendManager::PrepareTxToRetry()
     return txns;
 }
 
-void CInstantSendManager::RemoveConflictedTx(const CTransaction& tx)
-{
-    RemoveNonLockedTx(tx.GetHash(), false);
-    if (auto signer = m_signer.load(std::memory_order_acquire); signer) {
-        signer->ClearInputsFromQueue(GetIdsFromLockable(tx.vin));
-    }
-}
-
-void CInstantSendManager::TruncateRecoveredSigsForInputs(const instantsend::InstantSendLock& islock)
-{
-    auto ids = GetIdsFromLockable(islock.inputs);
-    if (auto signer = m_signer.load(std::memory_order_acquire); signer) {
-        signer->ClearInputsFromQueue(ids);
-    }
-    for (const auto& id : ids) {
-        sigman.TruncateRecoveredSig(Params().GetConsensus().llmqTypeDIP0024InstantSend, id);
-    }
-}
-
 void CInstantSendManager::TryEmplacePendingLock(const uint256& hash, const NodeId id,
                                                 const instantsend::InstantSendLockPtr& islock)
 {
@@ -426,103 +252,8 @@ void CInstantSendManager::TryEmplacePendingLock(const uint256& hash, const NodeI
     }
 }
 
-void CInstantSendManager::NotifyChainLock(const CBlockIndex* pindexChainLock)
-{
-    HandleFullyConfirmedBlock(pindexChainLock);
-}
-
-void CInstantSendManager::UpdatedBlockTip(const CBlockIndex* pindexNew)
-{
-    CacheTipHeight(pindexNew);
-
-    bool fDIP0008Active = pindexNew->pprev && pindexNew->pprev->nHeight >= Params().GetConsensus().DIP0008Height;
-
-    if (m_chainlocks.IsEnabled() && fDIP0008Active) {
-        // Nothing to do here. We should keep all islocks and let chainlocks handle them.
-        return;
-    }
-
-    int nConfirmedHeight = pindexNew->nHeight - Params().GetConsensus().nInstantSendKeepLock;
-    const CBlockIndex* pindex = pindexNew->GetAncestor(nConfirmedHeight);
-
-    if (pindex) {
-        HandleFullyConfirmedBlock(pindex);
-    }
-}
-
-void CInstantSendManager::HandleFullyConfirmedBlock(const CBlockIndex* pindex)
-{
-    if (!IsInstantSendEnabled()) {
-        return;
-    }
-
-    auto removeISLocks = db.RemoveConfirmedInstantSendLocks(pindex->nHeight);
-
-    for (const auto& [islockHash, islock] : removeISLocks) {
-        LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s: removed islock as it got fully confirmed\n", __func__,
-                 islock->txid.ToString(), islockHash.ToString());
-
-        // No need to keep recovered sigs for fully confirmed IS locks, as there is no chance for conflicts
-        // from now on. All inputs are spent now and can't be spend in any other TX.
-        TruncateRecoveredSigsForInputs(*islock);
-
-        // And we don't need the recovered sig for the ISLOCK anymore, as the block in which it got mined is considered
-        // fully confirmed now
-        sigman.TruncateRecoveredSig(Params().GetConsensus().llmqTypeDIP0024InstantSend, islock->GetRequestId());
-    }
-
-    db.RemoveArchivedInstantSendLocks(pindex->nHeight - 100);
-
-    // Find all previously unlocked TXs that got locked by this fully confirmed (ChainLock) block and remove them
-    // from the nonLockedTxs map. Also collect all children of these TXs and mark them for retrying of IS locking.
-    std::vector<uint256> toRemove;
-    {
-        LOCK(cs_nonLocked);
-        for (const auto& p : nonLockedTxs) {
-            const auto* pindexMined = p.second.pindexMined;
-
-            if (pindexMined && pindex->GetAncestor(pindexMined->nHeight) == pindexMined) {
-                toRemove.emplace_back(p.first);
-            }
-        }
-    }
-    for (const auto& txid : toRemove) {
-        // This will also add children to pendingRetryTxs
-        RemoveNonLockedTx(txid, true);
-    }
-}
-
-void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, const instantsend::InstantSendLock& islock)
-{
-    Uint256HashMap<CTransactionRef> toDelete;
-
-    {
-        LOCK(mempool.cs);
-
-        for (const auto& in : islock.inputs) {
-            auto it = mempool.mapNextTx.find(in);
-            if (it == mempool.mapNextTx.end()) {
-                continue;
-            }
-            if (it->second->GetHash() != islock.txid) {
-                toDelete.emplace(it->second->GetHash(), mempool.get(it->second->GetHash()));
-
-                LogPrintf("CInstantSendManager::%s -- txid=%s, islock=%s: mempool TX %s with input %s conflicts with islock\n", __func__,
-                          islock.txid.ToString(), hash.ToString(), it->second->GetHash().ToString(), in.ToStringShort());
-            }
-        }
-
-        for (const auto& p : toDelete) {
-            mempool.removeRecursive(*p.second, MemPoolRemovalReason::CONFLICT);
-        }
-    }
-
-    for (const auto& p : toDelete) {
-        RemoveConflictedTx(*p.second);
-    }
-}
-
-void CInstantSendManager::ResolveBlockConflicts(const uint256& islockHash, const instantsend::InstantSendLock& islock)
+std::unordered_map<const CBlockIndex*, Uint256HashMap<CTransactionRef>> CInstantSendManager::RetrieveISConflicts(
+    const uint256& islockHash, const instantsend::InstantSendLock& islock)
 {
     // Lets first collect all non-locked TXs which conflict with the given ISLOCK
     std::unordered_map<const CBlockIndex*, Uint256HashMap<CTransactionRef>> conflicts;
@@ -550,65 +281,13 @@ void CInstantSendManager::ResolveBlockConflicts(const uint256& islockHash, const
         }
     }
 
-    // Lets see if any of the conflicts was already mined into a ChainLocked block
-    bool hasChainLockedConflict = false;
-    for (const auto& p : conflicts) {
-        const auto* pindex = p.first;
-        if (m_chainlocks.HasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
-            hasChainLockedConflict = true;
-            break;
-        }
-    }
-
-    // If a conflict was mined into a ChainLocked block, then we have no other choice and must prune the ISLOCK and all
-    // chained ISLOCKs that build on top of this one. The probability of this is practically zero and can only happen
-    // when large parts of the masternode network are controlled by an attacker. In this case we must still find
-    // consensus and its better to sacrifice individual ISLOCKs then to sacrifice whole ChainLocks.
-    if (hasChainLockedConflict) {
-        LogPrintf("CInstantSendManager::%s -- txid=%s, islock=%s: at least one conflicted TX already got a ChainLock\n",
-                  __func__, islock.txid.ToString(), islockHash.ToString());
-        RemoveConflictingLock(islockHash, islock);
-        return;
-    }
-
-    bool isLockedTxKnown = WITH_LOCK(cs_pendingLocks, return pendingNoTxInstantSendLocks.find(islockHash) ==
-                                                             pendingNoTxInstantSendLocks.end());
-
-    bool activateBestChain = false;
-    for (const auto& p : conflicts) {
-        const auto* pindex = p.first;
-        for (const auto& p2 : p.second) {
-            const auto& tx = *p2.second;
-            RemoveConflictedTx(tx);
-        }
-
-        LogPrintf("CInstantSendManager::%s -- invalidating block %s\n", __func__, pindex->GetBlockHash().ToString());
-
-        BlockValidationState state;
-        // need non-const pointer
-        auto pindex2 = WITH_LOCK(::cs_main, return m_chainstate.m_blockman.LookupBlockIndex(pindex->GetBlockHash()));
-        if (!m_chainstate.InvalidateBlock(state, pindex2)) {
-            LogPrintf("CInstantSendManager::%s -- InvalidateBlock failed: %s\n", __func__, state.ToString());
-            // This should not have happened and we are in a state were it's not safe to continue anymore
-            assert(false);
-        }
-        if (isLockedTxKnown) {
-            activateBestChain = true;
-        } else {
-            LogPrintf("CInstantSendManager::%s -- resetting block %s\n", __func__, pindex2->GetBlockHash().ToString());
-            LOCK(::cs_main);
-            m_chainstate.ResetBlockFailureFlags(pindex2);
-        }
-    }
+    return conflicts;
+}
 
-    if (activateBestChain) {
-        BlockValidationState state;
-        if (!m_chainstate.ActivateBestChain(state)) {
-            LogPrintf("CInstantSendManager::%s -- ActivateBestChain failed: %s\n", __func__, state.ToString());
-            // This should not have happened and we are in a state were it's not safe to continue anymore
-            assert(false);
-        }
-    }
+bool CInstantSendManager::HasTxForLock(const uint256& islockHash) const
+{
+    LOCK(cs_pendingLocks);
+    return pendingNoTxInstantSendLocks.find(islockHash) == pendingNoTxInstantSendLocks.end();
 }
 
 void CInstantSendManager::RemoveConflictingLock(const uint256& islockHash, const instantsend::InstantSendLock& islock)
@@ -737,43 +416,33 @@ CInstantSendManager::Counts CInstantSendManager::GetCounts() const
     return ret;
 }
 
-void CInstantSendManager::CacheBlockHeightInternal(const CBlockIndex* const block_index) const
+void CInstantSendManager::CacheBlockHeight(const CBlockIndex* const block_index) const
 {
-    AssertLockHeld(cs_height_cache);
+    LOCK(cs_height_cache);
     m_cached_block_heights.insert(block_index->GetBlockHash(), block_index->nHeight);
 }
 
-void CInstantSendManager::CacheBlockHeight(const CBlockIndex* const block_index) const
+void CInstantSendManager::CacheDisconnectBlock(const CBlockIndex* pindexDisconnected)
 {
     LOCK(cs_height_cache);
-    CacheBlockHeightInternal(block_index);
+    m_cached_block_heights.erase(pindexDisconnected->GetBlockHash());
 }
 
-std::optional<int> CInstantSendManager::GetBlockHeight(const uint256& hash) const
+std::optional<int> CInstantSendManager::GetCachedHeight(const uint256& hash) const
 {
-    if (hash.IsNull()) {
-        return std::nullopt;
-    }
-    {
-        LOCK(cs_height_cache);
-        int cached_height{0};
-        if (m_cached_block_heights.get(hash, cached_height)) return cached_height;
-    }
+    LOCK(cs_height_cache);
 
-    const CBlockIndex* pindex = WITH_LOCK(::cs_main, return m_chainstate.m_blockman.LookupBlockIndex(hash));
-    if (pindex == nullptr) {
-        return std::nullopt;
-    }
+    int cached_height{0};
+    if (m_cached_block_heights.get(hash, cached_height)) return cached_height;
 
-    CacheBlockHeight(pindex);
-    return pindex->nHeight;
+    return std::nullopt;
 }
 
 void CInstantSendManager::CacheTipHeight(const CBlockIndex* const tip) const
 {
     LOCK(cs_height_cache);
     if (tip) {
-        CacheBlockHeightInternal(tip);
+        m_cached_block_heights.insert(tip->GetBlockHash(), tip->nHeight);
         m_cached_tip_height = tip->nHeight;
     } else {
         m_cached_tip_height = -1;
@@ -782,17 +451,14 @@ void CInstantSendManager::CacheTipHeight(const CBlockIndex* const tip) const
 
 int CInstantSendManager::GetTipHeight() const
 {
-    {
-        LOCK(cs_height_cache);
-        if (m_cached_tip_height >= 0) {
-            return m_cached_tip_height;
-        }
+    // It returns the cached tip height which is updated through notification mechanism
+    // If cached tip is not set by any reason, it's okay to return 0 because
+    // chainstate is not fully loaded yet and tip is not set
+    LOCK(cs_height_cache);
+    if (m_cached_tip_height >= 0) {
+        return m_cached_tip_height;
     }
-
-    const CBlockIndex* tip = WITH_LOCK(::cs_main, return m_chainstate.m_chain.Tip());
-
-    CacheTipHeight(tip);
-    return tip ? tip->nHeight : -1;
+    return 0;
 }
 
 bool CInstantSendManager::IsInstantSendEnabled() const
@@ -802,13 +468,38 @@ bool CInstantSendManager::IsInstantSendEnabled() const
 
 bool CInstantSendManager::RejectConflictingBlocks() const
 {
-    if (!m_mn_sync.IsBlockchainSynced()) {
-        return false;
-    }
     if (!spork_manager.IsSporkActive(SPORK_3_INSTANTSEND_BLOCK_FILTERING)) {
         LogPrint(BCLog::INSTANTSEND, "%s: spork3 is off, skipping transaction locking checks\n", __func__);
         return false;
     }
     return true;
 }
+
+Uint256HashMap<instantsend::InstantSendLockPtr> CInstantSendManager::RemoveConfirmedInstantSendLocks(const CBlockIndex* pindex)
+{
+    int nUntilHeight = pindex->nHeight;
+    auto removeISLocks = db.RemoveConfirmedInstantSendLocks(nUntilHeight);
+
+    db.RemoveArchivedInstantSendLocks(nUntilHeight - 100);
+
+    // Find all previously unlocked TXs that got locked by this fully confirmed (ChainLock) block and remove them
+    // from the nonLockedTxs map. Also collect all children of these TXs and mark them for retrying of IS locking.
+    std::vector<uint256> toRemove;
+    {
+        LOCK(cs_nonLocked);
+        for (const auto& p : nonLockedTxs) {
+            const auto* pindexMined = p.second.pindexMined;
+
+            if (pindexMined && pindex->GetAncestor(pindexMined->nHeight) == pindexMined) {
+                toRemove.emplace_back(p.first);
+            }
+        }
+    }
+    for (const auto& txid : toRemove) {
+        // This will also add children to pendingRetryTxs
+        RemoveNonLockedTx(txid, true);
+    }
+
+    return removeISLocks;
+}
 } // namespace llmq
diff --git a/src/instantsend/instantsend.h b/src/instantsend/instantsend.h
index dde3739d6030..4bdfc8d2d4a4 100644
--- a/src/instantsend/instantsend.h
+++ b/src/instantsend/instantsend.h
@@ -7,42 +7,29 @@
 
 #include <instantsend/db.h>
 #include <instantsend/lock.h>
-#include <instantsend/signing.h>
 
 #include <net_types.h>
-#include <primitives/transaction.h>
 #include <protocol.h>
+#include <saltedhasher.h>
 #include <sync.h>
 #include <threadsafety.h>
 #include <unordered_lru_cache.h>
 
-#include <atomic>
 #include <optional>
-#include <unordered_set>
-#include <variant>
 #include <vector>
 
-#include <saltedhasher.h>
-
 class CBlockIndex;
-class CChainState;
 class CDataStream;
-class CMasternodeSync;
 class CSporkManager;
-class CTxMemPool;
 namespace Consensus {
 struct LLMQParams;
 } // namespace Consensus
 namespace util {
 struct DbWrapperParams;
 } // namespace util
-
-namespace chainlock {
-class Chainlocks;
-}
+typedef std::shared_ptr<const CTransaction> CTransactionRef;
 
 namespace instantsend {
-class InstantSendSigner;
 
 struct PendingISLockFromPeer {
     NodeId node_id;
@@ -60,21 +47,12 @@ struct PendingState {
 } // namespace instantsend
 
 namespace llmq {
-class CSigningManager;
 
-class CInstantSendManager final : public instantsend::InstantSendSignerParent
+class CInstantSendManager
 {
 private:
     instantsend::CInstantSendDb db;
-
-    const chainlock::Chainlocks& m_chainlocks;
-    CChainState& m_chainstate;
-    CSigningManager& sigman;
     CSporkManager& spork_manager;
-    CTxMemPool& mempool;
-    const CMasternodeSync& m_mn_sync;
-
-    std::atomic<instantsend::InstantSendSigner*> m_signer{nullptr};
 
     mutable Mutex cs_pendingLocks;
     // Incoming and not verified yet
@@ -106,48 +84,28 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent
         GUARDED_BY(cs_height_cache);
     mutable int m_cached_tip_height GUARDED_BY(cs_height_cache){-1};
 
-    void CacheBlockHeightInternal(const CBlockIndex* const block_index) const EXCLUSIVE_LOCKS_REQUIRED(cs_height_cache);
-
 public:
     CInstantSendManager() = delete;
     CInstantSendManager(const CInstantSendManager&) = delete;
     CInstantSendManager& operator=(const CInstantSendManager&) = delete;
-    explicit CInstantSendManager(const chainlock::Chainlocks& chainlocks, CChainState& chainstate,
-                                 CSigningManager& _sigman, CSporkManager& sporkman, CTxMemPool& _mempool,
-                                 const CMasternodeSync& mn_sync, const util::DbWrapperParams& db_params);
+    explicit CInstantSendManager(CSporkManager& sporkman, const util::DbWrapperParams& db_params);
     ~CInstantSendManager();
 
-    void ConnectSigner(gsl::not_null<instantsend::InstantSendSigner*> signer)
-    {
-        // Prohibit double initialization
-        assert(m_signer.load(std::memory_order_acquire) == nullptr);
-        m_signer.store(signer, std::memory_order_release);
-    }
-    void DisconnectSigner() { m_signer.store(nullptr, std::memory_order_release); }
-
-    instantsend::InstantSendSigner* Signer() const { return m_signer.load(std::memory_order_acquire); }
-
-private:
     void AddNonLockedTx(const CTransactionRef& tx, const CBlockIndex* pindexMined)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_timingsTxSeen);
     void RemoveNonLockedTx(const uint256& txid, bool retryChildren)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
-    void RemoveConflictedTx(const CTransaction& tx)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
-    void TruncateRecoveredSigsForInputs(const instantsend::InstantSendLock& islock);
 
-    void RemoveMempoolConflictsForLock(const uint256& hash, const instantsend::InstantSendLock& islock)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
-    void ResolveBlockConflicts(const uint256& islockHash, const instantsend::InstantSendLock& islock)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry, !cs_height_cache);
+    instantsend::InstantSendLockPtr AttachISLockToTx(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
 
-    void HandleFullyConfirmedBlock(const CBlockIndex* pindex)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
+    std::unordered_map<const CBlockIndex*, Uint256HashMap<CTransactionRef>> RetrieveISConflicts(
+        const uint256& islockHash, const instantsend::InstantSendLock& islock)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks);
+    bool HasTxForLock(const uint256& islockHash) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
 
-public:
-    bool IsLocked(const uint256& txHash) const override;
+    bool IsLocked(const uint256& txHash) const;
     bool IsWaitingForTx(const uint256& txHash) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
-    instantsend::InstantSendLockPtr GetConflictingLock(const CTransaction& tx) const override;
+    instantsend::InstantSendLockPtr GetConflictingLock(const CTransaction& tx) const;
 
     /* Helpers for communications between CInstantSendManager & NetInstantSend */
     // This helper returns up to 32 pending locks and remove them from queue of pending
@@ -156,32 +114,24 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
     [[nodiscard]] std::vector<CTransactionRef> PrepareTxToRetry()
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
-    CSigningManager& Sigman() { return sigman; }
-    [[nodiscard]] std::variant<uint256, CTransactionRef, std::monostate> ProcessInstantSendLock(
-        NodeId from, const uint256& hash, const instantsend::InstantSendLockPtr& islock)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry, !cs_height_cache);
-
-    void TransactionAddedToMempool(const CTransactionRef& tx)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry, !cs_timingsTxSeen);
-    void TransactionRemovedFromMempool(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
-    void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry, !cs_timingsTxSeen, !cs_height_cache);
-    void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
+
+    void RemoveBlockISLocks(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex);
+    void WriteBlockISLocks(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex);
+    void WriteNewISLock(const uint256& hash, const instantsend::InstantSendLockPtr& islock, std::optional<int> minedHeight);
+    void AddPendingISLock(const uint256& hash, const instantsend::InstantSendLockPtr& islock, NodeId from)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
+
+    bool PreVerifyIsLock(const uint256& hash, const instantsend::InstantSendLockPtr& islock, NodeId from) const;
 
     bool AlreadyHave(const CInv& inv) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
     bool GetInstantSendLockByHash(const uint256& hash, instantsend::InstantSendLock& ret) const
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
     instantsend::InstantSendLockPtr GetInstantSendLockByTxid(const uint256& txid) const;
 
-    void NotifyChainLock(const CBlockIndex* pindexChainLock)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
-    void UpdatedBlockTip(const CBlockIndex* pindexNew)
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry, !cs_height_cache);
-
+    void TransactionIsRemoved(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
     void RemoveConflictingLock(const uint256& islockHash, const instantsend::InstantSendLock& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
-    void TryEmplacePendingLock(const uint256& hash, const NodeId id, const instantsend::InstantSendLockPtr& islock) override
+    void TryEmplacePendingLock(const uint256& hash, const NodeId id, const instantsend::InstantSendLockPtr& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
 
     size_t GetInstantSendLockCount() const;
@@ -195,17 +145,20 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent
     Counts GetCounts() const EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks, !cs_nonLocked);
 
     void CacheBlockHeight(const CBlockIndex* const block_index) const EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
-    std::optional<int> GetBlockHeight(const uint256& hash) const override EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
+    void CacheDisconnectBlock(const CBlockIndex* pindexDisconnected) EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
+    std::optional<int> GetCachedHeight(const uint256& hash) const EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
     void CacheTipHeight(const CBlockIndex* const tip) const EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
-    int GetTipHeight() const override EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
+    int GetTipHeight() const EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
 
-    bool IsInstantSendEnabled() const override;
+    bool IsInstantSendEnabled() const;
     /**
      * If true, MN should sign all transactions, if false, MN should not sign
      * transactions in mempool, but should sign txes included in a block. This
      * allows ChainLocks to continue even while this spork is disabled.
      */
     bool RejectConflictingBlocks() const;
+    Uint256HashMap<instantsend::InstantSendLockPtr> RemoveConfirmedInstantSendLocks(const CBlockIndex* pindex)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
 };
 } // namespace llmq
 
diff --git a/src/instantsend/net_instantsend.cpp b/src/instantsend/net_instantsend.cpp
index 64fcfd0fd8ee..2520eb615364 100644
--- a/src/instantsend/net_instantsend.cpp
+++ b/src/instantsend/net_instantsend.cpp
@@ -5,19 +5,30 @@
 #include <instantsend/net_instantsend.h>
 
 #include <bls/bls_batchverifier.h>
-#include <node/interface_ui.h>
+#include <chainlock/chainlock.h>
+#include <consensus/params.h>
 #include <cxxtimer.hpp>
 #include <instantsend/instantsend.h>
+#include <instantsend/signing.h>
 #include <llmq/commitment.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
+#include <masternode/sync.h>
+#include <node/interface_ui.h>
 #include <util/thread.h>
 #include <validation.h>
 
 #include <chrono>
 #include <set>
 
+// Forward declaration to break dependency over node/transaction.h
+namespace node {
+CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const m_mempool,
+                               const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock);
+} // namespace node
+
+using node::GetTransaction;
 namespace {
 constexpr int BATCH_VERIFIER_SOURCE_THRESHOLD{8};
 constexpr int INVALID_ISLOCK_MISBEHAVIOR_SCORE{100};
@@ -26,6 +37,23 @@ constexpr int OLD_ACTIVE_SET_FAILURE_MISBEHAVIOR_SCORE{20};
 constexpr auto WORK_THREAD_SLEEP_INTERVAL{std::chrono::milliseconds{100}};
 } // namespace
 
+static std::optional<int> GetBlockHeight(llmq::CInstantSendManager& is_manager, const CChainState& chainstate,
+                                         const uint256& hash)
+{
+    if (hash.IsNull()) {
+        return std::nullopt;
+    }
+    auto ret = is_manager.GetCachedHeight(hash);
+    if (ret) return ret;
+
+    const CBlockIndex* pindex = WITH_LOCK(::cs_main, return chainstate.m_blockman.LookupBlockIndex(hash));
+    if (pindex == nullptr) {
+        return std::nullopt;
+    }
+    is_manager.CacheBlockHeight(pindex);
+    return pindex->nHeight;
+}
+
 struct NetInstantSend::BatchVerificationData {
     CBLSBatchVerifier<NodeId, uint256> batchVerifier{false, true, BATCH_VERIFIER_SOURCE_THRESHOLD};
     Uint256HashMap<llmq::CRecoveredSig> recSigs;
@@ -45,7 +73,7 @@ bool NetInstantSend::ValidateIncomingISLock(const instantsend::InstantSendLock&
 
 std::optional<int> NetInstantSend::ResolveCycleHeight(const uint256& cycle_hash)
 {
-    auto cycle_height = m_is_manager.GetBlockHeight(cycle_hash);
+    auto cycle_height = GetBlockHeight(m_is_manager, m_chainstate, cycle_hash);
     if (cycle_height) {
         return cycle_height;
     }
@@ -98,12 +126,12 @@ std::unique_ptr<NetInstantSend::BatchVerificationData> NetInstantSend::BuildVeri
         auto id = islock->GetRequestId();
 
         // no need to verify an ISLOCK if we already have verified the recovered sig that belongs to it
-        if (m_is_manager.Sigman().HasRecoveredSig(llmq_params.type, id, islock->txid)) {
+        if (m_sigman.HasRecoveredSig(llmq_params.type, id, islock->txid)) {
             data->alreadyVerified++;
             continue;
         }
 
-        auto cycleHeightOpt = m_is_manager.GetBlockHeight(islock->cycleHash);
+        auto cycleHeightOpt = GetBlockHeight(m_is_manager, m_chainstate, islock->cycleHash);
         if (!cycleHeightOpt) {
             data->batchVerifier.badSources.emplace(nodeId);
             continue;
@@ -132,7 +160,7 @@ std::unique_ptr<NetInstantSend::BatchVerificationData> NetInstantSend::BuildVeri
         // We can reconstruct the CRecoveredSig objects from the islock and pass it to the signing manager, which
         // avoids unnecessary double-verification of the signature. We however only do this when verification here
         // turns out to be good (which is checked further down)
-        if (!m_is_manager.Sigman().HasRecoveredSigForId(llmq_params.type, id)) {
+        if (!m_sigman.HasRecoveredSigForId(llmq_params.type, id)) {
             data->recSigs.try_emplace(hash, llmq::CRecoveredSig(llmq_params.type, quorum->qc->quorumHash, id, islock->txid,
                                                                 islock->sig));
         }
@@ -172,27 +200,18 @@ Uint256HashSet NetInstantSend::ApplyVerificationResults(
             continue;
         }
 
-        CInv inv(MSG_ISDLOCK, hash);
-        auto ret = m_is_manager.ProcessInstantSendLock(nodeId, hash, islock);
-        if (std::holds_alternative<uint256>(ret)) {
-            m_peer_manager->PeerRelayInvFiltered(inv, std::get<uint256>(ret));
-            m_peer_manager->PeerAskPeersForTransaction(islock->txid);
-        } else if (std::holds_alternative<CTransactionRef>(ret)) {
-            m_peer_manager->PeerRelayInvFiltered(inv, *std::get<CTransactionRef>(ret));
-        } else {
-            assert(std::holds_alternative<std::monostate>(ret));
-        }
+        ProcessInstantSendLock(nodeId, hash, islock);
 
         // Pass a reconstructed recovered sig to the signing manager to avoid double-verification of the sig.
         auto it = data.recSigs.find(hash);
         if (it != data.recSigs.end()) {
             auto recSig = std::make_shared<llmq::CRecoveredSig>(std::move(it->second));
-            if (!m_is_manager.Sigman().HasRecoveredSigForId(llmq_params.type, recSig->getId())) {
+            if (!m_sigman.HasRecoveredSigForId(llmq_params.type, recSig->getId())) {
                 LogPrint(BCLog::INSTANTSEND, /* Continued */
                          "NetInstantSend::%s -- txid=%s, islock=%s: "
                          "passing reconstructed recSig to signing mgr, peer=%d\n",
                          __func__, islock->txid.ToString(), hash.ToString(), nodeId);
-                m_is_manager.Sigman().PushReconstructedRecoveredSig(recSig);
+                m_sigman.PushReconstructedRecoveredSig(recSig);
             }
         }
     }
@@ -200,6 +219,27 @@ Uint256HashSet NetInstantSend::ApplyVerificationResults(
     return badISLocks;
 }
 
+namespace {
+template <typename T>
+    requires std::same_as<T, CTxIn> || std::same_as<T, COutPoint>
+Uint256HashSet GetIdsFromLockable(const std::vector<T>& vec)
+{
+    Uint256HashSet ret{};
+    if (vec.empty()) return ret;
+    ret.reserve(vec.size());
+    for (const auto& in : vec) {
+        if constexpr (std::is_same_v<T, COutPoint>) {
+            ret.emplace(instantsend::GenInputLockRequestId(in));
+        } else if constexpr (std::is_same_v<T, CTxIn>) {
+            ret.emplace(instantsend::GenInputLockRequestId(in.prevout));
+        } else {
+            assert(false);
+        }
+    }
+    return ret;
+}
+} // anonymous namespace
+
 void NetInstantSend::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv)
 {
     if (msg_type != NetMsgType::ISDLOCK) {
@@ -282,7 +322,6 @@ Uint256HashSet NetInstantSend::ProcessPendingInstantSendLocks(
     return ApplyVerificationResults(llmq_params, ban, *batch, pend);
 }
 
-
 void NetInstantSend::ProcessPendingISLocks(std::vector<instantsend::PendingISLockEntry>&& locks_to_process)
 {
     // TODO Investigate if leaving this is ok
@@ -311,6 +350,61 @@ void NetInstantSend::ProcessPendingISLocks(std::vector<instantsend::PendingISLoc
     uiInterface.NotifyInstantSendChanged();
 }
 
+void NetInstantSend::ProcessInstantSendLock(NodeId from, const uint256& hash, const instantsend::InstantSendLockPtr& islock)
+{
+    LogPrint(BCLog::INSTANTSEND, "NetInstantSend::%s -- txid=%s, islock=%s: processing islock, peer=%d\n", __func__,
+             islock->txid.ToString(), hash.ToString(), from);
+
+    if (m_signer) {
+        m_signer->ClearLockFromQueue(islock);
+    }
+    if (!m_is_manager.PreVerifyIsLock(hash, islock, from)) return;
+
+    uint256 hashBlock{};
+    auto tx = GetTransaction(nullptr, &m_mempool, islock->txid, Params().GetConsensus(), hashBlock);
+    const bool found_transaction{tx != nullptr};
+    // we ignore failure here as we must be able to propagate the lock even if we don't have the TX locally
+    const auto minedHeight = GetBlockHeight(m_is_manager, m_chainstate, hashBlock);
+    if (found_transaction) {
+        // Let's see if the TX that was locked by this islock is already mined in a ChainLocked block. If yes,
+        // we can simply ignore the islock, as the ChainLock implies locking of all TXs in that chain
+        if (minedHeight.has_value() && m_chainlocks.HasChainLock(*minedHeight, hashBlock)) {
+            LogPrint(BCLog::INSTANTSEND, /* Continued */
+                     "NetInstantSend::%s -- txlock=%s, islock=%s: dropping islock as it already got a "
+                     "ChainLock in block %s, peer=%d\n",
+                     __func__, islock->txid.ToString(), hash.ToString(), hashBlock.ToString(), from);
+            return;
+        }
+        m_is_manager.WriteNewISLock(hash, islock, minedHeight);
+    } else {
+        m_is_manager.AddPendingISLock(hash, islock, from);
+    }
+
+    // This will also add children TXs to pendingRetryTxs
+    m_is_manager.RemoveNonLockedTx(islock->txid, true);
+    // We don't need the recovered sigs for the inputs anymore. This prevents unnecessary propagation of these sigs.
+    // We only need the ISLOCK from now on to detect conflicts
+    TruncateRecoveredSigsForInputs(*islock);
+    ResolveBlockConflicts(hash, *islock);
+
+    if (found_transaction) {
+        RemoveMempoolConflictsForLock(hash, *islock);
+        LogPrint(BCLog::INSTANTSEND, "NetInstantSend::%s -- notify about lock %s for tx %s\n", __func__,
+                 hash.ToString(), tx->GetHash().ToString());
+        GetMainSignals().NotifyTransactionLock(tx, islock);
+        // bump m_mempool counter to make sure newly locked txes are picked up by getblocktemplate
+        m_mempool.AddTransactionsUpdated(1);
+    }
+
+    CInv inv(MSG_ISDLOCK, hash);
+    if (found_transaction) {
+        m_peer_manager->PeerRelayInvFiltered(inv, *tx);
+    } else {
+        m_peer_manager->PeerRelayInvFiltered(inv, islock->txid);
+        m_peer_manager->PeerAskPeersForTransaction(islock->txid);
+    }
+}
+
 void NetInstantSend::WorkThreadMain()
 {
     while (!workInterrupt) {
@@ -321,8 +415,8 @@ void NetInstantSend::WorkThreadMain()
             if (!locks.empty()) {
                 ProcessPendingISLocks(std::move(locks));
             }
-            if (auto signer = m_is_manager.Signer(); signer) {
-                signer->ProcessPendingRetryLockTxs(m_is_manager.PrepareTxToRetry());
+            if (m_signer) {
+                m_signer->ProcessPendingRetryLockTxs(m_is_manager.PrepareTxToRetry());
             }
             return more_work;
         }();
@@ -332,3 +426,223 @@ void NetInstantSend::WorkThreadMain()
         }
     }
 }
+
+void NetInstantSend::TransactionAddedToMempool(const CTransactionRef& tx, int64_t, uint64_t mempool_sequence)
+{
+    if (!m_is_manager.IsInstantSendEnabled() || !m_mn_sync.IsBlockchainSynced() || tx->vin.empty()) {
+        return;
+    }
+
+    instantsend::InstantSendLockPtr islock = m_is_manager.AttachISLockToTx(tx);
+    if (islock == nullptr) {
+        if (m_signer) {
+            m_signer->ProcessTx(*tx, false, Params().GetConsensus());
+        }
+        // TX is not locked, so make sure it is tracked
+        m_is_manager.AddNonLockedTx(tx, nullptr);
+    } else {
+        RemoveMempoolConflictsForLock(::SerializeHash(*islock), *islock);
+    }
+}
+
+void NetInstantSend::ClearConflicting(const Uint256HashMap<CTransactionRef>& to_delete)
+{
+    for (const auto& [_, tx] : to_delete) {
+        m_is_manager.RemoveNonLockedTx(tx->GetHash(), false);
+        if (m_signer) {
+            m_signer->ClearInputsFromQueue(GetIdsFromLockable(tx->vin));
+        }
+    }
+}
+
+void NetInstantSend::RemoveMempoolConflictsForLock(const uint256& hash, const instantsend::InstantSendLock& islock)
+{
+    Uint256HashMap<CTransactionRef> toDelete;
+
+    {
+        LOCK(m_mempool.cs);
+
+        for (const auto& in : islock.inputs) {
+            auto it = m_mempool.mapNextTx.find(in);
+            if (it == m_mempool.mapNextTx.end()) {
+                continue;
+            }
+            if (it->second->GetHash() != islock.txid) {
+                toDelete.emplace(it->second->GetHash(), m_mempool.get(it->second->GetHash()));
+
+                LogPrintf("%s -- txid=%s, mempool TX %s with input %s conflicts with islock=%s\n", __func__,
+                          islock.txid.ToString(), it->second->GetHash().ToString(), in.ToStringShort(), hash.ToString());
+            }
+        }
+
+        for (const auto& p : toDelete) {
+            m_mempool.removeRecursive(*p.second, MemPoolRemovalReason::CONFLICT);
+        }
+    }
+    ClearConflicting(toDelete);
+}
+
+void NetInstantSend::SynchronousUpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork,
+                                                bool fInitialDownload)
+{
+    m_is_manager.CacheTipHeight(pindexNew);
+}
+
+void NetInstantSend::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload)
+{
+    bool fDIP0008Active = pindexNew->pprev && pindexNew->pprev->nHeight >= Params().GetConsensus().DIP0008Height;
+
+    if (m_chainlocks.IsEnabled() && fDIP0008Active) {
+        // Nothing to do here. We should keep all islocks and let chainlocks handle them.
+        return;
+    }
+
+    int nConfirmedHeight = pindexNew->nHeight - Params().GetConsensus().nInstantSendKeepLock;
+    const CBlockIndex* pindex = pindexNew->GetAncestor(nConfirmedHeight);
+
+    if (pindex) {
+        HandleFullyConfirmedBlock(pindex);
+    }
+}
+
+void NetInstantSend::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason,
+                                                   uint64_t mempool_sequence)
+{
+    m_is_manager.TransactionIsRemoved(tx);
+}
+
+void NetInstantSend::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
+{
+    if (!m_is_manager.IsInstantSendEnabled()) {
+        return;
+    }
+
+    m_is_manager.CacheTipHeight(pindex);
+
+    if (m_mn_sync.IsBlockchainSynced()) {
+        const bool has_chainlock = m_chainlocks.HasChainLock(pindex->nHeight, pindex->GetBlockHash());
+        for (const auto& tx : pblock->vtx) {
+            if (tx->IsCoinBase() || tx->vin.empty()) {
+                // coinbase and TXs with no inputs can't be locked
+                continue;
+            }
+
+            if (!m_is_manager.IsLocked(tx->GetHash()) && !has_chainlock) {
+                if (m_signer) {
+                    m_signer->ProcessTx(*tx, true, Params().GetConsensus());
+                }
+                // TX is not locked, so make sure it is tracked
+                m_is_manager.AddNonLockedTx(tx, pindex);
+            } else {
+                // TX is locked, so make sure we don't track it anymore
+                m_is_manager.RemoveNonLockedTx(tx->GetHash(), true);
+            }
+        }
+    }
+    m_is_manager.WriteBlockISLocks(pblock, pindex);
+}
+
+void NetInstantSend::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected)
+{
+    m_is_manager.CacheDisconnectBlock(pindexDisconnected);
+    m_is_manager.CacheTipHeight(pindexDisconnected->pprev);
+    m_is_manager.RemoveBlockISLocks(pblock, pindexDisconnected);
+}
+
+void NetInstantSend::NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig)
+{
+    HandleFullyConfirmedBlock(pindex);
+}
+
+void NetInstantSend::ResolveBlockConflicts(const uint256& islockHash, const instantsend::InstantSendLock& islock)
+{
+    auto conflicts = m_is_manager.RetrieveISConflicts(islockHash, islock);
+
+    // Lets see if any of the conflicts was already mined into a ChainLocked block
+    bool hasChainLockedConflict = false;
+    for (const auto& p : conflicts) {
+        const auto* pindex = p.first;
+        if (m_chainlocks.HasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+            hasChainLockedConflict = true;
+            break;
+        }
+    }
+
+    // If a conflict was mined into a ChainLocked block, then we have no other choice and must prune the ISLOCK and all
+    // chained ISLOCKs that build on top of this one. The probability of this is practically zero and can only happen
+    // when large parts of the masternode network are controlled by an attacker. In this case we must still find
+    // consensus and its better to sacrifice individual ISLOCKs then to sacrifice whole ChainLocks.
+    if (hasChainLockedConflict) {
+        LogPrintf("NetInstantSend::%s -- txid=%s, islock=%s: at least one conflicted TX already got a ChainLock\n",
+                  __func__, islock.txid.ToString(), islockHash.ToString());
+        m_is_manager.RemoveConflictingLock(islockHash, islock);
+        return;
+    }
+
+    bool hasTxForLock = m_is_manager.HasTxForLock(islockHash);
+
+    bool activateBestChain = false;
+    for (const auto& p : conflicts) {
+        const auto* pindex = p.first;
+        ClearConflicting(p.second);
+
+        LogPrintf("NetInstantSend::%s -- invalidating block %s\n", __func__, pindex->GetBlockHash().ToString());
+
+        BlockValidationState state;
+        // need non-const pointer
+        auto pindex2 = WITH_LOCK(::cs_main, return m_chainstate.m_blockman.LookupBlockIndex(pindex->GetBlockHash()));
+        if (!m_chainstate.InvalidateBlock(state, pindex2)) {
+            LogPrintf("NetInstantSend::%s -- InvalidateBlock failed: %s\n", __func__, state.ToString());
+            // This should not have happened and we are in a state were it's not safe to continue anymore
+            assert(false);
+        }
+        if (hasTxForLock) {
+            activateBestChain = true;
+        } else {
+            LogPrintf("NetInstantSend::%s -- resetting block %s\n", __func__, pindex2->GetBlockHash().ToString());
+            LOCK(::cs_main);
+            m_chainstate.ResetBlockFailureFlags(pindex2);
+        }
+    }
+
+    if (activateBestChain) {
+        BlockValidationState state;
+        if (!m_chainstate.ActivateBestChain(state)) {
+            LogPrintf("NetInstantSend::%s -- ActivateBestChain failed: %s\n", __func__, state.ToString());
+            // This should not have happened and we are in a state were it's not safe to continue anymore
+            assert(false);
+        }
+    }
+}
+
+void NetInstantSend::TruncateRecoveredSigsForInputs(const instantsend::InstantSendLock& islock)
+{
+    auto ids = GetIdsFromLockable(islock.inputs);
+    if (m_signer) {
+        m_signer->ClearInputsFromQueue(ids);
+    }
+    for (const auto& id : ids) {
+        m_sigman.TruncateRecoveredSig(Params().GetConsensus().llmqTypeDIP0024InstantSend, id);
+    }
+}
+
+void NetInstantSend::HandleFullyConfirmedBlock(const CBlockIndex* pindex)
+{
+    if (!m_is_manager.IsInstantSendEnabled()) {
+        return;
+    }
+
+    auto removeISLocks = m_is_manager.RemoveConfirmedInstantSendLocks(pindex);
+    for (const auto& [islockHash, islock] : removeISLocks) {
+        LogPrint(BCLog::INSTANTSEND, "NetInstantSend::%s -- txid=%s, islock=%s: removed islock as it got fully confirmed\n",
+                 __func__, islock->txid.ToString(), islockHash.ToString());
+
+        // And we don't need the recovered sig for the ISLOCK anymore, as the block in which it got mined is considered
+        // fully confirmed now
+        m_sigman.TruncateRecoveredSig(Params().GetConsensus().llmqTypeDIP0024InstantSend, islock->GetRequestId());
+
+        // No need to keep recovered sigs for fully confirmed IS locks, as there is no chance for conflicts
+        // from now on. All inputs are spent now and can't be spend in any other TX.
+        TruncateRecoveredSigsForInputs(*islock);
+    }
+}
diff --git a/src/instantsend/net_instantsend.h b/src/instantsend/net_instantsend.h
index 5601cbb5f1c2..4d0b64609b5c 100644
--- a/src/instantsend/net_instantsend.h
+++ b/src/instantsend/net_instantsend.h
@@ -6,9 +6,8 @@
 #define BITCOIN_INSTANTSEND_NET_INSTANTSEND_H
 
 #include <net_processing.h>
-#include <saltedhasher.h>
-
 #include <util/threadinterrupt.h>
+#include <validationinterface.h>
 
 #include <memory>
 #include <optional>
@@ -18,24 +17,42 @@
 namespace Consensus {
 struct LLMQParams;
 } // namespace Consensus
+
+namespace chainlock {
+class Chainlocks;
+} // namespace chainlock
+
+class CMasternodeSync;
+class CTxMemPool;
+
 namespace instantsend {
 struct InstantSendLock;
+using InstantSendLockPtr = std::shared_ptr<InstantSendLock>;
 struct PendingISLockEntry;
+class InstantSendSigner;
 } // namespace instantsend
 namespace llmq {
+class CSigningManager;
 class CInstantSendManager;
 class CQuorumManager;
 } // namespace llmq
 
-class NetInstantSend final : public NetHandler
+class NetInstantSend final : public NetHandler, public CValidationInterface
 {
 public:
-    NetInstantSend(PeerManagerInternal* peer_manager, llmq::CInstantSendManager& is_manager, llmq::CQuorumManager& qman,
-                   CChainState& chainstate) :
+    NetInstantSend(PeerManagerInternal* peer_manager, llmq::CInstantSendManager& is_manager,
+                   instantsend::InstantSendSigner* signer, llmq::CSigningManager& sigman, llmq::CQuorumManager& qman,
+                   const chainlock::Chainlocks& chainlocks, CChainState& chainstate, CTxMemPool& mempool,
+                   const CMasternodeSync& mn_sync) :
         NetHandler(peer_manager),
         m_is_manager{is_manager},
+        m_signer{signer},
+        m_sigman{sigman},
         m_qman(qman),
-        m_chainstate{chainstate}
+        m_chainlocks{chainlocks},
+        m_chainstate{chainstate},
+        m_mempool{mempool},
+        m_mn_sync{mn_sync}
     {
         workInterrupt.reset();
     }
@@ -47,6 +64,18 @@ class NetInstantSend final : public NetHandler
 
     void WorkThreadMain();
 
+protected:
+    // -- CValidationInterface
+    void SynchronousUpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork,
+                                    bool fInitialDownload) override;
+    void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
+    void TransactionAddedToMempool(const CTransactionRef&, int64_t, uint64_t mempool_sequence) override;
+    void TransactionRemovedFromMempool(const CTransactionRef& ptx, MemPoolRemovalReason reason,
+                                       uint64_t mempool_sequence) override;
+    void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) override;
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected) override;
+    void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
+
 private:
     struct BatchVerificationData;
 
@@ -63,13 +92,28 @@ class NetInstantSend final : public NetHandler
         const std::vector<instantsend::PendingISLockEntry>& pend);
 
     void ProcessPendingISLocks(std::vector<instantsend::PendingISLockEntry>&& locks_to_process);
+    void ProcessInstantSendLock(NodeId from, const uint256& hash, const instantsend::InstantSendLockPtr& islock);
+    void RemoveMempoolConflictsForLock(const uint256& hash, const instantsend::InstantSendLock& islock);
 
     Uint256HashSet ProcessPendingInstantSendLocks(
         const Consensus::LLMQParams& llmq_params, int signOffset, bool ban,
         const std::vector<instantsend::PendingISLockEntry>& pend);
+
+    void ResolveBlockConflicts(const uint256& islockHash, const instantsend::InstantSendLock& islock);
+
+    void TruncateRecoveredSigsForInputs(const instantsend::InstantSendLock& islock);
+
+    void HandleFullyConfirmedBlock(const CBlockIndex* pindex);
+    void ClearConflicting(const Uint256HashMap<CTransactionRef>& to_delete);
+
     llmq::CInstantSendManager& m_is_manager;
+    instantsend::InstantSendSigner* m_signer; // non-null only for masternode
+    llmq::CSigningManager& m_sigman;
     llmq::CQuorumManager& m_qman;
-    const CChainState& m_chainstate;
+    const chainlock::Chainlocks& m_chainlocks;
+    CChainState& m_chainstate;
+    CTxMemPool& m_mempool;
+    const CMasternodeSync& m_mn_sync;
 
     std::thread workThread;
     CThreadInterrupt workInterrupt;
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 2bd953e1c1ee..d531ee8ae1fb 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -4,17 +4,17 @@
 
 #include <instantsend/signing.h>
 
+#include <chain.h>
 #include <chainlock/chainlock.h>
+#include <chainparams.h>
+#include <index/txindex.h>
+#include <instantsend/instantsend.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signing_shares.h>
+#include <logging.h>
 #include <masternode/sync.h>
 #include <spork.h>
 #include <util/helpers.h>
-
-#include <chain.h>
-#include <chainparams.h>
-#include <index/txindex.h>
-#include <logging.h>
 #include <validation.h>
 
 #include <ranges>
@@ -31,7 +31,7 @@ using node::GetTransaction;
 
 namespace instantsend {
 InstantSendSigner::InstantSendSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks,
-                                     InstantSendSignerParent& isman, llmq::CSigningManager& sigman,
+                                     llmq::CInstantSendManager& isman, llmq::CSigningManager& sigman,
                                      llmq::CSigSharesManager& shareman, llmq::CQuorumManager& qman,
                                      CSporkManager& sporkman, CTxMemPool& mempool, const CMasternodeSync& mn_sync) :
     m_chainstate{chainstate},
@@ -207,28 +207,37 @@ bool InstantSendSigner::CheckCanLock(const COutPoint& outpoint, bool printDebug,
         return false;
     }
 
-    const auto blockHeight = m_isman.GetBlockHeight(hashBlock);
-    if (!blockHeight) {
-        if (printDebug) {
-            LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: failed to determine mined height for parent TX %s\n", __func__,
-                     txHash.ToString(), outpoint.hash.ToString());
+    int blockHeight{0};
+    if (!hashBlock.IsNull()) {
+        if (auto ret = m_isman.GetCachedHeight(hashBlock)) {
+            blockHeight = *ret;
+        } else {
+            const CBlockIndex* pindex = WITH_LOCK(::cs_main, return m_chainstate.m_blockman.LookupBlockIndex(hashBlock));
+            if (pindex == nullptr) {
+                if (printDebug) {
+                    LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: failed to determine mined height for parent TX %s\n",
+                             __func__, txHash.ToString(), outpoint.hash.ToString());
+                }
+                return false;
+            }
+            m_isman.CacheBlockHeight(pindex);
+            blockHeight = pindex->nHeight;
         }
-        return false;
     }
 
     const int tipHeight = m_isman.GetTipHeight();
 
-    if (tipHeight < *blockHeight) {
+    if (tipHeight < blockHeight) {
         if (printDebug) {
             LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: cached tip height %d is below block height %d for parent TX %s\n",
-                     __func__, txHash.ToString(), tipHeight, *blockHeight, outpoint.hash.ToString());
+                     __func__, txHash.ToString(), tipHeight, blockHeight, outpoint.hash.ToString());
         }
         return false;
     }
 
-    const int nTxAge = tipHeight - *blockHeight + 1;
+    const int nTxAge = tipHeight - blockHeight + 1;
 
-    if (nTxAge < nInstantSendConfirmationsRequired && !m_chainlocks.HasChainLock(*blockHeight, hashBlock)) {
+    if (nTxAge < nInstantSendConfirmationsRequired && !m_chainlocks.HasChainLock(blockHeight, hashBlock)) {
         if (printDebug) {
             LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: outpoint %s too new and not ChainLocked. nTxAge=%d, nInstantSendConfirmationsRequired=%d\n", __func__,
                      txHash.ToString(), outpoint.ToStringShort(), nTxAge, nInstantSendConfirmationsRequired);
diff --git a/src/instantsend/signing.h b/src/instantsend/signing.h
index 18860a22ffbd..f7df067e4b9d 100644
--- a/src/instantsend/signing.h
+++ b/src/instantsend/signing.h
@@ -7,8 +7,8 @@
 
 #include <instantsend/lock.h>
 #include <llmq/signing.h>
-
-#include <optional>
+#include <sync.h>
+#include <threadsafety.h>
 
 class CMasternodeSync;
 class CSporkManager;
@@ -29,25 +29,13 @@ class CQuorumManager;
 } // namespace llmq
 
 namespace instantsend {
-class InstantSendSignerParent
-{
-public:
-    virtual ~InstantSendSignerParent() = default;
-
-    virtual bool IsInstantSendEnabled() const = 0;
-    virtual bool IsLocked(const uint256& txHash) const = 0;
-    virtual InstantSendLockPtr GetConflictingLock(const CTransaction& tx) const = 0;
-    virtual void TryEmplacePendingLock(const uint256& hash, const NodeId id, const InstantSendLockPtr& islock) = 0;
-    virtual std::optional<int> GetBlockHeight(const uint256& hash) const = 0;
-    virtual int GetTipHeight() const = 0;
-};
 
 class InstantSendSigner final : public llmq::CRecoveredSigsListener
 {
 private:
     CChainState& m_chainstate;
     const chainlock::Chainlocks& m_chainlocks;
-    InstantSendSignerParent& m_isman;
+    llmq::CInstantSendManager& m_isman;
     llmq::CSigningManager& m_sigman;
     llmq::CSigSharesManager& m_shareman;
     llmq::CQuorumManager& m_qman;
@@ -79,7 +67,7 @@ class InstantSendSigner final : public llmq::CRecoveredSigsListener
     InstantSendSigner(const InstantSendSigner&) = delete;
     InstantSendSigner& operator=(const InstantSendSigner&) = delete;
     explicit InstantSendSigner(CChainState& chainstate, const chainlock::Chainlocks& chainlocks,
-                               InstantSendSignerParent& isman, llmq::CSigningManager& sigman,
+                               llmq::CInstantSendManager& isman, llmq::CSigningManager& sigman,
                                llmq::CSigSharesManager& shareman, llmq::CQuorumManager& qman, CSporkManager& sporkman,
                                CTxMemPool& mempool, const CMasternodeSync& mn_sync);
     ~InstantSendSigner();
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index f617c2f77342..3d28a364fa5b 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -13,8 +13,7 @@
 #include <validation.h>
 
 LLMQContext::LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, CSporkManager& sporkman,
-                         chainlock::Chainlocks& chainlocks, CTxMemPool& mempool, ChainstateManager& chainman,
-                         const CMasternodeSync& mn_sync, const util::DbWrapperParams& db_params, int8_t bls_threads,
+                         ChainstateManager& chainman, const util::DbWrapperParams& db_params, int8_t bls_threads,
                          int16_t worker_count, int64_t max_recsigs_age) :
     bls_worker{std::make_shared<CBLSWorker>()},
     qsnapman{std::make_unique<llmq::CQuorumSnapshotManager>(evo_db)},
@@ -23,8 +22,7 @@ LLMQContext::LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, CSpork
     qman{std::make_unique<llmq::CQuorumManager>(*bls_worker, dmnman, evo_db, *quorum_block_processor, *qsnapman,
                                                 chainman, db_params)},
     sigman{std::make_unique<llmq::CSigningManager>(*qman, db_params, max_recsigs_age)},
-    isman{std::make_unique<llmq::CInstantSendManager>(chainlocks, chainman.ActiveChainstate(), *sigman, sporkman,
-                                                      mempool, mn_sync, db_params)}
+    isman{std::make_unique<llmq::CInstantSendManager>(sporkman, db_params)}
 {
     // Have to start it early to let VerifyDB check ChainLock signatures in coinbase
     bls_worker->Start(worker_count);
diff --git a/src/llmq/context.h b/src/llmq/context.h
index 5f8a4ea65378..8ffc38dfa529 100644
--- a/src/llmq/context.h
+++ b/src/llmq/context.h
@@ -13,15 +13,9 @@ class CBLSWorker;
 class ChainstateManager;
 class CDeterministicMNManager;
 class CEvoDB;
-class CMasternodeSync;
 class CSporkManager;
-class CTxMemPool;
 class PeerManager;
 
-namespace chainlock {
-class Chainlocks;
-}
-
 namespace llmq {
 class CInstantSendManager;
 class CQuorumBlockProcessor;
@@ -39,8 +33,7 @@ struct LLMQContext {
     LLMQContext(const LLMQContext&) = delete;
     LLMQContext& operator=(const LLMQContext&) = delete;
     explicit LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, CSporkManager& sporkman,
-                         chainlock::Chainlocks& chainlocks, CTxMemPool& mempool, ChainstateManager& chainman,
-                         const CMasternodeSync& mn_sync, const util::DbWrapperParams& db_params, int8_t bls_threads,
+                         ChainstateManager& chainman, const util::DbWrapperParams& db_params, int8_t bls_threads,
                          int16_t worker_count, int64_t max_recsigs_age);
     ~LLMQContext();
 
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index 76384c8e73ed..ae71e08d28ca 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -6,9 +6,11 @@
 
 #include <bls/bls_ies.h>
 #include <evo/deterministicmns.h>
+#include <llmq/dkgsessionhandler.h>
 #include <llmq/options.h>
 #include <llmq/params.h>
 #include <llmq/utils.h>
+#include <msg_result.h>
 #include <spork.h>
 #include <unordered_lru_cache.h>
 #include <util/helpers.h>
diff --git a/src/llmq/dkgsessionmgr.h b/src/llmq/dkgsessionmgr.h
index 23cf14491ddd..96c2ddb53a71 100644
--- a/src/llmq/dkgsessionmgr.h
+++ b/src/llmq/dkgsessionmgr.h
@@ -7,11 +7,10 @@
 
 #include <bls/bls.h>
 #include <bls/bls_worker.h>
-#include <llmq/dkgsessionhandler.h>
-#include <msg_result.h>
-#include <util/helpers.h>
-
+#include <chainparams.h>
 #include <net_types.h>
+#include <util/helpers.h>
+#include <sync.h>
 
 #include <map>
 #include <memory>
@@ -31,10 +30,10 @@ class ChainstateManager;
 class CMasternodeMetaMan;
 class CSporkManager;
 class PeerManager;
-class CDKGContribution;
-class CDKGComplaint;
-class CDKGJustification;
-class CDKGPrematureCommitment;
+class CInv;
+class CNode;
+class CConnman;
+class MessageProcessingResult;
 namespace util {
 struct DbWrapperParams;
 } // namespace util
@@ -43,6 +42,11 @@ class UniValue;
 
 namespace llmq
 {
+class CDKGComplaint;
+class CDKGContribution;
+class CDKGJustification;
+class CDKGPrematureCommitment;
+class CDKGSessionHandler;
 class CQuorumSnapshotManager;
 
 class CDKGSessionManager
@@ -102,6 +106,7 @@ class CDKGSessionManager
     template <typename HandlerFn>
     void InitializeHandlers(HandlerFn&& handler_fn)
     {
+        // TODO: move it to cpp file and drop chainparams.h and helpers.h
         const Consensus::Params& consensus_params = Params().GetConsensus();
         for (const auto& params : consensus_params.llmqs) {
             auto session_count = (params.useRotation) ? params.signingActiveQuorumCount : 1;
@@ -111,6 +116,7 @@ class CDKGSessionManager
         }
     }
 
+    // TODO: SPLIT THIS CLASS TO contribution manager and everything else
     void StartThreads(CConnman& connman, PeerManager& peerman);
     void StopThreads();
 
diff --git a/src/llmq/net_signing.cpp b/src/llmq/net_signing.cpp
index a170513815d8..97d28cca55d9 100644
--- a/src/llmq/net_signing.cpp
+++ b/src/llmq/net_signing.cpp
@@ -5,24 +5,32 @@
 #include <llmq/net_signing.h>
 
 #include <bls/bls_batchverifier.h>
+#include <cxxtimer.hpp>
 #include <llmq/quorums.h>
 #include <llmq/signhash.h>
-#include <llmq/signing_shares.h>
 #include <llmq/signing.h>
-#include <spork.h>
-#include <util/std23.h>
-
+#include <llmq/signing_shares.h>
 #include <logging.h>
+#include <net.h>
+#include <netmessagemaker.h>
+#include <spork.h>
 #include <streams.h>
+#include <util/std23.h>
 #include <util/thread.h>
 #include <validationinterface.h>
 
-#include <cxxtimer.hpp>
-
 #include <algorithm>
 #include <ranges>
 #include <unordered_map>
 
+/// ----- todo remove these from this file
+#include <evo/deterministicmns.h>
+#include <llmq/commitment.h>
+#include <llmq/quorumsman.h>
+#include <llmq/utils.h>
+#include <masternode/meta.h>
+#include <validation.h>
+
 namespace llmq {
 void NetSigning::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv)
 {
@@ -404,4 +412,265 @@ bool NetSigning::ProcessPendingSigShares()
     return more_work;
 }
 
+MessageProcessingResult CQuorumManager::ProcessMessage(CNode& pfrom, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
+{
+    if (msg_type == NetMsgType::QGETDATA) {
+        if (!IsMasternode() || (pfrom.GetVerifiedProRegTxHash().IsNull() && !pfrom.qwatch)) {
+            return MisbehavingError{10, "not a verified masternode or a qwatch connection"};
+        }
+
+        CQuorumDataRequest request;
+        vRecv >> request;
+
+        auto sendQDATA = [&](CQuorumDataRequest::Errors nError,
+                             bool request_limit_exceeded,
+                             const CDataStream& body = CDataStream(SER_NETWORK, PROTOCOL_VERSION)) -> MessageProcessingResult {
+            MessageProcessingResult ret{};
+            switch (nError) {
+                case (CQuorumDataRequest::Errors::NONE):
+                case (CQuorumDataRequest::Errors::QUORUM_TYPE_INVALID):
+                case (CQuorumDataRequest::Errors::QUORUM_BLOCK_NOT_FOUND):
+                case (CQuorumDataRequest::Errors::QUORUM_NOT_FOUND):
+                case (CQuorumDataRequest::Errors::MASTERNODE_IS_NO_MEMBER):
+                case (CQuorumDataRequest::Errors::UNDEFINED):
+                    if (request_limit_exceeded) ret = MisbehavingError{25, "request limit exceeded"};
+                    break;
+                case (CQuorumDataRequest::Errors::QUORUM_VERIFICATION_VECTOR_MISSING):
+                case (CQuorumDataRequest::Errors::ENCRYPTED_CONTRIBUTIONS_MISSING):
+                    // Do not punish limit exceed if we don't have the requested data
+                    break;
+            }
+            request.SetError(nError);
+            CDataStream ssResponse{SER_NETWORK, pfrom.GetCommonVersion()};
+            ssResponse << request << body;
+            connman.PushMessage(&pfrom, CNetMsgMaker(pfrom.GetCommonVersion()).Make(NetMsgType::QDATA, ssResponse));
+            return ret;
+        };
+
+        bool request_limit_exceeded(false);
+        {
+            LOCK2(::cs_main, cs_data_requests);
+            const CQuorumDataRequestKey key(pfrom.GetVerifiedProRegTxHash(), false, request.GetQuorumHash(), request.GetLLMQType());
+            auto it = mapQuorumDataRequests.find(key);
+            if (it == mapQuorumDataRequests.end()) {
+                it = mapQuorumDataRequests.emplace(key, request).first;
+            } else if (it->second.IsExpired(/*add_bias=*/false)) {
+                it->second = request;
+            } else {
+                request_limit_exceeded = true;
+            }
+        }
+
+        if (!Params().GetLLMQ(request.GetLLMQType()).has_value()) {
+            return sendQDATA(CQuorumDataRequest::Errors::QUORUM_TYPE_INVALID, request_limit_exceeded);
+        }
+
+        const CBlockIndex* pQuorumBaseBlockIndex = WITH_LOCK(::cs_main, return m_chainman.m_blockman.LookupBlockIndex(request.GetQuorumHash()));
+        if (pQuorumBaseBlockIndex == nullptr) {
+            return sendQDATA(CQuorumDataRequest::Errors::QUORUM_BLOCK_NOT_FOUND, request_limit_exceeded);
+        }
+
+        const auto pQuorum = GetQuorum(request.GetLLMQType(), pQuorumBaseBlockIndex);
+        if (pQuorum == nullptr) {
+            return sendQDATA(CQuorumDataRequest::Errors::QUORUM_NOT_FOUND, request_limit_exceeded);
+        }
+
+        CDataStream ssResponseData(SER_NETWORK, pfrom.GetCommonVersion());
+
+        // Check if request wants QUORUM_VERIFICATION_VECTOR data
+        if (request.GetDataMask() & CQuorumDataRequest::QUORUM_VERIFICATION_VECTOR) {
+            if (!pQuorum->HasVerificationVector()) {
+                return sendQDATA(CQuorumDataRequest::Errors::QUORUM_VERIFICATION_VECTOR_MISSING, request_limit_exceeded);
+            }
+
+            WITH_LOCK(pQuorum->cs_vvec_shShare, ssResponseData << *pQuorum->quorumVvec);
+        }
+
+        // Check if request wants ENCRYPTED_CONTRIBUTIONS data
+        CQuorumDataRequest::Errors ret_err{CQuorumDataRequest::Errors::NONE};
+        MessageProcessingResult qdata_ret{}, ret{};
+        if (m_handler) {
+            ret = m_handler->ProcessContribQGETDATA(request_limit_exceeded, ssResponseData, *pQuorum, request, pQuorumBaseBlockIndex);
+            if (auto request_err = request.GetError(); request_err != CQuorumDataRequest::Errors::NONE &&
+                                                       request_err != CQuorumDataRequest::Errors::UNDEFINED) {
+                ret_err = request_err;
+            }
+        }
+        // sendQDATA also pushes a message independent of the returned value
+        if (ret_err != CQuorumDataRequest::Errors::NONE) {
+            qdata_ret = sendQDATA(ret_err, request_limit_exceeded);
+        } else {
+            qdata_ret = sendQDATA(CQuorumDataRequest::Errors::NONE, request_limit_exceeded, ssResponseData);
+        }
+        return ret.empty() ? qdata_ret : ret;
+    }
+
+    if (msg_type == NetMsgType::QDATA) {
+        if ((!IsMasternode() && !IsWatching()) || pfrom.GetVerifiedProRegTxHash().IsNull()) {
+            return MisbehavingError{10, "not a verified masternode and -watchquorums is not enabled"};
+        }
+
+        CQuorumDataRequest request;
+        vRecv >> request;
+
+        {
+            LOCK2(::cs_main, cs_data_requests);
+            const CQuorumDataRequestKey key(pfrom.GetVerifiedProRegTxHash(), true, request.GetQuorumHash(), request.GetLLMQType());
+            auto it = mapQuorumDataRequests.find(key);
+            if (it == mapQuorumDataRequests.end()) {
+                return MisbehavingError{10, "not requested"};
+            }
+            if (it->second.IsProcessed()) {
+                return MisbehavingError(10, "already received");
+            }
+            if (request != it->second) {
+                return MisbehavingError(10, "not like requested");
+            }
+            it->second.SetProcessed();
+        }
+
+        if (request.GetError() != CQuorumDataRequest::Errors::NONE) {
+            LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- %s: Error %d (%s), from peer=%d\n", __func__, msg_type, request.GetError(), request.GetErrorString(), pfrom.GetId());
+            return {};
+        }
+
+        CQuorumPtr pQuorum;
+        {
+            if (LOCK(m_cs_maps); !mapQuorumsCache[request.GetLLMQType()].get(request.GetQuorumHash(), pQuorum)) {
+                // Don't bump score because we asked for it
+                LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- %s: Quorum not found, from peer=%d\n", __func__, msg_type, pfrom.GetId());
+                return {};
+            }
+        }
+
+        // Check if request has QUORUM_VERIFICATION_VECTOR data
+        if (request.GetDataMask() & CQuorumDataRequest::QUORUM_VERIFICATION_VECTOR) {
+
+            std::vector<CBLSPublicKey> verificationVector;
+            vRecv >> verificationVector;
+
+            if (pQuorum->SetVerificationVector(verificationVector)) {
+                QueueQuorumForWarming(pQuorum);
+            } else {
+                return MisbehavingError{10, "invalid quorum verification vector"};
+            }
+        }
+
+        // Check if request has ENCRYPTED_CONTRIBUTIONS data
+        if (m_handler) {
+            if (auto ret = m_handler->ProcessContribQDATA(pfrom, vRecv, *pQuorum, request); !ret.empty()) {
+                return ret;
+            }
+        }
+
+        WITH_LOCK(cs_db, pQuorum->WriteContributions(*db));
+        return {};
+    }
+
+    return {};
+}
+
+// TODO: move it to the better place
+
+namespace utils {
+
+bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, CConnman& connman, const CSporkManager& sporkman,
+                             const UtilParameters& util_params, const CDeterministicMNList& tip_mn_list,
+                             const uint256& myProTxHash, bool is_masternode, bool quorums_watch)
+{
+    if (!is_masternode && !quorums_watch) {
+        return false;
+    }
+
+    auto members = GetAllQuorumMembers(llmqParams.type, util_params);
+    if (members.empty()) {
+        return false;
+    }
+
+    bool isMember = std::ranges::find_if(members, [&](const auto& dmn) { return dmn->proTxHash == myProTxHash; }) !=
+                    members.end();
+
+    if (!isMember && !quorums_watch) {
+        return false;
+    }
+
+    LogPrint(BCLog::NET_NETCONN, "%s -- isMember=%d for quorum %s:\n", __func__, isMember,
+             util_params.m_base_index->GetBlockHash().ToString());
+
+    Uint256HashSet connections;
+    if (isMember) {
+        connections = GetQuorumConnections(llmqParams, sporkman, util_params, myProTxHash, /*onlyOutbound=*/true);
+    } else {
+        auto cindexes = CalcDeterministicWatchConnections(llmqParams.type, util_params.m_base_index, members.size(), 1);
+        for (auto idx : cindexes) {
+            connections.emplace(members[idx]->proTxHash);
+        }
+    }
+    if (!connections.empty()) {
+        if (!connman.HasMasternodeQuorumNodes(llmqParams.type, util_params.m_base_index->GetBlockHash()) &&
+            LogAcceptDebug(BCLog::LLMQ)) {
+            std::string debugMsg = strprintf("%s -- adding masternodes quorum connections for quorum %s:\n", __func__,
+                                             util_params.m_base_index->GetBlockHash().ToString());
+            for (const auto& c : connections) {
+                auto dmn = tip_mn_list.GetValidMN(c);
+                if (!dmn) {
+                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
+                } else {
+                    debugMsg += strprintf("  %s (%s)\n", c.ToString(),
+                                          dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
+                }
+            }
+            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
+        }
+        connman.SetMasternodeQuorumNodes(llmqParams.type, util_params.m_base_index->GetBlockHash(), connections);
+        connman.SetMasternodeQuorumRelayMembers(llmqParams.type, util_params.m_base_index->GetBlockHash(), connections);
+    }
+    return true;
+}
+
+void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, CConnman& connman, CMasternodeMetaMan& mn_metaman,
+                               const CSporkManager& sporkman, const UtilParameters& util_params,
+                               const CDeterministicMNList& tip_mn_list, const uint256& myProTxHash)
+{
+    assert(mn_metaman.IsValid());
+
+    if (!IsQuorumPoseEnabled(llmqParams.type, sporkman)) {
+        return;
+    }
+
+    auto members = GetAllQuorumMembers(llmqParams.type, util_params);
+    auto curTime = GetTime<std::chrono::seconds>().count();
+
+    Uint256HashSet probeConnections;
+    for (const auto& dmn : members) {
+        if (dmn->proTxHash == myProTxHash) {
+            continue;
+        }
+        auto lastOutbound = mn_metaman.GetLastOutboundSuccess(dmn->proTxHash);
+        if (curTime - lastOutbound < 10 * 60) {
+            // avoid re-probing nodes too often
+            continue;
+        }
+        probeConnections.emplace(dmn->proTxHash);
+    }
+
+    if (!probeConnections.empty()) {
+        if (LogAcceptDebug(BCLog::LLMQ)) {
+            std::string debugMsg = strprintf("%s -- adding masternodes probes for quorum %s:\n", __func__,
+                                             util_params.m_base_index->GetBlockHash().ToString());
+            for (const auto& c : probeConnections) {
+                auto dmn = tip_mn_list.GetValidMN(c);
+                if (!dmn) {
+                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
+                } else {
+                    debugMsg += strprintf("  %s (%s)\n", c.ToString(),
+                                          dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
+                }
+            }
+            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
+        }
+        connman.AddPendingProbeConnections(probeConnections);
+    }
+}
+} // namespace utils
 } // namespace llmq
diff --git a/src/llmq/observer/context.cpp b/src/llmq/observer/context.cpp
index 717cd58f143b..3f360e822973 100644
--- a/src/llmq/observer/context.cpp
+++ b/src/llmq/observer/context.cpp
@@ -6,6 +6,7 @@
 
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
+#include <llmq/dkgsessionhandler.h>
 #include <llmq/observer/quorums.h>
 #include <llmq/quorumsman.h>
 
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index a93b5384e5d7..9dc1266f5b9d 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -20,8 +20,6 @@
 
 #include <chainparams.h>
 #include <dbwrapper.h>
-#include <net.h>
-#include <netmessagemaker.h>
 #include <util/thread.h>
 #include <util/time.h>
 #include <validation.h>
@@ -150,6 +148,8 @@ bool CQuorumManager::HasQuorum(Consensus::LLMQType llmqType, const CQuorumBlockP
 bool CQuorumManager::RequestQuorumData(CNode* pfrom, CConnman& connman, const CQuorum& quorum, uint16_t nDataMask,
                                        const uint256& proTxHash) const
 {
+    // TODO FIX ME FIX ME
+    /*
     if (pfrom == nullptr) {
         LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- Invalid pfrom: nullptr\n", __func__);
         return false;
@@ -174,7 +174,7 @@ bool CQuorumManager::RequestQuorumData(CNode* pfrom, CConnman& connman, const CQ
     const CQuorumDataRequest request(llmqType, pindex->GetBlockHash(), nDataMask, proTxHash);
     auto [old_pair, inserted] = mapQuorumDataRequests.emplace(key, request);
     if (!inserted) {
-        if (old_pair->second.IsExpired(/*add_bias=*/true)) {
+        if (old_pair->second.IsExpired(/*add_bias=*//*true)) {
             old_pair->second = request;
         } else {
             LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- Already requested\n", __func__);
@@ -186,7 +186,7 @@ bool CQuorumManager::RequestQuorumData(CNode* pfrom, CConnman& connman, const CQ
 
     CNetMsgMaker msgMaker(pfrom->GetCommonVersion());
     connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::QGETDATA, request));
-
+*/
     return true;
 }
 
@@ -406,164 +406,6 @@ CQuorumCPtr CQuorumManager::GetQuorum(Consensus::LLMQType llmqType, gsl::not_nul
     return BuildQuorumFromCommitment(llmqType, pQuorumBaseBlockIndex, populate_cache);
 }
 
-MessageProcessingResult CQuorumManager::ProcessMessage(CNode& pfrom, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
-{
-    if (msg_type == NetMsgType::QGETDATA) {
-        if (!IsMasternode() || (pfrom.GetVerifiedProRegTxHash().IsNull() && !pfrom.qwatch)) {
-            return MisbehavingError{10, "not a verified masternode or a qwatch connection"};
-        }
-
-        CQuorumDataRequest request;
-        vRecv >> request;
-
-        auto sendQDATA = [&](CQuorumDataRequest::Errors nError,
-                             bool request_limit_exceeded,
-                             const CDataStream& body = CDataStream(SER_NETWORK, PROTOCOL_VERSION)) -> MessageProcessingResult {
-            MessageProcessingResult ret{};
-            switch (nError) {
-                case (CQuorumDataRequest::Errors::NONE):
-                case (CQuorumDataRequest::Errors::QUORUM_TYPE_INVALID):
-                case (CQuorumDataRequest::Errors::QUORUM_BLOCK_NOT_FOUND):
-                case (CQuorumDataRequest::Errors::QUORUM_NOT_FOUND):
-                case (CQuorumDataRequest::Errors::MASTERNODE_IS_NO_MEMBER):
-                case (CQuorumDataRequest::Errors::UNDEFINED):
-                    if (request_limit_exceeded) ret = MisbehavingError{25, "request limit exceeded"};
-                    break;
-                case (CQuorumDataRequest::Errors::QUORUM_VERIFICATION_VECTOR_MISSING):
-                case (CQuorumDataRequest::Errors::ENCRYPTED_CONTRIBUTIONS_MISSING):
-                    // Do not punish limit exceed if we don't have the requested data
-                    break;
-            }
-            request.SetError(nError);
-            CDataStream ssResponse{SER_NETWORK, pfrom.GetCommonVersion()};
-            ssResponse << request << body;
-            connman.PushMessage(&pfrom, CNetMsgMaker(pfrom.GetCommonVersion()).Make(NetMsgType::QDATA, ssResponse));
-            return ret;
-        };
-
-        bool request_limit_exceeded(false);
-        {
-            LOCK2(::cs_main, cs_data_requests);
-            const CQuorumDataRequestKey key(pfrom.GetVerifiedProRegTxHash(), false, request.GetQuorumHash(), request.GetLLMQType());
-            auto it = mapQuorumDataRequests.find(key);
-            if (it == mapQuorumDataRequests.end()) {
-                it = mapQuorumDataRequests.emplace(key, request).first;
-            } else if (it->second.IsExpired(/*add_bias=*/false)) {
-                it->second = request;
-            } else {
-                request_limit_exceeded = true;
-            }
-        }
-
-        if (!Params().GetLLMQ(request.GetLLMQType()).has_value()) {
-            return sendQDATA(CQuorumDataRequest::Errors::QUORUM_TYPE_INVALID, request_limit_exceeded);
-        }
-
-        const CBlockIndex* pQuorumBaseBlockIndex = WITH_LOCK(::cs_main, return m_chainman.m_blockman.LookupBlockIndex(request.GetQuorumHash()));
-        if (pQuorumBaseBlockIndex == nullptr) {
-            return sendQDATA(CQuorumDataRequest::Errors::QUORUM_BLOCK_NOT_FOUND, request_limit_exceeded);
-        }
-
-        const auto pQuorum = GetQuorum(request.GetLLMQType(), pQuorumBaseBlockIndex);
-        if (pQuorum == nullptr) {
-            return sendQDATA(CQuorumDataRequest::Errors::QUORUM_NOT_FOUND, request_limit_exceeded);
-        }
-
-        CDataStream ssResponseData(SER_NETWORK, pfrom.GetCommonVersion());
-
-        // Check if request wants QUORUM_VERIFICATION_VECTOR data
-        if (request.GetDataMask() & CQuorumDataRequest::QUORUM_VERIFICATION_VECTOR) {
-            if (!pQuorum->HasVerificationVector()) {
-                return sendQDATA(CQuorumDataRequest::Errors::QUORUM_VERIFICATION_VECTOR_MISSING, request_limit_exceeded);
-            }
-
-            WITH_LOCK(pQuorum->cs_vvec_shShare, ssResponseData << *pQuorum->quorumVvec);
-        }
-
-        // Check if request wants ENCRYPTED_CONTRIBUTIONS data
-        CQuorumDataRequest::Errors ret_err{CQuorumDataRequest::Errors::NONE};
-        MessageProcessingResult qdata_ret{}, ret{};
-        if (m_handler) {
-            ret = m_handler->ProcessContribQGETDATA(request_limit_exceeded, ssResponseData, *pQuorum, request, pQuorumBaseBlockIndex);
-            if (auto request_err = request.GetError(); request_err != CQuorumDataRequest::Errors::NONE &&
-                                                       request_err != CQuorumDataRequest::Errors::UNDEFINED) {
-                ret_err = request_err;
-            }
-        }
-        // sendQDATA also pushes a message independent of the returned value
-        if (ret_err != CQuorumDataRequest::Errors::NONE) {
-            qdata_ret = sendQDATA(ret_err, request_limit_exceeded);
-        } else {
-            qdata_ret = sendQDATA(CQuorumDataRequest::Errors::NONE, request_limit_exceeded, ssResponseData);
-        }
-        return ret.empty() ? qdata_ret : ret;
-    }
-
-    if (msg_type == NetMsgType::QDATA) {
-        if ((!IsMasternode() && !IsWatching()) || pfrom.GetVerifiedProRegTxHash().IsNull()) {
-            return MisbehavingError{10, "not a verified masternode and -watchquorums is not enabled"};
-        }
-
-        CQuorumDataRequest request;
-        vRecv >> request;
-
-        {
-            LOCK2(::cs_main, cs_data_requests);
-            const CQuorumDataRequestKey key(pfrom.GetVerifiedProRegTxHash(), true, request.GetQuorumHash(), request.GetLLMQType());
-            auto it = mapQuorumDataRequests.find(key);
-            if (it == mapQuorumDataRequests.end()) {
-                return MisbehavingError{10, "not requested"};
-            }
-            if (it->second.IsProcessed()) {
-                return MisbehavingError(10, "already received");
-            }
-            if (request != it->second) {
-                return MisbehavingError(10, "not like requested");
-            }
-            it->second.SetProcessed();
-        }
-
-        if (request.GetError() != CQuorumDataRequest::Errors::NONE) {
-            LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- %s: Error %d (%s), from peer=%d\n", __func__, msg_type, request.GetError(), request.GetErrorString(), pfrom.GetId());
-            return {};
-        }
-
-        CQuorumPtr pQuorum;
-        {
-            if (LOCK(m_cs_maps); !mapQuorumsCache[request.GetLLMQType()].get(request.GetQuorumHash(), pQuorum)) {
-                // Don't bump score because we asked for it
-                LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- %s: Quorum not found, from peer=%d\n", __func__, msg_type, pfrom.GetId());
-                return {};
-            }
-        }
-
-        // Check if request has QUORUM_VERIFICATION_VECTOR data
-        if (request.GetDataMask() & CQuorumDataRequest::QUORUM_VERIFICATION_VECTOR) {
-
-            std::vector<CBLSPublicKey> verificationVector;
-            vRecv >> verificationVector;
-
-            if (pQuorum->SetVerificationVector(verificationVector)) {
-                QueueQuorumForWarming(pQuorum);
-            } else {
-                return MisbehavingError{10, "invalid quorum verification vector"};
-            }
-        }
-
-        // Check if request has ENCRYPTED_CONTRIBUTIONS data
-        if (m_handler) {
-            if (auto ret = m_handler->ProcessContribQDATA(pfrom, vRecv, *pQuorum, request); !ret.empty()) {
-                return ret;
-            }
-        }
-
-        WITH_LOCK(cs_db, pQuorum->WriteContributions(*db));
-        return {};
-    }
-
-    return {};
-}
-
 void CQuorumManager::CacheWarmingThreadMain() const
 {
     while (!m_cache_interrupt) {
diff --git a/src/llmq/quorumsman.h b/src/llmq/quorumsman.h
index 352ec128dc7f..55fd52adbec9 100644
--- a/src/llmq/quorumsman.h
+++ b/src/llmq/quorumsman.h
@@ -11,7 +11,6 @@
 #include <llmq/params.h>
 #include <llmq/quorums.h>
 #include <llmq/types.h>
-#include <msg_result.h>
 #include <saltedhasher.h>
 #include <unordered_lru_cache.h>
 
@@ -39,6 +38,7 @@ class CDBWrapper;
 class CEvoDB;
 class ChainstateManager;
 class CNode;
+class MessageProcessingResult;
 namespace util {
 struct DbWrapperParams;
 } // namespace util
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 41cab78da2f3..a3f6107b1c2e 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -777,103 +777,5 @@ std::unordered_set<size_t> CalcDeterministicWatchConnections(Consensus::LLMQType
     return result;
 }
 
-bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, CConnman& connman, const CSporkManager& sporkman,
-                             const UtilParameters& util_params, const CDeterministicMNList& tip_mn_list,
-                             const uint256& myProTxHash, bool is_masternode, bool quorums_watch)
-{
-    if (!is_masternode && !quorums_watch) {
-        return false;
-    }
-
-    auto members = GetAllQuorumMembers(llmqParams.type, util_params);
-    if (members.empty()) {
-        return false;
-    }
-
-    bool isMember = std::ranges::find_if(members, [&](const auto& dmn) { return dmn->proTxHash == myProTxHash; }) !=
-                    members.end();
-
-    if (!isMember && !quorums_watch) {
-        return false;
-    }
-
-    LogPrint(BCLog::NET_NETCONN, "%s -- isMember=%d for quorum %s:\n", __func__, isMember,
-             util_params.m_base_index->GetBlockHash().ToString());
-
-    Uint256HashSet connections;
-    if (isMember) {
-        connections = GetQuorumConnections(llmqParams, sporkman, util_params, myProTxHash, /*onlyOutbound=*/true);
-    } else {
-        auto cindexes = CalcDeterministicWatchConnections(llmqParams.type, util_params.m_base_index, members.size(), 1);
-        for (auto idx : cindexes) {
-            connections.emplace(members[idx]->proTxHash);
-        }
-    }
-    if (!connections.empty()) {
-        if (!connman.HasMasternodeQuorumNodes(llmqParams.type, util_params.m_base_index->GetBlockHash()) &&
-            LogAcceptDebug(BCLog::LLMQ)) {
-            std::string debugMsg = strprintf("%s -- adding masternodes quorum connections for quorum %s:\n", __func__,
-                                             util_params.m_base_index->GetBlockHash().ToString());
-            for (const auto& c : connections) {
-                auto dmn = tip_mn_list.GetValidMN(c);
-                if (!dmn) {
-                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
-                } else {
-                    debugMsg += strprintf("  %s (%s)\n", c.ToString(),
-                                          dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
-                }
-            }
-            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
-        }
-        connman.SetMasternodeQuorumNodes(llmqParams.type, util_params.m_base_index->GetBlockHash(), connections);
-        connman.SetMasternodeQuorumRelayMembers(llmqParams.type, util_params.m_base_index->GetBlockHash(), connections);
-    }
-    return true;
-}
-
-void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, CConnman& connman, CMasternodeMetaMan& mn_metaman,
-                               const CSporkManager& sporkman, const UtilParameters& util_params,
-                               const CDeterministicMNList& tip_mn_list, const uint256& myProTxHash)
-{
-    assert(mn_metaman.IsValid());
-
-    if (!IsQuorumPoseEnabled(llmqParams.type, sporkman)) {
-        return;
-    }
-
-    auto members = GetAllQuorumMembers(llmqParams.type, util_params);
-    auto curTime = GetTime<std::chrono::seconds>().count();
-
-    Uint256HashSet probeConnections;
-    for (const auto& dmn : members) {
-        if (dmn->proTxHash == myProTxHash) {
-            continue;
-        }
-        auto lastOutbound = mn_metaman.GetLastOutboundSuccess(dmn->proTxHash);
-        if (curTime - lastOutbound < 10 * 60) {
-            // avoid re-probing nodes too often
-            continue;
-        }
-        probeConnections.emplace(dmn->proTxHash);
-    }
-
-    if (!probeConnections.empty()) {
-        if (LogAcceptDebug(BCLog::LLMQ)) {
-            std::string debugMsg = strprintf("%s -- adding masternodes probes for quorum %s:\n", __func__,
-                                             util_params.m_base_index->GetBlockHash().ToString());
-            for (const auto& c : probeConnections) {
-                auto dmn = tip_mn_list.GetValidMN(c);
-                if (!dmn) {
-                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
-                } else {
-                    debugMsg += strprintf("  %s (%s)\n", c.ToString(),
-                                          dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
-                }
-            }
-            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
-        }
-        connman.AddPendingProbeConnections(probeConnections);
-    }
-}
 } // namespace utils
 } // namespace llmq
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index 72fb0cff9b84..933a1295cfc1 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -160,7 +160,7 @@ CAmount PlatformShare(const CAmount reward)
     int nOffset = nBlockHeight % m_consensus_params.nBudgetPaymentsCycleBlocks;
     if (nOffset < m_consensus_params.nBudgetPaymentsWindowBlocks) {
         // NOTE: old budget system is disabled since 12.1
-        if(m_mn_sync.IsSynced()) {
+        if (m_govman.IsValidAndSynced()) {
             // no old budget blocks should be accepted here on mainnet,
             // testnet/devnet/regtest should produce regular blocks only
             LogPrint(BCLog::GOBJECT, "CMNPaymentsProcessor::%s -- WARNING! Client synced but old budget system is disabled, checking block value against block reward\n", __func__);
@@ -232,7 +232,7 @@ bool CMNPaymentsProcessor::IsBlockValueValid(const CBlock& block, const int nBlo
         return false;
     }
 
-    if (!m_mn_sync.IsSynced() || !m_govman.IsValid()) {
+    if (!m_govman.IsValidAndSynced()) {
         LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- WARNING! Not enough data, checked superblock max bounds only\n", __func__);
         // not enough data for full checks but at least we know that the superblock limits were honored.
         // We rely on the network to have followed the correct chain in this case
@@ -291,7 +291,7 @@ bool CMNPaymentsProcessor::IsBlockPayeeValid(const CTransaction& txNew, const CB
         return false;
     }
 
-    if (!m_mn_sync.IsSynced() || !m_govman.IsValid()) {
+    if (!m_govman.IsValidAndSynced()) {
         // governance data is either incomplete or non-existent
         LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- WARNING! Not enough data, skipping superblock payee checks\n", __func__);
         return true;  // not an error
diff --git a/src/masternode/payments.h b/src/masternode/payments.h
index a4df891c8c1a..4c7c640afbc2 100644
--- a/src/masternode/payments.h
+++ b/src/masternode/payments.h
@@ -15,7 +15,6 @@ class CBlockIndex;
 class CDeterministicMNManager;
 class CGovernanceManager;
 class ChainstateManager;
-class CMasternodeSync;
 class CTransaction;
 class CSporkManager;
 class CTxOut;
@@ -37,7 +36,6 @@ class CMNPaymentsProcessor
     CGovernanceManager& m_govman;
     const ChainstateManager& m_chainman;
     const Consensus::Params& m_consensus_params;
-    const CMasternodeSync& m_mn_sync;
     const CSporkManager& m_sporkman;
 
 private:
@@ -50,10 +48,16 @@ class CMNPaymentsProcessor
     [[nodiscard]] bool IsOldBudgetBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet);
 
 public:
-    explicit CMNPaymentsProcessor(CDeterministicMNManager& dmnman, CGovernanceManager& govman, const ChainstateManager& chainman,
-                                  const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync, const CSporkManager& sporkman) :
-        m_dmnman{dmnman}, m_govman{govman}, m_chainman{chainman}, m_consensus_params{consensus_params}, m_mn_sync{mn_sync},
-        m_sporkman{sporkman} {}
+    explicit CMNPaymentsProcessor(CDeterministicMNManager& dmnman, CGovernanceManager& govman,
+                                  const ChainstateManager& chainman, const Consensus::Params& consensus_params,
+                                  const CSporkManager& sporkman) :
+        m_dmnman{dmnman},
+        m_govman{govman},
+        m_chainman{chainman},
+        m_consensus_params{consensus_params},
+        m_sporkman{sporkman}
+    {
+    }
 
     bool IsBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet, const bool check_superblock);
     bool IsBlockPayeeValid(const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, const bool check_superblock);
diff --git a/src/masternode/sync.cpp b/src/masternode/sync.cpp
index 2b69c71cb47d..e367a24e3e27 100644
--- a/src/masternode/sync.cpp
+++ b/src/masternode/sync.cpp
@@ -9,6 +9,11 @@
 #include <util/time.h>
 #include <util/translation.h>
 
+#include <cassert>
+
+void NullNodeSyncNotifier::SyncReset() { assert(false); }
+void NullNodeSyncNotifier::SyncFinished() { assert(false); }
+
 CMasternodeSync::CMasternodeSync(std::unique_ptr<NodeSyncNotifier>&& sync_notifier) :
     nTimeAssetSyncStarted{GetTime()},
     nTimeLastBumped{GetTime()},
diff --git a/src/masternode/sync.h b/src/masternode/sync.h
index 247d8d0ff889..98401982727e 100644
--- a/src/masternode/sync.h
+++ b/src/masternode/sync.h
@@ -32,6 +32,20 @@ class NodeSyncNotifier
     virtual ~NodeSyncNotifier() = default;
 };
 
+/** Stub implementation for use in chainstate-only (non-network) contexts.
+ *  CMasternodeSync constructed with this notifier permanently returns
+ *  IsBlockchainSynced()=false and IsSynced()=false, which correctly disables
+ *  network-dependent validation paths.
+ *
+ *  Asserts on any call — if sync state is being advanced, a real notifier
+ *  (NodeSyncNotifierImpl) must be used instead. */
+class NullNodeSyncNotifier final : public NodeSyncNotifier
+{
+public:
+    void SyncReset() override;
+    void SyncFinished() override;
+};
+
 //
 // CMasternodeSync : Sync masternode assets in stages
 //
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index cfa5845a78c5..c4428b28f9ea 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -4768,7 +4768,7 @@ void PeerManagerImpl::ProcessMessage(
                 // We will continue to reject this tx since it has rejected
                 // parents so avoid re-requesting it from other peers.
                 m_recent_rejects.insert(tx.GetHash());
-                m_llmq_ctx->isman->TransactionRemovedFromMempool(ptx);
+                m_llmq_ctx->isman->TransactionIsRemoved(ptx);
             }
         } else {
             m_recent_rejects.insert(tx.GetHash());
@@ -4799,7 +4799,7 @@ void PeerManagerImpl::ProcessMessage(
                 pfrom.GetId(),
                 state.ToString());
             MaybePunishNodeForTx(pfrom.GetId(), state);
-            m_llmq_ctx->isman->TransactionRemovedFromMempool(ptx);
+            m_llmq_ctx->isman->TransactionIsRemoved(ptx);
         }
         return;
     }
@@ -6661,3 +6661,24 @@ void PeerManagerImpl::PeerRelayRecoveredSig(const llmq::CRecoveredSig& sig, bool
 {
     RelayRecoveredSig(sig, proactive_relay);
 }
+MessageProcessingResult CSporkManager::ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
+{
+    if (msg_type == NetMsgType::SPORK) {
+        return ProcessSpork(peer.GetId(), vRecv);
+    } else if (msg_type == NetMsgType::GETSPORKS) {
+        ProcessGetSporks(peer, connman);
+    }
+    return {};
+}
+
+void CSporkManager::ProcessGetSporks(CNode& peer, CConnman& connman)
+{
+    LOCK(cs); // make sure to not lock this together with cs_main
+    for (const auto& pair : mapSporksActive) {
+        for (const auto& signerSporkPair : pair.second) {
+            connman.PushMessage(&peer, CNetMsgMaker(peer.GetCommonVersion()).Make(NetMsgType::SPORK, signerSporkPair.second));
+        }
+    }
+}
+
+
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index 98ac8e3d4f04..c97cf9c61f2d 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -37,7 +37,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      ChainstateManager& chainman,
                                                      CGovernanceManager& govman,
                                                      CMasternodeMetaMan& mn_metaman,
-                                                     CMasternodeSync& mn_sync,
                                                      CSporkManager& sporkman,
                                                      chainlock::Chainlocks& chainlocks,
                                                      std::unique_ptr<CChainstateHelper>& chain_helper,
@@ -83,7 +82,7 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
     pblocktree.reset();
     pblocktree.reset(new CBlockTreeDB(nBlockTreeDBCache, block_tree_db_in_memory, fReset));
 
-    DashChainstateSetup(chainman, govman, mn_metaman, mn_sync, sporkman, chainlocks, chain_helper,
+    DashChainstateSetup(chainman, govman, mn_metaman, sporkman, chainlocks, chain_helper,
                         dmnman, *evodb, llmq_ctx, mempool, data_dir, dash_dbs_in_memory,
                         /*llmq_dbs_wipe=*/fReset || fReindexChainState, bls_threads, worker_count,
                         max_recsigs_age, consensus_params);
@@ -209,7 +208,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
 void DashChainstateSetup(ChainstateManager& chainman,
                          CGovernanceManager& govman,
                          CMasternodeMetaMan& mn_metaman,
-                         CMasternodeSync& mn_sync,
                          CSporkManager& sporkman,
                          chainlock::Chainlocks& chainlocks,
                          std::unique_ptr<CChainstateHelper>& chain_helper,
@@ -230,13 +228,15 @@ void DashChainstateSetup(ChainstateManager& chainman,
     dmnman = std::make_unique<CDeterministicMNManager>(evodb, mn_metaman);
 
     llmq_ctx.reset();
-    llmq_ctx = std::make_unique<LLMQContext>(*dmnman, evodb, sporkman, chainlocks, *mempool, chainman, mn_sync,
+    llmq_ctx = std::make_unique<LLMQContext>(*dmnman, evodb, sporkman, chainman,
                                              util::DbWrapperParams{.path = data_dir, .memory = llmq_dbs_in_memory, .wipe = llmq_dbs_wipe},
                                              bls_threads, worker_count, max_recsigs_age);
-    mempool->ConnectManagers(dmnman.get(), llmq_ctx->isman.get());
+    if (mempool) {
+        mempool->ConnectManagers(dmnman.get(), llmq_ctx->isman.get());
+    }
     chain_helper.reset();
     chain_helper = std::make_unique<CChainstateHelper>(evodb, *dmnman, govman, *(llmq_ctx->isman), *(llmq_ctx->quorum_block_processor),
-                                                       *(llmq_ctx->qsnapman), chainman, consensus_params, mn_sync, sporkman, chainlocks,
+                                                       *(llmq_ctx->qsnapman), chainman, consensus_params, sporkman, chainlocks,
                                                        *(llmq_ctx->qman));
 }
 
@@ -248,7 +248,9 @@ void DashChainstateSetupClose(std::unique_ptr<CChainstateHelper>& chain_helper,
 {
     chain_helper.reset();
     llmq_ctx.reset();
-    mempool->DisconnectManagers();
+    if (mempool) {
+        mempool->DisconnectManagers();
+    }
     dmnman.reset();
 }
 
diff --git a/src/node/chainstate.h b/src/node/chainstate.h
index 09adc7cdf214..ac6b3f9235da 100644
--- a/src/node/chainstate.h
+++ b/src/node/chainstate.h
@@ -17,7 +17,6 @@ class CEvoDB;
 class CGovernanceManager;
 class ChainstateManager;
 class CMasternodeMetaMan;
-class CMasternodeSync;
 class CSporkManager;
 class CTxMemPool;
 struct LLMQContext;
@@ -80,7 +79,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      ChainstateManager& chainman,
                                                      CGovernanceManager& govman,
                                                      CMasternodeMetaMan& mn_metaman,
-                                                     CMasternodeSync& mn_sync,
                                                      CSporkManager& sporkman,
                                                      chainlock::Chainlocks& chainlocks,
                                                      std::unique_ptr<CChainstateHelper>& chain_helper,
@@ -111,7 +109,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
 void DashChainstateSetup(ChainstateManager& chainman,
                          CGovernanceManager& govman,
                          CMasternodeMetaMan& mn_metaman,
-                         CMasternodeSync& mn_sync,
                          CSporkManager& sporkman,
                          chainlock::Chainlocks& chainlocks,
                          std::unique_ptr<CChainstateHelper>& chain_helper,
diff --git a/src/qt/masternodemodel.cpp b/src/qt/masternodemodel.cpp
index ccafc277c3d9..2a5353882dc0 100644
--- a/src/qt/masternodemodel.cpp
+++ b/src/qt/masternodemodel.cpp
@@ -78,6 +78,7 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
         m_operator_reward = QObject::tr("NONE");
     }
 
+    // TODO: get rid of this JSON
     const auto json{dmn->toJson()};
     m_json = QString::fromStdString(json.write(2));
     if (const auto& val = json.find_value("collateralHash"); val.isStr()) {
diff --git a/src/rpc/evo_util.cpp b/src/rpc/evo_util.cpp
index 927bd55439fb..c9c57871e72e 100644
--- a/src/rpc/evo_util.cpp
+++ b/src/rpc/evo_util.cpp
@@ -4,7 +4,9 @@
 
 #include <rpc/evo_util.h>
 
+#include <evo/deterministicmns.h>
 #include <evo/providertx.h>
+#include <index/txindex.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
 
@@ -136,3 +138,29 @@ void ProcessNetInfoPlatform(ProTx& ptx, const UniValue& input_p2p, const UniValu
 }
 template void ProcessNetInfoPlatform(CProRegTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
 template void ProcessNetInfoPlatform(CProUpServTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
+
+
+UniValue CDeterministicMN::ToJson() const
+{
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("type", std::string(GetMnType(nType).description));
+    obj.pushKV("proTxHash", proTxHash.ToString());
+    obj.pushKV("collateralHash", collateralOutpoint.hash.ToString());
+    obj.pushKV("collateralIndex", collateralOutpoint.n);
+
+    if (g_txindex) {
+        CTransactionRef collateralTx;
+        uint256 nBlockHash;
+        g_txindex->FindTx(collateralOutpoint.hash, nBlockHash, collateralTx);
+        if (collateralTx) {
+            CTxDestination dest;
+            if (ExtractDestination(collateralTx->vout[collateralOutpoint.n].scriptPubKey, dest)) {
+                obj.pushKV("collateralAddress", EncodeDestination(dest));
+            }
+        }
+    }
+
+    obj.pushKV("operatorReward", (double)nOperatorReward / 100);
+    obj.pushKV("state", pdmnState->ToJson(nType));
+    return obj;
+}
diff --git a/src/spork.cpp b/src/spork.cpp
index d213dc417423..ccf5833784ca 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -126,16 +126,6 @@ void CSporkManager::CheckAndRemove()
     }
 }
 
-MessageProcessingResult CSporkManager::ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
-{
-    if (msg_type == NetMsgType::SPORK) {
-        return ProcessSpork(peer.GetId(), vRecv);
-    } else if (msg_type == NetMsgType::GETSPORKS) {
-        ProcessGetSporks(peer, connman);
-    }
-    return {};
-}
-
 MessageProcessingResult CSporkManager::ProcessSpork(NodeId from, CDataStream& vRecv)
 {
     CSporkMessage spork;
@@ -195,17 +185,6 @@ MessageProcessingResult CSporkManager::ProcessSpork(NodeId from, CDataStream& vR
     return ret;
 }
 
-void CSporkManager::ProcessGetSporks(CNode& peer, CConnman& connman)
-{
-    LOCK(cs); // make sure to not lock this together with cs_main
-    for (const auto& pair : mapSporksActive) {
-        for (const auto& signerSporkPair : pair.second) {
-            connman.PushMessage(&peer, CNetMsgMaker(peer.GetCommonVersion()).Make(NetMsgType::SPORK, signerSporkPair.second));
-        }
-    }
-}
-
-
 std::optional<CInv> CSporkManager::UpdateSpork(SporkId nSporkID, SporkValue nValue)
 {
     CSporkMessage spork(nSporkID, nValue, GetAdjustedTime());
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 2ac2bc6d6698..1562c679c088 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -20,6 +20,7 @@
 #include <versionbits.h>
 
 #include <evo/evodb.h>
+#include <chainlock/handler.h>
 #include <governance/governance.h>
 #include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
@@ -48,6 +49,8 @@ struct MinerTestingSetup : public TestingSetup {
     }
     BlockAssembler AssemblerForTest(const CChainParams& params);
 };
+
+static constexpr int WAIT_FOR_ISLOCK_TIMEOUT{601};
 } // namespace miner_tests
 
 BOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)
@@ -132,6 +135,8 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co
     uint256 hashHighFeeTx = tx.GetHash();
     m_node.mempool->addUnchecked(entry.Fee(50000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
 
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hashParentTx, hashMediumFeeTx, hashHighFeeTx}, std::chrono::duration_cast<std::chrono::seconds>(Now<NodeSeconds>().time_since_epoch()).count() - WAIT_FOR_ISLOCK_TIMEOUT);
     std::unique_ptr<CBlockTemplate> pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 4U);
     BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashParentTx);
@@ -142,6 +147,8 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co
     tx.vin[0].prevout.hash = hashHighFeeTx;
     tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
     uint256 hashFreeTx = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hashFreeTx}, std::chrono::duration_cast<std::chrono::seconds>(Now<NodeSeconds>().time_since_epoch()).count() - WAIT_FOR_ISLOCK_TIMEOUT);
     m_node.mempool->addUnchecked(entry.Fee(0).FromTx(tx));
     size_t freeTxSize = GetVirtualTransactionSize(CTransaction(tx));
 
@@ -167,6 +174,8 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co
     tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
     hashLowFeeTx = tx.GetHash();
     m_node.mempool->addUnchecked(entry.Fee(feeToUse+2).FromTx(tx));
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hashLowFeeTx}, std::chrono::duration_cast<std::chrono::seconds>(Now<NodeSeconds>().time_since_epoch()).count() - WAIT_FOR_ISLOCK_TIMEOUT);
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 6U);
     BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashFreeTx);
@@ -181,6 +190,8 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co
     tx.vout[1].nValue = 100000000; // 1BTC output
     uint256 hashFreeTx2 = tx.GetHash();
     m_node.mempool->addUnchecked(entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({tx.GetHash()}, std::chrono::duration_cast<std::chrono::seconds>(Now<NodeSeconds>().time_since_epoch()).count() - WAIT_FOR_ISLOCK_TIMEOUT);
 
     // This tx can't be mined by itself
     tx.vin[0].prevout.hash = hashFreeTx2;
@@ -189,6 +200,8 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co
     tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
     uint256 hashLowFeeTx2 = tx.GetHash();
     m_node.mempool->addUnchecked(entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({tx.GetHash()}, std::chrono::duration_cast<std::chrono::seconds>(Now<NodeSeconds>().time_since_epoch()).count() - WAIT_FOR_ISLOCK_TIMEOUT);
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
 
     // Verify that this tx isn't selected.
@@ -202,6 +215,8 @@ void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, co
     tx.vin[0].prevout.n = 1;
     tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
     m_node.mempool->addUnchecked(entry.Fee(10000).FromTx(tx));
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({tx.GetHash()}, std::chrono::duration_cast<std::chrono::seconds>(Now<NodeSeconds>().time_since_epoch()).count() - WAIT_FOR_ISLOCK_TIMEOUT);
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 9U);
     BOOST_CHECK(pblocktemplate->block.vtx[8]->GetHash() == hashLowFeeTx2);
@@ -235,8 +250,11 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     {
         tx.vout[0].nValue -= LOWFEE;
         hash = tx.GetHash();
+        // Age transaction for InstantSend
+        m_node.clhandler->UpdateTxFirstSeenMap({hash}, pblocktemplate->block.nTime - WAIT_FOR_ISLOCK_TIMEOUT);
         bool spendsCoinbase = i == 0; // only first tx spends coinbase
         // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
+
         m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
         tx.vin[0].prevout.hash = hash;
     }
@@ -252,6 +270,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
         hash = tx.GetHash();
         bool spendsCoinbase = i == 0; // only first tx spends coinbase
         // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
+        // Age transaction for InstantSend
+        m_node.clhandler->UpdateTxFirstSeenMap({hash}, pblocktemplate->block.nTime - WAIT_FOR_ISLOCK_TIMEOUT);
         m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).SigOps(20).FromTx(tx));
         tx.vin[0].prevout.hash = hash;
     }
@@ -281,6 +301,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     // orphan in mempool, template creation fails
     hash = tx.GetHash();
     m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).FromTx(tx));
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, pblocktemplate->block.nTime - WAIT_FOR_ISLOCK_TIMEOUT);
     BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     m_node.mempool->clear();
 
@@ -307,6 +329,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
     tx.vout[0].nValue = 0;
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, pblocktemplate->block.nTime - WAIT_FOR_ISLOCK_TIMEOUT);
     // give it a fee so it'll get mined
     m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
     // Should throw bad-cb-multiple
@@ -322,6 +346,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     tx.vout[0].scriptPubKey = CScript() << OP_2;
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, pblocktemplate->block.nTime - WAIT_FOR_ISLOCK_TIMEOUT);
     m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     m_node.mempool->clear();
@@ -361,11 +387,15 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     CScript script = CScript() << OP_0;
     tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, pblocktemplate->block.nTime - WAIT_FOR_ISLOCK_TIMEOUT);
     m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout.hash = hash;
     tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());
     tx.vout[0].nValue -= LOWFEE;
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, pblocktemplate->block.nTime - WAIT_FOR_ISLOCK_TIMEOUT);
     m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
     // Should throw block-validation-failed
     BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("block-validation-failed"));
@@ -382,6 +412,7 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
 
     // non-final txs in mempool
     SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
+    int64_t mocked_time_for_is = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() - WAIT_FOR_ISLOCK_TIMEOUT;
     const int flags{LOCKTIME_VERIFY_SEQUENCE};
     // height map
     std::vector<int> prevheights;
@@ -400,6 +431,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     tx.vout[0].scriptPubKey = CScript() << OP_1;
     tx.nLockTime = 0;
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, mocked_time_for_is);
     m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
     BOOST_CHECK(!TestSequenceLocks(CTransaction{tx})); // Sequence locks fail
@@ -414,6 +447,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1-m_node.chainman->ActiveChain()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
     prevheights[0] = baseheight + 2;
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, mocked_time_for_is);
     m_node.mempool->addUnchecked(entry.Time(Now<NodeSeconds>()).FromTx(tx));
     BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
     BOOST_CHECK(!TestSequenceLocks(CTransaction{tx})); // Sequence locks fail
@@ -437,6 +472,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     prevheights[0] = baseheight + 3;
     tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, mocked_time_for_is);
     m_node.mempool->addUnchecked(entry.Time(Now<NodeSeconds>()).FromTx(tx));
     BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
     BOOST_CHECK(TestSequenceLocks(CTransaction{tx})); // Sequence locks pass
@@ -448,6 +485,8 @@ void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const C
     prevheights.resize(1);
     prevheights[0] = baseheight + 4;
     hash = tx.GetHash();
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hash}, mocked_time_for_is);
     m_node.mempool->addUnchecked(entry.Time(Now<NodeSeconds>()).FromTx(tx));
     BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
     BOOST_CHECK(TestSequenceLocks(CTransaction{tx})); // Sequence locks pass
@@ -541,6 +580,8 @@ void MinerTestingSetup::TestPrioritisedMining(const CChainParams& chainparams, c
     uint256 hashFreeGrandchild = tx.GetHash();
     m_node.mempool->addUnchecked(entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
 
+    // Age transaction for InstantSend
+    m_node.clhandler->UpdateTxFirstSeenMap({hashMediumFeeTx, hashPrioritsedChild, hashParentTx, hashFreeParent, hashFreeChild, hashFreeGrandchild, hashFreePrioritisedTx}, std::chrono::duration_cast<std::chrono::seconds>(Now<NodeSeconds>().time_since_epoch()).count() - WAIT_FOR_ISLOCK_TIMEOUT);
     auto pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 6U);
     BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashFreeParent);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 9847e4b2f913..4eb5e3f45f07 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -143,7 +143,7 @@ void DashChainstateSetup(ChainstateManager& chainman,
                          bool llmq_dbs_wipe,
                          const Consensus::Params& consensus_params)
 {
-    DashChainstateSetup(chainman, *Assert(node.govman.get()), *Assert(node.mn_metaman.get()), *Assert(node.mn_sync.get()),
+    DashChainstateSetup(chainman, *Assert(node.govman.get()), *Assert(node.mn_metaman.get()),
                         *Assert(node.sporkman.get()), *Assert(node.chainlocks), node.chain_helper, node.dmnman, *node.evodb,
                         node.llmq_ctx, Assert(node.mempool.get()), node.args->GetDataDirNet(), llmq_dbs_in_memory, llmq_dbs_wipe,
                         llmq::DEFAULT_BLSCHECK_THREADS, llmq::DEFAULT_WORKER_COUNT, llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE,
@@ -323,7 +323,6 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
                                            *Assert(m_node.chainman.get()),
                                            *Assert(m_node.govman.get()),
                                            *Assert(m_node.mn_metaman.get()),
-                                           *Assert(m_node.mn_sync.get()),
                                            *Assert(m_node.sporkman.get()),
                                            *Assert(m_node.chainlocks.get()),
                                            m_node.chain_helper,
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index db7472d9eaef..064d8ea504c3 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -42,7 +42,7 @@
     "evo/specialtxman -> validation -> evo/specialtxman",
     "governance/classes -> governance/object -> governance/governance -> governance/classes",
     "governance/governance -> governance/signing -> governance/object -> governance/governance",
-    "instantsend/instantsend -> txmempool -> instantsend/instantsend",
+    "instantsend/instantsend -> node/blockstorage -> validation -> txmempool -> instantsend/instantsend",
     "llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> llmq/blockprocessor",
     "llmq/commitment -> llmq/utils -> llmq/snapshot -> llmq/commitment",
     "llmq/dkgsessionhandler -> net_processing -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler",