diff --git a/src/Makefile.am b/src/Makefile.am
index 9a071b0031..1451953f3b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -146,6 +146,9 @@ BITCOIN_CORE_H = \
   dbwrapper.h \
   limitedmap.h \
   logging.h \
+  masternodes/masternodes.h \
+  masternodes/mn_checks.h \
+  masternodes/mn_txdb.h \
   memusage.h \
   merkleblock.h \
   miner.h \
@@ -276,6 +279,10 @@ libbitcoin_server_a_SOURCES = \
   interfaces/node.cpp \
   init.cpp \
   dbwrapper.cpp \
+  masternodes/masternodes.cpp \
+  masternodes/mn_checks.cpp \
+  masternodes/mn_txdb.cpp \
+  masternodes/mn_rpc.cpp \
   miner.cpp \
   net.cpp \
   net_processing.cpp \
diff --git a/src/Makefile.bench.include b/src/Makefile.bench.include
index e421b377a0..e369a4614d 100644
--- a/src/Makefile.bench.include
+++ b/src/Makefile.bench.include
@@ -49,6 +49,7 @@ nodist_bench_bench_bitcoin_SOURCES = $(GENERATED_BENCH_FILES)
 bench_bench_bitcoin_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(EVENT_CLFAGS) $(EVENT_PTHREADS_CFLAGS) -I$(builddir)/bench/
 bench_bench_bitcoin_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 bench_bench_bitcoin_LDADD = \
+  $(LIBBITCOIN_MN) \
   $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_WALLET) \
   $(LIBBITCOIN_SERVER) \
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 9b8f17a23d..b98b0c6c09 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -7,6 +7,8 @@
 
 #include <chainparamsseeds.h>
 #include <consensus/merkle.h>
+#include <key_io.h>
+#include <masternodes/masternodes.h>
 #include <tinyformat.h>
 #include <util/system.h>
 #include <util/strencodings.h>
@@ -17,7 +19,43 @@
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
 
