From de6ea0dc5c2e7ef917700401813619dce116e8c9 Mon Sep 17 00:00:00 2001
From: barrystyle <barrystyle@westnet.com.au>
Date: Thu, 18 Jul 2019 06:48:43 +0800
Subject: [PATCH 1/2] Squashed proof of stake commits (initial set):

       61604537f58ed2165268a07f6a5bf77470361cb4
       4850537fdf2b0c6e87722a7c2262c2da210f2574
       17e8d4ef606935421962c19a33504d3ccd27c669
       89844c26031f0d066f1b0921d3e6837dac6cdac8
       c7881e59630585f1f7b71c6fadfa10e928f1954f
---
 configure.ac                          |   2 +-
 src/Makefile.am                       |  16 +-
 src/Makefile.qt.include               |   4 +-
 src/blocksigner.cpp                   |  83 +++++
 src/blocksigner.h                     |  13 +
 src/chain.cpp                         |  52 +++
 src/chain.h                           |  99 +++++-
 src/chainparams.cpp                   |  87 +++--
 src/chainparams.h                     |   2 +
 src/chainparamsseeds.h                | 310 -----------------
 src/coins.cpp                         |  13 +-
 src/coins.h                           |  68 +++-
 src/compat.h                          |  11 +
 src/compressor.h                      |   7 +
 src/consensus/consensus.h             |   2 +-
 src/consensus/params.h                |   9 +
 src/init.cpp                          |   4 +
 src/kernel.cpp                        | 410 ++++++++++++++++++++++
 src/kernel.h                          |  49 +++
 src/masternode-payments.cpp           |   7 +-
 src/masternode-payments.h             |   8 +-
 src/miner.cpp                         | 273 ++++++++++++++-
 src/miner.h                           |  11 +-
 src/pow.cpp                           | 197 ++++++++---
 src/pow.h                             |   6 +-
 src/primitives/block.cpp              |  10 +
 src/primitives/block.h                |  21 +-
 src/primitives/transaction.h          |  17 +
 src/qt/askpassphrasedialog.cpp        |   7 +-
 src/qt/askpassphrasedialog.h          |   1 +
 src/qt/bitcoingui.cpp                 |  34 +-
 src/qt/bitcoingui.h                   |   7 +
 src/qt/dash.qrc                       |   4 +
 src/qt/forms/askpassphrasedialog.ui   |  72 ++++
 src/qt/res/icons/staking_active.png   | Bin 0 -> 1143 bytes
 src/qt/res/icons/staking_inactive.png | Bin 0 -> 1004 bytes
 src/qt/transactionrecord.cpp          |  40 ++-
 src/qt/transactionrecord.h            |   4 +-
 src/qt/transactiontablemodel.cpp      |   8 +
 src/qt/transactionview.cpp            |   2 +
 src/qt/walletmodel.h                  |   7 +-
 src/qt/walletview.cpp                 |   2 +-
 src/rpc/client.cpp                    |   1 +
 src/rpc/mining.cpp                    |  10 +-
 src/rpc/misc.cpp                      |  44 +++
 src/rpc/rpcevo.cpp                    |   2 +-
 src/script/dashconsensus.cpp          |   2 +-
 src/script/interpreter.cpp            |  36 +-
 src/script/interpreter.h              |  10 +-
 src/script/sigcache.h                 |   1 +
 src/serialize.h                       |  24 +-
 src/span.h                            |  40 +++
 src/streams.h                         |  49 ++-
 src/txdb.cpp                          |  43 ++-
 src/txmempool.cpp                     |   2 +-
 src/util.cpp                          |  13 +
 src/util.h                            |   1 +
 src/validation.cpp                    | 466 ++++++++++++++++++++------
 src/validation.h                      |   3 +
 src/validationinterface.h             |   4 +-
 src/wallet/wallet.cpp                 | 224 ++++++++++++-
 src/wallet/wallet.h                   |  23 +-
 src/wallet/walletdb.cpp               |   4 +
 src/wallet/walletdb.h                 |   2 +-
 64 files changed, 2387 insertions(+), 596 deletions(-)
 create mode 100644 src/blocksigner.cpp
 create mode 100644 src/blocksigner.h
 create mode 100644 src/kernel.cpp
 create mode 100644 src/kernel.h
 create mode 100644 src/qt/res/icons/staking_active.png
 create mode 100644 src/qt/res/icons/staking_inactive.png
 create mode 100644 src/span.h

diff --git a/configure.ac b/configure.ac
index c3c6dc3145891..f0c644a770573 100644
--- a/configure.ac
+++ b/configure.ac
@@ -271,7 +271,7 @@ if test "x$CXXFLAGS_overridden" = "xno"; then
   AX_CHECK_COMPILE_FLAG([-Wformat],[CXXFLAGS="$CXXFLAGS -Wformat"],,[[$CXXFLAG_WERROR]])
   AX_CHECK_COMPILE_FLAG([-Wvla],[CXXFLAGS="$CXXFLAGS -Wvla"],,[[$CXXFLAG_WERROR]])
   AX_CHECK_COMPILE_FLAG([-Wformat-security],[CXXFLAGS="$CXXFLAGS -Wformat-security"],,[[$CXXFLAG_WERROR]])
-  AX_CHECK_COMPILE_FLAG([-Wshadow],[CXXFLAGS="$CXXFLAGS -Wshadow"],,[[$CXXFLAG_WERROR]])
+  AX_CHECK_COMPILE_FLAG([-Wthread-safety-analysis],[CXXFLAGS="$CXXFLAGS -Wthread-safety-analysis"],,[[$CXXFLAG_WERROR]])
 
   ## Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
   ## unknown options if any other warning is produced. Test the -Wfoo case, and
diff --git a/src/Makefile.am b/src/Makefile.am
index de6b93991ff21..5a0fb548f4a89 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -112,6 +112,7 @@ BITCOIN_CORE_H = \
   bip39.h \
   bip39_english.h \
   blockencodings.h \
+  blocksigner.h \
   bloom.h \
   cachemap.h \
   cachemultimap.h \
@@ -163,6 +164,7 @@ BITCOIN_CORE_H = \
   key.h \
   keepass.h \
   keystore.h \
+  kernel.h \
   dbwrapper.h \
   limitedmap.h \
   llmq/quorums.h \
@@ -265,6 +267,7 @@ libdash_server_a_SOURCES = \
   batchedlogger.cpp \
   bloom.cpp \
   blockencodings.cpp \
+  blocksigner.cpp \
   chain.cpp \
   checkpoints.cpp \
   dsnotificationinterface.cpp \
@@ -279,6 +282,7 @@ libdash_server_a_SOURCES = \
   httpserver.cpp \
   init.cpp \
   instantx.cpp \
+  kernel.cpp \
   dbwrapper.cpp \
   governance.cpp \
   governance-classes.cpp \
@@ -673,9 +677,9 @@ if EMBEDDED_LEVELDB
 include Makefile.leveldb.include
 endif
 
-if ENABLE_TESTS
-include Makefile.test.include
-endif
+#if ENABLE_TESTS
+#include Makefile.test.include
+#endif
 
 if ENABLE_BENCH
 include Makefile.bench.include
@@ -685,6 +689,6 @@ if ENABLE_QT
 include Makefile.qt.include
 endif
 
-if ENABLE_QT_TESTS
-include Makefile.qttest.include
-endif
+#if ENABLE_QT_TESTS
+#include Makefile.qttest.include
+#endif
diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index a50bf431334eb..def7a409869d9 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -452,7 +452,9 @@ RES_ICONS = \
   qt/res/icons/trad/verify.png \
   qt/res/icons/trad/fontbigger.png \
   qt/res/icons/trad/fontsmaller.png \
-  qt/res/icons/trad/network_disabled.png
+  qt/res/icons/trad/network_disabled.png \
+  qt/res/icons/staking_active.png \
+  qt/res/icons/staking_inactive.png
 
 BITCOIN_QT_BASE_CPP = \
   qt/bantablemodel.cpp \
diff --git a/src/blocksigner.cpp b/src/blocksigner.cpp
new file mode 100644
index 0000000000000..4832804b58709
--- /dev/null
+++ b/src/blocksigner.cpp
@@ -0,0 +1,83 @@
+#include <blocksigner.h>
+#include <keystore.h>
+#include <primitives/block.h>
+#include <utilstrencodings.h>
+#include <messagesigner.h>
+#include <util.h>
+
+typedef std::vector<uint8_t> valtype;
+
+bool SignBlockWithKey(CBlock& block, const CKey& key)
+{
+    if (!key.Sign(block.GetHash(), block.vchBlockSig))
+        return error("%s: failed to sign block hash with key", __func__);
+
+    return true;
+}
+
+bool GetKeyIDFromUTXO(const CTxOut& txout, CKeyID& keyID)
+{
+    std::vector<valtype> vSolutions;
+    txnouttype whichType;
+    if (!Solver(txout.scriptPubKey, whichType, vSolutions))
+        return false;
+    if (whichType == TX_PUBKEY) {
+        keyID = CPubKey(vSolutions[0]).GetID();
+    } else if (whichType == TX_PUBKEYHASH) {
+        keyID = CKeyID(uint160(vSolutions[0]));
+    }
+
+    return true;
+}
+
+bool SignBlock(CBlock& block, const CKeyStore& keystore)
+{
+    std::vector<valtype> vSolutions;
+    CKeyID keyID;
+    if (block.IsProofOfWork()) {
+        bool fFoundID = false;
+        for (const CTxOut& txout :block.vtx[0]->vout) {
+            if (!GetKeyIDFromUTXO(txout, keyID))
+                continue;
+            fFoundID = true;
+            break;
+        }
+        if (!fFoundID)
+            return error("%s: failed to find key for PoW", __func__);
+    } else {
+        if (!GetKeyIDFromUTXO(block.vtx[1]->vout[1], keyID))
+            return error("%s: failed to find key for PoS", __func__);
+    }
+
+    CKey key;
+    if (!keystore.GetKey(keyID, key))
+        return error("%s: failed to get key from keystore", __func__);
+
+    return SignBlockWithKey(block, key);
+}
+
+bool CheckBlockSignature(const CBlock& block)
+{
+    std::vector<valtype> vSolutions;
+
+    if (block.IsProofOfWork())
+        return block.vchBlockSig.empty();
+
+    if (block.vchBlockSig.empty())
+        return error("%s: vchBlockSig is empty!", __func__);
+
+    CPubKey pubkey;
+    txnouttype whichType;
+    const CTxOut& txout = block.vtx[1]->vout[1];
+    if (!Solver(txout.scriptPubKey, whichType, vSolutions))
+        return false;
+    if (whichType == TX_PUBKEY || whichType == TX_PUBKEYHASH) {
+        valtype& vchPubKey = vSolutions[0];
+        pubkey = CPubKey(vchPubKey);
+    }
+
+    if (!pubkey.IsValid())
+        return error("%s: invalid pubkey %s", __func__, HexStr(pubkey));
+
+    return pubkey.Verify(block.GetHash(), block.vchBlockSig);
+}
diff --git a/src/blocksigner.h b/src/blocksigner.h
new file mode 100644
index 0000000000000..a0c37c2b8c877
--- /dev/null
+++ b/src/blocksigner.h
@@ -0,0 +1,13 @@
+#ifndef BLOCKSIGNER_H
+#define BLOCKSIGNER_H
+
+class CBlock;
+class CPubKey;
+class CKey;
+class CKeyStore;
+
+bool SignBlockWithKey(CBlock& block, const CKey& key);
+bool SignBlock(CBlock& block, const CKeyStore& keystore);
+bool CheckBlockSignature(const CBlock& block);
+
+#endif // BLOCKSIGNER_H
diff --git a/src/chain.cpp b/src/chain.cpp
index 6154e24f2317d..6ef548b0ef2c3 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -111,6 +111,22 @@ const CBlockIndex* CBlockIndex::GetAncestor(int height) const
     return const_cast<CBlockIndex*>(this)->GetAncestor(height);
 }
 
+unsigned int CBlockIndex::GetStakeEntropyBit() const
+{
+    unsigned int nEntropyBit = (UintToArith256(GetBlockHash()).GetLow64() & 1);
+    if (GetBoolArg("-printstakemodifier", false))
+        LogPrintf("GetStakeEntropyBit: nHeight=%u hashBlock=%s nEntropyBit=%u\n", nHeight, GetBlockHash().ToString().c_str(), nEntropyBit);
+
+    return nEntropyBit;
+}
+
+void CBlockIndex::SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
+{
+    nStakeModifier = nModifier;
+    if (fGeneratedStakeModifier)
+        nFlags |= BLOCK_STAKE_MODIFIER;
+}
+
 void CBlockIndex::BuildSkip()
 {
     if (pprev)
@@ -148,3 +164,39 @@ int64_t GetBlockProofEquivalentTime(const CBlockIndex& to, const CBlockIndex& fr
     }
     return sign * r.GetLow64();
 }
+
+/** Find the last common ancestor two blocks have.
+ *  Both pa and pb must be non-nullptr. */
+const CBlockIndex* LastCommonAncestor(const CBlockIndex* pa, const CBlockIndex* pb) {
+    if (pa->nHeight > pb->nHeight) {
+        pa = pa->GetAncestor(pb->nHeight);
+    } else if (pb->nHeight > pa->nHeight) {
+        pb = pb->GetAncestor(pa->nHeight);
+    }
+
+    while (pa != pb && pa && pb) {
+        pa = pa->pprev;
+        pb = pb->pprev;
+    }
+
+    // Eventually all chain branches meet at the genesis block.
+    assert(pa == pb);
+    return pa;
+}
+
+arith_uint256 CBlockIndex::GetBlockTrust() const
+{
+    arith_uint256 bnTarget;
+    bnTarget.SetCompact(nBits);
+    if (bnTarget <= 0)
+        return 0;
+
+    if (IsProofOfStake()) {
+        // Return trust score as usual
+        return (arith_uint256(1) << 256) / (bnTarget + 1);
+    } else {
+        // Calculate work amount for block
+        arith_uint256 bnPoWTrust = ((~arith_uint256(0) >> 20) / (bnTarget + 1));
+        return bnPoWTrust > 1 ? bnPoWTrust : 1;
+    }
+}
diff --git a/src/chain.h b/src/chain.h
index ff72ff684cc58..4652c453ec41b 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -11,6 +11,7 @@
 #include "pow.h"
 #include "tinyformat.h"
 #include "uint256.h"
+#include "util.h"
 
 #include <vector>
 
@@ -18,6 +19,7 @@
  * Maximum amount of time that a block timestamp is allowed to exceed the
  * current network-adjusted time before the block will be accepted.
  */
+static const int64_t MAX_FUTURE_STAKE_TIME = 15 * 60;
 static const int64_t MAX_FUTURE_BLOCK_TIME = 2 * 60 * 60;
 
 /**
@@ -179,6 +181,9 @@ class CBlockIndex
     //! pointer to the index of some further predecessor of this block
     CBlockIndex* pskip;
 
+    //ppcoin: trust score of block chain
+    uint256 bnChainTrust;
+
     //! height of the entry in the chain. The genesis block has height 0
     int nHeight;
 
@@ -204,7 +209,24 @@ class CBlockIndex
     unsigned int nChainTx;
 
     //! Verification status of this block. See enum BlockStatus
-    unsigned int nStatus;
+    uint32_t nStatus;
+
+    unsigned int nFlags; // ppcoin: block index flags
+    enum {
+        BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
+        BLOCK_STAKE_ENTROPY = (1 << 1),  // entropy bit for stake modifier
+        BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
+    };
+
+    // proof-of-stake specific fields
+    arith_uint256 GetBlockTrust() const;
+    uint64_t nStakeModifier;             // hash modifier for proof-of-stake
+    unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
+    COutPoint prevoutStake;
+    unsigned int nStakeTime;
+    uint256 hashProofOfStake;
+    int64_t nMint;
+    int64_t nMoneySupply;
 
     //! block header
     int nVersion;
@@ -235,6 +257,15 @@ class CBlockIndex
         nSequenceId = 0;
         nTimeMax = 0;
 
+        nMint = 0;
+        bnChainTrust = uint256();
+        nMoneySupply = 0;
+        nFlags = 0;
+        nStakeModifier = 0;
+        nStakeModifierChecksum = 0;
+        prevoutStake.SetNull();
+        nStakeTime = 0;
+
         nVersion       = 0;
         hashMerkleRoot = uint256();
         nTime          = 0;
@@ -247,7 +278,7 @@ class CBlockIndex
         SetNull();
     }
 
-    CBlockIndex(const CBlockHeader& block)
+    CBlockIndex(const CBlock& block)
     {
         SetNull();
 
@@ -256,6 +287,24 @@ class CBlockIndex
         nTime          = block.nTime;
         nBits          = block.nBits;
         nNonce         = block.nNonce;
+
+        //Proof of Stake
+        bnChainTrust = uint256();
+        nMint = 0;
+        nMoneySupply = 0;
+        nFlags = 0;
+        nStakeModifier = 0;
+        nStakeModifierChecksum = 0;
+        hashProofOfStake = uint256();
+
+        if (block.IsProofOfStake()) {
+            SetProofOfStake();
+            prevoutStake = block.vtx[1]->vin[0].prevout;
+            nStakeTime = block.nTime;
+        } else {
+            prevoutStake.SetNull();
+            nStakeTime = 0;
+        }
     }
 
     CDiskBlockPos GetBlockPos() const {
@@ -320,6 +369,38 @@ class CBlockIndex
         return pbegin[(pend - pbegin)/2];
     }
 
+    bool IsProofOfWork() const
+    {
+        return !(nFlags & BLOCK_PROOF_OF_STAKE);
+    }
+
+    bool IsProofOfStake() const
+    {
+        return (nFlags & BLOCK_PROOF_OF_STAKE);
+    }
+
+    void SetProofOfStake()
+    {
+        nFlags |= BLOCK_PROOF_OF_STAKE;
+    }
+
+    unsigned int GetStakeEntropyBit() const;
+
+    bool SetStakeEntropyBit(unsigned int nEntropyBit)
+    {
+        if (nEntropyBit > 1)
+            return false;
+        nFlags |= (nEntropyBit ? BLOCK_STAKE_ENTROPY : 0);
+        return true;
+    }
+
+    bool GeneratedStakeModifier() const
+    {
+        return (nFlags & BLOCK_STAKE_MODIFIER);
+    }
+
+    void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier);
+
     std::string ToString() const
     {
         return strprintf("CBlockIndex(pprev=%p, nHeight=%d, merkle=%s, hashBlock=%s)",
@@ -398,6 +479,20 @@ class CDiskBlockIndex : public CBlockIndex
         if (nStatus & BLOCK_HAVE_UNDO)
             READWRITE(VARINT(nUndoPos));
 
+        READWRITE(nMint);
+        READWRITE(nMoneySupply);
+        READWRITE(nFlags);
+        READWRITE(nStakeModifier);
+        if (IsProofOfStake()) {
+            READWRITE(prevoutStake);
+            READWRITE(nStakeTime);
+            READWRITE(hashProofOfStake);
+        } else {
+            const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
+            const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
+            const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = uint256();
+        }
+
         // block hash
         READWRITE(hash);
         // block header
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index b1078edf46a7c..e78dbe6e61cd3 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -223,8 +223,15 @@ class CMainParams : public CChainParams {
         consensus.DIP0003EnforcementHeight = 1047200;
         consensus.DIP0003EnforcementHash = uint256S("000000000000002d1734087b4c5afc3133e4e1c3e1a89218f62bcd9bb3d17f81");
         consensus.powLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // ~uint256(0) >> 20
+        consensus.posLimit = uint256S("0007ffff00000000000000000000000000000000000000000000000000000000");
+        consensus.nLastPoWBlock = 100;
         consensus.nPowTargetTimespan = 24 * 60 * 60; // Dash: 1 day
         consensus.nPowTargetSpacing = 2.5 * 60; // Dash: 2.5 minutes
+        consensus.nPosTargetSpacing = consensus.nPowTargetSpacing;
+        consensus.nPosTargetTimespan = consensus.nPowTargetTimespan;
+        consensus.nStakeMinAge = 10 * 60;
+        consensus.nStakeMaxAge = 60 * 60 * 24 * 30;
+        consensus.nModifierInterval = 60 * 20;
         consensus.fPowAllowMinDifficultyBlocks = false;
         consensus.fPowNoRetargeting = false;
         consensus.nPowKGWHeight = 15200;
@@ -381,8 +388,8 @@ class CTestNetParams : public CChainParams {
 public:
     CTestNetParams() {
         strNetworkID = "test";
-        consensus.nSubsidyHalvingInterval = 210240;
-        consensus.nMasternodePaymentsStartBlock = 4010; // not true, but it's ok as long as it's less then nMasternodePaymentsIncreaseBlock
+        consensus.nSubsidyHalvingInterval = 250;
+        consensus.nMasternodePaymentsStartBlock = 500;
         consensus.nMasternodePaymentsIncreaseBlock = 4030;
         consensus.nMasternodePaymentsIncreasePeriod = 10;
         consensus.nInstantSendConfirmationsRequired = 2;
@@ -400,21 +407,28 @@ class CTestNetParams : public CChainParams {
         consensus.nMasternodeMinimumConfirmations = 1;
         consensus.BIP34Height = 76;
         consensus.BIP34Hash = uint256S("0x000008ebb1db2598e897d17275285767717c6acfeac4c73def49fbea1ddcbcb6");
-        consensus.BIP65Height = 2431; // 0000039cf01242c7f921dcb4806a5994bc003b48c1973ae0c89b67809c2bb2ab
-        consensus.BIP66Height = 2075; // 0000002acdd29a14583540cb72e1c5cc83783560e38fa7081495d474fe1671f7
+        consensus.BIP65Height = 2431;
+        consensus.BIP66Height = 2075;
         consensus.DIP0001Height = 5500;
         consensus.DIP0003Height = 7000;
         consensus.DIP0003EnforcementHeight = 7300;
         consensus.DIP0003EnforcementHash = uint256S("00000055ebc0e974ba3a3fb785c5ad4365a39637d4df168169ee80d313612f8f");
-        consensus.powLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // ~uint256(0) >> 20
-        consensus.nPowTargetTimespan = 24 * 60 * 60; // Dash: 1 day
-        consensus.nPowTargetSpacing = 2.5 * 60; // Dash: 2.5 minutes
+        consensus.powLimit = uint256S("0000fffff0000000000000000000000000000000000000000000000000000000");
+        consensus.posLimit = uint256S("0007ffff00000000000000000000000000000000000000000000000000000000");
+        consensus.nLastPoWBlock = 30;
+        consensus.nPowTargetTimespan = 180 * 4;
+        consensus.nPowTargetSpacing = 180 * 1;
+        consensus.nPosTargetSpacing = consensus.nPowTargetSpacing;
+        consensus.nPosTargetTimespan = consensus.nPowTargetTimespan;
+        consensus.nStakeMinAge = 5 * 60;
+        consensus.nStakeMaxAge = 60 * 60 * 24 * 30;
+        consensus.nModifierInterval = 60 * 20;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = false;
-        consensus.nPowKGWHeight = 4002; // nPowKGWHeight >= nPowDGWHeight means "no KGW"
+        consensus.nPowKGWHeight = 4002;
         consensus.nPowDGWHeight = 4002;
-        consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
-        consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
+        consensus.nRuleChangeActivationThreshold = 1512;
+        consensus.nMinerConfirmationWindow = 2016;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008
@@ -453,31 +467,38 @@ class CTestNetParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nThreshold = 50; // 50% of 100
 
         // The best chain should have at least this much work.
-        consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000062cd3e94ad2d62"); // 95930
+        consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000");
 
         // By default assume that the signatures in ancestors of this block are valid.
-        consensus.defaultAssumeValid = uint256S("0x0000000005ae4db9746d6cad8e0ccebdef1e05afec9c40809f31457fdaf7d843"); // 95930
+        consensus.defaultAssumeValid = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000");
 
-        pchMessageStart[0] = 0xce;
-        pchMessageStart[1] = 0xe2;
-        pchMessageStart[2] = 0xca;
-        pchMessageStart[3] = 0xff;
+        pchMessageStart[0] = 0x01;
+        pchMessageStart[1] = 0x23;
+        pchMessageStart[2] = 0x45;
+        pchMessageStart[3] = 0x67;
         vAlertPubKey = ParseHex("04517d8a699cb43d3938d7b24faaff7cda448ca4ea267723ba614784de661949bf632d6304316b244646dea079735b9a6fc4af804efb4752075b9fe2245e14e412");
-        nDefaultPort = 19999;
+        nDefaultPort = 29999;
         nPruneAfterHeight = 1000;
 
-        genesis = CreateGenesisBlock(1390666206UL, 3861367235UL, 0x1e0ffff0, 1, 50 * COIN);
-        consensus.hashGenesisBlock = genesis.GetHash();
-        assert(consensus.hashGenesisBlock == uint256S("0x00000bafbc94add76cb75e2ec92894837288a481e5c005f6563d91623bf8bc2c"));
-        assert(genesis.hashMerkleRoot == uint256S("0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7"));
+	/////////////////////////////////////////////////////////////////////////
+	uint32_t nTime = 1559300000;
+	uint32_t nNonce = 0;
+	while (UintToArith256(genesis.GetHash()) >
+			   UintToArith256(consensus.powLimit)) {
+	  nNonce++;
+	  genesis = CreateGenesisBlock(nTime, nNonce, 0x1f00ffff, 1, 0 * COIN);
+	}
+	genesis = CreateGenesisBlock(nTime, nNonce, 0x1f00ffff, 1, 0 * COIN);
+	consensus.hashGenesisBlock = genesis.GetHash();
+	/////////////////////////////////////////////////////////////////////////
+
+        // assert(consensus.hashGenesisBlock == uint256S("0x00000bafbc94add76cb75e2ec92894837288a481e5c005f6563d91623bf8bc2c"));
+        // assert(genesis.hashMerkleRoot == uint256S("0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7"));
 
         vFixedSeeds.clear();
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 
         vSeeds.clear();
-        // nodes with support for servicebits filtering should be at the top
-        vSeeds.push_back(CDNSSeedData("dashdot.io",  "testnet-seed.dashdot.io"));
-        vSeeds.push_back(CDNSSeedData("masternode.io", "test.dnsseed.masternode.io"));
 
         // Testnet Dash addresses start with 'y'
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,140);
@@ -500,10 +521,10 @@ class CTestNetParams : public CChainParams {
         consensus.llmqChainLocks = Consensus::LLMQ_50_60;
         consensus.llmqForInstantSend = Consensus::LLMQ_50_60;
 
-        fMiningRequiresPeers = true;
+        fMiningRequiresPeers = false;
         fDefaultConsistencyChecks = false;
         fRequireStandard = false;
-        fRequireRoutableExternalIP = true;
+        fRequireRoutableExternalIP = false;
         fMineBlocksOnDemand = false;
         fAllowMultipleAddressesFromGroup = false;
         fAllowMultiplePorts = true;
@@ -567,8 +588,15 @@ class CDevNetParams : public CChainParams {
         consensus.DIP0003EnforcementHeight = 2; // DIP0003 activated immediately on devnet
         consensus.DIP0003EnforcementHash = uint256();
         consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // ~uint256(0) >> 1
+        consensus.posLimit = uint256S("007ffff000000000000000000000000000000000000000000000000000000000");
+        consensus.nLastPoWBlock = 100;
         consensus.nPowTargetTimespan = 24 * 60 * 60; // Dash: 1 day
         consensus.nPowTargetSpacing = 2.5 * 60; // Dash: 2.5 minutes
+        consensus.nPosTargetSpacing = consensus.nPowTargetSpacing;
+        consensus.nPosTargetTimespan = consensus.nPowTargetTimespan;
+        consensus.nStakeMinAge = 10 * 60;
+        consensus.nStakeMaxAge = 60 * 60 * 24 * 30;
+        consensus.nModifierInterval = 60 * 20;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = false;
         consensus.nPowKGWHeight = 4001; // nPowKGWHeight >= nPowDGWHeight means "no KGW"
@@ -735,8 +763,15 @@ class CRegTestParams : public CChainParams {
         consensus.DIP0003EnforcementHeight = 500;
         consensus.DIP0003EnforcementHash = uint256();
         consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // ~uint256(0) >> 1
+        consensus.posLimit = uint256S("007ffff000000000000000000000000000000000000000000000000000000000");
+        consensus.nLastPoWBlock = 100;
         consensus.nPowTargetTimespan = 24 * 60 * 60; // Dash: 1 day
         consensus.nPowTargetSpacing = 2.5 * 60; // Dash: 2.5 minutes
+        consensus.nPosTargetSpacing = consensus.nPowTargetSpacing;
+        consensus.nPosTargetTimespan = consensus.nPowTargetTimespan;
+        consensus.nStakeMinAge = 10 * 60;
+        consensus.nStakeMaxAge = 60 * 60 * 24 * 30;
+        consensus.nModifierInterval = 60 * 20;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = true;
         consensus.nPowKGWHeight = 15200; // same as mainnet
diff --git a/src/chainparams.h b/src/chainparams.h
index f59ba102cd48d..4ca11caf1d99e 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -60,6 +60,7 @@ class CChainParams
     const CMessageHeader::MessageStartChars& MessageStart() const { return pchMessageStart; }
     const std::vector<unsigned char>& AlertKey() const { return vAlertPubKey; }
     int GetDefaultPort() const { return nDefaultPort; }
+    int MaxReorganizationDepth() const { return nMaxReorganizationDepth; }
 
     const CBlock& GenesisBlock() const { return genesis; }
     const CBlock& DevNetGenesisBlock() const { return devnetGenesis; }
@@ -122,6 +123,7 @@ class CChainParams
     int nFulfilledRequestExpireTime;
     std::vector<std::string> vSporkAddresses;
     int nMinSporkKeys;
+    int nMaxReorganizationDepth;
     bool fBIP9CheckMasternodesUpgraded;
 };
 
diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h
index c2853703745eb..871ec863892d5 100644
--- a/src/chainparamsseeds.h
+++ b/src/chainparamsseeds.h
@@ -8,318 +8,8 @@
  * IPv4 as well as onion addresses are wrapped inside a IPv6 address accordingly.
  */
 static SeedSpec6 pnSeed6_main[] = {
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x09,0x63,0x50}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x84,0xbf,0x6d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x84,0xbf,0xd3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x84,0xbf,0xd5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x84,0xbf,0xd8}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x86,0x73,0x25}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xbd,0xab,0x40}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xc8,0x17,0x21}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xc8,0x35,0x60}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0xdd,0x60,0x95}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xaf,0x00,0x6f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xaf,0x00,0x70}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xaf,0x00,0x71}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xaf,0x00,0x72}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xb6,0x80,0x15}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xb6,0x80,0x17}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xb6,0x80,0x18}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xb6,0x80,0x19}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xe3,0xa0,0x4c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xe3,0xa3,0x17}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x17,0xe3,0xa3,0x34}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1b,0x66,0x72,0x3d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1f,0x1f,0x49,0x52}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xc4,0x60,0x63}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xc7,0x82,0x45}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xe1,0x65,0x61}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xa7,0xc0,0xa5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xc4,0xf2,0xe3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xc5,0xbb,0x01}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0x61,0xe3,0x15}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0x78,0xa1,0x91}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0x9d,0xc7,0xd2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0xdd,0xc0,0xdc}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0xdd,0xc2,0x2a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x25,0xdd,0xc2,0x2b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x28,0x71,0x06,0x2c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2b,0xe5,0x4d,0x2e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x20,0xce,0xb9}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4c,0x40,0x06}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0x1c,0x6d,0xc3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0x25,0x9e,0xb1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0xa3,0xa6,0x39}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x34,0xe5,0x48}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x4b,0x31,0xe4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x5a,0x0e,0x9c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x62,0x42,0x5e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x68,0x60,0xcf}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0xf4,0x66,0x51}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x0f,0x2a,0x8f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x26,0x69,0x24}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x26,0x80,0xfb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0xff,0x20,0xd5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x4f,0x70,0x16}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xbb,0x87,0xbb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xeb,0x24,0xbb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xf2,0x25,0x08}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x36,0x46,0xe7,0xc3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x36,0xac,0x91,0xa2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3e,0x8a,0x03,0xd6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3e,0x8a,0x08,0x07}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3e,0x8a,0x08,0x67}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3e,0x92,0x0d,0x32}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3f,0x8e,0xfd,0x55}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x40,0x22,0xda,0x30}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x40,0x8c,0x9d,0x72}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x40,0x8c,0x9f,0xe2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0x17,0xf2,0x56}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0x17,0xf2,0x59}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0x17,0xf2,0x5a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0x17,0xf2,0x5b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0xac,0x0b,0x55}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0xac,0x1b,0x46}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x45,0x33,0x0d,0x5a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x45,0x33,0x0d,0x65}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x45,0x33,0x14,0x46}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x45,0x33,0x14,0x47}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4a,0xcf,0xe4,0xb4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4b,0x7f,0x04,0xf8}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4c,0x4a,0xdb,0x94}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4d,0x51,0xe2,0x92}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4e,0x29,0xcf,0x46}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4e,0x53,0x13,0x00}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4e,0x85,0xa9,0x46}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x50,0x78,0x1b,0x96}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x51,0xa9,0xcd,0xdc}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x51,0xa9,0xe5,0x54}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x51,0xab,0x02,0xf5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0x76,0xe3,0x34}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xa5,0x1d,0x67}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x15,0x80}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x15,0x83}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x15,0x88}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xd3,0x15,0x8b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x54,0xea,0x60,0x52}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x54,0xea,0x60,0x56}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x54,0xea,0x60,0x57}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0x19,0xc7,0xd7}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xb8,0xfe,0x1d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xb8,0xfe,0xb5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xd9,0xaa,0xce}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xd9,0xab,0xf3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xff,0x01,0x41}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xff,0x04,0xd4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x57,0x6a,0x3f,0x34}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x57,0x75,0xfd,0x37}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0x24,0xdc,0xf1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0x28,0x00,0x0e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0x28,0x72,0x45}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0xee,0xb5,0x4a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5b,0xdb,0xef,0x52}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5b,0xdb,0xef,0x53}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5c,0x3f,0x39,0x1c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5c,0x3f,0x39,0x78}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5d,0x5a,0xcd,0x50}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5d,0x68,0xd5,0xd0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5d,0x9e,0xd8,0x99}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0x9c,0xae,0xa6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xb0,0xef,0x3e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xb1,0xaa,0xdf}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xb1,0xe0,0xe1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xb1,0xe1,0x73}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xb1,0xe1,0xd2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xb1,0xe8,0x21}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xb1,0xfa,0x3d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0x2b,0x8b,0xa2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb5,0xe2,0x2f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb7,0x32,0x61}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb7,0x33,0x62}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb7,0x33,0x8d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb7,0x35,0x86}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd8,0x0b,0x39}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd8,0x93,0x2f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x60,0x7e,0x60,0xa4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x65,0x25,0x60,0x00}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x65,0x25,0x60,0x60}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x68,0xc4,0xa9,0x51}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x68,0xdf,0x06,0xa4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6b,0x06,0x8c,0x23}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6b,0x06,0x8c,0x37}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6b,0x06,0xaf,0x96}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6b,0x9b,0x76,0x89}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6b,0xbf,0x65,0xd4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6c,0x3d,0xe0,0x16}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6c,0x3d,0xe0,0x21}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6e,0x0a,0x19,0x4c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x73,0x9f,0x56,0x76}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x7a,0x6a,0x37,0xd6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x7a,0x72,0xad,0xda}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x7b,0xc1,0x40,0xa6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x82,0xb9,0xfb,0x45}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x82,0xb9,0xfb,0x71}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x85,0x82,0x66,0x16}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x8b,0x63,0xc1,0x17}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x94,0x42,0x32,0x2a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x97,0xec,0x0a,0x6d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9a,0x7f,0x39,0xf0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9a,0x7f,0x39,0xfe}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9a,0x7f,0x3b,0x1b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9a,0x7f,0x3c,0x08}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x45,0x9b,0x5e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x59,0x20,0x0c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x64,0x13,0xa6}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x64,0x13,0xa7}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0xcb,0x14,0x83}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa3,0x2c,0xa7,0x90}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa3,0x2c,0xa7,0xed}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa3,0x2c,0xa8,0xbf}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa7,0x58,0x0f,0x61}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa8,0xeb,0x60,0xcb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa8,0xeb,0x60,0xcd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa8,0xeb,0x63,0x2f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xaa,0x4b,0xa2,0x3c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xaa,0x4b,0xa2,0xdb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xaa,0x4b,0xa3,0x6c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xac,0x51,0xb1,0x2a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xac,0x56,0x79,0x94}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xac,0x68,0x40,0x0d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xac,0x6e,0x05,0x62}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xac,0x6e,0x06,0xa9}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xad,0xd4,0xf1,0x32}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb0,0x7a,0x14,0xcf}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0x3e,0xa0,0x1d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0xd1,0x32,0x1e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0xee,0x2a,0x07}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x16,0xae,0x25}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x1a,0x7e,0xfa}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x1c,0x65,0x5b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x1c,0x65,0x85}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x23,0x40,0xd9}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x23,0x43,0x75}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x2b,0xd2,0x7d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x3a,0xc2,0x71}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x3a,0xe0,0xea}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x40,0x68,0xdd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x40,0x68,0xde}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x40,0x68,0xdf}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x6a,0x7a,0x2e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x77,0x55,0x1e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x85,0x25,0x69}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x8b,0xed,0x9a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x8d,0x1a,0x6a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x8e,0xd4,0x90}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x9c,0xb2,0x7d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x9c,0xb2,0xd8}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x9c,0xb2,0xda}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0x9c,0xb2,0xde}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xa5,0xa8,0x15}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xa5,0xa8,0x16}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xa5,0xa8,0x17}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xa5,0xa8,0x19}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xa8,0x08,0x90}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xb7,0x61,0x83}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xb9,0x28,0x0d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xcb,0x75,0xe5}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xd4,0x2c,0xfa}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xd5,0x25,0x01}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xd5,0x25,0x06}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xd9,0x01,0x63}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xd9,0x01,0x64}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xf3,0x70,0x30}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xf3,0x70,0x50}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xf3,0x70,0xbb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xf3,0x70,0xdd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xfd,0xbd,0x12}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xfd,0xbd,0x42}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xfd,0xbd,0x46}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xfd,0xbd,0x50}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0xa6,0x45,0x58}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0xe3,0x4a,0xab}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0xe3,0x4a,0xc1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbe,0x04,0xb8,0xb4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbe,0x0a,0x08,0xfa}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0x51,0x82,0xe4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xa1,0xb6,0x68}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xa1,0xb6,0x6c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xa1,0xb6,0x6d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xe3,0x8f,0x29}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xe3,0xe4,0xc4}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xfa,0xe6,0x11}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0x1d,0xbb,0x55}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0xea,0xe0,0x48}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0xea,0xe0,0x64}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0xea,0xe0,0x67}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc1,0xea,0xe0,0x91}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc2,0x63,0x14,0x64}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc3,0x9a,0x69,0x6d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc3,0x9a,0x69,0x7d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc6,0x14,0x65,0x74}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc6,0x17,0x80,0x4b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc6,0x35,0x4a,0x0e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc6,0x3d,0xbe,0x8e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc7,0xc9,0x6e,0xc3}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc8,0x7a,0x80,0xac}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xca,0x47,0x62,0x7b}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xca,0x47,0x62,0x7c}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xca,0x47,0x62,0x7d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xca,0x47,0x62,0x7e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xcc,0x10,0xf3,0x6a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xcc,0x10,0xf5,0x62}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd1,0xb1,0x58,0x57}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd1,0xb1,0x5b,0xcb}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd4,0x18,0x60,0x10}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd4,0x18,0x60,0x1a}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd4,0x2f,0xeb,0xfd}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd4,0xe3,0xc9,0x2f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd4,0xed,0x25,0xf0}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd5,0x40,0xc5,0x5f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd5,0x88,0x50,0x5d}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd5,0x88,0x50,0x9f}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd8,0x6b,0xd9,0x3e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd8,0xbd,0x91,0xa1}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd8,0xbd,0x93,0xb2}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd9,0x3d,0x02,0x35}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xdd,0x9c,0x85,0x6e}, 9999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xde,0xe7,0x3b,0x1e}, 9999}
 };
 
 static SeedSpec6 pnSeed6_test[] = {
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0xca,0x34,0xaa}, 20008},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0xca,0x34,0xaa}, 20004},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0xca,0x34,0xaa}, 20000},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0xca,0x34,0xaa}, 20012},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0xca,0x34,0xaa}, 20016},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x12,0xca,0x34,0xaa}, 20020},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xff,0x0f,0x14}, 20007},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xff,0x0f,0x14}, 20003},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xff,0x0f,0x14}, 20015},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xff,0x0f,0x14}, 20011},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xff,0x0f,0x14}, 20019},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xff,0x0f,0x14}, 20023},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x32,0xd0,0x35}, 20009},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x32,0xd0,0x35}, 20005},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x32,0xd0,0x35}, 20001},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x32,0xd0,0x35}, 20013},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x32,0xd0,0x35}, 20017},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x32,0xd0,0x35}, 20021},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3f,0x21,0xee,0x55}, 20010},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3f,0x21,0xee,0x55}, 20006},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3f,0x21,0xee,0x55}, 20002},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3f,0x21,0xee,0x55}, 20014},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3f,0x21,0xee,0x55}, 20018},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3f,0x21,0xee,0x55}, 20022},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x10}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x11}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x12}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x13}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x14}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x15}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x16}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x17}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x18}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x91,0xef,0xeb,0x19}, 19999},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb2,0x3e,0xcb,0xf9}, 19999}
 };
 #endif // DASH_CHAINPARAMSSEEDS_H
