Merge pull request #413 from craigmacgregor/v452

v452 Hard Fork

Author: proletesseract

configure.ac

@@ -2,7 +2,7 @@ dnl require autoconf 2.60 (AS_ECHO/AS_ECHO_N)
 AC_PREREQ([2.60])
 define(_CLIENT_VERSION_MAJOR, 4)
 define(_CLIENT_VERSION_MINOR, 5)
-define(_CLIENT_VERSION_REVISION, 1)
+define(_CLIENT_VERSION_REVISION, 2)
 define(_CLIENT_VERSION_BUILD, 0)
 define(_CLIENT_VERSION_IS_RELEASE, true)
 define(_CLIENT_BUILD_IS_TEST_RELEASE, false)

qa/pull-tester/rpc-tests.py

@@ -150,6 +150,9 @@
     'cfund-donate.py',
     'cfund-listproposals.py',
     'cfund-paymentrequest-extract-funds.py',
+    'cfund-paymentrequest-payout.py',
+    'cfund-paymentrequest-duplicate.py',
+    'cfund-paymentrequest-hardfork-452.py',
     'cfund-paymentrequest-state-accept.py',
     'cfund-paymentrequest-state-accept-expired-proposal.py',
     'cfund-paymentrequest-state-expired.py',
@@ -168,6 +171,7 @@
     'coldstaking_spending.py',
     'staticr-staking-amount.py',
     'hardfork-451.py',
+    'hardfork-452.py',
     'staticr-tx-send.py',
 
     'sendtoaddress.py',