-static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
+
+std::vector<CTransactionRef> CChainParams::CreateGenesisMasternodes() const
+{
+//    CChainParamsDummy dummy(*this);
+
+
+    std::vector<CTransactionRef> mnTxs;
+    for (auto const & addrs : vMasternodes)
+    {
+        CMutableTransaction txNew;
+        txNew.nVersion = 1;
+        txNew.vin.resize(1);
+        txNew.vout.resize(2);
+        txNew.vin[0].scriptSig = CScript(); // << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
+
+        CTxDestination operatorDest = DecodeDestination(addrs.operatorAddress, *this);
+        assert(operatorDest.which() == 1 || operatorDest.which() == 4);
+        CTxDestination ownerDest = DecodeDestination(addrs.ownerAddress, *this);
+        assert(ownerDest.which() == 1 || ownerDest.which() == 4);
+
+        CKeyID operatorAuthKey = operatorDest.which() == 1 ? CKeyID(*boost::get<PKHash>(&operatorDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&operatorDest)) ;
+        CDataStream metadata(MnTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+        metadata << static_cast<unsigned char>(MasternodesTxType::CreateMasternode)
+                 << static_cast<char>(operatorDest.which()) << operatorAuthKey;
+
+        CScript scriptMeta;
+        scriptMeta << OP_RETURN << ToByteVector(metadata);
+
+        txNew.vout[0] = CTxOut(consensus.mn.creationFee, scriptMeta);
+        txNew.vout[1] = CTxOut(consensus.mn.collateralAmount, GetScriptForDestination(ownerDest));
+
+        mnTxs.push_back(MakeTransactionRef(std::move(txNew)));
+    }
+    return mnTxs;
+}
+
+static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward, std::vector<CTransactionRef> const & extraTxs)
 {
     CMutableTransaction txNew;
     txNew.nVersion = 1;
@@ -35,6 +73,12 @@ static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesi
     genesis.stakeModifier   = uint256S("0");
     genesis.mintedBlocks    = 0;
     genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
+
+    for (auto tx : extraTxs)
+    {
+        genesis.vtx.push_back(tx);
+    }
+
     genesis.hashPrevBlock.SetNull();
     genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
     return genesis;
@@ -51,11 +95,11 @@ static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesi
  *     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
  *   vMerkleTree: 4a5e1e
  */
-static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
+static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward, std::vector<CTransactionRef> const & extraTxs)
 {
     const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
     const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
-    return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nBits, nVersion, genesisReward);
+    return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nBits, nVersion, genesisReward, extraTxs);
 }
 
 /**
@@ -96,6 +140,13 @@ class CMainParams : public CChainParams {
         // By default assume that the signatures in ancestors of this block are valid.
         consensus.defaultAssumeValid = uint256S("0x0000000000000000000f1c54590ee18d15ec70e68c8cd4cfbadb1b4f11697eee"); //563378
 
+        // Masternodes' params
+        consensus.mn.activationDelay = 1500;
+        consensus.mn.collateralUnlockDelay = 300;
+        consensus.mn.creationFee = 1 * COIN;
+        consensus.mn.collateralAmount = 100 * COIN;
+        consensus.mn.historyFrame = 300;
+
         /**
          * The message start string is designed to be unlikely to occur in normal data.
          * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
@@ -110,8 +161,15 @@ class CMainParams : public CChainParams {
         m_assumed_blockchain_size = 240;
         m_assumed_chain_state_size = 3;
 
-        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN);
+        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,18); // '8' (0('1') for bitcoin)
+        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,90); // 'd' (5('3') for bitcoin)
+        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,128); // (128 ('5', 'K' or 'L') for bitcoin)
+        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
+        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
 
+        bech32_hrp = "df";
+
+        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN, CreateGenesisMasternodes());
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock == uint256S("0xc0f410a59e9aa22afd67ee4671d41c2e3135c0efc589446e4b393cc534d178ac"));
         assert(genesis.hashMerkleRoot == uint256S("0x800c7581a09c96d98bdad848db8fc027e8869d28d890ca21f6c25124baf53afe"));
@@ -130,14 +188,6 @@ class CMainParams : public CChainParams {
 //        vSeeds.emplace_back("seed.bitcoin.sprovoost.nl"); // Sjors Provoost
 //        vSeeds.emplace_back("dnsseed.emzy.de"); // Stephan Oeste
 
-        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,18); // '8' (0('1') for bitcoin)
-        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,90); // 'd' (5('3') for bitcoin)
-        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,128); // (128 ('5', 'K' or 'L') for bitcoin)
-        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
-        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
-
-        bech32_hrp = "df";
-
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
 
         fDefaultConsistencyChecks = false;
@@ -209,6 +259,13 @@ class CTestNetParams : public CChainParams {
         // By default assume that the signatures in ancestors of this block are valid.
         consensus.defaultAssumeValid = uint256S("0x0000000000000037a8cd3e06cd5edbfe9dd1dbcc5dacab279376ef7cfc2b4c75"); //1354312
 
+        // Masternodes' params
+        consensus.mn.activationDelay = 10;
+        consensus.mn.collateralUnlockDelay = 10;
+        consensus.mn.creationFee = 1 * COIN;
+        consensus.mn.collateralAmount = 10 * COIN;
+        consensus.mn.historyFrame = 300;
+
         pchMessageStart[0] = 0x0b;
         pchMessageStart[1] = 0x11;
         pchMessageStart[2] = 0x09;
@@ -218,7 +275,15 @@ class CTestNetParams : public CChainParams {
         m_assumed_blockchain_size = 30;
         m_assumed_chain_state_size = 2;
 
-        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN);
+        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,15); // '7' (111 ('m' or 'n') for bitcoin)
+        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,128); // 't' (196 ('2') for bitcoin)
+        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239); // (239 ('9' or 'c') for bitcoin)
+        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
+        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
+
+        bech32_hrp = "tf";
+
+        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN, CreateGenesisMasternodes());
         consensus.hashGenesisBlock = genesis.GetHash();
 
         assert(consensus.hashGenesisBlock == uint256S("0xc0f410a59e9aa22afd67ee4671d41c2e3135c0efc589446e4b393cc534d178ac"));
@@ -232,14 +297,6 @@ class CTestNetParams : public CChainParams {
 //        vSeeds.emplace_back("seed.testnet.bitcoin.sprovoost.nl");
 //        vSeeds.emplace_back("testnet-seed.bluematt.me"); // Just a static list of stable node(s), only supports x9
 
-        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,15); // '7' (111 ('m' or 'n') for bitcoin)
-        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,128); // 't' (196 ('2') for bitcoin)
-        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239); // (239 ('9' or 'c') for bitcoin)
-        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
-        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
-
-        bech32_hrp = "tf";
-
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 
         fDefaultConsistencyChecks = false;
@@ -299,6 +356,13 @@ class CRegTestParams : public CChainParams {
         // By default assume that the signatures in ancestors of this block are valid.
         consensus.defaultAssumeValid = uint256S("0x00");
 
+        // Masternodes' params
+        consensus.mn.activationDelay = 10;
+        consensus.mn.collateralUnlockDelay = 10;
+        consensus.mn.creationFee = 1 * COIN;
+        consensus.mn.collateralAmount = 10 * COIN;
+        consensus.mn.historyFrame = 300;
+
         pchMessageStart[0] = 0xfa;
         pchMessageStart[1] = 0xbf;
         pchMessageStart[2] = 0xb5;
@@ -310,11 +374,24 @@ class CRegTestParams : public CChainParams {
 
         UpdateActivationParametersFromArgs(args);
 
-        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN);
-        consensus.hashGenesisBlock = genesis.GetHash();
+        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
+        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
+        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);
+        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
+        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
-        assert(consensus.hashGenesisBlock == uint256S("0xc0f410a59e9aa22afd67ee4671d41c2e3135c0efc589446e4b393cc534d178ac"));
-        assert(genesis.hashMerkleRoot == uint256S("0x800c7581a09c96d98bdad848db8fc027e8869d28d890ca21f6c25124baf53afe"));
+        bech32_hrp = "bcrt";
+
+        // owner base58, operator base58
+        vMasternodes.push_back({"mwsZw8nF7pKxWH8eoKL9tPxTpaFkz7QeLU", "mswsMVsyGMj1FzDMbbxw2QW3KvQAv2FKiy"});
+        vMasternodes.push_back({"msER9bmJjyEemRpQoS8YYVL21VyZZrSgQ7", "mps7BdmwEF2vQ9DREDyNPibqsuSRZ8LuwQ"});
+        vMasternodes.push_back({"bcrt1qyrfrpadwgw7p5eh3e9h3jmu4kwlz4prx73cqny", "bcrt1qmfvw3dp3u6fdvqkdc0y3lr0e596le9cf22vtsv"});
+        vMasternodes.push_back({"bcrt1qyeuu9rvq8a67j86pzvh5897afdmdjpyankp4mu", "bcrt1qurwyhta75n2g75u2u5nds9p6w9v62y8wr40d2r"});
+
+        genesis = CreateGenesisBlock(1296688602, 0x207fffff, 1, 50 * COIN, CreateGenesisMasternodes());
+        consensus.hashGenesisBlock = genesis.GetHash();
+        assert(consensus.hashGenesisBlock == uint256S("0x000006772a3244d0a5a4911a5cb1d7e910e175f4e4b77c755018459122fa7a89"));
+        assert(genesis.hashMerkleRoot == uint256S("0x2faeba8cd467cb0df14c48d30b57736f1ed3275790401d127a03d55037df7b5c"));
 
         vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
         vSeeds.clear();      //!< Regtest mode doesn't have any DNS seeds.
@@ -325,7 +402,7 @@ class CRegTestParams : public CChainParams {
 
         checkpointData = {
             {
-                {0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},
+                {0, uint256S("0x000006772a3244d0a5a4911a5cb1d7e910e175f4e4b77c755018459122fa7a89")},
             }
         };
 
@@ -334,14 +411,6 @@ class CRegTestParams : public CChainParams {
             0,
             0
         };
-
-        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
-        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
-        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);
-        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
-        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
-
-        bech32_hrp = "bcrt";
     }
 
     /**
diff --git a/src/chainparams.h b/src/chainparams.h
index 90e94c6102..9c6743b420 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -104,6 +104,14 @@ class CChainParams
     bool m_is_test_chain;
     CCheckpointData checkpointData;
     ChainTxData chainTxData;
+
+    struct MasternodeKeys
+    {
+        std::string ownerAddress;
+        std::string operatorAddress;
+    };
+    std::vector<MasternodeKeys> vMasternodes;
+    std::vector<CTransactionRef> CreateGenesisMasternodes() const;
 };
 
 /**
diff --git a/src/consensus/params.h b/src/consensus/params.h
index b969d557ef..a9dee5ccb6 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_CONSENSUS_PARAMS_H
 #define BITCOIN_CONSENSUS_PARAMS_H
 
+#include <amount.h>
 #include <uint256.h>
 #include <limits>
 #include <map>
@@ -91,6 +92,15 @@ struct Params {
 
     uint256 nMinimumChainWork;
     uint256 defaultAssumeValid;
+
+    struct MnParams {
+        CAmount creationFee;
+        CAmount collateralAmount;
+        int activationDelay;
+        int collateralUnlockDelay;
+        int historyFrame;
+    };
+    MnParams mn;
 };
 } // namespace Consensus
 
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 4b93cae848..3537f791e7 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -5,6 +5,7 @@
 #include <consensus/tx_verify.h>
 
 #include <consensus/consensus.h>
+#include <masternodes/masternodes.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <consensus/validation.h>
@@ -156,7 +157,7 @@ int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& i
     return nSigOps;
 }
 
-bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
+bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, const CMasternodesView * mnview, int nSpendHeight, CAmount& txfee)
 {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
@@ -181,6 +182,12 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, c
         if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
             return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-inputvalues-outofrange");
         }
+
+        if (prevout.n == 1 && !mnview->CanSpend(prevout.hash, nSpendHeight))
+        {
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "mn-collateral-locked",
+                strprintf("tried to spend locked collateral for %s", prevout.hash.ToString())); /// @todo @max may be somehow place the height of unlocking?
+        }
     }
 
     const CAmount value_out = tx.GetValueOut();
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index 3519fc555d..aba9a12d40 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -12,6 +12,7 @@
 
 class CBlockIndex;
 class CCoinsViewCache;
+class CMasternodesView;
 class CTransaction;
 class CValidationState;
 
@@ -24,7 +25,7 @@ namespace Consensus {
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee);
+bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, const CMasternodesView * mnview, int nSpendHeight, CAmount& txfee);
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
diff --git a/src/init.cpp b/src/init.cpp
index 23c4788028..bf101d7b17 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -25,6 +25,8 @@
 #include <interfaces/chain.h>
 #include <key.h>
 #include <key_io.h>
+#include <masternodes/masternodes.h>
+#include <masternodes/mn_txdb.h>
 #include <miner.h>
 #include <net.h>
 #include <net_permissions.h>
@@ -261,6 +263,7 @@ void Shutdown(InitInterfaces& interfaces)
             g_chainstate->ForceFlushStateToDisk();
             g_chainstate->ResetCoinsViews();
         }
+        pmasternodesview.reset();
         pblocktree.reset();
     }
     for (const auto& client : interfaces.chain_clients) {
@@ -431,6 +434,8 @@ void SetupServerArgs()
     gArgs.AddArg("-peertimeout=<n>", strprintf("Specify p2p connection timeout in seconds. This option determines the amount of time a peer may be inactive before the connection to it is dropped. (minimum: 1, default: %d)", DEFAULT_PEER_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-torcontrol=<ip>:<port>", strprintf("Tor control port to use if onion listening enabled (default: %s)", DEFAULT_TOR_CONTROL), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
+    gArgs.AddArg("-masternode_owner=<address>", "Masternode owner address (default: empty)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    gArgs.AddArg("-masternode_operator=<address>", "Masternode operator address (default: empty)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #ifdef USE_UPNP
 #if USE_UPNP
     gArgs.AddArg("-upnp", "Use UPnP to map the listening port (default: 1 when listening and no -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
@@ -1538,6 +1543,10 @@ bool AppInitMain(InitInterfaces& interfaces)
                         _("Error reading from database, shutting down.").translated,
                         "", CClientUIInterface::MSG_ERROR);
                 });
+                pmasternodesview.reset();
+                pmasternodesview = MakeUnique<CMasternodesViewDB>(nMinDbCache << 20, false, fReset || fReindexChainState);
+                pmasternodesview->Load();
+
 
                 // If necessary, upgrade from older database format.
                 // This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
@@ -1547,7 +1556,7 @@ bool AppInitMain(InitInterfaces& interfaces)
                 }
 
                 // ReplayBlocks is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
-                if (!ReplayBlocks(chainparams, &::ChainstateActive().CoinsDB())) {
+                if (!ReplayBlocks(chainparams, &::ChainstateActive().CoinsDB(), pmasternodesview.get())) {
                     strLoadError = _("Unable to replay blocks. You will need to rebuild the database using -reindex-chainstate.").translated;
                     break;
                 }
diff --git a/src/interfaces/chain.cpp b/src/interfaces/chain.cpp
index b8b9ecded9..98444c37a6 100644
--- a/src/interfaces/chain.cpp
+++ b/src/interfaces/chain.cpp
@@ -8,6 +8,7 @@
 #include <chainparams.h>
 #include <interfaces/handler.h>
 #include <interfaces/wallet.h>
+#include <masternodes/masternodes.h>
 #include <net.h>
 #include <net_processing.h>
 #include <node/coin.h>
@@ -270,6 +271,12 @@ class ChainImpl : public Chain
         return true;
     }
     void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(coins); }
+    bool mnCanSpend(const uint256 & nodeId, int height) override
+    {
+        LOCK(cs_main);
+        return pmasternodesview->CanSpend(nodeId, height);
+    }
+
     double guessVerificationProgress(const uint256& block_hash) override
     {
         LOCK(cs_main);
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index da670a3370..7afb0c7718 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -145,6 +145,8 @@ class Chain
     //! populates the values.
     virtual void findCoins(std::map<COutPoint, Coin>& coins) = 0;
 
+    virtual bool mnCanSpend(const uint256 & nodeId, int height) = 0;
+
     //! Estimate fraction of total transactions verified if blocks up to
     //! the specified block hash are verified.
     virtual double guessVerificationProgress(const uint256& block_hash) = 0;
diff --git a/src/key_io.cpp b/src/key_io.cpp
index cd41a93549..c5ba83effb 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -69,6 +69,7 @@ class DestinationEncoder : public boost::static_visitor<std::string>
 
     std::string operator()(const CNoDestination& no) const { return {}; }
 };
+} // namespace
 
 CTxDestination DecodeDestination(const std::string& str, const CChainParams& params)
 {
@@ -128,7 +129,6 @@ CTxDestination DecodeDestination(const std::string& str, const CChainParams& par
     }
     return CNoDestination();
 }
-} // namespace
 
 CKey DecodeSecret(const std::string& str)
 {
diff --git a/src/key_io.h b/src/key_io.h
index d80c08f49c..51dc9e50c2 100644
--- a/src/key_io.h
+++ b/src/key_io.h
@@ -23,6 +23,7 @@ std::string EncodeExtPubKey(const CExtPubKey& extpubkey);
 
 std::string EncodeDestination(const CTxDestination& dest);
 CTxDestination DecodeDestination(const std::string& str);
+CTxDestination DecodeDestination(const std::string& str, const CChainParams& params);
 bool IsValidDestinationString(const std::string& str);
 bool IsValidDestinationString(const std::string& str, const CChainParams& params);
 
diff --git a/src/masternodes/masternodes.cpp b/src/masternodes/masternodes.cpp
new file mode 100644
index 0000000000..eb11914f11
--- /dev/null
+++ b/src/masternodes/masternodes.cpp
@@ -0,0 +1,465 @@
+// Copyright (c) 2019 The DeFi Foundation
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "masternodes.h"
+
+#include "chainparams.h"
+#include "key_io.h"
+//#include "mn_txdb.h"
+#include "primitives/block.h"
+#include "primitives/transaction.h"
+
+#include <algorithm>
+#include <functional>
+
+std::unique_ptr<CMasternodesView> pmasternodesview;
+
+static const std::map<char, MasternodesTxType> MasternodesTxTypeToCode =
+{
+    {'C', MasternodesTxType::CreateMasternode },
+    {'R', MasternodesTxType::ResignMasternode }
+};
+
+//extern CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams); // in main.cpp
+
+int GetMnActivationDelay()
+{
+    return Params().GetConsensus().mn.activationDelay;
+}
+
+int GetMnCollateralUnlockDelay()
+{
+    return Params().GetConsensus().mn.collateralUnlockDelay;
+}
+
+int GetMnHistoryFrame()
+{
+    return Params().GetConsensus().mn.historyFrame;
+}
+
+
+CAmount GetMnCollateralAmount()
+{
+    return Params().GetConsensus().mn.collateralAmount;
+}
+
+CAmount GetMnCreationFee(int height)
+{
+    return Params().GetConsensus().mn.creationFee;
+
+//    CAmount blockSubsidy = GetBlockSubsidy(height, Params().GetConsensus());
+}
+
+CMasternode::CMasternode()
+    : mintedBlocks(0)
+    , ownerAuthAddress()
+    , ownerType(0)
+    , operatorAuthAddress()
+    , operatorType(0)
+    , creationHeight(0)
+    , resignHeight(-1)
+    , resignTx()
+{
+}
+
+void CMasternode::FromTx(CTransaction const & tx, int heightIn, std::vector<unsigned char> const & metadata)
+{
+    CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
+    ss >> operatorType;
+    ss >> operatorAuthAddress;
+
+    ownerType = 0;
+    ownerAuthAddress = {};
+
+    CTxDestination dest;
+    if (ExtractDestination(tx.vout[1].scriptPubKey, dest)) {
+        if (dest.which() == 1) {
+            ownerType = 1;
+            ownerAuthAddress = CKeyID(*boost::get<PKHash>(&dest));
+        }
+        else if (dest.which() == 4) {
+            ownerType = 4;
+            ownerAuthAddress = CKeyID(*boost::get<WitnessV0KeyHash>(&dest));
+        }
+    }
+
+    creationHeight = heightIn;
+    resignHeight = -1;
+
+    resignTx = {};
+    mintedBlocks = 0;
+}
+
+std::string CMasternode::GetHumanReadableStatus() const
+{
+    std::string status;
+    if (IsActive())
+    {
+        return "active";
+    }
+    status += ((creationHeight == 0 || creationHeight + GetMnActivationDelay() <= ::ChainActive().Height())) ? "activated" : "created";
+    if (resignHeight != -1 || !resignTx.IsNull())
+    {
+        status += ", resigned";
+    }
+    return status;
+}
+
+bool operator==(CMasternode const & a, CMasternode const & b)
+{
+    return (a.mintedBlocks == b.mintedBlocks &&
+            a.ownerType == b.ownerType &&
+            a.ownerAuthAddress == b.ownerAuthAddress &&
+            a.operatorType == b.operatorType &&
+            a.operatorAuthAddress == b.operatorAuthAddress &&
+            a.creationHeight == b.creationHeight &&
+            a.resignHeight == b.resignHeight &&
+            a.resignTx == b.resignTx
+            );
+}
+
+bool operator!=(CMasternode const & a, CMasternode const & b)
+{
+    return !(a == b);
+}
+
+
+/*
+ * Searching MN index 'nodesByOwner' or 'nodesByOperator' for given 'auth' key
+ */
+boost::optional<CMasternodesByAuth::const_iterator>
+CMasternodesView::ExistMasternode(CMasternodesView::AuthIndex where, CKeyID const & auth) const
+{
+    CMasternodesByAuth const & index = (where == AuthIndex::ByOwner) ? nodesByOwner : nodesByOperator;
+    auto it = index.find(auth);
+    if (it == index.end() || it->second.IsNull())
+    {
+        return {};
+    }
+    return {it};
+}
+
+/*
+ * Searching all masternodes for given 'id'
+ */
+CMasternode const * CMasternodesView::ExistMasternode(uint256 const & id) const
+{
+    CMasternodes::const_iterator it = allNodes.find(id);
+    return it != allNodes.end() && it->second != CMasternode() ? &it->second : nullptr;
+}
+
+/*
+ * Check that given tx is not a masternode id or masternode was resigned enough time in the past
+ */
+bool CMasternodesView::CanSpend(const uint256 & nodeId, int height) const
+{
+    auto nodePtr = ExistMasternode(nodeId);
+    // if not exist or (resigned && delay passed)
+    return !nodePtr || (nodePtr->resignHeight != -1 && nodePtr->resignHeight + GetMnCollateralUnlockDelay() <= height);
+}
+
+/*
+ * Check that given node is involved in anchor's subsystem for a given height (or smth like that)
+ */
+bool CMasternodesView::IsAnchorInvolved(const uint256 & nodeId, int height) const
+{
+    /// @todo @max to be implemented
+    return false;
+}
+
+CMasternodesView::CMnBlocksUndo::mapped_type const & CMasternodesView::GetBlockUndo(CMnBlocksUndo::key_type key) const
+{
+    static CMnBlocksUndo::mapped_type const Empty = {};
+    CMnBlocksUndo::const_iterator it = blocksUndo.find(key);
+    return it != blocksUndo.end() ? it->second : Empty;
+}
+
+bool CMasternodesView::OnMasternodeCreate(uint256 const & nodeId, CMasternode const & node, int txn)
+{
+    // Check auth addresses and that there in no MN with such owner or operator
+    if ((node.operatorType != 1 && node.operatorType != 4 && node.ownerType != 1 && node.ownerType != 4) ||
+        node.ownerAuthAddress.IsNull() || node.operatorAuthAddress.IsNull() ||
+        ExistMasternode(nodeId) ||
+        ExistMasternode(AuthIndex::ByOwner, node.ownerAuthAddress) ||
+        ExistMasternode(AuthIndex::ByOperator, node.operatorAuthAddress)
+        )
+    {
+        return false;
+    }
+
+    allNodes[nodeId] = node;
+    nodesByOwner[node.ownerAuthAddress] = nodeId;
+    nodesByOperator[node.operatorAuthAddress] = nodeId;
+
+//    blocksUndo[std::make_pair(node.height, txn)] = std::make_pair(nodeId, MasternodesTxType::CreateMasternode);
+    blocksUndo[node.creationHeight][txn] = std::make_pair(nodeId, MasternodesTxType::CreateMasternode);
+
+    return true;
+}
+
+bool CMasternodesView::OnMasternodeResign(uint256 const & nodeId, uint256 const & txid, int height, int txn)
+{
+    // auth already checked!
+    auto const node = ExistMasternode(nodeId);
+    if (!node || node->resignHeight != -1 || !node->resignTx.IsNull() || IsAnchorInvolved(nodeId, height))
+    {
+        return false;
+    }
+
+    allNodes[nodeId] = *node; // !! cause may be cached!
+    allNodes[nodeId].resignTx = txid;
+    allNodes[nodeId].resignHeight = height;
+
+//    blocksUndo[std::make_pair(height, txn)] = std::make_pair(nodeId, MasternodesTxType::ResignMasternode);
+    blocksUndo[height][txn] = std::make_pair(nodeId, MasternodesTxType::ResignMasternode);
+
+    return true;
+}
+
+
+CMasternodesViewCache CMasternodesView::OnUndoBlock(int height)
+{
+    assert(height == lastHeight);
+
+    CMasternodesViewCache backup(this); // dummy, not used as "true base"
+
+    auto undoTxs = GetBlockUndo(height);
+
+    if (!undoTxs.empty())
+    {
+        for (auto undoData = undoTxs.rbegin(); undoData != undoTxs.rend(); ++undoData)
+        {
+            auto const id = undoData->second.first;
+            auto const txType = undoData->second.second;
+            CMasternode const & node = *ExistMasternode(id);
+
+            switch (txType)
+            {
+                case MasternodesTxType::CreateMasternode:
+                {
+                    backup.nodesByOwner[node.ownerAuthAddress] = id;
+                    backup.nodesByOperator[node.operatorAuthAddress] = id;
+                    backup.allNodes[id] = node;
+
+                    nodesByOwner[node.ownerAuthAddress] = {};
+                    nodesByOperator[node.operatorAuthAddress] = {};
+                    allNodes[id] = {};
+                }
+                break;
+                case MasternodesTxType::ResignMasternode:
+                {
+                    backup.allNodes[id] = node; // nodesByOwner && nodesByOperator stay untouched
+
+                    allNodes[id] = node;    // !! cause may be cached!
+                    allNodes[id].resignHeight = -1;
+                    allNodes[id].resignTx = {};
+                }
+                break;
+                default:
+                    break;
+            }
+        }
+        backup.blocksUndo[height] = undoTxs; // not `blocksUndo[height]`!! cause may be cached!
+        blocksUndo[height] = {};
+    }
+    backup.lastHeight = lastHeight;
+    --lastHeight;
+
+    return backup; // it is new value diff for height+1
+}
+
+//bool CMasternodesView::OnConnectBlock(int height, const CKeyID & minter)
+//{
+//    lastHeight = height;
+
+//    auto nodePtr = ExistMasternode(minter);
+//    assert(nodePtr);
+
+//    if (nodePtr)
+//    {
+//        allNodes[minter] = *nodePtr; // !! cause may be cached!
+//        ++allNodes[minter].mintedBlocks;
+
+//        return true;
+//    }
+//    return false;
+//}
+
+
+//bool CMasternodesView::IsTeamMember(int height, CKeyID const & operatorAuth) const
+//{
+//    CTeam const & team = ReadDposTeam(height);
+//    for (auto const & member : team)
+//    {
+//        if (member.second.operatorAuth == operatorAuth)
+//            return true;
+//    }
+//    return false;
+//}
+
+//CTeam const & CMasternodesView::ReadDposTeam(int height) const
+//{
+//    static CTeam const Empty{};
+
+//    auto const it = teams.find(height);
+//    if (it != teams.end())
+//        return it->second;
+
+//    // Nothing to complain here, cause teams not exists before dPoS activation!
+////    LogPrintf("MN ERROR: Fail to get team at height %d! May be already pruned!\n", height);
+//    return Empty;
+//}
+
+//void CMasternodesView::WriteDposTeam(int height, const CTeam & team)
+//{
+//    assert(height >= 0);
+//    teams[height] = team;
+//}
+
+
+/// Call it only for "clear" and "full" (not cached) view
+void CMasternodesView::PruneOlder(int height)
+{
+
+    /// @todo @max add foolproof (for heights, teams and collateral)
+    if (height < 0)
+    {
+        return;
+    }
+
+    // erase dead nodes
+    for (auto && it = allNodes.begin(); it != allNodes.end(); )
+    {
+        CMasternode const & node = it->second;
+        if(node.resignHeight != -1 && node.resignHeight < height)
+        {
+            nodesByOwner.erase(node.ownerAuthAddress);
+            nodesByOperator.erase(node.operatorAuthAddress);
+            it = allNodes.erase(it);
+        }
+        else ++it;
+    }
+
+    // erase undo info
+    blocksUndo.erase(blocksUndo.begin(), blocksUndo.lower_bound(height));
+    // erase old teams info
+//    teams.erase(teams.begin(), teams.lower_bound(height));
+}
+
+boost::optional<CMasternodesView::CMasternodeIDs> CMasternodesView::AmI(AuthIndex where) const
+{
+    std::string addressBase58 = (where == AuthIndex::ByOperator) ? gArgs.GetArg("-masternode_operator", "") : gArgs.GetArg("-masternode_owner", "");
+    if (addressBase58 != "")
+    {
+        CTxDestination dest = DecodeDestination(addressBase58);
+        auto const authAddress = dest.which() == 1 ? CKeyID(*boost::get<PKHash>(&dest)) : (dest.which() == 4 ? CKeyID(*boost::get<WitnessV0KeyHash>(&dest)) : CKeyID());
+        if (!authAddress.IsNull())
+        {
+            auto const it = ExistMasternode(where, authAddress);
+            if (it)
+            {
+                uint256 const & id = (*it)->second;
+                return { CMasternodeIDs {id, ExistMasternode(id)->operatorAuthAddress, ExistMasternode(id)->ownerAuthAddress} };
+            }
+        }
+    }
+    return {};
+}
+
+boost::optional<CMasternodesView::CMasternodeIDs> CMasternodesView::AmIOperator() const
+{
+    return AmI(AuthIndex::ByOperator);
+}
+
+boost::optional<CMasternodesView::CMasternodeIDs> CMasternodesView::AmIOwner() const
+{
+    return AmI(AuthIndex::ByOwner);
+}
+
+//boost::optional<CMasternodesView::CMasternodeIDs> CMasternodesView::AmIActiveOperator() const
+//{
+//    auto result = AmI(AuthIndex::ByOperator);
+//    if (result && ExistMasternode(result->id)->IsActive())
+//    {
+//        return result;
+//    }
+//    return {};
+//}
+
+//boost::optional<CMasternodesView::CMasternodeIDs> CMasternodesView::AmIActiveOwner() const
+//{
+//    auto result = AmI(AuthIndex::ByOwner);
+//    if (result && ExistMasternode(result->id)->IsActive())
+//    {
+//        return result;
+//    }
+//    return {};
+//}
+
+void CMasternodesView::ApplyCache(const CMasternodesView * cache)
+{
+    lastHeight = cache->lastHeight;
+
+    for (auto const & pair : cache->allNodes) {
+        allNodes[pair.first] = pair.second; // possible empty (if deleted)
+    }
+
+    for (auto const & pair : cache->nodesByOwner) {
+        nodesByOwner[pair.first] = pair.second; // possible empty (if deleted)
+    }
+
+    for (auto const & pair : cache->nodesByOperator) {
+        nodesByOperator[pair.first] = pair.second; // possible empty (if deleted)
+    }
+
+    for (auto const & pair : cache->blocksUndo) {
+        blocksUndo[pair.first] = pair.second; // possible empty (if deleted)
+    }
+}
+
+void CMasternodesView::Clear()
+{
+    lastHeight = 0;
+    allNodes.clear();
+    nodesByOwner.clear();
+    nodesByOperator.clear();
+
+    blocksUndo.clear();
+//    teams.clear();
+}
+
+/*
+ * Checks if given tx is probably one of 'MasternodeTx', returns tx type and serialized metadata in 'data'
+*/
+MasternodesTxType GuessMasternodeTxType(CTransaction const & tx, std::vector<unsigned char> & metadata)
+{
+    if (tx.vout.size() == 0)
+    {
+        return MasternodesTxType::None;
+    }
+    CScript const & memo = tx.vout[0].scriptPubKey;
+    CScript::const_iterator pc = memo.begin();
+    opcodetype opcode;
+    if (!memo.GetOp(pc, opcode) || opcode != OP_RETURN)
+    {
+        return MasternodesTxType::None;
+    }
+    if (!memo.GetOp(pc, opcode, metadata) ||
+            (opcode > OP_PUSHDATA1 &&
+             opcode != OP_PUSHDATA2 &&
+             opcode != OP_PUSHDATA4) ||
+            metadata.size() < MnTxMarker.size() + 1 ||     // i don't know how much exactly, but at least MnTxSignature + type prefix
+            memcmp(&metadata[0], &MnTxMarker[0], MnTxMarker.size()) != 0)
+    {
+        return MasternodesTxType::None;
+    }
+    auto const & it = MasternodesTxTypeToCode.find(metadata[MnTxMarker.size()]);
+    if (it == MasternodesTxTypeToCode.end())
+    {
+        return MasternodesTxType::None;
+    }
+    metadata.erase(metadata.begin(), metadata.begin() + MnTxMarker.size() + 1);
+    return it->second;
+}
+
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
new file mode 100644
index 0000000000..0a138a38ee
--- /dev/null
+++ b/src/masternodes/masternodes.h
@@ -0,0 +1,394 @@
+// Copyright (c) 2019 The DeFi Foundation
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef MASTERNODES_H
+#define MASTERNODES_H
+
+#include "amount.h"
+#include "primitives/transaction.h"
+#include "pubkey.h"
+#include "script/script.h"
+#include "script/standard.h"
+#include "serialize.h"
+#include "uint256.h"
+#include "validation.h"
+
+#include <map>
+#include <set>
+#include <stdint.h>
+#include <iostream>
+
+#include <boost/optional.hpp>
+#include <boost/scoped_ptr.hpp>
+
+static const std::vector<unsigned char> MnTxMarker = {'M', 'n', 'T', 'x'};  // 4d6e5478
+
+enum class MasternodesTxType : unsigned char
+{
+    None = 0,
+    CreateMasternode    = 'C',
+    ResignMasternode    = 'R'
+};
+
+template<typename Stream>
+inline void Serialize(Stream& s, MasternodesTxType txType)
+{
+    Serialize(s, static_cast<unsigned char>(txType));
+}
+
+template<typename Stream>
+inline void Unserialize(Stream& s, MasternodesTxType & txType) {
+    unsigned char ch;
+    Unserialize(s, ch);
+    txType = ch == 'C' ? MasternodesTxType::CreateMasternode :
+             ch == 'R' ? MasternodesTxType::ResignMasternode :
+                         MasternodesTxType::None;
+}
+
+// Works instead of constants cause 'regtest' differs (don't want to overcharge chainparams)
+int GetMnActivationDelay();
+int GetMnCollateralUnlockDelay();
+int GetMnHistoryFrame();
+CAmount GetMnCollateralAmount();
+CAmount GetMnCreationFee(int height);
+
+class CMasternode
+{
+public:
+    //! Minted blocks counter
+    uint32_t mintedBlocks;
+
+    //! Owner auth address == collateral address. Can be used as an ID.
+    CKeyID ownerAuthAddress;
+    char ownerType;
+
+    //! Operator auth address. Can be equal to ownerAuthAddress. Can be used as an ID
+    CKeyID operatorAuthAddress;
+    char operatorType;
+
+    //! MN creation block height
+    int32_t creationHeight;
+    //! Resign height
+    int32_t resignHeight;
+
+    //! This fields are for transaction rollback (by disconnecting block)
+    uint256 resignTx;
+
+    //! empty constructor
+    CMasternode();
+
+    //! constructor helper, runs without any checks
+    void FromTx(CTransaction const & tx, int heightIn, std::vector<unsigned char> const & metadata);
+
+    //! construct a CMasternode from a CTransaction, at a given height
+    CMasternode(CTransaction const & tx, int heightIn, std::vector<unsigned char> const & metadata)
+    {
+        FromTx(tx, heightIn, metadata);
+    }
+
+    bool IsActive(int h = ::ChainActive().Height()) const
+    {
+        // Special case for genesis block
+        if (creationHeight == 0)
+            return h > 0 && (resignHeight == -1 || resignHeight > h);
+
+        return  creationHeight + GetMnActivationDelay() <= h && (resignHeight == -1 || resignHeight > h);
+    }
+
+    std::string GetHumanReadableStatus() const;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action)
+    {
+        READWRITE(mintedBlocks);
+        READWRITE(ownerAuthAddress);
+        READWRITE(ownerType);
+        READWRITE(operatorAuthAddress);
+        READWRITE(operatorType);
+
+        READWRITE(creationHeight);
+        READWRITE(resignHeight);
+
+        READWRITE(resignTx);
+    }
+
+    //! equality test
+    friend bool operator==(CMasternode const & a, CMasternode const & b);
+    friend bool operator!=(CMasternode const & a, CMasternode const & b);
+};
+
+typedef std::map<uint256, CMasternode> CMasternodes;  // nodeId -> masternode object,
+//typedef std::set<uint256> CActiveMasternodes;         // just nodeId's,
+typedef std::map<CKeyID, uint256> CMasternodesByAuth; // for two indexes, owner->nodeId, operator->nodeId
+
+//struct TeamData
+//{
+//    int32_t joinHeight;
+//    CKeyID  operatorAuth;
+//};
+
+//typedef std::map<uint256, TeamData> CTeam;   // nodeId -> <joinHeight, operatorAuth> - masternodes' team
+
+class CMasternodesViewCache;
+class CMasternodesViewHistory;
+
+class CMasternodesView
+{
+public:
+    // Block of typedefs
+    struct CMasternodeIDs
+    {
+        uint256 id;
+        CKeyID operatorAuthAddress;
+        CKeyID ownerAuthAddress;
+    };
+    typedef std::map<int, std::pair<uint256, MasternodesTxType> > CMnTxsUndo; // txn, undoRec
+    typedef std::map<int, CMnTxsUndo> CMnBlocksUndo;
+//    typedef std::map<int, CTeam> CTeams;
+
+    enum class AuthIndex { ByOwner, ByOperator };
+
+protected:
+    int lastHeight;
+    CMasternodes allNodes;
+//    CActiveMasternodes activeNodes;
+    CMasternodesByAuth nodesByOwner;
+    CMasternodesByAuth nodesByOperator;
+
+    CMnBlocksUndo blocksUndo;
+//    CTeams teams;
+
+    CMasternodesView() : lastHeight(0) {}
+
+//    CMasternodesView(CMasternodesView const & other) = delete;
+
+public:
+    CMasternodesView & operator=(CMasternodesView const & other) = delete;
+
+    void ApplyCache(CMasternodesView const * cache);
+    void Clear();
+
+    bool IsEmpty() const
+    {
+        return allNodes.empty() && nodesByOwner.empty() && nodesByOperator.empty() && blocksUndo.empty();
+    }
+
+    virtual ~CMasternodesView() {}
+
+    void SetLastHeight(int h)
+    {
+        lastHeight = h;
+    }
+    int GetLastHeight() const
+    {
+        return lastHeight;
+    }
+
+    void IncrementMintedBy(CKeyID const & minter)
+    {
+        auto it = ExistMasternode(AuthIndex::ByOperator, minter);
+        assert(it);
+        auto const & nodeId = (*it)->second;
+        auto nodePtr = ExistMasternode(nodeId);
+        assert(nodePtr);
+        auto & node = allNodes[nodeId] = *nodePtr; // cause may be cached!!
+        ++node.mintedBlocks;
+    }
+
+    void DecrementMintedBy(CKeyID const & minter)
+    {
+        auto it = ExistMasternode(AuthIndex::ByOperator, minter);
+        assert(it);
+        auto const & nodeId = (*it)->second;
+        auto nodePtr = ExistMasternode(nodeId);
+        assert(nodePtr);
+        auto & node = allNodes[nodeId] = *nodePtr; // cause may be cached!!
+        --node.mintedBlocks;
+    }
+
+    virtual CMasternodes GetMasternodes() const
+    {
+        /// for tests now, will be changed
+        return allNodes;
+    }
+
+    //! Initial load of all data
+    virtual bool Load() { assert(false); }
+    virtual bool Flush() { assert(false); }
+
+    virtual boost::optional<CMasternodesByAuth::const_iterator>
+    ExistMasternode(AuthIndex where, CKeyID const & auth) const;
+
+    virtual CMasternode const * ExistMasternode(uint256 const & id) const;
+
+    bool CanSpend(uint256 const & nodeId, int height) const;
+    bool IsAnchorInvolved(uint256 const & nodeId, int height) const;
+
+    bool OnMasternodeCreate(uint256 const & nodeId, CMasternode const & node, int txn);
+    bool OnMasternodeResign(uint256 const & nodeId, uint256 const & txid, int height, int txn);
+    CMasternodesViewCache OnUndoBlock(int height);
+
+//    bool OnConnectBlock(int height, CKeyID const & minter);
+//    bool OnDisconnectBlock(int height, CKeyID const & minter);
+
+    void PruneOlder(int height);
+
+//    bool IsTeamMember(int height, CKeyID const & operatorAuth) const;
+//    CTeam CalcNextDposTeam(CActiveMasternodes const & activeNodes, CMasternodes const & allNodes, uint256 const & blockHash, int height);
+//    virtual CTeam const & ReadDposTeam(int height) const;
+
+
+protected:
+    virtual CMnBlocksUndo::mapped_type const & GetBlockUndo(CMnBlocksUndo::key_type key) const;
+
+//    virtual void WriteDposTeam(int height, CTeam const & team);
+
+
+private:
+    boost::optional<CMasternodeIDs> AmI(AuthIndex where) const;
+public:
+    boost::optional<CMasternodeIDs> AmIOperator() const;
+    boost::optional<CMasternodeIDs> AmIOwner() const;
+//    boost::optional<CMasternodeIDs> AmIActiveOperator() const;
+//    boost::optional<CMasternodeIDs> AmIActiveOwner() const;
+
+    friend class CMasternodesViewCache;
+    friend class CMasternodesViewHistory;
+};
+
+
+class CMasternodesViewCache : public CMasternodesView
+{
+protected:
+    CMasternodesView * base;
+//    CMasternodesViewCache() {}
+
+public:
+    CMasternodesViewCache(CMasternodesView * other)
+        : CMasternodesView()
+        , base(other)
+    {
+        assert(base);
+        lastHeight = base->lastHeight;
+        // cached items are empty!
+    }
+
+    ~CMasternodesViewCache() override {}
+
+    CMasternodes GetMasternodes() const override
+    {
+        auto const baseNodes = base->GetMasternodes();
+        CMasternodes result(allNodes);
+        result.insert(baseNodes.begin(), baseNodes.end());
+        return result;
+    }
+
+    boost::optional<CMasternodesByAuth::const_iterator>
+    ExistMasternode(AuthIndex where, CKeyID const & auth) const override
+    {
+        CMasternodesByAuth const & index = (where == AuthIndex::ByOwner) ? nodesByOwner : nodesByOperator;
+        auto it = index.find(auth);
+        if (it == index.end())
+        {
+            return base->ExistMasternode(where, auth);
+        }
+        if (it->second.IsNull())
+        {
+            return {};
+        }
+        return {it};
+    }
+
+    CMasternode const * ExistMasternode(uint256 const & id) const override
+    {
+        CMasternodes::const_iterator it = allNodes.find(id);
+        return it == allNodes.end() ? base->ExistMasternode(id) : it->second != CMasternode() ? &it->second : nullptr;
+    }
+
+    CMnBlocksUndo::mapped_type const & GetBlockUndo(CMnBlocksUndo::key_type key) const override
+    {
+        CMnBlocksUndo::const_iterator it = blocksUndo.find(key);
+        return it == blocksUndo.end() ? base->GetBlockUndo(key) : it->second;
+    }
+
+
+    bool Flush() override
+    {
+        base->ApplyCache(this);
+        Clear();
+
+        return true;
+    }
+
+//    virtual CTeam const & ReadDposTeam(int height) const
+//    {
+//        auto const it = teams.find(height);
+//        // return cached (new) or original value
+//        return it != teams.end() ? it->second : base->ReadDposTeam(height);
+//    }
+//    friend class CMasternodesViewHistory;
+};
+
+
+class CMasternodesViewHistory : public CMasternodesViewCache
+{
+protected:
+    std::map<int, CMasternodesViewCache> historyDiff;
+
+public:
+    CMasternodesViewHistory(CMasternodesView * top) : CMasternodesViewCache(top) { assert(top); }
+
+    bool Flush() override { assert(false); } // forbidden!!!
+
+    CMasternodesViewHistory & GetState(int targetHeight)
+    {
+        int const topHeight = base->GetLastHeight();
+        assert(targetHeight >= topHeight - GetMnHistoryFrame() && targetHeight <= topHeight);
+
+        if (lastHeight > targetHeight)
+        {
+            // go backward (undo)
+
+            for (; lastHeight >= targetHeight; )
+            {
+                auto it = historyDiff.find(lastHeight);
+                if (it != historyDiff.end())
+                {
+                    historyDiff.erase(it);
+                }
+                historyDiff.emplace(std::make_pair(lastHeight, OnUndoBlock(lastHeight)));
+
+//                DecrementMintedBy();
+
+                --lastHeight;
+            }
+        }
+        else if (lastHeight < targetHeight)
+        {
+            // go forward (redo)
+            for (; lastHeight < targetHeight; )
+            {
+                ++lastHeight;
+
+                // redo states should be cached!
+                assert(historyDiff.find(lastHeight) != historyDiff.end());
+                ApplyCache(&historyDiff.at(lastHeight));
+
+//                IncrementMintedBy();
+            }
+
+        }
+        return *this;
+    }
+};
+
+/** Global variable that points to the CMasternodeView (should be protected by cs_main) */
+extern std::unique_ptr<CMasternodesView> pmasternodesview;
+
+//! Checks if given tx is probably one of custom 'MasternodeTx', returns tx type and serialized metadata in 'data'
+MasternodesTxType GuessMasternodeTxType(CTransaction const & tx, std::vector<unsigned char> & metadata);
+
+#endif // MASTERNODES_H
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
new file mode 100644
index 0000000000..ac2d66fb24
--- /dev/null
+++ b/src/masternodes/mn_checks.cpp
@@ -0,0 +1,173 @@
+// Copyright (c) 2019 DeFi Foundation
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "mn_checks.h"
+#include "masternodes.h"
+
+#include "arith_uint256.h"
+#include "chainparams.h"
+#include "logging.h"
+#include "primitives/block.h"
+#include "primitives/transaction.h"
+#include "txmempool.h"
+#include "univalue/include/univalue.h"
+#include "streams.h"
+
+#include <algorithm>
+#include <sstream>
+
+using namespace std;
+
+CPubKey GetPubkeyFromScriptSig(CScript const & scriptSig)
+{
+    CScript::const_iterator pc = scriptSig.begin();
+    opcodetype opcode;
+    std::vector<unsigned char> data;
+    // Signature first, then pubkey. I think, that in all cases it will be OP_PUSHDATA1, but...
+    if (!scriptSig.GetOp(pc, opcode, data) ||
+            (opcode > OP_PUSHDATA1 &&
+             opcode != OP_PUSHDATA2 &&
+             opcode != OP_PUSHDATA4))
+    {
+        return CPubKey();
+    }
+    if (!scriptSig.GetOp(pc, opcode, data) ||
+            (opcode > OP_PUSHDATA1 &&
+             opcode != OP_PUSHDATA2 &&
+             opcode != OP_PUSHDATA4))
+    {
+        return CPubKey();
+    }
+    return CPubKey(data);
+}
+
+bool HasAuth(CTransaction const & tx, CKeyID const & auth)
+{
+    for (auto input : tx.vin)
+    {
+        if (input.scriptWitness.IsNull()) {
+            if (GetPubkeyFromScriptSig(input.scriptSig).GetID() == auth)
+               return true;
+        }
+        else
+        {
+            /// @todo EXTEND IT TO SUPPORT WITNESS!!
+            auto test = CPubKey(input.scriptWitness.stack.back());
+            auto addr = test.GetID();
+            (void) addr;
+            std::cout << addr.ToString();
+
+            if (test.GetID() == auth)
+               return true;
+        }
+    }
+    return false;
+}
+
+bool CheckMasternodeTx(CMasternodesViewCache & mnview, CTransaction const & tx, Consensus::Params const & consensusParams, int height, int txn, bool isCheck)
+{
+    bool result = true;
+    /// @todo @maxb txn?
+//    if (tx.IsCoinBase())
+//    {
+//        return true;
+//    }
+
+    if (tx.vout.size() > 0)
+    {
+        // Check if it is masternode tx with metadata
+        std::vector<unsigned char> metadata;
+        MasternodesTxType guess = GuessMasternodeTxType(tx, metadata);
+        switch (guess)
+        {
+            case MasternodesTxType::CreateMasternode:
+                result = result && CheckCreateMasternodeTx(mnview, tx, height, txn, metadata, isCheck);
+            break;
+            case MasternodesTxType::ResignMasternode:
+                result = result && CheckResignMasternodeTx(mnview, tx, height, txn, metadata, isCheck);
+            break;
+            default:
+                break;
+        }
+    }
+    // We are always accept blocks (but skip failed txs) and fails only if it only check (but not real block processing)
+    return isCheck ? result : true;
+}
+
+/*
+ * Checks if given tx is 'txCreateMasternode'. Creates new MN if all checks are passed
+ * Issued by: any
+ */
+bool CheckCreateMasternodeTx(CMasternodesViewCache & mnview, CTransaction const & tx, int height, int txn, std::vector<unsigned char> const & metadata, bool isCheck)
+{
+    // Check quick conditions first
+    if (tx.vout.size() < 2 ||
+        tx.vout[0].nValue < GetMnCreationFee(height) ||
+        tx.vout[1].nValue != GetMnCollateralAmount()
+        )
+    {
+        return false;
+    }
+    CMasternode node(tx, height, metadata);
+    if (node.ownerAuthAddress.IsNull() || node.operatorAuthAddress.IsNull())
+    {
+        return false;
+    }
+    bool result = mnview.OnMasternodeCreate(tx.GetHash(), node, txn);
+    if (!isCheck)
+    {
+        LogPrintf("MN %s: Creation by tx %s at block %d\n", result ? "APPLYED" : "SKIPPED", tx.GetHash().GetHex(), height);
+    }
+    return result;
+}
+
+bool CheckResignMasternodeTx(CMasternodesViewCache & mnview, CTransaction const & tx, int height, int txn, const std::vector<unsigned char> & metadata, bool isCheck)
+{
+    uint256 nodeId(metadata);
+    auto const node = mnview.ExistMasternode(nodeId);
+    if (!node || node->resignHeight != -1 || !node->resignTx.IsNull() || !HasAuth(tx, node->ownerAuthAddress))
+    {
+        /// @todo @maxb more verbose? at least, auth?
+        return false;
+    }
+
+    bool result = mnview.OnMasternodeResign(nodeId, tx.GetHash(), height, txn);
+    if (!isCheck)
+    {
+        LogPrintf("MN %s: Resign by tx %s at block %d\n", result ? "APPLYED" : "SKIPPED", tx.GetHash().GetHex(), height);
+    }
+    return result;
+}
+
+/*
+ * Checks all inputs for collateral.
+ */
+bool CheckInputsForCollateralSpent(CMasternodesViewCache & mnview, CTransaction const & tx, int height, bool isCheck)
+{
+    bool total(true);
+    for (uint32_t i = 0; i < tx.vin.size() && total; ++i)
+    {
+        COutPoint const & prevout = tx.vin[i].prevout;
+        // Checks if it was collateral output.
+        if (prevout.n == 1 && mnview.ExistMasternode(prevout.hash))
+        {
+            // i - unused
+            bool result = mnview.CanSpend(prevout.hash, height);
+
+            if (!isCheck)
+            {
+                LogPrintf("MN %s: Spent collateral by tx %s for %s at block %d\n", result ? "APPROVED" : "DENIED", tx.GetHash().GetHex(), prevout.hash.GetHex(), height);
+            }
+            total = total && result;
+        }
+    }
+    return total;
+}
+
+bool IsMempooledMnCreate(const CTxMemPool & pool, const uint256 & txid)
+{
+    CTransactionRef ptx = pool.get(txid);
+    std::vector<unsigned char> dummy;
+    return (ptx && GuessMasternodeTxType(*ptx, dummy) == MasternodesTxType::CreateMasternode);
+}
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
new file mode 100644
index 0000000000..8b43eb0982
--- /dev/null
+++ b/src/masternodes/mn_checks.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2019 DeFi Foundation
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef MN_CHECKS_H
+#define MN_CHECKS_H
+
+#include "consensus/params.h"
+#include <vector>
+
+class CBlock;
+class CTransaction;
+class CTxMemPool;
+
+class CMasternodesView;
+class CMasternodesViewCache;
+
+bool CheckMasternodeTx(CMasternodesViewCache & mnview, CTransaction const & tx, const Consensus::Params& consensusParams, int height, int txn, bool isCheck = true);
+
+bool CheckInputsForCollateralSpent(CMasternodesViewCache & mnview, CTransaction const & tx, int nHeight, bool isCheck);
+//! Deep check (and write)
+bool CheckCreateMasternodeTx(CMasternodesViewCache & mnview, CTransaction const & tx, int height, int txn, std::vector<unsigned char> const & metadata, bool isCheck);
+bool CheckResignMasternodeTx(CMasternodesViewCache & mnview, CTransaction const & tx, int height, int txn, std::vector<unsigned char> const & metadata, bool isCheck);
+
+bool IsMempooledMnCreate(const CTxMemPool& pool, const uint256 & txid);
+
+#endif // MN_CHECKS_H
diff --git a/src/masternodes/mn_rpc.cpp b/src/masternodes/mn_rpc.cpp
new file mode 100644
index 0000000000..7744059dd1
--- /dev/null
+++ b/src/masternodes/mn_rpc.cpp
@@ -0,0 +1,489 @@
+// Copyright (c) 2019 The DeFi Foundation
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "masternodes.h"
+
+#include <core_io.h>
+//#include "../init.h"       // pwalletMain
+#include <consensus/validation.h>
+#include <key_io.h>
+#include <net.h>
+#include <rpc/client.h>
+#include <rpc/server.h>
+#include <rpc/protocol.h>
+#include <rpc/util.h>
+#include <script/script_error.h>
+#include <script/sign.h>
+#include <univalue/include/univalue.h>
+#include <util/validation.h>
+#include <validation.h>
+#include <version.h>
+
+//#ifdef ENABLE_WALLET
+#include <wallet/coincontrol.h>
+#include <wallet/rpcwallet.h>
+#include <wallet/wallet.h>
+//#endif
+
+#include <future>
+#include <stdexcept>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/assign/list_of.hpp>
+
+extern UniValue createrawtransaction(UniValue const & params, bool fHelp); // in rawtransaction.cpp
+extern UniValue fundrawtransaction(UniValue const & params, bool fHelp); // in rpcwallet.cpp
+extern UniValue signrawtransaction(UniValue const & params, bool fHelp); // in rawtransaction.cpp
+extern UniValue sendrawtransaction(UniValue const & params, bool fHelp); // in rawtransaction.cpp
+extern UniValue getnewaddress(UniValue const & params, bool fHelp); // in rpcwallet.cpp
+extern bool EnsureWalletIsAvailable(bool avoidException); // in rpcwallet.cpp
+extern bool DecodeHexTx(CTransaction & tx, std::string const & strHexTx); // in core_io.h
+//extern std::string EncodeHexTx(CTransaction const & tx);
+
+extern void ScriptPubKeyToJSON(CScript const & scriptPubKey, UniValue & out, bool fIncludeHex); // in rawtransaction.cpp
+
+namespace {
+// stolen from rpc_tests.cpp, can't import cause it's in tests module (not linked in main binary)
+UniValue CallRPC(std::string args)
+{
+    std::vector<std::string> vArgs;
+    boost::split(vArgs, args, boost::is_any_of(" \t"));
+    std::string strMethod = vArgs[0];
+    vArgs.erase(vArgs.begin());
+    JSONRPCRequest request;
+    request.strMethod = strMethod;
+    request.params = RPCConvertValues(strMethod, vArgs);
+    request.fHelp = false;
+
+    if (RPCIsInWarmup(nullptr)) SetRPCWarmupFinished();
+
+    // nothing to "try/catch" here, will be passed over
+    UniValue result = tableRPC.execute(request);
+    return result;
+}
+
+} // namespace
+
+void EnsureBlocksDownloaded()
+{
+//    if (::ChainstateActive().IsInitialBlockDownload() && Params().NetworkIDString() != "regtest")
+//    {
+//        throw JSONRPCError(RPC_IN_WARMUP, "Try it later. It is initial block download!");
+//    }
+}
+
+extern void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& fee_out, int& change_position, UniValue options);
+
+static UniValue fundsignsend(CMutableTransaction & mtx, JSONRPCRequest const & request)
+{
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet* const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, false)) {
+        return NullUniValue;
+    }
+
+    CAmount fee;
+    int change_position;
+    UniValue options(UniValue::VOBJ);
+    options.pushKV("changePosition", mtx.vout.size());
+    FundTransaction(pwallet, mtx, fee, change_position, options);
+
+    JSONRPCRequest new_request;
+    new_request.id = request.id;
+    new_request.URI = request.URI;
+
+    new_request.params.setArray();
+    new_request.params.push_back(EncodeHexTx(CTransaction(mtx)));
+    UniValue txSigned = signrawtransactionwithwallet(new_request);
+
+    // from "sendrawtransaction"
+    {
+        CMutableTransaction mtx;
+        if (!DecodeHexTx(mtx, txSigned["hex"].get_str()))
+            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
+        CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
+
+        CAmount max_raw_tx_fee = {COIN / 10}; /// @todo @maxb check it with 0
+
+        std::string err_string;
+        AssertLockNotHeld(cs_main);
+        const TransactionError err = BroadcastTransaction(tx, err_string, max_raw_tx_fee, /*relay*/ true, /*wait_callback*/ false);
+        if (TransactionError::OK != err) {
+            throw JSONRPCTransactionError(err, err_string);
+        }
+        return tx->GetHash().GetHex();
+    }
+}
+
+
+CAmount EstimateMnCreationFee()
+{
+    // Current height + (1 day blocks) to avoid rejection;
+    int targetHeight = ::ChainActive().Height() + 1 + (60 * 60 / Params().GetConsensus().pos.nTargetSpacing);
+//    size_t targetMnCount = pmasternodesview->GetActiveMasternodes().size() < 4 ? 0 : pmasternodesview->GetActiveMasternodes().size() - 4;
+    return GetMnCreationFee(targetHeight);
+}
+
+//UniValue mn_estimatemncreationfee(UniValue const & params, bool fHelp)
+//{
+//    if (fHelp || params.size() != 0)
+//        throw std::runtime_error(
+//            "mn_estimateannouncementfee\n"
+//            "\nEstimates the approximate masternode announcement fee\n"
+//            "\nResult:\n"
+//            "n :    (numeric) estimated fee\n"
+//            "\n"
+//            "\nExample:\n"
+//            + HelpExampleCli("mn_estimatemncreationfee", ""));
+
+//    LOCK(cs_main);
+//    return ValueFromAmount(EstimateMnCreationFee());
+//}
+
+/*
+ *
+ *  Issued by: any
+*/
+
+void FillInputs(UniValue const & inputs, CMutableTransaction & rawTx)
+{
+    for (unsigned int idx = 0; idx < inputs.size(); idx++)
+    {
+        const UniValue& input = inputs[idx];
+        const UniValue& o = input.get_obj();
+
+        uint256 txid = ParseHashO(o, "txid");
+
+        const UniValue& vout_v = find_value(o, "vout");
+        if (!vout_v.isNum())
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing vout key");
+        int nOutput = vout_v.get_int();
+        if (nOutput < 0)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout must be positive");
+
+        rawTx.vin.push_back(CTxIn(txid, nOutput));
+    }
+}
+
+UniValue mn_create(const JSONRPCRequest& request)
+{
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet* const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    RPCHelpMan{"mn_create",
+        "\nCreates (and submits to local node and network) a masternode creation transaction with given metadata, spending the given inputs..\n"
+        "The first optional argument (may be empty array) is an array of specific UTXOs to spend." +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            {"prevouts", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of json objects. Provide it if you want to spent specific UTXOs",
+                {
+                    {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
+                        },
+                    },
+                },
+            },
+            {"metadata", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                {
+                    {"operatorAuthAddress", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Masternode operator auth address (P2PKH only, unique)" },
+                    {"collateralAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "Any valid address for keeping collateral amount (any P2PKH or P2WKH address) - used as owner key"},
+                },
+            },
+        },
+        RPCResult{
+            "\"hex\"                  (string) The hex-encoded raw transaction with signature(s)\n"
+        },
+        RPCExamples{
+            HelpExampleCli("mn_create", "\"[{\\\"txid\\\":\\\"id\\\",\\\"vout\\\":0}]\" "
+                                            "\"{\\\"operatorAuthAddress\\\":\\\"address\\\","
+                                               "\\\"collateralAddress\\\":\\\"address\\\""
+                                            "}\"")
+            + HelpExampleRpc("mn_create", "\"[{\\\"txid\\\":\\\"id\\\",\\\"vout\\\":0}]\" "
+                                          "\"{\\\"operatorAuthAddress\\\":\\\"address\\\","
+                                             "\\\"collateralAddress\\\":\\\"address\\\""
+                                            "}\"")
+        },
+    }.Check(request);
+
+
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot create Masternode while still in Initial Block Download");
+    }
+
+    // Make sure the results are valid at least up to the most recent block
+    // the user could have gotten from another RPC command prior to now
+    pwallet->BlockUntilSyncedToCurrentChain();
+
+    auto locked_chain = pwallet->chain().lock(); /// @todo @maxb is it enough? (i mean cs_main)
+    LOCK(pwallet->cs_wallet);
+
+    EnsureWalletIsUnlocked(pwallet);
+
+    RPCTypeCheck(request.params, { UniValue::VARR, UniValue::VOBJ }, true);
+    if (request.params[0].isNull() || request.params[1].isNull())
+    {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameters, arguments 1 and 2 must be non-null, and argument 2 expected as object with "
+                                                  "{\"name\",\"ownerAuthAddress\",\"operatorAuthAddress\",\"ownerRewardAddress\",\"collateralAddress\"}");
+    }
+    UniValue metaObj = request.params[1].get_obj();
+    RPCTypeCheckObj(metaObj, {
+                        { "operatorAuthAddress", UniValue::VSTR },
+                        { "collateralAddress", UniValue::VSTR }
+                    },
+                    true, true);
+
+    std::string collateralAddress =         metaObj["collateralAddress"].getValStr();
+    std::string operatorAuthAddressBase58 = metaObj["operatorAuthAddress"].getValStr();
+
+    // Parameters validation block
+    CTxDestination collateralDest = DecodeDestination(collateralAddress);
+    /// @todo @max implement WitnessV0KeyHash! (type 4)
+    if (collateralDest.which() != 1 && collateralDest.which() != 4)
+    {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "collateralAddress (" + collateralAddress + ") does not refer to a P2PKH or P2WPKH address");
+    }
+    CKeyID ownerAuthKey = collateralDest.which() == 1 ? CKeyID(*boost::get<PKHash>(&collateralDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&collateralDest));
+    if (pmasternodesview->ExistMasternode(CMasternodesView::AuthIndex::ByOwner, ownerAuthKey) ||
+        pmasternodesview->ExistMasternode(CMasternodesView::AuthIndex::ByOperator, ownerAuthKey))
+    {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Masternode with collateralAddress == " + collateralAddress + " already exists");
+    }
+
+    // owner and operator check
+    CTxDestination operatorDest = operatorAuthAddressBase58 == "" ? collateralDest : DecodeDestination(operatorAuthAddressBase58);
+    /// @todo @max implement WitnessV0KeyHash! (type 4)
+
+    if (operatorDest.which() != 1 && operatorDest.which() != 4)
+    {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "operatorAuthAddress (" + operatorAuthAddressBase58 + ") does not refer to a P2PKH or P2WPKH address");
+    }
+    CKeyID operatorAuthKey = operatorDest.which() == 1 ? CKeyID(*boost::get<PKHash>(&operatorDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&operatorDest)) ;
+    if (pmasternodesview->ExistMasternode(CMasternodesView::AuthIndex::ByOwner, operatorAuthKey) ||
+        pmasternodesview->ExistMasternode(CMasternodesView::AuthIndex::ByOperator, operatorAuthKey))
+    {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Masternode with operatorAuthAddress == " + EncodeDestination(operatorDest) + " already exists");
+    }
+
+    CDataStream metadata(MnTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    metadata << static_cast<unsigned char>(MasternodesTxType::CreateMasternode)
+             << static_cast<char>(operatorDest.which()) << operatorAuthKey;
+
+    CScript scriptMeta;
+    scriptMeta << OP_RETURN << ToByteVector(metadata);
+
+    CMutableTransaction rawTx;
+
+    FillInputs(request.params[0].get_array(), rawTx);
+
+    rawTx.vout.push_back(CTxOut(EstimateMnCreationFee(), scriptMeta));
+    rawTx.vout.push_back(CTxOut(GetMnCollateralAmount(), GetScriptForDestination(collateralDest)));
+
+    return fundsignsend(rawTx, request);
+}
+
+
+UniValue mn_resign(const JSONRPCRequest& request)
+{
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet* const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    RPCHelpMan{"mn_resign",
+        "\nCreates (and submits to local node and network) a transaction resigning your masternode. Collateral will be unlocked after " + std::to_string(GetMnCollateralUnlockDelay()) + " blocks.\n"
+        "The first optional argument (may be empty array) is an array of specific UTXOs to spend. One of UTXO's must belong to the MN's owner (collateral) address" +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            {"prevouts", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of json objects. Provide it if you want to spent specific UTXOs",
+                {
+                    {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
+                        },
+                    },
+                },
+            },
+            {"mn_id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The Masternode's ID"},
+        },
+        RPCResult{
+            "\"hex\"                      (string) The hex-encoded raw transaction with signature(s)\n"
+        },
+        RPCExamples{
+            HelpExampleCli("mn_resign", "\"[{\\\"txid\\\":\\\"id\\\",\\\"vout\\\":0}]\" \"mn_id\"")
+            + HelpExampleRpc("mn_resign", "\"[{\\\"txid\\\":\\\"id\\\",\\\"vout\\\":0}]\" \"mn_id\"")
+        },
+    }.Check(request);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot resign Masternode while still in Initial Block Download");
+    }
+
+    // Make sure the results are valid at least up to the most recent block
+    // the user could have gotten from another RPC command prior to now
+    pwallet->BlockUntilSyncedToCurrentChain();
+
+    auto locked_chain = pwallet->chain().lock();  /// @todo @maxb is it enough? (i mean cs_main)
+    LOCK(pwallet->cs_wallet);
+
+    EnsureWalletIsUnlocked(pwallet);
+
+    RPCTypeCheck(request.params, { UniValue::VARR, UniValue::VSTR }, true);
+
+    std::string const nodeIdStr = request.params[1].getValStr();
+    uint256 nodeId = uint256S(nodeIdStr);
+    auto optIDs = pmasternodesview->AmIOwner();
+    if (!optIDs)
+    {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("You are not the owner of masternode %s, or it does not exist", nodeIdStr));
+    }
+    auto nodePtr = pmasternodesview->ExistMasternode(nodeId);
+    if (!nodePtr->resignTx.IsNull())
+    {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Masternode %s was resigned by tx %s; collateral can be spend at block #%d", nodeIdStr, nodePtr->resignTx.GetHex(), nodePtr->resignHeight+GetMnActivationDelay()));
+    }
+
+    CMutableTransaction rawTx;
+
+    UniValue inputs = request.params[0].get_array();
+    if (inputs.size() > 0)
+    {
+        FillInputs(request.params[0].get_array(), rawTx);
+    }
+    else
+    {
+        CTxDestination ownerDest = nodePtr->ownerType == 1 ? CTxDestination(PKHash(nodePtr->ownerAuthAddress)) : CTxDestination(WitnessV0KeyHash(nodePtr->ownerAuthAddress));
+        std::vector<COutput> vecOutputs;
+        CCoinControl cctl;
+        cctl.m_avoid_address_reuse = false;
+        cctl.m_min_depth = 1;
+        cctl.m_max_depth = 9999999;
+        cctl.matchDestination = ownerDest;
+        pwallet->AvailableCoins(*locked_chain, vecOutputs, true, &cctl, 1, MAX_MONEY, MAX_MONEY, 1);
+
+        if (vecOutputs.size() == 0)
+        {
+            throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strprintf("Can't find any UTXO's for ownerAuthAddress (%s). Send some coins and try again!", EncodeDestination(ownerDest)));
+        }
+        rawTx.vin.push_back(CTxIn(vecOutputs[0].tx->GetHash(), vecOutputs[0].i));
+    }
+
+    CDataStream metadata(MnTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    metadata << static_cast<unsigned char>(MasternodesTxType::ResignMasternode)
+             << nodeId;
+
+    CScript scriptMeta;
+    scriptMeta << OP_RETURN << ToByteVector(metadata);
+
+    rawTx.vout.push_back(CTxOut(0, scriptMeta));
+
+    return fundsignsend(rawTx, request);
+}
+
+
+// Here (but not a class method) just by similarity with other '..ToJSON'
+UniValue mnToJSON(CMasternode const & node)
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("ownerAuthAddress", EncodeDestination(node.ownerType == 1 ? CTxDestination(PKHash(node.ownerAuthAddress)) : CTxDestination(WitnessV0KeyHash(node.ownerAuthAddress))));
+    ret.pushKV("operatorAuthAddress", EncodeDestination(node.operatorType == 1 ? CTxDestination(PKHash(node.operatorAuthAddress)) : CTxDestination(WitnessV0KeyHash(node.operatorAuthAddress))));
+
+    ret.pushKV("creationHeight", node.creationHeight);
+    ret.pushKV("resignHeight", node.resignHeight);
+
+    ret.pushKV("resignTx", node.resignTx.GetHex());
+    ret.pushKV("status", node.GetHumanReadableStatus());
+
+    return ret;
+}
+
+UniValue mn_list(const JSONRPCRequest& request)
+{
+    RPCHelpMan{"mn_list",
+        "\nReturns information about specified masternodes (or all, if list of ids is empty).\n",
+        {
+            {"ids", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of masternode ids",
+                {
+                    {"mn_id", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "Masternode's id"},
+                },
+            },
+            {"verbose", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Flag for verbose list (default = true), otherwise only ids and statuses listed"},
+        },
+        RPCResult{
+            "{id:{...},...}     (array) Json object with masternodes information\n"
+        },
+        RPCExamples{
+            HelpExampleCli("mn_resign", "\"[{\\\"txid\\\":\\\"id\\\",\\\"vout\\\":0}]\" \"mn_id\"")
+            + HelpExampleRpc("mn_resign", "\"[{\\\"txid\\\":\\\"id\\\",\\\"vout\\\":0}]\" \"mn_id\"")
+        },
+    }.Check(request);
+
+    LOCK(cs_main);
+
+    RPCTypeCheck(request.params, { UniValue::VARR, UniValue::VBOOL }, true);
+
+    UniValue inputs(UniValue::VARR);
+    if (request.params.size() > 0)
+    {
+        inputs = request.params[0].get_array();
+    }
+    bool verbose = true;
+    if (request.params.size() > 1)
+    {
+        verbose = request.params[1].get_bool();
+    }
+
+    UniValue ret(UniValue::VOBJ);
+    CMasternodes const & mns = pmasternodesview->GetMasternodes();
+    if (inputs.empty())
+    {
+        // Dumps all!
+        for (auto it = mns.begin(); it != mns.end(); ++it)
+        {
+            if (it->second != CMasternode())
+                ret.pushKV(it->first.GetHex(), verbose ? mnToJSON(it->second) : it->second.GetHumanReadableStatus());
+        }
+    }
+    else
+    {
+        for (size_t idx = 0; idx < inputs.size(); ++idx)
+        {
+            uint256 id = ParseHashV(inputs[idx], "masternode id");
+            auto const & node = pmasternodesview->ExistMasternode(id);
+            if (node && *node != CMasternode())
+            {
+                ret.pushKV(id.GetHex(), verbose ? mnToJSON(*node) : node->GetHumanReadableStatus());
+            }
+        }
+    }
+    return ret;
+}
+
+
+static const CRPCCommand commands[] =
+{ //  category          name                        actor (function)            params
+  //  ----------------- ------------------------    -----------------------     ----------
+//  { "masternodes",    "mn_estimateannouncementfee", &mn_estimateannouncementfee, {}  },
+  { "masternodes",      "mn_create",                &mn_create,                 { "inputs", "metadata" }  },
+  { "masternodes",      "mn_resign",                &mn_resign,                 { "mn_id" }  },
+
+  { "masternodes",      "mn_list",                  &mn_list,                   { "list", "verbose" } },
+
+};
+
+void RegisterMasternodesRPCCommands(CRPCTable &tableRPC)
+{
+    for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
+        tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
+}
diff --git a/src/masternodes/mn_txdb.cpp b/src/masternodes/mn_txdb.cpp
new file mode 100644
index 0000000000..9e3f020140
--- /dev/null
+++ b/src/masternodes/mn_txdb.cpp
@@ -0,0 +1,180 @@
+// Copyright (c) 2019 DeFi Foundation
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "mn_txdb.h"
+#include "masternodes/masternodes.h"
+
+#include "chainparams.h"
+#include "uint256.h"
+
+#include <stdint.h>
+
+#include <boost/thread.hpp>
+
+using namespace std;
+
+// Prefixes to the masternodes database (masternodes/)
+static const char DB_MASTERNODES = 'M';     // main masternodes table
+static const char DB_MASTERNODESUNDO = 'U'; // undo table
+//static const char DB_TEAM = 'T';
+//static const char DB_PRUNEDEAD = 'D';
+static const char DB_MN_HEIGHT = 'H';       // single record with last processed chain height
+static const char DB_PRUNE_HEIGHT = 'P';    // single record with pruned height (for validation of reachable data window)
+
+
+CMasternodesViewDB::CMasternodesViewDB(size_t nCacheSize, bool fMemory, bool fWipe)
+    : db(new CDBWrapper(GetDataDir() / "masternodes", nCacheSize, fMemory, fWipe))
+{
+}
+
+// for test purposes only
+CMasternodesViewDB::CMasternodesViewDB()
+    : db(nullptr)
+{
+}
+
+void CMasternodesViewDB::CommitBatch()
+{
+    if (batch)
+    {
+        db->WriteBatch(*batch);
+        batch.reset();
+    }
+}
+
+//void CMasternodesViewDB::DropBatch()
+//{
+//    if (batch)
+//    {
+//        batch.reset();
+//    }
+//}
+
+bool CMasternodesViewDB::ReadHeight(int & h)
+{
+    // it's a hack, cause we don't know active chain tip at the loading time
+    if (!db->Read(DB_MN_HEIGHT, h))
+    {
+        h = 0;
+    }
+    return true;
+}
+
+void CMasternodesViewDB::WriteHeight(int h)
+{
+    BatchWrite(DB_MN_HEIGHT, h);
+}
+
+void CMasternodesViewDB::WriteMasternode(uint256 const & txid, CMasternode const & node)
+{
+    BatchWrite(make_pair(DB_MASTERNODES, txid), node);
+}
+
+void CMasternodesViewDB::EraseMasternode(uint256 const & txid)
+{
+    BatchErase(make_pair(DB_MASTERNODES, txid));
+}
+
+//void CMasternodesViewDB::WriteDeadIndex(int height, uint256 const & txid, char type)
+//{
+//    BatchWrite(make_pair(make_pair(DB_PRUNEDEAD, static_cast<int32_t>(height)), txid), type);
+//}
+
+//void CMasternodesViewDB::EraseDeadIndex(int height, uint256 const & txid)
+//{
+//    BatchErase(make_pair(make_pair(DB_PRUNEDEAD, static_cast<int32_t>(height)), txid));
+//}
+
+void CMasternodesViewDB::WriteUndo(int height, CMnTxsUndo const & undo)
+{
+    BatchWrite(make_pair(DB_MASTERNODESUNDO, static_cast<int32_t>(height)), undo);
+}
+
+void CMasternodesViewDB::EraseUndo(int height)
+{
+    BatchErase(make_pair(DB_MASTERNODESUNDO, static_cast<int32_t>(height)));
+}
+
+//void CMasternodesViewDB::WriteTeam(int blockHeight, const CTeam & team)
+//{
+//    // we are sure that we have no spoiled records (all of them are deleted)
+//    for (CTeam::const_iterator it = team.begin(); it != team.end(); ++it)
+//    {
+//        BatchWrite(make_pair(make_pair(DB_TEAM, static_cast<int32_t>(blockHeight)), it->first), make_pair(it->second.joinHeight, it->second.operatorAuth));
+//    }
+//}
+
+/*
+ * Loads all data from DB, creates indexes
+ */
+bool CMasternodesViewDB::Load()
+{
+    Clear();
+
+    bool result = true;
+    result = result && ReadHeight(lastHeight);
+
+    result = result && LoadTable(DB_MASTERNODES, allNodes, [this] (uint256 nodeId, CMasternode & node) {
+        nodesByOwner.insert(std::make_pair(node.ownerAuthAddress, nodeId));
+        nodesByOperator.insert(std::make_pair(node.operatorAuthAddress, nodeId));
+    });
+    result = result && LoadTable(DB_MASTERNODESUNDO, blocksUndo);
+
+    // Load teams information
+//    result = result && LoadTable(DB_TEAM, teams);
+
+    if (result)
+//        LogPrintf("MN: db loaded: last height: %d; masternodes: %d; common undo: %d; teams: %d\n", lastHeight, allNodes.size(), txsUndo.size(), teams.size());
+        LogPrintf("MN: db loaded: last height: %d; masternodes: %d; common undo: %d\n", lastHeight, allNodes.size(), blocksUndo.size());
+    else {
+        LogPrintf("MN: fail to load database!");
+    }
+    return result;
+}
+
+bool CMasternodesViewDB::Flush()
+{
+    batch.reset();
+
+    /// @todo @max optimize with new diff model of view
+    int nMasternodes{0};
+    for (auto && it = allNodes.begin(); it != allNodes.end(); ) {
+        if (it->second == CMasternode()) {
+            EraseMasternode(it->first);
+            it = allNodes.erase(it);
+        }
+        else {
+            WriteMasternode(it->first, it->second);
+            ++nMasternodes;
+            ++it;
+        }
+    }
+
+    int nUndo{0};
+    for (auto && it = blocksUndo.begin(); it != blocksUndo.end(); )
+    {
+        if (it->second.size() == 0) {
+            EraseUndo(it->first);
+            it = blocksUndo.erase(it);
+        }
+        else {
+            WriteUndo(it->first, it->second);
+            ++nUndo;
+            ++it;
+        }
+    }
+
+//    for (auto && it = teams.begin(); it != teams.end(); ++it)
+//    {
+//        WriteTeam(it->first, it->second);
+//    }
+
+    WriteHeight(lastHeight);
+
+    CommitBatch();
+//    LogPrintf("MN: db saved: last height: %d; masternodes: %d; common undo: %d; teams: %d\n", lastHeight, nMasternodes, nUndo, teams.size());
+    LogPrintf("MN: db saved: last height: %d; masternodes: %d; common undo: %d\n", lastHeight, nMasternodes, nUndo);
+
+    return true;
+}
diff --git a/src/masternodes/mn_txdb.h b/src/masternodes/mn_txdb.h
new file mode 100644
index 0000000000..3d977271b4
--- /dev/null
+++ b/src/masternodes/mn_txdb.h
@@ -0,0 +1,110 @@
+// Copyright (c) 2019 DeFi Foundation
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef MASTERNODES_TXDB_H
+#define MASTERNODES_TXDB_H
+
+#include "dbwrapper.h"
+#include "masternodes.h"
+
+#include <functional>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+
+/** Access to the masternodes database (masternodes/) */
+class CMasternodesViewDB : public CMasternodesView
+{
+private:
+    boost::shared_ptr<CDBWrapper> db;
+    boost::scoped_ptr<CDBBatch> batch;
+
+public:
+    CMasternodesViewDB(size_t nCacheSize, bool fMemory = false, bool fWipe = false);
+    ~CMasternodesViewDB() override {}
+
+protected:
+    // for test purposes only
+    CMasternodesViewDB();
+
+private:
+    CMasternodesViewDB(CMasternodesViewDB const & other) = delete;
+    CMasternodesViewDB & operator=(CMasternodesViewDB const &) = delete;
+
+    template <typename K, typename V>
+    void BatchWrite(const K& key, const V& value)
+    {
+        if (!batch)
+        {
+            batch.reset(new CDBBatch(*db));
+        }
+        batch->Write<K,V>(key, value);
+    }
+    template <typename K>
+    void BatchErase(const K& key)
+    {
+        if (!batch)
+        {
+            batch.reset(new CDBBatch(*db));
+        }
+        batch->Erase<K>(key);
+    }
+
+    template <typename Container>
+    bool LoadTable(char prefix, Container & data, std::function<void(typename Container::key_type const &, typename Container::mapped_type &)> callback = nullptr)
+    {
+        boost::scoped_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
+        pcursor->Seek(prefix);
+
+        while (pcursor->Valid())
+        {
+            boost::this_thread::interruption_point();
+            std::pair<char, typename Container::key_type> key;
+            if (pcursor->GetKey(key) && key.first == prefix)
+            {
+                typename Container::mapped_type value;
+                if (pcursor->GetValue(value))
+                {
+                    data.emplace(key.second, std::move(value));
+                    if (callback)
+                        callback(key.second, data.at(key.second));
+                } else {
+                    return error("MNDB::Load() : unable to read value");
+                }
+            } else {
+                break;
+            }
+            pcursor->Next();
+        }
+        return true;
+    }
+
+protected:
+    void CommitBatch();
+//    void DropBatch();
+
+    bool ReadHeight(int & h);
+    void WriteHeight(int h);
+
+    void WriteMasternode(uint256 const & txid, CMasternode const & node);
+    void EraseMasternode(uint256 const & txid);
+
+//    void WriteDeadIndex(int height, uint256 const & txid, char type);
+//    void EraseDeadIndex(int height, uint256 const & txid);
+
+    void WriteUndo(int height, CMnTxsUndo const & undo);
+    void EraseUndo(int height);
+
+//    void WriteTeam(int blockHeight, CTeam const & team);
+
+public:
+    bool Load() override;
+    bool Flush() override;
+};
+
+#endif // MASTERNODES_TXDB_H
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index a4676ed2dc..1d5243566d 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -13,6 +13,7 @@
 #include <consensus/validation.h>
 #include <hash.h>
 #include <validation.h>
+#include <masternodes/masternodes.h>
 #include <merkleblock.h>
 #include <netmessagemaker.h>
 #include <netbase.h>
@@ -1845,7 +1846,7 @@ void static ProcessOrphanTx(CConnman* connman, std::set<uint256>& orphan_work_se
             EraseOrphanTx(orphanHash);
             done = true;
         }
-        mempool.check(&::ChainstateActive().CoinsTip());
+        mempool.xcheck(&::ChainstateActive().CoinsTip(), pmasternodesview.get());
     }
 }
 