diff --git a/src/coins.cpp b/src/coins.cpp
index 1f8baa2b1ba1e..4e612a56b85a0 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -13,8 +13,9 @@
 
 bool CCoinsView::GetCoin(const COutPoint &outpoint, Coin &coin) const { return false; }
 uint256 CCoinsView::GetBestBlock() const { return uint256(); }
+std::vector<uint256> CCoinsView::GetHeadBlocks() const { return std::vector<uint256>(); }
 bool CCoinsView::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { return false; }
-CCoinsViewCursor *CCoinsView::Cursor() const { return 0; }
+CCoinsViewCursor *CCoinsView::Cursor() const { return nullptr; }
 
 bool CCoinsView::HaveCoin(const COutPoint &outpoint) const
 {
@@ -26,6 +27,7 @@ CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
 bool CCoinsViewBacked::GetCoin(const COutPoint &outpoint, Coin &coin) const { return base->GetCoin(outpoint, coin); }
 bool CCoinsViewBacked::HaveCoin(const COutPoint &outpoint) const { return base->HaveCoin(outpoint); }
 uint256 CCoinsViewBacked::GetBestBlock() const { return base->GetBestBlock(); }
+std::vector<uint256> CCoinsViewBacked::GetHeadBlocks() const { return base->GetHeadBlocks(); }
 void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) { base = &viewIn; }
 bool CCoinsViewBacked::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { return base->BatchWrite(mapCoins, hashBlock); }
 CCoinsViewCursor *CCoinsViewBacked::Cursor() const { return base->Cursor(); }
@@ -86,13 +88,14 @@ void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin&& coin, bool possi
     cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
 }
 
-void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight) {
+void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight, bool check) {
     bool fCoinbase = tx.IsCoinBase();
     const uint256& txid = tx.GetHash();
     for (size_t i = 0; i < tx.vout.size(); ++i) {
-        // Pass fCoinbase as the possible_overwrite flag to AddCoin, in order to correctly
-        // deal with the pre-BIP30 occurrances of duplicate coinbase transactions.
-        cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase), fCoinbase);
+        bool overwrite = check ? cache.HaveCoin(COutPoint(txid, i)) : fCoinbase;
+        // Always set the possible_overwrite flag to AddCoin for coinbase txn, in order to correctly
+        // deal with the pre-BIP30 occurrences of duplicate coinbase transactions.
+        cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase, tx.IsCoinStake()), overwrite);
     }
 }
 
diff --git a/src/coins.h b/src/coins.h
index e2606c7c21bea..a72e3ebfcb453 100644
--- a/src/coins.h
+++ b/src/coins.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_COINS_H
 #define BITCOIN_COINS_H
 
+#include "primitives/transaction.h"
 #include "compressor.h"
 #include "core_memusage.h"
 #include "hash.h"
@@ -15,6 +16,7 @@
 
 #include <assert.h>
 #include <stdint.h>
+#include <bitset>
 #include <unordered_map>
 
 /**
@@ -32,32 +34,52 @@ class Coin
 
     //! whether containing transaction was a coinbase
     unsigned int fCoinBase : 1;
+    //! whether containing transaction was a coinstake
+    unsigned int fCoinStake : 1;
 
     //! at which height this containing transaction was included in the active block chain
-    uint32_t nHeight : 31;
+    uint32_t nHeight : 30;
 
     //! construct a Coin from a CTxOut and height/coinbase information.
-    Coin(CTxOut&& outIn, int nHeightIn, bool fCoinBaseIn) : out(std::move(outIn)), fCoinBase(fCoinBaseIn), nHeight(nHeightIn) {}
-    Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn) : out(outIn), fCoinBase(fCoinBaseIn),nHeight(nHeightIn) {}
+    Coin(CTxOut&& outIn, int nHeightIn, bool fCoinBaseIn, bool fCoinStakeIn) :
+        out(std::move(outIn)),
+        fCoinBase(fCoinBaseIn),
+        fCoinStake(fCoinStakeIn),
+        nHeight(nHeightIn)
+    { }
+
+    Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn, bool fCoinStakeIn) :
+        out(outIn),
+        fCoinBase(fCoinBaseIn),
+        fCoinStake(fCoinStakeIn),
+        nHeight(nHeightIn)
+    { }
 
     void Clear() {
         out.SetNull();
         fCoinBase = false;
+        fCoinStake = false;
         nHeight = 0;
     }
 
     //! empty constructor
-    Coin() : fCoinBase(false), nHeight(0) { }
+    Coin() : fCoinBase(false), fCoinStake(false), nHeight(0) { }
 
     bool IsCoinBase() const {
         return fCoinBase;
     }
 
+    bool IsCoinStake() const {
+        return fCoinStake;
+    }
+
     template<typename Stream>
     void Serialize(Stream &s) const {
         assert(!IsSpent());
-        uint32_t code = nHeight * 2 + fCoinBase;
-        ::Serialize(s, VARINT(code));
+        std::bitset<32> code(nHeight);
+        code[30] = fCoinStake;
+        code[31] = fCoinBase;
+        ::Serialize(s, VARINT(code.to_ulong()));
         ::Serialize(s, CTxOutCompressor(REF(out)));
     }
 
@@ -65,9 +87,13 @@ class Coin
     void Unserialize(Stream &s) {
         uint32_t code = 0;
         ::Unserialize(s, VARINT(code));
-        nHeight = code >> 1;
-        fCoinBase = code & 1;
-        ::Unserialize(s, REF(CTxOutCompressor(out)));
+        std::bitset<32> bitset(code);
+        fCoinBase = bitset[31];
+        fCoinStake = bitset[30];
+        bitset.reset(30);
+        bitset.reset(31);
+        nHeight = bitset.to_ulong();
+        ::Unserialize(s, CTxOutCompressor(out));
     }
 
     bool IsSpent() const {
@@ -128,7 +154,6 @@ class CCoinsViewCursor
 
     virtual bool GetKey(COutPoint &key) const = 0;
     virtual bool GetValue(Coin &coin) const = 0;
-    /* Don't care about GetKeySize here */
     virtual unsigned int GetValueSize() const = 0;
 
     virtual bool Valid() const = 0;
@@ -156,6 +181,12 @@ class CCoinsView
     //! Retrieve the block hash whose state this CCoinsView currently represents
     virtual uint256 GetBestBlock() const;
 
+    //! Retrieve the range of blocks that may have been only partially written.
+    //! If the database is in a consistent state, the result is the empty vector.
+    //! Otherwise, a two-element vector is returned consisting of the new and
+    //! the old block hash, in that order.
+    virtual std::vector<uint256> GetHeadBlocks() const;
+
     //! Do a bulk modification (multiple Coin changes + BestBlock change).
     //! The passed mapCoins can be modified.
     virtual bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock);
@@ -182,6 +213,7 @@ class CCoinsViewBacked : public CCoinsView
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     bool HaveCoin(const COutPoint &outpoint) const override;
     uint256 GetBestBlock() const override;
+    std::vector<uint256> GetHeadBlocks() const override;
     void SetBackend(CCoinsView &viewIn);
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) override;
     CCoinsViewCursor *Cursor() const override;
@@ -206,6 +238,11 @@ class CCoinsViewCache : public CCoinsViewBacked
 public:
     CCoinsViewCache(CCoinsView *baseIn);
 
+    /**
+     * By deleting the copy constructor, we prevent accidentally using it when one intends to create a cache on top of a base cache.
+     */
+    CCoinsViewCache(const CCoinsViewCache &) = delete;
+
     // Standard CCoinsView methods
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     bool HaveCoin(const COutPoint &outpoint) const override;
@@ -282,18 +319,15 @@ class CCoinsViewCache : public CCoinsViewBacked
 
 private:
     CCoinsMap::iterator FetchCoin(const COutPoint &outpoint) const;
-
-    /**
-     * By making the copy constructor private, we prevent accidentally using it when one intends to create a cache on top of a base cache.
-     */
-    CCoinsViewCache(const CCoinsViewCache &);
 };
 
 //! Utility function to add all of a transaction's outputs to a cache.
-// It assumes that overwrites are only possible for coinbase transactions,
+// When check is false, this assumes that overwrites are only possible for coinbase transactions.
+// When check is true, the underlying view may be queried to determine whether an addition is
+// an overwrite.
 // TODO: pass in a boolean to limit these possible overwrites to known
 // (pre-BIP34) cases.
-void AddCoins(CCoinsViewCache& cache, const CTransaction& tx, int nHeight);
+void AddCoins(CCoinsViewCache& cache, const CTransaction& tx, int nHeight, bool check = false);
 
 //! Utility function to find any unspent output with a given txid.
 // This function can be quite expensive because in the event of a transaction
diff --git a/src/compat.h b/src/compat.h
index 2e9663b8d63f3..f68e9a5edee22 100644
--- a/src/compat.h
+++ b/src/compat.h
@@ -74,6 +74,17 @@ typedef u_int SOCKET;
 #define MAX_PATH            1024
 #endif
 
+#ifndef WIN32
+// PRIO_MAX is not defined on Solaris
+#ifndef PRIO_MAX
+#define PRIO_MAX 20
+#endif
+#define THREAD_PRIORITY_LOWEST          PRIO_MAX
+#define THREAD_PRIORITY_BELOW_NORMAL    2
+#define THREAD_PRIORITY_NORMAL          0
+#define THREAD_PRIORITY_ABOVE_NORMAL    (-2)
+#endif
+
 // As Solaris does not have the MSG_NOSIGNAL flag for send(2) syscall, it is defined as 0
 #if !defined(HAVE_MSG_NOSIGNAL) && !defined(MSG_NOSIGNAL)
 #define MSG_NOSIGNAL 0
diff --git a/src/compressor.h b/src/compressor.h
index 961365d2618a4..57c365afb4607 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -14,6 +14,13 @@ class CKeyID;
 class CPubKey;
 class CScriptID;
 
