Merge pull request bitcoin#365 from qtumproject/djaen/python-qa-refactoring

Added MPoS helpers, more python tests and checking and overflow checking for gas stipend

Author: qtum-neil

qa/pull-tester/rpc-tests.py

@@ -185,7 +185,11 @@
     'qtum-null-sender.py',
     'qtum-transaction-prioritization.py',
     'qtum-dgp-block-size-sync.py',
-    'qtum-opcall.py'
+    'qtum-opcall.py',
+    'qtum-assign-mpos-fees-to-gas-refund.py',
+    'qtum-gas-limit-overflow.py',
+    'qtum-immature-coinstake-spend.py',
+    'qtum-ignore-mpos-participant-reward.py',
 ]
 
 

qa/rpc-tests/qtum-assign-mpos-fees-to-gas-refund.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import *
+from test_framework.script import *
+from test_framework.mininode import *
+from test_framework.address import *
+from test_framework.qtum import *
+import sys
+import random
+import time
+import io
+
+class QtumAssignMPoSFeesToGasRefundTest(BitcoinTestFramework):
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def setup_network(self, split=False):
+        self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
+        self.is_network_split = False
+        self.node = self.nodes[0]
+
+
+    def run_test(self):
+        self.node.setmocktime(int(time.time()) - 1000000)
+        self.node.generate(200 + COINBASE_MATURITY)
+
+        activate_mpos(self.node)
+        # First setup a dummy contract
+        bytecode = "60606040523415600e57600080fd5b603280601b6000396000f30060606040520000a165627a7a7230582008e466283dd617547ad26d9f100792d4f3e1ec49377f8f53ce3ba3d135beb5b30029"
+        address = self.node.createcontract(bytecode)['address']
+        self.node.generate(1)
+
+        staking_prevouts = collect_prevouts(self.node, amount=20000)
+        tip = self.node.getblock(self.node.getbestblockhash())
+        t = (tip['time'] + 0x30) & 0xfffffff0
+        self.node.setmocktime(t)
+        block, block_sig_key = create_unsigned_mpos_block(self.node, staking_prevouts, nTime=t, block_fees=2102200000)
+        block.hashUTXORoot = int(tip['hashUTXORoot'], 16)
+        block.hashStateRoot = int(tip['hashStateRoot'], 16)
+
+        unspents = [unspent for unspent in self.node.listunspent()[::-1] if unspent['amount'] == 20000]
+        unspent = unspents.pop(0)
+
+        tx_all_fees = CTransaction()
+        tx_all_fees.vin = [CTxIn(COutPoint(int(unspent['txid'], 16), unspent['vout']))]
+        tx_all_fees.vout = [CTxOut(0, scriptPubKey=CScript([OP_DUP, OP_HASH160, bytes.fromhex(p2pkh_to_hex_hash(unspent['address'])), OP_EQUALVERIFY, OP_CHECKSIG]))]
+        tx_all_fees = rpc_sign_transaction(self.node, tx_all_fees)
+        tx_all_fees.rehash()
+        block.vtx.append(tx_all_fees)
+
+        # Generate a dummy contract call that will steal the mpos participants' fee rewards.
+        # Since the fees in the last tx was 20000 00000000 we create a tx with 40000000 gas limit and 100000 gas price
+        unspent = unspents.pop(0)
+        tx = CTransaction()
+        tx.vin = [CTxIn(COutPoint(int(unspent['txid'], 16), unspent['vout']))]
+        tx.vout = [CTxOut(0, scriptPubKey=CScript([b"\x04", CScriptNum(40000000), CScriptNum(100000), b"\x00", bytes.fromhex(address), OP_CALL]))]
+        tx = rpc_sign_transaction(self.node, tx)
+        tx.rehash()
+        block.vtx.append(tx)
+
+        # We must also add the refund output to the coinstake
+        block.vtx[1].vout.append(CTxOut(3997897800000, scriptPubKey=CScript([OP_DUP, OP_HASH160, bytes.fromhex(p2pkh_to_hex_hash(unspent['address'])), OP_EQUALVERIFY, OP_CHECKSIG])))
+        block.vtx[1].rehash()
+
+        block.vtx[1] = rpc_sign_transaction(self.node, block.vtx[1])
+        block.hashMerkleRoot = block.calc_merkle_root()
+        block.sign_block(block_sig_key)
+        blockcount = self.node.getblockcount()
+        print(self.node.submitblock(bytes_to_hex_str(block.serialize())))
+        assert_equal(self.node.getblockcount(), blockcount)
+
+if __name__ == '__main__':
+    QtumAssignMPoSFeesToGasRefundTest().main()

