Merge remote-tracking branch 'upstream/core14' into core14-bls

qa/rpc-tests/test_framework/test_framework.py

@@ -322,27 +322,33 @@ class ZnodeTestFramework(BitcoinTestFramework):
     def __init__(self):
         super().__init__()
         self.znode_priv_keys = dict()
+        self.num_nodes = 4
+        self.num_znodes = 3
 
     def setup_chain(self):
         print("Initializing test directory "+self.options.tmpdir)
         self.setup_clean_chain = True
         super().setup_chain()
 
-    def write_master_znode_conf(self, znode, priv_key, collateral_tx_id, collateral_n, master_node=None):
-        if master_node is None:
-            master_node = 0
+    def setup_network(self, split=False):
+        super().setup_network(split)
+        for i in range(self.num_nodes):
+            for j in range(i, self.num_nodes):
+                connect_nodes_bi(self.nodes, i, j)
 
-        znode_conf = " ".join(["zn"+str(znode), "127.0.0.1:"+str(p2p_port(znode)), priv_key, collateral_tx_id, str(collateral_n)])
+    def write_master_znode_conf(self, znode, collateral):
+        znode_service = get_znode_service(znode)
+        znode_conf = " ".join(["zn"+str(znode), znode_service, self.znode_priv_keys[znode], collateral.tx_id, str(collateral.n)])
 
-        master_node_conf_filename = os.path.join(self.options.tmpdir, "node" + str(master_node), "regtest", "znode.conf")
+        master_node_conf_filename = os.path.join(self.options.tmpdir, "node" + str(znode), "regtest", "znode.conf")
         with open(master_node_conf_filename, "a") as master_node_conf:
             master_node_conf.write(znode_conf)
             master_node_conf.write("\n")
             master_node_conf.close()
 
     def generate_znode_collateral(self, generator_node=None):
         if generator_node is None:
-            generator_node = 0
+            generator_node = self.num_nodes - 1
         curr_balance = self.nodes[generator_node].getbalance()
         while curr_balance < ZNODE_COLLATERAL:
             self.nodes[generator_node].generate(int((ZNODE_COLLATERAL - curr_balance) / 25))
@@ -351,39 +357,41 @@ def generate_znode_collateral(self, generator_node=None):
 
     def send_znode_collateral(self, znode, collateral_provider=None):
         if collateral_provider is None:
-            collateral_provider = 0
+            collateral_provider = self.num_nodes - 1
         znode_address = self.nodes[znode].getaccountaddress("Znode")
         tx_id = self.nodes[collateral_provider].sendtoaddress(znode_address, ZNODE_COLLATERAL)
         tx_text = self.nodes[collateral_provider].getrawtransaction(tx_id, 1)
         collateral = ZnodeCollateral()
         return collateral.parse_collateral_output(znode_address, tx_text, tx_id)
 
     def send_mature_znode_collateral(self, znode, collateral_provider=None):
+        if collateral_provider is None:
+            collateral_provider = self.num_nodes - 1
         result = self.send_znode_collateral(znode, collateral_provider)
-        self.nodes[0].generate(10)
+        self.nodes[collateral_provider].generate(10)
         sync_blocks(self.nodes)
         time.sleep(3)
         return result
 
     def configure_znode(self, znode, master_znode=None):
         if master_znode is None:
-            master_znode = 0
+            master_znode = self.num_nodes - 1
         self.znode_priv_keys[znode] = self.nodes[znode].znode("genkey")
         stop_node(self.nodes[znode], znode)
-        self.nodes[znode] = start_node(znode, self.options.tmpdir, ["-znode", "-znodeprivkey="+self.znode_priv_keys[znode], "-externalip=127.0.0.1:"+str(p2p_port(znode)), "-listen"])
+        znode_service = get_znode_service(znode)
+        self.nodes[znode] = start_node(znode, self.options.tmpdir, ["-znode", "-znodeprivkey="+self.znode_priv_keys[znode], "-externalip="+znode_service, "-listen"])
         connect_nodes(self.nodes[znode], znode)
         for i in range(self.num_nodes):
             if i != znode:
                 connect_nodes_bi(self.nodes, i, znode)
 
-    def generate_znode_privkey(self, znode, master_znode=None):
-        if master_znode is None:
-            master_znode = 0
+    def generate_znode_privkey(self, znode):
         self.znode_priv_keys[znode] = self.nodes[znode].znode("genkey")
 
     def restart_as_znode(self, znode):
         stop_node(self.nodes[znode], znode)
