@@ -4,173 +4,162 @@
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
""" Test BIP65 (CHECKLOCKTIMEVERIFY).
-Connect to a single node.
-Mine 2 (version 3) blocks (save the coinbases for later).
-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.
+Test that the CHECKLOCKTIMEVERIFY soft-fork activates at (regtest) block height
+1351.
"""
-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
+from test_framework.script import CScript, OP_1NEGATE , OP_CHECKLOCKTIMEVERIFY , OP_DROP , CScriptNum
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)))
-
-class BIP65Test (ComparisonTestFramework ):
+def cltv_validate (node , tx , height ):
+ ''' 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" " 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)
- test.add_all_connections(self .nodes)
+ node0 = NodeConnCB()
+ connections = []
+ connections.append(NodeConn(' 127.0.0.1' 0 ), self .nodes[0 ], node0))
+ node0.add_connection(connections[0 ])
+
NetworkThread().start() # Start up network handling in another thread
- test.run()
-
- def create_transaction (self node , coinbase , to_address , amount ):
- from_txid = node.getblock(coinbase)[' tx' 0 ]
- inputs = [{ " txid" " vout" 0 }]
- outputs = { to_address : amount }
- 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 )
+
+ # wait_for_verack ensures that the P2P connection is fully up.
+ node0.wait_for_verack()
+
+ self .log.info(" Mining %d blocks" CLTV_HEIGHT - 2 )
+ self .coinbase_blocks = self .nodes[0 ].generate(CLTV_HEIGHT - 2 )
self .nodeaddress = self .nodes[0 ].getnewaddress()
- self .last_block_time = int (time.time())
-
- ''' 398 more version 3 blocks '''
- test_blocks = []
- for i in range (398 ):
- 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 )
+
+ self .log.info(" Test that an invalid-according-to-CLTV transaction can still appear in a block"
+
+ spendtx = 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 )
- block.nVersion = 4
+ tip = self .nodes[0 ].getbestblockhash()
+ 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
- self .tip = block.sha256
- height += 1
- yield TestInstance([[block, True ]])
-
- ''' Mine 199 new version blocks on last valid tip '''
- test_blocks = []
- 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 )
+ node0.send_and_ping(msg_block(block))
+ assert_equal(self .nodes[0 ].getbestblockhash(), block.hash)
+
+ self .log.info(" Test that blocks must now be at least version 4"
+ tip = block.sha256
+ block_time += 1
+ block = create_block(tip, create_coinbase(CLTV_HEIGHT ), block_time)
block.nVersion = 3
- block.rehash()
block.solve()
- self .last_block_time += 1
- self .tip = block.sha256
- height += 1
- yield TestInstance([[block, True ]])
+ node0.send_and_ping(msg_block(block))
+ assert_equal(int (self .nodes[0 ].getbestblockhash(), 16 ), tip)
- ''' Mine 1 new version block '''
- block = create_block(self .tip, create_coinbase(height), self .last_block_time + 1 )
+ assert wait_until(lambda : " reject" in node0.last_message.keys())
+ with mininode_lock:
+ assert_equal(node0.last_message[" reject" REJECT_OBSOLETE )
+ assert_equal(node0.last_message[" reject" b ' bad-version(0x00000003)'
+ assert_equal(node0.last_message[" reject"
+ 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()
- self .last_block_time += 1
- 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 )
+
+ spendtx = 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 )
- block.nVersion = 4
+ # First we show that this tx is valid except for CLTV by getting it
+ # 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 '''
- block = create_block(self .tip, create_coinbase(height), self .last_block_time + 1 )
- block.nVersion = 3
- block.rehash()
+ node0.send_and_ping(msg_block(block))
+ assert_equal(int (self .nodes[0 ].getbestblockhash(), 16 ), tip)
+
+ assert wait_until (lambda : " reject" in node0.last_message.keys())
+ with mininode_lock:
+ assert node0.last_message[" reject" in [REJECT_INVALID , REJECT_NONSTANDARD ]
+ assert_equal(node0.last_message[" reject"
+ if node0.last_message[" reject" == REJECT_INVALID :
+ # Generic rejection when a block is invalid
+ assert_equal(node0.last_message[" reject" b ' block-validation-failed'
+ else :
+ assert b ' Negative locktime' in node0.last_message[" reject"
+
+ 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()
For my own sanity it'd be nice if cltv_invalidate looked much more like cltv_validate, which would make it more obvious that the invalid tx is clearly invalid due to the CLTV and not some other reason, and while you're at it would be nice to test other ways CLTV can be invalid (both tx doesnt meet sequence requirements and tx doesnt meet locktime requirements).