qa/rpc-tests/qtum-gas-limit-overflow.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import *
+from test_framework.script import *
+from test_framework.mininode import *
+from test_framework.address import *
+from test_framework.qtum import *
+import sys
+import random
+import time
+import io
+
+class QtumGasLimitOverflowTest(BitcoinTestFramework):
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def setup_network(self, split=False):
+        self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
+        self.is_network_split = False
+        self.node = self.nodes[0]
+
+    def run_test(self):
+        self.node.setmocktime(int(time.time()) - 1000000)
+        self.node.generate(200 + COINBASE_MATURITY)
+        unspents = [unspent for unspent in self.node.listunspent() if unspent['amount'] == 20000]
+        unspent = unspents.pop(0)
+
+        tx = CTransaction()
+        tx.vin = [CTxIn(COutPoint(int(unspent['txid'], 16), unspent['vout']))]
+        tx.vout = [CTxOut(0, scriptPubKey=CScript([b"\x04", CScriptNum(0x10000), CScriptNum(0x100000000000), b"\x00", OP_CREATE])) for i in range(0x10)]
+        tx = rpc_sign_transaction(self.node, tx)
+        assert_raises(JSONRPCException, self.node.sendrawtransaction, bytes_to_hex_str(tx.serialize()))
+        self.node.generate(1)
+
+if __name__ == '__main__':
+    QtumGasLimitOverflowTest().main()

qa/rpc-tests/qtum-ignore-mpos-participant-reward.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import *
+from test_framework.script import *
+from test_framework.mininode import *
+from test_framework.address import *
+from test_framework.qtum import *
+import sys
+import random
+import time
+
+class QtumIgnoreMPOSParticipantRewardTest(BitcoinTestFramework):
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def setup_network(self, split=False):
+        self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
+        self.is_network_split = False
+        self.node = self.nodes[0]
+
+    def remove_from_staking_prevouts(self, remove_prevout):
+        for j in range(len(self.staking_prevouts)):
+            prevout = self.staking_prevouts[j]
+            if prevout[0].serialize() == remove_prevout.serialize():
+                self.staking_prevouts.pop(j)
+                break
+
+    def run_test(self):
+        self.node.setmocktime(int(time.time()) - 1000000)
+        self.node.generate(10 + COINBASE_MATURITY)
+        # These are the privkeys that corresponds to the pubkeys in the pos outputs
+        # These are used by default by create_pos_block
+        for i in range(0xff+1):
+            privkey = byte_to_base58(hash256(struct.pack('<I', i)), 239)
+            self.node.importprivkey(privkey)
+
+        """
+        pragma solidity ^0.4.12;
+        contract Test {
+            function() payable {
+            }
+        }
+        """
+        bytecode = "60606040523415600e57600080fd5b5b603580601c6000396000f30060606040525b5b5b0000a165627a7a723058205093ec5d227f741a4c8511f495e12b897d670259ab2f2b5b241af6af08753f5e0029"
+        contract_address = self.node.createcontract(bytecode)['address']
+
+        activate_mpos(self.node)
+
+        self.staking_prevouts = collect_prevouts(self.node)
+        # Only have staking outputs with nValue == 20000.0
+        # Since the rest of the code relies on this
+        i = 0
+        while i < len(self.staking_prevouts):
+            if self.staking_prevouts[i][1] != 20000*COIN:
+                self.staking_prevouts.pop(i)
+            i += 1
+
+        nTime = int(time.time()) & 0xfffffff0
+        self.node.setmocktime(nTime)
+
+
+        # Find the block.number - 505 coinstake's 2nd output
+        # This will be an mpos participant
+        mpos_participant_block = self.node.getblock(self.node.getblockhash(self.node.getblockcount() - 505))
+        mpos_participant_txid = mpos_participant_block['tx'][1]
+        mpos_participant_tx = self.node.getrawtransaction(mpos_participant_txid, True)
+        mpos_participant_pubkey = hex_str_to_bytes(mpos_participant_tx['vout'][1]['scriptPubKey']['asm'].split(' ')[0])
+        mpos_participant_hpubkey = hash160(mpos_participant_pubkey)
+        mpos_participant_addr = hex_hash_to_p2pkh(bytes_to_hex_str(mpos_participant_hpubkey))
+
+        tx = CTransaction()
+        tx.vin = [make_vin_from_unspent(self.node, address=mpos_participant_addr)]
+        tx.vout = [CTxOut(0, scriptPubKey=CScript([b"\x04", CScriptNum(4000000), CScriptNum(100000), b"\x00", hex_str_to_bytes(contract_address), OP_CALL]))]
+        tx = rpc_sign_transaction(self.node, tx)
+        self.remove_from_staking_prevouts(tx.vin[0].prevout)
+
+        block, block_sig_key = create_unsigned_mpos_block(self.node, self.staking_prevouts, block_fees=int(10000*COIN)-397897500000, nTime=nTime)
+        block.vtx.append(tx)
+        block.vtx[1].vout.append(CTxOut(397897500000, scriptPubKey=CScript([OP_DUP, OP_HASH160, mpos_participant_hpubkey, OP_EQUALVERIFY, OP_CHECKSIG])))
+
+        # Delete the mpos participant reward and assign it to the staker
+        block.vtx[1].vout.pop(-5)
+        block.vtx[1].vout[1].nValue += 260210250000
+
+        # Resign the coinstake tx
+        block.vtx[1] = rpc_sign_transaction(self.node, block.vtx[1])
+        block.hashMerkleRoot = block.calc_merkle_root()
+        block.sign_block(block_sig_key)
+
+        # Make sure that the block was rejected
+        blockcount = self.node.getblockcount()
+        print(self.node.submitblock(bytes_to_hex_str(block.serialize())))
+        assert_equal(self.node.getblockcount(), blockcount)
+        
+if __name__ == '__main__':
+    QtumIgnoreMPOSParticipantRewardTest().main()

