diff --git a/ZNODE.md b/ZNODE.md
new file mode 100644
index 0000000000..0df27b6822
--- /dev/null
+++ b/ZNODE.md
@@ -0,0 +1,105 @@
+Znode Build Instructions and Notes
+=============================
+ - Version 0.1.5
+ - Date: 28 November 2017
+
+Prerequisites
+-------------
+ - Ubuntu 16.04+
+ - Libraries to build from zcoin source
+ - Port **18618** is open
+
+Step 1. Build
+----------------------
+**1.1.**  Check out from source:
+
+    git clone -b znode https://github.com/zcoinofficial/zcoin
+
+**1.2.**  See [README.md](README.md) for instructions on building.
+
+Step 2. (Optional - only if firewall is running). Open port 18618
+----------------------
+**2.1.**  Run:
+
+    sudo ufw allow 18618
+    sudo ufw default allow outgoing
+    sudo ufw enable
+
+Step 3. First run on your Local Wallet
+----------------------
+**3.0.**  Go to the checked out folder
+
+    cd zcoin
+
+**3.1.**  Start daemon in testnet mode:
+
+    ./src/zcoind -daemon -server -testnet
+
+**3.2.**  Generate znodeprivkey:
+
+    ./src/zcoin-cli znode genkey
+
+(Store this key)
+
+**3.3.**  Get wallet address:
+
+    ./src/zcoin-cli getaccountaddress 0
+
+**3.4.**  Send to received address **exactly 1000 XZC** in **1 transaction**. Wait for 15 confirmations.
+
+**3.5.**  Stop daemon:
+
+    ./src/zcoin-cli stop
+
+Step 4. In your VPS where you are hosting your Znode. Update config files
+----------------------
+**4.1.**  Create file **zcoin.conf** (in folder **~/.zcoin**)
+
+    rpcuser=username
+    rpcpassword=password
+    rpcallowip=127.0.0.1
+    testnet=1
+    debug=1
+    txindex=1
+    daemon=1
+    server=1
+    listen=1
+    maxconnections=24
+    znode=1
+    znodeprivkey=XXXXXXXXXXXXXXXXX  ## Replace with your znode private key
+    externalIP=XXX.XXX.XXX.XXX ## Replace with your node external IP
+
+**4.2.**  Create file **znode.conf** (in 2 folders **~/.zcoin** and **~/.zcoin/testnet3**) contains the following info:
+ - LABEL: A one word name you make up to call your node (ex. ZN1)
+ - IP:PORT: Your znode VPS's IP, and the port is always 18168.
+ - ZNODEPRIVKEY: This is the result of your "znode genkey" from earlier.
+ - TRANSACTION HASH: The collateral tx. hash from the 1000 XZC deposit.
+ - INDEX: The Index is always 0 or 1.
+
+To get TRANSACTION HASH, run:
+
+    ./src/zcoin-cli znode outputs
+
+The output will look like:
+
+    { "d6fd38868bb8f9958e34d5155437d009b72dfd33fc28874c87fd42e51c0f74fdb" : "0", }
+
+Sample of znode.conf:
+
+    ZN1 51.52.53.54:18168 XrxSr3fXpX3dZcU7CoiFuFWqeHYw83r28btCFfIHqf6zkMp1PZ4 d6fd38868bb8f9958e34d5155437d009b72dfd33fc28874c87fd42e51c0f74fdb 0
+
+Step 5. Run a znode
+----------------------
+**5.1.**  Start znode:
+
+    ./src/zcoin-cli znode start-alias <LABEL>
+
+For example:
+
+    ./src/zcoin-cli znode start-alias ZN1
+
+**5.2.**  To check node status:
+
+    ./src/zcoin-cli znode debug
+
+If not successfully started, just repeat start command
diff --git a/configure.ac b/configure.ac
index d7e6c2002b..cd04f82db8 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2,8 +2,8 @@ dnl require autoconf 2.60 (AS_ECHO/AS_ECHO_N)
 AC_PREREQ([2.60])
 define(_CLIENT_VERSION_MAJOR, 0)
 define(_CLIENT_VERSION_MINOR, 13)
-define(_CLIENT_VERSION_REVISION, 3)
-define(_CLIENT_VERSION_BUILD, 3)
+define(_CLIENT_VERSION_REVISION, 4)
+define(_CLIENT_VERSION_BUILD, 1)
 define(_CLIENT_VERSION_IS_RELEASE, true)
 define(_COPYRIGHT_YEAR, 2017)
 define(_COPYRIGHT_HOLDERS,[The %s developers])
diff --git a/contrib/bitcoin-qt.pro b/contrib/bitcoin-qt.pro
index 6ae50ef62a..e63c1a1663 100644
--- a/contrib/bitcoin-qt.pro
+++ b/contrib/bitcoin-qt.pro
@@ -16,6 +16,7 @@ FORMS += \
     ../src/qt/forms/sendcoinsentry.ui \
     ../src/qt/forms/signverifymessagedialog.ui \
     ../src/qt/forms/transactiondescdialog.ui \
+    ../src/qt/forms/znodelist.ui \
     ../src/qt/forms/zerocoinpage.ui \
 
 RESOURCES += \
diff --git a/contrib/seeds/generate-seeds.py b/contrib/seeds/generate-seeds.py
index 9c4ec09e94..a533365a35 100755
--- a/contrib/seeds/generate-seeds.py
+++ b/contrib/seeds/generate-seeds.py
@@ -27,7 +27,7 @@
    }
    static SeedSpec6 pnSeed6_test[]={
    ...
-   }
+   }i
 
 These should be pasted into `src/chainparamsseeds.h`.
 '''
@@ -130,7 +130,7 @@ def main():
         process_nodes(g, f, 'pnSeed6_main', 8168)
     g.write('\n')
     with open(os.path.join(indir,'nodes_test.txt'),'r') as f:
-        process_nodes(g, f, 'pnSeed6_test', 28168)
+        process_nodes(g, f, 'pnSeed6_test', 18168)
     g.write('#endif // BITCOIN_CHAINPARAMSSEEDS_H\n')
 
 if __name__ == '__main__':
diff --git a/contrib/seeds/nodes_main.txt b/contrib/seeds/nodes_main.txt
index 300fff0420..1e3584074e 100644
--- a/contrib/seeds/nodes_main.txt
+++ b/contrib/seeds/nodes_main.txt
@@ -1,5 +1,9 @@
-52.187.41.88:8168
-52.166.11.108:8168
-40.76.72.210:8168
-47.52.0.193:8168
-52.178.34.114:8168
\ No newline at end of file
+45.77.205.5:8168
+45.32.232.195:8168
+104.238.172.164:8168
+45.63.91.151:8168
+45.77.184.187:8168
+45.77.51.98:8168
+45.77.61.203:8168
+45.76.206.15:8168
+45.76.149.126:8168
diff --git a/contrib/seeds/nodes_test.txt b/contrib/seeds/nodes_test.txt
index ca10ba501f..b5413728b3 100644
--- a/contrib/seeds/nodes_test.txt
+++ b/contrib/seeds/nodes_test.txt
@@ -1,5 +1,7 @@
 # List of fixed seed nodes for testnet
-52.175.244.22:28168
+#52.175.244.22:28168
+52.232.105.188:28168
+13.76.210.1:28168
 
 # Onion nodes
 
diff --git a/depends/packages/libevent.mk b/depends/packages/libevent.mk
index b7f74907fc..2e9be1e98c 100644
--- a/depends/packages/libevent.mk
+++ b/depends/packages/libevent.mk
@@ -1,8 +1,13 @@
 package=libevent
-$(package)_version=2.1.8
-$(package)_download_path=https://github.com/libevent/libevent/releases/download/release-2.1.8-stable
+$(package)_version=2.0.22
+$(package)_download_path=https://github.com/libevent/libevent/releases/download/release-2.0.22-stable
 $(package)_file_name=$(package)-$($(package)_version)-stable.tar.gz
-$(package)_sha256_hash=965cc5a8bb46ce4199a47e9b2c9e1cae3b137e8356ffdad6d94d3b9069b71dc2
+$(package)_sha256_hash=71c2c49f0adadacfdbe6332a372c38cf9c8b7895bb73dabeaa53cdcc1d4e1fa3
+$(package)_patches=reuseaddr.patch
+
+define $(package)_preprocess_cmds
+  patch -p1 < $($(package)_patch_dir)/reuseaddr.patch
+endef
 
 define $(package)_set_vars
   $(package)_config_opts=--disable-shared --disable-openssl --disable-libevent-regress
diff --git a/depends/patches/libevent/reuseaddr.patch b/depends/patches/libevent/reuseaddr.patch
new file mode 100644
index 0000000000..58695c11f5
--- /dev/null
+++ b/depends/patches/libevent/reuseaddr.patch
@@ -0,0 +1,21 @@
+--- old/evutil.c   2015-08-28 19:26:23.488765923 -0400
++++ new/evutil.c   2015-08-28 19:27:41.392767019 -0400
+@@ -321,15 +321,16 @@
+ int
+ evutil_make_listen_socket_reuseable(evutil_socket_t sock)
+ {
+-#ifndef WIN32
+ 	int one = 1;
++#ifndef WIN32
+ 	/* REUSEADDR on Unix means, "don't hang on to this address after the
+ 	 * listener is closed."  On Windows, though, it means "don't keep other
+ 	 * processes from binding to this address while we're using it. */
+ 	return setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*) &one,
+ 	    (ev_socklen_t)sizeof(one));
+ #else
+-	return 0;
++	return setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*) &one,
++		(ev_socklen_t)sizeof(one));
+ #endif
+ }
+ 
diff --git a/git.diff b/git.diff
deleted file mode 100644
index f69671aec9..0000000000
--- a/git.diff
+++ /dev/null
@@ -1,86 +0,0 @@
-diff --git a/configure.ac b/configure.ac
-index d9cddf1..d7e6c20 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -3,7 +3,7 @@ AC_PREREQ([2.60])
- define(_CLIENT_VERSION_MAJOR, 0)
- define(_CLIENT_VERSION_MINOR, 13)
- define(_CLIENT_VERSION_REVISION, 3)
--define(_CLIENT_VERSION_BUILD, 2)
-+define(_CLIENT_VERSION_BUILD, 3)
- define(_CLIENT_VERSION_IS_RELEASE, true)
- define(_COPYRIGHT_YEAR, 2017)
- define(_COPYRIGHT_HOLDERS,[The %s developers])
-diff --git a/contrib/gitian-descriptors/gitian-linux.yml b/contrib/gitian-descriptors/gitian-linux.yml
-index 6fd3d39..06b1d96 100644
---- a/contrib/gitian-descriptors/gitian-linux.yml
-+++ b/contrib/gitian-descriptors/gitian-linux.yml
-@@ -1,5 +1,5 @@
- ---
--name: "zcoin-linux-0.13"
-+name: "zcoin-linux-0.13.3.3"
- enable_cache: true
- suites:
- - "trusty"
-@@ -28,7 +28,7 @@ packages:
- - "ca-certificates"
- - "python"
- remotes:
--- "url": "https://gitlab.com/btzc/zcoin.git"
-+- "url": "https://github.com/zcoinofficial/zcoin"
-   "dir": "zcoin"
- files: []
- script: |
-diff --git a/contrib/gitian-descriptors/gitian-osx.yml b/contrib/gitian-descriptors/gitian-osx.yml
-index bba9866..40428f6 100644
---- a/contrib/gitian-descriptors/gitian-osx.yml
-+++ b/contrib/gitian-descriptors/gitian-osx.yml
-@@ -1,5 +1,5 @@
- ---
--name: "zcoin-osx-0.13"
-+name: "zcoin-osx-0.13.3.3"
- enable_cache: true
- suites:
- - "trusty"
-@@ -28,7 +28,7 @@ packages:
- - "python-setuptools"
- - "fonts-tuffy"
- remotes:
--- "url": "https://gitlab.com/btzc/zcoin.git"
-+- "url": "https://github.com/zcoinofficial/zcoin"
-   "dir": "zcoin"
- files:
- - "MacOSX10.11.sdk.tar.gz"
-diff --git a/contrib/gitian-descriptors/gitian-win.yml b/contrib/gitian-descriptors/gitian-win.yml
-index c7b7ef6..0737809 100644
---- a/contrib/gitian-descriptors/gitian-win.yml
-+++ b/contrib/gitian-descriptors/gitian-win.yml
-@@ -1,5 +1,5 @@
- ---
--name: "zcoin-win-0.13"
-+name: "zcoin-win-0.13.3.3"
- enable_cache: true
- suites:
- - "trusty"
-@@ -22,7 +22,7 @@ packages:
- - "ca-certificates"
- - "python"
- remotes:
--- "url": "https://gitlab.com/btzc/zcoin.git"
-+- "url": "https://github.com/zcoinofficial/zcoin"
-   "dir": "zcoin"
- files: []
- script: |
-diff --git a/src/clientversion.h b/src/clientversion.h
-index 9ff0314..3e1d4d6 100644
---- a/src/clientversion.h
-+++ b/src/clientversion.h
-@@ -18,7 +18,7 @@
- #define CLIENT_VERSION_MAJOR 0
- #define CLIENT_VERSION_MINOR 13
- #define CLIENT_VERSION_REVISION 3
--#define CLIENT_VERSION_BUILD 2
-+#define CLIENT_VERSION_BUILD 3
- 
- //! Set to true for release, false for prerelease or test build
- #define CLIENT_VERSION_IS_RELEASE true
diff --git a/prepare.sh b/prepare.sh
deleted file mode 100644
index 5b547a798d..0000000000
--- a/prepare.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-echo "Install libzerocoin"
-cd src/libzerocoin
-mkdir build
-cd build
-cmake ..
-make
-echo "Need sudo to add libzerocoin as library"
-sudo make install
-cd ../../..
\ No newline at end of file
diff --git a/src/Makefile.am b/src/Makefile.am
index 6cde135a50..989e99172b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -76,6 +76,7 @@ endif
 .PHONY: FORCE check-symbols check-security
 # bitcoin core #
 BITCOIN_CORE_H = \
+  activeznode.h \
   addrman.h \
   base58.h \
   bloom.h \
@@ -100,17 +101,26 @@ BITCOIN_CORE_H = \
   httprpc.h \
   httpserver.h \
   indirectmap.h \
+  darksend.h \
+  darksend-relay.h \
   init.h \
+  instantx.h \
   key.h \
   keystore.h \
   dbwrapper.h \
   limitedmap.h \
   main.h \
+  znode.h \
+  znode-payments.h \
+  znode-sync.h \
+  znodeman.h \
+  znodeconfig.h \
   memusage.h \
   merkleblock.h \
   miner.h \
   net.h \
   netbase.h \
+  netfulfilledman.h \
   noui.h \
   policy/fees.h \
   policy/policy.h \
@@ -182,6 +192,7 @@ libbitcoin_server_a_SOURCES = \
   merkleblock.cpp \
   miner.cpp \
   net.cpp \
+  netfulfilledman.cpp \
   noui.cpp \
   policy/fees.cpp \
   policy/policy.cpp \
@@ -192,6 +203,7 @@ libbitcoin_server_a_SOURCES = \
   rpc/misc.cpp \
   rpc/net.cpp \
   rpc/rawtransaction.cpp \
+  rpc/rpcznode.cpp \
   rpc/server.cpp \
   script/sigcache.cpp \
   script/ismine.cpp \
@@ -220,6 +232,14 @@ endif
 libbitcoin_wallet_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 libbitcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_wallet_a_SOURCES = \
+  activeznode.cpp \
+  darksend.cpp \
+  znode.cpp \
+  instantx.cpp \
+  znode-payments.cpp \
+  znode-sync.cpp \
+  znodeconfig.cpp \
+  znodeman.cpp \
   wallet/crypter.cpp \
   wallet/db.cpp \
   wallet/rpcdump.cpp \
@@ -261,6 +281,7 @@ libbitcoin_consensus_a_SOURCES = \
   consensus/params.h \
   consensus/validation.h \
   hash.cpp \
+  flat-database.h \
   hash.h \
   prevector.h \
   crypto/scrypt.h \
@@ -278,6 +299,7 @@ libbitcoin_consensus_a_SOURCES = \
   script/script_error.cpp \
   script/script_error.h \
   serialize.h \
+  spork.h \
   tinyformat.h \
   uint256.cpp \
   uint256.h \
@@ -314,6 +336,7 @@ libbitcoin_common_a_SOURCES = \
   scheduler.cpp \
   script/sign.cpp \
   script/standard.cpp \
+  spork.cpp \
   $(BITCOIN_CORE_H)
 
 # util: shared between all executables.
@@ -352,6 +375,8 @@ libbitcoin_util_a_SOURCES = \
   libzerocoin/CoinSpend.cpp \
   libzerocoin/Commitment.h \
   libzerocoin/Commitment.cpp \
+  libzerocoin/ParallelTasks.h \
+  libzerocoin/ParallelTasks.cpp \
   libzerocoin/ParamGeneration.h \
   libzerocoin/ParamGeneration.cpp \
   libzerocoin/Params.h \
diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index b61ffcc1ef..10fd0095e8 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -101,6 +101,7 @@ QT_FORMS_UI = \
   qt/forms/coincontroldialog.ui \
   qt/forms/editaddressdialog.ui \
   qt/forms/helpmessagedialog.ui \
+  qt/forms/znodelist.ui \
   qt/forms/intro.ui \
   qt/forms/openuridialog.ui \
   qt/forms/optionsdialog.ui \
@@ -132,6 +133,7 @@ QT_MOC_CPP = \
   qt/moc_intro.cpp \
   qt/moc_macdockiconhandler.cpp \
   qt/moc_macnotificationhandler.cpp \
+  qt/moc_znodelist.cpp \
   qt/moc_notificator.cpp \
   qt/moc_openuridialog.cpp \
   qt/moc_optionsdialog.cpp \
@@ -200,6 +202,7 @@ BITCOIN_QT_H = \
   qt/intro.h \
   qt/macdockiconhandler.h \
   qt/macnotificationhandler.h \
+  qt/znodelist.h \
   qt/networkstyle.h \
   qt/notificator.h \
   qt/openuridialog.h \
@@ -244,6 +247,7 @@ RES_ICONS = \
   qt/res/icons/bitcoin.png \
   qt/res/icons/zcoin.png \
   qt/res/icons/zerocoin.png \
+  qt/res/icons/znodes.png \
   qt/res/icons/qrcode.png \
   qt/res/icons/chevron.png \
   qt/res/icons/clock1.png \
@@ -346,6 +350,7 @@ BITCOIN_QT_WALLET_CPP = \
   qt/walletframe.cpp \
   qt/walletmodel.cpp \
   qt/walletmodeltransaction.cpp \
+  qt/znodelist.cpp \
   qt/walletview.cpp
 
 BITCOIN_QT_CPP = $(BITCOIN_QT_BASE_CPP)
diff --git a/src/activeznode.cpp b/src/activeznode.cpp
new file mode 100644
index 0000000000..d193832d39
--- /dev/null
+++ b/src/activeznode.cpp
@@ -0,0 +1,333 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "activeznode.h"
+#include "znode.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "protocol.h"
+
+extern CWallet *pwalletMain;
+
+// Keep track of the active Znode
+CActiveZnode activeZnode;
+
+void CActiveZnode::ManageState() {
+    LogPrint("znode", "CActiveZnode::ManageState -- Start\n");
+    if (!fZNode) {
+        LogPrint("znode", "CActiveZnode::ManageState -- Not a znode, returning\n");
+        return;
+    }
+
+    if (Params().NetworkIDString() != CBaseChainParams::REGTEST && !znodeSync.IsBlockchainSynced()) {
+        nState = ACTIVE_ZNODE_SYNC_IN_PROCESS;
+        LogPrintf("CActiveZnode::ManageState -- %s: %s\n", GetStateString(), GetStatus());
+        return;
+    }
+
+    if (nState == ACTIVE_ZNODE_SYNC_IN_PROCESS) {
+        nState = ACTIVE_ZNODE_INITIAL;
+    }
+
+    LogPrint("znode", "CActiveZnode::ManageState -- status = %s, type = %s, pinger enabled = %d\n",
+             GetStatus(), GetTypeString(), fPingerEnabled);
+
+    if (eType == ZNODE_UNKNOWN) {
+        ManageStateInitial();
+    }
+
+    if (eType == ZNODE_REMOTE) {
+        ManageStateRemote();
+    } else if (eType == ZNODE_LOCAL) {
+        // Try Remote Start first so the started local znode can be restarted without recreate znode broadcast.
+        ManageStateRemote();
+        if (nState != ACTIVE_ZNODE_STARTED)
+            ManageStateLocal();
+    }
+
+    SendZnodePing();
+}
+
+std::string CActiveZnode::GetStateString() const {
+    switch (nState) {
+        case ACTIVE_ZNODE_INITIAL:
+            return "INITIAL";
+        case ACTIVE_ZNODE_SYNC_IN_PROCESS:
+            return "SYNC_IN_PROCESS";
+        case ACTIVE_ZNODE_INPUT_TOO_NEW:
+            return "INPUT_TOO_NEW";
+        case ACTIVE_ZNODE_NOT_CAPABLE:
+            return "NOT_CAPABLE";
+        case ACTIVE_ZNODE_STARTED:
+            return "STARTED";
+        default:
+            return "UNKNOWN";
+    }
+}
+
+std::string CActiveZnode::GetStatus() const {
+    switch (nState) {
+        case ACTIVE_ZNODE_INITIAL:
+            return "Node just started, not yet activated";
+        case ACTIVE_ZNODE_SYNC_IN_PROCESS:
+            return "Sync in progress. Must wait until sync is complete to start Znode";
+        case ACTIVE_ZNODE_INPUT_TOO_NEW:
+            return strprintf("Znode input must have at least %d confirmations",
+                             Params().GetConsensus().nZnodeMinimumConfirmations);
+        case ACTIVE_ZNODE_NOT_CAPABLE:
+            return "Not capable znode: " + strNotCapableReason;
+        case ACTIVE_ZNODE_STARTED:
+            return "Znode successfully started";
+        default:
+            return "Unknown";
+    }
+}
+
+std::string CActiveZnode::GetTypeString() const {
+    std::string strType;
+    switch (eType) {
+        case ZNODE_UNKNOWN:
+            strType = "UNKNOWN";
+            break;
+        case ZNODE_REMOTE:
+            strType = "REMOTE";
+            break;
+        case ZNODE_LOCAL:
+            strType = "LOCAL";
+            break;
+        default:
+            strType = "UNKNOWN";
+            break;
+    }
+    return strType;
+}
+
+bool CActiveZnode::SendZnodePing() {
+    if (!fPingerEnabled) {
+        LogPrint("znode",
+                 "CActiveZnode::SendZnodePing -- %s: znode ping service is disabled, skipping...\n",
+                 GetStateString());
+        return false;
+    }
+
+    if (!mnodeman.Has(vin)) {
+        strNotCapableReason = "Znode not in znode list";
+        nState = ACTIVE_ZNODE_NOT_CAPABLE;
+        LogPrintf("CActiveZnode::SendZnodePing -- %s: %s\n", GetStateString(), strNotCapableReason);
+        return false;
+    }
+
+    CZnodePing mnp(vin);
+    if (!mnp.Sign(keyZnode, pubKeyZnode)) {
+        LogPrintf("CActiveZnode::SendZnodePing -- ERROR: Couldn't sign Znode Ping\n");
+        return false;
+    }
+
+    // Update lastPing for our znode in Znode list
+    if (mnodeman.IsZnodePingedWithin(vin, ZNODE_MIN_MNP_SECONDS, mnp.sigTime)) {
+        LogPrintf("CActiveZnode::SendZnodePing -- Too early to send Znode Ping\n");
+        return false;
+    }
+
+    mnodeman.SetZnodeLastPing(vin, mnp);
+
+    LogPrintf("CActiveZnode::SendZnodePing -- Relaying ping, collateral=%s\n", vin.ToString());
+    mnp.Relay();
+
+    return true;
+}
+
+void CActiveZnode::ManageStateInitial() {
+    LogPrint("znode", "CActiveZnode::ManageStateInitial -- status = %s, type = %s, pinger enabled = %d\n",
+             GetStatus(), GetTypeString(), fPingerEnabled);
+
+    // Check that our local network configuration is correct
+    if (!fListen) {
+        // listen option is probably overwritten by smth else, no good
+        nState = ACTIVE_ZNODE_NOT_CAPABLE;
+        strNotCapableReason = "Znode must accept connections from outside. Make sure listen configuration option is not overwritten by some another parameter.";
+        LogPrintf("CActiveZnode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
+        return;
+    }
+
+    bool fFoundLocal = false;
+    {
+        LOCK(cs_vNodes);
+
+        // First try to find whatever local address is specified by externalip option
+        fFoundLocal = GetLocal(service) && CZnode::IsValidNetAddr(service);
+        if (!fFoundLocal) {
+            // nothing and no live connections, can't do anything for now
+            if (vNodes.empty()) {
+                nState = ACTIVE_ZNODE_NOT_CAPABLE;
+                strNotCapableReason = "Can't detect valid external address. Will retry when there are some connections available.";
+                LogPrintf("CActiveZnode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
+                return;
+            }
+            // We have some peers, let's try to find our local address from one of them
+            BOOST_FOREACH(CNode * pnode, vNodes)
+            {
+                if (pnode->fSuccessfullyConnected && pnode->addr.IsIPv4()) {
+                    fFoundLocal = GetLocal(service, &pnode->addr) && CZnode::IsValidNetAddr(service);
+                    if (fFoundLocal) break;
+                }
+            }
+        }
+    }
+
+    if (!fFoundLocal) {
+        nState = ACTIVE_ZNODE_NOT_CAPABLE;
+        strNotCapableReason = "Can't detect valid external address. Please consider using the externalip configuration option if problem persists. Make sure to use IPv4 address only.";
+        LogPrintf("CActiveZnode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
+        return;
+    }
+
+    int mainnetDefaultPort = Params(CBaseChainParams::MAIN).GetDefaultPort();
+    if (Params().NetworkIDString() == CBaseChainParams::MAIN) {
+        if (service.GetPort() != mainnetDefaultPort) {
+            nState = ACTIVE_ZNODE_NOT_CAPABLE;
+            strNotCapableReason = strprintf("Invalid port: %u - only %d is supported on mainnet.", service.GetPort(),
+                                            mainnetDefaultPort);
+            LogPrintf("CActiveZnode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
+            return;
+        }
+    } else if (service.GetPort() == mainnetDefaultPort) {
+        nState = ACTIVE_ZNODE_NOT_CAPABLE;
+        strNotCapableReason = strprintf("Invalid port: %u - %d is only supported on mainnet.", service.GetPort(),
+                                        mainnetDefaultPort);
+        LogPrintf("CActiveZnode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
+        return;
+    }
+
+    LogPrintf("CActiveZnode::ManageStateInitial -- Checking inbound connection to '%s'\n", service.ToString());
+    //TODO
+    if (!ConnectNode(CAddress(service, NODE_NETWORK), NULL, false, true)) {
+        nState = ACTIVE_ZNODE_NOT_CAPABLE;
+        strNotCapableReason = "Could not connect to " + service.ToString();
+        LogPrintf("CActiveZnode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
+        return;
+    }
+
+    // Default to REMOTE
+    eType = ZNODE_REMOTE;
+
+    // Check if wallet funds are available
+    if (!pwalletMain) {
+        LogPrintf("CActiveZnode::ManageStateInitial -- %s: Wallet not available\n", GetStateString());
+        return;
+    }
+
+    if (pwalletMain->IsLocked()) {
+        LogPrintf("CActiveZnode::ManageStateInitial -- %s: Wallet is locked\n", GetStateString());
+        return;
+    }
+
+    if (pwalletMain->GetBalance() < ZNODE_COIN_REQUIRED * COIN) {
+        LogPrintf("CActiveZnode::ManageStateInitial -- %s: Wallet balance is < 1000 XZC\n", GetStateString());
+        return;
+    }
+
+    // Choose coins to use
+    CPubKey pubKeyCollateral;
+    CKey keyCollateral;
+
+    // If collateral is found switch to LOCAL mode
+    if (pwalletMain->GetZnodeVinAndKeys(vin, pubKeyCollateral, keyCollateral)) {
+        eType = ZNODE_LOCAL;
+    }
+
+    LogPrint("znode", "CActiveZnode::ManageStateInitial -- End status = %s, type = %s, pinger enabled = %d\n",
+             GetStatus(), GetTypeString(), fPingerEnabled);
+}
+
+void CActiveZnode::ManageStateRemote() {
+    LogPrint("znode",
+             "CActiveZnode::ManageStateRemote -- Start status = %s, type = %s, pinger enabled = %d, pubKeyZnode.GetID() = %s\n",
+             GetStatus(), fPingerEnabled, GetTypeString(), pubKeyZnode.GetID().ToString());
+
+    mnodeman.CheckZnode(pubKeyZnode);
+    znode_info_t infoMn = mnodeman.GetZnodeInfo(pubKeyZnode);
+    if (infoMn.fInfoValid) {
+        if (infoMn.nProtocolVersion != PROTOCOL_VERSION) {
+            nState = ACTIVE_ZNODE_NOT_CAPABLE;
+            strNotCapableReason = "Invalid protocol version";
+            LogPrintf("CActiveZnode::ManageStateRemote -- %s: %s\n", GetStateString(), strNotCapableReason);
+            return;
+        }
+        if (service != infoMn.addr) {
+            nState = ACTIVE_ZNODE_NOT_CAPABLE;
+            LogPrintf("service: %s\n", service.ToString());
+            LogPrintf("infoMn.addr: %s\n", infoMn.addr.ToString());
+            strNotCapableReason = "Broadcasted IP doesn't match our external address. Make sure you issued a new broadcast if IP of this znode changed recently.";
+            LogPrintf("CActiveZnode::ManageStateRemote -- %s: %s\n", GetStateString(), strNotCapableReason);
+            return;
+        }
+        if (!CZnode::IsValidStateForAutoStart(infoMn.nActiveState)) {
+            nState = ACTIVE_ZNODE_NOT_CAPABLE;
+            strNotCapableReason = strprintf("Znode in %s state", CZnode::StateToString(infoMn.nActiveState));
+            LogPrintf("CActiveZnode::ManageStateRemote -- %s: %s\n", GetStateString(), strNotCapableReason);
+            return;
+        }
+        if (nState != ACTIVE_ZNODE_STARTED) {
+            LogPrintf("CActiveZnode::ManageStateRemote -- STARTED!\n");
+            vin = infoMn.vin;
+            service = infoMn.addr;
+            fPingerEnabled = true;
+            nState = ACTIVE_ZNODE_STARTED;
+        }
+    } else {
+        nState = ACTIVE_ZNODE_NOT_CAPABLE;
+        strNotCapableReason = "Znode not in znode list";
+        LogPrintf("CActiveZnode::ManageStateRemote -- %s: %s\n", GetStateString(), strNotCapableReason);
+    }
+}
+
+void CActiveZnode::ManageStateLocal() {
+    LogPrint("znode", "CActiveZnode::ManageStateLocal -- status = %s, type = %s, pinger enabled = %d\n",
+             GetStatus(), GetTypeString(), fPingerEnabled);
+    if (nState == ACTIVE_ZNODE_STARTED) {
+        return;
+    }
+
+    // Choose coins to use
+    CPubKey pubKeyCollateral;
+    CKey keyCollateral;
+
+    if (pwalletMain->GetZnodeVinAndKeys(vin, pubKeyCollateral, keyCollateral)) {
+        int nInputAge = GetInputAge(vin);
+        if (nInputAge < Params().GetConsensus().nZnodeMinimumConfirmations) {
+            nState = ACTIVE_ZNODE_INPUT_TOO_NEW;
+            strNotCapableReason = strprintf(_("%s - %d confirmations"), GetStatus(), nInputAge);
+            LogPrintf("CActiveZnode::ManageStateLocal -- %s: %s\n", GetStateString(), strNotCapableReason);
+            return;
+        }
+
+        {
+            LOCK(pwalletMain->cs_wallet);
+            pwalletMain->LockCoin(vin.prevout);
+        }
+
+        CZnodeBroadcast mnb;
+        std::string strError;
+        if (!CZnodeBroadcast::Create(vin, service, keyCollateral, pubKeyCollateral, keyZnode,
+                                     pubKeyZnode, strError, mnb)) {
+            nState = ACTIVE_ZNODE_NOT_CAPABLE;
+            strNotCapableReason = "Error creating mastenode broadcast: " + strError;
+            LogPrintf("CActiveZnode::ManageStateLocal -- %s: %s\n", GetStateString(), strNotCapableReason);
+            return;
+        }
+
+        fPingerEnabled = true;
+        nState = ACTIVE_ZNODE_STARTED;
+
+        //update to znode list
+        LogPrintf("CActiveZnode::ManageStateLocal -- Update Znode List\n");
+        mnodeman.UpdateZnodeList(mnb);
+        mnodeman.NotifyZnodeUpdates();
+
+        //send to all peers
+        LogPrintf("CActiveZnode::ManageStateLocal -- Relay broadcast, vin=%s\n", vin.ToString());
+        mnb.RelayZNode();
+    }
+}
diff --git a/src/activeznode.h b/src/activeznode.h
new file mode 100644
index 0000000000..6b70f99793
--- /dev/null
+++ b/src/activeznode.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef ACTIVEZNODE_H
+#define ACTIVEZNODE_H
+
+#include "net.h"
+#include "key.h"
+#include "wallet/wallet.h"
+
+class CActiveZnode;
+
+static const int ACTIVE_ZNODE_INITIAL          = 0; // initial state
+static const int ACTIVE_ZNODE_SYNC_IN_PROCESS  = 1;
+static const int ACTIVE_ZNODE_INPUT_TOO_NEW    = 2;
+static const int ACTIVE_ZNODE_NOT_CAPABLE      = 3;
+static const int ACTIVE_ZNODE_STARTED          = 4;
+
+extern CActiveZnode activeZnode;
+
+// Responsible for activating the Znode and pinging the network
+class CActiveZnode
+{
+public:
+    enum znode_type_enum_t {
+        ZNODE_UNKNOWN = 0,
+        ZNODE_REMOTE  = 1,
+        ZNODE_LOCAL   = 2
+    };
+
+private:
+    // critical section to protect the inner data structures
+    mutable CCriticalSection cs;
+
+    znode_type_enum_t eType;
+
+    bool fPingerEnabled;
+
+    /// Ping Znode
+    bool SendZnodePing();
+
+public:
+    // Keys for the active Znode
+    CPubKey pubKeyZnode;
+    CKey keyZnode;
+
+    // Initialized while registering Znode
+    CTxIn vin;
+    CService service;
+
+    int nState; // should be one of ACTIVE_ZNODE_XXXX
+    std::string strNotCapableReason;
+
+    CActiveZnode()
+        : eType(ZNODE_UNKNOWN),
+          fPingerEnabled(false),
+          pubKeyZnode(),
+          keyZnode(),
+          vin(),
+          service(),
+          nState(ACTIVE_ZNODE_INITIAL)
+    {}
+
+    /// Manage state of active Znode
+    void ManageState();
+
+    std::string GetStateString() const;
+    std::string GetStatus() const;
+    std::string GetTypeString() const;
+
+private:
+    void ManageStateInitial();
+    void ManageStateRemote();
+    void ManageStateLocal();
+};
+
+#endif
diff --git a/src/bitcoind.cpp b/src/bitcoind.cpp
index 0d6e27fa7c..9f06b89522 100644
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -17,6 +17,7 @@
 #include "httpserver.h"
 #include "httprpc.h"
 #include "utilstrencodings.h"
+#include "znodeconfig.h"
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem.hpp>
@@ -118,6 +119,13 @@ bool AppInit(int argc, char* argv[])
             return false;
         }
 
+        // parse znode.conf
+        std::string strErr;
+        if(!znodeConfig.read(strErr)) {
+            fprintf(stderr,"Error reading znode configuration file: %s\n", strErr.c_str());
+            return false;
+        }
+
         // Command-line RPC
         bool fCommandLine = false;
         for (int i = 1; i < argc; i++)
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index ddfa0b22b3..227a29bc41 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -5,6 +5,7 @@
 
 #include "chainparams.h"
 #include "consensus/merkle.h"
+#include "consensus/consensus.h"
 
 #include "tinyformat.h"
 #include "util.h"
@@ -30,8 +31,7 @@ static CBlock CreateGenesisBlock(const char *pszTimestamp, const CScript &genesi
 //    std::cout << "CScriptNum(4):" << csn.GetHex();
 //    CBigNum cbn = CBigNum(4);
 //    std::cout << "CBigNum(4):" << cbn.GetHex();
-    txNew.vin[0].scriptSig = CScript() << 504365040 << CBigNum(4).getvch() << std::vector < unsigned
-    char >
+    txNew.vin[0].scriptSig = CScript() << 504365040 << CBigNum(4).getvch() << std::vector < unsigned char >
     ((const unsigned char *) pszTimestamp, (const unsigned char *) pszTimestamp + strlen(pszTimestamp)) << extraNonce;
     txNew.vout[0].nValue = genesisReward;
     txNew.vout[0].scriptPubKey = genesisOutputScript;
@@ -94,7 +94,7 @@ class CMainParams : public CChainParams {
         consensus.BIP34Height = 227931;
         consensus.BIP34Hash = uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
         consensus.powLimit = uint256S("00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-//            static const int64 nInterval = nTargetTimespan / nTargetSpacing;
+        //static const int64 nInterval = nTargetTimespan / nTargetSpacing;
         consensus.nPowTargetTimespan = 60 * 60; // 60 minutes between retargets
         consensus.nPowTargetSpacing = 10 * 60; // 10 minute blocks
         consensus.fPowAllowMinDifficultyBlocks = false;
@@ -116,14 +116,28 @@ class CMainParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout = 1510704000; // November 15th, 2017.
 
         // The best chain should have at least this much work.
-//        consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000003418b3ccbe5e93bcb39b43");
         consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000708f98bf623f02e");
 
-            /**
-             * The message start string is designed to be unlikely to occur in normal data.
-             * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
-           `  * a large 32-bit integer with any alignment.
-             */
+        // znode params
+        consensus.nZnodePaymentsStartBlock = HF_ZNODE_PAYMENT_START; // not true, but it's ok as long as it's less then nZnodePaymentsIncreaseBlock
+        // consensus.nZnodePaymentsIncreaseBlock = 680000; // actual historical value // not used for now, probably later
+        // consensus.nZnodePaymentsIncreasePeriod = 576*30; // 17280 - actual historical value // not used for now, probably later
+        // consensus.nSuperblockStartBlock = 614820;
+        // consensus.nBudgetPaymentsStartBlock = 328008; // actual historical value
+        // consensus.nBudgetPaymentsCycleBlocks = 16616; // ~(60*24*30)/2.6, actual number of blocks per month is 200700 / 12 = 16725
+        // consensus.nBudgetPaymentsWindowBlocks = 100;
+        nMaxTipAge = 6 * 60 * 60; // ~144 blocks behind -> 2 x fork detection time, was 24 * 60 * 60 in bitcoin
+
+        nPoolMaxTransactions = 3;
+        nFulfilledRequestExpireTime = 60*60; // fulfilled requests expire in 1 hour
+        strSporkPubKey = "04549ac134f694c0243f503e8c8a9a986f5de6610049c40b07816809b0d1d06a21b07be27b9bb555931773f62ba6cf35a25fd52f694d4e1106ccd237a7bb899fdd";
+        strZnodePaymentsPubKey = "04549ac134f694c0243f503e8c8a9a986f5de6610049c40b07816809b0d1d06a21b07be27b9bb555931773f62ba6cf35a25fd52f694d4e1106ccd237a7bb899fdd";
+
+        /**
+         * The message start string is designed to be unlikely to occur in normal data.
+         * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
+       `  * a large 32-bit integer with any alignment.
+         */
         //btzc: update zcoin pchMessage
         pchMessageStart[0] = 0xe3;
         pchMessageStart[1] = 0xd9;
@@ -147,14 +161,10 @@ class CMainParams : public CChainParams {
         extraNonce[3] = 0x00;
         genesis = CreateGenesisBlock(1414776286, 142392, 0x1e0ffff0, 2, 0 * COIN, extraNonce);
         const std::string s = genesis.GetHash().ToString();
-//        std::cout << "zcoin new hashMerkleRoot hash: " << genesis.hashMerkleRoot.ToString() << std::endl;
+        // std::cout << "zcoin new hashMerkleRoot hash: " << genesis.hashMerkleRoot.ToString() << std::endl;
         consensus.hashGenesisBlock = genesis.GetHash();
-        //btzc: update main zcoin hashGenesisBlock and hashMerkleRoot
-        assert(consensus.hashGenesisBlock ==
-               uint256S("0x4381deb85b1b2c9843c222944b616d997516dcbd6a964e1eaf0def0830695233"));
-        assert(genesis.hashMerkleRoot ==
-               uint256S("0x365d2aa75d061370c9aefdabac3985716b1e3b4bb7c4af4ed54f25e5aaa42783"));
-        //btzc: update zcoin cdnsseeddata`
+        assert(consensus.hashGenesisBlock == uint256S("0x4381deb85b1b2c9843c222944b616d997516dcbd6a964e1eaf0def0830695233"));
+        assert(genesis.hashMerkleRoot == uint256S("0x365d2aa75d061370c9aefdabac3985716b1e3b4bb7c4af4ed54f25e5aaa42783"));
         vSeeds.push_back(CDNSSeedData("sf1.zcoin.io", "sf1.zcoin.io", false));
         vSeeds.push_back(CDNSSeedData("sf2.zcoin.io", "sf2.zcoin.io", false));
         vSeeds.push_back(CDNSSeedData("london.zcoin.io", "london.zcoin.io", false));
@@ -233,12 +243,26 @@ class CTestNetParams : public CChainParams {
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000708f98bf623f02e");
+        // Znode params testnet
+        consensus.nZnodePaymentsStartBlock = 5200; // not true, but it's ok as long as it's less then n
+        //consensus.nZnodePaymentsIncreaseBlock = 360; // not used for now, probably later
+        //consensus.nZnodePaymentsIncreasePeriod = 650; // not used for now, probably later
+        //consensus.nSuperblockStartBlock = 61000;
+        //consensus.nBudgetPaymentsStartBlock = 60000;
+        //consensus.nBudgetPaymentsCycleBlocks = 50;
+        //consensus.nBudgetPaymentsWindowBlocks = 10;
+        nMaxTipAge = 0x7fffffff; // allow mining on top of old blocks for testnet
+
+        nPoolMaxTransactions = 3;
+        nFulfilledRequestExpireTime = 5*60; // fulfilled requests expire in 5 minutes
+        strSporkPubKey = "046f78dcf911fbd61910136f7f0f8d90578f68d0b3ac973b5040fb7afb501b5939f39b108b0569dca71488f5bbf498d92e4d1194f6f941307ffd95f75e76869f0e";
+        strZnodePaymentsPubKey = "046f78dcf911fbd61910136f7f0f8d90578f68d0b3ac973b5040fb7afb501b5939f39b108b0569dca71488f5bbf498d92e4d1194f6f941307ffd95f75e76869f0e";
 
         pchMessageStart[0] = 0xcf;
         pchMessageStart[1] = 0xfc;
         pchMessageStart[2] = 0xbe;
         pchMessageStart[3] = 0xea;
-        nDefaultPort = 28168;
+        nDefaultPort = 18168;
         nPruneAfterHeight = 1000;
         /**
           * btzc: testnet params
@@ -263,7 +287,8 @@ class CTestNetParams : public CChainParams {
         vSeeds.clear();
         // nodes with support for servicebits filtering should be at the top
         // zcoin test seeds
-        vSeeds.push_back(CDNSSeedData("52.175.244.22", "52.175.244.22", false));
+        vSeeds.push_back(CDNSSeedData("beta1.zcoin.io", "beta1.zcoin.io", false));
+        vSeeds.push_back(CDNSSeedData("beta2.zcoin.io", "beta2.zcoin.io", false));
 
 //        vSeeds.push_back(CDNSSeedData("testnetbitcoin.jonasschnelli.ch", "testnet-seed.bitcoin.jonasschnelli.ch", true));
 //        vSeeds.push_back(CDNSSeedData("petertodd.org", "seed.tbtc.petertodd.org", true));
@@ -329,6 +354,9 @@ class CRegTestParams : public CChainParams {
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S("0x00");
+        // Znode code
+        nFulfilledRequestExpireTime = 5*60; // fulfilled requests expire in 5 minutes
+        nMaxTipAge = 6 * 60 * 60; // ~144 blocks behind -> 2 x fork detection time, was 24 * 60 * 60 in bitcoin
 
         pchMessageStart[0] = 0xfa;
         pchMessageStart[1] = 0xbf;
diff --git a/src/chainparams.h b/src/chainparams.h
index 0c3820b7c6..85e1c9d8bc 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -75,6 +75,12 @@ class CChainParams
     const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
     const std::vector<SeedSpec6>& FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData& Checkpoints() const { return checkpointData; }
+    /** znode code from Dash*/
+    int64_t MaxTipAge() const { return nMaxTipAge; }
+    int PoolMaxTransactions() const { return nPoolMaxTransactions; }
+    int FulfilledRequestExpireTime() const { return nFulfilledRequestExpireTime; }
+    std::string SporkPubKey() const { return strSporkPubKey; }
+    std::string ZnodePaymentPubKey() const { return strZnodePaymentsPubKey; }
 protected:
     CChainParams() {}
 
@@ -93,6 +99,12 @@ class CChainParams
     bool fMineBlocksOnDemand;
     bool fTestnetToBeDeprecatedFieldRPC;
     CCheckpointData checkpointData;
+    /** znode params*/
+    long nMaxTipAge;
+    int nPoolMaxTransactions;
+    int nFulfilledRequestExpireTime;
+    std::string strSporkPubKey;
+    std::string strZnodePaymentsPubKey;
 };
 
 /**
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 7ddaf6a431..dae66907b5 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -59,7 +59,7 @@ class CBaseRegTestParams : public CBaseChainParams
 public:
     CBaseRegTestParams()
     {
-        nRPCPort = 18888;
+        nRPCPort = 28888;
         strDataDir = "regtest";
     }
 };
diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h
index 5d78c9e254..4b4f6f1aee 100644
--- a/src/chainparamsseeds.h
+++ b/src/chainparamsseeds.h
@@ -8,109 +8,18 @@
  * 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,0x34,0xbb,0x29,0x58}, 8168},
-//        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xa6,0x0b,0x6c}, 8168},
-//        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x28,0x4c,0x48,0xd2}, 8168},
-//        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x34,0x00,0xc1}, 8168},
-//        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xb2,0x22,0x72}, 8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0xbb,0x29,0x58},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0xb2,0x22,0x72},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x28,0x4c,0x48,0xd2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x1,0xa,0x88,0x78},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x1,0xa,0x88,0x54},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x68,0xed,0x4,0x21},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x6e,0x50,0x1,0xfa},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x70,0x4a,0x39,0xc2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x71,0x4e,0xfd,0xbe},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x72,0xd7,0x2e,0xd0},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x73,0xca,0x9f,0x1c},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x73,0xd7,0xe9,0xa2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x73,0xd8,0xb1,0x7e},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x75,0x96,0xb9,0x11},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x76,0xbe,0x4d,0x45},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x77,0x82,0xe5,0x89},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x77,0x89,0x35,0x60},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x77,0x89,0x37,0x4c},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x77,0x31,0x50,0xe0},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x78,0x4d,0x39,0x3f},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x79,0xdb,0x7b,0x43},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x79,0x28,0x76,0x3e},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x7b,0x74,0x6,0x89},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x7d,0x6f,0x8d,0x2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x7d,0x24,0x2f,0xef},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xd,0x5b,0x2d,0xfa},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x86,0x82,0xac,0x58},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x86,0xc4,0x17,0xee},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x88,0xf3,0x32,0x9f},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x8b,0x3b,0xe6,0x56},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x8c,0xe0,0x74,0x9d},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x90,0x4c,0xed,0x27},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x9e,0x45,0x7e,0x9c},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x9e,0x45,0xf8,0x5d},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xac,0x68,0x2d,0x73},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xad,0xef,0xd4,0x29},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xae,0x4c,0x9e,0xc2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xaf,0x91,0x57,0xc8},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xb0,0xe2,0x8f,0xc7},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xb6,0x37,0xd2,0x67},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xb7,0x59,0x5f,0xb4},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xb8,0xa4,0x81,0xca},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xb9,0x8d,0x1b,0x95},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xb9,0x59,0xf4,0x3f},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xc2,0xe4,0xb,0x90},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xd5,0xfe,0x67,0x42},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xd8,0x63,0x64,0xca},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xd9,0x4f,0x2e,0x9f},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xd9,0x4f,0x2e,0x9f},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xdb,0x83,0x7a,0xee},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xdc,0x82,0xea,0xe2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xdc,0xa0,0xc4,0x26},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xdd,0xb,0x16,0x85},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xde,0xa1,0x1a,0xeb},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xde,0x5c,0x48,0xae},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0xdf,0x49,0xea,0x1c},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x1b,0x98,0x5b,0xe9},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x1f,0xa,0x9d,0xe8},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x1f,0x86,0x27,0x69},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x22,0xc1,0x82,0xdd},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x22,0xca,0x6,0xce},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x22,0xe0,0x83,0xf8},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x23,0x9c,0x54,0x5a},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x24,0x2f,0x89,0xed},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x25,0x3b,0x18,0xf},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x27,0x6d,0x7d,0x49},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x28,0x4c,0x48,0xd2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x2b,0xe9,0x82,0x89},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x2e,0x0,0xc0,0x10},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x2e,0x79,0xc6,0x4a},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x2e,0xa6,0xcc,0x3e},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x2f,0x95,0x24,0x1d},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x2f,0x34,0x0,0xc1},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x2f,0x5a,0x17,0x3},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x31,0x23,0xc,0x6},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0xa6,0xb,0x6c},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0xa9,0xb,0x6d},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0xb2,0x22,0x72},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0xbb,0x16,0x34},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0xbb,0x29,0x58},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x34,0x6,0x3d,0xa3},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x3b,0xa8,0xa8,0x76},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x3d,0x64,0x12,0x7d},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x41,0xbe,0x25,0x93},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x42,0xb,0xb2,0x76},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x49,0x78,0x40,0xf9},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x4a,0xd0,0x58,0xa2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x4e,0x9d,0x18,0x50},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x4e,0x5e,0x20,0xc2},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x50,0x96,0xa3,0x22},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x54,0xd0,0x32,0x40},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x54,0x19,0x5a,0xe4},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x59,0x8e,0x28,0xdc},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x5c,0x3f,0x39,0xaa},8168},
-        {{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x5d,0x32,0x72,0x98},8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4d,0xcd,0x05}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x20,0xe8,0xc3}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x68,0xee,0xac,0xa4}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x3f,0x5b,0x97}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4d,0xb8,0xbb}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4d,0x33,0x62}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4d,0x3d,0xcb}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4c,0xce,0x0f}, 8168},
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x4c,0x95,0x7e}, 8168}
 };
 
 static SeedSpec6 pnSeed6_test[] = {
-        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xaf,0xf4,0x16}, 28168}
+        {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xaf,0xf4,0x16}, 18168}
 };
 #endif // BITCOIN_CHAINPARAMSSEEDS_H
\ No newline at end of file
diff --git a/src/checkpoints.cpp b/src/checkpoints.cpp
index d22c188c16..aefddce464 100644
--- a/src/checkpoints.cpp
+++ b/src/checkpoints.cpp
@@ -55,6 +55,16 @@ namespace Checkpoints {
         return fWorkBefore / (fWorkBefore + fWorkAfter);
     }
 
+    int GetTotalBlocksEstimate(const CCheckpointData& data)
+    {
+        const MapCheckpoints& checkpoints = data.mapCheckpoints;
+
+        if (checkpoints.empty())
+            return 0;
+
+        return checkpoints.rbegin()->first;
+    }
+
     CBlockIndex* GetLastCheckpoint(const CCheckpointData& data)
     {
         const MapCheckpoints& checkpoints = data.mapCheckpoints;
diff --git a/src/checkpoints.h b/src/checkpoints.h
index 04346f35ff..8fda4cb1eb 100644
--- a/src/checkpoints.h
+++ b/src/checkpoints.h
@@ -22,6 +22,9 @@ namespace Checkpoints
 //! Returns last CBlockIndex* in mapBlockIndex that is a checkpoint
 CBlockIndex* GetLastCheckpoint(const CCheckpointData& data);
 
+//! Return conservative estimate of total number of blocks, 0 if unknown
+int GetTotalBlocksEstimate(const CCheckpointData& data);
+
 double GuessVerificationProgress(const CCheckpointData& data, CBlockIndex* pindex, bool fSigchecks = true);
 
 } //namespace Checkpoints
diff --git a/src/clientversion.h b/src/clientversion.h
index 3e1d4d6b9c..a46e32038b 100644
--- a/src/clientversion.h
+++ b/src/clientversion.h
@@ -13,12 +13,11 @@
  * client versioning and copyright year
  */
 
-//btzc: update client version
 //! These need to be macros, as clientversion.cpp's and bitcoin*-res.rc's voodoo requires it
 #define CLIENT_VERSION_MAJOR 0
 #define CLIENT_VERSION_MINOR 13
-#define CLIENT_VERSION_REVISION 3
-#define CLIENT_VERSION_BUILD 3
+#define CLIENT_VERSION_REVISION 4
+#define CLIENT_VERSION_BUILD 1
 
 //! Set to true for release, false for prerelease or test build
 #define CLIENT_VERSION_IS_RELEASE true
diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index 5483eefc6b..775ce4e8ee 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -1,5 +1,7 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2016-2017 The Zcoin developers
+
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -8,6 +10,22 @@
 
 #include <stdint.h>
 
+// HF constants
+static const int HF_LYRA2VAR_HEIGHT = 500;
+static const int HF_LYRA2_HEIGHT = 8192;
+static const int HF_LYRA2Z_HEIGHT = 20500;
+static const int HF_ZNODE_HEIGHT = 66550;
+static const int HF_ZNODE_PAYMENT_START = HF_ZNODE_HEIGHT + 150; // 66700 - about 25h after HF
+//static const int HF_MTP_HEIGHT = 70000;
+
+static const int HF_LYRA2VAR_HEIGHT_TESTNET = 10;
+static const int HF_LYRA2_HEIGHT_TESTNET = 25; // for consistent purpose since the algo hash is so low
+static const int HF_LYRA2Z_HEIGHT_TESTNET = 30;
+static const int HF_ZNODE_HEIGHT_TESTNET = 500;
+//static const int HF_MTP_HEIGHT_TESTNET = 30;
+
+static const int HF_ZEROSPEND_FIX = 22000;
+
 /** The maximum allowed size for a serialized block, in bytes (only for buffer size limits) */
 static const unsigned int MAX_BLOCK_SERIALIZED_SIZE = 2000000;
 /** The maximum allowed weight for a block, see BIP 141 (network rule) */
diff --git a/src/consensus/params.h b/src/consensus/params.h
index de40c7d1db..726f294164 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -63,6 +63,16 @@ struct Params {
     int64_t nChainStartTime;
     unsigned char nMinNFactor;
     unsigned char nMaxNFactor;
+    int nInstantSendKeepLock; // in blocks
+    //int nBudgetPaymentsStartBlock;
+    //int nBudgetPaymentsCycleBlocks;
+    //int nBudgetPaymentsWindowBlocks;
+    int nZnodeMinimumConfirmations;
+    int nZnodePaymentsStartBlock;
+    //int nZnodePaymentsIncreaseBlock;
+    //int nZnodePaymentsIncreasePeriod; // in blocks
+    //int nSuperblockStartBlock;
+
     int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
     uint256 nMinimumChainWork;
 };
diff --git a/src/consensus/validation.h b/src/consensus/validation.h
index 5af0a1b384..6990a012e9 100644
--- a/src/consensus/validation.h
+++ b/src/consensus/validation.h
@@ -23,6 +23,7 @@ static const unsigned char PUBCOIN_NOT_VALIDATE = 0x46;
 static const unsigned char NSEQUENCE_INCORRECT = 0x47;
 static const unsigned char PUBLIC_COIN_FOR_ACCUMULATOR_INVALID = 0x48;
 static const unsigned char NO_MINT_ZEROCOIN = 0x49;
+static const unsigned char REJECT_INVALID_ZNODE_PAYMENT = 0x50;
 
 /** Capture information about block/transaction validation */
 class CValidationState {
diff --git a/src/crypto/scrypt.cpp b/src/crypto/scrypt.cpp
index aa25bb327a..2f9803d442 100644
--- a/src/crypto/scrypt.cpp
+++ b/src/crypto/scrypt.cpp
@@ -269,7 +269,6 @@ void scrypt_N_1_1_256_sp_generic(const char *input, char *output, char *scratchp
         X[k] = scrypt_le32dec(&B[4 * k]);
     N = (1 << (Nfactor + 1));
     for (i = 0; i < N; i++) {
-//        std::cout << "[btzc]scrypt_N_1_1_256_sp_generic checkpoint i=" << i << std::endl;
         memcpy(&V[i * 32], X, 128);
         xor_salsa8(&X[0], &X[16]);
         xor_salsa8(&X[16], &X[0]);
diff --git a/src/darksend-relay.cpp b/src/darksend-relay.cpp
new file mode 100644
index 0000000000..6a6b2d6fc8
--- /dev/null
+++ b/src/darksend-relay.cpp
@@ -0,0 +1,115 @@
+#include "darksend.h"
+#include "darksend-relay.h"
+
+
+CDarkSendRelay::CDarkSendRelay()
+{
+    vinZnode = CTxIn();
+    nBlockHeight = 0;
+    nRelayType = 0;
+    in = CTxIn();
+    out = CTxOut();
+}
+
+CDarkSendRelay::CDarkSendRelay(CTxIn& vinZnodeIn, vector<unsigned char>& vchSigIn, int nBlockHeightIn, int nRelayTypeIn, CTxIn& in2, CTxOut& out2)
+{
+    vinZnode = vinZnodeIn;
+    vchSig = vchSigIn;
+    nBlockHeight = nBlockHeightIn;
+    nRelayType = nRelayTypeIn;
+    in = in2;
+    out = out2;
+}
+
+std::string CDarkSendRelay::ToString()
+{
+    std::ostringstream info;
+
+    info << "vin: " << vinZnode.ToString() <<
+        " nBlockHeight: " << (int)nBlockHeight <<
+        " nRelayType: "  << (int)nRelayType <<
+        " in " << in.ToString() <<
+        " out " << out.ToString();
+        
+    return info.str();   
+}
+
+bool CDarkSendRelay::Sign(std::string strSharedKey)
+{
+    std::string strError = "";
+    std::string strMessage = in.ToString() + out.ToString();
+
+    CKey key2;
+    CPubKey pubkey2;
+
+    if(!darkSendSigner.GetKeysFromSecret(strSharedKey, key2, pubkey2)) {
+        LogPrintf("CDarkSendRelay::Sign -- GetKeysFromSecret() failed, invalid shared key %s\n", strSharedKey);
+        return false;
+    }
+
+    if(!darkSendSigner.SignMessage(strMessage, vchSig2, key2)) {
+        LogPrintf("CDarkSendRelay::Sign -- SignMessage() failed\n");
+        return false;
+    }
+
+    if(!darkSendSigner.VerifyMessage(pubkey2, vchSig2, strMessage, strError)) {
+        LogPrintf("CDarkSendRelay::Sign -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+bool CDarkSendRelay::VerifyMessage(std::string strSharedKey)
+{
+    std::string strError = "";
+    std::string strMessage = in.ToString() + out.ToString();
+
+    CKey key2;
+    CPubKey pubkey2;
+
+    if(!darkSendSigner.GetKeysFromSecret(strSharedKey, key2, pubkey2)) {
+        LogPrintf("CDarkSendRelay::VerifyMessage -- GetKeysFromSecret() failed, invalid shared key %s\n", strSharedKey);
+        return false;
+    }
+
+    if(!darkSendSigner.VerifyMessage(pubkey2, vchSig2, strMessage, strError)) {
+        LogPrintf("CDarkSendRelay::VerifyMessage -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+void CDarkSendRelay::Relay()
+{
+    int nCount = std::min(mnodeman.CountEnabled(MIN_PRIVATESEND_PEER_PROTO_VERSION), 20);
+    int nRank1 = (rand() % nCount)+1; 
+    int nRank2 = (rand() % nCount)+1; 
+
+    //keep picking another second number till we get one that doesn't match
+    while(nRank1 == nRank2) nRank2 = (rand() % nCount)+1;
+
+    //printf("rank 1 - rank2 %d %d \n", nRank1, nRank2);
+
+    //relay this message through 2 separate nodes for redundancy
+    RelayThroughNode(nRank1);
+    RelayThroughNode(nRank2);
+}
+
+void CDarkSendRelay::RelayThroughNode(int nRank)
+{
+    CZnode* pmn = mnodeman.GetZnodeByRank(nRank, nBlockHeight, MIN_PRIVATESEND_PEER_PROTO_VERSION);
+
+    if(pmn != NULL){
+        //printf("RelayThroughNode %s\n", pmn->addr.ToString().c_str());
+        CNode* pnode = ConnectNode((CAddress)pmn->addr, NULL);
+        if(pnode) {
+            //printf("Connected\n");
+            pnode->PushMessage("dsr", (*this));
+            return;
+        }
+    } else {
+        //printf("RelayThroughNode NULL\n");
+    }
+}
diff --git a/src/darksend-relay.h b/src/darksend-relay.h
new file mode 100644
index 0000000000..ee6ac57487
--- /dev/null
+++ b/src/darksend-relay.h
@@ -0,0 +1,51 @@
+
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef DARKSEND_RELAY_H
+#define DARKSEND_RELAY_H
+
+#include "main.h"
+#include "activeznode.h"
+#include "znodeman.h"
+
+
+class CDarkSendRelay
+{
+public:
+    CTxIn vinZnode;
+    vector<unsigned char> vchSig;
+    vector<unsigned char> vchSig2;
+    int nBlockHeight;
+    int nRelayType;
+    CTxIn in;
+    CTxOut out;
+
+    CDarkSendRelay();
+    CDarkSendRelay(CTxIn& vinZnodeIn, vector<unsigned char>& vchSigIn, int nBlockHeightIn, int nRelayTypeIn, CTxIn& in2, CTxOut& out2);
+    
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(vinZnode);
+        READWRITE(vchSig);
+        READWRITE(vchSig2);
+        READWRITE(nBlockHeight);
+        READWRITE(nRelayType);
+        READWRITE(in);
+        READWRITE(out);
+    }
+
+    std::string ToString();
+
+    bool Sign(std::string strSharedKey);
+    bool VerifyMessage(std::string strSharedKey);
+    void Relay();
+    void RelayThroughNode(int nRank);
+};
+
+
+
+#endif
diff --git a/src/darksend.cpp b/src/darksend.cpp
new file mode 100644
index 0000000000..32a89f5936
--- /dev/null
+++ b/src/darksend.cpp
@@ -0,0 +1,2546 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "activeznode.h"
+#include "coincontrol.h"
+#include "consensus/validation.h"
+#include "darksend.h"
+//#include "governance.h"
+#include "init.h"
+#include "instantx.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "script/sign.h"
+#include "txmempool.h"
+#include "util.h"
+#include "utilmoneystr.h"
+
+#include <boost/lexical_cast.hpp>
+
+int nPrivateSendRounds = DEFAULT_PRIVATESEND_ROUNDS;
+int nPrivateSendAmount = DEFAULT_PRIVATESEND_AMOUNT;
+int nLiquidityProvider = DEFAULT_PRIVATESEND_LIQUIDITY;
+bool fEnablePrivateSend = false;
+bool fPrivateSendMultiSession = DEFAULT_PRIVATESEND_MULTISESSION;
+
+CDarksendPool darkSendPool;
+CDarkSendSigner darkSendSigner;
+std::map <uint256, CDarksendBroadcastTx> mapDarksendBroadcastTxes;
+std::vector <CAmount> vecPrivateSendDenominations;
+
+void CDarksendPool::ProcessMessage(CNode *pfrom, std::string &strCommand, CDataStream &vRecv) {
+    if (fLiteMode) return; // ignore all Dash related functionality
+    if (!znodeSync.IsBlockchainSynced()) return;
+
+    if (strCommand == NetMsgType::DSACCEPT) {
+
+        if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
+            LogPrintf("DSACCEPT -- incompatible version! nVersion: %d\n", pfrom->nVersion);
+            PushStatus(pfrom, STATUS_REJECTED, ERR_VERSION);
+            return;
+        }
+
+        if (!fZNode) {
+            LogPrintf("DSACCEPT -- not a Znode!\n");
+            PushStatus(pfrom, STATUS_REJECTED, ERR_NOT_A_MN);
+            return;
+        }
+
+        if (IsSessionReady()) {
+            // too many users in this session already, reject new ones
+            LogPrintf("DSACCEPT -- queue is already full!\n");
+            PushStatus(pfrom, STATUS_ACCEPTED, ERR_QUEUE_FULL);
+            return;
+        }
+
+        int nDenom;
+        CTransaction txCollateral;
+        vRecv >> nDenom >> txCollateral;
+
+        LogPrint("privatesend", "DSACCEPT -- nDenom %d (%s)  txCollateral %s", nDenom, GetDenominationsToString(nDenom), txCollateral.ToString());
+
+        CZnode *pmn = mnodeman.Find(activeZnode.vin);
+        if (pmn == NULL) {
+            PushStatus(pfrom, STATUS_REJECTED, ERR_MN_LIST);
+            return;
+        }
+
+        if (vecSessionCollaterals.size() == 0 && pmn->nLastDsq != 0 &&
+            pmn->nLastDsq + mnodeman.CountEnabled(MIN_PRIVATESEND_PEER_PROTO_VERSION) / 5 > mnodeman.nDsqCount) {
+            LogPrintf("DSACCEPT -- last dsq too recent, must wait: addr=%s\n", pfrom->addr.ToString());
+            PushStatus(pfrom, STATUS_REJECTED, ERR_RECENT);
+            return;
+        }
+
+        PoolMessage nMessageID = MSG_NOERR;
+
+        bool fResult = nSessionID == 0 ? CreateNewSession(nDenom, txCollateral, nMessageID)
+                                       : AddUserToExistingSession(nDenom, txCollateral, nMessageID);
+        if (fResult) {
+            LogPrintf("DSACCEPT -- is compatible, please submit!\n");
+            PushStatus(pfrom, STATUS_ACCEPTED, nMessageID);
+            return;
+        } else {
+            LogPrintf("DSACCEPT -- not compatible with existing transactions!\n");
+            PushStatus(pfrom, STATUS_REJECTED, nMessageID);
+            return;
+        }
+
+    } else if (strCommand == NetMsgType::DSQUEUE) {
+        TRY_LOCK(cs_darksend, lockRecv);
+        if (!lockRecv) return;
+
+        if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
+            LogPrint("privatesend", "DSQUEUE -- incompatible version! nVersion: %d\n", pfrom->nVersion);
+            return;
+        }
+
+        CDarksendQueue dsq;
+        vRecv >> dsq;
+
+        // process every dsq only once
+        BOOST_FOREACH(CDarksendQueue
+        q, vecDarksendQueue) {
+            if (q == dsq) {
+                // LogPrint("privatesend", "DSQUEUE -- %s seen\n", dsq.ToString());
+                return;
+            }
+        }
+
+        LogPrint("privatesend", "DSQUEUE -- %s new\n", dsq.ToString());
+
+        if (dsq.IsExpired() || dsq.nTime > GetTime() + PRIVATESEND_QUEUE_TIMEOUT) return;
+
+        CZnode *pmn = mnodeman.Find(dsq.vin);
+        if (pmn == NULL) return;
+
+        if (!dsq.CheckSignature(pmn->pubKeyZnode)) {
+            // we probably have outdated info
+            mnodeman.AskForMN(pfrom, dsq.vin);
+            return;
+        }
+
+        // if the queue is ready, submit if we can
+        if (dsq.fReady) {
+            if (!pSubmittedToZnode) return;
+            if ((CNetAddr) pSubmittedToZnode->addr != (CNetAddr) pmn->addr) {
+                LogPrintf("DSQUEUE -- message doesn't match current Znode: pSubmittedToZnode=%s, addr=%s\n", pSubmittedToZnode->addr.ToString(), pmn->addr.ToString());
+                return;
+            }
+
+            if (nState == POOL_STATE_QUEUE) {
+                LogPrint("privatesend", "DSQUEUE -- PrivateSend queue (%s) is ready on znode %s\n", dsq.ToString(), pmn->addr.ToString());
+                SubmitDenominate();
+            }
+        } else {
+            BOOST_FOREACH(CDarksendQueue
+            q, vecDarksendQueue) {
+                if (q.vin == dsq.vin) {
+                    // no way same mn can send another "not yet ready" dsq this soon
+                    LogPrint("privatesend", "DSQUEUE -- Znode %s is sending WAY too many dsq messages\n", pmn->addr.ToString());
+                    return;
+                }
+            }
+
+            int nThreshold = pmn->nLastDsq + mnodeman.CountEnabled(MIN_PRIVATESEND_PEER_PROTO_VERSION) / 5;
+            LogPrint("privatesend", "DSQUEUE -- nLastDsq: %d  threshold: %d  nDsqCount: %d\n", pmn->nLastDsq, nThreshold, mnodeman.nDsqCount);
+            //don't allow a few nodes to dominate the queuing process
+            if (pmn->nLastDsq != 0 && nThreshold > mnodeman.nDsqCount) {
+                LogPrint("privatesend", "DSQUEUE -- Znode %s is sending too many dsq messages\n", pmn->addr.ToString());
+                return;
+            }
+            mnodeman.nDsqCount++;
+            pmn->nLastDsq = mnodeman.nDsqCount;
+            pmn->fAllowMixingTx = true;
+
+            LogPrint("privatesend", "DSQUEUE -- new PrivateSend queue (%s) from znode %s\n", dsq.ToString(), pmn->addr.ToString());
+            if (pSubmittedToZnode && pSubmittedToZnode->vin.prevout == dsq.vin.prevout) {
+                dsq.fTried = true;
+            }
+            vecDarksendQueue.push_back(dsq);
+            dsq.Relay();
+        }
+
+    } else if (strCommand == NetMsgType::DSVIN) {
+
+        if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
+            LogPrintf("DSVIN -- incompatible version! nVersion: %d\n", pfrom->nVersion);
+            PushStatus(pfrom, STATUS_REJECTED, ERR_VERSION);
+            return;
+        }
+
+        if (!fZNode) {
+            LogPrintf("DSVIN -- not a Znode!\n");
+            PushStatus(pfrom, STATUS_REJECTED, ERR_NOT_A_MN);
+            return;
+        }
+
+        //do we have enough users in the current session?
+        if (!IsSessionReady()) {
+            LogPrintf("DSVIN -- session not complete!\n");
+            PushStatus(pfrom, STATUS_REJECTED, ERR_SESSION);
+            return;
+        }
+
+        CDarkSendEntry entry;
+        vRecv >> entry;
+
+        LogPrint("privatesend", "DSVIN -- txCollateral %s", entry.txCollateral.ToString());
+
+        //do we have the same denominations as the current session?
+        if (!IsOutputsCompatibleWithSessionDenom(entry.vecTxDSOut)) {
+            LogPrintf("DSVIN -- not compatible with existing transactions!\n");
+            PushStatus(pfrom, STATUS_REJECTED, ERR_EXISTING_TX);
+            return;
+        }
+
+        //check it like a transaction
+        {
+            CAmount nValueIn = 0;
+            CAmount nValueOut = 0;
+
+            CMutableTransaction tx;
+
+            BOOST_FOREACH(
+            const CTxOut txout, entry.vecTxDSOut) {
+                nValueOut += txout.nValue;
+                tx.vout.push_back(txout);
+
+                if (txout.scriptPubKey.size() != 25) {
+                    LogPrintf("DSVIN -- non-standard pubkey detected! scriptPubKey=%s\n", ScriptToAsmStr(txout.scriptPubKey));
+                    PushStatus(pfrom, STATUS_REJECTED, ERR_NON_STANDARD_PUBKEY);
+                    return;
+                }
+                if (!txout.scriptPubKey.IsNormalPaymentScript()) {
+                    LogPrintf("DSVIN -- invalid script! scriptPubKey=%s\n", ScriptToAsmStr(txout.scriptPubKey));
+                    PushStatus(pfrom, STATUS_REJECTED, ERR_INVALID_SCRIPT);
+                    return;
+                }
+            }
+
+            BOOST_FOREACH(
+            const CTxIn txin, entry.vecTxDSIn) {
+                tx.vin.push_back(txin);
+
+                LogPrint("privatesend", "DSVIN -- txin=%s\n", txin.ToString());
+
+                CTransaction txPrev;
+                uint256 hash;
+                if (GetTransaction(txin.prevout.hash, txPrev, Params().GetConsensus(), hash, true)) {
+                    if (txPrev.vout.size() > txin.prevout.n)
+                        nValueIn += txPrev.vout[txin.prevout.n].nValue;
+                } else {
+                    LogPrintf("DSVIN -- missing input! tx=%s", tx.ToString());
+                    PushStatus(pfrom, STATUS_REJECTED, ERR_MISSING_TX);
+                    return;
+                }
+            }
+
+            if (nValueIn > PRIVATESEND_POOL_MAX) {
+                LogPrintf("DSVIN -- more than PrivateSend pool max! nValueIn: %lld, tx=%s", nValueIn, tx.ToString());
+                PushStatus(pfrom, STATUS_REJECTED, ERR_MAXIMUM);
+                return;
+            }
+
+            // Allow lowest denom (at max) as a a fee. Normally shouldn't happen though.
+            // TODO: Or do not allow fees at all?
+            if (nValueIn - nValueOut > vecPrivateSendDenominations.back()) {
+                LogPrintf("DSVIN -- fees are too high! fees: %lld, tx=%s", nValueIn - nValueOut, tx.ToString());
+                PushStatus(pfrom, STATUS_REJECTED, ERR_FEES);
+                return;
+            }
+
+            {
+                LOCK(cs_main);
+                CValidationState validationState;
+                mempool.PrioritiseTransaction(tx.GetHash(), tx.GetHash().ToString(), 1000, 0.1 * COIN);
+                if (!AcceptToMemoryPool(mempool, validationState, CTransaction(tx), true, false, NULL, false, true, true)) {
+                    LogPrintf("DSVIN -- transaction not valid! tx=%s", tx.ToString());
+                    PushStatus(pfrom, STATUS_REJECTED, ERR_INVALID_TX);
+                    return;
+                }
+            }
+        }
+
+        PoolMessage nMessageID = MSG_NOERR;
+
+        if (AddEntry(entry, nMessageID)) {
+            PushStatus(pfrom, STATUS_ACCEPTED, nMessageID);
+            CheckPool();
+            RelayStatus(STATUS_ACCEPTED);
+        } else {
+            PushStatus(pfrom, STATUS_REJECTED, nMessageID);
+            SetNull();
+        }
+
+    } else if (strCommand == NetMsgType::DSSTATUSUPDATE) {
+
+        if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
+            LogPrintf("DSSTATUSUPDATE -- incompatible version! nVersion: %d\n", pfrom->nVersion);
+            return;
+        }
+
+        if (fZNode) {
+            // LogPrintf("DSSTATUSUPDATE -- Can't run on a Znode!\n");
+            return;
+        }
+
+        if (!pSubmittedToZnode) return;
+        if ((CNetAddr) pSubmittedToZnode->addr != (CNetAddr) pfrom->addr) {
+            //LogPrintf("DSSTATUSUPDATE -- message doesn't match current Znode: pSubmittedToZnode %s addr %s\n", pSubmittedToZnode->addr.ToString(), pfrom->addr.ToString());
+            return;
+        }
+
+        int nMsgSessionID;
+        int nMsgState;
+        int nMsgEntriesCount;
+        int nMsgStatusUpdate;
+        int nMsgMessageID;
+        vRecv >> nMsgSessionID >> nMsgState >> nMsgEntriesCount >> nMsgStatusUpdate >> nMsgMessageID;
+
+        LogPrint("privatesend", "DSSTATUSUPDATE -- nMsgSessionID %d  nMsgState: %d  nEntriesCount: %d  nMsgStatusUpdate: %d  nMsgMessageID %d\n",
+                 nMsgSessionID, nMsgState, nEntriesCount, nMsgStatusUpdate, nMsgMessageID);
+
+        if (nMsgState < POOL_STATE_MIN || nMsgState > POOL_STATE_MAX) {
+            LogPrint("privatesend", "DSSTATUSUPDATE -- nMsgState is out of bounds: %d\n", nMsgState);
+            return;
+        }
+
+        if (nMsgStatusUpdate < STATUS_REJECTED || nMsgStatusUpdate > STATUS_ACCEPTED) {
+            LogPrint("privatesend", "DSSTATUSUPDATE -- nMsgStatusUpdate is out of bounds: %d\n", nMsgStatusUpdate);
+            return;
+        }
+
+        if (nMsgMessageID < MSG_POOL_MIN || nMsgMessageID > MSG_POOL_MAX) {
+            LogPrint("privatesend", "DSSTATUSUPDATE -- nMsgMessageID is out of bounds: %d\n", nMsgMessageID);
+            return;
+        }
+
+        LogPrint("privatesend", "DSSTATUSUPDATE -- GetMessageByID: %s\n", GetMessageByID(PoolMessage(nMsgMessageID)));
+
+        if (!CheckPoolStateUpdate(PoolState(nMsgState), nMsgEntriesCount, PoolStatusUpdate(nMsgStatusUpdate), PoolMessage(nMsgMessageID), nMsgSessionID)) {
+            LogPrint("privatesend", "DSSTATUSUPDATE -- CheckPoolStateUpdate failed\n");
+        }
+
+    } else if (strCommand == NetMsgType::DSSIGNFINALTX) {
+
+        if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
+            LogPrintf("DSSIGNFINALTX -- incompatible version! nVersion: %d\n", pfrom->nVersion);
+            return;
+        }
+
+        if (!fZNode) {
+            LogPrintf("DSSIGNFINALTX -- not a Znode!\n");
+            return;
+        }
+
+        std::vector <CTxIn> vecTxIn;
+        vRecv >> vecTxIn;
+
+        LogPrint("privatesend", "DSSIGNFINALTX -- vecTxIn.size() %s\n", vecTxIn.size());
+
+        int nTxInIndex = 0;
+        int nTxInsCount = (int) vecTxIn.size();
+
+        BOOST_FOREACH(
+        const CTxIn txin, vecTxIn) {
+            nTxInIndex++;
+            if (!AddScriptSig(txin)) {
+                LogPrint("privatesend", "DSSIGNFINALTX -- AddScriptSig() failed at %d/%d, session: %d\n", nTxInIndex, nTxInsCount, nSessionID);
+                RelayStatus(STATUS_REJECTED);
+                return;
+            }
+            LogPrint("privatesend", "DSSIGNFINALTX -- AddScriptSig() %d/%d success\n", nTxInIndex, nTxInsCount);
+        }
+        // all is good
+        CheckPool();
+
+    } else if (strCommand == NetMsgType::DSFINALTX) {
+
+        if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
+            LogPrintf("DSFINALTX -- incompatible version! nVersion: %d\n", pfrom->nVersion);
+            return;
+        }
+
+        if (fZNode) {
+            // LogPrintf("DSFINALTX -- Can't run on a Znode!\n");
+            return;
+        }
+
+        if (!pSubmittedToZnode) return;
+        if ((CNetAddr) pSubmittedToZnode->addr != (CNetAddr) pfrom->addr) {
+            //LogPrintf("DSFINALTX -- message doesn't match current Znode: pSubmittedToZnode %s addr %s\n", pSubmittedToZnode->addr.ToString(), pfrom->addr.ToString());
+            return;
+        }
+
+        int nMsgSessionID;
+        CTransaction txNew;
+        vRecv >> nMsgSessionID >> txNew;
+
+        if (nSessionID != nMsgSessionID) {
+            LogPrint("privatesend", "DSFINALTX -- message doesn't match current PrivateSend session: nSessionID: %d  nMsgSessionID: %d\n", nSessionID, nMsgSessionID);
+            return;
+        }
+
+        LogPrint("privatesend", "DSFINALTX -- txNew %s", txNew.ToString());
+
+        //check to see if input is spent already? (and probably not confirmed)
+        SignFinalTransaction(txNew, pfrom);
+
+    } else if (strCommand == NetMsgType::DSCOMPLETE) {
+
+        if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
+            LogPrintf("DSCOMPLETE -- incompatible version! nVersion: %d\n", pfrom->nVersion);
+            return;
+        }
+
+        if (fZNode) {
+            // LogPrintf("DSCOMPLETE -- Can't run on a Znode!\n");
+            return;
+        }
+
+        if (!pSubmittedToZnode) return;
+        if ((CNetAddr) pSubmittedToZnode->addr != (CNetAddr) pfrom->addr) {
+            LogPrint("privatesend", "DSCOMPLETE -- message doesn't match current Znode: pSubmittedToZnode=%s  addr=%s\n", pSubmittedToZnode->addr.ToString(), pfrom->addr.ToString());
+            return;
+        }
+
+        int nMsgSessionID;
+        int nMsgMessageID;
+        vRecv >> nMsgSessionID >> nMsgMessageID;
+
+        if (nMsgMessageID < MSG_POOL_MIN || nMsgMessageID > MSG_POOL_MAX) {
+            LogPrint("privatesend", "DSCOMPLETE -- nMsgMessageID is out of bounds: %d\n", nMsgMessageID);
+            return;
+        }
+
+        if (nSessionID != nMsgSessionID) {
+            LogPrint("privatesend", "DSCOMPLETE -- message doesn't match current PrivateSend session: nSessionID: %d  nMsgSessionID: %d\n", darkSendPool.nSessionID, nMsgSessionID);
+            return;
+        }
+
+        LogPrint("privatesend", "DSCOMPLETE -- nMsgSessionID %d  nMsgMessageID %d (%s)\n", nMsgSessionID, nMsgMessageID, GetMessageByID(PoolMessage(nMsgMessageID)));
+
+        CompletedTransaction(PoolMessage(nMsgMessageID));
+    }
+}
+
+void CDarksendPool::InitDenominations() {
+    vecPrivateSendDenominations.clear();
+    /* Denominations
+
+        A note about convertability. Within mixing pools, each denomination
+        is convertable to another.
+
+        For example:
+        1DRK+1000 == (.1DRK+100)*10
+        10DRK+10000 == (1DRK+1000)*10
+    */
+    /* Disabled
+    vecPrivateSendDenominations.push_back( (100      * COIN)+100000 );
+    */
+    vecPrivateSendDenominations.push_back((10 * COIN) + 10000);
+    vecPrivateSendDenominations.push_back((1 * COIN) + 1000);
+    vecPrivateSendDenominations.push_back((.1 * COIN) + 100);
+    vecPrivateSendDenominations.push_back((.01 * COIN) + 10);
+    /* Disabled till we need them
+    vecPrivateSendDenominations.push_back( (.001     * COIN)+1 );
+    */
+}
+
+void CDarksendPool::ResetPool() {
+    nCachedLastSuccessBlock = 0;
+    txMyCollateral = CMutableTransaction();
+    vecZnodesUsed.clear();
+    UnlockCoins();
+    SetNull();
+}
+
+void CDarksendPool::SetNull() {
+    // MN side
+    vecSessionCollaterals.clear();
+
+    // Client side
+    nEntriesCount = 0;
+    fLastEntryAccepted = false;
+    pSubmittedToZnode = NULL;
+
+    // Both sides
+    nState = POOL_STATE_IDLE;
+    nSessionID = 0;
+    nSessionDenom = 0;
+    vecEntries.clear();
+    finalMutableTransaction.vin.clear();
+    finalMutableTransaction.vout.clear();
+    nTimeLastSuccessfulStep = GetTimeMillis();
+}
+
+//
+// Unlock coins after mixing fails or succeeds
+//
+void CDarksendPool::UnlockCoins() {
+    while (true) {
+        TRY_LOCK(pwalletMain->cs_wallet, lockWallet);
+        if (!lockWallet) {
+            MilliSleep(50);
+            continue;
+        }
+        BOOST_FOREACH(COutPoint
+        outpoint, vecOutPointLocked)
+        pwalletMain->UnlockCoin(outpoint);
+        break;
+    }
+
+    vecOutPointLocked.clear();
+}
+
+std::string CDarksendPool::GetStateString() const {
+    switch (nState) {
+        case POOL_STATE_IDLE:
+            return "IDLE";
+        case POOL_STATE_QUEUE:
+            return "QUEUE";
+        case POOL_STATE_ACCEPTING_ENTRIES:
+            return "ACCEPTING_ENTRIES";
+        case POOL_STATE_SIGNING:
+            return "SIGNING";
+        case POOL_STATE_ERROR:
+            return "ERROR";
+        case POOL_STATE_SUCCESS:
+            return "SUCCESS";
+        default:
+            return "UNKNOWN";
+    }
+}
+
+std::string CDarksendPool::GetStatus() {
+    static int nStatusMessageProgress = 0;
+    nStatusMessageProgress += 10;
+    std::string strSuffix = "";
+
+    if ((pCurrentBlockIndex && pCurrentBlockIndex->nHeight - nCachedLastSuccessBlock < nMinBlockSpacing) || !znodeSync.IsBlockchainSynced())
+        return strAutoDenomResult;
+
+    switch (nState) {
+        case POOL_STATE_IDLE:
+            return _("PrivateSend is idle.");
+        case POOL_STATE_QUEUE:
+            if (nStatusMessageProgress % 70 <= 30) strSuffix = ".";
+            else if (nStatusMessageProgress % 70 <= 50) strSuffix = "..";
+            else if (nStatusMessageProgress % 70 <= 70) strSuffix = "...";
+            return strprintf(_("Submitted to znode, waiting in queue %s"), strSuffix);;
+        case POOL_STATE_ACCEPTING_ENTRIES:
+            if (nEntriesCount == 0) {
+                nStatusMessageProgress = 0;
+                return strAutoDenomResult;
+            } else if (fLastEntryAccepted) {
+                if (nStatusMessageProgress % 10 > 8) {
+                    fLastEntryAccepted = false;
+                    nStatusMessageProgress = 0;
+                }
+                return _("PrivateSend request complete:") + " " + _("Your transaction was accepted into the pool!");
+            } else {
+                if (nStatusMessageProgress % 70 <= 40) return strprintf(_("Submitted following entries to znode: %u / %d"), nEntriesCount, GetMaxPoolTransactions());
+                else if (nStatusMessageProgress % 70 <= 50) strSuffix = ".";
+                else if (nStatusMessageProgress % 70 <= 60) strSuffix = "..";
+                else if (nStatusMessageProgress % 70 <= 70) strSuffix = "...";
+                return strprintf(_("Submitted to znode, waiting for more entries ( %u / %d ) %s"), nEntriesCount, GetMaxPoolTransactions(), strSuffix);
+            }
+        case POOL_STATE_SIGNING:
+            if (nStatusMessageProgress % 70 <= 40) return _("Found enough users, signing ...");
+            else if (nStatusMessageProgress % 70 <= 50) strSuffix = ".";
+            else if (nStatusMessageProgress % 70 <= 60) strSuffix = "..";
+            else if (nStatusMessageProgress % 70 <= 70) strSuffix = "...";
+            return strprintf(_("Found enough users, signing ( waiting %s )"), strSuffix);
+        case POOL_STATE_ERROR:
+            return _("PrivateSend request incomplete:") + " " + strLastMessage + " " + _("Will retry...");
+        case POOL_STATE_SUCCESS:
+            return _("PrivateSend request complete:") + " " + strLastMessage;
+        default:
+            return strprintf(_("Unknown state: id = %u"), nState);
+    }
+}
+
+//
+// Check the mixing progress and send client updates if a Znode
+//
+void CDarksendPool::CheckPool() {
+    if (fZNode) {
+        LogPrint("privatesend", "CDarksendPool::CheckPool -- entries count %lu\n", GetEntriesCount());
+
+        // If entries are full, create finalized transaction
+        if (nState == POOL_STATE_ACCEPTING_ENTRIES && GetEntriesCount() >= GetMaxPoolTransactions()) {
+            LogPrint("privatesend", "CDarksendPool::CheckPool -- FINALIZE TRANSACTIONS\n");
+            CreateFinalTransaction();
+            return;
+        }
+
+        // If we have all of the signatures, try to compile the transaction
+        if (nState == POOL_STATE_SIGNING && IsSignaturesComplete()) {
+            LogPrint("privatesend", "CDarksendPool::CheckPool -- SIGNING\n");
+            CommitFinalTransaction();
+            return;
+        }
+    }
+
+    // reset if we're here for 10 seconds
+    if ((nState == POOL_STATE_ERROR || nState == POOL_STATE_SUCCESS) && GetTimeMillis() - nTimeLastSuccessfulStep >= 10000) {
+        LogPrint("privatesend", "CDarksendPool::CheckPool -- timeout, RESETTING\n");
+        UnlockCoins();
+        SetNull();
+    }
+}
+
+void CDarksendPool::CreateFinalTransaction() {
+    LogPrint("privatesend", "CDarksendPool::CreateFinalTransaction -- FINALIZE TRANSACTIONS\n");
+
+    CMutableTransaction txNew;
+
+    // make our new transaction
+    for (int i = 0; i < GetEntriesCount(); i++) {
+        BOOST_FOREACH(
+        const CTxDSOut &txdsout, vecEntries[i].vecTxDSOut)
+        txNew.vout.push_back(txdsout);
+
+        BOOST_FOREACH(
+        const CTxDSIn &txdsin, vecEntries[i].vecTxDSIn)
+        txNew.vin.push_back(txdsin);
+    }
+
+    // BIP69 https://github.com/kristovatlas/bips/blob/master/bip-0069.mediawiki
+    sort(txNew.vin.begin(), txNew.vin.end());
+    sort(txNew.vout.begin(), txNew.vout.end());
+
+    finalMutableTransaction = txNew;
+    LogPrint("privatesend", "CDarksendPool::CreateFinalTransaction -- finalMutableTransaction=%s", txNew.ToString());
+
+    // request signatures from clients
+    RelayFinalTransaction(finalMutableTransaction);
+    SetState(POOL_STATE_SIGNING);
+}
+
+void CDarksendPool::CommitFinalTransaction() {
+    if (!fZNode) return; // check and relay final tx only on znode
+
+    CTransaction finalTransaction = CTransaction(finalMutableTransaction);
+    uint256 hashTx = finalTransaction.GetHash();
+
+    LogPrint("privatesend", "CDarksendPool::CommitFinalTransaction -- finalTransaction=%s", finalTransaction.ToString());
+
+    {
+        // See if the transaction is valid
+        TRY_LOCK(cs_main, lockMain);
+        CValidationState validationState;
+        mempool.PrioritiseTransaction(hashTx, hashTx.ToString(), 1000, 0.1 * COIN);
+        if (!lockMain || !AcceptToMemoryPool(mempool, validationState, finalTransaction, true, false, NULL, false, true, true)) {
+            LogPrintf("CDarksendPool::CommitFinalTransaction -- AcceptToMemoryPool() error: Transaction not valid\n");
+            SetNull();
+            // not much we can do in this case, just notify clients
+            RelayCompletedTransaction(ERR_INVALID_TX);
+            return;
+        }
+    }
+
+    LogPrintf("CDarksendPool::CommitFinalTransaction -- CREATING DSTX\n");
+
+    // create and sign znode dstx transaction
+    if (!mapDarksendBroadcastTxes.count(hashTx)) {
+        CDarksendBroadcastTx dstx(finalTransaction, activeZnode.vin, GetAdjustedTime());
+        dstx.Sign();
+        mapDarksendBroadcastTxes.insert(std::make_pair(hashTx, dstx));
+    }
+
+    LogPrintf("CDarksendPool::CommitFinalTransaction -- TRANSMITTING DSTX\n");
+
+    CInv inv(MSG_DSTX, hashTx);
+    RelayInv(inv);
+
+    // Tell the clients it was successful
+    RelayCompletedTransaction(MSG_SUCCESS);
+
+    // Randomly charge clients
+    ChargeRandomFees();
+
+    // Reset
+    LogPrint("privatesend", "CDarksendPool::CommitFinalTransaction -- COMPLETED -- RESETTING\n");
+    SetNull();
+}
+
+//
+// Charge clients a fee if they're abusive
+//
+// Why bother? PrivateSend uses collateral to ensure abuse to the process is kept to a minimum.
+// The submission and signing stages are completely separate. In the cases where
+// a client submits a transaction then refused to sign, there must be a cost. Otherwise they
+// would be able to do this over and over again and bring the mixing to a hault.
+//
+// How does this work? Messages to Znodes come in via NetMsgType::DSVIN, these require a valid collateral
+// transaction for the client to be able to enter the pool. This transaction is kept by the Znode
+// until the transaction is either complete or fails.
+//
+void CDarksendPool::ChargeFees() {
+    if (!fZNode) return;
+
+    //we don't need to charge collateral for every offence.
+    if (GetRandInt(100) > 33) return;
+
+    std::vector <CTransaction> vecOffendersCollaterals;
+
+    if (nState == POOL_STATE_ACCEPTING_ENTRIES) {
+        BOOST_FOREACH(
+        const CTransaction &txCollateral, vecSessionCollaterals) {
+            bool fFound = false;
+            BOOST_FOREACH(
+            const CDarkSendEntry &entry, vecEntries)
+            if (entry.txCollateral == txCollateral)
+                fFound = true;
+
+            // This queue entry didn't send us the promised transaction
+            if (!fFound) {
+                LogPrintf("CDarksendPool::ChargeFees -- found uncooperative node (didn't send transaction), found offence\n");
+                vecOffendersCollaterals.push_back(txCollateral);
+            }
+        }
+    }
+
+    if (nState == POOL_STATE_SIGNING) {
+        // who didn't sign?
+        BOOST_FOREACH(
+        const CDarkSendEntry entry, vecEntries) {
+            BOOST_FOREACH(
+            const CTxDSIn txdsin, entry.vecTxDSIn) {
+                if (!txdsin.fHasSig) {
+                    LogPrintf("CDarksendPool::ChargeFees -- found uncooperative node (didn't sign), found offence\n");
+                    vecOffendersCollaterals.push_back(entry.txCollateral);
+                }
+            }
+        }
+    }
+
+    // no offences found
+    if (vecOffendersCollaterals.empty()) return;
+
+    //mostly offending? Charge sometimes
+    if ((int) vecOffendersCollaterals.size() >= Params().PoolMaxTransactions() - 1 && GetRandInt(100) > 33) return;
+
+    //everyone is an offender? That's not right
+    if ((int) vecOffendersCollaterals.size() >= Params().PoolMaxTransactions()) return;
+
+    //charge one of the offenders randomly
+    std::random_shuffle(vecOffendersCollaterals.begin(), vecOffendersCollaterals.end());
+
+    if (nState == POOL_STATE_ACCEPTING_ENTRIES || nState == POOL_STATE_SIGNING) {
+        LogPrintf("CDarksendPool::ChargeFees -- found uncooperative node (didn't %s transaction), charging fees: %s\n",
+                  (nState == POOL_STATE_SIGNING) ? "sign" : "send", vecOffendersCollaterals[0].ToString());
+
+        LOCK(cs_main);
+
+        CValidationState state;
+        bool fMissingInputs;
+        if (!AcceptToMemoryPool(mempool, state, vecOffendersCollaterals[0], true, false, &fMissingInputs, false, true)) {
+            // should never really happen
+            LogPrintf("CDarksendPool::ChargeFees -- ERROR: AcceptToMemoryPool failed!\n");
+        } else {
+            RelayTransaction(vecOffendersCollaterals[0]);
+        }
+    }
+}
+
+/*
+    Charge the collateral randomly.
+    Mixing is completely free, to pay miners we randomly pay the collateral of users.
+
+    Collateral Fee Charges:
+
+    Being that mixing has "no fees" we need to have some kind of cost associated
+    with using it to stop abuse. Otherwise it could serve as an attack vector and
+    allow endless transaction that would bloat Dash and make it unusable. To
+    stop these kinds of attacks 1 in 10 successful transactions are charged. This
+    adds up to a cost of 0.001DRK per transaction on average.
+*/
+void CDarksendPool::ChargeRandomFees() {
+    if (!fZNode) return;
+
+    LOCK(cs_main);
+
+    BOOST_FOREACH(
+    const CTransaction &txCollateral, vecSessionCollaterals) {
+
+        if (GetRandInt(100) > 10) return;
+
+        LogPrintf("CDarksendPool::ChargeRandomFees -- charging random fees, txCollateral=%s", txCollateral.ToString());
+
+        CValidationState state;
+        bool fMissingInputs;
+        if (!AcceptToMemoryPool(mempool, state, txCollateral, true, false, &fMissingInputs, false, true)) {
+            // should never really happen
+            LogPrintf("CDarksendPool::ChargeRandomFees -- ERROR: AcceptToMemoryPool failed!\n");
+        } else {
+            RelayTransaction(txCollateral);
+        }
+    }
+}
+
+//
+// Check for various timeouts (queue objects, mixing, etc)
+//
+void CDarksendPool::CheckTimeout() {
+    {
+        TRY_LOCK(cs_darksend, lockDS);
+        if (!lockDS) return; // it's ok to fail here, we run this quite frequently
+
+        // check mixing queue objects for timeouts
+        std::vector<CDarksendQueue>::iterator it = vecDarksendQueue.begin();
+        while (it != vecDarksendQueue.end()) {
+            if ((*it).IsExpired()) {
+                LogPrint("privatesend", "CDarksendPool::CheckTimeout -- Removing expired queue (%s)\n", (*it).ToString());
+                it = vecDarksendQueue.erase(it);
+            } else ++it;
+        }
+    }
+
+    if (!fEnablePrivateSend && !fZNode) return;
+
+    // catching hanging sessions
+    if (!fZNode) {
+        switch (nState) {
+            case POOL_STATE_ERROR:
+                LogPrint("privatesend", "CDarksendPool::CheckTimeout -- Pool error -- Running CheckPool\n");
+                CheckPool();
+                break;
+            case POOL_STATE_SUCCESS:
+                LogPrint("privatesend", "CDarksendPool::CheckTimeout -- Pool success -- Running CheckPool\n");
+                CheckPool();
+                break;
+            default:
+                break;
+        }
+    }
+
+    int nLagTime = fZNode ? 0 : 10000; // if we're the client, give the server a few extra seconds before resetting.
+    int nTimeout = (nState == POOL_STATE_SIGNING) ? PRIVATESEND_SIGNING_TIMEOUT : PRIVATESEND_QUEUE_TIMEOUT;
+    bool fTimeout = GetTimeMillis() - nTimeLastSuccessfulStep >= nTimeout * 1000 + nLagTime;
+
+    if (nState != POOL_STATE_IDLE && fTimeout) {
+        LogPrint("privatesend", "CDarksendPool::CheckTimeout -- %s timed out (%ds) -- restting\n",
+                 (nState == POOL_STATE_SIGNING) ? "Signing" : "Session", nTimeout);
+        ChargeFees();
+        UnlockCoins();
+        SetNull();
+        SetState(POOL_STATE_ERROR);
+        strLastMessage = _("Session timed out.");
+    }
+}
+
+/*
+    Check to see if we're ready for submissions from clients
+    After receiving multiple dsa messages, the queue will switch to "accepting entries"
+    which is the active state right before merging the transaction
+*/
+void CDarksendPool::CheckForCompleteQueue() {
+    if (!fEnablePrivateSend && !fZNode) return;
+
+    if (nState == POOL_STATE_QUEUE && IsSessionReady()) {
+        SetState(POOL_STATE_ACCEPTING_ENTRIES);
+
+        CDarksendQueue dsq(nSessionDenom, activeZnode.vin, GetTime(), true);
+        LogPrint("privatesend", "CDarksendPool::CheckForCompleteQueue -- queue is ready, signing and relaying (%s)\n", dsq.ToString());
+        dsq.Sign();
+        dsq.Relay();
+    }
+}
+
+// Check to make sure a given input matches an input in the pool and its scriptSig is valid
+bool CDarksendPool::IsInputScriptSigValid(const CTxIn &txin) {
+    CMutableTransaction txNew;
+    txNew.vin.clear();
+    txNew.vout.clear();
+
+    int i = 0;
+    int nTxInIndex = -1;
+    CScript sigPubKey = CScript();
+
+    BOOST_FOREACH(CDarkSendEntry & entry, vecEntries)
+    {
+
+        BOOST_FOREACH(
+        const CTxDSOut &txdsout, entry.vecTxDSOut)
+        txNew.vout.push_back(txdsout);
+
+        BOOST_FOREACH(
+        const CTxDSIn &txdsin, entry.vecTxDSIn) {
+            txNew.vin.push_back(txdsin);
+
+            if (txdsin.prevout == txin.prevout) {
+                nTxInIndex = i;
+                sigPubKey = txdsin.prevPubKey;
+            }
+            i++;
+        }
+    }
+
+    if (nTxInIndex >= 0) { //might have to do this one input at a time?
+        txNew.vin[nTxInIndex].scriptSig = txin.scriptSig;
+        const CAmount &amount = txNew.vout[nTxInIndex].nValue;
+        LogPrint("privatesend", "CDarksendPool::IsInputScriptSigValid -- verifying scriptSig %s\n", ScriptToAsmStr(txin.scriptSig).substr(0, 24));
+//        if(!VerifyScript(txNew.vin[nTxInIndex].scriptSig, sigPubKey, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, MutableTransactionSignatureChecker(&txNew, nTxInIndex, amount))) {
+//            LogPrint("privatesend", "CDarksendPool::IsInputScriptSigValid -- VerifyScript() failed on input %d\n", nTxInIndex);
+//            return false;
+//        }
+    } else {
+        LogPrint("privatesend", "CDarksendPool::IsInputScriptSigValid -- Failed to find matching input in pool, %s\n", txin.ToString());
+        return false;
+    }
+
+    LogPrint("privatesend", "CDarksendPool::IsInputScriptSigValid -- Successfully validated input and scriptSig\n");
+    return true;
+}
+
+// check to make sure the collateral provided by the client is valid
+bool CDarksendPool::IsCollateralValid(const CTransaction &txCollateral) {
+    if (txCollateral.vout.empty()) return false;
+    if (txCollateral.nLockTime != 0) return false;
+
+    CAmount nValueIn = 0;
+    CAmount nValueOut = 0;
+    bool fMissingTx = false;
+
+    BOOST_FOREACH(
+    const CTxOut txout, txCollateral.vout) {
+        nValueOut += txout.nValue;
+
+        if (!txout.scriptPubKey.IsNormalPaymentScript()) {
+            LogPrintf ("CDarksendPool::IsCollateralValid -- Invalid Script, txCollateral=%s", txCollateral.ToString());
+            return false;
+        }
+    }
+
+    BOOST_FOREACH(
+    const CTxIn txin, txCollateral.vin) {
+        CTransaction txPrev;
+        uint256 hash;
+        if (GetTransaction(txin.prevout.hash, txPrev, Params().GetConsensus(), hash, true)) {
+            if (txPrev.vout.size() > txin.prevout.n)
+                nValueIn += txPrev.vout[txin.prevout.n].nValue;
+        } else {
+            fMissingTx = true;
+        }
+    }
+
+    if (fMissingTx) {
+        LogPrint("privatesend", "CDarksendPool::IsCollateralValid -- Unknown inputs in collateral transaction, txCollateral=%s", txCollateral.ToString());
+        return false;
+    }
+
+    //collateral transactions are required to pay out PRIVATESEND_COLLATERAL as a fee to the miners
+    if (nValueIn - nValueOut < PRIVATESEND_COLLATERAL) {
+        LogPrint("privatesend", "CDarksendPool::IsCollateralValid -- did not include enough fees in transaction: fees: %d, txCollateral=%s", nValueOut - nValueIn, txCollateral.ToString());
+        return false;
+    }
+
+    LogPrint("privatesend", "CDarksendPool::IsCollateralValid -- %s", txCollateral.ToString());
+
+    {
+        LOCK(cs_main);
+        CValidationState validationState;
+        if (!AcceptToMemoryPool(mempool, validationState, txCollateral, true, false, NULL, false, true, true)) {
+            LogPrint("privatesend", "CDarksendPool::IsCollateralValid -- didn't pass AcceptToMemoryPool()\n");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+//
+// Add a clients transaction to the pool
+//
+bool CDarksendPool::AddEntry(const CDarkSendEntry &entryNew, PoolMessage &nMessageIDRet) {
+    if (!fZNode) return false;
+
+    BOOST_FOREACH(CTxIn
+    txin, entryNew.vecTxDSIn) {
+        if (txin.prevout.IsNull()) {
+            LogPrint("privatesend", "CDarksendPool::AddEntry -- input not valid!\n");
+            nMessageIDRet = ERR_INVALID_INPUT;
+            return false;
+        }
+    }
+
+    if (!IsCollateralValid(entryNew.txCollateral)) {
+        LogPrint("privatesend", "CDarksendPool::AddEntry -- collateral not valid!\n");
+        nMessageIDRet = ERR_INVALID_COLLATERAL;
+        return false;
+    }
+
+    if (GetEntriesCount() >= GetMaxPoolTransactions()) {
+        LogPrint("privatesend", "CDarksendPool::AddEntry -- entries is full!\n");
+        nMessageIDRet = ERR_ENTRIES_FULL;
+        return false;
+    }
+
+    BOOST_FOREACH(CTxIn
+    txin, entryNew.vecTxDSIn) {
+        LogPrint("privatesend", "looking for txin -- %s\n", txin.ToString());
+        BOOST_FOREACH(
+        const CDarkSendEntry &entry, vecEntries) {
+            BOOST_FOREACH(
+            const CTxDSIn &txdsin, entry.vecTxDSIn) {
+                if (txdsin.prevout == txin.prevout) {
+                    LogPrint("privatesend", "CDarksendPool::AddEntry -- found in txin\n");
+                    nMessageIDRet = ERR_ALREADY_HAVE;
+                    return false;
+                }
+            }
+        }
+    }
+
+    vecEntries.push_back(entryNew);
+
+    LogPrint("privatesend", "CDarksendPool::AddEntry -- adding entry\n");
+    nMessageIDRet = MSG_ENTRIES_ADDED;
+    nTimeLastSuccessfulStep = GetTimeMillis();
+
+    return true;
+}
+
+bool CDarksendPool::AddScriptSig(const CTxIn &txinNew) {
+    LogPrint("privatesend", "CDarksendPool::AddScriptSig -- scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
+
+    BOOST_FOREACH(
+    const CDarkSendEntry &entry, vecEntries) {
+        BOOST_FOREACH(
+        const CTxDSIn &txdsin, entry.vecTxDSIn) {
+            if (txdsin.scriptSig == txinNew.scriptSig) {
+                LogPrint("privatesend", "CDarksendPool::AddScriptSig -- already exists\n");
+                return false;
+            }
+        }
+    }
+
+    if (!IsInputScriptSigValid(txinNew)) {
+        LogPrint("privatesend", "CDarksendPool::AddScriptSig -- Invalid scriptSig\n");
+        return false;
+    }
+
+    LogPrint("privatesend", "CDarksendPool::AddScriptSig -- scriptSig=%s new\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
+
+    BOOST_FOREACH(CTxIn & txin, finalMutableTransaction.vin)
+    {
+        if (txinNew.prevout == txin.prevout && txin.nSequence == txinNew.nSequence) {
+            txin.scriptSig = txinNew.scriptSig;
+            txin.prevPubKey = txinNew.prevPubKey;
+            LogPrint("privatesend", "CDarksendPool::AddScriptSig -- adding to finalMutableTransaction, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
+        }
+    }
+    for (int i = 0; i < GetEntriesCount(); i++) {
+        if (vecEntries[i].AddScriptSig(txinNew)) {
+            LogPrint("privatesend", "CDarksendPool::AddScriptSig -- adding to entries, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
+            return true;
+        }
+    }
+
+    LogPrintf("CDarksendPool::AddScriptSig -- Couldn't set sig!\n");
+    return false;
+}
+
+// Check to make sure everything is signed
+bool CDarksendPool::IsSignaturesComplete() {
+    BOOST_FOREACH(
+    const CDarkSendEntry &entry, vecEntries)
+    BOOST_FOREACH(
+    const CTxDSIn &txdsin, entry.vecTxDSIn)
+    if (!txdsin.fHasSig) return false;
+
+    return true;
+}
+
+//
+// Execute a mixing denomination via a Znode.
+// This is only ran from clients
+//
+bool CDarksendPool::SendDenominate(const std::vector <CTxIn> &vecTxIn, const std::vector <CTxOut> &vecTxOut) {
+    if (fZNode) {
+        LogPrintf("CDarksendPool::SendDenominate -- PrivateSend from a Znode is not supported currently.\n");
+        return false;
+    }
+
+    if (txMyCollateral == CMutableTransaction()) {
+        LogPrintf("CDarksendPool:SendDenominate -- PrivateSend collateral not set\n");
+        return false;
+    }
+
+    // lock the funds we're going to use
+    BOOST_FOREACH(CTxIn
+    txin, txMyCollateral.vin)
+    vecOutPointLocked.push_back(txin.prevout);
+
+    BOOST_FOREACH(CTxIn
+    txin, vecTxIn)
+    vecOutPointLocked.push_back(txin.prevout);
+
+    // we should already be connected to a Znode
+    if (!nSessionID) {
+        LogPrintf("CDarksendPool::SendDenominate -- No Znode has been selected yet.\n");
+        UnlockCoins();
+        SetNull();
+        return false;
+    }
+
+    if (!CheckDiskSpace()) {
+        UnlockCoins();
+        SetNull();
+        fEnablePrivateSend = false;
+        LogPrintf("CDarksendPool::SendDenominate -- Not enough disk space, disabling PrivateSend.\n");
+        return false;
+    }
+
+    SetState(POOL_STATE_ACCEPTING_ENTRIES);
+    strLastMessage = "";
+
+    LogPrintf("CDarksendPool::SendDenominate -- Added transaction to pool.\n");
+
+    //check it against the memory pool to make sure it's valid
+    {
+        CValidationState validationState;
+        CMutableTransaction tx;
+
+        BOOST_FOREACH(
+        const CTxIn &txin, vecTxIn) {
+            LogPrint("privatesend", "CDarksendPool::SendDenominate -- txin=%s\n", txin.ToString());
+            tx.vin.push_back(txin);
+        }
+
+        BOOST_FOREACH(
+        const CTxOut &txout, vecTxOut) {
+            LogPrint("privatesend", "CDarksendPool::SendDenominate -- txout=%s\n", txout.ToString());
+            tx.vout.push_back(txout);
+        }
+
+        LogPrintf("CDarksendPool::SendDenominate -- Submitting partial tx %s", tx.ToString());
+
+        mempool.PrioritiseTransaction(tx.GetHash(), tx.GetHash().ToString(), 1000, 0.1 * COIN);
+        TRY_LOCK(cs_main, lockMain);
+        if (!lockMain || !AcceptToMemoryPool(mempool, validationState, CTransaction(tx), true, false, NULL, false, true, true)) {
+            LogPrintf("CDarksendPool::SendDenominate -- AcceptToMemoryPool() failed! tx=%s", tx.ToString());
+            UnlockCoins();
+            SetNull();
+            return false;
+        }
+    }
+
+    // store our entry for later use
+    CDarkSendEntry entry(vecTxIn, vecTxOut, txMyCollateral);
+    vecEntries.push_back(entry);
+    RelayIn(entry);
+    nTimeLastSuccessfulStep = GetTimeMillis();
+
+    return true;
+}
+
+// Incoming message from Znode updating the progress of mixing
+bool CDarksendPool::CheckPoolStateUpdate(PoolState nStateNew, int nEntriesCountNew, PoolStatusUpdate nStatusUpdate, PoolMessage nMessageID, int nSessionIDNew) {
+    if (fZNode) return false;
+
+    // do not update state when mixing client state is one of these
+    if (nState == POOL_STATE_IDLE || nState == POOL_STATE_ERROR || nState == POOL_STATE_SUCCESS) return false;
+
+    strAutoDenomResult = _("Znode:") + " " + GetMessageByID(nMessageID);
+
+    // if rejected at any state
+    if (nStatusUpdate == STATUS_REJECTED) {
+        LogPrintf("CDarksendPool::CheckPoolStateUpdate -- entry is rejected by Znode\n");
+        UnlockCoins();
+        SetNull();
+        SetState(POOL_STATE_ERROR);
+        strLastMessage = GetMessageByID(nMessageID);
+        return true;
+    }
+
+    if (nStatusUpdate == STATUS_ACCEPTED && nState == nStateNew) {
+        if (nStateNew == POOL_STATE_QUEUE && nSessionID == 0 && nSessionIDNew != 0) {
+            // new session id should be set only in POOL_STATE_QUEUE state
+            nSessionID = nSessionIDNew;
+            nTimeLastSuccessfulStep = GetTimeMillis();
+            LogPrintf("CDarksendPool::CheckPoolStateUpdate -- set nSessionID to %d\n", nSessionID);
+            return true;
+        } else if (nStateNew == POOL_STATE_ACCEPTING_ENTRIES && nEntriesCount != nEntriesCountNew) {
+            nEntriesCount = nEntriesCountNew;
+            nTimeLastSuccessfulStep = GetTimeMillis();
+            fLastEntryAccepted = true;
+            LogPrintf("CDarksendPool::CheckPoolStateUpdate -- new entry accepted!\n");
+            return true;
+        }
+    }
+
+    // only situations above are allowed, fail in any other case
+    return false;
+}
+
+//
+// After we receive the finalized transaction from the Znode, we must
+// check it to make sure it's what we want, then sign it if we agree.
+// If we refuse to sign, it's possible we'll be charged collateral
+//
+bool CDarksendPool::SignFinalTransaction(const CTransaction &finalTransactionNew, CNode *pnode) {
+    if (fZNode || pnode == NULL) return false;
+
+    finalMutableTransaction = finalTransactionNew;
+    LogPrintf("CDarksendPool::SignFinalTransaction -- finalMutableTransaction=%s", finalMutableTransaction.ToString());
+
+    std::vector <CTxIn> sigs;
+
+    //make sure my inputs/outputs are present, otherwise refuse to sign
+    BOOST_FOREACH(
+    const CDarkSendEntry entry, vecEntries) {
+        BOOST_FOREACH(
+        const CTxDSIn txdsin, entry.vecTxDSIn) {
+            /* Sign my transaction and all outputs */
+            int nMyInputIndex = -1;
+            CScript prevPubKey = CScript();
+            CTxIn txin = CTxIn();
+
+            for (unsigned int i = 0; i < finalMutableTransaction.vin.size(); i++) {
+                if (finalMutableTransaction.vin[i] == txdsin) {
+                    nMyInputIndex = i;
+                    prevPubKey = txdsin.prevPubKey;
+                    txin = txdsin;
+                }
+            }
+
+            if (nMyInputIndex >= 0) { //might have to do this one input at a time?
+                int nFoundOutputsCount = 0;
+                CAmount nValue1 = 0;
+                CAmount nValue2 = 0;
+
+                for (unsigned int i = 0; i < finalMutableTransaction.vout.size(); i++) {
+                    BOOST_FOREACH(
+                    const CTxOut &txout, entry.vecTxDSOut) {
+                        if (finalMutableTransaction.vout[i] == txout) {
+                            nFoundOutputsCount++;
+                            nValue1 += finalMutableTransaction.vout[i].nValue;
+                        }
+                    }
+                }
+
+                BOOST_FOREACH(
+                const CTxOut txout, entry.vecTxDSOut)
+                nValue2 += txout.nValue;
+
+                int nTargetOuputsCount = entry.vecTxDSOut.size();
+                if (nFoundOutputsCount < nTargetOuputsCount || nValue1 != nValue2) {
+                    // in this case, something went wrong and we'll refuse to sign. It's possible we'll be charged collateral. But that's
+                    // better then signing if the transaction doesn't look like what we wanted.
+                    LogPrintf("CDarksendPool::SignFinalTransaction -- My entries are not correct! Refusing to sign: nFoundOutputsCount: %d, nTargetOuputsCount: %d\n", nFoundOutputsCount, nTargetOuputsCount);
+                    UnlockCoins();
+                    SetNull();
+
+                    return false;
+                }
+
+                const CKeyStore &keystore = *pwalletMain;
+
+                LogPrint("privatesend", "CDarksendPool::SignFinalTransaction -- Signing my input %i\n", nMyInputIndex);
+                CAmount amount;
+                if (!SignSignature(keystore, prevPubKey, finalMutableTransaction, nMyInputIndex, amount, int(SIGHASH_ALL | SIGHASH_ANYONECANPAY))) { // changes scriptSig
+                    LogPrint("privatesend", "CDarksendPool::SignFinalTransaction -- Unable to sign my own transaction!\n");
+                    // not sure what to do here, it will timeout...?
+                }
+
+                sigs.push_back(finalMutableTransaction.vin[nMyInputIndex]);
+                LogPrint("privatesend", "CDarksendPool::SignFinalTransaction -- nMyInputIndex: %d, sigs.size(): %d, scriptSig=%s\n", nMyInputIndex, (int) sigs.size(), ScriptToAsmStr(finalMutableTransaction.vin[nMyInputIndex].scriptSig));
+            }
+        }
+    }
+
+    if (sigs.empty()) {
+        LogPrintf("CDarksendPool::SignFinalTransaction -- can't sign anything!\n");
+        UnlockCoins();
+        SetNull();
+
+        return false;
+    }
+
+    // push all of our signatures to the Znode
+    LogPrintf("CDarksendPool::SignFinalTransaction -- pushing sigs to the znode, finalMutableTransaction=%s", finalMutableTransaction.ToString());
+    pnode->PushMessage(NetMsgType::DSSIGNFINALTX, sigs);
+    SetState(POOL_STATE_SIGNING);
+    nTimeLastSuccessfulStep = GetTimeMillis();
+
+    return true;
+}
+
+void CDarksendPool::NewBlock() {
+    static int64_t nTimeNewBlockReceived = 0;
+
+    //we we're processing lots of blocks, we'll just leave
+    if (GetTime() - nTimeNewBlockReceived < 10) return;
+    nTimeNewBlockReceived = GetTime();
+    LogPrint("privatesend", "CDarksendPool::NewBlock\n");
+
+    CheckTimeout();
+}
+
+// mixing transaction was completed (failed or successful)
+void CDarksendPool::CompletedTransaction(PoolMessage nMessageID) {
+    if (fZNode) return;
+
+    if (nMessageID == MSG_SUCCESS) {
+        LogPrintf("CompletedTransaction -- success\n");
+        nCachedLastSuccessBlock = pCurrentBlockIndex->nHeight;
+    } else {
+        LogPrintf("CompletedTransaction -- error\n");
+    }
+    UnlockCoins();
+    SetNull();
+    strLastMessage = GetMessageByID(nMessageID);
+}
+
+//
+// Passively run mixing in the background to anonymize funds based on the given configuration.
+//
+bool CDarksendPool::DoAutomaticDenominating(bool fDryRun) {
+    if (!fEnablePrivateSend || fZNode || !pCurrentBlockIndex) return false;
+    if (!pwalletMain || pwalletMain->IsLocked(true)) return false;
+    if (nState != POOL_STATE_IDLE) return false;
+
+    if (!znodeSync.IsZnodeListSynced()) {
+        strAutoDenomResult = _("Can't mix while sync in progress.");
+        return false;
+    }
+
+    switch (nWalletBackups) {
+        case 0:
+            LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- Automatic backups disabled, no mixing available.\n");
+            strAutoDenomResult = _("Automatic backups disabled") + ", " + _("no mixing available.");
+            fEnablePrivateSend = false; // stop mixing
+            pwalletMain->nKeysLeftSinceAutoBackup = 0; // no backup, no "keys since last backup"
+            return false;
+        case -1:
+            // Automatic backup failed, nothing else we can do until user fixes the issue manually.
+            // There is no way to bring user attention in daemon mode so we just update status and
+            // keep spaming if debug is on.
+            LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- ERROR! Failed to create automatic backup.\n");
+            strAutoDenomResult = _("ERROR! Failed to create automatic backup") + ", " + _("see debug.log for details.");
+            return false;
+        case -2:
+            // We were able to create automatic backup but keypool was not replenished because wallet is locked.
+            // There is no way to bring user attention in daemon mode so we just update status and
+            // keep spaming if debug is on.
+            LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- WARNING! Failed to create replenish keypool, please unlock your wallet to do so.\n");
+            strAutoDenomResult = _("WARNING! Failed to replenish keypool, please unlock your wallet to do so.") + ", " + _("see debug.log for details.");
+            return false;
+    }
+
+    if (pwalletMain->nKeysLeftSinceAutoBackup < PRIVATESEND_KEYS_THRESHOLD_STOP) {
+        // We should never get here via mixing itself but probably smth else is still actively using keypool
+        LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- Very low number of keys left: %d, no mixing available.\n", pwalletMain->nKeysLeftSinceAutoBackup);
+        strAutoDenomResult = strprintf(_("Very low number of keys left: %d") + ", " + _("no mixing available."), pwalletMain->nKeysLeftSinceAutoBackup);
+        // It's getting really dangerous, stop mixing
+        fEnablePrivateSend = false;
+        return false;
+    } else if (pwalletMain->nKeysLeftSinceAutoBackup < PRIVATESEND_KEYS_THRESHOLD_WARNING) {
+        // Low number of keys left but it's still more or less safe to continue
+        LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- Very low number of keys left: %d\n", pwalletMain->nKeysLeftSinceAutoBackup);
+        strAutoDenomResult = strprintf(_("Very low number of keys left: %d"), pwalletMain->nKeysLeftSinceAutoBackup);
+
+        if (fCreateAutoBackups) {
+            LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- Trying to create new backup.\n");
+            std::string warningString;
+            std::string errorString;
+
+            if (!AutoBackupWallet(pwalletMain, "", warningString, errorString)) {
+                if (!warningString.empty()) {
+                    // There were some issues saving backup but yet more or less safe to continue
+                    LogPrintf("CDarksendPool::DoAutomaticDenominating -- WARNING! Something went wrong on automatic backup: %s\n", warningString);
+                }
+                if (!errorString.empty()) {
+                    // Things are really broken
+                    LogPrintf("CDarksendPool::DoAutomaticDenominating -- ERROR! Failed to create automatic backup: %s\n", errorString);
+                    strAutoDenomResult = strprintf(_("ERROR! Failed to create automatic backup") + ": %s", errorString);
+                    return false;
+                }
+            }
+        } else {
+            // Wait for someone else (e.g. GUI action) to create automatic backup for us
+            return false;
+        }
+    }
+
+    LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- Keys left since latest backup: %d\n", pwalletMain->nKeysLeftSinceAutoBackup);
+
+    if (GetEntriesCount() > 0) {
+        strAutoDenomResult = _("Mixing in progress...");
+        return false;
+    }
+
+    TRY_LOCK(cs_darksend, lockDS);
+    if (!lockDS) {
+        strAutoDenomResult = _("Lock is already in place.");
+        return false;
+    }
+
+    if (!fDryRun && pwalletMain->IsLocked(true)) {
+        strAutoDenomResult = _("Wallet is locked.");
+        return false;
+    }
+
+    if (!fPrivateSendMultiSession && pCurrentBlockIndex->nHeight - nCachedLastSuccessBlock < nMinBlockSpacing) {
+        LogPrintf("CDarksendPool::DoAutomaticDenominating -- Last successful PrivateSend action was too recent\n");
+        strAutoDenomResult = _("Last successful PrivateSend action was too recent.");
+        return false;
+    }
+
+    if (mnodeman.size() == 0) {
+        LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- No Znodes detected\n");
+        strAutoDenomResult = _("No Znodes detected.");
+        return false;
+    }
+
+    CAmount nValueMin = vecPrivateSendDenominations.back();
+
+    // if there are no confirmed DS collateral inputs yet
+    if (!pwalletMain->HasCollateralInputs()) {
+        // should have some additional amount for them
+        nValueMin += PRIVATESEND_COLLATERAL * 4;
+    }
+
+    // including denoms but applying some restrictions
+    CAmount nBalanceNeedsAnonymized = pwalletMain->GetNeedsToBeAnonymizedBalance(nValueMin);
+
+    // anonymizable balance is way too small
+    if (nBalanceNeedsAnonymized < nValueMin) {
+        LogPrintf("CDarksendPool::DoAutomaticDenominating -- Not enough funds to anonymize\n");
+        strAutoDenomResult = _("Not enough funds to anonymize.");
+        return false;
+    }
+
+    // excluding denoms
+    CAmount nBalanceAnonimizableNonDenom = pwalletMain->GetAnonymizableBalance(true);
+    // denoms
+    CAmount nBalanceDenominatedConf = pwalletMain->GetDenominatedBalance();
+    CAmount nBalanceDenominatedUnconf = pwalletMain->GetDenominatedBalance(true);
+    CAmount nBalanceDenominated = nBalanceDenominatedConf + nBalanceDenominatedUnconf;
+
+    LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- nValueMin: %f, nBalanceNeedsAnonymized: %f, nBalanceAnonimizableNonDenom: %f, nBalanceDenominatedConf: %f, nBalanceDenominatedUnconf: %f, nBalanceDenominated: %f\n",
+             (float) nValueMin / COIN,
+             (float) nBalanceNeedsAnonymized / COIN,
+             (float) nBalanceAnonimizableNonDenom / COIN,
+             (float) nBalanceDenominatedConf / COIN,
+             (float) nBalanceDenominatedUnconf / COIN,
+             (float) nBalanceDenominated / COIN);
+
+    if (fDryRun) return true;
+
+    // Check if we have should create more denominated inputs i.e.
+    // there are funds to denominate and denominated balance does not exceed
+    // max amount to mix yet.
+    if (nBalanceAnonimizableNonDenom >= nValueMin + PRIVATESEND_COLLATERAL && nBalanceDenominated < nPrivateSendAmount * COIN)
+        return CreateDenominated();
+
+    //check if we have the collateral sized inputs
+    if (!pwalletMain->HasCollateralInputs())
+        return !pwalletMain->HasCollateralInputs(false) && MakeCollateralAmounts();
+
+    if (nSessionID) {
+        strAutoDenomResult = _("Mixing in progress...");
+        return false;
+    }
+
+    // Initial phase, find a Znode
+    // Clean if there is anything left from previous session
+    UnlockCoins();
+    SetNull();
+
+    // should be no unconfirmed denoms in non-multi-session mode
+    if (!fPrivateSendMultiSession && nBalanceDenominatedUnconf > 0) {
+        LogPrintf("CDarksendPool::DoAutomaticDenominating -- Found unconfirmed denominated outputs, will wait till they confirm to continue.\n");
+        strAutoDenomResult = _("Found unconfirmed denominated outputs, will wait till they confirm to continue.");
+        return false;
+    }
+
+    //check our collateral and create new if needed
+    std::string strReason;
+    if (txMyCollateral == CMutableTransaction()) {
+        if (!pwalletMain->CreateCollateralTransaction(txMyCollateral, strReason)) {
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- create collateral error:%s\n", strReason);
+            return false;
+        }
+    } else {
+        if (!IsCollateralValid(txMyCollateral)) {
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- invalid collateral, recreating...\n");
+            if (!pwalletMain->CreateCollateralTransaction(txMyCollateral, strReason)) {
+                LogPrintf("CDarksendPool::DoAutomaticDenominating -- create collateral error: %s\n", strReason);
+                return false;
+            }
+        }
+    }
+
+    int nMnCountEnabled = mnodeman.CountEnabled(MIN_PRIVATESEND_PEER_PROTO_VERSION);
+
+    // If we've used 90% of the Znode list then drop the oldest first ~30%
+    int nThreshold_high = nMnCountEnabled * 0.9;
+    int nThreshold_low = nThreshold_high * 0.7;
+    LogPrint("privatesend", "Checking vecZnodesUsed: size: %d, threshold: %d\n", (int) vecZnodesUsed.size(), nThreshold_high);
+
+    if ((int) vecZnodesUsed.size() > nThreshold_high) {
+        vecZnodesUsed.erase(vecZnodesUsed.begin(), vecZnodesUsed.begin() + vecZnodesUsed.size() - nThreshold_low);
+        LogPrint("privatesend", "  vecZnodesUsed: new size: %d, threshold: %d\n", (int) vecZnodesUsed.size(), nThreshold_high);
+    }
+
+    bool fUseQueue = GetRandInt(100) > 33;
+    // don't use the queues all of the time for mixing unless we are a liquidity provider
+    if (nLiquidityProvider || fUseQueue) {
+
+        // Look through the queues and see if anything matches
+        BOOST_FOREACH(CDarksendQueue & dsq, vecDarksendQueue)
+        {
+            // only try each queue once
+            if (dsq.fTried) continue;
+            dsq.fTried = true;
+
+            if (dsq.IsExpired()) continue;
+
+            CZnode *pmn = mnodeman.Find(dsq.vin);
+            if (pmn == NULL) {
+                LogPrintf("CDarksendPool::DoAutomaticDenominating -- dsq znode is not in znode list, znode=%s\n", dsq.vin.prevout.ToStringShort());
+                continue;
+            }
+
+            if (pmn->nProtocolVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) continue;
+
+            std::vector<int> vecBits;
+            if (!GetDenominationsBits(dsq.nDenom, vecBits)) {
+                // incompatible denom
+                continue;
+            }
+
+            // mixing rate limit i.e. nLastDsq check should already pass in DSQUEUE ProcessMessage
+            // in order for dsq to get into vecDarksendQueue, so we should be safe to mix already,
+            // no need for additional verification here
+
+            LogPrint("privatesend", "CDarksendPool::DoAutomaticDenominating -- found valid queue: %s\n", dsq.ToString());
+
+            CAmount nValueInTmp = 0;
+            std::vector <CTxIn> vecTxInTmp;
+            std::vector <COutput> vCoinsTmp;
+
+            // Try to match their denominations if possible, select at least 1 denominations
+            if (!pwalletMain->SelectCoinsByDenominations(dsq.nDenom, vecPrivateSendDenominations[vecBits.front()], nBalanceNeedsAnonymized, vecTxInTmp, vCoinsTmp, nValueInTmp, 0, nPrivateSendRounds)) {
+                LogPrintf("CDarksendPool::DoAutomaticDenominating -- Couldn't match denominations %d %d (%s)\n", vecBits.front(), dsq.nDenom, GetDenominationsToString(dsq.nDenom));
+                continue;
+            }
+
+            vecZnodesUsed.push_back(dsq.vin);
+
+            CNode *pnodeFound = NULL;
+            {
+                LOCK(cs_vNodes);
+                pnodeFound = FindNode(pmn->addr);
+                if (pnodeFound) {
+                    if (pnodeFound->fDisconnect) {
+                        continue;
+                    } else {
+                        pnodeFound->AddRef();
+                    }
+                }
+            }
+
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- attempt to connect to znode from queue, addr=%s\n", pmn->addr.ToString());
+            // connect to Znode and submit the queue request
+            CNode *pnode = (pnodeFound && pnodeFound->fZnode) ? pnodeFound : ConnectNode(CAddress(pmn->addr, NODE_NETWORK), NULL, false, true);
+            if (pnode) {
+                pSubmittedToZnode = pmn;
+                nSessionDenom = dsq.nDenom;
+
+                pnode->PushMessage(NetMsgType::DSACCEPT, nSessionDenom, txMyCollateral);
+                LogPrintf("CDarksendPool::DoAutomaticDenominating -- connected (from queue), sending DSACCEPT: nSessionDenom: %d (%s), addr=%s\n",
+                          nSessionDenom, GetDenominationsToString(nSessionDenom), pnode->addr.ToString());
+                strAutoDenomResult = _("Mixing in progress...");
+                SetState(POOL_STATE_QUEUE);
+                nTimeLastSuccessfulStep = GetTimeMillis();
+                if (pnodeFound) {
+                    pnodeFound->Release();
+                }
+                return true;
+            } else {
+                LogPrintf("CDarksendPool::DoAutomaticDenominating -- can't connect, addr=%s\n", pmn->addr.ToString());
+                strAutoDenomResult = _("Error connecting to Znode.");
+                continue;
+            }
+        }
+    }
+
+    // do not initiate queue if we are a liquidity provider to avoid useless inter-mixing
+    if (nLiquidityProvider) return false;
+
+    int nTries = 0;
+
+    // ** find the coins we'll use
+    std::vector <CTxIn> vecTxIn;
+    CAmount nValueInTmp = 0;
+    if (!pwalletMain->SelectCoinsDark(nValueMin, nBalanceNeedsAnonymized, vecTxIn, nValueInTmp, 0, nPrivateSendRounds)) {
+        // this should never happen
+        LogPrintf("CDarksendPool::DoAutomaticDenominating -- Can't mix: no compatible inputs found!\n");
+        strAutoDenomResult = _("Can't mix: no compatible inputs found!");
+        return false;
+    }
+
+    // otherwise, try one randomly
+    while (nTries < 10) {
+        CZnode *pmn = mnodeman.FindRandomNotInVec(vecZnodesUsed, MIN_PRIVATESEND_PEER_PROTO_VERSION);
+        if (pmn == NULL) {
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- Can't find random znode!\n");
+            strAutoDenomResult = _("Can't find random Znode.");
+            return false;
+        }
+        vecZnodesUsed.push_back(pmn->vin);
+
+        if (pmn->nLastDsq != 0 && pmn->nLastDsq + nMnCountEnabled / 5 > mnodeman.nDsqCount) {
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- Too early to mix on this znode!"
+                              " znode=%s  addr=%s  nLastDsq=%d  CountEnabled/5=%d  nDsqCount=%d\n",
+                      pmn->vin.prevout.ToStringShort(), pmn->addr.ToString(), pmn->nLastDsq,
+                      nMnCountEnabled / 5, mnodeman.nDsqCount);
+            nTries++;
+            continue;
+        }
+
+        CNode *pnodeFound = NULL;
+        {
+            LOCK(cs_vNodes);
+            pnodeFound = FindNode(pmn->addr);
+            if (pnodeFound) {
+                if (pnodeFound->fDisconnect) {
+                    nTries++;
+                    continue;
+                } else {
+                    pnodeFound->AddRef();
+                }
+            }
+        }
+
+        LogPrintf("CDarksendPool::DoAutomaticDenominating -- attempt %d connection to Znode %s\n", nTries, pmn->addr.ToString());
+        CNode *pnode = (pnodeFound && pnodeFound->fZnode) ? pnodeFound : ConnectNode(CAddress(pmn->addr, NODE_NETWORK), NULL, false, true);
+        if (pnode) {
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- connected, addr=%s\n", pmn->addr.ToString());
+            pSubmittedToZnode = pmn;
+
+            std::vector <CAmount> vecAmounts;
+            pwalletMain->ConvertList(vecTxIn, vecAmounts);
+            // try to get a single random denom out of vecAmounts
+            while (nSessionDenom == 0) {
+                nSessionDenom = GetDenominationsByAmounts(vecAmounts);
+            }
+
+            pnode->PushMessage(NetMsgType::DSACCEPT, nSessionDenom, txMyCollateral);
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- connected, sending DSACCEPT, nSessionDenom: %d (%s)\n",
+                      nSessionDenom, GetDenominationsToString(nSessionDenom));
+            strAutoDenomResult = _("Mixing in progress...");
+            SetState(POOL_STATE_QUEUE);
+            nTimeLastSuccessfulStep = GetTimeMillis();
+            if (pnodeFound) {
+                pnodeFound->Release();
+            }
+            return true;
+        } else {
+            LogPrintf("CDarksendPool::DoAutomaticDenominating -- can't connect, addr=%s\n", pmn->addr.ToString());
+            nTries++;
+            continue;
+        }
+    }
+
+    strAutoDenomResult = _("No compatible Znode found.");
+    return false;
+}
+
+bool CDarksendPool::SubmitDenominate() {
+    std::string strError;
+    std::vector <CTxIn> vecTxInRet;
+    std::vector <CTxOut> vecTxOutRet;
+
+    // Submit transaction to the pool if we get here
+    // Try to use only inputs with the same number of rounds starting from lowest number of rounds possible
+    for (int i = 0; i < nPrivateSendRounds; i++) {
+        if (PrepareDenominate(i, i + 1, strError, vecTxInRet, vecTxOutRet)) {
+            LogPrintf("CDarksendPool::SubmitDenominate -- Running PrivateSend denominate for %d rounds, success\n", i);
+            return SendDenominate(vecTxInRet, vecTxOutRet);
+        }
+        LogPrintf("CDarksendPool::SubmitDenominate -- Running PrivateSend denominate for %d rounds, error: %s\n", i, strError);
+    }
+
+    // We failed? That's strange but let's just make final attempt and try to mix everything
+    if (PrepareDenominate(0, nPrivateSendRounds, strError, vecTxInRet, vecTxOutRet)) {
+        LogPrintf("CDarksendPool::SubmitDenominate -- Running PrivateSend denominate for all rounds, success\n");
+        return SendDenominate(vecTxInRet, vecTxOutRet);
+    }
+
+    // Should never actually get here but just in case
+    LogPrintf("CDarksendPool::SubmitDenominate -- Running PrivateSend denominate for all rounds, error: %s\n", strError);
+    strAutoDenomResult = strError;
+    return false;
+}
+
+bool CDarksendPool::PrepareDenominate(int nMinRounds, int nMaxRounds, std::string &strErrorRet, std::vector <CTxIn> &vecTxInRet, std::vector <CTxOut> &vecTxOutRet) {
+    if (pwalletMain->IsLocked(true)) {
+        strErrorRet = "Wallet locked, unable to create transaction!";
+        return false;
+    }
+
+    if (GetEntriesCount() > 0) {
+        strErrorRet = "Already have pending entries in the PrivateSend pool";
+        return false;
+    }
+
+    // make sure returning vectors are empty before filling them up
+    vecTxInRet.clear();
+    vecTxOutRet.clear();
+
+    // ** find the coins we'll use
+    std::vector <CTxIn> vecTxIn;
+    std::vector <COutput> vCoins;
+    CAmount nValueIn = 0;
+    CReserveKey reservekey(pwalletMain);
+
+    /*
+        Select the coins we'll use
+
+        if nMinRounds >= 0 it means only denominated inputs are going in and coming out
+    */
+    std::vector<int> vecBits;
+    if (!GetDenominationsBits(nSessionDenom, vecBits)) {
+        strErrorRet = "Incorrect session denom";
+        return false;
+    }
+    bool fSelected = pwalletMain->SelectCoinsByDenominations(nSessionDenom, vecPrivateSendDenominations[vecBits.front()], PRIVATESEND_POOL_MAX, vecTxIn, vCoins, nValueIn, nMinRounds, nMaxRounds);
+    if (nMinRounds >= 0 && !fSelected) {
+        strErrorRet = "Can't select current denominated inputs";
+        return false;
+    }
+
+    LogPrintf("CDarksendPool::PrepareDenominate -- max value: %f\n", (double) nValueIn / COIN);
+
+    {
+        LOCK(pwalletMain->cs_wallet);
+        BOOST_FOREACH(CTxIn
+        txin, vecTxIn) {
+            pwalletMain->LockCoin(txin.prevout);
+        }
+    }
+
+    CAmount nValueLeft = nValueIn;
+
+    // Try to add every needed denomination, repeat up to 5-9 times.
+    // NOTE: No need to randomize order of inputs because they were
+    // initially shuffled in CWallet::SelectCoinsByDenominations already.
+    int nStep = 0;
+    int nStepsMax = 5 + GetRandInt(5);
+
+    while (nStep < nStepsMax) {
+        BOOST_FOREACH(int
+        nBit, vecBits) {
+            CAmount nValueDenom = vecPrivateSendDenominations[nBit];
+            if (nValueLeft - nValueDenom < 0) continue;
+
+            // Note: this relies on a fact that both vectors MUST have same size
+            std::vector<CTxIn>::iterator it = vecTxIn.begin();
+            std::vector<COutput>::iterator it2 = vCoins.begin();
+            while (it2 != vCoins.end()) {
+                // we have matching inputs
+                if ((*it2).tx->vout[(*it2).i].nValue == nValueDenom) {
+                    // add new input in resulting vector
+                    vecTxInRet.push_back(*it);
+                    // remove corresponting items from initial vectors
+                    vecTxIn.erase(it);
+                    vCoins.erase(it2);
+
+                    CScript scriptChange;
+                    CPubKey vchPubKey;
+                    // use a unique change address
+                    assert(reservekey.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
+                    scriptChange = GetScriptForDestination(vchPubKey.GetID());
+                    reservekey.KeepKey();
+
+                    // add new output
+                    CTxOut txout(nValueDenom, scriptChange);
+                    vecTxOutRet.push_back(txout);
+
+                    // subtract denomination amount
+                    nValueLeft -= nValueDenom;
+
+                    // step is complete
+                    break;
+                }
+                ++it;
+                ++it2;
+            }
+        }
+        if (nValueLeft == 0) break;
+        nStep++;
+    }
+
+    {
+        // unlock unused coins
+        LOCK(pwalletMain->cs_wallet);
+        BOOST_FOREACH(CTxIn
+        txin, vecTxIn) {
+            pwalletMain->UnlockCoin(txin.prevout);
+        }
+    }
+
+    if (GetDenominations(vecTxOutRet) != nSessionDenom) {
+        // unlock used coins on failure
+        LOCK(pwalletMain->cs_wallet);
+        BOOST_FOREACH(CTxIn
+        txin, vecTxInRet) {
+            pwalletMain->UnlockCoin(txin.prevout);
+        }
+        strErrorRet = "Can't make current denominated outputs";
+        return false;
+    }
+
+    // We also do not care about full amount as long as we have right denominations
+    return true;
+}
+
+// Create collaterals by looping through inputs grouped by addresses
+bool CDarksendPool::MakeCollateralAmounts() {
+    std::vector <CompactTallyItem> vecTally;
+    if (!pwalletMain->SelectCoinsGrouppedByAddresses(vecTally, false)) {
+        LogPrint("privatesend", "CDarksendPool::MakeCollateralAmounts -- SelectCoinsGrouppedByAddresses can't find any inputs!\n");
+        return false;
+    }
+
+    BOOST_FOREACH(CompactTallyItem & item, vecTally)
+    {
+        if (!MakeCollateralAmounts(item)) continue;
+        return true;
+    }
+
+    LogPrintf("CDarksendPool::MakeCollateralAmounts -- failed!\n");
+    return false;
+}
+
+// Split up large inputs or create fee sized inputs
+bool CDarksendPool::MakeCollateralAmounts(const CompactTallyItem &tallyItem) {
+    CWalletTx wtx;
+    CAmount nFeeRet = 0;
+    int nChangePosRet = -1;
+    std::string strFail = "";
+    std::vector <CRecipient> vecSend;
+
+    // make our collateral address
+    CReserveKey reservekeyCollateral(pwalletMain);
+    // make our change address
+    CReserveKey reservekeyChange(pwalletMain);
+
+    CScript scriptCollateral;
+    CPubKey vchPubKey;
+    assert(reservekeyCollateral.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
+    scriptCollateral = GetScriptForDestination(vchPubKey.GetID());
+
+    vecSend.push_back((CRecipient) {scriptCollateral, PRIVATESEND_COLLATERAL * 4, false});
+
+    // try to use non-denominated and not mn-like funds first, select them explicitly
+    CCoinControl coinControl;
+    coinControl.fAllowOtherInputs = false;
+    coinControl.fAllowWatchOnly = false;
+    // send change to the same address so that we were able create more denoms out of it later
+    coinControl.destChange = tallyItem.address.Get();
+    BOOST_FOREACH(
+    const CTxIn &txin, tallyItem.vecTxIn)
+    coinControl.Select(txin.prevout);
+    //TODO
+    //bool fSuccess = pwalletMain->CreateTransaction(vecSend, wtx, reservekeyChange, nFeeRet, nChangePosRet, strFail, &coinControl, true, ONLY_NONDENOMINATED_NOT1000IFMN);
+    bool fSuccess = false;
+    if (!fSuccess) {
+        // if we failed (most likeky not enough funds), try to use all coins instead -
+        // MN-like funds should not be touched in any case and we can't mix denominated without collaterals anyway
+        LogPrintf("CDarksendPool::MakeCollateralAmounts -- ONLY_NONDENOMINATED_NOT1000IFMN Error: %s\n", strFail);
+        CCoinControl *coinControlNull = NULL;
+        //TODO
+//        fSuccess = pwalletMain->CreateTransaction(vecSend, wtx, reservekeyChange, nFeeRet, nChangePosRet, strFail, coinControlNull, true, ONLY_NOT1000IFMN);
+        fSuccess = false;
+        if (!fSuccess) {
+            LogPrintf("CDarksendPool::MakeCollateralAmounts -- ONLY_NOT1000IFMN Error: %s\n", strFail);
+            reservekeyCollateral.ReturnKey();
+            return false;
+        }
+    }
+
+    reservekeyCollateral.KeepKey();
+
+    LogPrintf("CDarksendPool::MakeCollateralAmounts -- txid=%s\n", wtx.GetHash().GetHex());
+
+    // use the same nCachedLastSuccessBlock as for DS mixinx to prevent race
+    if (!pwalletMain->CommitTransaction(wtx, reservekeyChange)) {
+        LogPrintf("CDarksendPool::MakeCollateralAmounts -- CommitTransaction failed!\n");
+        return false;
+    }
+
+    nCachedLastSuccessBlock = pCurrentBlockIndex->nHeight;
+
+    return true;
+}
+
+// Create denominations by looping through inputs grouped by addresses
+bool CDarksendPool::CreateDenominated() {
+    std::vector <CompactTallyItem> vecTally;
+    if (!pwalletMain->SelectCoinsGrouppedByAddresses(vecTally)) {
+        LogPrint("privatesend", "CDarksendPool::CreateDenominated -- SelectCoinsGrouppedByAddresses can't find any inputs!\n");
+        return false;
+    }
+
+    bool fCreateMixingCollaterals = !pwalletMain->HasCollateralInputs();
+
+    BOOST_FOREACH(CompactTallyItem & item, vecTally)
+    {
+        if (!CreateDenominated(item, fCreateMixingCollaterals)) continue;
+        return true;
+    }
+
+    LogPrintf("CDarksendPool::CreateDenominated -- failed!\n");
+    return false;
+}
+
+// Create denominations
+bool CDarksendPool::CreateDenominated(const CompactTallyItem &tallyItem, bool fCreateMixingCollaterals) {
+    std::vector <CRecipient> vecSend;
+    CAmount nValueLeft = tallyItem.nAmount;
+    nValueLeft -= PRIVATESEND_COLLATERAL; // leave some room for fees
+
+    LogPrintf("CreateDenominated0 nValueLeft: %f\n", (float) nValueLeft / COIN);
+    // make our collateral address
+    CReserveKey reservekeyCollateral(pwalletMain);
+
+    CScript scriptCollateral;
+    CPubKey vchPubKey;
+    assert(reservekeyCollateral.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
+    scriptCollateral = GetScriptForDestination(vchPubKey.GetID());
+
+    // ****** Add collateral outputs ************ /
+
+    if (fCreateMixingCollaterals) {
+        vecSend.push_back((CRecipient) {scriptCollateral, PRIVATESEND_COLLATERAL * 4, false});
+        nValueLeft -= PRIVATESEND_COLLATERAL * 4;
+    }
+
+    // ****** Add denoms ************ /
+
+    // make our denom addresses
+    CReserveKey reservekeyDenom(pwalletMain);
+
+    // try few times - skipping smallest denoms first if there are too much already, if failed - use them
+    int nOutputsTotal = 0;
+    bool fSkip = true;
+    do {
+
+        BOOST_REVERSE_FOREACH(CAmount
+        nDenomValue, vecPrivateSendDenominations) {
+
+            if (fSkip) {
+                // Note: denoms are skipped if there are already DENOMS_COUNT_MAX of them
+                // and there are still larger denoms which can be used for mixing
+
+                // check skipped denoms
+                if (IsDenomSkipped(nDenomValue)) continue;
+
+                // find new denoms to skip if any (ignore the largest one)
+                if (nDenomValue != vecPrivateSendDenominations[0] && pwalletMain->CountInputsWithAmount(nDenomValue) > DENOMS_COUNT_MAX) {
+                    strAutoDenomResult = strprintf(_("Too many %f denominations, removing."), (float) nDenomValue / COIN);
+                    LogPrintf("CDarksendPool::CreateDenominated -- %s\n", strAutoDenomResult);
+                    vecDenominationsSkipped.push_back(nDenomValue);
+                    continue;
+                }
+            }
+
+            int nOutputs = 0;
+
+            // add each output up to 10 times until it can't be added again
+            while (nValueLeft - nDenomValue >= 0 && nOutputs <= 10) {
+                CScript scriptDenom;
+                CPubKey vchPubKey;
+                //use a unique change address
+                assert(reservekeyDenom.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
+                scriptDenom = GetScriptForDestination(vchPubKey.GetID());
+                // TODO: do not keep reservekeyDenom here
+                reservekeyDenom.KeepKey();
+
+                vecSend.push_back((CRecipient) {scriptDenom, nDenomValue, false});
+
+                //increment outputs and subtract denomination amount
+                nOutputs++;
+                nValueLeft -= nDenomValue;
+                LogPrintf("CreateDenominated1: nOutputsTotal: %d, nOutputs: %d, nValueLeft: %f\n", nOutputsTotal, nOutputs, (float) nValueLeft / COIN);
+            }
+
+            nOutputsTotal += nOutputs;
+            if (nValueLeft == 0) break;
+        }
+        LogPrintf("CreateDenominated2: nOutputsTotal: %d, nValueLeft: %f\n", nOutputsTotal, (float) nValueLeft / COIN);
+        // if there were no outputs added, start over without skipping
+        fSkip = !fSkip;
+    } while (nOutputsTotal == 0 && !fSkip);
+    LogPrintf("CreateDenominated3: nOutputsTotal: %d, nValueLeft: %f\n", nOutputsTotal, (float) nValueLeft / COIN);
+
+    // if we have anything left over, it will be automatically send back as change - there is no need to send it manually
+
+    CCoinControl coinControl;
+    coinControl.fAllowOtherInputs = false;
+    coinControl.fAllowWatchOnly = false;
+    // send change to the same address so that we were able create more denoms out of it later
+    coinControl.destChange = tallyItem.address.Get();
+    BOOST_FOREACH(
+    const CTxIn &txin, tallyItem.vecTxIn)
+    coinControl.Select(txin.prevout);
+
+    CWalletTx wtx;
+    CAmount nFeeRet = 0;
+    int nChangePosRet = -1;
+    std::string strFail = "";
+    // make our change address
+    CReserveKey reservekeyChange(pwalletMain);
+    //TODO
+//    bool fSuccess = pwalletMain->CreateTransaction(vecSend, wtx, reservekeyChange, nFeeRet, nChangePosRet, strFail, &coinControl, true, ONLY_NONDENOMINATED_NOT1000IFMN);
+    bool fSuccess = false;
+    if (!fSuccess) {
+        LogPrintf("CDarksendPool::CreateDenominated -- Error: %s\n", strFail);
+        // TODO: return reservekeyDenom here
+        reservekeyCollateral.ReturnKey();
+        return false;
+    }
+
+    // TODO: keep reservekeyDenom here
+    reservekeyCollateral.KeepKey();
+
+    if (!pwalletMain->CommitTransaction(wtx, reservekeyChange)) {
+        LogPrintf("CDarksendPool::CreateDenominated -- CommitTransaction failed!\n");
+        return false;
+    }
+
+    // use the same nCachedLastSuccessBlock as for DS mixing to prevent race
+    nCachedLastSuccessBlock = pCurrentBlockIndex->nHeight;
+    LogPrintf("CDarksendPool::CreateDenominated -- txid=%s\n", wtx.GetHash().GetHex());
+
+    return true;
+}
+
+bool CDarksendPool::IsOutputsCompatibleWithSessionDenom(const std::vector <CTxDSOut> &vecTxDSOut) {
+    if (GetDenominations(vecTxDSOut) == 0) return false;
+
+    BOOST_FOREACH(
+    const CDarkSendEntry entry, vecEntries) {
+        LogPrintf("CDarksendPool::IsOutputsCompatibleWithSessionDenom -- vecTxDSOut denom %d, entry.vecTxDSOut denom %d\n", GetDenominations(vecTxDSOut), GetDenominations(entry.vecTxDSOut));
+        if (GetDenominations(vecTxDSOut) != GetDenominations(entry.vecTxDSOut)) return false;
+    }
+
+    return true;
+}
+
+bool CDarksendPool::IsAcceptableDenomAndCollateral(int nDenom, CTransaction txCollateral, PoolMessage &nMessageIDRet) {
+    if (!fZNode) return false;
+
+    // is denom even smth legit?
+    std::vector<int> vecBits;
+    if (!GetDenominationsBits(nDenom, vecBits)) {
+        LogPrint("privatesend", "CDarksendPool::IsAcceptableDenomAndCollateral -- denom not valid!\n");
+        nMessageIDRet = ERR_DENOM;
+        return false;
+    }
+
+    // check collateral
+    if (!fUnitTest && !IsCollateralValid(txCollateral)) {
+        LogPrint("privatesend", "CDarksendPool::IsAcceptableDenomAndCollateral -- collateral not valid!\n");
+        nMessageIDRet = ERR_INVALID_COLLATERAL;
+        return false;
+    }
+
+    return true;
+}
+
+bool CDarksendPool::CreateNewSession(int nDenom, CTransaction txCollateral, PoolMessage &nMessageIDRet) {
+    if (!fZNode || nSessionID != 0) return false;
+
+    // new session can only be started in idle mode
+    if (nState != POOL_STATE_IDLE) {
+        nMessageIDRet = ERR_MODE;
+        LogPrintf("CDarksendPool::CreateNewSession -- incompatible mode: nState=%d\n", nState);
+        return false;
+    }
+
+    if (!IsAcceptableDenomAndCollateral(nDenom, txCollateral, nMessageIDRet)) {
+        return false;
+    }
+
+    // start new session
+    nMessageIDRet = MSG_NOERR;
+    nSessionID = GetRandInt(999999) + 1;
+    nSessionDenom = nDenom;
+
+    SetState(POOL_STATE_QUEUE);
+    nTimeLastSuccessfulStep = GetTimeMillis();
+
+    if (!fUnitTest) {
+        //broadcast that I'm accepting entries, only if it's the first entry through
+        CDarksendQueue dsq(nDenom, activeZnode.vin, GetTime(), false);
+        LogPrint("privatesend", "CDarksendPool::CreateNewSession -- signing and relaying new queue: %s\n", dsq.ToString());
+        dsq.Sign();
+        dsq.Relay();
+        vecDarksendQueue.push_back(dsq);
+    }
+
+    vecSessionCollaterals.push_back(txCollateral);
+    LogPrintf("CDarksendPool::CreateNewSession -- new session created, nSessionID: %d  nSessionDenom: %d (%s)  vecSessionCollaterals.size(): %d\n",
+              nSessionID, nSessionDenom, GetDenominationsToString(nSessionDenom), vecSessionCollaterals.size());
+
+    return true;
+}
+
+bool CDarksendPool::AddUserToExistingSession(int nDenom, CTransaction txCollateral, PoolMessage &nMessageIDRet) {
+    if (!fZNode || nSessionID == 0 || IsSessionReady()) return false;
+
+    if (!IsAcceptableDenomAndCollateral(nDenom, txCollateral, nMessageIDRet)) {
+        return false;
+    }
+
+    // we only add new users to an existing session when we are in queue mode
+    if (nState != POOL_STATE_QUEUE) {
+        nMessageIDRet = ERR_MODE;
+        LogPrintf("CDarksendPool::AddUserToExistingSession -- incompatible mode: nState=%d\n", nState);
+        return false;
+    }
+
+    if (nDenom != nSessionDenom) {
+        LogPrintf("CDarksendPool::AddUserToExistingSession -- incompatible denom %d (%s) != nSessionDenom %d (%s)\n",
+                  nDenom, GetDenominationsToString(nDenom), nSessionDenom, GetDenominationsToString(nSessionDenom));
+        nMessageIDRet = ERR_DENOM;
+        return false;
+    }
+
+    // count new user as accepted to an existing session
+
+    nMessageIDRet = MSG_NOERR;
+    nTimeLastSuccessfulStep = GetTimeMillis();
+    vecSessionCollaterals.push_back(txCollateral);
+
+    LogPrintf("CDarksendPool::AddUserToExistingSession -- new user accepted, nSessionID: %d  nSessionDenom: %d (%s)  vecSessionCollaterals.size(): %d\n",
+              nSessionID, nSessionDenom, GetDenominationsToString(nSessionDenom), vecSessionCollaterals.size());
+
+    return true;
+}
+
+/*  Create a nice string to show the denominations
+    Function returns as follows (for 4 denominations):
+        ( bit on if present )
+        bit 0           - 100
+        bit 1           - 10
+        bit 2           - 1
+        bit 3           - .1
+        bit 4 and so on - out-of-bounds
+        none of above   - non-denom
+*/
+std::string CDarksendPool::GetDenominationsToString(int nDenom) {
+    std::string strDenom = "";
+    int nMaxDenoms = vecPrivateSendDenominations.size();
+
+    if (nDenom >= (1 << nMaxDenoms)) {
+        return "out-of-bounds";
+    }
+
+    for (int i = 0; i < nMaxDenoms; ++i) {
+        if (nDenom & (1 << i)) {
+            strDenom += (strDenom.empty() ? "" : "+") + FormatMoney(vecPrivateSendDenominations[i]);
+        }
+    }
+
+    if (strDenom.empty()) {
+        return "non-denom";
+    }
+
+    return strDenom;
+}
+
+int CDarksendPool::GetDenominations(const std::vector <CTxDSOut> &vecTxDSOut) {
+    std::vector <CTxOut> vecTxOut;
+
+    BOOST_FOREACH(CTxDSOut
+    out, vecTxDSOut)
+    vecTxOut.push_back(out);
+
+    return GetDenominations(vecTxOut);
+}
+
+/*  Return a bitshifted integer representing the denominations in this list
+    Function returns as follows (for 4 denominations):
+        ( bit on if present )
+        100       - bit 0
+        10        - bit 1
+        1         - bit 2
+        .1        - bit 3
+        non-denom - 0, all bits off
+*/
+int CDarksendPool::GetDenominations(const std::vector <CTxOut> &vecTxOut, bool fSingleRandomDenom) {
+    std::vector <std::pair<CAmount, int>> vecDenomUsed;
+
+    // make a list of denominations, with zero uses
+    BOOST_FOREACH(CAmount
+    nDenomValue, vecPrivateSendDenominations)
+    vecDenomUsed.push_back(std::make_pair(nDenomValue, 0));
+
+    // look for denominations and update uses to 1
+    BOOST_FOREACH(CTxOut
+    txout, vecTxOut) {
+        bool found = false;
+        BOOST_FOREACH(PAIRTYPE(CAmount, int) &s, vecDenomUsed)
+        {
+            if (txout.nValue == s.first) {
+                s.second = 1;
+                found = true;
+            }
+        }
+        if (!found) return 0;
+    }
+
+    int nDenom = 0;
+    int c = 0;
+    // if the denomination is used, shift the bit on
+    BOOST_FOREACH(PAIRTYPE(CAmount, int) &s, vecDenomUsed)
+    {
+        int bit = (fSingleRandomDenom ? GetRandInt(2) : 1) & s.second;
+        nDenom |= bit << c++;
+        if (fSingleRandomDenom && bit) break; // use just one random denomination
+    }
+
+    return nDenom;
+}
+
+bool CDarksendPool::GetDenominationsBits(int nDenom, std::vector<int> &vecBitsRet) {
+    // ( bit on if present, 4 denominations example )
+    // bit 0 - 100DASH+1
+    // bit 1 - 10DASH+1
+    // bit 2 - 1DASH+1
+    // bit 3 - .1DASH+1
+
+    int nMaxDenoms = vecPrivateSendDenominations.size();
+
+    if (nDenom >= (1 << nMaxDenoms)) return false;
+
+    vecBitsRet.clear();
+
+    for (int i = 0; i < nMaxDenoms; ++i) {
+        if (nDenom & (1 << i)) {
+            vecBitsRet.push_back(i);
+        }
+    }
+
+    return !vecBitsRet.empty();
+}
+
+int CDarksendPool::GetDenominationsByAmounts(const std::vector <CAmount> &vecAmount) {
+    CScript scriptTmp = CScript();
+    std::vector <CTxOut> vecTxOut;
+
+    BOOST_REVERSE_FOREACH(CAmount
+    nAmount, vecAmount) {
+        CTxOut txout(nAmount, scriptTmp);
+        vecTxOut.push_back(txout);
+    }
+
+    return GetDenominations(vecTxOut, true);
+}
+
+std::string CDarksendPool::GetMessageByID(PoolMessage nMessageID) {
+    switch (nMessageID) {
+        case ERR_ALREADY_HAVE:
+            return _("Already have that input.");
+        case ERR_DENOM:
+            return _("No matching denominations found for mixing.");
+        case ERR_ENTRIES_FULL:
+            return _("Entries are full.");
+        case ERR_EXISTING_TX:
+            return _("Not compatible with existing transactions.");
+        case ERR_FEES:
+            return _("Transaction fees are too high.");
+        case ERR_INVALID_COLLATERAL:
+            return _("Collateral not valid.");
+        case ERR_INVALID_INPUT:
+            return _("Input is not valid.");
+        case ERR_INVALID_SCRIPT:
+            return _("Invalid script detected.");
+        case ERR_INVALID_TX:
+            return _("Transaction not valid.");
+        case ERR_MAXIMUM:
+            return _("Value more than PrivateSend pool maximum allows.");
+        case ERR_MN_LIST:
+            return _("Not in the Znode list.");
+        case ERR_MODE:
+            return _("Incompatible mode.");
+        case ERR_NON_STANDARD_PUBKEY:
+            return _("Non-standard public key detected.");
+        case ERR_NOT_A_MN:
+            return _("This is not a Znode.");
+        case ERR_QUEUE_FULL:
+            return _("Znode queue is full.");
+        case ERR_RECENT:
+            return _("Last PrivateSend was too recent.");
+        case ERR_SESSION:
+            return _("Session not complete!");
+        case ERR_MISSING_TX:
+            return _("Missing input transaction information.");
+        case ERR_VERSION:
+            return _("Incompatible version.");
+        case MSG_NOERR:
+            return _("No errors detected.");
+        case MSG_SUCCESS:
+            return _("Transaction created successfully.");
+        case MSG_ENTRIES_ADDED:
+            return _("Your entries added successfully.");
+        default:
+            return _("Unknown response.");
+    }
+}
+
+bool CDarkSendSigner::IsVinAssociatedWithPubkey(const CTxIn &txin, const CPubKey &pubkey) {
+    CScript payee;
+    payee = GetScriptForDestination(pubkey.GetID());
+
+    CTransaction tx;
+    uint256 hash;
+    if (GetTransaction(txin.prevout.hash, tx, Params().GetConsensus(), hash, true)) {
+        BOOST_FOREACH(CTxOut out, tx.vout)
+        if (out.nValue == ZNODE_COIN_REQUIRED * COIN && out.scriptPubKey == payee) return true;
+    }
+
+    return false;
+}
+
+bool CDarkSendSigner::GetKeysFromSecret(std::string strSecret, CKey &keyRet, CPubKey &pubkeyRet) {
+    CBitcoinSecret vchSecret;
+
+    if (!vchSecret.SetString(strSecret)) return false;
+
+    keyRet = vchSecret.GetKey();
+    pubkeyRet = keyRet.GetPubKey();
+
+    return true;
+}
+
+bool CDarkSendSigner::SignMessage(std::string strMessage, std::vector<unsigned char> &vchSigRet, CKey key) {
+    CHashWriter ss(SER_GETHASH, 0);
+    ss << strMessageMagic;
+    ss << strMessage;
+
+    return key.SignCompact(ss.GetHash(), vchSigRet);
+}
+
+bool CDarkSendSigner::VerifyMessage(CPubKey pubkey, const std::vector<unsigned char> &vchSig, std::string strMessage, std::string &strErrorRet) {
+    CHashWriter ss(SER_GETHASH, 0);
+    ss << strMessageMagic;
+    ss << strMessage;
+
+    CPubKey pubkeyFromSig;
+    if (!pubkeyFromSig.RecoverCompact(ss.GetHash(), vchSig)) {
+        strErrorRet = "Error recovering public key.";
+        return false;
+    }
+
+    if (pubkeyFromSig.GetID() != pubkey.GetID()) {
+        strErrorRet = strprintf("Keys don't match: pubkey=%s, pubkeyFromSig=%s, strMessage=%s, vchSig=%s",
+                                pubkey.GetID().ToString(), pubkeyFromSig.GetID().ToString(), strMessage,
+                                EncodeBase64(&vchSig[0], vchSig.size()));
+        return false;
+    }
+
+    return true;
+}
+
+bool CDarkSendEntry::AddScriptSig(const CTxIn &txin) {
+    BOOST_FOREACH(CTxDSIn & txdsin, vecTxDSIn)
+    {
+        if (txdsin.prevout == txin.prevout && txdsin.nSequence == txin.nSequence) {
+            if (txdsin.fHasSig) return false;
+
+            txdsin.scriptSig = txin.scriptSig;
+            txdsin.prevPubKey = txin.prevPubKey;
+            txdsin.fHasSig = true;
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CDarksendQueue::Sign() {
+    if (!fZNode) return false;
+
+    std::string strMessage = vin.ToString() + boost::lexical_cast<std::string>(nDenom) + boost::lexical_cast<std::string>(nTime) + boost::lexical_cast<std::string>(fReady);
+
+    if (!darkSendSigner.SignMessage(strMessage, vchSig, activeZnode.keyZnode)) {
+        LogPrintf("CDarksendQueue::Sign -- SignMessage() failed, %s\n", ToString());
+        return false;
+    }
+
+    return CheckSignature(activeZnode.pubKeyZnode);
+}
+
+bool CDarksendQueue::CheckSignature(const CPubKey &pubKeyZnode) {
+    std::string strMessage = vin.ToString() + boost::lexical_cast<std::string>(nDenom) + boost::lexical_cast<std::string>(nTime) + boost::lexical_cast<std::string>(fReady);
+    std::string strError = "";
+
+    if (!darkSendSigner.VerifyMessage(pubKeyZnode, vchSig, strMessage, strError)) {
+        LogPrintf("CDarksendQueue::CheckSignature -- Got bad Znode queue signature: %s; error: %s\n", ToString(), strError);
+        return false;
+    }
+
+    return true;
+}
+
+bool CDarksendQueue::Relay() {
+    std::vector < CNode * > vNodesCopy = CopyNodeVector();
+    BOOST_FOREACH(CNode * pnode, vNodesCopy)
+        if (pnode->nVersion >= MIN_PRIVATESEND_PEER_PROTO_VERSION)
+            pnode->PushMessage(NetMsgType::DSQUEUE, (*this));
+
+    ReleaseNodeVector(vNodesCopy);
+    return true;
+}
+
+bool CDarksendBroadcastTx::Sign() {
+    if (!fZNode) return false;
+
+    std::string strMessage = tx.GetHash().ToString() + boost::lexical_cast<std::string>(sigTime);
+
+    if (!darkSendSigner.SignMessage(strMessage, vchSig, activeZnode.keyZnode)) {
+        LogPrintf("CDarksendBroadcastTx::Sign -- SignMessage() failed\n");
+        return false;
+    }
+
+    return CheckSignature(activeZnode.pubKeyZnode);
+}
+
+bool CDarksendBroadcastTx::CheckSignature(const CPubKey &pubKeyZnode) {
+    std::string strMessage = tx.GetHash().ToString() + boost::lexical_cast<std::string>(sigTime);
+    std::string strError = "";
+
+    if (!darkSendSigner.VerifyMessage(pubKeyZnode, vchSig, strMessage, strError)) {
+        LogPrintf("CDarksendBroadcastTx::CheckSignature -- Got bad dstx signature, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+void CDarksendPool::RelayFinalTransaction(const CTransaction &txFinal) {
+    LOCK(cs_vNodes);
+    BOOST_FOREACH(CNode * pnode, vNodes)
+        if (pnode->nVersion >= MIN_PRIVATESEND_PEER_PROTO_VERSION)
+            pnode->PushMessage(NetMsgType::DSFINALTX, nSessionID, txFinal);
+}
+
+void CDarksendPool::RelayIn(const CDarkSendEntry &entry) {
+    if (!pSubmittedToZnode) return;
+
+    CNode *pnode = FindNode(pSubmittedToZnode->addr);
+    if (pnode != NULL) {
+        LogPrintf("CDarksendPool::RelayIn -- found master, relaying message to %s\n", pnode->addr.ToString());
+        pnode->PushMessage(NetMsgType::DSVIN, entry);
+    }
+}
+
+void CDarksendPool::PushStatus(CNode *pnode, PoolStatusUpdate nStatusUpdate, PoolMessage nMessageID) {
+    if (!pnode) return;
+    pnode->PushMessage(NetMsgType::DSSTATUSUPDATE, nSessionID, (int) nState, (int) vecEntries.size(), (int) nStatusUpdate, (int) nMessageID);
+}
+
+void CDarksendPool::RelayStatus(PoolStatusUpdate nStatusUpdate, PoolMessage nMessageID) {
+    LOCK(cs_vNodes);
+    BOOST_FOREACH(CNode * pnode, vNodes)
+        if (pnode->nVersion >= MIN_PRIVATESEND_PEER_PROTO_VERSION)
+            PushStatus(pnode, nStatusUpdate, nMessageID);
+}
+
+void CDarksendPool::RelayCompletedTransaction(PoolMessage nMessageID) {
+    LOCK(cs_vNodes);
+    BOOST_FOREACH(CNode * pnode, vNodes)
+        if (pnode->nVersion >= MIN_PRIVATESEND_PEER_PROTO_VERSION)
+            pnode->PushMessage(NetMsgType::DSCOMPLETE, nSessionID, (int) nMessageID);
+}
+
+void CDarksendPool::SetState(PoolState nStateNew) {
+    if (fZNode && (nStateNew == POOL_STATE_ERROR || nStateNew == POOL_STATE_SUCCESS)) {
+        LogPrint("privatesend", "CDarksendPool::SetState -- Can't set state to ERROR or SUCCESS as a Znode. \n");
+        return;
+    }
+
+    LogPrintf("CDarksendPool::SetState -- nState: %d, nStateNew: %d\n", nState, nStateNew);
+    nState = nStateNew;
+}
+
+void CDarksendPool::UpdatedBlockTip(const CBlockIndex *pindex) {
+    pCurrentBlockIndex = pindex;
+    LogPrint("privatesend", "CDarksendPool::UpdatedBlockTip -- pCurrentBlockIndex->nHeight: %d\n", pCurrentBlockIndex->nHeight);
+
+    if (!fLiteMode && znodeSync.IsZnodeListSynced()) {
+        NewBlock();
+    }
+}
+
+//TODO: Rename/move to core
+void ThreadCheckDarkSendPool() {
+    if (fLiteMode) return; // disable all Dash specific functionality
+
+    static bool fOneThread;
+    if (fOneThread) return;
+    fOneThread = true;
+
+    // Make this thread recognisable as the PrivateSend thread
+    RenameThread("dash-privatesend");
+
+    unsigned int nTick = 0;
+    unsigned int nDoAutoNextRun = nTick + PRIVATESEND_AUTO_TIMEOUT_MIN;
+
+    while (true) {
+        MilliSleep(1000);
+
+        // try to sync from all available nodes, one step at a time
+        znodeSync.ProcessTick();
+
+        if (znodeSync.IsBlockchainSynced() && !ShutdownRequested()) {
+
+            nTick++;
+
+            // make sure to check all znodes first
+            mnodeman.Check();
+
+            // check if we should activate or ping every few minutes,
+            // slightly postpone first run to give net thread a chance to connect to some peers
+            if (nTick % ZNODE_MIN_MNP_SECONDS == 15)
+                activeZnode.ManageState();
+
+            if (nTick % 60 == 0) {
+                mnodeman.ProcessZnodeConnections();
+                mnodeman.CheckAndRemove();
+                mnpayments.CheckAndRemove();
+                instantsend.CheckAndRemove();
+            }
+            if (fZNode && (nTick % (60 * 5) == 0)) {
+                mnodeman.DoFullVerificationStep();
+            }
+
+//            if(nTick % (60 * 5) == 0) {
+//                governance.DoMaintenance();
+//            }
+
+            darkSendPool.CheckTimeout();
+            darkSendPool.CheckForCompleteQueue();
+
+            if (nDoAutoNextRun == nTick) {
+                darkSendPool.DoAutomaticDenominating();
+                nDoAutoNextRun = nTick + PRIVATESEND_AUTO_TIMEOUT_MIN + GetRandInt(PRIVATESEND_AUTO_TIMEOUT_MAX - PRIVATESEND_AUTO_TIMEOUT_MIN);
+            }
+        }
+    }
+}
diff --git a/src/darksend.h b/src/darksend.h
new file mode 100644
index 0000000000..22cb709992
--- /dev/null
+++ b/src/darksend.h
@@ -0,0 +1,483 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef DARKSEND_H
+#define DARKSEND_H
+
+#include "znode.h"
+#include "wallet/wallet.h"
+
+class CDarksendPool;
+class CDarkSendSigner;
+class CDarksendBroadcastTx;
+
+// timeouts
+static const int PRIVATESEND_AUTO_TIMEOUT_MIN       = 5;
+static const int PRIVATESEND_AUTO_TIMEOUT_MAX       = 15;
+static const int PRIVATESEND_QUEUE_TIMEOUT          = 30;
+static const int PRIVATESEND_SIGNING_TIMEOUT        = 15;
+
+//! minimum peer version accepted by mixing pool
+static const int MIN_PRIVATESEND_PEER_PROTO_VERSION = 70206;
+
+static const CAmount PRIVATESEND_COLLATERAL         = 0.001 * COIN;
+static const CAmount PRIVATESEND_POOL_MAX           = 999.999 * COIN;
+static const int DENOMS_COUNT_MAX                   = 100;
+
+static const int DEFAULT_PRIVATESEND_ROUNDS         = 2;
+static const int DEFAULT_PRIVATESEND_AMOUNT         = 1000;
+static const int DEFAULT_PRIVATESEND_LIQUIDITY      = 0;
+static const bool DEFAULT_PRIVATESEND_MULTISESSION  = false;
+
+// Warn user if mixing in gui or try to create backup if mixing in daemon mode
+// when we have only this many keys left
+static const int PRIVATESEND_KEYS_THRESHOLD_WARNING = 100;
+// Stop mixing completely, it's too dangerous to continue when we have only this many keys left
+static const int PRIVATESEND_KEYS_THRESHOLD_STOP    = 50;
+
+// The main object for accessing mixing
+extern CDarksendPool darkSendPool;
+// A helper object for signing messages from Znodes
+extern CDarkSendSigner darkSendSigner;
+
+extern int nPrivateSendRounds;
+extern int nPrivateSendAmount;
+extern int nLiquidityProvider;
+extern bool fEnablePrivateSend;
+extern bool fPrivateSendMultiSession;
+
+extern std::map<uint256, CDarksendBroadcastTx> mapDarksendBroadcastTxes;
+extern std::vector<CAmount> vecPrivateSendDenominations;
+
+/** Holds an mixing input
+ */
+class CTxDSIn : public CTxIn
+{
+public:
+    bool fHasSig; // flag to indicate if signed
+    int nSentTimes; //times we've sent this anonymously
+
+    CTxDSIn(const CTxIn& txin) :
+        CTxIn(txin),
+        fHasSig(false),
+        nSentTimes(0)
+        {}
+
+    CTxDSIn() :
+        CTxIn(),
+        fHasSig(false),
+        nSentTimes(0)
+        {}
+};
+
+/** Holds an mixing output
+ */
+class CTxDSOut : public CTxOut
+{
+public:
+    int nSentTimes; //times we've sent this anonymously
+
+    CTxDSOut(const CTxOut& out) :
+        CTxOut(out),
+        nSentTimes(0)
+        {}
+
+    CTxDSOut() :
+        CTxOut(),
+        nSentTimes(0)
+        {}
+};
+
+// A clients transaction in the mixing pool
+class CDarkSendEntry
+{
+public:
+    std::vector<CTxDSIn> vecTxDSIn;
+    std::vector<CTxDSOut> vecTxDSOut;
+    CTransaction txCollateral;
+
+    CDarkSendEntry() :
+        vecTxDSIn(std::vector<CTxDSIn>()),
+        vecTxDSOut(std::vector<CTxDSOut>()),
+        txCollateral(CTransaction())
+        {}
+
+    CDarkSendEntry(const std::vector<CTxIn>& vecTxIn, const std::vector<CTxOut>& vecTxOut, const CTransaction& txCollateral) :
+        txCollateral(txCollateral)
+    {
+        BOOST_FOREACH(CTxIn txin, vecTxIn)
+            vecTxDSIn.push_back(txin);
+        BOOST_FOREACH(CTxOut txout, vecTxOut)
+            vecTxDSOut.push_back(txout);
+    }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(vecTxDSIn);
+        READWRITE(txCollateral);
+        READWRITE(vecTxDSOut);
+    }
+
+    bool AddScriptSig(const CTxIn& txin);
+};
+
+
+/**
+ * A currently inprogress mixing merge and denomination information
+ */
+class CDarksendQueue
+{
+public:
+    int nDenom;
+    CTxIn vin;
+    int64_t nTime;
+    bool fReady; //ready for submit
+    std::vector<unsigned char> vchSig;
+    // memory only
+    bool fTried;
+
+    CDarksendQueue() :
+        nDenom(0),
+        vin(CTxIn()),
+        nTime(0),
+        fReady(false),
+        vchSig(std::vector<unsigned char>()),
+        fTried(false)
+        {}
+
+    CDarksendQueue(int nDenom, CTxIn vin, int64_t nTime, bool fReady) :
+        nDenom(nDenom),
+        vin(vin),
+        nTime(nTime),
+        fReady(fReady),
+        vchSig(std::vector<unsigned char>()),
+        fTried(false)
+        {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(nDenom);
+        READWRITE(vin);
+        READWRITE(nTime);
+        READWRITE(fReady);
+        READWRITE(vchSig);
+    }
+
+    /** Sign this mixing transaction
+     *  \return true if all conditions are met:
+     *     1) we have an active Znode,
+     *     2) we have a valid Znode private key,
+     *     3) we signed the message successfully, and
+     *     4) we verified the message successfully
+     */
+    bool Sign();
+    /// Check if we have a valid Znode address
+    bool CheckSignature(const CPubKey& pubKeyZnode);
+
+    bool Relay();
+
+    /// Is this queue expired?
+    bool IsExpired() { return GetTime() - nTime > PRIVATESEND_QUEUE_TIMEOUT; }
+
+    std::string ToString()
+    {
+        return strprintf("nDenom=%d, nTime=%lld, fReady=%s, fTried=%s, znode=%s",
+                        nDenom, nTime, fReady ? "true" : "false", fTried ? "true" : "false", vin.prevout.ToStringShort());
+    }
+
+    friend bool operator==(const CDarksendQueue& a, const CDarksendQueue& b)
+    {
+        return a.nDenom == b.nDenom && a.vin.prevout == b.vin.prevout && a.nTime == b.nTime && a.fReady == b.fReady;
+    }
+};
+
+/** Helper class to store mixing transaction (tx) information.
+ */
+class CDarksendBroadcastTx
+{
+public:
+    CTransaction tx;
+    CTxIn vin;
+    std::vector<unsigned char> vchSig;
+    int64_t sigTime;
+
+    CDarksendBroadcastTx() :
+        tx(CTransaction()),
+        vin(CTxIn()),
+        vchSig(std::vector<unsigned char>()),
+        sigTime(0)
+        {}
+
+    CDarksendBroadcastTx(CTransaction tx, CTxIn vin, int64_t sigTime) :
+        tx(tx),
+        vin(vin),
+        vchSig(std::vector<unsigned char>()),
+        sigTime(sigTime)
+        {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(tx);
+        READWRITE(vin);
+        READWRITE(vchSig);
+        READWRITE(sigTime);
+    }
+
+    bool Sign();
+    bool CheckSignature(const CPubKey& pubKeyZnode);
+};
+
+/** Helper object for signing and checking signatures
+ */
+class CDarkSendSigner
+{
+public:
+    /// Is the input associated with this public key? (and there is 1000 XZC - checking if valid znode)
+    bool IsVinAssociatedWithPubkey(const CTxIn& vin, const CPubKey& pubkey);
+    /// Set the private/public key values, returns true if successful
+    bool GetKeysFromSecret(std::string strSecret, CKey& keyRet, CPubKey& pubkeyRet);
+    /// Sign the message, returns true if successful
+    bool SignMessage(std::string strMessage, std::vector<unsigned char>& vchSigRet, CKey key);
+    /// Verify the message, returns true if succcessful
+    bool VerifyMessage(CPubKey pubkey, const std::vector<unsigned char>& vchSig, std::string strMessage, std::string& strErrorRet);
+};
+
+
+/** Used to keep track of current status of mixing pool
+ */
+class CDarksendPool
+{
+private:
+    // pool responses
+    enum PoolMessage {
+        ERR_ALREADY_HAVE,
+        ERR_DENOM,
+        ERR_ENTRIES_FULL,
+        ERR_EXISTING_TX,
+        ERR_FEES,
+        ERR_INVALID_COLLATERAL,
+        ERR_INVALID_INPUT,
+        ERR_INVALID_SCRIPT,
+        ERR_INVALID_TX,
+        ERR_MAXIMUM,
+        ERR_MN_LIST,
+        ERR_MODE,
+        ERR_NON_STANDARD_PUBKEY,
+        ERR_NOT_A_MN,
+        ERR_QUEUE_FULL,
+        ERR_RECENT,
+        ERR_SESSION,
+        ERR_MISSING_TX,
+        ERR_VERSION,
+        MSG_NOERR,
+        MSG_SUCCESS,
+        MSG_ENTRIES_ADDED,
+        MSG_POOL_MIN = ERR_ALREADY_HAVE,
+        MSG_POOL_MAX = MSG_ENTRIES_ADDED
+    };
+
+    // pool states
+    enum PoolState {
+        POOL_STATE_IDLE,
+        POOL_STATE_QUEUE,
+        POOL_STATE_ACCEPTING_ENTRIES,
+        POOL_STATE_SIGNING,
+        POOL_STATE_ERROR,
+        POOL_STATE_SUCCESS,
+        POOL_STATE_MIN = POOL_STATE_IDLE,
+        POOL_STATE_MAX = POOL_STATE_SUCCESS
+    };
+
+    // status update message constants
+    enum PoolStatusUpdate {
+        STATUS_REJECTED,
+        STATUS_ACCEPTED
+    };
+
+    mutable CCriticalSection cs_darksend;
+
+    // The current mixing sessions in progress on the network
+    std::vector<CDarksendQueue> vecDarksendQueue;
+    // Keep track of the used Znodes
+    std::vector<CTxIn> vecZnodesUsed;
+
+    std::vector<CAmount> vecDenominationsSkipped;
+    std::vector<COutPoint> vecOutPointLocked;
+    // Mixing uses collateral transactions to trust parties entering the pool
+    // to behave honestly. If they don't it takes their money.
+    std::vector<CTransaction> vecSessionCollaterals;
+    std::vector<CDarkSendEntry> vecEntries; // Znode/clients entries
+
+    PoolState nState; // should be one of the POOL_STATE_XXX values
+    int64_t nTimeLastSuccessfulStep; // the time when last successful mixing step was performed, in UTC milliseconds
+
+    int nCachedLastSuccessBlock;
+    int nMinBlockSpacing; //required blocks between mixes
+    const CBlockIndex *pCurrentBlockIndex; // Keep track of current block index
+
+    int nSessionID; // 0 if no mixing session is active
+
+    int nEntriesCount;
+    bool fLastEntryAccepted;
+
+    std::string strLastMessage;
+    std::string strAutoDenomResult;
+
+    bool fUnitTest;
+
+    CMutableTransaction txMyCollateral; // client side collateral
+    CMutableTransaction finalMutableTransaction; // the finalized transaction ready for signing
+
+    /// Add a clients entry to the pool
+    bool AddEntry(const CDarkSendEntry& entryNew, PoolMessage& nMessageIDRet);
+    /// Add signature to a txin
+    bool AddScriptSig(const CTxIn& txin);
+
+    /// Charge fees to bad actors (Charge clients a fee if they're abusive)
+    void ChargeFees();
+    /// Rarely charge fees to pay miners
+    void ChargeRandomFees();
+
+    /// Check for process
+    void CheckPool();
+
+    void CreateFinalTransaction();
+    void CommitFinalTransaction();
+
+    void CompletedTransaction(PoolMessage nMessageID);
+
+    /// Get the denominations for a specific amount of dash.
+    int GetDenominationsByAmounts(const std::vector<CAmount>& vecAmount);
+
+    std::string GetMessageByID(PoolMessage nMessageID);
+
+    /// Get the maximum number of transactions for the pool
+    int GetMaxPoolTransactions() { return Params().PoolMaxTransactions(); }
+
+    /// Is this nDenom and txCollateral acceptable?
+    bool IsAcceptableDenomAndCollateral(int nDenom, CTransaction txCollateral, PoolMessage &nMessageIDRet);
+    bool CreateNewSession(int nDenom, CTransaction txCollateral, PoolMessage &nMessageIDRet);
+    bool AddUserToExistingSession(int nDenom, CTransaction txCollateral, PoolMessage &nMessageIDRet);
+    /// Do we have enough users to take entries?
+    bool IsSessionReady() { return (int)vecSessionCollaterals.size() >= GetMaxPoolTransactions(); }
+
+    /// If the collateral is valid given by a client
+    bool IsCollateralValid(const CTransaction& txCollateral);
+    /// Check that all inputs are signed. (Are all inputs signed?)
+    bool IsSignaturesComplete();
+    /// Check to make sure a given input matches an input in the pool and its scriptSig is valid
+    bool IsInputScriptSigValid(const CTxIn& txin);
+    /// Are these outputs compatible with other client in the pool?
+    bool IsOutputsCompatibleWithSessionDenom(const std::vector<CTxDSOut>& vecTxDSOut);
+
+    bool IsDenomSkipped(CAmount nDenomValue) {
+        return std::find(vecDenominationsSkipped.begin(), vecDenominationsSkipped.end(), nDenomValue) != vecDenominationsSkipped.end();
+    }
+
+    /// Create denominations
+    bool CreateDenominated();
+    bool CreateDenominated(const CompactTallyItem& tallyItem, bool fCreateMixingCollaterals);
+
+    /// Split up large inputs or make fee sized inputs
+    bool MakeCollateralAmounts();
+    bool MakeCollateralAmounts(const CompactTallyItem& tallyItem);
+
+    /// As a client, submit part of a future mixing transaction to a Znode to start the process
+    bool SubmitDenominate();
+    /// step 1: prepare denominated inputs and outputs
+    bool PrepareDenominate(int nMinRounds, int nMaxRounds, std::string& strErrorRet, std::vector<CTxIn>& vecTxInRet, std::vector<CTxOut>& vecTxOutRet);
+    /// step 2: send denominated inputs and outputs prepared in step 1
+    bool SendDenominate(const std::vector<CTxIn>& vecTxIn, const std::vector<CTxOut>& vecTxOut);
+
+    /// Get Znode updates about the progress of mixing
+    bool CheckPoolStateUpdate(PoolState nStateNew, int nEntriesCountNew, PoolStatusUpdate nStatusUpdate, PoolMessage nMessageID, int nSessionIDNew=0);
+    // Set the 'state' value, with some logging and capturing when the state changed
+    void SetState(PoolState nStateNew);
+
+    /// As a client, check and sign the final transaction
+    bool SignFinalTransaction(const CTransaction& finalTransactionNew, CNode* pnode);
+
+    /// Relay mixing Messages
+    void RelayFinalTransaction(const CTransaction& txFinal);
+    void RelaySignaturesAnon(std::vector<CTxIn>& vin);
+    void RelayInAnon(std::vector<CTxIn>& vin, std::vector<CTxOut>& vout);
+    void RelayIn(const CDarkSendEntry& entry);
+    void PushStatus(CNode* pnode, PoolStatusUpdate nStatusUpdate, PoolMessage nMessageID);
+    void RelayStatus(PoolStatusUpdate nStatusUpdate, PoolMessage nMessageID = MSG_NOERR);
+    void RelayCompletedTransaction(PoolMessage nMessageID);
+
+    void SetNull();
+
+public:
+    CZnode* pSubmittedToZnode;
+    int nSessionDenom; //Users must submit an denom matching this
+    int nCachedNumBlocks; //used for the overview screen
+    bool fCreateAutoBackups; //builtin support for automatic backups
+    CDarksendPool() :
+            nCachedLastSuccessBlock(0),
+            nMinBlockSpacing(0),
+            fUnitTest(false),
+            txMyCollateral(CMutableTransaction()),
+            nCachedNumBlocks(std::numeric_limits<int>::max()),
+            fCreateAutoBackups(true) { SetNull(); }
+
+    /** Process a mixing message using the protocol below
+     * \param pfrom
+     * \param strCommand lower case command string; valid values are:
+     *        Command  | Description
+     *        -------- | -----------------
+     *        dsa      | Acceptable
+     *        dsc      | Complete
+     *        dsf      | Final tx
+     *        dsi      | Vector of CTxIn
+     *        dsq      | Queue
+     *        dss      | Signal Final Tx
+     *        dssu     | status update
+     * \param vRecv
+     */
+    void ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
+
+    void InitDenominations();
+    void ClearSkippedDenominations() { vecDenominationsSkipped.clear(); }
+
+    /// Get the denominations for a list of outputs (returns a bitshifted integer)
+    int GetDenominations(const std::vector<CTxOut>& vecTxOut, bool fSingleRandomDenom = false);
+    int GetDenominations(const std::vector<CTxDSOut>& vecTxDSOut);
+    std::string GetDenominationsToString(int nDenom);
+    bool GetDenominationsBits(int nDenom, std::vector<int> &vecBitsRet);
+
+    void SetMinBlockSpacing(int nMinBlockSpacingIn) { nMinBlockSpacing = nMinBlockSpacingIn; }
+
+    void ResetPool();
+
+    void UnlockCoins();
+
+    int GetQueueSize() const { return vecDarksendQueue.size(); }
+    int GetState() const { return nState; }
+    std::string GetStateString() const;
+    std::string GetStatus();
+
+    int GetEntriesCount() const { return vecEntries.size(); }
+
+    /// Passively run mixing in the background according to the configuration in settings
+    bool DoAutomaticDenominating(bool fDryRun=false);
+
+    void CheckTimeout();
+    void CheckForCompleteQueue();
+
+    /// Process a new block
+    void NewBlock();
+
+    void UpdatedBlockTip(const CBlockIndex *pindex);
+};
+
+void ThreadCheckDarkSendPool();
+
+#endif
\ No newline at end of file
diff --git a/src/definition.h b/src/definition.h
index 14db923f3e..73343a10c9 100644
--- a/src/definition.h
+++ b/src/definition.h
@@ -16,7 +16,7 @@ enum {
     BLOCK_VERSION_CHAIN_START = (1 << 16),
     BLOCK_VERSION_CHAIN_END = (1 << 30),
 };
-static int64_t nStartRewardTime = 1475020800;
+static const int64_t nStartRewardTime = 1475020800;
 
 #endif //BTZC_DEFINITION_H
 
diff --git a/src/flat-database.h b/src/flat-database.h
new file mode 100644
index 0000000000..bba622a65c
--- /dev/null
+++ b/src/flat-database.h
@@ -0,0 +1,229 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef FLAT_DATABASE_H
+#define FLAT_DATABASE_H
+
+#include "chainparams.h"
+#include "clientversion.h"
+#include "hash.h"
+#include "streams.h"
+#include "util.h"
+
+#include <boost/filesystem.hpp>
+
+/** 
+*   Generic Dumping and Loading
+*   ---------------------------
+*/
+
+template<typename T>
+class CFlatDB
+{
+private:
+
+    enum ReadResult {
+        Ok,
+        FileError,
+        HashReadError,
+        IncorrectHash,
+        IncorrectMagicMessage,
+        IncorrectMagicNumber,
+        IncorrectFormat
+    };
+
+    boost::filesystem::path pathDB;
+    std::string strFilename;
+    std::string strMagicMessage;
+
+    bool Write(const T& objToSave)
+    {
+        // LOCK(objToSave.cs);
+
+        int64_t nStart = GetTimeMillis();
+
+        // serialize, checksum data up to that point, then append checksum
+        CDataStream ssObj(SER_DISK, CLIENT_VERSION);
+        ssObj << strMagicMessage; // specific magic message for this type of object
+        ssObj << FLATDATA(Params().MessageStart()); // network specific magic number
+        ssObj << objToSave;
+        uint256 hash = Hash(ssObj.begin(), ssObj.end());
+        ssObj << hash;
+
+        // open output file, and associate with CAutoFile
+        FILE *file = fopen(pathDB.string().c_str(), "wb");
+        CAutoFile fileout(file, SER_DISK, CLIENT_VERSION);
+        if (fileout.IsNull())
+            return error("%s: Failed to open file %s", __func__, pathDB.string());
+
+        // Write and commit header, data
+        try {
+            fileout << ssObj;
+        }
+        catch (std::exception &e) {
+            return error("%s: Serialize or I/O error - %s", __func__, e.what());
+        }
+        fileout.fclose();
+
+        LogPrintf("Written info to %s  %dms\n", strFilename, GetTimeMillis() - nStart);
+        LogPrintf("     %s\n", objToSave.ToString());
+
+        return true;
+    }
+
+    ReadResult Read(T& objToLoad, bool fDryRun = false)
+    {
+        //LOCK(objToLoad.cs);
+
+        int64_t nStart = GetTimeMillis();
+        // open input file, and associate with CAutoFile
+        FILE *file = fopen(pathDB.string().c_str(), "rb");
+        CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
+        if (filein.IsNull())
+        {
+            error("%s: Failed to open file %s", __func__, pathDB.string());
+            return FileError;
+        }
+
+        // use file size to size memory buffer
+        int fileSize = boost::filesystem::file_size(pathDB);
+        int dataSize = fileSize - sizeof(uint256);
+        // Don't try to resize to a negative number if file is small
+        if (dataSize < 0)
+            dataSize = 0;
+        std::vector<unsigned char> vchData;
+        vchData.resize(dataSize);
+        uint256 hashIn;
+
+        // read data and checksum from file
+        try {
+            filein.read((char *)&vchData[0], dataSize);
+            filein >> hashIn;
+        }
+        catch (std::exception &e) {
+            error("%s: Deserialize or I/O error - %s", __func__, e.what());
+            return HashReadError;
+        }
+        filein.fclose();
+
+        CDataStream ssObj(vchData, SER_DISK, CLIENT_VERSION);
+
+        // verify stored checksum matches input data
+        uint256 hashTmp = Hash(ssObj.begin(), ssObj.end());
+        if (hashIn != hashTmp)
+        {
+            error("%s: Checksum mismatch, data corrupted", __func__);
+            return IncorrectHash;
+        }
+
+
+        unsigned char pchMsgTmp[4];
+        std::string strMagicMessageTmp;
+        try {
+            // de-serialize file header (file specific magic message) and ..
+            ssObj >> strMagicMessageTmp;
+
+            // ... verify the message matches predefined one
+            if (strMagicMessage != strMagicMessageTmp)
+            {
+                error("%s: Invalid magic message", __func__);
+                return IncorrectMagicMessage;
+            }
+
+
+            // de-serialize file header (network specific magic number) and ..
+            ssObj >> FLATDATA(pchMsgTmp);
+
+            // ... verify the network matches ours
+            if (memcmp(pchMsgTmp, Params().MessageStart(), sizeof(pchMsgTmp)))
+            {
+                error("%s: Invalid network magic number", __func__);
+                return IncorrectMagicNumber;
+            }
+
+            // de-serialize data into T object
+            ssObj >> objToLoad;
+        }
+        catch (std::exception &e) {
+            objToLoad.Clear();
+            error("%s: Deserialize or I/O error - %s", __func__, e.what());
+            return IncorrectFormat;
+        }
+
+        LogPrintf("Loaded info from %s  %dms\n", strFilename, GetTimeMillis() - nStart);
+        LogPrintf("     %s\n", objToLoad.ToString());
+        if(!fDryRun) {
+            LogPrintf("%s: Cleaning....\n", __func__);
+            objToLoad.CheckAndRemove();
+            LogPrintf("     %s\n", objToLoad.ToString());
+        }
+
+        return Ok;
+    }
+
+
+public:
+    CFlatDB(std::string strFilenameIn, std::string strMagicMessageIn)
+    {
+        pathDB = GetDataDir() / strFilenameIn;
+        strFilename = strFilenameIn;
+        strMagicMessage = strMagicMessageIn;
+    }
+
+    bool Load(T& objToLoad)
+    {
+        LogPrintf("Reading info from %s...\n", strFilename);
+        ReadResult readResult = Read(objToLoad);
+        if (readResult == FileError)
+            LogPrintf("Missing file %s, will try to recreate\n", strFilename);
+        else if (readResult != Ok)
+        {
+            LogPrintf("Error reading %s: ", strFilename);
+            if(readResult == IncorrectFormat)
+            {
+                LogPrintf("%s: Magic is ok but data has invalid format, will try to recreate\n", __func__);
+            }
+            else {
+                LogPrintf("%s: File format is unknown or invalid, please fix it manually\n", __func__);
+                // program should exit with an error
+                return false;
+            }
+        }
+        return true;
+    }
+
+    bool Dump(T& objToSave)
+    {
+        int64_t nStart = GetTimeMillis();
+
+        LogPrintf("Verifying %s format...\n", strFilename);
+        T tmpObjToLoad;
+        ReadResult readResult = Read(tmpObjToLoad, true);
+
+        // there was an error and it was not an error on file opening => do not proceed
+        if (readResult == FileError)
+            LogPrintf("Missing file %s, will try to recreate\n", strFilename);
+        else if (readResult != Ok)
+        {
+            LogPrintf("Error reading %s: ", strFilename);
+            if(readResult == IncorrectFormat)
+                LogPrintf("%s: Magic is ok but data has invalid format, will try to recreate\n", __func__);
+            else
+            {
+                LogPrintf("%s: File format is unknown or invalid, please fix it manually\n", __func__);
+                return false;
+            }
+        }
+
+        LogPrintf("Writting info to %s...\n", strFilename);
+        Write(objToSave);
+        LogPrintf("%s dump finished  %dms\n", strFilename, GetTimeMillis() - nStart);
+
+        return true;
+    }
+
+};
+
+
+#endif
\ No newline at end of file
diff --git a/src/init.cpp b/src/init.cpp
index 12f270f25b..ee7199fda8 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -56,12 +56,23 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/bind.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/function.hpp>
 #include <boost/interprocess/sync/file_lock.hpp>
 #include <boost/thread.hpp>
 #include <openssl/crypto.h>
+#include "activeznode.h"
+#include "darksend.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "znodeconfig.h"
+#include "netfulfilledman.h"
+#include "flat-database.h"
+#include "instantx.h"
+#include "spork.h"
 
 #if ENABLE_ZMQ
 #include "zmq/zmqnotificationinterface.h"
@@ -746,7 +757,8 @@ void ThreadImport(std::vector <boost::filesystem::path> vImportFiles) {
     }
 
     // -loadblock=
-    BOOST_FOREACH(const boost::filesystem::path &path, vImportFiles) {
+    BOOST_FOREACH(
+    const boost::filesystem::path &path, vImportFiles) {
         FILE *file = fopen(path.string().c_str(), "rb");
         if (file) {
             LogPrintf("Importing blocks file %s...\n", path.string());
@@ -898,7 +910,6 @@ void InitLogging() {
  *  @pre Parameters should be parsed and config file should be read.
  */
 bool AppInit2(boost::thread_group &threadGroup, CScheduler &scheduler) {
-//    std::cout << "[btzc]init.cpp --> AppInit2" << std::endl;
     // ********************************************************* Step 1: setup
 #ifdef _MSC_VER
     // Turn off Microsoft heap dump noise
@@ -1348,8 +1359,7 @@ bool AppInit2(boost::thread_group &threadGroup, CScheduler &scheduler) {
     }
 
     if (mapArgs.count("-externalip")) {
-        BOOST_FOREACH(
-        const std::string &strAddr, mapMultiArgs["-externalip"]) {
+        BOOST_FOREACH(const std::string &strAddr, mapMultiArgs["-externalip"]) {
             CService addrLocal;
             if (Lookup(strAddr.c_str(), addrLocal, GetListenPort(), fNameLookup) && addrLocal.IsValid())
                 AddLocal(addrLocal, LOCAL_MANUAL);
@@ -1657,6 +1667,131 @@ bool AppInit2(boost::thread_group &threadGroup, CScheduler &scheduler) {
     GenerateBitcoins(GetBoolArg("-gen", DEFAULT_GENERATE), GetArg("-genproclimit", DEFAULT_GENERATE_THREADS),
                      chainparams);
 
+    // ********************************************************* Step 11a: setup PrivateSend
+    fZNode = GetBoolArg("-znode", false);
+
+    LogPrintf("fZNode = %s\n", fZNode);
+    LogPrintf("znodeConfig.getCount(): %s\n", znodeConfig.getCount());
+
+    if ((fZNode || znodeConfig.getCount() > 0) && !fTxIndex) {
+        return InitError("Enabling Znode support requires turning on transaction indexing."
+                                 "Please add txindex=1 to your configuration and start with -reindex");
+    }
+
+    if (fZNode) {
+        LogPrintf("ZNODE:\n");
+
+        if (!GetArg("-znodeaddr", "").empty()) {
+            // Hot Znode (either local or remote) should get its address in
+            // CActiveZnode::ManageState() automatically and no longer relies on Znodeaddr.
+            return InitError(_("znodeaddr option is deprecated. Please use znode.conf to manage your remote znodes."));
+        }
+
+        std::string strZnodePrivKey = GetArg("-znodeprivkey", "");
+        if (!strZnodePrivKey.empty()) {
+            if (!darkSendSigner.GetKeysFromSecret(strZnodePrivKey, activeZnode.keyZnode,
+                                                  activeZnode.pubKeyZnode))
+                return InitError(_("Invalid znodeprivkey. Please see documenation."));
+
+            LogPrintf("  pubKeyZnode: %s\n", CBitcoinAddress(activeZnode.pubKeyZnode.GetID()).ToString());
+        } else {
+            return InitError(
+                    _("You must specify a znodeprivkey in the configuration. Please see documentation for help."));
+        }
+    }
+
+    LogPrintf("Using Znode config file %s\n", GetZnodeConfigFile().string());
+
+    if (GetBoolArg("-znconflock", true) && pwalletMain && (znodeConfig.getCount() > 0)) {
+        LOCK(pwalletMain->cs_wallet);
+        LogPrintf("Locking Znodes:\n");
+        uint256 mnTxHash;
+        int outputIndex;
+        BOOST_FOREACH(CZnodeConfig::CZnodeEntry mne, znodeConfig.getEntries()) {
+            mnTxHash.SetHex(mne.getTxHash());
+            outputIndex = boost::lexical_cast<unsigned int>(mne.getOutputIndex());
+            COutPoint outpoint = COutPoint(mnTxHash, outputIndex);
+            // don't lock non-spendable outpoint (i.e. it's already spent or it's not from this wallet at all)
+            if (pwalletMain->IsMine(CTxIn(outpoint)) != ISMINE_SPENDABLE) {
+                LogPrintf("  %s %s - IS NOT SPENDABLE, was not locked\n", mne.getTxHash(), mne.getOutputIndex());
+                continue;
+            }
+            pwalletMain->LockCoin(outpoint);
+            LogPrintf("  %s %s - locked successfully\n", mne.getTxHash(), mne.getOutputIndex());
+        }
+    }
+
+
+    nLiquidityProvider = GetArg("-liquidityprovider", nLiquidityProvider);
+    nLiquidityProvider = std::min(std::max(nLiquidityProvider, 0), 100);
+    darkSendPool.SetMinBlockSpacing(nLiquidityProvider * 15);
+
+    fEnablePrivateSend = GetBoolArg("-enableprivatesend", 0);
+    fPrivateSendMultiSession = GetBoolArg("-privatesendmultisession", DEFAULT_PRIVATESEND_MULTISESSION);
+    nPrivateSendRounds = GetArg("-privatesendrounds", DEFAULT_PRIVATESEND_ROUNDS);
+    nPrivateSendRounds = std::min(std::max(nPrivateSendRounds, 2), nLiquidityProvider ? 99999 : 16);
+    nPrivateSendAmount = GetArg("-privatesendamount", DEFAULT_PRIVATESEND_AMOUNT);
+    nPrivateSendAmount = std::min(std::max(nPrivateSendAmount, 2), 999999);
+
+    fEnableInstantSend = GetBoolArg("-enableinstantsend", 1);
+    nInstantSendDepth = GetArg("-instantsenddepth", DEFAULT_INSTANTSEND_DEPTH);
+    nInstantSendDepth = std::min(std::max(nInstantSendDepth, 0), 60);
+
+    //lite mode disables all Znode and Darksend related functionality
+    fLiteMode = GetBoolArg("-litemode", false);
+    if (fZNode && fLiteMode) {
+        return InitError("You can not start a znode in litemode");
+    }
+
+    LogPrintf("fLiteMode %d\n", fLiteMode);
+    LogPrintf("nInstantSendDepth %d\n", nInstantSendDepth);
+    LogPrintf("PrivateSend rounds %d\n", nPrivateSendRounds);
+    LogPrintf("PrivateSend amount %d\n", nPrivateSendAmount);
+
+    darkSendPool.InitDenominations();
+
+    // ********************************************************* Step 11b: Load cache data
+
+    // LOAD SERIALIZED DAT FILES INTO DATA CACHES FOR INTERNAL USE
+
+    uiInterface.InitMessage(_("Loading znode cache..."));
+    CFlatDB<CZnodeMan> flatdb1("mncache.dat", "magicZnodeCache");
+    if (!flatdb1.Load(mnodeman)) {
+        return InitError("Failed to load znode cache from mncache.dat");
+    }
+
+    if (mnodeman.size()) {
+        uiInterface.InitMessage(_("Loading Znode payment cache..."));
+        CFlatDB<CZnodePayments> flatdb2("mnpayments.dat", "magicZnodePaymentsCache");
+        if (!flatdb2.Load(mnpayments)) {
+            return InitError("Failed to load znode payments cache from mnpayments.dat");
+        }
+    } else {
+        uiInterface.InitMessage(_("Znode cache is empty, skipping payments and governance cache..."));
+    }
+
+    uiInterface.InitMessage(_("Loading fulfilled requests cache..."));
+    CFlatDB<CNetFulfilledRequestManager> flatdb4("netfulfilled.dat", "magicFulfilledCache");
+    if (!flatdb4.Load(netfulfilledman)) {
+        return InitError("Failed to load fulfilled requests cache from netfulfilled.dat");
+    }
+
+    // ********************************************************* Step 11c: update block tip in Dash modules
+
+    // force UpdatedBlockTip to initialize pCurrentBlockIndex for DS, MN payments and budgets
+    // but don't call it directly to prevent triggering of other listeners like zmq etc.
+//    GetMainSignals().UpdatedBlockTip(chainActive.Tip());
+    mnodeman.UpdatedBlockTip(chainActive.Tip());
+    darkSendPool.UpdatedBlockTip(chainActive.Tip());
+    mnpayments.UpdatedBlockTip(chainActive.Tip());
+    znodeSync.UpdatedBlockTip(chainActive.Tip());
+//    governance.UpdatedBlockTip(chainActive.Tip());
+
+    // ********************************************************* Step 11d: start dash-privatesend thread
+
+    threadGroup.create_thread(boost::bind(&ThreadCheckDarkSendPool));
+
+
 
     // ********************************************************* Step 12: finished
 
diff --git a/src/instantx.cpp b/src/instantx.cpp
new file mode 100644
index 0000000000..47430403d5
--- /dev/null
+++ b/src/instantx.cpp
@@ -0,0 +1,1161 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "activeznode.h"
+#include "darksend.h"
+#include "instantx.h"
+#include "key.h"
+#include "main.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "net.h"
+#include "protocol.h"
+#include "spork.h"
+#include "sync.h"
+#include "txmempool.h"
+#include "util.h"
+#include "consensus/validation.h"
+
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/thread.hpp>
+
+extern CWallet* pwalletMain;
+extern CTxMemPool mempool;
+
+bool fEnableInstantSend = true;
+int nInstantSendDepth = DEFAULT_INSTANTSEND_DEPTH;
+int nCompleteTXLocks;
+
+CInstantSend instantsend;
+
+// Transaction Locks
+//
+// step 1) Some node announces intention to lock transaction inputs via "txlreg" message
+// step 2) Top COutPointLock::SIGNATURES_TOTAL znodes per each spent outpoint push "txvote" message
+// step 3) Once there are COutPointLock::SIGNATURES_REQUIRED valid "txvote" messages per each spent outpoint
+//         for a corresponding "txlreg" message, all outpoints from that tx are treated as locked
+
+//
+// CInstantSend
+//
+
+void CInstantSend::ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
+{
+    if(fLiteMode) return; // disable all Dash specific functionality
+//    if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
+
+    // Ignore any InstantSend messages until znode list is synced
+    if(!znodeSync.IsZnodeListSynced()) return;
+
+    // NOTE: NetMsgType::TXLOCKREQUEST is handled via ProcessMessage() in main.cpp
+
+//    if (strCommand == NetMsgType::TXLOCKVOTE) // InstantSend Transaction Lock Consensus Votes
+//    {
+//        if(pfrom->nVersion < MIN_INSTANTSEND_PROTO_VERSION) return;
+//
+//        CTxLockVote vote;
+//        vRecv >> vote;
+//
+//        LOCK2(cs_main, cs_instantsend);
+//
+//        uint256 nVoteHash = vote.GetHash();
+//
+//        if(mapTxLockVotes.count(nVoteHash)) return;
+//        mapTxLockVotes.insert(std::make_pair(nVoteHash, vote));
+//
+//        ProcessTxLockVote(pfrom, vote);
+//
+//        return;
+//    }
+}
+
+bool CInstantSend::ProcessTxLockRequest(const CTxLockRequest& txLockRequest)
+{
+    LOCK2(cs_main, cs_instantsend);
+
+    uint256 txHash = txLockRequest.GetHash();
+
+    // Check to see if we conflict with existing completed lock,
+    // fail if so, there can't be 2 completed locks for the same outpoint
+    BOOST_FOREACH(const CTxIn& txin, txLockRequest.vin) {
+        std::map<COutPoint, uint256>::iterator it = mapLockedOutpoints.find(txin.prevout);
+        if(it != mapLockedOutpoints.end()) {
+            // Conflicting with complete lock, ignore this one
+            // (this could be the one we have but we don't want to try to lock it twice anyway)
+            LogPrintf("CInstantSend::ProcessTxLockRequest -- WARNING: Found conflicting completed Transaction Lock, skipping current one, txid=%s, completed lock txid=%s\n",
+                    txLockRequest.GetHash().ToString(), it->second.ToString());
+            return false;
+        }
+    }
+
+    // Check to see if there are votes for conflicting request,
+    // if so - do not fail, just warn user
+    BOOST_FOREACH(const CTxIn& txin, txLockRequest.vin) {
+        std::map<COutPoint, std::set<uint256> >::iterator it = mapVotedOutpoints.find(txin.prevout);
+        if(it != mapVotedOutpoints.end()) {
+            BOOST_FOREACH(const uint256& hash, it->second) {
+                if(hash != txLockRequest.GetHash()) {
+                    LogPrint("instantsend", "CInstantSend::ProcessTxLockRequest -- Double spend attempt! %s\n", txin.prevout.ToStringShort());
+                    // do not fail here, let it go and see which one will get the votes to be locked
+                }
+            }
+        }
+    }
+
+    if(!CreateTxLockCandidate(txLockRequest)) {
+        // smth is not right
+        LogPrintf("CInstantSend::ProcessTxLockRequest -- CreateTxLockCandidate failed, txid=%s\n", txHash.ToString());
+        return false;
+    }
+    LogPrintf("CInstantSend::ProcessTxLockRequest -- accepted, txid=%s\n", txHash.ToString());
+
+    std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
+    CTxLockCandidate& txLockCandidate = itLockCandidate->second;
+    Vote(txLockCandidate);
+    ProcessOrphanTxLockVotes();
+
+    // Znodes will sometimes propagate votes before the transaction is known to the client.
+    // If this just happened - lock inputs, resolve conflicting locks, update transaction status
+    // forcing external script notification.
+    TryToFinalizeLockCandidate(txLockCandidate);
+
+    return true;
+}
+
+bool CInstantSend::CreateTxLockCandidate(const CTxLockRequest& txLockRequest)
+{
+    // Normally we should require all outpoints to be unspent, but in case we are reprocessing
+    // because of a lot of legit orphan votes we should also check already spent outpoints.
+    uint256 txHash = txLockRequest.GetHash();
+    if(!txLockRequest.IsValid(!IsEnoughOrphanVotesForTx(txLockRequest))) return false;
+
+    LOCK(cs_instantsend);
+
+    std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
+    if(itLockCandidate == mapTxLockCandidates.end()) {
+        LogPrintf("CInstantSend::CreateTxLockCandidate -- new, txid=%s\n", txHash.ToString());
+
+        CTxLockCandidate txLockCandidate(txLockRequest);
+        // all inputs should already be checked by txLockRequest.IsValid() above, just use them now
+        BOOST_REVERSE_FOREACH(const CTxIn& txin, txLockRequest.vin) {
+            txLockCandidate.AddOutPointLock(txin.prevout);
+        }
+        mapTxLockCandidates.insert(std::make_pair(txHash, txLockCandidate));
+    } else {
+        LogPrint("instantsend", "CInstantSend::CreateTxLockCandidate -- seen, txid=%s\n", txHash.ToString());
+    }
+
+    return true;
+}
+
+void CInstantSend::Vote(CTxLockCandidate& txLockCandidate)
+{
+    if(!fZNode) return;
+
+    LOCK2(cs_main, cs_instantsend);
+
+    uint256 txHash = txLockCandidate.GetHash();
+    // check if we need to vote on this candidate's outpoints,
+    // it's possible that we need to vote for several of them
+    std::map<COutPoint, COutPointLock>::iterator itOutpointLock = txLockCandidate.mapOutPointLocks.begin();
+    while(itOutpointLock != txLockCandidate.mapOutPointLocks.end()) {
+
+        int nPrevoutHeight = GetUTXOHeight(itOutpointLock->first);
+        if(nPrevoutHeight == -1) {
+            LogPrint("instantsend", "CInstantSend::Vote -- Failed to find UTXO %s\n", itOutpointLock->first.ToStringShort());
+            return;
+        }
+
+        int nLockInputHeight = nPrevoutHeight + 4;
+
+        int n = mnodeman.GetZnodeRank(activeZnode.vin, nLockInputHeight, MIN_INSTANTSEND_PROTO_VERSION);
+
+        if(n == -1) {
+            LogPrint("instantsend", "CInstantSend::Vote -- Unknown Znode %s\n", activeZnode.vin.prevout.ToStringShort());
+            ++itOutpointLock;
+            continue;
+        }
+
+        int nSignaturesTotal = COutPointLock::SIGNATURES_TOTAL;
+        if(n > nSignaturesTotal) {
+            LogPrint("instantsend", "CInstantSend::Vote -- Znode not in the top %d (%d)\n", nSignaturesTotal, n);
+            ++itOutpointLock;
+            continue;
+        }
+
+        LogPrint("instantsend", "CInstantSend::Vote -- In the top %d (%d)\n", nSignaturesTotal, n);
+
+        std::map<COutPoint, std::set<uint256> >::iterator itVoted = mapVotedOutpoints.find(itOutpointLock->first);
+
+        // Check to see if we already voted for this outpoint,
+        // refuse to vote twice or to include the same outpoint in another tx
+        bool fAlreadyVoted = false;
+        if(itVoted != mapVotedOutpoints.end()) {
+            BOOST_FOREACH(const uint256& hash, itVoted->second) {
+                std::map<uint256, CTxLockCandidate>::iterator it2 = mapTxLockCandidates.find(hash);
+                if(it2->second.HasZnodeVoted(itOutpointLock->first, activeZnode.vin.prevout)) {
+                    // we already voted for this outpoint to be included either in the same tx or in a competing one,
+                    // skip it anyway
+                    fAlreadyVoted = true;
+                    LogPrintf("CInstantSend::Vote -- WARNING: We already voted for this outpoint, skipping: txHash=%s, outpoint=%s\n",
+                            txHash.ToString(), itOutpointLock->first.ToStringShort());
+                    break;
+                }
+            }
+        }
+        if(fAlreadyVoted) {
+            ++itOutpointLock;
+            continue; // skip to the next outpoint
+        }
+
+        // we haven't voted for this outpoint yet, let's try to do this now
+        CTxLockVote vote(txHash, itOutpointLock->first, activeZnode.vin.prevout);
+
+        if(!vote.Sign()) {
+            LogPrintf("CInstantSend::Vote -- Failed to sign consensus vote\n");
+            return;
+        }
+        if(!vote.CheckSignature()) {
+            LogPrintf("CInstantSend::Vote -- Signature invalid\n");
+            return;
+        }
+
+        // vote constructed sucessfully, let's store and relay it
+        uint256 nVoteHash = vote.GetHash();
+        mapTxLockVotes.insert(std::make_pair(nVoteHash, vote));
+        if(itOutpointLock->second.AddVote(vote)) {
+            LogPrintf("CInstantSend::Vote -- Vote created successfully, relaying: txHash=%s, outpoint=%s, vote=%s\n",
+                    txHash.ToString(), itOutpointLock->first.ToStringShort(), nVoteHash.ToString());
+
+            if(itVoted == mapVotedOutpoints.end()) {
+                std::set<uint256> setHashes;
+                setHashes.insert(txHash);
+                mapVotedOutpoints.insert(std::make_pair(itOutpointLock->first, setHashes));
+            } else {
+                mapVotedOutpoints[itOutpointLock->first].insert(txHash);
+                if(mapVotedOutpoints[itOutpointLock->first].size() > 1) {
+                    // it's ok to continue, just warn user
+                    LogPrintf("CInstantSend::Vote -- WARNING: Vote conflicts with some existing votes: txHash=%s, outpoint=%s, vote=%s\n",
+                            txHash.ToString(), itOutpointLock->first.ToStringShort(), nVoteHash.ToString());
+                }
+            }
+
+            vote.Relay();
+        }
+
+        ++itOutpointLock;
+    }
+}
+
+//received a consensus vote
+bool CInstantSend::ProcessTxLockVote(CNode* pfrom, CTxLockVote& vote)
+{
+    LOCK2(cs_main, cs_instantsend);
+
+    uint256 txHash = vote.GetTxHash();
+
+    if(!vote.IsValid(pfrom)) {
+        // could be because of missing MN
+        LogPrint("instantsend", "CInstantSend::ProcessTxLockVote -- Vote is invalid, txid=%s\n", txHash.ToString());
+        return false;
+    }
+
+    // Znodes will sometimes propagate votes before the transaction is known to the client,
+    // will actually process only after the lock request itself has arrived
+
+    std::map<uint256, CTxLockCandidate>::iterator it = mapTxLockCandidates.find(txHash);
+    if(it == mapTxLockCandidates.end()) {
+        if(!mapTxLockVotesOrphan.count(vote.GetHash())) {
+            mapTxLockVotesOrphan[vote.GetHash()] = vote;
+            LogPrint("instantsend", "CInstantSend::ProcessTxLockVote -- Orphan vote: txid=%s  znode=%s new\n",
+                    txHash.ToString(), vote.GetZnodeOutpoint().ToStringShort());
+            bool fReprocess = true;
+            std::map<uint256, CTxLockRequest>::iterator itLockRequest = mapLockRequestAccepted.find(txHash);
+            if(itLockRequest == mapLockRequestAccepted.end()) {
+                itLockRequest = mapLockRequestRejected.find(txHash);
+                if(itLockRequest == mapLockRequestRejected.end()) {
+                    // still too early, wait for tx lock request
+                    fReprocess = false;
+                }
+            }
+            if(fReprocess && IsEnoughOrphanVotesForTx(itLockRequest->second)) {
+                // We have enough votes for corresponding lock to complete,
+                // tx lock request should already be received at this stage.
+                LogPrint("instantsend", "CInstantSend::ProcessTxLockVote -- Found enough orphan votes, reprocessing Transaction Lock Request: txid=%s\n", txHash.ToString());
+                ProcessTxLockRequest(itLockRequest->second);
+                return true;
+            }
+        } else {
+            LogPrint("instantsend", "CInstantSend::ProcessTxLockVote -- Orphan vote: txid=%s  znode=%s seen\n",
+                    txHash.ToString(), vote.GetZnodeOutpoint().ToStringShort());
+        }
+
+        // This tracks those messages and allows only the same rate as of the rest of the network
+        // TODO: make sure this works good enough for multi-quorum
+
+        int nZnodeOrphanExpireTime = GetTime() + 60*10; // keep time data for 10 minutes
+        if(!mapZnodeOrphanVotes.count(vote.GetZnodeOutpoint())) {
+            mapZnodeOrphanVotes[vote.GetZnodeOutpoint()] = nZnodeOrphanExpireTime;
+        } else {
+            int64_t nPrevOrphanVote = mapZnodeOrphanVotes[vote.GetZnodeOutpoint()];
+            if(nPrevOrphanVote > GetTime() && nPrevOrphanVote > GetAverageZnodeOrphanVoteTime()) {
+                LogPrint("instantsend", "CInstantSend::ProcessTxLockVote -- znode is spamming orphan Transaction Lock Votes: txid=%s  znode=%s\n",
+                        txHash.ToString(), vote.GetZnodeOutpoint().ToStringShort());
+                // Misbehaving(pfrom->id, 1);
+                return false;
+            }
+            // not spamming, refresh
+            mapZnodeOrphanVotes[vote.GetZnodeOutpoint()] = nZnodeOrphanExpireTime;
+        }
+
+        return true;
+    }
+
+    LogPrint("instantsend", "CInstantSend::ProcessTxLockVote -- Transaction Lock Vote, txid=%s\n", txHash.ToString());
+
+    std::map<COutPoint, std::set<uint256> >::iterator it1 = mapVotedOutpoints.find(vote.GetOutpoint());
+    if(it1 != mapVotedOutpoints.end()) {
+        BOOST_FOREACH(const uint256& hash, it1->second) {
+            if(hash != txHash) {
+                // same outpoint was already voted to be locked by another tx lock request,
+                // find out if the same mn voted on this outpoint before
+                std::map<uint256, CTxLockCandidate>::iterator it2 = mapTxLockCandidates.find(hash);
+                if(it2->second.HasZnodeVoted(vote.GetOutpoint(), vote.GetZnodeOutpoint())) {
+                    // yes, it did, refuse to accept a vote to include the same outpoint in another tx
+                    // from the same znode.
+                    // TODO: apply pose ban score to this znode?
+                    // NOTE: if we decide to apply pose ban score here, this vote must be relayed further
+                    // to let all other nodes know about this node's misbehaviour and let them apply
+                    // pose ban score too.
+                    LogPrintf("CInstantSend::ProcessTxLockVote -- znode sent conflicting votes! %s\n", vote.GetZnodeOutpoint().ToStringShort());
+                    return false;
+                }
+            }
+        }
+        // we have votes by other znodes only (so far), let's continue and see who will win
+        it1->second.insert(txHash);
+    } else {
+        std::set<uint256> setHashes;
+        setHashes.insert(txHash);
+        mapVotedOutpoints.insert(std::make_pair(vote.GetOutpoint(), setHashes));
+    }
+
+    CTxLockCandidate& txLockCandidate = it->second;
+
+    if(!txLockCandidate.AddVote(vote)) {
+        // this should never happen
+        return false;
+    }
+
+    int nSignatures = txLockCandidate.CountVotes();
+    int nSignaturesMax = txLockCandidate.txLockRequest.GetMaxSignatures();
+    LogPrint("instantsend", "CInstantSend::ProcessTxLockVote -- Transaction Lock signatures count: %d/%d, vote hash=%s\n",
+            nSignatures, nSignaturesMax, vote.GetHash().ToString());
+
+    TryToFinalizeLockCandidate(txLockCandidate);
+
+    vote.Relay();
+
+    return true;
+}
+
+void CInstantSend::ProcessOrphanTxLockVotes()
+{
+    LOCK2(cs_main, cs_instantsend);
+    std::map<uint256, CTxLockVote>::iterator it = mapTxLockVotesOrphan.begin();
+    while(it != mapTxLockVotesOrphan.end()) {
+        if(ProcessTxLockVote(NULL, it->second)) {
+            mapTxLockVotesOrphan.erase(it++);
+        } else {
+            ++it;
+        }
+    }
+}
+
+bool CInstantSend::IsEnoughOrphanVotesForTx(const CTxLockRequest& txLockRequest)
+{
+    // There could be a situation when we already have quite a lot of votes
+    // but tx lock request still wasn't received. Let's scan through
+    // orphan votes to check if this is the case.
+    BOOST_FOREACH(const CTxIn& txin, txLockRequest.vin) {
+        if(!IsEnoughOrphanVotesForTxAndOutPoint(txLockRequest.GetHash(), txin.prevout)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool CInstantSend::IsEnoughOrphanVotesForTxAndOutPoint(const uint256& txHash, const COutPoint& outpoint)
+{
+    // Scan orphan votes to check if this outpoint has enough orphan votes to be locked in some tx.
+    LOCK2(cs_main, cs_instantsend);
+    int nCountVotes = 0;
+    std::map<uint256, CTxLockVote>::iterator it = mapTxLockVotesOrphan.begin();
+    while(it != mapTxLockVotesOrphan.end()) {
+        if(it->second.GetTxHash() == txHash && it->second.GetOutpoint() == outpoint) {
+            nCountVotes++;
+            if(nCountVotes >= COutPointLock::SIGNATURES_REQUIRED) {
+                return true;
+            }
+        }
+        ++it;
+    }
+    return false;
+}
+
+void CInstantSend::TryToFinalizeLockCandidate(const CTxLockCandidate& txLockCandidate)
+{
+    LOCK2(cs_main, cs_instantsend);
+
+    uint256 txHash = txLockCandidate.txLockRequest.GetHash();
+    if(txLockCandidate.IsAllOutPointsReady() && !IsLockedInstantSendTransaction(txHash)) {
+        // we have enough votes now
+        LogPrint("instantsend", "CInstantSend::TryToFinalizeLockCandidate -- Transaction Lock is ready to complete, txid=%s\n", txHash.ToString());
+        if(ResolveConflicts(txLockCandidate, Params().GetConsensus().nInstantSendKeepLock)) {
+            LockTransactionInputs(txLockCandidate);
+            UpdateLockedTransaction(txLockCandidate);
+        }
+    }
+}
+
+void CInstantSend::UpdateLockedTransaction(const CTxLockCandidate& txLockCandidate)
+{
+    LOCK(cs_instantsend);
+
+    uint256 txHash = txLockCandidate.GetHash();
+
+    if(!IsLockedInstantSendTransaction(txHash)) return; // not a locked tx, do not update/notify
+
+#ifdef ENABLE_WALLET
+    if(pwalletMain) {
+        pwalletMain->UpdatedTransaction(txHash);
+        // bumping this to update UI
+        nCompleteTXLocks++;
+        // notify an external script once threshold is reached
+        std::string strCmd = GetArg("-instantsendnotify", "");
+        if(!strCmd.empty()) {
+            boost::replace_all(strCmd, "%s", txHash.GetHex());
+            boost::thread t(runCommand, strCmd); // thread runs free
+        }
+    }
+#endif
+
+//    GetMainSignals().NotifyTransactionLock(txLockCandidate.txLockRequest);
+
+    LogPrint("instantsend", "CInstantSend::UpdateLockedTransaction -- done, txid=%s\n", txHash.ToString());
+}
+
+void CInstantSend::LockTransactionInputs(const CTxLockCandidate& txLockCandidate)
+{
+    LOCK(cs_instantsend);
+
+    uint256 txHash = txLockCandidate.GetHash();
+
+    if(!txLockCandidate.IsAllOutPointsReady()) return;
+
+    std::map<COutPoint, COutPointLock>::const_iterator it = txLockCandidate.mapOutPointLocks.begin();
+
+    while(it != txLockCandidate.mapOutPointLocks.end()) {
+        mapLockedOutpoints.insert(std::make_pair(it->first, txHash));
+        ++it;
+    }
+    LogPrint("instantsend", "CInstantSend::LockTransactionInputs -- done, txid=%s\n", txHash.ToString());
+}
+
+bool CInstantSend::GetLockedOutPointTxHash(const COutPoint& outpoint, uint256& hashRet)
+{
+    LOCK(cs_instantsend);
+    std::map<COutPoint, uint256>::iterator it = mapLockedOutpoints.find(outpoint);
+    if(it == mapLockedOutpoints.end()) return false;
+    hashRet = it->second;
+    return true;
+}
+
+bool CInstantSend::ResolveConflicts(const CTxLockCandidate& txLockCandidate, int nMaxBlocks)
+{
+    if(nMaxBlocks < 1) return false;
+
+    LOCK2(cs_main, cs_instantsend);
+
+    uint256 txHash = txLockCandidate.GetHash();
+
+    // make sure the lock is ready
+    if(!txLockCandidate.IsAllOutPointsReady()) return true; // not an error
+
+    LOCK(mempool.cs); // protect mempool.mapNextTx, mempool.mapTx
+
+    bool fMempoolConflict = false;
+
+    BOOST_FOREACH(const CTxIn& txin, txLockCandidate.txLockRequest.vin) {
+        uint256 hashConflicting;
+        if(GetLockedOutPointTxHash(txin.prevout, hashConflicting) && txHash != hashConflicting) {
+            // conflicting with complete lock, ignore current one
+            LogPrintf("CInstantSend::ResolveConflicts -- WARNING: Found conflicting completed Transaction Lock, skipping current one, txid=%s, conflicting txid=%s\n",
+                    txHash.ToString(), hashConflicting.ToString());
+            return false; // can't/shouldn't do anything
+        } else if (mempool.mapNextTx.count(txin.prevout)) {
+            // check if it's in mempool
+//            hashConflicting = mempool.mapNextTx[txin.prevout].ptx->GetHash();
+            if(txHash == hashConflicting) continue; // matches current, not a conflict, skip to next txin
+            // conflicting with tx in mempool
+            fMempoolConflict = true;
+            if(HasTxLockRequest(hashConflicting)) {
+                // There can be only one completed lock, the other lock request should never complete
+                LogPrintf("CInstantSend::ResolveConflicts -- WARNING: Found conflicting Transaction Lock Request, replacing by completed Transaction Lock, txid=%s, conflicting txid=%s\n",
+                        txHash.ToString(), hashConflicting.ToString());
+            } else {
+                // If this lock is completed, we don't really care about normal conflicting txes.
+                LogPrintf("CInstantSend::ResolveConflicts -- WARNING: Found conflicting transaction, replacing by completed Transaction Lock, txid=%s, conflicting txid=%s\n",
+                        txHash.ToString(), hashConflicting.ToString());
+            }
+        }
+    } // FOREACH
+    if(fMempoolConflict) {
+        std::list<CTransaction> removed;
+        // remove every tx conflicting with current Transaction Lock Request
+        mempool.removeConflicts(txLockCandidate.txLockRequest, removed);
+        // and try to accept it in mempool again
+        CValidationState state;
+        bool fMissingInputs = false;
+        if(!AcceptToMemoryPool(mempool, state, txLockCandidate.txLockRequest, true, true, &fMissingInputs)) {
+            LogPrintf("CInstantSend::ResolveConflicts -- ERROR: Failed to accept completed Transaction Lock to mempool, txid=%s\n", txHash.ToString());
+            return false;
+        }
+        LogPrintf("CInstantSend::ResolveConflicts -- Accepted completed Transaction Lock, txid=%s\n", txHash.ToString());
+        return true;
+    }
+    // No conflicts were found so far, check to see if it was already included in block
+    CTransaction txTmp;
+    uint256 hashBlock;
+    if(GetTransaction(txHash, txTmp, Params().GetConsensus(), hashBlock, true) && hashBlock != uint256()) {
+        LogPrint("instantsend", "CInstantSend::ResolveConflicts -- Done, %s is included in block %s\n", txHash.ToString(), hashBlock.ToString());
+        return true;
+    }
+    // Not in block yet, make sure all its inputs are still unspent
+    BOOST_FOREACH(const CTxIn& txin, txLockCandidate.txLockRequest.vin) {
+        CCoins coins;
+        if(!pcoinsTip->GetCoins(txin.prevout.hash, coins) ||
+           (unsigned int)txin.prevout.n>=coins.vout.size() ||
+           coins.vout[txin.prevout.n].IsNull()) {
+            // Not in UTXO anymore? A conflicting tx was mined while we were waiting for votes.
+            // Reprocess tip to make sure tx for this lock is included.
+            LogPrintf("CTxLockRequest::ResolveConflicts -- Failed to find UTXO %s - disconnecting tip...\n", txin.prevout.ToStringShort());
+            if(!DisconnectBlocks(1)) {
+                return false;
+            }
+            // Recursively check at "new" old height. Conflicting tx should be rejected by AcceptToMemoryPool.
+            ResolveConflicts(txLockCandidate, nMaxBlocks - 1);
+            LogPrintf("CTxLockRequest::ResolveConflicts -- Failed to find UTXO %s - activating best chain...\n", txin.prevout.ToStringShort());
+            // Activate best chain, block which includes conflicting tx should be rejected by ConnectBlock.
+            CValidationState state;
+            if(!ActivateBestChain(state, Params()) || !state.IsValid()) {
+                LogPrintf("CTxLockRequest::ResolveConflicts -- ActivateBestChain failed, txid=%s\n", txin.prevout.ToStringShort());
+                return false;
+            }
+            LogPrintf("CTxLockRequest::ResolveConflicts -- Failed to find UTXO %s - fixed!\n", txin.prevout.ToStringShort());
+        }
+    }
+    LogPrint("instantsend", "CInstantSend::ResolveConflicts -- Done, txid=%s\n", txHash.ToString());
+
+    return true;
+}
+
+int64_t CInstantSend::GetAverageZnodeOrphanVoteTime()
+{
+    LOCK(cs_instantsend);
+    // NOTE: should never actually call this function when mapZnodeOrphanVotes is empty
+    if(mapZnodeOrphanVotes.empty()) return 0;
+
+    std::map<COutPoint, int64_t>::iterator it = mapZnodeOrphanVotes.begin();
+    int64_t total = 0;
+
+    while(it != mapZnodeOrphanVotes.end()) {
+        total+= it->second;
+        ++it;
+    }
+
+    return total / mapZnodeOrphanVotes.size();
+}
+
+void CInstantSend::CheckAndRemove()
+{
+    if(!pCurrentBlockIndex) return;
+
+    LOCK(cs_instantsend);
+
+    std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.begin();
+
+    // remove expired candidates
+    while(itLockCandidate != mapTxLockCandidates.end()) {
+        CTxLockCandidate &txLockCandidate = itLockCandidate->second;
+        uint256 txHash = txLockCandidate.GetHash();
+        if(txLockCandidate.IsExpired(pCurrentBlockIndex->nHeight)) {
+            LogPrintf("CInstantSend::CheckAndRemove -- Removing expired Transaction Lock Candidate: txid=%s\n", txHash.ToString());
+            std::map<COutPoint, COutPointLock>::iterator itOutpointLock = txLockCandidate.mapOutPointLocks.begin();
+            while(itOutpointLock != txLockCandidate.mapOutPointLocks.end()) {
+                mapLockedOutpoints.erase(itOutpointLock->first);
+                mapVotedOutpoints.erase(itOutpointLock->first);
+                ++itOutpointLock;
+            }
+            mapLockRequestAccepted.erase(txHash);
+            mapLockRequestRejected.erase(txHash);
+            mapTxLockCandidates.erase(itLockCandidate++);
+        } else {
+            ++itLockCandidate;
+        }
+    }
+
+    // remove expired votes
+    std::map<uint256, CTxLockVote>::iterator itVote = mapTxLockVotes.begin();
+    while(itVote != mapTxLockVotes.end()) {
+        if(itVote->second.IsExpired(pCurrentBlockIndex->nHeight)) {
+            LogPrint("instantsend", "CInstantSend::CheckAndRemove -- Removing expired vote: txid=%s  znode=%s\n",
+                    itVote->second.GetTxHash().ToString(), itVote->second.GetZnodeOutpoint().ToStringShort());
+            mapTxLockVotes.erase(itVote++);
+        } else {
+            ++itVote;
+        }
+    }
+
+    // remove expired orphan votes
+    std::map<uint256, CTxLockVote>::iterator itOrphanVote = mapTxLockVotesOrphan.begin();
+    while(itOrphanVote != mapTxLockVotesOrphan.end()) {
+        if(GetTime() - itOrphanVote->second.GetTimeCreated() > ORPHAN_VOTE_SECONDS) {
+            LogPrint("instantsend", "CInstantSend::CheckAndRemove -- Removing expired orphan vote: txid=%s  znode=%s\n",
+                    itOrphanVote->second.GetTxHash().ToString(), itOrphanVote->second.GetZnodeOutpoint().ToStringShort());
+            mapTxLockVotes.erase(itOrphanVote->first);
+            mapTxLockVotesOrphan.erase(itOrphanVote++);
+        } else {
+            ++itOrphanVote;
+        }
+    }
+
+    // remove expired znode orphan votes (DOS protection)
+    std::map<COutPoint, int64_t>::iterator itZnodeOrphan = mapZnodeOrphanVotes.begin();
+    while(itZnodeOrphan != mapZnodeOrphanVotes.end()) {
+        if(itZnodeOrphan->second < GetTime()) {
+            LogPrint("instantsend", "CInstantSend::CheckAndRemove -- Removing expired orphan znode vote: znode=%s\n",
+                    itZnodeOrphan->first.ToStringShort());
+            mapZnodeOrphanVotes.erase(itZnodeOrphan++);
+        } else {
+            ++itZnodeOrphan;
+        }
+    }
+}
+
+bool CInstantSend::AlreadyHave(const uint256& hash)
+{
+    LOCK(cs_instantsend);
+    return mapLockRequestAccepted.count(hash) ||
+            mapLockRequestRejected.count(hash) ||
+            mapTxLockVotes.count(hash);
+}
+
+void CInstantSend::AcceptLockRequest(const CTxLockRequest& txLockRequest)
+{
+    LOCK(cs_instantsend);
+    mapLockRequestAccepted.insert(make_pair(txLockRequest.GetHash(), txLockRequest));
+}
+
+void CInstantSend::RejectLockRequest(const CTxLockRequest& txLockRequest)
+{
+    LOCK(cs_instantsend);
+    mapLockRequestRejected.insert(make_pair(txLockRequest.GetHash(), txLockRequest));
+}
+
+bool CInstantSend::HasTxLockRequest(const uint256& txHash)
+{
+    CTxLockRequest txLockRequestTmp;
+    return GetTxLockRequest(txHash, txLockRequestTmp);
+}
+
+bool CInstantSend::GetTxLockRequest(const uint256& txHash, CTxLockRequest& txLockRequestRet)
+{
+    LOCK(cs_instantsend);
+
+    std::map<uint256, CTxLockCandidate>::iterator it = mapTxLockCandidates.find(txHash);
+    if(it == mapTxLockCandidates.end()) return false;
+    txLockRequestRet = it->second.txLockRequest;
+
+    return true;
+}
+
+bool CInstantSend::GetTxLockVote(const uint256& hash, CTxLockVote& txLockVoteRet)
+{
+    LOCK(cs_instantsend);
+
+    std::map<uint256, CTxLockVote>::iterator it = mapTxLockVotes.find(hash);
+    if(it == mapTxLockVotes.end()) return false;
+    txLockVoteRet = it->second;
+
+    return true;
+}
+
+bool CInstantSend::IsInstantSendReadyToLock(const uint256& txHash)
+{
+//    if(!fEnableInstantSend || fLargeWorkForkFound || fLargeWorkInvalidChainFound ||
+//        !sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return false;
+
+    LOCK(cs_instantsend);
+    // There must be a successfully verified lock request
+    // and all outputs must be locked (i.e. have enough signatures)
+    std::map<uint256, CTxLockCandidate>::iterator it = mapTxLockCandidates.find(txHash);
+    return it != mapTxLockCandidates.end() && it->second.IsAllOutPointsReady();
+}
+
+bool CInstantSend::IsLockedInstantSendTransaction(const uint256& txHash)
+{
+//    if(!fEnableInstantSend || fLargeWorkForkFound || fLargeWorkInvalidChainFound ||
+//        !sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return false;
+
+    LOCK(cs_instantsend);
+
+    // there must be a lock candidate
+    std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
+    if(itLockCandidate == mapTxLockCandidates.end()) return false;
+
+    // which should have outpoints
+    if(itLockCandidate->second.mapOutPointLocks.empty()) return false;
+
+    // and all of these outputs must be included in mapLockedOutpoints with correct hash
+    std::map<COutPoint, COutPointLock>::iterator itOutpointLock = itLockCandidate->second.mapOutPointLocks.begin();
+    while(itOutpointLock != itLockCandidate->second.mapOutPointLocks.end()) {
+        uint256 hashLocked;
+        if(!GetLockedOutPointTxHash(itOutpointLock->first, hashLocked) || hashLocked != txHash) return false;
+        ++itOutpointLock;
+    }
+
+    return true;
+}
+
+int CInstantSend::GetTransactionLockSignatures(const uint256& txHash)
+{
+    if(!fEnableInstantSend) return -1;
+//    if(fLargeWorkForkFound || fLargeWorkInvalidChainFound) return -2;
+//    if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return -3;
+
+    LOCK(cs_instantsend);
+
+    std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
+    if(itLockCandidate != mapTxLockCandidates.end()) {
+        return itLockCandidate->second.CountVotes();
+    }
+
+    return -1;
+}
+
+bool CInstantSend::IsTxLockRequestTimedOut(const uint256& txHash)
+{
+    if(!fEnableInstantSend) return false;
+
+    LOCK(cs_instantsend);
+
+    std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
+    if (itLockCandidate != mapTxLockCandidates.end()) {
+        return !itLockCandidate->second.IsAllOutPointsReady() &&
+                itLockCandidate->second.txLockRequest.IsTimedOut();
+    }
+
+    return false;
+}
+
+void CInstantSend::Relay(const uint256& txHash)
+{
+    LOCK(cs_instantsend);
+
+    std::map<uint256, CTxLockCandidate>::const_iterator itLockCandidate = mapTxLockCandidates.find(txHash);
+    if (itLockCandidate != mapTxLockCandidates.end()) {
+        itLockCandidate->second.Relay();
+    }
+}
+
+void CInstantSend::UpdatedBlockTip(const CBlockIndex *pindex)
+{
+    pCurrentBlockIndex = pindex;
+}
+
+void CInstantSend::SyncTransaction(const CTransaction& tx, const CBlock* pblock)
+{
+    // Update lock candidates and votes if corresponding tx confirmed
+    // or went from confirmed to 0-confirmed or conflicted.
+
+    if (tx.IsCoinBase()) return;
+
+    LOCK2(cs_main, cs_instantsend);
+
+    uint256 txHash = tx.GetHash();
+
+    // When tx is 0-confirmed or conflicted, pblock is NULL and nHeightNew should be set to -1
+    CBlockIndex* pblockindex = pblock ? mapBlockIndex[pblock->GetHash()] : NULL;
+    int nHeightNew = pblockindex ? pblockindex->nHeight : -1;
+
+    LogPrint("instantsend", "CInstantSend::SyncTransaction -- txid=%s nHeightNew=%d\n", txHash.ToString(), nHeightNew);
+
+    // Check lock candidates
+    std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
+    if(itLockCandidate != mapTxLockCandidates.end()) {
+        LogPrint("instantsend", "CInstantSend::SyncTransaction -- txid=%s nHeightNew=%d lock candidate updated\n",
+                txHash.ToString(), nHeightNew);
+        itLockCandidate->second.SetConfirmedHeight(nHeightNew);
+        // Loop through outpoint locks
+        std::map<COutPoint, COutPointLock>::iterator itOutpointLock = itLockCandidate->second.mapOutPointLocks.begin();
+        while(itOutpointLock != itLockCandidate->second.mapOutPointLocks.end()) {
+            // Check corresponding lock votes
+            std::vector<CTxLockVote> vVotes = itOutpointLock->second.GetVotes();
+            std::vector<CTxLockVote>::iterator itVote = vVotes.begin();
+            std::map<uint256, CTxLockVote>::iterator it;
+            while(itVote != vVotes.end()) {
+                uint256 nVoteHash = itVote->GetHash();
+                LogPrint("instantsend", "CInstantSend::SyncTransaction -- txid=%s nHeightNew=%d vote %s updated\n",
+                        txHash.ToString(), nHeightNew, nVoteHash.ToString());
+                it = mapTxLockVotes.find(nVoteHash);
+                if(it != mapTxLockVotes.end()) {
+                    it->second.SetConfirmedHeight(nHeightNew);
+                }
+                ++itVote;
+            }
+            ++itOutpointLock;
+        }
+    }
+
+    // check orphan votes
+    std::map<uint256, CTxLockVote>::iterator itOrphanVote = mapTxLockVotesOrphan.begin();
+    while(itOrphanVote != mapTxLockVotesOrphan.end()) {
+        if(itOrphanVote->second.GetTxHash() == txHash) {
+            LogPrint("instantsend", "CInstantSend::SyncTransaction -- txid=%s nHeightNew=%d vote %s updated\n",
+                    txHash.ToString(), nHeightNew, itOrphanVote->first.ToString());
+            mapTxLockVotes[itOrphanVote->first].SetConfirmedHeight(nHeightNew);
+        }
+        ++itOrphanVote;
+    }
+}
+
+//
+// CTxLockRequest
+//
+
+bool CTxLockRequest::IsValid(bool fRequireUnspent) const
+{
+    if(vout.size() < 1) return false;
+
+    if(vin.size() > WARN_MANY_INPUTS) {
+        LogPrint("instantsend", "CTxLockRequest::IsValid -- WARNING: Too many inputs: tx=%s", ToString());
+    }
+
+    LOCK(cs_main);
+    if(!CheckFinalTx(*this)) {
+        LogPrint("instantsend", "CTxLockRequest::IsValid -- Transaction is not final: tx=%s", ToString());
+        return false;
+    }
+
+    CAmount nValueIn = 0;
+    CAmount nValueOut = 0;
+
+    BOOST_FOREACH(const CTxOut& txout, vout) {
+        // InstantSend supports normal scripts and unspendable (i.e. data) scripts.
+        // TODO: Look into other script types that are normal and can be included
+        if(!txout.scriptPubKey.IsNormalPaymentScript() && !txout.scriptPubKey.IsUnspendable()) {
+            LogPrint("instantsend", "CTxLockRequest::IsValid -- Invalid Script %s", ToString());
+            return false;
+        }
+        nValueOut += txout.nValue;
+    }
+
+    BOOST_FOREACH(const CTxIn& txin, vin) {
+
+        CCoins coins;
+        int nPrevoutHeight = 0;
+        CAmount nValue = 0;
+
+        if(!pcoinsTip->GetCoins(txin.prevout.hash, coins) ||
+           (unsigned int)txin.prevout.n>=coins.vout.size() ||
+           coins.vout[txin.prevout.n].IsNull()) {
+            LogPrint("instantsend", "CTxLockRequest::IsValid -- Failed to find UTXO %s\n", txin.prevout.ToStringShort());
+            // Normally above sould be enough, but in case we are reprocessing this because of
+            // a lot of legit orphan votes we should also check already spent outpoints.
+            if(fRequireUnspent) return false;
+            CTransaction txOutpointCreated;
+            uint256 nHashOutpointConfirmed;
+            if(!GetTransaction(txin.prevout.hash, txOutpointCreated, Params().GetConsensus(), nHashOutpointConfirmed, true) || nHashOutpointConfirmed == uint256()) {
+                LogPrint("instantsend", "CTxLockRequest::IsValid -- Failed to find outpoint %s\n", txin.prevout.ToStringShort());
+                return false;
+            }
+            if(txin.prevout.n >= txOutpointCreated.vout.size()) {
+                LogPrint("instantsend", "CTxLockRequest::IsValid -- Outpoint %s is out of bounds, size() = %lld\n",
+                        txin.prevout.ToStringShort(), txOutpointCreated.vout.size());
+                return false;
+            }
+            BlockMap::iterator mi = mapBlockIndex.find(nHashOutpointConfirmed);
+            if(mi == mapBlockIndex.end() || !mi->second) {
+                // shouldn't happen
+                LogPrint("instantsend", "CTxLockRequest::IsValid -- Failed to find block %s for outpoint %s\n",
+                        nHashOutpointConfirmed.ToString(), txin.prevout.ToStringShort());
+                return false;
+            }
+            nPrevoutHeight = mi->second->nHeight;
+            nValue = txOutpointCreated.vout[txin.prevout.n].nValue;
+        } else {
+            nPrevoutHeight = coins.nHeight;
+            nValue = coins.vout[txin.prevout.n].nValue;
+        }
+
+        int nTxAge = chainActive.Height() - nPrevoutHeight + 1;
+        // 1 less than the "send IX" gui requires, in case of a block propagating the network at the time
+        int nConfirmationsRequired = INSTANTSEND_CONFIRMATIONS_REQUIRED - 1;
+
+        if(nTxAge < nConfirmationsRequired) {
+            LogPrint("instantsend", "CTxLockRequest::IsValid -- outpoint %s too new: nTxAge=%d, nConfirmationsRequired=%d, txid=%s\n",
+                    txin.prevout.ToStringShort(), nTxAge, nConfirmationsRequired, GetHash().ToString());
+            return false;
+        }
+
+        nValueIn += nValue;
+    }
+
+//    if(nValueOut > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {
+//        LogPrint("instantsend", "CTxLockRequest::IsValid -- Transaction value too high: nValueOut=%d, tx=%s", nValueOut, ToString());
+//        return false;
+//    }
+
+    if(nValueIn - nValueOut < GetMinFee()) {
+        LogPrint("instantsend", "CTxLockRequest::IsValid -- did not include enough fees in transaction: fees=%d, tx=%s", nValueOut - nValueIn, ToString());
+        return false;
+    }
+
+    return true;
+}
+
+CAmount CTxLockRequest::GetMinFee() const
+{
+    CAmount nMinFee = MIN_FEE;
+    return std::max(nMinFee, CAmount(vin.size() * nMinFee));
+}
+
+int CTxLockRequest::GetMaxSignatures() const
+{
+    return vin.size() * COutPointLock::SIGNATURES_TOTAL;
+}
+
+bool CTxLockRequest::IsTimedOut() const
+{
+    return GetTime() - nTimeCreated > TIMEOUT_SECONDS;
+}
+
+//
+// CTxLockVote
+//
+
+bool CTxLockVote::IsValid(CNode* pnode) const
+{
+    if(!mnodeman.Has(CTxIn(outpointZnode))) {
+        LogPrint("instantsend", "CTxLockVote::IsValid -- Unknown znode %s\n", outpointZnode.ToStringShort());
+        mnodeman.AskForMN(pnode, CTxIn(outpointZnode));
+        return false;
+    }
+
+    int nPrevoutHeight = GetUTXOHeight(outpoint);
+    if(nPrevoutHeight == -1) {
+        LogPrint("instantsend", "CTxLockVote::IsValid -- Failed to find UTXO %s\n", outpoint.ToStringShort());
+        // Validating utxo set is not enough, votes can arrive after outpoint was already spent,
+        // if lock request was mined. We should process them too to count them later if they are legit.
+        CTransaction txOutpointCreated;
+        uint256 nHashOutpointConfirmed;
+        if(!GetTransaction(outpoint.hash, txOutpointCreated, Params().GetConsensus(), nHashOutpointConfirmed, true) || nHashOutpointConfirmed == uint256()) {
+            LogPrint("instantsend", "CTxLockVote::IsValid -- Failed to find outpoint %s\n", outpoint.ToStringShort());
+            return false;
+        }
+        LOCK(cs_main);
+        BlockMap::iterator mi = mapBlockIndex.find(nHashOutpointConfirmed);
+        if(mi == mapBlockIndex.end() || !mi->second) {
+            // not on this chain?
+            LogPrint("instantsend", "CTxLockVote::IsValid -- Failed to find block %s for outpoint %s\n", nHashOutpointConfirmed.ToString(), outpoint.ToStringShort());
+            return false;
+        }
+        nPrevoutHeight = mi->second->nHeight;
+    }
+
+    int nLockInputHeight = nPrevoutHeight + 4;
+
+    int n = mnodeman.GetZnodeRank(CTxIn(outpointZnode), nLockInputHeight, MIN_INSTANTSEND_PROTO_VERSION);
+
+    if(n == -1) {
+        //can be caused by past versions trying to vote with an invalid protocol
+        LogPrint("instantsend", "CTxLockVote::IsValid -- Outdated znode %s\n", outpointZnode.ToStringShort());
+        return false;
+    }
+    LogPrint("instantsend", "CTxLockVote::IsValid -- Znode %s, rank=%d\n", outpointZnode.ToStringShort(), n);
+
+    int nSignaturesTotal = COutPointLock::SIGNATURES_TOTAL;
+    if(n > nSignaturesTotal) {
+        LogPrint("instantsend", "CTxLockVote::IsValid -- Znode %s is not in the top %d (%d), vote hash=%s\n",
+                outpointZnode.ToStringShort(), nSignaturesTotal, n, GetHash().ToString());
+        return false;
+    }
+
+    if(!CheckSignature()) {
+        LogPrintf("CTxLockVote::IsValid -- Signature invalid\n");
+        return false;
+    }
+
+    return true;
+}
+
+uint256 CTxLockVote::GetHash() const
+{
+    CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+    ss << txHash;
+    ss << outpoint;
+    ss << outpointZnode;
+    return ss.GetHash();
+}
+
+bool CTxLockVote::CheckSignature() const
+{
+    std::string strError;
+    std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
+
+    znode_info_t infoMn = mnodeman.GetZnodeInfo(CTxIn(outpointZnode));
+
+    if(!infoMn.fInfoValid) {
+        LogPrintf("CTxLockVote::CheckSignature -- Unknown Znode: znode=%s\n", outpointZnode.ToString());
+        return false;
+    }
+
+    if(!darkSendSigner.VerifyMessage(infoMn.pubKeyZnode, vchZnodeSignature, strMessage, strError)) {
+        LogPrintf("CTxLockVote::CheckSignature -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+bool CTxLockVote::Sign()
+{
+    std::string strError;
+    std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
+
+    if(!darkSendSigner.SignMessage(strMessage, vchZnodeSignature, activeZnode.keyZnode)) {
+        LogPrintf("CTxLockVote::Sign -- SignMessage() failed\n");
+        return false;
+    }
+
+    if(!darkSendSigner.VerifyMessage(activeZnode.pubKeyZnode, vchZnodeSignature, strMessage, strError)) {
+        LogPrintf("CTxLockVote::Sign -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+void CTxLockVote::Relay() const
+{
+//    CInv inv(MSG_TXLOCK_VOTE, GetHash());
+//    RelayInv(inv);
+}
+
+bool CTxLockVote::IsExpired(int nHeight) const
+{
+    // Locks and votes expire nInstantSendKeepLock blocks after the block corresponding tx was included into.
+    return (nConfirmedHeight != -1) && (nHeight - nConfirmedHeight > Params().GetConsensus().nInstantSendKeepLock);
+}
+
+//
+// COutPointLock
+//
+
+bool COutPointLock::AddVote(const CTxLockVote& vote)
+{
+    if(mapZnodeVotes.count(vote.GetZnodeOutpoint()))
+        return false;
+    mapZnodeVotes.insert(std::make_pair(vote.GetZnodeOutpoint(), vote));
+    return true;
+}
+
+std::vector<CTxLockVote> COutPointLock::GetVotes() const
+{
+    std::vector<CTxLockVote> vRet;
+    std::map<COutPoint, CTxLockVote>::const_iterator itVote = mapZnodeVotes.begin();
+    while(itVote != mapZnodeVotes.end()) {
+        vRet.push_back(itVote->second);
+        ++itVote;
+    }
+    return vRet;
+}
+
+bool COutPointLock::HasZnodeVoted(const COutPoint& outpointZnodeIn) const
+{
+    return mapZnodeVotes.count(outpointZnodeIn);
+}
+
+void COutPointLock::Relay() const
+{
+    std::map<COutPoint, CTxLockVote>::const_iterator itVote = mapZnodeVotes.begin();
+    while(itVote != mapZnodeVotes.end()) {
+        itVote->second.Relay();
+        ++itVote;
+    }
+}
+
+//
+// CTxLockCandidate
+//
+
+void CTxLockCandidate::AddOutPointLock(const COutPoint& outpoint)
+{
+    mapOutPointLocks.insert(make_pair(outpoint, COutPointLock(outpoint)));
+}
+
+
+bool CTxLockCandidate::AddVote(const CTxLockVote& vote)
+{
+    std::map<COutPoint, COutPointLock>::iterator it = mapOutPointLocks.find(vote.GetOutpoint());
+    if(it == mapOutPointLocks.end()) return false;
+    return it->second.AddVote(vote);
+}
+
+bool CTxLockCandidate::IsAllOutPointsReady() const
+{
+    if(mapOutPointLocks.empty()) return false;
+
+    std::map<COutPoint, COutPointLock>::const_iterator it = mapOutPointLocks.begin();
+    while(it != mapOutPointLocks.end()) {
+        if(!it->second.IsReady()) return false;
+        ++it;
+    }
+    return true;
+}
+
+bool CTxLockCandidate::HasZnodeVoted(const COutPoint& outpointIn, const COutPoint& outpointZnodeIn)
+{
+    std::map<COutPoint, COutPointLock>::iterator it = mapOutPointLocks.find(outpointIn);
+    return it !=mapOutPointLocks.end() && it->second.HasZnodeVoted(outpointZnodeIn);
+}
+
+int CTxLockCandidate::CountVotes() const
+{
+    // Note: do NOT use vote count to figure out if tx is locked, use IsAllOutPointsReady() instead
+    int nCountVotes = 0;
+    std::map<COutPoint, COutPointLock>::const_iterator it = mapOutPointLocks.begin();
+    while(it != mapOutPointLocks.end()) {
+        nCountVotes += it->second.CountVotes();
+        ++it;
+    }
+    return nCountVotes;
+}
+
+bool CTxLockCandidate::IsExpired(int nHeight) const
+{
+    // Locks and votes expire nInstantSendKeepLock blocks after the block corresponding tx was included into.
+    return (nConfirmedHeight != -1) && (nHeight - nConfirmedHeight > Params().GetConsensus().nInstantSendKeepLock);
+}
+
+void CTxLockCandidate::Relay() const
+{
+    RelayTransaction(txLockRequest);
+    std::map<COutPoint, COutPointLock>::const_iterator itOutpointLock = mapOutPointLocks.begin();
+    while(itOutpointLock != mapOutPointLocks.end()) {
+        itOutpointLock->second.Relay();
+        ++itOutpointLock;
+    }
+}
diff --git a/src/instantx.h b/src/instantx.h
new file mode 100644
index 0000000000..886c65b4fc
--- /dev/null
+++ b/src/instantx.h
@@ -0,0 +1,249 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#ifndef INSTANTX_H
+#define INSTANTX_H
+
+#include "net.h"
+#include "primitives/transaction.h"
+
+class CTxLockVote;
+class COutPointLock;
+class CTxLockRequest;
+class CTxLockCandidate;
+class CInstantSend;
+
+extern CInstantSend instantsend;
+
+/*
+    At 15 signatures, 1/2 of the znode network can be owned by
+    one party without comprimising the security of InstantSend
+    (1000/2150.0)**10 = 0.00047382219560689856
+    (1000/2900.0)**10 = 2.3769498616783657e-05
+
+    ### getting 5 of 10 signatures w/ 1000 nodes of 2900
+    (1000/2900.0)**5 = 0.004875397277841433
+*/
+static const int INSTANTSEND_CONFIRMATIONS_REQUIRED = 6;
+static const int DEFAULT_INSTANTSEND_DEPTH          = 5;
+
+static const int MIN_INSTANTSEND_PROTO_VERSION      = 70206;
+
+extern bool fEnableInstantSend;
+extern int nInstantSendDepth;
+extern int nCompleteTXLocks;
+
+class CInstantSend
+{
+private:
+    static const int ORPHAN_VOTE_SECONDS            = 60;
+
+    // Keep track of current block index
+    const CBlockIndex *pCurrentBlockIndex;
+
+    // maps for AlreadyHave
+    std::map<uint256, CTxLockRequest> mapLockRequestAccepted; // tx hash - tx
+    std::map<uint256, CTxLockRequest> mapLockRequestRejected; // tx hash - tx
+    std::map<uint256, CTxLockVote> mapTxLockVotes; // vote hash - vote
+    std::map<uint256, CTxLockVote> mapTxLockVotesOrphan; // vote hash - vote
+
+    std::map<uint256, CTxLockCandidate> mapTxLockCandidates; // tx hash - lock candidate
+
+    std::map<COutPoint, std::set<uint256> > mapVotedOutpoints; // utxo - tx hash set
+    std::map<COutPoint, uint256> mapLockedOutpoints; // utxo - tx hash
+
+    //track znodes who voted with no txreq (for DOS protection)
+    std::map<COutPoint, int64_t> mapZnodeOrphanVotes; // mn outpoint - time
+
+    bool CreateTxLockCandidate(const CTxLockRequest& txLockRequest);
+    void Vote(CTxLockCandidate& txLockCandidate);
+
+    //process consensus vote message
+    bool ProcessTxLockVote(CNode* pfrom, CTxLockVote& vote);
+    void ProcessOrphanTxLockVotes();
+    bool IsEnoughOrphanVotesForTx(const CTxLockRequest& txLockRequest);
+    bool IsEnoughOrphanVotesForTxAndOutPoint(const uint256& txHash, const COutPoint& outpoint);
+    int64_t GetAverageZnodeOrphanVoteTime();
+
+    void TryToFinalizeLockCandidate(const CTxLockCandidate& txLockCandidate);
+    void LockTransactionInputs(const CTxLockCandidate& txLockCandidate);
+    //update UI and notify external script if any
+    void UpdateLockedTransaction(const CTxLockCandidate& txLockCandidate);
+    bool ResolveConflicts(const CTxLockCandidate& txLockCandidate, int nMaxBlocks);
+
+    bool IsInstantSendReadyToLock(const uint256 &txHash);
+
+public:
+    CCriticalSection cs_instantsend;
+
+    void ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
+
+    bool ProcessTxLockRequest(const CTxLockRequest& txLockRequest);
+
+    bool AlreadyHave(const uint256& hash);
+
+    void AcceptLockRequest(const CTxLockRequest& txLockRequest);
+    void RejectLockRequest(const CTxLockRequest& txLockRequest);
+    bool HasTxLockRequest(const uint256& txHash);
+    bool GetTxLockRequest(const uint256& txHash, CTxLockRequest& txLockRequestRet);
+
+    bool GetTxLockVote(const uint256& hash, CTxLockVote& txLockVoteRet);
+
+    bool GetLockedOutPointTxHash(const COutPoint& outpoint, uint256& hashRet);
+
+    // verify if transaction is currently locked
+    bool IsLockedInstantSendTransaction(const uint256& txHash);
+    // get the actual uber og accepted lock signatures
+    int GetTransactionLockSignatures(const uint256& txHash);
+
+    // remove expired entries from maps
+    void CheckAndRemove();
+    // verify if transaction lock timed out
+    bool IsTxLockRequestTimedOut(const uint256& txHash);
+
+    void Relay(const uint256& txHash);
+
+    void UpdatedBlockTip(const CBlockIndex *pindex);
+    void SyncTransaction(const CTransaction& tx, const CBlock* pblock);
+};
+
+class CTxLockRequest : public CTransaction
+{
+private:
+    static const int TIMEOUT_SECONDS        = 5 * 60;
+    static const CAmount MIN_FEE            = 0.001 * COIN;
+
+    int64_t nTimeCreated;
+
+public:
+    static const int WARN_MANY_INPUTS       = 100;
+
+    CTxLockRequest() :
+        CTransaction(),
+        nTimeCreated(GetTime())
+        {}
+    CTxLockRequest(const CTransaction& tx) :
+        CTransaction(tx),
+        nTimeCreated(GetTime())
+        {}
+
+    bool IsValid(bool fRequireUnspent = true) const;
+    CAmount GetMinFee() const;
+    int GetMaxSignatures() const;
+    bool IsTimedOut() const;
+};
+
+class CTxLockVote
+{
+private:
+    uint256 txHash;
+    COutPoint outpoint;
+    COutPoint outpointZnode;
+    std::vector<unsigned char> vchZnodeSignature;
+    // local memory only
+    int nConfirmedHeight; // when corresponding tx is 0-confirmed or conflicted, nConfirmedHeight is -1
+    int64_t nTimeCreated;
+
+public:
+    CTxLockVote() :
+        txHash(),
+        outpoint(),
+        outpointZnode(),
+        vchZnodeSignature(),
+        nConfirmedHeight(-1),
+        nTimeCreated(GetTime())
+        {}
+
+    CTxLockVote(const uint256& txHashIn, const COutPoint& outpointIn, const COutPoint& outpointZnodeIn) :
+        txHash(txHashIn),
+        outpoint(outpointIn),
+        outpointZnode(outpointZnodeIn),
+        vchZnodeSignature(),
+        nConfirmedHeight(-1),
+        nTimeCreated(GetTime())
+        {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(txHash);
+        READWRITE(outpoint);
+        READWRITE(outpointZnode);
+        READWRITE(vchZnodeSignature);
+    }
+
+    uint256 GetHash() const;
+
+    uint256 GetTxHash() const { return txHash; }
+    COutPoint GetOutpoint() const { return outpoint; }
+    COutPoint GetZnodeOutpoint() const { return outpointZnode; }
+    int64_t GetTimeCreated() const { return nTimeCreated; }
+
+    bool IsValid(CNode* pnode) const;
+    void SetConfirmedHeight(int nConfirmedHeightIn) { nConfirmedHeight = nConfirmedHeightIn; }
+    bool IsExpired(int nHeight) const;
+
+    bool Sign();
+    bool CheckSignature() const;
+
+    void Relay() const;
+};
+
+class COutPointLock
+{
+private:
+    COutPoint outpoint; // utxo
+    std::map<COutPoint, CTxLockVote> mapZnodeVotes; // znode outpoint - vote
+
+public:
+    static const int SIGNATURES_REQUIRED        = 6;
+    static const int SIGNATURES_TOTAL           = 10;
+
+    COutPointLock(const COutPoint& outpointIn) :
+        outpoint(outpointIn),
+        mapZnodeVotes()
+        {}
+
+    COutPoint GetOutpoint() const { return outpoint; }
+
+    bool AddVote(const CTxLockVote& vote);
+    std::vector<CTxLockVote> GetVotes() const;
+    bool HasZnodeVoted(const COutPoint& outpointZnodeIn) const;
+    int CountVotes() const { return mapZnodeVotes.size(); }
+    bool IsReady() const { return CountVotes() >= SIGNATURES_REQUIRED; }
+
+    void Relay() const;
+};
+
+class CTxLockCandidate
+{
+private:
+    int nConfirmedHeight; // when corresponding tx is 0-confirmed or conflicted, nConfirmedHeight is -1
+
+public:
+    CTxLockCandidate(const CTxLockRequest& txLockRequestIn) :
+        nConfirmedHeight(-1),
+        txLockRequest(txLockRequestIn),
+        mapOutPointLocks()
+        {}
+
+    CTxLockRequest txLockRequest;
+    std::map<COutPoint, COutPointLock> mapOutPointLocks;
+
+    uint256 GetHash() const { return txLockRequest.GetHash(); }
+
+    void AddOutPointLock(const COutPoint& outpoint);
+    bool AddVote(const CTxLockVote& vote);
+    bool IsAllOutPointsReady() const;
+
+    bool HasZnodeVoted(const COutPoint& outpointIn, const COutPoint& outpointZnodeIn);
+    int CountVotes() const;
+
+    void SetConfirmedHeight(int nConfirmedHeightIn) { nConfirmedHeight = nConfirmedHeightIn; }
+    bool IsExpired(int nHeight) const;
+
+    void Relay() const;
+};
+
+#endif
diff --git a/src/libzerocoin/Coin.cpp b/src/libzerocoin/Coin.cpp
index 64078aaac4..c9a476a67a 100755
--- a/src/libzerocoin/Coin.cpp
+++ b/src/libzerocoin/Coin.cpp
@@ -80,7 +80,7 @@ PrivateCoin::PrivateCoin(const Params* p, const CoinDenomination denomination):
 	// Mint a new coin with a random serial number using the standard process.
 	this->mintCoin(denomination);
 #endif
-	
+
 }
 
 /**
@@ -99,7 +99,7 @@ const unsigned char* PrivateCoin::getEcdsaSeckey() const {
      return this->ecdsaSeckey;
 }
 
-const unsigned int PrivateCoin::getVersion() const {
+unsigned int PrivateCoin::getVersion() const {
      return this->version;
 }
 
@@ -171,7 +171,6 @@ void PrivateCoin::mintCoin(const CoinDenomination denomination) {
 }
 
 void PrivateCoin::mintCoinFast(const CoinDenomination denomination) {
-	
 	Bignum s;
 
 	if(this->version == 2) {
@@ -203,14 +202,14 @@ void PrivateCoin::mintCoinFast(const CoinDenomination denomination) {
 		// "q" is the order of the commitment group.
 		s = Bignum::randBignum(this->params->coinCommitmentGroup.groupOrder);
 	}
-	
+
 	// Generate a random number "r" in the range 0...{q-1}
 	Bignum r = Bignum::randBignum(this->params->coinCommitmentGroup.groupOrder);
-	
+
 	// Manually compute a Pedersen commitment to the serial number "s" under randomness "r"
 	// C = g^s * h^r mod p
 	Bignum commitmentValue = this->params->coinCommitmentGroup.g.pow_mod(s, this->params->coinCommitmentGroup.modulus).mul_mod(this->params->coinCommitmentGroup.h.pow_mod(r, this->params->coinCommitmentGroup.modulus), this->params->coinCommitmentGroup.modulus);
-	
+
 	// Repeat this process up to MAX_COINMINT_ATTEMPTS times until
 	// we obtain a prime number
 	for (uint32_t attempt = 0; attempt < MAX_COINMINT_ATTEMPTS; attempt++) {
@@ -224,11 +223,11 @@ void PrivateCoin::mintCoinFast(const CoinDenomination denomination) {
 			this->serialNumber = s;
 			this->randomness = r;
 			this->publicCoin = PublicCoin(params, commitmentValue, denomination);
-				
+
 			// Success! We're done.
 			return;
 		}
-		
+
 		// Generate a new random "r_delta" in 0...{q-1}
 		Bignum r_delta = Bignum::randBignum(this->params->coinCommitmentGroup.groupOrder);
 
@@ -238,12 +237,12 @@ void PrivateCoin::mintCoinFast(const CoinDenomination denomination) {
 		r = (r + r_delta) % this->params->coinCommitmentGroup.groupOrder;
 		commitmentValue = commitmentValue.mul_mod(this->params->coinCommitmentGroup.h.pow_mod(r_delta, this->params->coinCommitmentGroup.modulus), this->params->coinCommitmentGroup.modulus);
 	}
-		
+
 	// We only get here if we did not find a coin within
 	// MAX_COINMINT_ATTEMPTS. Throw an exception.
 	throw ZerocoinException("Unable to mint a new Zerocoin (too many attempts)");
 }
-	
+
 const PublicCoin& PrivateCoin::getPublicCoin() const {
 	return this->publicCoin;
 }
diff --git a/src/libzerocoin/Coin.h b/src/libzerocoin/Coin.h
index c235a630b7..4d24a44b33 100755
--- a/src/libzerocoin/Coin.h
+++ b/src/libzerocoin/Coin.h
@@ -101,7 +101,7 @@ class PrivateCoin {
     const Bignum& getSerialNumber() const;
     const Bignum& getRandomness() const;
     const unsigned char* getEcdsaSeckey() const;
-    const unsigned int getVersion() const;
+    unsigned int getVersion() const;
     static const Bignum serialNumberFromSerializedPublicKey(const std::vector<unsigned char> &pub);
 
     void setPublicCoin(PublicCoin p){
diff --git a/src/libzerocoin/ParallelTasks.cpp b/src/libzerocoin/ParallelTasks.cpp
new file mode 100644
index 0000000000..668357aa57
--- /dev/null
+++ b/src/libzerocoin/ParallelTasks.cpp
@@ -0,0 +1,118 @@
+#include "Zerocoin.h"
+#include "ParallelTasks.h"
+
+#include <thread>
+#include <functional>
+#include <future>
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+#include <vector>
+
+using namespace std;
+namespace libzerocoin {
+
+#ifdef ZEROCOIN_THREADING
+
+// Simple thread pool class for using multiple cores effeciently
+
+static class ParallelOpThreadPool {
+private:
+    vector<thread>                threads;
+    queue<packaged_task<void()>>  taskQueue;
+    mutex                         taskQueueMutex;
+    condition_variable            taskQueueCondition;
+
+    bool                          shutdown;
+
+    void StartThreads() {
+        int nHardwareThreads = thread::hardware_concurrency();
+
+        auto threadProc = [this]() {
+            for (;;) {
+                packaged_task<void()> job;
+                {
+                    unique_lock<mutex> lock(taskQueueMutex);
+
+                    taskQueueCondition.wait(lock, [this]{return !taskQueue.empty() || shutdown; });
+                    if (taskQueue.empty())
+                        break;
+                    job = move(taskQueue.front());
+                    taskQueue.pop();
+                }
+                job();
+            }
+        };
+
+        for (int i=0; i<nHardwareThreads; i++)
+            threads.emplace_back(threadProc);
+    }
+
+public:
+    ParallelOpThreadPool() : shutdown(false) {}
+
+    ~ParallelOpThreadPool() {
+        taskQueueMutex.lock();
+        shutdown = true;
+        taskQueueCondition.notify_all();
+        taskQueueMutex.unlock();
+
+        for (thread &t: threads)
+            t.join();
+    }
+
+    // Post a task to the thread pool and return a future to wait for its completion
+    future<void> PostTask(function<void()> task) {
+        packaged_task<void()> packagedTask(move(task));
+        future<void> ret = packagedTask.get_future();
+
+        taskQueueMutex.lock();
+
+        // lazy start threads on first request
+        if (threads.size() == 0)
+            StartThreads();
+
+        taskQueue.emplace(move(packagedTask));
+        taskQueueCondition.notify_one();
+
+        taskQueueMutex.unlock();
+
+        return ret;
+    }
+
+} s_parallelOpThreadPool;
+
+#else
+
+static class ParallelOpThreadPool {
+public:
+    future<void> PostTask(function<void()> task) {
+        task();
+        promise<void> promise;
+        promise.set_value();
+        return promise.get_future();
+    }
+} s_parallelOpThreadPool;
+
+#endif
+
+// High level API to create number of parallel tasks and wait for completion
+
+ParallelTasks::ParallelTasks(int n) {
+    tasks.reserve(n);
+}
+
+void ParallelTasks::Add(function<void()> task) {
+    tasks.push_back(s_parallelOpThreadPool.PostTask(task));
+}
+
+void ParallelTasks::Wait() {
+    for (future<void> &f: tasks)
+        f.get();
+}
+
+void ParallelTasks::Reset() {
+    tasks.clear();
+}
+
+} // namespace libzerocoin
diff --git a/src/libzerocoin/ParallelTasks.h b/src/libzerocoin/ParallelTasks.h
new file mode 100644
index 0000000000..a58a91c567
--- /dev/null
+++ b/src/libzerocoin/ParallelTasks.h
@@ -0,0 +1,29 @@
+#ifndef PARALLELTASKS_H
+#define PARALLELTASKS_H
+
+#include <vector>
+#include <future>
+#include <functional>
+
+namespace libzerocoin {
+
+class ParallelTasks {
+private:
+    vector<std::future<void>> tasks;
+
+public:
+    ParallelTasks(int n=0);
+
+    // add new task
+    void Add(std::function<void()> task);
+
+    // wait for everything added so far
+    void Wait();
+
+    // clear all the tasks from the waiting list
+    void Reset();
+};
+
+}
+
+#endif // PARALLELTASKS_H
diff --git a/src/libzerocoin/SerialNumberSignatureOfKnowledge.cpp b/src/libzerocoin/SerialNumberSignatureOfKnowledge.cpp
index 3d80c9ce97..67f47fe358 100755
--- a/src/libzerocoin/SerialNumberSignatureOfKnowledge.cpp
+++ b/src/libzerocoin/SerialNumberSignatureOfKnowledge.cpp
@@ -11,6 +11,7 @@
 **/
 
 #include "Zerocoin.h"
+#include "ParallelTasks.h"
 
 namespace libzerocoin {
 
@@ -50,13 +51,16 @@ SerialNumberSignatureOfKnowledge::SerialNumberSignatureOfKnowledge(const Params*
 	// Openssl's rng is not thread safe, so we don't call it in a parallel loop,
 	// instead we generate the random values beforehand and run the calculations
 	// based on those values in parallel.
-#ifdef ZEROCOIN_THREADING
-	#pragma omp parallel for
-#endif
+
+    ParallelTasks challenges(params->zkp_iterations);
+
 	for(uint32_t i=0; i < params->zkp_iterations; i++) {
 		// compute g^{ {a^x b^r} h^v} mod p2
-		c[i] = challengeCalculation(coin.getSerialNumber(), r[i], v[i]);
+        challenges.Add([this, i, &coin, &c, &r, &v] {
+            c[i] = challengeCalculation(coin.getSerialNumber(), r[i], v[i]);
+        });
 	}
+    challenges.Wait();
 
 	// We can't hash data in parallel either
 	// because OPENMP cannot not guarantee loops
@@ -67,9 +71,7 @@ SerialNumberSignatureOfKnowledge::SerialNumberSignatureOfKnowledge(const Params*
     this->hash = hasher.GetArith256Hash();
 	unsigned char *hashbytes =  (unsigned char*) &hash;
 
-#ifdef ZEROCOIN_THREADING
-	#pragma omp parallel for
-#endif
+    challenges.Reset();
 	for(uint32_t i = 0; i < params->zkp_iterations; i++) {
 		int bit = i % 8;
 		int byte = i / 8;
@@ -79,11 +81,14 @@ SerialNumberSignatureOfKnowledge::SerialNumberSignatureOfKnowledge(const Params*
 			s_notprime[i]       = r[i];
 			sprime[i]           = v[i];
 		} else {
-			s_notprime[i]       = r[i] - coin.getRandomness();
-			sprime[i]           = v[i] - (commitmentToCoin.getRandomness() *
+            challenges.Add([this, i, &r, &v, &b, &commitmentToCoin, &coin] {
+                s_notprime[i]   = r[i] - coin.getRandomness();
+                sprime[i]       = v[i] - (commitmentToCoin.getRandomness() *
 			                              b.pow_mod(r[i] - coin.getRandomness(), params->serialNumberSoKCommitmentGroup.groupOrder));
+            });
 		}
-	}
+    }
+    challenges.Wait();
 }
 
 inline Bignum SerialNumberSignatureOfKnowledge::challengeCalculation(const Bignum& a_exp,const Bignum& b_exp,
@@ -118,22 +123,26 @@ bool SerialNumberSignatureOfKnowledge::Verify(const Bignum& coinSerialNumber, co
 
 	vector<CBigNum> tprime(params->zkp_iterations);
 	unsigned char *hashbytes = (unsigned char*) &this->hash;
-#ifdef ZEROCOIN_THREADING
-	#pragma omp parallel for
-#endif
+
+    ParallelTasks challenges(params->zkp_iterations);
+
 	for(uint32_t i = 0; i < params->zkp_iterations; i++) {
-		int bit = i % 8;
-		int byte = i / 8;
-		bool challenge_bit = ((hashbytes[byte] >> bit) & 0x01);
-		if(challenge_bit) {
-			tprime[i] = challengeCalculation(coinSerialNumber, s_notprime[i], sprime[i]);
-		} else {
-			Bignum exp = b.pow_mod(s_notprime[i], params->serialNumberSoKCommitmentGroup.groupOrder);
-			tprime[i] = ((valueOfCommitmentToCoin.pow_mod(exp, params->serialNumberSoKCommitmentGroup.modulus) % params->serialNumberSoKCommitmentGroup.modulus) *
-			             (h.pow_mod(sprime[i], params->serialNumberSoKCommitmentGroup.modulus) % params->serialNumberSoKCommitmentGroup.modulus)) %
-			            params->serialNumberSoKCommitmentGroup.modulus;
-		}
+        challenges.Add([this, i, hashbytes, &b, &h, &tprime, &coinSerialNumber, &valueOfCommitmentToCoin] {
+            int bit = i % 8;
+            int byte = i / 8;
+            bool challenge_bit = ((hashbytes[byte] >> bit) & 0x01);
+            if(challenge_bit) {
+                tprime[i] = challengeCalculation(coinSerialNumber, s_notprime[i], sprime[i]);
+            } else {
+                Bignum exp = b.pow_mod(s_notprime[i], params->serialNumberSoKCommitmentGroup.groupOrder);
+                tprime[i] = ((valueOfCommitmentToCoin.pow_mod(exp, params->serialNumberSoKCommitmentGroup.modulus) % params->serialNumberSoKCommitmentGroup.modulus) *
+                             (h.pow_mod(sprime[i], params->serialNumberSoKCommitmentGroup.modulus) % params->serialNumberSoKCommitmentGroup.modulus)) %
+                            params->serialNumberSoKCommitmentGroup.modulus;
+            }
+        });
 	}
+    challenges.Wait();
+
 	for(uint32_t i = 0; i < params->zkp_iterations; i++) {
 		hasher << tprime[i];
 	}
diff --git a/src/libzerocoin/bitcoin_bignum/bignum.h b/src/libzerocoin/bitcoin_bignum/bignum.h
index 94221085b9..817649545b 100755
--- a/src/libzerocoin/bitcoin_bignum/bignum.h
+++ b/src/libzerocoin/bitcoin_bignum/bignum.h
@@ -48,8 +48,7 @@ class CAutoBN_CTX
 };
 
 
-/** C++ wrapper for BIGNUM (OpenSSL bignum) */
-class CBigNum
+/** C++ wrapper for BIGNUM (OpenSSL bignum) */class CBigNum
 {
 protected:
     BIGNUM	*bn;
diff --git a/src/main.cpp b/src/main.cpp
index 42d7f55455..6ad27d3639 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -42,6 +42,12 @@
 #include "versionbits.h"
 #include "definition.h"
 
+#include "darksend.h"
+#include "instantx.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+
 #include <atomic>
 #include <sstream>
 #include <chrono>
@@ -94,6 +100,9 @@ CAmount maxTxFee = DEFAULT_TRANSACTION_MAXFEE;
 CTxMemPool mempool(::minRelayTxFee);
 FeeFilterRounder filterRounder(::minRelayTxFee);
 
+// Dash znode
+map <uint256, int64_t> mapRejectedBlocks GUARDED_BY(cs_main);
+
 // Settings
 int64_t nTransactionFee = 0;
 int64_t nMinimumInputValue = DUST_HARD_LIMIT;
@@ -244,6 +253,7 @@ namespace {
     /** Relay map, protected by cs_main. */
     typedef std::map <uint256, std::shared_ptr<const CTransaction>> MapRelay;
     MapRelay mapRelay;
+    std::map<CInv, CDataStream> mapRelayInv;
     /** Expiration-time ordered list of (expire time, relay map entry) pairs, protected by cs_main). */
     std::deque <std::pair<int64_t, MapRelay::iterator>> vRelayExpiration;
 } // anon namespace
@@ -657,8 +667,7 @@ namespace {
                     if (vBlocks.size() == count) {
                         return;
                     }
-                }
-                else if (waitingfor == -1) {
+                } else if (waitingfor == -1) {
                     // This is the first already-in-flight block.
                     waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first;
                 }
@@ -684,6 +693,15 @@ bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {
     return true;
 }
 
+bool GetBlockHash(uint256 &hashRet, int nBlockHeight) {
+    LOCK(cs_main);
+    if (chainActive.Tip() == NULL) return false;
+    if (nBlockHeight < -1 || nBlockHeight > chainActive.Height()) return false;
+    if (nBlockHeight == -1) nBlockHeight = chainActive.Height();
+    hashRet = chainActive[nBlockHeight]->GetBlockHash();
+    return true;
+}
+
 void RegisterNodeSignals(CNodeSignals &nodeSignals) {
     nodeSignals.GetHeight.connect(&GetHeight);
     nodeSignals.ProcessMessages.connect(&ProcessMessages);
@@ -823,10 +841,10 @@ bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime) {
     if (tx.nLockTime == 0)
         return true;
     if ((int64_t) tx.nLockTime < ((int64_t) tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t) nBlockHeight : nBlockTime)) {
-        LogPrintf("IsFinalTx tx=%s --> OK\n", tx.GetHash().ToString());
         return true;
     }
-    BOOST_FOREACH(const CTxIn &txin, tx.vin) {
+    BOOST_FOREACH(
+    const CTxIn &txin, tx.vin) {
         if (txin.nSequence != CTxIn::SEQUENCE_FINAL) {
             LogPrintf("txin=%s\n", txin.ToString());
             LogPrintf("IsFinalTx tx=%s --> FAILED\n", tx.GetHash().ToString());
@@ -1091,13 +1109,16 @@ bool setParams = bnTrustedModulus.SetHexBool(ZEROCOIN_MODULUS);
 uint32_t securityLevel = 80;
 static libzerocoin::Params *ZCParams = new libzerocoin::Params(bnTrustedModulus);
 
-bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx, list <CZerocoinEntry> listPubCoin, libzerocoin::CoinDenomination targetDenomination, CValidationState &state, uint256 hashTx, bool isVerifyDB, int nHeight, bool isCheckWallet) {
+bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx, list <CZerocoinEntry> listPubCoin,
+                                libzerocoin::CoinDenomination targetDenomination, CValidationState &state,
+                                uint256 hashTx, bool isVerifyDB, int nHeight, bool isCheckWallet) {
     // Check vOut
     // Only one loop, we checked on the format before enter this case
     // Check vIn
     CWalletDB walletdb(pwalletMain->strWalletFile);
     LogPrintf("CheckSpendZcoinTransaction denomination=%d nHeight=%d\n", targetDenomination, nHeight);
-    BOOST_FOREACH(const CTxIn &txin, tx.vin)
+    BOOST_FOREACH(
+    const CTxIn &txin, tx.vin)
     {
         if (txin.scriptSig.IsZerocoinSpend()) {
 
@@ -1146,7 +1167,8 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
             }
             int countPubcoin = 0;
             if (!passVerify) {
-                BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+                BOOST_FOREACH(
+                const CZerocoinEntry &pubCoinItem, listPubCoin) {
                     if (pubCoinItem.denomination == targetDenomination &&
                         (pubCoinItem.id >= 0 && (uint32_t) pubCoinItem.id == pubcoinId) &&
                         pubCoinItem.nHeight != -1) {
@@ -1157,7 +1179,8 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
                         }
                         countPubcoin++;
                         accumulator += pubCoinTemp;
-                        LogPrintf("count=%s, accumulator=%s\n", countPubcoin, accumulator.getValue().ToString().substr(0, 15));
+                        LogPrintf("count=%s, accumulator=%s\n", countPubcoin,
+                                  accumulator.getValue().ToString().substr(0, 15));
                         if (countPubcoin >= 2) { // MINIMUM REQUIREMENT IS 2 PUBCOINS
                             if (newSpend.Verify(accumulator, newMetadata)) {
                                 LogPrintf("COIN SPEND TX DID VERIFY - accumulator!\n");
@@ -1174,22 +1197,25 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
 
                 // It does not have this mint coins id, still sync
                 if (countPubcoin == 0) {
-                    return state.DoS(0, false, NO_MINT_ZEROCOIN, "CTransaction::CheckTransaction() : Error: Node does not have mint zerocoin to verify, please wait until ");
+                    return state.DoS(0, false, NO_MINT_ZEROCOIN,
+                                     "CTransaction::CheckTransaction() : Error: Node does not have mint zerocoin to verify, please wait until ");
                 }
             }
 
             if (!passVerify) {
                 int countPubcoin = 0;
 //                LogPrint("CheckSpendZcoinTransaction", "Check reverse\n");
-                BOOST_REVERSE_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+                BOOST_REVERSE_FOREACH(
+                const CZerocoinEntry &pubCoinItem, listPubCoin) {
 //                    LogPrintf("--denomination = %d, id = %d, pubcoinId = %d height = %d\n",
 //                              pubCoinItem.denomination, pubCoinItem.id, pubcoinId, pubCoinItem.nHeight);
                     if (pubCoinItem.denomination == targetDenomination &&
                         (pubCoinItem.id >= 0 && (uint32_t) pubCoinItem.id == pubcoinId) &&
                         pubCoinItem.nHeight != -1) {
-                        LogPrint("CheckSpendZcoinTransaction", "--## denomination = %d, id = %d, pubcoinId = %d height = %d\n",
-                                  pubCoinItem.denomination, pubCoinItem.id, pubcoinId,
-                                  pubCoinItem.nHeight);
+                        LogPrint("CheckSpendZcoinTransaction",
+                                 "--## denomination = %d, id = %d, pubcoinId = %d height = %d\n",
+                                 pubCoinItem.denomination, pubCoinItem.id, pubcoinId,
+                                 pubCoinItem.nHeight);
                         libzerocoin::PublicCoin pubCoinTemp(ZCParams, pubCoinItem.value, targetDenomination);
                         if (!pubCoinTemp.validate()) {
                             return state.DoS(100,
@@ -1197,7 +1223,8 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
                         }
                         countPubcoin++;
                         accumulatorRev += pubCoinTemp;
-                        LogPrintf("count=%s, accumulatorRev=%s\n", countPubcoin, accumulatorRev.getValue().ToString().substr(0, 15));
+                        LogPrintf("count=%s, accumulatorRev=%s\n", countPubcoin,
+                                  accumulatorRev.getValue().ToString().substr(0, 15));
                         if (countPubcoin >= 2) { // MINIMUM REQUIREMENT IS 2 PUBCOINS
                             if (newSpend.Verify(accumulatorRev, newMetadata)) {
                                 LogPrintf("COIN SPEND TX DID VERIFY - accumulatorRev!\n");
@@ -1210,7 +1237,8 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
 
                 // It does not have this mint coins id, still sync
                 if (countPubcoin == 0) {
-                    return state.DoS(0, false, NO_MINT_ZEROCOIN, "CTransaction::CheckTransaction() : Error: Node does not have mint zerocoin to verify, please wait until ");
+                    return state.DoS(0, false, NO_MINT_ZEROCOIN,
+                                     "CTransaction::CheckTransaction() : Error: Node does not have mint zerocoin to verify, please wait until ");
                 }
             }
 
@@ -1228,7 +1256,8 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
 
                     std::list <CZerocoinSpendEntry> listCoinSpendSerial;
                     walletdb.ListCoinSpendSerial(listCoinSpendSerial);
-                    BOOST_FOREACH(const CZerocoinSpendEntry &item, listCoinSpendSerial) {
+                    BOOST_FOREACH(
+                    const CZerocoinSpendEntry &item, listCoinSpendSerial) {
                         if (item.coinSerial == serialNumber
                             && nHeight > ZC_CHECK_BUG_FIXED_AT_BLOCK 
                             && (item.id >= 0 && (uint32_t) item.id == pubcoinId)
@@ -1240,7 +1269,8 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
                                    && (item.id >= 0 && (uint32_t) item.id == pubcoinId)
                                    && item.pubCoin != 0) {
                             // UPDATING PROCESS
-                            BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+                            BOOST_FOREACH(
+                            const CZerocoinEntry &pubCoinItem, listPubCoin) {
                                 if (pubCoinItem.value == item.pubCoin) {
                                     pubCoinTx.nHeight = pubCoinItem.nHeight;
                                     pubCoinTx.denomination = pubCoinItem.denomination;
@@ -1254,7 +1284,8 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
                                     walletdb.WriteZerocoinEntry(pubCoinTx);
                                     // Update UI wallet
                                     // LogPrint("CheckSpendZcoinTransaction", "pubcoin=%s, isUsed=Used\n", pubCoinItem.value.GetHex());
-                                    pwalletMain->NotifyZerocoinChanged(pwalletMain, pubCoinItem.value.GetHex(), "Used", CT_UPDATED);
+                                    pwalletMain->NotifyZerocoinChanged(pwalletMain, pubCoinItem.value.GetHex(), "Used",
+                                                                       CT_UPDATED);
                                     break;
                                 }
                             }
@@ -1294,8 +1325,10 @@ bool CheckSpendZcoinTransaction(const CTransaction &tx, CZerocoinEntry pubCoinTx
 }
 
 //static libzerocoin::Params *ZCParams;
-bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 hashTx,  bool isVerifyDB, int nHeight, bool isCheckWallet) {
-    LogPrintf("CheckTransaction nHeight=%s, isVerifyDB=%s, isCheckWallet=%s, txHash=%s\n", nHeight, isVerifyDB, isCheckWallet, tx.GetHash().ToString());
+bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 hashTx, bool isVerifyDB, int nHeight,
+                      bool isCheckWallet) {
+    LogPrintf("CheckTransaction nHeight=%s, isVerifyDB=%s, isCheckWallet=%s, txHash=%s\n", nHeight, isVerifyDB,
+              isCheckWallet, tx.GetHash().ToString());
 //    LogPrintf("transaction = %s\n", tx.ToString());
     bool fTestNet = (Params().NetworkIDString() == CBaseChainParams::TESTNET);
     // Basic checks that don't depend on any context
@@ -1322,7 +1355,8 @@ bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 h
 
     // Check for duplicate inputs
     set <COutPoint> vInOutPoints;
-    BOOST_FOREACH(const CTxIn &txin, tx.vin)
+    BOOST_FOREACH(
+    const CTxIn &txin, tx.vin)
     {
         if (vInOutPoints.count(txin.prevout))
             return state.DoS(100, false, REJECT_INVALID, "bad-txns-inputs-duplicate");
@@ -1333,55 +1367,109 @@ bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 h
         if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
             return state.DoS(100, false, REJECT_INVALID, "bad-cb-length");
         // Check for founders inputs
-        if ((nHeight > ZC_CHECK_BUG_FIXED_AT_BLOCK) && (nHeight < 210000)) {
+        if (((nHeight > ZC_CHECK_BUG_FIXED_AT_BLOCK) && (nHeight < 210000)) || (fTestNet && nHeight >= 7200)) {
             bool found_1 = false;
             bool found_2 = false;
             bool found_3 = false;
             bool found_4 = false;
             bool found_5 = false;
-
+            int total_payment_tx = 0; // no more than 1 output for payment
             CScript FOUNDER_1_SCRIPT;
             CScript FOUNDER_2_SCRIPT;
             CScript FOUNDER_3_SCRIPT;
             CScript FOUNDER_4_SCRIPT;
             CScript FOUNDER_5_SCRIPT;
-
-            if (!fTestNet && GetAdjustedTime() > nStartRewardTime) {
-                FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("aCAgTPgtYcA4EysU4UKC86EQd5cTtHtCcr").Get());
-                if (nHeight < 14000) {
-                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aLrg41sXbXZc5MyEj7dts8upZKSAtJmRDR").Get());
+            if (nHeight < Params().GetConsensus().nZnodePaymentsStartBlock) {
+                if (!fTestNet && GetAdjustedTime() > nStartRewardTime) {
+                    FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("aCAgTPgtYcA4EysU4UKC86EQd5cTtHtCcr").Get());
+                    if (nHeight < 14000) {
+                        FOUNDER_2_SCRIPT = GetScriptForDestination(
+                                CBitcoinAddress("aLrg41sXbXZc5MyEj7dts8upZKSAtJmRDR").Get());
+                    } else {
+                        FOUNDER_2_SCRIPT = GetScriptForDestination(
+                                CBitcoinAddress("aHu897ivzmeFuLNB6956X6gyGeVNHUBRgD").Get());
+                    }
+                    FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("aQ18FBVFtnueucZKeVg4srhmzbpAeb1KoN").Get());
+                    FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1HwTdCmQV3NspP2QqCGpehoFpi8NY4Zg3").Get());
+                    FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1kCCGddf5pMXSipLVD9hBG2MGGVNaJ15U").Get());
+                } else if (!fTestNet && GetAdjustedTime() <= nStartRewardTime) {
+                    return state.DoS(100, false, REJECT_TRANSACTION_TOO_EARLY,
+                                     "CTransaction::CheckTransaction() : transaction is too early");
                 } else {
-                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aHu897ivzmeFuLNB6956X6gyGeVNHUBRgD").Get());
+                    FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("TDk19wPKYq91i18qmY6U9FeTdTxwPeSveo").Get());
+                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("TWZZcDGkNixTAMtRBqzZkkMHbq1G6vUTk5").Get());
+                    FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("TRZTFdNCKCKbLMQV8cZDkQN9Vwuuq4gDzT").Get());
+                    FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("TG2ruj59E5b1u9G3F7HQVs6pCcVDBxrQve").Get());
+                    FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("TCsTzQZKVn4fao8jDmB9zQBk9YQNEZ3XfS").Get());
                 }
-                FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("aQ18FBVFtnueucZKeVg4srhmzbpAeb1KoN").Get());
-                FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1HwTdCmQV3NspP2QqCGpehoFpi8NY4Zg3").Get());
-                FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1kCCGddf5pMXSipLVD9hBG2MGGVNaJ15U").Get());
-            } else if (!fTestNet && GetAdjustedTime() <= nStartRewardTime) {
-                return state.DoS(100, false, REJECT_TRANSACTION_TOO_EARLY,
-                                 "CTransaction::CheckTransaction() : transaction is too early");
-            } else {
-                FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("TCE4hvs2UTDjYriey7R9qBkbvUAYxWmZni").Get());
-                FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("TPyA7d3fribqxXm9uJU61S76Lzuj7F8jLz").Get());
-                FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("TXatvpS15EvejVuJVC2rgD73rSaQz8JiX6").Get());
-                FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("TJMpFjtDi8s5AM3GyW41QshH2NNmKgrGNq").Get());
-                FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("TTtLk1iapn8QebamQcb8GEh1MNq8agYcVk").Get());
-            }
 
-            BOOST_FOREACH(const CTxOut &output, tx.vout) {
-                if (output.scriptPubKey == FOUNDER_1_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
-                    found_1 = true;
-                }
-                if (output.scriptPubKey == FOUNDER_2_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
-                    found_2 = true;
-                }
-                if (output.scriptPubKey == FOUNDER_3_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
-                    found_3 = true;
+                BOOST_FOREACH(const CTxOut &output, tx.vout) {
+                    if (output.scriptPubKey == FOUNDER_1_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
+                        found_1 = true;
+                    }
+                    if (output.scriptPubKey == FOUNDER_2_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
+                        found_2 = true;
+                    }
+                    if (output.scriptPubKey == FOUNDER_3_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
+                        found_3 = true;
+                    }
+                    if (output.scriptPubKey == FOUNDER_4_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
+                        found_4 = true;
+                    }
+                    if (output.scriptPubKey == FOUNDER_5_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
+                        found_5 = true;
+                    }
                 }
-                if (output.scriptPubKey == FOUNDER_4_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
-                    found_4 = true;
+            } else {
+
+                if (!fTestNet && GetAdjustedTime() > nStartRewardTime) {
+                    FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("aCAgTPgtYcA4EysU4UKC86EQd5cTtHtCcr").Get());
+                    if (nHeight < 14000) {
+                        FOUNDER_2_SCRIPT = GetScriptForDestination(
+                                CBitcoinAddress("aLrg41sXbXZc5MyEj7dts8upZKSAtJmRDR").Get());
+                    } else {
+                        FOUNDER_2_SCRIPT = GetScriptForDestination(
+                                CBitcoinAddress("aHu897ivzmeFuLNB6956X6gyGeVNHUBRgD").Get());
+                    }
+                    FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("aQ18FBVFtnueucZKeVg4srhmzbpAeb1KoN").Get());
+                    FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1HwTdCmQV3NspP2QqCGpehoFpi8NY4Zg3").Get());
+                    FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1kCCGddf5pMXSipLVD9hBG2MGGVNaJ15U").Get());
+                } else if (!fTestNet && GetAdjustedTime() <= nStartRewardTime) {
+                    return state.DoS(100, false, REJECT_TRANSACTION_TOO_EARLY,
+                                     "CTransaction::CheckTransaction() : transaction is too early");
+                } else {
+                    FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("TDk19wPKYq91i18qmY6U9FeTdTxwPeSveo").Get());
+                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("TWZZcDGkNixTAMtRBqzZkkMHbq1G6vUTk5").Get());
+                    FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("TRZTFdNCKCKbLMQV8cZDkQN9Vwuuq4gDzT").Get());
+                    FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("TG2ruj59E5b1u9G3F7HQVs6pCcVDBxrQve").Get());
+                    FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("TCsTzQZKVn4fao8jDmB9zQBk9YQNEZ3XfS").Get());
                 }
-                if (output.scriptPubKey == FOUNDER_5_SCRIPT && output.nValue == (int64_t)(2 * COIN)) {
-                    found_5 = true;
+
+                CAmount znodePayment = GetZnodePayment(nHeight);
+                BOOST_FOREACH(const CTxOut &output, tx.vout) {
+                    if (output.scriptPubKey == FOUNDER_1_SCRIPT && output.nValue == (int64_t)(1 * COIN)) {
+                        found_1 = true;
+                        continue;
+                    }
+                    if (output.scriptPubKey == FOUNDER_2_SCRIPT && output.nValue == (int64_t)(1 * COIN)) {
+                        found_2 = true;
+                        continue;
+                    }
+                    if (output.scriptPubKey == FOUNDER_3_SCRIPT && output.nValue == (int64_t)(1 * COIN)) {
+                        found_3 = true;
+                        continue;
+                    }
+                    if (output.scriptPubKey == FOUNDER_4_SCRIPT && output.nValue == (int64_t)(3 * COIN)) {
+                        found_4 = true;
+                        continue;
+                    }
+                    if (output.scriptPubKey == FOUNDER_5_SCRIPT && output.nValue == (int64_t)(1 * COIN)) {
+                        found_5 = true;
+                        continue;
+                    }
+                    if (znodePayment == output.nValue) {
+                        total_payment_tx = total_payment_tx + 1;
+                    }
                 }
             }
 
@@ -1389,6 +1477,11 @@ bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 h
                 return state.DoS(100, false, REJECT_FOUNDER_REWARD_MISSING,
                                  "CTransaction::CheckTransaction() : founders reward missing");
             }
+
+            if (total_payment_tx > 1) {
+                return state.DoS(100, false, REJECT_INVALID_ZNODE_PAYMENT,
+                                 "CTransaction::CheckTransaction() : invalid znode payment");
+            }
         }
     } else {
         BOOST_FOREACH(const CTxIn &txin, tx.vin)
@@ -1399,7 +1492,8 @@ bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 h
         // Check Mint Zerocoin Transaction
         BOOST_FOREACH(const CTxOut &txout, tx.vout) {
             if (!txout.scriptPubKey.empty() && txout.scriptPubKey.IsZerocoinMint()) {
-                LogPrintf("CheckMintZcoinTransaction txHash = %s, isVerifyDB = %d\n", txout.GetHash().ToString(), isVerifyDB);
+                LogPrintf("CheckMintZcoinTransaction txHash = %s, isVerifyDB = %d\n", txout.GetHash().ToString(),
+                          isVerifyDB);
                 LogPrintf("nValue = %d\n", txout.nValue);
                 vector<unsigned char> vchZeroMint;
                 vchZeroMint.insert(vchZeroMint.end(), txout.scriptPubKey.begin() + 6,
@@ -1455,7 +1549,8 @@ bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 h
                     bool isAlreadyStored = false;
 
                     // CHECKING PROCESS
-                    BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+                    BOOST_FOREACH(
+                    const CZerocoinEntry &pubCoinItem, listPubCoin) {
                         if (pubCoinItem.value == pubCoin && pubCoinItem.denomination == denomination) {
                             isAlreadyStored = true;
                             break;
@@ -1492,27 +1587,38 @@ bool CheckTransaction(const CTransaction &tx, CValidationState &state, uint256 h
                     listPubCoin.sort(CompHeight);
                     if (txout.nValue == libzerocoin::ZQ_LOVELACE * COIN) {
                         // Check vIn
-                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_LOVELACE, state, hashTx,isVerifyDB, nHeight, isCheckWallet)) {
-                            return state.DoS(100, error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_LOVELACE DID NOT VERIFY!"));
+                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_LOVELACE, state,
+                                                        hashTx, isVerifyDB, nHeight, isCheckWallet)) {
+                            return state.DoS(100,
+                                             error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_LOVELACE DID NOT VERIFY!"));
                         };
                     } else if (txout.nValue == libzerocoin::ZQ_GOLDWASSER * COIN) {
-                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_GOLDWASSER, state, hashTx, isVerifyDB, nHeight, isCheckWallet)) {
-                            return state.DoS(100, error("CTr[ansaction::CheckTransaction() : COIN SPEND TX IN ZQ_GOLDWASSER DID NOT VERIFY!"));
+                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_GOLDWASSER, state,
+                                                        hashTx, isVerifyDB, nHeight, isCheckWallet)) {
+                            return state.DoS(100,
+                                             error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_GOLDWASSER DID NOT VERIFY!"));
                         };
                     } else if (txout.nValue == libzerocoin::ZQ_RACKOFF * COIN) {
-                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_RACKOFF, state, hashTx, isVerifyDB, nHeight, isCheckWallet)) {
-                            return state.DoS(100, error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_RACKOFF DID NOT VERIFY!"));
+                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_RACKOFF, state,
+                                                        hashTx, isVerifyDB, nHeight, isCheckWallet)) {
+                            return state.DoS(100,
+                                             error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_RACKOFF DID NOT VERIFY!"));
                         };
                     } else if (txout.nValue == libzerocoin::ZQ_PEDERSEN * COIN) {
-                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_PEDERSEN, state, hashTx, isVerifyDB, nHeight, isCheckWallet)) {
-                            return state.DoS(100, error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_PEDERSEN DID NOT VERIFY!"));
+                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_PEDERSEN, state,
+                                                        hashTx, isVerifyDB, nHeight, isCheckWallet)) {
+                            return state.DoS(100,
+                                             error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_PEDERSEN DID NOT VERIFY!"));
                         };
                     } else if (txout.nValue == libzerocoin::ZQ_WILLIAMSON * COIN) {
-                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_WILLIAMSON, state, hashTx, isVerifyDB, nHeight, isCheckWallet)) {
-                            return state.DoS(100, error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_WILLIAMSON DID NOT VERIFY!"));
+                        if (!CheckSpendZcoinTransaction(tx, pubCoinTx, listPubCoin, libzerocoin::ZQ_WILLIAMSON, state,
+                                                        hashTx, isVerifyDB, nHeight, isCheckWallet)) {
+                            return state.DoS(100,
+                                             error("CTransaction::CheckTransaction() : COIN SPEND TX IN ZQ_WILLIAMSON DID NOT VERIFY!"));
                         };
                     } else {
-                        return state.DoS(100, error("CTransaction::CheckTransaction() : Your spending txout value does not match"));
+                        return state.DoS(100,
+                                         error("CTransaction::CheckTransaction() : Your spending txout value does not match"));
                     }
                     walletdb.Flush();
                     walletdb.Close();
@@ -1543,8 +1649,9 @@ std::string FormatStateMessage(const CValidationState &state) {
                      state.GetRejectCode());
 }
 
-bool AcceptToMemoryPoolWorker(CTxMemPool &pool, CValidationState &state, const CTransaction &tx, bool fCheckInputs, bool fLimitFree,
-                              bool *pfMissingInputs,  bool fOverrideMempoolLimit, const CAmount &nAbsurdFee,
+bool AcceptToMemoryPoolWorker(CTxMemPool &pool, CValidationState &state, const CTransaction &tx, bool fCheckInputs,
+                              bool fLimitFree,
+                              bool *pfMissingInputs, bool fOverrideMempoolLimit, const CAmount &nAbsurdFee,
                               std::vector <uint256> &vHashTxnToUncache, bool isCheckWalletTransaction) {
     bool fTestNet = (Params().NetworkIDString() == CBaseChainParams::TESTNET);
     LogPrintf("AcceptToMemoryPoolWorker(),fCheckInputs=%s, tx.IsZerocoinSpend()=%s, fTestNet=%s\n", fCheckInputs,
@@ -1598,11 +1705,12 @@ bool AcceptToMemoryPoolWorker(CTxMemPool &pool, CValidationState &state, const C
         return state.Invalid(false, REJECT_ALREADY_KNOWN, "txn-already-in-mempool");
     // Check for conflicts with in-memory transactions
     set <uint256> setConflicts;
-     //btzc
+    //btzc
     {
         LOCK(pool.cs); // protect pool.mapNextTx
         if (!tx.IsZerocoinSpend()) {
-            BOOST_FOREACH(const CTxIn &txin, tx.vin)
+            BOOST_FOREACH(
+            const CTxIn &txin, tx.vin)
             {
                 auto itConflicting = pool.mapNextTx.find(txin.prevout);
                 if (itConflicting != pool.mapNextTx.end()) {
@@ -1610,7 +1718,8 @@ bool AcceptToMemoryPoolWorker(CTxMemPool &pool, CValidationState &state, const C
                     if (!setConflicts.count(ptxConflicting->GetHash())) {
                         bool fReplacementOptOut = true;
                         if (fEnableReplacement) {
-                            BOOST_FOREACH(const CTxIn &txin, ptxConflicting->vin)
+                            BOOST_FOREACH(
+                            const CTxIn &txin, ptxConflicting->vin)
                             {
                                 if (txin.nSequence < std::numeric_limits < unsigned int > ::max() - 1)
                                 {
@@ -2028,22 +2137,27 @@ bool AcceptToMemoryPoolWorker(CTxMemPool &pool, CValidationState &state, const C
     return true;
 }
 
-bool AcceptToMemoryPool(CTxMemPool &pool, CValidationState &state, const CTransaction &tx, bool fCheckInputs, bool fLimitFree,
-                        bool *pfMissingInputs, bool fOverrideMempoolLimit, const CAmount nAbsurdFee, bool isCheckWalletTransaction) {
+bool AcceptToMemoryPool(CTxMemPool &pool, CValidationState &state, const CTransaction &tx, bool fCheckInputs,
+                        bool fLimitFree,
+                        bool *pfMissingInputs, bool fOverrideMempoolLimit, const CAmount nAbsurdFee,
+                        bool isCheckWalletTransaction) {
     LogPrintf("AcceptToMemoryPool(), fCheckInputs=%s\n", fCheckInputs);
     std::vector <uint256> vHashTxToUncache;
-    bool res = AcceptToMemoryPoolWorker(pool, state, tx, fCheckInputs, fLimitFree, pfMissingInputs, fOverrideMempoolLimit, nAbsurdFee,
+    bool res = AcceptToMemoryPoolWorker(pool, state, tx, fCheckInputs, fLimitFree, pfMissingInputs,
+                                        fOverrideMempoolLimit, nAbsurdFee,
                                         vHashTxToUncache, isCheckWalletTransaction);
     if (!res) {
         LogPrintf("AcceptToMemoryPoolWorker --> FAILED\n");
-        BOOST_FOREACH(const uint256 &hashTx, vHashTxToUncache)
-            pcoinsTip->Uncache(hashTx);
+        BOOST_FOREACH(
+        const uint256 &hashTx, vHashTxToUncache)
+        pcoinsTip->Uncache(hashTx);
     }
     return res;
 }
 
 /** Return transaction in txOut, and if it was found inside a block, its hash is placed in hashBlock */
-bool GetTransaction(const uint256 &hash, CTransaction &txOut, const Consensus::Params &consensusParams, uint256 &hashBlock,
+bool
+GetTransaction(const uint256 &hash, CTransaction &txOut, const Consensus::Params &consensusParams, uint256 &hashBlock,
                bool fAllowSlow) {
     CBlockIndex *pindexSlow = NULL;
 
@@ -2404,7 +2518,8 @@ int GetSpendHeight(const CCoinsViewCache &inputs) {
 }
 
 namespace Consensus {
-    bool CheckTxInputs(const CTransaction &tx, CValidationState &state, const CCoinsViewCache &inputs, int nSpendHeight) {
+    bool
+    CheckTxInputs(const CTransaction &tx, CValidationState &state, const CCoinsViewCache &inputs, int nSpendHeight) {
         // This doesn't trigger the DoS code on purpose; if it did, it would make it easier
         // for an attacker to attempt to split the network.
         if (!inputs.HaveInputs(tx))
@@ -2849,10 +2964,12 @@ bool ConnectBlock(const CBlock &block, CValidationState &state, CBlockIndex *pin
 
     bool fEnforceBIP30 = true;
     if (fEnforceBIP30) {
-        BOOST_FOREACH(const CTransaction &tx, block.vtx) {
+        BOOST_FOREACH(
+        const CTransaction &tx, block.vtx) {
             const CCoins *coins = view.AccessCoins(tx.GetHash());
             if (coins && !coins->IsPruned())
-                return state.DoS(100, error("ConnectBlock(): tried to overwrite transaction"), REJECT_INVALID, "bad-txns-BIP30");
+                return state.DoS(100, error("ConnectBlock(): tried to overwrite transaction"), REJECT_INVALID,
+                                 "bad-txns-BIP30");
         }
     }
 
@@ -2984,16 +3101,31 @@ bool ConnectBlock(const CBlock &block, CValidationState &state, CBlockIndex *pin
              (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);
     //btzc: Add time to check
-    LogPrintf("block=%s\n", block.ToString());
-    LogPrintf("nFees=%s\n", nFees);
-    LogPrintf("GetBlockSubsidy(pindex->nHeight, chainparams.GetConsensus(), pindex->nTime)=%s\n", GetBlockSubsidy(pindex->nHeight, chainparams.GetConsensus(), pindex->nTime));
-    LogPrintf("block.vtx[0].GetValueOut()=%s\n", block.vtx[0].GetValueOut());
     CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, chainparams.GetConsensus(), pindex->nTime);
     if (block.vtx[0].GetValueOut() > blockReward)
         return state.DoS(100, error("ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)",
                                     block.vtx[0].GetValueOut(), blockReward),
                          REJECT_INVALID, "bad-cb-amount");
 
+    // ZNODE : MODIFIED TO CHECK ZNODE PAYMENTS AND SUPERBLOCKS
+    // It's possible that we simply don't have enough data and this could fail
+    // (i.e. block itself could be a correct one and we need to store it),
+    // that's why this is in ConnectBlock. Could be the other way around however -
+    // the peer who sent us this block is missing some data and wasn't able
+    // to recognize that block is actually invalid.
+    // TODO: resync data (both ways?) and try to reprocess this block later.
+    std::string strError = "";
+    if (!IsBlockValueValid(block, pindex->nHeight, blockReward, strError)) {
+        return state.DoS(0, error("ConnectBlock(): %s", strError), REJECT_INVALID, "bad-cb-amount");
+    }
+
+    if (!IsBlockPayeeValid(block.vtx[0], pindex->nHeight, blockReward)) {
+        mapRejectedBlocks.insert(make_pair(block.GetHash(), GetTime()));
+        return state.DoS(0, error("ConnectBlock(): couldn't find znode or superblock payments"),
+                         REJECT_INVALID, "bad-cb-payee");
+    }
+    // END ZNODE
+
     if (!control.Wait())
         return state.DoS(100, false);
     int64_t nTime4 = GetTimeMicros();
@@ -3184,6 +3316,10 @@ void PruneAndFlush() {
 void static UpdateTip(CBlockIndex *pindexNew, const CChainParams &chainParams) {
     LogPrintf("UpdateTip() pindexNew.nHeight=%s\n", pindexNew->nHeight);
     chainActive.SetTip(pindexNew);
+    mnodeman.UpdatedBlockTip(chainActive.Tip());
+    darkSendPool.UpdatedBlockTip(chainActive.Tip());
+    mnpayments.UpdatedBlockTip(chainActive.Tip());
+    znodeSync.UpdatedBlockTip(chainActive.Tip());
 
     // New best block
     nTimeBestReceived = GetTime();
@@ -3221,14 +3357,16 @@ void static UpdateTip(CBlockIndex *pindexNew, const CChainParams &chainParams) {
             warningMessages.push_back(strprintf("%d of last 100 blocks have unexpected version", nUpgraded));
         if (nUpgraded > 100 / 2) {
             // strMiscWarning is read by GetWarnings(), called by Qt and the JSON-RPC code to warn the user:
-            strMiscWarning = _("Warning: Unknown block versions being mined! It's possible unknown rules are in effect");
+            strMiscWarning = _(
+                    "Warning: Unknown block versions being mined! It's possible unknown rules are in effect");
             if (!fWarned) {
                 AlertNotify(strMiscWarning);
                 fWarned = true;
             }
         }
     }
-    LogPrintf("%s: new best=%s height=%d version=0x%08x log2_work=%.8g tx=%lu date='%s' progress=%f cache=%.1fMiB(%utx)",
+    LogPrintf(
+            "%s: new best=%s height=%d version=0x%08x log2_work=%.8g tx=%lu date='%s' progress=%f cache=%.1fMiB(%utx)",
             __func__,
             chainActive.Tip()->GetBlockHash().ToString(), chainActive.Height(), chainActive.Tip()->nVersion,
             log(chainActive.Tip()->nChainWork.getdouble()) / log(2.0), (unsigned long) chainActive.Tip()->nChainTx,
@@ -3266,12 +3404,15 @@ bool static DisconnectTip(CValidationState &state, const CChainParams &chainpara
     list <CZerocoinSpendEntry> listCoinSpendSerial;
     walletdb.ListCoinSpendSerial(listCoinSpendSerial);
 
-    BOOST_FOREACH(const CTransaction &tx, block.vtx){
+    BOOST_FOREACH(
+    const CTransaction &tx, block.vtx){
         // Check Spend Zerocoin Transaction
         if (tx.IsZerocoinSpend()) {
-            BOOST_FOREACH(const CZerocoinSpendEntry &item, listCoinSpendSerial) {
+            BOOST_FOREACH(
+            const CZerocoinSpendEntry &item, listCoinSpendSerial) {
                 if (item.hashTx == tx.GetHash()) {
-                    BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+                    BOOST_FOREACH(
+                    const CZerocoinEntry &pubCoinItem, listPubCoin) {
                         if (pubCoinItem.value == item.pubCoin) {
                             CZerocoinEntry pubCoinTx;
                             pubCoinTx.nHeight = pubCoinItem.nHeight;
@@ -3285,7 +3426,8 @@ bool static DisconnectTip(CValidationState &state, const CChainParams &chainpara
                             walletdb.WriteZerocoinEntry(pubCoinTx);
                             LogPrintf("DisconnectTip() -> NotifyZerocoinChanged\n");
                             LogPrintf("pubcoin=%s, isUsed=New\n", pubCoinItem.value.GetHex());
-                            pwalletMain->NotifyZerocoinChanged(pwalletMain, pubCoinItem.value.GetHex(), "New", CT_UPDATED);
+                            pwalletMain->NotifyZerocoinChanged(pwalletMain, pubCoinItem.value.GetHex(), "New",
+                                                               CT_UPDATED);
                             walletdb.EraseCoinSpendSerialEntry(item);
                             pwalletMain->EraseFromWallet(item.hashTx);
                         }
@@ -3295,14 +3437,17 @@ bool static DisconnectTip(CValidationState &state, const CChainParams &chainpara
         }
 
         // Check Mint Zerocoin Transaction
-        BOOST_FOREACH(const CTxOut txout, tx.vout) {
+        BOOST_FOREACH(
+        const CTxOut txout, tx.vout) {
             if (!txout.scriptPubKey.empty() && txout.scriptPubKey.IsZerocoinMint()) {
                 vector<unsigned char> vchZeroMint;
-                vchZeroMint.insert(vchZeroMint.end(), txout.scriptPubKey.begin() + 6, txout.scriptPubKey.begin() + txout.scriptPubKey.size());
+                vchZeroMint.insert(vchZeroMint.end(), txout.scriptPubKey.begin() + 6,
+                                   txout.scriptPubKey.begin() + txout.scriptPubKey.size());
                 CBigNum pubCoin;
                 pubCoin.setvch(vchZeroMint);
                 int zerocoinMintHeight = -1;
-                BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+                BOOST_FOREACH(
+                const CZerocoinEntry &pubCoinItem, listPubCoin) {
                     if (pubCoinItem.value == pubCoin) {
                         zerocoinMintHeight = pubCoinItem.nHeight;
                         CZerocoinEntry pubCoinTx;
@@ -3313,13 +3458,15 @@ bool static DisconnectTip(CValidationState &state, const CChainParams &chainpara
                         pubCoinTx.serialNumber = pubCoinItem.serialNumber;
                         pubCoinTx.value = pubCoin;
                         pubCoinTx.nHeight = -1;
-                        LogPrintf("- Pubcoin Disconnect Reset Pubcoin Id: %d Height: %d\n", pubCoinTx.id, pindexDelete->nHeight);
+                        LogPrintf("- Pubcoin Disconnect Reset Pubcoin Id: %d Height: %d\n", pubCoinTx.id,
+                                  pindexDelete->nHeight);
                         walletdb.WriteZerocoinEntry(pubCoinTx);
                     }
 
                 }
 
-                BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+                BOOST_FOREACH(
+                const CZerocoinEntry &pubCoinItem, listPubCoin) {
                     if (pubCoinItem.nHeight > zerocoinMintHeight) {
                         CZerocoinEntry pubCoinTx;
                         pubCoinTx.id = -1;
@@ -3329,7 +3476,8 @@ bool static DisconnectTip(CValidationState &state, const CChainParams &chainpara
                         pubCoinTx.serialNumber = pubCoinItem.serialNumber;
                         pubCoinTx.value = pubCoin;
                         pubCoinTx.nHeight = -1;
-                        LogPrintf("- Disconnect Reset Pubcoin Id: %d Height: %d\n", pubCoinTx.id, pindexDelete->nHeight);
+                        LogPrintf("- Disconnect Reset Pubcoin Id: %d Height: %d\n", pubCoinTx.id,
+                                  pindexDelete->nHeight);
                         walletdb.WriteZerocoinEntry(pubCoinTx);
                     }
 
@@ -3345,7 +3493,8 @@ bool static DisconnectTip(CValidationState &state, const CChainParams &chainpara
     if (!fBare) {
         // Resurrect mempool transactions from the disconnected block.
         std::vector <uint256> vHashUpdate;
-        BOOST_FOREACH(const CTransaction &tx, block.vtx) {
+        BOOST_FOREACH(
+        const CTransaction &tx, block.vtx) {
             // ignore validation errors in resurrected transactions
             list <CTransaction> removed;
             CValidationState stateDummy;
@@ -3372,6 +3521,7 @@ bool static DisconnectTip(CValidationState &state, const CChainParams &chainpara
     }
     return true;
 }
+
 static int64_t nTimeReadFromDisk = 0;
 static int64_t nTimeConnectTotal = 0;
 static int64_t nTimeFlush = 0;
@@ -3382,7 +3532,8 @@ static int64_t nTimePostConnect = 0;
  * Connect a new block to chainActive. pblock is either NULL or a pointer to a CBlock
  * corresponding to pindexNew, to bypass loading it again from disk.
  */
-bool static ConnectTip(CValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexNew, const CBlock *pblock) {
+bool static
+ConnectTip(CValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexNew, const CBlock *pblock) {
     LogPrintf("ConnectTip() nHeight=%s\n", pindexNew->nHeight);
     assert(pindexNew->pprev == chainActive.Tip());
     // Read block from disk.
@@ -3410,7 +3561,8 @@ bool static ConnectTip(CValidationState &state, const CChainParams &chainparams,
         mapBlockSource.erase(pindexNew->GetBlockHash());
         nTime3 = GetTimeMicros();
         nTimeConnectTotal += nTime3 - nTime2;
-        LogPrint("bench", "  - Connect total: %.2fms [%.2fs]\n", (nTime3 - nTime2) * 0.001, nTimeConnectTotal * 0.000001);
+        LogPrint("bench", "  - Connect total: %.2fms [%.2fs]\n", (nTime3 - nTime2) * 0.001,
+                 nTimeConnectTotal * 0.000001);
         assert(view.Flush());
     }
     int64_t nTime4 = GetTimeMicros();
@@ -3431,11 +3583,13 @@ bool static ConnectTip(CValidationState &state, const CChainParams &chainparams,
     UpdateTip(pindexNew, chainparams);
     // Tell wallet about transactions that went from mempool
     // to conflicted:
-    BOOST_FOREACH(const CTransaction &tx, txConflicted) {
+    BOOST_FOREACH(
+    const CTransaction &tx, txConflicted) {
         SyncWithWallets(tx, pindexNew, NULL);
     }
     // ... and about transactions that got confirmed:
-    BOOST_FOREACH(const CTransaction &tx, pblock->vtx) {
+    BOOST_FOREACH(
+    const CTransaction &tx, pblock->vtx) {
         SyncWithWallets(tx, pindexNew, pblock);
     }
 
@@ -3448,11 +3602,64 @@ bool static ConnectTip(CValidationState &state, const CChainParams &chainparams,
     return true;
 }
 
+
+int GetUTXOHeight(const COutPoint &outpoint) {
+    LOCK(cs_main);
+    CCoins coins;
+    if (!pcoinsTip->GetCoins(outpoint.hash, coins) ||
+        (unsigned int) outpoint.n >= coins.vout.size() ||
+        coins.vout[outpoint.n].IsNull()) {
+        return -1;
+    }
+    return coins.nHeight;
+}
+
+int GetInputAge(const CTxIn &txin) {
+    CCoinsView viewDummy;
+    CCoinsViewCache view(&viewDummy);
+    {
+        LOCK(mempool.cs);
+        CCoinsViewMemPool viewMempool(pcoinsTip, mempool);
+        view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view
+
+        const CCoins *coins = view.AccessCoins(txin.prevout.hash);
+
+        if (coins) {
+            if (coins->nHeight < 0) return 0;
+            return chainActive.Height() - coins->nHeight + 1;
+        } else {
+            return -1;
+        }
+    }
+}
+
+CAmount GetZnodePayment(int nHeight, CAmount blockValue) {
+//    CAmount ret = blockValue * 30/100 ; // start at 30%
+//    int nMNPIBlock = Params().GetConsensus().nZnodePaymentsStartBlock;
+////    int nMNPIBlock = Params().GetConsensus().nZnodePaymentsIncreaseBlock;
+//    int nMNPIPeriod = Params().GetConsensus().nZnodePaymentsIncreasePeriod;
+//
+//    // mainnet:
+//    if (nHeight > nMNPIBlock) ret += blockValue / 20; // 158000 - 25.0% - 2014-10-24
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 1)) ret += blockValue / 20; // 175280 - 30.0% - 2014-11-25
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 2)) ret += blockValue / 20; // 192560 - 35.0% - 2014-12-26
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 3)) ret += blockValue / 40; // 209840 - 37.5% - 2015-01-26
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 4)) ret += blockValue / 40; // 227120 - 40.0% - 2015-02-27
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 5)) ret += blockValue / 40; // 244400 - 42.5% - 2015-03-30
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 6)) ret += blockValue / 40; // 261680 - 45.0% - 2015-05-01
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 7)) ret += blockValue / 40; // 278960 - 47.5% - 2015-06-01
+//    if (nHeight > nMNPIBlock + (nMNPIPeriod * 9)) ret += blockValue / 40; // 313520 - 50.0% - 2015-08-03
+    CAmount ret = 15 * COIN; //15XZC
+
+    return ret;
+}
+
 /**
  * Connect a new ZCblock to chainActive. pblock is either NULL or a pointer to a CBlock
  * corresponding to pindexNew, to bypass loading it again from disk.
  */
-bool static ConnectTipZC(CValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexNew, const CBlock *pblock) {
+bool static
+ConnectTipZC(CValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexNew, const CBlock *pblock) {
     CBlock block;
     if (!pblock) {
         if (!ReadBlockFromDisk(block, pindexNew, chainparams.GetConsensus()))
@@ -3470,7 +3677,8 @@ bool static ConnectTipZC(CValidationState &state, const CChainParams &chainparam
         BOOST_FOREACH(const CTxOut txout, tx.vout) {
             if (!txout.scriptPubKey.empty() && txout.scriptPubKey.IsZerocoinMint()) {
                 vector<unsigned char> vchZeroMint;
-                vchZeroMint.insert(vchZeroMint.end(), txout.scriptPubKey.begin() + 6, txout.scriptPubKey.begin() + txout.scriptPubKey.size());
+                vchZeroMint.insert(vchZeroMint.end(), txout.scriptPubKey.begin() + 6,
+                                   txout.scriptPubKey.begin() + txout.scriptPubKey.size());
 
                 CBigNum pubCoin;
                 pubCoin.setvch(vchZeroMint);
@@ -3487,7 +3695,8 @@ bool static ConnectTipZC(CValidationState &state, const CChainParams &chainparam
                         pubCoinTx.value = pubCoinItem.value;
                         pubCoinTx.nHeight = -1;
                         walletdb.WriteZerocoinEntry(pubCoinTx);
-                        LogPrintf("Pubcoin Connect Reset Pubcoin Denomination: %d Pubcoin Id: %d Height: %d\n", pubCoinTx.denomination, pubCoinTx.id, pubCoinItem.nHeight);
+                        LogPrintf("Pubcoin Connect Reset Pubcoin Denomination: %d Pubcoin Id: %d Height: %d\n",
+                                  pubCoinTx.denomination, pubCoinTx.id, pubCoinItem.nHeight);
                         zerocoinMintHeight = pindexNew->nHeight;
                     }
                 }
@@ -3501,7 +3710,8 @@ bool static ConnectTipZC(CValidationState &state, const CChainParams &chainparam
                         pubCoinTx.serialNumber = pubCoinItem.serialNumber;
                         pubCoinTx.value = pubCoin;
                         pubCoinTx.nHeight = -1;
-                        LogPrintf("Connect Reset Pubcoin Denomination: %d Pubcoin Id: %d Height: %d\n", pubCoinTx.denomination, pubCoinTx.id, pubCoinItem.nHeight);
+                        LogPrintf("Connect Reset Pubcoin Denomination: %d Pubcoin Id: %d Height: %d\n",
+                                  pubCoinTx.denomination, pubCoinTx.id, pubCoinItem.nHeight);
                         walletdb.WriteZerocoinEntry(pubCoinTx);
                     }
                 }
@@ -3511,11 +3721,55 @@ bool static ConnectTipZC(CValidationState &state, const CChainParams &chainparam
     return true;
 }
 
+bool DisconnectBlocks(int blocks) {
+    LOCK(cs_main);
+
+    CValidationState state;
+    const CChainParams &chainparams = Params();
+
+    LogPrintf("DisconnectBlocks -- Got command to replay %d blocks\n", blocks);
+    for (int i = 0; i < blocks; i++) {
+        if (!DisconnectTip(state, chainparams) || !state.IsValid()) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void ReprocessBlocks(int nBlocks) {
+    LOCK(cs_main);
+
+    std::map<uint256, int64_t>::iterator it = mapRejectedBlocks.begin();
+    while (it != mapRejectedBlocks.end()) {
+        //use a window twice as large as is usual for the nBlocks we want to reset
+        if ((*it).second > GetTime() - (nBlocks * 60 * 5)) {
+            BlockMap::iterator mi = mapBlockIndex.find((*it).first);
+            if (mi != mapBlockIndex.end() && (*mi).second) {
+
+                CBlockIndex *pindex = (*mi).second;
+                LogPrintf("ReprocessBlocks -- %s\n", (*it).first.ToString());
+
+                CValidationState state;
+                ReconsiderBlock(state, pindex);
+            }
+        }
+        ++it;
+    }
+
+    DisconnectBlocks(nBlocks);
+
+    CValidationState state;
+    ActivateBestChain(state, Params());
+}
+
+
 /**
  * Connect a new ZCblock to chainActive. pblock is either NULL or a pointer to a CBlock
  * corresponding to pindexNew, to bypass loading it again from disk.
  */
-bool static ReArrangeZcoinMint(CValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexNew, const CBlock *pblock) {
+bool static ReArrangeZcoinMint(CValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexNew,
+                               const CBlock *pblock) {
 //    LogPrintf("[ReArrangeZcoinMint]\n");
     CBlock block;
     if (!pblock) {
@@ -3528,9 +3782,11 @@ bool static ReArrangeZcoinMint(CValidationState &state, const CChainParams &chai
     CWalletDB walletdb(pwalletMain->strWalletFile);
     walletdb.ListPubCoin(listPubCoin);
 
-    BOOST_FOREACH(const CTransaction &tx, pblock->vtx){
+    BOOST_FOREACH(
+    const CTransaction &tx, pblock->vtx){
         // Check Mint Zerocoin Transaction
-        BOOST_FOREACH(const CTxOut txout, tx.vout) {
+        BOOST_FOREACH(
+        const CTxOut txout, tx.vout) {
             if (!txout.scriptPubKey.empty() && txout.scriptPubKey.IsZerocoinMint()) {
                 vector<unsigned char> vchZeroMint;
                 vchZeroMint.insert(vchZeroMint.end(), txout.scriptPubKey.begin() + 6,
@@ -3546,7 +3802,8 @@ bool static ReArrangeZcoinMint(CValidationState &state, const CChainParams &chai
                         int currentId = 1;
                         unsigned int countExistingItems = 0;
                         listPubCoin.sort(CompHeight);
-                        BOOST_FOREACH(const CZerocoinEntry &pubCoinIdItem, listPubCoin) {
+                        BOOST_FOREACH(
+                        const CZerocoinEntry &pubCoinIdItem, listPubCoin) {
 //                            LogPrintf("denomination = %d, id = %d, height = %d\n", pubCoinIdItem.denomination, pubCoinIdItem.id, pubCoinIdItem.nHeight);
                             if (pubCoinIdItem.id > 0) {
                                 if (pubCoinIdItem.nHeight <= pindexNew->nHeight) {
@@ -3617,7 +3874,8 @@ static CBlockIndex *FindMostWorkChain() {
             bool fMissingData = !(pindexTest->nStatus & BLOCK_HAVE_DATA);
             if (fFailedChain || fMissingData) {
                 // Candidate chain is not usable (either invalid or missing data)
-                if (fFailedChain && (pindexBestInvalid == NULL || pindexNew->nChainWork > pindexBestInvalid->nChainWork))
+                if (fFailedChain &&
+                    (pindexBestInvalid == NULL || pindexNew->nChainWork > pindexBestInvalid->nChainWork))
                     pindexBestInvalid = pindexNew;
                 CBlockIndex *pindexFailed = pindexNew;
                 // Remove the entire chain from the set.
@@ -3677,9 +3935,9 @@ static bool ActivateBestChainStep(CValidationState &state, const CChainParams &c
     }
     int nHeight = pindexFork ? pindexFork->nHeight : -1;
     // Build list of new blocks to connect.
-    std::vector <CBlockIndex *> vpindexToConnect;
+    std::vector < CBlockIndex * > vpindexToConnect;
     //btzc: add zcoin code
-    std::vector <CBlockIndex *> vpindexToConnectZC;
+    std::vector < CBlockIndex * > vpindexToConnectZC;
     bool fContinue = true;
 //    LogPrintf("[ActivateBestChainStep] fContinue=%d, nHeight=%d, pindexMostWork->nHeight=%d\n", fContinue, nHeight, pindexMostWork->nHeight);
     while (fContinue && nHeight != pindexMostWork->nHeight) {
@@ -3722,10 +3980,12 @@ static bool ActivateBestChainStep(CValidationState &state, const CChainParams &c
                 }
             }
         }
-        BOOST_FOREACH(CBlockIndex * pindexConnect, vpindexToConnect){
+        BOOST_FOREACH(CBlockIndex * pindexConnect, vpindexToConnect)
+        {
             ConnectTipZC(state, chainparams, pindexConnect, pindexConnect == pindexMostWork ? pblock : NULL);
         }
-        BOOST_FOREACH(CBlockIndex * pindexConnect, vpindexToConnectZC){
+        BOOST_FOREACH(CBlockIndex * pindexConnect, vpindexToConnectZC)
+        {
             ReArrangeZcoinMint(state, chainparams, pindexConnect, pindexConnect == pindexMostWork ? pblock : NULL);
         }
     }
@@ -3808,11 +4068,13 @@ bool ActivateBestChain(CValidationState &state, const CChainParams &chainparams,
 
             // Whether we have anything to do at all.
             if (pindexMostWork == NULL || pindexMostWork == chainActive.Tip()) {
-                    return true;
+                return true;
             }
 
             bool fInvalidFound = false;
-            if (!ActivateBestChainStep(state, chainparams, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : NULL, fInvalidFound)) {
+            if (!ActivateBestChainStep(state, chainparams, pindexMostWork,
+                                       pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : NULL,
+                                       fInvalidFound)) {
                 LogPrintf("ActivateBestChainStep --> Failed!\n");
                 return false;
             }
@@ -3852,8 +4114,7 @@ bool ActivateBestChain(CValidationState &state, const CChainParams &chainparams,
                     BOOST_FOREACH(CNode * pnode, vNodes)
                     {
                         if (nNewHeight > (pnode->nStartingHeight != -1 ? pnode->nStartingHeight - 2000 : 0)) {
-                            BOOST_REVERSE_FOREACH(
-                            const uint256 &hash, vHashes) {
+                            BOOST_REVERSE_FOREACH(const uint256 &hash, vHashes) {
                                 pnode->PushBlockHash(hash);
                             }
                         }
@@ -3917,6 +4178,41 @@ bool InvalidateBlock(CValidationState &state, const CChainParams &chainparams, C
     return true;
 }
 
+bool ReconsiderBlock(CValidationState &state, CBlockIndex *pindex) {
+    AssertLockHeld(cs_main);
+
+    int nHeight = pindex->nHeight;
+
+    // Remove the invalidity flag from this block and all its descendants.
+    BlockMap::iterator it = mapBlockIndex.begin();
+    while (it != mapBlockIndex.end()) {
+        if (!it->second->IsValid() && it->second->GetAncestor(nHeight) == pindex) {
+            it->second->nStatus &= ~BLOCK_FAILED_MASK;
+            setDirtyBlockIndex.insert(it->second);
+            if (it->second->IsValid(BLOCK_VALID_TRANSACTIONS) && it->second->nChainTx &&
+                setBlockIndexCandidates.value_comp()(chainActive.Tip(), it->second)) {
+                setBlockIndexCandidates.insert(it->second);
+            }
+            if (it->second == pindexBestInvalid) {
+                // Reset invalid block marker if it was pointing to one of those.
+                pindexBestInvalid = NULL;
+            }
+        }
+        it++;
+    }
+
+    // Remove the invalidity flag from all ancestors too.
+    while (pindex != NULL) {
+        if (pindex->nStatus & BLOCK_FAILED_MASK) {
+            pindex->nStatus &= ~BLOCK_FAILED_MASK;
+            setDirtyBlockIndex.insert(pindex);
+        }
+        pindex = pindex->pprev;
+    }
+    return true;
+}
+
+
 bool ResetBlockFailureFlags(CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
 
@@ -4122,7 +4418,8 @@ bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigne
 }
 
 //btzc: code from vertcoin, add
-bool CheckBlockHeader(const CBlockHeader &block, CValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW) {
+bool CheckBlockHeader(const CBlockHeader &block, CValidationState &state, const Consensus::Params &consensusParams,
+                      bool fCheckPOW) {
     int nHeight = getNHeight(block);
     if (fCheckPOW && !CheckProofOfWork(block.GetPoWHash(nHeight), block.nBits, consensusParams)) {
         return state.DoS(50, false, REJECT_INVALID, "high-hash", false, "proof of work failed");
@@ -4132,7 +4429,8 @@ bool CheckBlockHeader(const CBlockHeader &block, CValidationState &state, const
 
 bool CheckBlock(const CBlock &block, CValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW,
                 bool fCheckMerkleRoot, int nHeight, bool isVerifyDB) {
-    LogPrintf("CheckBlock() nHeight=%s, blockHash= %s, isVerifyDB = %s\n", nHeight, block.GetHash().ToString(), isVerifyDB);
+    LogPrintf("CheckBlock() nHeight=%s, blockHash= %s, isVerifyDB = %s\n", nHeight, block.GetHash().ToString(),
+              isVerifyDB);
     try {
         // These are checks that are independent of context.
         if (block.fChecked)
@@ -4187,6 +4485,36 @@ bool CheckBlock(const CBlock &block, CValidationState &state, const Consensus::P
             }
 
         }
+
+        // DASH : CHECK TRANSACTIONS FOR INSTANTSEND
+        if(sporkManager.IsSporkActive(SPORK_3_INSTANTSEND_BLOCK_FILTERING)) {
+            // We should never accept block which conflicts with completed transaction lock,
+            // that's why this is in CheckBlock unlike coinbase payee/amount.
+            // Require other nodes to comply, send them some data in case they are missing it.
+            BOOST_FOREACH(const CTransaction& tx, block.vtx) {
+                // skip coinbase, it has no inputs
+                if (tx.IsCoinBase()) continue;
+                // LOOK FOR TRANSACTION LOCK IN OUR MAP OF OUTPOINTS
+                BOOST_FOREACH(const CTxIn& txin, tx.vin) {
+                    uint256 hashLocked;
+                    if(instantsend.GetLockedOutPointTxHash(txin.prevout, hashLocked) && hashLocked != tx.GetHash()) {
+                        // Every node which relayed this block to us must invalidate it
+                        // but they probably need more data.
+                        // Relay corresponding transaction lock request and all its votes
+                        // to let other nodes complete the lock.
+                        instantsend.Relay(hashLocked);
+                        LOCK(cs_main);
+                        mapRejectedBlocks.insert(make_pair(block.GetHash(), GetTime()));
+                        return state.DoS(0, error("CheckBlock(XZC): transaction %s conflicts with transaction lock %s",
+                                                  tx.GetHash().ToString(), hashLocked.ToString()),
+                                         REJECT_INVALID, "conflict-tx-lock");
+                    }
+                }
+            }
+        } else {
+            LogPrintf("CheckBlock(XZC): spork is off, skipping transaction locking checks\n");
+        }
+
         // Check transactions
         if (nHeight == INT_MAX)
             nHeight = getNHeight(block.GetBlockHeader());
@@ -4197,7 +4525,8 @@ bool CheckBlock(const CBlock &block, CValidationState &state, const Consensus::P
                                            state.GetDebugMessage()));
         }
         unsigned int nSigOps = 0;
-        BOOST_FOREACH(const CTransaction &tx, block.vtx)
+        BOOST_FOREACH(
+        const CTransaction &tx, block.vtx)
         {
             nSigOps += GetLegacySigOpCount(tx);
         }
@@ -4215,7 +4544,8 @@ bool CheckBlock(const CBlock &block, CValidationState &state, const Consensus::P
     return true;
 }
 
-static bool CheckIndexAgainstCheckpoint(const CBlockIndex *pindexPrev, CValidationState &state, const CChainParams &chainparams,
+static bool
+CheckIndexAgainstCheckpoint(const CBlockIndex *pindexPrev, CValidationState &state, const CChainParams &chainparams,
                             const uint256 &hash) {
     if (*pindexPrev->phashBlock == chainparams.GetConsensus().hashGenesisBlock)
         return true;
@@ -4260,7 +4590,8 @@ void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPr
     }
 }
 
-std::vector<unsigned char>GenerateCoinbaseCommitment(CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams) {
+std::vector<unsigned char>
+GenerateCoinbaseCommitment(CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams) {
     std::vector<unsigned char> commitment;
     int commitpos = GetWitnessCommitmentIndex(block);
     std::vector<unsigned char> ret(32, 0x00);
@@ -4288,7 +4619,8 @@ std::vector<unsigned char>GenerateCoinbaseCommitment(CBlock &block, const CBlock
     return commitment;
 }
 
-bool ContextualCheckBlockHeader(const CBlockHeader &block, CValidationState &state, const Consensus::Params &consensusParams,
+bool
+ContextualCheckBlockHeader(const CBlockHeader &block, CValidationState &state, const Consensus::Params &consensusParams,
                            CBlockIndex *const pindexPrev, int64_t nAdjustedTime) {
     // Check proof of work
     if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
@@ -4329,7 +4661,8 @@ bool ContextualCheckBlock(const CBlock &block, CValidationState &state, CBlockIn
                               : block.GetBlockTime();
 
     // Check that all transactions are finalized
-    BOOST_FOREACH(const CTransaction &tx, block.vtx) {
+    BOOST_FOREACH(
+    const CTransaction &tx, block.vtx) {
         if (!IsFinalTx(tx, nHeight, nLockTimeCutoff)) {
             return state.DoS(10, false, REJECT_INVALID, "bad-txns-nonfinal", false, "non-final transaction");
         }
@@ -4337,10 +4670,12 @@ bool ContextualCheckBlock(const CBlock &block, CValidationState &state, CBlockIn
 
     // Enforce block.nVersion=2 rule that the coinbase starts with serialized block height
     // if 750 of the last 1,000 blocks are version 2 or greater (51/100 if testnet):
-    if ((block.nVersion&0xff) >= 2 && IsSuperMajority(2, pindexPrev, consensusParams.nMajorityEnforceBlockUpgrade, consensusParams)) {
+    if ((block.nVersion & 0xff) >= 2 &&
+        IsSuperMajority(2, pindexPrev, consensusParams.nMajorityEnforceBlockUpgrade, consensusParams)) {
         CScript expect = CScript() << nHeight;
 //        LogPrintf("block.vtx[0].vin[0].scriptSig.begin()=%s\n", block.vtx[0].vin[0].scriptSig.begin());
-        if (block.vtx[0].vin[0].scriptSig.size() < expect.size() || !std::equal(expect.begin(), expect.end(), block.vtx[0].vin[0].scriptSig.begin())) {
+        if (block.vtx[0].vin[0].scriptSig.size() < expect.size() ||
+            !std::equal(expect.begin(), expect.end(), block.vtx[0].vin[0].scriptSig.begin())) {
             return state.DoS(100, false, REJECT_INVALID, "bad-cb-height", false, "block height mismatch in coinbase");
         }
     }
@@ -4465,7 +4800,8 @@ static bool AcceptBlockHeader(const CBlockHeader &block, CValidationState &state
 }
 
 /** Store block on disk. If dbp is non-NULL, the file is known to already reside on disk */
-static bool AcceptBlock(const CBlock &block, CValidationState &state, const CChainParams &chainparams, CBlockIndex **ppindex,
+static bool
+AcceptBlock(const CBlock &block, CValidationState &state, const CChainParams &chainparams, CBlockIndex **ppindex,
             bool fRequested, const CDiskBlockPos *dbp, bool *fNewBlock) {
     if (fNewBlock) *fNewBlock = false;
     AssertLockHeld(cs_main);
@@ -4577,10 +4913,13 @@ bool ProcessNewBlock(CValidationState &state, const CChainParams &chainparams, C
         return error("%s: ActivateBestChain failed", __func__);
     }
 
+    znodeSync.IsBlockchainSynced(true);
+
     return true;
 }
 
-bool TestBlockValidity(CValidationState &state, const CChainParams &chainparams, const CBlock &block, CBlockIndex *pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot) {
+bool TestBlockValidity(CValidationState &state, const CChainParams &chainparams, const CBlock &block,
+                       CBlockIndex *pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot) {
     AssertLockHeld(cs_main);
     assert(pindexPrev && pindexPrev == chainActive.Tip());
     if (fCheckpointsEnabled && !CheckIndexAgainstCheckpoint(pindexPrev, state, chainparams, block.GetHash()))
@@ -4783,13 +5122,15 @@ bool static LoadBlockIndexDB() {
     // Calculate nChainWork
     vector <pair<int, CBlockIndex *>> vSortedByHeight;
     vSortedByHeight.reserve(mapBlockIndex.size());
-    BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*) &item, mapBlockIndex)
+    BOOST_FOREACH(
+    const PAIRTYPE(uint256, CBlockIndex*) &item, mapBlockIndex)
     {
         CBlockIndex *pindex = item.second;
         vSortedByHeight.push_back(make_pair(pindex->nHeight, pindex));
     }
     sort(vSortedByHeight.begin(), vSortedByHeight.end());
-    BOOST_FOREACH(const PAIRTYPE(int, CBlockIndex*) &item, vSortedByHeight)
+    BOOST_FOREACH(
+    const PAIRTYPE(int, CBlockIndex*) &item, vSortedByHeight)
     {
         CBlockIndex *pindex = item.second;
         pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) + GetBlockProof(*pindex);
@@ -5178,7 +5519,8 @@ bool LoadExternalBlockFile(const CChainParams &chainparams, FILE *fileIn, CDiskB
     int nLoaded = 0;
     try {
         // This takes over fileIn and calls fclose() on it in the CBufferedFile destructor
-        CBufferedFile blkdat(fileIn, 2 * MAX_BLOCK_SERIALIZED_SIZE, MAX_BLOCK_SERIALIZED_SIZE + 8, SER_DISK, CLIENT_VERSION);
+        CBufferedFile blkdat(fileIn, 2 * MAX_BLOCK_SERIALIZED_SIZE, MAX_BLOCK_SERIALIZED_SIZE + 8, SER_DISK,
+                             CLIENT_VERSION);
         uint64_t nRewind = blkdat.GetPos();
         while (!blkdat.eof()) {
             boost::this_thread::interruption_point();
@@ -5248,7 +5590,7 @@ bool LoadExternalBlockFile(const CChainParams &chainparams, FILE *fileIn, CDiskB
                 } else if (hash != chainparams.GetConsensus().hashGenesisBlock &&
                            mapBlockIndex[hash]->nHeight % 1000 == 0) {
                     LogPrintf("Block Import: already had block %s at height %d\n", hash.ToString(),
-                             mapBlockIndex[hash]->nHeight);
+                              mapBlockIndex[hash]->nHeight);
                 }
 
                 // Activate the genesis block so normal node progress can continue
@@ -5561,7 +5903,6 @@ std::string GetWarnings(const std::string &strFor) {
 // Messages
 //
 
-
 bool static AlreadyHave(const CInv &inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     switch (inv.type) {
         case MSG_TX:
@@ -5586,6 +5927,44 @@ bool static AlreadyHave(const CInv &inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
         case MSG_BLOCK:
         case MSG_WITNESS_BLOCK:
             return mapBlockIndex.count(inv.hash);
+    /*
+        Dash Related Inventory Messages
+
+        --
+
+        We shouldn't update the sync times for each of the messages when we already have it.
+        We're going to be asking many nodes upfront for the full inventory list, so we'll get duplicates of these.
+        We want to only update the time on new hits, so that we can time out appropriately if needed.
+    */
+        case MSG_TXLOCK_REQUEST:
+            return instantsend.AlreadyHave(inv.hash);
+
+        case MSG_TXLOCK_VOTE:
+            return instantsend.AlreadyHave(inv.hash);
+
+        case MSG_SPORK:
+            return mapSporks.count(inv.hash);
+
+        case MSG_ZNODE_PAYMENT_VOTE:
+            return mnpayments.mapZnodePaymentVotes.count(inv.hash);
+
+        case MSG_ZNODE_PAYMENT_BLOCK:
+        {
+            BlockMap::iterator mi = mapBlockIndex.find(inv.hash);
+            return mi != mapBlockIndex.end() && mnpayments.mapZnodeBlocks.find(mi->second->nHeight) != mnpayments.mapZnodeBlocks.end();
+        }
+
+        case MSG_ZNODE_ANNOUNCE:
+            return mnodeman.mapSeenZnodeBroadcast.count(inv.hash) && !mnodeman.IsMnbRecoveryRequested(inv.hash);
+
+        case MSG_ZNODE_PING:
+            return mnodeman.mapSeenZnodePing.count(inv.hash);
+
+        case MSG_DSTX:
+            return mapDarksendBroadcastTxes.count(inv.hash);
+
+        case MSG_ZNODE_VERIFY:
+            return mnodeman.mapSeenZnodeVerification.count(inv.hash);
     }
     // Don't know what it is, just say we already got one
     return true;
@@ -5607,7 +5986,6 @@ void static ProcessGetData(CNode *pfrom, const Consensus::Params &consensusParam
         {
             boost::this_thread::interruption_point();
             it++;
-
             if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK || inv.type == MSG_CMPCT_BLOCK ||
                 inv.type == MSG_WITNESS_BLOCK) {
                 bool send = false;
@@ -5708,26 +6086,148 @@ void static ProcessGetData(CNode *pfrom, const Consensus::Params &consensusParam
                     }
                 }
             } else if (inv.type == MSG_TX || inv.type == MSG_WITNESS_TX) {
-                // Send stream from relay memory
-                bool push = false;
-                auto mi = mapRelay.find(inv.hash);
-                if (mi != mapRelay.end()) {
-                    pfrom->PushMessageWithFlag(inv.type == MSG_TX ? SERIALIZE_TRANSACTION_NO_WITNESS : 0,
-                                               NetMsgType::TX, *mi->second);
-                    push = true;
-                } else if (pfrom->timeLastMempoolReq) {
-                    auto txinfo = mempool.info(inv.hash);
-                    // To protect privacy, do not answer getdata using the mempool when
-                    // that TX couldn't have been INVed in reply to a MEMPOOL request.
-                    if (txinfo.tx && txinfo.nTime <= pfrom->timeLastMempoolReq) {
+                    // Send stream from relay memory
+                    bool push = false;
+                    auto mi = mapRelay.find(inv.hash);
+                    if (mi != mapRelay.end()) {
                         pfrom->PushMessageWithFlag(inv.type == MSG_TX ? SERIALIZE_TRANSACTION_NO_WITNESS : 0,
-                                                   NetMsgType::TX, *txinfo.tx);
+                                                   NetMsgType::TX, *mi->second);
                         push = true;
+                    } else if (pfrom->timeLastMempoolReq) {
+                        auto txinfo = mempool.info(inv.hash);
+                        // To protect privacy, do not answer getdata using the mempool when
+                        // that TX couldn't have been INVed in reply to a MEMPOOL request.
+                        if (txinfo.tx && txinfo.nTime <= pfrom->timeLastMempoolReq) {
+                            pfrom->PushMessageWithFlag(inv.type == MSG_TX ? SERIALIZE_TRANSACTION_NO_WITNESS : 0,
+                                                       NetMsgType::TX, *txinfo.tx);
+                            push = true;
+                        }
+                    }
+                    if (!push) {
+                        vNotFound.push_back(inv);
+                    }
+
+//            } else if (inv.IsKnownType()) {
+            } else {
+//                LogPrintf("inv.type()=%s, inv.GetCommand=%s\n", inv.type, inv.GetCommand());
+                // Send stream from relay memory
+                bool pushed = false;
+                {
+                    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                    auto mi = mapRelay.find(inv.hash);
+                    if (mi != mapRelay.end()) {
+                        ss << (*mi).second;
+                        pushed = true;
+                    }
+                    if(pushed && inv.GetCommand()) {
+                        LogPrintf("pushed && inv.GetCommand()=%s\n", inv.GetCommand());
+                        pfrom->PushMessage(inv.GetCommand(), ss);
                     }
                 }
-                if (!push) {
-                    vNotFound.push_back(inv);
+
+                if (!pushed && inv.type == MSG_TXLOCK_REQUEST) {
+                    CTxLockRequest txLockRequest;
+                    if(instantsend.GetTxLockRequest(inv.hash, txLockRequest)) {
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << txLockRequest;
+                        pfrom->PushMessage(NetMsgType::TXLOCKREQUEST, ss);
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed && inv.type == MSG_TXLOCK_VOTE) {
+                    CTxLockVote vote;
+                    if(instantsend.GetTxLockVote(inv.hash, vote)) {
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << vote;
+                        pfrom->PushMessage(NetMsgType::TXLOCKVOTE, ss);
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed && inv.type == MSG_SPORK) {
+                    if(mapSporks.count(inv.hash)) {
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << mapSporks[inv.hash];
+                        pfrom->PushMessage(NetMsgType::SPORK, ss);
+                        pushed = true;
+                    }
                 }
+
+                if (!pushed && inv.type == MSG_ZNODE_PAYMENT_VOTE) {
+                    if(mnpayments.HasVerifiedPaymentVote(inv.hash)) {
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << mnpayments.mapZnodePaymentVotes[inv.hash];
+                        pfrom->PushMessage(NetMsgType::ZNODEPAYMENTVOTE, ss);
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed && inv.type == MSG_ZNODE_PAYMENT_BLOCK) {
+                    BlockMap::iterator mi = mapBlockIndex.find(inv.hash);
+                    LOCK(cs_mapZnodeBlocks);
+                    if (mi != mapBlockIndex.end() && mnpayments.mapZnodeBlocks.count(mi->second->nHeight)) {
+                        BOOST_FOREACH(CZnodePayee& payee, mnpayments.mapZnodeBlocks[mi->second->nHeight].vecPayees) {
+                            std::vector<uint256> vecVoteHashes = payee.GetVoteHashes();
+                            BOOST_FOREACH(uint256& hash, vecVoteHashes) {
+                                if(mnpayments.HasVerifiedPaymentVote(hash)) {
+                                    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                                    ss.reserve(1000);
+                                    ss << mnpayments.mapZnodePaymentVotes[hash];
+                                    pfrom->PushMessage(NetMsgType::ZNODEPAYMENTVOTE, ss);
+                                }
+                            }
+                        }
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed && inv.type == MSG_ZNODE_ANNOUNCE) {
+                    if(mnodeman.mapSeenZnodeBroadcast.count(inv.hash)){
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << mnodeman.mapSeenZnodeBroadcast[inv.hash].second;
+                        pfrom->PushMessage(NetMsgType::MNANNOUNCE, ss);
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed && inv.type == MSG_ZNODE_PING) {
+                    if(mnodeman.mapSeenZnodePing.count(inv.hash)) {
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << mnodeman.mapSeenZnodePing[inv.hash];
+                        pfrom->PushMessage(NetMsgType::MNPING, ss);
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed && inv.type == MSG_DSTX) {
+                    if(mapDarksendBroadcastTxes.count(inv.hash)) {
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << mapDarksendBroadcastTxes[inv.hash];
+                        pfrom->PushMessage(NetMsgType::DSTX, ss);
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed && inv.type == MSG_ZNODE_VERIFY) {
+                    if(mnodeman.mapSeenZnodeVerification.count(inv.hash)) {
+                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+                        ss.reserve(1000);
+                        ss << mnodeman.mapSeenZnodeVerification[inv.hash];
+                        pfrom->PushMessage(NetMsgType::MNVERIFY, ss);
+                        pushed = true;
+                    }
+                }
+
+                if (!pushed)
+                    vNotFound.push_back(inv);
             }
 
             // Track requests for our stuff.
@@ -5768,6 +6268,8 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
         return true;
     }
 
+    LogPrint("main", "ProcessMessage, strCommand=%s\n", strCommand);
+
 
     if (!(nLocalServices & NODE_BLOOM) &&
         (strCommand == NetMsgType::FILTERLOAD ||
@@ -5811,19 +6313,22 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
             addrman.SetServices(pfrom->addr, pfrom->nServices);
         }
         if (pfrom->nServicesExpected & ~pfrom->nServices) {
-//            LogPrintf("peer=%d does not offer the expected services (%08x offered, %08x expected); disconnecting\n",
-//                     pfrom->id, pfrom->nServices, pfrom->nServicesExpected);
-            pfrom->PushMessage(NetMsgType::REJECT, strCommand, REJECT_NONSTANDARD,
-                               strprintf("Expected to offer services %08x", pfrom->nServicesExpected));
+            // LogPrintf("peer=%d does not offer the expected services (%08x offered, %08x expected); disconnecting\n", pfrom->id, pfrom->nServices, pfrom->nServicesExpected);
+            pfrom->PushMessage(NetMsgType::REJECT, strCommand, REJECT_NONSTANDARD, strprintf("Expected to offer services %08x", pfrom->nServicesExpected));
             pfrom->fDisconnect = true;
             return false;
         }
 
-        if (pfrom->nVersion < MIN_PEER_PROTO_VERSION) {
+        int nHeight;
+        {
+            LOCK(cs_main);
+            nHeight = chainActive.Height();
+        }
+        int minPeerVersion = (nHeight + 1 < HF_ZNODE_HEIGHT) ? MIN_PEER_PROTO_VERSION : MIN_PEER_PROTO_VERSION_AFTER_ZNODE_PAYMENT_HF;
+        if (pfrom->nVersion < minPeerVersion) {
             // disconnect from peers older than this proto version
-//            LogPrintf("peer=%d using obsolete version %i; disconnecting\n", pfrom->id, pfrom->nVersion);
-            pfrom->PushMessage(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE,
-                               strprintf("Version must be %d or greater", MIN_PEER_PROTO_VERSION));
+            // LogPrintf("peer=%d using obsolete version %i; disconnecting\n", pfrom->id, pfrom->nVersion);
+            pfrom->PushMessage(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE, strprintf("Version must be %d or greater", minPeerVersion));
             pfrom->fDisconnect = true;
             return false;
         }
@@ -6063,6 +6568,11 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
 
             boost::this_thread::interruption_point();
 
+//            if(!inv.IsKnownType()) {
+//                LogPrint("net", "got inv of unknown type %d: %s peer=%d\n", inv.type, inv.hash.ToString(), pfrom->id);
+//                continue;
+//            }
+
             bool fAlreadyHave = AlreadyHave(inv);
 //            LogPrint("net", "got inv: %s  %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom->id);
 
@@ -6104,8 +6614,7 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
                 if (fBlocksOnly) {
                     LogPrint("net", "transaction (%s) inv sent in violation of protocol peer=%d\n", inv.hash.ToString(),
                              pfrom->id);
-                }
-                else if (!fAlreadyHave && !fImporting && !fReindex && !IsInitialBlockDownload())
+                } else if (!fAlreadyHave && !fImporting && !fReindex && !IsInitialBlockDownload())
                     pfrom->AskFor(inv);
             }
 
@@ -6120,7 +6629,9 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
 
         if (!vToFetch.empty())
             pfrom->PushMessage(NetMsgType::GETDATA, vToFetch);
+
     } else if (strCommand == NetMsgType::GETDATA) {
+        LogPrintf("ProcessMessage=%s\n", strCommand);
         vector <CInv> vInv;
         vRecv >> vInv;
         if (vInv.size() > MAX_INV_SZ) {
@@ -6128,13 +6639,12 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
             Misbehaving(pfrom->GetId(), 20);
             return error("message getdata size() = %u", vInv.size());
         }
-
         if (fDebug || (vInv.size() != 1)) {
             LogPrint("net", "received getdata (%u invsz) peer=%d\n", vInv.size(), pfrom->id);
         }
 
         if ((fDebug && vInv.size() > 0) || (vInv.size() == 1)) {
-            LogPrint("net", "received getdata for: %s peer=%d\n", vInv[0].ToString(), pfrom->id);
+            LogPrint("net", "received getdata for: peer=%d\n", pfrom->id);
         }
 
         pfrom->vRecvGetData.insert(pfrom->vRecvGetData.end(), vInv.begin(), vInv.end());
@@ -6168,7 +6678,7 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
             if (fPruneMode && (!(pindex->nStatus & BLOCK_HAVE_DATA) ||
                                pindex->nHeight <= chainActive.Tip()->nHeight - nPrunedBlocksLikelyToHave)) {
                 LogPrintf("getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight,
-                         pindex->GetBlockHash().ToString());
+                          pindex->GetBlockHash().ToString());
                 break;
             }
             pfrom->PushInventory(CInv(MSG_BLOCK, pindex->GetBlockHash()));
@@ -6266,7 +6776,8 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
         // pindexBestHeaderSent to be our tip.
         nodestate->pindexBestHeaderSent = pindex ? pindex : chainActive.Tip();
         pfrom->PushMessage(NetMsgType::HEADERS, vHeaders);
-    } else if (strCommand == NetMsgType::TX) {
+    } else if (strCommand == NetMsgType::TX || strCommand == NetMsgType::DSTX ||
+               strCommand == NetMsgType::TXLOCKREQUEST) {
         // Stop processing the transaction early if
         // We are in blocks only mode and peer is either not whitelisted or whitelistrelay is off
         if (!fRelayTxes && (!pfrom->fWhitelisted || !GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY))) {
@@ -6276,13 +6787,68 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
 
         deque <COutPoint> vWorkQueue;
         vector <uint256> vEraseQueue;
+        CTxLockRequest txLockRequest;
+        CDarksendBroadcastTx dstx;
+        int nInvType = MSG_TX;
         CTransaction tx;
-        vRecv >> tx;
+//        vRecv >> tx;
         LogPrintf("ProcessMessage() txHash=%s\n", tx.GetHash().ToString());
 
-        CInv inv(MSG_TX, tx.GetHash());
+        // Read data and assign inv type
+        if (strCommand == NetMsgType::TX) {
+            vRecv >> tx;
+        } else if (strCommand == NetMsgType::TXLOCKREQUEST) {
+            vRecv >> txLockRequest;
+            tx = txLockRequest;
+            nInvType = MSG_TXLOCK_REQUEST;
+        } else if (strCommand == NetMsgType::DSTX) {
+            vRecv >> dstx;
+            tx = dstx.tx;
+            nInvType = MSG_DSTX;
+        }
+
+        CInv inv(nInvType, tx.GetHash());
         pfrom->AddInventoryKnown(inv);
 
+        // Process custom logic, no matter if tx will be accepted to mempool later or not
+        if (strCommand == NetMsgType::TXLOCKREQUEST) {
+            if (!instantsend.ProcessTxLockRequest(txLockRequest)) {
+                LogPrint("instantsend", "TXLOCKREQUEST -- failed %s\n", txLockRequest.GetHash().ToString());
+                return false;
+            }
+        } else if (strCommand == NetMsgType::DSTX) {
+            uint256 hashTx = tx.GetHash();
+
+            if (mapDarksendBroadcastTxes.count(hashTx)) {
+                LogPrint("privatesend", "DSTX -- Already have %s, skipping...\n", hashTx.ToString());
+                return true; // not an error
+            }
+
+            CZnode *pmn = mnodeman.Find(dstx.vin);
+            if (pmn == NULL) {
+                LogPrint("privatesend", "DSTX -- Can't find znode %s to verify %s\n",
+                         dstx.vin.prevout.ToStringShort(), hashTx.ToString());
+                return false;
+            }
+
+            if (!pmn->fAllowMixingTx) {
+                LogPrint("privatesend", "DSTX -- Znode %s is sending too many transactions %s\n",
+                         dstx.vin.prevout.ToStringShort(), hashTx.ToString());
+                return true;
+                // TODO: Not an error? Could it be that someone is relaying old DSTXes
+                // we have no idea about (e.g we were offline)? How to handle them?
+            }
+
+            if (!dstx.CheckSignature(pmn->pubKeyZnode)) {
+                LogPrint("privatesend", "DSTX -- CheckSignature() failed for %s\n", hashTx.ToString());
+                return false;
+            }
+
+            LogPrintf("DSTX -- Got Znode transaction %s\n", hashTx.ToString());
+            mempool.PrioritiseTransaction(hashTx, hashTx.ToString(), 1000, 0.1 * COIN);
+            pmn->fAllowMixingTx = false;
+        }
+
         LOCK(cs_main);
 
         bool fMissingInputs = false;
@@ -6327,7 +6893,8 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
 
                     if (setMisbehaving.count(fromPeer))
                         continue;
-                    if (AcceptToMemoryPool(mempool, stateDummy, orphanTx, true, true, &fMissingInputs2, false, 0, true)) {
+                    if (AcceptToMemoryPool(mempool, stateDummy, orphanTx, true, true, &fMissingInputs2, false, 0,
+                                           true)) {
 //                        LogPrintf("Accepted orphan tx %s\n", orphanHash.ToString());
                         RelayTransaction(orphanTx);
                         for (unsigned int i = 0; i < orphanTx.vout.size(); i++) {
@@ -6358,8 +6925,9 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
                 }
             }
 
-            BOOST_FOREACH(uint256 hash, vEraseQueue)
-                EraseOrphanTx(hash);
+            BOOST_FOREACH(uint256
+            hash, vEraseQueue)
+            EraseOrphanTx(hash);
             //btzc: zcoin condition
         } else if (!AlreadyHave(inv) && tx.IsZerocoinSpend() && AcceptToMemoryPool(mempool, state, tx, false, true, &fMissingInputsZerocoin, false, 0, true)) {
             RelayTransaction(tx);
@@ -6370,7 +6938,8 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
 
         } else if (fMissingInputs) {
             bool fRejectedParents = false; // It may be the case that the orphans parents have all been rejected
-            BOOST_FOREACH(const CTxIn &txin, tx.vin) {
+            BOOST_FOREACH(
+            const CTxIn &txin, tx.vin) {
                 if (recentRejects->contains(txin.prevout.hash)) {
                     fRejectedParents = true;
                     break;
@@ -6714,7 +7283,8 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
 
             LogPrintf("ProcessMessage.AcceptBlockHeader() total %s blocks\n", headers.size());
             CBlockIndex *pindexLast = NULL;
-            BOOST_FOREACH(const CBlockHeader &header, headers) {
+            BOOST_FOREACH(
+            const CBlockHeader &header, headers) {
                 CValidationState state;
 //                int64_t start = std::chrono::duration_cast<std::chrono::milliseconds>(
 //                        std::chrono::system_clock::now().time_since_epoch()).count();
@@ -7029,11 +7599,30 @@ bool static ProcessMessage(CNode *pfrom, string strCommand, CDataStream &vRecv,
         // We do not care about the NOTFOUND message, but logging an Unknown Command
         // message would be undesirable as we transmit it ourselves.
     } else {
+//        LogPrintf("Main.cpp ProcessMessage() strCommand=%s\n", strCommand);
         // Ignore unknown commands for extensibility
-//        LogPrint("net", "Unknown command \"%s\" from peer=%d\n", SanitizeString(strCommand), pfrom->id);
-    }
-
+        bool found = false;
+        const std::vector <std::string> &allMessages = getAllNetMessageTypes();
+        BOOST_FOREACH(const std::string msg, allMessages) {
+            if (msg == strCommand) {
+                found = true;
+                break;
+            }
+        }
 
+        if (found) {
+            //probably one the extensions
+            darkSendPool.ProcessMessage(pfrom, strCommand, vRecv);
+            mnodeman.ProcessMessage(pfrom, strCommand, vRecv);
+            mnpayments.ProcessMessage(pfrom, strCommand, vRecv);
+            instantsend.ProcessMessage(pfrom, strCommand, vRecv);
+            sporkManager.ProcessSpork(pfrom, strCommand, vRecv);
+            znodeSync.ProcessMessage(pfrom, strCommand, vRecv);
+        } else {
+            // Ignore unknown commands for extensibility
+            LogPrint("net", "Unknown command \"%s\" from peer=%d\n", SanitizeString(strCommand), pfrom->id);
+        }
+    }
     return true;
 }
 
@@ -7111,13 +7700,17 @@ bool ProcessMessages(CNode *pfrom) {
             pfrom->PushMessage(NetMsgType::REJECT, strCommand, REJECT_MALFORMED, string("error parsing message"));
             if (strstr(e.what(), "end of data")) {
                 // Allow exceptions from under-length message on vRecv
-                LogPrintf("%s(%s, %u bytes): Exception '%s' caught, normally caused by a message being shorter than its stated length\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
+                LogPrintf(
+                        "%s(%s, %u bytes): Exception '%s' caught, normally caused by a message being shorter than its stated length\n",
+                        __func__, SanitizeString(strCommand), nMessageSize, e.what());
             } else if (strstr(e.what(), "size too large")) {
                 // Allow exceptions from over-long size
-                LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
+                LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand),
+                          nMessageSize, e.what());
             } else if (strstr(e.what(), "non-canonical ReadCompactSize()")) {
                 // Allow exceptions from non-canonical encoding
-                LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
+                LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand),
+                          nMessageSize, e.what());
             } else {
                 PrintExceptionContinue(&e, "ProcessMessages() 1");
             }
@@ -7126,13 +7719,15 @@ bool ProcessMessages(CNode *pfrom) {
             throw;
         }
         catch (const std::exception &e) {
+            LogPrintf("Exception with strCommand=%s\n", strCommand);
             PrintExceptionContinue(&e, "ProcessMessages() 2");
         } catch (...) {
             PrintExceptionContinue(NULL, "ProcessMessages() 3");
         }
 
         if (!fRet)
-            LogPrintf("%s(%s, %u bytes) FAILED peer=%d\n", __func__, SanitizeString(strCommand), nMessageSize, pfrom->id);
+            LogPrintf("%s(%s, %u bytes) FAILED peer=%d\n", __func__, SanitizeString(strCommand), nMessageSize,
+                      pfrom->id);
 
         break;
     }
@@ -7248,8 +7843,7 @@ bool SendMessages(CNode *pto) {
             state.fShouldBan = false;
         }
 
-        BOOST_FOREACH(
-        const CBlockReject &reject, state.rejects)
+        BOOST_FOREACH(const CBlockReject &reject, state.rejects)
         pto->PushMessage(NetMsgType::REJECT, (string) NetMsgType::BLOCK, reject.chRejectCode, reject.strRejectReason,
                          reject.hashBlock);
         state.rejects.clear();
@@ -7311,7 +7905,8 @@ bool SendMessages(CNode *pto) {
                 // Try to find first header that our peer doesn't have, and
                 // then send all headers past that one.  If we come across any
                 // headers that aren't on chainActive, give up.
-                BOOST_FOREACH(const uint256 &hash, pto->vBlockHashesToAnnounce) {
+                BOOST_FOREACH(
+                const uint256 &hash, pto->vBlockHashesToAnnounce) {
                     BlockMap::iterator mi = mapBlockIndex.find(hash);
                     assert(mi != mapBlockIndex.end());
                     CBlockIndex *pindex = mi->second;
@@ -7414,14 +8009,14 @@ bool SendMessages(CNode *pto) {
         //
         // Message: inventory
         //
-        vector <CInv> vInv;
+        vector<CInv> vInv;
+        vector<CInv> vInvWait;
         {
             LOCK(pto->cs_inventory);
             vInv.reserve(std::max<size_t>(pto->vInventoryBlockToSend.size(), INVENTORY_BROADCAST_MAX));
 
             // Add blocks
-            BOOST_FOREACH(
-            const uint256 &hash, pto->vInventoryBlockToSend) {
+            BOOST_FOREACH(const uint256 &hash, pto->vInventoryBlockToSend) {
                 vInv.push_back(CInv(MSG_BLOCK, hash));
                 if (vInv.size() == MAX_INV_SZ) {
                     pto->PushMessage(NetMsgType::INV, vInv);
@@ -7543,6 +8138,27 @@ bool SendMessages(CNode *pto) {
                 }
             }
         }
+        // vInventoryToSend from dash
+        {
+            LOCK(pto->cs_inventory);
+            vInv.reserve(std::min<size_t>(1000, pto->vInventoryToSend.size()));
+            vInvWait.reserve(pto->vInventoryToSend.size());
+            BOOST_FOREACH(const CInv& inv, pto->vInventoryToSend)
+            {
+                pto->filterInventoryKnown.insert(inv.hash);
+
+                LogPrintf("SendMessages -- queued inv: %s  index=%d peer=%d\n", inv.ToString(), vInv.size(), pto->id);
+                vInv.push_back(inv);
+                if (vInv.size() >= 1000)
+                {
+                    LogPrintf("SendMessages -- pushing inv's: count=%d peer=%d\n", vInv.size(), pto->id);
+                    pto->PushMessage(NetMsgType::INV, vInv);
+                    vInv.clear();
+                }
+            }
+            pto->vInventoryToSend = vInvWait;
+        }
+
         if (!vInv.empty())
             pto->PushMessage(NetMsgType::INV, vInv);
 
diff --git a/src/main.h b/src/main.h
index b0765ad2ca..920d5997ae 100644
--- a/src/main.h
+++ b/src/main.h
@@ -17,7 +17,6 @@
 #include "script/script_error.h"
 #include "sync.h"
 #include "versionbits.h"
-//BTZC: add for zcoin
 #include "timedata.h"
 #include "chainparams.h"
 
@@ -91,6 +90,7 @@ static const unsigned int DEFAULT_BLOCK_PRIORITY_SIZE = 50000; // 50KB
 /** Dust Hard Limit, ignored as wallet inputs (mininput default) */
 static const int64_t DUST_HARD_LIMIT = 1000;   // 0.00001 XZC mininput
 
+
 /** Maximum number of script-checking threads allowed */
 static const int MAX_SCRIPTCHECK_THREADS = 16;
 /** -par default (number of script-checking threads, 0 = auto) */
@@ -144,7 +144,7 @@ static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
 /** Default for -permitbaremultisig */
 static const bool DEFAULT_PERMIT_BAREMULTISIG = true;
 static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
-static const bool DEFAULT_TXINDEX = false;
+static const bool DEFAULT_TXINDEX = true;
 static const unsigned int DEFAULT_BANSCORE_THRESHOLD = 100;
 
 static const bool DEFAULT_TESTSAFEMODE = false;
@@ -182,8 +182,6 @@ static const bool DEFAULT_PEERBLOOMFILTERS = true;
 // Add more spend txs per block at block height
 #define SWITCH_TO_MORE_SPEND_TXS 60000
 
-// Enabled lowest diff for test local env
-#define ENABLED_LOWEST_DIFF false
 
 struct BlockHasher
 {
@@ -445,6 +443,12 @@ bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeig
  */
 bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* lp = NULL, bool useExistingLockPoints = false);
 
+/**
+ * Return true if hash can be found in chainActive at nBlockHeight height.
+ * Fills hashRet with found hash, if no nBlockHeight is specified - chainActive.Height() is used.
+ */
+bool GetBlockHash(uint256& hashRet, int nBlockHeight = -1);
+
 /**
  * Closure representing one script verification
  * Note that this stores references to the spending transaction 
@@ -513,6 +517,16 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
  *  of problems. Note that in any case, coins may be modified. */
 bool DisconnectBlock(const CBlock& block, CValidationState& state, const CBlockIndex* pindex, CCoinsViewCache& coins, bool* pfClean = NULL);
 
+/** Reprocess a number of blocks to try and get on the correct chain again **/
+bool DisconnectBlocks(int blocks);
+void ReprocessBlocks(int nBlocks);
+
+int GetUTXOHeight(const COutPoint& outpoint);
+int GetInputAge(const CTxIn &txin);
+int GetInputAgeIX(const uint256 &nTXHash, const CTxIn &txin);
+int GetIXConfirmations(const uint256 &nTXHash);
+CAmount GetZnodePayment(int nHeight, CAmount blockValue = 50 * COIN);
+
 /** Check a block is completely valid from start to finish (only works on top of our current best block, with cs_main held) */
 bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
 
@@ -542,6 +556,9 @@ CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& loc
 /** Mark a block as invalid. */
 bool InvalidateBlock(CValidationState& state, const CChainParams& chainparams, CBlockIndex *pindex);
 
+/** Remove invalidity status from a block and its descendants. */
+bool ReconsiderBlock(CValidationState& state, CBlockIndex *pindex);
+
 /** Remove invalidity status from a block and its descendants. */
 bool ResetBlockFailureFlags(CBlockIndex *pindex);
 
diff --git a/src/miner.cpp b/src/miner.cpp
index 34d1d606cc..9f436ee7c0 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -30,7 +30,8 @@
 #include "crypto/scrypt.h"
 #include "crypto/Lyra2Z/Lyra2Z.h"
 #include "crypto/Lyra2Z/Lyra2.h"
-
+#include "znode-payments.h"
+#include "znode-sync.h"
 #include <algorithm>
 #include <boost/thread.hpp>
 #include <boost/tuple/tuple.hpp>
@@ -116,7 +117,6 @@ void BlockAssembler::resetBlock()
     // Reserve space for coinbase tx
     nBlockSize = 1000;
     nBlockWeight = 4000;
-    //btzc: update zcoin value
     nBlockSigOpsCost = 100;
     fIncludeWitness = false;
 
@@ -139,57 +139,87 @@ CBlockTemplate* BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
         return NULL;
     CBlock *pblock = &pblocktemplate->block; // pointer for convenience
     // Create coinbase tx
-    CTransaction txNew;
-    txNew.vin.resize(1);
-    txNew.vin[0].prevout.SetNull();
-    txNew.vout.resize(1);
-    txNew.vout[0].scriptPubKey = scriptPubKeyIn;
-    txNew.vout[0].nValue = 0;
+    CMutableTransaction coinbaseTx;
+    coinbaseTx.vin.resize(1);
+    coinbaseTx.vin[0].prevout.SetNull();
+    coinbaseTx.vout.resize(1);
+    coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
+    coinbaseTx.vout[0].nValue = 0;
     CBlockIndex* pindexPrev = chainActive.Tip();
     const int nHeight = pindexPrev->nHeight + 1;
 
 
     // To founders and investors
-    if ((nHeight > 0) && (nHeight < 210000)) {
-        // Take some reward away from us
-        txNew.vout[0].nValue = -10 * COIN;
-
+    // To founders and investors
+    if ((nHeight + 1 > 0) && (nHeight + 1 < 210000)) {
         CScript FOUNDER_1_SCRIPT;
         CScript FOUNDER_2_SCRIPT;
         CScript FOUNDER_3_SCRIPT;
         CScript FOUNDER_4_SCRIPT;
         CScript FOUNDER_5_SCRIPT;
+        if (nHeight < Params().GetConsensus().nZnodePaymentsStartBlock) {
+            // Take some reward away from us
+            coinbaseTx.vout[0].nValue = -10 * COIN;
+
+            if (!fTestNet && (GetAdjustedTime() > nStartRewardTime)) {
+                FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("aCAgTPgtYcA4EysU4UKC86EQd5cTtHtCcr").Get());
+                if (nHeight + 1 < 14000) {
+                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aLrg41sXbXZc5MyEj7dts8upZKSAtJmRDR").Get());
+                } else {
+                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aHu897ivzmeFuLNB6956X6gyGeVNHUBRgD").Get());
+                }
+                FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("aQ18FBVFtnueucZKeVg4srhmzbpAeb1KoN").Get());
+                FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1HwTdCmQV3NspP2QqCGpehoFpi8NY4Zg3").Get());
+                FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1kCCGddf5pMXSipLVD9hBG2MGGVNaJ15U").Get());
+            } else if (!fTestNet && (GetAdjustedTime() <= nStartRewardTime)) {
+                throw std::runtime_error("CreateNewBlock() : Create new block too early");
+            } else if (fTestNet) {
+                FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("TDk19wPKYq91i18qmY6U9FeTdTxwPeSveo").Get());
+                FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("TWZZcDGkNixTAMtRBqzZkkMHbq1G6vUTk5").Get());
+                FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("TRZTFdNCKCKbLMQV8cZDkQN9Vwuuq4gDzT").Get());
+                FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("TG2ruj59E5b1u9G3F7HQVs6pCcVDBxrQve").Get());
+                FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("TCsTzQZKVn4fao8jDmB9zQBk9YQNEZ3XfS").Get());
+            }
 
-        if (!fTestNet && (GetAdjustedTime() > nStartRewardTime)) {
-            FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("aCAgTPgtYcA4EysU4UKC86EQd5cTtHtCcr").Get());
-            if (nHeight < 14000) {
-                FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aLrg41sXbXZc5MyEj7dts8upZKSAtJmRDR").Get());
-            } else {
-                FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aHu897ivzmeFuLNB6956X6gyGeVNHUBRgD").Get());
+            // And give it to the founders
+            coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_1_SCRIPT.begin(), FOUNDER_1_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_2_SCRIPT.begin(), FOUNDER_2_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_3_SCRIPT.begin(), FOUNDER_3_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_4_SCRIPT.begin(), FOUNDER_4_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_5_SCRIPT.begin(), FOUNDER_5_SCRIPT.end())));
+        } else if (nHeight >= Params().GetConsensus().nZnodePaymentsStartBlock) {
+            // Take some reward away from us
+            coinbaseTx.vout[0].nValue = -7 * COIN;
+
+            if (!fTestNet && (GetAdjustedTime() > nStartRewardTime)) {
+                FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("aCAgTPgtYcA4EysU4UKC86EQd5cTtHtCcr").Get());
+                if (nHeight + 1 < 14000) {
+                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aLrg41sXbXZc5MyEj7dts8upZKSAtJmRDR").Get());
+                } else {
+                    FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aHu897ivzmeFuLNB6956X6gyGeVNHUBRgD").Get());
+                }
+                FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("aQ18FBVFtnueucZKeVg4srhmzbpAeb1KoN").Get());
+                FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1HwTdCmQV3NspP2QqCGpehoFpi8NY4Zg3").Get());
+                FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1kCCGddf5pMXSipLVD9hBG2MGGVNaJ15U").Get());
+            } else if (!fTestNet && (GetAdjustedTime() <= nStartRewardTime)) {
+                throw std::runtime_error("CreateNewBlock() : Create new block too early");
+            } else if (fTestNet) {
+                FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("TDk19wPKYq91i18qmY6U9FeTdTxwPeSveo").Get());
+                FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("TWZZcDGkNixTAMtRBqzZkkMHbq1G6vUTk5").Get());
+                FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("TRZTFdNCKCKbLMQV8cZDkQN9Vwuuq4gDzT").Get());
+                FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("TG2ruj59E5b1u9G3F7HQVs6pCcVDBxrQve").Get());
+                FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("TCsTzQZKVn4fao8jDmB9zQBk9YQNEZ3XfS").Get());
             }
-            FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("aQ18FBVFtnueucZKeVg4srhmzbpAeb1KoN").Get());
-            FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1HwTdCmQV3NspP2QqCGpehoFpi8NY4Zg3").Get());
-            FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1kCCGddf5pMXSipLVD9hBG2MGGVNaJ15U").Get());
-        } else if (!fTestNet && (GetAdjustedTime() <= nStartRewardTime)) {
-            throw std::runtime_error("CreateNewBlock() : Create new block too early");
-        } else {
-            FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("TCE4hvs2UTDjYriey7R9qBkbvUAYxWmZni").Get());
-            FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("TPyA7d3fribqxXm9uJU61S76Lzuj7F8jLz").Get());
-            FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("TXatvpS15EvejVuJVC2rgD73rSaQz8JiX6").Get());
-            FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("TJMpFjtDi8s5AM3GyW41QshH2NNmKgrGNq").Get());
-            FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("TTtLk1iapn8QebamQcb8GEh1MNq8agYcVk").Get());
-        }
 
-        // And give it to the founders
-        txNew.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_1_SCRIPT.begin(), FOUNDER_1_SCRIPT.end())));
-        txNew.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_2_SCRIPT.begin(), FOUNDER_2_SCRIPT.end())));
-        txNew.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_3_SCRIPT.begin(), FOUNDER_3_SCRIPT.end())));
-        txNew.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_4_SCRIPT.begin(), FOUNDER_4_SCRIPT.end())));
-        txNew.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_5_SCRIPT.begin(), FOUNDER_5_SCRIPT.end())));
+            // And give it to the founders
+            coinbaseTx.vout.push_back(CTxOut(1 * COIN, CScript(FOUNDER_1_SCRIPT.begin(), FOUNDER_1_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(1 * COIN, CScript(FOUNDER_2_SCRIPT.begin(), FOUNDER_2_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(1 * COIN, CScript(FOUNDER_3_SCRIPT.begin(), FOUNDER_3_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(3 * COIN, CScript(FOUNDER_4_SCRIPT.begin(), FOUNDER_4_SCRIPT.end())));
+            coinbaseTx.vout.push_back(CTxOut(1 * COIN, CScript(FOUNDER_5_SCRIPT.begin(), FOUNDER_5_SCRIPT.end())));
+        }
     }
 
-
-
     // Add dummy coinbase tx as first transaction
     pblock->vtx.push_back(CTransaction());
     pblocktemplate->vTxFees.push_back(-1); // updated at end
@@ -212,8 +242,8 @@ CBlockTemplate* BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
 
     unsigned int COUNT_SPEND_ZC_TX = 0;
     unsigned int MAX_SPEND_ZC_TX_PER_BLOCK = 0;
-    if(fTestNet || nHeight > OLD_LIMIT_SPEND_TXS){
-        MAX_SPEND_ZC_TX_PER_BLOCK = 0;
+    if(fTestNet || nHeight > HF_ZEROSPEND_FIX){
+        MAX_SPEND_ZC_TX_PER_BLOCK = 1;
     }
     if(fTestNet || nHeight > SWITCH_TO_MORE_SPEND_TXS){
         MAX_SPEND_ZC_TX_PER_BLOCK = 1;
@@ -452,15 +482,23 @@ CBlockTemplate* BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
                 }
             }
         }
+        CAmount blockReward = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
+        // Update coinbase transaction with additional info about znode and governance payments,
+        // get some info back to pass to getblocktemplate
+        if (nHeight >= chainparams.GetConsensus().nZnodePaymentsStartBlock) {
+            CAmount znodePayment = GetZnodePayment(nHeight, blockReward);
+            coinbaseTx.vout[0].nValue -= znodePayment;
+            FillBlockPayments(coinbaseTx, nHeight, znodePayment, pblock->txoutZnode, pblock->voutSuperblock);
+        }
 
         nLastBlockTx = nBlockTx;
         nLastBlockSize = nBlockSize;
         LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps);
 
         // Compute final coinbase transaction.
-        txNew.vout[0].nValue += nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
-        txNew.vin[0].scriptSig = CScript() << nHeight << OP_0;
-        pblock->vtx[0] = txNew;
+        coinbaseTx.vout[0].nValue += blockReward;
+        coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
+        pblock->vtx[0] = coinbaseTx;
         pblocktemplate->vTxFees[0] = -nFees;
 
         // Fill in header
@@ -478,105 +516,6 @@ CBlockTemplate* BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
     return pblocktemplate.release();
 }
 
-CBlockTemplate* BlockAssembler::CreateNewBlock_(const CScript& scriptPubKeyIn)
-{
-    LogPrintf("BlockAssembler::CreateNewBlock()\n");
-    bool fTestNet = (Params().NetworkIDString() == CBaseChainParams::TESTNET);
-    resetBlock();
-    pblocktemplate.reset(new CBlockTemplate());
-    if(!pblocktemplate.get())
-        return NULL;
-    pblock = &pblocktemplate->block; // pointer for convenience
-
-    CBlockIndex* pindexPrev = chainActive.Tip();
-    nHeight = pindexPrev->nHeight;
-
-    CTransaction coinbaseTx;
-    coinbaseTx.vin.resize(1);
-    coinbaseTx.vin[0].prevout.SetNull();
-    coinbaseTx.vout.resize(1);
-    coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
-    coinbaseTx.vout[0].nValue = 0;
-
-    // To founders and investors
-    if ((nHeight + 1> 0) && (nHeight + 1 < 210000)) {
-        // Take some reward away from us
-        coinbaseTx.vout[0].nValue = -10 * COIN;
-
-        CScript FOUNDER_1_SCRIPT;
-        CScript FOUNDER_2_SCRIPT;
-        CScript FOUNDER_3_SCRIPT;
-        CScript FOUNDER_4_SCRIPT;
-        CScript FOUNDER_5_SCRIPT;
-
-        if (!fTestNet && (GetAdjustedTime() > nStartRewardTime)) {
-            FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("aCAgTPgtYcA4EysU4UKC86EQd5cTtHtCcr").Get());
-            if (nHeight + 1 < 14000) {
-                FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aLrg41sXbXZc5MyEj7dts8upZKSAtJmRDR").Get());
-            } else {
-                FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("aHu897ivzmeFuLNB6956X6gyGeVNHUBRgD").Get());
-            }
-            FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("aQ18FBVFtnueucZKeVg4srhmzbpAeb1KoN").Get());
-            FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1HwTdCmQV3NspP2QqCGpehoFpi8NY4Zg3").Get());
-            FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("a1kCCGddf5pMXSipLVD9hBG2MGGVNaJ15U").Get());
-        } else if (!fTestNet && (GetAdjustedTime() <= nStartRewardTime)) {
-            throw std::runtime_error("CreateNewBlock() : Create new block too early");
-        } else {
-            FOUNDER_1_SCRIPT = GetScriptForDestination(CBitcoinAddress("TCE4hvs2UTDjYriey7R9qBkbvUAYxWmZni").Get());
-            FOUNDER_2_SCRIPT = GetScriptForDestination(CBitcoinAddress("TPyA7d3fribqxXm9uJU61S76Lzuj7F8jLz").Get());
-            FOUNDER_3_SCRIPT = GetScriptForDestination(CBitcoinAddress("TXatvpS15EvejVuJVC2rgD73rSaQz8JiX6").Get());
-            FOUNDER_4_SCRIPT = GetScriptForDestination(CBitcoinAddress("TJMpFjtDi8s5AM3GyW41QshH2NNmKgrGNq").Get());
-            FOUNDER_5_SCRIPT = GetScriptForDestination(CBitcoinAddress("TTtLk1iapn8QebamQcb8GEh1MNq8agYcVk").Get());
-        }
-
-        // And give it to the founders
-        coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_1_SCRIPT.begin(), FOUNDER_1_SCRIPT.end())));
-        coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_2_SCRIPT.begin(), FOUNDER_2_SCRIPT.end())));
-        coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_3_SCRIPT.begin(), FOUNDER_3_SCRIPT.end())));
-        coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_4_SCRIPT.begin(), FOUNDER_4_SCRIPT.end())));
-        coinbaseTx.vout.push_back(CTxOut(2 * COIN, CScript(FOUNDER_5_SCRIPT.begin(), FOUNDER_5_SCRIPT.end())));
-    }
-
-    // Add dummy coinbase tx as first transaction
-    pblock->vtx.push_back(coinbaseTx);
-    pblocktemplate->vTxFees.push_back(-1); // updated at end
-    pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end
-//    pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, chainparams.GetConsensus());
-    pblocktemplate->vTxFees[0] = -nFees;
-    GetSerializeSize(*pblock, SER_NETWORK, PROTOCOL_VERSION);
-
-    LOCK2(cs_main, mempool.cs);
-//    pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
-//    if (chainparams.MineBlocksOnDemand())
-//        pblock->nVersion = GetArg("-blockversion", pblock->nVersion);
-    pblock->nTime = GetAdjustedTime();
-    const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();
-    nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST) ? nMedianTimePast : pblock->GetBlockTime();
-    fIncludeWitness = IsWitnessEnabled(pindexPrev, chainparams.GetConsensus());
-
-    addPriorityTxs();
-    addPackageTxs();
-
-    nLastBlockTx = nBlockTx;
-    nLastBlockSize = nBlockSize;
-    nLastBlockWeight = nBlockWeight;
-
-    // Fill in header
-    pblock->hashPrevBlock  = pindexPrev->GetBlockHash();
-    UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
-    pblock->nBits          = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
-    pblock->nNonce         = 0;
-    pblock->vtx[0].vin[0].scriptSig = CScript() << OP_0 << OP_0;
-    CScript expect = CScript() << nHeight;
-    pblock->vtx[0].vout[0].nValue += nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus(), pblock->nTime);
-    pblocktemplate->vTxSigOpsCost[0] = GetLegacySigOpCount(pblock->vtx[0]);
-    CValidationState state;
-    if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
-        throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state)));
-    }
-    return pblocktemplate.release();
-}
-
 
 CBlockTemplate* BlockAssembler::CreateNewBlockWithKey(CReserveKey &reservekey) {
     LogPrintf("CreateNewBlockWithKey()\n");
@@ -946,8 +885,8 @@ void BlockAssembler::addPriorityTxs()
 
     unsigned int COUNT_SPEND_ZC_TX = 0;
     unsigned int MAX_SPEND_ZC_TX_PER_BLOCK = 0;
-    if (chainActive.Height() + 1 > OLD_LIMIT_SPEND_TXS) {
-        MAX_SPEND_ZC_TX_PER_BLOCK = 0;
+    if (chainActive.Height() + 1 > HF_ZEROSPEND_FIX) {
+        MAX_SPEND_ZC_TX_PER_BLOCK = 1;
     }
     if (nHeight + 1 > SWITCH_TO_MORE_SPEND_TXS) {
         MAX_SPEND_ZC_TX_PER_BLOCK = 1;
@@ -1156,9 +1095,8 @@ void static ZcoinMiner(const CChainParams &chainparams) {
             unsigned int nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
             CBlockIndex *pindexPrev = chainActive.Tip();
             if (pindexPrev) {
-                LogPrintf("loop pindexPrev->nHeight=%s", pindexPrev->nHeight);
+                LogPrintf("loop pindexPrev->nHeight=%s\n", pindexPrev->nHeight);
             }
-            LogPrintf("CreateNewBlock=%s\n");
             auto_ptr <CBlockTemplate> pblocktemplate(BlockAssembler(Params()).CreateNewBlock(coinbaseScript->reserveScript));
             if (!pblocktemplate.get()) {
                 LogPrintf("Error in ZcoinMiner: Keypool ran out, please call keypoolrefill before restarting the mining thread\n");
@@ -1186,18 +1124,19 @@ void static ZcoinMiner(const CChainParams &chainparams) {
                 uint256 thash;
 
                 while (true) {
-                    if ((!fTestNet && pindexPrev->nHeight + 1 >= LYRA2Z_HEIGHT)) {
+                    if ((!fTestNet && pindexPrev->nHeight + 1 >= HF_LYRA2Z_HEIGHT)) {
                         lyra2z_hash(BEGIN(pblock->nVersion), BEGIN(thash));
-                    } else if (!fTestNet && pindexPrev->nHeight + 1 >= 8192) {
+                    } else if (!fTestNet && pindexPrev->nHeight + 1 >= HF_LYRA2_HEIGHT) {
                         LYRA2(BEGIN(thash), 32, BEGIN(pblock->nVersion), 80, BEGIN(pblock->nVersion), 80, 2, 8192, 256);
-                    } else if (!fTestNet && pindexPrev->nHeight + 1 >= 500) {
+                    } else if (!fTestNet && pindexPrev->nHeight + 1 >= HF_LYRA2VAR_HEIGHT) {
                         LYRA2(BEGIN(thash), 32, BEGIN(pblock->nVersion), 80, BEGIN(pblock->nVersion), 80, 2,
                               pindexPrev->nHeight + 1, 256);
-                    } else if (fTestNet && pindexPrev->nHeight + 1 >= 90) { // testnet
+                    } else if (fTestNet && pindexPrev->nHeight + 1 >= HF_LYRA2Z_HEIGHT_TESTNET) { // testnet
                         lyra2z_hash(BEGIN(pblock->nVersion), BEGIN(thash));
-                    } else if (fTestNet && pindexPrev->nHeight + 1 >= 80) { // testnet
-                        LYRA2(BEGIN(thash), 32, BEGIN(pblock->nVersion), 80, BEGIN(pblock->nVersion), 80, 2, 8192,
-                              256);
+                    } else if (fTestNet && pindexPrev->nHeight + 1 >= HF_LYRA2_HEIGHT_TESTNET) { // testnet
+                        LYRA2(BEGIN(thash), 32, BEGIN(pblock->nVersion), 80, BEGIN(pblock->nVersion), 80, 2, 8192, 256);
+                    } else if (fTestNet && pindexPrev->nHeight + 1 >= HF_LYRA2VAR_HEIGHT_TESTNET) { // testnet
+                        LYRA2(BEGIN(thash), 32, BEGIN(pblock->nVersion), 80, BEGIN(pblock->nVersion), 80, 2, pindexPrev->nHeight + 1, 256);
                     } else {
                         unsigned long int scrypt_scratpad_size_current_block =
                                 ((1 << (GetNfactor(pblock->nTime) + 1)) * 128) + 63;
diff --git a/src/miner.h b/src/miner.h
index c39ae4266e..b2d07670ae 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -168,7 +168,6 @@ class BlockAssembler
     BlockAssembler(const CChainParams& chainparams);
     /** Construct a new block template with coinbase to scriptPubKeyIn */
     CBlockTemplate* CreateNewBlock(const CScript& scriptPubKeyIn);
-    CBlockTemplate* CreateNewBlock_(const CScript& scriptPubKeyIn);
     CBlockTemplate* CreateNewBlockWithKey(CReserveKey& reservekey);
 
 private:
diff --git a/src/net.cpp b/src/net.cpp
index 7f30330f66..8de07977d5 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -24,7 +24,9 @@
 #ifdef WIN32
 #include <string.h>
 #else
+
 #include <fcntl.h>
+
 #endif
 
 #ifdef USE_UPNP
@@ -86,24 +88,24 @@ bool fListen = true;
 ServiceFlags nLocalServices = NODE_NETWORK;
 bool fRelayTxes = true;
 CCriticalSection cs_mapLocalHost;
-std::map<CNetAddr, LocalServiceInfo> mapLocalHost;
+std::map <CNetAddr, LocalServiceInfo> mapLocalHost;
 static bool vfLimited[NET_MAX] = {};
-static CNode* pnodeLocalHost = NULL;
+static CNode *pnodeLocalHost = NULL;
 uint64_t nLocalHostNonce = 0;
-static std::vector<ListenSocket> vhListenSocket;
+static std::vector <ListenSocket> vhListenSocket;
 CAddrMan addrman;
 int nMaxConnections = DEFAULT_MAX_PEER_CONNECTIONS;
 bool fAddressesInitialized = false;
 std::string strSubVersion;
 
-std::vector<CNode*> vNodes;
+std::vector<CNode *> vNodes;
 CCriticalSection cs_vNodes;
 limitedmap<uint256, int64_t> mapAlreadyAskedFor(MAX_INV_SZ);
 
-static std::deque<std::string> vOneShots;
+static std::deque <std::string> vOneShots;
 CCriticalSection cs_vOneShots;
 
-std::vector<std::string> vAddedNodes;
+std::vector <std::string> vAddedNodes;
 CCriticalSection cs_vAddedNodes;
 
 NodeId nLastNodeId = 0;
@@ -114,22 +116,20 @@ boost::condition_variable messageHandlerCondition;
 
 // Signals for message handling
 static CNodeSignals g_signals;
-CNodeSignals& GetNodeSignals() { return g_signals; }
 
-void AddOneShot(const std::string& strDest)
-{
+CNodeSignals &GetNodeSignals() { return g_signals; }
+
+void AddOneShot(const std::string &strDest) {
     LOCK(cs_vOneShots);
     vOneShots.push_back(strDest);
 }
 
-unsigned short GetListenPort()
-{
-    return (unsigned short)(GetArg("-port", Params().GetDefaultPort()));
+unsigned short GetListenPort() {
+    return (unsigned short) (GetArg("-port", Params().GetDefaultPort()));
 }
 
 // find 'best' local address for a particular peer
-bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
-{
+bool GetLocal(CService &addr, const CNetAddr *paddrPeer) {
     if (!fListen)
         return false;
 
@@ -137,12 +137,10 @@ bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
     int nBestReachability = -1;
     {
         LOCK(cs_mapLocalHost);
-        for (std::map<CNetAddr, LocalServiceInfo>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++)
-        {
+        for (std::map<CNetAddr, LocalServiceInfo>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++) {
             int nScore = (*it).second.nScore;
             int nReachability = (*it).first.GetReachabilityFrom(paddrPeer);
-            if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))
-            {
+            if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore)) {
                 addr = CService((*it).first, (*it).second.nPort);
                 nBestReachability = nReachability;
                 nBestScore = nScore;
@@ -153,17 +151,15 @@ bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
 }
 
 //! Convert the pnSeeds6 array into usable address objects.
-static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &vSeedsIn)
-{
+static std::vector <CAddress> convertSeed6(const std::vector <SeedSpec6> &vSeedsIn) {
     // It'll only connect to one or two seed nodes because once it connects,
     // it'll get a pile of addresses with newer timestamps.
     // Seed nodes are given a random 'last seen time' of between one and two
     // weeks ago.
-    const int64_t nOneWeek = 7*24*60*60;
-    std::vector<CAddress> vSeedsOut;
+    const int64_t nOneWeek = 7 * 24 * 60 * 60;
+    std::vector <CAddress> vSeedsOut;
     vSeedsOut.reserve(vSeedsIn.size());
-    for (std::vector<SeedSpec6>::const_iterator i(vSeedsIn.begin()); i != vSeedsIn.end(); ++i)
-    {
+    for (std::vector<SeedSpec6>::const_iterator i(vSeedsIn.begin()); i != vSeedsIn.end(); ++i) {
         struct in6_addr ip;
         memcpy(&ip, i->addr, sizeof(ip));
         CAddress addr(CService(ip, i->port), NODE_NETWORK);
@@ -177,20 +173,17 @@ static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &vSeedsIn
 // Otherwise, return the unroutable 0.0.0.0 but filled in with
 // the normal parameters, since the IP may be changed to a useful
 // one by discovery.
-CAddress GetLocalAddress(const CNetAddr *paddrPeer)
-{
-    CAddress ret(CService("0.0.0.0",GetListenPort()), nLocalServices);
+CAddress GetLocalAddress(const CNetAddr *paddrPeer) {
+    CAddress ret(CService("0.0.0.0", GetListenPort()), nLocalServices);
     CService addr;
-    if (GetLocal(addr, paddrPeer))
-    {
+    if (GetLocal(addr, paddrPeer)) {
         ret = CAddress(addr, nLocalServices);
     }
     ret.nTime = GetAdjustedTime();
     return ret;
 }
 
-int GetnScore(const CService& addr)
-{
+int GetnScore(const CService &addr) {
     LOCK(cs_mapLocalHost);
     if (mapLocalHost.count(addr) == LOCAL_NONE)
         return 0;
@@ -198,28 +191,23 @@ int GetnScore(const CService& addr)
 }
 
 // Is our peer's addrLocal potentially useful as an external IP source?
-bool IsPeerAddrLocalGood(CNode *pnode)
-{
+bool IsPeerAddrLocalGood(CNode *pnode) {
     return fDiscover && pnode->addr.IsRoutable() && pnode->addrLocal.IsRoutable() &&
            !IsLimited(pnode->addrLocal.GetNetwork());
 }
 
 // pushes our own address to a peer
-void AdvertiseLocal(CNode *pnode)
-{
-    if (fListen && pnode->fSuccessfullyConnected)
-    {
+void AdvertiseLocal(CNode *pnode) {
+    if (fListen && pnode->fSuccessfullyConnected) {
         CAddress addrLocal = GetLocalAddress(&pnode->addr);
         // If discovery is enabled, sometimes give our peer the address it
         // tells us that it sees us as in case it has a better idea of our
         // address than we do.
         if (IsPeerAddrLocalGood(pnode) && (!addrLocal.IsRoutable() ||
-             GetRand((GetnScore(addrLocal) > LOCAL_MANUAL) ? 8:2) == 0))
-        {
+                                           GetRand((GetnScore(addrLocal) > LOCAL_MANUAL) ? 8 : 2) == 0)) {
             addrLocal.SetIP(pnode->addrLocal);
         }
-        if (addrLocal.IsRoutable())
-        {
+        if (addrLocal.IsRoutable()) {
             LogPrintf("AdvertiseLocal: advertising address %s\n", addrLocal.ToString());
             pnode->PushAddress(addrLocal);
         }
@@ -227,8 +215,7 @@ void AdvertiseLocal(CNode *pnode)
 }
 
 // learn a new local address
-bool AddLocal(const CService& addr, int nScore)
-{
+bool AddLocal(const CService &addr, int nScore) {
     if (!addr.IsRoutable())
         return false;
 
@@ -253,13 +240,11 @@ bool AddLocal(const CService& addr, int nScore)
     return true;
 }
 
-bool AddLocal(const CNetAddr &addr, int nScore)
-{
+bool AddLocal(const CNetAddr &addr, int nScore) {
     return AddLocal(CService(addr, GetListenPort()), nScore);
 }
 
-bool RemoveLocal(const CService& addr)
-{
+bool RemoveLocal(const CService &addr) {
     LOCK(cs_mapLocalHost);
     LogPrintf("RemoveLocal(%s)\n", addr.ToString());
     mapLocalHost.erase(addr);
@@ -267,28 +252,24 @@ bool RemoveLocal(const CService& addr)
 }
 
 /** Make a particular network entirely off-limits (no automatic connects to it) */
-void SetLimited(enum Network net, bool fLimited)
-{
+void SetLimited(enum Network net, bool fLimited) {
     if (net == NET_UNROUTABLE)
         return;
     LOCK(cs_mapLocalHost);
     vfLimited[net] = fLimited;
 }
 
-bool IsLimited(enum Network net)
-{
+bool IsLimited(enum Network net) {
     LOCK(cs_mapLocalHost);
     return vfLimited[net];
 }
 
-bool IsLimited(const CNetAddr &addr)
-{
+bool IsLimited(const CNetAddr &addr) {
     return IsLimited(addr.GetNetwork());
 }
 
 /** vote for a local address */
-bool SeenLocal(const CService& addr)
-{
+bool SeenLocal(const CService &addr) {
     {
         LOCK(cs_mapLocalHost);
         if (mapLocalHost.count(addr) == 0)
@@ -300,28 +281,24 @@ bool SeenLocal(const CService& addr)
 
 
 /** check whether a given address is potentially local */
-bool IsLocal(const CService& addr)
-{
+bool IsLocal(const CService &addr) {
     LOCK(cs_mapLocalHost);
     return mapLocalHost.count(addr) > 0;
 }
 
 /** check whether a given network is one we can probably connect to */
-bool IsReachable(enum Network net)
-{
+bool IsReachable(enum Network net) {
     LOCK(cs_mapLocalHost);
     return !vfLimited[net];
 }
 
 /** check whether a given address is in a network we can probably connect to */
-bool IsReachable(const CNetAddr& addr)
-{
+bool IsReachable(const CNetAddr &addr) {
     enum Network net = addr.GetNetwork();
     return IsReachable(net);
 }
 
-void AddressCurrentlyConnected(const CService& addr)
-{
+void AddressCurrentlyConnected(const CService &addr) {
     addrman.Connected(addr);
 }
 
@@ -333,65 +310,65 @@ CCriticalSection CNode::cs_totalBytesSent;
 
 uint64_t CNode::nMaxOutboundLimit = 0;
 uint64_t CNode::nMaxOutboundTotalBytesSentInCycle = 0;
-uint64_t CNode::nMaxOutboundTimeframe = 60*60*24; //1 day
+uint64_t CNode::nMaxOutboundTimeframe = 60 * 60 * 24; //1 day
 uint64_t CNode::nMaxOutboundCycleStartTime = 0;
 
-CNode* FindNode(const CNetAddr& ip)
-{
+CNode *FindNode(const CNetAddr &ip) {
     LOCK(cs_vNodes);
-    BOOST_FOREACH(CNode* pnode, vNodes)
-        if ((CNetAddr)pnode->addr == ip)
-            return (pnode);
+    BOOST_FOREACH(CNode * pnode, vNodes)
+    if ((CNetAddr) pnode->addr == ip)
+        return (pnode);
     return NULL;
 }
 
-CNode* FindNode(const CSubNet& subNet)
-{
+CNode *FindNode(const CSubNet &subNet) {
     LOCK(cs_vNodes);
-    BOOST_FOREACH(CNode* pnode, vNodes)
-    if (subNet.Match((CNetAddr)pnode->addr))
+    BOOST_FOREACH(CNode * pnode, vNodes)
+    if (subNet.Match((CNetAddr) pnode->addr))
         return (pnode);
     return NULL;
 }
 
-CNode* FindNode(const std::string& addrName)
-{
+CNode *FindNode(const std::string &addrName) {
     LOCK(cs_vNodes);
-    BOOST_FOREACH(CNode* pnode, vNodes)
-        if (pnode->addrName == addrName)
-            return (pnode);
+    BOOST_FOREACH(CNode * pnode, vNodes)
+    if (pnode->addrName == addrName)
+        return (pnode);
     return NULL;
 }
 
-CNode* FindNode(const CService& addr)
-{
+CNode *FindNode(const CService &addr) {
     LOCK(cs_vNodes);
-    BOOST_FOREACH(CNode* pnode, vNodes)
-        if ((CService)pnode->addr == addr)
-            return (pnode);
+    BOOST_FOREACH(CNode * pnode, vNodes)
+    if ((CService) pnode->addr == addr)
+        return (pnode);
     return NULL;
 }
 
 //TODO: This is used in only one place in main, and should be removed
-CNode* FindNode(const NodeId nodeid)
-{
+CNode *FindNode(const NodeId nodeid) {
     LOCK(cs_vNodes);
-    BOOST_FOREACH(CNode* pnode, vNodes)
-        if (pnode->GetId() == nodeid)
-            return (pnode);
+    BOOST_FOREACH(CNode * pnode, vNodes)
+    if (pnode->GetId() == nodeid)
+        return (pnode);
     return NULL;
 }
 
-CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure)
-{
+CNode *ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, bool fConnectToZnode) {
     if (pszDest == NULL) {
-        if (IsLocal(addrConnect))
+        // we clean znode connections in CZnodeMan::ProcessZnodeConnections()
+        // so should be safe to skip this and connect to local Hot MN on CActiveZnode::ManageState()
+        if (IsLocal(addrConnect) && !fConnectToZnode)
             return NULL;
-
+        LOCK(cs_vNodes);
         // Look for an existing connection
-        CNode* pnode = FindNode((CService)addrConnect);
-        if (pnode)
-        {
+        CNode *pnode = FindNode((CService) addrConnect);
+        if (pnode) {
+            // we have existing connection to this node but it was not a connection to znode,
+            // change flag and add reference so that we can correctly clear it later
+            if (fConnectToZnode && !pnode->fZnode) {
+                pnode->fZnode = true;
+            }
             pnode->AddRef();
             return pnode;
         }
@@ -399,15 +376,15 @@ CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure
 
     /// debug print
     LogPrint("net", "trying connection %s lastseen=%.1fhrs\n",
-        pszDest ? pszDest : addrConnect.ToString(),
-        pszDest ? 0.0 : (double)(GetAdjustedTime() - addrConnect.nTime)/3600.0);
+             pszDest ? pszDest : addrConnect.ToString(),
+             pszDest ? 0.0 : (double) (GetAdjustedTime() - addrConnect.nTime) / 3600.0);
 
     // Connect
     SOCKET hSocket;
     bool proxyConnectionFailed = false;
-    if (pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, Params().GetDefaultPort(), nConnectTimeout, &proxyConnectionFailed) :
-                  ConnectSocket(addrConnect, hSocket, nConnectTimeout, &proxyConnectionFailed))
-    {
+    if (pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, Params().GetDefaultPort(), nConnectTimeout,
+                                      &proxyConnectionFailed) :
+        ConnectSocket(addrConnect, hSocket, nConnectTimeout, &proxyConnectionFailed)) {
         if (!IsSelectableSocket(hSocket)) {
             LogPrintf("Cannot create connection: non-selectable socket created (fd >= FD_SETSIZE ?)\n");
             CloseSocket(hSocket);
@@ -419,9 +396,11 @@ CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure
             // In that case, drop the connection that was just created, and return the existing CNode instead.
             // Also store the name we used to connect in that CNode, so that future FindNode() calls to that
             // name catch this early.
-            CNode* pnode = FindNode((CService)addrConnect);
-            if (pnode)
-            {
+            CNode *pnode = FindNode((CService) addrConnect);
+            if (pnode) {
+                if (fConnectToZnode && !pnode->fZnode) {
+                    pnode->fZnode = true;
+                }
                 pnode->AddRef();
                 {
                     LOCK(cs_vNodes);
@@ -437,7 +416,10 @@ CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure
         addrman.Attempt(addrConnect, fCountFailure);
 
         // Add node
-        CNode* pnode = new CNode(hSocket, addrConnect, pszDest ? pszDest : "", false);
+        CNode *pnode = new CNode(hSocket, addrConnect, pszDest ? pszDest : "", false);
+        if (fConnectToZnode) {
+            pnode->fZnode = true;
+        }
         pnode->AddRef();
 
         {
@@ -458,8 +440,8 @@ CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure
     return NULL;
 }
 
-static void DumpBanlist()
-{
+
+static void DumpBanlist() {
     CNode::SweepBanned(); // clean unused entries (if bantime has expired)
 
     if (!CNode::BannedSetIsDirty())
@@ -475,14 +457,12 @@ static void DumpBanlist()
         CNode::SetBannedSetDirty(true);
 
     LogPrint("net", "Flushed %d banned node ips/subnets to banlist.dat  %dms\n",
-        banmap.size(), GetTimeMillis() - nStart);
+             banmap.size(), GetTimeMillis() - nStart);
 }
 
-void CNode::CloseSocketDisconnect()
-{
+void CNode::CloseSocketDisconnect() {
     fDisconnect = true;
-    if (hSocket != INVALID_SOCKET)
-    {
+    if (hSocket != INVALID_SOCKET) {
         LogPrint("net", "disconnecting peer=%d\n", id);
         CloseSocket(hSocket);
     }
@@ -493,19 +473,20 @@ void CNode::CloseSocketDisconnect()
         vRecvMsg.clear();
 }
 
-void CNode::PushVersion()
-{
+void CNode::PushVersion() {
     int nBestHeight = GetNodeSignals().GetHeight().get_value_or(0);
 
     int64_t nTime = (fInbound ? GetAdjustedTime() : GetTime());
     CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService("0.0.0.0", 0), addr.nServices));
     CAddress addrMe = CAddress(CService(), nLocalServices);
-    GetRandBytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
+    GetRandBytes((unsigned char *) &nLocalHostNonce, sizeof(nLocalHostNonce));
     if (fLogIPs)
-        LogPrint("net", "send version message: version %d, blocks=%d, us=%s, them=%s, peer=%d\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString(), addrYou.ToString(), id);
+        LogPrint("net", "send version message: version %d, blocks=%d, us=%s, them=%s, peer=%d\n", PROTOCOL_VERSION,
+                 nBestHeight, addrMe.ToString(), addrYou.ToString(), id);
     else
-        LogPrint("net", "send version message: version %d, blocks=%d, us=%s, peer=%d\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString(), id);
-    PushMessage(NetMsgType::VERSION, PROTOCOL_VERSION, (uint64_t)nLocalServices, nTime, addrYou, addrMe,
+        LogPrint("net", "send version message: version %d, blocks=%d, us=%s, peer=%d\n", PROTOCOL_VERSION, nBestHeight,
+                 addrMe.ToString(), id);
+    PushMessage(NetMsgType::VERSION, PROTOCOL_VERSION, (uint64_t) nLocalServices, nTime, addrYou, addrMe,
                 nLocalHostNonce, strSubVersion, nBestHeight, ::fRelayTxes);
 }
 
@@ -514,8 +495,7 @@ banmap_t CNode::setBanned;
 CCriticalSection CNode::cs_setBanned;
 bool CNode::setBannedIsDirty;
 
-void CNode::ClearBanned()
-{
+void CNode::ClearBanned() {
     {
         LOCK(cs_setBanned);
         setBanned.clear();
@@ -525,31 +505,27 @@ void CNode::ClearBanned()
     uiInterface.BannedListChanged();
 }
 
-bool CNode::IsBanned(CNetAddr ip)
-{
+bool CNode::IsBanned(CNetAddr ip) {
     bool fResult = false;
     {
         LOCK(cs_setBanned);
-        for (banmap_t::iterator it = setBanned.begin(); it != setBanned.end(); it++)
-        {
+        for (banmap_t::iterator it = setBanned.begin(); it != setBanned.end(); it++) {
             CSubNet subNet = (*it).first;
             CBanEntry banEntry = (*it).second;
 
-            if(subNet.Match(ip) && GetTime() < banEntry.nBanUntil)
+            if (subNet.Match(ip) && GetTime() < banEntry.nBanUntil)
                 fResult = true;
         }
     }
     return fResult;
 }
 
-bool CNode::IsBanned(CSubNet subnet)
-{
+bool CNode::IsBanned(CSubNet subnet) {
     bool fResult = false;
     {
         LOCK(cs_setBanned);
         banmap_t::iterator i = setBanned.find(subnet);
-        if (i != setBanned.end())
-        {
+        if (i != setBanned.end()) {
             CBanEntry banEntry = (*i).second;
             if (GetTime() < banEntry.nBanUntil)
                 fResult = true;
@@ -558,39 +534,38 @@ bool CNode::IsBanned(CSubNet subnet)
     return fResult;
 }
 
-void CNode::Ban(const CNetAddr& addr, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
+void CNode::Ban(const CNetAddr &addr, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
     CSubNet subNet(addr);
     Ban(subNet, banReason, bantimeoffset, sinceUnixEpoch);
 }
 
-void CNode::Ban(const CSubNet& subNet, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
+void CNode::Ban(const CSubNet &subNet, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {
     CBanEntry banEntry(GetTime());
     banEntry.banReason = banReason;
-    if (bantimeoffset <= 0)
-    {
+    if (bantimeoffset <= 0) {
         bantimeoffset = GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME);
         sinceUnixEpoch = false;
     }
-    banEntry.nBanUntil = (sinceUnixEpoch ? 0 : GetTime() )+bantimeoffset;
+    banEntry.nBanUntil = (sinceUnixEpoch ? 0 : GetTime()) + bantimeoffset;
 
     {
         LOCK(cs_setBanned);
         if (setBanned[subNet].nBanUntil < banEntry.nBanUntil) {
             setBanned[subNet] = banEntry;
             setBannedIsDirty = true;
-        }
-        else
+        } else
             return;
     }
     uiInterface.BannedListChanged();
     {
         LOCK(cs_vNodes);
-        BOOST_FOREACH(CNode* pnode, vNodes) {
-            if (subNet.Match((CNetAddr)pnode->addr))
+        BOOST_FOREACH(CNode * pnode, vNodes)
+        {
+            if (subNet.Match((CNetAddr) pnode->addr))
                 pnode->fDisconnect = true;
         }
     }
-    if(banReason == BanReasonManuallyAdded)
+    if (banReason == BanReasonManuallyAdded)
         DumpBanlist(); //store banlist to disk immediately if user requested ban
 }
 
@@ -611,59 +586,52 @@ bool CNode::Unban(const CSubNet &subNet) {
     return true;
 }
 
-void CNode::GetBanned(banmap_t &banMap)
-{
+void CNode::GetBanned(banmap_t &banMap) {
     LOCK(cs_setBanned);
     banMap = setBanned; //create a thread safe copy
 }
 
-void CNode::SetBanned(const banmap_t &banMap)
-{
+void CNode::SetBanned(const banmap_t &banMap) {
     LOCK(cs_setBanned);
     setBanned = banMap;
     setBannedIsDirty = true;
 }
 
-void CNode::SweepBanned()
-{
+void CNode::SweepBanned() {
     int64_t now = GetTime();
 
     LOCK(cs_setBanned);
     banmap_t::iterator it = setBanned.begin();
-    while(it != setBanned.end())
-    {
+    while (it != setBanned.end()) {
         CSubNet subNet = (*it).first;
         CBanEntry banEntry = (*it).second;
-        if(now > banEntry.nBanUntil)
-        {
+        if (now > banEntry.nBanUntil) {
             setBanned.erase(it++);
             setBannedIsDirty = true;
             LogPrint("net", "%s: Removed banned node ip/subnet from banlist.dat: %s\n", __func__, subNet.ToString());
-        }
-        else
+        } else
             ++it;
     }
 }
 
-bool CNode::BannedSetIsDirty()
-{
+bool CNode::BannedSetIsDirty() {
     LOCK(cs_setBanned);
     return setBannedIsDirty;
 }
 
-void CNode::SetBannedSetDirty(bool dirty)
-{
+void CNode::SetBannedSetDirty(bool dirty) {
     LOCK(cs_setBanned); //reuse setBanned lock for the isDirty flag
     setBannedIsDirty = dirty;
 }
 
 
-std::vector<CSubNet> CNode::vWhitelistedRange;
+std::vector <CSubNet> CNode::vWhitelistedRange;
 CCriticalSection CNode::cs_vWhitelistedRange;
 
 bool CNode::IsWhitelistedRange(const CNetAddr &addr) {
     LOCK(cs_vWhitelistedRange);
-    BOOST_FOREACH(const CSubNet& subnet, vWhitelistedRange) {
+    BOOST_FOREACH(
+    const CSubNet &subnet, vWhitelistedRange) {
         if (subnet.Match(addr))
             return true;
     }
@@ -677,8 +645,8 @@ void CNode::AddWhitelistedRange(const CSubNet &subnet) {
 
 #undef X
 #define X(name) stats.name = name
-void CNode::copyStats(CNodeStats &stats)
-{
+
+void CNode::copyStats(CNodeStats &stats) {
     stats.nodeid = this->GetId();
     X(nServices);
     X(fRelayTxes);
@@ -709,18 +677,18 @@ void CNode::copyStats(CNodeStats &stats)
     }
 
     // Raw ping time is in microseconds, but show it to user as whole seconds (Bitcoin users should be well used to small numbers with many decimal places by now :)
-    stats.dPingTime = (((double)nPingUsecTime) / 1e6);
-    stats.dPingMin  = (((double)nMinPingUsecTime) / 1e6);
-    stats.dPingWait = (((double)nPingUsecWait) / 1e6);
+    stats.dPingTime = (((double) nPingUsecTime) / 1e6);
+    stats.dPingMin = (((double) nMinPingUsecTime) / 1e6);
+    stats.dPingWait = (((double) nPingUsecWait) / 1e6);
 
     // Leave string empty if addrLocal invalid (not filled in yet)
     stats.addrLocal = addrLocal.IsValid() ? addrLocal.ToString() : "";
 }
+
 #undef X
 
 // requires LOCK(cs_vRecvMsg)
-bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes)
-{
+bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes) {
     while (nBytes > 0) {
 
         // get current incomplete message, or create a new one
@@ -728,7 +696,7 @@ bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes)
             vRecvMsg.back().complete())
             vRecvMsg.push_back(CNetMessage(Params().MessageStart(), SER_NETWORK, nRecvVersion));
 
-        CNetMessage& msg = vRecvMsg.back();
+        CNetMessage &msg = vRecvMsg.back();
 
         // absorb network data
         int handled;
@@ -738,7 +706,7 @@ bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes)
             handled = msg.readData(pch, nBytes);
 
         if (handled < 0)
-                return false;
+            return false;
 
         if (msg.in_data && msg.hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {
             LogPrint("net", "Oversized message from peer=%i, disconnecting\n", GetId());
@@ -766,8 +734,7 @@ bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes)
     return true;
 }
 
-int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
-{
+int CNetMessage::readHeader(const char *pch, unsigned int nBytes) {
     // copy data to temporary parsing buffer
     unsigned int nRemaining = 24 - nHdrPos;
     unsigned int nCopy = std::min(nRemaining, nBytes);
@@ -783,13 +750,13 @@ int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
     try {
         hdrbuf >> hdr;
     }
-    catch (const std::exception&) {
+    catch (const std::exception &) {
         return -1;
     }
 
     // reject messages larger than MAX_SIZE
     if (hdr.nMessageSize > MAX_SIZE)
-            return -1;
+        return -1;
 
     // switch state to reading message data
     in_data = true;
@@ -797,8 +764,7 @@ int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
     return nCopy;
 }
 
-int CNetMessage::readData(const char *pch, unsigned int nBytes)
-{
+int CNetMessage::readData(const char *pch, unsigned int nBytes) {
     unsigned int nRemaining = hdr.nMessageSize - nDataPos;
     unsigned int nCopy = std::min(nRemaining, nBytes);
 
@@ -814,22 +780,15 @@ int CNetMessage::readData(const char *pch, unsigned int nBytes)
 }
 
 
-
-
-
-
-
-
-
 // requires LOCK(cs_vSend)
-void SocketSendData(CNode *pnode)
-{
+void SocketSendData(CNode *pnode) {
     std::deque<CSerializeData>::iterator it = pnode->vSendMsg.begin();
 
     while (it != pnode->vSendMsg.end()) {
         const CSerializeData &data = *it;
         assert(data.size() > pnode->nSendOffset);
-        int nBytes = send(pnode->hSocket, &data[pnode->nSendOffset], data.size() - pnode->nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT);
+        int nBytes = send(pnode->hSocket, &data[pnode->nSendOffset], data.size() - pnode->nSendOffset,
+                          MSG_NOSIGNAL | MSG_DONTWAIT);
         if (nBytes > 0) {
             pnode->nLastSend = GetTime();
             pnode->nSendBytes += nBytes;
@@ -847,8 +806,7 @@ void SocketSendData(CNode *pnode)
             if (nBytes < 0) {
                 // error
                 int nErr = WSAGetLastError();
-                if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
-                {
+                if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
                     LogPrintf("socket send error %s\n", NetworkErrorString(nErr));
                     pnode->CloseSocketDisconnect();
                 }
@@ -865,10 +823,9 @@ void SocketSendData(CNode *pnode)
     pnode->vSendMsg.erase(pnode->vSendMsg.begin(), it);
 }
 
-static std::list<CNode*> vNodesDisconnected;
+static std::list<CNode *> vNodesDisconnected;
 
-struct NodeEvictionCandidate
-{
+struct NodeEvictionCandidate {
     NodeId id;
     int64_t nTimeConnected;
     int64_t nMinPingUsecTime;
@@ -881,13 +838,11 @@ struct NodeEvictionCandidate
     uint64_t nKeyedNetGroup;
 };
 
-static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
-{
+static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) {
     return a.nMinPingUsecTime > b.nMinPingUsecTime;
 }
 
-static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
-{
+static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) {
     return a.nTimeConnected > b.nTimeConnected;
 }
 
@@ -895,16 +850,14 @@ static bool CompareNetGroupKeyed(const NodeEvictionCandidate &a, const NodeEvict
     return a.nKeyedNetGroup < b.nKeyedNetGroup;
 }
 
-static bool CompareNodeBlockTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
-{
+static bool CompareNodeBlockTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) {
     // There is a fall-through here because it is common for a node to have many peers which have not yet relayed a block.
     if (a.nLastBlockTime != b.nLastBlockTime) return a.nLastBlockTime < b.nLastBlockTime;
     if (a.fRelevantServices != b.fRelevantServices) return b.fRelevantServices;
     return a.nTimeConnected > b.nTimeConnected;
 }
 
-static bool CompareNodeTXTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)
-{
+static bool CompareNodeTXTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) {
     // There is a fall-through here because it is common for a node to have more than a few peers that have not yet relayed txn.
     if (a.nLastTXTime != b.nLastTXTime) return a.nLastTXTime < b.nLastTXTime;
     if (a.fRelayTxes != b.fRelayTxes) return b.fRelayTxes;
@@ -921,11 +874,12 @@ static bool CompareNodeTXTime(const NodeEvictionCandidate &a, const NodeEviction
  *   simultaneously better at all of them than honest peers.
  */
 static bool AttemptToEvictConnection() {
-    std::vector<NodeEvictionCandidate> vEvictionCandidates;
+    std::vector <NodeEvictionCandidate> vEvictionCandidates;
     {
         LOCK(cs_vNodes);
 
-        BOOST_FOREACH(CNode *node, vNodes) {
+        BOOST_FOREACH(CNode * node, vNodes)
+        {
             if (node->fWhitelisted)
                 continue;
             if (!node->fInbound)
@@ -935,7 +889,8 @@ static bool AttemptToEvictConnection() {
             NodeEvictionCandidate candidate = {node->id, node->nTimeConnected, node->nMinPingUsecTime,
                                                node->nLastBlockTime, node->nLastTXTime,
                                                (node->nServices & nRelevantServices) == nRelevantServices,
-                                               node->fRelayTxes, node->pfilter != NULL, node->addr, node->nKeyedNetGroup};
+                                               node->fRelayTxes, node->pfilter != NULL, node->addr,
+                                               node->nKeyedNetGroup};
             vEvictionCandidates.push_back(candidate);
         }
     }
@@ -947,35 +902,40 @@ static bool AttemptToEvictConnection() {
     // Deterministically select 4 peers to protect by netgroup.
     // An attacker cannot predict which netgroups will be protected
     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), CompareNetGroupKeyed);
-    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(4, static_cast<int>(vEvictionCandidates.size())), vEvictionCandidates.end());
+    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(4, static_cast<int>(vEvictionCandidates.size())),
+                              vEvictionCandidates.end());
 
     if (vEvictionCandidates.empty()) return false;
 
     // Protect the 8 nodes with the lowest minimum ping time.
     // An attacker cannot manipulate this metric without physically moving nodes closer to the target.
     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), ReverseCompareNodeMinPingTime);
-    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(8, static_cast<int>(vEvictionCandidates.size())), vEvictionCandidates.end());
+    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(8, static_cast<int>(vEvictionCandidates.size())),
+                              vEvictionCandidates.end());
 
     if (vEvictionCandidates.empty()) return false;
 
     // Protect 4 nodes that most recently sent us transactions.
     // An attacker cannot manipulate this metric without performing useful work.
     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), CompareNodeTXTime);
-    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(4, static_cast<int>(vEvictionCandidates.size())), vEvictionCandidates.end());
+    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(4, static_cast<int>(vEvictionCandidates.size())),
+                              vEvictionCandidates.end());
 
     if (vEvictionCandidates.empty()) return false;
 
     // Protect 4 nodes that most recently sent us blocks.
     // An attacker cannot manipulate this metric without performing useful work.
     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), CompareNodeBlockTime);
-    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(4, static_cast<int>(vEvictionCandidates.size())), vEvictionCandidates.end());
+    vEvictionCandidates.erase(vEvictionCandidates.end() - std::min(4, static_cast<int>(vEvictionCandidates.size())),
+                              vEvictionCandidates.end());
 
     if (vEvictionCandidates.empty()) return false;
 
     // Protect the half of the remaining nodes which have been connected the longest.
     // This replicates the non-eviction implicit behavior, and precludes attacks that start later.
     std::sort(vEvictionCandidates.begin(), vEvictionCandidates.end(), ReverseCompareNodeTimeConnected);
-    vEvictionCandidates.erase(vEvictionCandidates.end() - static_cast<int>(vEvictionCandidates.size() / 2), vEvictionCandidates.end());
+    vEvictionCandidates.erase(vEvictionCandidates.end() - static_cast<int>(vEvictionCandidates.size() / 2),
+                              vEvictionCandidates.end());
 
     if (vEvictionCandidates.empty()) return false;
 
@@ -984,8 +944,9 @@ static bool AttemptToEvictConnection() {
     uint64_t naMostConnections;
     unsigned int nMostConnections = 0;
     int64_t nMostConnectionsTime = 0;
-    std::map<uint64_t, std::vector<NodeEvictionCandidate> > mapAddrCounts;
-    BOOST_FOREACH(const NodeEvictionCandidate &node, vEvictionCandidates) {
+    std::map <uint64_t, std::vector<NodeEvictionCandidate>> mapAddrCounts;
+    BOOST_FOREACH(
+    const NodeEvictionCandidate &node, vEvictionCandidates) {
         mapAddrCounts[node.nKeyedNetGroup].push_back(node);
         int64_t grouptime = mapAddrCounts[node.nKeyedNetGroup][0].nTimeConnected;
         size_t groupsize = mapAddrCounts[node.nKeyedNetGroup].size();
@@ -1003,7 +964,7 @@ static bool AttemptToEvictConnection() {
     // Disconnect from the network group with the most connections
     NodeId evicted = vEvictionCandidates.front().id;
     LOCK(cs_vNodes);
-    for(std::vector<CNode*>::const_iterator it(vNodes.begin()); it != vNodes.end(); ++it) {
+    for (std::vector<CNode *>::const_iterator it(vNodes.begin()); it != vNodes.end(); ++it) {
         if ((*it)->GetId() == evicted) {
             (*it)->fDisconnect = true;
             return true;
@@ -1012,36 +973,34 @@ static bool AttemptToEvictConnection() {
     return false;
 }
 
-static void AcceptConnection(const ListenSocket& hListenSocket) {
+static void AcceptConnection(const ListenSocket &hListenSocket) {
     struct sockaddr_storage sockaddr;
     socklen_t len = sizeof(sockaddr);
-    SOCKET hSocket = accept(hListenSocket.socket, (struct sockaddr*)&sockaddr, &len);
+    SOCKET hSocket = accept(hListenSocket.socket, (struct sockaddr *) &sockaddr, &len);
     CAddress addr;
     int nInbound = 0;
     int nMaxInbound = nMaxConnections - (MAX_OUTBOUND_CONNECTIONS + MAX_FEELER_CONNECTIONS);
 
     if (hSocket != INVALID_SOCKET)
-        if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr))
+        if (!addr.SetSockAddr((const struct sockaddr *) &sockaddr))
             LogPrintf("Warning: Unknown socket family\n");
 
     bool whitelisted = hListenSocket.whitelisted || CNode::IsWhitelistedRange(addr);
     {
         LOCK(cs_vNodes);
-        BOOST_FOREACH(CNode* pnode, vNodes)
-            if (pnode->fInbound)
-                nInbound++;
+        BOOST_FOREACH(CNode * pnode, vNodes)
+        if (pnode->fInbound)
+            nInbound++;
     }
 
-    if (hSocket == INVALID_SOCKET)
-    {
+    if (hSocket == INVALID_SOCKET) {
         int nErr = WSAGetLastError();
         if (nErr != WSAEWOULDBLOCK)
             LogPrintf("socket error accept failed: %s\n", NetworkErrorString(nErr));
         return;
     }
 
-    if (!IsSelectableSocket(hSocket))
-    {
+    if (!IsSelectableSocket(hSocket)) {
         LogPrintf("connection from %s dropped: non-selectable socket\n", addr.ToString());
         CloseSocket(hSocket);
         return;
@@ -1053,18 +1012,16 @@ static void AcceptConnection(const ListenSocket& hListenSocket) {
 #ifdef WIN32
     setsockopt(hSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&set, sizeof(int));
 #else
-    setsockopt(hSocket, IPPROTO_TCP, TCP_NODELAY, (void*)&set, sizeof(int));
+    setsockopt(hSocket, IPPROTO_TCP, TCP_NODELAY, (void *) &set, sizeof(int));
 #endif
 
-    if (CNode::IsBanned(addr) && !whitelisted)
-    {
+    if (CNode::IsBanned(addr) && !whitelisted) {
         LogPrintf("connection from %s dropped (banned)\n", addr.ToString());
         CloseSocket(hSocket);
         return;
     }
 
-    if (nInbound >= nMaxInbound)
-    {
+    if (nInbound >= nMaxInbound) {
         if (!AttemptToEvictConnection()) {
             // No connection to evict, disconnect the new connection
             LogPrint("net", "failed to find an eviction candidate - connection dropped (full)\n");
@@ -1073,7 +1030,7 @@ static void AcceptConnection(const ListenSocket& hListenSocket) {
         }
     }
 
-    CNode* pnode = new CNode(hSocket, addr, "", true);
+    CNode *pnode = new CNode(hSocket, addr, "", true);
     pnode->AddRef();
     pnode->fWhitelisted = whitelisted;
 
@@ -1085,23 +1042,21 @@ static void AcceptConnection(const ListenSocket& hListenSocket) {
     }
 }
 
-void ThreadSocketHandler()
-{
+void ThreadSocketHandler() {
     unsigned int nPrevNodeCount = 0;
-    while (true)
-    {
+    while (true) {
         //
         // Disconnect nodes
         //
         {
             LOCK(cs_vNodes);
             // Disconnect unused nodes
-            std::vector<CNode*> vNodesCopy = vNodes;
-            BOOST_FOREACH(CNode* pnode, vNodesCopy)
+            std::vector < CNode * > vNodesCopy = vNodes;
+            BOOST_FOREACH(CNode * pnode, vNodesCopy)
             {
                 if (pnode->fDisconnect ||
-                    (pnode->GetRefCount() <= 0 && pnode->vRecvMsg.empty() && pnode->nSendSize == 0 && pnode->ssSend.empty()))
-                {
+                    (pnode->GetRefCount() <= 0 && pnode->vRecvMsg.empty() && pnode->nSendSize == 0 &&
+                     pnode->ssSend.empty())) {
                     // remove from vNodes
                     vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
 
@@ -1120,35 +1075,31 @@ void ThreadSocketHandler()
         }
         {
             // Delete disconnected nodes
-            std::list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
-            BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
+            std::list < CNode * > vNodesDisconnectedCopy = vNodesDisconnected;
+            BOOST_FOREACH(CNode * pnode, vNodesDisconnectedCopy)
             {
                 // wait until threads are done using it
-                if (pnode->GetRefCount() <= 0)
-                {
+                if (pnode->GetRefCount() <= 0) {
                     bool fDelete = false;
                     {
                         TRY_LOCK(pnode->cs_vSend, lockSend);
-                        if (lockSend)
-                        {
+                        if (lockSend) {
                             TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
-                            if (lockRecv)
-                            {
+                            if (lockRecv) {
                                 TRY_LOCK(pnode->cs_inventory, lockInv);
                                 if (lockInv)
                                     fDelete = true;
                             }
                         }
                     }
-                    if (fDelete)
-                    {
+                    if (fDelete) {
                         vNodesDisconnected.remove(pnode);
                         delete pnode;
                     }
                 }
             }
         }
-        if(vNodes.size() != nPrevNodeCount) {
+        if (vNodes.size() != nPrevNodeCount) {
             nPrevNodeCount = vNodes.size();
             uiInterface.NotifyNumConnectionsChanged(nPrevNodeCount);
         }
@@ -1157,7 +1108,7 @@ void ThreadSocketHandler()
         // Find which sockets have data to receive
         //
         struct timeval timeout;
-        timeout.tv_sec  = 0;
+        timeout.tv_sec = 0;
         timeout.tv_usec = 50000; // frequency to poll pnode->vSend
 
         fd_set fdsetRecv;
@@ -1169,7 +1120,8 @@ void ThreadSocketHandler()
         SOCKET hSocketMax = 0;
         bool have_fds = false;
 
-        BOOST_FOREACH(const ListenSocket& hListenSocket, vhListenSocket) {
+        BOOST_FOREACH(
+        const ListenSocket &hListenSocket, vhListenSocket) {
             FD_SET(hListenSocket.socket, &fdsetRecv);
             hSocketMax = std::max(hSocketMax, hListenSocket.socket);
             have_fds = true;
@@ -1177,7 +1129,7 @@ void ThreadSocketHandler()
 
         {
             LOCK(cs_vNodes);
-            BOOST_FOREACH(CNode* pnode, vNodes)
+            BOOST_FOREACH(CNode * pnode, vNodes)
             {
                 if (pnode->hSocket == INVALID_SOCKET)
                     continue;
@@ -1210,8 +1162,8 @@ void ThreadSocketHandler()
                 {
                     TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
                     if (lockRecv && (
-                        pnode->vRecvMsg.empty() || !pnode->vRecvMsg.front().complete() ||
-                        pnode->GetTotalRecvSize() <= ReceiveFloodSize()))
+                            pnode->vRecvMsg.empty() || !pnode->vRecvMsg.front().complete() ||
+                            pnode->GetTotalRecvSize() <= ReceiveFloodSize()))
                         FD_SET(pnode->hSocket, &fdsetRecv);
                 }
             }
@@ -1221,10 +1173,8 @@ void ThreadSocketHandler()
                              &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
         boost::this_thread::interruption_point();
 
-        if (nSelect == SOCKET_ERROR)
-        {
-            if (have_fds)
-            {
+        if (nSelect == SOCKET_ERROR) {
+            if (have_fds) {
                 int nErr = WSAGetLastError();
                 LogPrintf("socket select error %s\n", NetworkErrorString(nErr));
                 for (unsigned int i = 0; i <= hSocketMax; i++)
@@ -1232,16 +1182,16 @@ void ThreadSocketHandler()
             }
             FD_ZERO(&fdsetSend);
             FD_ZERO(&fdsetError);
-            MilliSleep(timeout.tv_usec/1000);
+            MilliSleep(timeout.tv_usec / 1000);
         }
 
         //
         // Accept new connections
         //
-        BOOST_FOREACH(const ListenSocket& hListenSocket, vhListenSocket)
+        BOOST_FOREACH(
+        const ListenSocket &hListenSocket, vhListenSocket)
         {
-            if (hListenSocket.socket != INVALID_SOCKET && FD_ISSET(hListenSocket.socket, &fdsetRecv))
-            {
+            if (hListenSocket.socket != INVALID_SOCKET && FD_ISSET(hListenSocket.socket, &fdsetRecv)) {
                 AcceptConnection(hListenSocket);
             }
         }
@@ -1249,14 +1199,14 @@ void ThreadSocketHandler()
         //
         // Service each socket
         //
-        std::vector<CNode*> vNodesCopy;
+        std::vector < CNode * > vNodesCopy;
         {
             LOCK(cs_vNodes);
             vNodesCopy = vNodes;
-            BOOST_FOREACH(CNode* pnode, vNodesCopy)
-                pnode->AddRef();
+            BOOST_FOREACH(CNode * pnode, vNodesCopy)
+            pnode->AddRef();
         }
-        BOOST_FOREACH(CNode* pnode, vNodesCopy)
+        BOOST_FOREACH(CNode * pnode, vNodesCopy)
         {
             boost::this_thread::interruption_point();
 
@@ -1265,36 +1215,29 @@ void ThreadSocketHandler()
             //
             if (pnode->hSocket == INVALID_SOCKET)
                 continue;
-            if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
-            {
+            if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError)) {
                 TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
-                if (lockRecv)
-                {
+                if (lockRecv) {
                     {
                         // typical socket buffer is 8K-64K
                         char pchBuf[0x10000];
                         int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
-                        if (nBytes > 0)
-                        {
+                        if (nBytes > 0) {
                             if (!pnode->ReceiveMsgBytes(pchBuf, nBytes))
                                 pnode->CloseSocketDisconnect();
                             pnode->nLastRecv = GetTime();
                             pnode->nRecvBytes += nBytes;
                             pnode->RecordBytesRecv(nBytes);
-                        }
-                        else if (nBytes == 0)
-                        {
+                        } else if (nBytes == 0) {
                             // socket closed gracefully
                             if (!pnode->fDisconnect)
                                 LogPrint("net", "socket closed\n");
                             pnode->CloseSocketDisconnect();
-                        }
-                        else if (nBytes < 0)
-                        {
+                        } else if (nBytes < 0) {
                             // error
                             int nErr = WSAGetLastError();
-                            if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
-                            {
+                            if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR &&
+                                nErr != WSAEINPROGRESS) {
                                 if (!pnode->fDisconnect)
                                     LogPrintf("socket recv error %s\n", NetworkErrorString(nErr));
                                 pnode->CloseSocketDisconnect();
@@ -1309,8 +1252,7 @@ void ThreadSocketHandler()
             //
             if (pnode->hSocket == INVALID_SOCKET)
                 continue;
-            if (FD_ISSET(pnode->hSocket, &fdsetSend))
-            {
+            if (FD_ISSET(pnode->hSocket, &fdsetSend)) {
                 TRY_LOCK(pnode->cs_vSend, lockSend);
                 if (lockSend)
                     SocketSendData(pnode);
@@ -1320,25 +1262,20 @@ void ThreadSocketHandler()
             // Inactivity checking
             //
             int64_t nTime = GetTime();
-            if (nTime - pnode->nTimeConnected > 60)
-            {
-                if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
-                {
-                    LogPrint("net", "socket no message in first 60 seconds, %d %d from %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0, pnode->id);
+            if (nTime - pnode->nTimeConnected > 60) {
+                if (pnode->nLastRecv == 0 || pnode->nLastSend == 0) {
+                    LogPrint("net", "socket no message in first 60 seconds, %d %d from %d\n", pnode->nLastRecv != 0,
+                             pnode->nLastSend != 0, pnode->id);
                     pnode->fDisconnect = true;
-                }
-                else if (nTime - pnode->nLastSend > TIMEOUT_INTERVAL)
-                {
+                } else if (nTime - pnode->nLastSend > TIMEOUT_INTERVAL) {
                     LogPrintf("socket sending timeout: %is\n", nTime - pnode->nLastSend);
                     pnode->fDisconnect = true;
-                }
-                else if (nTime - pnode->nLastRecv > (pnode->nVersion > BIP0031_VERSION ? TIMEOUT_INTERVAL : 90*60))
-                {
+                } else if (nTime - pnode->nLastRecv >
+                           (pnode->nVersion > BIP0031_VERSION ? TIMEOUT_INTERVAL : 90 * 60)) {
                     LogPrintf("socket receive timeout: %is\n", nTime - pnode->nLastRecv);
                     pnode->fDisconnect = true;
-                }
-                else if (pnode->nPingNonceSent && pnode->nPingUsecStart + TIMEOUT_INTERVAL * 1000000 < GetTimeMicros())
-                {
+                } else if (pnode->nPingNonceSent &&
+                           pnode->nPingUsecStart + TIMEOUT_INTERVAL * 1000000 < GetTimeMicros()) {
                     LogPrintf("ping timeout: %fs\n", 0.000001 * (GetTimeMicros() - pnode->nPingUsecStart));
                     pnode->fDisconnect = true;
                 }
@@ -1346,20 +1283,13 @@ void ThreadSocketHandler()
         }
         {
             LOCK(cs_vNodes);
-            BOOST_FOREACH(CNode* pnode, vNodesCopy)
-                pnode->Release();
+            BOOST_FOREACH(CNode * pnode, vNodesCopy)
+            pnode->Release();
         }
     }
 }
 
 
-
-
-
-
-
-
-
 #ifdef USE_UPNP
 void ThreadMapPort()
 {
@@ -1467,19 +1397,15 @@ void MapPort(bool fUseUPnP)
 }
 
 #else
-void MapPort(bool)
-{
+
+void MapPort(bool) {
     // Intentionally left blank.
 }
-#endif
-
-
-
 
+#endif
 
 
-static std::string GetDNSHost(const CDNSSeedData& data, ServiceFlags* requiredServiceBits)
-{
+static std::string GetDNSHost(const CDNSSeedData &data, ServiceFlags *requiredServiceBits) {
     //use default host for non-filter-capable seeds or if we use the default service bits (NODE_NETWORK)
     if (!data.supportsServiceBitsFiltering || *requiredServiceBits == NODE_NETWORK) {
         *requiredServiceBits = NODE_NETWORK;
@@ -1491,8 +1417,7 @@ static std::string GetDNSHost(const CDNSSeedData& data, ServiceFlags* requiredSe
 }
 
 
-void ThreadDNSAddressSeed()
-{
+void ThreadDNSAddressSeed() {
     // goal: only query DNS seeds if address need is acute
     // Avoiding DNS seeds when we don't need them improves user privacy by
     //  creating fewer identifying DNS requests, reduces trust by giving seeds
@@ -1512,25 +1437,27 @@ void ThreadDNSAddressSeed()
         }
     }
 
-    const std::vector<CDNSSeedData> &vSeeds = Params().DNSSeeds();
+    const std::vector <CDNSSeedData> &vSeeds = Params().DNSSeeds();
     int found = 0;
 
     LogPrintf("Loading addresses from DNS seeds (could take a while)\n");
 
-    BOOST_FOREACH(const CDNSSeedData &seed, vSeeds) {
+    BOOST_FOREACH(
+    const CDNSSeedData &seed, vSeeds) {
         if (HaveNameProxy()) {
             AddOneShot(seed.host);
         } else {
-            std::vector<CNetAddr> vIPs;
-            std::vector<CAddress> vAdd;
+            std::vector <CNetAddr> vIPs;
+            std::vector <CAddress> vAdd;
             ServiceFlags requiredServiceBits = nRelevantServices;
-            if (LookupHost(GetDNSHost(seed, &requiredServiceBits).c_str(), vIPs, 0, true))
-            {
-                BOOST_FOREACH(const CNetAddr& ip, vIPs)
+            if (LookupHost(GetDNSHost(seed, &requiredServiceBits).c_str(), vIPs, 0, true)) {
+                BOOST_FOREACH(
+                const CNetAddr &ip, vIPs)
                 {
-                    int nOneDay = 24*3600;
+                    int nOneDay = 24 * 3600;
                     CAddress addr = CAddress(CService(ip, Params().GetDefaultPort()), requiredServiceBits);
-                    addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
+                    addr.nTime =
+                            GetTime() - 3 * nOneDay - GetRand(4 * nOneDay); // use a random age between 3 and 7 days old
                     vAdd.push_back(addr);
                     found++;
                 }
@@ -1551,35 +1478,22 @@ void ThreadDNSAddressSeed()
 }
 
 
-
-
-
-
-
-
-
-
-
-
-void DumpAddresses()
-{
+void DumpAddresses() {
     int64_t nStart = GetTimeMillis();
 
     CAddrDB adb;
     adb.Write(addrman);
 
     LogPrint("net", "Flushed %d addresses to peers.dat  %dms\n",
-           addrman.size(), GetTimeMillis() - nStart);
+             addrman.size(), GetTimeMillis() - nStart);
 }
 
-void DumpData()
-{
+void DumpData() {
     DumpAddresses();
     DumpBanlist();
 }
 
-void static ProcessOneShot()
-{
+void static ProcessOneShot() {
     std::string strDest;
     {
         LOCK(cs_vOneShots);
@@ -1596,20 +1510,17 @@ void static ProcessOneShot()
     }
 }
 
-void ThreadOpenConnections()
-{
+void ThreadOpenConnections() {
     // Connect to specific addresses
-    if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0)
-    {
-        for (int64_t nLoop = 0;; nLoop++)
-        {
+    if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0) {
+        for (int64_t nLoop = 0;; nLoop++) {
             ProcessOneShot();
-            BOOST_FOREACH(const std::string& strAddr, mapMultiArgs["-connect"])
+            BOOST_FOREACH(
+            const std::string &strAddr, mapMultiArgs["-connect"])
             {
                 CAddress addr(CService(), NODE_NONE);
                 OpenNetworkConnection(addr, false, NULL, strAddr.c_str());
-                for (int i = 0; i < 10 && i < nLoop; i++)
-                {
+                for (int i = 0; i < 10 && i < nLoop; i++) {
                     MilliSleep(500);
                 }
             }
@@ -1621,9 +1532,8 @@ void ThreadOpenConnections()
     int64_t nStart = GetTime();
 
     // Minimum time before next feeler connection (in microseconds).
-    int64_t nNextFeeler = PoissonNextSend(nStart*1000*1000, FEELER_INTERVAL);
-    while (true)
-    {
+    int64_t nNextFeeler = PoissonNextSend(nStart * 1000 * 1000, FEELER_INTERVAL);
+    while (true) {
         ProcessOneShot();
 
         MilliSleep(500);
@@ -1649,10 +1559,11 @@ void ThreadOpenConnections()
         // Only connect out to one peer per network group (/16 for IPv4).
         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
         int nOutbound = 0;
-        std::set<std::vector<unsigned char> > setConnected;
+        std::set <std::vector<unsigned char>> setConnected;
         {
             LOCK(cs_vNodes);
-            BOOST_FOREACH(CNode* pnode, vNodes) {
+            BOOST_FOREACH(CNode * pnode, vNodes)
+            {
                 if (!pnode->fInbound) {
                     setConnected.insert(pnode->addr.GetGroup());
                     nOutbound++;
@@ -1685,8 +1596,7 @@ void ThreadOpenConnections()
 
         int64_t nANow = GetAdjustedTime();
         int nTries = 0;
-        while (true)
-        {
+        while (true) {
             CAddrInfo addr = addrman.Select(fFeeler);
 
             // if we selected an invalid address, restart
@@ -1712,7 +1622,8 @@ void ThreadOpenConnections()
                 continue;
 
             // only consider nodes missing relevant services after 40 failed attempts and only if less than half the outbound are up.
-            if ((addr.nServices & nRelevantServices) != nRelevantServices && (nTries < 40 || nOutbound >= (MAX_OUTBOUND_CONNECTIONS >> 1)))
+            if ((addr.nServices & nRelevantServices) != nRelevantServices &&
+                (nTries < 40 || nOutbound >= (MAX_OUTBOUND_CONNECTIONS >> 1)))
                 continue;
 
             // do not allow non-default ports, unless after 50 invalid addresses selected already
@@ -1732,40 +1643,43 @@ void ThreadOpenConnections()
                 LogPrint("net", "Making feeler connection to %s\n", addrConnect.ToString());
             }
 
-            OpenNetworkConnection(addrConnect, (int)setConnected.size() >= std::min(nMaxConnections - 1, 2), &grant, NULL, false, fFeeler);
+            OpenNetworkConnection(addrConnect, (int) setConnected.size() >= std::min(nMaxConnections - 1, 2), &grant,
+                                  NULL, false, fFeeler);
         }
     }
 }
 
-std::vector<AddedNodeInfo> GetAddedNodeInfo()
-{
-    std::vector<AddedNodeInfo> ret;
+std::vector <AddedNodeInfo> GetAddedNodeInfo() {
+    std::vector <AddedNodeInfo> ret;
 
-    std::list<std::string> lAddresses(0);
+    std::list <std::string> lAddresses(0);
     {
         LOCK(cs_vAddedNodes);
         ret.reserve(vAddedNodes.size());
-        BOOST_FOREACH(const std::string& strAddNode, vAddedNodes)
-            lAddresses.push_back(strAddNode);
+        BOOST_FOREACH(
+        const std::string &strAddNode, vAddedNodes)
+        lAddresses.push_back(strAddNode);
     }
 
 
     // Build a map of all already connected addresses (by IP:port and by name) to inbound/outbound and resolved CService
     std::map<CService, bool> mapConnected;
-    std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
+    std::map <std::string, std::pair<bool, CService>> mapConnectedByName;
     {
         LOCK(cs_vNodes);
-        for (const CNode* pnode : vNodes) {
+        for (const CNode *pnode : vNodes) {
             if (pnode->addr.IsValid()) {
                 mapConnected[pnode->addr] = pnode->fInbound;
             }
             if (!pnode->addrName.empty()) {
-                mapConnectedByName[pnode->addrName] = std::make_pair(pnode->fInbound, static_cast<const CService&>(pnode->addr));
+                mapConnectedByName[pnode->addrName] = std::make_pair(pnode->fInbound,
+                                                                     static_cast<const CService &>(pnode->addr));
             }
         }
     }
 
-    BOOST_FOREACH(const std::string& strAddNode, lAddresses) {
+    BOOST_FOREACH(
+    const std::string &strAddNode, lAddresses) {
         CService service(strAddNode, Params().GetDefaultPort());
         if (service.IsValid()) {
             // strAddNode is an IP:port
@@ -1789,17 +1703,15 @@ std::vector<AddedNodeInfo> GetAddedNodeInfo()
     return ret;
 }
 
-void ThreadOpenAddedConnections()
-{
+void ThreadOpenAddedConnections() {
     {
         LOCK(cs_vAddedNodes);
         vAddedNodes = mapMultiArgs["-addnode"];
     }
 
-    for (unsigned int i = 0; true; i++)
-    {
-        std::vector<AddedNodeInfo> vInfo = GetAddedNodeInfo();
-        for (const AddedNodeInfo& info : vInfo) {
+    for (unsigned int i = 0; true; i++) {
+        std::vector <AddedNodeInfo> vInfo = GetAddedNodeInfo();
+        for (const AddedNodeInfo &info : vInfo) {
             if (!info.fConnected) {
                 CSemaphoreGrant grant(*semOutbound);
                 // If strAddedNode is an IP/port, decode it immediately, so
@@ -1815,21 +1727,21 @@ void ThreadOpenAddedConnections()
 }
 
 // if successful, this moves the passed grant to the constructed node
-bool OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *pszDest, bool fOneShot, bool fFeeler)
-{
+bool OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound,
+                           const char *pszDest, bool fOneShot, bool fFeeler) {
     //
     // Initiate outbound network connection
     //
     boost::this_thread::interruption_point();
     if (!pszDest) {
         if (IsLocal(addrConnect) ||
-            FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect) ||
+            FindNode((CNetAddr) addrConnect) || CNode::IsBanned(addrConnect) ||
             FindNode(addrConnect.ToStringIPPort()))
             return false;
     } else if (FindNode(std::string(pszDest)))
         return false;
 
-    CNode* pnode = ConnectNode(addrConnect, pszDest, fCountFailure);
+    CNode *pnode = ConnectNode(addrConnect, pszDest, fCountFailure);
     boost::this_thread::interruption_point();
 
     if (!pnode)
@@ -1846,25 +1758,24 @@ bool OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSem
 }
 
 
-void ThreadMessageHandler()
-{
+void ThreadMessageHandler() {
     boost::mutex condition_mutex;
     boost::unique_lock<boost::mutex> lock(condition_mutex);
 
-    while (true)
-    {
-        std::vector<CNode*> vNodesCopy;
+    while (true) {
+        std::vector < CNode * > vNodesCopy;
         {
             LOCK(cs_vNodes);
             vNodesCopy = vNodes;
-            BOOST_FOREACH(CNode* pnode, vNodesCopy) {
+            BOOST_FOREACH(CNode * pnode, vNodesCopy)
+            {
                 pnode->AddRef();
             }
         }
 
         bool fSleep = true;
 
-        BOOST_FOREACH(CNode* pnode, vNodesCopy)
+        BOOST_FOREACH(CNode * pnode, vNodesCopy)
         {
             if (pnode->fDisconnect)
                 continue;
@@ -1872,15 +1783,13 @@ void ThreadMessageHandler()
             // Receive messages
             {
                 TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
-                if (lockRecv)
-                {
+                if (lockRecv) {
                     if (!GetNodeSignals().ProcessMessages(pnode))
                         pnode->CloseSocketDisconnect();
 
-                    if (pnode->nSendSize < SendBufferSize())
-                    {
-                        if (!pnode->vRecvGetData.empty() || (!pnode->vRecvMsg.empty() && pnode->vRecvMsg[0].complete()))
-                        {
+                    if (pnode->nSendSize < SendBufferSize()) {
+                        if (!pnode->vRecvGetData.empty() ||
+                            (!pnode->vRecvMsg.empty() && pnode->vRecvMsg[0].complete())) {
                             fSleep = false;
                         }
                     }
@@ -1899,44 +1808,38 @@ void ThreadMessageHandler()
 
         {
             LOCK(cs_vNodes);
-            BOOST_FOREACH(CNode* pnode, vNodesCopy)
-                pnode->Release();
+            BOOST_FOREACH(CNode * pnode, vNodesCopy)
+            pnode->Release();
         }
 
         if (fSleep)
-            messageHandlerCondition.timed_wait(lock, boost::posix_time::microsec_clock::universal_time() + boost::posix_time::milliseconds(100));
+            messageHandlerCondition.timed_wait(lock, boost::posix_time::microsec_clock::universal_time() +
+                                                     boost::posix_time::milliseconds(100));
     }
 }
 
 
-
-
-
-
-bool BindListenPort(const CService &addrBind, std::string& strError, bool fWhitelisted)
-{
+bool BindListenPort(const CService &addrBind, std::string &strError, bool fWhitelisted) {
     strError = "";
     int nOne = 1;
 
     // Create socket for listening for incoming connections
     struct sockaddr_storage sockaddr;
     socklen_t len = sizeof(sockaddr);
-    if (!addrBind.GetSockAddr((struct sockaddr*)&sockaddr, &len))
-    {
+    if (!addrBind.GetSockAddr((struct sockaddr *) &sockaddr, &len)) {
         strError = strprintf("Error: Bind address family for %s not supported", addrBind.ToString());
         LogPrintf("%s\n", strError);
         return false;
     }
 
-    SOCKET hListenSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
-    if (hListenSocket == INVALID_SOCKET)
-    {
-        strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %s)", NetworkErrorString(WSAGetLastError()));
+    SOCKET hListenSocket = socket(((struct sockaddr *) &sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
+    if (hListenSocket == INVALID_SOCKET) {
+        strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %s)",
+                             NetworkErrorString(WSAGetLastError()));
         LogPrintf("%s\n", strError);
         return false;
     }
-    if (!IsSelectableSocket(hListenSocket))
-    {
+    if (!IsSelectableSocket(hListenSocket)) {
         strError = "Error: Couldn't create a listenable socket for incoming connections";
         LogPrintf("%s\n", strError);
         return false;
@@ -1950,9 +1853,9 @@ bool BindListenPort(const CService &addrBind, std::string& strError, bool fWhite
 #endif
     // Allow binding if the port is still in TIME_WAIT state after
     // the program was closed and restarted.
-    setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
+    setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void *) &nOne, sizeof(int));
     // Disable Nagle's algorithm
-    setsockopt(hListenSocket, IPPROTO_TCP, TCP_NODELAY, (void*)&nOne, sizeof(int));
+    setsockopt(hListenSocket, IPPROTO_TCP, TCP_NODELAY, (void *) &nOne, sizeof(int));
 #else
     setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&nOne, sizeof(int));
     setsockopt(hListenSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&nOne, sizeof(int));
@@ -1960,7 +1863,8 @@ bool BindListenPort(const CService &addrBind, std::string& strError, bool fWhite
 
     // Set to non-blocking, incoming connections will also inherit this
     if (!SetSocketNonBlocking(hListenSocket, true)) {
-        strError = strprintf("BindListenPort: Setting listening socket to non-blocking failed, error %s\n", NetworkErrorString(WSAGetLastError()));
+        strError = strprintf("BindListenPort: Setting listening socket to non-blocking failed, error %s\n",
+                             NetworkErrorString(WSAGetLastError()));
         LogPrintf("%s\n", strError);
         return false;
     }
@@ -1981,13 +1885,14 @@ bool BindListenPort(const CService &addrBind, std::string& strError, bool fWhite
 #endif
     }
 
-    if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)
-    {
+    if (::bind(hListenSocket, (struct sockaddr *) &sockaddr, len) == SOCKET_ERROR) {
         int nErr = WSAGetLastError();
         if (nErr == WSAEADDRINUSE)
-            strError = strprintf(_("Unable to bind to %s on this computer. %s is probably already running."), addrBind.ToString(), _(PACKAGE_NAME));
+            strError = strprintf(_("Unable to bind to %s on this computer. %s is probably already running."),
+                                 addrBind.ToString(), _(PACKAGE_NAME));
         else
-            strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %s)"), addrBind.ToString(), NetworkErrorString(nErr));
+            strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %s)"),
+                                 addrBind.ToString(), NetworkErrorString(nErr));
         LogPrintf("%s\n", strError);
         CloseSocket(hListenSocket);
         return false;
@@ -1995,9 +1900,9 @@ bool BindListenPort(const CService &addrBind, std::string& strError, bool fWhite
     LogPrintf("Bound to %s\n", addrBind.ToString());
 
     // Listen for incoming connections
-    if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
-    {
-        strError = strprintf(_("Error: Listening for incoming connections failed (listen returned error %s)"), NetworkErrorString(WSAGetLastError()));
+    if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR) {
+        strError = strprintf(_("Error: Listening for incoming connections failed (listen returned error %s)"),
+                             NetworkErrorString(WSAGetLastError()));
         LogPrintf("%s\n", strError);
         CloseSocket(hListenSocket);
         return false;
@@ -2011,8 +1916,7 @@ bool BindListenPort(const CService &addrBind, std::string& strError, bool fWhite
     return true;
 }
 
-void static Discover(boost::thread_group& threadGroup)
-{
+void static Discover(boost::thread_group &threadGroup) {
     if (!fDiscover)
         return;
 
@@ -2033,25 +1937,20 @@ void static Discover(boost::thread_group& threadGroup)
     }
 #else
     // Get local host ip
-    struct ifaddrs* myaddrs;
-    if (getifaddrs(&myaddrs) == 0)
-    {
-        for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
-        {
+    struct ifaddrs *myaddrs;
+    if (getifaddrs(&myaddrs) == 0) {
+        for (struct ifaddrs *ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next) {
             if (ifa->ifa_addr == NULL) continue;
             if ((ifa->ifa_flags & IFF_UP) == 0) continue;
             if (strcmp(ifa->ifa_name, "lo") == 0) continue;
             if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
-            if (ifa->ifa_addr->sa_family == AF_INET)
-            {
-                struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
+            if (ifa->ifa_addr->sa_family == AF_INET) {
+                struct sockaddr_in *s4 = (struct sockaddr_in *) (ifa->ifa_addr);
                 CNetAddr addr(s4->sin_addr);
                 if (AddLocal(addr, LOCAL_IF))
                     LogPrintf("%s: IPv4 %s: %s\n", __func__, ifa->ifa_name, addr.ToString());
-            }
-            else if (ifa->ifa_addr->sa_family == AF_INET6)
-            {
-                struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
+            } else if (ifa->ifa_addr->sa_family == AF_INET6) {
+                struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) (ifa->ifa_addr);
                 CNetAddr addr(s6->sin6_addr);
                 if (AddLocal(addr, LOCAL_IF))
                     LogPrintf("%s: IPv6 %s: %s\n", __func__, ifa->ifa_name, addr.ToString());
@@ -2062,8 +1961,7 @@ void static Discover(boost::thread_group& threadGroup)
 #endif
 }
 
-void StartNode(boost::thread_group& threadGroup, CScheduler& scheduler)
-{
+void StartNode(boost::thread_group &threadGroup, CScheduler &scheduler) {
     uiInterface.InitMessage(_("Loading addresses..."));
     // Load addresses from peers.dat
     int64_t nStart = GetTimeMillis();
@@ -2089,7 +1987,7 @@ void StartNode(boost::thread_group& threadGroup, CScheduler& scheduler)
         CNode::SweepBanned(); // sweep out unused entries
 
         LogPrint("net", "Loaded %d banned node ips/subnets from banlist.dat  %dms\n",
-            banmap.size(), GetTimeMillis() - nStart);
+                 banmap.size(), GetTimeMillis() - nStart);
     } else {
         LogPrintf("Invalid or missing banlist.dat; recreating\n");
         CNode::SetBannedSetDirty(true); // force write
@@ -2139,16 +2037,14 @@ void StartNode(boost::thread_group& threadGroup, CScheduler& scheduler)
     scheduler.scheduleEvery(&DumpData, DUMP_ADDRESSES_INTERVAL);
 }
 
-bool StopNode()
-{
+bool StopNode() {
     LogPrintf("StopNode()\n");
     MapPort(false);
     if (semOutbound)
-        for (int i=0; i<(MAX_OUTBOUND_CONNECTIONS + MAX_FEELER_CONNECTIONS); i++)
+        for (int i = 0; i < (MAX_OUTBOUND_CONNECTIONS + MAX_FEELER_CONNECTIONS); i++)
             semOutbound->post();
 
-    if (fAddressesInitialized)
-    {
+    if (fAddressesInitialized) {
         DumpData();
         fAddressesInitialized = false;
     }
@@ -2156,27 +2052,25 @@ bool StopNode()
     return true;
 }
 
-class CNetCleanup
-{
+class CNetCleanup {
 public:
     CNetCleanup() {}
 
-    ~CNetCleanup()
-    {
+    ~CNetCleanup() {
         // Close sockets
-        BOOST_FOREACH(CNode* pnode, vNodes)
-            if (pnode->hSocket != INVALID_SOCKET)
-                CloseSocket(pnode->hSocket);
-        BOOST_FOREACH(ListenSocket& hListenSocket, vhListenSocket)
-            if (hListenSocket.socket != INVALID_SOCKET)
-                if (!CloseSocket(hListenSocket.socket))
-                    LogPrintf("CloseSocket(hListenSocket) failed with error %s\n", NetworkErrorString(WSAGetLastError()));
+        BOOST_FOREACH(CNode * pnode, vNodes)
+        if (pnode->hSocket != INVALID_SOCKET)
+            CloseSocket(pnode->hSocket);
+        BOOST_FOREACH(ListenSocket & hListenSocket, vhListenSocket)
+        if (hListenSocket.socket != INVALID_SOCKET)
+            if (!CloseSocket(hListenSocket.socket))
+                LogPrintf("CloseSocket(hListenSocket) failed with error %s\n", NetworkErrorString(WSAGetLastError()));
 
         // clean up some globals (to help leak detection)
-        BOOST_FOREACH(CNode *pnode, vNodes)
-            delete pnode;
-        BOOST_FOREACH(CNode *pnode, vNodesDisconnected)
-            delete pnode;
+        BOOST_FOREACH(CNode * pnode, vNodes)
+        delete pnode;
+        BOOST_FOREACH(CNode * pnode, vNodesDisconnected)
+        delete pnode;
         vNodes.clear();
         vNodesDisconnected.clear();
         vhListenSocket.clear();
@@ -2191,33 +2085,42 @@ class CNetCleanup
 #endif
     }
 }
-instance_of_cnetcleanup;
+        instance_of_cnetcleanup;
 
 
-void RelayTransaction(const CTransaction& tx)
-{
+void RelayTransaction(const CTransaction &tx) {
     CInv inv(MSG_TX, tx.GetHash());
     LOCK(cs_vNodes);
-    BOOST_FOREACH(CNode* pnode, vNodes)
+    BOOST_FOREACH(CNode * pnode, vNodes)
     {
         pnode->PushInventory(inv);
     }
 }
 
-void CNode::RecordBytesRecv(uint64_t bytes)
-{
+void RelayInv(CInv &inv, const int minProtoVersion) {
+    LOCK(cs_vNodes);
+//    LogPrintf("RelayInv, vNodes.size()=%s\n", vNodes.size());
+    BOOST_FOREACH(CNode * pnode, vNodes)
+    {
+//        LogPrintf("pnode->nVersion=%s\n", pnode->nVersion);
+//        LogPrintf("minProtoVersion=%s\n", minProtoVersion);
+        if (pnode->nVersion >= minProtoVersion) {
+            pnode->PushInventory(inv);
+        }
+    }
+}
+
+void CNode::RecordBytesRecv(uint64_t bytes) {
     LOCK(cs_totalBytesRecv);
     nTotalBytesRecv += bytes;
 }
 
-void CNode::RecordBytesSent(uint64_t bytes)
-{
+void CNode::RecordBytesSent(uint64_t bytes) {
     LOCK(cs_totalBytesSent);
     nTotalBytesSent += bytes;
 
     uint64_t now = GetTime();
-    if (nMaxOutboundCycleStartTime + nMaxOutboundTimeframe < now)
-    {
+    if (nMaxOutboundCycleStartTime + nMaxOutboundTimeframe < now) {
         // timeframe expired, reset cycle
         nMaxOutboundCycleStartTime = now;
         nMaxOutboundTotalBytesSentInCycle = 0;
@@ -2227,26 +2130,22 @@ void CNode::RecordBytesSent(uint64_t bytes)
     nMaxOutboundTotalBytesSentInCycle += bytes;
 }
 
-void CNode::SetMaxOutboundTarget(uint64_t limit)
-{
+void CNode::SetMaxOutboundTarget(uint64_t limit) {
     LOCK(cs_totalBytesSent);
     nMaxOutboundLimit = limit;
 }
 
-uint64_t CNode::GetMaxOutboundTarget()
-{
+uint64_t CNode::GetMaxOutboundTarget() {
     LOCK(cs_totalBytesSent);
     return nMaxOutboundLimit;
 }
 
-uint64_t CNode::GetMaxOutboundTimeframe()
-{
+uint64_t CNode::GetMaxOutboundTimeframe() {
     LOCK(cs_totalBytesSent);
     return nMaxOutboundTimeframe;
 }
 
-uint64_t CNode::GetMaxOutboundTimeLeftInCycle()
-{
+uint64_t CNode::GetMaxOutboundTimeLeftInCycle() {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0)
         return 0;
@@ -2259,11 +2158,9 @@ uint64_t CNode::GetMaxOutboundTimeLeftInCycle()
     return (cycleEndTime < now) ? 0 : cycleEndTime - GetTime();
 }
 
-void CNode::SetMaxOutboundTimeframe(uint64_t timeframe)
-{
+void CNode::SetMaxOutboundTimeframe(uint64_t timeframe) {
     LOCK(cs_totalBytesSent);
-    if (nMaxOutboundTimeframe != timeframe)
-    {
+    if (nMaxOutboundTimeframe != timeframe) {
         // reset measure-cycle in case of changing
         // the timeframe
         nMaxOutboundCycleStartTime = GetTime();
@@ -2271,76 +2168,69 @@ void CNode::SetMaxOutboundTimeframe(uint64_t timeframe)
     nMaxOutboundTimeframe = timeframe;
 }
 
-bool CNode::OutboundTargetReached(bool historicalBlockServingLimit)
-{
+bool CNode::OutboundTargetReached(bool historicalBlockServingLimit) {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0)
         return false;
 
-    if (historicalBlockServingLimit)
-    {
+    if (historicalBlockServingLimit) {
         // keep a large enough buffer to at least relay each block once
         uint64_t timeLeftInCycle = GetMaxOutboundTimeLeftInCycle();
         uint64_t buffer = timeLeftInCycle / 600 * MAX_BLOCK_SERIALIZED_SIZE;
         if (buffer >= nMaxOutboundLimit || nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer)
             return true;
-    }
-    else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
+    } else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
         return true;
 
     return false;
 }
 
-uint64_t CNode::GetOutboundTargetBytesLeft()
-{
+uint64_t CNode::GetOutboundTargetBytesLeft() {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0)
         return 0;
 
-    return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
+    return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit -
+                                                                          nMaxOutboundTotalBytesSentInCycle;
 }
 
-uint64_t CNode::GetTotalBytesRecv()
-{
+uint64_t CNode::GetTotalBytesRecv() {
     LOCK(cs_totalBytesRecv);
     return nTotalBytesRecv;
 }
 
-uint64_t CNode::GetTotalBytesSent()
-{
+uint64_t CNode::GetTotalBytesSent() {
     LOCK(cs_totalBytesSent);
     return nTotalBytesSent;
 }
 
-void CNode::Fuzz(int nChance)
-{
+void CNode::Fuzz(int nChance) {
     if (!fSuccessfullyConnected) return; // Don't fuzz initial handshake
     if (GetRand(nChance) != 0) return; // Fuzz 1 of every nChance messages
 
-    switch (GetRand(3))
-    {
-    case 0:
-        // xor a random byte with a random value:
-        if (!ssSend.empty()) {
-            CDataStream::size_type pos = GetRand(ssSend.size());
-            ssSend[pos] ^= (unsigned char)(GetRand(256));
-        }
-        break;
-    case 1:
-        // delete a random byte:
-        if (!ssSend.empty()) {
-            CDataStream::size_type pos = GetRand(ssSend.size());
-            ssSend.erase(ssSend.begin()+pos);
-        }
-        break;
-    case 2:
-        // insert a random byte at a random position
+    switch (GetRand(3)) {
+        case 0:
+            // xor a random byte with a random value:
+            if (!ssSend.empty()) {
+                CDataStream::size_type pos = GetRand(ssSend.size());
+                ssSend[pos] ^= (unsigned char) (GetRand(256));
+            }
+            break;
+        case 1:
+            // delete a random byte:
+            if (!ssSend.empty()) {
+                CDataStream::size_type pos = GetRand(ssSend.size());
+                ssSend.erase(ssSend.begin() + pos);
+            }
+            break;
+        case 2:
+            // insert a random byte at a random position
         {
             CDataStream::size_type pos = GetRand(ssSend.size());
-            char ch = (char)GetRand(256);
-            ssSend.insert(ssSend.begin()+pos, ch);
+            char ch = (char) GetRand(256);
+            ssSend.insert(ssSend.begin() + pos, ch);
         }
-        break;
+            break;
     }
     // Chance of more than one change half the time:
     // (more changes exponentially less likely):
@@ -2351,16 +2241,14 @@ void CNode::Fuzz(int nChance)
 // CAddrDB
 //
 
-CAddrDB::CAddrDB()
-{
+CAddrDB::CAddrDB() {
     pathAddr = GetDataDir() / "peers.dat";
 }
 
-bool CAddrDB::Write(const CAddrMan& addr)
-{
+bool CAddrDB::Write(const CAddrMan &addr) {
     // Generate random temporary filename
     unsigned short randv = 0;
-    GetRandBytes((unsigned char*)&randv, sizeof(randv));
+    GetRandBytes((unsigned char *) &randv, sizeof(randv));
     std::string tmpfn = strprintf("peers.dat.%04x", randv);
 
     // serialize addresses, checksum data up to that point, then append csum
@@ -2381,7 +2269,7 @@ bool CAddrDB::Write(const CAddrMan& addr)
     try {
         fileout << ssPeers;
     }
-    catch (const std::exception& e) {
+    catch (const std::exception &e) {
         return error("%s: Serialize or I/O error - %s", __func__, e.what());
     }
     FileCommit(fileout.Get());
@@ -2394,8 +2282,7 @@ bool CAddrDB::Write(const CAddrMan& addr)
     return true;
 }
 
-bool CAddrDB::Read(CAddrMan& addr)
-{
+bool CAddrDB::Read(CAddrMan &addr) {
     // open input file, and associate with CAutoFile
     FILE *file = fopen(pathAddr.string().c_str(), "rb");
     CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
@@ -2414,10 +2301,10 @@ bool CAddrDB::Read(CAddrMan& addr)
 
     // read data and checksum from file
     try {
-        filein.read((char *)&vchData[0], dataSize);
+        filein.read((char *) &vchData[0], dataSize);
         filein >> hashIn;
     }
-    catch (const std::exception& e) {
+    catch (const std::exception &e) {
         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
     }
     filein.fclose();
@@ -2432,8 +2319,7 @@ bool CAddrDB::Read(CAddrMan& addr)
     return Read(addr, ssPeers);
 }
 
-bool CAddrDB::Read(CAddrMan& addr, CDataStream& ssPeers)
-{
+bool CAddrDB::Read(CAddrMan &addr, CDataStream &ssPeers) {
     unsigned char pchMsgTmp[4];
     try {
         // de-serialize file header (network specific magic number) and ..
@@ -2446,7 +2332,7 @@ bool CAddrDB::Read(CAddrMan& addr, CDataStream& ssPeers)
         // de-serialize address data into one CAddrMan object
         ssPeers >> addr;
     }
-    catch (const std::exception& e) {
+    catch (const std::exception &e) {
         // de-serialization has failed, ensure addrman is left in a clean state
         addr.Clear();
         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
@@ -2455,16 +2341,16 @@ bool CAddrDB::Read(CAddrMan& addr, CDataStream& ssPeers)
     return true;
 }
 
-unsigned int ReceiveFloodSize() { return 1000*GetArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER); }
-unsigned int SendBufferSize() { return 1000*GetArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER); }
+unsigned int ReceiveFloodSize() { return 1000 * GetArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER); }
 
-CNode::CNode(SOCKET hSocketIn, const CAddress& addrIn, const std::string& addrNameIn, bool fInboundIn) :
-    ssSend(SER_NETWORK, INIT_PROTO_VERSION),
-    addr(addrIn),
-    nKeyedNetGroup(CalculateKeyedNetGroup(addrIn)),
-    addrKnown(5000, 0.001),
-    filterInventoryKnown(50000, 0.000001)
-{
+unsigned int SendBufferSize() { return 1000 * GetArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER); }
+
+CNode::CNode(SOCKET hSocketIn, const CAddress &addrIn, const std::string &addrNameIn, bool fInboundIn) :
+        ssSend(SER_NETWORK, INIT_PROTO_VERSION),
+        addr(addrIn),
+        nKeyedNetGroup(CalculateKeyedNetGroup(addrIn)),
+        addrKnown(5000, 0.001),
+        filterInventoryKnown(50000, 0.000001) {
     nServices = NODE_NONE;
     nServicesExpected = NODE_NONE;
     hSocket = hSocketIn;
@@ -2511,9 +2397,12 @@ CNode::CNode(SOCKET hSocketIn, const CAddress& addrIn, const std::string& addrNa
     minFeeFilter = 0;
     lastSentFeeFilter = 0;
     nextSendTimeFeeFilter = 0;
+    // znode
+    fZnode = false;
 
-    BOOST_FOREACH(const std::string &msg, getAllNetMessageTypes())
-        mapRecvBytesPerMsgCmd[msg] = 0;
+    BOOST_FOREACH(
+    const std::string &msg, getAllNetMessageTypes())
+    mapRecvBytesPerMsgCmd[msg] = 0;
     mapRecvBytesPerMsgCmd[NET_MESSAGE_COMMAND_OTHER] = 0;
 
     {
@@ -2533,8 +2422,7 @@ CNode::CNode(SOCKET hSocketIn, const CAddress& addrIn, const std::string& addrNa
     GetNodeSignals().InitializeNode(GetId(), this);
 }
 
-CNode::~CNode()
-{
+CNode::~CNode() {
     CloseSocket(hSocket);
 
     if (pfilter)
@@ -2543,8 +2431,7 @@ CNode::~CNode()
     GetNodeSignals().FinalizeNode(GetId());
 }
 
-void CNode::AskFor(const CInv& inv)
-{
+void CNode::AskFor(const CInv &inv) {
     if (mapAskFor.size() > MAPASKFOR_MAX_SZ || setAskFor.size() > SETASKFOR_MAX_SZ)
         return;
     // a peer may not have multiple non-responded queue positions for a single inv item
@@ -2559,7 +2446,8 @@ void CNode::AskFor(const CInv& inv)
         nRequestTime = it->second;
     else
         nRequestTime = 0;
-    LogPrint("net", "askfor %s  %d (%s) peer=%d\n", inv.ToString(), nRequestTime, DateTimeStrFormat("%H:%M:%S", nRequestTime/1000000), id);
+    LogPrint("net", "askfor %s  %d (%s) peer=%d\n", inv.ToString(), nRequestTime,
+             DateTimeStrFormat("%H:%M:%S", nRequestTime / 1000000), id);
 
     // Make sure not to reuse time indexes to keep things in the same order
     int64_t nNow = GetTimeMicros() - 1000000;
@@ -2577,16 +2465,14 @@ void CNode::AskFor(const CInv& inv)
     mapAskFor.insert(std::make_pair(nRequestTime, inv));
 }
 
-void CNode::BeginMessage(const char* pszCommand) EXCLUSIVE_LOCK_FUNCTION(cs_vSend)
-{
+void CNode::BeginMessage(const char *pszCommand) EXCLUSIVE_LOCK_FUNCTION(cs_vSend) {
     ENTER_CRITICAL_SECTION(cs_vSend);
     assert(ssSend.size() == 0);
     ssSend << CMessageHeader(Params().MessageStart(), pszCommand, 0);
     LogPrint("net", "sending: %s ", SanitizeString(pszCommand));
 }
 
-void CNode::AbortMessage() UNLOCK_FUNCTION(cs_vSend)
-{
+void CNode::AbortMessage() UNLOCK_FUNCTION(cs_vSend) {
     ssSend.clear();
 
     LEAVE_CRITICAL_SECTION(cs_vSend);
@@ -2594,13 +2480,11 @@ void CNode::AbortMessage() UNLOCK_FUNCTION(cs_vSend)
     LogPrint("net", "(aborted)\n");
 }
 
-void CNode::EndMessage(const char* pszCommand) UNLOCK_FUNCTION(cs_vSend)
-{
+void CNode::EndMessage(const char *pszCommand) UNLOCK_FUNCTION(cs_vSend) {
     // The -*messagestest options are intentionally not documented in the help message,
     // since they are only used during development to debug the networking code and are
     // not intended for end-users.
-    if (mapArgs.count("-dropmessagestest") && GetRand(GetArg("-dropmessagestest", 2)) == 0)
-    {
+    if (mapArgs.count("-dropmessagestest") && GetRand(GetArg("-dropmessagestest", 2)) == 0) {
         LogPrint("net", "dropmessages DROPPING SEND MESSAGE\n");
         AbortMessage();
         return;
@@ -2608,14 +2492,13 @@ void CNode::EndMessage(const char* pszCommand) UNLOCK_FUNCTION(cs_vSend)
     if (mapArgs.count("-fuzzmessagestest"))
         Fuzz(GetArg("-fuzzmessagestest", 10));
 
-    if (ssSend.size() == 0)
-    {
+    if (ssSend.size() == 0) {
         LEAVE_CRITICAL_SECTION(cs_vSend);
         return;
     }
     // Set the size
     unsigned int nSize = ssSend.size() - CMessageHeader::HEADER_SIZE;
-    WriteLE32((uint8_t*)&ssSend[CMessageHeader::MESSAGE_SIZE_OFFSET], nSize);
+    WriteLE32((uint8_t * ) & ssSend[CMessageHeader::MESSAGE_SIZE_OFFSET], nSize);
 
     //log total amount of bytes per command
     mapSendBytesPerMsgCmd[std::string(pszCommand)] += nSize + CMessageHeader::HEADER_SIZE;
@@ -2624,8 +2507,8 @@ void CNode::EndMessage(const char* pszCommand) UNLOCK_FUNCTION(cs_vSend)
     uint256 hash = Hash(ssSend.begin() + CMessageHeader::HEADER_SIZE, ssSend.end());
     unsigned int nChecksum = 0;
     memcpy(&nChecksum, &hash, sizeof(nChecksum));
-    assert(ssSend.size () >= CMessageHeader::CHECKSUM_OFFSET + sizeof(nChecksum));
-    memcpy((char*)&ssSend[CMessageHeader::CHECKSUM_OFFSET], &nChecksum, sizeof(nChecksum));
+    assert(ssSend.size() >= CMessageHeader::CHECKSUM_OFFSET + sizeof(nChecksum));
+    memcpy((char *) &ssSend[CMessageHeader::CHECKSUM_OFFSET], &nChecksum, sizeof(nChecksum));
 
     LogPrint("net", "(%d bytes) peer=%d\n", nSize, id);
 
@@ -2644,16 +2527,14 @@ void CNode::EndMessage(const char* pszCommand) UNLOCK_FUNCTION(cs_vSend)
 // CBanDB
 //
 
-CBanDB::CBanDB()
-{
+CBanDB::CBanDB() {
     pathBanlist = GetDataDir() / "banlist.dat";
 }
 
-bool CBanDB::Write(const banmap_t& banSet)
-{
+bool CBanDB::Write(const banmap_t &banSet) {
     // Generate random temporary filename
     unsigned short randv = 0;
-    GetRandBytes((unsigned char*)&randv, sizeof(randv));
+    GetRandBytes((unsigned char *) &randv, sizeof(randv));
     std::string tmpfn = strprintf("banlist.dat.%04x", randv);
 
     // serialize banlist, checksum data up to that point, then append csum
@@ -2674,7 +2555,7 @@ bool CBanDB::Write(const banmap_t& banSet)
     try {
         fileout << ssBanlist;
     }
-    catch (const std::exception& e) {
+    catch (const std::exception &e) {
         return error("%s: Serialize or I/O error - %s", __func__, e.what());
     }
     FileCommit(fileout.Get());
@@ -2687,8 +2568,7 @@ bool CBanDB::Write(const banmap_t& banSet)
     return true;
 }
 
-bool CBanDB::Read(banmap_t& banSet)
-{
+bool CBanDB::Read(banmap_t &banSet) {
     // open input file, and associate with CAutoFile
     FILE *file = fopen(pathBanlist.string().c_str(), "rb");
     CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
@@ -2707,10 +2587,10 @@ bool CBanDB::Read(banmap_t& banSet)
 
     // read data and checksum from file
     try {
-        filein.read((char *)&vchData[0], dataSize);
+        filein.read((char *) &vchData[0], dataSize);
         filein >> hashIn;
     }
-    catch (const std::exception& e) {
+    catch (const std::exception &e) {
         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
     }
     filein.fclose();
@@ -2734,7 +2614,7 @@ bool CBanDB::Read(banmap_t& banSet)
         // de-serialize address data into one CAddrMan object
         ssBanlist >> banSet;
     }
-    catch (const std::exception& e) {
+    catch (const std::exception &e) {
         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
     }
 
@@ -2742,11 +2622,12 @@ bool CBanDB::Read(banmap_t& banSet)
 }
 
 int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds) {
-    return nNow + (int64_t)(log1p(GetRand(1ULL << 48) * -0.0000000000000035527136788 /* -1/2^48 */) * average_interval_seconds * -1000000.0 + 0.5);
+    return nNow + (int64_t)(
+            log1p(GetRand(1ULL << 48) * -0.0000000000000035527136788 /* -1/2^48 */) * average_interval_seconds *
+            -1000000.0 + 0.5);
 }
 
-/* static */ uint64_t CNode::CalculateKeyedNetGroup(const CAddress& ad)
-{
+/* static */ uint64_t CNode::CalculateKeyedNetGroup(const CAddress &ad) {
     static const uint64_t k0 = GetRand(std::numeric_limits<uint64_t>::max());
     static const uint64_t k1 = GetRand(std::numeric_limits<uint64_t>::max());
 
@@ -2754,3 +2635,21 @@ int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds) {
 
     return CSipHasher(k0, k1).Write(&vchNetGroup[0], vchNetGroup.size()).Finalize();
 }
+
+std::vector<CNode *> CopyNodeVector() {
+    std::vector < CNode * > vecNodesCopy;
+    LOCK(cs_vNodes);
+    for (size_t i = 0; i < vNodes.size(); ++i) {
+        CNode *pnode = vNodes[i];
+        pnode->AddRef();
+        vecNodesCopy.push_back(pnode);
+    }
+    return vecNodesCopy;
+}
+
+void ReleaseNodeVector(const std::vector<CNode *> &vecNodes) {
+    for (size_t i = 0; i < vecNodes.size(); ++i) {
+        CNode *pnode = vecNodes[i];
+        pnode->Release();
+    }
+}
\ No newline at end of file
diff --git a/src/net.h b/src/net.h
index 63bb2c2ecf..f81b605302 100644
--- a/src/net.h
+++ b/src/net.h
@@ -91,6 +91,9 @@ CNode* FindNode(const CSubNet& subNet);
 CNode* FindNode(const std::string& addrName);
 CNode* FindNode(const CService& ip);
 CNode* FindNode(const NodeId id); //TODO: Remove this
+
+CNode* ConnectNode(CAddress addrConnect, const char *pszDest = NULL, bool fCountFailure = false, bool fConnectToZnode = false);
+
 bool OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false, bool fFeeler = false);
 void MapPort(bool fUseUPnP);
 unsigned short GetListenPort();
@@ -370,6 +373,8 @@ class CNode
     CBloomFilter* pfilter;
     int nRefCount;
     NodeId id;
+    // znode from dash
+    bool fZnode;
 
     const uint64_t nKeyedNetGroup;
 protected:
@@ -405,6 +410,7 @@ class CNode
 
     // inventory based relay
     CRollingBloomFilter filterInventoryKnown;
+    std::vector<CInv> vInventoryToSend;
     // Set of transaction ids we still have to announce.
     // They are sorted by the mempool before relay, so the order is not important.
     std::set<uint256> setInventoryTxToSend;
@@ -447,6 +453,7 @@ class CNode
     int64_t nextSendTimeFeeFilter;
 
     CNode(SOCKET hSocketIn, const CAddress &addrIn, const std::string &addrNameIn = "", bool fInboundIn = false);
+//    CNode(SOCKET hSocketIn, const CAddress &addrIn, const std::string &addrNameIn = "", bool fInboundIn = false, bool fNetworkNodeIn = false);
     ~CNode();
 
 private:
@@ -549,6 +556,8 @@ class CNode
             }
         } else if (inv.type == MSG_BLOCK) {
             vInventoryBlockToSend.push_back(inv.hash);
+        } else {
+            vInventoryToSend.push_back(inv);
         }
     }
 
@@ -818,6 +827,7 @@ class CNode
 
 class CTransaction;
 void RelayTransaction(const CTransaction& tx);
+void RelayInv(CInv &inv, const int minProtoVersion = MIN_PEER_PROTO_VERSION);
 
 /** Access to the (IP) address database (peers.dat) */
 class CAddrDB
@@ -853,6 +863,9 @@ struct AddedNodeInfo
     bool fInbound;
 };
 
+std::vector<CNode*> CopyNodeVector();
+void ReleaseNodeVector(const std::vector<CNode*>& vecNodes);
+
 std::vector<AddedNodeInfo> GetAddedNodeInfo();
 
 #endif // BITCOIN_NET_H
diff --git a/src/netfulfilledman.cpp b/src/netfulfilledman.cpp
new file mode 100644
index 0000000000..e512d2938b
--- /dev/null
+++ b/src/netfulfilledman.cpp
@@ -0,0 +1,72 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "chainparams.h"
+#include "netfulfilledman.h"
+#include "util.h"
+
+CNetFulfilledRequestManager netfulfilledman;
+
+void CNetFulfilledRequestManager::AddFulfilledRequest(CAddress addr, std::string strRequest)
+{
+    LOCK(cs_mapFulfilledRequests);
+    mapFulfilledRequests[addr][strRequest] = GetTime() + Params().FulfilledRequestExpireTime();
+}
+
+bool CNetFulfilledRequestManager::HasFulfilledRequest(CAddress addr, std::string strRequest)
+{
+    LOCK(cs_mapFulfilledRequests);
+    fulfilledreqmap_t::iterator it = mapFulfilledRequests.find(addr);
+
+    return  it != mapFulfilledRequests.end() &&
+            it->second.find(strRequest) != it->second.end() &&
+            it->second[strRequest] > GetTime();
+}
+
+void CNetFulfilledRequestManager::RemoveFulfilledRequest(CAddress addr, std::string strRequest)
+{
+    LOCK(cs_mapFulfilledRequests);
+    fulfilledreqmap_t::iterator it = mapFulfilledRequests.find(addr);
+
+    if (it != mapFulfilledRequests.end()) {
+        it->second.erase(strRequest);
+    }
+}
+
+void CNetFulfilledRequestManager::CheckAndRemove()
+{
+    LOCK(cs_mapFulfilledRequests);
+
+    int64_t now = GetTime();
+    fulfilledreqmap_t::iterator it = mapFulfilledRequests.begin();
+
+    while(it != mapFulfilledRequests.end()) {
+        fulfilledreqmapentry_t::iterator it_entry = it->second.begin();
+        while(it_entry != it->second.end()) {
+            if(now > it_entry->second) {
+                it->second.erase(it_entry++);
+            } else {
+                ++it_entry;
+            }
+        }
+        if(it->second.size() == 0) {
+            mapFulfilledRequests.erase(it++);
+        } else {
+            ++it;
+        }
+    }
+}
+
+void CNetFulfilledRequestManager::Clear()
+{
+    LOCK(cs_mapFulfilledRequests);
+    mapFulfilledRequests.clear();
+}
+
+std::string CNetFulfilledRequestManager::ToString() const
+{
+    std::ostringstream info;
+    info << "Nodes with fulfilled requests: " << (int)mapFulfilledRequests.size();
+    return info.str();
+}
diff --git a/src/netfulfilledman.h b/src/netfulfilledman.h
new file mode 100644
index 0000000000..d447261964
--- /dev/null
+++ b/src/netfulfilledman.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef NETFULFILLEDMAN_H
+#define NETFULFILLEDMAN_H
+
+#include "netbase.h"
+#include "protocol.h"
+#include "serialize.h"
+#include "sync.h"
+
+// Fulfilled requests are used to prevent nodes from asking for the same data on sync
+// and from being banned for doing so too often.
+class CNetFulfilledRequestManager;
+extern CNetFulfilledRequestManager netfulfilledman;
+
+class CNetFulfilledRequestManager
+{
+private:
+    typedef std::map<std::string, int64_t> fulfilledreqmapentry_t;
+    typedef std::map<CNetAddr, fulfilledreqmapentry_t> fulfilledreqmap_t;
+
+    //keep track of what node has/was asked for and when
+    fulfilledreqmap_t mapFulfilledRequests;
+    CCriticalSection cs_mapFulfilledRequests;
+
+public:
+    CNetFulfilledRequestManager() {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        LOCK(cs_mapFulfilledRequests);
+        READWRITE(mapFulfilledRequests);
+    }
+
+    void AddFulfilledRequest(CAddress addr, std::string strRequest); // expire after 1 hour by default
+    bool HasFulfilledRequest(CAddress addr, std::string strRequest);
+    void RemoveFulfilledRequest(CAddress addr, std::string strRequest);
+
+    void CheckAndRemove();
+    void Clear();
+
+    std::string ToString() const;
+};
+
+#endif
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index ccc2d9e395..3178252b0c 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -84,7 +84,6 @@ bool IsStandardTx(const CTransaction& tx, std::string& reason, const bool witnes
         // future-proofing. That's also enough to spend a 20-of-20
         // CHECKMULTISIG scriptPubKey, though such a scriptPubKey is not
         // considered standard.
-        //btzc
         if (txin.scriptSig.size() > 500 && !txin.scriptSig.IsZerocoinSpend()) {
             reason = "scriptsig-size";
             return false;
diff --git a/src/pow.cpp b/src/pow.cpp
index f259019b5c..7f83b29109 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -8,6 +8,7 @@
 #include "arith_uint256.h"
 #include "chain.h"
 #include "primitives/block.h"
+#include "consensus/consensus.h"
 #include "uint256.h"
 #include <iostream>
 #include "util.h"
@@ -33,10 +34,12 @@ double GetDifficultyHelper(unsigned int nBits) {
     return dDiff;
 }
 
-//btzc, zcoin GetNextWorkRequired
+// zcoin GetNextWorkRequired
 unsigned int GetNextWorkRequired(const CBlockIndex *pindexLast, const CBlockHeader *pblock, const Consensus::Params &params) {
+    bool fTestNet = Params().NetworkIDString() == CBaseChainParams::TESTNET;
 
-	if(ENABLED_LOWEST_DIFF){
+    // allow instamine first x blocks on testnet for distribution testing
+	if(fTestNet && pindexLast->nHeight < 5000){
 		return bnProofOfWorkLimit.GetCompact();
 	}
 
@@ -50,27 +53,27 @@ unsigned int GetNextWorkRequired(const CBlockIndex *pindexLast, const CBlockHead
     int64_t PastSecondsMax = TimeDaySeconds * 7;// 604800
     uint32_t PastBlocksMin = PastSecondsMin / BlocksTargetSpacing; // 36 blocks
     uint32_t PastBlocksMax = PastSecondsMax / BlocksTargetSpacing; // 1008 blocks
-    bool fTestNet = Params().NetworkIDString() == CBaseChainParams::TESTNET;
+
     if (fTestNet) {
         // If the new block's timestamp is more than nTargetSpacing*6
         // then allow mining of a min-difficulty block
-        if (pblock->nTime > pindexLast->nTime + params.nPowTargetTimespan * 6) {
+        if (pblock->nTime > pindexLast->nTime + params.nPowTargetTimespan * 1) {
             return bnProofOfWorkLimit.GetCompact();
         }
     }
 
     // 9/29/2016 - Reset to Lyra2(2,block_height,256) due to ASIC KnC Miner Scrypt
     // 36 block look back, reset to mininmum diff
-    if (!fTestNet && pindexLast->nHeight + 1 >= 500 && pindexLast->nHeight + 1 <= 535) {
+    if (!fTestNet && pindexLast->nHeight + 1 >= HF_LYRA2VAR_HEIGHT && pindexLast->nHeight + 1 <= HF_LYRA2VAR_HEIGHT + 36 - 1) {
         return bnProofOfWorkLimit.GetCompact();
     }
     // reset to minimum diff at testnet after scrypt_n, 6 block look back
-    if (fTestNet && pindexLast->nHeight + 1 >= 80 && pindexLast->nHeight + 1 <= 85) {
+    if (fTestNet && pindexLast->nHeight + 1 >= HF_LYRA2VAR_HEIGHT_TESTNET && pindexLast->nHeight + 1 <= HF_LYRA2VAR_HEIGHT_TESTNET + 6 - 1) {
         return bnProofOfWorkLimit.GetCompact();
     }
 
     // 02/11/2017 - Increase diff to match with new hashrates of Lyra2Z algo
-    if ((!fTestNet && pindexLast->nHeight + 1 == 20500) || (fTestNet && pindexLast->nHeight + 1 == 90)) {
+    if ((!fTestNet && pindexLast->nHeight + 1 == HF_LYRA2Z_HEIGHT) || (fTestNet && pindexLast->nHeight + 1 == HF_LYRA2Z_HEIGHT_TESTNET)) {
         CBigNum bnNew;
         bnNew.SetCompact(pindexLast->nBits);
         bnNew /= 20000; // increase the diff by 20000x since the new hashrate is approx. 20000 times higher
@@ -88,42 +91,6 @@ unsigned int GetNextWorkRequired(const CBlockIndex *pindexLast, const CBlockHead
     return BorisRidiculouslyNamedDifficultyFunction(pindexLast, BlocksTargetSpacing, PastBlocksMin, PastBlocksMax);
 }
 
-unsigned int GetNextWorkRequired_Bitcoin(const CBlockIndex *pindexLast, const CBlockHeader *pblock,
-                                         const Consensus::Params &params) {
-    unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
-
-    // Genesis block
-    if (pindexLast == NULL)
-        return nProofOfWorkLimit;
-    // Only change once per difficulty adjustment 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* 10 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;
-            }
-        }
-        return pindexLast->nBits;
-    }
-
-    // Go back by what we want to be 14 days worth of blocks
-    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval() - 1);
-    assert(nHeightFirst >= 0);
-    const CBlockIndex *pindexFirst = pindexLast->GetAncestor(nHeightFirst);
-    assert(pindexFirst);
-
-    return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
-}
-
 unsigned int CalculateNextWorkRequired(const CBlockIndex *pindexLast, int64_t nFirstBlockTime, const Consensus::Params &params) {
     if (params.fPowNoRetargeting)
         return pindexLast->nBits;
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index aa0b152a2d..2579d76a7e 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -4,7 +4,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include "primitives/block.h"
-
+#include "consensus/consensus.h"
 #include "main.h"
 #include "hash.h"
 #include "tinyformat.h"
@@ -23,6 +23,7 @@
 #include "precomputed_hash.h"
 
 
+
 unsigned char GetNfactor(int64_t nTimestamp) {
     int l = 0;
     if (nTimestamp <= Params().GetConsensus().nChainStartTime)
@@ -66,16 +67,18 @@ uint256 CBlockHeader::GetPoWHash(int nHeight) const {
     }
     uint256 powHash;
     try {
-        if (!fTestNet && nHeight >= LYRA2Z_HEIGHT) {
+        if (!fTestNet && nHeight >= HF_LYRA2Z_HEIGHT) {
             lyra2z_hash(BEGIN(nVersion), BEGIN(powHash));
-        } else if (!fTestNet && nHeight >= 8192) {
+        } else if (!fTestNet && nHeight >= HF_LYRA2_HEIGHT) {
             LYRA2(BEGIN(powHash), 32, BEGIN(nVersion), 80, BEGIN(nVersion), 80, 2, 8192, 256);
-        } else if (!fTestNet && nHeight >= 500) {
+        } else if (!fTestNet && nHeight >= HF_LYRA2VAR_HEIGHT) {
             LYRA2(BEGIN(powHash), 32, BEGIN(nVersion), 80, BEGIN(nVersion), 80, 2, nHeight, 256);
-        } else if (fTestNet && nHeight >= 90) { // testnet
+        } else if (fTestNet && nHeight >= HF_LYRA2Z_HEIGHT_TESTNET) { // testnet
             lyra2z_hash(BEGIN(nVersion), BEGIN(powHash));
-        } else if (fTestNet && nHeight >= 80) { // testnet
+        } else if (fTestNet && nHeight >= HF_LYRA2_HEIGHT_TESTNET) { // testnet
             LYRA2(BEGIN(powHash), 32, BEGIN(nVersion), 80, BEGIN(nVersion), 80, 2, 8192, 256);
+        } else if (fTestNet && nHeight >= HF_LYRA2VAR_HEIGHT_TESTNET) { // testnet
+            LYRA2(BEGIN(powHash), 32, BEGIN(nVersion), 80, BEGIN(nVersion), 80, 2, nHeight, 256);
         } else {
             scrypt_N_1_1_256(BEGIN(nVersion), BEGIN(powHash), GetNfactor(nTime));
         }
diff --git a/src/primitives/block.h b/src/primitives/block.h
index d5aba0e761..be7c5dc757 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -40,8 +40,7 @@ class CBlockHeader
 
     static const int CURRENT_VERSION = 2;
 
-    //btzc
-//    uint32_t lastHeight;
+    // uint32_t lastHeight;
     uint256 powHash;
     int32_t isComputed;
 
@@ -113,6 +112,8 @@ class CBlock : public CBlockHeader
     std::vector<CTransaction> vtx;
 
     // memory only
+    mutable CTxOut txoutZnode; // znode payment
+    mutable std::vector<CTxOut> voutSuperblock; // superblock payment
     mutable bool fChecked;
 
     CBlock()
@@ -138,6 +139,8 @@ class CBlock : public CBlockHeader
     {
         CBlockHeader::SetNull();
         vtx.clear();
+        txoutZnode = CTxOut();
+        voutSuperblock.clear();
         fChecked = false;
     }
 
diff --git a/src/primitives/precomputed_hash.h b/src/primitives/precomputed_hash.h
index b0a29ebdcc..cdbb34b140 100644
--- a/src/primitives/precomputed_hash.h
+++ b/src/primitives/precomputed_hash.h
@@ -6,7 +6,7 @@
 
 static map<int, uint256> mapPoWHash;
 
-std::string precomputedHash[20501] = {
+const char *precomputedHash[20501] = {
         "",
         "00000da58fce09f363bf5bb42409fbc2aabfc8b58c2211b24a3d7e2a7deedc90", "000009614e788eaeb5a3647d4313f37c8be994c678f10b7462476c1605c4c8df", "000008404d2723be9fb2eb0d4d1d1541ca1e823909faf572fa1d11097fc0123a", "000007c74d283118c293bfee54c5085573ab887549ed09a8d8d8664269c79685",
         "000002aed9eee0aab7be474c08e953b359e917d1fde806961bb9009639943555", "00000d51f1c82b16db53a09eb7dfe53e8d744a968e19cb976a262150d456bb12", "00000a9d826969c5a16b369a63d270f9bffd11e179ea021bcc12a1300d0e016c", "000006426aaead3840b90fc095c15b42026a301e717404331294f484d50a5a08",
diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp
index 63087517ef..981e3af6d7 100644
--- a/src/primitives/transaction.cpp
+++ b/src/primitives/transaction.cpp
@@ -28,6 +28,11 @@ std::string COutPoint::ToString() const
     return strprintf("COutPoint(%s, %u)", hash.ToString(), n);
 }
 
+std::string COutPoint::ToStringShort() const
+{
+    return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,64), n);
+}
+
 CTxIn::CTxIn(COutPoint prevoutIn, CScript scriptSigIn, uint32_t nSequenceIn)
 {
     prevout = prevoutIn;
@@ -81,6 +86,22 @@ uint256 CMutableTransaction::GetHash() const
     return SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
 }
 
+std::string CMutableTransaction::ToString() const
+{
+    std::string str;
+    str += strprintf("CMutableTransaction(hash=%s, ver=%d, vin.size=%u, vout.size=%u, nLockTime=%u)\n",
+                     GetHash().ToString().substr(0,10),
+                     nVersion,
+                     vin.size(),
+                     vout.size(),
+                     nLockTime);
+    for (unsigned int i = 0; i < vin.size(); i++)
+        str += "    " + vin[i].ToString() + "\n";
+    for (unsigned int i = 0; i < vout.size(); i++)
+        str += "    " + vout[i].ToString() + "\n";
+    return str;
+}
+
 void CTransaction::UpdateHash() const
 {
     *const_cast<uint256*>(&hash) = SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
@@ -172,7 +193,6 @@ double CTransaction::ComputePriority(double dPriorityInputs, unsigned int nTxSiz
     return dPriorityInputs / nTxSize;
 }
 
-//btzc: add zerocoin to coinbase
 bool CTransaction::IsCoinBase() const
 {
     return (vin.size() == 1 && vin[0].prevout.IsNull() && (vin[0].scriptSig[0] != OP_ZEROCOINSPEND) );
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index b558d45110..1473ba1d8a 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -52,6 +52,7 @@ class COutPoint
     }
 
     std::string ToString() const;
+    std::string ToStringShort() const;
 };
 
 /** An input of a transaction.  It contains the location of the previous
@@ -64,6 +65,7 @@ class CTxIn
     COutPoint prevout;
     CScript scriptSig;
     uint32_t nSequence;
+    CScript prevPubKey;
 
     /* Setting nSequence to this value for every input in a transaction
      * disables nLockTime. */
@@ -121,6 +123,11 @@ class CTxIn
         return !(a == b);
     }
 
+    friend bool operator<(const CTxIn& a, const CTxIn& b)
+    {
+        return a.prevout<b.prevout;
+    }
+
     std::string ToString() const;
 };
 
@@ -132,6 +139,7 @@ class CTxOut
 public:
     CAmount nValue;
     CScript scriptPubKey;
+    int nRounds;
 
     CTxOut()
     {
@@ -152,6 +160,7 @@ class CTxOut
     {
         nValue = -1;
         scriptPubKey.clear();
+        nRounds = -10; // an initial value, should be no way to get this by calculations
     }
 
     bool IsNull() const
@@ -195,7 +204,6 @@ class CTxOut
 
     bool IsDust() const
     {
-        //btzc: zcoin disable dust
         return false;
     }
 
@@ -209,7 +217,8 @@ class CTxOut
     friend bool operator==(const CTxOut& a, const CTxOut& b)
     {
         return (a.nValue       == b.nValue &&
-                a.scriptPubKey == b.scriptPubKey);
+                a.scriptPubKey == b.scriptPubKey &&
+                a.nRounds      == b.nRounds);
     }
 
     friend bool operator!=(const CTxOut& a, const CTxOut& b)
@@ -217,6 +226,11 @@ class CTxOut
         return !(a == b);
     }
 
+    friend bool operator<(const CTxOut& a, const CTxOut& b)
+    {
+        return a.nValue < b.nValue || (a.nValue == b.nValue && a.scriptPubKey < b.scriptPubKey);
+    }
+
     std::string ToString() const;
 };
 
@@ -385,7 +399,6 @@ class CTransaction
     const int32_t nVersion;
     static int64_t nMinTxFee;
     static int64_t nMinRelayTxFee;
-    //btzc: remove const
     std::vector<CTxIn> vin;
     std::vector<CTxOut> vout;
     CTxWitness wit; // Not const: can change without invalidating the txid cache
@@ -435,7 +448,6 @@ class CTransaction
     // Compute modified tx size for priority calculation (optionally given tx size)
     unsigned int CalculateModifiedSize(unsigned int nTxSize=0) const;
 
-    //btzc: add zerocoin to coinbase
     bool IsCoinBase() const;
 
     bool IsZerocoinSpend() const;
@@ -481,6 +493,17 @@ struct CMutableTransaction
      * fly, as opposed to GetHash() in CTransaction, which uses a cached result.
      */
     uint256 GetHash() const;
+
+    std::string ToString() const;
+    friend bool operator==(const CMutableTransaction& a, const CMutableTransaction& b)
+    {
+        return a.GetHash() == b.GetHash();
+    }
+
+    friend bool operator!=(const CMutableTransaction& a, const CMutableTransaction& b)
+    {
+        return !(a == b);
+    }
 };
 
 /** Compute the weight of a transaction, as defined by BIP 141 */
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 247c6c2120..c083a135d3 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -9,81 +9,124 @@
 #include "utilstrencodings.h"
 
 #ifndef WIN32
+
 # include <arpa/inet.h>
+
 #endif
 
 namespace NetMsgType {
-const char *VERSION="version";
-const char *VERACK="verack";
-const char *ADDR="addr";
-const char *INV="inv";
-const char *GETDATA="getdata";
-const char *MERKLEBLOCK="merkleblock";
-const char *GETBLOCKS="getblocks";
-const char *GETHEADERS="getheaders";
-const char *TX="tx";
-const char *HEADERS="headers";
-const char *BLOCK="block";
-const char *GETADDR="getaddr";
-const char *MEMPOOL="mempool";
-const char *PING="ping";
-const char *PONG="pong";
-const char *NOTFOUND="notfound";
-const char *FILTERLOAD="filterload";
-const char *FILTERADD="filteradd";
-const char *FILTERCLEAR="filterclear";
-const char *REJECT="reject";
-const char *SENDHEADERS="sendheaders";
-const char *FEEFILTER="feefilter";
-const char *SENDCMPCT="sendcmpct";
-const char *CMPCTBLOCK="cmpctblock";
-const char *GETBLOCKTXN="getblocktxn";
-const char *BLOCKTXN="blocktxn";
+    const char *VERSION = "version";
+    const char *VERACK = "verack";
+    const char *ADDR = "addr";
+    const char *INV = "inv";
+    const char *GETDATA = "getdata";
+    const char *MERKLEBLOCK = "merkleblock";
+    const char *GETBLOCKS = "getblocks";
+    const char *GETHEADERS = "getheaders";
+    const char *TX = "tx";
+    const char *HEADERS = "headers";
+    const char *BLOCK = "block";
+    const char *GETADDR = "getaddr";
+    const char *MEMPOOL = "mempool";
+    const char *PING = "ping";
+    const char *PONG = "pong";
+    const char *NOTFOUND = "notfound";
+    const char *FILTERLOAD = "filterload";
+    const char *FILTERADD = "filteradd";
+    const char *FILTERCLEAR = "filterclear";
+    const char *REJECT = "reject";
+    const char *SENDHEADERS = "sendheaders";
+    const char *FEEFILTER = "feefilter";
+    const char *SENDCMPCT = "sendcmpct";
+    const char *CMPCTBLOCK = "cmpctblock";
+    const char *GETBLOCKTXN = "getblocktxn";
+    const char *BLOCKTXN = "blocktxn";
+//znode
+    const char *TXLOCKVOTE="txlvote";
+    const char *SPORK = "spork";
+    const char *GETSPORKS = "getsporks";
+    const char *ZNODEPAYMENTVOTE = "mnw";
+    const char *ZNODEPAYMENTBLOCK = "mnwb";
+    const char *ZNODEPAYMENTSYNC = "mnget";
+    const char *MNANNOUNCE = "mnb";
+    const char *MNPING = "mnp";
+    const char *DSACCEPT = "dsa";
+    const char *DSVIN = "dsi";
+    const char *DSFINALTX = "dsf";
+    const char *DSSIGNFINALTX = "dss";
+    const char *DSCOMPLETE = "dsc";
+    const char *DSSTATUSUPDATE = "dssu";
+    const char *DSTX = "dstx";
+    const char *DSQUEUE = "dsq";
+    const char *DSEG = "dseg";
+    const char *SYNCSTATUSCOUNT = "ssc";
+    const char *MNVERIFY = "mnv";
+    const char *TXLOCKREQUEST = "ix";
+
 };
 
 /** All known message types. Keep this in the same order as the list of
  * messages above and in protocol.h.
  */
 const static std::string allNetMessageTypes[] = {
-    NetMsgType::VERSION,
-    NetMsgType::VERACK,
-    NetMsgType::ADDR,
-    NetMsgType::INV,
-    NetMsgType::GETDATA,
-    NetMsgType::MERKLEBLOCK,
-    NetMsgType::GETBLOCKS,
-    NetMsgType::GETHEADERS,
-    NetMsgType::TX,
-    NetMsgType::HEADERS,
-    NetMsgType::BLOCK,
-    NetMsgType::GETADDR,
-    NetMsgType::MEMPOOL,
-    NetMsgType::PING,
-    NetMsgType::PONG,
-    NetMsgType::NOTFOUND,
-    NetMsgType::FILTERLOAD,
-    NetMsgType::FILTERADD,
-    NetMsgType::FILTERCLEAR,
-    NetMsgType::REJECT,
-    NetMsgType::SENDHEADERS,
-    NetMsgType::FEEFILTER,
-    NetMsgType::SENDCMPCT,
-    NetMsgType::CMPCTBLOCK,
-    NetMsgType::GETBLOCKTXN,
-    NetMsgType::BLOCKTXN,
+        NetMsgType::VERSION,
+        NetMsgType::VERACK,
+        NetMsgType::ADDR,
+        NetMsgType::INV,
+        NetMsgType::GETDATA,
+        NetMsgType::MERKLEBLOCK,
+        NetMsgType::GETBLOCKS,
+        NetMsgType::GETHEADERS,
+        NetMsgType::TX,
+        NetMsgType::HEADERS,
+        NetMsgType::BLOCK,
+        NetMsgType::GETADDR,
+        NetMsgType::MEMPOOL,
+        NetMsgType::PING,
+        NetMsgType::PONG,
+        NetMsgType::NOTFOUND,
+        NetMsgType::FILTERLOAD,
+        NetMsgType::FILTERADD,
+        NetMsgType::FILTERCLEAR,
+        NetMsgType::REJECT,
+        NetMsgType::SENDHEADERS,
+        NetMsgType::FEEFILTER,
+        NetMsgType::SENDCMPCT,
+        NetMsgType::CMPCTBLOCK,
+        NetMsgType::GETBLOCKTXN,
+        NetMsgType::BLOCKTXN,
+        //znode
+        NetMsgType::TXLOCKREQUEST,
+        NetMsgType::ZNODEPAYMENTVOTE,
+        NetMsgType::ZNODEPAYMENTBLOCK,
+        NetMsgType::ZNODEPAYMENTSYNC,
+        NetMsgType::SPORK,
+        NetMsgType::GETSPORKS,
+        NetMsgType::MNANNOUNCE,
+        NetMsgType::MNPING,
+        NetMsgType::DSACCEPT,
+        NetMsgType::DSVIN,
+        NetMsgType::DSFINALTX,
+        NetMsgType::DSSIGNFINALTX,
+        NetMsgType::DSCOMPLETE,
+        NetMsgType::DSSTATUSUPDATE,
+        NetMsgType::DSTX,
+        NetMsgType::DSQUEUE,
+        NetMsgType::DSEG,
+        NetMsgType::SYNCSTATUSCOUNT,
+        NetMsgType::MNVERIFY,
+
 };
-const static std::vector<std::string> allNetMessageTypesVec(allNetMessageTypes, allNetMessageTypes+ARRAYLEN(allNetMessageTypes));
+const static std::vector <std::string> allNetMessageTypesVec(allNetMessageTypes, allNetMessageTypes + ARRAYLEN(allNetMessageTypes));
 
-CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn)
-{
+CMessageHeader::CMessageHeader(const MessageStartChars &pchMessageStartIn) {
     memcpy(pchMessageStart, pchMessageStartIn, MESSAGE_START_SIZE);
     memset(pchCommand, 0, sizeof(pchCommand));
     nMessageSize = -1;
     nChecksum = 0;
 }
 
-CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn, const char* pszCommand, unsigned int nMessageSizeIn)
-{
+CMessageHeader::CMessageHeader(const MessageStartChars &pchMessageStartIn, const char *pszCommand, unsigned int nMessageSizeIn) {
     memcpy(pchMessageStart, pchMessageStartIn, MESSAGE_START_SIZE);
     memset(pchCommand, 0, sizeof(pchCommand));
     strncpy(pchCommand, pszCommand, COMMAND_SIZE);
@@ -91,34 +134,28 @@ CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn, const
     nChecksum = 0;
 }
 
-std::string CMessageHeader::GetCommand() const
-{
+std::string CMessageHeader::GetCommand() const {
     return std::string(pchCommand, pchCommand + strnlen(pchCommand, COMMAND_SIZE));
 }
 
-bool CMessageHeader::IsValid(const MessageStartChars& pchMessageStartIn) const
-{
+bool CMessageHeader::IsValid(const MessageStartChars &pchMessageStartIn) const {
     // Check start string
     if (memcmp(pchMessageStart, pchMessageStartIn, MESSAGE_START_SIZE) != 0)
         return false;
 
     // Check the command string for errors
-    for (const char* p1 = pchCommand; p1 < pchCommand + COMMAND_SIZE; p1++)
-    {
-        if (*p1 == 0)
-        {
+    for (const char *p1 = pchCommand; p1 < pchCommand + COMMAND_SIZE; p1++) {
+        if (*p1 == 0) {
             // Must be all zeros after the first zero
             for (; p1 < pchCommand + COMMAND_SIZE; p1++)
                 if (*p1 != 0)
                     return false;
-        }
-        else if (*p1 < ' ' || *p1 > 0x7E)
+        } else if (*p1 < ' ' || *p1 > 0x7E)
             return false;
     }
 
     // Message size
-    if (nMessageSize > MAX_SIZE)
-    {
+    if (nMessageSize > MAX_SIZE) {
         LogPrintf("CMessageHeader::IsValid(): (%s, %u bytes) nMessageSize > MAX_SIZE\n", GetCommand(), nMessageSize);
         return false;
     }
@@ -127,64 +164,82 @@ bool CMessageHeader::IsValid(const MessageStartChars& pchMessageStartIn) const
 }
 
 
-
-CAddress::CAddress() : CService()
-{
+CAddress::CAddress() : CService() {
     Init();
 }
 
-CAddress::CAddress(CService ipIn, ServiceFlags nServicesIn) : CService(ipIn)
-{
+CAddress::CAddress(CService ipIn, ServiceFlags nServicesIn) : CService(ipIn) {
     Init();
     nServices = nServicesIn;
 }
 
-void CAddress::Init()
-{
+void CAddress::Init() {
     nServices = NODE_NONE;
     nTime = 100000000;
 }
 
-CInv::CInv()
-{
+CInv::CInv() {
     type = 0;
     hash.SetNull();
 }
 
-CInv::CInv(int typeIn, const uint256& hashIn)
-{
+CInv::CInv(int typeIn, const uint256 &hashIn) {
     type = typeIn;
     hash = hashIn;
 }
 
-bool operator<(const CInv& a, const CInv& b)
-{
+bool operator<(const CInv &a, const CInv &b) {
     return (a.type < b.type || (a.type == b.type && a.hash < b.hash));
 }
 
-std::string CInv::GetCommand() const
+const char* CInv::GetCommand() const
 {
     std::string cmd;
     if (type & MSG_WITNESS_FLAG)
         cmd.append("witness-");
-    int masked = type & MSG_TYPE_MASK;
-    switch (masked)
+    switch (type)
     {
-    case MSG_TX:             return cmd.append(NetMsgType::TX);
-    case MSG_BLOCK:          return cmd.append(NetMsgType::BLOCK);
-    case MSG_FILTERED_BLOCK: return cmd.append(NetMsgType::MERKLEBLOCK);
-    case MSG_CMPCT_BLOCK:    return cmd.append(NetMsgType::CMPCTBLOCK);
-    default:
-        throw std::out_of_range(strprintf("CInv::GetCommand(): type=%d unknown type", type));
+        case MSG_TX:                    return NetMsgType::TX;
+        case MSG_BLOCK:                 return NetMsgType::BLOCK;
+        case MSG_FILTERED_BLOCK:        return NetMsgType::MERKLEBLOCK;
+        case MSG_CMPCT_BLOCK:           return NetMsgType::CMPCTBLOCK;
+        case MSG_TXLOCK_REQUEST:        return NetMsgType::TXLOCKREQUEST;
+        case MSG_TXLOCK_VOTE:           return NetMsgType::TXLOCKVOTE;
+        case MSG_SPORK:                 return NetMsgType::SPORK;
+        case MSG_ZNODE_PAYMENT_VOTE:    return NetMsgType::ZNODEPAYMENTVOTE;
+        case MSG_ZNODE_PAYMENT_BLOCK:   return NetMsgType::ZNODEPAYMENTBLOCK;
+        case MSG_ZNODE_ANNOUNCE:        return NetMsgType::MNANNOUNCE;
+        case MSG_ZNODE_PING:            return NetMsgType::MNPING;
+        case MSG_DSTX:                  return NetMsgType::DSTX;
+        case MSG_ZNODE_VERIFY:          return NetMsgType::MNVERIFY;
+        default: {
+            LogPrintf("ERROR - UNKNOWN INV COMMAND\n");
+            return "error";
+        }
+    //        throw std::out_of_range(strprintf("CInv::GetCommand(): type=%d unknown type", type));
     }
 }
 
+//std::string CInv::GetCommand() const {
+//    if (!IsKnownType()) {
+//        LogPrintf("CInv::GetCommand(): type=%d unknown type\n", type);
+//        throw std::out_of_range(strprintf("CInv::GetCommand(): type=%d unknown type", type));
+//    }
+//    return ppszTypeName[type];
+//}
+
+//const char* CInv::GetCommand() const
+//{
+//    if (!IsKnownType())
+//        throw std::out_of_range(strprintf("CInv::GetCommand(): type=%d unknown type", type));
+//    return ppszTypeName[type];
+//}
+
 std::string CInv::ToString() const
 {
     return strprintf("%s %s", GetCommand(), hash.ToString());
 }
 
-const std::vector<std::string> &getAllNetMessageTypes()
-{
+const std::vector <std::string> &getAllNetMessageTypes() {
     return allNetMessageTypesVec;
 }
diff --git a/src/protocol.h b/src/protocol.h
index 15f27e2d2f..0d2de92c2a 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -243,6 +243,29 @@ extern const char *GETBLOCKTXN;
  * @since protocol version 70014 as described by BIP 152
  */
 extern const char *BLOCKTXN;
+
+extern const char *TXLOCKVOTE;
+extern const char *SPORK;
+extern const char *GETSPORKS;
+extern const char *ZNODEPAYMENTVOTE;
+extern const char *ZNODEPAYMENTSYNC;
+extern const char *SYNCSTATUSCOUNT;
+extern const char *MNVERIFY;
+extern const char *MNPING;
+extern const char *MNANNOUNCE;
+extern const char *DSACCEPT;
+extern const char *DSQUEUE;
+extern const char *DSEG;
+extern const char *DSVIN;
+extern const char *DSSTATUSUPDATE;
+extern const char *DSSIGNFINALTX;
+extern const char *DSCOMPLETE;
+extern const char *DSFINALTX;
+extern const char *TXLOCKVOTE;
+extern const char *DSTX;
+extern const char *TXLOCKREQUEST;
+
+
 };
 
 /* Get a vector of all valid message types (see above) */
@@ -318,7 +341,7 @@ const uint32_t MSG_TYPE_MASK    = 0xffffffff >> 2;
 enum GetDataMsg
 {
     UNDEFINED = 0,
-    MSG_TX,
+    MSG_TX = 1,
     MSG_BLOCK,
     MSG_TYPE_MAX = MSG_BLOCK,
     // The following can only occur in getdata. Invs always use TX or BLOCK.
@@ -327,6 +350,16 @@ enum GetDataMsg
     MSG_WITNESS_BLOCK = MSG_BLOCK | MSG_WITNESS_FLAG,
     MSG_WITNESS_TX = MSG_TX | MSG_WITNESS_FLAG,
     MSG_FILTERED_WITNESS_BLOCK = MSG_FILTERED_BLOCK | MSG_WITNESS_FLAG,
+    MSG_SPORK,
+    MSG_ZNODE_PAYMENT_VOTE,
+    MSG_ZNODE_PAYMENT_BLOCK,
+    MSG_ZNODE_ANNOUNCE,
+    MSG_ZNODE_PING,
+    MSG_ZNODE_VERIFY,
+    MSG_TXLOCK_REQUEST,
+    MSG_TXLOCK_VOTE,
+    MSG_DSTX,
+    DSQUEUE,
 };
 
 /** inv message data */
@@ -334,6 +367,7 @@ class CInv
 {
 public:
     CInv();
+//    CInv(const std::string& strType, const uint256& hashIn);
     CInv(int typeIn, const uint256& hashIn);
 
     ADD_SERIALIZE_METHODS;
@@ -347,7 +381,9 @@ class CInv
 
     friend bool operator<(const CInv& a, const CInv& b);
 
-    std::string GetCommand() const;
+//    bool IsKnownType() const;
+//    std::string GetCommand() const;
+    const char* GetCommand() const;
     std::string ToString() const;
 
     // TODO: make private (improves encapsulation)
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
index 618c7109ae..a9d87b54a0 100644
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -19,6 +19,7 @@
 #include "splashscreen.h"
 #include "utilitydialog.h"
 #include "winshutdownmonitor.h"
+#include "znodeconfig.h"
 
 #ifdef ENABLE_WALLET
 #include "paymentserver.h"
@@ -627,6 +628,14 @@ int main(int argc, char *argv[])
     initTranslations(qtTranslatorBase, qtTranslator, translatorBase, translator);
 
 #ifdef ENABLE_WALLET
+    /// 7a. parse znode.conf
+    std::string strErr;
+    if(!znodeConfig.read(strErr)) {
+        QMessageBox::critical(0, QObject::tr("Zcoin Core"),
+                              QObject::tr("Error reading znode configuration file: %1").arg(strErr.c_str()));
+        return EXIT_FAILURE;
+    }
+
     /// 8. URI IPC sending
     // - Do this early as we don't want to bother initializing if we are just calling IPC
     // - Do this *after* setting up the data directory, as the data directory hash is used in the name
diff --git a/src/qt/bitcoin.qrc b/src/qt/bitcoin.qrc
index 7a69dcee0b..447b81a98a 100644
--- a/src/qt/bitcoin.qrc
+++ b/src/qt/bitcoin.qrc
@@ -29,6 +29,7 @@
         <file alias="history">res/icons/history.png</file>
         <file alias="qrcode">res/icons/qrcode.png</file>
         <file alias="zerocoin">res/icons/zerocoin.png</file>
+        <file alias="znodes">res/icons/znodes.png</file>
         <file alias="overview">res/icons/overview.png</file>
         <file alias="export">res/icons/export.png</file>
         <file alias="synced">res/icons/synced.png</file>
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 7143e6f0f2..5fed121b8a 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -34,6 +34,9 @@
 #include "ui_interface.h"
 #include "util.h"
 
+#include "znode-sync.h"
+#include "znodelist.h"
+
 #include <iostream>
 
 #include <QAction>
@@ -97,6 +100,7 @@ BitcoinGUI::BitcoinGUI(const PlatformStyle *platformStyle, const NetworkStyle *n
     signMessageAction(0),
     verifyMessageAction(0),
     aboutAction(0),
+    znodeAction(0),
     receiveCoinsAction(0),
     receiveCoinsMenuAction(0),
     optionsAction(0),
@@ -310,8 +314,20 @@ void BitcoinGUI::createActions()
 
 
 #ifdef ENABLE_WALLET
-	// These showNormalIfMinimized are needed because Send Coins and Receive Coins
-	// can be triggered from the tray menu, and need to show the GUI to be useful.
+    // These showNormalIfMinimized are needed because Send Coins and Receive Coins
+    // can be triggered from the tray menu, and need to show the GUI to be useful.
+    znodeAction = new QAction(platformStyle->SingleColorIcon(":/icons/znodes"), tr("&Znodes"), this);
+    znodeAction->setStatusTip(tr("Browse znodes"));
+    znodeAction->setToolTip(znodeAction->statusTip());
+    znodeAction->setCheckable(true);
+#ifdef Q_OS_MAC
+    znodeAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_5));
+#else
+    znodeAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_5));
+#endif
+    tabGroup->addAction(znodeAction);
+    connect(znodeAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
+    connect(znodeAction, SIGNAL(triggered()), this, SLOT(gotoZnodePage()));
 	connect(overviewAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
 	connect(overviewAction, SIGNAL(triggered()), this, SLOT(gotoOverviewPage()));
 	connect(sendCoinsAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
@@ -460,6 +476,7 @@ void BitcoinGUI::createToolBars()
         toolbar->addAction(receiveCoinsAction);
         toolbar->addAction(historyAction);
         toolbar->addAction(zerocoinAction);
+        toolbar->addAction(znodeAction);
         overviewAction->setChecked(true);
     }
 }
@@ -480,6 +497,8 @@ void BitcoinGUI::setClientModel(ClientModel *clientModel)
         setNumBlocks(clientModel->getNumBlocks(), clientModel->getLastBlockDate(), clientModel->getVerificationProgress(NULL), false);
         connect(clientModel, SIGNAL(numBlocksChanged(int,QDateTime,double,bool)), this, SLOT(setNumBlocks(int,QDateTime,double,bool)));
 
+        connect(clientModel, SIGNAL(additionalDataSyncProgressChanged(double)), this, SLOT(setAdditionalDataSyncProgress(double)));
+
         // Receive and report messages from client model
         connect(clientModel, SIGNAL(message(QString,QString,unsigned int)), this, SLOT(message(QString,QString,unsigned int)));
 
@@ -558,6 +577,7 @@ void BitcoinGUI::setWalletActionsEnabled(bool enabled)
     receiveCoinsMenuAction->setEnabled(enabled);
     historyAction->setEnabled(enabled);
     zerocoinAction->setEnabled(enabled);
+    znodeAction->setEnabled(enabled);
     encryptWalletAction->setEnabled(enabled);
     backupWalletAction->setEnabled(enabled);
     changePassphraseAction->setEnabled(enabled);
@@ -688,6 +708,13 @@ void BitcoinGUI::gotoHistoryPage()
     if (walletFrame) walletFrame->gotoHistoryPage();
 }
 
+void BitcoinGUI::gotoZnodePage()
+{
+    QSettings settings;
+    znodeAction->setChecked(true);
+    if (walletFrame) walletFrame->gotoZnodePage();
+}
+
 void BitcoinGUI::gotoReceiveCoinsPage()
 {
     receiveCoinsAction->setChecked(true);
@@ -774,21 +801,7 @@ void BitcoinGUI::setNumBlocks(int count, const QDateTime& blockDate, double nVer
 
     tooltip = tr("Processed %n block(s) of transaction history.", "", count);
 
-    // Set icon state: spinning if catching up, tick otherwise
-    if(secs < 90*60)
-    {
-        tooltip = tr("Up to date") + QString(".<br>") + tooltip;
-        labelBlocksIcon->setPixmap(platformStyle->SingleColorIcon(":/icons/synced").pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
-
-#ifdef ENABLE_WALLET
-        if(walletFrame)
-            walletFrame->showOutOfSyncWarning(false);
-#endif // ENABLE_WALLET
-
-        progressBarLabel->setVisible(false);
-        progressBar->setVisible(false);
-    }
-    else
+    if(!znodeSync.IsBlockchainSynced())
     {
         // Represent time from last generated block in human readable text
         QString timeBehindText;
@@ -825,8 +838,8 @@ void BitcoinGUI::setNumBlocks(int count, const QDateTime& blockDate, double nVer
         if(count != prevBlocks)
         {
             labelBlocksIcon->setPixmap(platformStyle->SingleColorIcon(QString(
-                ":/movies/spinner-%1").arg(spinnerFrame, 3, 10, QChar('0')))
-                .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
+                            ":/movies/spinner-%1").arg(spinnerFrame, 3, 10, QChar('0')))
+                                               .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES;
         }
         prevBlocks = count;
@@ -850,6 +863,61 @@ void BitcoinGUI::setNumBlocks(int count, const QDateTime& blockDate, double nVer
     progressBar->setToolTip(tooltip);
 }
 
+
+void BitcoinGUI::setAdditionalDataSyncProgress(double nSyncProgress)
+{
+    if(!clientModel)
+        return;
+
+    // Prevent orphan statusbar messages (e.g. hover Quit in main menu, wait until chain-sync starts -> garbelled text)
+    statusBar()->clearMessage();
+
+    QString tooltip;
+
+    // Set icon state: spinning if catching up, tick otherwise
+
+    if(znodeSync.IsBlockchainSynced())
+    {
+        QString strSyncStatus;
+        tooltip = tr("Up to date") + QString(".<br>") + tooltip;
+
+        if(znodeSync.IsSynced()) {
+            progressBarLabel->setVisible(false);
+            progressBar->setVisible(false);
+            labelBlocksIcon->setPixmap(platformStyle->SingleColorIcon(":/icons/synced").pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
+        } else {
+
+            labelBlocksIcon->setPixmap(platformStyle->SingleColorIcon(QString(
+                            ":/movies/spinner-%1").arg(spinnerFrame, 3, 10, QChar('0')))
+                                               .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
+            spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES;
+
+#ifdef ENABLE_WALLET
+            if(walletFrame)
+                walletFrame->showOutOfSyncWarning(false);
+#endif // ENABLE_WALLET
+
+            progressBar->setFormat(tr("Synchronizing additional data: %p%"));
+            progressBar->setMaximum(1000000000);
+            LogPrintf("nSyncProgress=%s\n", nSyncProgress);
+            LogPrintf("nSyncProgress * 1000000000.0 + 0.5=%s\n", nSyncProgress * 1000000000.0 + 0.5);
+            progressBar->setValue(nSyncProgress * 1000000000.0 + 0.5);
+        }
+
+        strSyncStatus = QString(znodeSync.GetSyncStatus().c_str());
+        progressBarLabel->setText(strSyncStatus);
+        tooltip = strSyncStatus + QString("<br>") + tooltip;
+    }
+
+    // Don't word-wrap this (fixed-width) tooltip
+    tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
+
+    labelBlocksIcon->setToolTip(tooltip);
+    progressBarLabel->setToolTip(tooltip);
+    progressBar->setToolTip(tooltip);
+}
+
+
 void BitcoinGUI::message(const QString &title, const QString &message, unsigned int style, bool *ret)
 {
     QString strTitle = tr("Zcoin"); // default title
diff --git a/src/qt/bitcoingui.h b/src/qt/bitcoingui.h
index 5e9f12f40d..6d0a34af4a 100644
--- a/src/qt/bitcoingui.h
+++ b/src/qt/bitcoingui.h
@@ -112,6 +112,7 @@ class BitcoinGUI : public QMainWindow
     QAction *openAction;
     QAction *showHelpMessageAction;
     QAction *zerocoinAction;
+    QAction *znodeAction;
     QAction *zerocoinMenuAction;
 
     QSystemTrayIcon *trayIcon;
@@ -154,6 +155,8 @@ public Q_SLOTS:
     void setNumConnections(int count);
     /** Set number of blocks and last block date shown in the UI */
     void setNumBlocks(int count, const QDateTime& blockDate, double nVerificationProgress, bool headers);
+    /** Set additional data sync status shown in the UI */
+    void setAdditionalDataSyncProgress(double nSyncProgress);
 
     /** Notify the user of an event from the core network or transaction handling code.
        @param[in] title     the message box / notification title
@@ -183,6 +186,8 @@ private Q_SLOTS:
     void gotoOverviewPage();
     /** Switch to history (transactions) page */
     void gotoHistoryPage();
+    /** Switch to znode page */
+    void gotoZnodePage();
     /** Switch to receive coins page */
     void gotoReceiveCoinsPage();
     /** Switch to send coins page */
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
index 9530b63a27..607e27c754 100644
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -211,6 +211,12 @@ static void NotifyNumConnectionsChanged(ClientModel *clientmodel, int newNumConn
                               Q_ARG(int, newNumConnections));
 }
 
+static void NotifyAdditionalDataSyncProgressChanged(ClientModel *clientmodel, double nSyncProgress)
+{
+    QMetaObject::invokeMethod(clientmodel, "additionalDataSyncProgressChanged", Qt::QueuedConnection,
+                              Q_ARG(double, nSyncProgress));
+}
+
 static void NotifyAlertChanged(ClientModel *clientmodel)
 {
     qDebug() << "NotifyAlertChanged";
@@ -255,6 +261,7 @@ void ClientModel::subscribeToCoreSignals()
     uiInterface.BannedListChanged.connect(boost::bind(BannedListChanged, this));
     uiInterface.NotifyBlockTip.connect(boost::bind(BlockTipChanged, this, _1, _2, false));
     uiInterface.NotifyHeaderTip.connect(boost::bind(BlockTipChanged, this, _1, _2, true));
+    uiInterface.NotifyAdditionalDataSyncProgressChanged.connect(boost::bind(NotifyAdditionalDataSyncProgressChanged, this, _1));
 }
 
 void ClientModel::unsubscribeFromCoreSignals()
@@ -266,4 +273,5 @@ void ClientModel::unsubscribeFromCoreSignals()
     uiInterface.BannedListChanged.disconnect(boost::bind(BannedListChanged, this));
     uiInterface.NotifyBlockTip.disconnect(boost::bind(BlockTipChanged, this, _1, _2, false));
     uiInterface.NotifyHeaderTip.disconnect(boost::bind(BlockTipChanged, this, _1, _2, true));
+    uiInterface.NotifyAdditionalDataSyncProgressChanged.disconnect(boost::bind(NotifyAdditionalDataSyncProgressChanged, this, _1));
 }
diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
index 99fd574b9e..a774f25c22 100644
--- a/src/qt/clientmodel.h
+++ b/src/qt/clientmodel.h
@@ -92,6 +92,7 @@ class ClientModel : public QObject
     void mempoolSizeChanged(long count, size_t mempoolSizeInBytes);
     void alertsChanged(const QString &warnings);
     void bytesChanged(quint64 totalBytesIn, quint64 totalBytesOut);
+    void additionalDataSyncProgressChanged(double nSyncProgress);
 
     //! Fired when a message should be reported to the user
     void message(const QString &title, const QString &message, unsigned int style);
diff --git a/src/qt/forms/znodelist.ui b/src/qt/forms/znodelist.ui
new file mode 100644
index 0000000000..08bbd66008
--- /dev/null
+++ b/src/qt/forms/znodelist.ui
@@ -0,0 +1,317 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ZnodeList</class>
+ <widget class="QWidget" name="ZnodeList">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>811</width>
+    <height>457</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="topLayout">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <property name="bottomMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <spacer name="horizontalSpacer0">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QTabWidget" name="tabWidget">
+       <property name="currentIndex">
+        <number>1</number>
+       </property>
+       <widget class="QWidget" name="tabMyZnodes">
+        <attribute name="title">
+         <string>My Znodes</string>
+        </attribute>
+        <layout class="QGridLayout" name="gridLayout_2">
+         <item row="0" column="0">
+          <layout class="QVBoxLayout" name="verticalLayout_2">
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <layout class="QHBoxLayout" name="horizontalLayout_note">
+             <property name="bottomMargin">
+              <number>0</number>
+             </property>
+             <item>
+              <widget class="QLabel" name="updateNote">
+               <property name="text">
+                <string>Note: Status of your znodes in local wallet can potentially be slightly incorrect.&lt;br /&gt;Always wait for wallet to sync additional data and then double check from another node&lt;br /&gt;if your znode should be running but you still do not see &quot;ENABLED&quot; in &quot;Status&quot; field.</string>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
+           <item>
+            <widget class="QTableWidget" name="tableWidgetMyZnodes">
+             <property name="minimumSize">
+              <size>
+               <width>695</width>
+               <height>0</height>
+              </size>
+             </property>
+             <property name="editTriggers">
+              <set>QAbstractItemView::NoEditTriggers</set>
+             </property>
+             <property name="alternatingRowColors">
+              <bool>true</bool>
+             </property>
+             <property name="selectionMode">
+              <enum>QAbstractItemView::SingleSelection</enum>
+             </property>
+             <property name="selectionBehavior">
+              <enum>QAbstractItemView::SelectRows</enum>
+             </property>
+             <property name="sortingEnabled">
+              <bool>true</bool>
+             </property>
+             <attribute name="horizontalHeaderStretchLastSection">
+              <bool>true</bool>
+             </attribute>
+             <column>
+              <property name="text">
+               <string>Alias</string>
+              </property>
+             </column>
+             <column>
+              <property name="text">
+               <string>Address</string>
+              </property>
+             </column>
+             <column>
+              <property name="text">
+               <string>Protocol</string>
+              </property>
+             </column>
+             <column>
+              <property name="text">
+               <string>Status</string>
+              </property>
+             </column>
+             <column>
+              <property name="text">
+               <string>Active</string>
+              </property>
+             </column>
+             <column>
+              <property name="text">
+               <string>Last Seen</string>
+              </property>
+             </column>
+             <column>
+              <property name="text">
+               <string>Payee</string>
+              </property>
+             </column>
+            </widget>
+           </item>
+           <item>
+            <layout class="QHBoxLayout" name="horizontalLayout_5">
+             <property name="bottomMargin">
+              <number>0</number>
+             </property>
+             <item>
+              <widget class="QPushButton" name="startButton">
+               <property name="text">
+                <string>S&amp;tart alias</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QPushButton" name="startAllButton">
+               <property name="text">
+                <string>Start &amp;all</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QPushButton" name="startMissingButton">
+               <property name="text">
+                <string>Start &amp;MISSING</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QPushButton" name="UpdateButton">
+               <property name="text">
+                <string>&amp;Update status</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QLabel" name="autoupdate_label">
+               <property name="text">
+                <string>Status will be updated automatically in (sec):</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QLabel" name="secondsLabel">
+               <property name="text">
+                <string>0</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <spacer name="horizontalSpacer_5">
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>40</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
+            </layout>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </widget>
+       <widget class="QWidget" name="tabAllZnodes">
+        <attribute name="title">
+         <string>All Znodes</string>
+        </attribute>
+        <layout class="QGridLayout" name="gridLayout">
+         <item row="1" column="0">
+          <widget class="QTableWidget" name="tableWidgetZnodes">
+           <property name="editTriggers">
+            <set>QAbstractItemView::NoEditTriggers</set>
+           </property>
+           <property name="alternatingRowColors">
+            <bool>true</bool>
+           </property>
+           <property name="selectionBehavior">
+            <enum>QAbstractItemView::SelectRows</enum>
+           </property>
+           <property name="sortingEnabled">
+            <bool>true</bool>
+           </property>
+           <attribute name="horizontalHeaderStretchLastSection">
+            <bool>true</bool>
+           </attribute>
+           <column>
+            <property name="text">
+             <string>Address</string>
+            </property>
+           </column>
+           <column>
+            <property name="text">
+             <string>Protocol</string>
+            </property>
+           </column>
+           <column>
+            <property name="text">
+             <string>Status</string>
+            </property>
+           </column>
+           <column>
+            <property name="text">
+             <string>Active</string>
+            </property>
+           </column>
+           <column>
+            <property name="text">
+             <string>Last Seen</string>
+            </property>
+           </column>
+           <column>
+            <property name="text">
+             <string>Payee</string>
+            </property>
+           </column>
+          </widget>
+         </item>
+         <item row="0" column="0">
+          <layout class="QHBoxLayout" name="horizontalLayout_3">
+           <property name="bottomMargin">
+            <number>0</number>
+           </property>
+           <item>
+            <widget class="QLabel" name="label_filter">
+             <property name="text">
+              <string>Filter List:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLineEdit" name="filterLineEdit">
+             <property name="toolTip">
+              <string>Filter znode list</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <spacer name="horizontalSpacer_3">
+             <property name="orientation">
+              <enum>Qt::Horizontal</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>10</width>
+               <height>20</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item>
+            <widget class="QLabel" name="label_count">
+             <property name="text">
+              <string>Node Count:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="countLabel">
+             <property name="text">
+              <string>0</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </widget>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index 7f5a417a2f..4fc5112ac1 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -953,4 +953,41 @@ QString formatTimeOffset(int64_t nTimeOffset)
   return QString(QObject::tr("%1 s")).arg(QString::number((int)nTimeOffset, 10));
 }
 
+QString formatNiceTimeOffset(qint64 secs)
+{
+    // Represent time from last generated block in human readable text
+    QString timeBehindText;
+    const int HOUR_IN_SECONDS = 60*60;
+    const int DAY_IN_SECONDS = 24*60*60;
+    const int WEEK_IN_SECONDS = 7*24*60*60;
+    const int YEAR_IN_SECONDS = 31556952; // Average length of year in Gregorian calendar
+    if(secs < 60)
+    {
+        timeBehindText = QObject::tr("%n second(s)","",secs);
+    }
+    else if(secs < 2*HOUR_IN_SECONDS)
+    {
+        timeBehindText = QObject::tr("%n minute(s)","",secs/60);
+    }
+    else if(secs < 2*DAY_IN_SECONDS)
+    {
+        timeBehindText = QObject::tr("%n hour(s)","",secs/HOUR_IN_SECONDS);
+    }
+    else if(secs < 2*WEEK_IN_SECONDS)
+    {
+        timeBehindText = QObject::tr("%n day(s)","",secs/DAY_IN_SECONDS);
+    }
+    else if(secs < YEAR_IN_SECONDS)
+    {
+        timeBehindText = QObject::tr("%n week(s)","",secs/WEEK_IN_SECONDS);
+    }
+    else
+    {
+        qint64 years = secs / YEAR_IN_SECONDS;
+        qint64 remainder = secs % YEAR_IN_SECONDS;
+        timeBehindText = QObject::tr("%1 and %2").arg(QObject::tr("%n year(s)", "", years)).arg(QObject::tr("%n week(s)","", remainder/WEEK_IN_SECONDS));
+    }
+    return timeBehindText;
+}
+
 } // namespace GUIUtil
diff --git a/src/qt/guiutil.h b/src/qt/guiutil.h
index 83cd6b5d46..6a28555b07 100644
--- a/src/qt/guiutil.h
+++ b/src/qt/guiutil.h
@@ -200,6 +200,8 @@ namespace GUIUtil
     /* Format a CNodeCombinedStats.nTimeOffset into a user-readable string. */
     QString formatTimeOffset(int64_t nTimeOffset);
 
+    QString formatNiceTimeOffset(qint64 secs);
+
 #if defined(Q_OS_MAC) && QT_VERSION >= 0x050000
     // workaround for Qt OSX Bug:
     // https://bugreports.qt-project.org/browse/QTBUG-15631
diff --git a/src/qt/res/icons/zcoin.svg b/src/qt/res/icons/zcoin.svg
new file mode 100644
index 0000000000..757e230318
--- /dev/null
+++ b/src/qt/res/icons/zcoin.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" height="512" viewBox="0 0 512 512">
+  <image id="Layer_0" data-name="Layer 0" x="9" y="23" width="495" height="489" xlink:href="data:img/png;base64,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"/>
+</svg>
diff --git a/src/qt/res/icons/znodes.png b/src/qt/res/icons/znodes.png
new file mode 100644
index 0000000000..1257d31cec
Binary files /dev/null and b/src/qt/res/icons/znodes.png differ
diff --git a/src/qt/walletframe.cpp b/src/qt/walletframe.cpp
index cf555abca8..d38f92dadc 100644
--- a/src/qt/walletframe.cpp
+++ b/src/qt/walletframe.cpp
@@ -120,6 +120,13 @@ void WalletFrame::gotoHistoryPage()
         i.value()->gotoHistoryPage();
 }
 
+void WalletFrame::gotoZnodePage()
+{
+    QMap<QString, WalletView*>::const_iterator i;
+    for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i)
+        i.value()->gotoZnodePage();
+}
+
 void WalletFrame::gotoReceiveCoinsPage()
 {
     QMap<QString, WalletView*>::const_iterator i;
diff --git a/src/qt/walletframe.h b/src/qt/walletframe.h
index 5846358175..20633540c1 100644
--- a/src/qt/walletframe.h
+++ b/src/qt/walletframe.h
@@ -55,6 +55,8 @@ public Q_SLOTS:
     void gotoOverviewPage();
     /** Switch to history (transactions) page */
     void gotoHistoryPage();
+    /** Switch to znode page */
+    void gotoZnodePage();
     /** Switch to receive coins page */
     void gotoReceiveCoinsPage();
     /** Switch to send coins page */
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
index 0263a95508..48ac6cae2b 100644
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -122,6 +122,7 @@ class WalletModel : public QObject
     {
         Unencrypted,  // !wallet->IsCrypted()
         Locked,       // wallet->IsCrypted() && wallet->IsLocked()
+        UnlockedForMixingOnly,  // wallet->IsCrypted() && !wallet->IsLocked(true) && wallet->IsLocked()
         Unlocked      // wallet->IsCrypted() && !wallet->IsLocked()
     };
 
diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
index dc1fc5fee4..b136b3ef00 100644
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -67,6 +67,8 @@ WalletView::WalletView(const PlatformStyle *platformStyle, QWidget *parent):
     addWidget(receiveCoinsPage);
     addWidget(sendCoinsPage);
     addWidget(zerocoinPage);
+    znodeListPage = new ZnodeList(platformStyle);
+    addWidget(znodeListPage);
 
     // Clicking on a transaction on the overview pre-selects the transaction on the transaction history page
     connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), transactionView, SLOT(focusTransaction(QModelIndex)));
@@ -111,6 +113,7 @@ void WalletView::setClientModel(ClientModel *clientModel)
 
     overviewPage->setClientModel(clientModel);
     sendCoinsPage->setClientModel(clientModel);
+    znodeListPage->setClientModel(clientModel);
 }
 
 void WalletView::setWalletModel(WalletModel *walletModel)
@@ -125,6 +128,7 @@ void WalletView::setWalletModel(WalletModel *walletModel)
     zerocoinPage->setModel(walletModel->getAddressTableModel());
     usedReceivingAddressesPage->setModel(walletModel->getAddressTableModel());
     usedSendingAddressesPage->setModel(walletModel->getAddressTableModel());
+    znodeListPage->setWalletModel(walletModel);
 
     if (walletModel)
     {
@@ -177,6 +181,11 @@ void WalletView::gotoHistoryPage()
     setCurrentWidget(transactionsPage);
 }
 
+void WalletView::gotoZnodePage()
+{
+    setCurrentWidget(znodeListPage);
+}
+
 void WalletView::gotoReceiveCoinsPage()
 {
     setCurrentWidget(receiveCoinsPage);
diff --git a/src/qt/walletview.h b/src/qt/walletview.h
index 29ade07cde..9320a3ca36 100644
--- a/src/qt/walletview.h
+++ b/src/qt/walletview.h
@@ -6,6 +6,7 @@
 #define BITCOIN_QT_WALLETVIEW_H
 
 #include "amount.h"
+#include "znodelist.h"
 
 #include <QStackedWidget>
 
@@ -67,6 +68,7 @@ class WalletView : public QStackedWidget
     AddressBookPage *usedReceivingAddressesPage;
     ZerocoinPage *zerocoinPage;
     TransactionView *transactionView;
+    ZnodeList *znodeListPage;
 
     QProgressDialog *progressDialog;
     const PlatformStyle *platformStyle;
@@ -76,6 +78,8 @@ public Q_SLOTS:
     void gotoOverviewPage();
     /** Switch to history (transactions) page */
     void gotoHistoryPage();
+    /** Switch to znode page */
+    void gotoZnodePage();
     /** Switch to receive coins page */
     void gotoReceiveCoinsPage();
     /** Switch to send coins page */
diff --git a/src/qt/znodelist.cpp b/src/qt/znodelist.cpp
new file mode 100644
index 0000000000..b208398089
--- /dev/null
+++ b/src/qt/znodelist.cpp
@@ -0,0 +1,428 @@
+#include "znodelist.h"
+#include "ui_znodelist.h"
+
+#include "activeznode.h"
+#include "clientmodel.h"
+#include "init.h"
+#include "guiutil.h"
+#include "znode-sync.h"
+#include "znodeconfig.h"
+#include "znodeman.h"
+#include "sync.h"
+#include "wallet/wallet.h"
+#include "walletmodel.h"
+
+#include <QTimer>
+#include <QMessageBox>
+
+int GetOffsetFromUtc()
+{
+#if QT_VERSION < 0x050200
+    const QDateTime dateTime1 = QDateTime::currentDateTime();
+    const QDateTime dateTime2 = QDateTime(dateTime1.date(), dateTime1.time(), Qt::UTC);
+    return dateTime1.secsTo(dateTime2);
+#else
+    return QDateTime::currentDateTime().offsetFromUtc();
+#endif
+}
+
+ZnodeList::ZnodeList(const PlatformStyle *platformStyle, QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::ZnodeList),
+    clientModel(0),
+    walletModel(0)
+{
+    ui->setupUi(this);
+
+    ui->startButton->setEnabled(false);
+
+    int columnAliasWidth = 100;
+    int columnAddressWidth = 200;
+    int columnProtocolWidth = 60;
+    int columnStatusWidth = 80;
+    int columnActiveWidth = 130;
+    int columnLastSeenWidth = 130;
+
+    ui->tableWidgetMyZnodes->setColumnWidth(0, columnAliasWidth);
+    ui->tableWidgetMyZnodes->setColumnWidth(1, columnAddressWidth);
+    ui->tableWidgetMyZnodes->setColumnWidth(2, columnProtocolWidth);
+    ui->tableWidgetMyZnodes->setColumnWidth(3, columnStatusWidth);
+    ui->tableWidgetMyZnodes->setColumnWidth(4, columnActiveWidth);
+    ui->tableWidgetMyZnodes->setColumnWidth(5, columnLastSeenWidth);
+
+    ui->tableWidgetZnodes->setColumnWidth(0, columnAddressWidth);
+    ui->tableWidgetZnodes->setColumnWidth(1, columnProtocolWidth);
+    ui->tableWidgetZnodes->setColumnWidth(2, columnStatusWidth);
+    ui->tableWidgetZnodes->setColumnWidth(3, columnActiveWidth);
+    ui->tableWidgetZnodes->setColumnWidth(4, columnLastSeenWidth);
+
+    ui->tableWidgetMyZnodes->setContextMenuPolicy(Qt::CustomContextMenu);
+
+    QAction *startAliasAction = new QAction(tr("Start alias"), this);
+    contextMenu = new QMenu();
+    contextMenu->addAction(startAliasAction);
+    connect(ui->tableWidgetMyZnodes, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(showContextMenu(const QPoint&)));
+    connect(startAliasAction, SIGNAL(triggered()), this, SLOT(on_startButton_clicked()));
+
+    timer = new QTimer(this);
+    connect(timer, SIGNAL(timeout()), this, SLOT(updateNodeList()));
+    connect(timer, SIGNAL(timeout()), this, SLOT(updateMyNodeList()));
+    timer->start(1000);
+
+    fFilterUpdated = false;
+    nTimeFilterUpdated = GetTime();
+    updateNodeList();
+}
+
+ZnodeList::~ZnodeList()
+{
+    delete ui;
+}
+
+void ZnodeList::setClientModel(ClientModel *model)
+{
+    this->clientModel = model;
+    if(model) {
+        // try to update list when znode count changes
+        connect(clientModel, SIGNAL(strZnodesChanged(QString)), this, SLOT(updateNodeList()));
+    }
+}
+
+void ZnodeList::setWalletModel(WalletModel *model)
+{
+    this->walletModel = model;
+}
+
+void ZnodeList::showContextMenu(const QPoint &point)
+{
+    QTableWidgetItem *item = ui->tableWidgetMyZnodes->itemAt(point);
+    if(item) contextMenu->exec(QCursor::pos());
+}
+
+void ZnodeList::StartAlias(std::string strAlias)
+{
+    std::string strStatusHtml;
+    strStatusHtml += "<center>Alias: " + strAlias;
+
+    BOOST_FOREACH(CZnodeConfig::CZnodeEntry mne, znodeConfig.getEntries()) {
+        if(mne.getAlias() == strAlias) {
+            std::string strError;
+            CZnodeBroadcast mnb;
+
+            bool fSuccess = CZnodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(), mne.getOutputIndex(), strError, mnb);
+
+            if(fSuccess) {
+                strStatusHtml += "<br>Successfully started znode.";
+                mnodeman.UpdateZnodeList(mnb);
+                mnb.RelayZNode();
+                mnodeman.NotifyZnodeUpdates();
+            } else {
+                strStatusHtml += "<br>Failed to start znode.<br>Error: " + strError;
+            }
+            break;
+        }
+    }
+    strStatusHtml += "</center>";
+
+    QMessageBox msg;
+    msg.setText(QString::fromStdString(strStatusHtml));
+    msg.exec();
+
+    updateMyNodeList(true);
+}
+
+void ZnodeList::StartAll(std::string strCommand)
+{
+    int nCountSuccessful = 0;
+    int nCountFailed = 0;
+    std::string strFailedHtml;
+
+    BOOST_FOREACH(CZnodeConfig::CZnodeEntry mne, znodeConfig.getEntries()) {
+        std::string strError;
+        CZnodeBroadcast mnb;
+
+        int32_t nOutputIndex = 0;
+        if(!ParseInt32(mne.getOutputIndex(), &nOutputIndex)) {
+            continue;
+        }
+
+        COutPoint outpoint = COutPoint(uint256S(mne.getTxHash()), nOutputIndex);
+
+        if(strCommand == "start-missing" && mnodeman.Has(CTxIn(outpoint))) continue;
+
+        bool fSuccess = CZnodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(), mne.getOutputIndex(), strError, mnb);
+
+        if(fSuccess) {
+            nCountSuccessful++;
+            mnodeman.UpdateZnodeList(mnb);
+            mnb.RelayZNode();
+            mnodeman.NotifyZnodeUpdates();
+        } else {
+            nCountFailed++;
+            strFailedHtml += "\nFailed to start " + mne.getAlias() + ". Error: " + strError;
+        }
+    }
+    pwalletMain->Lock();
+
+    std::string returnObj;
+    returnObj = strprintf("Successfully started %d znodes, failed to start %d, total %d", nCountSuccessful, nCountFailed, nCountFailed + nCountSuccessful);
+    if (nCountFailed > 0) {
+        returnObj += strFailedHtml;
+    }
+
+    QMessageBox msg;
+    msg.setText(QString::fromStdString(returnObj));
+    msg.exec();
+
+    updateMyNodeList(true);
+}
+
+void ZnodeList::updateMyZnodeInfo(QString strAlias, QString strAddr, const COutPoint& outpoint)
+{
+    bool fOldRowFound = false;
+    int nNewRow = 0;
+
+    for(int i = 0; i < ui->tableWidgetMyZnodes->rowCount(); i++) {
+        if(ui->tableWidgetMyZnodes->item(i, 0)->text() == strAlias) {
+            fOldRowFound = true;
+            nNewRow = i;
+            break;
+        }
+    }
+
+    if(nNewRow == 0 && !fOldRowFound) {
+        nNewRow = ui->tableWidgetMyZnodes->rowCount();
+        ui->tableWidgetMyZnodes->insertRow(nNewRow);
+    }
+
+    znode_info_t infoMn = mnodeman.GetZnodeInfo(CTxIn(outpoint));
+    bool fFound = infoMn.fInfoValid;
+
+    QTableWidgetItem *aliasItem = new QTableWidgetItem(strAlias);
+    QTableWidgetItem *addrItem = new QTableWidgetItem(fFound ? QString::fromStdString(infoMn.addr.ToString()) : strAddr);
+    QTableWidgetItem *protocolItem = new QTableWidgetItem(QString::number(fFound ? infoMn.nProtocolVersion : -1));
+    QTableWidgetItem *statusItem = new QTableWidgetItem(QString::fromStdString(fFound ? CZnode::StateToString(infoMn.nActiveState) : "MISSING"));
+    QTableWidgetItem *activeSecondsItem = new QTableWidgetItem(QString::fromStdString(DurationToDHMS(fFound ? (infoMn.nTimeLastPing - infoMn.sigTime) : 0)));
+    QTableWidgetItem *lastSeenItem = new QTableWidgetItem(QString::fromStdString(DateTimeStrFormat("%Y-%m-%d %H:%M",
+                                                                                                   fFound ? infoMn.nTimeLastPing + GetOffsetFromUtc() : 0)));
+    QTableWidgetItem *pubkeyItem = new QTableWidgetItem(QString::fromStdString(fFound ? CBitcoinAddress(infoMn.pubKeyCollateralAddress.GetID()).ToString() : ""));
+
+    ui->tableWidgetMyZnodes->setItem(nNewRow, 0, aliasItem);
+    ui->tableWidgetMyZnodes->setItem(nNewRow, 1, addrItem);
+    ui->tableWidgetMyZnodes->setItem(nNewRow, 2, protocolItem);
+    ui->tableWidgetMyZnodes->setItem(nNewRow, 3, statusItem);
+    ui->tableWidgetMyZnodes->setItem(nNewRow, 4, activeSecondsItem);
+    ui->tableWidgetMyZnodes->setItem(nNewRow, 5, lastSeenItem);
+    ui->tableWidgetMyZnodes->setItem(nNewRow, 6, pubkeyItem);
+}
+
+void ZnodeList::updateMyNodeList(bool fForce)
+{
+    TRY_LOCK(cs_mymnlist, fLockAcquired);
+    if(!fLockAcquired) {
+        return;
+    }
+    static int64_t nTimeMyListUpdated = 0;
+
+    // automatically update my znode list only once in MY_MASTERNODELIST_UPDATE_SECONDS seconds,
+    // this update still can be triggered manually at any time via button click
+    int64_t nSecondsTillUpdate = nTimeMyListUpdated + MY_MASTERNODELIST_UPDATE_SECONDS - GetTime();
+    ui->secondsLabel->setText(QString::number(nSecondsTillUpdate));
+
+    if(nSecondsTillUpdate > 0 && !fForce) return;
+    nTimeMyListUpdated = GetTime();
+
+    ui->tableWidgetZnodes->setSortingEnabled(false);
+    BOOST_FOREACH(CZnodeConfig::CZnodeEntry mne, znodeConfig.getEntries()) {
+        int32_t nOutputIndex = 0;
+        if(!ParseInt32(mne.getOutputIndex(), &nOutputIndex)) {
+            continue;
+        }
+
+        updateMyZnodeInfo(QString::fromStdString(mne.getAlias()), QString::fromStdString(mne.getIp()), COutPoint(uint256S(mne.getTxHash()), nOutputIndex));
+    }
+    ui->tableWidgetZnodes->setSortingEnabled(true);
+
+    // reset "timer"
+    ui->secondsLabel->setText("0");
+}
+
+void ZnodeList::updateNodeList()
+{
+    TRY_LOCK(cs_mnlist, fLockAcquired);
+    if(!fLockAcquired) {
+        return;
+    }
+
+    static int64_t nTimeListUpdated = GetTime();
+
+    // to prevent high cpu usage update only once in MASTERNODELIST_UPDATE_SECONDS seconds
+    // or MASTERNODELIST_FILTER_COOLDOWN_SECONDS seconds after filter was last changed
+    int64_t nSecondsToWait = fFilterUpdated
+                            ? nTimeFilterUpdated - GetTime() + MASTERNODELIST_FILTER_COOLDOWN_SECONDS
+                            : nTimeListUpdated - GetTime() + MASTERNODELIST_UPDATE_SECONDS;
+
+    if(fFilterUpdated) ui->countLabel->setText(QString::fromStdString(strprintf("Please wait... %d", nSecondsToWait)));
+    if(nSecondsToWait > 0) return;
+
+    nTimeListUpdated = GetTime();
+    fFilterUpdated = false;
+
+    QString strToFilter;
+    ui->countLabel->setText("Updating...");
+    ui->tableWidgetZnodes->setSortingEnabled(false);
+    ui->tableWidgetZnodes->clearContents();
+    ui->tableWidgetZnodes->setRowCount(0);
+//    std::map<COutPoint, CZnode> mapZnodes = mnodeman.GetFullZnodeMap();
+    std::vector<CZnode> vZnodes = mnodeman.GetFullZnodeVector();
+    int offsetFromUtc = GetOffsetFromUtc();
+
+    BOOST_FOREACH(CZnode & mn, vZnodes)
+    {
+//        CZnode mn = mnpair.second;
+        // populate list
+        // Address, Protocol, Status, Active Seconds, Last Seen, Pub Key
+        QTableWidgetItem *addressItem = new QTableWidgetItem(QString::fromStdString(mn.addr.ToString()));
+        QTableWidgetItem *protocolItem = new QTableWidgetItem(QString::number(mn.nProtocolVersion));
+        QTableWidgetItem *statusItem = new QTableWidgetItem(QString::fromStdString(mn.GetStatus()));
+        QTableWidgetItem *activeSecondsItem = new QTableWidgetItem(QString::fromStdString(DurationToDHMS(mn.lastPing.sigTime - mn.sigTime)));
+        QTableWidgetItem *lastSeenItem = new QTableWidgetItem(QString::fromStdString(DateTimeStrFormat("%Y-%m-%d %H:%M", mn.lastPing.sigTime + offsetFromUtc)));
+        QTableWidgetItem *pubkeyItem = new QTableWidgetItem(QString::fromStdString(CBitcoinAddress(mn.pubKeyCollateralAddress.GetID()).ToString()));
+
+        if (strCurrentFilter != "")
+        {
+            strToFilter =   addressItem->text() + " " +
+                            protocolItem->text() + " " +
+                            statusItem->text() + " " +
+                            activeSecondsItem->text() + " " +
+                            lastSeenItem->text() + " " +
+                            pubkeyItem->text();
+            if (!strToFilter.contains(strCurrentFilter)) continue;
+        }
+
+        ui->tableWidgetZnodes->insertRow(0);
+        ui->tableWidgetZnodes->setItem(0, 0, addressItem);
+        ui->tableWidgetZnodes->setItem(0, 1, protocolItem);
+        ui->tableWidgetZnodes->setItem(0, 2, statusItem);
+        ui->tableWidgetZnodes->setItem(0, 3, activeSecondsItem);
+        ui->tableWidgetZnodes->setItem(0, 4, lastSeenItem);
+        ui->tableWidgetZnodes->setItem(0, 5, pubkeyItem);
+    }
+
+    ui->countLabel->setText(QString::number(ui->tableWidgetZnodes->rowCount()));
+    ui->tableWidgetZnodes->setSortingEnabled(true);
+}
+
+void ZnodeList::on_filterLineEdit_textChanged(const QString &strFilterIn)
+{
+    strCurrentFilter = strFilterIn;
+    nTimeFilterUpdated = GetTime();
+    fFilterUpdated = true;
+    ui->countLabel->setText(QString::fromStdString(strprintf("Please wait... %d", MASTERNODELIST_FILTER_COOLDOWN_SECONDS)));
+}
+
+void ZnodeList::on_startButton_clicked()
+{
+    std::string strAlias;
+    {
+        LOCK(cs_mymnlist);
+        // Find selected node alias
+        QItemSelectionModel* selectionModel = ui->tableWidgetMyZnodes->selectionModel();
+        QModelIndexList selected = selectionModel->selectedRows();
+
+        if(selected.count() == 0) return;
+
+        QModelIndex index = selected.at(0);
+        int nSelectedRow = index.row();
+        strAlias = ui->tableWidgetMyZnodes->item(nSelectedRow, 0)->text().toStdString();
+    }
+
+    // Display message box
+    QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm znode start"),
+        tr("Are you sure you want to start znode %1?").arg(QString::fromStdString(strAlias)),
+        QMessageBox::Yes | QMessageBox::Cancel,
+        QMessageBox::Cancel);
+
+    if(retval != QMessageBox::Yes) return;
+
+    WalletModel::EncryptionStatus encStatus = walletModel->getEncryptionStatus();
+
+    if(encStatus == walletModel->Locked || encStatus == walletModel->UnlockedForMixingOnly) {
+        WalletModel::UnlockContext ctx(walletModel->requestUnlock());
+
+        if(!ctx.isValid()) return; // Unlock wallet was cancelled
+
+        StartAlias(strAlias);
+        return;
+    }
+
+    StartAlias(strAlias);
+}
+
+void ZnodeList::on_startAllButton_clicked()
+{
+    // Display message box
+    QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm all znodes start"),
+        tr("Are you sure you want to start ALL znodes?"),
+        QMessageBox::Yes | QMessageBox::Cancel,
+        QMessageBox::Cancel);
+
+    if(retval != QMessageBox::Yes) return;
+
+    WalletModel::EncryptionStatus encStatus = walletModel->getEncryptionStatus();
+
+    if(encStatus == walletModel->Locked || encStatus == walletModel->UnlockedForMixingOnly) {
+        WalletModel::UnlockContext ctx(walletModel->requestUnlock());
+
+        if(!ctx.isValid()) return; // Unlock wallet was cancelled
+
+        StartAll();
+        return;
+    }
+
+    StartAll();
+}
+
+void ZnodeList::on_startMissingButton_clicked()
+{
+
+    if(!znodeSync.IsZnodeListSynced()) {
+        QMessageBox::critical(this, tr("Command is not available right now"),
+            tr("You can't use this command until znode list is synced"));
+        return;
+    }
+
+    // Display message box
+    QMessageBox::StandardButton retval = QMessageBox::question(this,
+        tr("Confirm missing znodes start"),
+        tr("Are you sure you want to start MISSING znodes?"),
+        QMessageBox::Yes | QMessageBox::Cancel,
+        QMessageBox::Cancel);
+
+    if(retval != QMessageBox::Yes) return;
+
+    WalletModel::EncryptionStatus encStatus = walletModel->getEncryptionStatus();
+
+    if(encStatus == walletModel->Locked || encStatus == walletModel->UnlockedForMixingOnly) {
+        WalletModel::UnlockContext ctx(walletModel->requestUnlock());
+
+        if(!ctx.isValid()) return; // Unlock wallet was cancelled
+
+        StartAll("start-missing");
+        return;
+    }
+
+    StartAll("start-missing");
+}
+
+void ZnodeList::on_tableWidgetMyZnodes_itemSelectionChanged()
+{
+    if(ui->tableWidgetMyZnodes->selectedItems().count() > 0) {
+        ui->startButton->setEnabled(true);
+    }
+}
+
+void ZnodeList::on_UpdateButton_clicked()
+{
+    updateMyNodeList(true);
+}
diff --git a/src/qt/znodelist.h b/src/qt/znodelist.h
new file mode 100644
index 0000000000..e8e49b0862
--- /dev/null
+++ b/src/qt/znodelist.h
@@ -0,0 +1,77 @@
+#ifndef MASTERNODELIST_H
+#define MASTERNODELIST_H
+
+#include "primitives/transaction.h"
+#include "platformstyle.h"
+#include "sync.h"
+#include "util.h"
+
+#include <QMenu>
+#include <QTimer>
+#include <QWidget>
+
+#define MY_MASTERNODELIST_UPDATE_SECONDS                 60
+#define MASTERNODELIST_UPDATE_SECONDS                    15
+#define MASTERNODELIST_FILTER_COOLDOWN_SECONDS            3
+
+namespace Ui {
+    class ZnodeList;
+}
+
+class ClientModel;
+class WalletModel;
+
+QT_BEGIN_NAMESPACE
+class QModelIndex;
+QT_END_NAMESPACE
+
+/** Znode Manager page widget */
+class ZnodeList : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit ZnodeList(const PlatformStyle *platformStyle, QWidget *parent = 0);
+    ~ZnodeList();
+
+    void setClientModel(ClientModel *clientModel);
+    void setWalletModel(WalletModel *walletModel);
+    void StartAlias(std::string strAlias);
+    void StartAll(std::string strCommand = "start-all");
+
+private:
+    QMenu *contextMenu;
+    int64_t nTimeFilterUpdated;
+    bool fFilterUpdated;
+
+public Q_SLOTS:
+    void updateMyZnodeInfo(QString strAlias, QString strAddr, const COutPoint& outpoint);
+    void updateMyNodeList(bool fForce = false);
+    void updateNodeList();
+
+Q_SIGNALS:
+
+private:
+    QTimer *timer;
+    Ui::ZnodeList *ui;
+    ClientModel *clientModel;
+    WalletModel *walletModel;
+
+    // Protects tableWidgetZnodes
+    CCriticalSection cs_mnlist;
+
+    // Protects tableWidgetMyZnodes
+    CCriticalSection cs_mymnlist;
+
+    QString strCurrentFilter;
+
+private Q_SLOTS:
+    void showContextMenu(const QPoint &);
+    void on_filterLineEdit_textChanged(const QString &strFilterIn);
+    void on_startButton_clicked();
+    void on_startAllButton_clicked();
+    void on_startMissingButton_clicked();
+    void on_tableWidgetMyZnodes_itemSelectionChanged();
+    void on_UpdateButton_clicked();
+};
+#endif // MASTERNODELIST_H
diff --git a/src/random.cpp b/src/random.cpp
index d9a8cc145e..9a9eb30e75 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -197,3 +197,21 @@ void seed_insecure_rand(bool fDeterministic)
         insecure_rand_Rw = tmp;
     }
 }
+
+InsecureRand::InsecureRand(bool _fDeterministic)
+        : nRz(11),
+          nRw(11),
+          fDeterministic(_fDeterministic)
+{
+    // The seed values have some unlikely fixed points which we avoid.
+    if(fDeterministic) return;
+    uint32_t nTmp;
+    do {
+        GetRandBytes((unsigned char*)&nTmp, 4);
+    } while (nTmp == 0 || nTmp == 0x9068ffffU);
+    nRz = nTmp;
+    do {
+        GetRandBytes((unsigned char*)&nTmp, 4);
+    } while (nTmp == 0 || nTmp == 0x464fffffU);
+    nRw = nTmp;
+}
diff --git a/src/random.h b/src/random.h
index 31b80bd565..671ee80e6d 100644
--- a/src/random.h
+++ b/src/random.h
@@ -49,4 +49,32 @@ static inline uint32_t insecure_rand(void)
     return (insecure_rand_Rw << 16) + insecure_rand_Rz;
 }
 
+/**
+ * PRNG initialized from secure entropy based RNG
+ */
+class InsecureRand
+{
+private:
+    uint32_t nRz;
+    uint32_t nRw;
+    bool fDeterministic;
+
+public:
+    InsecureRand(bool _fDeterministic = false);
+
+    /**
+     * MWC RNG of George Marsaglia
+     * This is intended to be fast. It has a period of 2^59.3, though the
+     * least significant 16 bits only have a period of about 2^30.1.
+     *
+     * @return random value < nMax
+     */
+    int64_t operator()(int64_t nMax)
+    {
+        nRz = 36969 * (nRz & 65535) + (nRz >> 16);
+        nRw = 18000 * (nRw & 65535) + (nRw >> 16);
+        return ((nRw << 16) + nRz) % nMax;
+    }
+};
+
 #endif // BITCOIN_RANDOM_H
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 786c186a74..7084d9769d 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -113,6 +113,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "setmintzerocoinstatus", 2 },
     { "setmintzerocoinstatus", 1 },
     { "listmintzerocoins", 0 },
+    { "listpubcoins", 0 },
 };
 
 class CRPCConvertTable
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 3441248fc0..5eb9272086 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -19,6 +19,9 @@
 #include "rpc/server.h"
 #include "txmempool.h"
 #include "util.h"
+#ifdef ENABLE_WALLET
+#include "znode-sync.h"
+#endif
 #include "utilstrencodings.h"
 #include "validationinterface.h"
 
@@ -457,6 +460,13 @@ UniValue getblocktemplate(const UniValue& params, bool fHelp)
             "  \"curtime\" : ttt,                  (numeric) current timestamp in seconds since epoch (Jan 1 1970 GMT)\n"
             "  \"bits\" : \"xxxxxxxx\",              (string) compressed target of next block\n"
             "  \"height\" : n                      (numeric) The height of the next block\n"
+            "  \"znode\" : {                  (json object) required znode payee that must be included in the next block\n"
+            "      \"payee\" : \"xxxx\",             (string) payee address\n"
+            "      \"script\" : \"xxxx\",            (string) payee scriptPubKey\n"
+            "      \"amount\": n                   (numeric) required amount to pay\n"
+            "  },\n"
+            "  \"znode_payments_started\" :  true|false, (boolean) true, if znode payments started\n"
+//            "  \"znode_payments_enforced\" : true|false, (boolean) true, if znode payments are enforced\n"
             "}\n"
 
             "\nExamples:\n"
@@ -536,6 +546,10 @@ UniValue getblocktemplate(const UniValue& params, bool fHelp)
         throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Zcoin is not connected!");
     if (IsInitialBlockDownload())
         throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Zcoin is downloading blocks...");
+
+    if (!znodeSync.IsSynced())
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Zcoin Core is syncing with network...");
+
     static unsigned int nTransactionsUpdatedLast;
     if (!lpval.isNull())
     {
@@ -634,6 +648,7 @@ UniValue getblocktemplate(const UniValue& params, bool fHelp)
     if(chainActive.Height() + 1 > SWITCH_TO_MORE_SPEND_TXS){
         MAX_SPEND_ZC_TX_PER_BLOCK = 1;
     }
+
     BOOST_FOREACH (CTransaction& tx, pblock->vtx) {
         uint256 txHash = tx.GetHash();
         setTxIndex[txHash] = i++;
@@ -768,6 +783,19 @@ UniValue getblocktemplate(const UniValue& params, bool fHelp)
     result.push_back(Pair("bits", strprintf("%08x", pblock->nBits)));
     result.push_back(Pair("height", (int64_t)(pindexPrev->nHeight+1)));
 
+    UniValue znodeObj(UniValue::VOBJ);
+    if(pblock->txoutZnode != CTxOut()) {
+        CTxDestination address1;
+        ExtractDestination(pblock->txoutZnode.scriptPubKey, address1);
+        CBitcoinAddress address2(address1);
+        znodeObj.push_back(Pair("payee", address2.ToString().c_str()));
+        znodeObj.push_back(Pair("script", HexStr(pblock->txoutZnode.scriptPubKey.begin(), pblock->txoutZnode.scriptPubKey.end())));
+        znodeObj.push_back(Pair("amount", pblock->txoutZnode.nValue));
+    }
+    result.push_back(Pair("znode", znodeObj));
+    result.push_back(Pair("znode_payments_started", pindexPrev->nHeight + 1 > Params().GetConsensus().nZnodePaymentsStartBlock));
+//    result.push_back(Pair("znode_payments_enforced", sporkManager.IsSporkActive(SPORK_8_MASTERNODE_PAYMENT_ENFORCEMENT)));
+
     const struct BIP9DeploymentInfo& segwit_info = VersionBitsDeploymentInfo[Consensus::DEPLOYMENT_SEGWIT];
     if (!pblocktemplate->vchCoinbaseCommitment.empty() && setClientRules.find(segwit_info.name) != setClientRules.end()) {
         result.push_back(Pair("default_witness_commitment", HexStr(pblocktemplate->vchCoinbaseCommitment.begin(), pblocktemplate->vchCoinbaseCommitment.end())));
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 9a902522a9..4bb4a9b398 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -14,6 +14,7 @@
 #include "util.h"
 #include "utilstrencodings.h"
 #ifdef ENABLE_WALLET
+#include "znode-sync.h"
 #include "wallet/wallet.h"
 #include "wallet/walletdb.h"
 #endif
@@ -278,6 +279,44 @@ CScript _createmultisig_redeemScript(const UniValue& params)
     return result;
 }
 
+UniValue znsync(const UniValue& params, bool fHelp)
+{
+    if (fHelp || params.size() != 1)
+        throw runtime_error(
+                "znsync [status|next|reset]\n"
+                        "Returns the sync status, updates to the next step or resets it entirely.\n"
+        );
+
+    std::string strMode = params[0].get_str();
+
+    if(strMode == "status") {
+        UniValue objStatus(UniValue::VOBJ);
+        objStatus.push_back(Pair("AssetID", znodeSync.GetAssetID()));
+        objStatus.push_back(Pair("AssetName", znodeSync.GetAssetName()));
+        objStatus.push_back(Pair("Attempt", znodeSync.GetAttempt()));
+        objStatus.push_back(Pair("IsBlockchainSynced", znodeSync.IsBlockchainSynced()));
+        objStatus.push_back(Pair("IsZnodeListSynced", znodeSync.IsZnodeListSynced()));
+        objStatus.push_back(Pair("IsWinnersListSynced", znodeSync.IsWinnersListSynced()));
+        objStatus.push_back(Pair("IsSynced", znodeSync.IsSynced()));
+        objStatus.push_back(Pair("IsFailed", znodeSync.IsFailed()));
+        return objStatus;
+    }
+
+    if(strMode == "next")
+    {
+        znodeSync.SwitchToNextAsset();
+        return "sync updated to " + znodeSync.GetAssetName();
+    }
+
+    if(strMode == "reset")
+    {
+        znodeSync.Reset();
+        return "success";
+    }
+    return "failure";
+}
+
+
 UniValue createmultisig(const UniValue& params, bool fHelp)
 {
     if (fHelp || params.size() < 2 || params.size() > 2)
diff --git a/src/rpc/rpcznode.cpp b/src/rpc/rpcznode.cpp
new file mode 100644
index 0000000000..b40f8f0fe5
--- /dev/null
+++ b/src/rpc/rpcznode.cpp
@@ -0,0 +1,804 @@
+#include "activeznode.h"
+#include "darksend.h"
+#include "init.h"
+#include "main.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeconfig.h"
+#include "znodeman.h"
+#include "rpc/server.h"
+#include "util.h"
+#include "utilmoneystr.h"
+#include "net.h"
+
+#include <fstream>
+#include <iomanip>
+#include <univalue.h>
+
+void EnsureWalletIsUnlocked();
+
+UniValue privatesend(const UniValue &params, bool fHelp) {
+    if (fHelp || params.size() != 1)
+        throw std::runtime_error(
+                "privatesend \"command\"\n"
+                        "\nArguments:\n"
+                        "1. \"command\"        (string or set of strings, required) The command to execute\n"
+                        "\nAvailable commands:\n"
+                        "  start       - Start mixing\n"
+                        "  stop        - Stop mixing\n"
+                        "  reset       - Reset mixing\n"
+        );
+
+    if (params[0].get_str() == "start") {
+        {
+            LOCK(pwalletMain->cs_wallet);
+            EnsureWalletIsUnlocked();
+        }
+
+        if (fZNode)
+            return "Mixing is not supported from znodes";
+
+        fEnablePrivateSend = true;
+        bool result = darkSendPool.DoAutomaticDenominating();
+        return "Mixing " +
+               (result ? "started successfully" : ("start failed: " + darkSendPool.GetStatus() + ", will retry"));
+    }
+
+    if (params[0].get_str() == "stop") {
+        fEnablePrivateSend = false;
+        return "Mixing was stopped";
+    }
+
+    if (params[0].get_str() == "reset") {
+        darkSendPool.ResetPool();
+        return "Mixing was reset";
+    }
+
+    return "Unknown command, please see \"help privatesend\"";
+}
+
+UniValue getpoolinfo(const UniValue &params, bool fHelp) {
+    if (fHelp || params.size() != 0)
+        throw std::runtime_error(
+                "getpoolinfo\n"
+                        "Returns an object containing mixing pool related information.\n");
+
+    UniValue obj(UniValue::VOBJ);
+    obj.push_back(Pair("state", darkSendPool.GetStateString()));
+//    obj.push_back(Pair("mixing_mode",       fPrivateSendMultiSession ? "multi-session" : "normal"));
+    obj.push_back(Pair("queue", darkSendPool.GetQueueSize()));
+    obj.push_back(Pair("entries", darkSendPool.GetEntriesCount()));
+    obj.push_back(Pair("status", darkSendPool.GetStatus()));
+
+    if (darkSendPool.pSubmittedToZnode) {
+        obj.push_back(Pair("outpoint", darkSendPool.pSubmittedToZnode->vin.prevout.ToStringShort()));
+        obj.push_back(Pair("addr", darkSendPool.pSubmittedToZnode->addr.ToString()));
+    }
+
+    if (pwalletMain) {
+        obj.push_back(Pair("keys_left", pwalletMain->nKeysLeftSinceAutoBackup));
+        obj.push_back(Pair("warnings", pwalletMain->nKeysLeftSinceAutoBackup < PRIVATESEND_KEYS_THRESHOLD_WARNING
+                                       ? "WARNING: keypool is almost depleted!" : ""));
+    }
+
+    return obj;
+}
+
+
+UniValue znode(const UniValue &params, bool fHelp) {
+    std::string strCommand;
+    if (params.size() >= 1) {
+        strCommand = params[0].get_str();
+    }
+
+    if (strCommand == "start-many")
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "DEPRECATED, please use start-all instead");
+
+    if (fHelp ||
+        (strCommand != "start" && strCommand != "start-alias" && strCommand != "start-all" &&
+         strCommand != "start-missing" &&
+         strCommand != "start-disabled" && strCommand != "list" && strCommand != "list-conf" && strCommand != "count" &&
+         strCommand != "debug" && strCommand != "current" && strCommand != "winner" && strCommand != "winners" &&
+         strCommand != "genkey" &&
+         strCommand != "connect" && strCommand != "outputs" && strCommand != "status"))
+        throw std::runtime_error(
+                "znode \"command\"...\n"
+                        "Set of commands to execute znode related actions\n"
+                        "\nArguments:\n"
+                        "1. \"command\"        (string or set of strings, required) The command to execute\n"
+                        "\nAvailable commands:\n"
+                        "  count        - Print number of all known znodes (optional: 'ps', 'enabled', 'all', 'qualify')\n"
+                        "  current      - Print info on current znode winner to be paid the next block (calculated locally)\n"
+                        "  debug        - Print znode status\n"
+                        "  genkey       - Generate new znodeprivkey\n"
+                        "  outputs      - Print znode compatible outputs\n"
+                        "  start        - Start local Hot znode configured in dash.conf\n"
+                        "  start-alias  - Start single remote znode by assigned alias configured in znode.conf\n"
+                        "  start-<mode> - Start remote znodes configured in znode.conf (<mode>: 'all', 'missing', 'disabled')\n"
+                        "  status       - Print znode status information\n"
+                        "  list         - Print list of all known znodes (see znodelist for more info)\n"
+                        "  list-conf    - Print znode.conf in JSON format\n"
+                        "  winner       - Print info on next znode winner to vote for\n"
+                        "  winners      - Print list of znode winners\n"
+        );
+
+    if (strCommand == "list") {
+        UniValue newParams(UniValue::VARR);
+        // forward params but skip "list"
+        for (unsigned int i = 1; i < params.size(); i++) {
+            newParams.push_back(params[i]);
+        }
+        return znodelist(newParams, fHelp);
+    }
+
+    if (strCommand == "connect") {
+        if (params.size() < 2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Znode address required");
+
+        std::string strAddress = params[1].get_str();
+
+        CService addr = CService(strAddress);
+
+        CNode *pnode = ConnectNode(CAddress(addr, NODE_NETWORK), NULL);
+        if (!pnode)
+            throw JSONRPCError(RPC_INTERNAL_ERROR, strprintf("Couldn't connect to znode %s", strAddress));
+
+        return "successfully connected";
+    }
+
+    if (strCommand == "count") {
+        if (params.size() > 2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Too many parameters");
+
+        if (params.size() == 1)
+            return mnodeman.size();
+
+        std::string strMode = params[1].get_str();
+
+        if (strMode == "ps")
+            return mnodeman.CountEnabled(MIN_PRIVATESEND_PEER_PROTO_VERSION);
+
+        if (strMode == "enabled")
+            return mnodeman.CountEnabled();
+
+        int nCount;
+        mnodeman.GetNextZnodeInQueueForPayment(true, nCount);
+
+        if (strMode == "qualify")
+            return nCount;
+
+        if (strMode == "all")
+            return strprintf("Total: %d (PS Compatible: %d / Enabled: %d / Qualify: %d)",
+                             mnodeman.size(), mnodeman.CountEnabled(MIN_PRIVATESEND_PEER_PROTO_VERSION),
+                             mnodeman.CountEnabled(), nCount);
+    }
+
+    if (strCommand == "current" || strCommand == "winner") {
+        int nCount;
+        int nHeight;
+        CZnode *winner = NULL;
+        {
+            LOCK(cs_main);
+            nHeight = chainActive.Height() + (strCommand == "current" ? 1 : 10);
+        }
+        mnodeman.UpdateLastPaid();
+        winner = mnodeman.GetNextZnodeInQueueForPayment(nHeight, true, nCount);
+        if (!winner) return "unknown";
+
+        UniValue obj(UniValue::VOBJ);
+
+        obj.push_back(Pair("height", nHeight));
+        obj.push_back(Pair("IP:port", winner->addr.ToString()));
+        obj.push_back(Pair("protocol", (int64_t) winner->nProtocolVersion));
+        obj.push_back(Pair("vin", winner->vin.prevout.ToStringShort()));
+        obj.push_back(Pair("payee", CBitcoinAddress(winner->pubKeyCollateralAddress.GetID()).ToString()));
+        obj.push_back(Pair("lastseen", (winner->lastPing == CZnodePing()) ? winner->sigTime :
+                                       winner->lastPing.sigTime));
+        obj.push_back(Pair("activeseconds", (winner->lastPing == CZnodePing()) ? 0 :
+                                            (winner->lastPing.sigTime - winner->sigTime)));
+        obj.push_back(Pair("nBlockLastPaid", winner->nBlockLastPaid));
+        return obj;
+    }
+
+    if (strCommand == "debug") {
+        if (activeZnode.nState != ACTIVE_ZNODE_INITIAL || !znodeSync.IsBlockchainSynced())
+            return activeZnode.GetStatus();
+
+        CTxIn vin;
+        CPubKey pubkey;
+        CKey key;
+
+        if (!pwalletMain || !pwalletMain->GetZnodeVinAndKeys(vin, pubkey, key))
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               "Missing znode input, please look at the documentation for instructions on znode creation");
+
+        return activeZnode.GetStatus();
+    }
+
+    if (strCommand == "start") {
+        if (!fZNode)
+            throw JSONRPCError(RPC_INTERNAL_ERROR, "You must set znode=1 in the configuration");
+
+        {
+            LOCK(pwalletMain->cs_wallet);
+            EnsureWalletIsUnlocked();
+        }
+
+        if (activeZnode.nState != ACTIVE_ZNODE_STARTED) {
+            activeZnode.nState = ACTIVE_ZNODE_INITIAL; // TODO: consider better way
+            activeZnode.ManageState();
+        }
+
+        return activeZnode.GetStatus();
+    }
+
+    if (strCommand == "start-alias") {
+        if (params.size() < 2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Please specify an alias");
+
+        {
+            LOCK(pwalletMain->cs_wallet);
+            EnsureWalletIsUnlocked();
+        }
+
+        std::string strAlias = params[1].get_str();
+
+        bool fFound = false;
+
+        UniValue statusObj(UniValue::VOBJ);
+        statusObj.push_back(Pair("alias", strAlias));
+
+        BOOST_FOREACH(CZnodeConfig::CZnodeEntry mne, znodeConfig.getEntries()) {
+            if (mne.getAlias() == strAlias) {
+                fFound = true;
+                std::string strError;
+                CZnodeBroadcast mnb;
+
+                bool fResult = CZnodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(),
+                                                            mne.getOutputIndex(), strError, mnb);
+                statusObj.push_back(Pair("result", fResult ? "successful" : "failed"));
+                if (fResult) {
+                    mnodeman.UpdateZnodeList(mnb);
+                    mnb.RelayZNode();
+                } else {
+                    LogPrintf("Start-alias: errorMessage = %s\n", strError);
+                    statusObj.push_back(Pair("errorMessage", strError));
+                }
+                mnodeman.NotifyZnodeUpdates();
+                break;
+            }
+        }
+
+        if (!fFound) {
+            statusObj.push_back(Pair("result", "failed"));
+            statusObj.push_back(Pair("errorMessage", "Could not find alias in config. Verify with list-conf."));
+        }
+
+//        LogPrintf("start-alias: statusObj=%s\n", statusObj);
+
+        return statusObj;
+
+    }
+
+    if (strCommand == "start-all" || strCommand == "start-missing" || strCommand == "start-disabled") {
+        {
+            LOCK(pwalletMain->cs_wallet);
+            EnsureWalletIsUnlocked();
+        }
+
+        if ((strCommand == "start-missing" || strCommand == "start-disabled") &&
+            !znodeSync.IsZnodeListSynced()) {
+            throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                               "You can't use this command until znode list is synced");
+        }
+
+        int nSuccessful = 0;
+        int nFailed = 0;
+
+        UniValue resultsObj(UniValue::VOBJ);
+
+        BOOST_FOREACH(CZnodeConfig::CZnodeEntry mne, znodeConfig.getEntries()) {
+            std::string strError;
+
+            CTxIn vin = CTxIn(uint256S(mne.getTxHash()), uint32_t(atoi(mne.getOutputIndex().c_str())));
+            CZnode *pmn = mnodeman.Find(vin);
+            CZnodeBroadcast mnb;
+
+            if (strCommand == "start-missing" && pmn) continue;
+            if (strCommand == "start-disabled" && pmn && pmn->IsEnabled()) continue;
+
+            bool fResult = CZnodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(),
+                                                        mne.getOutputIndex(), strError, mnb);
+
+            UniValue statusObj(UniValue::VOBJ);
+            statusObj.push_back(Pair("alias", mne.getAlias()));
+            statusObj.push_back(Pair("result", fResult ? "successful" : "failed"));
+
+            if (fResult) {
+                nSuccessful++;
+                mnodeman.UpdateZnodeList(mnb);
+                mnb.RelayZNode();
+            } else {
+                nFailed++;
+                statusObj.push_back(Pair("errorMessage", strError));
+            }
+
+            resultsObj.push_back(Pair("status", statusObj));
+        }
+        mnodeman.NotifyZnodeUpdates();
+
+        UniValue returnObj(UniValue::VOBJ);
+        returnObj.push_back(Pair("overall",
+                                 strprintf("Successfully started %d znodes, failed to start %d, total %d",
+                                           nSuccessful, nFailed, nSuccessful + nFailed)));
+        returnObj.push_back(Pair("detail", resultsObj));
+
+        return returnObj;
+    }
+
+    if (strCommand == "genkey") {
+        CKey secret;
+        secret.MakeNewKey(false);
+
+        return CBitcoinSecret(secret).ToString();
+    }
+
+    if (strCommand == "list-conf") {
+        UniValue resultObj(UniValue::VOBJ);
+
+        BOOST_FOREACH(CZnodeConfig::CZnodeEntry mne, znodeConfig.getEntries()) {
+            CTxIn vin = CTxIn(uint256S(mne.getTxHash()), uint32_t(atoi(mne.getOutputIndex().c_str())));
+            CZnode *pmn = mnodeman.Find(vin);
+
+            std::string strStatus = pmn ? pmn->GetStatus() : "MISSING";
+
+            UniValue mnObj(UniValue::VOBJ);
+            mnObj.push_back(Pair("alias", mne.getAlias()));
+            mnObj.push_back(Pair("address", mne.getIp()));
+            mnObj.push_back(Pair("privateKey", mne.getPrivKey()));
+            mnObj.push_back(Pair("txHash", mne.getTxHash()));
+            mnObj.push_back(Pair("outputIndex", mne.getOutputIndex()));
+            mnObj.push_back(Pair("status", strStatus));
+            resultObj.push_back(Pair("znode", mnObj));
+        }
+
+        return resultObj;
+    }
+
+    if (strCommand == "outputs") {
+        // Find possible candidates
+        std::vector <COutput> vPossibleCoins;
+        pwalletMain->AvailableCoins(vPossibleCoins, true, NULL, false, ONLY_1000);
+
+        UniValue obj(UniValue::VOBJ);
+        BOOST_FOREACH(COutput & out, vPossibleCoins)
+        {
+            obj.push_back(Pair(out.tx->GetHash().ToString(), strprintf("%d", out.i)));
+        }
+
+        return obj;
+
+    }
+
+    if (strCommand == "status") {
+        if (!fZNode)
+            throw JSONRPCError(RPC_INTERNAL_ERROR, "This is not a znode");
+
+        UniValue mnObj(UniValue::VOBJ);
+
+        mnObj.push_back(Pair("vin", activeZnode.vin.ToString()));
+        mnObj.push_back(Pair("service", activeZnode.service.ToString()));
+
+        CZnode mn;
+        if (mnodeman.Get(activeZnode.vin, mn)) {
+            mnObj.push_back(Pair("payee", CBitcoinAddress(mn.pubKeyCollateralAddress.GetID()).ToString()));
+        }
+
+        mnObj.push_back(Pair("status", activeZnode.GetStatus()));
+        return mnObj;
+    }
+
+    if (strCommand == "winners") {
+        int nHeight;
+        {
+            LOCK(cs_main);
+            CBlockIndex *pindex = chainActive.Tip();
+            if (!pindex) return NullUniValue;
+
+            nHeight = pindex->nHeight;
+        }
+
+        int nLast = 10;
+        std::string strFilter = "";
+
+        if (params.size() >= 2) {
+            nLast = atoi(params[1].get_str());
+        }
+
+        if (params.size() == 3) {
+            strFilter = params[2].get_str();
+        }
+
+        if (params.size() > 3)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Correct usage is 'znode winners ( \"count\" \"filter\" )'");
+
+        UniValue obj(UniValue::VOBJ);
+
+        for (int i = nHeight - nLast; i < nHeight + 20; i++) {
+            std::string strPayment = GetRequiredPaymentsString(i);
+            if (strFilter != "" && strPayment.find(strFilter) == std::string::npos) continue;
+            obj.push_back(Pair(strprintf("%d", i), strPayment));
+        }
+
+        return obj;
+    }
+
+    return NullUniValue;
+}
+
+UniValue znodelist(const UniValue &params, bool fHelp) {
+    std::string strMode = "status";
+    std::string strFilter = "";
+
+    if (params.size() >= 1) strMode = params[0].get_str();
+    if (params.size() == 2) strFilter = params[1].get_str();
+
+    if (fHelp || (
+            strMode != "activeseconds" && strMode != "addr" && strMode != "full" &&
+            strMode != "lastseen" && strMode != "lastpaidtime" && strMode != "lastpaidblock" &&
+            strMode != "protocol" && strMode != "payee" && strMode != "rank" && strMode != "status")) {
+        throw std::runtime_error(
+                "znodelist ( \"mode\" \"filter\" )\n"
+                        "Get a list of znodes in different modes\n"
+                        "\nArguments:\n"
+                        "1. \"mode\"      (string, optional/required to use filter, defaults = status) The mode to run list in\n"
+                        "2. \"filter\"    (string, optional) Filter results. Partial match by outpoint by default in all modes,\n"
+                        "                                    additional matches in some modes are also available\n"
+                        "\nAvailable modes:\n"
+                        "  activeseconds  - Print number of seconds znode recognized by the network as enabled\n"
+                        "                   (since latest issued \"znode start/start-many/start-alias\")\n"
+                        "  addr           - Print ip address associated with a znode (can be additionally filtered, partial match)\n"
+                        "  full           - Print info in format 'status protocol payee lastseen activeseconds lastpaidtime lastpaidblock IP'\n"
+                        "                   (can be additionally filtered, partial match)\n"
+                        "  lastpaidblock  - Print the last block height a node was paid on the network\n"
+                        "  lastpaidtime   - Print the last time a node was paid on the network\n"
+                        "  lastseen       - Print timestamp of when a znode was last seen on the network\n"
+                        "  payee          - Print Dash address associated with a znode (can be additionally filtered,\n"
+                        "                   partial match)\n"
+                        "  protocol       - Print protocol of a znode (can be additionally filtered, exact match))\n"
+                        "  rank           - Print rank of a znode based on current block\n"
+                        "  status         - Print znode status: PRE_ENABLED / ENABLED / EXPIRED / WATCHDOG_EXPIRED / NEW_START_REQUIRED /\n"
+                        "                   UPDATE_REQUIRED / POSE_BAN / OUTPOINT_SPENT (can be additionally filtered, partial match)\n"
+        );
+    }
+
+    if (strMode == "full" || strMode == "lastpaidtime" || strMode == "lastpaidblock") {
+        mnodeman.UpdateLastPaid();
+    }
+
+    UniValue obj(UniValue::VOBJ);
+    if (strMode == "rank") {
+        std::vector <std::pair<int, CZnode>> vZnodeRanks = mnodeman.GetZnodeRanks();
+        BOOST_FOREACH(PAIRTYPE(int, CZnode) & s, vZnodeRanks)
+        {
+            std::string strOutpoint = s.second.vin.prevout.ToStringShort();
+            if (strFilter != "" && strOutpoint.find(strFilter) == std::string::npos) continue;
+            obj.push_back(Pair(strOutpoint, s.first));
+        }
+    } else {
+        std::vector <CZnode> vZnodes = mnodeman.GetFullZnodeVector();
+        BOOST_FOREACH(CZnode & mn, vZnodes)
+        {
+            std::string strOutpoint = mn.vin.prevout.ToStringShort();
+            if (strMode == "activeseconds") {
+                if (strFilter != "" && strOutpoint.find(strFilter) == std::string::npos) continue;
+                obj.push_back(Pair(strOutpoint, (int64_t)(mn.lastPing.sigTime - mn.sigTime)));
+            } else if (strMode == "addr") {
+                std::string strAddress = mn.addr.ToString();
+                if (strFilter != "" && strAddress.find(strFilter) == std::string::npos &&
+                    strOutpoint.find(strFilter) == std::string::npos)
+                    continue;
+                obj.push_back(Pair(strOutpoint, strAddress));
+            } else if (strMode == "full") {
+                std::ostringstream streamFull;
+                streamFull << std::setw(18) <<
+                           mn.GetStatus() << " " <<
+                           mn.nProtocolVersion << " " <<
+                           CBitcoinAddress(mn.pubKeyCollateralAddress.GetID()).ToString() << " " <<
+                           (int64_t) mn.lastPing.sigTime << " " << std::setw(8) <<
+                           (int64_t)(mn.lastPing.sigTime - mn.sigTime) << " " << std::setw(10) <<
+                           mn.GetLastPaidTime() << " " << std::setw(6) <<
+                           mn.GetLastPaidBlock() << " " <<
+                           mn.addr.ToString();
+                std::string strFull = streamFull.str();
+                if (strFilter != "" && strFull.find(strFilter) == std::string::npos &&
+                    strOutpoint.find(strFilter) == std::string::npos)
+                    continue;
+                obj.push_back(Pair(strOutpoint, strFull));
+            } else if (strMode == "lastpaidblock") {
+                if (strFilter != "" && strOutpoint.find(strFilter) == std::string::npos) continue;
+                obj.push_back(Pair(strOutpoint, mn.GetLastPaidBlock()));
+            } else if (strMode == "lastpaidtime") {
+                if (strFilter != "" && strOutpoint.find(strFilter) == std::string::npos) continue;
+                obj.push_back(Pair(strOutpoint, mn.GetLastPaidTime()));
+            } else if (strMode == "lastseen") {
+                if (strFilter != "" && strOutpoint.find(strFilter) == std::string::npos) continue;
+                obj.push_back(Pair(strOutpoint, (int64_t) mn.lastPing.sigTime));
+            } else if (strMode == "payee") {
+                CBitcoinAddress address(mn.pubKeyCollateralAddress.GetID());
+                std::string strPayee = address.ToString();
+                if (strFilter != "" && strPayee.find(strFilter) == std::string::npos &&
+                    strOutpoint.find(strFilter) == std::string::npos)
+                    continue;
+                obj.push_back(Pair(strOutpoint, strPayee));
+            } else if (strMode == "protocol") {
+                if (strFilter != "" && strFilter != strprintf("%d", mn.nProtocolVersion) &&
+                    strOutpoint.find(strFilter) == std::string::npos)
+                    continue;
+                obj.push_back(Pair(strOutpoint, (int64_t) mn.nProtocolVersion));
+            } else if (strMode == "status") {
+                std::string strStatus = mn.GetStatus();
+                if (strFilter != "" && strStatus.find(strFilter) == std::string::npos &&
+                    strOutpoint.find(strFilter) == std::string::npos)
+                    continue;
+                obj.push_back(Pair(strOutpoint, strStatus));
+            }
+        }
+    }
+    return obj;
+}
+
+bool DecodeHexVecMnb(std::vector <CZnodeBroadcast> &vecMnb, std::string strHexMnb) {
+
+    if (!IsHex(strHexMnb))
+        return false;
+
+    std::vector<unsigned char> mnbData(ParseHex(strHexMnb));
+    CDataStream ssData(mnbData, SER_NETWORK, PROTOCOL_VERSION);
+    try {
+        ssData >> vecMnb;
+    }
+    catch (const std::exception &) {
+        return false;
+    }
+
+    return true;
+}
+
+UniValue znodebroadcast(const UniValue &params, bool fHelp) {
+    std::string strCommand;
+    if (params.size() >= 1)
+        strCommand = params[0].get_str();
+
+    if (fHelp ||
+        (strCommand != "create-alias" && strCommand != "create-all" && strCommand != "decode" && strCommand != "relay"))
+        throw std::runtime_error(
+                "znodebroadcast \"command\"...\n"
+                        "Set of commands to create and relay znode broadcast messages\n"
+                        "\nArguments:\n"
+                        "1. \"command\"        (string or set of strings, required) The command to execute\n"
+                        "\nAvailable commands:\n"
+                        "  create-alias  - Create single remote znode broadcast message by assigned alias configured in znode.conf\n"
+                        "  create-all    - Create remote znode broadcast messages for all znodes configured in znode.conf\n"
+                        "  decode        - Decode znode broadcast message\n"
+                        "  relay         - Relay znode broadcast message to the network\n"
+        );
+
+    if (strCommand == "create-alias") {
+        // wait for reindex and/or import to finish
+        if (fImporting || fReindex)
+            throw JSONRPCError(RPC_INTERNAL_ERROR, "Wait for reindex and/or import to finish");
+
+        if (params.size() < 2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Please specify an alias");
+
+        {
+            LOCK(pwalletMain->cs_wallet);
+            EnsureWalletIsUnlocked();
+        }
+
+        bool fFound = false;
+        std::string strAlias = params[1].get_str();
+
+        UniValue statusObj(UniValue::VOBJ);
+        std::vector <CZnodeBroadcast> vecMnb;
+
+        statusObj.push_back(Pair("alias", strAlias));
+
+        BOOST_FOREACH(CZnodeConfig::CZnodeEntry
+        mne, znodeConfig.getEntries()) {
+            if (mne.getAlias() == strAlias) {
+                fFound = true;
+                std::string strError;
+                CZnodeBroadcast mnb;
+
+                bool fResult = CZnodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(),
+                                                            mne.getOutputIndex(), strError, mnb, true);
+
+                statusObj.push_back(Pair("result", fResult ? "successful" : "failed"));
+                if (fResult) {
+                    vecMnb.push_back(mnb);
+                    CDataStream ssVecMnb(SER_NETWORK, PROTOCOL_VERSION);
+                    ssVecMnb << vecMnb;
+                    statusObj.push_back(Pair("hex", HexStr(ssVecMnb.begin(), ssVecMnb.end())));
+                } else {
+                    statusObj.push_back(Pair("errorMessage", strError));
+                }
+                break;
+            }
+        }
+
+        if (!fFound) {
+            statusObj.push_back(Pair("result", "not found"));
+            statusObj.push_back(Pair("errorMessage", "Could not find alias in config. Verify with list-conf."));
+        }
+
+        return statusObj;
+
+    }
+
+    if (strCommand == "create-all") {
+        // wait for reindex and/or import to finish
+        if (fImporting || fReindex)
+            throw JSONRPCError(RPC_INTERNAL_ERROR, "Wait for reindex and/or import to finish");
+
+        {
+            LOCK(pwalletMain->cs_wallet);
+            EnsureWalletIsUnlocked();
+        }
+
+        std::vector <CZnodeConfig::CZnodeEntry> mnEntries;
+        mnEntries = znodeConfig.getEntries();
+
+        int nSuccessful = 0;
+        int nFailed = 0;
+
+        UniValue resultsObj(UniValue::VOBJ);
+        std::vector <CZnodeBroadcast> vecMnb;
+
+        BOOST_FOREACH(CZnodeConfig::CZnodeEntry
+        mne, znodeConfig.getEntries()) {
+            std::string strError;
+            CZnodeBroadcast mnb;
+
+            bool fResult = CZnodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(),
+                                                        mne.getOutputIndex(), strError, mnb, true);
+
+            UniValue statusObj(UniValue::VOBJ);
+            statusObj.push_back(Pair("alias", mne.getAlias()));
+            statusObj.push_back(Pair("result", fResult ? "successful" : "failed"));
+
+            if (fResult) {
+                nSuccessful++;
+                vecMnb.push_back(mnb);
+            } else {
+                nFailed++;
+                statusObj.push_back(Pair("errorMessage", strError));
+            }
+
+            resultsObj.push_back(Pair("status", statusObj));
+        }
+
+        CDataStream ssVecMnb(SER_NETWORK, PROTOCOL_VERSION);
+        ssVecMnb << vecMnb;
+        UniValue returnObj(UniValue::VOBJ);
+        returnObj.push_back(Pair("overall", strprintf(
+                "Successfully created broadcast messages for %d znodes, failed to create %d, total %d",
+                nSuccessful, nFailed, nSuccessful + nFailed)));
+        returnObj.push_back(Pair("detail", resultsObj));
+        returnObj.push_back(Pair("hex", HexStr(ssVecMnb.begin(), ssVecMnb.end())));
+
+        return returnObj;
+    }
+
+    if (strCommand == "decode") {
+        if (params.size() != 2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Correct usage is 'znodebroadcast decode \"hexstring\"'");
+
+        std::vector <CZnodeBroadcast> vecMnb;
+
+        if (!DecodeHexVecMnb(vecMnb, params[1].get_str()))
+            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Znode broadcast message decode failed");
+
+        int nSuccessful = 0;
+        int nFailed = 0;
+        int nDos = 0;
+        UniValue returnObj(UniValue::VOBJ);
+
+        BOOST_FOREACH(CZnodeBroadcast & mnb, vecMnb)
+        {
+            UniValue resultObj(UniValue::VOBJ);
+
+            if (mnb.CheckSignature(nDos)) {
+                nSuccessful++;
+                resultObj.push_back(Pair("vin", mnb.vin.ToString()));
+                resultObj.push_back(Pair("addr", mnb.addr.ToString()));
+                resultObj.push_back(Pair("pubKeyCollateralAddress",
+                                         CBitcoinAddress(mnb.pubKeyCollateralAddress.GetID()).ToString()));
+                resultObj.push_back(Pair("pubKeyZnode", CBitcoinAddress(mnb.pubKeyZnode.GetID()).ToString()));
+                resultObj.push_back(Pair("vchSig", EncodeBase64(&mnb.vchSig[0], mnb.vchSig.size())));
+                resultObj.push_back(Pair("sigTime", mnb.sigTime));
+                resultObj.push_back(Pair("protocolVersion", mnb.nProtocolVersion));
+                resultObj.push_back(Pair("nLastDsq", mnb.nLastDsq));
+
+                UniValue lastPingObj(UniValue::VOBJ);
+                lastPingObj.push_back(Pair("vin", mnb.lastPing.vin.ToString()));
+                lastPingObj.push_back(Pair("blockHash", mnb.lastPing.blockHash.ToString()));
+                lastPingObj.push_back(Pair("sigTime", mnb.lastPing.sigTime));
+                lastPingObj.push_back(
+                        Pair("vchSig", EncodeBase64(&mnb.lastPing.vchSig[0], mnb.lastPing.vchSig.size())));
+
+                resultObj.push_back(Pair("lastPing", lastPingObj));
+            } else {
+                nFailed++;
+                resultObj.push_back(Pair("errorMessage", "Znode broadcast signature verification failed"));
+            }
+
+            returnObj.push_back(Pair(mnb.GetHash().ToString(), resultObj));
+        }
+
+        returnObj.push_back(Pair("overall", strprintf(
+                "Successfully decoded broadcast messages for %d znodes, failed to decode %d, total %d",
+                nSuccessful, nFailed, nSuccessful + nFailed)));
+
+        return returnObj;
+    }
+
+    if (strCommand == "relay") {
+        if (params.size() < 2 || params.size() > 3)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "znodebroadcast relay \"hexstring\" ( fast )\n"
+                    "\nArguments:\n"
+                    "1. \"hex\"      (string, required) Broadcast messages hex string\n"
+                    "2. fast       (string, optional) If none, using safe method\n");
+
+        std::vector <CZnodeBroadcast> vecMnb;
+
+        if (!DecodeHexVecMnb(vecMnb, params[1].get_str()))
+            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Znode broadcast message decode failed");
+
+        int nSuccessful = 0;
+        int nFailed = 0;
+        bool fSafe = params.size() == 2;
+        UniValue returnObj(UniValue::VOBJ);
+
+        // verify all signatures first, bailout if any of them broken
+        BOOST_FOREACH(CZnodeBroadcast & mnb, vecMnb)
+        {
+            UniValue resultObj(UniValue::VOBJ);
+
+            resultObj.push_back(Pair("vin", mnb.vin.ToString()));
+            resultObj.push_back(Pair("addr", mnb.addr.ToString()));
+
+            int nDos = 0;
+            bool fResult;
+            if (mnb.CheckSignature(nDos)) {
+                if (fSafe) {
+                    fResult = mnodeman.CheckMnbAndUpdateZnodeList(NULL, mnb, nDos);
+                } else {
+                    mnodeman.UpdateZnodeList(mnb);
+                    mnb.RelayZNode();
+                    fResult = true;
+                }
+                mnodeman.NotifyZnodeUpdates();
+            } else fResult = false;
+
+            if (fResult) {
+                nSuccessful++;
+                resultObj.push_back(Pair(mnb.GetHash().ToString(), "successful"));
+            } else {
+                nFailed++;
+                resultObj.push_back(Pair("errorMessage", "Znode broadcast signature verification failed"));
+            }
+
+            returnObj.push_back(Pair(mnb.GetHash().ToString(), resultObj));
+        }
+
+        returnObj.push_back(Pair("overall", strprintf(
+                "Successfully relayed broadcast messages for %d znodes, failed to relay %d, total %d", nSuccessful,
+                nFailed, nSuccessful + nFailed)));
+
+        return returnObj;
+    }
+
+    return NullUniValue;
+}
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 8ee6b70d10..852ee083b9 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -271,6 +271,12 @@ static const CRPCCommand vRPCCommands[] =
     /* Overall control/query calls */
     { "control",            "help",                   &help,                   true  },
     { "control",            "stop",                   &stop,                   true  },
+        /* Dash features */
+    { "zcoin",               "znode",             &znode,             true  },
+    { "zcoin",               "znsync",             &znsync,             true  },
+    { "zcoin",               "znodelist",         &znodelist,         true  },
+    { "zcoin",               "znodebroadcast",    &znodebroadcast,    true  },
+    { "zcoin",               "getpoolinfo",            &getpoolinfo,            true  },
 };
 
 CRPCTable::CRPCTable()
diff --git a/src/rpc/server.h b/src/rpc/server.h
index 1ed8f2466d..d6183f9f07 100644
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -190,6 +190,13 @@ extern std::string HelpRequiringPassphrase();
 extern std::string HelpExampleCli(const std::string& methodname, const std::string& args);
 extern std::string HelpExampleRpc(const std::string& methodname, const std::string& args);
 
+extern UniValue getpoolinfo(const UniValue& params, bool fHelp);
+extern UniValue spork(const UniValue& params, bool fHelp);
+extern UniValue znode(const UniValue& params, bool fHelp);
+extern UniValue znodelist(const UniValue& params, bool fHelp);
+extern UniValue znodebroadcast(const UniValue& params, bool fHelp);
+extern UniValue znsync(const UniValue& params, bool fHelp);
+
 extern void EnsureWalletIsUnlocked();
 
 bool StartRPC();
diff --git a/src/script/script.cpp b/src/script/script.cpp
index e7905bb713..c343f7ab0a 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -205,6 +205,30 @@ unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
     return subscript.GetSigOpCount(true);
 }
 
+bool CScript::IsNormalPaymentScript() const
+{
+    if(this->size() != 25) return false;
+
+    std::string str;
+    opcodetype opcode;
+    const_iterator pc = begin();
+    int i = 0;
+    while (pc < end())
+    {
+        GetOp(pc, opcode);
+
+        if(     i == 0 && opcode != OP_DUP) return false;
+        else if(i == 1 && opcode != OP_HASH160) return false;
+        else if(i == 3 && opcode != OP_EQUALVERIFY) return false;
+        else if(i == 4 && opcode != OP_CHECKSIG) return false;
+        else if(i == 5) return false;
+
+        i++;
+    }
+
+    return true;
+}
+
 bool CScript::IsPayToScriptHash() const
 {
     // Extra-fast test for pay-to-script-hash CScripts:
@@ -240,7 +264,6 @@ bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program
     return false;
 }
 
-//btzc: add check zerocoint function
 bool CScript::IsZerocoinMint() const
 {
     // Extra-fast test for Zerocoin Mint CScripts:
diff --git a/src/script/script.h b/src/script/script.h
index 021b602428..7baffbbcbb 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -632,12 +632,12 @@ class CScript : public CScriptBase
      * pay-to-script-hash transactions:
      */
     unsigned int GetSigOpCount(const CScript& scriptSig) const;
+    bool IsNormalPaymentScript() const;
 
     bool IsPayToScriptHash() const;
     bool IsPayToWitnessScriptHash() const;
     bool IsWitnessProgram(int& version, std::vector<unsigned char>& program) const;
 
-    //btzc: add check zerocoin function
     bool IsZerocoinMint() const;
     bool IsZerocoinSpend() const;
     // Called by IsStandardTx.
diff --git a/src/spork.cpp b/src/spork.cpp
new file mode 100644
index 0000000000..e314a10297
--- /dev/null
+++ b/src/spork.cpp
@@ -0,0 +1,263 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "darksend.h"
+#include "main.h"
+#include "spork.h"
+
+#include <boost/lexical_cast.hpp>
+
+class CSporkMessage;
+class CSporkManager;
+
+CSporkManager sporkManager;
+
+std::map<uint256, CSporkMessage> mapSporks;
+
+void CSporkManager::ProcessSpork(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
+{
+    if(fLiteMode) return; // disable all Dash specific functionality
+
+    if (strCommand == NetMsgType::SPORK) {
+
+        CDataStream vMsg(vRecv);
+        CSporkMessage spork;
+        vRecv >> spork;
+
+        uint256 hash = spork.GetHash();
+
+        std::string strLogMsg;
+        {
+            LOCK(cs_main);
+            pfrom->setAskFor.erase(hash);
+            if(!chainActive.Tip()) return;
+            strLogMsg = strprintf("SPORK -- hash: %s id: %d value: %10d bestHeight: %d peer=%d", hash.ToString(), spork.nSporkID, spork.nValue, chainActive.Height(), pfrom->id);
+        }
+
+        if(mapSporksActive.count(spork.nSporkID)) {
+            if (mapSporksActive[spork.nSporkID].nTimeSigned >= spork.nTimeSigned) {
+                LogPrint("spork", "%s seen\n", strLogMsg);
+                return;
+            } else {
+                LogPrintf("%s updated\n", strLogMsg);
+            }
+        } else {
+            LogPrintf("%s new\n", strLogMsg);
+        }
+
+        if(!spork.CheckSignature()) {
+            LogPrintf("CSporkManager::ProcessSpork -- invalid signature\n");
+            Misbehaving(pfrom->GetId(), 100);
+            return;
+        }
+
+        mapSporks[hash] = spork;
+        mapSporksActive[spork.nSporkID] = spork;
+        spork.Relay();
+
+        //does a task if needed
+        ExecuteSpork(spork.nSporkID, spork.nValue);
+
+    } else if (strCommand == NetMsgType::GETSPORKS) {
+
+        std::map<int, CSporkMessage>::iterator it = mapSporksActive.begin();
+
+        while(it != mapSporksActive.end()) {
+            pfrom->PushMessage(NetMsgType::SPORK, it->second);
+            it++;
+        }
+    }
+
+}
+
+void CSporkManager::ExecuteSpork(int nSporkID, int nValue)
+{
+    //correct fork via spork technology
+    if(nSporkID == SPORK_12_RECONSIDER_BLOCKS && nValue > 0) {
+        // allow to reprocess 24h of blocks max, which should be enough to resolve any issues
+        int64_t nMaxBlocks = 576;
+        // this potentially can be a heavy operation, so only allow this to be executed once per 10 minutes
+        int64_t nTimeout = 10 * 60;
+
+        static int64_t nTimeExecuted = 0; // i.e. it was never executed before
+
+        if(GetTime() - nTimeExecuted < nTimeout) {
+            LogPrint("spork", "CSporkManager::ExecuteSpork -- ERROR: Trying to reconsider blocks, too soon - %d/%d\n", GetTime() - nTimeExecuted, nTimeout);
+            return;
+        }
+
+        if(nValue > nMaxBlocks) {
+            LogPrintf("CSporkManager::ExecuteSpork -- ERROR: Trying to reconsider too many blocks %d/%d\n", nValue, nMaxBlocks);
+            return;
+        }
+
+
+        LogPrintf("CSporkManager::ExecuteSpork -- Reconsider Last %d Blocks\n", nValue);
+
+        ReprocessBlocks(nValue);
+        nTimeExecuted = GetTime();
+    }
+}
+
+bool CSporkManager::UpdateSpork(int nSporkID, int64_t nValue)
+{
+
+    CSporkMessage spork = CSporkMessage(nSporkID, nValue, GetTime());
+
+    if(spork.Sign(strMasterPrivKey)) {
+        spork.Relay();
+        mapSporks[spork.GetHash()] = spork;
+        mapSporksActive[nSporkID] = spork;
+        return true;
+    }
+
+    return false;
+}
+
+// grab the spork, otherwise say it's off
+bool CSporkManager::IsSporkActive(int nSporkID)
+{
+    int64_t r = -1;
+
+    if(mapSporksActive.count(nSporkID)){
+        r = mapSporksActive[nSporkID].nValue;
+    } else {
+        switch (nSporkID) {
+            case SPORK_2_INSTANTSEND_ENABLED:               r = SPORK_2_INSTANTSEND_ENABLED_DEFAULT; break;
+            case SPORK_3_INSTANTSEND_BLOCK_FILTERING:       r = SPORK_3_INSTANTSEND_BLOCK_FILTERING_DEFAULT; break;
+            case SPORK_5_INSTANTSEND_MAX_VALUE:             r = SPORK_5_INSTANTSEND_MAX_VALUE_DEFAULT; break;
+            case SPORK_8_ZNODE_PAYMENT_ENFORCEMENT:    r = SPORK_8_ZNODE_PAYMENT_ENFORCEMENT_DEFAULT; break;
+            case SPORK_9_SUPERBLOCKS_ENABLED:               r = SPORK_9_SUPERBLOCKS_ENABLED_DEFAULT; break;
+            case SPORK_10_ZNODE_PAY_UPDATED_NODES:     r = SPORK_10_ZNODE_PAY_UPDATED_NODES_DEFAULT; break;
+            case SPORK_12_RECONSIDER_BLOCKS:                r = SPORK_12_RECONSIDER_BLOCKS_DEFAULT; break;
+            case SPORK_13_OLD_SUPERBLOCK_FLAG:              r = SPORK_13_OLD_SUPERBLOCK_FLAG_DEFAULT; break;
+            case SPORK_14_REQUIRE_SENTINEL_FLAG:            r = SPORK_14_REQUIRE_SENTINEL_FLAG_DEFAULT; break;
+            default:
+                LogPrint("spork", "CSporkManager::IsSporkActive -- Unknown Spork ID %d\n", nSporkID);
+                r = 4070908800ULL; // 2099-1-1 i.e. off by default
+                break;
+        }
+    }
+
+    return r < GetTime();
+}
+
+// grab the value of the spork on the network, or the default
+int64_t CSporkManager::GetSporkValue(int nSporkID)
+{
+    if (mapSporksActive.count(nSporkID))
+        return mapSporksActive[nSporkID].nValue;
+
+    switch (nSporkID) {
+        case SPORK_2_INSTANTSEND_ENABLED:               return SPORK_2_INSTANTSEND_ENABLED_DEFAULT;
+        case SPORK_3_INSTANTSEND_BLOCK_FILTERING:       return SPORK_3_INSTANTSEND_BLOCK_FILTERING_DEFAULT;
+        case SPORK_5_INSTANTSEND_MAX_VALUE:             return SPORK_5_INSTANTSEND_MAX_VALUE_DEFAULT;
+        case SPORK_8_ZNODE_PAYMENT_ENFORCEMENT:    return SPORK_8_ZNODE_PAYMENT_ENFORCEMENT_DEFAULT;
+        case SPORK_9_SUPERBLOCKS_ENABLED:               return SPORK_9_SUPERBLOCKS_ENABLED_DEFAULT;
+        case SPORK_10_ZNODE_PAY_UPDATED_NODES:     return SPORK_10_ZNODE_PAY_UPDATED_NODES_DEFAULT;
+        case SPORK_12_RECONSIDER_BLOCKS:                return SPORK_12_RECONSIDER_BLOCKS_DEFAULT;
+        case SPORK_13_OLD_SUPERBLOCK_FLAG:              return SPORK_13_OLD_SUPERBLOCK_FLAG_DEFAULT;
+        case SPORK_14_REQUIRE_SENTINEL_FLAG:            return SPORK_14_REQUIRE_SENTINEL_FLAG_DEFAULT;
+        default:
+            LogPrint("spork", "CSporkManager::GetSporkValue -- Unknown Spork ID %d\n", nSporkID);
+            return -1;
+    }
+
+}
+
+int CSporkManager::GetSporkIDByName(std::string strName)
+{
+    if (strName == "SPORK_2_INSTANTSEND_ENABLED")               return SPORK_2_INSTANTSEND_ENABLED;
+    if (strName == "SPORK_3_INSTANTSEND_BLOCK_FILTERING")       return SPORK_3_INSTANTSEND_BLOCK_FILTERING;
+    if (strName == "SPORK_5_INSTANTSEND_MAX_VALUE")             return SPORK_5_INSTANTSEND_MAX_VALUE;
+    if (strName == "SPORK_8_ZNODE_PAYMENT_ENFORCEMENT")    return SPORK_8_ZNODE_PAYMENT_ENFORCEMENT;
+    if (strName == "SPORK_9_SUPERBLOCKS_ENABLED")               return SPORK_9_SUPERBLOCKS_ENABLED;
+    if (strName == "SPORK_10_ZNODE_PAY_UPDATED_NODES")     return SPORK_10_ZNODE_PAY_UPDATED_NODES;
+    if (strName == "SPORK_12_RECONSIDER_BLOCKS")                return SPORK_12_RECONSIDER_BLOCKS;
+    if (strName == "SPORK_13_OLD_SUPERBLOCK_FLAG")              return SPORK_13_OLD_SUPERBLOCK_FLAG;
+    if (strName == "SPORK_14_REQUIRE_SENTINEL_FLAG")            return SPORK_14_REQUIRE_SENTINEL_FLAG;
+
+    LogPrint("spork", "CSporkManager::GetSporkIDByName -- Unknown Spork name '%s'\n", strName);
+    return -1;
+}
+
+std::string CSporkManager::GetSporkNameByID(int nSporkID)
+{
+    switch (nSporkID) {
+        case SPORK_2_INSTANTSEND_ENABLED:               return "SPORK_2_INSTANTSEND_ENABLED";
+        case SPORK_3_INSTANTSEND_BLOCK_FILTERING:       return "SPORK_3_INSTANTSEND_BLOCK_FILTERING";
+        case SPORK_5_INSTANTSEND_MAX_VALUE:             return "SPORK_5_INSTANTSEND_MAX_VALUE";
+        case SPORK_8_ZNODE_PAYMENT_ENFORCEMENT:    return "SPORK_8_ZNODE_PAYMENT_ENFORCEMENT";
+        case SPORK_9_SUPERBLOCKS_ENABLED:               return "SPORK_9_SUPERBLOCKS_ENABLED";
+        case SPORK_10_ZNODE_PAY_UPDATED_NODES:     return "SPORK_10_ZNODE_PAY_UPDATED_NODES";
+        case SPORK_12_RECONSIDER_BLOCKS:                return "SPORK_12_RECONSIDER_BLOCKS";
+        case SPORK_13_OLD_SUPERBLOCK_FLAG:              return "SPORK_13_OLD_SUPERBLOCK_FLAG";
+        case SPORK_14_REQUIRE_SENTINEL_FLAG:            return "SPORK_14_REQUIRE_SENTINEL_FLAG";
+        default:
+            LogPrint("spork", "CSporkManager::GetSporkNameByID -- Unknown Spork ID %d\n", nSporkID);
+            return "Unknown";
+    }
+}
+
+bool CSporkManager::SetPrivKey(std::string strPrivKey)
+{
+    CSporkMessage spork;
+
+    spork.Sign(strPrivKey);
+
+    if(spork.CheckSignature()){
+        // Test signing successful, proceed
+        LogPrintf("CSporkManager::SetPrivKey -- Successfully initialized as spork signer\n");
+        strMasterPrivKey = strPrivKey;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool CSporkMessage::Sign(std::string strSignKey)
+{
+    CKey key;
+    CPubKey pubkey;
+    std::string strError = "";
+    std::string strMessage = boost::lexical_cast<std::string>(nSporkID) + boost::lexical_cast<std::string>(nValue) + boost::lexical_cast<std::string>(nTimeSigned);
+
+    if(!darkSendSigner.GetKeysFromSecret(strSignKey, key, pubkey)) {
+        LogPrintf("CSporkMessage::Sign -- GetKeysFromSecret() failed, invalid spork key %s\n", strSignKey);
+        return false;
+    }
+
+    if(!darkSendSigner.SignMessage(strMessage, vchSig, key)) {
+        LogPrintf("CSporkMessage::Sign -- SignMessage() failed\n");
+        return false;
+    }
+
+    if(!darkSendSigner.VerifyMessage(pubkey, vchSig, strMessage, strError)) {
+        LogPrintf("CSporkMessage::Sign -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+bool CSporkMessage::CheckSignature()
+{
+    //note: need to investigate why this is failing
+    std::string strError = "";
+    std::string strMessage = boost::lexical_cast<std::string>(nSporkID) + boost::lexical_cast<std::string>(nValue) + boost::lexical_cast<std::string>(nTimeSigned);
+    CPubKey pubkey(ParseHex(Params().SporkPubKey()));
+
+    if(!darkSendSigner.VerifyMessage(pubkey, vchSig, strMessage, strError)) {
+        LogPrintf("CSporkMessage::CheckSignature -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+void CSporkMessage::Relay()
+{
+    CInv inv(MSG_SPORK, GetHash());
+    RelayInv(inv);
+}
diff --git a/src/spork.h b/src/spork.h
new file mode 100644
index 0000000000..e70aecc935
--- /dev/null
+++ b/src/spork.h
@@ -0,0 +1,122 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef SPORK_H
+#define SPORK_H
+
+#include "hash.h"
+#include "net.h"
+#include "utilstrencodings.h"
+#include "util.h"
+
+class CSporkMessage;
+
+/*
+    Don't ever reuse these IDs for other sporks
+    - This would result in old clients getting confused about which spork is for what
+*/
+static const int SPORK_START                                            = 10001;
+static const int SPORK_END                                              = 10013;
+
+static const int SPORK_2_INSTANTSEND_ENABLED                            = 10001;
+static const int SPORK_3_INSTANTSEND_BLOCK_FILTERING                    = 10002;
+static const int SPORK_5_INSTANTSEND_MAX_VALUE                          = 10004;
+static const int SPORK_8_ZNODE_PAYMENT_ENFORCEMENT                 = 10007;
+static const int SPORK_9_SUPERBLOCKS_ENABLED                            = 10008;
+static const int SPORK_10_ZNODE_PAY_UPDATED_NODES                  = 10009;
+static const int SPORK_12_RECONSIDER_BLOCKS                             = 10011;
+static const int SPORK_13_OLD_SUPERBLOCK_FLAG                           = 10012;
+static const int SPORK_14_REQUIRE_SENTINEL_FLAG                         = 10013;
+
+static const int64_t SPORK_2_INSTANTSEND_ENABLED_DEFAULT                = 0;            // ON
+static const int64_t SPORK_3_INSTANTSEND_BLOCK_FILTERING_DEFAULT        = 0;            // ON
+static const int64_t SPORK_5_INSTANTSEND_MAX_VALUE_DEFAULT              = 1000;         // 1000 XZC
+static const int64_t SPORK_8_ZNODE_PAYMENT_ENFORCEMENT_DEFAULT     = 4070908800ULL;// OFF
+static const int64_t SPORK_9_SUPERBLOCKS_ENABLED_DEFAULT                = 4070908800ULL;// OFF
+static const int64_t SPORK_10_ZNODE_PAY_UPDATED_NODES_DEFAULT      = 4070908800ULL;// OFF
+static const int64_t SPORK_12_RECONSIDER_BLOCKS_DEFAULT                 = 0;            // 0 BLOCKS
+static const int64_t SPORK_13_OLD_SUPERBLOCK_FLAG_DEFAULT               = 4070908800ULL;// OFF
+static const int64_t SPORK_14_REQUIRE_SENTINEL_FLAG_DEFAULT             = 4070908800ULL;// OFF
+
+extern std::map<uint256, CSporkMessage> mapSporks;
+
+//
+// Spork classes
+// Keep track of all of the network spork settings
+//
+
+class CSporkMessage
+{
+private:
+    std::vector<unsigned char> vchSig;
+
+public:
+    int nSporkID;
+    int64_t nValue;
+    int64_t nTimeSigned;
+
+    CSporkMessage(int nSporkID, int64_t nValue, int64_t nTimeSigned) :
+        nSporkID(nSporkID),
+        nValue(nValue),
+        nTimeSigned(nTimeSigned)
+        {}
+
+    CSporkMessage() :
+        nSporkID(0),
+        nValue(0),
+        nTimeSigned(0)
+        {}
+
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(nSporkID);
+        READWRITE(nValue);
+        READWRITE(nTimeSigned);
+        READWRITE(vchSig);
+    }
+
+    uint256 GetHash() const
+    {
+        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+        ss << nSporkID;
+        ss << nValue;
+        ss << nTimeSigned;
+        return ss.GetHash();
+    }
+
+    bool Sign(std::string strSignKey);
+    bool CheckSignature();
+    void Relay();
+};
+
+
+class CSporkManager
+{
+private:
+    std::vector<unsigned char> vchSig;
+    std::string strMasterPrivKey;
+    std::map<int, CSporkMessage> mapSporksActive;
+
+public:
+
+    CSporkManager() {}
+
+    void ProcessSpork(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
+    void ExecuteSpork(int nSporkID, int nValue);
+    bool UpdateSpork(int nSporkID, int64_t nValue);
+
+    bool IsSporkActive(int nSporkID);
+    int64_t GetSporkValue(int nSporkID);
+    int GetSporkIDByName(std::string strName);
+    std::string GetSporkNameByID(int nSporkID);
+
+    bool SetPrivKey(std::string strPrivKey);
+};
+
+extern CSporkManager sporkManager;
+
+#endif
diff --git a/src/streams.h b/src/streams.h
index e399036be3..8731e9d37c 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -68,7 +68,6 @@ class CDataStream
 public:
     int nType;
     int nVersion;
-    //btzc: switch vch from protected to public
     vector_type vch;
 
     typedef vector_type::allocator_type   allocator_type;
diff --git a/src/sync.cpp b/src/sync.cpp
index 641ed2c8ca..762d2917f1 100644
--- a/src/sync.cpp
+++ b/src/sync.cpp
@@ -123,6 +123,7 @@ static void potential_deadlock_detected(const std::pair<void*, void*>& mismatch,
         LogPrintf(" %s\n", i.second.ToString());
     }
     assert(onlyMaybeDeadlock);
+//    LogPrintf("onlyMaybeDeadlock=%s\n", onlyMaybeDeadlock);
 }
 
 static void push_lock(void* c, const CLockLocation& locklocation, bool fTry)
diff --git a/src/test/buildenv.py b/src/test/buildenv.py
new file mode 100644
index 0000000000..a2cb8f38da
--- /dev/null
+++ b/src/test/buildenv.py
@@ -0,0 +1,2 @@
+#!/usr/bin/python
+exeext=""
diff --git a/src/ui_interface.h b/src/ui_interface.h
index d703dfd17a..98406cdd3a 100644
--- a/src/ui_interface.h
+++ b/src/ui_interface.h
@@ -107,6 +107,9 @@ class CClientUIInterface
 
     /** Banlist did change. */
     boost::signals2::signal<void (void)> BannedListChanged;
+
+    /** Additional data sync progress changed */
+    boost::signals2::signal<void (double nSyncProgress)> NotifyAdditionalDataSyncProgressChanged;
 };
 
 /** Show warning message **/
diff --git a/src/util.cpp b/src/util.cpp
index 0fce422271..401324b685 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -99,6 +99,11 @@ namespace boost {
 
 using namespace std;
 
+// znode fZnode
+bool fZNode = false;
+bool fLiteMode = false;
+int nWalletBackups = 10;
+
 const char * const BITCOIN_CONF_FILENAME = "zcoin.conf";
 const char * const BITCOIN_PID_FILENAME = "zcoind.pid";
 
@@ -485,6 +490,34 @@ static boost::filesystem::path pathCached;
 static boost::filesystem::path pathCachedNetSpecific;
 static CCriticalSection csPathCached;
 
+static boost::filesystem::path backupsDirCached;
+static CCriticalSection csBackupsDirCached;
+
+const boost::filesystem::path &GetBackupsDir()
+{
+    namespace fs = boost::filesystem;
+
+    LOCK(csBackupsDirCached);
+
+    fs::path &backupsDir = backupsDirCached;
+
+    if (!backupsDir.empty())
+        return backupsDir;
+
+    if (mapArgs.count("-walletbackupsdir")) {
+        backupsDir = fs::absolute(mapArgs["-walletbackupsdir"]);
+        // Path must exist
+        if (fs::is_directory(backupsDir)) return backupsDir;
+        // Fallback to default path if it doesn't
+        LogPrintf("%s: Warning: incorrect parameter -walletbackupsdir, path must exist! Using default path.\n", __func__);
+        strMiscWarning = _("Warning: incorrect parameter -walletbackupsdir, path must exist! Using default path.");
+    }
+    // Default path
+    backupsDir = GetDataDir() / "backups";
+
+    return backupsDir;
+}
+
 const boost::filesystem::path &GetDataDir(bool fNetSpecific)
 {
     namespace fs = boost::filesystem;
@@ -530,6 +563,14 @@ boost::filesystem::path GetConfigFile()
     return pathConfigFile;
 }
 
+boost::filesystem::path GetZnodeConfigFile()
+{
+    boost::filesystem::path pathConfigFile(GetArg("-znconf", "znode.conf"));
+    if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir() / pathConfigFile;
+    LogPrintf("pathConfigFile=%s\n", pathConfigFile);
+    return pathConfigFile;
+}
+
 void ReadConfigFile(map<string, string>& mapSettingsRet,
                     map<string, vector<string> >& mapMultiSettingsRet)
 {
diff --git a/src/util.h b/src/util.h
index 5c2e16dea1..543e846fc1 100644
--- a/src/util.h
+++ b/src/util.h
@@ -41,6 +41,9 @@ class CTranslationInterface
     /** Translate a message to the native language of the user. */
     boost::signals2::signal<std::string (const char* psz)> Translate;
 };
+extern bool fZNode;
+extern bool fLiteMode;
+extern int nWalletBackups;
 
 extern std::map<std::string, std::string> mapArgs;
 extern std::map<std::string, std::vector<std::string> > mapMultiArgs;
@@ -69,10 +72,6 @@ inline std::string _(const char* psz)
     return rv ? (*rv) : psz;
 }
 
-/**
- * btzc: Add some utils for zerocoin
- */
-
 inline int roundint(double d)
 {
     return (int)(d > 0 ? d + 0.5 : d - 0.5);
@@ -133,8 +132,10 @@ bool RenameOver(boost::filesystem::path src, boost::filesystem::path dest);
 bool TryCreateDirectory(const boost::filesystem::path& p);
 boost::filesystem::path GetDefaultDataDir();
 const boost::filesystem::path &GetDataDir(bool fNetSpecific = true);
+const boost::filesystem::path &GetBackupsDir();
 void ClearDatadirCache();
 boost::filesystem::path GetConfigFile();
+boost::filesystem::path GetZnodeConfigFile();
 #ifndef WIN32
 boost::filesystem::path GetPidFile();
 void CreatePidFile(const boost::filesystem::path &path, pid_t pid);
diff --git a/src/utiltime.cpp b/src/utiltime.cpp
index da590f8889..d0bd71f9ed 100644
--- a/src/utiltime.cpp
+++ b/src/utiltime.cpp
@@ -8,6 +8,7 @@
 #endif
 
 #include "utiltime.h"
+#include "tinyformat.h"
 
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/thread.hpp>
@@ -81,3 +82,18 @@ std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime)
     ss << boost::posix_time::from_time_t(nTime);
     return ss.str();
 }
+
+std::string DurationToDHMS(int64_t nDurationTime)
+{
+    int seconds = nDurationTime % 60;
+    nDurationTime /= 60;
+    int minutes = nDurationTime % 60;
+    nDurationTime /= 60;
+    int hours = nDurationTime % 24;
+    int days = nDurationTime / 24;
+    if(days)
+        return strprintf("%dd %02dh:%02dm:%02ds", days, hours, minutes, seconds);
+    if(hours)
+        return strprintf("%02dh:%02dm:%02ds", hours, minutes, seconds);
+    return strprintf("%02dm:%02ds", minutes, seconds);
+}
diff --git a/src/utiltime.h b/src/utiltime.h
index b2807267db..041b458621 100644
--- a/src/utiltime.h
+++ b/src/utiltime.h
@@ -17,5 +17,6 @@ void SetMockTime(int64_t nMockTimeIn);
 void MilliSleep(int64_t n);
 
 std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime);
+std::string DurationToDHMS(int64_t nDurationTime);
 
 #endif // BITCOIN_UTILTIME_H
diff --git a/src/version.h b/src/version.h
index 60fa06c01d..473c30947e 100644
--- a/src/version.h
+++ b/src/version.h
@@ -9,7 +9,7 @@
  * network protocol versioning
  */
 
-static const int PROTOCOL_VERSION = 90023;
+static const int PROTOCOL_VERSION = 90024;
 
 //! initial proto version, to be increased after version/verack negotiation
 static const int INIT_PROTO_VERSION = 90013;
@@ -18,7 +18,10 @@ static const int INIT_PROTO_VERSION = 90013;
 static const int GETHEADERS_VERSION = 90020;
 
 //! disconnect from peers older than this proto version
-static const int MIN_PEER_PROTO_VERSION = 90022;
+static const int MIN_PEER_PROTO_VERSION = 90023;
+
+//! disconnect from all older peers after Znode payment HF
+static const int MIN_PEER_PROTO_VERSION_AFTER_ZNODE_PAYMENT_HF = 90024;
 
 //! nTime field added to CAddress, starting with this version;
 //! if possible, avoid requesting addresses nodes older than this
diff --git a/src/wallet/crypter.h b/src/wallet/crypter.h
index 5d0a4a3305..122abb5c8d 100644
--- a/src/wallet/crypter.h
+++ b/src/wallet/crypter.h
@@ -133,6 +133,9 @@ class CCryptoKeyStore : public CBasicKeyStore
     //! keeps track of whether Unlock has run a thorough check before
     bool fDecryptionThoroughlyChecked;
 
+    //! if fOnlyMixingAllowed is true, only mixing should be allowed in unlocked wallet
+    bool fOnlyMixingAllowed;
+
 protected:
     bool SetCrypted();
 
@@ -151,7 +154,7 @@ class CCryptoKeyStore : public CBasicKeyStore
         return fUseCrypto;
     }
 
-    bool IsLocked() const
+    bool IsLocked(bool fForMixing = false) const
     {
         if (!IsCrypted())
             return false;
@@ -160,6 +163,7 @@ class CCryptoKeyStore : public CBasicKeyStore
             LOCK(cs_KeyStore);
             result = vMasterKey.empty();
         }
+//        if(!fForMixing && fOnlyMixingAllowed) return true;
         return result;
     }
 
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 79bd2b34b6..4b7e5f12a2 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -2883,6 +2883,45 @@ UniValue listmintzerocoins(const UniValue& params, bool fHelp) {
     return results;
 }
 
+
+UniValue listpubcoins(const UniValue& params, bool fHelp) {
+    if (fHelp || params.size() > 1)
+        throw runtime_error(
+                "listpubcoin <all>(1/10/25/50/100)\n"
+                        "\nArguments:\n"
+                        "1. <all> (int, optional) 1,10,25,50,100 (default) to return all pubcoin with denomination. empty to return all pubcoin.\n"
+                        "\nResults are an array of Objects, each of which has:\n"
+                        "{id, IsUsed, denomination, value, serialNumber, nHeight, randomness}");
+
+    int denomination = -1;
+    if (params.size() > 0) {
+        denomination = params[0].get_int();
+    }
+
+    list <CZerocoinEntry> listPubcoin;
+    CWalletDB walletdb(pwalletMain->strWalletFile);
+    walletdb.ListPubCoin(listPubcoin);
+    UniValue results(UniValue::VARR);
+    listPubcoin.sort(CompID);
+
+    BOOST_FOREACH(const CZerocoinEntry &zerocoinItem, listPubcoin) {
+        if (zerocoinItem.id > 0 && (denomination < 0 || zerocoinItem.denomination == denomination)) {
+            UniValue entry(UniValue::VOBJ);
+            entry.push_back(Pair("id", zerocoinItem.id));
+            entry.push_back(Pair("IsUsed", zerocoinItem.IsUsed));
+            entry.push_back(Pair("denomination", zerocoinItem.denomination));
+            entry.push_back(Pair("value", zerocoinItem.value.GetHex()));
+            entry.push_back(Pair("serialNumber", zerocoinItem.serialNumber.GetHex()));
+            entry.push_back(Pair("nHeight", zerocoinItem.nHeight));
+            entry.push_back(Pair("randomness", zerocoinItem.randomness.GetHex()));
+            results.push_back(entry);
+        }
+    }
+
+    return results;
+}
+
+
 UniValue setmintzerocoinstatus(const UniValue& params, bool fHelp) {
     if (fHelp || params.size() != 2)
         throw runtime_error(
@@ -3045,6 +3084,7 @@ static const CRPCCommand commands[] =
     { "wallet",             "resetmintzerocoin",        &resetmintzerocoin,        false },
     { "wallet",             "setmintzerocoinstatus",        &setmintzerocoinstatus,        false },
     { "wallet",             "listmintzerocoins",        &listmintzerocoins,        false },
+    { "wallet",             "listpubcoins",        &listpubcoins,        false },
     { "wallet",             "removetxmempool",          &removetxmempool,          false },
     { "wallet",             "removetxwallet",           &removetxwallet,           false },
 };
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 1deddf5a1c..fa7a12d844 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -25,6 +25,10 @@
 #include "ui_interface.h"
 #include "utilmoneystr.h"
 #include "validation.h"
+#include "darksend.h"
+#include "instantx.h"
+#include "znode.h"
+#include "random.h"
 
 #include <assert.h>
 #include <boost/algorithm/string/replace.hpp>
@@ -33,6 +37,9 @@
 
 #define ZEROCOIN_MODULUS   "25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987549182422433637259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133844143603833904414952634432190114657544454178424020924616515723350778707749817125772467962926386356373289912154831438167899885040445364023527381951378636564391212010397122822120720357"
 
+// number of mint confirmations needed to spend coin
+#define ZC_MINT_CONFIRMATIONS   6
+
 using namespace std;
 
 CWallet *pwalletMain = NULL;
@@ -71,6 +78,33 @@ struct CompareValueOnly {
     }
 };
 
+struct CompareByPriority
+{
+    bool operator()(const COutput& t1,
+                    const COutput& t2) const
+    {
+        return t1.Priority() > t2.Priority();
+    }
+};
+
+struct CompareByAmount
+{
+    bool operator()(const CompactTallyItem& t1, const CompactTallyItem& t2) const
+    {
+        return t1.nAmount > t2.nAmount;
+    }
+};
+
+int COutput::Priority() const
+{
+    BOOST_FOREACH(CAmount d, vecPrivateSendDenominations)
+    if(tx->vout[i].nValue == d) return 10000;
+    if(tx->vout[i].nValue < 1*COIN) return 20000;
+
+    //nondenom return largest first
+    return -(tx->vout[i].nValue/COIN);
+}
+
 std::string COutput::ToString() const {
     return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->vout[i].nValue));
 }
@@ -255,6 +289,7 @@ bool CWallet::RemoveWatchOnly(const CScript &dest) {
     return true;
 }
 
+
 bool CWallet::LoadWatchOnly(const CScript &dest) {
     return CCryptoKeyStore::AddWatchOnly(dest);
 }
@@ -265,8 +300,7 @@ bool CWallet::Unlock(const SecureString &strWalletPassphrase) {
 
     {
         LOCK(cs_wallet);
-        BOOST_FOREACH(
-        const MasterKeyMap::value_type &pMasterKey, mapMasterKeys)
+        BOOST_FOREACH(const MasterKeyMap::value_type &pMasterKey, mapMasterKeys)
         {
             if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt,
                                               pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
@@ -386,8 +420,7 @@ set <uint256> CWallet::GetConflicts(const uint256 &txid) const {
 
     std::pair <TxSpends::const_iterator, TxSpends::const_iterator> range;
 
-    BOOST_FOREACH(
-    const CTxIn &txin, wtx.vin)
+    BOOST_FOREACH(const CTxIn &txin, wtx.vin)
     {
         if (mapTxSpends.count(txin.prevout) <= 1)
             continue;  // No conflict if zero or one spends
@@ -523,8 +556,7 @@ void CWallet::AddToSpends(const uint256 &wtxid) {
     if (thisTx.IsCoinBase() || thisTx.IsZerocoinSpend()) // Coinbases don't spend anything!
         return;
 
-    BOOST_FOREACH(
-    const CTxIn &txin, thisTx.vin)
+    BOOST_FOREACH(const CTxIn &txin, thisTx.vin)
     AddToSpends(txin.prevout, wtxid);
 }
 
@@ -686,8 +718,7 @@ bool CWallet::GetAccountPubkey(CPubKey &pubKey, std::string strAccount, bool bFo
             for (map<uint256, CWalletTx>::iterator it = mapWallet.begin();
                  it != mapWallet.end() && account.vchPubKey.IsValid();
                  ++it)
-                BOOST_FOREACH(
-            const CTxOut &txout, (*it).second.vout)
+                BOOST_FOREACH(const CTxOut &txout, (*it).second.vout)
             if (txout.scriptPubKey == scriptPubKey) {
                 bForceNew = true;
                 break;
@@ -712,8 +743,7 @@ bool CWallet::GetAccountPubkey(CPubKey &pubKey, std::string strAccount, bool bFo
 void CWallet::MarkDirty() {
     {
         LOCK(cs_wallet);
-        BOOST_FOREACH(PAIRTYPE(
-        const uint256, CWalletTx)&item, mapWallet)
+        BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)&item, mapWallet)
         item.second.MarkDirty();
     }
 }
@@ -931,8 +961,7 @@ bool CWallet::AbandonTransaction(const uint256 &hashTx) {
             }
             // If a transaction changes 'conflicted' state, that changes the balance
             // available of the outputs it spends. So force those to be recomputed
-            BOOST_FOREACH(
-            const CTxIn &txin, wtx.vin)
+            BOOST_FOREACH(const CTxIn &txin, wtx.vin)
             {
                 if (mapWallet.count(txin.prevout.hash))
                     mapWallet[txin.prevout.hash].MarkDirty();
@@ -1097,8 +1126,7 @@ bool CWallet::IsFromMe(const CTransaction &tx) const {
 
 CAmount CWallet::GetDebit(const CTransaction &tx, const isminefilter &filter) const {
     CAmount nDebit = 0;
-    BOOST_FOREACH(
-    const CTxIn &txin, tx.vin)
+    BOOST_FOREACH(const CTxIn &txin, tx.vin)
     {
         nDebit += GetDebit(txin, filter);
         if (!MoneyRange(nDebit))
@@ -1109,8 +1137,7 @@ CAmount CWallet::GetDebit(const CTransaction &tx, const isminefilter &filter) co
 
 CAmount CWallet::GetCredit(const CTransaction &tx, const isminefilter &filter) const {
     CAmount nCredit = 0;
-    BOOST_FOREACH(
-    const CTxOut &txout, tx.vout)
+    BOOST_FOREACH(const CTxOut &txout, tx.vout)
     {
         nCredit += GetCredit(txout, filter);
         if (!MoneyRange(nCredit))
@@ -1121,8 +1148,7 @@ CAmount CWallet::GetCredit(const CTransaction &tx, const isminefilter &filter) c
 
 CAmount CWallet::GetChange(const CTransaction &tx) const {
     CAmount nChange = 0;
-    BOOST_FOREACH(
-    const CTxOut &txout, tx.vout)
+    BOOST_FOREACH(const CTxOut &txout, tx.vout)
     {
         nChange += GetChange(txout);
         if (!MoneyRange(nChange))
@@ -1285,15 +1311,13 @@ void CWalletTx::GetAccountAmounts(const string &strAccount, CAmount &nReceived,
     GetAmounts(listReceived, listSent, allFee, strSentAccount, filter);
 
     if (strAccount == strSentAccount) {
-        BOOST_FOREACH(
-        const COutputEntry &s, listSent)
+        BOOST_FOREACH(const COutputEntry &s, listSent)
         nSent += s.amount;
         nFee = allFee;
     }
     {
         LOCK(pwallet->cs_wallet);
-        BOOST_FOREACH(
-        const COutputEntry &r, listReceived)
+        BOOST_FOREACH(const COutputEntry &r, listReceived)
         {
             if (pwallet->mapAddressBook.count(r.destination)) {
                 map<CTxDestination, CAddressBookData>::const_iterator mi = pwallet->mapAddressBook.find(r.destination);
@@ -1374,7 +1398,7 @@ void CWallet::ReacceptWalletTransactions() {
 
         int nDepth = wtx.GetDepthInMainChain();
 
-        if ((wtx.IsCoinBase() ||  wtx.IsZerocoinSpend()) && (nDepth == 0 && !wtx.isAbandoned()))
+        if ((wtx.IsCoinBase() || wtx.IsZerocoinSpend()) && (nDepth == 0 && !wtx.isAbandoned()))
             continue;
 
         if (nDepth == 0 && !wtx.isAbandoned()) {
@@ -1582,8 +1606,7 @@ bool CWalletTx::IsTrusted() const {
         return false;
 
     // Trusted if all inputs are from us and are in the mempool:
-    BOOST_FOREACH(
-    const CTxIn &txin, vin)
+    BOOST_FOREACH(const CTxIn &txin, vin)
     {
         // Transactions not sent by us: not trusted
         const CWalletTx *parent = pwallet->GetWalletTx(txin.prevout.hash);
@@ -1609,10 +1632,8 @@ std::vector <uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime) {
 
     LOCK(cs_wallet);
     // Sort them in chronological order
-    multimap < unsigned
-    int, CWalletTx * > mapSorted;
-    BOOST_FOREACH(PAIRTYPE(
-    const uint256, CWalletTx)&item, mapWallet)
+    multimap < unsigned int, CWalletTx * > mapSorted;
+    BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)&item, mapWallet)
     {
         CWalletTx &wtx = item.second;
         // Don't rebroadcast if newer than nTime:
@@ -1620,8 +1641,7 @@ std::vector <uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime) {
             continue;
         mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
     }
-    BOOST_FOREACH(PAIRTYPE(
-    const unsigned int, CWalletTx *)&item, mapSorted)
+    BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx *)&item, mapSorted)
     {
         CWalletTx &wtx = *item.second;
         if (wtx.RelayWalletTransaction())
@@ -1677,6 +1697,118 @@ CAmount CWallet::GetBalance() const {
     return nTotal;
 }
 
+CAmount CWallet::GetAnonymizableBalance(bool fSkipDenominated) const {
+    if (fLiteMode) return 0;
+
+    std::vector <CompactTallyItem> vecTally;
+    if (!SelectCoinsGrouppedByAddresses(vecTally, fSkipDenominated)) return 0;
+
+    CAmount nTotal = 0;
+
+    BOOST_FOREACH(CompactTallyItem & item, vecTally)
+    {
+        bool fIsDenominated = IsDenominatedAmount(item.nAmount);
+        if (fSkipDenominated && fIsDenominated) continue;
+        // assume that the fee to create denoms be PRIVATESEND_COLLATERAL at max
+        if (item.nAmount >= vecPrivateSendDenominations.back() + (fIsDenominated ? 0 : PRIVATESEND_COLLATERAL))
+            nTotal += item.nAmount;
+    }
+
+    return nTotal;
+}
+
+CAmount CWallet::GetAnonymizedBalance() const {
+    if (fLiteMode) return 0;
+
+    CAmount nTotal = 0;
+    {
+        LOCK2(cs_main, cs_wallet);
+        for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) {
+            const CWalletTx *pcoin = &(*it).second;
+
+            if (pcoin->IsTrusted())
+                nTotal += 0;
+//                nTotal += pcoin->GetAnonymizedCredit();
+        }
+    }
+
+    return nTotal;
+}
+
+CAmount CWalletTx::GetAnonymizedCredit(bool fUseCache) const {
+    if (pwallet == 0)
+        return 0;
+
+    // Must wait until coinbase is safely deep enough in the chain before valuing it
+    if (IsCoinBase() && GetBlocksToMaturity() > 0)
+        return 0;
+
+//    if (fUseCache && fAnonymizedCreditCached)
+//        return nAnonymizedCreditCached;
+
+    CAmount nCredit = 0;
+    uint256 hashTx = GetHash();
+    for (unsigned int i = 0; i < vout.size(); i++) {
+        const CTxOut &txout = vout[i];
+        const CTxIn txin = CTxIn(hashTx, i);
+
+        if (pwallet->IsSpent(hashTx, i) || !pwallet->IsDenominated(txin)) continue;
+
+//        const int nRounds = pwallet->GetInputPrivateSendRounds(txin);
+        const int nRounds = 0;
+        if (nRounds >= nPrivateSendRounds) {
+            nCredit += pwallet->GetCredit(txout, ISMINE_SPENDABLE);
+            if (!MoneyRange(nCredit))
+                throw std::runtime_error("CWalletTx::GetAnonymizedCredit() : value out of range");
+        }
+    }
+
+//    nAnonymizedCreditCached = nCredit;
+//    fAnonymizedCreditCached = true;
+    return nCredit;
+}
+
+
+CAmount CWallet::GetNeedsToBeAnonymizedBalance(CAmount nMinBalance) const {
+    if (fLiteMode) return 0;
+
+    CAmount nAnonymizedBalance = GetAnonymizedBalance();
+    CAmount nNeedsToAnonymizeBalance = nPrivateSendAmount * COIN - nAnonymizedBalance;
+
+    // try to overshoot target DS balance up to nMinBalance
+    nNeedsToAnonymizeBalance += nMinBalance;
+
+    CAmount nAnonymizableBalance = GetAnonymizableBalance();
+
+    // anonymizable balance is way too small
+    if (nAnonymizableBalance < nMinBalance) return 0;
+
+    // not enough funds to anonymze amount we want, try the max we can
+    if (nNeedsToAnonymizeBalance > nAnonymizableBalance) nNeedsToAnonymizeBalance = nAnonymizableBalance;
+
+    // we should never exceed the pool max
+    if (nNeedsToAnonymizeBalance > PRIVATESEND_POOL_MAX) nNeedsToAnonymizeBalance = PRIVATESEND_POOL_MAX;
+
+    return nNeedsToAnonymizeBalance;
+}
+
+CAmount CWallet::GetDenominatedBalance(bool unconfirmed) const {
+    if (fLiteMode) return 0;
+
+    CAmount nTotal = 0;
+    {
+        LOCK2(cs_main, cs_wallet);
+        for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) {
+            const CWalletTx *pcoin = &(*it).second;
+
+//            nTotal += pcoin->GetDenominatedCredit(unconfirmed);
+        }
+    }
+
+    return nTotal;
+}
+
+
 CAmount CWallet::GetUnconfirmedBalance() const {
     CAmount nTotal = 0;
     {
@@ -1729,6 +1861,158 @@ CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const {
     return nTotal;
 }
 
+// Recursively determine the rounds of a given input (How deep is the PrivateSend chain for a given input)
+int CWallet::GetRealInputPrivateSendRounds(CTxIn txin, int nRounds) const
+{
+    static std::map<uint256, CMutableTransaction> mDenomWtxes;
+
+    if(nRounds >= 16) return 15; // 16 rounds max
+
+    uint256 hash = txin.prevout.hash;
+    unsigned int nout = txin.prevout.n;
+
+    const CWalletTx* wtx = GetWalletTx(hash);
+    if(wtx != NULL)
+    {
+        std::map<uint256, CMutableTransaction>::const_iterator mdwi = mDenomWtxes.find(hash);
+        if (mdwi == mDenomWtxes.end()) {
+            // not known yet, let's add it
+            LogPrint("privatesend", "GetRealInputPrivateSendRounds INSERTING %s\n", hash.ToString());
+            mDenomWtxes[hash] = CMutableTransaction(*wtx);
+        } else if(mDenomWtxes[hash].vout[nout].nRounds != -10) {
+            // found and it's not an initial value, just return it
+            return mDenomWtxes[hash].vout[nout].nRounds;
+        }
+
+
+        // bounds check
+        if (nout >= wtx->vout.size()) {
+            // should never actually hit this
+            LogPrint("privatesend", "GetRealInputPrivateSendRounds UPDATED   %s %3d %3d\n", hash.ToString(), nout, -4);
+            return -4;
+        }
+
+        if (IsCollateralAmount(wtx->vout[nout].nValue)) {
+            mDenomWtxes[hash].vout[nout].nRounds = -3;
+            LogPrint("privatesend", "GetRealInputPrivateSendRounds UPDATED   %s %3d %3d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
+            return mDenomWtxes[hash].vout[nout].nRounds;
+        }
+
+        //make sure the final output is non-denominate
+        if (!IsDenominatedAmount(wtx->vout[nout].nValue)) { //NOT DENOM
+            mDenomWtxes[hash].vout[nout].nRounds = -2;
+            LogPrint("privatesend", "GetRealInputPrivateSendRounds UPDATED   %s %3d %3d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
+            return mDenomWtxes[hash].vout[nout].nRounds;
+        }
+
+        bool fAllDenoms = true;
+        BOOST_FOREACH(CTxOut out, wtx->vout) {
+            fAllDenoms = fAllDenoms && IsDenominatedAmount(out.nValue);
+        }
+
+        // this one is denominated but there is another non-denominated output found in the same tx
+        if (!fAllDenoms) {
+            mDenomWtxes[hash].vout[nout].nRounds = 0;
+            LogPrint("privatesend", "GetRealInputPrivateSendRounds UPDATED   %s %3d %3d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
+            return mDenomWtxes[hash].vout[nout].nRounds;
+        }
+
+        int nShortest = -10; // an initial value, should be no way to get this by calculations
+        bool fDenomFound = false;
+        // only denoms here so let's look up
+        BOOST_FOREACH(CTxIn txinNext, wtx->vin) {
+            if (IsMine(txinNext)) {
+                int n = GetRealInputPrivateSendRounds(txinNext, nRounds + 1);
+                // denom found, find the shortest chain or initially assign nShortest with the first found value
+                if(n >= 0 && (n < nShortest || nShortest == -10)) {
+                    nShortest = n;
+                    fDenomFound = true;
+                }
+            }
+        }
+        mDenomWtxes[hash].vout[nout].nRounds = fDenomFound
+                                               ? (nShortest >= 15 ? 16 : nShortest + 1) // good, we a +1 to the shortest one but only 16 rounds max allowed
+                                               : 0;            // too bad, we are the fist one in that chain
+        LogPrint("privatesend", "GetRealInputPrivateSendRounds UPDATED   %s %3d %3d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
+        return mDenomWtxes[hash].vout[nout].nRounds;
+    }
+
+    return nRounds - 1;
+}
+
+// respect current settings
+int CWallet::GetInputPrivateSendRounds(CTxIn txin) const
+{
+    LOCK(cs_wallet);
+    int realPrivateSendRounds = GetRealInputPrivateSendRounds(txin, 0);
+    return realPrivateSendRounds > nPrivateSendRounds ? nPrivateSendRounds : realPrivateSendRounds;
+}
+
+
+bool CWallet::IsDenominated(const CTxIn &txin) const {
+    LOCK(cs_wallet);
+
+    map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
+    if (mi != mapWallet.end()) {
+        const CWalletTx &prev = (*mi).second;
+        if (txin.prevout.n < prev.vout.size()) {
+            return IsDenominatedAmount(prev.vout[txin.prevout.n].nValue);
+        }
+    }
+
+    return false;
+}
+
+bool CWallet::IsDenominatedAmount(CAmount nInputAmount) const {
+    BOOST_FOREACH(CAmount d, vecPrivateSendDenominations)
+    if(nInputAmount == d)
+        return true;
+    return false;
+}
+
+int CWallet::CountInputsWithAmount(CAmount nInputAmount) {
+    CAmount nTotal = 0;
+    {
+        LOCK2(cs_main, cs_wallet);
+        for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) {
+            const CWalletTx *pcoin = &(*it).second;
+            if (pcoin->IsTrusted()) {
+                int nDepth = pcoin->GetDepthInMainChain(false);
+
+                for (unsigned int i = 0; i < pcoin->vout.size(); i++) {
+                    COutput out = COutput(pcoin, i, nDepth, true, true);
+                    CTxIn txin = CTxIn(out.tx->GetHash(), out.i);
+
+                    if (out.tx->vout[out.i].nValue != nInputAmount) continue;
+                    if (!IsDenominatedAmount(pcoin->vout[i].nValue)) continue;
+                    if (IsSpent(out.tx->GetHash(), i) || IsMine(pcoin->vout[i]) != ISMINE_SPENDABLE ||
+                        !IsDenominated(txin))
+                        continue;
+
+                    nTotal++;
+                }
+            }
+        }
+    }
+
+    return nTotal;
+}
+
+bool CWallet::HasCollateralInputs(bool fOnlyConfirmed) const {
+    vector <COutput> vCoins;
+    AvailableCoins(vCoins, fOnlyConfirmed, NULL, false, ONLY_PRIVATESEND_COLLATERAL);
+
+    return !vCoins.empty();
+}
+
+
+bool CWallet::IsCollateralAmount(CAmount nInputAmount) const {
+    // collateral inputs should always be a 2x..4x of PRIVATESEND_COLLATERAL
+    return nInputAmount >= PRIVATESEND_COLLATERAL * 2 &&
+           nInputAmount <= PRIVATESEND_COLLATERAL * 4 &&
+           nInputAmount % PRIVATESEND_COLLATERAL == 0;
+}
+
 CAmount CWallet::GetImmatureWatchOnlyBalance() const {
     CAmount nTotal = 0;
     {
@@ -1742,7 +2026,7 @@ CAmount CWallet::GetImmatureWatchOnlyBalance() const {
 }
 
 void CWallet::AvailableCoins(vector <COutput> &vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl,
-                             bool fIncludeZeroValue) const {
+                             bool fIncludeZeroValue, AvailableCoinsType nCoinType, bool fUseInstantSend) const {
     vCoins.clear();
 
     {
@@ -1760,9 +2044,10 @@ void CWallet::AvailableCoins(vector <COutput> &vCoins, bool fOnlyConfirmed, cons
             if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
                 continue;
 
-            int nDepth = pcoin->GetDepthInMainChain();
-            if (nDepth < 0)
-                continue;
+            int nDepth = pcoin->GetDepthInMainChain(false);
+            // do not use IX for inputs that have less then INSTANTSEND_CONFIRMATIONS_REQUIRED blockchain confirmations
+//            if (fUseInstantSend && nDepth < INSTANTSEND_CONFIRMATIONS_REQUIRED)
+//                continue;
 
             // We should not consider coins which aren't at least in our mempool
             // It's possible for these to be conflicted via ancestors which we may never be able to detect
@@ -1770,20 +2055,177 @@ void CWallet::AvailableCoins(vector <COutput> &vCoins, bool fOnlyConfirmed, cons
                 continue;
 
             for (unsigned int i = 0; i < pcoin->vout.size(); i++) {
+                bool found = false;
+                if (nCoinType == ONLY_DENOMINATED) {
+                    found = IsDenominatedAmount(pcoin->vout[i].nValue);
+                } else if (nCoinType == ONLY_NOT1000IFMN) {
+                    found = !(fZNode && pcoin->vout[i].nValue == ZNODE_COIN_REQUIRED * COIN);
+                } else if (nCoinType == ONLY_NONDENOMINATED_NOT1000IFMN) {
+                    if (IsCollateralAmount(pcoin->vout[i].nValue)) continue; // do not use collateral amounts
+                    found = !IsDenominatedAmount(pcoin->vout[i].nValue);
+                    if (found && fZNode) found = pcoin->vout[i].nValue != ZNODE_COIN_REQUIRED * COIN; // do not use Hot MN funds
+                } else if (nCoinType == ONLY_1000) {
+                    LogPrintf("nCoinType = ONLY_1000\n");
+                    LogPrintf("pcoin->vout[i].nValue = %s\n", pcoin->vout[i].nValue);
+                    found = pcoin->vout[i].nValue == ZNODE_COIN_REQUIRED * COIN;
+                } else if (nCoinType == ONLY_PRIVATESEND_COLLATERAL) {
+                    found = IsCollateralAmount(pcoin->vout[i].nValue);
+                } else {
+                    found = true;
+                }
+                if (!found) continue;
+
                 isminetype mine = IsMine(pcoin->vout[i]);
-                if (!(IsSpent(wtxid, i)) && mine != ISMINE_NO &&
-                    !IsLockedCoin((*it).first, i) && (pcoin->vout[i].nValue > nMinimumInputValue) &&
-                    (!coinControl || !coinControl->HasSelected() || coinControl->fAllowOtherInputs ||
-                     coinControl->IsSelected(COutPoint((*it).first, i))))
+                LogPrintf("!(IsSpent(wtxid, i)) = %s\n", !(IsSpent(wtxid, i)));
+                LogPrintf("mine != ISMINE_NO = %s\n", mine != ISMINE_NO);
+                LogPrintf("(!IsLockedCoin((*it).first, i) || nCoinType == ONLY_1000) = %s\n", (!IsLockedCoin((*it).first, i) || nCoinType == ONLY_1000));
+                LogPrintf("(pcoin->vout[i].nValue > nMinimumInputValue) = %s\n", (pcoin->vout[i].nValue > nMinimumInputValue));
+                LogPrintf("!coinControl = %s\n", (
+                        !coinControl ||
+                        !coinControl->HasSelected() ||
+                        coinControl->fAllowOtherInputs ||
+                        coinControl->IsSelected(COutPoint((*it).first, i))
+                ));
+//                LogPrintf("!coinControl->HasSelected() = %s\n", !coinControl->HasSelected());
+//                LogPrintf("coinControl->fAllowOtherInputs = %s\n", coinControl->fAllowOtherInputs);
+//                LogPrintf("coinControl->IsSelected(COutPoint((*it).first, i)) = %s\n", coinControl->IsSelected(COutPoint((*it).first, i)));
+                if (!(IsSpent(wtxid, i)) &&
+                        mine != ISMINE_NO &&
+                        (!IsLockedCoin((*it).first, i) || nCoinType == ONLY_1000) &&
+                        (pcoin->vout[i].nValue > nMinimumInputValue) &&
+                        (
+                                !coinControl ||
+                                !coinControl->HasSelected() ||
+                                coinControl->fAllowOtherInputs ||
+                                coinControl->IsSelected(COutPoint((*it).first, i))
+                        )
+                    ) {
                     vCoins.push_back(COutput(pcoin, i, nDepth,
                                              ((mine & ISMINE_SPENDABLE) != ISMINE_NO) ||
                                              (coinControl && coinControl->fAllowWatchOnly &&
                                               (mine & ISMINE_WATCH_SOLVABLE) != ISMINE_NO),
                                              (mine & (ISMINE_SPENDABLE | ISMINE_WATCH_SOLVABLE)) != ISMINE_NO));
+                }
             }
         }
     }
 }
+
+
+bool CWallet::SelectCoinsDark(CAmount nValueMin, CAmount nValueMax, std::vector <CTxIn> &vecTxInRet, CAmount &nValueRet,
+                              int nPrivateSendRoundsMin, int nPrivateSendRoundsMax) const {
+    CCoinControl *coinControl = NULL;
+
+    vecTxInRet.clear();
+    nValueRet = 0;
+
+    vector <COutput> vCoins;
+    AvailableCoins(vCoins, true, coinControl, false, nPrivateSendRoundsMin < 0 ? ONLY_NONDENOMINATED_NOT1000IFMN : ONLY_DENOMINATED);
+
+    //order the array so largest nondenom are first, then denominations, then very small inputs.
+    sort(vCoins.rbegin(), vCoins.rend(), CompareByPriority());
+
+    BOOST_FOREACH(const COutput &out, vCoins)
+    {
+        //do not allow inputs less than 1/10th of minimum value
+        if (out.tx->vout[out.i].nValue < nValueMin / 10) continue;
+        //do not allow collaterals to be selected
+        if (IsCollateralAmount(out.tx->vout[out.i].nValue)) continue;
+        if (fZNode && out.tx->vout[out.i].nValue == ZNODE_COIN_REQUIRED * COIN) continue; //znode input
+
+        if (nValueRet + out.tx->vout[out.i].nValue <= nValueMax) {
+            CTxIn txin = CTxIn(out.tx->GetHash(), out.i);
+
+            int nRounds = GetInputPrivateSendRounds(txin);
+            if (nRounds >= nPrivateSendRoundsMax) continue;
+            if (nRounds < nPrivateSendRoundsMin) continue;
+
+            txin.prevPubKey = out.tx->vout[out.i].scriptPubKey; // the inputs PubKey
+            nValueRet += out.tx->vout[out.i].nValue;
+            vecTxInRet.push_back(txin);
+        }
+    }
+
+    return nValueRet >= nValueMin;
+}
+
+// znode
+bool CWallet::GetCollateralTxIn(CTxIn& txinRet, CAmount& nValueRet) const
+{
+    vector<COutput> vCoins;
+
+    AvailableCoins(vCoins);
+
+    BOOST_FOREACH(const COutput& out, vCoins)
+    {
+        if(IsCollateralAmount(out.tx->vout[out.i].nValue))
+        {
+            txinRet = CTxIn(out.tx->GetHash(), out.i);
+            txinRet.prevPubKey = out.tx->vout[out.i].scriptPubKey; // the inputs PubKey
+            nValueRet = out.tx->vout[out.i].nValue;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CWallet::GetZnodeVinAndKeys(CTxIn &txinRet, CPubKey &pubKeyRet, CKey &keyRet, std::string strTxHash,
+                                 std::string strOutputIndex) {
+    // wait for reindex and/or import to finish
+    if (fImporting || fReindex) return false;
+
+    // Find possible candidates
+    std::vector <COutput> vPossibleCoins;
+    AvailableCoins(vPossibleCoins, true, NULL, false, ONLY_1000);
+    if (vPossibleCoins.empty()) {
+        LogPrintf("CWallet::GetZnodeVinAndKeys -- Could not locate any valid znode vin\n");
+        return false;
+    }
+
+    if (strTxHash.empty()) // No output specified, select the first one
+        return GetVinAndKeysFromOutput(vPossibleCoins[0], txinRet, pubKeyRet, keyRet);
+
+    // Find specific vin
+    uint256 txHash = uint256S(strTxHash);
+    int nOutputIndex = atoi(strOutputIndex.c_str());
+
+    BOOST_FOREACH(COutput & out, vPossibleCoins)
+    if (out.tx->GetHash() == txHash && out.i == nOutputIndex) // found it!
+        return GetVinAndKeysFromOutput(out, txinRet, pubKeyRet, keyRet);
+
+    LogPrintf("CWallet::GetZnodeVinAndKeys -- Could not locate specified znode vin\n");
+    return false;
+}
+
+bool CWallet::GetVinAndKeysFromOutput(COutput out, CTxIn &txinRet, CPubKey &pubKeyRet, CKey &keyRet) {
+    // wait for reindex and/or import to finish
+    if (fImporting || fReindex) return false;
+
+    CScript pubScript;
+
+    txinRet = CTxIn(out.tx->GetHash(), out.i);
+    pubScript = out.tx->vout[out.i].scriptPubKey; // the inputs PubKey
+
+    CTxDestination address1;
+    ExtractDestination(pubScript, address1);
+    CBitcoinAddress address2(address1);
+
+    CKeyID keyID;
+    if (!address2.GetKeyID(keyID)) {
+        LogPrintf("CWallet::GetVinAndKeysFromOutput -- Address does not refer to a key\n");
+        return false;
+    }
+
+    if (!GetKey(keyID, keyRet)) {
+        LogPrintf("CWallet::GetVinAndKeysFromOutput -- Private key for address is not known\n");
+        return false;
+    }
+
+    pubKeyRet = keyRet.GetPubKey();
+    return true;
+}
+
 //[zcoin]
 void CWallet::ListAvailableCoinsMintCoins(vector <COutput> &vCoins, bool fOnlyConfirmed) const {
     vCoins.clear();
@@ -1848,9 +2290,10 @@ void CWallet::ListAvailableCoinsMintCoins(vector <COutput> &vCoins, bool fOnlyCo
     }
 }
 
-static void ApproximateBestSubset(vector <pair<CAmount, pair<const CWalletTx *, unsigned int> >> vValue, const CAmount &nTotalLower,
-                      const CAmount &nTargetValue,
-                      vector<char> &vfBest, CAmount &nBest, int iterations = 1000) {
+static void ApproximateBestSubset(vector <pair<CAmount, pair<const CWalletTx *, unsigned int> >> vValue,
+                                  const CAmount &nTotalLower,
+                                  const CAmount &nTargetValue,
+                                  vector<char> &vfBest, CAmount &nBest, int iterations = 1000) {
     vector<char> vfIncluded;
 
     vfBest.assign(vValue.size(), true);
@@ -1890,7 +2333,8 @@ static void ApproximateBestSubset(vector <pair<CAmount, pair<const CWalletTx *,
 
 bool CWallet::SelectCoinsMinConf(const CAmount &nTargetValue, const int nConfMine, const int nConfTheirs,
                                  const uint64_t nMaxAncestors, vector <COutput> vCoins,
-                                 set <pair<const CWalletTx *, unsigned int>> &setCoinsRet, CAmount &nValueRet) const {
+                                 set <pair<const CWalletTx *, unsigned int>> &setCoinsRet,
+                                 CAmount &nValueRet) const {
     setCoinsRet.clear();
     nValueRet = 0;
 
@@ -1903,8 +2347,7 @@ bool CWallet::SelectCoinsMinConf(const CAmount &nTargetValue, const int nConfMin
 
     random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
 
-    BOOST_FOREACH(
-    const COutput &output, vCoins)
+    BOOST_FOREACH(const COutput &output, vCoins)
     {
         if (!output.fSpendable)
             continue;
@@ -1985,22 +2428,49 @@ bool CWallet::SelectCoinsMinConf(const CAmount &nTargetValue, const int nConfMin
 
 bool CWallet::SelectCoins(const vector <COutput> &vAvailableCoins, const CAmount &nTargetValue,
                           set <pair<const CWalletTx *, unsigned int>> &setCoinsRet, CAmount &nValueRet,
-                          const CCoinControl *coinControl) const {
+                          const CCoinControl *coinControl, AvailableCoinsType nCoinType, bool fUseInstantSend) const {
     vector <COutput> vCoins(vAvailableCoins);
 
     // coin control -> return all selected outputs (we want all selected to go into the transaction for sure)
     if (coinControl && coinControl->HasSelected() && !coinControl->fAllowOtherInputs) {
-        BOOST_FOREACH(
-        const COutput &out, vCoins)
+        BOOST_FOREACH(const COutput &out, vCoins)
         {
             if (!out.fSpendable)
                 continue;
+            if (nCoinType == ONLY_DENOMINATED) {
+                CTxIn txin = CTxIn(out.tx->GetHash(), out.i);
+                int nRounds = GetInputPrivateSendRounds(txin);
+                // make sure it's actually anonymized
+                if (nRounds < nPrivateSendRounds) continue;
+            }
             nValueRet += out.tx->vout[out.i].nValue;
             setCoinsRet.insert(make_pair(out.tx, out.i));
         }
         return (nValueRet >= nTargetValue);
     }
 
+    //if we're doing only denominated, we need to round up to the nearest smallest denomination
+    if (nCoinType == ONLY_DENOMINATED) {
+        CAmount nSmallestDenom = vecPrivateSendDenominations.back();
+        // Make outputs by looping through denominations, from large to small
+        BOOST_FOREACH(CAmount nDenom, vecPrivateSendDenominations)
+        {
+            BOOST_FOREACH(const COutput &out, vCoins)
+            {
+                //make sure it's the denom we're looking for, round the amount up to smallest denom
+                if (out.tx->vout[out.i].nValue == nDenom && nValueRet + nDenom < nTargetValue + nSmallestDenom) {
+                    CTxIn txin = CTxIn(out.tx->GetHash(), out.i);
+                    int nRounds = GetInputPrivateSendRounds(txin);
+                    // make sure it's actually anonymized
+                    if (nRounds < nPrivateSendRounds) continue;
+                    nValueRet += nDenom;
+                    setCoinsRet.insert(make_pair(out.tx, out.i));
+                }
+            }
+        }
+        return (nValueRet >= nTargetValue);
+    }
+
     // calculate value from preset inputs and store them
     set <pair<const CWalletTx *, uint32_t>> setPresetCoins;
     CAmount nValueFromPresetInputs = 0;
@@ -2008,8 +2478,7 @@ bool CWallet::SelectCoins(const vector <COutput> &vAvailableCoins, const CAmount
     std::vector <COutPoint> vPresetInputs;
     if (coinControl)
         coinControl->ListSelected(vPresetInputs);
-    BOOST_FOREACH(
-    const COutPoint &outpoint, vPresetInputs)
+    BOOST_FOREACH(const COutPoint &outpoint, vPresetInputs)
     {
         map<uint256, CWalletTx>::const_iterator it = mapWallet.find(outpoint.hash);
         if (it != mapWallet.end()) {
@@ -2040,7 +2509,8 @@ bool CWallet::SelectCoins(const vector <COutput> &vAvailableCoins, const CAmount
                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 6, 0, vCoins, setCoinsRet, nValueRet) ||
                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 1, 0, vCoins, setCoinsRet, nValueRet) ||
                (bSpendZeroConfChange &&
-                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, 2, vCoins, setCoinsRet, nValueRet)) ||
+                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, 2, vCoins, setCoinsRet,
+                                   nValueRet)) ||
                (bSpendZeroConfChange && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1,
                                                            std::min((size_t) 4, nMaxChainLength / 3), vCoins,
                                                            setCoinsRet, nValueRet)) ||
@@ -2048,10 +2518,12 @@ bool CWallet::SelectCoins(const vector <COutput> &vAvailableCoins, const CAmount
                 SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, nMaxChainLength / 2, vCoins,
                                    setCoinsRet, nValueRet)) ||
                (bSpendZeroConfChange &&
-                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, nMaxChainLength, vCoins, setCoinsRet,
+                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, nMaxChainLength, vCoins,
+                                   setCoinsRet,
                                    nValueRet)) ||
                (bSpendZeroConfChange && !fRejectLongChains &&
-                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, std::numeric_limits<uint64_t>::max(),
+                SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1,
+                                   std::numeric_limits<uint64_t>::max(),
                                    vCoins, setCoinsRet, nValueRet));
 
     // because SelectCoinsMinConf clears the setCoinsRet, we now add the possible inputs to the coinset
@@ -2069,8 +2541,7 @@ bool CWallet::FundTransaction(CMutableTransaction &tx, CAmount &nFeeRet, bool ov
     vector <CRecipient> vecSend;
 
     // Turn the txout set into a CRecipient vector
-    BOOST_FOREACH(
-    const CTxOut &txOut, tx.vout)
+    BOOST_FOREACH(const CTxOut &txOut, tx.vout)
     {
         CRecipient recipient = {txOut.scriptPubKey, txOut.nValue, false};
         vecSend.push_back(recipient);
@@ -2083,9 +2554,8 @@ bool CWallet::FundTransaction(CMutableTransaction &tx, CAmount &nFeeRet, bool ov
     coinControl.fOverrideFeeRate = overrideEstimatedFeeRate;
     coinControl.nFeeRate = specificFeeRate;
 
-    BOOST_FOREACH(
-    const CTxIn &txin, tx.vin)
-    coinControl.Select(txin.prevout);
+    BOOST_FOREACH(const CTxIn &txin, tx.vin)
+        coinControl.Select(txin.prevout);
 
     CReserveKey reservekey(this);
     CWalletTx wtx;
@@ -2096,8 +2566,7 @@ bool CWallet::FundTransaction(CMutableTransaction &tx, CAmount &nFeeRet, bool ov
         tx.vout.insert(tx.vout.begin() + nChangePosInOut, wtx.vout[nChangePosInOut]);
 
     // Add new txins (keeping original txin scriptSig/order)
-    BOOST_FOREACH(
-    const CTxIn &txin, wtx.vin)
+    BOOST_FOREACH(const CTxIn &txin, wtx.vin)
     {
         if (!coinControl.IsSelected(txin.prevout)) {
             tx.vin.push_back(txin);
@@ -2112,10 +2581,205 @@ bool CWallet::FundTransaction(CMutableTransaction &tx, CAmount &nFeeRet, bool ov
     return true;
 }
 
+bool CWallet::ConvertList(std::vector <CTxIn> vecTxIn, std::vector <CAmount> &vecAmounts) {
+    BOOST_FOREACH(CTxIn txin, vecTxIn) {
+        if (mapWallet.count(txin.prevout.hash)) {
+            CWalletTx &wtx = mapWallet[txin.prevout.hash];
+            if (txin.prevout.n < wtx.vout.size()) {
+                vecAmounts.push_back(wtx.vout[txin.prevout.n].nValue);
+            }
+        } else {
+            LogPrintf("CWallet::ConvertList -- Couldn't find transaction\n");
+        }
+    }
+    return true;
+}
+
+bool CWallet::SelectCoinsByDenominations(int nDenom, CAmount nValueMin, CAmount nValueMax,
+                                         std::vector <CTxIn> &vecTxInRet, std::vector <COutput> &vCoinsRet,
+                                         CAmount &nValueRet, int nPrivateSendRoundsMin, int nPrivateSendRoundsMax) {
+    vecTxInRet.clear();
+    vCoinsRet.clear();
+    nValueRet = 0;
+
+    vector <COutput> vCoins;
+    AvailableCoins(vCoins, true, NULL, false, ONLY_DENOMINATED);
+
+    std::random_shuffle(vCoins.rbegin(), vCoins.rend(), GetRandInt);
+
+    // ( bit on if present )
+    // bit 0 - 100ZCOIN+1
+    // bit 1 - 10ZCOIN+1
+    // bit 2 - 1ZCOIN+1
+    // bit 3 - .1ZCOIN+1
+
+    std::vector<int> vecBits;
+    if (!darkSendPool.GetDenominationsBits(nDenom, vecBits)) {
+        return false;
+    }
+
+    int nDenomResult = 0;
+
+    InsecureRand insecureRand;
+    BOOST_FOREACH(const COutput &out, vCoins)
+    {
+        // znode-like input should not be selected by AvailableCoins now anyway
+        //if(out.tx->vout[out.i].nValue == 1000*COIN) continue;
+        if (nValueRet + out.tx->vout[out.i].nValue <= nValueMax) {
+
+            CTxIn txin = CTxIn(out.tx->GetHash(), out.i);
+
+            int nRounds = GetInputPrivateSendRounds(txin);
+            if (nRounds >= nPrivateSendRoundsMax) continue;
+            if (nRounds < nPrivateSendRoundsMin) continue;
+
+            BOOST_FOREACH(int nBit, vecBits) {
+                if (out.tx->vout[out.i].nValue == vecPrivateSendDenominations[nBit]) {
+                    if (nValueRet >= nValueMin) {
+                        //randomly reduce the max amount we'll submit (for anonymity)
+                        nValueMax -= insecureRand(nValueMax/5);
+                        //on average use 50% of the inputs or less
+                        int r = insecureRand(vCoins.size());
+                        if ((int) vecTxInRet.size() > r) return true;
+                    }
+                    txin.prevPubKey = out.tx->vout[out.i].scriptPubKey; // the inputs PubKey
+                    nValueRet += out.tx->vout[out.i].nValue;
+                    vecTxInRet.push_back(txin);
+                    vCoinsRet.push_back(out);
+                    nDenomResult |= 1 << nBit;
+                }
+            }
+        }
+    }
+
+    return nValueRet >= nValueMin && nDenom == nDenomResult;
+}
+
+bool CWallet::CreateCollateralTransaction(CMutableTransaction &txCollateral, std::string &strReason) {
+    txCollateral.vin.clear();
+    txCollateral.vout.clear();
+
+    CReserveKey reservekey(this);
+    CAmount nValue = 0;
+    CTxIn txinCollateral;
+
+    if (!GetCollateralTxIn(txinCollateral, nValue)) {
+        strReason = "PrivateSend requires a collateral transaction and could not locate an acceptable input!";
+        return false;
+    }
+
+    // make our change address
+    CScript scriptChange;
+    CPubKey vchPubKey;
+    assert(reservekey.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
+    scriptChange = GetScriptForDestination(vchPubKey.GetID());
+    reservekey.KeepKey();
+
+    txCollateral.vin.push_back(txinCollateral);
+
+    //pay collateral charge in fees
+    CTxOut txout = CTxOut(nValue - PRIVATESEND_COLLATERAL, scriptChange);
+    txCollateral.vout.push_back(txout);
+    CAmount amount;
+    if (!SignSignature(*this, txinCollateral.prevPubKey, txCollateral, 0, amount, int(SIGHASH_ALL | SIGHASH_ANYONECANPAY))) {
+        strReason = "Unable to sign collateral transaction!";
+        return false;
+    }
+
+    return true;
+}
+
+bool CWallet::SelectCoinsGrouppedByAddresses(std::vector <CompactTallyItem> &vecTallyRet, bool fSkipDenominated,
+                                             bool fAnonymizable) const {
+    LOCK2(cs_main, cs_wallet);
+
+    isminefilter filter = ISMINE_SPENDABLE;
+
+    // try to use cache
+    if (fAnonymizable) {
+        if(fSkipDenominated && fAnonymizableTallyCachedNonDenom) {
+            vecTallyRet = vecAnonymizableTallyCachedNonDenom;
+            LogPrint("selectcoins", "SelectCoinsGrouppedByAddresses - using cache for non-denom inputs\n");
+            return vecTallyRet.size() > 0;
+        }
+        if(!fSkipDenominated && fAnonymizableTallyCached) {
+            vecTallyRet = vecAnonymizableTallyCached;
+            LogPrint("selectcoins", "SelectCoinsGrouppedByAddresses - using cache for all inputs\n");
+            return vecTallyRet.size() > 0;
+        }
+    }
+
+    // Tally
+    map <CBitcoinAddress, CompactTallyItem> mapTally;
+    for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) {
+        const CWalletTx &wtx = (*it).second;
+
+        if (wtx.IsCoinBase() && wtx.GetBlocksToMaturity() > 0) continue;
+        if (!fAnonymizable && !wtx.IsTrusted()) continue;
+
+        for (unsigned int i = 0; i < wtx.vout.size(); i++) {
+            CTxDestination address;
+            if (!ExtractDestination(wtx.vout[i].scriptPubKey, address)) continue;
+
+            isminefilter mine = ::IsMine(*this, address);
+            if (!(mine & filter)) continue;
+
+            if (IsSpent(wtx.GetHash(), i) || IsLockedCoin(wtx.GetHash(), i)) continue;
+
+            if (fSkipDenominated && IsDenominatedAmount(wtx.vout[i].nValue)) continue;
+
+            if (fAnonymizable) {
+                // ignore collaterals
+                if (IsCollateralAmount(wtx.vout[i].nValue)) continue;
+                if (fZNode && wtx.vout[i].nValue == ZNODE_COIN_REQUIRED * COIN) continue;
+                // ignore outputs that are 10 times smaller then the smallest denomination
+                // otherwise they will just lead to higher fee / lower priority
+                if (wtx.vout[i].nValue <= vecPrivateSendDenominations.back() / 10) continue;
+                // ignore anonymized
+                if(GetInputPrivateSendRounds(CTxIn(wtx.GetHash(), i)) >= nPrivateSendRounds) continue;
+            }
+
+            CompactTallyItem &item = mapTally[address];
+            item.address = address;
+            item.nAmount += wtx.vout[i].nValue;
+            item.vecTxIn.push_back(CTxIn(wtx.GetHash(), i));
+        }
+    }
+
+    // construct resulting vector
+    vecTallyRet.clear();
+    BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, CompactTallyItem)&item, mapTally) {
+        if (fAnonymizable && item.second.nAmount < vecPrivateSendDenominations.back()) continue;
+        vecTallyRet.push_back(item.second);
+    }
+
+    // order by amounts per address, from smallest to largest
+    sort(vecTallyRet.rbegin(), vecTallyRet.rend(), CompareByAmount());
+
+    // cache anonymizable for later use
+    if (fAnonymizable) {
+        if (fSkipDenominated) {
+            vecAnonymizableTallyCachedNonDenom = vecTallyRet;
+            fAnonymizableTallyCachedNonDenom = true;
+        } else {
+            vecAnonymizableTallyCached = vecTallyRet;
+            fAnonymizableTallyCached = true;
+        }
+    }
+
+    // debug
+    std::string strMessage = "SelectCoinsGrouppedByAddresses - vecTallyRet:\n";
+    BOOST_FOREACH(CompactTallyItem & item, vecTallyRet)
+        strMessage += strprintf("  %s %f\n", item.address.ToString().c_str(), float(item.nAmount) / COIN);
+    LogPrint("selectcoins", "%s", strMessage);
+
+    return vecTallyRet.size() > 0;
+}
+
 bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &wtxNew, CReserveKey &reservekey,
                                 CAmount &nFeeRet,
                                 int &nChangePosInOut, std::string &strFailReason, const CCoinControl *coinControl,
-                                bool sign) {
+                                bool sign, AvailableCoinsType nCoinType, bool fUseInstantSend) {
     LogPrintf("CreateTransaction()\n");
     CAmount nValue = 0;
     int nChangePosRequest = nChangePosInOut;
@@ -2175,7 +2839,7 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
         LOCK2(cs_main, cs_wallet);
         {
             std::vector <COutput> vAvailableCoins;
-            AvailableCoins(vAvailableCoins, true, coinControl);
+            AvailableCoins(vAvailableCoins, true, coinControl, false, nCoinType, fUseInstantSend);
 
             nFeeRet = payTxFee.GetFeePerK();
             // Start with no fee and loop until there is enough fee
@@ -2195,24 +2859,12 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
                 {
                     CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
 
-//                    if (recipient.fSubtractFeeFromAmount) {
-//                        txout.nValue -=
-//                                nFeeRet / nSubtractFeeFromAmount; // Subtract fee equally from each selected recipient
-//
-//                        if (fFirst) // first receiver pays the remainder not divisible by output count
-//                        {
-//                            fFirst = false;
-//                            txout.nValue -= nFeeRet % nSubtractFeeFromAmount;
-//                        }
-//                    }
-
                     if (txout.IsDust(::minRelayTxFee)) {
                         if (recipient.fSubtractFeeFromAmount && nFeeRet > 0) {
                             if (txout.nValue < 0)
                                 strFailReason = _("The transaction amount is too small to pay the fee");
                             else
-                                strFailReason = _(
-                                        "The transaction amount is too small to send after the fee has been deducted");
+                                strFailReason = _("The transaction amount is too small to send after the fee has been deducted");
                         } else
                             strFailReason = _("Transaction amount too small");
                         return false;
@@ -2224,9 +2876,19 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
                 set <pair<const CWalletTx *, unsigned int>> setCoins;
                 CAmount nValueIn = 0;
                 if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins, nValueIn, coinControl)) {
-                    strFailReason = _("Insufficient funds");
+                    if (nCoinType == ONLY_NOT1000IFMN) {
+                        strFailReason = _("Unable to locate enough funds for this transaction that are not equal 1000 XZC.");
+                    } else if (nCoinType == ONLY_NONDENOMINATED_NOT1000IFMN) {
+                        strFailReason = _("Unable to locate enough PrivateSend non-denominated funds for this transaction that are not equal 1000 XZC.");
+                    } else if (nCoinType == ONLY_DENOMINATED) {
+                        strFailReason = _("Unable to locate enough PrivateSend denominated funds for this transaction.");
+                        strFailReason += _("PrivateSend uses exact denominated amounts to send funds, you might simply need to anonymize some more coins.");
+                    } else if (nValueIn < nValueToSelect) {
+                        strFailReason = _("Insufficient funds.");
+                    }
                     return false;
                 }
+
                 BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
                 {
                     CAmount nCredit = pcoin.first->vout[pcoin.second].nValue;
@@ -2243,75 +2905,83 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
 
                 const CAmount nChange = nValueIn - nValueToSelect;
                 if (nChange > 0) {
-                    // Fill a vout to ourself
-                    // TODO: pass in scriptChange instead of reservekey so
-                    // change transaction isn't always pay-to-bitcoin-address
-                    CScript scriptChange;
-
-                    // coin control: send change to custom address
-                    if (coinControl && !boost::get<CNoDestination>(&coinControl->destChange))
-                        scriptChange = GetScriptForDestination(coinControl->destChange);
-
-                        // no coin control: send change to newly generated address
-                    else {
-                        // Note: We use a new key here to keep it from being obvious which side is the change.
-                        //  The drawback is that by not reusing a previous key, the change may be lost if a
-                        //  backup is restored, if the backup doesn't have the new private key for the change.
-                        //  If we reused the old key, it would be possible to add code to look for and
-                        //  rediscover unknown transactions that were written with keys of ours to recover
-                        //  post-backup change.
+                    //over pay for denominated transactions
+                    if (nCoinType == ONLY_DENOMINATED) {
+                        nFeeRet += nChange;
+                        wtxNew.mapValue["DS"] = "1";
+                        // recheck skipped denominations during next mixing
+                        darkSendPool.ClearSkippedDenominations();
+                    } else {
+                        // Fill a vout to ourself
+                        // TODO: pass in scriptChange instead of reservekey so
+                        // change transaction isn't always pay-to-bitcoin-address
+                        CScript scriptChange;
+
+                        // coin control: send change to custom address
+                        if (coinControl && !boost::get<CNoDestination>(&coinControl->destChange))
+                            scriptChange = GetScriptForDestination(coinControl->destChange);
+
+                            // no coin control: send change to newly generated address
+                        else {
+                            // Note: We use a new key here to keep it from being obvious which side is the change.
+                            //  The drawback is that by not reusing a previous key, the change may be lost if a
+                            //  backup is restored, if the backup doesn't have the new private key for the change.
+                            //  If we reused the old key, it would be possible to add code to look for and
+                            //  rediscover unknown transactions that were written with keys of ours to recover
+                            //  post-backup change.
+
+                            // Reserve a new key pair from key pool
+                            CPubKey vchPubKey;
+                            bool ret;
+                            ret = reservekey.GetReservedKey(vchPubKey);
+                            if (!ret) {
+                                strFailReason = _("Keypool ran out, please call keypoolrefill first");
+                                return false;
+                            }
 
-                        // Reserve a new key pair from key pool
-                        CPubKey vchPubKey;
-                        bool ret;
-                        ret = reservekey.GetReservedKey(vchPubKey);
-                        if (!ret) {
-                            strFailReason = _("Keypool ran out, please call keypoolrefill first");
-                            return false;
+                            scriptChange = GetScriptForDestination(vchPubKey.GetID());
                         }
 
-                        scriptChange = GetScriptForDestination(vchPubKey.GetID());
-                    }
-
-                    CTxOut newTxOut(nChange, scriptChange);
-
-                    // We do not move dust-change to fees, because the sender would end up paying more than requested.
-                    // This would be against the purpose of the all-inclusive feature.
-                    // So instead we raise the change and deduct from the recipient.
-                    if (nSubtractFeeFromAmount > 0 && newTxOut.IsDust(::minRelayTxFee)) {
-                        CAmount nDust = newTxOut.GetDustThreshold(::minRelayTxFee) - newTxOut.nValue;
-                        newTxOut.nValue += nDust; // raise change until no more dust
-                        for (unsigned int i = 0; i < vecSend.size(); i++) // subtract from first recipient
-                        {
-                            if (vecSend[i].fSubtractFeeFromAmount) {
-                                txNew.vout[i].nValue -= nDust;
-                                if (txNew.vout[i].IsDust(::minRelayTxFee)) {
-                                    strFailReason = _(
-                                            "The transaction amount is too small to send after the fee has been deducted");
-                                    return false;
+                        CTxOut newTxOut(nChange, scriptChange);
+
+                        // We do not move dust-change to fees, because the sender would end up paying more than requested.
+                        // This would be against the purpose of the all-inclusive feature.
+                        // So instead we raise the change and deduct from the recipient.
+                        if (nSubtractFeeFromAmount > 0 && newTxOut.IsDust(::minRelayTxFee)) {
+                            CAmount nDust = newTxOut.GetDustThreshold(::minRelayTxFee) - newTxOut.nValue;
+                            newTxOut.nValue += nDust; // raise change until no more dust
+                            for (unsigned int i = 0; i < vecSend.size(); i++) // subtract from first recipient
+                            {
+                                if (vecSend[i].fSubtractFeeFromAmount) {
+                                    txNew.vout[i].nValue -= nDust;
+                                    if (txNew.vout[i].IsDust(::minRelayTxFee)) {
+                                        strFailReason = _(
+                                                "The transaction amount is too small to send after the fee has been deducted");
+                                        return false;
+                                    }
+                                    break;
                                 }
-                                break;
                             }
                         }
-                    }
 
-                    // Never create dust outputs; if we would, just
-                    // add the dust to the fee.
-                    if (newTxOut.IsDust(::minRelayTxFee)) {
-                        nChangePosInOut = -1;
-                        nFeeRet += nChange;
-                        reservekey.ReturnKey();
-                    } else {
-                        if (nChangePosInOut == -1) {
-                            // Insert change txn at random position:
-                            nChangePosInOut = GetRandInt(txNew.vout.size() + 1);
-                        } else if ((unsigned int) nChangePosInOut > txNew.vout.size()) {
-                            strFailReason = _("Change index out of range");
-                            return false;
-                        }
+                        // Never create dust outputs; if we would, just
+                        // add the dust to the fee.
+                        if (newTxOut.IsDust(::minRelayTxFee)) {
+                            nChangePosInOut = -1;
+                            nFeeRet += nChange;
+                            reservekey.ReturnKey();
+                        } else {
+                            if (nChangePosInOut == -1) {
+                                // Insert change txn at random position:
+                                nChangePosInOut = GetRandInt(txNew.vout.size() + 1);
+                            } else if ((unsigned int) nChangePosInOut > txNew.vout.size()) {
+                                strFailReason = _("Change index out of range");
+                                return false;
+                            }
 
-                        vector<CTxOut>::iterator position = txNew.vout.begin() + nChangePosInOut;
-                        txNew.vout.insert(position, newTxOut);
+                            vector<CTxOut>::iterator position = txNew.vout.begin() + nChangePosInOut;
+                            txNew.vout.insert(position, newTxOut);
+                        }
                     }
                 } else
                     reservekey.ReturnKey();
@@ -2332,9 +3002,8 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
                     const CScript &scriptPubKey = coin.first->vout[coin.second].scriptPubKey;
                     SignatureData sigdata;
                     if (sign)
-                        signSuccess = ProduceSignature(TransactionSignatureCreator(this, &txNewConst, nIn,
-                                                                                   coin.first->vout[coin.second].nValue,
-                                                                                   SIGHASH_ALL), scriptPubKey, sigdata);
+                        signSuccess = ProduceSignature(TransactionSignatureCreator(this, &txNewConst, nIn, coin.first->vout[coin.second].nValue, SIGHASH_ALL),
+                                scriptPubKey, sigdata);
                     else
                         signSuccess = ProduceSignature(DummySignatureCreator(this), scriptPubKey, sigdata);
 
@@ -2353,7 +3022,7 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
                 // Remove scriptSigs if we used dummy signatures for fee calculation
                 if (!sign) {
                     BOOST_FOREACH(CTxIn & vin, txNew.vin)
-                    vin.scriptSig = CScript();
+                        vin.scriptSig = CScript();
                     txNew.wit.SetNull();
                 }
 
@@ -2381,6 +3050,9 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
                 fAllowFree = true;// Allow free for send
                 int64_t nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND);
                 int64_t nFeeNeeded = nPayFee;
+                if (fUseInstantSend) {
+                    nFeeNeeded = std::max(nFeeNeeded, CTxLockRequest(txNew).GetMinFee());
+                }
                 if (nFeeNeeded < nMinFee) {
                     nFeeNeeded = nMinFee;
                 }
@@ -2391,28 +3063,6 @@ bool CWallet::CreateTransaction(const vector <CRecipient> &vecSend, CWalletTx &w
                 // Include more fee and try again.
                 nFeeRet = nFeeNeeded;
                 continue;
-
-
-//                CAmount nFeeNeeded = GetMinimumFee(nBytes, nTxConfirmTarget, mempool);
-//                if (coinControl && nFeeNeeded > 0 && coinControl->nMinimumTotalFee > nFeeNeeded) {
-//                    nFeeNeeded = coinControl->nMinimumTotalFee;
-//                }
-//                if (coinControl && coinControl->fOverrideFeeRate)
-//                    nFeeNeeded = coinControl->nFeeRate.GetFee(nBytes);
-
-                // If we made it here and we aren't even able to meet the relay fee on the next pass, give up
-                // because we must be at the maximum allowed fee.
-//                if (nFeeNeeded < ::minRelayTxFee.GetFee(nBytes)) {
-//                    strFailReason = _("Transaction too large for fee policy");
-//                    return false;
-//                }
-
-//                if (nFeeRet >= nFeeNeeded)
-//                    break; // Done, enough fee included.
-
-                // Include more fee and try again.
-//                nFeeRet = nFeeNeeded;
-                continue;
             }
         }
     }
@@ -2458,8 +3108,7 @@ bool CWallet::CommitTransaction(CWalletTx &wtxNew, CReserveKey &reservekey) {
 
             // Notify that old coins are spent
             set < CWalletTx * > setCoins;
-            BOOST_FOREACH(
-            const CTxIn &txin, wtxNew.vin)
+            BOOST_FOREACH(const CTxIn &txin, wtxNew.vin)
             {
                 CWalletTx &coin = mapWallet[txin.prevout.hash];
                 coin.BindWallet(this);
@@ -2489,8 +3138,7 @@ bool CWallet::CommitTransaction(CWalletTx &wtxNew, CReserveKey &reservekey) {
     return true;
 }
 
-bool CWallet::EraseFromWallet(uint256 hash)
-{
+bool CWallet::EraseFromWallet(uint256 hash) {
     if (!fFileBacked)
         return false;
     {
@@ -2501,9 +3149,6 @@ bool CWallet::EraseFromWallet(uint256 hash)
     return true;
 }
 
-/**
-  btzc: add Zerocoin function
-  */
 bool CWallet::CreateZerocoinMintModel(string &stringError, string denomAmount) {
 
     if (!fFileBacked)
@@ -2556,7 +3201,7 @@ bool CWallet::CreateZerocoinMintModel(string &stringError, string denomAmount) {
     BOOST_FOREACH(const CZerocoinEntry &pubCoinIdItem, listPubCoin) {
 		//LogPrintf("denomination = %d, id = %d, height = %d\n", pubCoinIdItem.denomination, pubCoinIdItem.id, pubCoinIdItem.nHeight);
 		if (pubCoinIdItem.id > 0) {
-			if(pubCoinIdItem.nHeight <= chainActive.Height()){
+            if (pubCoinIdItem.nHeight <= chainActive.Height()) {
 				if (pubCoinIdItem.denomination == denomination) {
 					countExistingItems++;
 					if (pubCoinIdItem.id > currentId) {
@@ -2564,7 +3209,7 @@ bool CWallet::CreateZerocoinMintModel(string &stringError, string denomAmount) {
 						countExistingItems = 1;
 					}
 				}
-			}else{
+            } else{
 				break;
 			}
 		}
@@ -2591,7 +3236,8 @@ bool CWallet::CreateZerocoinMintModel(string &stringError, string denomAmount) {
     // Validate
     if (pubCoin.validate()) {
         //TODOS
-        CScript scriptSerializedCoin = CScript() << OP_ZEROCOINMINT << pubCoin.getValue().getvch().size() << pubCoin.getValue().getvch();
+        CScript scriptSerializedCoin =
+                CScript() << OP_ZEROCOINMINT << pubCoin.getValue().getvch().size() << pubCoin.getValue().getvch();
 
         // Wallet comments
         CWalletTx wtx;
@@ -2620,32 +3266,29 @@ bool CWallet::CreateZerocoinMintModel(string &stringError, string denomAmount) {
     }
 }
 
-/**
- * btzc: CreateZerocoinSpendModel
- */
-bool CWallet::CreateZerocoinSpendModel(string &stringError, string denomAmount){
-    if(!fFileBacked)
+bool CWallet::CreateZerocoinSpendModel(string &stringError, string denomAmount) {
+    if (!fFileBacked)
         return false;
 
     int64_t nAmount = 0;
     libzerocoin::CoinDenomination denomination;
     // Amount
-    if(denomAmount == "1"){
+    if (denomAmount == "1") {
         denomination = libzerocoin::ZQ_LOVELACE;
         nAmount = roundint64(1 * COIN);
-    }else if(denomAmount == "10"){
+    } else if (denomAmount == "10") {
         denomination = libzerocoin::ZQ_GOLDWASSER;
         nAmount = roundint64(10 * COIN);
-    }else if(denomAmount == "25"){
+    } else if (denomAmount == "25") {
         denomination = libzerocoin::ZQ_RACKOFF;
         nAmount = roundint64(25 * COIN);
-    }else if(denomAmount == "50"){
+    } else if (denomAmount == "50") {
         denomination = libzerocoin::ZQ_PEDERSEN;
         nAmount = roundint64(50 * COIN);
-    }else if(denomAmount == "100"){
+    } else if (denomAmount == "100") {
         denomination = libzerocoin::ZQ_WILLIAMSON;
         nAmount = roundint64(100 * COIN);
-    }else{
+    } else {
         return false;
     }
 
@@ -2666,7 +3309,7 @@ bool CWallet::CreateZerocoinSpendModel(string &stringError, string denomAmount){
 
 }
 
-/** btzc: add zerocoin transaction
+/**
  * @brief CWallet::CreateZerocoinMintTransaction
  * @param vecSend
  * @param wtxNew
@@ -2676,8 +3319,10 @@ bool CWallet::CreateZerocoinSpendModel(string &stringError, string denomAmount){
  * @param coinControl
  * @return
  */
-bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend, CWalletTx &wtxNew, CReserveKey &reservekey,
-            CAmount &nFeeRet, int &nChangePosInOut, std::string &strFailReason, const CCoinControl *coinControl, bool sign) {
+bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend, CWalletTx &wtxNew,
+                                            CReserveKey &reservekey,
+                                            CAmount &nFeeRet, int &nChangePosInOut, std::string &strFailReason,
+                                            const CCoinControl *coinControl, bool sign) {
     CAmount nValue = 0;
     int nChangePosRequest = nChangePosInOut;
     unsigned int nSubtractFeeFromAmount = 0;
@@ -2711,6 +3356,7 @@ bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend,
             std::vector <COutput> vAvailableCoins;
             AvailableCoins(vAvailableCoins, true, coinControl);
 
+
             nFeeRet = payTxFee.GetFeePerK();
             LogPrintf("nFeeRet=%s\n", nFeeRet);
             // Start with no fee and loop until there is enough fee
@@ -2760,7 +3406,9 @@ bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend,
                 set <pair<const CWalletTx *, unsigned int>> setCoins;
                 CAmount nValueIn = 0;
                 if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins, nValueIn, coinControl)) {
-                    strFailReason = _("Insufficient funds");
+                    if (nValueIn < nValueToSelect) {
+                        strFailReason = _("Insufficient funds.");
+                    }
                     return false;
                 }
                 BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
@@ -2779,8 +3427,7 @@ bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend,
 
                 CAmount nChange = nValueIn - nValueToSelect;
                 // NOTE: this depends on the exact behaviour of GetMinFee
-                if (nFeeRet < CTransaction::nMinTxFee && nChange > 0 && nChange < CENT)
-                {
+                if (nFeeRet < CTransaction::nMinTxFee && nChange > 0 && nChange < CENT) {
                     int64_t nMoveToFee = min(nChange, CTransaction::nMinTxFee - nFeeRet);
                     nChange -= nMoveToFee;
                     nFeeRet += nMoveToFee;
@@ -2792,14 +3439,13 @@ bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend,
                     CScript scriptChange;
 
                     // coin control: send change to custom address
-                    if (coinControl && !boost::get<CNoDestination>(&coinControl->destChange))
-                    {
+                    if (coinControl && !boost::get<CNoDestination>(&coinControl->destChange)) {
                         scriptChange = GetScriptForDestination(coinControl->destChange);
                     }
                         // send change to one of the specified change addresses
-                    else if (mapArgs.count("-change") && mapMultiArgs["-change"].size() > 0)
-                    {
-                        CBitcoinAddress address(mapMultiArgs["-change"][GetRandInt(mapMultiArgs["-change"].size())]);
+                    else if (mapArgs.count("-change") && mapMultiArgs["-change"].size() > 0) {
+                        CBitcoinAddress
+                        address(mapMultiArgs["-change"][GetRandInt(mapMultiArgs["-change"].size())]);
                         CKeyID keyID;
                         if (!address.GetKeyID(keyID)) {
                             strFailReason = _("Bad change address");
@@ -2873,14 +3519,14 @@ bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend,
                 //
                 // Note how the sequence number is set to max()-1 so that the
                 // nLockTime set above actually works.
-                BOOST_FOREACH(const PAIRTYPE(const CWalletTx *, unsigned int) & coin, setCoins)
-                txNew.vin.push_back(CTxIn(coin.first->GetHash(), coin.second, CScript(),
+                BOOST_FOREACH(const PAIRTYPE(const CWalletTx *, unsigned int) &coin, setCoins)
+                    txNew.vin.push_back(CTxIn(coin.first->GetHash(), coin.second, CScript(),
                                           std::numeric_limits < unsigned int > ::max() - 1));
 
                 // Sign
                 int nIn = 0;
                 CTransaction txNewConst(txNew);
-                BOOST_FOREACH(const PAIRTYPE(const CWalletTx *, unsigned int) & coin, setCoins)
+                BOOST_FOREACH(const PAIRTYPE(const CWalletTx *, unsigned int) &coin, setCoins)
                 {
                     bool signSuccess;
                     const CScript &scriptPubKey = coin.first->vout[coin.second].scriptPubKey;
@@ -2888,7 +3534,8 @@ bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend,
                     if (sign)
                         signSuccess = ProduceSignature(TransactionSignatureCreator(this, &txNewConst, nIn,
                                                                                    coin.first->vout[coin.second].nValue,
-                                                                                   SIGHASH_ALL), scriptPubKey, sigdata);
+                                                                                   SIGHASH_ALL), scriptPubKey,
+                                                       sigdata);
                     else
                         signSuccess = ProduceSignature(DummySignatureCreator(this), scriptPubKey, sigdata);
 
@@ -2977,15 +3624,20 @@ bool CWallet::CreateZerocoinMintTransaction(const vector <CRecipient> &vecSend,
     }
     return true;
 }
-bool CWallet::CreateZerocoinMintTransaction(CScript pubCoin, int64_t nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, std::string& strFailReason, const CCoinControl *coinControl){
+
+bool
+CWallet::CreateZerocoinMintTransaction(CScript pubCoin, int64_t nValue, CWalletTx &wtxNew, CReserveKey &reservekey,
+                                       int64_t &nFeeRet, std::string &strFailReason,
+                                       const CCoinControl *coinControl) {
     vector <CRecipient> vecSend;
     CRecipient recipient = {pubCoin, nValue, false};
     vecSend.push_back(recipient);
     int nChangePosRet = -1;
-    return CreateZerocoinMintTransaction(vecSend, wtxNew, reservekey, nFeeRet, nChangePosRet, strFailReason, coinControl);
+    return CreateZerocoinMintTransaction(vecSend, wtxNew, reservekey, nFeeRet, nChangePosRet, strFailReason,
+                                         coinControl);
 }
+
 /**
- * btzc:
  * @brief CWallet::CreateZerocoinSpendTransaction
  * @param nValue
  * @param denomination
@@ -2999,19 +3651,19 @@ bool CWallet::CreateZerocoinMintTransaction(CScript pubCoin, int64_t nValue, CWa
  * @return
  */
 bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDenomination denomination,
-                                CWalletTx& wtxNew, CReserveKey& reservekey, CBigNum& coinSerial, uint256& txHash, CBigNum& zcSelectedValue, bool& zcSelectedIsUsed,  std::string& strFailReason)
-{
-    if (nValue < 0)
-    {
-       strFailReason = _("Transaction amounts must be positive");
-       return false;
+                                             CWalletTx &wtxNew, CReserveKey &reservekey, CBigNum &coinSerial,
+                                             uint256 &txHash, CBigNum &zcSelectedValue, bool &zcSelectedIsUsed,
+                                             std::string &strFailReason) {
+    if (nValue < 0) {
+        strFailReason = _("Transaction amounts must be positive");
+        return false;
     }
 
     wtxNew.BindWallet(this);
     CMutableTransaction txNew;
     txNew.nLockTime = chainActive.Height();
-        if (GetRandInt(10) == 0)
-            txNew.nLockTime = std::max(0, (int) txNew.nLockTime - GetRandInt(100));
+    if (GetRandInt(10) == 0)
+        txNew.nLockTime = std::max(0, (int) txNew.nLockTime - GetRandInt(100));
     {
         LOCK2(cs_main, cs_wallet);
         {
@@ -3029,7 +3681,7 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
             CTxOut newTxOut(nValue, scriptChange);
 
             // Insert change txn at random position:
-            vector<CTxOut>::iterator position = txNew.vout.begin() + GetRandInt(txNew.vout.size()+1);
+            vector<CTxOut>::iterator position = txNew.vout.begin() + GetRandInt(txNew.vout.size() + 1);
             txNew.vout.insert(position, newTxOut);
 //            LogPrintf("txNew:%s\n", txNew.ToString());
             LogPrintf("txNew.GetHash():%s\n", txNew.GetHash().ToString());
@@ -3041,7 +3693,7 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
             static CBigNum bnTrustedModulus;
             bool setParams = bnTrustedModulus.SetHexBool(ZEROCOIN_MODULUS);
             if (!setParams) {
-                LogPrintf("[btzc] bnTrustedModulus.SetHexBool(ZEROCOIN_MODULUS) failed");
+                LogPrintf("bnTrustedModulus.SetHexBool(ZEROCOIN_MODULUS) failed");
             }
 
             // Set up the Zerocoin Params object
@@ -3053,11 +3705,11 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
             // 2. Get pubcoin from the private coin
             // 3. Compute Accomulator by you self by getting pubcoins value from wallet, but it must not include the public coin of the private that we select
             // 4. Generate withness with follwing stmt
-                // libzerocoin::AccumulatorWitness witness(params, accumulator, newCoin.getPublicCoin());
-                // Add the public half of "newCoin" to the Accumulator itself.
-                // accumulator += newCoin.getPublicCoin();
+            // libzerocoin::AccumulatorWitness witness(params, accumulator, newCoin.getPublicCoin());
+            // Add the public half of "newCoin" to the Accumulator itself.
+            // accumulator += newCoin.getPublicCoin();
             // 1. Selection a private coin that doesn't be used in wallet
-            list<CZerocoinEntry> listPubCoin;
+            list <CZerocoinEntry> listPubCoin;
             CWalletDB(strWalletFile).ListPubCoin(listPubCoin);
             listPubCoin.sort(CompHeight);
             CZerocoinEntry zerocoinSelected;
@@ -3065,42 +3717,42 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
 
             // GET MIN ID
             int currentId = INT_MAX;
-            BOOST_FOREACH(const CZerocoinEntry& minIdPubcoin, listPubCoin) {
+            BOOST_FOREACH(const CZerocoinEntry &minIdPubcoin, listPubCoin) {
                 if (minIdPubcoin.id < currentId
-                        && minIdPubcoin.denomination == denomination
-                        && minIdPubcoin.IsUsed == false
-                        && minIdPubcoin.randomness != 0
-                        && minIdPubcoin.serialNumber != 0
-                        && minIdPubcoin.id != -1
-                        && minIdPubcoin.nHeight != -1
-                        && minIdPubcoin.nHeight != INT_MAX
-                        && minIdPubcoin.nHeight >= 1
-                        && chainActive.Height() > -1
-                        && minIdPubcoin.nHeight + 6 <= chainActive.Height()
+                    && minIdPubcoin.denomination == denomination
+                    && minIdPubcoin.IsUsed == false
+                    && minIdPubcoin.randomness != 0
+                    && minIdPubcoin.serialNumber != 0
+                    && minIdPubcoin.id != -1
+                    && minIdPubcoin.nHeight != -1
+                    && minIdPubcoin.nHeight != INT_MAX
+                    && minIdPubcoin.nHeight >= 1
+                    && chainActive.Height() > -1
+                    && minIdPubcoin.nHeight + (ZC_MINT_CONFIRMATIONS-1) <= chainActive.Height()
                         ) {
                     currentId = minIdPubcoin.id;
                 }
             }
 
-            BOOST_FOREACH(const CZerocoinEntry& zerocoinItem, listPubCoin){
-                if(zerocoinItem.IsUsed == false
-                        && zerocoinItem.denomination == denomination
-                        && zerocoinItem.randomness != 0
-                        && zerocoinItem.serialNumber != 0
-                        && zerocoinItem.id == currentId
-                        && zerocoinItem.nHeight != -1
-                        && zerocoinItem.nHeight != INT_MAX
-                        && zerocoinItem.nHeight >= 1
-                        && chainActive.Height() > -1
-                        && zerocoinItem.nHeight + 6 <= chainActive.Height()
-                        ){
+            BOOST_FOREACH(const CZerocoinEntry &zerocoinItem, listPubCoin){
+                if (zerocoinItem.IsUsed == false
+                    && zerocoinItem.denomination == denomination
+                    && zerocoinItem.randomness != 0
+                    && zerocoinItem.serialNumber != 0
+                    && zerocoinItem.id == currentId
+                    && zerocoinItem.nHeight != -1
+                    && zerocoinItem.nHeight != INT_MAX
+                    && zerocoinItem.nHeight >= 1
+                    && chainActive.Height() > -1
+                    && zerocoinItem.nHeight + (ZC_MINT_CONFIRMATIONS-1) <= chainActive.Height()
+                        ) {
                     zerocoinSelected = zerocoinItem;
                     selectedPubcoin = true;
                     break;
                 }
             }
 
-            if(!selectedPubcoin){
+            if (!selectedPubcoin){
                 strFailReason = _("it has to have at least two mint coins with at least 6 confirmation in order to spend a coin");
                 return false;
             }
@@ -3118,15 +3770,16 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
             }
 
             LogPrintf("listPubcoin.size()=%s\n", listPubCoin.size());
-            LogPrintf("Consider: zerocoinSelected.value=%s\n, zerocoinSelected.id=%s\n",zerocoinSelected.value.ToString(), zerocoinSelected.id);
+            LogPrintf("Consider: zerocoinSelected.value=%s\n, zerocoinSelected.id=%s\n",
+                      zerocoinSelected.value.ToString(), zerocoinSelected.id);
             // 3. Compute Accomulator by yourself by getting at least 9 pubcoins from wallet, but it must not include the public coin of the selected private coin
             int countUseablePubcoin = 0;
-            BOOST_FOREACH(const CZerocoinEntry& zerocoinItem, listPubCoin){
+            BOOST_FOREACH(const CZerocoinEntry &zerocoinItem, listPubCoin){
                 // Count pubcoins in same block
-                if(zerocoinItem.value  != zerocoinSelected.value
+                if (zerocoinItem.value != zerocoinSelected.value
                         && zerocoinItem.id == zerocoinSelected.id
                         && chainActive.Height() > -1
-                        && zerocoinItem.nHeight + 6 <= chainActive.Height()
+                        && zerocoinItem.nHeight + (ZC_MINT_CONFIRMATIONS-1) <= chainActive.Height()
                         && zerocoinItem.nHeight >= 1
                         && zerocoinItem.nHeight != INT_MAX
                         && zerocoinItem.denomination == denomination
@@ -3134,10 +3787,11 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
                     LogPrintf("VALID COIN - PUBCOIN ID: %d HEIGHT: %d\n", zerocoinItem.id, zerocoinItem.nHeight);
 
                     libzerocoin::PublicCoin pubCoinTemp(ZCParams, zerocoinItem.value, denomination);
-                    if(pubCoinTemp.validate()){
+                    if (pubCoinTemp.validate()) {
                         countUseablePubcoin++;
                         //if(countUseablePubcoin == 9) break;
-                        LogPrintf("USEABLE - COIN NO: %d PUBCOIN ID: %d HEIGHT: %d\n", countUseablePubcoin, zerocoinItem.id, zerocoinItem.nHeight);
+                        LogPrintf("USEABLE - COIN NO: %d PUBCOIN ID: %d HEIGHT: %d\n", countUseablePubcoin,
+                                  zerocoinItem.id, zerocoinItem.nHeight);
                         accumulator += pubCoinTemp;
                     }
                 }
@@ -3145,15 +3799,15 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
 
             LogPrintf("USEABLE PUBCOINS: %d\n", countUseablePubcoin);
 
-            if(countUseablePubcoin < 1){ // You have to have at least two mint zerocoins.
+            if (countUseablePubcoin < 1) { // You have to have at least two mint zerocoins.
                 strFailReason = _("at least two mint coins with are using calculating accumulator");
                 return false;
             }
 
             // 4. Generate withness with follwing stmt
-                // libzerocoin::AccumulatorWitness witness(params, accumulator, newCoin.getPublicCoin());
-                // Add the public half of "newCoin" to the Accumulator itself.
-                // accumulator += newCoin.getPublicCoin();
+            // libzerocoin::AccumulatorWitness witness(params, accumulator, newCoin.getPublicCoin());
+            // Add the public half of "newCoin" to the Accumulator itself.
+            // accumulator += newCoin.getPublicCoin();
             libzerocoin::AccumulatorWitness witness(ZCParams, accumulator, pubCoinSelected);
             accumulator += pubCoinSelected;
 
@@ -3306,14 +3960,14 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
             }
 
             /*zerocoinSelected.IsUsed = true;
-            zerocoinSelected.randomness = 0;
-            zerocoinSelected.serialNumber = 0;
-            CWalletDB(strWalletFile).WriteZerocoinEntry(zerocoinSelected);*/
+        zerocoinSelected.randomness = 0;
+        zerocoinSelected.serialNumber = 0;
+        CWalletDB(strWalletFile).WriteZerocoinEntry(zerocoinSelected);*/
 
-            std::list<CZerocoinSpendEntry> listCoinSpendSerial;
+            std::list <CZerocoinSpendEntry> listCoinSpendSerial;
             CWalletDB(strWalletFile).ListCoinSpendSerial(listCoinSpendSerial);
-            BOOST_FOREACH(const CZerocoinSpendEntry& item, listCoinSpendSerial){
-                if(spend.getCoinSerialNumber() == item.coinSerial){
+            BOOST_FOREACH(const CZerocoinSpendEntry &item, listCoinSpendSerial){
+                if (spend.getCoinSerialNumber() == item.coinSerial) {
                     // THIS SELECEDTED COIN HAS BEEN USED, SO UPDATE ITS STATUS
                     CZerocoinEntry pubCoinTx;
                     pubCoinTx.nHeight = zerocoinSelected.nHeight;
@@ -3326,7 +3980,8 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
                     CWalletDB(strWalletFile).WriteZerocoinEntry(pubCoinTx);
                     LogPrintf("CreateZerocoinSpendTransaction() -> NotifyZerocoinChanged\n");
                     LogPrintf("pubcoin=%s, isUsed=Used\n", zerocoinSelected.value.GetHex());
-                    pwalletMain->NotifyZerocoinChanged(pwalletMain, zerocoinSelected.value.GetHex(), "Used", CT_UPDATED);
+                    pwalletMain->NotifyZerocoinChanged(pwalletMain, zerocoinSelected.value.GetHex(), "Used",
+                                                       CT_UPDATED);
                     strFailReason = _("the coin spend has been used");
                     return false;
                 }
@@ -3345,7 +4000,7 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
             entry.id = zerocoinSelected.id;
             entry.denomination = zerocoinSelected.denomination;
             LogPrintf("WriteCoinSpendSerialEntry, serialNumber=%s\n", coinSerial.ToString());
-            if(!CWalletDB(strWalletFile).WriteCoinSpendSerialEntry(entry)){
+            if (!CWalletDB(strWalletFile).WriteCoinSpendSerialEntry(entry)) {
                 strFailReason = _("it cannot write coin serial number into wallet");
             }
         }
@@ -3354,8 +4009,7 @@ bool CWallet::CreateZerocoinSpendTransaction(int64_t nValue, libzerocoin::CoinDe
     return true;
 }
 
-bool CWallet::CommitZerocoinSpendTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
-{
+bool CWallet::CommitZerocoinSpendTransaction(CWalletTx &wtxNew, CReserveKey &reservekey) {
     {
         LOCK2(cs_main, cs_wallet);
         LogPrintf("CommitZerocoinSpendTransaction:\n%s", wtxNew.ToString());
@@ -3364,7 +4018,7 @@ bool CWallet::CommitZerocoinSpendTransaction(CWalletTx& wtxNew, CReserveKey& res
             // This is only to keep the database open to defeat the auto-flush for the
             // duration of this scope.  This is the only place where this optimization
             // maybe makes sense; please don't do it anywhere else.
-            CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile, "w") : NULL;
+            CWalletDB *pwalletdb = fFileBacked ? new CWalletDB(strWalletFile, "w") : NULL;
 
             // Take key pair from key pool so it won't be used again
             reservekey.KeepKey();
@@ -3384,7 +4038,8 @@ bool CWallet::CommitZerocoinSpendTransaction(CWalletTx& wtxNew, CReserveKey& res
             CValidationState state;
             // Broadcast
             if (!wtxNew.AcceptToMemoryPool(false, maxTxFee, state, false)) {
-                LogPrintf("CommitZerocoinSpendTransaction(): Transaction cannot be broadcast immediately, %s\n", state.GetRejectReason());
+                LogPrintf("CommitZerocoinSpendTransaction(): Transaction cannot be broadcast immediately, %s\n",
+                          state.GetRejectReason());
                 // TODO: if we expect the failure to be long term or permanent, instead delete wtx from the wallet and return failure.
             } else {
                 wtxNew.RelayWalletTransaction(false);
@@ -3393,8 +4048,8 @@ bool CWallet::CommitZerocoinSpendTransaction(CWalletTx& wtxNew, CReserveKey& res
     }
     return true;
 }
+
 /**
- * btzc:
  * @brief CWallet::MintZerocoin
  * @param pubCoin
  * @param nValue
@@ -3402,41 +4057,42 @@ bool CWallet::CommitZerocoinSpendTransaction(CWalletTx& wtxNew, CReserveKey& res
  * @param fAskFee
  * @return
  */
-string CWallet::MintZerocoin(CScript pubCoin, int64_t nValue, CWalletTx& wtxNew, bool fAskFee)
-{
+string CWallet::MintZerocoin(CScript pubCoin, int64_t nValue, CWalletTx &wtxNew, bool fAskFee) {
     LogPrintf("MintZerocoin: value = %s\n", nValue);
     // Check amount
     if (nValue <= 0)
         return _("Invalid amount");
-    LogPrintf("CWallet.MintZerocoin() nValue = %s, payTxFee.GetFee(1000) = %s, GetBalance() = %s \n", nValue, payTxFee.GetFee(1000), GetBalance());
+    LogPrintf("CWallet.MintZerocoin() nValue = %s, payTxFee.GetFee(1000) = %s, GetBalance() = %s \n", nValue,
+              payTxFee.GetFee(1000), GetBalance());
     if (nValue + payTxFee.GetFeePerK() > GetBalance())
         return _("Insufficient funds");
     LogPrintf("payTxFee.GetFeePerK()=%s\n", payTxFee.GetFeePerK());
     CReserveKey reservekey(this);
     int64_t nFeeRequired;
 
-    if (IsLocked())
-    {
+    if (IsLocked()) {
         string strError = _("Error: Wallet locked, unable to create transaction!");
         LogPrintf("MintZerocoin() : %s", strError);
         return strError;
     }
 
     string strError;
-    if (!CreateZerocoinMintTransaction(pubCoin, nValue, wtxNew, reservekey, nFeeRequired, strError))
-    {
+    if (!CreateZerocoinMintTransaction(pubCoin, nValue, wtxNew, reservekey, nFeeRequired, strError)) {
         LogPrintf("nFeeRequired=%s\n", nFeeRequired);
         if (nValue + nFeeRequired > GetBalance())
-            return strprintf(_("Error: This transaction requires a transaction fee of at least %s because of its amount, complexity, or use of recently received funds!"), FormatMoney(nFeeRequired).c_str());
+            return strprintf(
+                    _("Error: This transaction requires a transaction fee of at least %s because of its amount, complexity, or use of recently received funds!"),
+                    FormatMoney(nFeeRequired).c_str());
         return strError;
     }
 
     if (fAskFee && !uiInterface.ThreadSafeAskFee(nFeeRequired))
         return "ABORTED";
 
-    if (!CommitTransaction(wtxNew, reservekey)){
-        return _("Error: The transaction was rejected! This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
-    }else{
+    if (!CommitTransaction(wtxNew, reservekey)) {
+        return _(
+                "Error: The transaction was rejected! This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
+    } else {
         LogPrintf("CommitTransaction success!\n");
 //        //TODO :
 //        // 1. In this case, we already have pubcoin that just committed to network.
@@ -3448,7 +4104,6 @@ string CWallet::MintZerocoin(CScript pubCoin, int64_t nValue, CWalletTx& wtxNew,
 }
 
 /**
- * btzc: add spendZerocoin
  * @brief CWallet::SpendZerocoin
  * @param nValue
  * @param denomination
@@ -3459,37 +4114,38 @@ string CWallet::MintZerocoin(CScript pubCoin, int64_t nValue, CWalletTx& wtxNew,
  * @param zcSelectedIsUsed
  * @return
  */
-string CWallet::SpendZerocoin(int64_t nValue, libzerocoin::CoinDenomination denomination, CWalletTx& wtxNew, CBigNum& coinSerial, uint256& txHash, CBigNum& zcSelectedValue, bool& zcSelectedIsUsed)
-{
+string CWallet::SpendZerocoin(int64_t nValue, libzerocoin::CoinDenomination denomination, CWalletTx &wtxNew,
+                              CBigNum &coinSerial, uint256 &txHash, CBigNum &zcSelectedValue,
+                              bool &zcSelectedIsUsed) {
     // Check amount
     if (nValue <= 0)
         return _("Invalid amount");
 
     CReserveKey reservekey(this);
 
-    if (IsLocked())
-    {
+    if (IsLocked()) {
         string strError = _("Error: Wallet locked, unable to create transaction!");
         LogPrintf("SpendZerocoin() : %s", strError);
         return strError;
     }
 
     string strError;
-    if(!CreateZerocoinSpendTransaction(nValue, denomination, wtxNew, reservekey, coinSerial, txHash, zcSelectedValue, zcSelectedIsUsed, strError)){
+    if (!CreateZerocoinSpendTransaction(nValue, denomination, wtxNew, reservekey, coinSerial, txHash,
+                                        zcSelectedValue, zcSelectedIsUsed, strError)) {
         LogPrintf("SpendZerocoin() : %s\n", strError.c_str());
         return strError;
     }
 
-    if (!CommitZerocoinSpendTransaction(wtxNew, reservekey)){
+    if (!CommitZerocoinSpendTransaction(wtxNew, reservekey)) {
         LogPrintf("CommitZerocoinSpendTransaction() -> FAILED!\n");
         CZerocoinEntry pubCoinTx;
-        list<CZerocoinEntry> listPubCoin;
+        list <CZerocoinEntry> listPubCoin;
         listPubCoin.clear();
 
         CWalletDB walletdb(pwalletMain->strWalletFile);
         walletdb.ListPubCoin(listPubCoin);
-        BOOST_FOREACH(const CZerocoinEntry& pubCoinItem, listPubCoin) {
-            if(zcSelectedValue == pubCoinItem.value){
+        BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+            if (zcSelectedValue == pubCoinItem.value) {
                 pubCoinTx.id = pubCoinItem.id;
                 pubCoinTx.IsUsed = false; // having error, so set to false, to be able to use again
                 pubCoinTx.value = pubCoinItem.value;
@@ -3507,19 +4163,14 @@ string CWallet::SpendZerocoin(int64_t nValue, libzerocoin::CoinDenomination deno
         entry.coinSerial = coinSerial;
         entry.hashTx = txHash;
         entry.pubCoin = zcSelectedValue;
-        if(!CWalletDB(strWalletFile).EraseCoinSpendSerialEntry(entry)){
+        if (!CWalletDB(strWalletFile).EraseCoinSpendSerialEntry(entry)) {
             return _("Error: It cannot delete coin serial number in wallet");
         }
-        return _("Error: The transaction was rejected! This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
+        return _(
+                "Error: The transaction was rejected! This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
     }
     return "";
 }
-/** btzc:
- * @brief CompHeight
- * @param a
- * @param b
- * @return
- */
 
 bool CWallet::AddAccountingEntry(const CAccountingEntry &acentry, CWalletDB &pwalletdb) {
     if (!pwalletdb.WriteAccountingEntry_Backend(acentry))
@@ -3639,7 +4290,8 @@ bool CWallet::SetAddressBook(const CTxDestination &address, const string &strNam
                              strPurpose, (fUpdated ? CT_UPDATED : CT_NEW));
     if (!fFileBacked)
         return false;
-    if (!strPurpose.empty() && !CWalletDB(strWalletFile).WritePurpose(CBitcoinAddress(address).ToString(), strPurpose))
+    if (!strPurpose.empty() &&
+        !CWalletDB(strWalletFile).WritePurpose(CBitcoinAddress(address).ToString(), strPurpose))
         return false;
     return CWalletDB(strWalletFile).WriteName(CBitcoinAddress(address).ToString(), strName);
 }
@@ -3651,8 +4303,7 @@ bool CWallet::DelAddressBook(const CTxDestination &address) {
         if (fFileBacked) {
             // Delete destdata tuples associated with address
             std::string strAddress = CBitcoinAddress(address).ToString();
-            BOOST_FOREACH(
-            const PAIRTYPE(string, string) &item, mapAddressBook[address].destdata)
+            BOOST_FOREACH(const PAIRTYPE(string, string) &item, mapAddressBook[address].destdata)
             {
                 CWalletDB(strWalletFile).EraseDestData(strAddress, item.first);
             }
@@ -3685,8 +4336,7 @@ bool CWallet::NewKeyPool() {
     {
         LOCK(cs_wallet);
         CWalletDB walletdb(strWalletFile);
-        BOOST_FOREACH(int64_t
-        nIndex, setKeyPool)
+        BOOST_FOREACH(int64_t nIndex, setKeyPool)
         walletdb.ErasePool(nIndex);
         setKeyPool.clear();
 
@@ -3816,8 +4466,7 @@ std::map <CTxDestination, CAmount> CWallet::GetAddressBalances() {
 
     {
         LOCK(cs_wallet);
-        BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx)
-        walletEntry, mapWallet)
+        BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
         {
             CWalletTx *pcoin = &walletEntry.second;
 
@@ -3855,16 +4504,14 @@ set <set<CTxDestination>> CWallet::GetAddressGroupings() {
     set <set<CTxDestination>> groupings;
     set <CTxDestination> grouping;
 
-    BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx)
-    walletEntry, mapWallet)
+    BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
     {
         CWalletTx *pcoin = &walletEntry.second;
 
         if (pcoin->vin.size() > 0) {
             bool any_mine = false;
             // group all input addresses with each other
-            BOOST_FOREACH(CTxIn
-            txin, pcoin->vin)
+            BOOST_FOREACH(CTxIn txin, pcoin->vin)
             {
                 CTxDestination address;
                 if (!IsMine(txin)) /* If this input isn't mine, ignore it */
@@ -3877,8 +4524,7 @@ set <set<CTxDestination>> CWallet::GetAddressGroupings() {
 
             // group change with input addresses
             if (any_mine) {
-                BOOST_FOREACH(CTxOut
-                txout, pcoin->vout)
+                BOOST_FOREACH(CTxOut txout, pcoin->vout)
                 if (IsChange(txout)) {
                     CTxDestination txoutAddr;
                     if (!ExtractDestination(txout.scriptPubKey, txoutAddr))
@@ -3912,8 +4558,7 @@ set <set<CTxDestination>> CWallet::GetAddressGroupings() {
         set < set < CTxDestination > * > hits;
         map < CTxDestination, set < CTxDestination > * > ::iterator
         it;
-        BOOST_FOREACH(CTxDestination
-        address, grouping)
+        BOOST_FOREACH(CTxDestination address, grouping)
         if ((it = setmap.find(address)) != setmap.end())
             hits.insert((*it).second);
 
@@ -3928,8 +4573,7 @@ set <set<CTxDestination>> CWallet::GetAddressGroupings() {
         uniqueGroupings.insert(merged);
 
         // update setmap
-        BOOST_FOREACH(CTxDestination
-        element, *merged)
+        BOOST_FOREACH(CTxDestination element, *merged)
         setmap[element] = merged;
     }
 
@@ -3975,8 +4619,7 @@ CAmount CWallet::GetAccountBalance(CWalletDB &walletdb, const std::string &strAc
 std::set <CTxDestination> CWallet::GetAccountAddresses(const std::string &strAccount) const {
     LOCK(cs_wallet);
     set <CTxDestination> result;
-    BOOST_FOREACH(
-    const PAIRTYPE(CTxDestination, CAddressBookData)&item, mapAddressBook)
+    BOOST_FOREACH(const PAIRTYPE(CTxDestination, CAddressBookData)&item, mapAddressBook)
     {
         const CTxDestination &address = item.first;
         const string &strName = item.second.name;
@@ -4021,8 +4664,7 @@ void CWallet::GetAllReserveKeys(set <CKeyID> &setAddress) const {
     CWalletDB walletdb(strWalletFile);
 
     LOCK2(cs_main, cs_wallet);
-    BOOST_FOREACH(
-    const int64_t &id, setKeyPool)
+    BOOST_FOREACH(const int64_t &id, setKeyPool)
     {
         CKeyPool keypool;
         if (!walletdb.ReadPool(id, keypool))
@@ -4102,8 +4744,7 @@ class CAffectedKeysVisitor : public boost::static_visitor<void> {
         std::vector <CTxDestination> vDest;
         int nRequired;
         if (ExtractDestinations(script, type, vDest, nRequired)) {
-            BOOST_FOREACH(
-            const CTxDestination &dest, vDest)
+            BOOST_FOREACH(const CTxDestination &dest, vDest)
             boost::apply_visitor(*this, dest);
         }
     }
@@ -4127,17 +4768,18 @@ void CWallet::GetKeyBirthTimes(std::map <CKeyID, int64_t> &mapKeyBirth) const {
     mapKeyBirth.clear();
 
     // get birth times for keys with metadata
-    for (std::map<CKeyID, CKeyMetadata>::const_iterator it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++)
+    for (std::map<CKeyID, CKeyMetadata>::const_iterator it = mapKeyMetadata.begin();
+         it != mapKeyMetadata.end(); it++)
         if (it->second.nCreateTime)
             mapKeyBirth[it->first] = it->second.nCreateTime;
 
     // map in which we'll infer heights of other keys
-    CBlockIndex *pindexMax = chainActive[std::max(0, chainActive.Height() -  144)]; // the tip can be reorganized; use a 144-block safety margin
+    CBlockIndex *pindexMax = chainActive[std::max(0, chainActive.Height() -
+                                                     144)]; // the tip can be reorganized; use a 144-block safety margin
     std::map < CKeyID, CBlockIndex * > mapKeyFirstBlock;
     std::set <CKeyID> setKeys;
     GetKeys(setKeys);
-    BOOST_FOREACH(
-    const CKeyID &keyid, setKeys) {
+    BOOST_FOREACH(const CKeyID &keyid, setKeys) {
         if (mapKeyBirth.count(keyid) == 0)
             mapKeyFirstBlock[keyid] = pindexMax;
     }
@@ -4156,12 +4798,10 @@ void CWallet::GetKeyBirthTimes(std::map <CKeyID, int64_t> &mapKeyBirth) const {
         if (blit != mapBlockIndex.end() && chainActive.Contains(blit->second)) {
             // ... which are already in a block
             int nHeight = blit->second->nHeight;
-            BOOST_FOREACH(
-            const CTxOut &txout, wtx.vout) {
+            BOOST_FOREACH(const CTxOut &txout, wtx.vout) {
                 // iterate over all their outputs
                 CAffectedKeysVisitor(*this, vAffected).Process(txout.scriptPubKey);
-                BOOST_FOREACH(
-                const CKeyID &keyid, vAffected) {
+                BOOST_FOREACH(const CKeyID &keyid, vAffected) {
                     // ... and all their affected keys
                     std::map<CKeyID, CBlockIndex *>::iterator rit = mapKeyFirstBlock.find(keyid);
                     if (rit != mapKeyFirstBlock.end() && nHeight < rit->second->nHeight)
@@ -4229,11 +4869,13 @@ std::string CWallet::GetWalletHelpString(bool showDebug) {
                                strprintf(_("Fee (in %s/kB) to add to transactions you send (default: %s)"),
                                          CURRENCY_UNIT, FormatMoney(payTxFee.GetFeePerK())));
     strUsage += HelpMessageOpt("-rescan", _("Rescan the block chain for missing wallet transactions on startup"));
-    strUsage += HelpMessageOpt("-salvagewallet", _("Attempt to recover private keys from a corrupt wallet on startup"));
+    strUsage += HelpMessageOpt("-salvagewallet",
+                               _("Attempt to recover private keys from a corrupt wallet on startup"));
     if (showDebug)
         strUsage += HelpMessageOpt("-sendfreetransactions",
-                                   strprintf(_("Send transactions as zero-fee transactions if possible (default: %u)"),
-                                             DEFAULT_SEND_FREE_TRANSACTIONS));
+                                   strprintf(
+                                           _("Send transactions as zero-fee transactions if possible (default: %u)"),
+                                           DEFAULT_SEND_FREE_TRANSACTIONS));
     strUsage += HelpMessageOpt("-spendzeroconfchange",
                                strprintf(_("Spend unconfirmed change when sending transactions (default: %u)"),
                                          DEFAULT_SPEND_ZEROCONF_CHANGE));
@@ -4261,8 +4903,9 @@ std::string CWallet::GetWalletHelpString(bool showDebug) {
         strUsage += HelpMessageOpt("-dblogsize=<n>", strprintf(
                 "Flush wallet database activity from memory to disk log every <n> megabytes (default: %u)",
                 DEFAULT_WALLET_DBLOGSIZE));
-        strUsage += HelpMessageOpt("-flushwallet", strprintf("Run a thread to flush wallet periodically (default: %u)",
-                                                             DEFAULT_FLUSHWALLET));
+        strUsage += HelpMessageOpt("-flushwallet",
+                                   strprintf("Run a thread to flush wallet periodically (default: %u)",
+                                             DEFAULT_FLUSHWALLET));
         strUsage += HelpMessageOpt("-privdb",
                                    strprintf("Sets the DB_PRIVATE flag in the wallet db environment (default: %u)",
                                              DEFAULT_WALLET_PRIVDB));
@@ -4276,7 +4919,6 @@ std::string CWallet::GetWalletHelpString(bool showDebug) {
 
 void ReIndexZerocoin(std::string strWalletFile) {
     LogPrintf("ReIndexZerocoin\n");
-    //btzc: add zercoin wallet init
     // Zerocoin reorg, calculate new height and id
     list <CZerocoinEntry> listPubCoin = list<CZerocoinEntry>();
     CWalletDB walletdb(strWalletFile);
@@ -4287,7 +4929,8 @@ void ReIndexZerocoin(std::string strWalletFile) {
 
     // RECURSIVE, SET NEW ID
     LogPrintf("lastCalculatedZCBlock: %s\n", lastCalculatedZCBlock);
-    BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
+    BOOST_FOREACH(
+    const CZerocoinEntry &pubCoinItem, listPubCoin) {
         if (!fReindex && pubCoinItem.nHeight < lastCalculatedZCBlock) {
             continue;
         } else {
@@ -4311,12 +4954,8 @@ void ReIndexZerocoin(std::string strWalletFile) {
         list <CZerocoinEntry> listPubCoin = list<CZerocoinEntry>();
         CWalletDB walletdb(strWalletFile);
         walletdb.ListPubCoin(listPubCoin);
-//        BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
-//            walletdb.EraseZerocoinEntry(pubCoinItem);
-//        }
 
         BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
-//            walletdb.EraseZerocoinEntry(pubCoinItem);
             CZerocoinEntry pubCoinTx;
             pubCoinTx.value = pubCoinItem.value;
             pubCoinTx.id = -1;
@@ -4328,20 +4967,11 @@ void ReIndexZerocoin(std::string strWalletFile) {
             LogPrintf("- Reindex Pubcoin Id: %d Denomination: %d\n", pubCoinTx.id, pubCoinTx.denomination);
             walletdb.WriteZerocoinEntry(pubCoinTx);
         }
-//        LogPrintf("RecheckZerocoin\n");
-//        CWalletDB walletdbNew(strWalletFile);
-//        listPubCoin.clear();
-//        walletdbNew.ListPubCoin(listPubCoin);
-//        BOOST_FOREACH(const CZerocoinEntry &pubCoinItem, listPubCoin) {
-//            walletdb.EraseZerocoinEntry(pubCoinItem);
-//            LogPrintf("- Exists Id: %d Denomination: %d Height: %d\n", pubCoinItem.id, pubCoinItem.denomination, pubCoinItem.nHeight);
-//        }
 
         std::list <CZerocoinSpendEntry> listCoinSpendSerial;
         walletdb.ListCoinSpendSerial(listCoinSpendSerial);
         BOOST_FOREACH(const CZerocoinSpendEntry &item, listCoinSpendSerial) {
             walletdb.EraseCoinSpendSerialEntry(item);
-//            LogPrintf("serialNumber=%s\n", item.coinSerial.ToString());
         }
     } else {
         LogPrintf("chainActive.Genesis() nHeight= %s\n", chainActive.Genesis()->nHeight);
@@ -4354,8 +4984,9 @@ void ReIndexZerocoin(std::string strWalletFile) {
                     continue;
                 } else {
 //                    LogPrintf("PROCESS BLOCK = %d\n", pindexRecur->nHeight);
-                    std::string blocksProcessed = "Loading wallet... " + std::to_string(pindexRecur->nHeight) + "/" +
-                                                  std::to_string(mapBlockIndex.size());
+                    std::string blocksProcessed =
+                            "Loading wallet... " + std::to_string(pindexRecur->nHeight) + "/" +
+                            std::to_string(mapBlockIndex.size());
                     uiInterface.InitMessage(blocksProcessed);
                     CBlock blockRecur;
                     ReadBlockFromDisk(blockRecur, pindexRecur, Params().GetConsensus());
@@ -4381,23 +5012,23 @@ void ReIndexZerocoin(std::string strWalletFile) {
                                         int currentId = 1;
                                         unsigned int countExistingItems = 0;
                                         listPubCoinInLoop.sort(CompHeight);
-                                        BOOST_FOREACH(const CZerocoinEntry& pubCoinIdItem, listPubCoinInLoop) {
-                                            if(pubCoinIdItem.id > 0){
-                                                if(pubCoinIdItem.nHeight <= pindexRecur->nHeight){
-                                                    if(pubCoinIdItem.denomination == pubCoinItem.denomination){
+                                        BOOST_FOREACH(const CZerocoinEntry &pubCoinIdItem, listPubCoinInLoop) {
+                                            if (pubCoinIdItem.id > 0) {
+                                                if (pubCoinIdItem.nHeight <= pindexRecur->nHeight) {
+                                                    if (pubCoinIdItem.denomination == pubCoinItem.denomination) {
                                                         countExistingItems++;
-                                                        if(pubCoinIdItem.id > currentId){
+                                                        if (pubCoinIdItem.id > currentId) {
                                                             currentId = pubCoinIdItem.id;
                                                             countExistingItems = 1;
                                                         }
                                                     }
-                                                }else{
+                                                } else {
                                                     break;
                                                 }
                                             }
                                         }
 
-                                        if(countExistingItems > 9){
+                                        if (countExistingItems > 9) {
                                             currentId++;
                                         }
                                         pubCoinTx.id = currentId;
@@ -4406,7 +5037,8 @@ void ReIndexZerocoin(std::string strWalletFile) {
                                         pubCoinTx.serialNumber = pubCoinItem.serialNumber;
                                         pubCoinTx.value = pubCoinItem.value;
                                         pubCoinTx.nHeight = pindexRecur->nHeight;
-                                        LogPrintf("REORG PUBCOIN ID: %d HEIGHT: %d DENOMINATION: %d\n", pubCoinTx.id,
+                                        LogPrintf("REORG PUBCOIN ID: %d HEIGHT: %d DENOMINATION: %d\n",
+                                                  pubCoinTx.id,
                                                   pubCoinTx.nHeight, pubCoinItem.denomination);
                                         walletdbInLoop.WriteZerocoinEntry(pubCoinTx);
                                     }
@@ -4465,7 +5097,8 @@ bool CWallet::InitLoadWallet() {
             return InitError(strprintf(_("Error loading %s: Wallet requires newer version of %s"),
                                        walletFile, _(PACKAGE_NAME)));
         else if (nLoadWalletRet == DB_NEED_REWRITE) {
-            return InitError(strprintf(_("Wallet needed to be rewritten: restart %s to complete"), _(PACKAGE_NAME)));
+            return InitError(
+                    strprintf(_("Wallet needed to be rewritten: restart %s to complete"), _(PACKAGE_NAME)));
         } else
             return InitError(strprintf(_("Error loading %s"), walletFile));
     }
@@ -4510,10 +5143,12 @@ bool CWallet::InitLoadWallet() {
         bool useHD = GetBoolArg("-usehd", DEFAULT_USE_HD_WALLET);
         if (!walletInstance->hdChain.masterKeyID.IsNull() && !useHD)
             return InitError(
-                    strprintf(_("Error loading %s: You can't disable HD on a already existing HD wallet"), walletFile));
+                    strprintf(_("Error loading %s: You can't disable HD on a already existing HD wallet"),
+                              walletFile));
         if (walletInstance->hdChain.masterKeyID.IsNull() && useHD)
-            return InitError(strprintf(_("Error loading %s: You can't enable HD on a already existing non-HD wallet"),
-                                       walletFile));
+            return InitError(
+                    strprintf(_("Error loading %s: You can't enable HD on a already existing non-HD wallet"),
+                              walletFile));
     }
 
     LogPrintf(" wallet      %15dms\n", GetTimeMillis() - nStart);
@@ -4595,7 +5230,8 @@ bool CWallet::ParameterInteraction() {
     if (mapArgs.count("-fallbackfee")) {
         CAmount nFeePerK = 0;
         if (!ParseMoney(mapArgs["-fallbackfee"], nFeePerK))
-            return InitError(strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"), mapArgs["-fallbackfee"]));
+            return InitError(
+                    strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"), mapArgs["-fallbackfee"]));
 //        if (nFeePerK > HIGH_TX_FEE_PER_KB)
 //            InitWarning(
 //                    _("-fallbackfee is set very high! This is the transaction fee you may pay when fee estimates are not available."));
@@ -4627,10 +5263,10 @@ bool CWallet::ParameterInteraction() {
         }
     }
 
-    if (mapArgs.count("-mininput"))
-    {
+    if (mapArgs.count("-mininput")) {
         if (!ParseMoney(mapArgs["-mininput"], nMinimumInputValue))
-            return InitError(strprintf(_("Invalid amount for -mininput=<amount>: '%s'"), mapArgs["-mininput"].c_str()));
+            return InitError(
+                    strprintf(_("Invalid amount for -mininput=<amount>: '%s'"), mapArgs["-mininput"].c_str()));
     }
 
     nTxConfirmTarget = GetArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET);
@@ -4686,7 +5322,8 @@ CKeyPool::CKeyPool(const CPubKey &vchPubKeyIn) {
     vchPubKey = vchPubKeyIn;
 }
 
-CWalletKey::CWalletKey(int64_t nExpires) {
+CWalletKey::CWalletKey(int64_t
+                       nExpires) {
     nTimeCreated = (nExpires ? GetTime() : 0);
     nTimeExpires = nExpires;
 }
@@ -4719,6 +5356,38 @@ int CMerkleTx::SetMerkleBranch(const CBlock &block) {
     return chainActive.Height() - pindex->nHeight + 1;
 }
 
+int CMerkleTx::GetDepthInMainChain(const CBlockIndex *&pindexRet, bool enableIX) const {
+    int nResult;
+
+    if (hashUnset())
+        nResult = 0;
+    else {
+        AssertLockHeld(cs_main);
+
+        // Find the block it claims to be in
+        BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
+        if (mi == mapBlockIndex.end())
+            nResult = 0;
+        else {
+            CBlockIndex *pindex = (*mi).second;
+            if (!pindex || !chainActive.Contains(pindex))
+                nResult = 0;
+            else {
+                pindexRet = pindex;
+                nResult = ((nIndex == -1) ? (-1) : 1) * (chainActive.Height() - pindex->nHeight + 1);
+
+                if (nResult == 0 && !mempool.exists(GetHash()))
+                    return -1; // Not in chain, not in mempool
+            }
+        }
+    }
+
+    if (enableIX && nResult < 6 && instantsend.IsLockedInstantSendTransaction(GetHash()))
+        return nInstantSendDepth + nResult;
+
+    return nResult;
+}
+
 int CMerkleTx::GetDepthInMainChain(const CBlockIndex *&pindexRet) const {
     if (hashUnset())
         return 0;
@@ -4743,9 +5412,13 @@ int CMerkleTx::GetBlocksToMaturity() const {
 }
 
 
-bool CMerkleTx::AcceptToMemoryPool(bool fLimitFree, CAmount nAbsurdFee, CValidationState &state, bool fCheckInputs, bool isCheckWalletTransaction) {
+bool CMerkleTx::AcceptToMemoryPool(bool fLimitFree, CAmount nAbsurdFee, CValidationState &state, bool fCheckInputs,
+                                   bool isCheckWalletTransaction) {
     LogPrintf("CMerkleTx::AcceptToMemoryPool(), fCheckInputs=%s\n", fCheckInputs);
-    return ::AcceptToMemoryPool(mempool, state, *this, fCheckInputs, fLimitFree, NULL, false, nAbsurdFee, isCheckWalletTransaction);
+    return ::AcceptToMemoryPool(mempool, state, *this, fCheckInputs, fLimitFree, NULL, false, nAbsurdFee,
+                                isCheckWalletTransaction);
 }
 
-bool CompHeight(const CZerocoinEntry & a, const CZerocoinEntry & b) { return a.nHeight < b.nHeight; }
+bool CompHeight(const CZerocoinEntry &a, const CZerocoinEntry &b) { return a.nHeight < b.nHeight; }
+
+bool CompID(const CZerocoinEntry &a, const CZerocoinEntry &b) { return a.id < b.id; }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index c0f2e2e4be..6aba2543a4 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -17,6 +17,7 @@
 #include "wallet/crypter.h"
 #include "wallet/walletdb.h"
 #include "wallet/rpcwallet.h"
+#include "../base58.h"
 
 #include <algorithm>
 #include <map>
@@ -85,6 +86,27 @@ enum WalletFeature
     FEATURE_LATEST = FEATURE_COMPRPUBKEY // HD is optional, use FEATURE_COMPRPUBKEY as latest version
 };
 
+enum AvailableCoinsType
+{
+    ALL_COINS = 1,
+    ONLY_DENOMINATED = 2,
+    ONLY_NOT1000IFMN = 3,
+    ONLY_NONDENOMINATED_NOT1000IFMN = 4,
+    ONLY_1000 = 5, // find znode outputs including locked ones (use with caution)
+    ONLY_PRIVATESEND_COLLATERAL = 6
+};
+
+struct CompactTallyItem
+{
+    CBitcoinAddress address;
+    CAmount nAmount;
+    std::vector<CTxIn> vecTxIn;
+    CompactTallyItem()
+    {
+        nAmount = 0;
+    }
+};
+
 
 /** A key pool entry */
 class CKeyPool
@@ -213,6 +235,10 @@ class CMerkleTx : public CTransaction
      */
     int GetDepthInMainChain(const CBlockIndex* &pindexRet) const;
     int GetDepthInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
+
+    int GetDepthInMainChain(const CBlockIndex* &pindexRet, bool enableIX) const;
+    int GetDepthInMainChain(bool enableIX) const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet, enableIX); }
+
     bool IsInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet) > 0; }
     int GetBlocksToMaturity() const;
     /** Pass this transaction to the mempool. Fails if absolute fee exceeds absurd fee. */
@@ -382,6 +408,7 @@ class CWalletTx : public CMerkleTx
     CAmount GetAvailableCredit(bool fUseCache=true) const;
     CAmount GetImmatureWatchOnlyCredit(const bool& fUseCache=true) const;
     CAmount GetAvailableWatchOnlyCredit(const bool& fUseCache=true) const;
+    CAmount GetAnonymizedCredit(bool fUseCache=true) const;
     CAmount GetChange() const;
 
     void GetAmounts(std::list<COutputEntry>& listReceived,
@@ -425,6 +452,7 @@ class COutput
     {
         tx = txIn; i = iIn; nDepth = nDepthIn; fSpendable = fSpendableIn; fSolvable = fSolvableIn;
     }
+    int Priority() const;
 
     std::string ToString() const;
 };
@@ -552,7 +580,7 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
      * all coins from coinControl are selected; Never select unconfirmed coins
      * if they are not ours
      */
-    bool SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, const CCoinControl *coinControl = NULL) const;
+    bool SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, const CCoinControl *coinControl = NULL, AvailableCoinsType nCoinType = ALL_COINS, bool fUseInstantSend = false) const;
 
     CWalletDB *pwalletdbEncryption;
 
@@ -566,6 +594,11 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     int64_t nLastResend;
     bool fBroadcastTransactions;
 
+    mutable bool fAnonymizableTallyCached;
+    mutable std::vector<CompactTallyItem> vecAnonymizableTallyCached;
+    mutable bool fAnonymizableTallyCachedNonDenom;
+    mutable std::vector<CompactTallyItem> vecAnonymizableTallyCachedNonDenom;
+
     /**
      * Used to keep track of spent outpoints, and
      * detect and report conflicts (double-spends or
@@ -599,6 +632,8 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
 
     std::set<int64_t> setKeyPool;
     std::map<CKeyID, CKeyMetadata> mapKeyMetadata;
+    //znode
+    int64_t nKeysLeftSinceAutoBackup;
 
     typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
     MasterKeyMap mapMasterKeys;
@@ -635,6 +670,10 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
         nLastResend = 0;
         nTimeFirstKey = 0;
         fBroadcastTransactions = false;
+        fAnonymizableTallyCached = false;
+        fAnonymizableTallyCachedNonDenom = false;
+        vecAnonymizableTallyCached.clear();
+        vecAnonymizableTallyCachedNonDenom.clear();
     }
 
     std::map<uint256, CWalletTx> mapWallet;
@@ -663,7 +702,7 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     /**
      * populate vCoins with vector of available COutputs.
      */
-    void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlyConfirmed=true, const CCoinControl *coinControl = NULL, bool fIncludeZeroValue=false) const;
+    void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlyConfirmed=true, const CCoinControl *coinControl = NULL, bool fIncludeZeroValue=false, AvailableCoinsType nCoinType=ALL_COINS, bool fUseInstantSend = false) const;
 
     /**
      * Shuffle and select coins until nTargetValue is reached while avoiding
@@ -672,6 +711,10 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
      * assembled
      */
     bool SelectCoinsMinConf(const CAmount& nTargetValue, int nConfMine, int nConfTheirs, uint64_t nMaxAncestors, std::vector<COutput> vCoins, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet) const;
+    bool SelectCoinsByDenominations(int nDenom, CAmount nValueMin, CAmount nValueMax, std::vector<CTxIn>& vecTxInRet, std::vector<COutput>& vCoinsRet, CAmount& nValueRet, int nPrivateSendRoundsMin, int nPrivateSendRoundsMax);
+    bool GetCollateralTxIn(CTxIn& txinRet, CAmount& nValueRet) const;
+    bool SelectCoinsDark(CAmount nValueMin, CAmount nValueMax, std::vector<CTxIn>& vecTxInRet, CAmount& nValueRet, int nPrivateSendRoundsMin, int nPrivateSendRoundsMax) const;
+    bool SelectCoinsGrouppedByAddresses(std::vector<CompactTallyItem>& vecTallyRet, bool fSkipDenominated = true, bool fAnonymizable = true) const;
 
     bool IsSpent(const uint256& hash, unsigned int n) const;
 
@@ -681,6 +724,14 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     void UnlockAllCoins();
     void ListLockedCoins(std::vector<COutPoint>& vOutpts);
 
+    // znode
+    /// Get 1000 XZC output and keys which can be used for the Znode
+    bool GetZnodeVinAndKeys(CTxIn& txinRet, CPubKey& pubKeyRet, CKey& keyRet, std::string strTxHash = "", std::string strOutputIndex = "");
+    /// Extract txin information and keys from output
+    bool GetVinAndKeysFromOutput(COutput out, CTxIn& txinRet, CPubKey& pubKeyRet, CKey& keyRet);
+    bool HasCollateralInputs(bool fOnlyConfirmed = true) const;
+    int  CountInputsWithAmount(CAmount nInputAmount);
+
     /**
      * keystore implementation
      * Generate a new key
@@ -739,13 +790,26 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     void ReacceptWalletTransactions();
     void ResendWalletTransactions(int64_t nBestBlockTime);
     std::vector<uint256> ResendWalletTransactionsBefore(int64_t nTime);
+    //znode
     CAmount GetBalance() const;
     CAmount GetUnconfirmedBalance() const;
     CAmount GetImmatureBalance() const;
     CAmount GetWatchOnlyBalance() const;
     CAmount GetUnconfirmedWatchOnlyBalance() const;
     CAmount GetImmatureWatchOnlyBalance() const;
-
+    // get the PrivateSend chain depth for a given input
+    int GetRealInputPrivateSendRounds(CTxIn txin, int nRounds) const;
+    // respect current settings
+    int GetInputPrivateSendRounds(CTxIn txin) const;
+    bool IsDenominated(const CTxIn &txin) const;
+    bool IsDenominatedAmount(CAmount nInputAmount) const;
+    bool IsCollateralAmount(CAmount nInputAmount) const;
+    CAmount GetAnonymizableBalance(bool fSkipDenominated = false) const;
+    CAmount GetAnonymizedBalance() const;
+//    double GetAverageAnonymizedRounds() const;
+//    CAmount GetNormalizedAnonymizedBalance() const;
+    CAmount GetNeedsToBeAnonymizedBalance(CAmount nMinBalance = 0) const;
+    CAmount GetDenominatedBalance(bool unconfirmed=false) const;
     /**
      * Insert additional inputs into the transaction by
      * calling CreateTransaction();
@@ -758,9 +822,9 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
      * @note passing nChangePosInOut as -1 will result in setting a random position
      */
     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);
+                           std::string& strFailReason, const CCoinControl *coinControl = NULL, bool sign = true, AvailableCoinsType nCoinType = ALL_COINS, bool fUseInstantSend = false);
+
     /**
-     * btzc:
      * Add zerocoin Mint and Spend function
      */
     void ListAvailableCoinsMintCoins(std::vector<COutput>& vCoins, bool fOnlyConfirmed=true) const;
@@ -778,10 +842,12 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     bool CreateZerocoinMintModel(string &stringError, string denomAmount);
     bool CreateZerocoinSpendModel(string &stringError, string denomAmount);
     bool SetZerocoinBook(const CZerocoinEntry& zerocoinEntry);
-    //end btzc:
 
     bool CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey);
 
+    bool CreateCollateralTransaction(CMutableTransaction& txCollateral, std::string& strReason);
+    bool ConvertList(std::vector<CTxIn> vecTxIn, std::vector<CAmount>& vecAmounts);
+
     bool AddAccountingEntry(const CAccountingEntry&, CWalletDB & pwalletdb);
 
     static CFeeRate minTxFee;
@@ -896,7 +962,6 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     boost::signals2::signal<void (CWallet *wallet, const uint256 &hashTx,
             ChangeType status)> NotifyTransactionChanged;
     /**
-     * btzc:
      * Zerocoin entry changed.
      * @note called with lock cs_wallet held.
      */
@@ -1075,4 +1140,5 @@ class CZerocoinSpendEntry
 };
 
 bool CompHeight(const CZerocoinEntry & a, const CZerocoinEntry & b);
+bool CompID(const CZerocoinEntry & a, const CZerocoinEntry & b);
 #endif // BITCOIN_WALLET_WALLET_H
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index c444c54ef3..ba14f4ed81 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -225,8 +225,6 @@ void CWalletDB::ListAccountCreditDebit(const string &strAccount, list <CAccounti
     pcursor->close();
 }
 
-
-//btzc: add zerocoin funtion here
 bool CWalletDB::WriteCoinSpendSerialEntry(const CZerocoinSpendEntry &zerocoinSpend) {
     return Write(make_pair(string("zcserial"), zerocoinSpend.coinSerial), zerocoinSpend, true);
 }
@@ -338,9 +336,6 @@ void CWalletDB::ListCoinSpendSerial(std::list <CZerocoinSpendEntry> &listCoinSpe
     pcursor->close();
 }
 
-//end #btzc
-
-
 DBErrors CWalletDB::ReorderTransactions(CWallet *pwallet) {
     LOCK(pwallet->cs_wallet);
     // Old wallets didn't have any defined order for transactions
@@ -928,6 +923,125 @@ void ThreadFlushWalletDB(const string &strFile) {
     }
 }
 
+// This should be called carefully:
+// either supply "wallet" (if already loaded) or "strWalletFile" (if wallet wasn't loaded yet)
+bool AutoBackupWallet (CWallet* wallet, std::string strWalletFile, std::string& strBackupWarning, std::string& strBackupError)
+{
+    namespace fs = boost::filesystem;
+
+    strBackupWarning = strBackupError = "";
+
+    if(nWalletBackups > 0)
+    {
+        fs::path backupsDir = GetBackupsDir();
+
+        if (!fs::exists(backupsDir))
+        {
+            // Always create backup folder to not confuse the operating system's file browser
+            LogPrintf("Creating backup folder %s\n", backupsDir.string());
+            if(!fs::create_directories(backupsDir)) {
+                // smth is wrong, we shouldn't continue until it's resolved
+                strBackupError = strprintf(_("Wasn't able to create wallet backup folder %s!"), backupsDir.string());
+                LogPrintf("%s\n", strBackupError);
+                nWalletBackups = -1;
+                return false;
+            }
+        }
+
+        // Create backup of the ...
+        std::string dateTimeStr = DateTimeStrFormat(".%Y-%m-%d-%H-%M", GetTime());
+        if (wallet)
+        {
+            // ... opened wallet
+            LOCK2(cs_main, wallet->cs_wallet);
+            strWalletFile = wallet->strWalletFile;
+            fs::path backupFile = backupsDir / (strWalletFile + dateTimeStr);
+//            if(!BackupWallet(*wallet, backupFile.string())) {
+//                strBackupWarning = strprintf(_("Failed to create backup %s!"), backupFile.string());
+//                LogPrintf("%s\n", strBackupWarning);
+//                nWalletBackups = -1;
+//                return false;
+//            }
+            // Update nKeysLeftSinceAutoBackup using current pool size
+            wallet->nKeysLeftSinceAutoBackup = wallet->GetKeyPoolSize();
+            LogPrintf("nKeysLeftSinceAutoBackup: %d\n", wallet->nKeysLeftSinceAutoBackup);
+            if(wallet->IsLocked(true)) {
+                strBackupWarning = _("Wallet is locked, can't replenish keypool! Automatic backups and mixing are disabled, please unlock your wallet to replenish keypool.");
+                LogPrintf("%s\n", strBackupWarning);
+                nWalletBackups = -2;
+                return false;
+            }
+        } else {
+            // ... strWalletFile file
+            fs::path sourceFile = GetDataDir() / strWalletFile;
+            fs::path backupFile = backupsDir / (strWalletFile + dateTimeStr);
+            sourceFile.make_preferred();
+            backupFile.make_preferred();
+            if (fs::exists(backupFile))
+            {
+                strBackupWarning = _("Failed to create backup, file already exists! This could happen if you restarted wallet in less than 60 seconds. You can continue if you are ok with this.");
+                LogPrintf("%s\n", strBackupWarning);
+                return false;
+            }
+            if(fs::exists(sourceFile)) {
+                try {
+                    fs::copy_file(sourceFile, backupFile);
+                    LogPrintf("Creating backup of %s -> %s\n", sourceFile.string(), backupFile.string());
+                } catch(fs::filesystem_error &error) {
+                    strBackupWarning = strprintf(_("Failed to create backup, error: %s"), error.what());
+                    LogPrintf("%s\n", strBackupWarning);
+                    nWalletBackups = -1;
+                    return false;
+                }
+            }
+        }
+
+        // Keep only the last 10 backups, including the new one of course
+        typedef std::multimap<std::time_t, fs::path> folder_set_t;
+        folder_set_t folder_set;
+        fs::directory_iterator end_iter;
+        backupsDir.make_preferred();
+        // Build map of backup files for current(!) wallet sorted by last write time
+        fs::path currentFile;
+        for (fs::directory_iterator dir_iter(backupsDir); dir_iter != end_iter; ++dir_iter)
+        {
+            // Only check regular files
+            if ( fs::is_regular_file(dir_iter->status()))
+            {
+                currentFile = dir_iter->path().filename();
+                // Only add the backups for the current wallet, e.g. wallet.dat.*
+                if(dir_iter->path().stem().string() == strWalletFile)
+                {
+                    folder_set.insert(folder_set_t::value_type(fs::last_write_time(dir_iter->path()), *dir_iter));
+                }
+            }
+        }
+
+        // Loop backward through backup files and keep the N newest ones (1 <= N <= 10)
+        int counter = 0;
+        BOOST_REVERSE_FOREACH(PAIRTYPE(const std::time_t, fs::path) file, folder_set)
+        {
+            counter++;
+            if (counter > nWalletBackups)
+            {
+                // More than nWalletBackups backups: delete oldest one(s)
+                try {
+                    fs::remove(file.second);
+                    LogPrintf("Old backup deleted: %s\n", file.second);
+                } catch(fs::filesystem_error &error) {
+                    strBackupWarning = strprintf(_("Failed to delete backup, error: %s"), error.what());
+                    LogPrintf("%s\n", strBackupWarning);
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    LogPrintf("Automatic wallet backups are disabled!\n");
+    return false;
+}
+
 //
 // Try to (very carefully!) recover wallet file if there is a problem.
 //
@@ -1025,4 +1139,4 @@ bool CWalletDB::EraseDestData(const std::string &address, const std::string &key
 bool CWalletDB::WriteHDChain(const CHDChain &chain) {
     nWalletDBUpdated++;
     return Write(std::string("hdchain"), chain);
-}
\ No newline at end of file
+}
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index 2cc0aea840..196f4402e7 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -31,7 +31,6 @@ class CWallet;
 class CWalletTx;
 class uint160;
 class uint256;
-//btzc: add zerocoin entry
 class CZerocoinEntry;
 class CZerocoinSpendEntry;
 
@@ -172,7 +171,6 @@ class CWalletDB : public CDB
     CAmount GetAccountCreditDebit(const std::string& strAccount);
     void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries);
 
-    //btzc: add zerocoin function method
     bool WriteZerocoinEntry(const CZerocoinEntry& zerocoin);
     bool EraseZerocoinEntry(const CZerocoinEntry& zerocoin);
     void ListPubCoin(std::list<CZerocoinEntry>& listPubCoin);
@@ -181,8 +179,7 @@ class CWalletDB : public CDB
     bool EraseCoinSpendSerialEntry(const CZerocoinSpendEntry& zerocoinSpend);
     bool WriteZerocoinAccumulator(libzerocoin::Accumulator accumulator, libzerocoin::CoinDenomination denomination, int pubcoinid);
     bool ReadZerocoinAccumulator(libzerocoin::Accumulator& accumulator, libzerocoin::CoinDenomination denomination, int pubcoinid);
-//    bool EraseZerocoinAccumulator(libzerocoin::Accumulator& accumulator, libzerocoin::CoinDenomination denomination, int pubcoinid);
-    //end #btzc
+    // bool EraseZerocoinAccumulator(libzerocoin::Accumulator& accumulator, libzerocoin::CoinDenomination denomination, int pubcoinid);
 
     bool ReadCalculatedZCBlock(int& height);
     bool WriteCalculatedZCBlock(int height);
@@ -206,5 +203,6 @@ class CWalletDB : public CDB
 };
 
 void ThreadFlushWalletDB(const std::string& strFile);
+bool AutoBackupWallet (CWallet* wallet, std::string strWalletFile, std::string& strBackupWarning, std::string& strBackupError);
 
 #endif // BITCOIN_WALLET_WALLETDB_H
diff --git a/src/znode-payments.cpp b/src/znode-payments.cpp
new file mode 100644
index 0000000000..cfc73e39c5
--- /dev/null
+++ b/src/znode-payments.cpp
@@ -0,0 +1,922 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "activeznode.h"
+#include "darksend.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "netfulfilledman.h"
+#include "spork.h"
+#include "util.h"
+
+#include <boost/lexical_cast.hpp>
+
+/** Object for who's going to get paid on which blocks */
+CZnodePayments mnpayments;
+
+CCriticalSection cs_vecPayees;
+CCriticalSection cs_mapZnodeBlocks;
+CCriticalSection cs_mapZnodePaymentVotes;
+
+/**
+* IsBlockValueValid
+*
+*   Determine if coinbase outgoing created money is the correct value
+*
+*   Why is this needed?
+*   - In Dash some blocks are superblocks, which output much higher amounts of coins
+*   - Otherblocks are 10% lower in outgoing value, so in total, no extra coins are created
+*   - When non-superblocks are detected, the normal schedule should be maintained
+*/
+
+bool IsBlockValueValid(const CBlock &block, int nBlockHeight, CAmount blockReward, std::string &strErrorRet) {
+    strErrorRet = "";
+
+    bool isBlockRewardValueMet = (block.vtx[0].GetValueOut() <= blockReward);
+    if (fDebug) LogPrintf("block.vtx[0].GetValueOut() %lld <= blockReward %lld\n", block.vtx[0].GetValueOut(), blockReward);
+
+    // we are still using budgets, but we have no data about them anymore,
+    // all we know is predefined budget cycle and window
+
+//    const Consensus::Params &consensusParams = Params().GetConsensus();
+//
+////    if (nBlockHeight < consensusParams.nSuperblockStartBlock) {
+//        int nOffset = nBlockHeight % consensusParams.nBudgetPaymentsCycleBlocks;
+//        if (nBlockHeight >= consensusParams.nBudgetPaymentsStartBlock &&
+//            nOffset < consensusParams.nBudgetPaymentsWindowBlocks) {
+//            // NOTE: make sure SPORK_13_OLD_SUPERBLOCK_FLAG is disabled when 12.1 starts to go live
+//            if (znodeSync.IsSynced() && !sporkManager.IsSporkActive(SPORK_13_OLD_SUPERBLOCK_FLAG)) {
+//                // no budget blocks should be accepted here, if SPORK_13_OLD_SUPERBLOCK_FLAG is disabled
+//                LogPrint("gobject", "IsBlockValueValid -- Client synced but budget spork is disabled, checking block value against block reward\n");
+//                if (!isBlockRewardValueMet) {
+//                    strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, budgets are disabled",
+//                                            nBlockHeight, block.vtx[0].GetValueOut(), blockReward);
+//                }
+//                return isBlockRewardValueMet;
+//            }
+//            LogPrint("gobject", "IsBlockValueValid -- WARNING: Skipping budget block value checks, accepting block\n");
+//            // TODO: reprocess blocks to make sure they are legit?
+//            return true;
+//        }
+//        // LogPrint("gobject", "IsBlockValueValid -- Block is not in budget cycle window, checking block value against block reward\n");
+//        if (!isBlockRewardValueMet) {
+//            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, block is not in budget cycle window",
+//                                    nBlockHeight, block.vtx[0].GetValueOut(), blockReward);
+//        }
+//        return isBlockRewardValueMet;
+//    }
+
+    // superblocks started
+
+//    CAmount nSuperblockMaxValue =  blockReward + CSuperblock::GetPaymentsLimit(nBlockHeight);
+//    bool isSuperblockMaxValueMet = (block.vtx[0].GetValueOut() <= nSuperblockMaxValue);
+//    bool isSuperblockMaxValueMet = false;
+
+//    LogPrint("gobject", "block.vtx[0].GetValueOut() %lld <= nSuperblockMaxValue %lld\n", block.vtx[0].GetValueOut(), nSuperblockMaxValue);
+
+    if (!znodeSync.IsSynced()) {
+        // not enough data but at least it must NOT exceed superblock max value
+//        if(CSuperblock::IsValidBlockHeight(nBlockHeight)) {
+//            if(fDebug) LogPrintf("IsBlockPayeeValid -- WARNING: Client not synced, checking superblock max bounds only\n");
+//            if(!isSuperblockMaxValueMet) {
+//                strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded superblock max value",
+//                                        nBlockHeight, block.vtx[0].GetValueOut(), nSuperblockMaxValue);
+//            }
+//            return isSuperblockMaxValueMet;
+//        }
+        if (!isBlockRewardValueMet) {
+            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, only regular blocks are allowed at this height",
+                                    nBlockHeight, block.vtx[0].GetValueOut(), blockReward);
+        }
+        // it MUST be a regular block otherwise
+        return isBlockRewardValueMet;
+    }
+
+    // we are synced, let's try to check as much data as we can
+
+    if (sporkManager.IsSporkActive(SPORK_9_SUPERBLOCKS_ENABLED)) {
+////        if(CSuperblockManager::IsSuperblockTriggered(nBlockHeight)) {
+////            if(CSuperblockManager::IsValid(block.vtx[0], nBlockHeight, blockReward)) {
+////                LogPrint("gobject", "IsBlockValueValid -- Valid superblock at height %d: %s", nBlockHeight, block.vtx[0].ToString());
+////                // all checks are done in CSuperblock::IsValid, nothing to do here
+////                return true;
+////            }
+////
+////            // triggered but invalid? that's weird
+////            LogPrintf("IsBlockValueValid -- ERROR: Invalid superblock detected at height %d: %s", nBlockHeight, block.vtx[0].ToString());
+////            // should NOT allow invalid superblocks, when superblocks are enabled
+////            strErrorRet = strprintf("invalid superblock detected at height %d", nBlockHeight);
+////            return false;
+////        }
+//        LogPrint("gobject", "IsBlockValueValid -- No triggered superblock detected at height %d\n", nBlockHeight);
+//        if(!isBlockRewardValueMet) {
+//            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, no triggered superblock detected",
+//                                    nBlockHeight, block.vtx[0].GetValueOut(), blockReward);
+//        }
+    } else {
+//        // should NOT allow superblocks at all, when superblocks are disabled
+        LogPrint("gobject", "IsBlockValueValid -- Superblocks are disabled, no superblocks allowed\n");
+        if (!isBlockRewardValueMet) {
+            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, superblocks are disabled",
+                                    nBlockHeight, block.vtx[0].GetValueOut(), blockReward);
+        }
+    }
+
+    // it MUST be a regular block
+    return isBlockRewardValueMet;
+}
+
+bool IsBlockPayeeValid(const CTransaction &txNew, int nBlockHeight, CAmount blockReward) {
+    // we can only check znode payment /
+    const Consensus::Params &consensusParams = Params().GetConsensus();
+
+    if (nBlockHeight < consensusParams.nZnodePaymentsStartBlock) {
+        //there is no budget data to use to check anything, let's just accept the longest chain
+        if (fDebug) LogPrintf("IsBlockPayeeValid -- znode isn't start\n");
+        return true;
+    }
+    if (!znodeSync.IsSynced()) {
+        //there is no budget data to use to check anything, let's just accept the longest chain
+        if (fDebug) LogPrintf("IsBlockPayeeValid -- WARNING: Client not synced, skipping block payee checks\n");
+        return true;
+    }
+
+    //check for znode payee
+    if (mnpayments.IsTransactionValid(txNew, nBlockHeight)) {
+        LogPrint("mnpayments", "IsBlockPayeeValid -- Valid znode payment at height %d: %s", nBlockHeight, txNew.ToString());
+        return true;
+    } else {
+        if(sporkManager.IsSporkActive(SPORK_8_ZNODE_PAYMENT_ENFORCEMENT)){
+            return false;
+        } else {
+            LogPrintf("ZNode payment enforcement is disabled, accepting block\n");
+            return true;
+        }
+    }
+}
+
+void FillBlockPayments(CMutableTransaction &txNew, int nBlockHeight, CAmount znodePayment, CTxOut &txoutZnodeRet, std::vector <CTxOut> &voutSuperblockRet) {
+    // only create superblocks if spork is enabled AND if superblock is actually triggered
+    // (height should be validated inside)
+//    if(sporkManager.IsSporkActive(SPORK_9_SUPERBLOCKS_ENABLED) &&
+//        CSuperblockManager::IsSuperblockTriggered(nBlockHeight)) {
+//            LogPrint("gobject", "FillBlockPayments -- triggered superblock creation at height %d\n", nBlockHeight);
+//            CSuperblockManager::CreateSuperblock(txNew, nBlockHeight, voutSuperblockRet);
+//            return;
+//    }
+
+    // FILL BLOCK PAYEE WITH ZNODE PAYMENT OTHERWISE
+    mnpayments.FillBlockPayee(txNew, nBlockHeight, znodePayment, txoutZnodeRet);
+    LogPrint("mnpayments", "FillBlockPayments -- nBlockHeight %d znodePayment %lld txoutZnodeRet %s txNew %s",
+             nBlockHeight, znodePayment, txoutZnodeRet.ToString(), txNew.ToString());
+}
+
+std::string GetRequiredPaymentsString(int nBlockHeight) {
+    // IF WE HAVE A ACTIVATED TRIGGER FOR THIS HEIGHT - IT IS A SUPERBLOCK, GET THE REQUIRED PAYEES
+//    if(CSuperblockManager::IsSuperblockTriggered(nBlockHeight)) {
+//        return CSuperblockManager::GetRequiredPaymentsString(nBlockHeight);
+//    }
+
+    // OTHERWISE, PAY ZNODE
+    return mnpayments.GetRequiredPaymentsString(nBlockHeight);
+}
+
+void CZnodePayments::Clear() {
+    LOCK2(cs_mapZnodeBlocks, cs_mapZnodePaymentVotes);
+    mapZnodeBlocks.clear();
+    mapZnodePaymentVotes.clear();
+}
+
+bool CZnodePayments::CanVote(COutPoint outZnode, int nBlockHeight) {
+    LOCK(cs_mapZnodePaymentVotes);
+
+    if (mapZnodesLastVote.count(outZnode) && mapZnodesLastVote[outZnode] == nBlockHeight) {
+        return false;
+    }
+
+    //record this znode voted
+    mapZnodesLastVote[outZnode] = nBlockHeight;
+    return true;
+}
+
+std::string CZnodePayee::ToString() const {
+    CTxDestination address1;
+    ExtractDestination(scriptPubKey, address1);
+    CBitcoinAddress address2(address1);
+    std::string str;
+    str += "(address: ";
+    str += address2.ToString();
+    str += ")\n";
+    return str;
+}
+
+/**
+*   FillBlockPayee
+*
+*   Fill Znode ONLY payment block
+*/
+
+void CZnodePayments::FillBlockPayee(CMutableTransaction &txNew, int nBlockHeight, CAmount znodePayment, CTxOut &txoutZnodeRet) {
+    // make sure it's not filled yet
+    txoutZnodeRet = CTxOut();
+
+    CScript payee;
+    bool foundMaxVotedPayee = true;
+
+    if (!mnpayments.GetBlockPayee(nBlockHeight, payee)) {
+        // no znode detected...
+        LogPrintf("no znode detected...\n");
+        foundMaxVotedPayee = false;
+        int nCount = 0;
+        CZnode *winningNode = mnodeman.GetNextZnodeInQueueForPayment(nBlockHeight, true, nCount);
+        if (!winningNode) {
+            // ...and we can't calculate it on our own
+            LogPrintf("CZnodePayments::FillBlockPayee -- Failed to detect znode to pay\n");
+            return;
+        }
+        // fill payee with locally calculated winner and hope for the best
+        payee = GetScriptForDestination(winningNode->pubKeyCollateralAddress.GetID());
+        LogPrintf("payee=%s\n", winningNode->ToString());
+    }
+    txoutZnodeRet = CTxOut(znodePayment, payee);
+    txNew.vout.push_back(txoutZnodeRet);
+
+    CTxDestination address1;
+    ExtractDestination(payee, address1);
+    CBitcoinAddress address2(address1);
+    if (foundMaxVotedPayee) {
+        LogPrintf("CZnodePayments::FillBlockPayee::foundMaxVotedPayee -- Znode payment %lld to %s\n", znodePayment, address2.ToString());
+    } else {
+        LogPrintf("CZnodePayments::FillBlockPayee -- Znode payment %lld to %s\n", znodePayment, address2.ToString());
+    }
+
+}
+
+int CZnodePayments::GetMinZnodePaymentsProto() {
+    return sporkManager.IsSporkActive(SPORK_10_ZNODE_PAY_UPDATED_NODES)
+           ? MIN_ZNODE_PAYMENT_PROTO_VERSION_2
+           : MIN_ZNODE_PAYMENT_PROTO_VERSION_1;
+}
+
+void CZnodePayments::ProcessMessage(CNode *pfrom, std::string &strCommand, CDataStream &vRecv) {
+
+//    LogPrintf("CZnodePayments::ProcessMessage strCommand=%s\n", strCommand);
+    // Ignore any payments messages until znode list is synced
+    if (!znodeSync.IsZnodeListSynced()) return;
+
+    if (fLiteMode) return; // disable all Dash specific functionality
+
+    if (strCommand == NetMsgType::ZNODEPAYMENTSYNC) { //Znode Payments Request Sync
+
+        // Ignore such requests until we are fully synced.
+        // We could start processing this after znode list is synced
+        // but this is a heavy one so it's better to finish sync first.
+        if (!znodeSync.IsSynced()) return;
+
+        int nCountNeeded;
+        vRecv >> nCountNeeded;
+
+        if (netfulfilledman.HasFulfilledRequest(pfrom->addr, NetMsgType::ZNODEPAYMENTSYNC)) {
+            // Asking for the payments list multiple times in a short period of time is no good
+            LogPrintf("ZNODEPAYMENTSYNC -- peer already asked me for the list, peer=%d\n", pfrom->id);
+            Misbehaving(pfrom->GetId(), 20);
+            return;
+        }
+        netfulfilledman.AddFulfilledRequest(pfrom->addr, NetMsgType::ZNODEPAYMENTSYNC);
+
+        Sync(pfrom);
+        LogPrintf("ZNODEPAYMENTSYNC -- Sent Znode payment votes to peer %d\n", pfrom->id);
+
+    } else if (strCommand == NetMsgType::ZNODEPAYMENTVOTE) { // Znode Payments Vote for the Winner
+
+        CZnodePaymentVote vote;
+        vRecv >> vote;
+
+        if (pfrom->nVersion < GetMinZnodePaymentsProto()) return;
+
+        if (!pCurrentBlockIndex) return;
+
+        uint256 nHash = vote.GetHash();
+
+        pfrom->setAskFor.erase(nHash);
+
+        {
+            LOCK(cs_mapZnodePaymentVotes);
+            if (mapZnodePaymentVotes.count(nHash)) {
+                LogPrint("mnpayments", "ZNODEPAYMENTVOTE -- hash=%s, nHeight=%d seen\n", nHash.ToString(), pCurrentBlockIndex->nHeight);
+                return;
+            }
+
+            // Avoid processing same vote multiple times
+            mapZnodePaymentVotes[nHash] = vote;
+            // but first mark vote as non-verified,
+            // AddPaymentVote() below should take care of it if vote is actually ok
+            mapZnodePaymentVotes[nHash].MarkAsNotVerified();
+        }
+
+        int nFirstBlock = pCurrentBlockIndex->nHeight - GetStorageLimit();
+        if (vote.nBlockHeight < nFirstBlock || vote.nBlockHeight > pCurrentBlockIndex->nHeight + 20) {
+            LogPrint("mnpayments", "ZNODEPAYMENTVOTE -- vote out of range: nFirstBlock=%d, nBlockHeight=%d, nHeight=%d\n", nFirstBlock, vote.nBlockHeight, pCurrentBlockIndex->nHeight);
+            return;
+        }
+
+        std::string strError = "";
+        if (!vote.IsValid(pfrom, pCurrentBlockIndex->nHeight, strError)) {
+            LogPrint("mnpayments", "ZNODEPAYMENTVOTE -- invalid message, error: %s\n", strError);
+            return;
+        }
+
+        if (!CanVote(vote.vinZnode.prevout, vote.nBlockHeight)) {
+            LogPrintf("ZNODEPAYMENTVOTE -- znode already voted, znode=%s\n", vote.vinZnode.prevout.ToStringShort());
+            return;
+        }
+
+        znode_info_t mnInfo = mnodeman.GetZnodeInfo(vote.vinZnode);
+        if (!mnInfo.fInfoValid) {
+            // mn was not found, so we can't check vote, some info is probably missing
+            LogPrintf("ZNODEPAYMENTVOTE -- znode is missing %s\n", vote.vinZnode.prevout.ToStringShort());
+            mnodeman.AskForMN(pfrom, vote.vinZnode);
+            return;
+        }
+
+        int nDos = 0;
+        if (!vote.CheckSignature(mnInfo.pubKeyZnode, pCurrentBlockIndex->nHeight, nDos)) {
+            if (nDos) {
+                LogPrintf("ZNODEPAYMENTVOTE -- ERROR: invalid signature\n");
+                Misbehaving(pfrom->GetId(), nDos);
+            } else {
+                // only warn about anything non-critical (i.e. nDos == 0) in debug mode
+                LogPrint("mnpayments", "ZNODEPAYMENTVOTE -- WARNING: invalid signature\n");
+            }
+            // Either our info or vote info could be outdated.
+            // In case our info is outdated, ask for an update,
+            mnodeman.AskForMN(pfrom, vote.vinZnode);
+            // but there is nothing we can do if vote info itself is outdated
+            // (i.e. it was signed by a mn which changed its key),
+            // so just quit here.
+            return;
+        }
+
+        CTxDestination address1;
+        ExtractDestination(vote.payee, address1);
+        CBitcoinAddress address2(address1);
+
+        LogPrint("mnpayments", "ZNODEPAYMENTVOTE -- vote: address=%s, nBlockHeight=%d, nHeight=%d, prevout=%s\n", address2.ToString(), vote.nBlockHeight, pCurrentBlockIndex->nHeight, vote.vinZnode.prevout.ToStringShort());
+
+        if (AddPaymentVote(vote)) {
+            vote.Relay();
+            znodeSync.AddedPaymentVote();
+        }
+    }
+}
+
+bool CZnodePaymentVote::Sign() {
+    std::string strError;
+    std::string strMessage = vinZnode.prevout.ToStringShort() +
+                             boost::lexical_cast<std::string>(nBlockHeight) +
+                             ScriptToAsmStr(payee);
+
+    if (!darkSendSigner.SignMessage(strMessage, vchSig, activeZnode.keyZnode)) {
+        LogPrintf("CZnodePaymentVote::Sign -- SignMessage() failed\n");
+        return false;
+    }
+
+    if (!darkSendSigner.VerifyMessage(activeZnode.pubKeyZnode, vchSig, strMessage, strError)) {
+        LogPrintf("CZnodePaymentVote::Sign -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+bool CZnodePayments::GetBlockPayee(int nBlockHeight, CScript &payee) {
+    if (mapZnodeBlocks.count(nBlockHeight)) {
+        return mapZnodeBlocks[nBlockHeight].GetBestPayee(payee);
+    }
+
+    return false;
+}
+
+// Is this znode scheduled to get paid soon?
+// -- Only look ahead up to 8 blocks to allow for propagation of the latest 2 blocks of votes
+bool CZnodePayments::IsScheduled(CZnode &mn, int nNotBlockHeight) {
+    LOCK(cs_mapZnodeBlocks);
+
+    if (!pCurrentBlockIndex) return false;
+
+    CScript mnpayee;
+    mnpayee = GetScriptForDestination(mn.pubKeyCollateralAddress.GetID());
+
+    CScript payee;
+    for (int64_t h = pCurrentBlockIndex->nHeight; h <= pCurrentBlockIndex->nHeight + 8; h++) {
+        if (h == nNotBlockHeight) continue;
+        if (mapZnodeBlocks.count(h) && mapZnodeBlocks[h].GetBestPayee(payee) && mnpayee == payee) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CZnodePayments::AddPaymentVote(const CZnodePaymentVote &vote) {
+    LogPrintf("CZnodePayments::AddPaymentVote\n");
+    uint256 blockHash = uint256();
+    if (!GetBlockHash(blockHash, vote.nBlockHeight - 101)) return false;
+
+    if (HasVerifiedPaymentVote(vote.GetHash())) return false;
+
+    LOCK2(cs_mapZnodeBlocks, cs_mapZnodePaymentVotes);
+
+    mapZnodePaymentVotes[vote.GetHash()] = vote;
+
+    if (!mapZnodeBlocks.count(vote.nBlockHeight)) {
+        CZnodeBlockPayees blockPayees(vote.nBlockHeight);
+        mapZnodeBlocks[vote.nBlockHeight] = blockPayees;
+    }
+
+    mapZnodeBlocks[vote.nBlockHeight].AddPayee(vote);
+
+    return true;
+}
+
+bool CZnodePayments::HasVerifiedPaymentVote(uint256 hashIn) {
+    LOCK(cs_mapZnodePaymentVotes);
+    std::map<uint256, CZnodePaymentVote>::iterator it = mapZnodePaymentVotes.find(hashIn);
+    return it != mapZnodePaymentVotes.end() && it->second.IsVerified();
+}
+
+void CZnodeBlockPayees::AddPayee(const CZnodePaymentVote &vote) {
+    LOCK(cs_vecPayees);
+
+    BOOST_FOREACH(CZnodePayee & payee, vecPayees)
+    {
+        if (payee.GetPayee() == vote.payee) {
+            payee.AddVoteHash(vote.GetHash());
+            return;
+        }
+    }
+    CZnodePayee payeeNew(vote.payee, vote.GetHash());
+    vecPayees.push_back(payeeNew);
+}
+
+bool CZnodeBlockPayees::GetBestPayee(CScript &payeeRet) {
+    LOCK(cs_vecPayees);
+    LogPrintf("CZnodeBlockPayees::GetBestPayee, vecPayees.size()=%s\n", vecPayees.size());
+    if (!vecPayees.size()) {
+        LogPrint("mnpayments", "CZnodeBlockPayees::GetBestPayee -- ERROR: couldn't find any payee\n");
+        return false;
+    }
+
+    int nVotes = -1;
+    BOOST_FOREACH(CZnodePayee & payee, vecPayees)
+    {
+        LogPrintf("payee=%s\n", payee.ToString());
+        LogPrintf("payee.GetVoteCount()=%s\n", payee.GetVoteCount());
+        LogPrintf("nVotes=%s\n", nVotes);
+        if (payee.GetVoteCount() > nVotes) {
+            payeeRet = payee.GetPayee();
+            nVotes = payee.GetVoteCount();
+        }
+    }
+
+    return (nVotes > -1);
+}
+
+bool CZnodeBlockPayees::HasPayeeWithVotes(CScript payeeIn, int nVotesReq) {
+    LOCK(cs_vecPayees);
+
+    BOOST_FOREACH(CZnodePayee & payee, vecPayees)
+    {
+        if (payee.GetVoteCount() >= nVotesReq && payee.GetPayee() == payeeIn) {
+            return true;
+        }
+    }
+
+//    LogPrint("mnpayments", "CZnodeBlockPayees::HasPayeeWithVotes -- ERROR: couldn't find any payee with %d+ votes\n", nVotesReq);
+    return false;
+}
+
+bool CZnodeBlockPayees::IsTransactionValid(const CTransaction &txNew) {
+    LOCK(cs_vecPayees);
+
+    int nMaxSignatures = 0;
+    std::string strPayeesPossible = "";
+
+    CAmount nZnodePayment = GetZnodePayment(nBlockHeight, txNew.GetValueOut());
+
+    //require at least MNPAYMENTS_SIGNATURES_REQUIRED signatures
+
+    BOOST_FOREACH(CZnodePayee & payee, vecPayees)
+    {
+        if (payee.GetVoteCount() >= nMaxSignatures) {
+            nMaxSignatures = payee.GetVoteCount();
+        }
+    }
+
+    // if we don't have at least MNPAYMENTS_SIGNATURES_REQUIRED signatures on a payee, approve whichever is the longest chain
+    if (nMaxSignatures < MNPAYMENTS_SIGNATURES_REQUIRED) return true;
+
+    bool hasValidPayee = false;
+
+    BOOST_FOREACH(CZnodePayee & payee, vecPayees)
+    {
+        if (payee.GetVoteCount() >= MNPAYMENTS_SIGNATURES_REQUIRED) {
+            hasValidPayee = true;
+
+            BOOST_FOREACH(CTxOut txout, txNew.vout) {
+                if (payee.GetPayee() == txout.scriptPubKey && nZnodePayment == txout.nValue) {
+                    LogPrint("mnpayments", "CZnodeBlockPayees::IsTransactionValid -- Found required payment\n");
+                    return true;
+                }
+            }
+
+            CTxDestination address1;
+            ExtractDestination(payee.GetPayee(), address1);
+            CBitcoinAddress address2(address1);
+
+            if (strPayeesPossible == "") {
+                strPayeesPossible = address2.ToString();
+            } else {
+                strPayeesPossible += "," + address2.ToString();
+            }
+        }
+    }
+
+    if (!hasValidPayee) return true;
+
+    LogPrintf("CZnodeBlockPayees::IsTransactionValid -- ERROR: Missing required payment, possible payees: '%s', amount: %f XZC\n", strPayeesPossible, (float) nZnodePayment / COIN);
+    return false;
+}
+
+std::string CZnodeBlockPayees::GetRequiredPaymentsString() {
+    LOCK(cs_vecPayees);
+
+    std::string strRequiredPayments = "Unknown";
+
+    BOOST_FOREACH(CZnodePayee & payee, vecPayees)
+    {
+        CTxDestination address1;
+        ExtractDestination(payee.GetPayee(), address1);
+        CBitcoinAddress address2(address1);
+
+        if (strRequiredPayments != "Unknown") {
+            strRequiredPayments += ", " + address2.ToString() + ":" + boost::lexical_cast<std::string>(payee.GetVoteCount());
+        } else {
+            strRequiredPayments = address2.ToString() + ":" + boost::lexical_cast<std::string>(payee.GetVoteCount());
+        }
+    }
+
+    return strRequiredPayments;
+}
+
+std::string CZnodePayments::GetRequiredPaymentsString(int nBlockHeight) {
+    LOCK(cs_mapZnodeBlocks);
+
+    if (mapZnodeBlocks.count(nBlockHeight)) {
+        return mapZnodeBlocks[nBlockHeight].GetRequiredPaymentsString();
+    }
+
+    return "Unknown";
+}
+
+bool CZnodePayments::IsTransactionValid(const CTransaction &txNew, int nBlockHeight) {
+    LOCK(cs_mapZnodeBlocks);
+
+    if (mapZnodeBlocks.count(nBlockHeight)) {
+        return mapZnodeBlocks[nBlockHeight].IsTransactionValid(txNew);
+    }
+
+    return true;
+}
+
+void CZnodePayments::CheckAndRemove() {
+    if (!pCurrentBlockIndex) return;
+
+    LOCK2(cs_mapZnodeBlocks, cs_mapZnodePaymentVotes);
+
+    int nLimit = GetStorageLimit();
+
+    std::map<uint256, CZnodePaymentVote>::iterator it = mapZnodePaymentVotes.begin();
+    while (it != mapZnodePaymentVotes.end()) {
+        CZnodePaymentVote vote = (*it).second;
+
+        if (pCurrentBlockIndex->nHeight - vote.nBlockHeight > nLimit) {
+            LogPrint("mnpayments", "CZnodePayments::CheckAndRemove -- Removing old Znode payment: nBlockHeight=%d\n", vote.nBlockHeight);
+            mapZnodePaymentVotes.erase(it++);
+            mapZnodeBlocks.erase(vote.nBlockHeight);
+        } else {
+            ++it;
+        }
+    }
+    LogPrintf("CZnodePayments::CheckAndRemove -- %s\n", ToString());
+}
+
+bool CZnodePaymentVote::IsValid(CNode *pnode, int nValidationHeight, std::string &strError) {
+    CZnode *pmn = mnodeman.Find(vinZnode);
+
+    if (!pmn) {
+        strError = strprintf("Unknown Znode: prevout=%s", vinZnode.prevout.ToStringShort());
+        // Only ask if we are already synced and still have no idea about that Znode
+        if (znodeSync.IsZnodeListSynced()) {
+            mnodeman.AskForMN(pnode, vinZnode);
+        }
+
+        return false;
+    }
+
+    int nMinRequiredProtocol;
+    if (nBlockHeight >= nValidationHeight) {
+        // new votes must comply SPORK_10_ZNODE_PAY_UPDATED_NODES rules
+        nMinRequiredProtocol = mnpayments.GetMinZnodePaymentsProto();
+    } else {
+        // allow non-updated znodes for old blocks
+        nMinRequiredProtocol = MIN_ZNODE_PAYMENT_PROTO_VERSION_1;
+    }
+
+    if (pmn->nProtocolVersion < nMinRequiredProtocol) {
+        strError = strprintf("Znode protocol is too old: nProtocolVersion=%d, nMinRequiredProtocol=%d", pmn->nProtocolVersion, nMinRequiredProtocol);
+        return false;
+    }
+
+    // Only znodes should try to check znode rank for old votes - they need to pick the right winner for future blocks.
+    // Regular clients (miners included) need to verify znode rank for future block votes only.
+    if (!fZNode && nBlockHeight < nValidationHeight) return true;
+
+    int nRank = mnodeman.GetZnodeRank(vinZnode, nBlockHeight - 101, nMinRequiredProtocol, false);
+
+    if (nRank == -1) {
+        LogPrint("mnpayments", "CZnodePaymentVote::IsValid -- Can't calculate rank for znode %s\n",
+                 vinZnode.prevout.ToStringShort());
+        return false;
+    }
+
+    if (nRank > MNPAYMENTS_SIGNATURES_TOTAL) {
+        // It's common to have znodes mistakenly think they are in the top 10
+        // We don't want to print all of these messages in normal mode, debug mode should print though
+        strError = strprintf("Znode is not in the top %d (%d)", MNPAYMENTS_SIGNATURES_TOTAL, nRank);
+        // Only ban for new mnw which is out of bounds, for old mnw MN list itself might be way too much off
+        if (nRank > MNPAYMENTS_SIGNATURES_TOTAL * 2 && nBlockHeight > nValidationHeight) {
+            strError = strprintf("Znode is not in the top %d (%d)", MNPAYMENTS_SIGNATURES_TOTAL * 2, nRank);
+            LogPrintf("CZnodePaymentVote::IsValid -- Error: %s\n", strError);
+            Misbehaving(pnode->GetId(), 20);
+        }
+        // Still invalid however
+        return false;
+    }
+
+    return true;
+}
+
+bool CZnodePayments::ProcessBlock(int nBlockHeight) {
+
+    LogPrintf("CZnodePayments::ProcessBlock nBlockHeight=%s\n", nBlockHeight);
+
+    // DETERMINE IF WE SHOULD BE VOTING FOR THE NEXT PAYEE
+
+    if (fLiteMode || !fZNode) {
+        LogPrintf("LogPrintf fZnode failed here 1\n");
+        return false;
+    }
+
+    // We have little chances to pick the right winner if winners list is out of sync
+    // but we have no choice, so we'll try. However it doesn't make sense to even try to do so
+    // if we have not enough data about znodes.
+    if (!znodeSync.IsZnodeListSynced()) {
+        LogPrintf("znodeSync.IsZnodeListSynced failed\n");
+        return false;
+    }
+
+
+    int nRank = mnodeman.GetZnodeRank(activeZnode.vin, nBlockHeight - 101, GetMinZnodePaymentsProto(), false);
+    LogPrintf("nRank=%s\n", nRank);
+
+    if (nRank == -1) {
+        LogPrint("mnpayments", "CZnodePayments::ProcessBlock -- Unknown Znode\n");
+        return false;
+    }
+
+    if (nRank > MNPAYMENTS_SIGNATURES_TOTAL) {
+        LogPrint("mnpayments", "CZnodePayments::ProcessBlock -- Znode not in the top %d (%d)\n", MNPAYMENTS_SIGNATURES_TOTAL, nRank);
+        return false;
+    }
+
+
+    // LOCATE THE NEXT ZNODE WHICH SHOULD BE PAID
+
+    LogPrintf("CZnodePayments::ProcessBlock -- Start: nBlockHeight=%d, znode=%s\n", nBlockHeight, activeZnode.vin.prevout.ToStringShort());
+
+    // pay to the oldest MN that still had no payment but its input is old enough and it was active long enough
+    int nCount = 0;
+    CZnode *pmn = mnodeman.GetNextZnodeInQueueForPayment(nBlockHeight, true, nCount);
+
+    if (pmn == NULL) {
+        LogPrintf("CZnodePayments::ProcessBlock -- ERROR: Failed to find znode to pay\n");
+        return false;
+    }
+
+    LogPrintf("CZnodePayments::ProcessBlock -- Znode found by GetNextZnodeInQueueForPayment(): %s\n", pmn->vin.prevout.ToStringShort());
+
+
+    CScript payee = GetScriptForDestination(pmn->pubKeyCollateralAddress.GetID());
+
+    CZnodePaymentVote voteNew(activeZnode.vin, nBlockHeight, payee);
+
+    CTxDestination address1;
+    ExtractDestination(payee, address1);
+    CBitcoinAddress address2(address1);
+
+    LogPrintf("CZnodePayments::ProcessBlock -- vote: payee=%s, nBlockHeight=%d\n", address2.ToString(), nBlockHeight);
+
+    // SIGN MESSAGE TO NETWORK WITH OUR ZNODE KEYS
+
+    LogPrintf("CZnodePayments::ProcessBlock -- Signing vote\n");
+    if (voteNew.Sign()) {
+        LogPrintf("CZnodePayments::ProcessBlock -- AddPaymentVote()\n");
+
+        if (AddPaymentVote(voteNew)) {
+            voteNew.Relay();
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void CZnodePaymentVote::Relay() {
+    // do not relay until synced
+    if (!znodeSync.IsWinnersListSynced()) {
+        LogPrintf("CZnodePaymentVote::Relay - znodeSync.IsWinnersListSynced() not sync\n");
+        return;
+    }
+    CInv inv(MSG_ZNODE_PAYMENT_VOTE, GetHash());
+    RelayInv(inv);
+}
+
+bool CZnodePaymentVote::CheckSignature(const CPubKey &pubKeyZnode, int nValidationHeight, int &nDos) {
+    // do not ban by default
+    nDos = 0;
+
+    std::string strMessage = vinZnode.prevout.ToStringShort() +
+                             boost::lexical_cast<std::string>(nBlockHeight) +
+                             ScriptToAsmStr(payee);
+
+    std::string strError = "";
+    if (!darkSendSigner.VerifyMessage(pubKeyZnode, vchSig, strMessage, strError)) {
+        // Only ban for future block vote when we are already synced.
+        // Otherwise it could be the case when MN which signed this vote is using another key now
+        // and we have no idea about the old one.
+        if (znodeSync.IsZnodeListSynced() && nBlockHeight > nValidationHeight) {
+            nDos = 20;
+        }
+        return error("CZnodePaymentVote::CheckSignature -- Got bad Znode payment signature, znode=%s, error: %s", vinZnode.prevout.ToStringShort().c_str(), strError);
+    }
+
+    return true;
+}
+
+std::string CZnodePaymentVote::ToString() const {
+    std::ostringstream info;
+
+    info << vinZnode.prevout.ToStringShort() <<
+         ", " << nBlockHeight <<
+         ", " << ScriptToAsmStr(payee) <<
+         ", " << (int) vchSig.size();
+
+    return info.str();
+}
+
+// Send only votes for future blocks, node should request every other missing payment block individually
+void CZnodePayments::Sync(CNode *pnode) {
+    LOCK(cs_mapZnodeBlocks);
+
+    if (!pCurrentBlockIndex) return;
+
+    int nInvCount = 0;
+
+    for (int h = pCurrentBlockIndex->nHeight; h < pCurrentBlockIndex->nHeight + 20; h++) {
+        if (mapZnodeBlocks.count(h)) {
+            BOOST_FOREACH(CZnodePayee & payee, mapZnodeBlocks[h].vecPayees)
+            {
+                std::vector <uint256> vecVoteHashes = payee.GetVoteHashes();
+                BOOST_FOREACH(uint256 & hash, vecVoteHashes)
+                {
+                    if (!HasVerifiedPaymentVote(hash)) continue;
+                    pnode->PushInventory(CInv(MSG_ZNODE_PAYMENT_VOTE, hash));
+                    nInvCount++;
+                }
+            }
+        }
+    }
+
+    LogPrintf("CZnodePayments::Sync -- Sent %d votes to peer %d\n", nInvCount, pnode->id);
+    pnode->PushMessage(NetMsgType::SYNCSTATUSCOUNT, ZNODE_SYNC_MNW, nInvCount);
+}
+
+// Request low data/unknown payment blocks in batches directly from some node instead of/after preliminary Sync.
+void CZnodePayments::RequestLowDataPaymentBlocks(CNode *pnode) {
+    LogPrintf("CZnodePayments::RequestLowDataPaymentBlocks\n");
+    if (!pCurrentBlockIndex) return;
+
+    LOCK2(cs_main, cs_mapZnodeBlocks);
+
+    std::vector <CInv> vToFetch;
+    int nLimit = GetStorageLimit();
+
+    const CBlockIndex *pindex = pCurrentBlockIndex;
+
+    while (pCurrentBlockIndex->nHeight - pindex->nHeight < nLimit) {
+        if (!mapZnodeBlocks.count(pindex->nHeight)) {
+            // We have no idea about this block height, let's ask
+            vToFetch.push_back(CInv(MSG_ZNODE_PAYMENT_BLOCK, pindex->GetBlockHash()));
+            // We should not violate GETDATA rules
+            if (vToFetch.size() == MAX_INV_SZ) {
+                LogPrintf("CZnodePayments::SyncLowDataPaymentBlocks -- asking peer %d for %d blocks\n", pnode->id, MAX_INV_SZ);
+                pnode->PushMessage(NetMsgType::GETDATA, vToFetch);
+                // Start filling new batch
+                vToFetch.clear();
+            }
+        }
+        if (!pindex->pprev) break;
+        pindex = pindex->pprev;
+    }
+
+    std::map<int, CZnodeBlockPayees>::iterator it = mapZnodeBlocks.begin();
+
+    while (it != mapZnodeBlocks.end()) {
+        int nTotalVotes = 0;
+        bool fFound = false;
+        BOOST_FOREACH(CZnodePayee & payee, it->second.vecPayees)
+        {
+            if (payee.GetVoteCount() >= MNPAYMENTS_SIGNATURES_REQUIRED) {
+                fFound = true;
+                break;
+            }
+            nTotalVotes += payee.GetVoteCount();
+        }
+        // A clear winner (MNPAYMENTS_SIGNATURES_REQUIRED+ votes) was found
+        // or no clear winner was found but there are at least avg number of votes
+        if (fFound || nTotalVotes >= (MNPAYMENTS_SIGNATURES_TOTAL + MNPAYMENTS_SIGNATURES_REQUIRED) / 2) {
+            // so just move to the next block
+            ++it;
+            continue;
+        }
+        // DEBUG
+//        DBG (
+//            // Let's see why this failed
+//            BOOST_FOREACH(CZnodePayee& payee, it->second.vecPayees) {
+//                CTxDestination address1;
+//                ExtractDestination(payee.GetPayee(), address1);
+//                CBitcoinAddress address2(address1);
+//                printf("payee %s votes %d\n", address2.ToString().c_str(), payee.GetVoteCount());
+//            }
+//            printf("block %d votes total %d\n", it->first, nTotalVotes);
+//        )
+        // END DEBUG
+        // Low data block found, let's try to sync it
+        uint256 hash;
+        if (GetBlockHash(hash, it->first)) {
+            vToFetch.push_back(CInv(MSG_ZNODE_PAYMENT_BLOCK, hash));
+        }
+        // We should not violate GETDATA rules
+        if (vToFetch.size() == MAX_INV_SZ) {
+            LogPrintf("CZnodePayments::SyncLowDataPaymentBlocks -- asking peer %d for %d payment blocks\n", pnode->id, MAX_INV_SZ);
+            pnode->PushMessage(NetMsgType::GETDATA, vToFetch);
+            // Start filling new batch
+            vToFetch.clear();
+        }
+        ++it;
+    }
+    // Ask for the rest of it
+    if (!vToFetch.empty()) {
+        LogPrintf("CZnodePayments::SyncLowDataPaymentBlocks -- asking peer %d for %d payment blocks\n", pnode->id, vToFetch.size());
+        pnode->PushMessage(NetMsgType::GETDATA, vToFetch);
+    }
+}
+
+std::string CZnodePayments::ToString() const {
+    std::ostringstream info;
+
+    info << "Votes: " << (int) mapZnodePaymentVotes.size() <<
+         ", Blocks: " << (int) mapZnodeBlocks.size();
+
+    return info.str();
+}
+
+bool CZnodePayments::IsEnoughData() {
+    float nAverageVotes = (MNPAYMENTS_SIGNATURES_TOTAL + MNPAYMENTS_SIGNATURES_REQUIRED) / 2;
+    int nStorageLimit = GetStorageLimit();
+    return GetBlockCount() > nStorageLimit && GetVoteCount() > nStorageLimit * nAverageVotes;
+}
+
+int CZnodePayments::GetStorageLimit() {
+    return std::max(int(mnodeman.size() * nStorageCoeff), nMinBlocksToStore);
+}
+
+void CZnodePayments::UpdatedBlockTip(const CBlockIndex *pindex) {
+    pCurrentBlockIndex = pindex;
+    LogPrint("mnpayments", "CZnodePayments::UpdatedBlockTip -- pCurrentBlockIndex->nHeight=%d\n", pCurrentBlockIndex->nHeight);
+    
+    ProcessBlock(pindex->nHeight + 5);
+}
diff --git a/src/znode-payments.h b/src/znode-payments.h
new file mode 100644
index 0000000000..c128c67000
--- /dev/null
+++ b/src/znode-payments.h
@@ -0,0 +1,225 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef ZNODE_PAYMENTS_H
+#define ZNODE_PAYMENTS_H
+
+#include "util.h"
+#include "core_io.h"
+#include "key.h"
+#include "main.h"
+#include "znode.h"
+#include "utilstrencodings.h"
+
+class CZnodePayments;
+class CZnodePaymentVote;
+class CZnodeBlockPayees;
+
+static const int MNPAYMENTS_SIGNATURES_REQUIRED         = 6;
+static const int MNPAYMENTS_SIGNATURES_TOTAL            = 10;
+
+//! minimum peer version that can receive and send znode payment messages,
+//  vote for znode and be elected as a payment winner
+// V1 - Last protocol version before update
+// V2 - Newest protocol version
+static const int MIN_ZNODE_PAYMENT_PROTO_VERSION_1 = 90020;
+static const int MIN_ZNODE_PAYMENT_PROTO_VERSION_2 = 90020;
+
+extern CCriticalSection cs_vecPayees;
+extern CCriticalSection cs_mapZnodeBlocks;
+extern CCriticalSection cs_mapZnodePayeeVotes;
+
+extern CZnodePayments 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, CTxOut& txoutZnodeRet, std::vector<CTxOut>& voutSuperblockRet);
+std::string GetRequiredPaymentsString(int nBlockHeight);
+
+class CZnodePayee
+{
+private:
+    CScript scriptPubKey;
+    std::vector<uint256> vecVoteHashes;
+
+public:
+    CZnodePayee() :
+        scriptPubKey(),
+        vecVoteHashes()
+        {}
+
+    CZnodePayee(CScript payee, uint256 hashIn) :
+        scriptPubKey(payee),
+        vecVoteHashes()
+    {
+        vecVoteHashes.push_back(hashIn);
+    }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(*(CScriptBase*)(&scriptPubKey));
+        READWRITE(vecVoteHashes);
+    }
+
+    CScript GetPayee() { return scriptPubKey; }
+
+    void AddVoteHash(uint256 hashIn) { vecVoteHashes.push_back(hashIn); }
+    std::vector<uint256> GetVoteHashes() { return vecVoteHashes; }
+    int GetVoteCount() { return vecVoteHashes.size(); }
+    std::string ToString() const;
+};
+
+// Keep track of votes for payees from znodes
+class CZnodeBlockPayees
+{
+public:
+    int nBlockHeight;
+    std::vector<CZnodePayee> vecPayees;
+
+    CZnodeBlockPayees() :
+        nBlockHeight(0),
+        vecPayees()
+        {}
+    CZnodeBlockPayees(int nBlockHeightIn) :
+        nBlockHeight(nBlockHeightIn),
+        vecPayees()
+        {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(nBlockHeight);
+        READWRITE(vecPayees);
+    }
+
+    void AddPayee(const CZnodePaymentVote& vote);
+    bool GetBestPayee(CScript& payeeRet);
+    bool HasPayeeWithVotes(CScript payeeIn, int nVotesReq);
+
+    bool IsTransactionValid(const CTransaction& txNew);
+
+    std::string GetRequiredPaymentsString();
+};
+
+// vote for the winning payment
+class CZnodePaymentVote
+{
+public:
+    CTxIn vinZnode;
+
+    int nBlockHeight;
+    CScript payee;
+    std::vector<unsigned char> vchSig;
+
+    CZnodePaymentVote() :
+        vinZnode(),
+        nBlockHeight(0),
+        payee(),
+        vchSig()
+        {}
+
+    CZnodePaymentVote(CTxIn vinZnode, int nBlockHeight, CScript payee) :
+        vinZnode(vinZnode),
+        nBlockHeight(nBlockHeight),
+        payee(payee),
+        vchSig()
+        {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(vinZnode);
+        READWRITE(nBlockHeight);
+        READWRITE(*(CScriptBase*)(&payee));
+        READWRITE(vchSig);
+    }
+
+    uint256 GetHash() const {
+        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+        ss << *(CScriptBase*)(&payee);
+        ss << nBlockHeight;
+        ss << vinZnode.prevout;
+        return ss.GetHash();
+    }
+
+    bool Sign();
+    bool CheckSignature(const CPubKey& pubKeyZnode, int nValidationHeight, int &nDos);
+
+    bool IsValid(CNode* pnode, int nValidationHeight, std::string& strError);
+    void Relay();
+
+    bool IsVerified() { return !vchSig.empty(); }
+    void MarkAsNotVerified() { vchSig.clear(); }
+
+    std::string ToString() const;
+};
+
+//
+// Znode Payments Class
+// Keeps track of who should get paid for which blocks
+//
+
+class CZnodePayments
+{
+private:
+    // znode count times nStorageCoeff payments blocks should be stored ...
+    const float nStorageCoeff;
+    // ... but at least nMinBlocksToStore (payments blocks)
+    const int nMinBlocksToStore;
+
+    // Keep track of current block index
+    const CBlockIndex *pCurrentBlockIndex;
+
+public:
+    std::map<uint256, CZnodePaymentVote> mapZnodePaymentVotes;
+    std::map<int, CZnodeBlockPayees> mapZnodeBlocks;
+    std::map<COutPoint, int> mapZnodesLastVote;
+
+    CZnodePayments() : nStorageCoeff(1.25), nMinBlocksToStore(5000) {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(mapZnodePaymentVotes);
+        READWRITE(mapZnodeBlocks);
+    }
+
+    void Clear();
+
+    bool AddPaymentVote(const CZnodePaymentVote& vote);
+    bool HasVerifiedPaymentVote(uint256 hashIn);
+    bool ProcessBlock(int nBlockHeight);
+
+    void Sync(CNode* node);
+    void RequestLowDataPaymentBlocks(CNode* pnode);
+    void CheckAndRemove();
+
+    bool GetBlockPayee(int nBlockHeight, CScript& payee);
+    bool IsTransactionValid(const CTransaction& txNew, int nBlockHeight);
+    bool IsScheduled(CZnode& mn, int nNotBlockHeight);
+
+    bool CanVote(COutPoint outZnode, int nBlockHeight);
+
+    int GetMinZnodePaymentsProto();
+    void ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
+    std::string GetRequiredPaymentsString(int nBlockHeight);
+    void FillBlockPayee(CMutableTransaction& txNew, int nBlockHeight, CAmount blockReward, CTxOut& txoutZnodeRet);
+    std::string ToString() const;
+
+    int GetBlockCount() { return mapZnodeBlocks.size(); }
+    int GetVoteCount() { return mapZnodePaymentVotes.size(); }
+
+    bool IsEnoughData();
+    int GetStorageLimit();
+
+    void UpdatedBlockTip(const CBlockIndex *pindex);
+};
+
+#endif
diff --git a/src/znode-sync.cpp b/src/znode-sync.cpp
new file mode 100644
index 0000000000..46acbd104b
--- /dev/null
+++ b/src/znode-sync.cpp
@@ -0,0 +1,425 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "activeznode.h"
+#include "checkpoints.h"
+#include "main.h"
+#include "znode.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "netfulfilledman.h"
+#include "spork.h"
+#include "util.h"
+
+class CZnodeSync;
+
+CZnodeSync znodeSync;
+
+bool CZnodeSync::CheckNodeHeight(CNode *pnode, bool fDisconnectStuckNodes) {
+    CNodeStateStats stats;
+    if (!GetNodeStateStats(pnode->id, stats) || stats.nCommonHeight == -1 || stats.nSyncHeight == -1) return false; // not enough info about this peer
+
+    // Check blocks and headers, allow a small error margin of 1 block
+    if (pCurrentBlockIndex->nHeight - 1 > stats.nCommonHeight) {
+        // This peer probably stuck, don't sync any additional data from it
+        if (fDisconnectStuckNodes) {
+            // Disconnect to free this connection slot for another peer.
+            pnode->fDisconnect = true;
+            LogPrintf("CZnodeSync::CheckNodeHeight -- disconnecting from stuck peer, nHeight=%d, nCommonHeight=%d, peer=%d\n",
+                      pCurrentBlockIndex->nHeight, stats.nCommonHeight, pnode->id);
+        } else {
+            LogPrintf("CZnodeSync::CheckNodeHeight -- skipping stuck peer, nHeight=%d, nCommonHeight=%d, peer=%d\n",
+                      pCurrentBlockIndex->nHeight, stats.nCommonHeight, pnode->id);
+        }
+        return false;
+    } else if (pCurrentBlockIndex->nHeight < stats.nSyncHeight - 1) {
+        // This peer announced more headers than we have blocks currently
+        LogPrintf("CZnodeSync::CheckNodeHeight -- skipping peer, who announced more headers than we have blocks currently, nHeight=%d, nSyncHeight=%d, peer=%d\n",
+                  pCurrentBlockIndex->nHeight, stats.nSyncHeight, pnode->id);
+        return false;
+    }
+
+    return true;
+}
+
+bool CZnodeSync::IsBlockchainSynced(bool fBlockAccepted) {
+    static bool fBlockchainSynced = false;
+    static int64_t nTimeLastProcess = GetTime();
+    static int nSkipped = 0;
+    static bool fFirstBlockAccepted = false;
+
+    // if the last call to this function was more than 60 minutes ago (client was in sleep mode) reset the sync process
+    if (GetTime() - nTimeLastProcess > 60 * 60) {
+        LogPrintf("CZnodeSync::IsBlockchainSynced time-check fBlockchainSynced=%s\n", fBlockchainSynced);
+        Reset();
+        fBlockchainSynced = false;
+    }
+
+    if (!pCurrentBlockIndex || !pindexBestHeader || fImporting || fReindex) return false;
+
+    if (fBlockAccepted) {
+        // this should be only triggered while we are still syncing
+        if (!IsSynced()) {
+            // we are trying to download smth, reset blockchain sync status
+            LogPrintf("CZnodeSync::IsBlockchainSynced -- reset\n");
+            fFirstBlockAccepted = true;
+            fBlockchainSynced = false;
+            nTimeLastProcess = GetTime();
+            return false;
+        }
+    } else {
+        // skip if we already checked less than 1 tick ago
+        if (GetTime() - nTimeLastProcess < ZNODE_SYNC_TICK_SECONDS) {
+            nSkipped++;
+            return fBlockchainSynced;
+        }
+    }
+
+    if (fDebug) LogPrintf("CZnodeSync::IsBlockchainSynced -- state before check: %ssynced, skipped %d times\n", fBlockchainSynced ? "" : "not ", nSkipped);
+
+    nTimeLastProcess = GetTime();
+    nSkipped = 0;
+
+    if (fBlockchainSynced){
+        return true;
+    }
+
+    if (fCheckpointsEnabled && pCurrentBlockIndex->nHeight < Checkpoints::GetTotalBlocksEstimate(Params().Checkpoints())) {
+        return false;
+    }
+
+    std::vector < CNode * > vNodesCopy = CopyNodeVector();
+    LogPrintf("vNodesCopy.size() = %s\n", vNodesCopy.size());
+    LogPrintf("ZNODE_SYNC_ENOUGH_PEERS = %s\n", ZNODE_SYNC_ENOUGH_PEERS);
+    // We have enough peers and assume most of them are synced
+    if (vNodesCopy.size() >= ZNODE_SYNC_ENOUGH_PEERS) {
+        // Check to see how many of our peers are (almost) at the same height as we are
+        int nNodesAtSameHeight = 0;
+        BOOST_FOREACH(CNode * pnode, vNodesCopy)
+        {
+            // Make sure this peer is presumably at the same height
+            if (!CheckNodeHeight(pnode)) {
+                continue;
+            }
+            nNodesAtSameHeight++;
+            LogPrintf("nNodesAtSameHeight=%s\n", nNodesAtSameHeight);
+            // if we have decent number of such peers, most likely we are synced now
+            if (nNodesAtSameHeight >= ZNODE_SYNC_ENOUGH_PEERS) {
+                LogPrintf("CZnodeSync::IsBlockchainSynced -- found enough peers on the same height as we are, done\n");
+                fBlockchainSynced = true;
+                ReleaseNodeVector(vNodesCopy);
+                return true;
+            }
+        }
+    }
+    ReleaseNodeVector(vNodesCopy);
+
+    // wait for at least one new block to be accepted
+    if (!fFirstBlockAccepted) return false;
+
+    // same as !IsInitialBlockDownload() but no cs_main needed here
+    int64_t nMaxBlockTime = std::max(pCurrentBlockIndex->GetBlockTime(), pindexBestHeader->GetBlockTime());
+    fBlockchainSynced = pindexBestHeader->nHeight - pCurrentBlockIndex->nHeight < 24 * 6 &&
+                        GetTime() - nMaxBlockTime < Params().MaxTipAge();
+    return fBlockchainSynced;
+}
+
+void CZnodeSync::Fail() {
+    nTimeLastFailure = GetTime();
+    nRequestedZnodeAssets = ZNODE_SYNC_FAILED;
+}
+
+void CZnodeSync::Reset() {
+    nRequestedZnodeAssets = ZNODE_SYNC_INITIAL;
+    nRequestedZnodeAttempt = 0;
+    nTimeAssetSyncStarted = GetTime();
+    nTimeLastZnodeList = GetTime();
+    nTimeLastPaymentVote = GetTime();
+    nTimeLastGovernanceItem = GetTime();
+    nTimeLastFailure = 0;
+    nCountFailures = 0;
+}
+
+std::string CZnodeSync::GetAssetName() {
+    switch (nRequestedZnodeAssets) {
+        case (ZNODE_SYNC_INITIAL):
+            return "ZNODE_SYNC_INITIAL";
+        case (ZNODE_SYNC_SPORKS):
+            return "ZNODE_SYNC_SPORKS";
+        case (ZNODE_SYNC_LIST):
+            return "ZNODE_SYNC_LIST";
+        case (ZNODE_SYNC_MNW):
+            return "ZNODE_SYNC_MNW";
+        case (ZNODE_SYNC_FAILED):
+            return "ZNODE_SYNC_FAILED";
+        case ZNODE_SYNC_FINISHED:
+            return "ZNODE_SYNC_FINISHED";
+        default:
+            return "UNKNOWN";
+    }
+}
+
+void CZnodeSync::SwitchToNextAsset() {
+    switch (nRequestedZnodeAssets) {
+        case (ZNODE_SYNC_FAILED):
+            throw std::runtime_error("Can't switch to next asset from failed, should use Reset() first!");
+            break;
+        case (ZNODE_SYNC_INITIAL):
+            ClearFulfilledRequests();
+            nRequestedZnodeAssets = ZNODE_SYNC_SPORKS;
+            LogPrintf("CZnodeSync::SwitchToNextAsset -- Starting %s\n", GetAssetName());
+            break;
+        case (ZNODE_SYNC_SPORKS):
+            nTimeLastZnodeList = GetTime();
+            nRequestedZnodeAssets = ZNODE_SYNC_LIST;
+            LogPrintf("CZnodeSync::SwitchToNextAsset -- Starting %s\n", GetAssetName());
+            break;
+        case (ZNODE_SYNC_LIST):
+            nTimeLastPaymentVote = GetTime();
+            nRequestedZnodeAssets = ZNODE_SYNC_MNW;
+            LogPrintf("CZnodeSync::SwitchToNextAsset -- Starting %s\n", GetAssetName());
+            break;
+
+        case (ZNODE_SYNC_MNW):
+            nTimeLastGovernanceItem = GetTime();
+            LogPrintf("CZnodeSync::SwitchToNextAsset -- Sync has finished\n");
+            nRequestedZnodeAssets = ZNODE_SYNC_FINISHED;
+            break;
+    }
+    nRequestedZnodeAttempt = 0;
+    nTimeAssetSyncStarted = GetTime();
+}
+
+std::string CZnodeSync::GetSyncStatus() {
+    switch (znodeSync.nRequestedZnodeAssets) {
+        case ZNODE_SYNC_INITIAL:
+            return _("Synchronization pending...");
+        case ZNODE_SYNC_SPORKS:
+            return _("Synchronizing sporks...");
+        case ZNODE_SYNC_LIST:
+            return _("Synchronizing znodes...");
+        case ZNODE_SYNC_MNW:
+            return _("Synchronizing znode payments...");
+        case ZNODE_SYNC_FAILED:
+            return _("Synchronization failed");
+        case ZNODE_SYNC_FINISHED:
+            return _("Synchronization finished");
+        default:
+            return "";
+    }
+}
+
+void CZnodeSync::ProcessMessage(CNode *pfrom, std::string &strCommand, CDataStream &vRecv) {
+    if (strCommand == NetMsgType::SYNCSTATUSCOUNT) { //Sync status count
+
+        //do not care about stats if sync process finished or failed
+        if (IsSynced() || IsFailed()) return;
+
+        int nItemID;
+        int nCount;
+        vRecv >> nItemID >> nCount;
+
+        LogPrintf("SYNCSTATUSCOUNT -- got inventory count: nItemID=%d  nCount=%d  peer=%d\n", nItemID, nCount, pfrom->id);
+    }
+}
+
+void CZnodeSync::ClearFulfilledRequests() {
+    TRY_LOCK(cs_vNodes, lockRecv);
+    if (!lockRecv) return;
+
+    BOOST_FOREACH(CNode * pnode, vNodes)
+    {
+        netfulfilledman.RemoveFulfilledRequest(pnode->addr, "spork-sync");
+        netfulfilledman.RemoveFulfilledRequest(pnode->addr, "znode-list-sync");
+        netfulfilledman.RemoveFulfilledRequest(pnode->addr, "znode-payment-sync");
+        netfulfilledman.RemoveFulfilledRequest(pnode->addr, "full-sync");
+    }
+}
+
+void CZnodeSync::ProcessTick() {
+    static int nTick = 0;
+    if (nTick++ % ZNODE_SYNC_TICK_SECONDS != 0) return;
+    if (!pCurrentBlockIndex) return;
+
+    //the actual count of znodes we have currently
+    int nMnCount = mnodeman.CountZnodes();
+
+    if (fDebug) LogPrintf("CZnodeSync::ProcessTick -- nTick %d nMnCount %d\n", nTick, nMnCount);
+
+    // INITIAL SYNC SETUP / LOG REPORTING
+    double nSyncProgress = double(nRequestedZnodeAttempt + (nRequestedZnodeAssets - 1) * 8) / (8 * 4);
+    LogPrint("ProcessTick", "CZnodeSync::ProcessTick -- nTick %d nRequestedZnodeAssets %d nRequestedZnodeAttempt %d nSyncProgress %f\n", nTick, nRequestedZnodeAssets, nRequestedZnodeAttempt, nSyncProgress);
+    uiInterface.NotifyAdditionalDataSyncProgressChanged(nSyncProgress);
+
+    // RESET SYNCING INCASE OF FAILURE
+    {
+        if (IsSynced()) {
+            /*
+                Resync if we lost all znodes from sleep/wake or failed to sync originally
+            */
+            if (nMnCount == 0) {
+                LogPrintf("CZnodeSync::ProcessTick -- WARNING: not enough data, restarting sync\n");
+                Reset();
+            } else {
+                std::vector < CNode * > vNodesCopy = CopyNodeVector();
+                ReleaseNodeVector(vNodesCopy);
+                return;
+            }
+        }
+
+        //try syncing again
+        if (IsFailed()) {
+            if (nTimeLastFailure + (1 * 60) < GetTime()) { // 1 minute cooldown after failed sync
+                Reset();
+            }
+            return;
+        }
+    }
+
+    if (Params().NetworkIDString() != CBaseChainParams::REGTEST && !IsBlockchainSynced() && nRequestedZnodeAssets > ZNODE_SYNC_SPORKS) {
+        nTimeLastZnodeList = GetTime();
+        nTimeLastPaymentVote = GetTime();
+        nTimeLastGovernanceItem = GetTime();
+        return;
+    }
+    if (nRequestedZnodeAssets == ZNODE_SYNC_INITIAL || (nRequestedZnodeAssets == ZNODE_SYNC_SPORKS && IsBlockchainSynced())) {
+        SwitchToNextAsset();
+    }
+
+    std::vector < CNode * > vNodesCopy = CopyNodeVector();
+
+    BOOST_FOREACH(CNode * pnode, vNodesCopy)
+    {
+        // Don't try to sync any data from outbound "znode" connections -
+        // they are temporary and should be considered unreliable for a sync process.
+        // Inbound connection this early is most likely a "znode" connection
+        // initialted from another node, so skip it too.
+        if (pnode->fZnode || (fZNode && pnode->fInbound)) continue;
+
+        // QUICK MODE (REGTEST ONLY!)
+        if (Params().NetworkIDString() == CBaseChainParams::REGTEST) {
+            if (nRequestedZnodeAttempt <= 2) {
+                pnode->PushMessage(NetMsgType::GETSPORKS); //get current network sporks
+            } else if (nRequestedZnodeAttempt < 4) {
+                mnodeman.DsegUpdate(pnode);
+            } else if (nRequestedZnodeAttempt < 6) {
+                int nMnCount = mnodeman.CountZnodes();
+                pnode->PushMessage(NetMsgType::ZNODEPAYMENTSYNC, nMnCount); //sync payment votes
+            } else {
+                nRequestedZnodeAssets = ZNODE_SYNC_FINISHED;
+            }
+            nRequestedZnodeAttempt++;
+            ReleaseNodeVector(vNodesCopy);
+            return;
+        }
+
+        // NORMAL NETWORK MODE - TESTNET/MAINNET
+        {
+            if (netfulfilledman.HasFulfilledRequest(pnode->addr, "full-sync")) {
+                // We already fully synced from this node recently,
+                // disconnect to free this connection slot for another peer.
+                pnode->fDisconnect = true;
+                LogPrintf("CZnodeSync::ProcessTick -- disconnecting from recently synced peer %d\n", pnode->id);
+                continue;
+            }
+
+            // SPORK : ALWAYS ASK FOR SPORKS AS WE SYNC (we skip this mode now)
+
+            if (!netfulfilledman.HasFulfilledRequest(pnode->addr, "spork-sync")) {
+                // only request once from each peer
+                netfulfilledman.AddFulfilledRequest(pnode->addr, "spork-sync");
+                // get current network sporks
+                pnode->PushMessage(NetMsgType::GETSPORKS);
+                LogPrintf("CZnodeSync::ProcessTick -- nTick %d nRequestedZnodeAssets %d -- requesting sporks from peer %d\n", nTick, nRequestedZnodeAssets, pnode->id);
+                continue; // always get sporks first, switch to the next node without waiting for the next tick
+            }
+
+            // MNLIST : SYNC ZNODE LIST FROM OTHER CONNECTED CLIENTS
+
+            if (nRequestedZnodeAssets == ZNODE_SYNC_LIST) {
+                // check for timeout first
+                if (nTimeLastZnodeList < GetTime() - ZNODE_SYNC_TIMEOUT_SECONDS) {
+                    LogPrintf("CZnodeSync::ProcessTick -- nTick %d nRequestedZnodeAssets %d -- timeout\n", nTick, nRequestedZnodeAssets);
+                    if (nRequestedZnodeAttempt == 0) {
+                        LogPrintf("CZnodeSync::ProcessTick -- ERROR: failed to sync %s\n", GetAssetName());
+                        // there is no way we can continue without znode list, fail here and try later
+                        Fail();
+                        ReleaseNodeVector(vNodesCopy);
+                        return;
+                    }
+                    SwitchToNextAsset();
+                    ReleaseNodeVector(vNodesCopy);
+                    return;
+                }
+
+                // only request once from each peer
+                if (netfulfilledman.HasFulfilledRequest(pnode->addr, "znode-list-sync")) continue;
+                netfulfilledman.AddFulfilledRequest(pnode->addr, "znode-list-sync");
+
+                if (pnode->nVersion < mnpayments.GetMinZnodePaymentsProto()) continue;
+                nRequestedZnodeAttempt++;
+
+                mnodeman.DsegUpdate(pnode);
+
+                ReleaseNodeVector(vNodesCopy);
+                return; //this will cause each peer to get one request each six seconds for the various assets we need
+            }
+
+            // MNW : SYNC ZNODE PAYMENT VOTES FROM OTHER CONNECTED CLIENTS
+
+            if (nRequestedZnodeAssets == ZNODE_SYNC_MNW) {
+                LogPrint("mnpayments", "CZnodeSync::ProcessTick -- nTick %d nRequestedZnodeAssets %d nTimeLastPaymentVote %lld GetTime() %lld diff %lld\n", nTick, nRequestedZnodeAssets, nTimeLastPaymentVote, GetTime(), GetTime() - nTimeLastPaymentVote);
+                // check for timeout first
+                // This might take a lot longer than ZNODE_SYNC_TIMEOUT_SECONDS minutes due to new blocks,
+                // but that should be OK and it should timeout eventually.
+                if (nTimeLastPaymentVote < GetTime() - ZNODE_SYNC_TIMEOUT_SECONDS) {
+                    LogPrintf("CZnodeSync::ProcessTick -- nTick %d nRequestedZnodeAssets %d -- timeout\n", nTick, nRequestedZnodeAssets);
+                    if (nRequestedZnodeAttempt == 0) {
+                        LogPrintf("CZnodeSync::ProcessTick -- ERROR: failed to sync %s\n", GetAssetName());
+                        // probably not a good idea to proceed without winner list
+                        Fail();
+                        ReleaseNodeVector(vNodesCopy);
+                        return;
+                    }
+                    SwitchToNextAsset();
+                    ReleaseNodeVector(vNodesCopy);
+                    return;
+                }
+
+                // check for data
+                // if mnpayments already has enough blocks and votes, switch to the next asset
+                // try to fetch data from at least two peers though
+                if (nRequestedZnodeAttempt > 1 && mnpayments.IsEnoughData()) {
+                    LogPrintf("CZnodeSync::ProcessTick -- nTick %d nRequestedZnodeAssets %d -- found enough data\n", nTick, nRequestedZnodeAssets);
+                    SwitchToNextAsset();
+                    ReleaseNodeVector(vNodesCopy);
+                    return;
+                }
+
+                // only request once from each peer
+                if (netfulfilledman.HasFulfilledRequest(pnode->addr, "znode-payment-sync")) continue;
+                netfulfilledman.AddFulfilledRequest(pnode->addr, "znode-payment-sync");
+
+                if (pnode->nVersion < mnpayments.GetMinZnodePaymentsProto()) continue;
+                nRequestedZnodeAttempt++;
+
+                // ask node for all payment votes it has (new nodes will only return votes for future payments)
+                pnode->PushMessage(NetMsgType::ZNODEPAYMENTSYNC, mnpayments.GetStorageLimit());
+                // ask node for missing pieces only (old nodes will not be asked)
+                mnpayments.RequestLowDataPaymentBlocks(pnode);
+
+                ReleaseNodeVector(vNodesCopy);
+                return; //this will cause each peer to get one request each six seconds for the various assets we need
+            }
+
+        }
+    }
+    // looped through all nodes, release them
+    ReleaseNodeVector(vNodesCopy);
+}
+
+void CZnodeSync::UpdatedBlockTip(const CBlockIndex *pindex) {
+    pCurrentBlockIndex = pindex;
+}
diff --git a/src/znode-sync.h b/src/znode-sync.h
new file mode 100644
index 0000000000..0ade7e98a6
--- /dev/null
+++ b/src/znode-sync.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#ifndef ZNODE_SYNC_H
+#define ZNODE_SYNC_H
+
+#include "chain.h"
+#include "net.h"
+
+#include <univalue.h>
+
+class CZnodeSync;
+
+static const int ZNODE_SYNC_FAILED          = -1;
+static const int ZNODE_SYNC_INITIAL         = 0;
+static const int ZNODE_SYNC_SPORKS          = 1;
+static const int ZNODE_SYNC_LIST            = 2;
+static const int ZNODE_SYNC_MNW             = 3;
+static const int ZNODE_SYNC_FINISHED        = 999;
+
+static const int ZNODE_SYNC_TICK_SECONDS    = 6;
+static const int ZNODE_SYNC_TIMEOUT_SECONDS = 30; // our blocks are 2.5 minutes so 30 seconds should be fine
+
+//static const int ZNODE_SYNC_ENOUGH_PEERS    = 6;
+static const int ZNODE_SYNC_ENOUGH_PEERS    = 3;
+
+extern CZnodeSync znodeSync;
+
+//
+// CZnodeSync : Sync znode assets in stages
+//
+
+class CZnodeSync
+{
+private:
+    // Keep track of current asset
+    int nRequestedZnodeAssets;
+    // Count peers we've requested the asset from
+    int nRequestedZnodeAttempt;
+
+    // Time when current znode asset sync started
+    int64_t nTimeAssetSyncStarted;
+
+    // Last time when we received some znode asset ...
+    int64_t nTimeLastZnodeList;
+    int64_t nTimeLastPaymentVote;
+    int64_t nTimeLastGovernanceItem;
+    // ... or failed
+    int64_t nTimeLastFailure;
+
+    // How many times we failed
+    int nCountFailures;
+
+    // Keep track of current block index
+    const CBlockIndex *pCurrentBlockIndex;
+
+    bool CheckNodeHeight(CNode* pnode, bool fDisconnectStuckNodes = false);
+    void Fail();
+    void ClearFulfilledRequests();
+
+public:
+    CZnodeSync() { Reset(); }
+
+    void AddedZnodeList() { nTimeLastZnodeList = GetTime(); }
+    void AddedPaymentVote() { nTimeLastPaymentVote = GetTime(); }
+    void AddedGovernanceItem() { nTimeLastGovernanceItem = GetTime(); };
+
+    void SendGovernanceSyncRequest(CNode* pnode);
+
+    bool IsFailed() { return nRequestedZnodeAssets == ZNODE_SYNC_FAILED; }
+    bool IsBlockchainSynced(bool fBlockAccepted = false);
+    bool IsZnodeListSynced() { return nRequestedZnodeAssets > ZNODE_SYNC_LIST; }
+    bool IsWinnersListSynced() { return nRequestedZnodeAssets > ZNODE_SYNC_MNW; }
+    bool IsSynced() { return nRequestedZnodeAssets == ZNODE_SYNC_FINISHED; }
+
+    int GetAssetID() { return nRequestedZnodeAssets; }
+    int GetAttempt() { return nRequestedZnodeAttempt; }
+    std::string GetAssetName();
+    std::string GetSyncStatus();
+
+    void Reset();
+    void SwitchToNextAsset();
+
+    void ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
+    void ProcessTick();
+
+    void UpdatedBlockTip(const CBlockIndex *pindex);
+};
+
+#endif
diff --git a/src/znode.cpp b/src/znode.cpp
new file mode 100644
index 0000000000..fee4df0833
--- /dev/null
+++ b/src/znode.cpp
@@ -0,0 +1,948 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "activeznode.h"
+#include "consensus/validation.h"
+#include "darksend.h"
+#include "init.h"
+//#include "governance.h"
+#include "znode.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "util.h"
+
+#include <boost/lexical_cast.hpp>
+
+
+CZnode::CZnode() :
+        vin(),
+        addr(),
+        pubKeyCollateralAddress(),
+        pubKeyZnode(),
+        lastPing(),
+        vchSig(),
+        sigTime(GetAdjustedTime()),
+        nLastDsq(0),
+        nTimeLastChecked(0),
+        nTimeLastPaid(0),
+        nTimeLastWatchdogVote(0),
+        nActiveState(ZNODE_ENABLED),
+        nCacheCollateralBlock(0),
+        nBlockLastPaid(0),
+        nProtocolVersion(PROTOCOL_VERSION),
+        nPoSeBanScore(0),
+        nPoSeBanHeight(0),
+        fAllowMixingTx(true),
+        fUnitTest(false) {}
+
+CZnode::CZnode(CService addrNew, CTxIn vinNew, CPubKey pubKeyCollateralAddressNew, CPubKey pubKeyZnodeNew, int nProtocolVersionIn) :
+        vin(vinNew),
+        addr(addrNew),
+        pubKeyCollateralAddress(pubKeyCollateralAddressNew),
+        pubKeyZnode(pubKeyZnodeNew),
+        lastPing(),
+        vchSig(),
+        sigTime(GetAdjustedTime()),
+        nLastDsq(0),
+        nTimeLastChecked(0),
+        nTimeLastPaid(0),
+        nTimeLastWatchdogVote(0),
+        nActiveState(ZNODE_ENABLED),
+        nCacheCollateralBlock(0),
+        nBlockLastPaid(0),
+        nProtocolVersion(nProtocolVersionIn),
+        nPoSeBanScore(0),
+        nPoSeBanHeight(0),
+        fAllowMixingTx(true),
+        fUnitTest(false) {}
+
+CZnode::CZnode(const CZnode &other) :
+        vin(other.vin),
+        addr(other.addr),
+        pubKeyCollateralAddress(other.pubKeyCollateralAddress),
+        pubKeyZnode(other.pubKeyZnode),
+        lastPing(other.lastPing),
+        vchSig(other.vchSig),
+        sigTime(other.sigTime),
+        nLastDsq(other.nLastDsq),
+        nTimeLastChecked(other.nTimeLastChecked),
+        nTimeLastPaid(other.nTimeLastPaid),
+        nTimeLastWatchdogVote(other.nTimeLastWatchdogVote),
+        nActiveState(other.nActiveState),
+        nCacheCollateralBlock(other.nCacheCollateralBlock),
+        nBlockLastPaid(other.nBlockLastPaid),
+        nProtocolVersion(other.nProtocolVersion),
+        nPoSeBanScore(other.nPoSeBanScore),
+        nPoSeBanHeight(other.nPoSeBanHeight),
+        fAllowMixingTx(other.fAllowMixingTx),
+        fUnitTest(other.fUnitTest) {}
+
+CZnode::CZnode(const CZnodeBroadcast &mnb) :
+        vin(mnb.vin),
+        addr(mnb.addr),
+        pubKeyCollateralAddress(mnb.pubKeyCollateralAddress),
+        pubKeyZnode(mnb.pubKeyZnode),
+        lastPing(mnb.lastPing),
+        vchSig(mnb.vchSig),
+        sigTime(mnb.sigTime),
+        nLastDsq(0),
+        nTimeLastChecked(0),
+        nTimeLastPaid(0),
+        nTimeLastWatchdogVote(mnb.sigTime),
+        nActiveState(mnb.nActiveState),
+        nCacheCollateralBlock(0),
+        nBlockLastPaid(0),
+        nProtocolVersion(mnb.nProtocolVersion),
+        nPoSeBanScore(0),
+        nPoSeBanHeight(0),
+        fAllowMixingTx(true),
+        fUnitTest(false) {}
+
+//CSporkManager sporkManager;
+//
+// When a new znode broadcast is sent, update our information
+//
+bool CZnode::UpdateFromNewBroadcast(CZnodeBroadcast &mnb) {
+    if (mnb.sigTime <= sigTime && !mnb.fRecovery) return false;
+
+    pubKeyZnode = mnb.pubKeyZnode;
+    sigTime = mnb.sigTime;
+    vchSig = mnb.vchSig;
+    nProtocolVersion = mnb.nProtocolVersion;
+    addr = mnb.addr;
+    nPoSeBanScore = 0;
+    nPoSeBanHeight = 0;
+    nTimeLastChecked = 0;
+    int nDos = 0;
+    if (mnb.lastPing == CZnodePing() || (mnb.lastPing != CZnodePing() && mnb.lastPing.CheckAndUpdate(this, true, nDos))) {
+        lastPing = mnb.lastPing;
+        mnodeman.mapSeenZnodePing.insert(std::make_pair(lastPing.GetHash(), lastPing));
+    }
+    // if it matches our Znode privkey...
+    if (fZNode && pubKeyZnode == activeZnode.pubKeyZnode) {
+        nPoSeBanScore = -ZNODE_POSE_BAN_MAX_SCORE;
+        if (nProtocolVersion == PROTOCOL_VERSION) {
+            // ... and PROTOCOL_VERSION, then we've been remotely activated ...
+            activeZnode.ManageState();
+        } else {
+            // ... otherwise we need to reactivate our node, do not add it to the list and do not relay
+            // but also do not ban the node we get this message from
+            LogPrintf("CZnode::UpdateFromNewBroadcast -- wrong PROTOCOL_VERSION, re-activate your MN: message nProtocolVersion=%d  PROTOCOL_VERSION=%d\n", nProtocolVersion, PROTOCOL_VERSION);
+            return false;
+        }
+    }
+    return true;
+}
+
+//
+// Deterministically calculate a given "score" for a Znode depending on how close it's hash is to
+// the proof of work for that block. The further away they are the better, the furthest will win the election
+// and get paid this block
+//
+arith_uint256 CZnode::CalculateScore(const uint256 &blockHash) {
+    uint256 aux = ArithToUint256(UintToArith256(vin.prevout.hash) + vin.prevout.n);
+
+    CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+    ss << blockHash;
+    arith_uint256 hash2 = UintToArith256(ss.GetHash());
+
+    CHashWriter ss2(SER_GETHASH, PROTOCOL_VERSION);
+    ss2 << blockHash;
+    ss2 << aux;
+    arith_uint256 hash3 = UintToArith256(ss2.GetHash());
+
+    return (hash3 > hash2 ? hash3 - hash2 : hash2 - hash3);
+}
+
+void CZnode::Check(bool fForce) {
+    LOCK(cs);
+
+    if (ShutdownRequested()) return;
+
+    if (!fForce && (GetTime() - nTimeLastChecked < ZNODE_CHECK_SECONDS)) return;
+    nTimeLastChecked = GetTime();
+
+    LogPrint("znode", "CZnode::Check -- Znode %s is in %s state\n", vin.prevout.ToStringShort(), GetStateString());
+
+    //once spent, stop doing the checks
+    if (IsOutpointSpent()) return;
+
+    int nHeight = 0;
+    if (!fUnitTest) {
+        TRY_LOCK(cs_main, lockMain);
+        if (!lockMain) return;
+
+        CCoins coins;
+        if (!pcoinsTip->GetCoins(vin.prevout.hash, coins) ||
+            (unsigned int) vin.prevout.n >= coins.vout.size() ||
+            coins.vout[vin.prevout.n].IsNull()) {
+            nActiveState = ZNODE_OUTPOINT_SPENT;
+            LogPrint("znode", "CZnode::Check -- Failed to find Znode UTXO, znode=%s\n", vin.prevout.ToStringShort());
+            return;
+        }
+
+        nHeight = chainActive.Height();
+    }
+
+    if (IsPoSeBanned()) {
+        if (nHeight < nPoSeBanHeight) return; // too early?
+        // Otherwise give it a chance to proceed further to do all the usual checks and to change its state.
+        // Znode still will be on the edge and can be banned back easily if it keeps ignoring mnverify
+        // or connect attempts. Will require few mnverify messages to strengthen its position in mn list.
+        LogPrintf("CZnode::Check -- Znode %s is unbanned and back in list now\n", vin.prevout.ToStringShort());
+        DecreasePoSeBanScore();
+    } else if (nPoSeBanScore >= ZNODE_POSE_BAN_MAX_SCORE) {
+        nActiveState = ZNODE_POSE_BAN;
+        // ban for the whole payment cycle
+        nPoSeBanHeight = nHeight + mnodeman.size();
+        LogPrintf("CZnode::Check -- Znode %s is banned till block %d now\n", vin.prevout.ToStringShort(), nPoSeBanHeight);
+        return;
+    }
+
+    int nActiveStatePrev = nActiveState;
+    bool fOurZnode = fZNode && activeZnode.pubKeyZnode == pubKeyZnode;
+
+    // znode doesn't meet payment protocol requirements ...
+    bool fRequireUpdate = nProtocolVersion < mnpayments.GetMinZnodePaymentsProto() ||
+                          // or it's our own node and we just updated it to the new protocol but we are still waiting for activation ...
+                          (fOurZnode && nProtocolVersion < PROTOCOL_VERSION);
+
+    if (fRequireUpdate) {
+        nActiveState = ZNODE_UPDATE_REQUIRED;
+        if (nActiveStatePrev != nActiveState) {
+            LogPrint("znode", "CZnode::Check -- Znode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
+        }
+        return;
+    }
+
+    // keep old znodes on start, give them a chance to receive updates...
+    bool fWaitForPing = !znodeSync.IsZnodeListSynced() && !IsPingedWithin(ZNODE_MIN_MNP_SECONDS);
+
+    if (fWaitForPing && !fOurZnode) {
+        // ...but if it was already expired before the initial check - return right away
+        if (IsExpired() || IsWatchdogExpired() || IsNewStartRequired()) {
+            LogPrint("znode", "CZnode::Check -- Znode %s is in %s state, waiting for ping\n", vin.prevout.ToStringShort(), GetStateString());
+            return;
+        }
+    }
+
+    // don't expire if we are still in "waiting for ping" mode unless it's our own znode
+    if (!fWaitForPing || fOurZnode) {
+
+        if (!IsPingedWithin(ZNODE_NEW_START_REQUIRED_SECONDS)) {
+            nActiveState = ZNODE_NEW_START_REQUIRED;
+            if (nActiveStatePrev != nActiveState) {
+                LogPrint("znode", "CZnode::Check -- Znode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
+            }
+            return;
+        }
+
+        bool fWatchdogActive = znodeSync.IsSynced() && mnodeman.IsWatchdogActive();
+        bool fWatchdogExpired = (fWatchdogActive && ((GetTime() - nTimeLastWatchdogVote) > ZNODE_WATCHDOG_MAX_SECONDS));
+
+//        LogPrint("znode", "CZnode::Check -- outpoint=%s, nTimeLastWatchdogVote=%d, GetTime()=%d, fWatchdogExpired=%d\n",
+//                vin.prevout.ToStringShort(), nTimeLastWatchdogVote, GetTime(), fWatchdogExpired);
+
+        if (fWatchdogExpired) {
+            nActiveState = ZNODE_WATCHDOG_EXPIRED;
+            if (nActiveStatePrev != nActiveState) {
+                LogPrint("znode", "CZnode::Check -- Znode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
+            }
+            return;
+        }
+
+        if (!IsPingedWithin(ZNODE_EXPIRATION_SECONDS)) {
+            nActiveState = ZNODE_EXPIRED;
+            if (nActiveStatePrev != nActiveState) {
+                LogPrint("znode", "CZnode::Check -- Znode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
+            }
+            return;
+        }
+    }
+
+    if (lastPing.sigTime - sigTime < ZNODE_MIN_MNP_SECONDS) {
+        nActiveState = ZNODE_PRE_ENABLED;
+        if (nActiveStatePrev != nActiveState) {
+            LogPrint("znode", "CZnode::Check -- Znode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
+        }
+        return;
+    }
+
+    nActiveState = ZNODE_ENABLED; // OK
+    if (nActiveStatePrev != nActiveState) {
+        LogPrint("znode", "CZnode::Check -- Znode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
+    }
+}
+
+bool CZnode::IsValidNetAddr() {
+    return IsValidNetAddr(addr);
+}
+
+bool CZnode::IsValidForPayment() {
+    if (nActiveState == ZNODE_ENABLED) {
+        return true;
+    }
+//    if(!sporkManager.IsSporkActive(SPORK_14_REQUIRE_SENTINEL_FLAG) &&
+//       (nActiveState == ZNODE_WATCHDOG_EXPIRED)) {
+//        return true;
+//    }
+
+    return false;
+}
+
+bool CZnode::IsValidNetAddr(CService addrIn) {
+    // TODO: regtest is fine with any addresses for now,
+    // should probably be a bit smarter if one day we start to implement tests for this
+    return Params().NetworkIDString() == CBaseChainParams::REGTEST ||
+           (addrIn.IsIPv4() && IsReachable(addrIn) && addrIn.IsRoutable());
+}
+
+znode_info_t CZnode::GetInfo() {
+    znode_info_t info;
+    info.vin = vin;
+    info.addr = addr;
+    info.pubKeyCollateralAddress = pubKeyCollateralAddress;
+    info.pubKeyZnode = pubKeyZnode;
+    info.sigTime = sigTime;
+    info.nLastDsq = nLastDsq;
+    info.nTimeLastChecked = nTimeLastChecked;
+    info.nTimeLastPaid = nTimeLastPaid;
+    info.nTimeLastWatchdogVote = nTimeLastWatchdogVote;
+    info.nTimeLastPing = lastPing.sigTime;
+    info.nActiveState = nActiveState;
+    info.nProtocolVersion = nProtocolVersion;
+    info.fInfoValid = true;
+    return info;
+}
+
+std::string CZnode::StateToString(int nStateIn) {
+    switch (nStateIn) {
+        case ZNODE_PRE_ENABLED:
+            return "PRE_ENABLED";
+        case ZNODE_ENABLED:
+            return "ENABLED";
+        case ZNODE_EXPIRED:
+            return "EXPIRED";
+        case ZNODE_OUTPOINT_SPENT:
+            return "OUTPOINT_SPENT";
+        case ZNODE_UPDATE_REQUIRED:
+            return "UPDATE_REQUIRED";
+        case ZNODE_WATCHDOG_EXPIRED:
+            return "WATCHDOG_EXPIRED";
+        case ZNODE_NEW_START_REQUIRED:
+            return "NEW_START_REQUIRED";
+        case ZNODE_POSE_BAN:
+            return "POSE_BAN";
+        default:
+            return "UNKNOWN";
+    }
+}
+
+std::string CZnode::GetStateString() const {
+    return StateToString(nActiveState);
+}
+
+std::string CZnode::GetStatus() const {
+    // TODO: return smth a bit more human readable here
+    return GetStateString();
+}
+
+std::string CZnode::ToString() const {
+    std::string str;
+    str += "znode{";
+    str += addr.ToString();
+    str += " ";
+    str += std::to_string(nProtocolVersion);
+    str += " ";
+    str += vin.prevout.ToStringShort();
+    str += " ";
+    str += CBitcoinAddress(pubKeyCollateralAddress.GetID()).ToString();
+    str += " ";
+    str += std::to_string(lastPing == CZnodePing() ? sigTime : lastPing.sigTime);
+    str += " ";
+    str += std::to_string(lastPing == CZnodePing() ? 0 : lastPing.sigTime - sigTime);
+    str += " ";
+    str += std::to_string(nBlockLastPaid);
+    str += "}\n";
+    return str;
+}
+
+int CZnode::GetCollateralAge() {
+    int nHeight;
+    {
+        TRY_LOCK(cs_main, lockMain);
+        if (!lockMain || !chainActive.Tip()) return -1;
+        nHeight = chainActive.Height();
+    }
+
+    if (nCacheCollateralBlock == 0) {
+        int nInputAge = GetInputAge(vin);
+        if (nInputAge > 0) {
+            nCacheCollateralBlock = nHeight - nInputAge;
+        } else {
+            return nInputAge;
+        }
+    }
+
+    return nHeight - nCacheCollateralBlock;
+}
+
+void CZnode::UpdateLastPaid(const CBlockIndex *pindex, int nMaxBlocksToScanBack) {
+    if (!pindex) {
+        LogPrintf("CZnode::UpdateLastPaid pindex is NULL\n");
+        return;
+    }
+
+    const CBlockIndex *BlockReading = pindex;
+
+    CScript mnpayee = GetScriptForDestination(pubKeyCollateralAddress.GetID());
+    LogPrint("znode", "CZnode::UpdateLastPaidBlock -- searching for block with payment to %s\n", vin.prevout.ToStringShort());
+
+    LOCK(cs_mapZnodeBlocks);
+
+    for (int i = 0; BlockReading && BlockReading->nHeight > nBlockLastPaid && i < nMaxBlocksToScanBack; i++) {
+//        LogPrintf("mnpayments.mapZnodeBlocks.count(BlockReading->nHeight)=%s\n", mnpayments.mapZnodeBlocks.count(BlockReading->nHeight));
+//        LogPrintf("mnpayments.mapZnodeBlocks[BlockReading->nHeight].HasPayeeWithVotes(mnpayee, 2)=%s\n", mnpayments.mapZnodeBlocks[BlockReading->nHeight].HasPayeeWithVotes(mnpayee, 2));
+        if (mnpayments.mapZnodeBlocks.count(BlockReading->nHeight) &&
+            mnpayments.mapZnodeBlocks[BlockReading->nHeight].HasPayeeWithVotes(mnpayee, 2)) {
+            LogPrintf("i=%s, BlockReading->nHeight=%s\n", i, BlockReading->nHeight);
+            CBlock block;
+            if (!ReadBlockFromDisk(block, BlockReading, Params().GetConsensus())) // shouldn't really happen
+            {
+                LogPrintf("ReadBlockFromDisk failed\n");
+                continue;
+            }
+
+            CAmount nZnodePayment = GetZnodePayment(BlockReading->nHeight, block.vtx[0].GetValueOut());
+
+            BOOST_FOREACH(CTxOut txout, block.vtx[0].vout)
+            if (mnpayee == txout.scriptPubKey && nZnodePayment == txout.nValue) {
+                nBlockLastPaid = BlockReading->nHeight;
+                nTimeLastPaid = BlockReading->nTime;
+                LogPrint("znode", "CZnode::UpdateLastPaidBlock -- searching for block with payment to %s -- found new %d\n", vin.prevout.ToStringShort(), nBlockLastPaid);
+                return;
+            }
+        }
+
+        if (BlockReading->pprev == NULL) {
+            assert(BlockReading);
+            break;
+        }
+        BlockReading = BlockReading->pprev;
+    }
+
+    // Last payment for this znode wasn't found in latest mnpayments blocks
+    // or it was found in mnpayments blocks but wasn't found in the blockchain.
+    // LogPrint("znode", "CZnode::UpdateLastPaidBlock -- searching for block with payment to %s -- keeping old %d\n", vin.prevout.ToStringShort(), nBlockLastPaid);
+}
+
+bool CZnodeBroadcast::Create(std::string strService, std::string strKeyZnode, std::string strTxHash, std::string strOutputIndex, std::string &strErrorRet, CZnodeBroadcast &mnbRet, bool fOffline) {
+    LogPrintf("CZnodeBroadcast::Create\n");
+    CTxIn txin;
+    CPubKey pubKeyCollateralAddressNew;
+    CKey keyCollateralAddressNew;
+    CPubKey pubKeyZnodeNew;
+    CKey keyZnodeNew;
+    //need correct blocks to send ping
+    if (!fOffline && !znodeSync.IsBlockchainSynced()) {
+        strErrorRet = "Sync in progress. Must wait until sync is complete to start Znode";
+        LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+        return false;
+    }
+
+    //TODO
+    if (!darkSendSigner.GetKeysFromSecret(strKeyZnode, keyZnodeNew, pubKeyZnodeNew)) {
+        strErrorRet = strprintf("Invalid znode key %s", strKeyZnode);
+        LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+        return false;
+    }
+
+    if (!pwalletMain->GetZnodeVinAndKeys(txin, pubKeyCollateralAddressNew, keyCollateralAddressNew, strTxHash, strOutputIndex)) {
+        strErrorRet = strprintf("Could not allocate txin %s:%s for znode %s", strTxHash, strOutputIndex, strService);
+        LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+        return false;
+    }
+
+    CService service = CService(strService);
+    int mainnetDefaultPort = Params(CBaseChainParams::MAIN).GetDefaultPort();
+    if (Params().NetworkIDString() == CBaseChainParams::MAIN) {
+        if (service.GetPort() != mainnetDefaultPort) {
+            strErrorRet = strprintf("Invalid port %u for znode %s, only %d is supported on mainnet.", service.GetPort(), strService, mainnetDefaultPort);
+            LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+            return false;
+        }
+    } else if (service.GetPort() == mainnetDefaultPort) {
+        strErrorRet = strprintf("Invalid port %u for znode %s, %d is the only supported on mainnet.", service.GetPort(), strService, mainnetDefaultPort);
+        LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+        return false;
+    }
+
+    return Create(txin, CService(strService), keyCollateralAddressNew, pubKeyCollateralAddressNew, keyZnodeNew, pubKeyZnodeNew, strErrorRet, mnbRet);
+}
+
+bool CZnodeBroadcast::Create(CTxIn txin, CService service, CKey keyCollateralAddressNew, CPubKey pubKeyCollateralAddressNew, CKey keyZnodeNew, CPubKey pubKeyZnodeNew, std::string &strErrorRet, CZnodeBroadcast &mnbRet) {
+    // wait for reindex and/or import to finish
+    if (fImporting || fReindex) return false;
+
+    LogPrint("znode", "CZnodeBroadcast::Create -- pubKeyCollateralAddressNew = %s, pubKeyZnodeNew.GetID() = %s\n",
+             CBitcoinAddress(pubKeyCollateralAddressNew.GetID()).ToString(),
+             pubKeyZnodeNew.GetID().ToString());
+
+
+    CZnodePing mnp(txin);
+    if (!mnp.Sign(keyZnodeNew, pubKeyZnodeNew)) {
+        strErrorRet = strprintf("Failed to sign ping, znode=%s", txin.prevout.ToStringShort());
+        LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+        mnbRet = CZnodeBroadcast();
+        return false;
+    }
+
+    mnbRet = CZnodeBroadcast(service, txin, pubKeyCollateralAddressNew, pubKeyZnodeNew, PROTOCOL_VERSION);
+
+    if (!mnbRet.IsValidNetAddr()) {
+        strErrorRet = strprintf("Invalid IP address, znode=%s", txin.prevout.ToStringShort());
+        LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+        mnbRet = CZnodeBroadcast();
+        return false;
+    }
+
+    mnbRet.lastPing = mnp;
+    if (!mnbRet.Sign(keyCollateralAddressNew)) {
+        strErrorRet = strprintf("Failed to sign broadcast, znode=%s", txin.prevout.ToStringShort());
+        LogPrintf("CZnodeBroadcast::Create -- %s\n", strErrorRet);
+        mnbRet = CZnodeBroadcast();
+        return false;
+    }
+
+    return true;
+}
+
+bool CZnodeBroadcast::SimpleCheck(int &nDos) {
+    nDos = 0;
+
+    // make sure addr is valid
+    if (!IsValidNetAddr()) {
+        LogPrintf("CZnodeBroadcast::SimpleCheck -- Invalid addr, rejected: znode=%s  addr=%s\n",
+                  vin.prevout.ToStringShort(), addr.ToString());
+        return false;
+    }
+
+    // make sure signature isn't in the future (past is OK)
+    if (sigTime > GetAdjustedTime() + 60 * 60) {
+        LogPrintf("CZnodeBroadcast::SimpleCheck -- Signature rejected, too far into the future: znode=%s\n", vin.prevout.ToStringShort());
+        nDos = 1;
+        return false;
+    }
+
+    // empty ping or incorrect sigTime/unknown blockhash
+    if (lastPing == CZnodePing() || !lastPing.SimpleCheck(nDos)) {
+        // one of us is probably forked or smth, just mark it as expired and check the rest of the rules
+        nActiveState = ZNODE_EXPIRED;
+    }
+
+    if (nProtocolVersion < mnpayments.GetMinZnodePaymentsProto()) {
+        LogPrintf("CZnodeBroadcast::SimpleCheck -- ignoring outdated Znode: znode=%s  nProtocolVersion=%d\n", vin.prevout.ToStringShort(), nProtocolVersion);
+        return false;
+    }
+
+    CScript pubkeyScript;
+    pubkeyScript = GetScriptForDestination(pubKeyCollateralAddress.GetID());
+
+    if (pubkeyScript.size() != 25) {
+        LogPrintf("CZnodeBroadcast::SimpleCheck -- pubKeyCollateralAddress has the wrong size\n");
+        nDos = 100;
+        return false;
+    }
+
+    CScript pubkeyScript2;
+    pubkeyScript2 = GetScriptForDestination(pubKeyZnode.GetID());
+
+    if (pubkeyScript2.size() != 25) {
+        LogPrintf("CZnodeBroadcast::SimpleCheck -- pubKeyZnode has the wrong size\n");
+        nDos = 100;
+        return false;
+    }
+
+    if (!vin.scriptSig.empty()) {
+        LogPrintf("CZnodeBroadcast::SimpleCheck -- Ignore Not Empty ScriptSig %s\n", vin.ToString());
+        nDos = 100;
+        return false;
+    }
+
+    int mainnetDefaultPort = Params(CBaseChainParams::MAIN).GetDefaultPort();
+    if (Params().NetworkIDString() == CBaseChainParams::MAIN) {
+        if (addr.GetPort() != mainnetDefaultPort) return false;
+    } else if (addr.GetPort() == mainnetDefaultPort) return false;
+
+    return true;
+}
+
+bool CZnodeBroadcast::Update(CZnode *pmn, int &nDos) {
+    nDos = 0;
+
+    if (pmn->sigTime == sigTime && !fRecovery) {
+        // mapSeenZnodeBroadcast in CZnodeMan::CheckMnbAndUpdateZnodeList should filter legit duplicates
+        // but this still can happen if we just started, which is ok, just do nothing here.
+        return false;
+    }
+
+    // this broadcast is older than the one that we already have - it's bad and should never happen
+    // unless someone is doing something fishy
+    if (pmn->sigTime > sigTime) {
+        LogPrintf("CZnodeBroadcast::Update -- Bad sigTime %d (existing broadcast is at %d) for Znode %s %s\n",
+                  sigTime, pmn->sigTime, vin.prevout.ToStringShort(), addr.ToString());
+        return false;
+    }
+
+    pmn->Check();
+
+    // znode is banned by PoSe
+    if (pmn->IsPoSeBanned()) {
+        LogPrintf("CZnodeBroadcast::Update -- Banned by PoSe, znode=%s\n", vin.prevout.ToStringShort());
+        return false;
+    }
+
+    // IsVnAssociatedWithPubkey is validated once in CheckOutpoint, after that they just need to match
+    if (pmn->pubKeyCollateralAddress != pubKeyCollateralAddress) {
+        LogPrintf("CZnodeBroadcast::Update -- Got mismatched pubKeyCollateralAddress and vin\n");
+        nDos = 33;
+        return false;
+    }
+
+    if (!CheckSignature(nDos)) {
+        LogPrintf("CZnodeBroadcast::Update -- CheckSignature() failed, znode=%s\n", vin.prevout.ToStringShort());
+        return false;
+    }
+
+    // if ther was no znode broadcast recently or if it matches our Znode privkey...
+    if (!pmn->IsBroadcastedWithin(ZNODE_MIN_MNB_SECONDS) || (fZNode && pubKeyZnode == activeZnode.pubKeyZnode)) {
+        // take the newest entry
+        LogPrintf("CZnodeBroadcast::Update -- Got UPDATED Znode entry: addr=%s\n", addr.ToString());
+        if (pmn->UpdateFromNewBroadcast((*this))) {
+            pmn->Check();
+            RelayZNode();
+        }
+        znodeSync.AddedZnodeList();
+    }
+
+    return true;
+}
+
+bool CZnodeBroadcast::CheckOutpoint(int &nDos) {
+    // we are a znode with the same vin (i.e. already activated) and this mnb is ours (matches our Znode privkey)
+    // so nothing to do here for us
+    if (fZNode && vin.prevout == activeZnode.vin.prevout && pubKeyZnode == activeZnode.pubKeyZnode) {
+        return false;
+    }
+
+    if (!CheckSignature(nDos)) {
+        LogPrintf("CZnodeBroadcast::CheckOutpoint -- CheckSignature() failed, znode=%s\n", vin.prevout.ToStringShort());
+        return false;
+    }
+
+    {
+        TRY_LOCK(cs_main, lockMain);
+        if (!lockMain) {
+            // not mnb fault, let it to be checked again later
+            LogPrint("znode", "CZnodeBroadcast::CheckOutpoint -- Failed to aquire lock, addr=%s", addr.ToString());
+            mnodeman.mapSeenZnodeBroadcast.erase(GetHash());
+            return false;
+        }
+
+        CCoins coins;
+        if (!pcoinsTip->GetCoins(vin.prevout.hash, coins) ||
+            (unsigned int) vin.prevout.n >= coins.vout.size() ||
+            coins.vout[vin.prevout.n].IsNull()) {
+            LogPrint("znode", "CZnodeBroadcast::CheckOutpoint -- Failed to find Znode UTXO, znode=%s\n", vin.prevout.ToStringShort());
+            return false;
+        }
+        if (coins.vout[vin.prevout.n].nValue != ZNODE_COIN_REQUIRED * COIN) {
+            LogPrint("znode", "CZnodeBroadcast::CheckOutpoint -- Znode UTXO should have 1000 XZC, znode=%s\n", vin.prevout.ToStringShort());
+            return false;
+        }
+        if (chainActive.Height() - coins.nHeight + 1 < Params().GetConsensus().nZnodeMinimumConfirmations) {
+            LogPrintf("CZnodeBroadcast::CheckOutpoint -- Znode UTXO must have at least %d confirmations, znode=%s\n",
+                      Params().GetConsensus().nZnodeMinimumConfirmations, vin.prevout.ToStringShort());
+            // maybe we miss few blocks, let this mnb to be checked again later
+            mnodeman.mapSeenZnodeBroadcast.erase(GetHash());
+            return false;
+        }
+    }
+
+    LogPrint("znode", "CZnodeBroadcast::CheckOutpoint -- Znode UTXO verified\n");
+
+    // make sure the vout that was signed is related to the transaction that spawned the Znode
+    //  - this is expensive, so it's only done once per Znode
+    if (!darkSendSigner.IsVinAssociatedWithPubkey(vin, pubKeyCollateralAddress)) {
+        LogPrintf("CZnodeMan::CheckOutpoint -- Got mismatched pubKeyCollateralAddress and vin\n");
+        nDos = 33;
+        return false;
+    }
+
+    // verify that sig time is legit in past
+    // should be at least not earlier than block when 1000 XZC tx got nZnodeMinimumConfirmations
+    uint256 hashBlock = uint256();
+    CTransaction tx2;
+    GetTransaction(vin.prevout.hash, tx2, Params().GetConsensus(), hashBlock, true);
+    {
+        LOCK(cs_main);
+        BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
+        if (mi != mapBlockIndex.end() && (*mi).second) {
+            CBlockIndex *pMNIndex = (*mi).second; // block for 1000 XZC tx -> 1 confirmation
+            CBlockIndex *pConfIndex = chainActive[pMNIndex->nHeight + Params().GetConsensus().nZnodeMinimumConfirmations - 1]; // block where tx got nZnodeMinimumConfirmations
+            if (pConfIndex->GetBlockTime() > sigTime) {
+                LogPrintf("CZnodeBroadcast::CheckOutpoint -- Bad sigTime %d (%d conf block is at %d) for Znode %s %s\n",
+                          sigTime, Params().GetConsensus().nZnodeMinimumConfirmations, pConfIndex->GetBlockTime(), vin.prevout.ToStringShort(), addr.ToString());
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+bool CZnodeBroadcast::Sign(CKey &keyCollateralAddress) {
+    std::string strError;
+    std::string strMessage;
+
+    sigTime = GetAdjustedTime();
+
+    strMessage = addr.ToString() + boost::lexical_cast<std::string>(sigTime) +
+                 pubKeyCollateralAddress.GetID().ToString() + pubKeyZnode.GetID().ToString() +
+                 boost::lexical_cast<std::string>(nProtocolVersion);
+
+    if (!darkSendSigner.SignMessage(strMessage, vchSig, keyCollateralAddress)) {
+        LogPrintf("CZnodeBroadcast::Sign -- SignMessage() failed\n");
+        return false;
+    }
+
+    if (!darkSendSigner.VerifyMessage(pubKeyCollateralAddress, vchSig, strMessage, strError)) {
+        LogPrintf("CZnodeBroadcast::Sign -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+bool CZnodeBroadcast::CheckSignature(int &nDos) {
+    std::string strMessage;
+    std::string strError = "";
+    nDos = 0;
+
+    strMessage = addr.ToString() + boost::lexical_cast<std::string>(sigTime) +
+                 pubKeyCollateralAddress.GetID().ToString() + pubKeyZnode.GetID().ToString() +
+                 boost::lexical_cast<std::string>(nProtocolVersion);
+
+    LogPrint("znode", "CZnodeBroadcast::CheckSignature -- strMessage: %s  pubKeyCollateralAddress address: %s  sig: %s\n", strMessage, CBitcoinAddress(pubKeyCollateralAddress.GetID()).ToString(), EncodeBase64(&vchSig[0], vchSig.size()));
+
+    if (!darkSendSigner.VerifyMessage(pubKeyCollateralAddress, vchSig, strMessage, strError)) {
+        LogPrintf("CZnodeBroadcast::CheckSignature -- Got bad Znode announce signature, error: %s\n", strError);
+        nDos = 100;
+        return false;
+    }
+
+    return true;
+}
+
+void CZnodeBroadcast::RelayZNode() {
+    LogPrintf("CZnodeBroadcast::RelayZNode\n");
+    CInv inv(MSG_ZNODE_ANNOUNCE, GetHash());
+    RelayInv(inv);
+}
+
+CZnodePing::CZnodePing(CTxIn &vinNew) {
+    LOCK(cs_main);
+    if (!chainActive.Tip() || chainActive.Height() < 12) return;
+
+    vin = vinNew;
+    blockHash = chainActive[chainActive.Height() - 12]->GetBlockHash();
+    sigTime = GetAdjustedTime();
+    vchSig = std::vector < unsigned char > ();
+}
+
+bool CZnodePing::Sign(CKey &keyZnode, CPubKey &pubKeyZnode) {
+    std::string strError;
+    std::string strZNodeSignMessage;
+
+    sigTime = GetAdjustedTime();
+    std::string strMessage = vin.ToString() + blockHash.ToString() + boost::lexical_cast<std::string>(sigTime);
+
+    if (!darkSendSigner.SignMessage(strMessage, vchSig, keyZnode)) {
+        LogPrintf("CZnodePing::Sign -- SignMessage() failed\n");
+        return false;
+    }
+
+    if (!darkSendSigner.VerifyMessage(pubKeyZnode, vchSig, strMessage, strError)) {
+        LogPrintf("CZnodePing::Sign -- VerifyMessage() failed, error: %s\n", strError);
+        return false;
+    }
+
+    return true;
+}
+
+bool CZnodePing::CheckSignature(CPubKey &pubKeyZnode, int &nDos) {
+    std::string strMessage = vin.ToString() + blockHash.ToString() + boost::lexical_cast<std::string>(sigTime);
+    std::string strError = "";
+    nDos = 0;
+
+    if (!darkSendSigner.VerifyMessage(pubKeyZnode, vchSig, strMessage, strError)) {
+        LogPrintf("CZnodePing::CheckSignature -- Got bad Znode ping signature, znode=%s, error: %s\n", vin.prevout.ToStringShort(), strError);
+        nDos = 33;
+        return false;
+    }
+    return true;
+}
+
+bool CZnodePing::SimpleCheck(int &nDos) {
+    // don't ban by default
+    nDos = 0;
+
+    if (sigTime > GetAdjustedTime() + 60 * 60) {
+        LogPrintf("CZnodePing::SimpleCheck -- Signature rejected, too far into the future, znode=%s\n", vin.prevout.ToStringShort());
+        nDos = 1;
+        return false;
+    }
+
+    {
+//        LOCK(cs_main);
+        AssertLockHeld(cs_main);
+        BlockMap::iterator mi = mapBlockIndex.find(blockHash);
+        if (mi == mapBlockIndex.end()) {
+            LogPrint("znode", "CZnodePing::SimpleCheck -- Znode ping is invalid, unknown block hash: znode=%s blockHash=%s\n", vin.prevout.ToStringShort(), blockHash.ToString());
+            // maybe we stuck or forked so we shouldn't ban this node, just fail to accept this ping
+            // TODO: or should we also request this block?
+            return false;
+        }
+    }
+    LogPrint("znode", "CZnodePing::SimpleCheck -- Znode ping verified: znode=%s  blockHash=%s  sigTime=%d\n", vin.prevout.ToStringShort(), blockHash.ToString(), sigTime);
+    return true;
+}
+
+bool CZnodePing::CheckAndUpdate(CZnode *pmn, bool fFromNewBroadcast, int &nDos) {
+    // don't ban by default
+    nDos = 0;
+
+    if (!SimpleCheck(nDos)) {
+        return false;
+    }
+
+    if (pmn == NULL) {
+        LogPrint("znode", "CZnodePing::CheckAndUpdate -- Couldn't find Znode entry, znode=%s\n", vin.prevout.ToStringShort());
+        return false;
+    }
+
+    if (!fFromNewBroadcast) {
+        if (pmn->IsUpdateRequired()) {
+            LogPrint("znode", "CZnodePing::CheckAndUpdate -- znode protocol is outdated, znode=%s\n", vin.prevout.ToStringShort());
+            return false;
+        }
+
+        if (pmn->IsNewStartRequired()) {
+            LogPrint("znode", "CZnodePing::CheckAndUpdate -- znode is completely expired, new start is required, znode=%s\n", vin.prevout.ToStringShort());
+            return false;
+        }
+    }
+
+    {
+        LOCK(cs_main);
+        BlockMap::iterator mi = mapBlockIndex.find(blockHash);
+        if ((*mi).second && (*mi).second->nHeight < chainActive.Height() - 24) {
+            LogPrintf("CZnodePing::CheckAndUpdate -- Znode ping is invalid, block hash is too old: znode=%s  blockHash=%s\n", vin.prevout.ToStringShort(), blockHash.ToString());
+            // nDos = 1;
+            return false;
+        }
+    }
+
+    LogPrint("znode", "CZnodePing::CheckAndUpdate -- New ping: znode=%s  blockHash=%s  sigTime=%d\n", vin.prevout.ToStringShort(), blockHash.ToString(), sigTime);
+
+    // LogPrintf("mnping - Found corresponding mn for vin: %s\n", vin.prevout.ToStringShort());
+    // update only if there is no known ping for this znode or
+    // last ping was more then ZNODE_MIN_MNP_SECONDS-60 ago comparing to this one
+    if (pmn->IsPingedWithin(ZNODE_MIN_MNP_SECONDS - 60, sigTime)) {
+        LogPrint("znode", "CZnodePing::CheckAndUpdate -- Znode ping arrived too early, znode=%s\n", vin.prevout.ToStringShort());
+        //nDos = 1; //disable, this is happening frequently and causing banned peers
+        return false;
+    }
+
+    if (!CheckSignature(pmn->pubKeyZnode, nDos)) return false;
+
+    // so, ping seems to be ok
+
+    // if we are still syncing and there was no known ping for this mn for quite a while
+    // (NOTE: assuming that ZNODE_EXPIRATION_SECONDS/2 should be enough to finish mn list sync)
+    if (!znodeSync.IsZnodeListSynced() && !pmn->IsPingedWithin(ZNODE_EXPIRATION_SECONDS / 2)) {
+        // let's bump sync timeout
+        LogPrint("znode", "CZnodePing::CheckAndUpdate -- bumping sync timeout, znode=%s\n", vin.prevout.ToStringShort());
+        znodeSync.AddedZnodeList();
+    }
+
+    // let's store this ping as the last one
+    LogPrint("znode", "CZnodePing::CheckAndUpdate -- Znode ping accepted, znode=%s\n", vin.prevout.ToStringShort());
+    pmn->lastPing = *this;
+
+    // and update mnodeman.mapSeenZnodeBroadcast.lastPing which is probably outdated
+    CZnodeBroadcast mnb(*pmn);
+    uint256 hash = mnb.GetHash();
+    if (mnodeman.mapSeenZnodeBroadcast.count(hash)) {
+        mnodeman.mapSeenZnodeBroadcast[hash].second.lastPing = *this;
+    }
+
+    pmn->Check(true); // force update, ignoring cache
+    if (!pmn->IsEnabled()) return false;
+
+    LogPrint("znode", "CZnodePing::CheckAndUpdate -- Znode ping acceepted and relayed, znode=%s\n", vin.prevout.ToStringShort());
+    Relay();
+
+    return true;
+}
+
+void CZnodePing::Relay() {
+    CInv inv(MSG_ZNODE_PING, GetHash());
+    RelayInv(inv);
+}
+
+//void CZnode::AddGovernanceVote(uint256 nGovernanceObjectHash)
+//{
+//    if(mapGovernanceObjectsVotedOn.count(nGovernanceObjectHash)) {
+//        mapGovernanceObjectsVotedOn[nGovernanceObjectHash]++;
+//    } else {
+//        mapGovernanceObjectsVotedOn.insert(std::make_pair(nGovernanceObjectHash, 1));
+//    }
+//}
+
+//void CZnode::RemoveGovernanceObject(uint256 nGovernanceObjectHash)
+//{
+//    std::map<uint256, int>::iterator it = mapGovernanceObjectsVotedOn.find(nGovernanceObjectHash);
+//    if(it == mapGovernanceObjectsVotedOn.end()) {
+//        return;
+//    }
+//    mapGovernanceObjectsVotedOn.erase(it);
+//}
+
+void CZnode::UpdateWatchdogVoteTime() {
+    LOCK(cs);
+    nTimeLastWatchdogVote = GetTime();
+}
+
+/**
+*   FLAG GOVERNANCE ITEMS AS DIRTY
+*
+*   - When znode come and go on the network, we must flag the items they voted on to recalc it's cached flags
+*
+*/
+//void CZnode::FlagGovernanceItemsAsDirty()
+//{
+//    std::vector<uint256> vecDirty;
+//    {
+//        std::map<uint256, int>::iterator it = mapGovernanceObjectsVotedOn.begin();
+//        while(it != mapGovernanceObjectsVotedOn.end()) {
+//            vecDirty.push_back(it->first);
+//            ++it;
+//        }
+//    }
+//    for(size_t i = 0; i < vecDirty.size(); ++i) {
+//        mnodeman.AddDirtyGovernanceObjectHash(vecDirty[i]);
+//    }
+//}
diff --git a/src/znode.h b/src/znode.h
new file mode 100644
index 0000000000..3bdfb32df7
--- /dev/null
+++ b/src/znode.h
@@ -0,0 +1,442 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef ZNODE_H
+#define ZNODE_H
+
+#include "key.h"
+#include "main.h"
+#include "net.h"
+#include "spork.h"
+#include "timedata.h"
+#include "utiltime.h"
+
+class CZnode;
+class CZnodeBroadcast;
+class CZnodePing;
+
+static const int ZNODE_CHECK_SECONDS               =   5;
+static const int ZNODE_MIN_MNB_SECONDS             =   5 * 60; //BROADCAST_TIME
+static const int ZNODE_MIN_MNP_SECONDS             =  10 * 60; //PRE_ENABLE_TIME
+static const int ZNODE_EXPIRATION_SECONDS          =  65 * 60;
+static const int ZNODE_WATCHDOG_MAX_SECONDS        = 120 * 60;
+static const int ZNODE_NEW_START_REQUIRED_SECONDS  = 180 * 60;
+static const int ZNODE_COIN_REQUIRED  = 1000;
+
+static const int ZNODE_POSE_BAN_MAX_SCORE          = 5;
+//
+// The Znode Ping Class : Contains a different serialize method for sending pings from znodes throughout the network
+//
+
+class CZnodePing
+{
+public:
+    CTxIn vin;
+    uint256 blockHash;
+    int64_t sigTime; //mnb message times
+    std::vector<unsigned char> vchSig;
+    //removed stop
+
+    CZnodePing() :
+        vin(),
+        blockHash(),
+        sigTime(0),
+        vchSig()
+        {}
+
+    CZnodePing(CTxIn& vinNew);
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(vin);
+        READWRITE(blockHash);
+        READWRITE(sigTime);
+        READWRITE(vchSig);
+    }
+
+    void swap(CZnodePing& first, CZnodePing& second) // nothrow
+    {
+        // enable ADL (not necessary in our case, but good practice)
+        using std::swap;
+
+        // by swapping the members of two classes,
+        // the two classes are effectively swapped
+        swap(first.vin, second.vin);
+        swap(first.blockHash, second.blockHash);
+        swap(first.sigTime, second.sigTime);
+        swap(first.vchSig, second.vchSig);
+    }
+
+    uint256 GetHash() const
+    {
+        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+        ss << vin;
+        ss << sigTime;
+        return ss.GetHash();
+    }
+
+    bool IsExpired() { return GetTime() - sigTime > ZNODE_NEW_START_REQUIRED_SECONDS; }
+
+    bool Sign(CKey& keyZnode, CPubKey& pubKeyZnode);
+    bool CheckSignature(CPubKey& pubKeyZnode, int &nDos);
+    bool SimpleCheck(int& nDos);
+    bool CheckAndUpdate(CZnode* pmn, bool fFromNewBroadcast, int& nDos);
+    void Relay();
+
+    CZnodePing& operator=(CZnodePing from)
+    {
+        swap(*this, from);
+        return *this;
+    }
+    friend bool operator==(const CZnodePing& a, const CZnodePing& b)
+    {
+        return a.vin == b.vin && a.blockHash == b.blockHash;
+    }
+    friend bool operator!=(const CZnodePing& a, const CZnodePing& b)
+    {
+        return !(a == b);
+    }
+
+};
+
+struct znode_info_t
+{
+    znode_info_t()
+        : vin(),
+          addr(),
+          pubKeyCollateralAddress(),
+          pubKeyZnode(),
+          sigTime(0),
+          nLastDsq(0),
+          nTimeLastChecked(0),
+          nTimeLastPaid(0),
+          nTimeLastWatchdogVote(0),
+          nTimeLastPing(0),
+          nActiveState(0),
+          nProtocolVersion(0),
+          fInfoValid(false)
+        {}
+
+    CTxIn vin;
+    CService addr;
+    CPubKey pubKeyCollateralAddress;
+    CPubKey pubKeyZnode;
+    int64_t sigTime; //mnb message time
+    int64_t nLastDsq; //the dsq count from the last dsq broadcast of this node
+    int64_t nTimeLastChecked;
+    int64_t nTimeLastPaid;
+    int64_t nTimeLastWatchdogVote;
+    int64_t nTimeLastPing;
+    int nActiveState;
+    int nProtocolVersion;
+    bool fInfoValid;
+};
+
+//
+// The Znode Class. For managing the Darksend process. It contains the input of the 1000DRK, signature to prove
+// it's the one who own that ip address and code for calculating the payment election.
+//
+class CZnode
+{
+private:
+    // critical section to protect the inner data structures
+    mutable CCriticalSection cs;
+
+public:
+    enum state {
+        ZNODE_PRE_ENABLED,
+        ZNODE_ENABLED,
+        ZNODE_EXPIRED,
+        ZNODE_OUTPOINT_SPENT,
+        ZNODE_UPDATE_REQUIRED,
+        ZNODE_WATCHDOG_EXPIRED,
+        ZNODE_NEW_START_REQUIRED,
+        ZNODE_POSE_BAN
+    };
+
+    CTxIn vin;
+    CService addr;
+    CPubKey pubKeyCollateralAddress;
+    CPubKey pubKeyZnode;
+    CZnodePing lastPing;
+    std::vector<unsigned char> vchSig;
+    int64_t sigTime; //mnb message time
+    int64_t nLastDsq; //the dsq count from the last dsq broadcast of this node
+    int64_t nTimeLastChecked;
+    int64_t nTimeLastPaid;
+    int64_t nTimeLastWatchdogVote;
+    int nActiveState;
+    int nCacheCollateralBlock;
+    int nBlockLastPaid;
+    int nProtocolVersion;
+    int nPoSeBanScore;
+    int nPoSeBanHeight;
+    bool fAllowMixingTx;
+    bool fUnitTest;
+
+    // KEEP TRACK OF GOVERNANCE ITEMS EACH ZNODE HAS VOTE UPON FOR RECALCULATION
+    std::map<uint256, int> mapGovernanceObjectsVotedOn;
+
+    CZnode();
+    CZnode(const CZnode& other);
+    CZnode(const CZnodeBroadcast& mnb);
+    CZnode(CService addrNew, CTxIn vinNew, CPubKey pubKeyCollateralAddressNew, CPubKey pubKeyZnodeNew, int nProtocolVersionIn);
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        LOCK(cs);
+        READWRITE(vin);
+        READWRITE(addr);
+        READWRITE(pubKeyCollateralAddress);
+        READWRITE(pubKeyZnode);
+        READWRITE(lastPing);
+        READWRITE(vchSig);
+        READWRITE(sigTime);
+        READWRITE(nLastDsq);
+        READWRITE(nTimeLastChecked);
+        READWRITE(nTimeLastPaid);
+        READWRITE(nTimeLastWatchdogVote);
+        READWRITE(nActiveState);
+        READWRITE(nCacheCollateralBlock);
+        READWRITE(nBlockLastPaid);
+        READWRITE(nProtocolVersion);
+        READWRITE(nPoSeBanScore);
+        READWRITE(nPoSeBanHeight);
+        READWRITE(fAllowMixingTx);
+        READWRITE(fUnitTest);
+        READWRITE(mapGovernanceObjectsVotedOn);
+    }
+
+    void swap(CZnode& first, CZnode& second) // nothrow
+    {
+        // enable ADL (not necessary in our case, but good practice)
+        using std::swap;
+
+        // by swapping the members of two classes,
+        // the two classes are effectively swapped
+        swap(first.vin, second.vin);
+        swap(first.addr, second.addr);
+        swap(first.pubKeyCollateralAddress, second.pubKeyCollateralAddress);
+        swap(first.pubKeyZnode, second.pubKeyZnode);
+        swap(first.lastPing, second.lastPing);
+        swap(first.vchSig, second.vchSig);
+        swap(first.sigTime, second.sigTime);
+        swap(first.nLastDsq, second.nLastDsq);
+        swap(first.nTimeLastChecked, second.nTimeLastChecked);
+        swap(first.nTimeLastPaid, second.nTimeLastPaid);
+        swap(first.nTimeLastWatchdogVote, second.nTimeLastWatchdogVote);
+        swap(first.nActiveState, second.nActiveState);
+        swap(first.nCacheCollateralBlock, second.nCacheCollateralBlock);
+        swap(first.nBlockLastPaid, second.nBlockLastPaid);
+        swap(first.nProtocolVersion, second.nProtocolVersion);
+        swap(first.nPoSeBanScore, second.nPoSeBanScore);
+        swap(first.nPoSeBanHeight, second.nPoSeBanHeight);
+        swap(first.fAllowMixingTx, second.fAllowMixingTx);
+        swap(first.fUnitTest, second.fUnitTest);
+        swap(first.mapGovernanceObjectsVotedOn, second.mapGovernanceObjectsVotedOn);
+    }
+
+    // CALCULATE A RANK AGAINST OF GIVEN BLOCK
+    arith_uint256 CalculateScore(const uint256& blockHash);
+
+    bool UpdateFromNewBroadcast(CZnodeBroadcast& mnb);
+
+    void Check(bool fForce = false);
+
+    bool IsBroadcastedWithin(int nSeconds) { return GetAdjustedTime() - sigTime < nSeconds; }
+
+    bool IsPingedWithin(int nSeconds, int64_t nTimeToCheckAt = -1)
+    {
+        if(lastPing == CZnodePing()) return false;
+
+        if(nTimeToCheckAt == -1) {
+            nTimeToCheckAt = GetAdjustedTime();
+        }
+        return nTimeToCheckAt - lastPing.sigTime < nSeconds;
+    }
+
+    bool IsEnabled() { return nActiveState == ZNODE_ENABLED; }
+    bool IsPreEnabled() { return nActiveState == ZNODE_PRE_ENABLED; }
+    bool IsPoSeBanned() { return nActiveState == ZNODE_POSE_BAN; }
+    // NOTE: this one relies on nPoSeBanScore, not on nActiveState as everything else here
+    bool IsPoSeVerified() { return nPoSeBanScore <= -ZNODE_POSE_BAN_MAX_SCORE; }
+    bool IsExpired() { return nActiveState == ZNODE_EXPIRED; }
+    bool IsOutpointSpent() { return nActiveState == ZNODE_OUTPOINT_SPENT; }
+    bool IsUpdateRequired() { return nActiveState == ZNODE_UPDATE_REQUIRED; }
+    bool IsWatchdogExpired() { return nActiveState == ZNODE_WATCHDOG_EXPIRED; }
+    bool IsNewStartRequired() { return nActiveState == ZNODE_NEW_START_REQUIRED; }
+
+    static bool IsValidStateForAutoStart(int nActiveStateIn)
+    {
+        return  nActiveStateIn == ZNODE_ENABLED ||
+                nActiveStateIn == ZNODE_PRE_ENABLED ||
+                nActiveStateIn == ZNODE_EXPIRED ||
+                nActiveStateIn == ZNODE_WATCHDOG_EXPIRED;
+    }
+
+    bool IsValidForPayment();
+
+    bool IsValidNetAddr();
+    static bool IsValidNetAddr(CService addrIn);
+
+    void IncreasePoSeBanScore() { if(nPoSeBanScore < ZNODE_POSE_BAN_MAX_SCORE) nPoSeBanScore++; }
+    void DecreasePoSeBanScore() { if(nPoSeBanScore > -ZNODE_POSE_BAN_MAX_SCORE) nPoSeBanScore--; }
+
+    znode_info_t GetInfo();
+
+    static std::string StateToString(int nStateIn);
+    std::string GetStateString() const;
+    std::string GetStatus() const;
+    std::string ToString() const;
+
+    int GetCollateralAge();
+
+    int GetLastPaidTime() { return nTimeLastPaid; }
+    int GetLastPaidBlock() { return nBlockLastPaid; }
+    void UpdateLastPaid(const CBlockIndex *pindex, int nMaxBlocksToScanBack);
+
+    // KEEP TRACK OF EACH GOVERNANCE ITEM INCASE THIS NODE GOES OFFLINE, SO WE CAN RECALC THEIR STATUS
+    void AddGovernanceVote(uint256 nGovernanceObjectHash);
+    // RECALCULATE CACHED STATUS FLAGS FOR ALL AFFECTED OBJECTS
+    void FlagGovernanceItemsAsDirty();
+
+    void RemoveGovernanceObject(uint256 nGovernanceObjectHash);
+
+    void UpdateWatchdogVoteTime();
+
+    CZnode& operator=(CZnode from)
+    {
+        swap(*this, from);
+        return *this;
+    }
+    friend bool operator==(const CZnode& a, const CZnode& b)
+    {
+        return a.vin == b.vin;
+    }
+    friend bool operator!=(const CZnode& a, const CZnode& b)
+    {
+        return !(a.vin == b.vin);
+    }
+
+};
+
+
+//
+// The Znode Broadcast Class : Contains a different serialize method for sending znodes through the network
+//
+
+class CZnodeBroadcast : public CZnode
+{
+public:
+
+    bool fRecovery;
+
+    CZnodeBroadcast() : CZnode(), fRecovery(false) {}
+    CZnodeBroadcast(const CZnode& mn) : CZnode(mn), fRecovery(false) {}
+    CZnodeBroadcast(CService addrNew, CTxIn vinNew, CPubKey pubKeyCollateralAddressNew, CPubKey pubKeyZnodeNew, int nProtocolVersionIn) :
+        CZnode(addrNew, vinNew, pubKeyCollateralAddressNew, pubKeyZnodeNew, nProtocolVersionIn), fRecovery(false) {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(vin);
+        READWRITE(addr);
+        READWRITE(pubKeyCollateralAddress);
+        READWRITE(pubKeyZnode);
+        READWRITE(vchSig);
+        READWRITE(sigTime);
+        READWRITE(nProtocolVersion);
+        READWRITE(lastPing);
+    }
+
+    uint256 GetHash() const
+    {
+        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+        ss << vin;
+        ss << pubKeyCollateralAddress;
+        ss << sigTime;
+        return ss.GetHash();
+    }
+
+    /// Create Znode broadcast, needs to be relayed manually after that
+    static bool Create(CTxIn vin, CService service, CKey keyCollateralAddressNew, CPubKey pubKeyCollateralAddressNew, CKey keyZnodeNew, CPubKey pubKeyZnodeNew, std::string &strErrorRet, CZnodeBroadcast &mnbRet);
+    static bool Create(std::string strService, std::string strKey, std::string strTxHash, std::string strOutputIndex, std::string& strErrorRet, CZnodeBroadcast &mnbRet, bool fOffline = false);
+
+    bool SimpleCheck(int& nDos);
+    bool Update(CZnode* pmn, int& nDos);
+    bool CheckOutpoint(int& nDos);
+
+    bool Sign(CKey& keyCollateralAddress);
+    bool CheckSignature(int& nDos);
+    void RelayZNode();
+};
+
+class CZnodeVerification
+{
+public:
+    CTxIn vin1;
+    CTxIn vin2;
+    CService addr;
+    int nonce;
+    int nBlockHeight;
+    std::vector<unsigned char> vchSig1;
+    std::vector<unsigned char> vchSig2;
+
+    CZnodeVerification() :
+        vin1(),
+        vin2(),
+        addr(),
+        nonce(0),
+        nBlockHeight(0),
+        vchSig1(),
+        vchSig2()
+        {}
+
+    CZnodeVerification(CService addr, int nonce, int nBlockHeight) :
+        vin1(),
+        vin2(),
+        addr(addr),
+        nonce(nonce),
+        nBlockHeight(nBlockHeight),
+        vchSig1(),
+        vchSig2()
+        {}
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(vin1);
+        READWRITE(vin2);
+        READWRITE(addr);
+        READWRITE(nonce);
+        READWRITE(nBlockHeight);
+        READWRITE(vchSig1);
+        READWRITE(vchSig2);
+    }
+
+    uint256 GetHash() const
+    {
+        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+        ss << vin1;
+        ss << vin2;
+        ss << addr;
+        ss << nonce;
+        ss << nBlockHeight;
+        return ss.GetHash();
+    }
+
+    void Relay() const
+    {
+        CInv inv(MSG_ZNODE_VERIFY, GetHash());
+        RelayInv(inv);
+    }
+};
+
+#endif
diff --git a/src/znodeconfig.cpp b/src/znodeconfig.cpp
new file mode 100644
index 0000000000..70ae027284
--- /dev/null
+++ b/src/znodeconfig.cpp
@@ -0,0 +1,94 @@
+
+#include "netbase.h"
+#include "znodeconfig.h"
+#include "util.h"
+#include "chainparams.h"
+
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+CZnodeConfig znodeConfig;
+
+void CZnodeConfig::add(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex) {
+    CZnodeEntry cme(alias, ip, privKey, txHash, outputIndex);
+    entries.push_back(cme);
+}
+
+bool CZnodeConfig::read(std::string& strErr) {
+    int linenumber = 1;
+    boost::filesystem::path pathZnodeConfigFile = GetZnodeConfigFile();
+    boost::filesystem::ifstream streamConfig(pathZnodeConfigFile);
+    LogPrintf("pathZnodeConfigFile=%s\n", pathZnodeConfigFile);
+
+    if (!streamConfig.good()) {
+        FILE* configFile = fopen(pathZnodeConfigFile.string().c_str(), "a");
+        if (configFile != NULL) {
+            std::string strHeader = "# Znode config file\n"
+                          "# Format: alias IP:port znode_privatekey collateral_output_txid collateral_output_index\n"
+                          "# Example: zn1 127.0.0.1:8168 7Cqyr4U7GU7qVo5TE1nrfA8XPVqh7GXBuEBPYzaWxEhiRRDLZ5c 2bcd3c84c84f87eaa86e4e56834c92927a07f9e18718810b92e0d0324456a67c 1\n";
+            fwrite(strHeader.c_str(), std::strlen(strHeader.c_str()), 1, configFile);
+            fclose(configFile);
+        }
+        return true; // Nothing to read, so just return
+    }
+
+    for(std::string line; std::getline(streamConfig, line); linenumber++)
+    {
+        if(line.empty()) continue;
+        LogPrintf("Read line=%s\n", line);
+        std::istringstream iss(line);
+        std::string comment, alias, ip, privKey, txHash, outputIndex;
+
+        if (iss >> comment) {
+            if(comment.at(0) == '#') continue;
+            iss.str(line);
+            iss.clear();
+        }
+        if (!(iss >> alias >> ip >> privKey >> txHash >> outputIndex)) {
+            iss.str(line);
+            iss.clear();
+            if (!(iss >> alias >> ip >> privKey >> txHash >> outputIndex)) {
+                strErr = _("Could not parse znode.conf") + "\n" +
+                        strprintf(_("Line: %d"), linenumber) + "\n\"" + line + "\"";
+                streamConfig.close();
+                return false;
+            }
+        }
+
+        int port = 0;
+        std::string hostname = "";
+        SplitHostPort(ip, port, hostname);
+        if(port == 0 || hostname == "") {
+            strErr = _("Failed to parse host:port string") + "\n"+
+                    strprintf(_("Line: %d"), linenumber) + "\n\"" + line + "\"";
+            streamConfig.close();
+            return false;
+        }
+        int mainnetDefaultPort = Params(CBaseChainParams::MAIN).GetDefaultPort();
+        LogPrintf("mainnetDefaultPort=%s\n", mainnetDefaultPort);
+        LogPrintf("Params().NetworkIDString()=%s\n", Params().NetworkIDString());
+        LogPrintf("CBaseChainParams::MAIN=%s\n", CBaseChainParams::MAIN);
+        if(Params().NetworkIDString() == CBaseChainParams::MAIN) {
+            if(port != mainnetDefaultPort) {
+                strErr = _("Invalid port detected in znode.conf") + "\n" +
+                        strprintf(_("Port: %d"), port) + "\n" +
+                        strprintf(_("Line: %d"), linenumber) + "\n\"" + line + "\"" + "\n" +
+                        strprintf(_("(must be %d for mainnet)"), mainnetDefaultPort);
+                streamConfig.close();
+                return false;
+            }
+        } else if(port == mainnetDefaultPort) {
+            strErr = _("Invalid port detected in znode.conf") + "\n" +
+                    strprintf(_("Line: %d"), linenumber) + "\n\"" + line + "\"" + "\n" +
+                    strprintf(_("(%d could be used only on mainnet)"), mainnetDefaultPort);
+            streamConfig.close();
+            return false;
+        }
+
+
+        add(alias, ip, privKey, txHash, outputIndex);
+    }
+
+    streamConfig.close();
+    return true;
+}
diff --git a/src/znodeconfig.h b/src/znodeconfig.h
new file mode 100644
index 0000000000..72abe0af32
--- /dev/null
+++ b/src/znodeconfig.h
@@ -0,0 +1,99 @@
+
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef SRC_ZNODECONFIG_H_
+#define SRC_ZNODECONFIG_H_
+
+class CZnodeConfig;
+extern CZnodeConfig znodeConfig;
+
+class CZnodeConfig
+{
+
+public:
+
+    class CZnodeEntry {
+
+    private:
+        std::string alias;
+        std::string ip;
+        std::string privKey;
+        std::string txHash;
+        std::string outputIndex;
+    public:
+
+        CZnodeEntry(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex) {
+            this->alias = alias;
+            this->ip = ip;
+            this->privKey = privKey;
+            this->txHash = txHash;
+            this->outputIndex = outputIndex;
+        }
+
+        const std::string& getAlias() const {
+            return alias;
+        }
+
+        void setAlias(const std::string& alias) {
+            this->alias = alias;
+        }
+
+        const std::string& getOutputIndex() const {
+            return outputIndex;
+        }
+
+        void setOutputIndex(const std::string& outputIndex) {
+            this->outputIndex = outputIndex;
+        }
+
+        const std::string& getPrivKey() const {
+            return privKey;
+        }
+
+        void setPrivKey(const std::string& privKey) {
+            this->privKey = privKey;
+        }
+
+        const std::string& getTxHash() const {
+            return txHash;
+        }
+
+        void setTxHash(const std::string& txHash) {
+            this->txHash = txHash;
+        }
+
+        const std::string& getIp() const {
+            return ip;
+        }
+
+        void setIp(const std::string& ip) {
+            this->ip = ip;
+        }
+    };
+
+    CZnodeConfig() {
+        entries = std::vector<CZnodeEntry>();
+    }
+
+    void clear();
+    bool read(std::string& strErr);
+    void add(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex);
+
+    std::vector<CZnodeEntry>& getEntries() {
+        return entries;
+    }
+
+    int getCount() {
+        return (int)entries.size();
+    }
+
+private:
+    std::vector<CZnodeEntry> entries;
+
+
+};
+
+
+#endif /* SRC_ZNODECONFIG_H_ */
diff --git a/src/znodeman.cpp b/src/znodeman.cpp
new file mode 100644
index 0000000000..bc9570dab0
--- /dev/null
+++ b/src/znodeman.cpp
@@ -0,0 +1,1712 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "activeznode.h"
+#include "addrman.h"
+#include "darksend.h"
+//#include "governance.h"
+#include "znode-payments.h"
+#include "znode-sync.h"
+#include "znodeman.h"
+#include "netfulfilledman.h"
+#include "util.h"
+
+/** Znode manager */
+CZnodeMan mnodeman;
+
+const std::string CZnodeMan::SERIALIZATION_VERSION_STRING = "CZnodeMan-Version-4";
+
+struct CompareLastPaidBlock
+{
+    bool operator()(const std::pair<int, CZnode*>& t1,
+                    const std::pair<int, CZnode*>& t2) const
+    {
+        return (t1.first != t2.first) ? (t1.first < t2.first) : (t1.second->vin < t2.second->vin);
+    }
+};
+
+struct CompareScoreMN
+{
+    bool operator()(const std::pair<int64_t, CZnode*>& t1,
+                    const std::pair<int64_t, CZnode*>& t2) const
+    {
+        return (t1.first != t2.first) ? (t1.first < t2.first) : (t1.second->vin < t2.second->vin);
+    }
+};
+
+CZnodeIndex::CZnodeIndex()
+    : nSize(0),
+      mapIndex(),
+      mapReverseIndex()
+{}
+
+bool CZnodeIndex::Get(int nIndex, CTxIn& vinZnode) const
+{
+    rindex_m_cit it = mapReverseIndex.find(nIndex);
+    if(it == mapReverseIndex.end()) {
+        return false;
+    }
+    vinZnode = it->second;
+    return true;
+}
+
+int CZnodeIndex::GetZnodeIndex(const CTxIn& vinZnode) const
+{
+    index_m_cit it = mapIndex.find(vinZnode);
+    if(it == mapIndex.end()) {
+        return -1;
+    }
+    return it->second;
+}
+
+void CZnodeIndex::AddZnodeVIN(const CTxIn& vinZnode)
+{
+    index_m_it it = mapIndex.find(vinZnode);
+    if(it != mapIndex.end()) {
+        return;
+    }
+    int nNextIndex = nSize;
+    mapIndex[vinZnode] = nNextIndex;
+    mapReverseIndex[nNextIndex] = vinZnode;
+    ++nSize;
+}
+
+void CZnodeIndex::Clear()
+{
+    mapIndex.clear();
+    mapReverseIndex.clear();
+    nSize = 0;
+}
+struct CompareByAddr
+
+{
+    bool operator()(const CZnode* t1,
+                    const CZnode* t2) const
+    {
+        return t1->addr < t2->addr;
+    }
+};
+
+void CZnodeIndex::RebuildIndex()
+{
+    nSize = mapIndex.size();
+    for(index_m_it it = mapIndex.begin(); it != mapIndex.end(); ++it) {
+        mapReverseIndex[it->second] = it->first;
+    }
+}
+
+CZnodeMan::CZnodeMan() : cs(),
+  vZnodes(),
+  mAskedUsForZnodeList(),
+  mWeAskedForZnodeList(),
+  mWeAskedForZnodeListEntry(),
+  mWeAskedForVerification(),
+  mMnbRecoveryRequests(),
+  mMnbRecoveryGoodReplies(),
+  listScheduledMnbRequestConnections(),
+  nLastIndexRebuildTime(0),
+  indexZnodes(),
+  indexZnodesOld(),
+  fIndexRebuilt(false),
+  fZnodesAdded(false),
+  fZnodesRemoved(false),
+//  vecDirtyGovernanceObjectHashes(),
+  nLastWatchdogVoteTime(0),
+  mapSeenZnodeBroadcast(),
+  mapSeenZnodePing(),
+  nDsqCount(0)
+{}
+
+bool CZnodeMan::Add(CZnode &mn)
+{
+    LOCK(cs);
+
+    CZnode *pmn = Find(mn.vin);
+    if (pmn == NULL) {
+        LogPrint("znode", "CZnodeMan::Add -- Adding new Znode: addr=%s, %i now\n", mn.addr.ToString(), size() + 1);
+        vZnodes.push_back(mn);
+        indexZnodes.AddZnodeVIN(mn.vin);
+        fZnodesAdded = true;
+        return true;
+    }
+
+    return false;
+}
+
+void CZnodeMan::AskForMN(CNode* pnode, const CTxIn &vin)
+{
+    if(!pnode) return;
+
+    LOCK(cs);
+
+    std::map<COutPoint, std::map<CNetAddr, int64_t> >::iterator it1 = mWeAskedForZnodeListEntry.find(vin.prevout);
+    if (it1 != mWeAskedForZnodeListEntry.end()) {
+        std::map<CNetAddr, int64_t>::iterator it2 = it1->second.find(pnode->addr);
+        if (it2 != it1->second.end()) {
+            if (GetTime() < it2->second) {
+                // we've asked recently, should not repeat too often or we could get banned
+                return;
+            }
+            // we asked this node for this outpoint but it's ok to ask again already
+            LogPrintf("CZnodeMan::AskForMN -- Asking same peer %s for missing znode entry again: %s\n", pnode->addr.ToString(), vin.prevout.ToStringShort());
+        } else {
+            // we already asked for this outpoint but not this node
+            LogPrintf("CZnodeMan::AskForMN -- Asking new peer %s for missing znode entry: %s\n", pnode->addr.ToString(), vin.prevout.ToStringShort());
+        }
+    } else {
+        // we never asked any node for this outpoint
+        LogPrintf("CZnodeMan::AskForMN -- Asking peer %s for missing znode entry for the first time: %s\n", pnode->addr.ToString(), vin.prevout.ToStringShort());
+    }
+    mWeAskedForZnodeListEntry[vin.prevout][pnode->addr] = GetTime() + DSEG_UPDATE_SECONDS;
+
+    pnode->PushMessage(NetMsgType::DSEG, vin);
+}
+
+void CZnodeMan::Check()
+{
+    LOCK(cs);
+
+//    LogPrint("znode", "CZnodeMan::Check -- nLastWatchdogVoteTime=%d, IsWatchdogActive()=%d\n", nLastWatchdogVoteTime, IsWatchdogActive());
+
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+        mn.Check();
+    }
+}
+
+void CZnodeMan::CheckAndRemove()
+{
+    if(!znodeSync.IsZnodeListSynced()) return;
+
+    LogPrintf("CZnodeMan::CheckAndRemove\n");
+
+    {
+        // Need LOCK2 here to ensure consistent locking order because code below locks cs_main
+        // in CheckMnbAndUpdateZnodeList()
+        LOCK2(cs_main, cs);
+
+        Check();
+
+        // Remove spent znodes, prepare structures and make requests to reasure the state of inactive ones
+        std::vector<CZnode>::iterator it = vZnodes.begin();
+        std::vector<std::pair<int, CZnode> > vecZnodeRanks;
+        // ask for up to MNB_RECOVERY_MAX_ASK_ENTRIES znode entries at a time
+        int nAskForMnbRecovery = MNB_RECOVERY_MAX_ASK_ENTRIES;
+        while(it != vZnodes.end()) {
+            CZnodeBroadcast mnb = CZnodeBroadcast(*it);
+            uint256 hash = mnb.GetHash();
+            // If collateral was spent ...
+            if ((*it).IsOutpointSpent()) {
+                LogPrint("znode", "CZnodeMan::CheckAndRemove -- Removing Znode: %s  addr=%s  %i now\n", (*it).GetStateString(), (*it).addr.ToString(), size() - 1);
+
+                // erase all of the broadcasts we've seen from this txin, ...
+                mapSeenZnodeBroadcast.erase(hash);
+                mWeAskedForZnodeListEntry.erase((*it).vin.prevout);
+
+                // and finally remove it from the list
+//                it->FlagGovernanceItemsAsDirty();
+                it = vZnodes.erase(it);
+                fZnodesRemoved = true;
+            } else {
+                bool fAsk = pCurrentBlockIndex &&
+                            (nAskForMnbRecovery > 0) &&
+                            znodeSync.IsSynced() &&
+                            it->IsNewStartRequired() &&
+                            !IsMnbRecoveryRequested(hash);
+                if(fAsk) {
+                    // this mn is in a non-recoverable state and we haven't asked other nodes yet
+                    std::set<CNetAddr> setRequested;
+                    // calulate only once and only when it's needed
+                    if(vecZnodeRanks.empty()) {
+                        int nRandomBlockHeight = GetRandInt(pCurrentBlockIndex->nHeight);
+                        vecZnodeRanks = GetZnodeRanks(nRandomBlockHeight);
+                    }
+                    bool fAskedForMnbRecovery = false;
+                    // ask first MNB_RECOVERY_QUORUM_TOTAL znodes we can connect to and we haven't asked recently
+                    for(int i = 0; setRequested.size() < MNB_RECOVERY_QUORUM_TOTAL && i < (int)vecZnodeRanks.size(); i++) {
+                        // avoid banning
+                        if(mWeAskedForZnodeListEntry.count(it->vin.prevout) && mWeAskedForZnodeListEntry[it->vin.prevout].count(vecZnodeRanks[i].second.addr)) continue;
+                        // didn't ask recently, ok to ask now
+                        CService addr = vecZnodeRanks[i].second.addr;
+                        setRequested.insert(addr);
+                        listScheduledMnbRequestConnections.push_back(std::make_pair(addr, hash));
+                        fAskedForMnbRecovery = true;
+                    }
+                    if(fAskedForMnbRecovery) {
+                        LogPrint("znode", "CZnodeMan::CheckAndRemove -- Recovery initiated, znode=%s\n", it->vin.prevout.ToStringShort());
+                        nAskForMnbRecovery--;
+                    }
+                    // wait for mnb recovery replies for MNB_RECOVERY_WAIT_SECONDS seconds
+                    mMnbRecoveryRequests[hash] = std::make_pair(GetTime() + MNB_RECOVERY_WAIT_SECONDS, setRequested);
+                }
+                ++it;
+            }
+        }
+
+        // proces replies for ZNODE_NEW_START_REQUIRED znodes
+        LogPrint("znode", "CZnodeMan::CheckAndRemove -- mMnbRecoveryGoodReplies size=%d\n", (int)mMnbRecoveryGoodReplies.size());
+        std::map<uint256, std::vector<CZnodeBroadcast> >::iterator itMnbReplies = mMnbRecoveryGoodReplies.begin();
+        while(itMnbReplies != mMnbRecoveryGoodReplies.end()){
+            if(mMnbRecoveryRequests[itMnbReplies->first].first < GetTime()) {
+                // all nodes we asked should have replied now
+                if(itMnbReplies->second.size() >= MNB_RECOVERY_QUORUM_REQUIRED) {
+                    // majority of nodes we asked agrees that this mn doesn't require new mnb, reprocess one of new mnbs
+                    LogPrint("znode", "CZnodeMan::CheckAndRemove -- reprocessing mnb, znode=%s\n", itMnbReplies->second[0].vin.prevout.ToStringShort());
+                    // mapSeenZnodeBroadcast.erase(itMnbReplies->first);
+                    int nDos;
+                    itMnbReplies->second[0].fRecovery = true;
+                    CheckMnbAndUpdateZnodeList(NULL, itMnbReplies->second[0], nDos);
+                }
+                LogPrint("znode", "CZnodeMan::CheckAndRemove -- removing mnb recovery reply, znode=%s, size=%d\n", itMnbReplies->second[0].vin.prevout.ToStringShort(), (int)itMnbReplies->second.size());
+                mMnbRecoveryGoodReplies.erase(itMnbReplies++);
+            } else {
+                ++itMnbReplies;
+            }
+        }
+    }
+    {
+        // no need for cm_main below
+        LOCK(cs);
+
+        std::map<uint256, std::pair< int64_t, std::set<CNetAddr> > >::iterator itMnbRequest = mMnbRecoveryRequests.begin();
+        while(itMnbRequest != mMnbRecoveryRequests.end()){
+            // Allow this mnb to be re-verified again after MNB_RECOVERY_RETRY_SECONDS seconds
+            // if mn is still in ZNODE_NEW_START_REQUIRED state.
+            if(GetTime() - itMnbRequest->second.first > MNB_RECOVERY_RETRY_SECONDS) {
+                mMnbRecoveryRequests.erase(itMnbRequest++);
+            } else {
+                ++itMnbRequest;
+            }
+        }
+
+        // check who's asked for the Znode list
+        std::map<CNetAddr, int64_t>::iterator it1 = mAskedUsForZnodeList.begin();
+        while(it1 != mAskedUsForZnodeList.end()){
+            if((*it1).second < GetTime()) {
+                mAskedUsForZnodeList.erase(it1++);
+            } else {
+                ++it1;
+            }
+        }
+
+        // check who we asked for the Znode list
+        it1 = mWeAskedForZnodeList.begin();
+        while(it1 != mWeAskedForZnodeList.end()){
+            if((*it1).second < GetTime()){
+                mWeAskedForZnodeList.erase(it1++);
+            } else {
+                ++it1;
+            }
+        }
+
+        // check which Znodes we've asked for
+        std::map<COutPoint, std::map<CNetAddr, int64_t> >::iterator it2 = mWeAskedForZnodeListEntry.begin();
+        while(it2 != mWeAskedForZnodeListEntry.end()){
+            std::map<CNetAddr, int64_t>::iterator it3 = it2->second.begin();
+            while(it3 != it2->second.end()){
+                if(it3->second < GetTime()){
+                    it2->second.erase(it3++);
+                } else {
+                    ++it3;
+                }
+            }
+            if(it2->second.empty()) {
+                mWeAskedForZnodeListEntry.erase(it2++);
+            } else {
+                ++it2;
+            }
+        }
+
+        std::map<CNetAddr, CZnodeVerification>::iterator it3 = mWeAskedForVerification.begin();
+        while(it3 != mWeAskedForVerification.end()){
+            if(it3->second.nBlockHeight < pCurrentBlockIndex->nHeight - MAX_POSE_BLOCKS) {
+                mWeAskedForVerification.erase(it3++);
+            } else {
+                ++it3;
+            }
+        }
+
+        // NOTE: do not expire mapSeenZnodeBroadcast entries here, clean them on mnb updates!
+
+        // remove expired mapSeenZnodePing
+        std::map<uint256, CZnodePing>::iterator it4 = mapSeenZnodePing.begin();
+        while(it4 != mapSeenZnodePing.end()){
+            if((*it4).second.IsExpired()) {
+                LogPrint("znode", "CZnodeMan::CheckAndRemove -- Removing expired Znode ping: hash=%s\n", (*it4).second.GetHash().ToString());
+                mapSeenZnodePing.erase(it4++);
+            } else {
+                ++it4;
+            }
+        }
+
+        // remove expired mapSeenZnodeVerification
+        std::map<uint256, CZnodeVerification>::iterator itv2 = mapSeenZnodeVerification.begin();
+        while(itv2 != mapSeenZnodeVerification.end()){
+            if((*itv2).second.nBlockHeight < pCurrentBlockIndex->nHeight - MAX_POSE_BLOCKS){
+                LogPrint("znode", "CZnodeMan::CheckAndRemove -- Removing expired Znode verification: hash=%s\n", (*itv2).first.ToString());
+                mapSeenZnodeVerification.erase(itv2++);
+            } else {
+                ++itv2;
+            }
+        }
+
+        LogPrintf("CZnodeMan::CheckAndRemove -- %s\n", ToString());
+
+        if(fZnodesRemoved) {
+            CheckAndRebuildZnodeIndex();
+        }
+    }
+
+    if(fZnodesRemoved) {
+        NotifyZnodeUpdates();
+    }
+}
+
+void CZnodeMan::Clear()
+{
+    LOCK(cs);
+    vZnodes.clear();
+    mAskedUsForZnodeList.clear();
+    mWeAskedForZnodeList.clear();
+    mWeAskedForZnodeListEntry.clear();
+    mapSeenZnodeBroadcast.clear();
+    mapSeenZnodePing.clear();
+    nDsqCount = 0;
+    nLastWatchdogVoteTime = 0;
+    indexZnodes.Clear();
+    indexZnodesOld.Clear();
+}
+
+int CZnodeMan::CountZnodes(int nProtocolVersion)
+{
+    LOCK(cs);
+    int nCount = 0;
+    nProtocolVersion = nProtocolVersion == -1 ? mnpayments.GetMinZnodePaymentsProto() : nProtocolVersion;
+
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+        if(mn.nProtocolVersion < nProtocolVersion) continue;
+        nCount++;
+    }
+
+    return nCount;
+}
+
+int CZnodeMan::CountEnabled(int nProtocolVersion)
+{
+    LOCK(cs);
+    int nCount = 0;
+    nProtocolVersion = nProtocolVersion == -1 ? mnpayments.GetMinZnodePaymentsProto() : nProtocolVersion;
+
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+        if(mn.nProtocolVersion < nProtocolVersion || !mn.IsEnabled()) continue;
+        nCount++;
+    }
+
+    return nCount;
+}
+
+/* Only IPv4 znodes are allowed in 12.1, saving this for later
+int CZnodeMan::CountByIP(int nNetworkType)
+{
+    LOCK(cs);
+    int nNodeCount = 0;
+
+    BOOST_FOREACH(CZnode& mn, vZnodes)
+        if ((nNetworkType == NET_IPV4 && mn.addr.IsIPv4()) ||
+            (nNetworkType == NET_TOR  && mn.addr.IsTor())  ||
+            (nNetworkType == NET_IPV6 && mn.addr.IsIPv6())) {
+                nNodeCount++;
+        }
+
+    return nNodeCount;
+}
+*/
+
+void CZnodeMan::DsegUpdate(CNode* pnode)
+{
+    LOCK(cs);
+
+    if(Params().NetworkIDString() == CBaseChainParams::MAIN) {
+        if(!(pnode->addr.IsRFC1918() || pnode->addr.IsLocal())) {
+            std::map<CNetAddr, int64_t>::iterator it = mWeAskedForZnodeList.find(pnode->addr);
+            if(it != mWeAskedForZnodeList.end() && GetTime() < (*it).second) {
+                LogPrintf("CZnodeMan::DsegUpdate -- we already asked %s for the list; skipping...\n", pnode->addr.ToString());
+                return;
+            }
+        }
+    }
+    
+    pnode->PushMessage(NetMsgType::DSEG, CTxIn());
+    int64_t askAgain = GetTime() + DSEG_UPDATE_SECONDS;
+    mWeAskedForZnodeList[pnode->addr] = askAgain;
+
+    LogPrint("znode", "CZnodeMan::DsegUpdate -- asked %s for the list\n", pnode->addr.ToString());
+}
+
+CZnode* CZnodeMan::Find(const CScript &payee)
+{
+    LOCK(cs);
+
+    BOOST_FOREACH(CZnode& mn, vZnodes)
+    {
+        if(GetScriptForDestination(mn.pubKeyCollateralAddress.GetID()) == payee)
+            return &mn;
+    }
+    return NULL;
+}
+
+CZnode* CZnodeMan::Find(const CTxIn &vin)
+{
+    LOCK(cs);
+
+    BOOST_FOREACH(CZnode& mn, vZnodes)
+    {
+        if(mn.vin.prevout == vin.prevout)
+            return &mn;
+    }
+    return NULL;
+}
+
+CZnode* CZnodeMan::Find(const CPubKey &pubKeyZnode)
+{
+    LOCK(cs);
+
+    BOOST_FOREACH(CZnode& mn, vZnodes)
+    {
+        if(mn.pubKeyZnode == pubKeyZnode)
+            return &mn;
+    }
+    return NULL;
+}
+
+bool CZnodeMan::Get(const CPubKey& pubKeyZnode, CZnode& znode)
+{
+    // Theses mutexes are recursive so double locking by the same thread is safe.
+    LOCK(cs);
+    CZnode* pMN = Find(pubKeyZnode);
+    if(!pMN)  {
+        return false;
+    }
+    znode = *pMN;
+    return true;
+}
+
+bool CZnodeMan::Get(const CTxIn& vin, CZnode& znode)
+{
+    // Theses mutexes are recursive so double locking by the same thread is safe.
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    if(!pMN)  {
+        return false;
+    }
+    znode = *pMN;
+    return true;
+}
+
+znode_info_t CZnodeMan::GetZnodeInfo(const CTxIn& vin)
+{
+    znode_info_t info;
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    if(!pMN)  {
+        return info;
+    }
+    info = pMN->GetInfo();
+    return info;
+}
+
+znode_info_t CZnodeMan::GetZnodeInfo(const CPubKey& pubKeyZnode)
+{
+    znode_info_t info;
+    LOCK(cs);
+    CZnode* pMN = Find(pubKeyZnode);
+    if(!pMN)  {
+        return info;
+    }
+    info = pMN->GetInfo();
+    return info;
+}
+
+bool CZnodeMan::Has(const CTxIn& vin)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    return (pMN != NULL);
+}
+
+//
+// Deterministically select the oldest/best znode to pay on the network
+//
+CZnode* CZnodeMan::GetNextZnodeInQueueForPayment(bool fFilterSigTime, int& nCount)
+{
+    if(!pCurrentBlockIndex) {
+        nCount = 0;
+        return NULL;
+    }
+    return GetNextZnodeInQueueForPayment(pCurrentBlockIndex->nHeight, fFilterSigTime, nCount);
+}
+
+CZnode* CZnodeMan::GetNextZnodeInQueueForPayment(int nBlockHeight, bool fFilterSigTime, int& nCount)
+{
+    // Need LOCK2 here to ensure consistent locking order because the GetBlockHash call below locks cs_main
+    LOCK2(cs_main,cs);
+
+    CZnode *pBestZnode = NULL;
+    std::vector<std::pair<int, CZnode*> > vecZnodeLastPaid;
+
+    /*
+        Make a vector with all of the last paid times
+    */
+    LogPrintf("vZnodes.size()=%s\n", vZnodes.size());
+    int nMnCount = CountEnabled();
+    int index = 0;
+    BOOST_FOREACH(CZnode &mn, vZnodes)
+    {
+        index += 1;
+        LogPrintf("index=%s, mn=%s\n", index, mn.ToString());
+        if(!mn.IsValidForPayment()) {
+            LogPrintf("Invalid payment!\n");
+            continue;
+        }
+        // //check protocol version
+        if(mn.nProtocolVersion < mnpayments.GetMinZnodePaymentsProto()) {
+            LogPrintf("Invalid nProtocolVersion!\n");
+            LogPrintf("mn.nProtocolVersion=%s!\n", mn.nProtocolVersion);
+            LogPrintf("mnpayments.GetMinZnodePaymentsProto=%s!\n", mnpayments.GetMinZnodePaymentsProto());
+            continue;
+        }
+        //it's in the list (up to 8 entries ahead of current block to allow propagation) -- so let's skip it
+        if(mnpayments.IsScheduled(mn, nBlockHeight)){
+            LogPrintf("mnpayments.IsScheduled!\n");
+            continue;
+        }
+        //it's too new, wait for a cycle
+        if(fFilterSigTime && mn.sigTime + (nMnCount * 2.6 * 60) > GetAdjustedTime()){
+            LogPrintf("it's too new, wait for a cycle!\n");
+            continue;
+        }
+        //make sure it has at least as many confirmations as there are znodes
+        if(mn.GetCollateralAge() < nMnCount) {
+            LogPrintf("mn.GetCollateralAge()=%s!\n", mn.GetCollateralAge());
+            LogPrintf("nMnCount=%s!\n", nMnCount);
+            continue;
+        }
+
+        vecZnodeLastPaid.push_back(std::make_pair(mn.GetLastPaidBlock(), &mn));
+    }
+    nCount = (int)vecZnodeLastPaid.size();
+
+    //when the network is in the process of upgrading, don't penalize nodes that recently restarted
+    if(fFilterSigTime && nCount < nMnCount / 3) {
+        LogPrintf("Need Return, nCount=%s, nMnCount/3=%s\n", nCount, nMnCount/3);
+        return GetNextZnodeInQueueForPayment(nBlockHeight, false, nCount);
+    }
+
+    // Sort them low to high
+    sort(vecZnodeLastPaid.begin(), vecZnodeLastPaid.end(), CompareLastPaidBlock());
+
+    uint256 blockHash;
+    if(!GetBlockHash(blockHash, nBlockHeight - 101)) {
+        LogPrintf("CZnode::GetNextZnodeInQueueForPayment -- ERROR: GetBlockHash() failed at nBlockHeight %d\n", nBlockHeight - 101);
+        return NULL;
+    }
+    // Look at 1/10 of the oldest nodes (by last payment), calculate their scores and pay the best one
+    //  -- This doesn't look at who is being paid in the +8-10 blocks, allowing for double payments very rarely
+    //  -- 1/100 payments should be a double payment on mainnet - (1/(3000/10))*2
+    //  -- (chance per block * chances before IsScheduled will fire)
+    int nTenthNetwork = nMnCount/10;
+    int nCountTenth = 0;
+    arith_uint256 nHighest = 0;
+    BOOST_FOREACH (PAIRTYPE(int, CZnode*)& s, vecZnodeLastPaid){
+        arith_uint256 nScore = s.second->CalculateScore(blockHash);
+        LogPrintf("node=%s\n", s.second->addr.ToString());
+        LogPrintf("nScore=%s, nHighest=%s\n", nScore.ToString(), nHighest.ToString());
+        if(nScore > nHighest){
+            nHighest = nScore;
+            pBestZnode = s.second;
+        }
+        nCountTenth++;
+        if(nCountTenth >= nTenthNetwork) break;
+    }
+    return pBestZnode;
+}
+
+CZnode* CZnodeMan::FindRandomNotInVec(const std::vector<CTxIn> &vecToExclude, int nProtocolVersion)
+{
+    LOCK(cs);
+
+    nProtocolVersion = nProtocolVersion == -1 ? mnpayments.GetMinZnodePaymentsProto() : nProtocolVersion;
+
+    int nCountEnabled = CountEnabled(nProtocolVersion);
+    int nCountNotExcluded = nCountEnabled - vecToExclude.size();
+
+    LogPrintf("CZnodeMan::FindRandomNotInVec -- %d enabled znodes, %d znodes to choose from\n", nCountEnabled, nCountNotExcluded);
+    if(nCountNotExcluded < 1) return NULL;
+
+    // fill a vector of pointers
+    std::vector<CZnode*> vpZnodesShuffled;
+    BOOST_FOREACH(CZnode &mn, vZnodes) {
+        vpZnodesShuffled.push_back(&mn);
+    }
+
+    InsecureRand insecureRand;
+    // shuffle pointers
+    std::random_shuffle(vpZnodesShuffled.begin(), vpZnodesShuffled.end(), insecureRand);
+    bool fExclude;
+
+    // loop through
+    BOOST_FOREACH(CZnode* pmn, vpZnodesShuffled) {
+        if(pmn->nProtocolVersion < nProtocolVersion || !pmn->IsEnabled()) continue;
+        fExclude = false;
+        BOOST_FOREACH(const CTxIn &txinToExclude, vecToExclude) {
+            if(pmn->vin.prevout == txinToExclude.prevout) {
+                fExclude = true;
+                break;
+            }
+        }
+        if(fExclude) continue;
+        // found the one not in vecToExclude
+        LogPrint("znode", "CZnodeMan::FindRandomNotInVec -- found, znode=%s\n", pmn->vin.prevout.ToStringShort());
+        return pmn;
+    }
+
+    LogPrint("znode", "CZnodeMan::FindRandomNotInVec -- failed\n");
+    return NULL;
+}
+
+int CZnodeMan::GetZnodeRank(const CTxIn& vin, int nBlockHeight, int nMinProtocol, bool fOnlyActive)
+{
+    std::vector<std::pair<int64_t, CZnode*> > vecZnodeScores;
+
+    //make sure we know about this block
+    uint256 blockHash = uint256();
+    if(!GetBlockHash(blockHash, nBlockHeight)) return -1;
+
+    LOCK(cs);
+
+    // scan for winner
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+        if(mn.nProtocolVersion < nMinProtocol) continue;
+        if(fOnlyActive) {
+            if(!mn.IsEnabled()) continue;
+        }
+        else {
+            if(!mn.IsValidForPayment()) continue;
+        }
+        int64_t nScore = mn.CalculateScore(blockHash).GetCompact(false);
+
+        vecZnodeScores.push_back(std::make_pair(nScore, &mn));
+    }
+
+    sort(vecZnodeScores.rbegin(), vecZnodeScores.rend(), CompareScoreMN());
+
+    int nRank = 0;
+    BOOST_FOREACH (PAIRTYPE(int64_t, CZnode*)& scorePair, vecZnodeScores) {
+        nRank++;
+        if(scorePair.second->vin.prevout == vin.prevout) return nRank;
+    }
+
+    return -1;
+}
+
+std::vector<std::pair<int, CZnode> > CZnodeMan::GetZnodeRanks(int nBlockHeight, int nMinProtocol)
+{
+    std::vector<std::pair<int64_t, CZnode*> > vecZnodeScores;
+    std::vector<std::pair<int, CZnode> > vecZnodeRanks;
+
+    //make sure we know about this block
+    uint256 blockHash = uint256();
+    if(!GetBlockHash(blockHash, nBlockHeight)) return vecZnodeRanks;
+
+    LOCK(cs);
+
+    // scan for winner
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+
+        if(mn.nProtocolVersion < nMinProtocol || !mn.IsEnabled()) continue;
+
+        int64_t nScore = mn.CalculateScore(blockHash).GetCompact(false);
+
+        vecZnodeScores.push_back(std::make_pair(nScore, &mn));
+    }
+
+    sort(vecZnodeScores.rbegin(), vecZnodeScores.rend(), CompareScoreMN());
+
+    int nRank = 0;
+    BOOST_FOREACH (PAIRTYPE(int64_t, CZnode*)& s, vecZnodeScores) {
+        nRank++;
+        vecZnodeRanks.push_back(std::make_pair(nRank, *s.second));
+    }
+
+    return vecZnodeRanks;
+}
+
+CZnode* CZnodeMan::GetZnodeByRank(int nRank, int nBlockHeight, int nMinProtocol, bool fOnlyActive)
+{
+    std::vector<std::pair<int64_t, CZnode*> > vecZnodeScores;
+
+    LOCK(cs);
+
+    uint256 blockHash;
+    if(!GetBlockHash(blockHash, nBlockHeight)) {
+        LogPrintf("CZnode::GetZnodeByRank -- ERROR: GetBlockHash() failed at nBlockHeight %d\n", nBlockHeight);
+        return NULL;
+    }
+
+    // Fill scores
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+
+        if(mn.nProtocolVersion < nMinProtocol) continue;
+        if(fOnlyActive && !mn.IsEnabled()) continue;
+
+        int64_t nScore = mn.CalculateScore(blockHash).GetCompact(false);
+
+        vecZnodeScores.push_back(std::make_pair(nScore, &mn));
+    }
+
+    sort(vecZnodeScores.rbegin(), vecZnodeScores.rend(), CompareScoreMN());
+
+    int rank = 0;
+    BOOST_FOREACH (PAIRTYPE(int64_t, CZnode*)& s, vecZnodeScores){
+        rank++;
+        if(rank == nRank) {
+            return s.second;
+        }
+    }
+
+    return NULL;
+}
+
+void CZnodeMan::ProcessZnodeConnections()
+{
+    //we don't care about this for regtest
+    if(Params().NetworkIDString() == CBaseChainParams::REGTEST) return;
+
+    LOCK(cs_vNodes);
+    BOOST_FOREACH(CNode* pnode, vNodes) {
+        if(pnode->fZnode) {
+            if(darkSendPool.pSubmittedToZnode != NULL && pnode->addr == darkSendPool.pSubmittedToZnode->addr) continue;
+            LogPrintf("Closing Znode connection: peer=%d, addr=%s\n", pnode->id, pnode->addr.ToString());
+            pnode->fDisconnect = true;
+        }
+    }
+}
+
+std::pair<CService, std::set<uint256> > CZnodeMan::PopScheduledMnbRequestConnection()
+{
+    LOCK(cs);
+    if(listScheduledMnbRequestConnections.empty()) {
+        return std::make_pair(CService(), std::set<uint256>());
+    }
+
+    std::set<uint256> setResult;
+
+    listScheduledMnbRequestConnections.sort();
+    std::pair<CService, uint256> pairFront = listScheduledMnbRequestConnections.front();
+
+    // squash hashes from requests with the same CService as the first one into setResult
+    std::list< std::pair<CService, uint256> >::iterator it = listScheduledMnbRequestConnections.begin();
+    while(it != listScheduledMnbRequestConnections.end()) {
+        if(pairFront.first == it->first) {
+            setResult.insert(it->second);
+            it = listScheduledMnbRequestConnections.erase(it);
+        } else {
+            // since list is sorted now, we can be sure that there is no more hashes left
+            // to ask for from this addr
+            break;
+        }
+    }
+    return std::make_pair(pairFront.first, setResult);
+}
+
+
+void CZnodeMan::ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
+{
+
+//    LogPrint("znode", "CZnodeMan::ProcessMessage, strCommand=%s\n", strCommand);
+    if(fLiteMode) return; // disable all Dash specific functionality
+    if(!znodeSync.IsBlockchainSynced()) return;
+
+    if (strCommand == NetMsgType::MNANNOUNCE) { //Znode Broadcast
+        CZnodeBroadcast mnb;
+        vRecv >> mnb;
+
+        pfrom->setAskFor.erase(mnb.GetHash());
+
+        LogPrintf("MNANNOUNCE -- Znode announce, znode=%s\n", mnb.vin.prevout.ToStringShort());
+
+        int nDos = 0;
+
+        if (CheckMnbAndUpdateZnodeList(pfrom, mnb, nDos)) {
+            // use announced Znode as a peer
+            addrman.Add(CAddress(mnb.addr, NODE_NETWORK), pfrom->addr, 2*60*60);
+        } else if(nDos > 0) {
+            Misbehaving(pfrom->GetId(), nDos);
+        }
+
+        if(fZnodesAdded) {
+            NotifyZnodeUpdates();
+        }
+    } else if (strCommand == NetMsgType::MNPING) { //Znode Ping
+
+        CZnodePing mnp;
+        vRecv >> mnp;
+
+        uint256 nHash = mnp.GetHash();
+
+        pfrom->setAskFor.erase(nHash);
+
+        LogPrint("znode", "MNPING -- Znode ping, znode=%s\n", mnp.vin.prevout.ToStringShort());
+
+        // Need LOCK2 here to ensure consistent locking order because the CheckAndUpdate call below locks cs_main
+        LOCK2(cs_main, cs);
+
+        if(mapSeenZnodePing.count(nHash)) return; //seen
+        mapSeenZnodePing.insert(std::make_pair(nHash, mnp));
+
+        LogPrint("znode", "MNPING -- Znode ping, znode=%s new\n", mnp.vin.prevout.ToStringShort());
+
+        // see if we have this Znode
+        CZnode* pmn = mnodeman.Find(mnp.vin);
+
+        // too late, new MNANNOUNCE is required
+        if(pmn && pmn->IsNewStartRequired()) return;
+
+        int nDos = 0;
+        if(mnp.CheckAndUpdate(pmn, false, nDos)) return;
+
+        if(nDos > 0) {
+            // if anything significant failed, mark that node
+            Misbehaving(pfrom->GetId(), nDos);
+        } else if(pmn != NULL) {
+            // nothing significant failed, mn is a known one too
+            return;
+        }
+
+        // something significant is broken or mn is unknown,
+        // we might have to ask for a znode entry once
+        AskForMN(pfrom, mnp.vin);
+
+    } else if (strCommand == NetMsgType::DSEG) { //Get Znode list or specific entry
+        // Ignore such requests until we are fully synced.
+        // We could start processing this after znode list is synced
+        // but this is a heavy one so it's better to finish sync first.
+        if (!znodeSync.IsSynced()) return;
+
+        CTxIn vin;
+        vRecv >> vin;
+
+        LogPrint("znode", "DSEG -- Znode list, znode=%s\n", vin.prevout.ToStringShort());
+
+        LOCK(cs);
+
+        if(vin == CTxIn()) { //only should ask for this once
+            //local network
+            bool isLocal = (pfrom->addr.IsRFC1918() || pfrom->addr.IsLocal());
+
+            if(!isLocal && Params().NetworkIDString() == CBaseChainParams::MAIN) {
+                std::map<CNetAddr, int64_t>::iterator i = mAskedUsForZnodeList.find(pfrom->addr);
+                if (i != mAskedUsForZnodeList.end()){
+                    int64_t t = (*i).second;
+                    if (GetTime() < t) {
+                        Misbehaving(pfrom->GetId(), 34);
+                        LogPrintf("DSEG -- peer already asked me for the list, peer=%d\n", pfrom->id);
+                        return;
+                    }
+                }
+                int64_t askAgain = GetTime() + DSEG_UPDATE_SECONDS;
+                mAskedUsForZnodeList[pfrom->addr] = askAgain;
+            }
+        } //else, asking for a specific node which is ok
+
+        int nInvCount = 0;
+
+        BOOST_FOREACH(CZnode& mn, vZnodes) {
+            if (vin != CTxIn() && vin != mn.vin) continue; // asked for specific vin but we are not there yet
+            if (mn.addr.IsRFC1918() || mn.addr.IsLocal()) continue; // do not send local network znode
+            if (mn.IsUpdateRequired()) continue; // do not send outdated znodes
+
+            LogPrint("znode", "DSEG -- Sending Znode entry: znode=%s  addr=%s\n", mn.vin.prevout.ToStringShort(), mn.addr.ToString());
+            CZnodeBroadcast mnb = CZnodeBroadcast(mn);
+            uint256 hash = mnb.GetHash();
+            pfrom->PushInventory(CInv(MSG_ZNODE_ANNOUNCE, hash));
+            pfrom->PushInventory(CInv(MSG_ZNODE_PING, mn.lastPing.GetHash()));
+            nInvCount++;
+
+            if (!mapSeenZnodeBroadcast.count(hash)) {
+                mapSeenZnodeBroadcast.insert(std::make_pair(hash, std::make_pair(GetTime(), mnb)));
+            }
+
+            if (vin == mn.vin) {
+                LogPrintf("DSEG -- Sent 1 Znode inv to peer %d\n", pfrom->id);
+                return;
+            }
+        }
+
+        if(vin == CTxIn()) {
+            pfrom->PushMessage(NetMsgType::SYNCSTATUSCOUNT, ZNODE_SYNC_LIST, nInvCount);
+            LogPrintf("DSEG -- Sent %d Znode invs to peer %d\n", nInvCount, pfrom->id);
+            return;
+        }
+        // smth weird happen - someone asked us for vin we have no idea about?
+        LogPrint("znode", "DSEG -- No invs sent to peer %d\n", pfrom->id);
+
+    } else if (strCommand == NetMsgType::MNVERIFY) { // Znode Verify
+
+        // Need LOCK2 here to ensure consistent locking order because the all functions below call GetBlockHash which locks cs_main
+        LOCK2(cs_main, cs);
+
+        CZnodeVerification mnv;
+        vRecv >> mnv;
+
+        if(mnv.vchSig1.empty()) {
+            // CASE 1: someone asked me to verify myself /IP we are using/
+            SendVerifyReply(pfrom, mnv);
+        } else if (mnv.vchSig2.empty()) {
+            // CASE 2: we _probably_ got verification we requested from some znode
+            ProcessVerifyReply(pfrom, mnv);
+        } else {
+            // CASE 3: we _probably_ got verification broadcast signed by some znode which verified another one
+            ProcessVerifyBroadcast(pfrom, mnv);
+        }
+    }
+}
+
+// Verification of znodes via unique direct requests.
+
+void CZnodeMan::DoFullVerificationStep()
+{
+    if(activeZnode.vin == CTxIn()) return;
+    if(!znodeSync.IsSynced()) return;
+
+    std::vector<std::pair<int, CZnode> > vecZnodeRanks = GetZnodeRanks(pCurrentBlockIndex->nHeight - 1, MIN_POSE_PROTO_VERSION);
+
+    // Need LOCK2 here to ensure consistent locking order because the SendVerifyRequest call below locks cs_main
+    // through GetHeight() signal in ConnectNode
+    LOCK2(cs_main, cs);
+
+    int nCount = 0;
+
+    int nMyRank = -1;
+    int nRanksTotal = (int)vecZnodeRanks.size();
+
+    // send verify requests only if we are in top MAX_POSE_RANK
+    std::vector<std::pair<int, CZnode> >::iterator it = vecZnodeRanks.begin();
+    while(it != vecZnodeRanks.end()) {
+        if(it->first > MAX_POSE_RANK) {
+            LogPrint("znode", "CZnodeMan::DoFullVerificationStep -- Must be in top %d to send verify request\n",
+                        (int)MAX_POSE_RANK);
+            return;
+        }
+        if(it->second.vin == activeZnode.vin) {
+            nMyRank = it->first;
+            LogPrint("znode", "CZnodeMan::DoFullVerificationStep -- Found self at rank %d/%d, verifying up to %d znodes\n",
+                        nMyRank, nRanksTotal, (int)MAX_POSE_CONNECTIONS);
+            break;
+        }
+        ++it;
+    }
+
+    // edge case: list is too short and this znode is not enabled
+    if(nMyRank == -1) return;
+
+    // send verify requests to up to MAX_POSE_CONNECTIONS znodes
+    // starting from MAX_POSE_RANK + nMyRank and using MAX_POSE_CONNECTIONS as a step
+    int nOffset = MAX_POSE_RANK + nMyRank - 1;
+    if(nOffset >= (int)vecZnodeRanks.size()) return;
+
+    std::vector<CZnode*> vSortedByAddr;
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+        vSortedByAddr.push_back(&mn);
+    }
+
+    sort(vSortedByAddr.begin(), vSortedByAddr.end(), CompareByAddr());
+
+    it = vecZnodeRanks.begin() + nOffset;
+    while(it != vecZnodeRanks.end()) {
+        if(it->second.IsPoSeVerified() || it->second.IsPoSeBanned()) {
+            LogPrint("znode", "CZnodeMan::DoFullVerificationStep -- Already %s%s%s znode %s address %s, skipping...\n",
+                        it->second.IsPoSeVerified() ? "verified" : "",
+                        it->second.IsPoSeVerified() && it->second.IsPoSeBanned() ? " and " : "",
+                        it->second.IsPoSeBanned() ? "banned" : "",
+                        it->second.vin.prevout.ToStringShort(), it->second.addr.ToString());
+            nOffset += MAX_POSE_CONNECTIONS;
+            if(nOffset >= (int)vecZnodeRanks.size()) break;
+            it += MAX_POSE_CONNECTIONS;
+            continue;
+        }
+        LogPrint("znode", "CZnodeMan::DoFullVerificationStep -- Verifying znode %s rank %d/%d address %s\n",
+                    it->second.vin.prevout.ToStringShort(), it->first, nRanksTotal, it->second.addr.ToString());
+        if(SendVerifyRequest(CAddress(it->second.addr, NODE_NETWORK), vSortedByAddr)) {
+            nCount++;
+            if(nCount >= MAX_POSE_CONNECTIONS) break;
+        }
+        nOffset += MAX_POSE_CONNECTIONS;
+        if(nOffset >= (int)vecZnodeRanks.size()) break;
+        it += MAX_POSE_CONNECTIONS;
+    }
+
+    LogPrint("znode", "CZnodeMan::DoFullVerificationStep -- Sent verification requests to %d znodes\n", nCount);
+}
+
+// This function tries to find znodes with the same addr,
+// find a verified one and ban all the other. If there are many nodes
+// with the same addr but none of them is verified yet, then none of them are banned.
+// It could take many times to run this before most of the duplicate nodes are banned.
+
+void CZnodeMan::CheckSameAddr()
+{
+    if(!znodeSync.IsSynced() || vZnodes.empty()) return;
+
+    std::vector<CZnode*> vBan;
+    std::vector<CZnode*> vSortedByAddr;
+
+    {
+        LOCK(cs);
+
+        CZnode* pprevZnode = NULL;
+        CZnode* pverifiedZnode = NULL;
+
+        BOOST_FOREACH(CZnode& mn, vZnodes) {
+            vSortedByAddr.push_back(&mn);
+        }
+
+        sort(vSortedByAddr.begin(), vSortedByAddr.end(), CompareByAddr());
+
+        BOOST_FOREACH(CZnode* pmn, vSortedByAddr) {
+            // check only (pre)enabled znodes
+            if(!pmn->IsEnabled() && !pmn->IsPreEnabled()) continue;
+            // initial step
+            if(!pprevZnode) {
+                pprevZnode = pmn;
+                pverifiedZnode = pmn->IsPoSeVerified() ? pmn : NULL;
+                continue;
+            }
+            // second+ step
+            if(pmn->addr == pprevZnode->addr) {
+                if(pverifiedZnode) {
+                    // another znode with the same ip is verified, ban this one
+                    vBan.push_back(pmn);
+                } else if(pmn->IsPoSeVerified()) {
+                    // this znode with the same ip is verified, ban previous one
+                    vBan.push_back(pprevZnode);
+                    // and keep a reference to be able to ban following znodes with the same ip
+                    pverifiedZnode = pmn;
+                }
+            } else {
+                pverifiedZnode = pmn->IsPoSeVerified() ? pmn : NULL;
+            }
+            pprevZnode = pmn;
+        }
+    }
+
+    // ban duplicates
+    BOOST_FOREACH(CZnode* pmn, vBan) {
+        LogPrintf("CZnodeMan::CheckSameAddr -- increasing PoSe ban score for znode %s\n", pmn->vin.prevout.ToStringShort());
+        pmn->IncreasePoSeBanScore();
+    }
+}
+
+bool CZnodeMan::SendVerifyRequest(const CAddress& addr, const std::vector<CZnode*>& vSortedByAddr)
+{
+    if(netfulfilledman.HasFulfilledRequest(addr, strprintf("%s", NetMsgType::MNVERIFY)+"-request")) {
+        // we already asked for verification, not a good idea to do this too often, skip it
+        LogPrint("znode", "CZnodeMan::SendVerifyRequest -- too many requests, skipping... addr=%s\n", addr.ToString());
+        return false;
+    }
+
+    CNode* pnode = ConnectNode(addr, NULL, false, true);
+    if(pnode == NULL) {
+        LogPrintf("CZnodeMan::SendVerifyRequest -- can't connect to node to verify it, addr=%s\n", addr.ToString());
+        return false;
+    }
+
+    netfulfilledman.AddFulfilledRequest(addr, strprintf("%s", NetMsgType::MNVERIFY)+"-request");
+    // use random nonce, store it and require node to reply with correct one later
+    CZnodeVerification mnv(addr, GetRandInt(999999), pCurrentBlockIndex->nHeight - 1);
+    mWeAskedForVerification[addr] = mnv;
+    LogPrintf("CZnodeMan::SendVerifyRequest -- verifying node using nonce %d addr=%s\n", mnv.nonce, addr.ToString());
+    pnode->PushMessage(NetMsgType::MNVERIFY, mnv);
+
+    return true;
+}
+
+void CZnodeMan::SendVerifyReply(CNode* pnode, CZnodeVerification& mnv)
+{
+    // only znodes can sign this, why would someone ask regular node?
+    if(!fZNode) {
+        // do not ban, malicious node might be using my IP
+        // and trying to confuse the node which tries to verify it
+        return;
+    }
+
+    if(netfulfilledman.HasFulfilledRequest(pnode->addr, strprintf("%s", NetMsgType::MNVERIFY)+"-reply")) {
+//        // peer should not ask us that often
+        LogPrintf("ZnodeMan::SendVerifyReply -- ERROR: peer already asked me recently, peer=%d\n", pnode->id);
+        Misbehaving(pnode->id, 20);
+        return;
+    }
+
+    uint256 blockHash;
+    if(!GetBlockHash(blockHash, mnv.nBlockHeight)) {
+        LogPrintf("ZnodeMan::SendVerifyReply -- can't get block hash for unknown block height %d, peer=%d\n", mnv.nBlockHeight, pnode->id);
+        return;
+    }
+
+    std::string strMessage = strprintf("%s%d%s", activeZnode.service.ToString(), mnv.nonce, blockHash.ToString());
+
+    if(!darkSendSigner.SignMessage(strMessage, mnv.vchSig1, activeZnode.keyZnode)) {
+        LogPrintf("ZnodeMan::SendVerifyReply -- SignMessage() failed\n");
+        return;
+    }
+
+    std::string strError;
+
+    if(!darkSendSigner.VerifyMessage(activeZnode.pubKeyZnode, mnv.vchSig1, strMessage, strError)) {
+        LogPrintf("ZnodeMan::SendVerifyReply -- VerifyMessage() failed, error: %s\n", strError);
+        return;
+    }
+
+    pnode->PushMessage(NetMsgType::MNVERIFY, mnv);
+    netfulfilledman.AddFulfilledRequest(pnode->addr, strprintf("%s", NetMsgType::MNVERIFY)+"-reply");
+}
+
+void CZnodeMan::ProcessVerifyReply(CNode* pnode, CZnodeVerification& mnv)
+{
+    std::string strError;
+
+    // did we even ask for it? if that's the case we should have matching fulfilled request
+    if(!netfulfilledman.HasFulfilledRequest(pnode->addr, strprintf("%s", NetMsgType::MNVERIFY)+"-request")) {
+        LogPrintf("CZnodeMan::ProcessVerifyReply -- ERROR: we didn't ask for verification of %s, peer=%d\n", pnode->addr.ToString(), pnode->id);
+        Misbehaving(pnode->id, 20);
+        return;
+    }
+
+    // Received nonce for a known address must match the one we sent
+    if(mWeAskedForVerification[pnode->addr].nonce != mnv.nonce) {
+        LogPrintf("CZnodeMan::ProcessVerifyReply -- ERROR: wrong nounce: requested=%d, received=%d, peer=%d\n",
+                    mWeAskedForVerification[pnode->addr].nonce, mnv.nonce, pnode->id);
+        Misbehaving(pnode->id, 20);
+        return;
+    }
+
+    // Received nBlockHeight for a known address must match the one we sent
+    if(mWeAskedForVerification[pnode->addr].nBlockHeight != mnv.nBlockHeight) {
+        LogPrintf("CZnodeMan::ProcessVerifyReply -- ERROR: wrong nBlockHeight: requested=%d, received=%d, peer=%d\n",
+                    mWeAskedForVerification[pnode->addr].nBlockHeight, mnv.nBlockHeight, pnode->id);
+        Misbehaving(pnode->id, 20);
+        return;
+    }
+
+    uint256 blockHash;
+    if(!GetBlockHash(blockHash, mnv.nBlockHeight)) {
+        // this shouldn't happen...
+        LogPrintf("ZnodeMan::ProcessVerifyReply -- can't get block hash for unknown block height %d, peer=%d\n", mnv.nBlockHeight, pnode->id);
+        return;
+    }
+
+//    // we already verified this address, why node is spamming?
+    if(netfulfilledman.HasFulfilledRequest(pnode->addr, strprintf("%s", NetMsgType::MNVERIFY)+"-done")) {
+        LogPrintf("CZnodeMan::ProcessVerifyReply -- ERROR: already verified %s recently\n", pnode->addr.ToString());
+        Misbehaving(pnode->id, 20);
+        return;
+    }
+
+    {
+        LOCK(cs);
+
+        CZnode* prealZnode = NULL;
+        std::vector<CZnode*> vpZnodesToBan;
+        std::vector<CZnode>::iterator it = vZnodes.begin();
+        std::string strMessage1 = strprintf("%s%d%s", pnode->addr.ToString(), mnv.nonce, blockHash.ToString());
+        while(it != vZnodes.end()) {
+            if(CAddress(it->addr, NODE_NETWORK) == pnode->addr) {
+                if(darkSendSigner.VerifyMessage(it->pubKeyZnode, mnv.vchSig1, strMessage1, strError)) {
+                    // found it!
+                    prealZnode = &(*it);
+                    if(!it->IsPoSeVerified()) {
+                        it->DecreasePoSeBanScore();
+                    }
+                    netfulfilledman.AddFulfilledRequest(pnode->addr, strprintf("%s", NetMsgType::MNVERIFY)+"-done");
+
+                    // we can only broadcast it if we are an activated znode
+                    if(activeZnode.vin == CTxIn()) continue;
+                    // update ...
+                    mnv.addr = it->addr;
+                    mnv.vin1 = it->vin;
+                    mnv.vin2 = activeZnode.vin;
+                    std::string strMessage2 = strprintf("%s%d%s%s%s", mnv.addr.ToString(), mnv.nonce, blockHash.ToString(),
+                                            mnv.vin1.prevout.ToStringShort(), mnv.vin2.prevout.ToStringShort());
+                    // ... and sign it
+                    if(!darkSendSigner.SignMessage(strMessage2, mnv.vchSig2, activeZnode.keyZnode)) {
+                        LogPrintf("ZnodeMan::ProcessVerifyReply -- SignMessage() failed\n");
+                        return;
+                    }
+
+                    std::string strError;
+
+                    if(!darkSendSigner.VerifyMessage(activeZnode.pubKeyZnode, mnv.vchSig2, strMessage2, strError)) {
+                        LogPrintf("ZnodeMan::ProcessVerifyReply -- VerifyMessage() failed, error: %s\n", strError);
+                        return;
+                    }
+
+                    mWeAskedForVerification[pnode->addr] = mnv;
+                    mnv.Relay();
+
+                } else {
+                    vpZnodesToBan.push_back(&(*it));
+                }
+            }
+            ++it;
+        }
+        // no real znode found?...
+        if(!prealZnode) {
+            // this should never be the case normally,
+            // only if someone is trying to game the system in some way or smth like that
+            LogPrintf("CZnodeMan::ProcessVerifyReply -- ERROR: no real znode found for addr %s\n", pnode->addr.ToString());
+            Misbehaving(pnode->id, 20);
+            return;
+        }
+        LogPrintf("CZnodeMan::ProcessVerifyReply -- verified real znode %s for addr %s\n",
+                    prealZnode->vin.prevout.ToStringShort(), pnode->addr.ToString());
+        // increase ban score for everyone else
+        BOOST_FOREACH(CZnode* pmn, vpZnodesToBan) {
+            pmn->IncreasePoSeBanScore();
+            LogPrint("znode", "CZnodeMan::ProcessVerifyBroadcast -- increased PoSe ban score for %s addr %s, new score %d\n",
+                        prealZnode->vin.prevout.ToStringShort(), pnode->addr.ToString(), pmn->nPoSeBanScore);
+        }
+        LogPrintf("CZnodeMan::ProcessVerifyBroadcast -- PoSe score increased for %d fake znodes, addr %s\n",
+                    (int)vpZnodesToBan.size(), pnode->addr.ToString());
+    }
+}
+
+void CZnodeMan::ProcessVerifyBroadcast(CNode* pnode, const CZnodeVerification& mnv)
+{
+    std::string strError;
+
+    if(mapSeenZnodeVerification.find(mnv.GetHash()) != mapSeenZnodeVerification.end()) {
+        // we already have one
+        return;
+    }
+    mapSeenZnodeVerification[mnv.GetHash()] = mnv;
+
+    // we don't care about history
+    if(mnv.nBlockHeight < pCurrentBlockIndex->nHeight - MAX_POSE_BLOCKS) {
+        LogPrint("znode", "ZnodeMan::ProcessVerifyBroadcast -- Outdated: current block %d, verification block %d, peer=%d\n",
+                    pCurrentBlockIndex->nHeight, mnv.nBlockHeight, pnode->id);
+        return;
+    }
+
+    if(mnv.vin1.prevout == mnv.vin2.prevout) {
+        LogPrint("znode", "ZnodeMan::ProcessVerifyBroadcast -- ERROR: same vins %s, peer=%d\n",
+                    mnv.vin1.prevout.ToStringShort(), pnode->id);
+        // that was NOT a good idea to cheat and verify itself,
+        // ban the node we received such message from
+        Misbehaving(pnode->id, 100);
+        return;
+    }
+
+    uint256 blockHash;
+    if(!GetBlockHash(blockHash, mnv.nBlockHeight)) {
+        // this shouldn't happen...
+        LogPrintf("ZnodeMan::ProcessVerifyBroadcast -- Can't get block hash for unknown block height %d, peer=%d\n", mnv.nBlockHeight, pnode->id);
+        return;
+    }
+
+    int nRank = GetZnodeRank(mnv.vin2, mnv.nBlockHeight, MIN_POSE_PROTO_VERSION);
+
+    if (nRank == -1) {
+        LogPrint("znode", "CZnodeMan::ProcessVerifyBroadcast -- Can't calculate rank for znode %s\n",
+                    mnv.vin2.prevout.ToStringShort());
+        return;
+    }
+
+    if(nRank > MAX_POSE_RANK) {
+        LogPrint("znode", "CZnodeMan::ProcessVerifyBroadcast -- Mastrernode %s is not in top %d, current rank %d, peer=%d\n",
+                    mnv.vin2.prevout.ToStringShort(), (int)MAX_POSE_RANK, nRank, pnode->id);
+        return;
+    }
+
+    {
+        LOCK(cs);
+
+        std::string strMessage1 = strprintf("%s%d%s", mnv.addr.ToString(), mnv.nonce, blockHash.ToString());
+        std::string strMessage2 = strprintf("%s%d%s%s%s", mnv.addr.ToString(), mnv.nonce, blockHash.ToString(),
+                                mnv.vin1.prevout.ToStringShort(), mnv.vin2.prevout.ToStringShort());
+
+        CZnode* pmn1 = Find(mnv.vin1);
+        if(!pmn1) {
+            LogPrintf("CZnodeMan::ProcessVerifyBroadcast -- can't find znode1 %s\n", mnv.vin1.prevout.ToStringShort());
+            return;
+        }
+
+        CZnode* pmn2 = Find(mnv.vin2);
+        if(!pmn2) {
+            LogPrintf("CZnodeMan::ProcessVerifyBroadcast -- can't find znode2 %s\n", mnv.vin2.prevout.ToStringShort());
+            return;
+        }
+
+        if(pmn1->addr != mnv.addr) {
+            LogPrintf("CZnodeMan::ProcessVerifyBroadcast -- addr %s do not match %s\n", mnv.addr.ToString(), pnode->addr.ToString());
+            return;
+        }
+
+        if(darkSendSigner.VerifyMessage(pmn1->pubKeyZnode, mnv.vchSig1, strMessage1, strError)) {
+            LogPrintf("ZnodeMan::ProcessVerifyBroadcast -- VerifyMessage() for znode1 failed, error: %s\n", strError);
+            return;
+        }
+
+        if(darkSendSigner.VerifyMessage(pmn2->pubKeyZnode, mnv.vchSig2, strMessage2, strError)) {
+            LogPrintf("ZnodeMan::ProcessVerifyBroadcast -- VerifyMessage() for znode2 failed, error: %s\n", strError);
+            return;
+        }
+
+        if(!pmn1->IsPoSeVerified()) {
+            pmn1->DecreasePoSeBanScore();
+        }
+        mnv.Relay();
+
+        LogPrintf("CZnodeMan::ProcessVerifyBroadcast -- verified znode %s for addr %s\n",
+                    pmn1->vin.prevout.ToStringShort(), pnode->addr.ToString());
+
+        // increase ban score for everyone else with the same addr
+        int nCount = 0;
+        BOOST_FOREACH(CZnode& mn, vZnodes) {
+            if(mn.addr != mnv.addr || mn.vin.prevout == mnv.vin1.prevout) continue;
+            mn.IncreasePoSeBanScore();
+            nCount++;
+            LogPrint("znode", "CZnodeMan::ProcessVerifyBroadcast -- increased PoSe ban score for %s addr %s, new score %d\n",
+                        mn.vin.prevout.ToStringShort(), mn.addr.ToString(), mn.nPoSeBanScore);
+        }
+        LogPrintf("CZnodeMan::ProcessVerifyBroadcast -- PoSe score incresed for %d fake znodes, addr %s\n",
+                    nCount, pnode->addr.ToString());
+    }
+}
+
+std::string CZnodeMan::ToString() const
+{
+    std::ostringstream info;
+
+    info << "Znodes: " << (int)vZnodes.size() <<
+            ", peers who asked us for Znode list: " << (int)mAskedUsForZnodeList.size() <<
+            ", peers we asked for Znode list: " << (int)mWeAskedForZnodeList.size() <<
+            ", entries in Znode list we asked for: " << (int)mWeAskedForZnodeListEntry.size() <<
+            ", znode index size: " << indexZnodes.GetSize() <<
+            ", nDsqCount: " << (int)nDsqCount;
+
+    return info.str();
+}
+
+void CZnodeMan::UpdateZnodeList(CZnodeBroadcast mnb)
+{
+    try {
+        LogPrintf("CZnodeMan::UpdateZnodeList\n");
+        LOCK2(cs_main, cs);
+        mapSeenZnodePing.insert(std::make_pair(mnb.lastPing.GetHash(), mnb.lastPing));
+        mapSeenZnodeBroadcast.insert(std::make_pair(mnb.GetHash(), std::make_pair(GetTime(), mnb)));
+
+        LogPrintf("CZnodeMan::UpdateZnodeList -- znode=%s  addr=%s\n", mnb.vin.prevout.ToStringShort(), mnb.addr.ToString());
+
+        CZnode *pmn = Find(mnb.vin);
+        if (pmn == NULL) {
+            CZnode mn(mnb);
+            if (Add(mn)) {
+                znodeSync.AddedZnodeList();
+            }
+        } else {
+            CZnodeBroadcast mnbOld = mapSeenZnodeBroadcast[CZnodeBroadcast(*pmn).GetHash()].second;
+            if (pmn->UpdateFromNewBroadcast(mnb)) {
+                znodeSync.AddedZnodeList();
+                mapSeenZnodeBroadcast.erase(mnbOld.GetHash());
+            }
+        }
+    } catch (const std::exception &e) {
+        LogPrintf("UpdateZnodeList\n");
+        PrintExceptionContinue(&e, "UpdateZnodeList");
+    }
+}
+
+bool CZnodeMan::CheckMnbAndUpdateZnodeList(CNode* pfrom, CZnodeBroadcast mnb, int& nDos)
+{
+    // Need LOCK2 here to ensure consistent locking order because the SimpleCheck call below locks cs_main
+    LOCK(cs_main);
+
+    {
+        LOCK(cs);
+        nDos = 0;
+        LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- znode=%s\n", mnb.vin.prevout.ToStringShort());
+
+        uint256 hash = mnb.GetHash();
+        if (mapSeenZnodeBroadcast.count(hash) && !mnb.fRecovery) { //seen
+            LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- znode=%s seen\n", mnb.vin.prevout.ToStringShort());
+            // less then 2 pings left before this MN goes into non-recoverable state, bump sync timeout
+            if (GetTime() - mapSeenZnodeBroadcast[hash].first > ZNODE_NEW_START_REQUIRED_SECONDS - ZNODE_MIN_MNP_SECONDS * 2) {
+                LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- znode=%s seen update\n", mnb.vin.prevout.ToStringShort());
+                mapSeenZnodeBroadcast[hash].first = GetTime();
+                znodeSync.AddedZnodeList();
+            }
+            // did we ask this node for it?
+            if (pfrom && IsMnbRecoveryRequested(hash) && GetTime() < mMnbRecoveryRequests[hash].first) {
+                LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- mnb=%s seen request\n", hash.ToString());
+                if (mMnbRecoveryRequests[hash].second.count(pfrom->addr)) {
+                    LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- mnb=%s seen request, addr=%s\n", hash.ToString(), pfrom->addr.ToString());
+                    // do not allow node to send same mnb multiple times in recovery mode
+                    mMnbRecoveryRequests[hash].second.erase(pfrom->addr);
+                    // does it have newer lastPing?
+                    if (mnb.lastPing.sigTime > mapSeenZnodeBroadcast[hash].second.lastPing.sigTime) {
+                        // simulate Check
+                        CZnode mnTemp = CZnode(mnb);
+                        mnTemp.Check();
+                        LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- mnb=%s seen request, addr=%s, better lastPing: %d min ago, projected mn state: %s\n", hash.ToString(), pfrom->addr.ToString(), (GetTime() - mnb.lastPing.sigTime) / 60, mnTemp.GetStateString());
+                        if (mnTemp.IsValidStateForAutoStart(mnTemp.nActiveState)) {
+                            // this node thinks it's a good one
+                            LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- znode=%s seen good\n", mnb.vin.prevout.ToStringShort());
+                            mMnbRecoveryGoodReplies[hash].push_back(mnb);
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        mapSeenZnodeBroadcast.insert(std::make_pair(hash, std::make_pair(GetTime(), mnb)));
+
+        LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- znode=%s new\n", mnb.vin.prevout.ToStringShort());
+
+        if (!mnb.SimpleCheck(nDos)) {
+            LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- SimpleCheck() failed, znode=%s\n", mnb.vin.prevout.ToStringShort());
+            return false;
+        }
+
+        // search Znode list
+        CZnode *pmn = Find(mnb.vin);
+        if (pmn) {
+            CZnodeBroadcast mnbOld = mapSeenZnodeBroadcast[CZnodeBroadcast(*pmn).GetHash()].second;
+            if (!mnb.Update(pmn, nDos)) {
+                LogPrint("znode", "CZnodeMan::CheckMnbAndUpdateZnodeList -- Update() failed, znode=%s\n", mnb.vin.prevout.ToStringShort());
+                return false;
+            }
+            if (hash != mnbOld.GetHash()) {
+                mapSeenZnodeBroadcast.erase(mnbOld.GetHash());
+            }
+        }
+    } // end of LOCK(cs);
+
+    if(mnb.CheckOutpoint(nDos)) {
+        Add(mnb);
+        znodeSync.AddedZnodeList();
+        // if it matches our Znode privkey...
+        if(fZNode && mnb.pubKeyZnode == activeZnode.pubKeyZnode) {
+            mnb.nPoSeBanScore = -ZNODE_POSE_BAN_MAX_SCORE;
+            if(mnb.nProtocolVersion == PROTOCOL_VERSION) {
+                // ... and PROTOCOL_VERSION, then we've been remotely activated ...
+                LogPrintf("CZnodeMan::CheckMnbAndUpdateZnodeList -- Got NEW Znode entry: znode=%s  sigTime=%lld  addr=%s\n",
+                            mnb.vin.prevout.ToStringShort(), mnb.sigTime, mnb.addr.ToString());
+                activeZnode.ManageState();
+            } else {
+                // ... otherwise we need to reactivate our node, do not add it to the list and do not relay
+                // but also do not ban the node we get this message from
+                LogPrintf("CZnodeMan::CheckMnbAndUpdateZnodeList -- wrong PROTOCOL_VERSION, re-activate your MN: message nProtocolVersion=%d  PROTOCOL_VERSION=%d\n", mnb.nProtocolVersion, PROTOCOL_VERSION);
+                return false;
+            }
+        }
+        mnb.RelayZNode();
+    } else {
+        LogPrintf("CZnodeMan::CheckMnbAndUpdateZnodeList -- Rejected Znode entry: %s  addr=%s\n", mnb.vin.prevout.ToStringShort(), mnb.addr.ToString());
+        return false;
+    }
+
+    return true;
+}
+
+void CZnodeMan::UpdateLastPaid()
+{
+    LOCK(cs);
+    if(fLiteMode) return;
+    if(!pCurrentBlockIndex) {
+        LogPrintf("CZnodeMan::UpdateLastPaid, pCurrentBlockIndex=NULL\n");
+        return;
+    }
+    LogPrintf("CZnodeMan::UpdateLastPaid,pCurrentBlockIndex->nHeight=%s\n", pCurrentBlockIndex->nHeight);
+
+    static bool IsFirstRun = true;
+    // Do full scan on first run or if we are not a znode
+    // (MNs should update this info on every block, so limited scan should be enough for them)
+    int nMaxBlocksToScanBack = (IsFirstRun || !fZNode) ? mnpayments.GetStorageLimit() : LAST_PAID_SCAN_BLOCKS;
+
+    LogPrint("mnpayments", "CZnodeMan::UpdateLastPaid -- nHeight=%d, nMaxBlocksToScanBack=%d, IsFirstRun=%s\n",
+                             pCurrentBlockIndex->nHeight, nMaxBlocksToScanBack, IsFirstRun ? "true" : "false");
+
+    BOOST_FOREACH(CZnode& mn, vZnodes) {
+        mn.UpdateLastPaid(pCurrentBlockIndex, nMaxBlocksToScanBack);
+    }
+
+    // every time is like the first time if winners list is not synced
+    IsFirstRun = !znodeSync.IsWinnersListSynced();
+}
+
+void CZnodeMan::CheckAndRebuildZnodeIndex()
+{
+    LOCK(cs);
+
+    if(GetTime() - nLastIndexRebuildTime < MIN_INDEX_REBUILD_TIME) {
+        return;
+    }
+
+    if(indexZnodes.GetSize() <= MAX_EXPECTED_INDEX_SIZE) {
+        return;
+    }
+
+    if(indexZnodes.GetSize() <= int(vZnodes.size())) {
+        return;
+    }
+
+    indexZnodesOld = indexZnodes;
+    indexZnodes.Clear();
+    for(size_t i = 0; i < vZnodes.size(); ++i) {
+        indexZnodes.AddZnodeVIN(vZnodes[i].vin);
+    }
+
+    fIndexRebuilt = true;
+    nLastIndexRebuildTime = GetTime();
+}
+
+void CZnodeMan::UpdateWatchdogVoteTime(const CTxIn& vin)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    if(!pMN)  {
+        return;
+    }
+    pMN->UpdateWatchdogVoteTime();
+    nLastWatchdogVoteTime = GetTime();
+}
+
+bool CZnodeMan::IsWatchdogActive()
+{
+    LOCK(cs);
+    // Check if any znodes have voted recently, otherwise return false
+    return (GetTime() - nLastWatchdogVoteTime) <= ZNODE_WATCHDOG_MAX_SECONDS;
+}
+
+//bool CZnodeMan::AddGovernanceVote(const CTxIn& vin, uint256 nGovernanceObjectHash)
+//{
+//    LOCK(cs);
+//    CZnode* pMN = Find(vin);
+//    if(!pMN)  {
+//        return false;
+//    }
+//    pMN->AddGovernanceVote(nGovernanceObjectHash);
+//    return true;
+//}
+
+//void CZnodeMan::RemoveGovernanceObject(uint256 nGovernanceObjectHash)
+//{
+//    LOCK(cs);
+//    BOOST_FOREACH(CZnode& mn, vZnodes) {
+//        mn.RemoveGovernanceObject(nGovernanceObjectHash);
+//    }
+//}
+
+void CZnodeMan::CheckZnode(const CTxIn& vin, bool fForce)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    if(!pMN)  {
+        return;
+    }
+    pMN->Check(fForce);
+}
+
+void CZnodeMan::CheckZnode(const CPubKey& pubKeyZnode, bool fForce)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(pubKeyZnode);
+    if(!pMN)  {
+        return;
+    }
+    pMN->Check(fForce);
+}
+
+int CZnodeMan::GetZnodeState(const CTxIn& vin)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    if(!pMN)  {
+        return CZnode::ZNODE_NEW_START_REQUIRED;
+    }
+    return pMN->nActiveState;
+}
+
+int CZnodeMan::GetZnodeState(const CPubKey& pubKeyZnode)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(pubKeyZnode);
+    if(!pMN)  {
+        return CZnode::ZNODE_NEW_START_REQUIRED;
+    }
+    return pMN->nActiveState;
+}
+
+bool CZnodeMan::IsZnodePingedWithin(const CTxIn& vin, int nSeconds, int64_t nTimeToCheckAt)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    if(!pMN) {
+        return false;
+    }
+    return pMN->IsPingedWithin(nSeconds, nTimeToCheckAt);
+}
+
+void CZnodeMan::SetZnodeLastPing(const CTxIn& vin, const CZnodePing& mnp)
+{
+    LOCK(cs);
+    CZnode* pMN = Find(vin);
+    if(!pMN)  {
+        return;
+    }
+    pMN->lastPing = mnp;
+    mapSeenZnodePing.insert(std::make_pair(mnp.GetHash(), mnp));
+
+    CZnodeBroadcast mnb(*pMN);
+    uint256 hash = mnb.GetHash();
+    if(mapSeenZnodeBroadcast.count(hash)) {
+        mapSeenZnodeBroadcast[hash].second.lastPing = mnp;
+    }
+}
+
+void CZnodeMan::UpdatedBlockTip(const CBlockIndex *pindex)
+{
+    pCurrentBlockIndex = pindex;
+    LogPrint("znode", "CZnodeMan::UpdatedBlockTip -- pCurrentBlockIndex->nHeight=%d\n", pCurrentBlockIndex->nHeight);
+
+    CheckSameAddr();
+
+    if(fZNode) {
+        // normal wallet does not need to update this every block, doing update on rpc call should be enough
+        UpdateLastPaid();
+    }
+}
+
+void CZnodeMan::NotifyZnodeUpdates()
+{
+    // Avoid double locking
+    bool fZnodesAddedLocal = false;
+    bool fZnodesRemovedLocal = false;
+    {
+        LOCK(cs);
+        fZnodesAddedLocal = fZnodesAdded;
+        fZnodesRemovedLocal = fZnodesRemoved;
+    }
+
+    if(fZnodesAddedLocal) {
+//        governance.CheckZnodeOrphanObjects();
+//        governance.CheckZnodeOrphanVotes();
+    }
+    if(fZnodesRemovedLocal) {
+//        governance.UpdateCachesAndClean();
+    }
+
+    LOCK(cs);
+    fZnodesAdded = false;
+    fZnodesRemoved = false;
+}
diff --git a/src/znodeman.h b/src/znodeman.h
new file mode 100644
index 0000000000..a62fa2a6a4
--- /dev/null
+++ b/src/znodeman.h
@@ -0,0 +1,366 @@
+// Copyright (c) 2014-2017 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef ZNODEMAN_H
+#define ZNODEMAN_H
+
+#include "znode.h"
+#include "sync.h"
+
+using namespace std;
+
+class CZnodeMan;
+
+extern CZnodeMan mnodeman;
+
+/**
+ * Provides a forward and reverse index between MN vin's and integers.
+ *
+ * This mapping is normally add-only and is expected to be permanent
+ * It is only rebuilt if the size of the index exceeds the expected maximum number
+ * of MN's and the current number of known MN's.
+ *
+ * The external interface to this index is provided via delegation by CZnodeMan
+ */
+class CZnodeIndex
+{
+public: // Types
+    typedef std::map<CTxIn,int> index_m_t;
+
+    typedef index_m_t::iterator index_m_it;
+
+    typedef index_m_t::const_iterator index_m_cit;
+
+    typedef std::map<int,CTxIn> rindex_m_t;
+
+    typedef rindex_m_t::iterator rindex_m_it;
+
+    typedef rindex_m_t::const_iterator rindex_m_cit;
+
+private:
+    int                  nSize;
+
+    index_m_t            mapIndex;
+
+    rindex_m_t           mapReverseIndex;
+
+public:
+    CZnodeIndex();
+
+    int GetSize() const {
+        return nSize;
+    }
+
+    /// Retrieve znode vin by index
+    bool Get(int nIndex, CTxIn& vinZnode) const;
+
+    /// Get index of a znode vin
+    int GetZnodeIndex(const CTxIn& vinZnode) const;
+
+    void AddZnodeVIN(const CTxIn& vinZnode);
+
+    void Clear();
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
+    {
+        READWRITE(mapIndex);
+        if(ser_action.ForRead()) {
+            RebuildIndex();
+        }
+    }
+
+private:
+    void RebuildIndex();
+
+};
+
+class CZnodeMan
+{
+public:
+    typedef std::map<CTxIn,int> index_m_t;
+
+    typedef index_m_t::iterator index_m_it;
+
+    typedef index_m_t::const_iterator index_m_cit;
+
+private:
+    static const int MAX_EXPECTED_INDEX_SIZE = 30000;
+
+    /// Only allow 1 index rebuild per hour
+    static const int64_t MIN_INDEX_REBUILD_TIME = 3600;
+
+    static const std::string SERIALIZATION_VERSION_STRING;
+
+    static const int DSEG_UPDATE_SECONDS        = 3 * 60 * 60;
+
+    static const int LAST_PAID_SCAN_BLOCKS      = 100;
+
+    static const int MIN_POSE_PROTO_VERSION     = 70203;
+    static const int MAX_POSE_CONNECTIONS       = 10;
+    static const int MAX_POSE_RANK              = 10;
+    static const int MAX_POSE_BLOCKS            = 10;
+
+    static const int MNB_RECOVERY_QUORUM_TOTAL      = 10;
+    static const int MNB_RECOVERY_QUORUM_REQUIRED   = 6;
+    static const int MNB_RECOVERY_MAX_ASK_ENTRIES   = 10;
+    static const int MNB_RECOVERY_WAIT_SECONDS      = 60;
+    static const int MNB_RECOVERY_RETRY_SECONDS     = 3 * 60 * 60;
+
+
+    // critical section to protect the inner data structures
+    mutable CCriticalSection cs;
+
+    // Keep track of current block index
+    const CBlockIndex *pCurrentBlockIndex;
+
+    // map to hold all MNs
+    std::vector<CZnode> vZnodes;
+    // who's asked for the Znode list and the last time
+    std::map<CNetAddr, int64_t> mAskedUsForZnodeList;
+    // who we asked for the Znode list and the last time
+    std::map<CNetAddr, int64_t> mWeAskedForZnodeList;
+    // which Znodes we've asked for
+    std::map<COutPoint, std::map<CNetAddr, int64_t> > mWeAskedForZnodeListEntry;
+    // who we asked for the znode verification
+    std::map<CNetAddr, CZnodeVerification> mWeAskedForVerification;
+
+    // these maps are used for znode recovery from ZNODE_NEW_START_REQUIRED state
+    std::map<uint256, std::pair< int64_t, std::set<CNetAddr> > > mMnbRecoveryRequests;
+    std::map<uint256, std::vector<CZnodeBroadcast> > mMnbRecoveryGoodReplies;
+    std::list< std::pair<CService, uint256> > listScheduledMnbRequestConnections;
+
+    int64_t nLastIndexRebuildTime;
+
+    CZnodeIndex indexZnodes;
+
+    CZnodeIndex indexZnodesOld;
+
+    /// Set when index has been rebuilt, clear when read
+    bool fIndexRebuilt;
+
+    /// Set when znodes are added, cleared when CGovernanceManager is notified
+    bool fZnodesAdded;
+
+    /// Set when znodes are removed, cleared when CGovernanceManager is notified
+    bool fZnodesRemoved;
+
+    std::vector<uint256> vecDirtyGovernanceObjectHashes;
+
+    int64_t nLastWatchdogVoteTime;
+
+    friend class CZnodeSync;
+
+public:
+    // Keep track of all broadcasts I've seen
+    std::map<uint256, std::pair<int64_t, CZnodeBroadcast> > mapSeenZnodeBroadcast;
+    // Keep track of all pings I've seen
+    std::map<uint256, CZnodePing> mapSeenZnodePing;
+    // Keep track of all verifications I've seen
+    std::map<uint256, CZnodeVerification> mapSeenZnodeVerification;
+    // keep track of dsq count to prevent znodes from gaming darksend queue
+    int64_t nDsqCount;
+
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        LOCK(cs);
+        std::string strVersion;
+        if(ser_action.ForRead()) {
+            READWRITE(strVersion);
+        }
+        else {
+            strVersion = SERIALIZATION_VERSION_STRING; 
+            READWRITE(strVersion);
+        }
+
+        READWRITE(vZnodes);
+        READWRITE(mAskedUsForZnodeList);
+        READWRITE(mWeAskedForZnodeList);
+        READWRITE(mWeAskedForZnodeListEntry);
+        READWRITE(mMnbRecoveryRequests);
+        READWRITE(mMnbRecoveryGoodReplies);
+        READWRITE(nLastWatchdogVoteTime);
+        READWRITE(nDsqCount);
+
+        READWRITE(mapSeenZnodeBroadcast);
+        READWRITE(mapSeenZnodePing);
+        READWRITE(indexZnodes);
+        if(ser_action.ForRead() && (strVersion != SERIALIZATION_VERSION_STRING)) {
+            Clear();
+        }
+    }
+
+    CZnodeMan();
+
+    /// Add an entry
+    bool Add(CZnode &mn);
+
+    /// Ask (source) node for mnb
+    void AskForMN(CNode *pnode, const CTxIn &vin);
+    void AskForMnb(CNode *pnode, const uint256 &hash);
+
+    /// Check all Znodes
+    void Check();
+
+    /// Check all Znodes and remove inactive
+    void CheckAndRemove();
+
+    /// Clear Znode vector
+    void Clear();
+
+    /// Count Znodes filtered by nProtocolVersion.
+    /// Znode nProtocolVersion should match or be above the one specified in param here.
+    int CountZnodes(int nProtocolVersion = -1);
+    /// Count enabled Znodes filtered by nProtocolVersion.
+    /// Znode nProtocolVersion should match or be above the one specified in param here.
+    int CountEnabled(int nProtocolVersion = -1);
+
+    /// Count Znodes by network type - NET_IPV4, NET_IPV6, NET_TOR
+    // int CountByIP(int nNetworkType);
+
+    void DsegUpdate(CNode* pnode);
+
+    /// Find an entry
+    CZnode* Find(const CScript &payee);
+    CZnode* Find(const CTxIn& vin);
+    CZnode* Find(const CPubKey& pubKeyZnode);
+
+    /// Versions of Find that are safe to use from outside the class
+    bool Get(const CPubKey& pubKeyZnode, CZnode& znode);
+    bool Get(const CTxIn& vin, CZnode& znode);
+
+    /// Retrieve znode vin by index
+    bool Get(int nIndex, CTxIn& vinZnode, bool& fIndexRebuiltOut) {
+        LOCK(cs);
+        fIndexRebuiltOut = fIndexRebuilt;
+        return indexZnodes.Get(nIndex, vinZnode);
+    }
+
+    bool GetIndexRebuiltFlag() {
+        LOCK(cs);
+        return fIndexRebuilt;
+    }
+
+    /// Get index of a znode vin
+    int GetZnodeIndex(const CTxIn& vinZnode) {
+        LOCK(cs);
+        return indexZnodes.GetZnodeIndex(vinZnode);
+    }
+
+    /// Get old index of a znode vin
+    int GetZnodeIndexOld(const CTxIn& vinZnode) {
+        LOCK(cs);
+        return indexZnodesOld.GetZnodeIndex(vinZnode);
+    }
+
+    /// Get znode VIN for an old index value
+    bool GetZnodeVinForIndexOld(int nZnodeIndex, CTxIn& vinZnodeOut) {
+        LOCK(cs);
+        return indexZnodesOld.Get(nZnodeIndex, vinZnodeOut);
+    }
+
+    /// Get index of a znode vin, returning rebuild flag
+    int GetZnodeIndex(const CTxIn& vinZnode, bool& fIndexRebuiltOut) {
+        LOCK(cs);
+        fIndexRebuiltOut = fIndexRebuilt;
+        return indexZnodes.GetZnodeIndex(vinZnode);
+    }
+
+    void ClearOldZnodeIndex() {
+        LOCK(cs);
+        indexZnodesOld.Clear();
+        fIndexRebuilt = false;
+    }
+
+    bool Has(const CTxIn& vin);
+
+    znode_info_t GetZnodeInfo(const CTxIn& vin);
+
+    znode_info_t GetZnodeInfo(const CPubKey& pubKeyZnode);
+
+    /// Find an entry in the znode list that is next to be paid
+    CZnode* GetNextZnodeInQueueForPayment(int nBlockHeight, bool fFilterSigTime, int& nCount);
+    /// Same as above but use current block height
+    CZnode* GetNextZnodeInQueueForPayment(bool fFilterSigTime, int& nCount);
+
+    /// Find a random entry
+    CZnode* FindRandomNotInVec(const std::vector<CTxIn> &vecToExclude, int nProtocolVersion = -1);
+
+    std::vector<CZnode> GetFullZnodeVector() { return vZnodes; }
+
+    std::vector<std::pair<int, CZnode> > GetZnodeRanks(int nBlockHeight = -1, int nMinProtocol=0);
+    int GetZnodeRank(const CTxIn &vin, int nBlockHeight, int nMinProtocol=0, bool fOnlyActive=true);
+    CZnode* GetZnodeByRank(int nRank, int nBlockHeight, int nMinProtocol=0, bool fOnlyActive=true);
+
+    void ProcessZnodeConnections();
+    std::pair<CService, std::set<uint256> > PopScheduledMnbRequestConnection();
+
+    void ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
+
+    void DoFullVerificationStep();
+    void CheckSameAddr();
+    bool SendVerifyRequest(const CAddress& addr, const std::vector<CZnode*>& vSortedByAddr);
+    void SendVerifyReply(CNode* pnode, CZnodeVerification& mnv);
+    void ProcessVerifyReply(CNode* pnode, CZnodeVerification& mnv);
+    void ProcessVerifyBroadcast(CNode* pnode, const CZnodeVerification& mnv);
+
+    /// Return the number of (unique) Znodes
+    int size() { return vZnodes.size(); }
+
+    std::string ToString() const;
+
+    /// Update znode list and maps using provided CZnodeBroadcast
+    void UpdateZnodeList(CZnodeBroadcast mnb);
+    /// Perform complete check and only then update list and maps
+    bool CheckMnbAndUpdateZnodeList(CNode* pfrom, CZnodeBroadcast mnb, int& nDos);
+    bool IsMnbRecoveryRequested(const uint256& hash) { return mMnbRecoveryRequests.count(hash); }
+
+    void UpdateLastPaid();
+
+    void CheckAndRebuildZnodeIndex();
+
+    void AddDirtyGovernanceObjectHash(const uint256& nHash)
+    {
+        LOCK(cs);
+        vecDirtyGovernanceObjectHashes.push_back(nHash);
+    }
+
+    std::vector<uint256> GetAndClearDirtyGovernanceObjectHashes()
+    {
+        LOCK(cs);
+        std::vector<uint256> vecTmp = vecDirtyGovernanceObjectHashes;
+        vecDirtyGovernanceObjectHashes.clear();
+        return vecTmp;;
+    }
+
+    bool IsWatchdogActive();
+    void UpdateWatchdogVoteTime(const CTxIn& vin);
+    bool AddGovernanceVote(const CTxIn& vin, uint256 nGovernanceObjectHash);
+    void RemoveGovernanceObject(uint256 nGovernanceObjectHash);
+
+    void CheckZnode(const CTxIn& vin, bool fForce = false);
+    void CheckZnode(const CPubKey& pubKeyZnode, bool fForce = false);
+
+    int GetZnodeState(const CTxIn& vin);
+    int GetZnodeState(const CPubKey& pubKeyZnode);
+
+    bool IsZnodePingedWithin(const CTxIn& vin, int nSeconds, int64_t nTimeToCheckAt = -1);
+    void SetZnodeLastPing(const CTxIn& vin, const CZnodePing& mnp);
+
+    void UpdatedBlockTip(const CBlockIndex *pindex);
+
+    /**
+     * Called to notify CGovernanceManager that the znode index has been updated.
+     * Must be called while not holding the CZnodeMan::cs mutex
+     */
+    void NotifyZnodeUpdates();
+
+};
+
+#endif