+bool CompressScript(const CScript& script, std::vector<unsigned char> &out);
+unsigned int GetSpecialScriptSize(unsigned int nSize);
+bool DecompressScript(CScript& script, unsigned int nSize, const std::vector<unsigned char> &out);
+
+uint64_t CompressAmount(uint64_t nAmount);
+uint64_t DecompressAmount(uint64_t nAmount);
+
 /** Compact serializer for scripts.
  *
  *  It detects common cases and encodes them much more efficiently.
diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index 0efe580c1e082..a8278674d38a7 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -21,7 +21,7 @@ inline unsigned int MaxBlockSigOps(bool fDIP0001Active /*= false */)
 /** The maximum allowed size of version 3 extra payload */
 static const unsigned int MAX_TX_EXTRA_PAYLOAD = 10000;
 /** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
-static const int COINBASE_MATURITY = 100;
+static const int COINBASE_MATURITY = 20;
 
 /** Flags for nSequence and nLockTime locks */
 enum {
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 9fae740720da3..c0c384e3b80bc 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -168,10 +168,19 @@ struct Params {
     int64_t nPowTargetTimespan;
     int nPowKGWHeight;
     int nPowDGWHeight;
+    int nLastPoWBlock;
     int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
     uint256 nMinimumChainWork;
     uint256 defaultAssumeValid;
 
+    /** Proof of stake parameters */
+    uint256 posLimit;
+    int64_t nPosTargetSpacing;
+    int64_t nPosTargetTimespan;
+    int nStakeMinAge;
+    int nStakeMaxAge;
+    int64_t nModifierInterval;
+
     /** these parameters are only used on devnet and can be configured from the outside */
     int nMinimumDifficultyBlocks{0};
     int nHighSubsidyBlocks{0};
diff --git a/src/init.cpp b/src/init.cpp
index 65101215625f1..c97ce386eab67 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -2129,6 +2129,10 @@ bool AppInitMain(boost::thread_group& threadGroup, CScheduler& scheduler)
         pwalletMain->postInitProcess(scheduler);
 #endif
 
+    if(GetBoolArg("-staking", true)) {
+        threadGroup.create_thread(std::bind(&ThreadStakeMinter, boost::ref(chainparams), boost::ref(connman)));
+    }
+
     threadGroup.create_thread(boost::bind(&ThreadSendAlert, boost::ref(connman)));
 
     return !fRequestShutdown;
diff --git a/src/kernel.cpp b/src/kernel.cpp
new file mode 100644
index 0000000000000..5f0805672d0cb
--- /dev/null
+++ b/src/kernel.cpp
@@ -0,0 +1,410 @@
+// Copyright (c) 2012-2013 The PPCoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <boost/assign/list_of.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <chainparams.h>
+#include <db.h>
+#include <kernel.h>
+#include <script/interpreter.h>
+#include <timedata.h>
+#include <util.h>
+#include <wallet/wallet.h>
+#include <validation.h>
+#include <policy/policy.h>
+#include <init.h>
+#include <utiltime.h>
+
+#include <numeric>
+
+#define PRI64x  "llx"
+
+using namespace std;
+
+// Modifier interval: time to elapse before new modifier is computed
+// Set to 3-hour for production network and 20-minute for test network
+unsigned int nModifierInterval = MODIFIER_INTERVAL;
+unsigned int getIntervalVersion(bool fTestNet)
+{
+    if (fTestNet)
+        return MODIFIER_INTERVAL_TESTNET;
+    else
+        return MODIFIER_INTERVAL;
+}
+
+// Hard checkpoints of stake modifiers to ensure they are deterministic
+static std::map<int, unsigned int> mapStakeModifierCheckpoints =
+        boost::assign::map_list_of(0, 0xfd11f4e7);
+
+// Get time weight
+int64_t GetWeight(int64_t nIntervalBeginning, int64_t nIntervalEnd)
+{
+    return nIntervalEnd - nIntervalBeginning - Params().GetConsensus().nStakeMinAge;
+}
+
+// Get the last stake modifier and its generation time from a given block
+static bool GetLastStakeModifier(const CBlockIndex* pindex, uint64_t& nStakeModifier, int64_t& nModifierTime)
+{
+    if (!pindex)
+        return error("GetLastStakeModifier: null pindex");
+    while (pindex && pindex->pprev && !pindex->GeneratedStakeModifier())
+        pindex = pindex->pprev;
+    if (!pindex->GeneratedStakeModifier())
+        return error("GetLastStakeModifier: no generation at genesis block");
+    nStakeModifier = pindex->nStakeModifier;
+    nModifierTime = pindex->GetBlockTime();
+    return true;
+}
+
+// Get selection interval section (in seconds)
+static int64_t GetStakeModifierSelectionIntervalSection(int nSection)
+{
+    assert(nSection >= 0 && nSection < 64);
+    int64_t a = nModifierInterval * 63 / (63 + ((63 - nSection) * (MODIFIER_INTERVAL_RATIO - 1)));
+    return a;
+}
+
+// Get stake modifier selection interval (in seconds)
+static int64_t GetStakeModifierSelectionInterval()
+{
+    int64_t nSelectionInterval = 0;
+    for (int nSection = 0; nSection < 64; nSection++) {
+        nSelectionInterval += GetStakeModifierSelectionIntervalSection(nSection);
+    }
+    return nSelectionInterval;
+}
+
+// select a block from the candidate blocks in vSortedByTimestamp, excluding
+// already selected blocks in vSelectedBlocks, and with timestamp up to
+// nSelectionIntervalStop.
+static bool SelectBlockFromCandidates(
+        vector<pair<int64_t, uint256> >& vSortedByTimestamp,
+        map<uint256, const CBlockIndex*>& mapSelectedBlocks,
+        int64_t nSelectionIntervalStop, uint64_t nStakeModifierPrev,
+        const CBlockIndex** pindexSelected)
+{
+    bool fSelected = false;
+    arith_uint256 hashBest;
+    *pindexSelected = nullptr;
+    for(const auto &item : vSortedByTimestamp)
+    {
+        if (!mapBlockIndex.count(item.second))
+            return error("SelectBlockFromCandidates: failed to find block index for candidate block %s", item.second.ToString().c_str());
+        const CBlockIndex* pindex = mapBlockIndex[item.second];
+        if (fSelected && pindex->GetBlockTime() > nSelectionIntervalStop)
+            break;
+        if (mapSelectedBlocks.count(pindex->GetBlockHash()) > 0)
+            continue;
+        // compute the selection hash by hashing its proof-hash and the
+        // previous proof-of-stake modifier
+        uint256 hashProof = pindex->IsProofOfStake()? pindex->hashProofOfStake : pindex->GetBlockHash();
+        CDataStream ss(SER_GETHASH, 0);
+        ss << hashProof << nStakeModifierPrev;
+        arith_uint256 hashSelection = UintToArith256(Hash(ss.begin(), ss.end()));
+        // the selection hash is divided by 2**32 so that proof-of-stake block
+        // is always favored over proof-of-work block. this is to preserve
+        // the energy efficiency property
+        if (pindex->IsProofOfStake())
+            hashSelection >>= 32;
+        if (fSelected && hashSelection < hashBest)
+        {
+            hashBest = hashSelection;
+            *pindexSelected = (const CBlockIndex*) pindex;
+        }
+        else if (!fSelected)
+        {
+            fSelected = true;
+            hashBest = hashSelection;
+            *pindexSelected = (const CBlockIndex*) pindex;
+        }
+    }
+    if (GetBoolArg("-printstakemodifier", false))
+        LogPrintf("%s : selection hash=%s\n", __func__, hashBest.ToString().c_str());
+    return fSelected;
+}
+
+// Stake Modifier (hash modifier of proof-of-stake):
+// The purpose of stake modifier is to prevent a txout (coin) owner from
+// computing future proof-of-stake generated by this txout at the time
+// of transaction confirmation. To meet kernel protocol, the txout
+// must hash with a future stake modifier to generate the proof.
+// Stake modifier consists of bits each of which is contributed from a
+// selected block of a given block group in the past.
+// The selection of a block is based on a hash of the block's proof-hash and
+// the previous stake modifier.
+// Stake modifier is recomputed at a fixed time interval instead of every
+// block. This is to make it difficult for an attacker to gain control of
+// additional bits in the stake modifier, even after generating a chain of
+// blocks.
+bool ComputeNextStakeModifier(const CBlockIndex* pindexCurrent, uint64_t &nStakeModifier, bool& fGeneratedStakeModifier)
+{
+    const Consensus::Params& params = Params().GetConsensus();
+    const CBlockIndex* pindexPrev = pindexCurrent->pprev;
+    nStakeModifier = 0;
+    fGeneratedStakeModifier = false;
+    if (!pindexPrev)
+    {
+        fGeneratedStakeModifier = true;
+        return true;  // genesis block's modifier is 0
+    }
+    // First find current stake modifier and its generation block time
+    // if it's not old enough, return the same stake modifier
+    int64_t nModifierTime = 0;
+    if (!GetLastStakeModifier(pindexPrev, nStakeModifier, nModifierTime))
+        return error("ComputeNextStakeModifier: unable to get last modifier");
+    LogPrintf("ComputeNextStakeModifier: prev modifier=0x%016x time=%s epoch=%u\n", nStakeModifier, DateTimeStrFormat("%Y-%m-%d %H:%M:%S", nModifierTime).c_str(), (unsigned int)nModifierTime);
+    if (nModifierTime / params.nModifierInterval >= pindexPrev->GetBlockTime() / params.nModifierInterval)
+        return true;
+
+    // Sort candidate blocks by timestamp
+    vector<pair<int64_t, uint256> > vSortedByTimestamp;
+    vSortedByTimestamp.reserve(64 * params.nModifierInterval / params.nPosTargetSpacing);
+    int64_t nSelectionInterval = GetStakeModifierSelectionInterval();
+    int64_t nSelectionIntervalStart = (pindexPrev->GetBlockTime() / params.nModifierInterval) * params.nModifierInterval - nSelectionInterval;
+    const CBlockIndex* pindex = pindexPrev;
+    while (pindex && pindex->GetBlockTime() >= nSelectionIntervalStart)
+    {
+        vSortedByTimestamp.push_back(make_pair(pindex->GetBlockTime(), pindex->GetBlockHash()));
+        pindex = pindex->pprev;
+    }
+    int nHeightFirstCandidate = pindex ? (pindex->nHeight + 1) : 0;
+    reverse(vSortedByTimestamp.begin(), vSortedByTimestamp.end());
+    sort(vSortedByTimestamp.begin(), vSortedByTimestamp.end());
+
+    // Select 64 blocks from candidate blocks to generate stake modifier
+    uint64_t nStakeModifierNew = 0;
+    int64_t nSelectionIntervalStop = nSelectionIntervalStart;
+    map<uint256, const CBlockIndex*> mapSelectedBlocks;
+    for (int nRound=0; nRound<min(64, (int)vSortedByTimestamp.size()); nRound++)
+    {
+        // add an interval section to the current selection round
+        nSelectionIntervalStop += GetStakeModifierSelectionIntervalSection(nRound);
+        // select a block from the candidates of current round
+        if (!SelectBlockFromCandidates(vSortedByTimestamp, mapSelectedBlocks, nSelectionIntervalStop, nStakeModifier, &pindex))
+            return error("ComputeNextStakeModifier: unable to select block at round %d", nRound);
+        // write the entropy bit of the selected block
+        nStakeModifierNew |= (((uint64_t)pindex->GetStakeEntropyBit()) << nRound);
+        // add the selected block from candidates to selected list
+        mapSelectedBlocks.insert(make_pair(pindex->GetBlockHash(), pindex));
+        LogPrintf("%s : selected round %d stop=%s height=%d bit=%d\n", __func__, nRound, DateTimeStrFormat("%Y-%m-%d %H:%M:%S", nSelectionIntervalStop).c_str(), pindex->nHeight, pindex->GetStakeEntropyBit());
+    }
+
+    // Print selection map for visualization of the selected blocks
+    if (GetBoolArg("-debug", false) && GetBoolArg("-printstakemodifier", false))
+    {
+        string strSelectionMap = "";
+        // '-' indicates proof-of-work blocks not selected
+        strSelectionMap.insert(0, pindexPrev->nHeight - nHeightFirstCandidate + 1, '-');
+        pindex = pindexPrev;
+        while (pindex && pindex->nHeight >= nHeightFirstCandidate)
+        {
+            // '=' indicates proof-of-stake blocks not selected
+            if (pindex->IsProofOfStake())
+                strSelectionMap.replace(pindex->nHeight - nHeightFirstCandidate, 1, "=");
+            pindex = pindex->pprev;
+        }
+        for (const auto& item : mapSelectedBlocks)
+        {
+            // 'S' indicates selected proof-of-stake blocks
+            // 'W' indicates selected proof-of-work blocks
+            strSelectionMap.replace(item.second->nHeight - nHeightFirstCandidate, 1, item.second->IsProofOfStake()? "S" : "W");
+        }
+        LogPrintf("ComputeNextStakeModifier: selection height [%d, %d] map %s\n", nHeightFirstCandidate, pindexPrev->nHeight, strSelectionMap);
+    }
+    LogPrintf("ComputeNextStakeModifier: new modifier=0x%016x time=%s\n", nStakeModifierNew, DateTimeStrFormat("%Y-%m-%d %H:%M:%S", pindexPrev->GetBlockTime()).c_str());
+
+    nStakeModifier = nStakeModifierNew;
+    fGeneratedStakeModifier = true;
+    return true;
+}
+
+static bool GetKernelStakeModifierV03(uint256 hashBlockFrom, unsigned int nTimeTx, uint64_t& nStakeModifier, int& nStakeModifierHeight, int64_t& nStakeModifierTime, bool fPrintProofOfStake)
+{
+    nStakeModifier = 0;
+    if (!mapBlockIndex.count(hashBlockFrom))
+        return error("GetKernelStakeModifier() : block not indexed");
+
+    const CBlockIndex* pindexFrom = mapBlockIndex[hashBlockFrom];
+    nStakeModifierHeight = pindexFrom->nHeight;
+    nStakeModifierTime = pindexFrom->GetBlockTime();
+    int64_t nStakeModifierSelectionInterval = GetStakeModifierSelectionInterval();
+    const CBlockIndex* pindex = pindexFrom;
+    CBlockIndex* pindexNext = chainActive[pindexFrom->nHeight + 1];
+
+    // loop to find the stake modifier later by a selection interval
+    while (nStakeModifierTime < pindexFrom->GetBlockTime() + nStakeModifierSelectionInterval) {
+        if (!pindexNext) {
+            // Should never happen
+            if(Params().NetworkIDString() == CBaseChainParams::TESTNET)
+            {
+                nStakeModifierHeight = pindexFrom->nHeight;
+                nStakeModifierTime = pindexFrom->GetBlockTime();
+                if(pindex->GeneratedStakeModifier())
+                    nStakeModifier = pindex->nStakeModifier;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        pindex = pindexNext;
+        pindexNext = chainActive[pindexNext->nHeight + 1];
+        if (pindex->GeneratedStakeModifier()) {
+            nStakeModifierHeight = pindex->nHeight;
+            nStakeModifierTime = pindex->GetBlockTime();
+        }
+    }
+    nStakeModifier = pindex->nStakeModifier;
+    return true;
+}
+
+// Get the stake modifier specified by the protocol to hash for a stake kernel
+static bool GetKernelStakeModifier(uint256 hashBlockFrom, unsigned int nTimeTx, uint64_t& nStakeModifier, int& nStakeModifierHeight, int64_t& nStakeModifierTime, bool fPrintProofOfStake)
+{
+    return GetKernelStakeModifierV03(hashBlockFrom, nTimeTx, nStakeModifier, nStakeModifierHeight, nStakeModifierTime, fPrintProofOfStake);
+}
+
+uint256 stakeHash(unsigned int nTimeTx, CDataStream ss, unsigned int prevoutIndex, uint256 prevoutHash, unsigned int nTimeBlockFrom)
+{
+    ss << nTimeBlockFrom << prevoutIndex << prevoutHash << nTimeTx;
+    return Hash(ss.begin(), ss.end());
+}
+
+bool CheckStakeKernelHash(unsigned int nBits, const CBlock& blockFrom, unsigned int nTxPrevOffset, const CTransactionRef& txPrev, const COutPoint& prevout, unsigned int nTimeTx, uint256& hashProofOfStake, bool fMinting, bool fValidate)
+{
+    auto txPrevTime = blockFrom.GetBlockTime();
+    if (nTimeTx < txPrevTime)  // Transaction timestamp violation
+        return error("CheckStakeKernelHash() : nTime violation");
+
+    auto nStakeMinAge = Params().GetConsensus().nStakeMinAge;
+    auto nStakeMaxAge = Params().GetConsensus().nStakeMaxAge;
+    unsigned int nTimeBlockFrom = blockFrom.GetBlockTime();
+    if (nTimeBlockFrom + nStakeMinAge > nTimeTx) // Min age requirement
+        return error("CheckStakeKernelHash() : min age violation");
+
+    arith_uint256 bnTargetPerCoinDay;
+    bnTargetPerCoinDay.SetCompact(nBits);
+    CAmount nValueIn = txPrev->vout[prevout.n].nValue;
+
+    // stake input must be of a minimum value
+    if (nValueIn < COIN)
+        return error("CheckStakeKernelHash() : nValueIn is less than COIN (nValueIn=%llu)", nValueIn);
+
+    // v0.3 protocol kernel hash weight starts from 0 at the 30-day min age
+    // this change increases active coins participating the hash and helps
+    // to secure the network when proof-of-stake difficulty is low
+    int64_t nTimeWeight = std::min<int64_t>(nTimeTx - txPrevTime, nStakeMaxAge - nStakeMinAge);
+    arith_uint256 bnCoinDayWeight = nValueIn * nTimeWeight / COIN / 200;
+
+    // Calculate hash
+    CDataStream ss(SER_GETHASH, 0);
+    uint64_t nStakeModifier = 0;
+    int nStakeModifierHeight = 0;
+    int64_t nStakeModifierTime = 0;
+
+    if (!GetKernelStakeModifier(blockFrom.GetHash(), nTimeTx, nStakeModifier, nStakeModifierHeight, nStakeModifierTime, false))
+        return false;
+    ss << nStakeModifier;
+    ss << nTimeBlockFrom << nTxPrevOffset << txPrevTime << prevout.n << nTimeTx;
+    hashProofOfStake = Hash(ss.begin(), ss.end());
+
+    // Now check if proof-of-stake hash meets target protocol
+    if (UintToArith256(hashProofOfStake) > bnCoinDayWeight * bnTargetPerCoinDay)
+        return false;
+
+    return true;
+}
+
+bool CheckKernelScript(CScript scriptVin, CScript scriptVout)
+{
+    auto extractKeyID = [](CScript scriptPubKey) {
+
+        std::vector<std::vector<unsigned char>> vSolutions;
+        txnouttype whichType;
+
+        CKeyID keyID;
+        if (Solver(scriptPubKey, whichType, vSolutions))
+        {
+            if (whichType == TX_PUBKEYHASH)
+            {
+                keyID = CKeyID(uint160(vSolutions[0]));
+            }
+            else if(whichType == TX_PUBKEY)
+            {
+                keyID = CPubKey(vSolutions[0]).GetID();
+            }
+        }
+
+        return keyID;
+    };
+
+    return extractKeyID(scriptVin) == extractKeyID(scriptVout);
+}
+
+// Check kernel hash target and coinstake signature
+bool CheckProofOfStake(const CBlock &block, uint256& hashProofOfStake)
+{
+    const CTransactionRef &tx = block.vtx[1];
+    if (!tx->IsCoinStake())
+        return error("CheckProofOfStake() : called on non-coinstake %s", tx->GetHash().ToString().c_str());
+
+    // Kernel (input 0) must match the stake hash target per coin age (nBits)
+    const CTxIn& txin = tx->vin[0];
+
+    // First try finding the previous transaction in database
+    uint256 hashBlock;
+    CTransactionRef txPrev;
+
+    const auto &cons = Params().GetConsensus();
+
+    if (!GetTransaction(txin.prevout.hash, txPrev, cons, hashBlock, true))
+        return error("CheckProofOfStake() : INFO: read txPrev failed");
+
+    CTxOut prevTxOut = txPrev->vout[txin.prevout.n];
+    CBlockIndex* pindex = NULL;
+    BlockMap::iterator it = mapBlockIndex.find(hashBlock);
+    if (it != mapBlockIndex.end())
+        pindex = it->second;
+    else
+        return error("CheckProofOfStake() : read block failed");
+
+    // Read block header
+    CBlock blockprev;
+    if (!ReadBlockFromDisk(blockprev, pindex->GetBlockPos(), cons))
+        return error("CheckProofOfStake(): INFO: failed to find block");
+
+    if(!CheckKernelScript(prevTxOut.scriptPubKey, tx->vout[1].scriptPubKey))
+        return error("CheckProofOfStake() : INFO: check kernel script failed on coinstake %s, hashProof=%s \n", tx->GetHash().ToString().c_str(), hashProofOfStake.ToString().c_str());
+
+    unsigned int nTime = block.nTime;
+    if (!CheckStakeKernelHash(block.nBits, blockprev, sizeof(CBlock), txPrev, txin.prevout, nTime, hashProofOfStake, false, true))
+        return error("CheckProofOfStake() : INFO: check kernel failed on coinstake %s, hashProof=%s \n", tx->GetHash().ToString().c_str(), hashProofOfStake.ToString().c_str()); // may occur during initial download or if behind on block chain sync
+
+    return true;
+}
+
+// Get stake modifier checksum
+unsigned int GetStakeModifierChecksum(const CBlockIndex* pindex)
+{
+    assert (pindex->pprev || pindex->GetBlockHash() == Params().GetConsensus().hashGenesisBlock);
+    // Hash previous checksum with flags, hashProofOfStake and nStakeModifier
+    CDataStream ss(SER_GETHASH, 0);
+    if (pindex->pprev)
+        ss << pindex->pprev->nStakeModifierChecksum;
+    ss << pindex->nFlags << pindex->hashProofOfStake << pindex->nStakeModifier;
+    arith_uint256 hashChecksum = UintToArith256(Hash(ss.begin(), ss.end()));
+    hashChecksum >>= (256 - 32);
+    return hashChecksum.GetLow64();
+}
+
+// Check stake modifier hard checkpoints
+bool CheckStakeModifierCheckpoints(int nHeight, unsigned int nStakeModifierChecksum)
+{
+    if (mapStakeModifierCheckpoints.count(nHeight))
+        return nStakeModifierChecksum == mapStakeModifierCheckpoints[nHeight];
+    return true;
+}
diff --git a/src/kernel.h b/src/kernel.h
new file mode 100644
index 0000000000000..00b722180ac50
--- /dev/null
+++ b/src/kernel.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2012-2013 The PPCoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_KERNEL_H
+#define BITCOIN_KERNEL_H
+
+#include <uint256.h>
+#include <streams.h>
+#include <arith_uint256.h>
+#include <primitives/transaction.h>
+
+class CBlock;
+class CWallet;
+class COutPoint;
+class CBlockIndex;
+
+// MODIFIER_INTERVAL: time to elapse before new modifier is computed
+static const unsigned int MODIFIER_INTERVAL = 60;
+static const unsigned int MODIFIER_INTERVAL_TESTNET = 20;
+extern unsigned int nModifierInterval;
+extern unsigned int getIntervalVersion(bool fTestNet);
+
+// MODIFIER_INTERVAL_RATIO:
+// ratio of group interval length between the last group and the first group
+static const int MODIFIER_INTERVAL_RATIO = 3;
+
+// Compute the hash modifier for proof-of-stake
+bool ComputeNextStakeModifier(const CBlockIndex* pindexPrev, uint64_t& nStakeModifier, bool& fGeneratedStakeModifier);
+
+// Check whether stake kernel meets hash target
+// Sets hashProofOfStake on success return
+bool CheckStakeKernelHash(unsigned int nBits, const CBlock& blockFrom, unsigned int nTxPrevOffset,
+                          const CTransactionRef& txPrev, const COutPoint& prevout, unsigned int nTimeTx,
+                          uint256& hashProofOfStake, bool fMinting = true, bool fValidate = true);
+
+// wrapper for checkstakekernelhash (bitcoin routine) for traditional method
+bool CheckStake(unsigned int nBits, const CBlock blockFrom, const CTransaction txPrev, const COutPoint prevout, unsigned int& nTimeTx, unsigned int nHashDrift, bool fCheck, uint256& hashProofOfStake, bool fPrintProofOfStake);
+
+// Check kernel hash target and coinstake signature
+// Sets hashProofOfStake on success return
+bool CheckProofOfStake(const CBlock &block, uint256& hashProofOfStake);
+
+// Get stake modifier checksum
+unsigned int GetStakeModifierChecksum(const CBlockIndex* pindex);
+
+// Check stake modifier hard checkpoints
+bool CheckStakeModifierCheckpoints(int nHeight, unsigned int nStakeModifierChecksum);
+
+#endif // BITCOIN_KERNEL_H
diff --git a/src/masternode-payments.cpp b/src/masternode-payments.cpp
index d71b15df7cacd..37341475925d9 100644
--- a/src/masternode-payments.cpp
+++ b/src/masternode-payments.cpp
@@ -82,6 +82,9 @@ bool IsBlockValueValid(const CBlock& block, int nBlockHeight, CAmount blockRewar
 
     strErrorRet = "";
 
+    bool isProofOfStake = !block.IsProofOfWork();
+    const auto& coinbaseTransaction = block.vtx[isProofOfStake];
+
     if (nBlockHeight < consensusParams.nBudgetPaymentsStartBlock) {
         // old budget system is not activated yet, just make sure we do not exceed the regular block reward
         if(!isBlockRewardValueMet) {
@@ -229,10 +232,12 @@ void FillBlockPayments(CMutableTransaction& txNew, int nBlockHeight, CAmount blo
     txNew.vout.insert(txNew.vout.end(), voutMasternodePaymentsRet.begin(), voutMasternodePaymentsRet.end());
     txNew.vout.insert(txNew.vout.end(), voutSuperblockPaymentsRet.begin(), voutSuperblockPaymentsRet.end());
 
+    // done this way to be capable of pow/mn & pos/mn if desired
     std::string voutMasternodeStr;
+    bool IsProofOfStake = nBlockHeight > Params().GetConsensus().nLastPoWBlock ? true : false;
     for (const auto& txout : voutMasternodePaymentsRet) {
         // subtract MN payment from miner reward
-        txNew.vout[0].nValue -= txout.nValue;
+        txNew.vout[IsProofOfStake].nValue -= txout.nValue;
         if (!voutMasternodeStr.empty())
             voutMasternodeStr += ",";
         voutMasternodeStr += txout.ToString();
diff --git a/src/masternode-payments.h b/src/masternode-payments.h
index db6a7fd010148..9c1b9746593c8 100644
--- a/src/masternode-payments.h
+++ b/src/masternode-payments.h
@@ -14,14 +14,17 @@
 #include "evo/deterministicmns.h"
 
 class CMasternodePayments;
+extern CMasternodePayments mnpayments;
 
 /// TODO: all 4 functions do not belong here really, they should be refactored/moved somewhere (main.cpp ?)
 bool IsBlockValueValid(const CBlock& block, int nBlockHeight, CAmount blockReward, std::string& strErrorRet);
 bool IsBlockPayeeValid(const CTransaction& txNew, int nBlockHeight, CAmount blockReward);
-void FillBlockPayments(CMutableTransaction& txNew, int nBlockHeight, CAmount blockReward, std::vector<CTxOut>& voutMasternodePaymentsRet, std::vector<CTxOut>& voutSuperblockPaymentsRet);
+void FillBlockPayments(CMutableTransaction& txNew, int nBlockHeight, CAmount blockReward, std::vector<CTxOut>& txoutMasternodeRet, std::vector<CTxOut>& voutSuperblockRet);
 std::map<int, std::string> GetRequiredPaymentsStrings(int nStartHeight, int nEndHeight);
 
-extern CMasternodePayments mnpayments;
+
+
+
 
 //
 // Masternode Payments Class
@@ -34,7 +37,6 @@ class CMasternodePayments
     bool GetBlockTxOuts(int nBlockHeight, CAmount blockReward, std::vector<CTxOut>& voutMasternodePaymentsRet) const;
     bool IsTransactionValid(const CTransaction& txNew, int nBlockHeight, CAmount blockReward) const;
     bool IsScheduled(const CDeterministicMNCPtr& dmn, int nNotBlockHeight) const;
-
     bool GetMasternodeTxOuts(int nBlockHeight, CAmount blockReward, std::vector<CTxOut>& voutMasternodePaymentsRet) const;
 };
 
diff --git a/src/miner.cpp b/src/miner.cpp
index db456b624895c..7cd409b0945a1 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -7,6 +7,7 @@
 #include "miner.h"
 
 #include "amount.h"
+#include "blocksigner.h"
 #include "chain.h"
 #include "chainparams.h"
 #include "coins.h"
@@ -27,6 +28,7 @@
 #include "masternode-payments.h"
 #include "masternode-sync.h"
 #include "validationinterface.h"
+#include "wallet/wallet.h"
 
 #include "evo/specialtx.h"
 #include "evo/cbtx.h"
@@ -55,6 +57,8 @@
 
 uint64_t nLastBlockTx = 0;
 uint64_t nLastBlockSize = 0;
+uint64_t nLastBlockWeight = 0;
+int64_t nLastCoinStakeSearchInterval = 0;
 
 class ScoreCompare
 {
@@ -75,10 +79,6 @@ int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParam
     if (nOldTime < nNewTime)
         pblock->nTime = nNewTime;
 
-    // Updating time can change work required on testnet:
-    if (consensusParams.fPowAllowMinDifficultyBlocks)
-        pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
-
     return nNewTime - nOldTime;
 }
 
@@ -112,7 +112,11 @@ static BlockAssembler::Options DefaultOptions(const CChainParams& params)
     return options;
 }
 
-BlockAssembler::BlockAssembler(const CChainParams& params) : BlockAssembler(params, DefaultOptions(params)) {}
+BlockAssembler::BlockAssembler(const CChainParams& params) :
+    BlockAssembler(params, DefaultOptions(params))
+{
+    nLastCoinStakeSearchInterval = GetAdjustedTime();
+}
 
 void BlockAssembler::resetBlock()
 {
@@ -127,7 +131,7 @@ void BlockAssembler::resetBlock()
     nFees = 0;
 }
 
-std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
+std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn, bool fProofOfStake)
 {
     int64_t nTimeStart = GetTimeMicros();
 
@@ -194,12 +198,38 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     coinbaseTx.vin[0].prevout.SetNull();
     coinbaseTx.vout.resize(1);
     coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
+    CAmount blockReward = GetBlockSubsidy(pindexPrev->nHeight, Params().GetConsensus());
+    std::vector<const CWalletTx*> vwtxPrev;
+    if(fProofOfStake)
+    {
+        assert(pwalletMain);
+        boost::this_thread::interruption_point();
+        pblock->nBits = GetNextWorkRequired(pindexPrev, chainparams.GetConsensus(), fProofOfStake);
+        CMutableTransaction coinstakeTx;
+        int64_t nSearchTime = pblock->nTime; // search to current time
+        bool fStakeFound = false;
+        if (nSearchTime >= nLastCoinStakeSearchTime) {
+            unsigned int nTxNewTime = 0;
+            if (pwalletMain->CreateCoinStake(*pwalletMain, pblock->nBits, blockReward, coinstakeTx, nTxNewTime, vwtxPrev))
+            {
+                pblock->nTime = nTxNewTime;
+                coinbaseTx.vout[0].SetEmpty();
+                pblock->vtx.emplace_back(MakeTransactionRef(coinstakeTx));
+
+                fStakeFound = true;
+            }
 
-    // NOTE: unlike in bitcoin, we need to pass PREVIOUS block height here
-    CAmount blockReward = nFees + GetBlockSubsidy(pindexPrev->nBits, pindexPrev->nHeight, Params().GetConsensus());
+            nLastCoinStakeSearchInterval = nSearchTime - nLastCoinStakeSearchTime;
+            nLastCoinStakeSearchTime = nSearchTime;
+        }
 
-    // Compute regular coinbase transaction.
-    coinbaseTx.vout[0].nValue = blockReward;
+        if (!fStakeFound)
+            return nullptr;
+    }
+    else
+    {
+        coinbaseTx.vout[0].nValue = blockReward;
+    }
 
     if (!fDIP0003Active_context) {
         coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
@@ -234,17 +264,19 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     // Update coinbase transaction with additional info about masternode and governance payments,
     // get some info back to pass to getblocktemplate
-    FillBlockPayments(coinbaseTx, nHeight, blockReward, pblocktemplate->voutMasternodePayments, pblocktemplate->voutSuperblockPayments);
+    // FillBlockPayments(coinbaseTx, nHeight, blockReward, pblocktemplate->voutMasternodePayments, pblocktemplate->voutSuperblockPayments);
     // LogPrintf("CreateNewBlock -- nBlockHeight %d blockReward %lld txoutMasternode %s coinbaseTx %s",
     //             nHeight, blockReward, pblocktemplate->txoutsMasternode.ToString(), coinbaseTx.ToString());
 
+    coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
     pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
     pblocktemplate->vTxFees[0] = -nFees;
 
     // Fill in header
     pblock->hashPrevBlock  = pindexPrev->GetBlockHash();
-    UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
-    pblock->nBits          = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
+    if(!fProofOfStake)
+        UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
+    pblock->nBits          = GetNextWorkRequired(pindexPrev, chainparams.GetConsensus(), fProofOfStake);
     pblock->nNonce         = 0;
     pblocktemplate->nPrevBits = pindexPrev->nBits;
     pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(*pblock->vtx[0]);
@@ -528,3 +560,218 @@ void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned
     pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
     pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
 }
+
+static bool ProcessBlockFound(const std::shared_ptr<const CBlock> &pblock, const CChainParams& chainparams)
+{
+    LogPrintf("%s\n", pblock->ToString());
+    LogPrintf("generated %s\n", FormatMoney(pblock->vtx[0]->vout[0].nValue));
+
+    // Found a solution
+    {
+        LOCK(cs_main);
+        if (pblock->hashPrevBlock != chainActive.Tip()->GetBlockHash())
+            return error("ProcessBlockFound -- generated block is stale");
+    }
+
+    // Inform about the new block
+    // GetMainSignals().BlockFound(pblock->GetHash());
+
+    // Process this block the same as if we had received it from another node
+    if (!ProcessNewBlock(chainparams, pblock, true, nullptr))
+        return error("ProcessBlockFound -- ProcessNewBlock() failed, block not accepted");
+
+    return true;
+}
+
+void static BitcoinMiner(const CChainParams& chainparams, CConnman& connman, CWallet* pwallet, bool fProofOfStake)
+{
+    LogPrintf("bitcoinminer -- started\n");
+    SetThreadPriority(THREAD_PRIORITY_LOWEST);
+    RenameThread("bitcoin-miner");
+
+    unsigned int nExtraNonce = 0;
+    std::shared_ptr<CReserveScript> coinbaseScript;
+    pwallet->GetScriptForMining(coinbaseScript);
+
+    while (true) {
+        try {
+
+            MilliSleep(1000);
+
+            // Throw an error if no script was provided.  This can happen
+            // due to some internal error but also if the keypool is empty.
+            // In the latter case, already the pointer is NULL.
+            if (!coinbaseScript || coinbaseScript->reserveScript.empty())
+                throw std::runtime_error("No coinbase script available (mining requires a wallet)");
+
+            do {
+                if (!chainparams.MiningRequiresPeers())
+                    break;
+                bool fvNodesEmpty = connman.GetNodeCount(CConnman::CONNECTIONS_ALL) == 0;
+                if (!fvNodesEmpty && !IsInitialBlockDownload() && masternodeSync.IsSynced())
+                    break;
+                MilliSleep(1000);
+            } while (true);
+
+            if(fProofOfStake)
+            {
+                if (chainActive.Tip()->nHeight+1 < chainparams.GetConsensus().nLastPoWBlock ||
+                    pwallet->IsLocked() || !masternodeSync.IsSynced())
+                {
+                    nLastCoinStakeSearchInterval = 0;
+                    MilliSleep(5000);
+                    continue;
+                }
+            }
+
+            if(!fProofOfStake && chainActive.Tip()->nHeight >= chainparams.GetConsensus().nLastPoWBlock)
+                return;
+
+            //
+            // Create new block
+            //
+            unsigned int nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
+            CBlockIndex* pindexPrev = chainActive.Tip();
+            if(!pindexPrev) break;
+
+            BlockAssembler assembler(chainparams);
+            auto pblocktemplate = assembler.CreateNewBlock(coinbaseScript->reserveScript, fProofOfStake);
+            if (!pblocktemplate.get())
+            {
+                LogPrintf("bitcoinminer -- Failed to find a coinstake\n");
+                MilliSleep(5000);
+                continue;
+            }
+            auto pblock = std::make_shared<CBlock>(pblocktemplate->block);
+            IncrementExtraNonce(pblock.get(), pindexPrev, nExtraNonce);
+
+            LogPrintf("BitcoinMiner -- Running miner with %u transactions in block (%u bytes)\n", pblock->vtx.size(),
+                      ::GetSerializeSize(*pblock, SER_NETWORK, PROTOCOL_VERSION));
+
+            //Sign block
+            if (fProofOfStake)
+            {
+                LogPrintf("CPUMiner : proof-of-stake block found %s \n", pblock->GetHash().ToString().c_str());
+
+                if (!SignBlock(*pblock, *pwallet)) {
+                    LogPrintf("BitcoinMiner(): Signing new block failed \n");
+                    throw std::runtime_error(strprintf("%s: SignBlock failed", __func__));
+                }
+
+                LogPrintf("CPUMiner : proof-of-stake block was signed %s \n", pblock->GetHash().ToString().c_str());
+            }
+
+            // check if block is valid
+            CValidationState state;
+            if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
+                throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state)));
+            }
+
+            // process proof of stake block
+            if(fProofOfStake) {
+                SetThreadPriority(THREAD_PRIORITY_NORMAL);
+                ProcessBlockFound(pblock, chainparams);
+                SetThreadPriority(THREAD_PRIORITY_LOWEST);
+                MilliSleep(10000);
+                continue;
+            }
+
+            //
+            // Search
+            //
+            int64_t nStart = GetTime();
+            arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
+            while (true)
+            {
+                unsigned int nHashesDone = 0;
+
+                uint256 hash;
+                while (true)
+                {
+                    hash = pblock->GetHash();
+                    if (UintToArith256(hash) <= hashTarget)
+                    {
+                        // Found a solution
+                        SetThreadPriority(THREAD_PRIORITY_NORMAL);
+                        LogPrintf("bitcoinminer:\n  proof-of-work found\n  hash: %s\n  target: %s\n", hash.GetHex(), hashTarget.GetHex());
+                        ProcessBlockFound(pblock, chainparams);
+                        SetThreadPriority(THREAD_PRIORITY_LOWEST);
+                        coinbaseScript->KeepScript();
+                        break;
+                    }
+                    pblock->nNonce += 1;
+                    nHashesDone += 1;
+                    if ((pblock->nNonce & 0xFF) == 0)
+                        break;
+                }
+
+                // Check for stop or if block needs to be rebuilt
+                boost::this_thread::interruption_point();
+                // Regtest mode doesn't require peers
+                if (connman.GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
+                    break;
+                if (pblock->nNonce >= 0xffff0000)
+                    break;
+                if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 60)
+                    break;
+                if (pindexPrev != chainActive.Tip())
+                    break;
+
+                // Update nTime every few seconds
+                if (UpdateTime(pblock.get(), chainparams.GetConsensus(), pindexPrev) < 0)
+                    break;
+            }
+        }
+        catch (const boost::thread_interrupted&)
+        {
+            LogPrintf("BitcoinMiner -- terminated\n");
+            throw;
+        }
+        catch (const std::runtime_error &e)
+        {
+            LogPrintf("bitcoinminer -- runtime error: %s\n", e.what());
+            //            return;
+        }
+    }
+}
+
+void GenerateBitcoins(bool fGenerate,
+                  int nThreads,
+                  const CChainParams& chainparams,
+                  CConnman &connman)
+{
+    static boost::thread_group* minerThreads = NULL;
+
+    if (nThreads < 0)
+        nThreads = GetNumCores();
+
+    if (minerThreads != NULL)
+    {
+        minerThreads->interrupt_all();
+        delete minerThreads;
+        minerThreads = NULL;
+    }
+
+    if (nThreads == 0 || !fGenerate)
+        return;
+
+    minerThreads = new boost::thread_group();
+    for (int i = 0; i < nThreads; i++)
+        minerThreads->create_thread(boost::bind(&BitcoinMiner, boost::cref(chainparams), boost::ref(connman), pwalletMain, false));
+}
+
+void ThreadStakeMinter(const CChainParams &chainparams, CConnman &connman)
+{
+    boost::this_thread::interruption_point();
+    LogPrintf("ThreadStakeMinter started\n");
+    try {
+        BitcoinMiner(chainparams, connman, pwalletMain, true);
+        boost::this_thread::interruption_point();
+    } catch (std::exception& e) {
+        LogPrintf("ThreadStakeMinter() exception %s\n", e.what());
+    } catch (...) {
+        LogPrintf("ThreadStakeMinter() error \n");
+    }
+    LogPrintf("ThreadStakeMinter exiting,\n");
+
+}
diff --git a/src/miner.h b/src/miner.h
index 995cce10c747a..e3d0dc68396aa 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -20,10 +20,12 @@ class CConnman;
 class CReserveKey;
 class CScript;
 class CWallet;
+class CWalletTx;
 
 namespace Consensus { struct Params; };
 
 static const bool DEFAULT_PRINTPRIORITY = false;
+extern int64_t nLastCoinStakeSearchInterval;
 
 struct CBlockTemplate
 {
@@ -158,6 +160,9 @@ class BlockAssembler
     int64_t nLockTimeCutoff;
     const CChainParams& chainparams;
 
+    // Stake info
+    int64_t nLastCoinStakeSearchTime = 0;
+
 public:
     struct Options {
         Options();
@@ -169,7 +174,7 @@ class BlockAssembler
     BlockAssembler(const CChainParams& params, const Options& options);
 
     /** Construct a new block template with coinbase to scriptPubKeyIn */
-    std::unique_ptr<CBlockTemplate> CreateNewBlock(const CScript& scriptPubKeyIn);
+    std::unique_ptr<CBlockTemplate> CreateNewBlock(const CScript& scriptPubKeyIn, bool fProofOfStake);
 
 private:
     // utility functions
@@ -209,4 +214,8 @@ class BlockAssembler
 void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev);
 
+/** Run the miner threads */
+void GenerateBitcoins(bool fGenerate, int nThreads, const CChainParams& chainparams, CConnman &connman);
+void ThreadStakeMinter(const CChainParams& chainparams, CConnman &connman);
+
 #endif // BITCOIN_MINER_H
diff --git a/src/pow.cpp b/src/pow.cpp
index 7e55e3d39c517..beadbb68d316a 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -13,6 +13,141 @@
 
 #include <math.h>
 
+const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake)
+{
+    while (pindex && pindex->pprev && (pindex->IsProofOfStake() != fProofOfStake))
+        pindex = pindex->pprev;
+    return pindex;
+}
+
+unsigned int DualKGW3(const CBlockIndex* pindexLast, const Consensus::Params& params)
+{
+    const CBlockIndex* BlockLastSolved = GetLastBlockIndex(pindexLast, false);
+    const CBlockIndex* BlockReading = GetLastBlockIndex(pindexLast, false);
+    int64_t PastBlocksMass = 0;
+    int64_t PastRateActualSeconds = 0;
+    int64_t PastRateTargetSeconds = 0;
+    double PastRateAdjustmentRatio = double(1);
+    arith_uint256 PastDifficultyAverage;
+    arith_uint256 PastDifficultyAveragePrev;
+    double EventHorizonDeviation;
+    double EventHorizonDeviationFast;
+    double EventHorizonDeviationSlow;
+    static const int64_t Blocktime = params.nPowTargetSpacing;
+    static const unsigned int timeDaySeconds = 86400;
+    uint64_t pastSecondsMin = timeDaySeconds * 0.025;
+    uint64_t pastSecondsMax = timeDaySeconds * 7;
+    uint64_t PastBlocksMin = pastSecondsMin / Blocktime;
+    uint64_t PastBlocksMax = pastSecondsMax / Blocktime;
+    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
+
+    if (BlockLastSolved == NULL || BlockLastSolved->nHeight == 0 ||
+            (uint64_t)BlockLastSolved->nHeight < PastBlocksMin)
+        return bnPowLimit.GetCompact();
+
+    for (unsigned int i = 1; BlockReading && BlockReading->nHeight > 0; i++) {
+        if (PastBlocksMax > 0 && i > PastBlocksMax) break;
+        PastBlocksMass++;
+        PastDifficultyAverage.SetCompact(BlockReading->nBits);
+        if (i > 1) {
+            if (PastDifficultyAverage >= PastDifficultyAveragePrev)
+                PastDifficultyAverage =
+                        ((PastDifficultyAverage - PastDifficultyAveragePrev) / i) +
+                        PastDifficultyAveragePrev;
+            else
+                PastDifficultyAverage =
+                        PastDifficultyAveragePrev -
+                        ((PastDifficultyAveragePrev - PastDifficultyAverage) / i);
+        }
+        PastDifficultyAveragePrev = PastDifficultyAverage;
+        PastRateActualSeconds =
+                BlockLastSolved->GetBlockTime() - BlockReading->GetBlockTime();
+        PastRateTargetSeconds = Blocktime * PastBlocksMass;
+        PastRateAdjustmentRatio = double(1);
+        if (PastRateActualSeconds < 0) PastRateActualSeconds = 0;
+        if (PastRateActualSeconds != 0 && PastRateTargetSeconds != 0)
+            PastRateAdjustmentRatio =
+                    double(PastRateTargetSeconds) / double(PastRateActualSeconds);
+        EventHorizonDeviation =
+                1 + (0.7084 * pow((double(PastBlocksMass) / double(72)), -1.228));
+        EventHorizonDeviationFast = EventHorizonDeviation;
+        EventHorizonDeviationSlow = 1 / EventHorizonDeviation;
+
+        if (PastBlocksMass >= PastBlocksMin) {
+            if ((PastRateAdjustmentRatio <= EventHorizonDeviationSlow) ||
+                    (PastRateAdjustmentRatio >= EventHorizonDeviationFast)) {
+                assert(BlockReading);
+                break;
+            }
+        }
+        if (BlockReading->pprev == NULL) {
+            assert(BlockReading);
+            break;
+        }
+        BlockReading = BlockReading->pprev;
+    }
+
+    arith_uint256 kgw_dual1(PastDifficultyAverage);
+    arith_uint256 kgw_dual2;
+    kgw_dual2.SetCompact(pindexLast->nBits);
+    if (PastRateActualSeconds != 0 && PastRateTargetSeconds != 0) {
+        kgw_dual1 *= PastRateActualSeconds;
+        kgw_dual1 /= PastRateTargetSeconds;
+    }
+    int64_t nActualTime1 =
+            pindexLast->GetBlockTime() - pindexLast->pprev->GetBlockTime();
+    int64_t nActualTimespanshort = nActualTime1;
+
+    if (nActualTime1 < 0) nActualTime1 = Blocktime;
+    if (nActualTime1 < Blocktime / 3) nActualTime1 = Blocktime / 3;
+    if (nActualTime1 > Blocktime * 3) nActualTime1 = Blocktime * 3;
+    kgw_dual2 *= nActualTime1;
+    kgw_dual2 /= Blocktime;
+    arith_uint256 bnNew;
+    bnNew = ((kgw_dual2 + kgw_dual1) / 2);
+
+    if (nActualTimespanshort < Blocktime / 6) {
+        const int nLongShortNew1 = 85;
+        const int nLongShortNew2 = 100;
+        bnNew = bnNew * nLongShortNew1;
+        bnNew = bnNew / nLongShortNew2;
+    }
+
+    if (bnNew > bnPowLimit) bnNew = bnPowLimit;
+
+    return bnNew.GetCompact();
+}
+
+unsigned int PoSWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params)
+{
+    const CBlockIndex* LastPoSBlock = GetLastBlockIndex(pindexLast, true);
+    const arith_uint256 bnPosLimit = UintToArith256(params.posLimit);
+    int64_t nTargetSpacing = Params().GetConsensus().nPosTargetSpacing;
+    int64_t nTargetTimespan = Params().GetConsensus().nPosTargetTimespan;
+
+    int64_t nActualSpacing = 0;
+    if (LastPoSBlock->nHeight != 0)
+        nActualSpacing = LastPoSBlock->GetBlockTime() - LastPoSBlock->pprev->GetBlockTime();
+
+    if (nActualSpacing < 0)
+        nActualSpacing = 1;
+
+    // ppcoin: target change every block
+    // ppcoin: retarget with exponential moving toward target spacing
+    arith_uint256 bnNew;
+    bnNew.SetCompact(LastPoSBlock->nBits);
+
+    int64_t nInterval = nTargetTimespan / nTargetSpacing;
+    bnNew *= ((nInterval - 1) * nTargetSpacing + nActualSpacing + nActualSpacing);
+    bnNew /= ((nInterval + 1) * nTargetSpacing);
+
+    if (bnNew <= 0 || bnNew > bnPosLimit)
+        bnNew = bnPosLimit;
+
+    return bnNew.GetCompact();
+}
+
+
 unsigned int static KimotoGravityWell(const CBlockIndex* pindexLast, const Consensus::Params& params) {
     const CBlockIndex *BlockLastSolved = pindexLast;
     const CBlockIndex *BlockReading = pindexLast;
@@ -79,7 +214,7 @@ unsigned int static KimotoGravityWell(const CBlockIndex* pindexLast, const Conse
     return bnNew.GetCompact();
 }
 
-unsigned int static DarkGravityWave(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params) {
+unsigned int static DarkGravityWave(const CBlockIndex* pindexLast, const Consensus::Params& params) {
     /* current difficulty formula, dash - DarkGravity v3, written by Evan Duffield - evan@dash.org */
     const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
     int64_t nPastBlocks = 24;
@@ -89,21 +224,6 @@ unsigned int static DarkGravityWave(const CBlockIndex* pindexLast, const CBlockH
         return bnPowLimit.GetCompact();
     }
 
-    if (params.fPowAllowMinDifficultyBlocks) {
-        // recent block is more than 2 hours old
-        if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + 2 * 60 * 60) {
-            return bnPowLimit.GetCompact();
-        }
-        // recent block is more than 10 minutes old
-        if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nPowTargetSpacing * 4) {
-            arith_uint256 bnNew = arith_uint256().SetCompact(pindexLast->nBits) * 10;
-            if (bnNew > bnPowLimit) {
-                bnNew = bnPowLimit;
-            }
-            return bnNew.GetCompact();
-        }
-    }
-
     const CBlockIndex *pindex = pindexLast;
     arith_uint256 bnPastTargetAvg;
 
@@ -144,30 +264,13 @@ unsigned int static DarkGravityWave(const CBlockIndex* pindexLast, const CBlockH
     return bnNew.GetCompact();
 }
 
-unsigned int GetNextWorkRequiredBTC(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
+unsigned int GetNextWorkRequiredBTC(const CBlockIndex* pindexLast, const Consensus::Params& params)
 {
     assert(pindexLast != NULL);
     unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
 
     // Only change once per interval
-    if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
-    {
-        if (params.fPowAllowMinDifficultyBlocks)
-        {
-            // Special difficulty rule for testnet:
-            // If the new block's timestamp is more than 2* 2.5 minutes
-            // then allow mining of a min-difficulty block.
-            if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nPowTargetSpacing*2)
-                return nProofOfWorkLimit;
-            else
-            {
-                // Return the last non-special-min-difficulty-rules-block
-                const CBlockIndex* pindex = pindexLast;
-                while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
-                    pindex = pindex->pprev;
-                return pindex->nBits;
-            }
-        }
+    if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0) {
         return pindexLast->nBits;
     }
 
@@ -180,24 +283,14 @@ unsigned int GetNextWorkRequiredBTC(const CBlockIndex* pindexLast, const CBlockH
    return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
 }
 
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params, bool fProofOfStake)
 {
-    // this is only active on devnets
-    if (pindexLast->nHeight < params.nMinimumDifficultyBlocks) {
-        unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
-        return nProofOfWorkLimit;
-    }
-
-    // Most recent algo first
-    if (pindexLast->nHeight + 1 >= params.nPowDGWHeight) {
-        return DarkGravityWave(pindexLast, pblock, params);
-    }
-    else if (pindexLast->nHeight + 1 >= params.nPowKGWHeight) {
-        return KimotoGravityWell(pindexLast, params);
-    }
-    else {
-        return GetNextWorkRequiredBTC(pindexLast, pblock, params);
-    }
+    unsigned int nBits = UintToArith256(params.powLimit).GetCompact();
+    if(fProofOfStake)
+        nBits = PoSWorkRequired(pindexLast, params);
+    else
+        nBits = DualKGW3(pindexLast, params);
+    return nBits;
 }
 
 // for DIFF_BTC only!
diff --git a/src/pow.h b/src/pow.h
index 1f66b5c965e30..ef930be5daa80 100644
--- a/src/pow.h
+++ b/src/pow.h
@@ -14,10 +14,12 @@ class CBlockHeader;
 class CBlockIndex;
 class uint256;
 
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params&);
+const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
+unsigned int DualKGW3(const CBlockIndex* pindexLast, const Consensus::Params& params);
+unsigned int PoSWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params);
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params&, bool fProofOfStake = false);
 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params&);
 