@@ -2498,7 +2499,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
 
         if (!AlreadyHave(inv) &&
             AcceptToMemoryPool(mempool, state, ptx, &fMissingInputs, &lRemovedTxn, false /* bypass_limits */, 0 /* nAbsurdFee */)) {
-            mempool.check(&::ChainstateActive().CoinsTip());
+            mempool.xcheck(&::ChainstateActive().CoinsTip(), pmasternodesview.get());
             RelayTransaction(tx.GetHash(), *connman);
             for (unsigned int i = 0; i < tx.vout.size(); i++) {
                 auto it_by_prev = mapOrphanTransactionsByPrev.find(COutPoint(inv.hash, i));
diff --git a/src/pos.cpp b/src/pos.cpp
index 83b2b5bb58..efe2dc2f86 100644
--- a/src/pos.cpp
+++ b/src/pos.cpp
@@ -6,8 +6,6 @@
 #include <wallet/wallet.h>
 #include <txdb.h>
 
-std::unique_ptr<CMasternodesView> pmasternodesview; // TODO: (SS) Change to real
-
 namespace pos {
 static bool CheckStakeModifier(const CBlockIndex* pindexPrev, const CBlockHeader& blockHeader) {
     if (blockHeader.hashPrevBlock.IsNull())
diff --git a/src/pos.h b/src/pos.h
index 1a3da91eb4..288ea8b46d 100644
--- a/src/pos.h
+++ b/src/pos.h
@@ -3,6 +3,7 @@
 #include <consensus/params.h>
 #include <arith_uint256.h>
 #include <memory>
+#include <masternodes/masternodes.h>
 
 class CBlock;
 
@@ -12,9 +13,6 @@ class CBlockHeader;
 
 class CCoinsViewCache;
 
-class CMasternodesView {}; // TODO: (SS) Change to real CMasternodesView class
-extern std::unique_ptr<CMasternodesView> pmasternodesview; // TODO: (SS) Change to real
-
 namespace pos {
 
 /// Check PoS signatures (PoS block hashes are signed with privkey of  first coinstake out pubkey)
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 3cd661e067..4aeefbd3af 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -169,6 +169,11 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "createwallet", 4, "avoid_reuse"},
     { "getnodeaddresses", 0, "count"},
     { "stop", 0, "wait" },
+    { "mn_create", 0, "inputs" },
+    { "mn_create", 1, "metadata" },
+    { "mn_resign", 0, "inputs" },
+    { "mn_list", 0, "list" },
+    { "mn_list", 1, "verbose" },
 };
 // clang-format on
 
diff --git a/src/rpc/register.h b/src/rpc/register.h
index 374a1e3db8..dd38ebe473 100644
--- a/src/rpc/register.h
+++ b/src/rpc/register.h
@@ -19,6 +19,8 @@ void RegisterMiscRPCCommands(CRPCTable &tableRPC);
 void RegisterMiningRPCCommands(CRPCTable &tableRPC);
 /** Register raw transaction RPC commands */
 void RegisterRawTransactionRPCCommands(CRPCTable &tableRPC);
+/** Register masternodes RPC commands */
+void RegisterMasternodesRPCCommands(CRPCTable &tableRPC);
 
 static inline void RegisterAllCoreRPCCommands(CRPCTable &t)
 {
@@ -27,6 +29,7 @@ static inline void RegisterAllCoreRPCCommands(CRPCTable &t)
     RegisterMiscRPCCommands(t);
     RegisterMiningRPCCommands(t);
     RegisterRawTransactionRPCCommands(t);
+    RegisterMasternodesRPCCommands(t);
 }
 
 #endif // BITCOIN_RPC_REGISTER_H
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 9257cff718..e518c1317e 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -8,6 +8,8 @@
 #include <consensus/consensus.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
+#include <masternodes/masternodes.h>
+#include <masternodes/mn_checks.h>
 #include <validation.h>
 #include <policy/policy.h>
 #include <policy/fees.h>
@@ -509,6 +511,16 @@ void CTxMemPool::removeForReorg(const CCoinsViewCache *pcoins, unsigned int nMem
                     break;
                 }
             }
+        } else {
+            for (const CTxIn& txin : tx.vin) {
+
+                if (txin.prevout.n == 1 && (!pmasternodesview->CanSpend(txin.prevout.hash, nMemPoolHeight) || IsMempooledMnCreate(*this, txin.prevout.hash)))
+                {
+                    txToRemove.insert(it);
+                    break;
+                }
+
+            }
         }
         if (!validLP) {
             mapTx.modify(it, update_lock_points(lp));
@@ -589,16 +601,16 @@ void CTxMemPool::clear()
     _clear();
 }
 
-static void CheckInputsAndUpdateCoins(const CTransaction& tx, CCoinsViewCache& mempoolDuplicate, const int64_t spendheight)
+static void CheckInputsAndUpdateCoins(const CTransaction& tx, CCoinsViewCache& mempoolDuplicate, const CMasternodesView * mnview, const int64_t spendheight)
 {
     CValidationState state;
     CAmount txfee = 0;
-    bool fCheckResult = tx.IsCoinBase() || Consensus::CheckTxInputs(tx, state, mempoolDuplicate, spendheight, txfee);
+    bool fCheckResult = tx.IsCoinBase() || Consensus::CheckTxInputs(tx, state, mempoolDuplicate, mnview, spendheight, txfee);
     assert(fCheckResult);
     UpdateCoins(tx, mempoolDuplicate, std::numeric_limits<int>::max());
 }
 
-void CTxMemPool::check(const CCoinsViewCache *pcoins) const
+void CTxMemPool::xcheck(const CCoinsViewCache *pcoins, const CMasternodesView * mnview) const
 {
     LOCK(cs);
     if (nCheckFrequency == 0)
@@ -686,7 +698,7 @@ void CTxMemPool::check(const CCoinsViewCache *pcoins) const
         if (fDependsWait)
             waitingOnDependants.push_back(&(*it));
         else {
-            CheckInputsAndUpdateCoins(tx, mempoolDuplicate, spendheight);
+            CheckInputsAndUpdateCoins(tx, mempoolDuplicate, mnview, spendheight);
         }
     }
     unsigned int stepsSinceLastRemove = 0;
@@ -698,7 +710,7 @@ void CTxMemPool::check(const CCoinsViewCache *pcoins) const
             stepsSinceLastRemove++;
             assert(stepsSinceLastRemove < waitingOnDependants.size());
         } else {
-            CheckInputsAndUpdateCoins(entry->GetTx(), mempoolDuplicate, spendheight);
+            CheckInputsAndUpdateCoins(entry->GetTx(), mempoolDuplicate, mnview, spendheight);
             stepsSinceLastRemove = 0;
         }
     }