qa/rpc-tests/cfund-paymentrequest-duplicate.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# Copyright (c) 2018 The Navcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from test_framework.test_framework import NavCoinTestFramework
+from test_framework.cfund_util import *
+
+import time
+import http.client
+import urllib.parse
+
+class CommunityFundPaymentRequestDuplicate(NavCoinTestFramework):
+    """Tests the payment request procedures of the Community fund."""
+
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 2
+
+    def setup_network(self, split=False):
+        self.nodes = []
+
+        self.nodes.append(start_node(0, self.options.tmpdir, []))
+        self.nodes.append(start_node(1, self.options.tmpdir, []))
+
+        connect_nodes(self.nodes[0], 1)
+
+        self.is_network_split = split
+
+    def run_test(self):
+
+        activate_cfund(self.nodes[0])
+        self.nodes[0].donatefund(100000)
+
+        sync_blocks(self.nodes)
+
+        balance = self.nodes[0].getbalance()
+
+        balanceSplit = float(balance / self.num_nodes)
+
+        addresses = []
+
+        for x in range(self.num_nodes):
+            addresses.append(self.nodes[x].getnewaddress())
+            self.nodes[0].sendtoaddress(addresses[x], balanceSplit)
+
+        slow_gen(self.nodes[0], 1)
+
+        sync_blocks(self.nodes)
+
+        for x in range(self.num_nodes):
+            assert(self.nodes[x].getbalance() >= balanceSplit)
+
+        SATOSHI = 100000000
+
+        proposals = [{},{},{},{},{}]
+
+        # internships
+        proposals[0]["address"] = self.nodes[0].getnewaddress()
+        proposals[0]["amount"] = 10000
+        proposals[0]["preqs"] = [{"amount": 3333}]
+
+        # beekart posters
+        proposals[1]["address"] = self.nodes[0].getnewaddress()
+        proposals[1]["amount"] = 5000
+        proposals[1]["preqs"] = [{"amount": 5000}]
+
+        # vinyl stickers
+        proposals[2]["address"] = self.nodes[0].getnewaddress()
+        proposals[2]["amount"] = 2000
+        proposals[2]["preqs"] = [{"amount": 2000}]
+
+        # nio italia
+        proposals[3]["address"] = self.nodes[0].getnewaddress()
+        proposals[3]["amount"] = 1000
+        proposals[3]["preqs"] = [{"amount": 1000}]
+
+        # cryptocandor video
+        proposals[4]["address"] = self.nodes[0].getnewaddress()
+        proposals[4]["amount"] = 5500
+        proposals[4]["preqs"] = [{"amount": 2500}, {"amount": 2000}]
+
+        # Create proposals
+        for proposal in proposals:
+            proposal["proposalHash"] = self.nodes[0].createproposal(proposal["address"], proposal["amount"], 36000, "proposal description")["hash"]
+
+        end_cycle(self.nodes[0])
+        sync_blocks(self.nodes)
+
+        # Accept the proposals
+        for proposal in proposals:
+            self.nodes[0].proposalvote(proposal["proposalHash"], "yes")
+
+        slow_gen(self.nodes[0], 1)
+        end_cycle(self.nodes[0])
+
+        locked_accepted = self.nodes[0].cfundstats()["funds"]["locked"]
+
+        sync_blocks(self.nodes)
+
+        # Check proposals are accepted on all nodes
+        for x in range(self.num_nodes):
+            locked_tallied = 0
+            for proposal in proposals:
+                assert(self.nodes[x].getproposal(proposal["proposalHash"])["state"] == 1)
+                assert(self.nodes[x].getproposal(proposal["proposalHash"])["status"] == "accepted")
+                locked_tallied += float(self.nodes[x].getproposal(proposal["proposalHash"])["requestedAmount"])
+            assert(locked_accepted == locked_tallied)
+
+        # Create payment requests for all the proposals
+
+        for proposal in proposals:
+            for preq in proposal["preqs"]:
+                preq["hash"] = self.nodes[0].createpaymentrequest(proposal["proposalHash"], preq["amount"], "payment request description")["hash"]
+
+        slow_gen(self.nodes[0], 1)
+        sync_blocks(self.nodes)
+
+        # Check payment requests are present on all nodes
+
+        for x in range(self.num_nodes):
+            for proposal in proposals:
+                for preq in proposal["preqs"]:
+                    assert(self.nodes[x].getpaymentrequest(preq["hash"])["state"] == 0)
+                    assert(self.nodes[x].getpaymentrequest(preq["hash"])["status"] == "pending")
+                    assert(self.nodes[x].cfundstats()["funds"]["locked"] == locked_accepted)
+
+        end_cycle(self.nodes[0])
+
+        # vote yes for the payment requests
+
+        for proposal in proposals:
+            for preq in proposal["preqs"]:
+                 self.nodes[0].paymentrequestvote(preq["hash"], "yes")
+
+        slow_gen(self.nodes[0], 1)
+        end_cycle(self.nodes[0])
+        sync_blocks(self.nodes)
+
+        for x in range(self.num_nodes):
+            for proposal in proposals:
+                for preq in proposal["preqs"]:
+                    assert(self.nodes[x].getpaymentrequest(preq["hash"])["state"] == 1)
+                    assert(self.nodes[x].getpaymentrequest(preq["hash"])["paidOnBlock"] == "0000000000000000000000000000000000000000000000000000000000000000")
+
+
+
+        wallet_info1 = self.nodes[0].getwalletinfo()
+
+        while self.nodes[0].getpaymentrequest(proposals[0]["preqs"][0]["hash"])["paidOnBlock"] == "0000000000000000000000000000000000000000000000000000000000000000":
+            blocks = slow_gen(self.nodes[0], 1)
+
+        sync_blocks(self.nodes)
+
+        wallet_info2 = self.nodes[0].getwalletinfo()
+
+        # check all wallets see the payout
+
+
+        for x in range(self.num_nodes):
+            paymentsFound = 0
+            preqsFound = 0
+            for proposal in proposals:
+                for preq in proposal["preqs"]:
+                    preqsFound += 1
+                    payoutBlockHash = self.nodes[x].getpaymentrequest(preq["hash"])["paidOnBlock"]
+                    payoutBlock = self.nodes[x].getblock(payoutBlockHash)
+                    payoutHex = self.nodes[x].getrawtransaction(payoutBlock["tx"][0])
+                    payoutTx = self.nodes[x].decoderawtransaction(payoutHex)
+
+                    for vout in payoutTx["vout"]:
+                        if vout["scriptPubKey"]["addresses"][0] == proposal["address"] and vout["valueSat"] == preq["amount"] * SATOSHI:
+                            paymentsFound += 1
+
+            assert(paymentsFound == 6)
+            assert(preqsFound == 6)
+
+        # check node zero received the payout
+
+        lastTransactions = self.nodes[0].listtransactions("", 7)
+
+        # print(lastTransactions)
+        txFound = 0
+        preqsFound = 0
+
+        for tx in lastTransactions:
+            for proposal in proposals:
+                for preq in proposal["preqs"]:
+                    preqsFound += 1
+                    if tx["address"] == proposal["address"] and int(tx["amount"] * SATOSHI) == int(preq["amount"] * SATOSHI):
+                        assert(tx["category"] == "immature")
+                        assert(tx["confirmations"] == 1)
+                        txFound += 1
+
+        assert(txFound == 6)
+
+        # disconnect the nodes mine blocks on each
+        url = urllib.parse.urlparse(self.nodes[1].url)
+        self.nodes[0].disconnectnode(url.hostname+":"+str(p2p_port(1)))
+
+        blocks0 = self.nodes[0].getblockchaininfo()["blocks"]
+        blocks1 = self.nodes[1].getblockchaininfo()["blocks"]
+
+        slow_gen(self.nodes[0], 2)
+        slow_gen(self.nodes[1], 1)
+
+        assert(self.nodes[0].getblockchaininfo()["blocks"] == blocks0 + 2)
+        assert(self.nodes[1].getblockchaininfo()["blocks"] == blocks1 + 1)
+        assert(self.nodes[0].getbestblockhash() != self.nodes[1].getbestblockhash())
+
+        # reconnect the node making node 1 reorg
+        connect_nodes_bi(self.nodes,0,1)
+        sync_blocks(self.nodes)
+
+        assert(self.nodes[0].getblockchaininfo()["blocks"] == blocks0 + 2)
+        assert(self.nodes[1].getblockchaininfo()["blocks"] == blocks1 + 2)
+        assert(self.nodes[0].getbestblockhash() == self.nodes[1].getbestblockhash())
+
+        slow_gen(self.nodes[1], 1)
+
+        bestblockHash = self.nodes[1].getbestblockhash()
+        bestBlock = self.nodes[1].getblock(bestblockHash)
+
+        # Check that the only tx in the block is the block reward
+
+        assert(len(bestBlock["tx"]) == 1)
+
+if __name__ == '__main__':
+    CommunityFundPaymentRequestDuplicate().main()