-        self.nodes[znode] = start_node(znode, self.options.tmpdir, ["-znode", "-znodeprivkey="+self.znode_priv_keys[znode], "-externalip=127.0.0.1:"+str(p2p_port(znode)), "-listen"])
+        znode_service = get_znode_service(znode)
+        self.nodes[znode] = start_node(znode, self.options.tmpdir, ["-znode", "-znodeprivkey="+self.znode_priv_keys[znode], "-externalip="+znode_service, "-listen"])
         connect_nodes(self.nodes[znode], znode)
         for i in range(self.num_nodes):
             if i != znode:
@@ -398,11 +406,28 @@ def configure_znode(self, znode, master_znode=None ):
         self.generate_znode_privkey(znode, master_znode)
         self.restart_as_znode(znode)
 
-    def wait_znode_enabled(self, znode_to_wait_on, enabled_znode_number = 1, timeout = 10):
+    def wait_znode_enabled(self, enabled_znode_number, znode_to_wait_on = None, timeout = 10):
+        if znode_to_wait_on is None:
+            znode_to_wait_on = self.num_nodes - 1
         wait_to_sync_znodes(self.nodes[znode_to_wait_on])
         for j in range (timeout):
             if self.nodes[znode_to_wait_on].znode("count", "enabled") == enabled_znode_number:
                 return
             print(self.nodes[znode_to_wait_on].znode("count", "all"))
             time.sleep(1)
         raise Exception("Cannot wait until znodes enabled")
+
+    def generate(self, blocks, generator_node=None):
+        if generator_node is None:
+            generator_node = self.num_nodes - 1
+        for b in range(blocks):
+            self.nodes[generator_node].generate(1)
+            sync_blocks(self.nodes)
+            time.sleep(3)
+
+
+def get_znode_service(znode):
+    znode_ip_str = "127.0.1." + str(znode + 1)
+    znode_port_str = str(p2p_port(znode))
+    return znode_ip_str + ":" + znode_port_str
+

qa/rpc-tests/test_framework/util.py

@@ -765,3 +765,8 @@ def wait_to_sync_znodes(node, fast_znsync=False):
         if fast_znsync:
             # skip mnsync states
             node.znsync("next")
+
+def get_full_balance(node):
+    wallet_info = node.getwalletinfo()
+    return wallet_info["balance"] + wallet_info["immature_balance"] + wallet_info["unconfirmed_balance"]
+

qa/rpc-tests/znode_check_payments.py

@@ -6,33 +6,55 @@
 from test_framework.util import *
 
 # Description: a very straightforward check of Znode operability
-# 1. start Znodes
-# 2. mine blocks
-# 3. check znode reward
+# 1. Start several nodes
+# 2. Mine blocks and check the reward comes to the proper nodes
+
 class ZnodeCheckPayments(ZnodeTestFramework):
     def __init__(self):
         super().__init__()
-        self.num_nodes = 4
+        self.num_nodes = 5
+        self.num_znodes = 3
         self.setup_clean_chain = True
 
     def run_test(self):
+
+        for zn in range(self.num_znodes):
+            self.generate_znode_collateral()
+            collateral = self.send_mature_znode_collateral(zn)
+
+            self.generate_znode_privkey(zn)
+            self.write_master_znode_conf(zn, collateral)
+
         self.generate_znode_collateral()
-        sync_blocks(self.nodes)
+        collateral3 = self.send_mature_znode_collateral(3)
+
+        for zn in range(self.num_znodes):
+            self.restart_as_znode(zn)
+            self.znode_start(zn)
+
+        self.wait_znode_enabled(self.num_znodes)
+
+        self.generate(5 + 3*6)
+
+        for zn in range(self.num_znodes):
+            assert_equal(1000 + 4*15, get_full_balance(self.nodes[zn]))
+
+# New Znode
+        self.generate_znode_privkey(3)
+        self.write_master_znode_conf(3, collateral3)
 
-        collateral = self.send_mature_znode_collateral(1)
+        self.restart_as_znode(3)
+        self.znode_start(3)
 
-        self.generate_znode_privkey(1, 1)
-        self.write_master_znode_conf(1, self.znode_priv_keys[1], collateral.tx_id, collateral.n, 1)
-        self.restart_as_znode(1)
+        self.wait_znode_enabled(4)
 
-        self.znode_start(1)
+        self.generate(6)
 
-        self.wait_znode_enabled(0)
+        for zn in range(self.num_znodes):
+            assert_equal(1000 + 5*15, get_full_balance(self.nodes[zn]))
 
-        self.nodes[0].generate(1)
-        sync_blocks(self.nodes)
+        assert_equal(1000 + 15, get_full_balance(self.nodes[3]))
 