diff --git a/src/txmempool.h b/src/txmempool.h
index 6e5ba445d3..e4cf083c03 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -30,6 +30,7 @@
 #include <boost/signals2/signal.hpp>
 
 class CBlockIndex;
+class CMasternodesView;
 extern CCriticalSection cs_main;
 
 /** Fake height value used in Coin to signify they are only in the memory pool (since 0.8) */
@@ -560,7 +561,7 @@ class CTxMemPool
      * all inputs are in the mapNextTx array). If sanity-checking is turned off,
      * check does nothing.
      */
-    void check(const CCoinsViewCache *pcoins) const;
+    void xcheck(const CCoinsViewCache *pcoins, const CMasternodesView *mnview) const;
     void setSanityCheck(double dFrequency = 1.0) { LOCK(cs); nCheckFrequency = static_cast<uint32_t>(dFrequency * 4294967295.0); }
 
     // addUnchecked must updated state for all ancestors of a given transaction,
diff --git a/src/validation.cpp b/src/validation.cpp
index 6f84ad6a43..e0ef1a1b83 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -18,6 +18,9 @@
 #include <flatfile.h>
 #include <hash.h>
 #include <index/txindex.h>
+#include <masternodes/masternodes.h>
+#include <masternodes/mn_checks.h>
+#include <masternodes/mn_txdb.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -547,6 +550,12 @@ static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool
                 }
                 return false; // fMissingInputs and !state.IsInvalid() is used to detect this condition, don't set state.Invalid()
             }