-
 /** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
 bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&);
 
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index 6459d0e957be2..fde64f4f31d25 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -19,6 +19,16 @@ uint256 CBlockHeader::GetHash() const
     return HashX11((const char *)vch.data(), (const char *)vch.data() + vch.size());
 }
 
+bool CBlock::IsProofOfStake() const
+{
+    return (vtx.size() > 1 && vtx[1]->IsCoinStake());
+}
+
+bool CBlock::IsProofOfWork() const
+{
+    return !IsProofOfStake();
+}
+
 std::string CBlock::ToString() const
 {
     std::stringstream s;
diff --git a/src/primitives/block.h b/src/primitives/block.h
index dda9a9d609b75..fb05d2ba6bcd2 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -74,8 +74,11 @@ class CBlock : public CBlockHeader
 public:
     // network and disk
     std::vector<CTransactionRef> vtx;
+    std::vector<unsigned char> vchBlockSig;
 
     // memory only
+    mutable CTxOut txoutMasternode;
+    mutable std::vector<CTxOut> voutSuperblock;
     mutable bool fChecked;
 
     CBlock()
@@ -86,15 +89,19 @@ class CBlock : public CBlockHeader
     CBlock(const CBlockHeader &header)
     {
         SetNull();
-        *((CBlockHeader*)this) = header;
+        *(static_cast<CBlockHeader*>(this)) = header;
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(*(CBlockHeader*)this);
+        READWRITEAS(CBlockHeader, *this);
         READWRITE(vtx);
+        if(vtx.size() > 1 && vtx[1]->IsCoinStake())
+        {
+            READWRITE(vchBlockSig);
+        }
     }
 
     void SetNull()
@@ -102,6 +109,7 @@ class CBlock : public CBlockHeader
         CBlockHeader::SetNull();
         vtx.clear();
         fChecked = false;
+		    vchBlockSig.clear();
     }
 
     CBlockHeader GetBlockHeader() const
@@ -116,10 +124,12 @@ class CBlock : public CBlockHeader
         return block;
     }
 
+    bool IsProofOfStake() const;
+    bool IsProofOfWork() const;
+
     std::string ToString() const;
 };
 
-
 /** Describes a place in the block chain to another node such that if the
  * other node doesn't have the same branch, it can find a recent common trunk.
  * The further back it is, the further before the fork it may be.
@@ -130,10 +140,7 @@ struct CBlockLocator
 
     CBlockLocator() {}
 
-    CBlockLocator(const std::vector<uint256>& vHaveIn)
-    {
-        vHave = vHaveIn;
-    }
+    explicit CBlockLocator(const std::vector<uint256>& vHaveIn) : vHave(vHaveIn) {}
 
     ADD_SERIALIZE_METHODS;
 
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 76cdc3463a57d..ba62f645a2763 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -175,6 +175,17 @@ class CTxOut
         return (nValue == -1);
     }
 
+    void SetEmpty()
+    {
+        nValue = 0;
+        scriptPubKey.clear();
+    }
+
+    bool IsEmpty() const
+    {
+        return (nValue == 0 && scriptPubKey.empty());
+    }
+
     CAmount GetDustThreshold(const CFeeRate &minRelayTxFee) const
     {
         // "Dust" is defined in terms of CTransaction::minRelayTxFee, which has units duffs-per-kilobyte.
@@ -295,6 +306,12 @@ class CTransaction
         return (vin.size() == 1 && vin[0].prevout.IsNull());
     }
 
+    bool IsCoinStake() const
+    {
+        // ppcoin: the coin stake transaction is marked with the first output empty
+        return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
+    }
+
     friend bool operator==(const CTransaction& a, const CTransaction& b)
     {
         return a.hash == b.hash;
diff --git a/src/qt/askpassphrasedialog.cpp b/src/qt/askpassphrasedialog.cpp
index 2367c38f79d31..f91da8e517301 100644
--- a/src/qt/askpassphrasedialog.cpp
+++ b/src/qt/askpassphrasedialog.cpp
@@ -47,6 +47,7 @@ AskPassphraseDialog::AskPassphraseDialog(Mode _mode, QWidget *parent) :
             ui->warningLabel->setText(tr("Enter the new passphrase to the wallet.<br/>Please use a passphrase of <b>ten or more random characters</b>, or <b>eight or more words</b>."));
             ui->passLabel1->hide();
             ui->passEdit1->hide();
+            ui->stakingCheckBox->hide();
             setWindowTitle(tr("Encrypt wallet"));
             break;
         case UnlockMixing:
@@ -75,10 +76,12 @@ AskPassphraseDialog::AskPassphraseDialog(Mode _mode, QWidget *parent) :
             break;
         case ChangePass: // Ask old passphrase + new passphrase x2
             setWindowTitle(tr("Change passphrase"));
+            ui->stakingCheckBox->hide();
             ui->warningLabel->setText(tr("Enter the old passphrase and new passphrase to the wallet."));
             break;
     }
     textChanged();
+    connect(ui->toggleShowPasswordButton, SIGNAL(toggled(bool)), this, SLOT(toggleShowPassword(bool)));
     connect(ui->passEdit1, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
     connect(ui->passEdit2, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
     connect(ui->passEdit3, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
@@ -175,8 +178,9 @@ void AskPassphraseDialog::accept()
         }
         } break;
     case UnlockMixing:
+    case UnlockStaking:
     case Unlock:
-        if(!model->setWalletLocked(false, oldpass, mode == UnlockMixing))
+        if(!model->setWalletLocked(false, oldpass, mode == UnlockMixing || mode == UnlockStaking))
         {
             QMessageBox::critical(this, tr("Wallet unlock failed"),
                                   tr("The passphrase entered for the wallet decryption was incorrect."));
@@ -230,6 +234,7 @@ void AskPassphraseDialog::textChanged()
     case Encrypt: // New passphrase x2
         acceptable = !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
         break;
+    case UnlockStaking: // Old passphrase x1
     case UnlockMixing: // Old passphrase x1
     case Unlock: // Old passphrase x1
     case Decrypt:
diff --git a/src/qt/askpassphrasedialog.h b/src/qt/askpassphrasedialog.h
index fa02cad60bd70..7fc90200bbfd5 100644
--- a/src/qt/askpassphrasedialog.h
+++ b/src/qt/askpassphrasedialog.h
@@ -22,6 +22,7 @@ class AskPassphraseDialog : public QDialog
 public:
     enum Mode {
         Encrypt,    /**< Ask passphrase twice and encrypt */
+        UnlockStaking, /**< Ask passphrase and unlock for staking */
         UnlockMixing,     /**< Ask passphrase and unlock only for mixing */
         Unlock,     /**< Ask passphrase and unlock */
         ChangePass, /**< Ask old passphrase + new passphrase twice */
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 065ebf2e73622..d72f6028646c4 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -38,6 +38,7 @@
 #include "util.h"
 #include "masternode-sync.h"
 #include "masternodelist.h"
+#include "miner.h"
 
 #include <iostream>
 
@@ -207,6 +208,7 @@ BitcoinGUI::BitcoinGUI(const PlatformStyle *_platformStyle, const NetworkStyle *
     frameBlocksLayout->setContentsMargins(3,0,3,0);
     frameBlocksLayout->setSpacing(3);
     unitDisplayControl = new UnitDisplayStatusBarControl(platformStyle);
+    labelStakingIcon = new QLabel();
     labelWalletEncryptionIcon = new QLabel();
     labelWalletHDStatusIcon = new QLabel();
     labelConnectionsIcon = new GUIUtil::ClickableLabel();
@@ -217,6 +219,7 @@ BitcoinGUI::BitcoinGUI(const PlatformStyle *_platformStyle, const NetworkStyle *
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(unitDisplayControl);
         frameBlocksLayout->addStretch();
+        frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(labelWalletEncryptionIcon);
         frameBlocksLayout->addWidget(labelWalletHDStatusIcon);
     }
@@ -224,6 +227,7 @@ BitcoinGUI::BitcoinGUI(const PlatformStyle *_platformStyle, const NetworkStyle *
     frameBlocksLayout->addWidget(labelConnectionsIcon);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(labelBlocksIcon);
+    frameBlocksLayout->addWidget(labelStakingIcon);
     frameBlocksLayout->addStretch();
 
     // Progress bar and label for blocks download
@@ -266,6 +270,11 @@ BitcoinGUI::BitcoinGUI(const PlatformStyle *_platformStyle, const NetworkStyle *
         connect(progressBar, SIGNAL(clicked(QPoint)), this, SLOT(showModalOverlay()));
     }
 #endif
+
+    QTimer* timerStakingIcon = new QTimer(labelStakingIcon);
+    connect(timerStakingIcon, SIGNAL(timeout()), this, SLOT(setStakingStatus()));
+    timerStakingIcon->start(10000);
+    setStakingStatus();
 }
 
 BitcoinGUI::~BitcoinGUI()
@@ -1298,6 +1307,19 @@ void BitcoinGUI::setHDStatus(int hdEnabled)
     labelWalletHDStatusIcon->setEnabled(hdEnabled);
 }
 
