[qa] Rewrite BIP65 functional tests

After 122786d0e0, BIP65 activates at
a particular height (without regard to version numbers of blocks
below that height).  Rewrite the BIP65 functional tests to take
this into account, and add a test case that exercises
OP_CHECKLOCKTIMEVERIFY in a block where the soft-fork is active.

Also moves the bip65 functional test out of the extended test suite.

test/functional/bip65-cltv-p2p.py

@@ -4,173 +4,162 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test BIP65 (CHECKLOCKTIMEVERIFY).
 
-Connect to a single node.
+Test that the CHECKLOCKTIMEVERIFY soft-fork activates at (regtest) block height
-Mine 2 (version 3) blocks (save the coinbases for later).
+1351.
-Generate 98 more version 3 blocks, verify the node accepts.
-Mine 749 version 4 blocks, verify the node accepts.
-Check that the new CLTV rules are not enforced on the 750th version 4 block.
-Check that the new CLTV rules are enforced on the 751st version 4 block.
-Mine 199 new version blocks.
-Mine 1 old-version block.
-Mine 1 new version block.
-Mine 1 old version block, see that the node rejects.
 """
 
-from test_framework.test_framework import ComparisonTestFramework
+from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import *
-from test_framework.mininode import CTransaction, NetworkThread
+from test_framework.mininode import *
 from test_framework.blocktools import create_coinbase, create_block
-from test_framework.comptool import TestInstance, TestManager
+from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP, CScriptNum
-from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP
 from io import BytesIO
-import time
+
+CLTV_HEIGHT = 1351
+
+# Reject codes that we might receive in this test
+REJECT_INVALID = 16
+REJECT_OBSOLETE = 17
+REJECT_NONSTANDARD = 64
 
 def cltv_invalidate(tx):
     '''Modify the signature in vin 0 of the tx to fail CLTV
 
     Prepends -1 CLTV DROP in the scriptSig itself.
+
+    TODO: test more ways that transactions using CLTV could be invalid (eg
+    locktime requirements fail, sequence time requirements fail, etc).
     '''
     tx.vin[0].scriptSig = CScript([OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP] +
                                   list(CScript(tx.vin[0].scriptSig)))
 
-
+def cltv_validate(node, tx, height):
-class BIP65Test(ComparisonTestFramework):
+    '''Modify the signature in vin 0 of the tx to pass CLTV
+    Prepends <height> CLTV DROP in the scriptSig, and sets
+    the locktime to height'''
+    tx.vin[0].nSequence = 0
+    tx.nLockTime = height
+
+    # Need to re-sign, since nSequence and nLockTime changed
+    signed_result = node.signrawtransaction(ToHex(tx))
+    new_tx = CTransaction()
+    new_tx.deserialize(BytesIO(hex_str_to_bytes(signed_result['hex'])))
+
+    new_tx.vin[0].scriptSig = CScript([CScriptNum(height), OP_CHECKLOCKTIMEVERIFY, OP_DROP] +
+                                  list(CScript(new_tx.vin[0].scriptSig)))
+    return new_tx
+
+def create_transaction(node, coinbase, to_address, amount):
+    from_txid = node.getblock(coinbase)['tx'][0]
+    inputs = [{ "txid" : from_txid, "vout" : 0}]
+    outputs = { to_address : amount }
+    rawtx = node.createrawtransaction(inputs, outputs)
+    signresult = node.signrawtransaction(rawtx)
+    tx = CTransaction()
+    tx.deserialize(BytesIO(hex_str_to_bytes(signresult['hex'])))
+    return tx
+
+class BIP65Test(BitcoinTestFramework):
 
     def __init__(self):
         super().__init__()
         self.num_nodes = 1
-        self.extra_args = [['-whitelist=127.0.0.1', '-blockversion=3']]
+        self.extra_args = [['-promiscuousmempoolflags=1', '-whitelist=127.0.0.1']]
+        self.setup_clean_chain = True
 
     def run_test(self):
-        test = TestManager(self, self.options.tmpdir)
+        node0 = NodeConnCB()
-        test.add_all_connections(self.nodes)
+        connections = []
+        connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
+        node0.add_connection(connections[0])
+
         NetworkThread().start() # Start up network handling in another thread
-        test.run()
+
-
+        # wait_for_verack ensures that the P2P connection is fully up.
-    def create_transaction(self, node, coinbase, to_address, amount):
+        node0.wait_for_verack()
-        from_txid = node.getblock(coinbase)['tx'][0]
+
-        inputs = [{ "txid" : from_txid, "vout" : 0}]
+        self.log.info("Mining %d blocks", CLTV_HEIGHT - 2)
-        outputs = { to_address : amount }
+        self.coinbase_blocks = self.nodes[0].generate(CLTV_HEIGHT - 2)
-        rawtx = node.createrawtransaction(inputs, outputs)
-        signresult = node.signrawtransaction(rawtx)
-        tx = CTransaction()
-        f = BytesIO(hex_str_to_bytes(signresult['hex']))
-        tx.deserialize(f)
-        return tx
-
-    def get_tests(self):
-
-        self.coinbase_blocks = self.nodes[0].generate(2)
-        height = 3  # height of the next block to build
-        self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
         self.nodeaddress = self.nodes[0].getnewaddress()
-        self.last_block_time = int(time.time())
+
-
+        self.log.info("Test that an invalid-according-to-CLTV transaction can still appear in a block")
-        ''' 398 more version 3 blocks '''
+
-        test_blocks = []
+        spendtx = create_transaction(self.nodes[0], self.coinbase_blocks[0],
-        for i in range(398):
+                self.nodeaddress, 1.0)
-            block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
-            block.nVersion = 3
-            block.rehash()
-            block.solve()
-            test_blocks.append([block, True])
-            self.last_block_time += 1
-            self.tip = block.sha256
-            height += 1
-        yield TestInstance(test_blocks, sync_every_block=False)
-
-        ''' Mine 749 version 4 blocks '''
-        test_blocks = []
-        for i in range(749):
-            block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
-            block.nVersion = 4
-            block.rehash()
-            block.solve()
-            test_blocks.append([block, True])
-            self.last_block_time += 1
-            self.tip = block.sha256
-            height += 1
-        yield TestInstance(test_blocks, sync_every_block=False)
-
-        '''
-        Check that the new CLTV rules are not enforced in the 750th
-        version 3 block.
-        '''
-        spendtx = self.create_transaction(self.nodes[0],
-                self.coinbase_blocks[0], self.nodeaddress, 1.0)
         cltv_invalidate(spendtx)
         spendtx.rehash()
 
-        block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
+        tip = self.nodes[0].getbestblockhash()
-        block.nVersion = 4
+        block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
+        block = create_block(int(tip, 16), create_coinbase(CLTV_HEIGHT - 1), block_time)
+        block.nVersion = 3
         block.vtx.append(spendtx)
         block.hashMerkleRoot = block.calc_merkle_root()
-        block.rehash()
         block.solve()
 
-        self.last_block_time += 1
+        node0.send_and_ping(msg_block(block))
-        self.tip = block.sha256
+        assert_equal(self.nodes[0].getbestblockhash(), block.hash)
-        height += 1
+
-        yield TestInstance([[block, True]])
+        self.log.info("Test that blocks must now be at least version 4")
-
+        tip = block.sha256
-        ''' Mine 199 new version blocks on last valid tip '''
+        block_time += 1
-        test_blocks = []
+        block = create_block(tip, create_coinbase(CLTV_HEIGHT), block_time)
-        for i in range(199):
-            block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
-            block.nVersion = 4
-            block.rehash()
-            block.solve()
-            test_blocks.append([block, True])
-            self.last_block_time += 1
-            self.tip = block.sha256
-            height += 1
-        yield TestInstance(test_blocks, sync_every_block=False)
-
-        ''' Mine 1 old version block '''
-        block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
         block.nVersion = 3
-        block.rehash()
         block.solve()
-        self.last_block_time += 1
+        node0.send_and_ping(msg_block(block))
-        self.tip = block.sha256
+        assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
-        height += 1
-        yield TestInstance([[block, True]])
 
-        ''' Mine 1 new version block '''
+        assert wait_until(lambda: "reject" in node0.last_message.keys())
-        block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
+        with mininode_lock:
+            assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE)
+            assert_equal(node0.last_message["reject"].reason, b'bad-version(0x00000003)')
+            assert_equal(node0.last_message["reject"].data, block.sha256)
+            del node0.last_message["reject"]
+
+        self.log.info("Test that invalid-according-to-cltv transactions cannot appear in a block")
         block.nVersion = 4
-        block.rehash()
+
-        block.solve()
+        spendtx = create_transaction(self.nodes[0], self.coinbase_blocks[1],
-        self.last_block_time += 1
+                self.nodeaddress, 1.0)
-        self.tip = block.sha256
-        height += 1
-        yield TestInstance([[block, True]])
-
-        '''
-        Check that the new CLTV rules are enforced in the 951st version 4
-        block.
-        '''
-        spendtx = self.create_transaction(self.nodes[0],
-                self.coinbase_blocks[1], self.nodeaddress, 1.0)
         cltv_invalidate(spendtx)
         spendtx.rehash()
 
-        block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
+        # First we show that this tx is valid except for CLTV by getting it
-        block.nVersion = 4
+        # accepted to the mempool (which we can achieve with
+        # -promiscuousmempoolflags).
+        node0.send_and_ping(msg_tx(spendtx))
+        assert spendtx.hash in self.nodes[0].getrawmempool()
+
+        # Now we verify that a block with this transaction is invalid.
         block.vtx.append(spendtx)
         block.hashMerkleRoot = block.calc_merkle_root()
-        block.rehash()
         block.solve()
-        self.last_block_time += 1
-        yield TestInstance([[block, False]])
 
-        ''' Mine 1 old version block, should be invalid '''
+        node0.send_and_ping(msg_block(block))
-        block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
+        assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
-        block.nVersion = 3
+
-        block.rehash()
+        assert wait_until (lambda: "reject" in node0.last_message.keys())
+        with mininode_lock:
+            assert node0.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD]
+            assert_equal(node0.last_message["reject"].data, block.sha256)
+            if node0.last_message["reject"].code == REJECT_INVALID:
+                # Generic rejection when a block is invalid
+                assert_equal(node0.last_message["reject"].reason, b'block-validation-failed')
+            else:
+                assert b'Negative locktime' in node0.last_message["reject"].reason
+
+        self.log.info("Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
+        spendtx = cltv_validate(self.nodes[0], spendtx, CLTV_HEIGHT - 1)
+        spendtx.rehash()
+
+        block.vtx.pop(1)
+        block.vtx.append(spendtx)
+        block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
-        self.last_block_time += 1
+
-        yield TestInstance([[block, False]])
+        node0.send_and_ping(msg_block(block))
+        assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)
+
 
 if __name__ == '__main__':
     BIP65Test().main()

test/functional/bip65-cltv.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2015-2016 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test the CHECKLOCKTIMEVERIFY (BIP65) soft-fork logic."""
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-
-class BIP65Test(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
-        self.num_nodes = 3
-        self.setup_clean_chain = False
-        self.extra_args = [[], ["-blockversion=3"], ["-blockversion=4"]]
-
-    def setup_network(self):
-        self.setup_nodes()
-        connect_nodes(self.nodes[1], 0)
-        connect_nodes(self.nodes[2], 0)
-        self.sync_all()
-
-    def run_test(self):
-        cnt = self.nodes[0].getblockcount()
-
-        # Mine some old-version blocks
-        self.nodes[1].generate(200)
-        cnt += 100
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 100):
-            raise AssertionError("Failed to mine 100 version=3 blocks")
-
-        # Mine 750 new-version blocks
-        for i in range(15):
-            self.nodes[2].generate(50)
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 850):
-            raise AssertionError("Failed to mine 750 version=4 blocks")
-
-        # TODO: check that new CHECKLOCKTIMEVERIFY rules are not enforced
-
-        # Mine 1 new-version block
-        self.nodes[2].generate(1)
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 851):
-            raise AssertionError("Failed to mine a version=4 blocks")
-
-        # TODO: check that new CHECKLOCKTIMEVERIFY rules are enforced
-
-        # Mine 198 new-version blocks
-        for i in range(2):
-            self.nodes[2].generate(99)
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 1049):
-            raise AssertionError("Failed to mine 198 version=4 blocks")
-
-        # Mine 1 old-version block
-        self.nodes[1].generate(1)
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 1050):
-            raise AssertionError("Failed to mine a version=3 block after 949 version=4 blocks")
-
-        # Mine 1 new-version blocks
-        self.nodes[2].generate(1)
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 1051):
-            raise AssertionError("Failed to mine a version=4 block")
-
-        # Mine 1 old-version blocks. This should fail
-        assert_raises_jsonrpc(-1,"CreateNewBlock: TestBlockValidity failed: bad-version(0x00000003)", self.nodes[1].generate, 1)
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 1051):
-            raise AssertionError("Accepted a version=3 block after 950 version=4 blocks")
-
-        # Mine 1 new-version blocks
-        self.nodes[2].generate(1)
-        self.sync_all()
-        if (self.nodes[0].getblockcount() != cnt + 1052):
-            raise AssertionError("Failed to mine a version=4 block")
-
-if __name__ == '__main__':
-    BIP65Test().main()

test/functional/test_runner.py

@@ -113,6 +113,7 @@ BASE_SCRIPTS= [
     'listsinceblock.py',
     'p2p-leaktests.py',
     'wallet-encryption.py',
+    'bip65-cltv-p2p.py',
     'uptime.py',
 ]
 
@@ -136,8 +137,6 @@ EXTENDED_SCRIPTS = [
     'rpcbind_test.py',
     # vv Tests less than 30s vv
     'assumevalid.py',
-    'bip65-cltv.py',
-    'bip65-cltv-p2p.py',
     'bipdersig-p2p.py',
     'bipdersig.py',
     'example_test.py',