qa/rpc-tests/qtum-immature-coinstake-spend.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import *
+from test_framework.script import *
+from test_framework.mininode import *
+from test_framework.address import *
+from test_framework.qtum import *
+import sys
+import random
+import time
+
+class QtumPrematureCoinstakeSpendTest(BitcoinTestFramework):
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def setup_network(self, split=False):
+        self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
+        self.is_network_split = False
+        self.node = self.nodes[0]
+
+    def remove_from_staking_prevouts(self, remove_prevout):
+        for j in range(len(self.staking_prevouts)):
+            prevout = self.staking_prevouts[j]
+            if prevout[0].serialize() == remove_prevout.serialize():
+                self.staking_prevouts.pop(j)
+                break
+
+    def assert_spend_of_coinstake_at_height(self, height, should_accept):
+        spend_block = self.node.getblock(self.node.getblockhash(height))
+        spend_coinstake_txid = spend_block['tx'][1]
+        spend_coinstake_txout = self.node.gettxout(spend_coinstake_txid, 1)
+
+        tx = CTransaction()
+        tx.vin = [CTxIn(COutPoint(int(spend_coinstake_txid, 16), 1))]
+        tx.vout = [CTxOut(int(float(str(spend_coinstake_txout['value']))*COIN - 1000000), scriptPubKey=CScript([OP_TRUE]))]
+        tx = rpc_sign_transaction(self.node, tx)
+        
+        if should_accept:
+            self.node.sendrawtransaction(bytes_to_hex_str(tx.serialize()))
+        else:
+            assert_raises(JSONRPCException, self.node.sendrawtransaction, bytes_to_hex_str(tx.serialize()))
+
+        tip = self.node.getblock(self.node.getbestblockhash())
+
+        next_block_time = (tip['time'] + 0x30) & 0xfffffff0
+        self.node.setmocktime(next_block_time)
+        block, sig_key = create_unsigned_mpos_block(self.node, self.staking_prevouts, next_block_time, 1000000)
+        block.vtx.append(tx)
+        block.hashMerkleRoot = block.calc_merkle_root()
+        block.rehash()
+        block.sign_block(sig_key)
+        blockcount = self.node.getblockcount()
+        self.node.submitblock(bytes_to_hex_str(block.serialize()))
+        assert_equal(self.node.getblockcount(), blockcount + (1 if should_accept else 0))
+        self.remove_from_staking_prevouts(block.prevoutStake)
+
+
+    def run_test(self):
+        self.node.setmocktime(int(time.time()) - 1000000)
+        self.node.generate(10 + COINBASE_MATURITY)
+        # These are the privkeys that corresponds to the pubkeys in the pos outputs
+        # These are used by default by create_pos_block
+        for i in range(0xff+1):
+            privkey = byte_to_base58(hash256(struct.pack('<I', i)), 239)
+            self.node.importprivkey(privkey)
+
+        activate_mpos(self.node)
+        self.staking_prevouts = collect_prevouts(self.node)
+        self.assert_spend_of_coinstake_at_height(height=4502, should_accept=False)
+        self.assert_spend_of_coinstake_at_height(height=4501, should_accept=True)
+        # Invalidate the last block and make sure that the previous rejection of the premature coinstake spends fails
+        self.node.invalidateblock(self.node.getbestblockhash())
+        self.assert_spend_of_coinstake_at_height(height=4502, should_accept=False)
+
+if __name__ == '__main__':
+    QtumPrematureCoinstakeSpendTest().main()