+void BitcoinGUI::setStakingStatus()
+{
+    if (nLastCoinStakeSearchInterval) {
+        labelStakingIcon->show();
+        labelStakingIcon->setPixmap(QIcon(QString(":/icons/staking_active")).pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
+        labelStakingIcon->setToolTip(tr("Staking is active\n"));
+    } else {
+        labelStakingIcon->show();
+        labelStakingIcon->setPixmap(QIcon(QString(":/icons/staking_inactive")).pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
+        labelStakingIcon->setToolTip(tr("Staking is inactive\n"));
+    }
+}
+
 void BitcoinGUI::setEncryptionStatus(int status)
 {
     QString theme = GUIUtil::getThemeName();
@@ -1321,10 +1343,20 @@ void BitcoinGUI::setEncryptionStatus(int status)
         lockWalletAction->setVisible(true);
         encryptWalletAction->setEnabled(false); // TODO: decrypt currently not supported
         break;
+    case WalletModel::UnlockedForStakingOnly:
+        labelWalletEncryptionIcon->show();
+        labelWalletEncryptionIcon->setPixmap(platformStyle->SingleColorIcon(":/icons/lock_open").pixmap(STATUSBAR_ICONSIZE,STATUSBAR_ICONSIZE));
+        labelWalletEncryptionIcon->setToolTip(tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b> for staking only"));
+        encryptWalletAction->setChecked(true);
+        changePassphraseAction->setEnabled(true);
+        unlockWalletAction->setVisible(true);
+        lockWalletAction->setVisible(true);
+        encryptWalletAction->setEnabled(false);
+        break;
     case WalletModel::UnlockedForMixingOnly:
         labelWalletEncryptionIcon->show();
         labelWalletEncryptionIcon->setPixmap(QIcon(":/icons/" + theme + "/lock_open").pixmap(STATUSBAR_ICONSIZE,STATUSBAR_ICONSIZE));
-        labelWalletEncryptionIcon->setToolTip(tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b> for mixing only"));
+        labelWalletEncryptionIcon->setToolTip(tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b> for staking only"));
         encryptWalletAction->setChecked(true);
         changePassphraseAction->setEnabled(true);
         unlockWalletAction->setVisible(true);
diff --git a/src/qt/bitcoingui.h b/src/qt/bitcoingui.h
index e01da23c4e838..6ce6ab9765ec6 100644
--- a/src/qt/bitcoingui.h
+++ b/src/qt/bitcoingui.h
@@ -84,6 +84,7 @@ class BitcoinGUI : public QMainWindow
     WalletFrame *walletFrame;
 
     UnitDisplayStatusBarControl *unitDisplayControl;
+    QLabel* labelStakingIcon = nullptr;
     QLabel *labelWalletEncryptionIcon;
     QLabel *labelWalletHDStatusIcon;
     QLabel *labelConnectionsIcon;
@@ -191,6 +192,12 @@ public Q_SLOTS:
     void message(const QString &title, const QString &message, unsigned int style, bool *ret = NULL);
 
 #ifdef ENABLE_WALLET
+
+    /** Set the UI status indicators based on the currently selected wallet.
+    */
+    void setStakingStatus();
+
+private:
     /** Set the hd-enabled status as shown in the UI.
      @param[in] status            current hd enabled status
      @see WalletModel::EncryptionStatus
diff --git a/src/qt/dash.qrc b/src/qt/dash.qrc
index a5ee91da3a328..6e77bb89857e7 100644
--- a/src/qt/dash.qrc
+++ b/src/qt/dash.qrc
@@ -284,6 +284,10 @@
         <file alias="transaction_abandoned">res/icons/trad/transaction_abandoned.png</file>
         <file alias="network_disabled">res/icons/trad/network_disabled.png</file>
     </qresource>
+    <qresource prefix="/icons">
+        <file alias="staking_active">res/icons/staking_active.png</file>
+        <file alias="staking_inactive">res/icons/staking_inactive.png</file>
+    </qresource>
     <qresource prefix="/css">
         <file alias="drkblue">res/css/drkblue.css</file>
         <file alias="crownium">res/css/crownium.css</file>
diff --git a/src/qt/forms/askpassphrasedialog.ui b/src/qt/forms/askpassphrasedialog.ui
index a2105ecd0ae12..c54687fef451c 100644
--- a/src/qt/forms/askpassphrasedialog.ui
+++ b/src/qt/forms/askpassphrasedialog.ui
@@ -108,6 +108,78 @@
        </property>
       </widget>
      </item>
+     <item row="6" column="0">
+      <widget class="QCheckBox" name="mixingOnlyCheckBox">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <property name="visible">
+        <bool>false</bool>
+       </property>
+       <property name="toolTip">
+        <string>Serves to disable the trivial sendmoney when OS account compromised. Provides no real security.</string>
+       </property>
+       <property name="text">
+        <string>Only for mixing via PrivateSend</string>
+       </property>
+      </widget>
+     </item>
+     <item row="5" column="0">
+      <widget class="QCheckBox" name="stakingCheckBox">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <property name="visible">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string> Unlock for staking only</string>
+       </property>
+      </widget>
+     </item>
+     <item row="5" column="1">
+      <widget class="QCheckBox" name="toggleShowPasswordButton">
+       <property name="text">
+        <string>Show password</string>
+       </property>
+      </widget>
+     </item>
+     <item row="6" column="0">
+      <widget class="QCheckBox" name="mixingOnlyCheckBox">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <property name="visible">
+        <bool>false</bool>
+       </property>
+       <property name="toolTip">
+        <string>Serves to disable the trivial sendmoney when OS account compromised. Provides no real security.</string>
+       </property>
+       <property name="text">
+        <string>Only for mixing via PrivateSend</string>
+       </property>
+      </widget>
+     </item>
+     <item row="5" column="0">
+      <widget class="QCheckBox" name="stakingCheckBox">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <property name="visible">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string> Unlock for staking only</string>
+       </property>
+      </widget>
+     </item>
+     <item row="5" column="1">
+      <widget class="QCheckBox" name="toggleShowPasswordButton">
+       <property name="text">
+        <string>Show password</string>
+       </property>
+      </widget>
+     </item>
     </layout>
    </item>
    <item>
diff --git a/src/qt/res/icons/staking_active.png b/src/qt/res/icons/staking_active.png
new file mode 100644
index 0000000000000000000000000000000000000000..b9ff5aaca1cf37d09cf3e2b4f7b87e1a799b6202
GIT binary patch
literal 1143
zcmV--1c>{IP)<h;3K|Lk000e1NJLTq000mG000mO0{{R3C@l|D00087P)t-s0yhZ&
z0006t2m&|>0yhc+HVOa&00un`2|*AGL=qNN9T!y{4Mr3SK@kN!3;-hl02u%aND>fA
z7XS+Y02}}eP7@PP82}9c01yBNMGgr>5C9GU13U^cemMXm00ck_4^$QeLJJdM90pAf
z4qX=qO%MrN69z&K23ipYKMe#-4gom{2W1lhDh2>70tY}20yzi(A_f2-00=@40Xzr+
zDhB``00KG*CSffNQxyO<2LdYy03iSXDF6sV4;D`y7Ec`%P8$zP763j7051gtCkQ5S
zELXW(e(!&b`HYtNm6Pt2ZMknRZZtchL38eRdh>jF;d_A1f{oUWm+F_L^QEiwtX-pF
zDVi}`=3#O0b#2{nbF_EP+s?Vsx`@b%n(UjY?y9Kks#~UD4`>)V+C*08TwvH_TBBdv
z=G*-H`}p|xvCgx7!GD|Yo}B2Phuw=Bq$V`mJwVM!Lzhb4>EHYM`}+F%{{8->#inYt
zZ-VEBd*XmarA;BsFC)S(GLt*g;?(f;@BIAy_W1Vy|NoV}nM<isUEF0wzfUjHKN_Pa
zox`Er=-pzVXu{dVoWh{<_w+!INHWGhG{{0j(osCOM{2Baqr;{>mqaXpG{4uuEQ&RC
zt$Ucfn;eZN9mOpjzAj40Szga-NxV}qt2-dPEGB#}ywtudqBRw&Ar_?~7`Z1J!z&W2
zBs!c&b=7}q(sNMGTs6-^C3`Ns)4wXCH5|n&8^kIYz$z8KDGZDq7+oQD&47K=hhold
zNz7I^ia-1O`m)WmG^ju>!#*XyHyF7s52_<MfI@i2f_2S+XUue0xnf6?O;4a$QNUhG
z#aTSPOeU!|333)cfJSe!c6!5ucF2Hr%YSyvfo;WjTDN67nne(58b*OkU7KTQr*37Y
zY)+C@EORu1nTnVI002gGQchC<0000000Je9)A#t)iy;INhlLOmtg#pZijN2-@;Qil
z)4cfe`18`ehj<|HIs}Q31rf2a85WK5@QxS<I()wK^S^vL1f8B!m;e9(32;bRa{vGf
z6951U69E94oEQKA0UJp~K~xyi0T2Q2{r~_00R{&M2?`4g4Gs?h0s{a60T2;JM@UIZ
zOH54?69EJO0TdNZPf$@(Q&d$}R~8om02moqSz23MU0z>cVPaz%8vq<+WoBn+X=-b1
zZEkOH9UcH5adLBXb#`}mczJqze0?AQA%1^=fp~(0goK5Lhlq(H03(WvjD?Mkg^!St
zg_4t$BmgCqmY0~BnuVL3ot~edp(X$)qNAjxrl*Cdsj922t*$5lDX*}xva_^>wYImo
zxw^Y504uz`zQ4f1!o$SH#>dDkEdVYr$;!*j&Cbuz(bCh@FfjlDGBefI*Vx(G+uYsW
zG&KPL1pziUIN#vm;^X8wIy(UX00001JUu=?KtV!7L`4Ar0XSW1nw0h9x&QzG07*qo
JM6N<$f(mDgwT=J)

literal 0
HcmV?d00001

diff --git a/src/qt/res/icons/staking_inactive.png b/src/qt/res/icons/staking_inactive.png
new file mode 100644
index 0000000000000000000000000000000000000000..b2d83f4ad7e0adb13f4c40e0f61ca9d8a438aac0
GIT binary patch
literal 1004
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GXl4m{bFNLR@8JWPl=tg@p+T3EA1%
zdU|@Yva+F}q5Aszii%1`Mn*0!E`@~!4Gs0p%}r%xWj;PWj*bo@BEl*vDuIE4VPRoH
zLLhc*Y;0<3D$pn(+sDT@HZ}&xHZU+~Z*O;YcDA##i;s_wi;DxQ$;ik^N=iyh1X`E?
z6bA}gT3S|CRysL32?+@S&5w?b2I>_R6$P4^mX-!&Gcz+sMMbr?w${|t#KeG121=!a
z0Z>75axzfR!NCD2-qO;%YuB#BhYy`Nas2e@Q)kYcK6>;>Pfz#k*|WEA-@a$h?rqz)
zu3fuk$Byl1&z`w(;oPQ8o2E{kx_<q-ty{NTxpH~UnpG!Ho;Y{z%=z=@)~#DxUS7Up
z#qvdq7S`9-J$Ufo&!1mEetbW0VBdlT^G}^RdF<HH`Sa&5S+ZpM^y&Hed5<4I{{8#c
zuU|j^{rkIR%jQXwCLTO^;J|_X%a$!&v}n<U2@`-Gzjf=@-@ku9efsq0&!6w#zyJUL
zzp1Hd)25B9R;?;6EnUBU{lkY38yXtUo;~~Z>(|W8j5%}WOr1KVudjE*h7Gy7xxmnl
zi;JB&al(ofD}dp-bm`LV+qcc0J*&IBJ0Kw7*s)_36&1iZ>hJGgxpIY{pC2$(XU&>5
zckbMI^X5&QII*g#YUj?K8#itQhS=V{ds|vs7B60W<j9djhYs%DyJz9Tg#`uqjg1YP
zH*Z?DY}u||J10+`eE9I;-Me>juU#(!3|!ZeAU|NjfdVGA?#ti5U+Gq45o~W05MHxU
zf~l*YL-mtoN7dy$KR$on+g_pY!HT780;}N0jgn%$pFZ}n*X;Z9d4G)+%bPjLUxCJO
z7I;J!Gca%qgD@k*tT_@442;sAE{-7*ml*{Z-~R)089BMQd3gEw1q6i{nLvDD5mz^N
z4^J;|A5k$zW(G!a312_|fWRP+;E+&BDMkiqnXvGPz_3W~sOXs3I9WLc`S^sm#H8eu
z)U<Suj7$YZ2Boa*oZP(pf`Y=L;*!!bWd@b<ipr|$n%cU$`h<pnMpXv2rskIV*0%cg
z@Q(V<u0VALwb1UK-oE~N&j}MJP41ea!JrZ_by~yp8TB)pXU(3IRj$dP)m!4<ICozC
z%=rrzE?Tr$n?YyEOz)-3mglcnnY}72OIMFU-ynPSnzifJZ)n;WxM_}|5d)*K$&@vj
z-kF&tn|rsInlUo4Fq&IfHkGd4x-HAfT8fdCfsLKfM$gvH-oeqy*@cmVaqGv((kio6
R%Ry1#>FVdQ&MBdZ3jj2(uB-q6

literal 0
HcmV?d00001

diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
index f5ef214093232..06a6ddce96c28 100644
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -11,6 +11,7 @@
 #include "timedata.h"
 #include "wallet/wallet.h"
 
+#include "instantx.h"
 #include "privatesend.h"
 
 #include <stdint.h>
@@ -44,8 +45,42 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *
     CAmount nNet = nCredit - nDebit;
     uint256 hash = wtx.GetHash();
     std::map<std::string, std::string> mapValue = wtx.mapValue;
+    if(wtx.tx->IsCoinStake())
+    {
+        TransactionRecord sub(hash, nTime);
+        CTxDestination address;
+        if (!ExtractDestination(wtx.tx->vout[1].scriptPubKey, address))
+            return parts;
 
-    if (nNet > 0 || wtx.IsCoinBase())
+        if (!IsMine(*wallet, address))
+        {
+                for (unsigned int i = 1; i < wtx.tx->vout.size(); i++) {
+                    CTxDestination outAddress;
+                    if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, outAddress)) {
+                        isminetype mine = IsMine(*wallet, outAddress);
+                        if (mine) {
+                            //isminetype mine = wallet->IsMine(wtx.tx->vout[i]);
+                            sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
+                            sub.type = TransactionRecord::MNReward;
+                            sub.address = CBitcoinAddress(outAddress).ToString();
+                            sub.credit = wtx.tx->vout[i].nValue;
+                        }
+                    }
+            }
+        }
+        else
+        {
+            //stake reward
+            isminetype mine = IsMine(*wallet, address);
+            sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
+            sub.address = CBitcoinAddress(address).ToString();
+            sub.credit = nCredit - nDebit;
+            sub.type = TransactionRecord::StakeMint;
+
+        }
+        parts.append(sub);
+    }
+    else if (nNet > 0 || wtx.IsCoinBase())
     {
         //
         // Credit
@@ -288,7 +323,8 @@ void TransactionRecord::updateStatus(const CWalletTx &wtx, int numISLocks, int c
         }
     }
     // For generated transactions, determine maturity
-    else if(type == TransactionRecord::Generated)
+    else if(type == TransactionRecord::Generated || type == TransactionRecord::StakeMint
+            || type == TransactionRecord::MNReward)
     {
         if (wtx.GetBlocksToMaturity() > 0)
         {
diff --git a/src/qt/transactionrecord.h b/src/qt/transactionrecord.h
index 3ad6556fd0a83..a66d8107eb8e0 100644
--- a/src/qt/transactionrecord.h
+++ b/src/qt/transactionrecord.h
@@ -81,6 +81,7 @@ class TransactionRecord
     {
         Other,
         Generated,
+        StakeMint,
         SendToAddress,
         SendToOther,
         RecvWithAddress,
@@ -91,7 +92,8 @@ class TransactionRecord
         PrivateSendCollateralPayment,
         PrivateSendMakeCollaterals,
         PrivateSendCreateDenominations,
-        PrivateSend
+        PrivateSend,
+        MNReward
     };
 
     /** Number of confirmation recommended for accepting a transaction */
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
index 36de15b899c28..d96c13430c0f6 100644
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -393,6 +393,10 @@ QString TransactionTableModel::formatTxType(const TransactionRecord *wtx) const
     {
     case TransactionRecord::RecvWithAddress:
         return tr("Received with");
+    case TransactionRecord::MNReward:
+        return tr("Masternode Reward");
+    case TransactionRecord::StakeMint:
+        return tr("Minted");
     case TransactionRecord::RecvFromOther:
         return tr("Received from");
     case TransactionRecord::RecvWithPrivateSend:
@@ -455,6 +459,8 @@ QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx, b
         return QString::fromStdString(wtx->address) + watchAddress;
     case TransactionRecord::RecvWithAddress:
     case TransactionRecord::RecvWithPrivateSend:
+    case TransactionRecord::MNReward:
+    case TransactionRecord::StakeMint:
     case TransactionRecord::SendToAddress:
     case TransactionRecord::Generated:
     case TransactionRecord::PrivateSend:
@@ -473,6 +479,8 @@ QVariant TransactionTableModel::addressColor(const TransactionRecord *wtx) const
     switch(wtx->type)
     {
     case TransactionRecord::RecvWithAddress:
+    case TransactionRecord::MNReward:
+    case TransactionRecord::StakeMint:
     case TransactionRecord::SendToAddress:
     case TransactionRecord::Generated:
     case TransactionRecord::PrivateSend:
diff --git a/src/qt/transactionview.cpp b/src/qt/transactionview.cpp
index 7f2be564b5020..faf500d09a35e 100644
--- a/src/qt/transactionview.cpp
+++ b/src/qt/transactionview.cpp
@@ -108,6 +108,8 @@ TransactionView::TransactionView(const PlatformStyle *platformStyle, QWidget *pa
     typeWidget->addItem(tr("PrivateSend Collateral Payment"), TransactionFilterProxy::TYPE(TransactionRecord::PrivateSendCollateralPayment));
     typeWidget->addItem(tr("To yourself"), TransactionFilterProxy::TYPE(TransactionRecord::SendToSelf));
     typeWidget->addItem(tr("Mined"), TransactionFilterProxy::TYPE(TransactionRecord::Generated));
+    typeWidget->addItem(tr("Minted"), TransactionFilterProxy::TYPE(TransactionRecord::StakeMint));
+    typeWidget->addItem(tr("Masternode Reward"), TransactionFilterProxy::TYPE(TransactionRecord::MNReward));
     typeWidget->addItem(tr("Other"), TransactionFilterProxy::TYPE(TransactionRecord::Other));
     typeWidget->setCurrentIndex(settings.value("transactionType").toInt());
 
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
index 095c94a1d61c2..c1ba1fd9d290b 100644
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -121,7 +121,8 @@ class WalletModel : public QObject
         TransactionCreationFailed, // Error returned when wallet is still locked
         TransactionCommitFailed,
         AbsurdFee,
-        PaymentRequestExpired
+        PaymentRequestExpired,
+        StakingOnlyUnlocked
     };
 
     enum EncryptionStatus
@@ -129,6 +130,7 @@ class WalletModel : public QObject
         Unencrypted,            // !wallet->IsCrypted()
         Locked,                 // wallet->IsCrypted() && wallet->IsLocked(true)
         UnlockedForMixingOnly,  // wallet->IsCrypted() && !wallet->IsLocked(true) && wallet->IsLocked()
+        UnlockedForStakingOnly, // wallet->IsCrypted() && !wallet->IsLocked() && wallet->fWalletUnlockStakingOnly
         Unlocked,               // wallet->IsCrypted() && !wallet->IsLocked()
     };
 
@@ -174,6 +176,9 @@ class WalletModel : public QObject
     bool setWalletLocked(bool locked, const SecureString &passPhrase=SecureString(), bool fMixing=false);
     bool changePassphrase(const SecureString &oldPass, const SecureString &newPass);
 
+    // Is wallet unlocked for staking only?
+    bool isStakingOnlyUnlocked();
+
     // Wallet backup
     bool backupWallet(const QString &filename);
 
diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
index 8fe72c9c731c8..d97faddaa60a1 100644
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -324,8 +324,8 @@ void WalletView::unlockWallet(bool fForMixingOnly)
 {
     if(!walletModel)
         return;
-    // Unlock wallet when requested by wallet model
 
+    // Unlock wallet when requested by wallet model
     if (walletModel->getEncryptionStatus() == WalletModel::Locked || walletModel->getEncryptionStatus() == WalletModel::UnlockedForMixingOnly)
     {
         AskPassphraseDialog dlg(fForMixingOnly ? AskPassphraseDialog::UnlockMixing : AskPassphraseDialog::Unlock, this);
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index a0572f867dfb4..f06b3eaed12bc 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -64,6 +64,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "getchaintips", 0, "count" },
     { "getchaintips", 1, "branchlen" },
     { "getblockhash", 0, "height" },
+    { "setstakesplitthreshold", 0, "value"},
     { "getsuperblockbudget", 0, "index" },
     { "waitforblockheight", 0, "height" },
     { "waitforblockheight", 1, "timeout" },
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 3b65ca11ad1cf..4999b86665f2a 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -105,7 +105,7 @@ UniValue getnetworkhashps(const JSONRPCRequest& request)
 }
 
 #if ENABLE_MINER
-UniValue generateBlocks(boost::shared_ptr<CReserveScript> coinbaseScript, int nGenerate, uint64_t nMaxTries, bool keepScript)
+UniValue generateBlocks(std::shared_ptr<CReserveScript> coinbaseScript, int nGenerate, uint64_t nMaxTries, bool keepScript)
 {
     static const int nInnerLoopCount = 0x10000;
     int nHeightStart = 0;
@@ -122,7 +122,7 @@ UniValue generateBlocks(boost::shared_ptr<CReserveScript> coinbaseScript, int nG
     UniValue blockHashes(UniValue::VARR);
     while (nHeight < nHeightEnd)
     {
-        std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(Params()).CreateNewBlock(coinbaseScript->reserveScript));
+        std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(Params()).CreateNewBlock(coinbaseScript->reserveScript, false));
         if (!pblocktemplate.get())
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         CBlock *pblock = &pblocktemplate->block;
@@ -177,7 +177,7 @@ UniValue generate(const JSONRPCRequest& request)
         nMaxTries = request.params[1].get_int();
     }
 
-    boost::shared_ptr<CReserveScript> coinbaseScript;
+    std::shared_ptr<CReserveScript> coinbaseScript;
     GetMainSignals().ScriptForMining(coinbaseScript);
 
     // If the keypool is exhausted, no script is returned at all.  Catch this.
@@ -218,7 +218,7 @@ UniValue generatetoaddress(const JSONRPCRequest& request)
     if (!address.IsValid())
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
 
-    boost::shared_ptr<CReserveScript> coinbaseScript(new CReserveScript());
+    std::shared_ptr<CReserveScript> coinbaseScript(new CReserveScript());
     coinbaseScript->reserveScript = GetScriptForDestination(address.Get());
 
     return generateBlocks(coinbaseScript, nGenerate, nMaxTries, false);
@@ -572,7 +572,7 @@ UniValue getblocktemplate(const JSONRPCRequest& request)
 
         // Create new block
         CScript scriptDummy = CScript() << OP_TRUE;
-        pblocktemplate = BlockAssembler(Params()).CreateNewBlock(scriptDummy);
+        pblocktemplate = BlockAssembler(Params()).CreateNewBlock(scriptDummy, false);
         if (!pblocktemplate)
             throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
 
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 5fc2f612bf080..73f253744688c 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -31,6 +31,8 @@
 
 #include <univalue.h>
 
+extern int64_t nLastCoinStakeSearchInterval;
+
 /**
  * @note Do not add or change anything in the information returned by this
  * method. `getinfo` exists for backwards-compatibility only. It combines
@@ -1104,6 +1106,47 @@ UniValue getspentinfo(const JSONRPCRequest& request)
     return obj;
 }
 
+UniValue getstakingstatus(const JSONRPCRequest& request)
+{
+    if (request.fHelp || request.params.size() != 0)
+        throw std::runtime_error(
+            "getstakingstatus\n"
+            "Returns an object containing various staking information.\n"
+            "\nResult:\n"
+            "{\n"
+            "  \"validtime\": true|false,          (boolean) if the chain tip is within staking phases\n"
+            "  \"haveconnections\": true|false,    (boolean) if network connections are present\n"
+            "  \"walletunlocked\": true|false,     (boolean) if the wallet is unlocked\n"
+            "  \"mintablecoins\": true|false,      (boolean) if the wallet has mintable coins\n"
+            "  \"enoughcoins\": true|false,        (boolean) if available coins are greater than reserve balance\n"
+            "  \"mnsync\": true|false,             (boolean) if masternode data is synced\n"
+            "  \"staking status\": true|false,     (boolean) if the wallet is staking or not\n"
+            "}\n"
+            "\nExamples:\n" +
+            HelpExampleCli("getstakingstatus", "") + HelpExampleRpc("getstakingstatus", ""));
+
+    CWallet * const pwalletMain = GetWalletForJSONRPCRequest(request);
+
+    UniValue obj(UniValue::VOBJ);
+    obj.push_back(Pair("validtime", chainActive.Tip()->nTime > 1471482000));
+    obj.push_back(Pair("haveconnections", g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL) > 0));
+    if (pwalletMain) {
+        obj.push_back(Pair("walletunlocked", !pwalletMain->IsLocked()));
+        obj.push_back(Pair("mintablecoins", pwalletMain->MintableCoins()));
+        obj.push_back(Pair("enoughcoins", pwalletMain->GetBalance() > 0));
+    }
+    obj.push_back(Pair("mnsync", masternodeSync.IsSynced()));
+
+    bool nStaking = false;
+
+    if (nLastCoinStakeSearchInterval > 0)
+        nStaking = true;
+
+    obj.push_back(Pair("staking status", nStaking));
+
+    return obj;
+}
+
 static UniValue RPCLockedMemoryInfo()
 {
     LockedPool::Stats stats = LockedPoolManager::Instance().stats();
@@ -1170,6 +1213,7 @@ static const CRPCCommand commands[] =
     { "util",               "verifymessage",          &verifymessage,          true,  {"address","signature","message"} },
     { "util",               "signmessagewithprivkey", &signmessagewithprivkey, true,  {"privkey","message"} },
     { "blockchain",         "getspentinfo",           &getspentinfo,           false, {"json"} },
+    { "util",               "getstakingstatus",       &getstakingstatus,       true,  {} },
 
     /* Address index */
     { "addressindex",       "getaddressmempool",      &getaddressmempool,      true,  {"addresses"}  },
diff --git a/src/rpc/rpcevo.cpp b/src/rpc/rpcevo.cpp
index 4c5ed8468770d..bfc7e45bbf9e8 100644
--- a/src/rpc/rpcevo.cpp
+++ b/src/rpc/rpcevo.cpp
@@ -282,7 +282,7 @@ static std::string SignAndSendSpecialTx(const CMutableTransaction& tx)
     JSONRPCRequest signRequest;
     signRequest.params.setArray();
     signRequest.params.push_back(HexStr(ds.begin(), ds.end()));
-    UniValue signResult = signrawtransaction(signRequest);
+     UniValue signResult = signrawtransaction(signRequest);
 
     JSONRPCRequest sendRequest;
     sendRequest.params.setArray();
diff --git a/src/script/dashconsensus.cpp b/src/script/dashconsensus.cpp
index 7785eb6d91141..173cb881ace3a 100644
--- a/src/script/dashconsensus.cpp
+++ b/src/script/dashconsensus.cpp
@@ -76,7 +76,7 @@ static bool verify_flags(unsigned int flags)
     return (flags & ~(dashconsensus_SCRIPT_FLAGS_VERIFY_ALL)) == 0;
 }
 
-int dashconsensus_verify_script(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen,
+int dashconsensus_verify_script(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen, CAmount amount,
                                     const unsigned char *txTo        , unsigned int txToLen,
                                     unsigned int nIn, unsigned int flags, dashconsensus_error* err)
 {
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index bc7e58acdd021..12e9507651c01 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -1112,13 +1112,45 @@ class CTransactionSignatureSerializer {
              SerializeOutput(s, nOutput);
         // Serialize nLockTime
         ::Serialize(s, txTo.nLockTime);
-        if (txTo.nVersion == 3 && txTo.nType != TRANSACTION_NORMAL)
-            ::Serialize(s, txTo.vExtraPayload);
     }
 };
 
+uint256 GetPrevoutHash(const CTransaction& txTo) {
+    CHashWriter ss(SER_GETHASH, 0);
+    for (const auto& txin : txTo.vin) {
+        ss << txin.prevout;
+    }
+    return ss.GetHash();
+}
+
+uint256 GetSequenceHash(const CTransaction& txTo) {
+    CHashWriter ss(SER_GETHASH, 0);
+    for (const auto& txin : txTo.vin) {
+        ss << txin.nSequence;
+    }
+    return ss.GetHash();
+}
+
+uint256 GetOutputsHash(const CTransaction& txTo) {
+    CHashWriter ss(SER_GETHASH, 0);
+    for (const auto& txout : txTo.vout) {
+        ss << txout;
+    }
+    return ss.GetHash();
+}
+
 } // anon namespace
 
+PrecomputedTransactionData::PrecomputedTransactionData(const CTransaction& txTo)
+{
+
+    hashPrevouts = GetPrevoutHash(txTo);
+    hashSequence = GetSequenceHash(txTo);
+    hashOutputs = GetOutputsHash(txTo);
+    ready = true;
+
+}
+
 uint256 SignatureHash(const CScript& scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
 {
     static const uint256 one(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index 801e23b361d2f..9f778db77661f 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -94,6 +94,14 @@ enum
 
 bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned int flags, ScriptError* serror);
 
+struct PrecomputedTransactionData
+{
+    uint256 hashPrevouts, hashSequence, hashOutputs;
+    bool ready = false;
+
+    explicit PrecomputedTransactionData(const CTransaction& tx);
+};
+
 uint256 SignatureHash(const CScript &scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType);
 
 class BaseSignatureChecker
@@ -143,6 +151,6 @@ class MutableTransactionSignatureChecker : public TransactionSignatureChecker
 };
 
 bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, unsigned int flags, const BaseSignatureChecker& checker, ScriptError* error = NULL);
-bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, unsigned int flags, const BaseSignatureChecker& checker, ScriptError* error = NULL);
+bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, unsigned int flags, const BaseSignatureChecker& checker, ScriptError* serror = nullptr);
 
 #endif // BITCOIN_SCRIPT_INTERPRETER_H
diff --git a/src/script/sigcache.h b/src/script/sigcache.h
index 15ee161deffea..e0fe391426416 100644
--- a/src/script/sigcache.h
+++ b/src/script/sigcache.h
@@ -19,6 +19,7 @@ static const int64_t MAX_MAX_SIG_CACHE_SIZE = 16384;
 
 class CPubKey;
 
+
 class CachingTransactionSignatureChecker : public TransactionSignatureChecker
 {
 private:
diff --git a/src/serialize.h b/src/serialize.h
index 55e1e67d54c8a..46920e9b0ec27 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -25,6 +25,7 @@
 #include <vector>
 
 #include "prevector.h"
+#include "span.h"
 
 static const unsigned int MAX_SIZE = 0x02000000;
 
@@ -62,6 +63,12 @@ inline T* NCONST_PTR(const T* val)
     return const_cast<T*>(val);
 }
 
+//! Safely convert odd char pointer types to standard ones.
+inline char* CharCast(char* c) { return c; }
+inline char* CharCast(unsigned char* c) { return (char*)c; }
+inline const char* CharCast(const char* c) { return c; }
+inline const char* CharCast(const unsigned char* c) { return (const char*)c; }
+
 /*
  * Lowest-level serialization and conversion.
  * @note Sizes of these types are verified in the tests
@@ -162,8 +169,12 @@ enum
     SER_GETHASH         = (1 << 2),
 };
 
-#define READWRITE(obj)      (::SerReadWrite(s, (obj), ser_action))
-#define READWRITEMANY(...)      (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
+//! Convert the reference base type to X, without changing constness or reference type.
+template<typename X> X& ReadWriteAsHelper(X& x) { return x; }
+template<typename X> const X& ReadWriteAsHelper(const X& x) { return x; }
+
+#define READWRITE(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
+#define READWRITEAS(type, obj) (::SerReadWriteMany(s, ser_action, ReadWriteAsHelper<type>(obj)))
 
 /** 
  * Implement three methods for serializable objects. These are actually wrappers over
@@ -192,6 +203,10 @@ template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_wri
 template<typename Stream> inline void Serialize(Stream& s, uint64_t a) { ser_writedata64(s, a); }
 template<typename Stream> inline void Serialize(Stream& s, float a   ) { ser_writedata32(s, ser_float_to_uint32(a)); }
 template<typename Stream> inline void Serialize(Stream& s, double a  ) { ser_writedata64(s, ser_double_to_uint64(a)); }
+template<typename Stream, int N> inline void Serialize(Stream& s, const char (&a)[N]) { s.write(a, N); }
+template<typename Stream, int N> inline void Serialize(Stream& s, const unsigned char (&a)[N]) { s.write(CharCast(a), N); }
+template<typename Stream> inline void Serialize(Stream& s, const Span<const unsigned char>& span) { s.write(CharCast(span.data()), span.size()); }
+template<typename Stream> inline void Serialize(Stream& s, const Span<unsigned char>& span) { s.write(CharCast(span.data()), span.size()); }
 
 template<typename Stream> inline void Unserialize(Stream& s, char& a    ) { a = ser_readdata8(s); } // TODO Get rid of bare char
 template<typename Stream> inline void Unserialize(Stream& s, int8_t& a  ) { a = ser_readdata8(s); }
@@ -204,6 +219,9 @@ template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a =
 template<typename Stream> inline void Unserialize(Stream& s, uint64_t& a) { a = ser_readdata64(s); }
 template<typename Stream> inline void Unserialize(Stream& s, float& a   ) { a = ser_uint32_to_float(ser_readdata32(s)); }
 template<typename Stream> inline void Unserialize(Stream& s, double& a  ) { a = ser_uint64_to_double(ser_readdata64(s)); }
+template<typename Stream, int N> inline void Unserialize(Stream& s, char (&a)[N]) { s.read(a, N); }
+template<typename Stream, int N> inline void Unserialize(Stream& s, unsigned char (&a)[N]) { s.read(CharCast(a), N); }
+template<typename Stream> inline void Unserialize(Stream& s, Span<unsigned char>& span) { s.read(CharCast(span.data()), span.size()); }
 
 template<typename Stream> inline void Serialize(Stream& s, bool a)    { char f=a; ser_writedata8(s, f); }
 template<typename Stream> inline void Unserialize(Stream& s, bool& a) { char f=ser_readdata8(s); a=f; }
@@ -722,7 +740,7 @@ inline void Serialize(Stream& os, const T& a)
 }
 
 template<typename Stream, typename T>
-inline void Unserialize(Stream& is, T& a)
+inline void Unserialize(Stream& is, T&& a)
 {
     a.Unserialize(is);
 }
diff --git a/src/span.h b/src/span.h
new file mode 100644
index 0000000000000..707fc2191869c
--- /dev/null
+++ b/src/span.h
@@ -0,0 +1,40 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_SPAN_H
+#define BITCOIN_SPAN_H
+
+#include <type_traits>
+#include <cstddef>
+
+/** A Span is an object that can refer to a contiguous sequence of objects.
+ *
+ * It implements a subset of C++20's std::span.
+ */
+template<typename C>
+class Span
+{
+    C* m_data;
+    std::ptrdiff_t m_size;
+
+public:
+    constexpr Span() noexcept : m_data(nullptr), m_size(0) {}
+    constexpr Span(C* data, std::ptrdiff_t size) noexcept : m_data(data), m_size(size) {}
+
+    constexpr C* data() const noexcept { return m_data; }
+    constexpr std::ptrdiff_t size() const noexcept { return m_size; }
+};
+
+/** Create a span to a container exposing data() and size().
+ *
+ * This correctly deals with constness: the returned Span's element type will be
+ * whatever data() returns a pointer to. If either the passed container is const,
+ * or its element type is const, the resulting span will have a const element type.
+ *
+ * std::span will have a constructor that implements this functionality directly.
+ */
+template<typename V>
+constexpr Span<typename std::remove_pointer<decltype(std::declval<V>().data())>::type> MakeSpan(V& v) { return Span<typename std::remove_pointer<decltype(std::declval<V>().data())>::type>(v.data(), v.size()); }
+
+#endif
diff --git a/src/streams.h b/src/streams.h
index 088a87c72d2c8..7acd1b9873339 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -22,6 +22,53 @@
 #include <utility>
 #include <vector>
 
+template<typename Stream>
+class OverrideStream
+{
+    Stream* stream;
+
+    const int nType;
+    const int nVersion;
+
+public:
+    OverrideStream(Stream* stream_, int nType_, int nVersion_) : stream(stream_), nType(nType_), nVersion(nVersion_) {}
+
+    template<typename T>
+    OverrideStream<Stream>& operator<<(const T& obj)
+    {
+        // Serialize to this stream
+        ::Serialize(*this, obj);
+        return (*this);
+    }
+
+    template<typename T>
+    OverrideStream<Stream>& operator>>(T&& obj)
+    {
+        // Unserialize from this stream
+        ::Unserialize(*this, obj);
+        return (*this);
+    }
+
+    void write(const char* pch, size_t nSize)
+    {
+        stream->write(pch, nSize);
+    }
+
+    void read(char* pch, size_t nSize)
+    {
+        stream->read(pch, nSize);
+    }
+
+    int GetVersion() const { return nVersion; }
+    int GetType() const { return nType; }
+};
+
+template<typename S>
+OverrideStream<S> WithOrVersion(S* s, int nVersionFlag)
+{
+    return OverrideStream<S>(s, s->GetType(), s->GetVersion() | nVersionFlag);
+}
+
 /* Minimal stream for overwriting and/or appending to an existing byte vector
  *
  * The referenced vector will grow as necessary
@@ -358,7 +405,7 @@ class CDataStream
     }
 
     template<typename T>
-    CDataStream& operator>>(T& obj)
+    CDataStream& operator>>(T&& obj)
     {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
diff --git a/src/txdb.cpp b/src/txdb.cpp
index ac38cc8a34577..70e51fd9cbff0 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -358,22 +358,31 @@ bool CBlockTreeDB::LoadBlockIndexGuts(boost::function<CBlockIndex*(const uint256
             CDiskBlockIndex diskindex;
             if (pcursor->GetValue(diskindex)) {
                 // Construct block index object
-                CBlockIndex* pindexNew = insertBlockIndex(diskindex.GetBlockHash());
-                pindexNew->pprev          = insertBlockIndex(diskindex.hashPrev);
-                pindexNew->nHeight        = diskindex.nHeight;
-                pindexNew->nFile          = diskindex.nFile;
-                pindexNew->nDataPos       = diskindex.nDataPos;
-                pindexNew->nUndoPos       = diskindex.nUndoPos;
-                pindexNew->nVersion       = diskindex.nVersion;
-                pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
-                pindexNew->nTime          = diskindex.nTime;
-                pindexNew->nBits          = diskindex.nBits;
-                pindexNew->nNonce         = diskindex.nNonce;
-                pindexNew->nStatus        = diskindex.nStatus;
-                pindexNew->nTx            = diskindex.nTx;
-
-                if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
-                    return error("%s: CheckProofOfWork failed: %s", __func__, pindexNew->ToString());
+                CBlockIndex* pindexNew      = insertBlockIndex(diskindex.GetBlockHash());
+                pindexNew->pprev            = insertBlockIndex(diskindex.hashPrev);
+                pindexNew->nHeight          = diskindex.nHeight;
+                pindexNew->nFile            = diskindex.nFile;
+                pindexNew->nDataPos         = diskindex.nDataPos;
+                pindexNew->nUndoPos         = diskindex.nUndoPos;
+                pindexNew->nVersion         = diskindex.nVersion;
+                pindexNew->hashMerkleRoot   = diskindex.hashMerkleRoot;
+                pindexNew->nTime            = diskindex.nTime;
+                pindexNew->nBits            = diskindex.nBits;
+                pindexNew->nNonce           = diskindex.nNonce;
+                pindexNew->nStatus          = diskindex.nStatus;
+                pindexNew->nTx              = diskindex.nTx;
+
+                //Proof Of Stake
+                pindexNew->nMint            = diskindex.nMint;
+                pindexNew->nMoneySupply     = diskindex.nMoneySupply;
+                pindexNew->nFlags           = diskindex.nFlags;
+                pindexNew->nStakeModifier   = diskindex.nStakeModifier;
+                pindexNew->prevoutStake     = diskindex.prevoutStake;
+                pindexNew->nStakeTime       = diskindex.nStakeTime;
+                pindexNew->hashProofOfStake = diskindex.hashProofOfStake;
+
+                // if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
+                //    return error("%s: CheckProofOfWork failed: %s", __func__, pindexNew->ToString());
 
                 pcursor->Next();
             } else {
@@ -485,7 +494,7 @@ bool CCoinsViewDB::Upgrade() {
             COutPoint outpoint(key.second, 0);
             for (size_t i = 0; i < old_coins.vout.size(); ++i) {
                 if (!old_coins.vout[i].IsNull() && !old_coins.vout[i].scriptPubKey.IsUnspendable()) {
-                    Coin newcoin(std::move(old_coins.vout[i]), old_coins.nHeight, old_coins.fCoinBase);
+                    Coin newcoin(std::move(old_coins.vout[i]), old_coins.nHeight, old_coins.fCoinBase, false);
                     outpoint.n = i;
                     CoinEntry entry(&outpoint);
                     batch.Write(entry, newcoin);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 779072ba43434..79fa128bd3e86 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1433,7 +1433,7 @@ bool CCoinsViewMemPool::GetCoin(const COutPoint &outpoint, Coin &coin) const {
     CTransactionRef ptx = mempool.get(outpoint.hash);
     if (ptx) {
         if (outpoint.n < ptx->vout.size()) {
-            coin = Coin(ptx->vout[outpoint.n], MEMPOOL_HEIGHT, false);
+            coin = Coin(ptx->vout[outpoint.n], MEMPOOL_HEIGHT, false, false);
             return true;
         } else {
             return false;
diff --git a/src/util.cpp b/src/util.cpp
index 82bcf74e4d09d..434ae93512fff 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -876,6 +876,19 @@ void runCommand(const std::string& strCommand)
         LogPrintf("runCommand error: system(%s) returned %d\n", strCommand, nErr);
 }
 
+void SetThreadPriority(int nPriority)
+{
+#ifdef WIN32
+    SetThreadPriority(GetCurrentThread(), nPriority);
+#else // WIN32
+#ifdef PRIO_THREAD
+    setpriority(PRIO_THREAD, 0, nPriority);
+#else // PRIO_THREAD
+    setpriority(PRIO_PROCESS, 0, nPriority);
+#endif // PRIO_THREAD
+#endif // WIN32
+}
+
 void RenameThread(const char* name)
 {
 #if defined(PR_SET_NAME)
diff --git a/src/util.h b/src/util.h
index eda300bdeec90..864bd1c6d2513 100644
--- a/src/util.h
+++ b/src/util.h
@@ -151,6 +151,7 @@ boost::filesystem::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
 void OpenDebugLog();
 void ShrinkDebugFile();
 void runCommand(const std::string& strCommand);
+void SetThreadPriority(int nPriority);
 
 inline bool IsSwitchChar(char c)
 {
diff --git a/src/validation.cpp b/src/validation.cpp
index 6422ac2e07b14..b2e846562a856 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -15,8 +15,10 @@
 #include "consensus/consensus.h"
 #include "consensus/merkle.h"
 #include "consensus/validation.h"
+#include "cuckoocache.h"
 #include "hash.h"
 #include "init.h"
+#include "kernel.h"
 #include "policy/policy.h"
 #include "pow.h"
 #include "primitives/block.h"
@@ -63,6 +65,8 @@
 # error "Dash Core cannot be compiled without assertions."
 #endif
 
+static std::map<uint256, uint256> mapProofOfStake;
+
 /**
  * Global state
  */
@@ -98,6 +102,7 @@ std::atomic<bool> fDIP0001ActiveAtTip{false};
 std::atomic<bool> fDIP0003ActiveAtTip{false};
 
 uint256 hashAssumeValid;
+std::map<COutPoint, int> mapStakeSpent;
 
 CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE);
 CAmount maxTxFee = DEFAULT_TRANSACTION_MAXFEE;
@@ -662,6 +667,11 @@ bool AcceptToMemoryPoolWorker(CTxMemPool& pool, CValidationState& state, const C
     if (tx.IsCoinBase())
         return state.DoS(100, false, REJECT_INVALID, "coinbase");
 
+    //Coinstake is also only valid in a block, not as a loose transaction
+    if (tx.IsCoinStake())
+        return state.DoS(100, error("AcceptToMemoryPoolWorker: coinstake as individual tx"),
+                         REJECT_INVALID, "coinstake");
+
     // Rather not work on nonstandard transactions (unless -testnet/-regtest)
     std::string reason;
     if (fRequireStandard && !IsStandardTx(tx, reason))
@@ -1093,8 +1103,14 @@ bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos, const Consensus:
     }
 
     // Check the header
-    if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
+    if (block.IsProofOfWork()) {
+      LogPrintf("Reading PoW block %s\n", block.GetHash().ToString().c_str());
+      if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
         return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
+    }
+    else {
+      LogPrintf("Reading PoS block %s\n", block.GetHash().ToString().c_str());
+    }
 
     return true;
 }
@@ -1129,60 +1145,75 @@ double ConvertBitsToDouble(unsigned int nBits)
     return dDiff;
 }
 
-/*
-NOTE:   unlike bitcoin we are using PREVIOUS block height here,
-        might be a good idea to change this to use prev bits
-        but current height to avoid confusion.
-*/
+//  /*
+//  NOTE:   unlike bitcoin we are using PREVIOUS block height here,
+//          might be a good idea to change this to use prev bits
+//          but current height to avoid confusion.
+//  */
+//  CAmount GetBlockSubsidy(int nPrevBits, int nPrevHeight, const Consensus::Params& consensusParams, bool fSuperblockPartOnly)
+//  {
+//      double dDiff;
+//      CAmount nSubsidyBase;
+//
+//      if (nPrevHeight <= 4500 && Params().NetworkIDString() == CBaseChainParams::MAIN) {
+//          /* a bug which caused diff to not be correctly calculated */
+//          dDiff = (double)0x0000ffff / (double)(nPrevBits & 0x00ffffff);
+//      } else {
+//          dDiff = ConvertBitsToDouble(nPrevBits);
+//      }
+//
+//      if (nPrevHeight < 5465) {
+//          // Early ages...
+//          // 1111/((x+1)^2)
+//          nSubsidyBase = (1111.0 / (pow((dDiff+1.0),2.0)));
+//          if(nSubsidyBase > 500) nSubsidyBase = 500;
+//          else if(nSubsidyBase < 1) nSubsidyBase = 1;
+//      } else if (nPrevHeight < 17000 || (dDiff <= 75 && nPrevHeight < 24000)) {
+//          // CPU mining era
+//          // 11111/(((x+51)/6)^2)
+//          nSubsidyBase = (11111.0 / (pow((dDiff+51.0)/6.0,2.0)));
+//          if(nSubsidyBase > 500) nSubsidyBase = 500;
+//          else if(nSubsidyBase < 25) nSubsidyBase = 25;
+//      } else {
+//          // GPU/ASIC mining era
+//          // 2222222/(((x+2600)/9)^2)
+//          nSubsidyBase = (2222222.0 / (pow((dDiff+2600.0)/9.0,2.0)));
+//          if(nSubsidyBase > 25) nSubsidyBase = 25;
+//          else if(nSubsidyBase < 5) nSubsidyBase = 5;
+//      }
+//
+//      // LogPrintf("height %u diff %4.2f reward %d\n", nPrevHeight, dDiff, nSubsidyBase);
+//      CAmount nSubsidy = nSubsidyBase * COIN;
+//
+//      // yearly decline of production by ~7.1% per year, projected ~18M coins max by year 2050+.
+//      for (int i = consensusParams.nSubsidyHalvingInterval; i <= nPrevHeight; i += consensusParams.nSubsidyHalvingInterval) {
+//          nSubsidy -= nSubsidy/14;
+//      }
+//
+//      // this is only active on devnets
+//      if (nPrevHeight < consensusParams.nHighSubsidyBlocks) {
+//          nSubsidy *= consensusParams.nHighSubsidyFactor;
+//      }
+//
+//      // Hard fork to reduce the block reward by 10 extra percent (allowing budget/superblocks)
+//      CAmount nSuperblockPart = (nPrevHeight > consensusParams.nBudgetPaymentsStartBlock) ? nSubsidy/10 : 0;
+//
+//      return fSuperblockPartOnly ? nSuperblockPart : nSubsidy - nSuperblockPart;
+//  }
+
 CAmount GetBlockSubsidy(int nPrevBits, int nPrevHeight, const Consensus::Params& consensusParams, bool fSuperblockPartOnly)
 {
-    double dDiff;
-    CAmount nSubsidyBase;
-
-    if (nPrevHeight <= 4500 && Params().NetworkIDString() == CBaseChainParams::MAIN) {
-        /* a bug which caused diff to not be correctly calculated */
-        dDiff = (double)0x0000ffff / (double)(nPrevBits & 0x00ffffff);
-    } else {
-        dDiff = ConvertBitsToDouble(nPrevBits);
-    }
-
-    if (nPrevHeight < 5465) {
-        // Early ages...
-        // 1111/((x+1)^2)
-        nSubsidyBase = (1111.0 / (pow((dDiff+1.0),2.0)));
-        if(nSubsidyBase > 500) nSubsidyBase = 500;
-        else if(nSubsidyBase < 1) nSubsidyBase = 1;
-    } else if (nPrevHeight < 17000 || (dDiff <= 75 && nPrevHeight < 24000)) {
-        // CPU mining era
-        // 11111/(((x+51)/6)^2)
-        nSubsidyBase = (11111.0 / (pow((dDiff+51.0)/6.0,2.0)));
-        if(nSubsidyBase > 500) nSubsidyBase = 500;
-        else if(nSubsidyBase < 25) nSubsidyBase = 25;
-    } else {
-        // GPU/ASIC mining era
-        // 2222222/(((x+2600)/9)^2)
-        nSubsidyBase = (2222222.0 / (pow((dDiff+2600.0)/9.0,2.0)));
-        if(nSubsidyBase > 25) nSubsidyBase = 25;
-        else if(nSubsidyBase < 5) nSubsidyBase = 5;
-    }
-
-    // LogPrintf("height %u diff %4.2f reward %d\n", nPrevHeight, dDiff, nSubsidyBase);
-    CAmount nSubsidy = nSubsidyBase * COIN;
-
-    // yearly decline of production by ~7.1% per year, projected ~18M coins max by year 2050+.
-    for (int i = consensusParams.nSubsidyHalvingInterval; i <= nPrevHeight; i += consensusParams.nSubsidyHalvingInterval) {
-        nSubsidy -= nSubsidy/14;
-    }
-
-    // this is only active on devnets
-    if (nPrevHeight < consensusParams.nHighSubsidyBlocks) {
-        nSubsidy *= consensusParams.nHighSubsidyFactor;
-    }
-
-    // Hard fork to reduce the block reward by 10 extra percent (allowing budget/superblocks)
-    CAmount nSuperblockPart = (nPrevHeight > consensusParams.nBudgetPaymentsStartBlock) ? nSubsidy/10 : 0;
+    if (nPrevHeight < 10)
+        return 1000000 * COIN;
+    return 10 * COIN;
+}
 
-    return fSuperblockPartOnly ? nSuperblockPart : nSubsidy - nSuperblockPart;
+/*
+	A wrapper to call from the PoS miner.
+*/
+CAmount GetBlockSubsidy(int nPrevHeight, const Consensus::Params& consensusParams, bool fSuperblockPartOnly)
+{
+    return GetBlockSubsidy(0, nPrevHeight, consensusParams, false);
 }
 
 CAmount GetMasternodePayment(int nHeight, CAmount blockValue)
@@ -1375,6 +1406,7 @@ int GetSpendHeight(const CCoinsViewCache& inputs)
     return pindexPrev->nHeight + 1;
 }
 