+
+            // Special check of collateral spending for _not_created_mn_ (cheating?), those creation tx yet in mempool. CMasternode::CanSpend() (and CheckTxInputs()) will skip this situation
+            if (txin.prevout.n == 1 && IsMempooledMnCreate(pool, txin.prevout.hash)) {
+                    return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "mn-collateral-locked-in-mempool",
+                                         strprintf("tried to spend collateral of non-created mn %s, cheater?", txin.prevout.hash.ToString()));
+            }
         }
 
         // Bring the best block into scope
@@ -564,7 +573,7 @@ static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool
             return state.Invalid(ValidationInvalidReason::TX_PREMATURE_SPEND, false, REJECT_NONSTANDARD, "non-BIP68-final");
 
         CAmount nFees = 0;
-        if (!Consensus::CheckTxInputs(tx, state, view, GetSpendHeight(view), nFees)) {
+        if (!Consensus::CheckTxInputs(tx, state, view, pmasternodesview.get(), GetSpendHeight(view), nFees)) {
             return error("%s: Consensus::CheckTxInputs: %s, %s", __func__, tx.GetHash().ToString(), FormatStateMessage(state));
         }
 
@@ -1500,7 +1509,7 @@ int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)
 
 /** Undo the effects of this block (with given index) on the UTXO set represented by coins.
  *  When FAILED is returned, view is left in an indeterminate state. */
-DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
+DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view, CMasternodesViewCache& mnview)
 {
     bool fClean = true;
 
@@ -1515,6 +1524,11 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
         return DISCONNECT_FAILED;
     }
 
+    if (mnview.GetLastHeight() != pindex->nHeight) {
+        error("DisconnectBlock(): mnview: wrong last processed block hash (view: %d, current: %d)", mnview.GetLastHeight(), pindex->nHeight);
+        return DISCONNECT_FAILED;
+    }
+
     // undo transactions in reverse order
     for (int i = block.vtx.size() - 1; i >= 0; i--) {
         const CTransaction &tx = *(block.vtx[i]);
@@ -1550,10 +1564,16 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
             // At this point, all of txundo.vprevout should have been moved out.
         }
     }
+    // process transactions revert for masternodes
+    mnview.OnUndoBlock(pindex->nHeight);
 
     // move best block pointer to prevout block
     view.SetBestBlock(pindex->pprev->GetBlockHash());
 
+    /// @todo @maxb temp removed due to assertion
+//    mnview.DecrementMintedBy(CKeyID()); /// @todo @maxb pindex->pprev->minter or smth
+    mnview.SetLastHeight(pindex->pprev->nHeight);
+
     return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
 }
 
@@ -1713,7 +1733,7 @@ static int64_t nBlocksTotal = 0;
  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
  *  can fail if those validity checks fail (among other reasons). */
 bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex,