-        assert_equal(15, self.nodes[1].getwalletinfo()["immature_balance"])
 
 if __name__ == '__main__':
     ZnodeCheckPayments().main()

src/darksend.cpp

@@ -16,9 +16,12 @@
 #include "txmempool.h"
 #include "util.h"
 #include "utilmoneystr.h"
+#include "netmessagemaker.h"
 
 #include <boost/lexical_cast.hpp>
 
+#define cs_vNodes (g_connman->cs_vNodes)
+
 int nPrivateSendRounds = DEFAULT_PRIVATESEND_ROUNDS;
 int nPrivateSendAmount = DEFAULT_PRIVATESEND_AMOUNT;
 int nLiquidityProvider = DEFAULT_PRIVATESEND_LIQUIDITY;
@@ -283,8 +286,6 @@ bool CDarksendPool::IsInputScriptSigValid(const CTxIn &txin) {
 bool CDarksendPool::IsCollateralValid(const CTransaction &txCollateral) {
     return true;
 }
-
-
 //
 // Add a clients transaction to the pool
 //
@@ -553,6 +554,15 @@ std::string CDarksendPool::GetMessageByID(PoolMessage nMessageID) {
 }
 
 bool CDarkSendSigner::IsVinAssociatedWithPubkey(const CTxIn &txin, const CPubKey &pubkey) {
+    CScript payee;
+    payee = GetScriptForDestination(pubkey.GetID());
+
+    CTransactionRef 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;
 }
 

src/net_processing.cpp

@@ -3584,6 +3584,28 @@ bool SendMessages(CNode* pto, CConnman& connman, const std::atomic<bool>& interr
                 }
             }
         }
+
+        // vInventoryToSend from dash
+        vector<CInv> vInvWait;
+        {
+            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);
+
+                LogPrint("net", "SendMessages -- queued inv: %s  index=%d peer=%d\n", inv.ToString(), vInv.size(), pto->id);
+                vInv.push_back(inv);
+                if (vInv.size() >= 1000)
+                {
+                    LogPrint("net", "SendMessages -- pushing inv's: count=%d peer=%d\n", vInv.size(), pto->id);
+                    connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
+                    vInv.clear();
+                }
+            }
+            pto->vInventoryToSend = vInvWait;
+        }
 
         if (!vInv.empty())
             connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));

src/wallet/wallet.cpp

@@ -2937,13 +2937,18 @@ void CWallet::AvailableCoins(vector <COutput> &vCoins, bool fOnlyConfirmed, cons
                 if (!found) continue;
 
                 isminetype mine = IsMine(pcoin->tx->vout[i]);
+
+
                 if (!(IsSpent(wtxid, i)) && mine != ISMINE_NO &&
-                    !IsLockedCoin((*it).first, i) && (pcoin->tx->vout[i].nValue > 0 || fIncludeZeroValue) &&
-                    (!coinControl || !coinControl->HasSelected() || coinControl->fAllowOtherInputs || coinControl->IsSelected(COutPoint((*it).first, i))))
+                    (!IsLockedCoin((*it).first, i) || nCoinType == ONLY_1000) &&
+                    (pcoin->tx->vout[i].nValue > 0 || fIncludeZeroValue) &&
+                    (!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));            }
+                                                 (mine & (ISMINE_SPENDABLE | ISMINE_WATCH_SOLVABLE)) != ISMINE_NO));
+                }
+            }
         }
     }
 }

src/znode.cpp

@@ -14,6 +14,7 @@
 #include "darksend.h"
 #include "util.h"
 #include "net.h"
+#include "netbase.h"
 
 #include <boost/lexical_cast.hpp>
 
@@ -474,8 +475,8 @@ bool CZnodeBroadcast::Create(std::string strService, std::string strKeyZnode, st
     }
 
     // TODO: upgrade dash
-    /*
-    CService service = CService(strService);
+
+    CService service = LookupNumeric(strService.c_str());
     int mainnetDefaultPort = Params(CBaseChainParams::MAIN).GetDefaultPort();
     if (Params().NetworkIDString() == CBaseChainParams::MAIN) {
         if (service.GetPort() != mainnetDefaultPort) {
@@ -489,9 +490,7 @@ bool CZnodeBroadcast::Create(std::string strService, std::string strKeyZnode, st
         return false;
     }
 
-    return Create(txin, CService(strService), keyCollateralAddressNew, pubKeyCollateralAddressNew, keyZnodeNew, pubKeyZnodeNew, strErrorRet, mnbRet);*/
-
-    return false;
+    return Create(txin, LookupNumeric(strService.c_str()), 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) {