+
 namespace Consensus {
 bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight)
 {
@@ -1406,17 +1438,19 @@ bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoins
 
         }
 
-        if (nValueIn < tx.GetValueOut())
-            return state.DoS(100, false, REJECT_INVALID, "bad-txns-in-belowout", false,
-                strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(tx.GetValueOut())));
+        if (!tx.IsCoinStake())
+        {
+            if (nValueIn < tx.GetValueOut())
+                return state.DoS(100, false, REJECT_INVALID, "bad-txns-in-belowout", false,
+                    strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(tx.GetValueOut())));
+            CAmount nTxFee = nValueIn - tx.GetValueOut();
+            if (nTxFee < 0)
+                return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-negative");
+            nFees += nTxFee;
+            if (!MoneyRange(nFees))
+                return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-outofrange");
+        }
 
-        // Tally transaction fees
-        CAmount nTxFee = nValueIn - tx.GetValueOut();
-        if (nTxFee < 0)
-            return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-negative");
-        nFees += nTxFee;
-        if (!MoneyRange(nFees))
-            return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-outofrange");
     return true;
 }
 }// namespace Consensus
@@ -1427,25 +1461,28 @@ bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsVi
     {
         if (!Consensus::CheckTxInputs(tx, state, inputs, GetSpendHeight(inputs)))
             return false;
-
         if (pvChecks)
             pvChecks->reserve(tx.vin.size());
-
         // The first loop above does all the inexpensive checks.
         // Only if ALL inputs pass do we perform expensive ECDSA signature checks.
         // Helps prevent CPU exhaustion attacks.
-
         // Skip script verification when connecting blocks under the
         // assumevalid block. Assuming the assumevalid block is valid this
         // is safe because block merkle hashes are still computed and checked,
         // Of course, if an assumed valid block is invalid due to false scriptSigs
         // this optimization would allow an invalid chain to be accepted.
+            // We only use the first 19 bytes of nonce to avoid a second SHA
+            // round - giving us 19 + 32 + 4 = 55 bytes (+ 8 + 1 = 64)
         if (fScriptChecks) {
+
             for (unsigned int i = 0; i < tx.vin.size(); i++) {
                 const COutPoint &prevout = tx.vin[i].prevout;
                 const Coin& coin = inputs.AccessCoin(prevout);
                 assert(!coin.IsSpent());
 
+                if(tx.IsCoinStake())
+                    continue;
+
                 // We very carefully only pass in things to CScriptCheck which
                 // are clearly committed to by tx' witness hash. This provides
                 // a sanity check that our caching is not introducing consensus
@@ -1482,6 +1519,7 @@ bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsVi
                     return state.DoS(100,false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));
                 }
             }
+
         }
     }
 
@@ -1708,6 +1746,9 @@ static DisconnectResult DisconnectBlock(const CBlock& block, CValidationState& s
                 if (res == DISCONNECT_FAILED) return DISCONNECT_FAILED;
                 fClean = fClean && res != DISCONNECT_UNCLEAN;
 
+                // erase the spent input
+                mapStakeSpent.erase(out);
+
                 const CTxIn input = tx.vin[j];
 
                 if (fSpentIndex) {
@@ -1901,12 +1942,8 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
         return state.DoS(10, error("%s: conflicting with chainlock", __func__), REJECT_INVALID, "bad-chainlock");
     }
 
-    // verify that the view's current state corresponds to the previous block
-    uint256 hashPrevBlock = pindex->pprev == NULL ? uint256() : pindex->pprev->GetBlockHash();
-    assert(hashPrevBlock == view.GetBestBlock());
-
     if (pindex->pprev) {
-        bool fDIP0003Active = pindex->nHeight >= chainparams.GetConsensus().DIP0003Height;
+        bool fDIP0003Active = VersionBitsState(pindex->pprev, Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0003, versionbitscache) == THRESHOLD_ACTIVE;
         bool fHasBestBlock = evoDb->VerifyBestBlock(pindex->pprev->GetBlockHash());
 
         if (fDIP0003Active && !fHasBestBlock) {
@@ -1915,6 +1952,10 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
         }
     }
 
+    // verify that the view's current state corresponds to the previous block
+    uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
+    assert(hashPrevBlock == view.GetBestBlock());
+
     // Special case for the genesis block, skipping connection of its transactions
     // (its coinbase is unspendable)
     if (block.GetHash() == chainparams.GetConsensus().hashGenesisBlock) {
@@ -1923,6 +1964,11 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
         return true;
     }
 
+    if (pindex->nHeight > Params().GetConsensus().nLastPoWBlock && block.IsProofOfWork()) {
+        return state.DoS(100, error("ConnectBlock() : PoW period ended"),
+                         REJECT_INVALID, "PoW-ended");
+    }
+
     bool fScriptChecks = true;
     if (!hashAssumeValid.IsNull()) {
         // We've been configured with the hash of a block which has been externally verified to have a valid history.
@@ -2037,11 +2083,15 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
     std::vector<int> prevheights;
     CAmount nFees = 0;
     int nInputs = 0;
+    CAmount nValueOut = 0;
+    CAmount nValueIn = 0;
     unsigned int nSigOps = 0;
     CDiskTxPos pos(pindex->GetBlockPos(), GetSizeOfCompactSize(block.vtx.size()));
     std::vector<std::pair<uint256, CDiskTxPos> > vPos;
     vPos.reserve(block.vtx.size());
     blockundo.vtxundo.reserve(block.vtx.size() - 1);
+    std::vector<PrecomputedTransactionData> txdata;
+    txdata.reserve(block.vtx.size());
     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > addressUnspentIndex;
     std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> > spentIndex;
@@ -2129,7 +2179,14 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
                                      REJECT_INVALID, "bad-blk-sigops");
             }
 
-            nFees += view.GetValueIn(tx)-tx.GetValueOut();
+        }
+
+        txdata.emplace_back(tx);
+        if (!tx.IsCoinBase())
+        {
+            if (!tx.IsCoinStake())
+                nFees += view.GetValueIn(tx) - tx.GetValueOut();
+            nValueIn += view.GetValueIn(tx);
 
             std::vector<CScriptCheck> vChecks;
             bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
@@ -2172,6 +2229,8 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
             }
         }
 
+        nValueOut += tx.GetValueOut();
+
         CTxUndo undoDummy;
         if (i > 0) {
             blockundo.vtxundo.push_back(CTxUndo());
@@ -2181,6 +2240,12 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
         vPos.push_back(std::make_pair(tx.GetHash(), pos));
         pos.nTxOffset += ::GetSerializeSize(tx, SER_DISK, CLIENT_VERSION);
     }
+
+    // ppcoin: track money supply and mint amount info
+    CAmount nMoneySupplyPrev = pindex->pprev ? pindex->pprev->nMoneySupply : 0;
+    pindex->nMoneySupply = nMoneySupplyPrev + nValueOut - nValueIn;
+    pindex->nMint = pindex->nMoneySupply - nMoneySupplyPrev;
+
     int64_t nTime3 = GetTimeMicros(); nTimeConnect += nTime3 - nTime2;
     LogPrint("bench", "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs]\n", (unsigned)block.vtx.size(), 0.001 * (nTime3 - nTime2), 0.001 * (nTime3 - nTime2) / block.vtx.size(), nInputs <= 1 ? 0 : 0.001 * (nTime3 - nTime2) / (nInputs-1), nTimeConnect * 0.000001);
 
@@ -2265,6 +2330,9 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
     int64_t nTime5_4 = GetTimeMicros(); nTimePayeeValid += nTime5_4 - nTime5_3;
     LogPrint("bench", "      - IsBlockPayeeValid: %.2fms [%.2fs]\n", 0.001 * (nTime5_4 - nTime5_3), nTimePayeeValid * 0.000001);
 
+    bool isProofOfStake = !block.IsProofOfWork();
+    const auto& coinbaseTransaction = block.vtx[isProofOfStake];
+
     if (!ProcessSpecialTxsInBlock(block, pindex, state, fJustCheck, fScriptChecks)) {
         return error("ConnectBlock(DASH): ProcessSpecialTxsInBlock for block %s failed with %s",
                      pindex->GetBlockHash().ToString(), FormatStateMessage(state));
@@ -2304,6 +2372,27 @@ static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockInd
         if (!pblocktree->WriteTxIndex(vPos))
             return AbortNode(state, "Failed to write transaction index");
 
+    // add new entries
+    for (const CTransactionRef ptx: block.vtx) {
+        const CTransaction& tx = *ptx;
+        if (tx.IsCoinBase())
+            continue;
+        for (const CTxIn in: tx.vin) {
+            LogPrintf("mapStakeSpent: Insert %s | %u\n", in.prevout.ToString(), pindex->nHeight);
+            mapStakeSpent.insert(std::make_pair(in.prevout, pindex->nHeight));
+        }
+    }
+
+    // delete old entries
+    for (auto it = mapStakeSpent.begin(); it != mapStakeSpent.end();) {
+        if (it->second < pindex->nHeight - Params().MaxReorganizationDepth()) {
+            LogPrintf("mapStakeSpent: Erase %s | %u\n", it->first.ToString(), it->second);
+            it = mapStakeSpent.erase(it);
+        }else {
+            it++;
+        }
+    }
+
     if (fAddressIndex) {
         if (!pblocktree->WriteAddressIndex(addressIndex)) {
             return AbortNode(state, "Failed to write address index");
@@ -3076,6 +3165,56 @@ bool ResetBlockFailureFlags(CBlockIndex *pindex) {
     return true;
 }
 
+static void AcceptProofOfStakeBlock(const CBlock &block, CBlockIndex *pindexNew)
+{
+    if(!pindexNew)
+        return;
+
+    if (block.IsProofOfStake()) {
+        pindexNew->SetProofOfStake();
+        pindexNew->prevoutStake = block.vtx[1]->vin[0].prevout;
+        pindexNew->nStakeTime = block.nTime;
+    } else {
+        pindexNew->prevoutStake.SetNull();
+        pindexNew->nStakeTime = 0;
+    }
+
+    //update previous block pointer
+    //        pindexNew->pprev->pnext = pindexNew;
+
+    // ppcoin: compute chain trust score
+    pindexNew->bnChainTrust = (pindexNew->pprev ? pindexNew->pprev->bnChainTrust : ArithToUint256(0 + pindexNew->GetBlockTrust()));
+
+    // ppcoin: compute stake entropy bit for stake modifier
+    if (!pindexNew->SetStakeEntropyBit(pindexNew->GetStakeEntropyBit()))
+        LogPrintf("AcceptProofOfStakeBlock() : SetStakeEntropyBit() failed \n");
+
+    uint256 hash = block.GetHash();
+
+    // ppcoin: record proof-of-stake hash value
+    if (pindexNew->IsProofOfStake()) {
+        if (!mapProofOfStake.count(hash))
+            LogPrintf("AcceptProofOfStakeBlock() : hashProofOfStake not found in map \n");
+        pindexNew->hashProofOfStake = mapProofOfStake[hash];
+    }
+
+    // ppcoin: compute stake modifier
+    uint64_t nStakeModifier = 0;
+    bool fGeneratedStakeModifier = false;
+    if (!ComputeNextStakeModifier(pindexNew, nStakeModifier, fGeneratedStakeModifier))
+        LogPrintf("AcceptProofOfStakeBlock() : ComputeNextStakeModifier() failed \n");
+    pindexNew->SetStakeModifier(nStakeModifier, fGeneratedStakeModifier);
+    pindexNew->nStakeModifierChecksum = GetStakeModifierChecksum(pindexNew);
+    if (!CheckStakeModifierCheckpoints(pindexNew->nHeight, pindexNew->nStakeModifierChecksum)) {
+        LogPrintf("AcceptProofOfStakeBlock() : Rejected by stake modifier checkpoint height=%d, modifier=%s \n", pindexNew->nHeight, std::to_string(nStakeModifier));
+        LogPrintf("pindexNew->nStakeModifierChecksum = %08x\n", pindexNew->nStakeModifierChecksum);
+    } else {
+        LogPrintf("AcceptProofOfStakeBlock() : Accepted stake modifier - checksum %08x\n", pindexNew->nStakeModifierChecksum);
+    }
+
+    setDirtyBlockIndex.insert(pindexNew);
+}
+
 CBlockIndex* AddToBlockIndex(const CBlockHeader& block, enum BlockStatus nStatus = BLOCK_VALID_TREE)
 {
     // Check for duplicate
@@ -3101,6 +3240,7 @@ CBlockIndex* AddToBlockIndex(const CBlockHeader& block, enum BlockStatus nStatus
         pindexNew->BuildSkip();
     }
     pindexNew->nTimeMax = (pindexNew->pprev ? std::max(pindexNew->pprev->nTimeMax, pindexNew->nTime) : pindexNew->nTime);
+
     pindexNew->nChainWork = (pindexNew->pprev ? pindexNew->pprev->nChainWork : 0) + GetBlockProof(*pindexNew);
     if (nStatus & BLOCK_VALID_MASK) {
         pindexNew->RaiseValidity(nStatus);
@@ -3167,7 +3307,7 @@ bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBl
     return true;
 }
 
-bool FindBlockPos(CValidationState &state, CDiskBlockPos &pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown = false)
+bool FindBlockPos(/*CValidationState &state,*/CDiskBlockPos &pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown = false)
 {
     LOCK(cs_LastBlockFile);
 
@@ -3216,7 +3356,7 @@ bool FindBlockPos(CValidationState &state, CDiskBlockPos &pos, unsigned int nAdd
                 }
             }
             else
-                return state.Error("out of disk space");
+                return error("out of disk space");
         }
     }
 
@@ -3281,7 +3421,7 @@ bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::P
 
     // Check that the header is valid (particularly PoW).  This is mostly
     // redundant with the call in AcceptBlockHeader.
-    if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW))
+    if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW && block.IsProofOfWork()))
         return false;
 
     // Check the merkle root.