-                  CCoinsViewCache& view, const CChainParams& chainparams, bool fJustCheck)
+                  CCoinsViewCache& view, CMasternodesViewCache& mnview, const CChainParams& chainparams, bool fJustCheck)
 {
     AssertLockHeld(cs_main);
     assert(pindex);
@@ -1747,11 +1767,23 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
     assert(hashPrevBlock == view.GetBestBlock());
 
+    // verify that the mn view's current state corresponds to the previous block
+    if (pindex->nHeight != 0) {
+        if (mnview.GetLastHeight() != pindex->nHeight-1)
+            return AbortNode(state, "Masternodes database is corrupted (height mismatch)! DB prev block = " + std::to_string(mnview.GetLastHeight()) +
+                             ", current block = " + std::to_string(pindex->nHeight) + ". Please restart with -reindex to recover.");
+    }
+
     // Special case for the genesis block, skipping connection of its transactions
     // (its coinbase is unspendable)
     if (block.GetHash() == chainparams.GetConsensus().hashGenesisBlock) {
-        if (!fJustCheck)
+        if (!fJustCheck) {
             view.SetBestBlock(pindex->GetBlockHash());
+            /// @todo @maxb init view|db with genesis here
+            for (int i = 1; i < block.vtx.size(); ++i) {
+                CheckMasternodeTx(mnview, *block.vtx[i], chainparams.GetConsensus(), pindex->nHeight, i, fJustCheck);
+            }
+        }
         return true;
     }
 
@@ -1908,7 +1940,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
         if (!tx.IsCoinBase())
         {
             CAmount txfee = 0;
-            if (!Consensus::CheckTxInputs(tx, state, view, pindex->nHeight, txfee)) {
+            if (!Consensus::CheckTxInputs(tx, state, view, &mnview, pindex->nHeight, txfee)) {
                 if (!IsBlockReason(state.GetReason())) {
                     // CheckTxInputs may return MISSING_INPUTS or
                     // PREMATURE_SPEND but we can't return that, as it's not
@@ -1967,6 +1999,10 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                 return error("ConnectBlock(): CheckInputs on %s failed with %s",
                     tx.GetHash().ToString(), FormatStateMessage(state));
             }
+
+            // we will never fail, but skip
+            CheckMasternodeTx(mnview, tx, chainparams.GetConsensus(), pindex->nHeight, i, fJustCheck);
+
             control.Add(vChecks);
         }
 
@@ -2005,6 +2041,9 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     assert(pindex->phashBlock);
     // add this block to the view's block chain
     view.SetBestBlock(pindex->GetBlockHash());
+    /// @todo @maxb temp removed due to assertion
+//    mnview.IncrementMintedBy(CKeyID()); /// @todo @maxb pindex->minter or smth
+    mnview.SetLastHeight(pindex->nHeight);
 
     int64_t nTime5 = GetTimeMicros(); nTimeIndex += nTime5 - nTime4;
     LogPrint(BCLog::BENCH, "    - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime5 - nTime4), nTimeIndex * MICRO, nTimeIndex * MILLI / nBlocksTotal);
@@ -2107,12 +2146,14 @@ bool CChainState::FlushStateToDisk(
             // twice (once in the log, and once in the tables). This is already
             // an overestimation, as most will delete an existing entry or
             // overwrite one. Still, use a conservative safety factor of 2.
+            /// @todo @maxb check free space fo pmasternodesview flushing
             if (!CheckDiskSpace(GetDataDir(), 48 * 2 * 2 * CoinsTip().GetCacheSize())) {
                 return AbortNode(state, "Disk space is too low!", _("Error: Disk space is too low!").translated, CClientUIInterface::MSG_NOPREFIX);
             }
             // Flush the chainstate (which may refer to block index entries).
-            if (!CoinsTip().Flush())
-                return AbortNode(state, "Failed to write to coin database");
+            /// @todo @maxb may be integrate pmasternodesview into ChainState?
+            if (!CoinsTip().Flush() || !pmasternodesview->Flush())
+                return AbortNode(state, "Failed to write to coin or masternodes database");
             nLastFlush = nNow;
             full_flush_completed = true;
         }
@@ -2237,10 +2278,11 @@ bool CChainState::DisconnectTip(CValidationState& state, const CChainParams& cha
     int64_t nStart = GetTimeMicros();
     {
         CCoinsViewCache view(&CoinsTip());
+        CMasternodesViewCache mnview(pmasternodesview.get());
         assert(view.GetBestBlock() == pindexDelete->GetBlockHash());
-        if (DisconnectBlock(block, pindexDelete, view) != DISCONNECT_OK)
+        if (DisconnectBlock(block, pindexDelete, view, mnview) != DISCONNECT_OK)
             return error("DisconnectTip(): DisconnectBlock %s failed", pindexDelete->GetBlockHash().ToString());
-        bool flushed = view.Flush();
+        bool flushed = view.Flush() && mnview.Flush();
         assert(flushed);
     }
     LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n", (GetTimeMicros() - nStart) * MILLI);
@@ -2365,7 +2407,8 @@ bool CChainState::ConnectTip(CValidationState& state, const CChainParams& chainp
     LogPrint(BCLog::BENCH, "  - Load block from disk: %.2fms [%.2fs]\n", (nTime2 - nTime1) * MILLI, nTimeReadFromDisk * MICRO);
     {
         CCoinsViewCache view(&CoinsTip());
-        bool rv = ConnectBlock(blockConnecting, state, pindexNew, view, chainparams);
+        CMasternodesViewCache mnview(pmasternodesview.get());
+        bool rv = ConnectBlock(blockConnecting, state, pindexNew, view, mnview, chainparams);
         GetMainSignals().BlockChecked(blockConnecting, state);
         if (!rv) {
             if (state.IsInvalid())
@@ -2374,7 +2417,7 @@ bool CChainState::ConnectTip(CValidationState& state, const CChainParams& chainp
         }
         nTime3 = GetTimeMicros(); nTimeConnectTotal += nTime3 - nTime2;
         LogPrint(BCLog::BENCH, "  - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime3 - nTime2) * MILLI, nTimeConnectTotal * MICRO, nTimeConnectTotal * MILLI / nBlocksTotal);
-        bool flushed = view.Flush();
+        bool flushed = view.Flush() && mnview.Flush();
         assert(flushed);
     }
     int64_t nTime4 = GetTimeMicros(); nTimeFlush += nTime4 - nTime3;
@@ -2551,7 +2594,7 @@ bool CChainState::ActivateBestChainStep(CValidationState& state, const CChainPar
         // any disconnected transactions back to the mempool.
         UpdateMempoolForReorg(disconnectpool, true);
     }
-    mempool.check(&CoinsTip());
+    mempool.xcheck(&CoinsTip(), pmasternodesview.get());
 
     // Callbacks/notifications for a new best chain.
     if (fInvalidFound)
@@ -3062,15 +3105,22 @@ bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::P
     // First transaction must be coinbase, the rest must not be
     if (block.vtx.empty() || !block.vtx[0]->IsCoinBase())
         return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-missing", "first tx is not coinbase");
-    for (unsigned int i = 1; i < block.vtx.size(); i++)
-        if (block.vtx[i]->IsCoinBase())
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-multiple", "more than one coinbase");
+
+    /// @todo @max skip this validation if it is Genesis (due to mn creation txs)
+    if (block.GetHash() != consensusParams.hashGenesisBlock) {
+        for (unsigned int i = 1; i < block.vtx.size(); i++)
+            if (block.vtx[i]->IsCoinBase())
+                return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-multiple", "more than one coinbase");
+    }
 
     // Check transactions
-    for (const auto& tx : block.vtx)
-        if (!CheckTransaction(*tx, state, true))
-            return state.Invalid(state.GetReason(), false, state.GetRejectCode(), state.GetRejectReason(),
-                                 strprintf("Transaction check failed (tx hash %s) %s", tx->GetHash().ToString(), state.GetDebugMessage()));
+    /// @todo @max skip this validation if it is Genesis (due to mn creation txs)
+    if (block.GetHash() != consensusParams.hashGenesisBlock) {
+        for (const auto& tx : block.vtx)
+            if (!CheckTransaction(*tx, state, true))
+                return state.Invalid(state.GetReason(), false, state.GetRejectCode(), state.GetRejectReason(),
+                                     strprintf("Transaction check failed (tx hash %s) %s", tx->GetHash().ToString(), state.GetDebugMessage()));
+    }
 
     unsigned int nSigOps = 0;
     for (const auto& tx : block.vtx)
@@ -3552,6 +3602,7 @@ bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams,
     AssertLockHeld(cs_main);
     assert(pindexPrev && pindexPrev == ::ChainActive().Tip());
     CCoinsViewCache viewNew(&::ChainstateActive().CoinsTip());
+    CMasternodesViewCache mnview(pmasternodesview.get());
     uint256 block_hash(block.GetHash());
     CBlockIndex indexDummy(block);
     indexDummy.pprev = pindexPrev;
@@ -3565,7 +3616,7 @@ bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams,
         return error("%s: Consensus::CheckBlock: %s", __func__, FormatStateMessage(state));
     if (!ContextualCheckBlock(block, state, chainparams.GetConsensus(), pindexPrev))
         return error("%s: Consensus::ContextualCheckBlock: %s", __func__, FormatStateMessage(state));
-    if (!::ChainstateActive().ConnectBlock(block, state, &indexDummy, viewNew, chainparams, true))
+    if (!::ChainstateActive().ConnectBlock(block, state, &indexDummy, viewNew, mnview, chainparams, true))
         return false;
     assert(state.IsValid());
 
@@ -3948,6 +3999,7 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
     nCheckLevel = std::max(0, std::min(4, nCheckLevel));
     LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
     CCoinsViewCache coins(coinsview);
+    CMasternodesViewCache mnview(pmasternodesview.get()); /// @todo @maxb really need to pass it from outside??
     CBlockIndex* pindex;
     CBlockIndex* pindexFailure = nullptr;
     int nGoodTransactions = 0;
@@ -3990,7 +4042,7 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
         // check level 3: check for inconsistencies during memory-only disconnect of tip blocks
         if (nCheckLevel >= 3 && (coins.DynamicMemoryUsage() + ::ChainstateActive().CoinsTip().DynamicMemoryUsage()) <= nCoinCacheUsage) {
             assert(coins.GetBestBlock() == pindex->GetBlockHash());
-            DisconnectResult res = ::ChainstateActive().DisconnectBlock(block, pindex, coins);
+            DisconnectResult res = ::ChainstateActive().DisconnectBlock(block, pindex, coins, mnview);
             if (res == DISCONNECT_FAILED) {
                 return error("VerifyDB(): *** irrecoverable inconsistency in block data at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
             }
@@ -4025,7 +4077,7 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
             CBlock block;
             if (!ReadBlockFromDisk(block, pindex, chainparams.GetConsensus()))
                 return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
-            if (!::ChainstateActive().ConnectBlock(block, state, pindex, coins, chainparams))
+            if (!::ChainstateActive().ConnectBlock(block, state, pindex, coins, mnview, chainparams))
                 return error("VerifyDB(): *** found unconnectable block at %d, hash=%s (%s)", pindex->nHeight, pindex->GetBlockHash().ToString(), FormatStateMessage(state));
         }
     }
@@ -4037,7 +4089,7 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
 }
 
 /** Apply the effects of a block on the utxo cache, ignoring that it may already have been applied. */
-bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs, const CChainParams& params)
+bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs, CMasternodesViewCache& mnview, const CChainParams& params)
 {
     // TODO: merge with ConnectBlock
     CBlock block;
@@ -4053,20 +4105,27 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
         }
         // Pass check = true as every addition may be an overwrite.
         AddCoins(inputs, *tx, pindex->nHeight, true);
+
+        /// @todo @maxb turn it on when you are sure it is safe
+//        CheckMasternodeTx(mnview, *tx, params.GetConsensus(), pindex->nHeight, i, false);
     }
     return true;
 }
 
-bool CChainState::ReplayBlocks(const CChainParams& params, CCoinsView* view)
+bool CChainState::ReplayBlocks(const CChainParams& params, CCoinsView* view, CMasternodesView* mnview)
 {
     LOCK(cs_main);
 
     CCoinsViewCache cache(view);
+    CMasternodesViewCache mncache(mnview);
 
     std::vector<uint256> hashHeads = view->GetHeadBlocks();
     if (hashHeads.empty()) return true; // We're already in a consistent state.
     if (hashHeads.size() != 2) return error("ReplayBlocks(): unknown inconsistent state");
 
+    /// @todo @max may be it is possible to keep it run? how to safely connect blocks for mndb?
+    return error("ReplayBlocks() turned off for safety reasons. Make reindex!");
+
     uiInterface.ShowProgress(_("Replaying blocks...").translated, 0, false);
     LogPrintf("Replaying blocks\n");
 
@@ -4096,7 +4155,7 @@ bool CChainState::ReplayBlocks(const CChainParams& params, CCoinsView* view)
                 return error("RollbackBlock(): ReadBlockFromDisk() failed at %d, hash=%s", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
             }
             LogPrintf("Rolling back %s (%i)\n", pindexOld->GetBlockHash().ToString(), pindexOld->nHeight);
-            DisconnectResult res = DisconnectBlock(block, pindexOld, cache);
+            DisconnectResult res = DisconnectBlock(block, pindexOld, cache, mncache);
             if (res == DISCONNECT_FAILED) {
                 return error("RollbackBlock(): DisconnectBlock failed at %d, hash=%s", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
             }
@@ -4114,17 +4173,18 @@ bool CChainState::ReplayBlocks(const CChainParams& params, CCoinsView* view)
         const CBlockIndex* pindex = pindexNew->GetAncestor(nHeight);
         LogPrintf("Rolling forward %s (%i)\n", pindex->GetBlockHash().ToString(), nHeight);
         uiInterface.ShowProgress(_("Replaying blocks...").translated, (int) ((nHeight - nForkHeight) * 100.0 / (pindexNew->nHeight - nForkHeight)) , false);
-        if (!RollforwardBlock(pindex, cache, params)) return false;
+        if (!RollforwardBlock(pindex, cache, mncache, params)) return false;
     }
 
     cache.SetBestBlock(pindexNew->GetBlockHash());
     cache.Flush();
+    mncache.Flush();
     uiInterface.ShowProgress("", 100, false);
     return true;
 }
 
-bool ReplayBlocks(const CChainParams& params, CCoinsView* view) {
-    return ::ChainstateActive().ReplayBlocks(params, view);
+bool ReplayBlocks(const CChainParams& params, CCoinsView* view, CMasternodesView* mnview) {
+    return ::ChainstateActive().ReplayBlocks(params, view, mnview);
 }
 
 //! Helper for CChainState::RewindBlockIndex
diff --git a/src/validation.h b/src/validation.h
index 99850f71d9..0496bab42b 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -34,6 +34,8 @@
 #include <vector>
 
 class CChainState;
+class CMasternodesView;
+class CMasternodesViewCache;
 class CBlockIndex;
 class CBlockTreeDB;
 class CBlockUndo;
@@ -401,7 +403,7 @@ class CVerifyDB {
 };
 
 /** Replay blocks that aren't fully applied to the database. */
-bool ReplayBlocks(const CChainParams& params, CCoinsView* view);
+bool ReplayBlocks(const CChainParams& params, CCoinsView* view, CMasternodesView* mnview);
 
 CBlockIndex* LookupBlockIndex(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
@@ -672,9 +674,9 @@ class CChainState {
     bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CValidationState& state, const CChainParams& chainparams, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Block (dis)connection on a given view:
-    DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view);
+    DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view, CMasternodesViewCache& mnview);
     bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex,
-                      CCoinsViewCache& view, const CChainParams& chainparams, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+                      CCoinsViewCache& view, CMasternodesViewCache& mnview, const CChainParams& chainparams, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Apply the effects of a block disconnection on the UTXO set.
     bool DisconnectTip(CValidationState& state, const CChainParams& chainparams, DisconnectedBlockTransactions* disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, ::mempool.cs);
@@ -684,7 +686,7 @@ class CChainState {
     bool InvalidateBlock(CValidationState& state, const CChainParams& chainparams, CBlockIndex* pindex) LOCKS_EXCLUDED(cs_main);
     void ResetBlockFailureFlags(CBlockIndex* pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
-    bool ReplayBlocks(const CChainParams& params, CCoinsView* view);
+    bool ReplayBlocks(const CChainParams& params, CCoinsView* view, CMasternodesView* mnview);
     bool RewindBlockIndex(const CChainParams& params) LOCKS_EXCLUDED(cs_main);
     bool LoadGenesisBlock(const CChainParams& chainparams);
 
@@ -710,7 +712,7 @@ class CChainState {
     CBlockIndex* FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     void ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos, const Consensus::Params& consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
-    bool RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs, const CChainParams& params) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs, CMasternodesViewCache& mnview, const CChainParams& params) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     //! Mark a block as not having block data
     void EraseBlockData(CBlockIndex* index) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
diff --git a/src/wallet/coincontrol.cpp b/src/wallet/coincontrol.cpp
index 14513bc9e9..e39318b10f 100644
--- a/src/wallet/coincontrol.cpp
+++ b/src/wallet/coincontrol.cpp
@@ -22,5 +22,6 @@ void CCoinControl::SetNull()
     m_fee_mode = FeeEstimateMode::UNSET;
     m_min_depth = DEFAULT_MIN_DEPTH;
     m_max_depth = DEFAULT_MAX_DEPTH;
+    matchDestination = CNoDestination();
 }
 
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
index 92a290530c..e45c00a211 100644
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -45,6 +45,8 @@ class CCoinControl
     int m_min_depth = DEFAULT_MIN_DEPTH;
     //! Maximum chain depth value for coin availability
     int m_max_depth = DEFAULT_MAX_DEPTH;
+    //! Match coin with this destination
+    CTxDestination matchDestination;
 
     CCoinControl()
     {
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 5f6260aa42..e535ab0d14 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -13,6 +13,7 @@
 #include <interfaces/wallet.h>
 #include <key.h>
 #include <key_io.h>
+#include <masternodes/masternodes.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <primitives/block.h>
@@ -2543,6 +2544,19 @@ void CWallet::AvailableCoins(interfaces::Chain::Lock& locked_chain, std::vector<
                 continue;
             }
 
+            if (i == 1 && locked_chain.getHeight() && !chain().mnCanSpend(wtx.tx->GetHash(), *locked_chain.getHeight())) {
+                continue;
+            }
+
+            if (coinControl && coinControl->matchDestination.which() != 0) {
+                CTxDestination dest;
+                ExtractDestination(wtx.tx->vout[i].scriptPubKey, dest);
+                if (dest != coinControl->matchDestination) {
+                    continue;
+                }
+            }
+
+
             bool solvable = IsSolvable(*this, wtx.tx->vout[i].scriptPubKey);
             bool spendable = ((mine & ISMINE_SPENDABLE) != ISMINE_NO) || (((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) && (coinControl && coinControl->fAllowWatchOnly && solvable));
 
diff --git a/test/functional/rpc_mn_basic.py b/test/functional/rpc_mn_basic.py
new file mode 100755
index 0000000000..0a5b408669
--- /dev/null
+++ b/test/functional/rpc_mn_basic.py
@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2019 The Bitcoin Core developers
+# Copyright (c) DeFi Foundation
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test the masternodes RPC.
+
+- verify basic MN creation and resign
+"""
+
+from test_framework.test_framework import BitcoinTestFramework
+
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_greater_than, \
+    connect_nodes_bi, disconnect_nodes, \
+    sync_blocks, sync_mempools
+
+from decimal import Decimal
+import pprint
+import time
+
+class MasternodesRpcBasicTest (BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.setup_clean_chain = True
+
+    def gen(self, count=1, node_id=0):
+        self.nodes[node_id].generatetoaddress(count, self.nodes[node_id].get_deterministic_priv_key().address)
+
+
+    def run_test(self):
+        pp = pprint.PrettyPrinter(indent=4)
+
+        assert_equal(self.nodes[0].mn_list(), {})
+        self.gen(100)
+        self.sync_blocks()
+
+        # Stop node #2 for future revert
+        self.stop_node(2)
+
+        # CREATION:
+        #========================
+
+        collateral0 = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fail to create: Insufficient funds (not matured coins)
+        try:
+            idnode0 = self.nodes[0].mn_create([], {
+                # "operatorAuthAddress": operator0,
+                "collateralAddress": collateral0
+            })
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("Insufficient funds" in errorString)
+
+        # Create node0
+        self.gen(2)
+        idnode0 = self.nodes[0].mn_create([], {
+            # "operatorAuthAddress": operator0,
+            "collateralAddress": collateral0
+        })
+
+        # Create and sign (only) collateral spending tx
+        spendTx = self.nodes[0].createrawtransaction([{'txid':idnode0, 'vout':1}],[{collateral0:9.999}])
+        signedTx = self.nodes[0].signrawtransactionwithwallet(spendTx)
+        assert_equal(signedTx['complete'], True)
+
+        # Try to spend collateral of mempooled mn_create tx
+        try:
+            self.nodes[0].sendrawtransaction(signedTx['hex'])
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("mn-collateral-locked-in-mempool," in errorString)
+
+        self.gen()
+        # At this point, mn was created
+        assert_equal(self.nodes[0].mn_list([], False), { idnode0: "created"} )
+
+        self.sync_blocks(self.nodes[0:2])
+        # Stop node #1 for future revert
+        self.stop_node(1)
+
+        # Try to spend locked collateral again
+        try:
+            self.nodes[0].sendrawtransaction(signedTx['hex'])
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("mn-collateral-locked," in errorString)
+
+
+        # RESIGNING:
+        #========================
+
+        # Fail to resign: Forget to place params in config
+        try:
+            self.nodes[0].mn_resign([], idnode0)
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("You are not the owner" in errorString)
+
+        # Restart with new params, but have no money on auth address
+        self.restart_node(0, extra_args=['-masternode_owner='+collateral0]) 
+        try:
+            self.nodes[0].mn_resign([], idnode0)
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("Can't find any UTXO's" in errorString)
+
+        # Funding auth address and successful resign        
+        fundingTx = self.nodes[0].sendtoaddress(collateral0, 1)
+        self.gen()
+        resignTx = self.nodes[0].mn_resign([], idnode0)
+        self.gen()
+        assert_equal(self.nodes[0].mn_list()[idnode0]['status'], "created, resigned")
+
+        # Spend unlocked collateral
+        # This checks two cases at once:
+        # 1) Finally, we should not fail on accept to mempool
+        # 2) But we don't mine blocks after it, so, after chain reorg (on 'REVERTING'), we should not fail: tx should be removed from mempool!
+        self.gen(12)
+        sendedTxHash = self.nodes[0].sendrawtransaction(signedTx['hex'])
+        # Don't mine here, check mempool after reorg!
+        # self.gen(1)
+
+
+        # REVERTING:
+        #========================
+
+        # Revert resign!
+        self.start_node(1)
+        self.gen(20, 1)
+        # Check that collateral spending tx is still in the mempool
+        assert_equal(sendedTxHash, self.nodes[0].getrawmempool()[0]);
+        connect_nodes_bi(self.nodes, 0, 1)
+        self.sync_blocks(self.nodes[0:2])
+        # Check that collateral spending tx was deleted
+        # print ("CreateTx", idnode0)
+        # print ("ResignTx", resignTx)
+        # print ("FundingTx", fundingTx)
+        # print ("SpendTx", sendedTxHash)
+        assert_equal(self.nodes[0].getrawmempool(), [fundingTx, resignTx]);
+        assert_equal(self.nodes[0].mn_list()[idnode0]['status'], "active")
+
+        # Revert creation!
+        self.start_node(2)
+        self.gen(25, 2)
+        connect_nodes_bi(self.nodes, 0, 2)
+        self.sync_blocks(self.nodes[0:3])
+        assert_equal(self.nodes[0].mn_list(), {})
+        assert_equal(self.nodes[0].getrawmempool(), [idnode0, fundingTx, resignTx]);
+
+if __name__ == '__main__':
+    MasternodesRpcBasicTest ().main ()