qa/rpc-tests/cfund-paymentrequest-hardfork-452.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# Copyright (c) 2018 The Navcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from test_framework.test_framework import NavCoinTestFramework
+from test_framework.hardfork_util import *
+from test_framework.cfund_util import *
+
+class PaymentRequest452(NavCoinTestFramework):
+    """Tests whether payment requests can be double paid before and after the hardfork."""
+
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def setup_network(self, split=False):
+        self.nodes = self.setup_nodes()
+        self.is_network_split = split
+
+    def run_test(self):
+        activate_cfund(self.nodes[0])
+        self.nodes[0].donatefund(100000)
+        self.nodes[0].staking(False)
+
+        payoutTxID_1 = self.create_double_preq_payout()
+        print("Second payment request payout:\n"+str(self.nodes[0].gettxout(payoutTxID_1, 1)))
+        
+        # If the payment request is paid out again, the coinbase tx will have 2 vouts, so check txout at index 1
+        assert(self.nodes[0].gettxout(payoutTxID_1, 1) != None)
+
+
+        activateHardFork(self.nodes[0], 21, 1000)
+
+
+        payoutTxID_2 = self.create_double_preq_payout()
+        print("Second payment request payout:\n"+str(self.nodes[0].gettxout(payoutTxID_2, 1)))
+        
+
+        # If the payment request is paid out again, the coinbase tx will have 2 vouts, so check txout at index 1
+        assert(self.nodes[0].gettxout(payoutTxID_2, 1) == None)
+        
+
+    def create_double_preq_payout(self):
+        # Creates a proposal and payment request that is paid out twice
+        ## Returns the txid of the second payout
+        paymentAddress = self.nodes[0].getnewaddress()
+        proposalAmount = 10000
+        payoutAmount = 3333
+
+        # Create a proposal and accept by voting
+
+        proposalid0 = self.nodes[0].createproposal(paymentAddress, proposalAmount, 36000, "test")["hash"]
+        start_new_cycle(self.nodes[0])
+        
+        self.nodes[0].proposalvote(proposalid0, "yes")
+        
+        start_new_cycle(self.nodes[0])
+        
+        # Proposal should be accepted
+        assert(self.nodes[0].getproposal(proposalid0)["state"] == 1)
+        assert(self.nodes[0].getproposal(proposalid0)["status"] == "accepted")
+
+        # Create 1 payment request
+
+        paymentReq = self.nodes[0].createpaymentrequest(proposalid0, payoutAmount, "test0")["hash"]
+
+        slow_gen(self.nodes[0], 1)
+
+        # vote yes for the payment request and generate until paid out
+
+        self.nodes[0].paymentrequestvote(paymentReq, "yes")
+
+        start_new_cycle(self.nodes[0])
+        assert(self.nodes[0].getpaymentrequest(paymentReq)["state"] == 1)
+        assert(self.nodes[0].getpaymentrequest(paymentReq)["paidOnBlock"] == "0000000000000000000000000000000000000000000000000000000000000000")
+
+        while self.nodes[0].getpaymentrequest(paymentReq)["paidOnBlock"] == "0000000000000000000000000000000000000000000000000000000000000000":
+            blocks = slow_gen(self.nodes[0], 1)
+
+        slow_gen(self.nodes[0], 1)
+
+
+        # try to payout accepted payment request a second time
+        rawOutput = self.nodes[0].createrawtransaction([], {paymentAddress: payoutAmount}, "", 0)
+
+        self.nodes[0].coinbaseoutputs([rawOutput])
+        self.nodes[0].setcoinbasestrdzeel('[\"'+paymentReq+'\"]')
+        
+        payoutBlockHash = slow_gen(self.nodes[0], 1)[0]
+
+        payoutTxID = self.nodes[0].getblock(payoutBlockHash)["tx"][0]
+        
+        return payoutTxID
+
+
+if __name__ == '__main__':
+    PaymentRequest452().main()