@@ -3313,6 +3453,16 @@ bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::P
         if (block.vtx[i]->IsCoinBase())
             return state.DoS(100, false, REJECT_INVALID, "bad-cb-multiple", false, "more than one coinbase");
 
+    if (block.IsProofOfStake()) {
+
+        // Second transaction must be coinstake, the rest must not be
+        if (block.vtx.empty() || !block.vtx[1]->IsCoinStake())
+            return state.DoS(100, error("CheckBlock() : second tx is not coinstake"));
+        for (unsigned int i = 2; i < block.vtx.size(); i++)
+            if (block.vtx[i]->IsCoinStake())
+                return state.DoS(100, error("CheckBlock() : more than one coinstake"));
+    }
+
     // Check transactions
     for (const auto& tx : block.vtx)
         if (!CheckTransaction(*tx, state))
@@ -3352,28 +3502,26 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta
 {
     assert(pindexPrev != NULL);
     const int nHeight = pindexPrev->nHeight + 1;
-    // Check proof of work
-    if(Params().NetworkIDString() == CBaseChainParams::MAIN && nHeight <= 68589){
-        // architecture issues with DGW v1 and v2)
-        unsigned int nBitsNext = GetNextWorkRequired(pindexPrev, &block, consensusParams);
-        double n1 = ConvertBitsToDouble(block.nBits);
-        double n2 = ConvertBitsToDouble(nBitsNext);
-
-        if (abs(n1-n2) > n1*0.5)
-            return state.DoS(100, error("%s : incorrect proof of work (DGW pre-fork) - %f %f %f at %d", __func__, abs(n1-n2), n1, n2, nHeight),
-                            REJECT_INVALID, "bad-diffbits");
-    } else {
-        if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
-            return state.DoS(100, false, REJECT_INVALID, "bad-diffbits", false, strprintf("incorrect proof of work at %d", nHeight));
+
+    // Test PoW block difficulty
+    if (block.nNonce != uint32_t(0) && (block.nBits != GetNextWorkRequired(pindexPrev, consensusParams))) {
+        return state.DoS(100, false, REJECT_INVALID, "bad-diffbits", false, strprintf("incorrect proof of work at %d", nHeight));
     }
 
+    // Limit damage by PoSv3 potential vulnerabilities (barrystyle/giaki3003 2019)
+    if (block.nNonce == uint32_t(0) && (block.GetBlockTime() > nAdjustedTime + MAX_FUTURE_STAKE_TIME))
+        return state.Invalid(false, REJECT_INVALID, "time-too-new", 
+                                 strprintf("PoS block timestamp too far in the future %d %d", block.GetBlockTime(), nAdjustedTime + MAX_FUTURE_STAKE_TIME));
+
     // Check timestamp against prev
     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
-        return state.Invalid(false, REJECT_INVALID, "time-too-old", strprintf("block's timestamp is too early %d %d", block.GetBlockTime(), pindexPrev->GetMedianTimePast()));
+        return state.Invalid(false, REJECT_INVALID, "time-too-old", 
+                                 strprintf("block's timestamp is too early %d %d", block.GetBlockTime(), pindexPrev->GetMedianTimePast()));
 
     // Check timestamp
     if (block.GetBlockTime() > nAdjustedTime + MAX_FUTURE_BLOCK_TIME)
-        return state.Invalid(false, REJECT_INVALID, "time-too-new", strprintf("block timestamp too far in the future %d %d", block.GetBlockTime(), nAdjustedTime + 2 * 60 * 60));
+        return state.Invalid(false, REJECT_INVALID, "time-too-new", 
+                                 strprintf("block timestamp too far in the future %d %d", block.GetBlockTime(), nAdjustedTime + 2 * 60 * 60));
 
     // check for version 2, 3 and 4 upgrades
     if((block.nVersion < 2 && nHeight >= consensusParams.BIP34Height) ||
@@ -3389,6 +3537,38 @@ bool ContextualCheckBlock(const CBlock& block, CValidationState& state, const Co
 {
     const int nHeight = pindexPrev == NULL ? 0 : pindexPrev->nHeight + 1;
 
+    // always return true for genesis block (assumed valid)
+    if (block.GetHash() == Params().GenesisBlock().GetHash())
+        return true;
+
+    // nullptr check to prevent segfaults
+    if (!pindexPrev)
+        return state.DoS(100, false, REJECT_INVALID, "bad-pindex-prev", false, strprintf("current block is not genesis but has null previous"));
+
+    // Test if stake matches target given
+    uint256 hashProofOfStake = uint256();
+    if (block.IsProofOfStake())
+    {
+        uint256 hash = block.GetHash();
+        if(!CheckProofOfStake(block, hashProofOfStake))
+           return state.DoS(100, error("CheckBlock(): check proof-of-stake failed for block %s\n", hash.ToString().c_str()));
+
+        if(hashProofOfStake == uint256())
+           return state.DoS(100, error("CheckBlock(): check proof-of-stake failed for block %s\n", hash.ToString().c_str()));
+
+        if(!mapProofOfStake.count(hash)) // add to mapProofOfStake
+            mapProofOfStake.insert(std::make_pair(hash, hashProofOfStake));
+    }
+
+    // Check difficulty
+    if (block.nBits != GetNextWorkRequired(pindexPrev, consensusParams, block.IsProofOfStake()))
+        return state.DoS(100, false, REJECT_INVALID, "bad-diffbits", false, strprintf("incorrect difficulty: block pow=%d bits=%08x calc=%08x",
+                  block.IsProofOfWork() ? "Y" : "N", block.nBits, GetNextWorkRequired(pindexPrev, consensusParams, block.IsProofOfStake())));
+    else
+        LogPrintf("Block pow=%s bits=%08x found=%08x %s=%s\n", block.IsProofOfWork() ? "Y" : "N", GetNextWorkRequired(pindexPrev,
+                  consensusParams, block.IsProofOfStake()), block.nBits, block.IsProofOfWork() ? "powhash" : "hashproof",
+                  block.IsProofOfWork() ? block.GetHash().ToString().c_str() : hashProofOfStake.ToString().c_str());
+
     // Start enforcing BIP113 (Median Time Past) using versionbits logic.
     int nLockTimeFlags = 0;
     if (VersionBitsState(pindexPrev, consensusParams, Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) {
@@ -3442,6 +3622,12 @@ bool ContextualCheckBlock(const CBlock& block, CValidationState& state, const Co
         }
     }
 
+    if(block.IsProofOfStake())
+    {
+        // Coinbase output should be empty if proof-of-stake block
+        if (!block.vtx[0]->vout[0].IsEmpty())
+            return state.DoS(100, error("CheckBlock() : coinbase output not empty for proof-of-stake block"));
+    }
     return true;
 }
 
@@ -3466,7 +3652,7 @@ static bool AcceptBlockHeader(const CBlockHeader& block, CValidationState& state
             return true;
         }
 
-        if (!CheckBlockHeader(block, state, chainparams.GetConsensus()))
+        if (!CheckBlockHeader(block, state, chainparams.GetConsensus(), false))
             return error("%s: Consensus::CheckBlockHeader: %s, %s", __func__, hash.ToString(), FormatStateMessage(state));
 
         // Get prev block index
@@ -3530,6 +3716,25 @@ bool ProcessNewBlockHeaders(const std::vector<CBlockHeader>& headers, CValidatio
     return true;
 }
 
+/** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */
+static CDiskBlockPos SaveBlockToDisk(const CBlock& block, int nHeight, const CChainParams& chainparams, const CDiskBlockPos* dbp) {
+    unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
+    CDiskBlockPos blockPos;
+    if (dbp != nullptr)
+        blockPos = *dbp;
+    if (!FindBlockPos(blockPos, nBlockSize+8, nHeight, block.GetBlockTime(), dbp != nullptr)) {
+        error("%s: FindBlockPos failed", __func__);
+        return CDiskBlockPos();
+    }
+    if (dbp == nullptr) {
+        if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart())) {
+            AbortNode("Failed to write block");
+            return CDiskBlockPos();
+        }
+    }
+    return blockPos;
+}
+
 /** Store block on disk. If dbp is non-NULL, the file is known to already reside on disk */
 static bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CValidationState& state, const CChainParams& chainparams, CBlockIndex** ppindex, bool fRequested, const CDiskBlockPos* dbp, bool* fNewBlock)
 {
@@ -3541,6 +3746,12 @@ static bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CValidation
     CBlockIndex *pindexDummy = NULL;
     CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
 
+    CBlockIndex* pindexPrev = nullptr;
+    BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
+    if (mi == mapBlockIndex.end())
+        return state.DoS(10, error("%s: prev block not found", __func__), 0, "prev-blk-not-found");
+    pindexPrev = (*mi).second;
+
     if (!AcceptBlockHeader(block, state, chainparams, &pindex))
         return false;
 
@@ -3580,25 +3791,75 @@ static bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CValidation
         return error("%s: %s", __func__, FormatStateMessage(state));
     }
 
+    AcceptProofOfStakeBlock(block, pindex);
+
     // Header is valid/has work, merkle tree is good...RELAY NOW
     // (but if it does not build on our best tip, let the SendMessages loop relay it)
     if (!IsInitialBlockDownload() && chainActive.Tip() == pindex->pprev)
         GetMainSignals().NewPoWValidBlock(pindex, pblock);
 
-    int nHeight = pindex->nHeight;
+    if (block.IsProofOfStake()) {
+        LOCK(cs_main);
+
+        CCoinsViewCache coins(pcoinsTip);
+
+        const CTransaction& tx = *block.vtx[1];
+        if (!coins.HaveInputs(tx)) {
+            // the inputs are spent at the chain tip so we should look at the recently spent outputs
+
+            for (CTxIn in : tx.vin) {
+                auto it = mapStakeSpent.find(in.prevout);
+                if (it == mapStakeSpent.end()) {
+                    return false;
+                }
+                if (it->second < pindexPrev->nHeight) {
+                    return false;
+                }
+            }
+        }
+
+        // if this is on fork
+        if (!chainActive.Contains(pindexPrev) && pindexPrev != nullptr) {
+            // start at the block we're adding on to
+            CBlockIndex *last = pindexPrev;
+
+            // while that block is not on the main chain
+            while (!chainActive.Contains(last) && last != NULL) {
+                CBlock bl;
+                ReadBlockFromDisk(bl, last, Params().GetConsensus());
+                // loop through every spent input from said block
+
+                for (CTransactionRef tRef : bl.vtx) {
+                    const CTransaction& t = *tRef;
+                    for (CTxIn in : t.vin) {
+                        // loop through every spent input in the staking transaction of the new block
+
+                        const CTransaction& tx = *block.vtx[1];
+                        for (CTxIn stakeIn : tx.vin) {
+
+                            // if they spent the same input
+                            if (stakeIn.prevout == in.prevout) {
+                                // reject the block
+                                return false;
+                            }
+                        }
+                    }
+                }
+
+                // go to the parent block
+                last = last->pprev;
+            }
+        }
+    }
 
     // Write block to history file
     try {
-        unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
-        CDiskBlockPos blockPos;
-        if (dbp != NULL)
-            blockPos = *dbp;
-        if (!FindBlockPos(state, blockPos, nBlockSize+8, nHeight, block.GetBlockTime(), dbp != NULL))
-            return error("AcceptBlock(): FindBlockPos failed");
-        if (dbp == NULL)
-            if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
-                AbortNode(state, "Failed to write block");
-        if (!ReceivedBlockTransactions(block, state, pindex, blockPos))
+        CDiskBlockPos blockPos = SaveBlockToDisk(block, pindex->nHeight, chainparams, dbp);
+        if (blockPos.IsNull()) {
+            state.Error(strprintf("%s: Failed to find position to write new block to disk", __func__));
+            return false;
+        }
+        if (!ReceivedBlockTransactions(block, state, pindex, blockPos /*, chainparams.GetConsensus()*/))
             return error("AcceptBlock(): ReceivedBlockTransactions failed");
     } catch (const std::runtime_error& e) {
         return AbortNode(state, std::string("System error: ") + e.what());
@@ -4158,11 +4419,12 @@ static bool AddGenesisBlock(const CChainParams& chainparams, const CBlock& block
     // Start new block file
     unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
     CDiskBlockPos blockPos;
-    if (!FindBlockPos(state, blockPos, nBlockSize+8, 0, block.GetBlockTime()))
+    if (!FindBlockPos(/*state,*/blockPos, nBlockSize+8, 0, block.GetBlockTime()))
         return error("%s: FindBlockPos failed", __func__);
     if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
         return error("%s: writing genesis block to disk failed", __func__);
     CBlockIndex *pindex = AddToBlockIndex(block);
+    AcceptProofOfStakeBlock(block, pindex);
     if (!ReceivedBlockTransactions(block, state, pindex, blockPos))
         return error("%s: genesis block not accepted", __func__);
     return true;
diff --git a/src/validation.h b/src/validation.h
index 6be85f4ae6a3d..2772cb77464df 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -47,6 +47,7 @@ class CValidationInterface;
 class CValidationState;
 struct ChainTxData;
 
+struct PrecomputedTransactionData;
 struct LockPoints;
 
 /** Default for accepting alerts from the P2P network. */
@@ -288,6 +289,7 @@ bool ActivateBestChain(CValidationState& state, const CChainParams& chainparams,
 
 double ConvertBitsToDouble(unsigned int nBits);
 CAmount GetBlockSubsidy(int nBits, int nHeight, const Consensus::Params& consensusParams, bool fSuperblockPartOnly = false);
+CAmount GetBlockSubsidy(int nPrevHeight, const Consensus::Params& consensusParams, bool fSuperblockPartOnly = false);
 CAmount GetMasternodePayment(int nHeight, CAmount blockValue);
 
 /** Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip). */
@@ -448,6 +450,7 @@ class CScriptCheck
     unsigned int nFlags;
     bool cacheStore;
     ScriptError error;
+    PrecomputedTransactionData *txdata;
 
 public:
     CScriptCheck(): ptxTo(0), nIn(0), nFlags(0), cacheStore(false), error(SCRIPT_ERR_UNKNOWN_ERROR) {}
diff --git a/src/validationinterface.h b/src/validationinterface.h
index f4ac971bad8e7..4f7f24f9cf2cf 100644
--- a/src/validationinterface.h
+++ b/src/validationinterface.h
@@ -50,7 +50,7 @@ class CValidationInterface {
     virtual void Inventory(const uint256 &hash) {}
     virtual void ResendWalletTransactions(int64_t nBestBlockTime, CConnman* connman) {}
     virtual void BlockChecked(const CBlock&, const CValidationState&) {}
-    virtual void GetScriptForMining(boost::shared_ptr<CReserveScript>&) {}
+    virtual void GetScriptForMining(std::shared_ptr<CReserveScript>&) {}
     virtual void ResetRequestCount(const uint256 &hash) {}
     virtual void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& block) {}
     friend void ::RegisterValidationInterface(CValidationInterface*);
@@ -99,7 +99,7 @@ struct CMainSignals {
     /** Notifies listeners of a block validation result */
     boost::signals2::signal<void (const CBlock&, const CValidationState&)> BlockChecked;
     /** Notifies listeners that a key for mining is required (coinbase) */
-    boost::signals2::signal<void (boost::shared_ptr<CReserveScript>&)> ScriptForMining;
+    boost::signals2::signal<void (std::shared_ptr<CReserveScript>&)> ScriptForMining;
     /** Notifies listeners that a block has been successfully mined */
     boost::signals2::signal<void (const uint256 &)> BlockFound;
     /**
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 4fdd185d93e70..44d0228b190e2 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -12,8 +12,10 @@
 #include "wallet/coincontrol.h"
 #include "consensus/consensus.h"
 #include "consensus/validation.h"
+#include "kernel.h"
 #include "key.h"
 #include "keystore.h"
+#include "masternode-payments.h"
 #include "validation.h"
 #include "net.h"
 #include "policy/policy.h"
@@ -399,6 +401,11 @@ bool CWallet::AddWatchOnly(const CScript& dest)
     return CWalletDB(strWalletFile).WriteWatchOnly(dest, meta);
 }
 
+CAmount GetStakeReward(CAmount blockReward, unsigned int percentage)
+{
+    return (blockReward / 100) * percentage;
+}
+
 bool CWallet::AddWatchOnly(const CScript& dest, int64_t nCreateTime)
 {
     mapKeyMetadata[CScriptID(dest)].nCreateTime = nCreateTime;
@@ -3734,6 +3741,217 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletT
     return true;
 }
 
+bool CWallet::CreateCoinStakeKernel(CScript &kernelScript, const CScript &stakeScript,
+                                    unsigned int nBits, const CBlock &blockFrom,
+                                    unsigned int nTxPrevOffset, const CTransactionRef &txPrev,
+                                    const COutPoint &prevout, unsigned int &nTimeTx, bool fPrintProofOfStake) const
+{
+    unsigned int nTryTime = 0;
+    uint256 hashProofOfStake;
+
+    if (blockFrom.GetBlockTime() + Params().GetConsensus().nStakeMinAge + nHashDrift > nTimeTx) // Min age requirement
+        return false;
+    for(unsigned int i = 0; i < nHashDrift; ++i)
+    {
+        nTryTime = nTimeTx - i;
+        if (CheckStakeKernelHash(nBits, blockFrom, nTxPrevOffset, txPrev, prevout, nTryTime, hashProofOfStake, true, false))
+        {
+            //Double check that this will pass time requirements
+            if (nTryTime <= chainActive.Tip()->GetMedianTimePast()) {
+                LogPrintf("CreateCoinStakeKernel() : kernel found, but it is too far in the past \n");
+                continue;
+            }
+            // Found a kernel
+            LogPrintf("CreateCoinStakeKernel : kernel found\n");
+            kernelScript.clear();
+            kernelScript = stakeScript;
+            nTimeTx = nTryTime;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool CWallet::MintableCoins()
+{
+    std::vector<COutput> vCoins;
+    LOCK2(cs_main, cs_wallet);
+    AvailableCoins(vCoins, true);
+
+    for (const COutput& out : vCoins)
+    {
+        if (GetTime() - out.tx->GetTxTime() > Params().GetConsensus().nStakeMinAge)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CWallet::SelectStakeCoins(StakeCoinsSet &setCoins, CAmount nTargetAmount, const CScript &scriptFilterPubKey) const
+{
+    std::vector<COutput> vCoins;
+    CCoinControl coinControl;
+    coinControl.fAllowWatchOnly = !scriptFilterPubKey.empty();
+    {
+        LOCK2(cs_main, cs_wallet);
+        AvailableCoins(vCoins, !scriptFilterPubKey.empty(), &coinControl);
+    }
+    CAmount nAmountSelected = 0;
+
+    std::set<CScript> rejectCache;
+
+    for (const COutput& out : vCoins) {
+
+        CScript scriptPubKeyKernel;
+        scriptPubKeyKernel = out.tx->tx->vout[out.i].scriptPubKey;
+
+        if(!coinControl.fAllowWatchOnly && !out.fSpendable)
+            continue;
+
+        CTxDestination dest;
+        if(!ExtractDestination(scriptPubKeyKernel, dest))
+            continue;
+
+        if (GetTime() - out.tx->GetTxTime() < Params().GetConsensus().nStakeMinAge)
+            continue;
+
+        if (out.nDepth < (out.tx->tx->IsCoinStake() ? COINBASE_MATURITY : 10))
+            continue;
+
+        auto scriptPubKeyCoin = out.tx->tx->vout[out.i].scriptPubKey;
+        if(!scriptFilterPubKey.empty() && scriptPubKeyCoin != scriptFilterPubKey)
+            continue;
+
+        if(rejectCache.count(scriptPubKeyCoin))
+            continue;
+
+        nAmountSelected += out.tx->tx->vout[out.i].nValue;
+        setCoins.emplace(out.tx, out.i);
+
+    }
+    return true;
+}
+
+void CWallet::FillCoinStakePayments(CMutableTransaction &transaction,
+                                    const CScript &scriptPubKeyOut,
+                                    const COutPoint &stakePrevout,
+                                    CAmount blockReward) const
+{
+    const CWalletTx *walletTx = GetWalletTx(stakePrevout.hash);
+    CTxOut prevTxOut = walletTx->tx->vout[stakePrevout.n];
+    auto nCredit = prevTxOut.nValue;
+    unsigned int percentage = 100;
+
+    auto nCoinStakeReward = nCredit + GetStakeReward(blockReward, percentage);
+    transaction.vin.emplace_back(CTxIn(stakePrevout));
+    //presstab HyperStake - calculate the total size of our new output including the stake reward so that we can use it to decide whether to split the stake outputs
+    // adding output which will pay to coin stake
+    transaction.vout.emplace_back(nCoinStakeReward, scriptPubKeyOut);
+    {
+        CTxOut &lastTx = transaction.vout.back();
+        if(lastTx.nValue / 2 > nStakeSplitThreshold * COIN)
+        {
+            lastTx.nValue /= 2;
+            transaction.vout.emplace_back(lastTx.nValue, lastTx.scriptPubKey);
+        }
+    }
+}
+
+typedef std::vector<unsigned char> valtype;
+bool CWallet::CreateCoinStake(const CKeyStore& keystore,
+                              unsigned int nBits,
+                              CAmount blockReward,
+                              CMutableTransaction &txNew,
+                              unsigned int &nTxNewTime,
+                              std::vector<const CWalletTx*> &vwtxPrev)
+{
+    // The following split & combine thresholds are important to security
+    // Should not be adjusted if you don't understand the consequences
+    //int64_t nCombineThreshold = 0;
+    txNew.vin.clear();
+    txNew.vout.clear();
+
+    // Mark coin stake transaction
+    CScript scriptEmpty;
+    scriptEmpty.clear();
+    txNew.vout.push_back(CTxOut(0, scriptEmpty));
+
+    // Choose coins to use
+    CAmount nBalance = GetBalance();
+
+    // presstab HyperStake - Initialize as static and don't update the set on every run of CreateCoinStake() in order to lighten resource use
+    static StakeCoinsSet setStakeCoins;
+    static int nLastStakeSetUpdate = 0;
+
+    if (GetTime() - nLastStakeSetUpdate > nStakeSetUpdateTime) {
+        setStakeCoins.clear();
+
+        CScript scriptPubKey;
+
+        if (!SelectStakeCoins(setStakeCoins, nBalance, scriptPubKey)) {
+            return error("Failed to select coins for staking");
+        }
+
+        LogPrintf("Selected %d coins for staking\n", setStakeCoins.size());
+
+        nLastStakeSetUpdate = GetTime();
+    }
+
+    if (setStakeCoins.empty())
+        return error("CreateCoinStake() : No Coins to stake");
+
+    CScript scriptPubKeyKernel;
+
+    //prevent staking a time that won't be accepted
+    if (GetAdjustedTime() <= chainActive.Tip()->nTime)
+        MilliSleep(10000);
+
+    bool fKernelFound = false;
+    for(const std::pair<const CWalletTx*, unsigned int> &pcoin : setStakeCoins)
+    {
+        //make sure that enough time has elapsed between
+        CBlockIndex* pindex = NULL;
+        BlockMap::iterator it = mapBlockIndex.find(pcoin.first->hashBlock);
+        if (it != mapBlockIndex.end())
+            pindex = it->second;
+        else {
+            LogPrintf("failed to find block index ");
+            continue;
+        }
+        // Read block header
+        CBlockHeader block = pindex->GetBlockHeader();
+        COutPoint prevoutStake = COutPoint(pcoin.first->GetHash(), pcoin.second);
+        nTxNewTime = GetAdjustedTime();
+        //iterates each utxo inside of CheckStakeKernelHash()
+        CScript kernelScript;
+        auto stakeScript = pcoin.first->tx->vout[pcoin.second].scriptPubKey;
+        fKernelFound = CreateCoinStakeKernel(kernelScript, stakeScript, nBits,
+                                             block, sizeof(CBlock), pcoin.first->tx,
+                                             prevoutStake, nTxNewTime, false);
+        if(fKernelFound)
+        {
+            FillCoinStakePayments(txNew, kernelScript, prevoutStake, blockReward);
+            break;
+        }
+    }
+    if(!fKernelFound)
+    {
+        LogPrintf("Failed to find coinstake kernel");
+        return false;
+    }
+
+    // Update coinbase transaction with additional info about masternode and governance payments,
+    // get some info back to pass to getblocktemplate
+    std::vector<CTxOut> txoutMasternodeRet;
+    std::vector<CTxOut> voutSuperblockRet;
+    int nHeight = chainActive.Tip()->nHeight + 1;
+    FillBlockPayments(txNew, nHeight, blockReward, txoutMasternodeRet, voutSuperblockRet);
+    nLastStakeSetUpdate = 0;
+    return true;
+}
+
 /**
  * Call after CreateTransaction unless you want to abort
  */
@@ -4484,9 +4702,9 @@ bool CWallet::UpdatedTransaction(const uint256 &hashTx)
     return false;
 }
 
-void CWallet::GetScriptForMining(boost::shared_ptr<CReserveScript> &script)
+void CWallet::GetScriptForMining(std::shared_ptr<CReserveScript> &script)
 {
-    boost::shared_ptr<CReserveKey> rKey(new CReserveKey(this));
+    std::shared_ptr<CReserveKey> rKey(new CReserveKey(this));
     CPubKey pubkey;
     if (!rKey->GetReservedKey(pubkey, false))
         return;
@@ -5415,7 +5633,7 @@ bool CMerkleTx::IsChainLocked() const
 
 int CMerkleTx::GetBlocksToMaturity() const
 {
-    if (!IsCoinBase())
+    if (!IsCoinBase() && !IsCoinStake())
         return 0;
     return std::max(0, (COINBASE_MATURITY+1) - GetDepthInMainChain());
 }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index fc5e95e05f670..4094731ba1d4b 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -282,6 +282,7 @@ class CMerkleTx
 
     const uint256& GetHash() const { return tx->GetHash(); }
     bool IsCoinBase() const { return tx->IsCoinBase(); }
+    bool IsCoinStake() const { return tx->IsCoinStake(); }
 };
 
 /** 
@@ -693,6 +694,11 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     int64_t nLastResend;
     bool fBroadcastTransactions;
 
+    // Stake Settings
+    unsigned int nHashDrift = 45;
+    unsigned int nHashInterval = 22;
+    int nStakeSetUpdateTime = 300; // 5 mins
+
     mutable bool fAnonymizableTallyCached;
     mutable std::vector<CompactTallyItem> vecAnonymizableTallyCached;
     mutable bool fAnonymizableTallyCachedNonDenom;
@@ -717,6 +723,13 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
 
     /* HD derive new child key (on internal or external chain) */
     void DeriveNewChildKey(const CKeyMetadata& metadata, CKey& secretRet, uint32_t nAccountIndex, bool fInternal /*= false*/);
+    bool CreateCoinStakeKernel(CScript &kernelScript, const CScript &stakeScript,
+                               unsigned int nBits, const CBlock& blockFrom,
+                               unsigned int nTxPrevOffset, const CTransactionRef &txPrev,
+                               const COutPoint& prevout, unsigned int &nTimeTx, bool fPrintProofOfStake) const;
+    void FillCoinStakePayments(CMutableTransaction &transaction,
+                               const CScript &kernelScript,
+                               const COutPoint &stakePrevout, CAmount blockReward) const;
 
     bool fFileBacked;
 
@@ -791,6 +804,8 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
         pwalletdbEncryption = NULL;
     }
 
+    uint64_t nStakeSplitThreshold = 2000;
+
     void SetNull()
     {
         nWalletVersion = FEATURE_BASE;
@@ -851,6 +866,9 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     bool SelectPSInOutPairsByDenominations(int nDenom, CAmount nValueMin, CAmount nValueMax, std::vector< std::pair<CTxDSIn, CTxOut> >& vecPSInOutPairsRet);
     bool GetCollateralTxDSIn(CTxDSIn& txdsinRet, CAmount& nValueRet) const;
     bool SelectPrivateCoins(CAmount nValueMin, CAmount nValueMax, std::vector<CTxIn>& vecTxInRet, CAmount& nValueRet, int nPrivateSendRoundsMin, int nPrivateSendRoundsMax) const;
+    using StakeCoinsSet = std::set<std::pair<const CWalletTx*, unsigned int>>;
+    bool MintableCoins();
+    bool SelectStakeCoins(StakeCoinsSet &setCoins, CAmount nTargetAmount, const CScript &scriptFilterPubKey) const;
 
     bool SelectCoinsGroupedByAddresses(std::vector<CompactTallyItem>& vecTallyRet, bool fSkipDenominated = true, bool fAnonymizable = true, bool fSkipUnconfirmed = true, int nMaxOupointsPerAddress = -1) const;
 
@@ -982,6 +1000,9 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
      */
     bool CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRet, int& nChangePosInOut,
                            std::string& strFailReason, const CCoinControl *coinControl = NULL, bool sign = true, AvailableCoinsType nCoinType=ALL_COINS, bool fUseInstantSend=false, int nExtraPayloadSize = 0);
+    bool CreateCoinStake(const CKeyStore& keystore, unsigned int nBits, CAmount blockReward,
+                         CMutableTransaction& txNew, unsigned int& nTxNewTime,
+                         std::vector<const CWalletTx *> &vwtxPrev);
     bool CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey, CConnman* connman, CValidationState& state, const std::string& strCommand="tx");
 
     bool CreateCollateralTransaction(CMutableTransaction& txCollateral, std::string& strReason);
@@ -1068,7 +1089,7 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
         }
     }
 
-    void GetScriptForMining(boost::shared_ptr<CReserveScript> &script) override;
+    void GetScriptForMining(std::shared_ptr<CReserveScript> &script);
     void ResetRequestCount(const uint256 &hash) override
     {
         LOCK(cs_wallet);
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 645c8b21e6413..2ee9c87bdacee 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -514,6 +514,10 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
         {
             ssValue >> pwallet->nOrderPosNext;
         }
+        else if (strType == "stakeSplitThreshold")
+        {
+            ssValue >> pwallet->nStakeSplitThreshold;
+        }
         else if (strType == "destdata")
         {
             std::string strAddress, strKey, strValue;
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index cad8a2cdb49b4..3014e878d2c25 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -103,7 +103,7 @@ class CWalletDB : public CDB
     bool ReadBestBlock(CBlockLocator& locator);
 
     bool WriteOrderPosNext(int64_t nOrderPosNext);
-
+    bool WriteStakeSplitThreshold(uint64_t nStakeSplitThreshold);
     bool WriteDefaultKey(const CPubKey& vchPubKey);
 
     bool ReadPool(int64_t nPool, CKeyPool& keypool);

From 1db4ad529c7723d6b213ee1951f1e0332a901d67 Mon Sep 17 00:00:00 2001
From: barrystyle <barrystyle@westnet.com.au>
Date: Thu, 18 Jul 2019 06:56:58 +0800
Subject: [PATCH 2/2] Squashed proof of stake commits (secondary set):

	1a142768aa258e66b4f848515a4939673340b831
	bf5f082c6766b3c9f0782a16627dd760f7dd59bc
	371731ba7270b39b9c29eea14ce6771c6a355391
---
 src/chainparams.cpp                        | 119 +++++++++++----------
 src/chainparamsseeds.h                     |   3 +-
 src/miner.cpp                              |  58 +++++-----
 src/net.cpp                                |   2 +-
 src/pow.cpp                                |  62 +++--------
 src/pow.h                                  |   6 +-
 src/qt/forms/askpassphrasedialog.ui        |  36 -------
 src/qt/res/images/light/splash_testnet.png | Bin 9370 -> 779484 bytes
 src/serialize.h                            |   3 +-
 src/util.cpp                               |   6 +-
 src/validation.cpp                         |  23 ++--
 11 files changed, 125 insertions(+), 193 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index e78dbe6e61cd3..26ac1b5332f31 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -19,6 +19,11 @@
 
 #include "chainparamsseeds.h"
 
+#include <stdio.h>
+
+const int32_t NEVER32 = 400000U;
+const int64_t NEVER64 = 4070908800ULL;
+
 static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 {
     CMutableTransaction txNew;
@@ -388,83 +393,83 @@ class CTestNetParams : public CChainParams {
 public:
     CTestNetParams() {
         strNetworkID = "test";
-        consensus.nSubsidyHalvingInterval = 250;
-        consensus.nMasternodePaymentsStartBlock = 500;
-        consensus.nMasternodePaymentsIncreaseBlock = 4030;
-        consensus.nMasternodePaymentsIncreasePeriod = 10;
+        consensus.nSubsidyHalvingInterval = NEVER32; // unused
+        consensus.nMasternodePaymentsStartBlock = 50;
+        consensus.nMasternodePaymentsIncreaseBlock = NEVER32;
+        consensus.nMasternodePaymentsIncreasePeriod = NEVER32;
         consensus.nInstantSendConfirmationsRequired = 2;
         consensus.nInstantSendKeepLock = 6;
         consensus.nInstantSendSigsRequired = 6;
         consensus.nInstantSendSigsTotal = 10;
-        consensus.nBudgetPaymentsStartBlock = 4100;
-        consensus.nBudgetPaymentsCycleBlocks = 50;
-        consensus.nBudgetPaymentsWindowBlocks = 10;
-        consensus.nSuperblockStartBlock = 4200; // NOTE: Should satisfy nSuperblockStartBlock > nBudgetPeymentsStartBlock
+        consensus.nBudgetPaymentsStartBlock = NEVER32;
+        consensus.nBudgetPaymentsCycleBlocks = NEVER32;
+        consensus.nBudgetPaymentsWindowBlocks = NEVER32;
+        consensus.nSuperblockStartBlock = NEVER32;
         consensus.nSuperblockStartHash = uint256(); // do not check this on testnet
         consensus.nSuperblockCycle = 24; // Superblocks can be issued hourly on testnet
         consensus.nGovernanceMinQuorum = 1;
         consensus.nGovernanceFilterElements = 500;
-        consensus.nMasternodeMinimumConfirmations = 1;
-        consensus.BIP34Height = 76;
-        consensus.BIP34Hash = uint256S("0x000008ebb1db2598e897d17275285767717c6acfeac4c73def49fbea1ddcbcb6");
-        consensus.BIP65Height = 2431;
-        consensus.BIP66Height = 2075;
-        consensus.DIP0001Height = 5500;
-        consensus.DIP0003Height = 7000;
-        consensus.DIP0003EnforcementHeight = 7300;
-        consensus.DIP0003EnforcementHash = uint256S("00000055ebc0e974ba3a3fb785c5ad4365a39637d4df168169ee80d313612f8f");
+        consensus.nMasternodeMinimumConfirmations = 15;
+        consensus.BIP34Height = 1;
+        consensus.BIP34Hash = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000");
+        consensus.BIP65Height = 0;
+        consensus.BIP66Height = 0;
+        consensus.DIP0001Height = 1;
+        consensus.DIP0003Height = 1;
+        consensus.DIP0003EnforcementHeight = 250;
+        consensus.DIP0003EnforcementHash = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000");
         consensus.powLimit = uint256S("0000fffff0000000000000000000000000000000000000000000000000000000");
-        consensus.posLimit = uint256S("0007ffff00000000000000000000000000000000000000000000000000000000");
-        consensus.nLastPoWBlock = 30;
-        consensus.nPowTargetTimespan = 180 * 4;
-        consensus.nPowTargetSpacing = 180 * 1;
+        consensus.posLimit = uint256S("007ffff000000000000000000000000000000000000000000000000000000000");
+        consensus.nLastPoWBlock = 125;
+        consensus.nPowTargetTimespan = 450;
+        consensus.nPowTargetSpacing = 150;
         consensus.nPosTargetSpacing = consensus.nPowTargetSpacing;
         consensus.nPosTargetTimespan = consensus.nPowTargetTimespan;
-        consensus.nStakeMinAge = 5 * 60;
+        consensus.nStakeMinAge = 10 * 60;
         consensus.nStakeMaxAge = 60 * 60 * 24 * 30;
         consensus.nModifierInterval = 60 * 20;
-        consensus.fPowAllowMinDifficultyBlocks = true;
+        consensus.fPowAllowMinDifficultyBlocks = false;
         consensus.fPowNoRetargeting = false;
-        consensus.nPowKGWHeight = 4002;
-        consensus.nPowDGWHeight = 4002;
+        consensus.nPowKGWHeight = NEVER32; // unused
+        consensus.nPowDGWHeight = NEVER32; // unused
         consensus.nRuleChangeActivationThreshold = 1512;
         consensus.nMinerConfirmationWindow = 2016;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
-        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008
-        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1544655600;
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = NEVER32;
 
         // Deployment of BIP68, BIP112, and BIP113.
         consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;
-        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1544655600; // Dec 13th, 2018
-        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 1576191600; // Dec 13th, 2019
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1544655600;
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = NEVER32;
 
         // Deployment of DIP0001
         consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].bit = 1;
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime = 1544655600; // Dec 13th, 2018
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout = 1576191600; // Dec 13th, 2019
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime = 1544655600;
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout = NEVER32;
         consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nWindowSize = 100;
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nThreshold = 50; // 50% of 100
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nThreshold = 50;
 
         // Deployment of BIP147
         consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].bit = 2;
-        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime = 1544655600; // Dec 13th, 2018
-        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout = 1576191600; // Dec 13th, 2019
+        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime = 1544655600;
+        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout = NEVER32;
         consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nWindowSize = 100;
-        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nThreshold = 50; // 50% of 100
+        consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nThreshold = 50;
 
         // Deployment of DIP0003
         consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].bit = 3;
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime = 1544655600; // Dec 13th, 2018
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout = 1576191600; // Dec 13th, 2019
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime = 1544655600;
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout = NEVER32;
         consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nWindowSize = 100;
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nThreshold = 50; // 50% of 100
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nThreshold = 50;
 
         // Deployment of DIP0008
         consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].bit = 4;
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime = 1553126400; // Mar 21st, 2019
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout = 1584748800; // Mar 21st, 2020
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime = 1544655600;
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout = NEVER32;
         consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nWindowSize = 100;
-        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nThreshold = 50; // 50% of 100
+        consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nThreshold = 10;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000");
@@ -472,19 +477,20 @@ class CTestNetParams : public CChainParams {
         // By default assume that the signatures in ancestors of this block are valid.
         consensus.defaultAssumeValid = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000");
 
-        pchMessageStart[0] = 0x01;
-        pchMessageStart[1] = 0x23;
-        pchMessageStart[2] = 0x45;
-        pchMessageStart[3] = 0x67;
+        pchMessageStart[0] = 0x23;
+        pchMessageStart[1] = 0x45;
+        pchMessageStart[2] = 0x67;
+        pchMessageStart[3] = 0x89;
         vAlertPubKey = ParseHex("04517d8a699cb43d3938d7b24faaff7cda448ca4ea267723ba614784de661949bf632d6304316b244646dea079735b9a6fc4af804efb4752075b9fe2245e14e412");
         nDefaultPort = 29999;
         nPruneAfterHeight = 1000;
 
 	/////////////////////////////////////////////////////////////////////////
-	uint32_t nTime = 1559300000;
+	uint32_t nTime = 1563050000;
 	uint32_t nNonce = 0;
 	while (UintToArith256(genesis.GetHash()) >
-			   UintToArith256(consensus.powLimit)) {
+	       UintToArith256(consensus.powLimit))
+        {
 	  nNonce++;
 	  genesis = CreateGenesisBlock(nTime, nNonce, 0x1f00ffff, 1, 0 * COIN);
 	}
@@ -492,8 +498,8 @@ class CTestNetParams : public CChainParams {
 	consensus.hashGenesisBlock = genesis.GetHash();
 	/////////////////////////////////////////////////////////////////////////
 
-        // assert(consensus.hashGenesisBlock == uint256S("0x00000bafbc94add76cb75e2ec92894837288a481e5c005f6563d91623bf8bc2c"));
-        // assert(genesis.hashMerkleRoot == uint256S("0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7"));
+        consensus.hashGenesisBlock = genesis.GetHash();
+        // assert(consensus.hashGenesisBlock == uint256S("0x0000071f25514da6d65c4fa2187ef8ee1f6b6a68b7761af91ecfb28dc85d3e8a"));
 
         vFixedSeeds.clear();
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
@@ -521,7 +527,7 @@ class CTestNetParams : public CChainParams {
         consensus.llmqChainLocks = Consensus::LLMQ_50_60;
         consensus.llmqForInstantSend = Consensus::LLMQ_50_60;
 
-        fMiningRequiresPeers = false;
+        fMiningRequiresPeers = true;
         fDefaultConsistencyChecks = false;
         fRequireStandard = false;
         fRequireRoutableExternalIP = false;
@@ -533,23 +539,20 @@ class CTestNetParams : public CChainParams {
         nPoolMaxParticipants = 5;
         nFulfilledRequestExpireTime = 5*60; // fulfilled requests expire in 5 minutes
 
-        vSporkAddresses = {"yjPtiKh2uwk3bDutTEA2q9mCtXyiZRWn55"};
+        vSporkAddresses = {"yb1YKkEEBLntPYgkzoiZoLacrNACMNZBT7"};
         nMinSporkKeys = 1;
         fBIP9CheckMasternodesUpgraded = true;
 
         checkpointData = (CCheckpointData) {
             boost::assign::map_list_of
-            (    261, uint256S("0x00000c26026d0815a7e2ce4fa270775f61403c040647ff2c3091f99e894a4618"))
-            (   1999, uint256S("0x00000052e538d27fa53693efe6fb6892a0c1d26c0235f599171c48a3cce553b1"))
-            (   2999, uint256S("0x0000024bc3f4f4cb30d29827c13d921ad77d2c6072e586c7f60d83c2722cdcc5"))
-            (  96090, uint256S("0x00000000033df4b94d17ab43e999caaf6c4735095cc77703685da81254d09bba"))
+            (      0, genesis.GetHash() )
         };
 
         chainTxData = ChainTxData{
-            1557603759, // * UNIX timestamp of last known number of transactions (Block 96717)
-            968552,     // * total number of transactions between genesis and that timestamp
+            nTime,      // * UNIX timestamp of last known number of transactions
+            0,          // * total number of transactions between genesis and that timestamp
                         //   (the tx=... number in the SetBestChain debug.log lines)
-            0.01        // * estimated number of transactions per second after that timestamp
+            0.0         // * estimated number of transactions per second after that timestamp
         };
 
     }
diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h
index 871ec863892d5..ca0aa93592e19 100644
--- a/src/chainparamsseeds.h
+++ b/src/chainparamsseeds.h
@@ -9,7 +9,8 @@
  */
 static SeedSpec6 pnSeed6_main[] = {
 };
-
 static SeedSpec6 pnSeed6_test[] = {
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9d,0xe6,0xf4,0xe9}, 29999},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa5,0x16,0x64,0x7f}, 29999}
 };
 #endif // DASH_CHAINPARAMSSEEDS_H
diff --git a/src/miner.cpp b/src/miner.cpp
index 7cd409b0945a1..94cb077bec2ad 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -169,29 +169,6 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                        ? nMedianTimePast
                        : pblock->GetBlockTime();
 
-    if (fDIP0003Active_context) {
-        for (auto& p : chainparams.GetConsensus().llmqs) {
-            CTransactionRef qcTx;
-            if (llmq::quorumBlockProcessor->GetMinableCommitmentTx(p.first, nHeight, qcTx)) {
-                pblock->vtx.emplace_back(qcTx);
-                pblocktemplate->vTxFees.emplace_back(0);
-                pblocktemplate->vTxSigOps.emplace_back(0);
-                nBlockSize += qcTx->GetTotalSize();
-                ++nBlockTx;
-            }
-        }
-    }
-
-    int nPackagesSelected = 0;
-    int nDescendantsUpdated = 0;
-    addPackageTxs(nPackagesSelected, nDescendantsUpdated);
-
-    int64_t nTime1 = GetTimeMicros();
-
-    nLastBlockTx = nBlockTx;
-    nLastBlockSize = nBlockSize;
-    LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps);
-
     // Create coinbase transaction.
     CMutableTransaction coinbaseTx;
     coinbaseTx.vin.resize(1);
@@ -204,7 +181,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     {
         assert(pwalletMain);
         boost::this_thread::interruption_point();
-        pblock->nBits = GetNextWorkRequired(pindexPrev, chainparams.GetConsensus(), fProofOfStake);
+        pblock->nBits = GetNextWorkRequired(pindexPrev, chainparams.GetConsensus());
         CMutableTransaction coinstakeTx;
         int64_t nSearchTime = pblock->nTime; // search to current time
         bool fStakeFound = false;
@@ -231,6 +208,29 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         coinbaseTx.vout[0].nValue = blockReward;
     }
 
+    if (fDIP0003Active_context) {
+        for (auto& p : chainparams.GetConsensus().llmqs) {
+            CTransactionRef qcTx;
+            if (llmq::quorumBlockProcessor->GetMinableCommitmentTx(p.first, nHeight, qcTx)) {
+                pblock->vtx.emplace_back(qcTx);
+                pblocktemplate->vTxFees.emplace_back(0);
+                pblocktemplate->vTxSigOps.emplace_back(0);
+                nBlockSize += qcTx->GetTotalSize();
+                ++nBlockTx;
+            }
+        }
+    }
+
+    int nPackagesSelected = 0;
+    int nDescendantsUpdated = 0;
+    addPackageTxs(nPackagesSelected, nDescendantsUpdated);
+
+    int64_t nTime1 = GetTimeMicros();
+
+    nLastBlockTx = nBlockTx;
+    nLastBlockSize = nBlockSize;
+    LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps);
+
     if (!fDIP0003Active_context) {
         coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
     } else {
@@ -264,11 +264,10 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     // Update coinbase transaction with additional info about masternode and governance payments,
     // get some info back to pass to getblocktemplate
-    // FillBlockPayments(coinbaseTx, nHeight, blockReward, pblocktemplate->voutMasternodePayments, pblocktemplate->voutSuperblockPayments);
+    FillBlockPayments(coinbaseTx, nHeight, blockReward, pblocktemplate->voutMasternodePayments, pblocktemplate->voutSuperblockPayments);
     // LogPrintf("CreateNewBlock -- nBlockHeight %d blockReward %lld txoutMasternode %s coinbaseTx %s",
     //             nHeight, blockReward, pblocktemplate->txoutsMasternode.ToString(), coinbaseTx.ToString());
 
-    coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
     pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
     pblocktemplate->vTxFees[0] = -nFees;
 
@@ -276,7 +275,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     pblock->hashPrevBlock  = pindexPrev->GetBlockHash();
     if(!fProofOfStake)
         UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
-    pblock->nBits          = GetNextWorkRequired(pindexPrev, chainparams.GetConsensus(), fProofOfStake);
+    pblock->nBits          = GetNextWorkRequired(pindexPrev, chainparams.GetConsensus());
     pblock->nNonce         = 0;
     pblocktemplate->nPrevBits = pindexPrev->nBits;
     pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(*pblock->vtx[0]);
@@ -615,9 +614,8 @@ void static BitcoinMiner(const CChainParams& chainparams, CConnman& connman, CWa
 
             if(fProofOfStake)
             {
-                if (chainActive.Tip()->nHeight+1 < chainparams.GetConsensus().nLastPoWBlock ||
-                    pwallet->IsLocked() || !masternodeSync.IsSynced())
-                {
+                if (chainActive.Tip()->nHeight < chainparams.GetConsensus().nLastPoWBlock ||
+                    pwallet->IsLocked() || !masternodeSync.IsSynced()) {
                     nLastCoinStakeSearchInterval = 0;
                     MilliSleep(5000);
                     continue;
diff --git a/src/net.cpp b/src/net.cpp
index 78b20eda184cf..819dae27f5d31 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -1814,7 +1814,7 @@ void CConnman::ThreadOpenConnections()
             return;
 
         // Add seed nodes if DNS seeds are all down (an infrastructure attack?).
-        if (addrman.size() == 0 && (GetTime() - nStart > 60)) {
+        if (addrman.size() == 0 && (GetTime() - nStart > 1)) {
             static bool done = false;
             if (!done) {
                 LogPrintf("Adding fixed seed nodes as DNS doesn't seem to be available.\n");
diff --git a/src/pow.cpp b/src/pow.cpp
index beadbb68d316a..bf41f89f8d86e 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -13,17 +13,10 @@
 
 #include <math.h>
 
-const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake)
+unsigned int DualKGW3(const CBlockIndex* pindexLast, bool fProofOfStake, const Consensus::Params& params)
 {
-    while (pindex && pindex->pprev && (pindex->IsProofOfStake() != fProofOfStake))
-        pindex = pindex->pprev;
-    return pindex;
-}
-
-unsigned int DualKGW3(const CBlockIndex* pindexLast, const Consensus::Params& params)
-{
-    const CBlockIndex* BlockLastSolved = GetLastBlockIndex(pindexLast, false);
-    const CBlockIndex* BlockReading = GetLastBlockIndex(pindexLast, false);
+    const CBlockIndex *BlockLastSolved = pindexLast;
+    const CBlockIndex *BlockReading = pindexLast;
     int64_t PastBlocksMass = 0;
     int64_t PastRateActualSeconds = 0;
     int64_t PastRateTargetSeconds = 0;
@@ -33,13 +26,15 @@ unsigned int DualKGW3(const CBlockIndex* pindexLast, const Consensus::Params& pa
     double EventHorizonDeviation;
     double EventHorizonDeviationFast;
     double EventHorizonDeviationSlow;
-    static const int64_t Blocktime = params.nPowTargetSpacing;
+    static const int64_t Blocktime = fProofOfStake ? params.nPosTargetSpacing :
+                                                     params.nPowTargetSpacing;
     static const unsigned int timeDaySeconds = 86400;
     uint64_t pastSecondsMin = timeDaySeconds * 0.025;
     uint64_t pastSecondsMax = timeDaySeconds * 7;
     uint64_t PastBlocksMin = pastSecondsMin / Blocktime;
     uint64_t PastBlocksMax = pastSecondsMax / Blocktime;
-    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
+    const arith_uint256 bnPowLimit = fProofOfStake ? UintToArith256(params.posLimit) :
+                                                     UintToArith256(params.powLimit);
 
     if (BlockLastSolved == NULL || BlockLastSolved->nHeight == 0 ||
             (uint64_t)BlockLastSolved->nHeight < PastBlocksMin)
@@ -118,36 +113,6 @@ unsigned int DualKGW3(const CBlockIndex* pindexLast, const Consensus::Params& pa
     return bnNew.GetCompact();
 }
 
-unsigned int PoSWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params)
-{
-    const CBlockIndex* LastPoSBlock = GetLastBlockIndex(pindexLast, true);
-    const arith_uint256 bnPosLimit = UintToArith256(params.posLimit);
-    int64_t nTargetSpacing = Params().GetConsensus().nPosTargetSpacing;
-    int64_t nTargetTimespan = Params().GetConsensus().nPosTargetTimespan;
-
-    int64_t nActualSpacing = 0;
-    if (LastPoSBlock->nHeight != 0)
-        nActualSpacing = LastPoSBlock->GetBlockTime() - LastPoSBlock->pprev->GetBlockTime();
-
-    if (nActualSpacing < 0)
-        nActualSpacing = 1;
-
-    // ppcoin: target change every block
-    // ppcoin: retarget with exponential moving toward target spacing
-    arith_uint256 bnNew;
-    bnNew.SetCompact(LastPoSBlock->nBits);
-
-    int64_t nInterval = nTargetTimespan / nTargetSpacing;
-    bnNew *= ((nInterval - 1) * nTargetSpacing + nActualSpacing + nActualSpacing);
-    bnNew /= ((nInterval + 1) * nTargetSpacing);
-
-    if (bnNew <= 0 || bnNew > bnPosLimit)
-        bnNew = bnPosLimit;
-
-    return bnNew.GetCompact();
-}
-
-
 unsigned int static KimotoGravityWell(const CBlockIndex* pindexLast, const Consensus::Params& params) {
     const CBlockIndex *BlockLastSolved = pindexLast;
     const CBlockIndex *BlockReading = pindexLast;
@@ -283,14 +248,13 @@ unsigned int GetNextWorkRequiredBTC(const CBlockIndex* pindexLast, const Consens
    return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
 }
 
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params, bool fProofOfStake)
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params)
 {
-    unsigned int nBits = UintToArith256(params.powLimit).GetCompact();
-    if(fProofOfStake)
-        nBits = PoSWorkRequired(pindexLast, params);
-    else
-        nBits = DualKGW3(pindexLast, params);
-    return nBits;
+    if(pindexLast->nHeight + 1 > params.nLastPoWBlock)
+        return DualKGW3(pindexLast, true, params);
+    if(pindexLast->nHeight + 1 > params.nLastPoWBlock - 10)
+        return DualKGW3(pindexLast, false, params);
+    return UintToArith256(params.powLimit).GetCompact();
 }
 
 // for DIFF_BTC only!
diff --git a/src/pow.h b/src/pow.h
index ef930be5daa80..16035e33f21d7 100644
--- a/src/pow.h
+++ b/src/pow.h
@@ -14,10 +14,8 @@ class CBlockHeader;
 class CBlockIndex;
 class uint256;
 
-const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
-unsigned int DualKGW3(const CBlockIndex* pindexLast, const Consensus::Params& params);
-unsigned int PoSWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params);
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params&, bool fProofOfStake = false);
+unsigned int DualKGW3(const CBlockIndex* pindexLast, bool fProofOfStake, const Consensus::Params& params);
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params);
 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params&);
 
 /** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
diff --git a/src/qt/forms/askpassphrasedialog.ui b/src/qt/forms/askpassphrasedialog.ui
index c54687fef451c..238ba2adb826a 100644
--- a/src/qt/forms/askpassphrasedialog.ui
+++ b/src/qt/forms/askpassphrasedialog.ui
@@ -144,42 +144,6 @@
        </property>
       </widget>
      </item>
-     <item row="6" column="0">
-      <widget class="QCheckBox" name="mixingOnlyCheckBox">
-       <property name="enabled">
-        <bool>true</bool>
-       </property>
-       <property name="visible">
-        <bool>false</bool>
-       </property>
-       <property name="toolTip">
-        <string>Serves to disable the trivial sendmoney when OS account compromised. Provides no real security.</string>
-       </property>
-       <property name="text">
-        <string>Only for mixing via PrivateSend</string>
-       </property>
-      </widget>
-     </item>
-     <item row="5" column="0">
-      <widget class="QCheckBox" name="stakingCheckBox">
-       <property name="enabled">
-        <bool>true</bool>
-       </property>
-       <property name="visible">
-        <bool>false</bool>
-       </property>
-       <property name="text">
-        <string> Unlock for staking only</string>
-       </property>
-      </widget>
-     </item>
-     <item row="5" column="1">
-      <widget class="QCheckBox" name="toggleShowPasswordButton">
-       <property name="text">
-        <string>Show password</string>
-       </property>
-      </widget>
-     </item>
     </layout>
    </item>
    <item>
diff --git a/src/qt/res/images/light/splash_testnet.png b/src/qt/res/images/light/splash_testnet.png
index 5517624b2f9724b26103d0c330e06bef14961a9c..9c859f1cab89c22bf1b9b0538f57dd91f7f0cd2d 100644
GIT binary patch
literal 779484
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
b?Kc<v=a0Lcd!f8LXWv6-|99{2{_6h$zuoX2

literal 9370
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
FKLA{2URnSE

diff --git a/src/serialize.h b/src/serialize.h
index 46920e9b0ec27..b036b3f716256 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -173,8 +173,9 @@ enum
 template<typename X> X& ReadWriteAsHelper(X& x) { return x; }
 template<typename X> const X& ReadWriteAsHelper(const X& x) { return x; }
 
-#define READWRITE(...) (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
+#define READWRITE(obj)      (::SerReadWrite(s, (obj), ser_action))
 #define READWRITEAS(type, obj) (::SerReadWriteMany(s, ser_action, ReadWriteAsHelper<type>(obj)))
+#define READWRITEMANY(...)      (::SerReadWriteMany(s, ser_action, __VA_ARGS__))
 
 /** 
  * Implement three methods for serializable objects. These are actually wrappers over
diff --git a/src/util.cpp b/src/util.cpp
index 434ae93512fff..057fec67457ee 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -571,7 +571,7 @@ boost::filesystem::path GetDefaultDataDir()
     // Unix: ~/.dashcore
 #ifdef WIN32
     // Windows
-    return GetSpecialFolderPath(CSIDL_APPDATA) / "DashCore";
+    return GetSpecialFolderPath(CSIDL_APPDATA) / "pactestneta";
 #else
     fs::path pathRet;
     char* pszHome = getenv("HOME");
@@ -581,10 +581,10 @@ boost::filesystem::path GetDefaultDataDir()
         pathRet = fs::path(pszHome);
 #ifdef MAC_OSX
     // Mac
-    return pathRet / "Library/Application Support/DashCore";
+    return pathRet / "Library/Application Support/pactestneta";
 #else
     // Unix
-    return pathRet / ".dashcore";
+    return pathRet / ".pactestneta";
 #endif
 #endif
 }
diff --git a/src/validation.cpp b/src/validation.cpp
index b2e846562a856..960e86b15bda0 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1203,9 +1203,9 @@ double ConvertBitsToDouble(unsigned int nBits)
 
 CAmount GetBlockSubsidy(int nPrevBits, int nPrevHeight, const Consensus::Params& consensusParams, bool fSuperblockPartOnly)
 {
-    if (nPrevHeight < 10)
+    if (nPrevHeight < 20)
         return 1000000 * COIN;
-    return 10 * COIN;
+    return 10000 * COIN;
 }
 
 /*
@@ -3560,14 +3560,17 @@ bool ContextualCheckBlock(const CBlock& block, CValidationState& state, const Co
             mapProofOfStake.insert(std::make_pair(hash, hashProofOfStake));
     }
 
-    // Check difficulty
-    if (block.nBits != GetNextWorkRequired(pindexPrev, consensusParams, block.IsProofOfStake()))
-        return state.DoS(100, false, REJECT_INVALID, "bad-diffbits", false, strprintf("incorrect difficulty: block pow=%d bits=%08x calc=%08x",
-                  block.IsProofOfWork() ? "Y" : "N", block.nBits, GetNextWorkRequired(pindexPrev, consensusParams, block.IsProofOfStake())));
-    else
-        LogPrintf("Block pow=%s bits=%08x found=%08x %s=%s\n", block.IsProofOfWork() ? "Y" : "N", GetNextWorkRequired(pindexPrev,
-                  consensusParams, block.IsProofOfStake()), block.nBits, block.IsProofOfWork() ? "powhash" : "hashproof",
-                  block.IsProofOfWork() ? block.GetHash().ToString().c_str() : hashProofOfStake.ToString().c_str());
+    // Test nbits if proof of work
+    if (block.IsProofOfWork())
+    {
+        if (block.nBits != GetNextWorkRequired(pindexPrev, consensusParams))
+            return state.DoS(100, false, REJECT_INVALID, "bad-diffbits", false, strprintf("incorrect difficulty: block pow=Y bits=%08x calc=%08x",
+                             block.nBits, GetNextWorkRequired(pindexPrev, consensusParams)));
+    }
+    else {
+        LogPrintf("Block pow=N bits=%08x found=%08x hashProof=%s\n", GetNextWorkRequired(pindexPrev, consensusParams), block.nBits,
+                  hashProofOfStake.ToString().c_str());
+    }
 
     // Start enforcing BIP113 (Median Time Past) using versionbits logic.
     int nLockTimeFlags = 0;