D3514.diff
No OneTemporary
Actions

Size

76 KB

Subscribers

None

D3514.diff
View Options

	diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
	--- a/test/functional/feature_block.py
	+++ b/test/functional/feature_block.py
	@@ -1,17 +1,9 @@
	#!/usr/bin/env python3
	-# Copyright (c) 2015-2016 The Bitcoin Core developers
	+# Copyright (c) 2015-2017 The Bitcoin Core developers
	# Copyright (c) 2017 The Bitcoin developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.
	-"""Test block processing.
	-
	-This reimplements tests from the bitcoinj/FullBlockTestGenerator used
	-by the pull-tester.
	-
	-We use the testing framework in which we expect a particular answer from
	-each test.
	-"""
	-
	+"""Test block processing."""
	import copy
	import struct
	import time
	@@ -24,21 +16,18 @@
	make_conform_to_ctor,
	)
	from test_framework.cdefs import LEGACY_MAX_BLOCK_SIZE, MAX_BLOCK_SIGOPS_PER_MB
	-from test_framework.comptool import RejectResult, TestInstance, TestManager
	from test_framework.key import CECKey
	from test_framework.messages import (
	CBlock,
	- CBlockHeader,
	COIN,
	COutPoint,
	CTransaction,
	CTxIn,
	CTxOut,
	- ser_uint256,
	uint256_from_compact,
	uint256_from_str,
	)
	-from test_framework.mininode import network_thread_start
	+from test_framework.mininode import P2PDataStore, network_thread_start, network_thread_join
	from test_framework.script import (
	CScript,
	hash160,
	@@ -61,7 +50,7 @@
	SIGHASH_FORKID,
	SignatureHashForkId,
	)
	-from test_framework.test_framework import ComparisonTestFramework
	+from test_framework.test_framework import BitcoinTestFramework
	from test_framework.txtools import pad_tx
	from test_framework.util import assert_equal

	@@ -76,10 +65,6 @@


	class CBrokenBlock(CBlock):
	-
	- def __init__(self, header=None):
	- super(CBrokenBlock, self).__init__(header)
	-
	def initialize(self, base_block):
	self.vtx = copy.deepcopy(base_block.vtx)
	self.hashMerkleRoot = self.calc_merkle_root()
	@@ -93,374 +78,273 @@
	return r

	def normal_serialize(self):
	- r = b""
	- r += super(CBrokenBlock, self).serialize()
	- return r
	+ return super().serialize()


	-class FullBlockTest(ComparisonTestFramework):
	- # Can either run this test as 1 node with expected answers, or two and compare them.
	- # Change the "outcome" variable from each TestInstance object to only do the comparison.
	+class FullBlockTest(BitcoinTestFramework):
	def set_test_params(self):
	self.num_nodes = 1
	- self.extra_args = [['-whitelist=127.0.0.1',
	- '-noparkdeepreorg', '-maxreorgdepth=-1']]
	self.setup_clean_chain = True
	+ self.extra_args = [['-noparkdeepreorg', '-maxreorgdepth=-1']]
	+
	+ def run_test(self):
	+ node = self.nodes[0] # convenience reference to the node
	+
	+ # reconnect_p2p() expects the network thread to be running
	+ network_thread_start()
	+
	+ self.reconnect_p2p()
	+
	self.block_heights = {}
	self.coinbase_key = CECKey()
	self.coinbase_key.set_secretbytes(b"horsebattery")
	self.coinbase_pubkey = self.coinbase_key.get_pubkey()
	self.tip = None
	self.blocks = {}
	-
	- def add_options(self, parser):
	- super().add_options(parser)
	- parser.add_argument(
	- "--runbarelyexpensive", dest="runbarelyexpensive", default=True)
	-
	- def run_test(self):
	- self.test = TestManager(self, self.options.tmpdir)
	- self.test.add_all_connections(self.nodes)
	- network_thread_start()
	- self.test.run()
	-
	- def add_transactions_to_block(self, block, tx_list):
	- [tx.rehash() for tx in tx_list]
	- block.vtx.extend(tx_list)
	-
	- # this is a little handier to use than the version in blocktools.py
	- def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE])):
	- tx = create_transaction(spend_tx, n, b"", value, script)
	- return tx
	-
	- # sign a transaction, using the key we know about
	- # this signs input 0 in tx, which is assumed to be spending output n in
	- # spend_tx
	- def sign_tx(self, tx, spend_tx, n):
	- scriptPubKey = bytearray(spend_tx.vout[n].scriptPubKey)
	- if (scriptPubKey[0] == OP_TRUE): # an anyone-can-spend
	- tx.vin[0].scriptSig = CScript()
	- return
	- sighash = SignatureHashForkId(
	- spend_tx.vout[n].scriptPubKey, tx, 0, SIGHASH_ALL \| SIGHASH_FORKID, spend_tx.vout[n].nValue)
	- tx.vin[0].scriptSig = CScript(
	- [self.coinbase_key.sign(sighash) + bytes(bytearray([SIGHASH_ALL \| SIGHASH_FORKID]))])
	-
	- def create_and_sign_transaction(self, spend_tx, n, value, script=CScript([OP_TRUE])):
	- tx = self.create_tx(spend_tx, n, value, script)
	- self.sign_tx(tx, spend_tx, n)
	- tx.rehash()
	- return tx
	-
	- def next_block(self, number, spend=None, additional_coinbase_value=0, script=CScript([OP_TRUE]), solve=True):
	- if self.tip == None:
	- base_block_hash = self.genesis_hash
	- block_time = int(time.time()) + 1
	- else:
	- base_block_hash = self.tip.sha256
	- block_time = self.tip.nTime + 1
	- # First create the coinbase
	- height = self.block_heights[base_block_hash] + 1
	- coinbase = create_coinbase(height, self.coinbase_pubkey)
	- coinbase.vout[0].nValue += additional_coinbase_value
	- coinbase.rehash()
	- if spend == None:
	- block = create_block(base_block_hash, coinbase, block_time)
	- else:
	- # all but one satoshi to fees
	- coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1
	- assert(coinbase.vout[0].nValue)
	- coinbase.rehash()
	- block = create_block(base_block_hash, coinbase, block_time)
	- # spend 1 satoshi
	- tx = create_transaction(spend.tx, spend.n, b"", 1, script)
	- self.sign_tx(tx, spend.tx, spend.n)
	- self.add_transactions_to_block(block, [tx])
	- make_conform_to_ctor(block)
	- block.hashMerkleRoot = block.calc_merkle_root()
	- if solve:
	- block.solve()
	- self.tip = block
	- self.block_heights[block.sha256] = height
	- assert number not in self.blocks
	- self.blocks[number] = block
	- return block
	-
	- def get_tests(self):
	self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
	self.block_heights[self.genesis_hash] = 0
	- spendable_outputs = []
	-
	- # save the current tip so it can be spent by a later block
	- def save_spendable_output():
	- spendable_outputs.append(self.tip)
	-
	- # get an output that we previously marked as spendable
	- def get_spendable_output():
	- return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)
	-
	- # returns a test case that asserts that the current tip was accepted
	- def accepted():
	- return TestInstance([[self.tip, True]])
	-
	- # returns a test case that asserts that the current tip was rejected
	- def rejected(reject=None):
	- if reject is None:
	- return TestInstance([[self.tip, False]])
	- else:
	- return TestInstance([[self.tip, reject]])
	-
	- # move the tip back to a previous block
	- def tip(number):
	- self.tip = self.blocks[number]
	-
	- # adds transactions to the block and updates state
	- def update_block(block_number, new_transactions, reorder=True):
	- block = self.blocks[block_number]
	- self.add_transactions_to_block(block, new_transactions)
	- old_sha256 = block.sha256
	- if reorder:
	- make_conform_to_ctor(block)
	- block.hashMerkleRoot = block.calc_merkle_root()
	- block.solve()
	- # Update the internal state just like in next_block
	- self.tip = block
	- if block.sha256 != old_sha256:
	- self.block_heights[block.sha256] = self.block_heights[old_sha256]
	- del self.block_heights[old_sha256]
	- self.blocks[block_number] = block
	- return block
	-
	- # shorthand for functions
	- block = self.next_block
	- create_tx = self.create_tx
	- create_and_sign_tx = self.create_and_sign_transaction
	+ self.spendable_outputs = []

	# Create a new block
	- block(0)
	- save_spendable_output()
	- yield accepted()
	+ b0 = self.next_block(0)
	+ self.save_spendable_output()
	+ self.sync_blocks([b0])

	- # Now we need that block to mature so we can spend the coinbase.
	- test = TestInstance(sync_every_block=False)
	+ # Allow the block to mature
	+ blocks = []
	for i in range(99):
	- block(5000 + i)
	- test.blocks_and_transactions.append([self.tip, True])
	- save_spendable_output()
	- yield test
	+ blocks.append(self.next_block(5000 + i))
	+ self.save_spendable_output()
	+ self.sync_blocks(blocks)

	# collect spendable outputs now to avoid cluttering the code later on
	out = []
	for i in range(33):
	- out.append(get_spendable_output())
	+ out.append(self.get_spendable_output())

	# Start by building a couple of blocks on top (which output is spent is
	# in parentheses):
	# genesis -> b1 (0) -> b2 (1)
	- block(1, spend=out[0])
	- save_spendable_output()
	- yield accepted()
	+ b1 = self.next_block(1, spend=out[0])
	+ self.save_spendable_output()

	- block(2, spend=out[1])
	- yield accepted()
	- save_spendable_output()
	+ b2 = self.next_block(2, spend=out[1])
	+ self.save_spendable_output()

	- # so fork like this:
	+ self.sync_blocks([b1, b2])
	+
	+ # Fork like this:
	#
	# genesis -> b1 (0) -> b2 (1)
	# \-> b3 (1)
	#
	- # Nothing should happen at this point. We saw b2 first so it takes
	- # priority.
	- tip(1)
	- b3 = block(3, spend=out[1])
	+ # Nothing should happen at this point. We saw b2 first so it takes priority.
	+ self.log.info("Don't reorg to a chain of the same length")
	+ self.move_tip(1)
	+ b3 = self.next_block(3, spend=out[1])
	txout_b3 = PreviousSpendableOutput(b3.vtx[1], 0)
	- yield rejected()
	+ self.sync_blocks([b3], False)

	# Now we add another block to make the alternative chain longer.
	#
	# genesis -> b1 (0) -> b2 (1)
	# \-> b3 (1) -> b4 (2)
	- block(4, spend=out[2])
	- yield accepted()
	+ self.log.info("Reorg to a longer chain")
	+ b4 = self.next_block(4, spend=out[2])
	+ self.sync_blocks([b4])

	# ... and back to the first chain.
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b3 (1) -> b4 (2)
	- tip(2)
	- block(5, spend=out[2])
	- save_spendable_output()
	- yield rejected()
	+ self.move_tip(2)
	+ b5 = self.next_block(5, spend=out[2])
	+ self.save_spendable_output()
	+ self.sync_blocks([b5], False)

	- block(6, spend=out[3])
	- yield accepted()
	+ self.log.info("Reorg back to the original chain")
	+ b6 = self.next_block(6, spend=out[3])
	+ self.sync_blocks([b6], True)

	# Try to create a fork that double-spends
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b7 (2) -> b8 (4)
	# \-> b3 (1) -> b4 (2)
	- tip(5)
	- block(7, spend=out[2])
	- yield rejected()
	+ self.log.info(
	+ "Reject a chain with a double spend, even if it is longer")
	+ self.move_tip(5)
	+ b7 = self.next_block(7, spend=out[2])
	+ self.sync_blocks([b7], False)

	- block(8, spend=out[4])
	- yield rejected()
	+ b8 = self.next_block(8, spend=out[4])
	+ self.sync_blocks([b8], False, reconnect=True)

	# Try to create a block that has too much fee
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b9 (4)
	# \-> b3 (1) -> b4 (2)
	- tip(6)
	- block(9, spend=out[4], additional_coinbase_value=1)
	- yield rejected(RejectResult(16, b'bad-cb-amount'))
	+ self.log.info(
	+ "Reject a block where the miner creates too much coinbase reward")
	+ self.move_tip(6)
	+ b9 = self.next_block(9, spend=out[4], additional_coinbase_value=1)
	+ self.sync_blocks([b9], False, 16, b'bad-cb-amount', reconnect=True)

	# Create a fork that ends in a block with too much fee (the one that causes the reorg)
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b10 (3) -> b11 (4)
	# \-> b3 (1) -> b4 (2)
	- tip(5)
	- block(10, spend=out[3])
	- yield rejected()
	+ self.log.info(
	+ "Reject a chain where the miner creates too much coinbase reward, even if the chain is longer")
	+ self.move_tip(5)
	+ b10 = self.next_block(10, spend=out[3])
	+ self.sync_blocks([b10], False)

	- block(11, spend=out[4], additional_coinbase_value=1)
	- yield rejected(RejectResult(16, b'bad-cb-amount'))
	+ b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1)
	+ self.sync_blocks([b11], False, 16, b'bad-cb-amount', reconnect=True)

	# Try again, but with a valid fork first
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b14 (5)
	- # (b12 added last)
	# \-> b3 (1) -> b4 (2)
	- tip(5)
	- b12 = block(12, spend=out[3])
	- save_spendable_output()
	- b13 = block(13, spend=out[4])
	- # Deliver the block header for b12, and the block b13.
	- # b13 should be accepted but the tip won't advance until b12 is
	- # delivered.
	- yield TestInstance([[CBlockHeader(b12), None], [b13, False]])
	-
	- save_spendable_output()
	- # b14 is invalid, but the node won't know that until it tries to connect
	- # Tip still can't advance because b12 is missing
	- block(14, spend=out[5], additional_coinbase_value=1)
	- yield rejected()
	-
	- yield TestInstance([[b12, True, b13.sha256]]) # New tip should be b13.
	+ self.log.info(
	+ "Reject a chain where the miner creates too much coinbase reward, even if the chain is longer (on a forked chain)")
	+ self.move_tip(5)
	+ b12 = self.next_block(12, spend=out[3])
	+ self.save_spendable_output()
	+ b13 = self.next_block(13, spend=out[4])
	+ self.save_spendable_output()
	+ b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1)
	+ self.sync_blocks([b12, b13, b14], False, 16,
	+ b'bad-cb-amount', reconnect=True)
	+
	+ # New tip should be b13.
	+ assert_equal(node.getbestblockhash(), b13.hash)

	# Add a block with MAX_BLOCK_SIGOPS_PER_MB and one with one more sigop
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b16 (6)
	# \-> b3 (1) -> b4 (2)
	-
	- # Test that a block with a lot of checksigs is okay
	+ self.log.info("Accept a block with lots of checksigs")
	lots_of_checksigs = CScript(
	[OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB - 1))
	- tip(13)
	- block(15, spend=out[5], script=lots_of_checksigs)
	- yield accepted()
	- save_spendable_output()
	+ self.move_tip(13)
	+ b15 = self.next_block(15, spend=out[5], script=lots_of_checksigs)
	+ self.save_spendable_output()
	+ self.sync_blocks([b15], True)

	- # Test that a block with too many checksigs is rejected
	+ self.log.info("Reject a block with too many checksigs")
	too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB))
	- block(16, spend=out[6], script=too_many_checksigs)
	- yield rejected(RejectResult(16, b'bad-blk-sigops'))
	+ b16 = self.next_block(16, spend=out[6], script=too_many_checksigs)
	+ self.sync_blocks([b16], False, 16, b'bad-blk-sigops', reconnect=True)

	# Attempt to spend a transaction created on a different fork
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])
	# \-> b3 (1) -> b4 (2)
	- tip(15)
	- block(17, spend=txout_b3)
	- yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
	+ self.log.info("Reject a block with a spend from a re-org'ed out tx")
	+ self.move_tip(15)
	+ b17 = self.next_block(17, spend=txout_b3)
	+ self.sync_blocks([b17], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)

	# Attempt to spend a transaction created on a different fork (on a fork this time)
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5)
	# \-> b18 (b3.vtx[1]) -> b19 (6)
	# \-> b3 (1) -> b4 (2)
	- tip(13)
	- block(18, spend=txout_b3)
	- yield rejected()
	+ self.log.info(
	+ "Reject a block with a spend from a re-org'ed out tx (on a forked chain)")
	+ self.move_tip(13)
	+ b18 = self.next_block(18, spend=txout_b3)
	+ self.sync_blocks([b18], False)

	- block(19, spend=out[6])
	- yield rejected()
	+ b19 = self.next_block(19, spend=out[6])
	+ self.sync_blocks([b19], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)

	# Attempt to spend a coinbase at depth too low
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)
	# \-> b3 (1) -> b4 (2)
	- tip(15)
	- block(20, spend=out[7])
	- yield rejected(RejectResult(16, b'bad-txns-premature-spend-of-coinbase'))
	+ self.log.info("Reject a block spending an immature coinbase.")
	+ self.move_tip(15)
	+ b20 = self.next_block(20, spend=out[7])
	+ self.sync_blocks([b20], False, 16,
	+ b'bad-txns-premature-spend-of-coinbase')

	# Attempt to spend a coinbase at depth too low (on a fork this time)
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5)
	# \-> b21 (6) -> b22 (5)
	# \-> b3 (1) -> b4 (2)
	- tip(13)
	- block(21, spend=out[6])
	- yield rejected()
	+ self.log.info(
	+ "Reject a block spending an immature coinbase (on a forked chain)")
	+ self.move_tip(13)
	+ b21 = self.next_block(21, spend=out[6])
	+ self.sync_blocks([b21], False)

	- block(22, spend=out[5])
	- yield rejected()
	+ b22 = self.next_block(22, spend=out[5])
	+ self.sync_blocks([b22], False, 16,
	+ b'bad-txns-premature-spend-of-coinbase')

	# Create a block on either side of LEGACY_MAX_BLOCK_SIZE and make sure its accepted/rejected
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)
	# \-> b24 (6) -> b25 (7)
	# \-> b3 (1) -> b4 (2)
	- tip(15)
	- b23 = block(23, spend=out[6])
	+ self.log.info("Accept a block of size LEGACY_MAX_BLOCK_SIZE")
	+ self.move_tip(15)
	+ b23 = self.next_block(23, spend=out[6])
	tx = CTransaction()
	script_length = LEGACY_MAX_BLOCK_SIZE - len(b23.serialize()) - 69
	script_output = CScript([b'\x00' * script_length])
	tx.vout.append(CTxOut(0, script_output))
	tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))
	- b23 = update_block(23, [tx])
	+ b23 = self.update_block(23, [tx])
	# Make sure the math above worked out to produce a max-sized block
	assert_equal(len(b23.serialize()), LEGACY_MAX_BLOCK_SIZE)
	- yield accepted()
	- save_spendable_output()
	+ self.sync_blocks([b23], True)
	+ self.save_spendable_output()

	# Create blocks with a coinbase input script size out of range
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7)
	# \-> ... (6) -> ... (7)
	# \-> b3 (1) -> b4 (2)
	- tip(15)
	- b26 = block(26, spend=out[6])
	+ self.log.info(
	+ "Reject a block with coinbase input script size out of range")
	+ self.move_tip(15)
	+ b26 = self.next_block(26, spend=out[6])
	b26.vtx[0].vin[0].scriptSig = b'\x00'
	b26.vtx[0].rehash()
	# update_block causes the merkle root to get updated, even with no new
	# transactions, and updates the required state.
	- b26 = update_block(26, [])
	- yield rejected(RejectResult(16, b'bad-cb-length'))
	+ b26 = self.update_block(26, [])
	+ self.sync_blocks([b26], False, 16, b'bad-cb-length', reconnect=True)

	# Extend the b26 chain to make sure bitcoind isn't accepting b26
	- block(27, spend=out[7])
	- yield rejected(False)
	+ b27 = self.next_block(27, spend=out[7])
	+ self.sync_blocks([b27], False)

	# Now try a too-large-coinbase script
	- tip(15)
	- b28 = block(28, spend=out[6])
	+ self.move_tip(15)
	+ b28 = self.next_block(28, spend=out[6])
	b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
	b28.vtx[0].rehash()
	- b28 = update_block(28, [])
	- yield rejected(RejectResult(16, b'bad-cb-length'))
	+ b28 = self.update_block(28, [])
	+ self.sync_blocks([b28], False, 16, b'bad-cb-length', reconnect=True)

	# Extend the b28 chain to make sure bitcoind isn't accepting b28
	- block(29, spend=out[7])
	- yield rejected(False)
	+ b29 = self.next_block(29, spend=out[7])
	+ self.sync_blocks([b29], False)

	# b30 has a max-sized coinbase scriptSig.
	- tip(23)
	- b30 = block(30)
	+ self.move_tip(23)
	+ b30 = self.next_block(30)
	b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
	b30.vtx[0].rehash()
	- b30 = update_block(30, [])
	- yield accepted()
	- save_spendable_output()
	+ b30 = self.update_block(30, [])
	+ self.sync_blocks([b30], True)
	+ self.save_spendable_output()

	# b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY
	#
	@@ -470,48 +354,57 @@
	# \-> b32 (9)
	#

	- # MULTISIG: each op code counts as 20 sigops. To create the edge case,
	- # pack another 19 sigops at the end.
	- lots_of_multisigs = CScript([OP_CHECKMULTISIG] * (
	- (MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)
	- b31 = block(31, spend=out[8], script=lots_of_multisigs)
	+ # MULTISIG: each op code counts as 20 sigops. To create the edge case, pack another 19 sigops at the end.
	+ self.log.info(
	+ "Accept a block with the max number of OP_CHECKMULTISIG sigops")
	+ lots_of_multisigs = CScript(
	+ [OP_CHECKMULTISIG] * ((MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)
	+ b31 = self.next_block(31, spend=out[8], script=lots_of_multisigs)
	assert_equal(get_legacy_sigopcount_block(b31), MAX_BLOCK_SIGOPS_PER_MB)
	- yield accepted()
	- save_spendable_output()
	+ self.sync_blocks([b31], True)
	+ self.save_spendable_output()

	# this goes over the limit because the coinbase has one sigop
	+ self.log.info("Reject a block with too many OP_CHECKMULTISIG sigops")
	too_many_multisigs = CScript(
	[OP_CHECKMULTISIG] * (MAX_BLOCK_SIGOPS_PER_MB // 20))
	- b32 = block(32, spend=out[9], script=too_many_multisigs)
	+ b32 = self.next_block(32, spend=out[9], script=too_many_multisigs)
	assert_equal(get_legacy_sigopcount_block(
	b32), MAX_BLOCK_SIGOPS_PER_MB + 1)
	- yield rejected(RejectResult(16, b'bad-blk-sigops'))
	+ self.sync_blocks([b32], False, 16, b'bad-blk-sigops', reconnect=True)

	# CHECKMULTISIGVERIFY
	- tip(31)
	- lots_of_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * (
	- (MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)
	- block(33, spend=out[9], script=lots_of_multisigs)
	- yield accepted()
	- save_spendable_output()
	-
	+ self.log.info(
	+ "Accept a block with the max number of OP_CHECKMULTISIGVERIFY sigops")
	+ self.move_tip(31)
	+ lots_of_multisigs = CScript(
	+ [OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)
	+ b33 = self.next_block(33, spend=out[9], script=lots_of_multisigs)
	+ self.sync_blocks([b33], True)
	+ self.save_spendable_output()
	+
	+ self.log.info(
	+ "Reject a block with too many OP_CHECKMULTISIGVERIFY sigops")
	too_many_multisigs = CScript(
	[OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB // 20))
	- block(34, spend=out[10], script=too_many_multisigs)
	- yield rejected(RejectResult(16, b'bad-blk-sigops'))
	+ b34 = self.next_block(34, spend=out[10], script=too_many_multisigs)
	+ self.sync_blocks([b34], False, 16, b'bad-blk-sigops', reconnect=True)

	# CHECKSIGVERIFY
	- tip(33)
	+ self.log.info(
	+ "Accept a block with the max number of OP_CHECKSIGVERIFY sigops")
	+ self.move_tip(33)
	lots_of_checksigs = CScript(
	[OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB - 1))
	- b35 = block(35, spend=out[10], script=lots_of_checksigs)
	- yield accepted()
	- save_spendable_output()
	+ b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs)
	+ self.sync_blocks([b35], True)
	+ self.save_spendable_output()

	+ self.log.info("Reject a block with too many OP_CHECKSIGVERIFY sigops")
	too_many_checksigs = CScript(
	[OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB))
	- block(36, spend=out[11], script=too_many_checksigs)
	- yield rejected(RejectResult(16, b'bad-blk-sigops'))
	+ b36 = self.next_block(36, spend=out[11], script=too_many_checksigs)
	+ self.sync_blocks([b36], False, 16, b'bad-blk-sigops', reconnect=True)

	# Check spending of a transaction in a block which failed to connect
	#
	@@ -521,20 +414,22 @@
	# \-> b38 (11/37)
	#

	- # save 37's spendable output, but then double-spend out11 to invalidate
	- # the block
	- tip(35)
	- b37 = block(37, spend=out[11])
	+ # save 37's spendable output, but then double-spend out11 to invalidate the block
	+ self.log.info(
	+ "Reject a block spending transaction from a block which failed to connect")
	+ self.move_tip(35)
	+ b37 = self.next_block(37, spend=out[11])
	txout_b37 = PreviousSpendableOutput(b37.vtx[1], 0)
	- tx = create_and_sign_tx(out[11].tx, out[11].n, 0)
	- b37 = update_block(37, [tx])
	- yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
	+ tx = self.create_and_sign_transaction(out[11].tx, out[11].n, 0)
	+ b37 = self.update_block(37, [tx])
	+ self.sync_blocks([b37], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)

	- # attempt to spend b37's first non-coinbase tx, at which point b37 was
	- # still considered valid
	- tip(35)
	- block(38, spend=txout_b37)
	- yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
	+ # attempt to spend b37's first non-coinbase tx, at which point b37 was still considered valid
	+ self.move_tip(35)
	+ b38 = self.next_block(38, spend=txout_b37)
	+ self.sync_blocks([b38], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)

	# Check P2SH SigOp counting
	#
	@@ -547,8 +442,9 @@
	# redeem_script = COINBASE_PUBKEY, (OP_2DUP+OP_CHECKSIGVERIFY) * 5, OP_CHECKSIG
	# p2sh_script = OP_HASH160, ripemd160(sha256(script)), OP_EQUAL
	#
	- tip(35)
	- b39 = block(39)
	+ self.log.info("Check P2SH SIGOPS are correctly counted")
	+ self.move_tip(35)
	+ b39 = self.next_block(39)
	b39_outputs = 0
	b39_sigops_per_output = 6

	@@ -561,12 +457,12 @@
	# Create a transaction that spends one satoshi to the p2sh_script, the rest to OP_TRUE
	# This must be signed because it is spending a coinbase
	spend = out[11]
	- tx = create_tx(spend.tx, spend.n, 1, p2sh_script)
	+ tx = self.create_tx(spend.tx, spend.n, 1, p2sh_script)
	tx.vout.append(
	CTxOut(spend.tx.vout[spend.n].nValue - 1, CScript([OP_TRUE])))
	self.sign_tx(tx, spend.tx, spend.n)
	tx.rehash()
	- b39 = update_block(39, [tx])
	+ b39 = self.update_block(39, [tx])
	b39_outputs += 1

	# Until block is full, add tx's with 1 satoshi to p2sh_script, the rest
	@@ -576,7 +472,7 @@
	tx_last_n = len(tx.vout) - 1
	total_size = len(b39.serialize())
	while(total_size < LEGACY_MAX_BLOCK_SIZE):
	- tx_new = create_tx(tx_last, tx_last_n, 1, p2sh_script)
	+ tx_new = self.create_tx(tx_last, tx_last_n, 1, p2sh_script)
	tx_new.vout.append(
	CTxOut(tx_last.vout[tx_last_n].nValue - 1, CScript([OP_TRUE])))
	tx_new.rehash()
	@@ -588,9 +484,9 @@
	tx_last_n = len(tx_new.vout) - 1
	b39_outputs += 1

	- b39 = update_block(39, [])
	- yield accepted()
	- save_spendable_output()
	+ b39 = self.update_block(39, [])
	+ self.sync_blocks([b39], True)
	+ self.save_spendable_output()

	# Test sigops in P2SH redeem scripts
	#
	@@ -599,8 +495,9 @@
	#
	# b41 does the same, less one, so it has the maximum sigops permitted.
	#
	- tip(39)
	- b40 = block(40, spend=out[12])
	+ self.log.info("Reject a block with too many P2SH sigops")
	+ self.move_tip(39)
	+ b40 = self.next_block(40, spend=out[12])
	sigops = get_legacy_sigopcount_block(b40)
	numTxs = (MAX_BLOCK_SIGOPS_PER_MB - sigops) // b39_sigops_per_output
	assert_equal(numTxs <= b39_outputs, True)
	@@ -638,34 +535,34 @@
	pad_tx(tx)
	tx.rehash()
	new_txs.append(tx)
	- update_block(40, new_txs)
	- yield rejected(RejectResult(16, b'bad-blk-sigops'))
	+ self.update_block(40, new_txs)
	+ self.sync_blocks([b40], False, 16, b'bad-blk-sigops', reconnect=True)

	# same as b40, but one less sigop
	- tip(39)
	- block(41, spend=None)
	- update_block(41, [b40tx for b40tx in b40.vtx[1:] if b40tx != tx])
	+ self.log.info("Accept a block with the max number of P2SH sigops")
	+ self.move_tip(39)
	+ b41 = self.next_block(41, spend=None)
	+ self.update_block(41, [b40tx for b40tx in b40.vtx[1:] if b40tx != tx])
	b41_sigops_to_fill = b40_sigops_to_fill - 1
	tx = CTransaction()
	tx.vin.append(CTxIn(lastOutpoint, b''))
	tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b41_sigops_to_fill)))
	pad_tx(tx)
	- update_block(41, [tx])
	- yield accepted()
	+ self.update_block(41, [tx])
	+ self.sync_blocks([b41], True)

	# Fork off of b39 to create a constant base again
	#
	# b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13)
	# \-> b41 (12)
	#
	- tip(39)
	- block(42, spend=out[12])
	- yield rejected()
	- save_spendable_output()
	+ self.move_tip(39)
	+ b42 = self.next_block(42, spend=out[12])
	+ self.save_spendable_output()

	- block(43, spend=out[13])
	- yield accepted()
	- save_spendable_output()
	+ b43 = self.next_block(43, spend=out[13])
	+ self.save_spendable_output()
	+ self.sync_blocks([b42, b43], True)

	# Test a number of really invalid scenarios
	#
	@@ -673,8 +570,8 @@
	# \-> ??? (15)

	# The next few blocks are going to be created "by hand" since they'll do funky things, such as having
	- # the first transaction be non-coinbase, etc. The purpose of b44 is to
	- # make sure this works.
	+ # the first transaction be non-coinbase, etc. The purpose of b44 is to make sure this works.
	+ self.log.info("Build block 44 manually")
	height = self.block_heights[self.tip.sha256] + 1
	coinbase = create_coinbase(height, self.coinbase_pubkey)
	b44 = CBlock()
	@@ -687,10 +584,10 @@
	self.tip = b44
	self.block_heights[b44.sha256] = height
	self.blocks[44] = b44
	- yield accepted()
	+ self.sync_blocks([b44], True)

	- # A block with a non-coinbase as the first tx
	- non_coinbase = create_tx(out[15].tx, out[15].n, 1)
	+ self.log.info("Reject a block with a non-coinbase as the first tx")
	+ non_coinbase = self.create_tx(out[15].tx, out[15].n, 1)
	b45 = CBlock()
	b45.nTime = self.tip.nTime + 1
	b45.hashPrevBlock = self.tip.sha256
	@@ -703,10 +600,10 @@
	self.tip.sha256] + 1
	self.tip = b45
	self.blocks[45] = b45
	- yield rejected(RejectResult(16, b'bad-cb-missing'))
	+ self.sync_blocks([b45], False, 16, b'bad-cb-missing', reconnect=True)

	- # A block with no txns
	- tip(44)
	+ self.log.info("Reject a block with no transactions")
	+ self.move_tip(44)
	b46 = CBlock()
	b46.nTime = b44.nTime + 1
	b46.hashPrevBlock = b44.sha256
	@@ -718,77 +615,75 @@
	self.tip = b46
	assert 46 not in self.blocks
	self.blocks[46] = b46
	- s = ser_uint256(b46.hashMerkleRoot)
	- yield rejected(RejectResult(16, b'bad-cb-missing'))
	+ self.sync_blocks([b46], False, 16, b'bad-cb-missing', reconnect=True)

	- # A block with invalid work
	- tip(44)
	- b47 = block(47, solve=False)
	+ self.log.info("Reject a block with invalid work")
	+ self.move_tip(44)
	+ b47 = self.next_block(47, solve=False)
	target = uint256_from_compact(b47.nBits)
	- while b47.sha256 < target: # changed > to <
	+ while b47.sha256 < target:
	b47.nNonce += 1
	b47.rehash()
	- yield rejected(RejectResult(16, b'high-hash'))
	+ self.sync_blocks([b47], False, request_block=False)

	- # A block with timestamp > 2 hrs in the future
	- tip(44)
	- b48 = block(48, solve=False)
	+ self.log.info("Reject a block with a timestamp >2 hours in the future")
	+ self.move_tip(44)
	+ b48 = self.next_block(48, solve=False)
	b48.nTime = int(time.time()) + 60 * 60 * 3
	b48.solve()
	- yield rejected(RejectResult(16, b'time-too-new'))
	+ self.sync_blocks([b48], False, request_block=False)

	- # A block with an invalid merkle hash
	- tip(44)
	- b49 = block(49)
	+ self.log.info("Reject a block with invalid merkle hash")
	+ self.move_tip(44)
	+ b49 = self.next_block(49)
	b49.hashMerkleRoot += 1
	b49.solve()
	- yield rejected(RejectResult(16, b'bad-txnmrklroot'))
	+ self.sync_blocks([b49], False, 16, b'bad-txnmrklroot', reconnect=True)

	- # A block with an incorrect POW limit
	- tip(44)
	- b50 = block(50)
	+ self.log.info("Reject a block with incorrect POW limit")
	+ self.move_tip(44)
	+ b50 = self.next_block(50)
	b50.nBits = b50.nBits - 1
	b50.solve()
	- yield rejected(RejectResult(16, b'bad-diffbits'))
	+ self.sync_blocks([b50], False, request_block=False, reconnect=True)

	- # A block with two coinbase txns
	- tip(44)
	- b51 = block(51)
	+ self.log.info("Reject a block with two coinbase transactions")
	+ self.move_tip(44)
	+ b51 = self.next_block(51)
	cb2 = create_coinbase(51, self.coinbase_pubkey)
	- b51 = update_block(51, [cb2])
	- yield rejected(RejectResult(16, b'bad-tx-coinbase'))
	+ b51 = self.update_block(51, [cb2])
	+ self.sync_blocks([b51], False, 16, b'bad-tx-coinbase', reconnect=True)

	- # A block w/ duplicate txns
	- tip(44)
	- b52 = block(52, spend=out[15])
	- b52 = update_block(52, [b52.vtx[1]])
	- yield rejected(RejectResult(16, b'tx-duplicate'))
	+ self.log.info("Reject a block with duplicate transactions")
	+ self.move_tip(44)
	+ b52 = self.next_block(52, spend=out[15])
	+ b52 = self.update_block(52, [b52.vtx[1]])
	+ self.sync_blocks([b52], False, 16, b'tx-duplicate', reconnect=True)

	# Test block timestamps
	# -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
	# \-> b54 (15)
	#
	- tip(43)
	- block(53, spend=out[14])
	- yield rejected() # rejected since b44 is at same height
	- save_spendable_output()
	+ self.move_tip(43)
	+ b53 = self.next_block(53, spend=out[14])
	+ self.sync_blocks([b53], False)
	+ self.save_spendable_output()

	- # invalid timestamp (b35 is 5 blocks back, so its time is
	- # MedianTimePast)
	- b54 = block(54, spend=out[15])
	+ self.log.info("Reject a block with timestamp before MedianTimePast")
	+ b54 = self.next_block(54, spend=out[15])
	b54.nTime = b35.nTime - 1
	b54.solve()
	- yield rejected(RejectResult(16, b'time-too-old'))
	+ self.sync_blocks([b54], False, request_block=False)

	# valid timestamp
	- tip(53)
	- b55 = block(55, spend=out[15])
	+ self.move_tip(53)
	+ b55 = self.next_block(55, spend=out[15])
	b55.nTime = b35.nTime
	- update_block(55, [])
	- yield accepted()
	- save_spendable_output()
	+ self.update_block(55, [])
	+ self.sync_blocks([b55], True)
	+ self.save_spendable_output()

	- # Test CVE-2012-2459
	+ # Test Merkle tree malleability
	#
	# -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)
	# \-> b57 (16)
	@@ -816,46 +711,53 @@
	# that the error was caught early, avoiding a DOS vulnerability.)

	# b57 - a good block with 2 txs, don't submit until end
	- tip(55)
	- b57 = block(57)
	- tx = create_and_sign_tx(out[16].tx, out[16].n, 1)
	- tx1 = create_tx(tx, 0, 1)
	- b57 = update_block(57, [tx, tx1])
	+ self.move_tip(55)
	+ b57 = self.next_block(57)
	+ tx = self.create_and_sign_transaction(out[16].tx, out[16].n, 1)
	+ tx1 = self.create_tx(tx, 0, 1)
	+ b57 = self.update_block(57, [tx, tx1])

	# b56 - copy b57, add a duplicate tx
	- tip(55)
	+ self.log.info(
	+ "Reject a block with a duplicate transaction in the Merkle Tree (but with a valid Merkle Root)")
	+ self.move_tip(55)
	b56 = copy.deepcopy(b57)
	self.blocks[56] = b56
	assert_equal(len(b56.vtx), 3)
	- b56 = update_block(56, [b57.vtx[2]])
	+ b56 = self.update_block(56, [b57.vtx[2]])
	assert_equal(b56.hash, b57.hash)
	- yield rejected(RejectResult(16, b'bad-txns-duplicate'))
	+ self.sync_blocks([b56], False, 16,
	+ b'bad-txns-duplicate', reconnect=True)

	# b57p2 - a good block with 6 tx'es, don't submit until end
	- tip(55)
	- b57p2 = block("57p2")
	- tx = create_and_sign_tx(out[16].tx, out[16].n, 1)
	- tx1 = create_tx(tx, 0, 1)
	- tx2 = create_tx(tx1, 0, 1)
	- tx3 = create_tx(tx2, 0, 1)
	- tx4 = create_tx(tx3, 0, 1)
	- b57p2 = update_block("57p2", [tx, tx1, tx2, tx3, tx4])
	+ self.move_tip(55)
	+ b57p2 = self.next_block("57p2")
	+ tx = self.create_and_sign_transaction(out[16].tx, out[16].n, 1)
	+ tx1 = self.create_tx(tx, 0, 1)
	+ tx2 = self.create_tx(tx1, 0, 1)
	+ tx3 = self.create_tx(tx2, 0, 1)
	+ tx4 = self.create_tx(tx3, 0, 1)
	+ b57p2 = self.update_block("57p2", [tx, tx1, tx2, tx3, tx4])

	# b56p2 - copy b57p2, duplicate two non-consecutive tx's
	- tip(55)
	+ self.log.info(
	+ "Reject a block with two duplicate transactions in the Merkle Tree (but with a valid Merkle Root)")
	+ self.move_tip(55)
	b56p2 = copy.deepcopy(b57p2)
	self.blocks["b56p2"] = b56p2
	assert_equal(len(b56p2.vtx), 6)
	- b56p2 = update_block("b56p2", b56p2.vtx[4:6], reorder=False)
	+ b56p2 = self.update_block("b56p2", b56p2.vtx[4:6], reorder=False)
	assert_equal(b56p2.hash, b57p2.hash)
	- yield rejected(RejectResult(16, b'bad-txns-duplicate'))
	+ self.sync_blocks([b56p2], False, 16,
	+ b'bad-txns-duplicate', reconnect=True)

	- tip("57p2")
	- yield accepted()
	+ self.move_tip("57p2")
	+ self.sync_blocks([b57p2], True)

	- tip(57)
	- yield rejected() # rejected because 57p2 seen first
	- save_spendable_output()
	+ self.move_tip(57)
	+ # The tip is not updated because 57p2 seen first
	+ self.sync_blocks([b57], False)
	+ self.save_spendable_output()

	# Test a few invalid tx types
	#
	@@ -864,8 +766,10 @@
	#

	# tx with prevout.n out of range
	- tip(57)
	- b58 = block(58, spend=out[17])
	+ self.log.info(
	+ "Reject a block with a transaction with prevout.n out of range")
	+ self.move_tip(57)
	+ b58 = self.next_block(58, spend=out[17])
	tx = CTransaction()
	assert(len(out[17].tx.vout) < 42)
	tx.vin.append(
	@@ -873,21 +777,25 @@
	tx.vout.append(CTxOut(0, b""))
	pad_tx(tx)
	tx.calc_sha256()
	- b58 = update_block(58, [tx])
	- yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
	-
	- # tx with output value > input value out of range
	- tip(57)
	- b59 = block(59)
	- tx = create_and_sign_tx(out[17].tx, out[17].n, 51 * COIN)
	- b59 = update_block(59, [tx])
	- yield rejected(RejectResult(16, b'bad-txns-in-belowout'))
	+ b58 = self.update_block(58, [tx])
	+ self.sync_blocks([b58], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)
	+
	+ # tx with output value > input value
	+ self.log.info(
	+ "Reject a block with a transaction with outputs > inputs")
	+ self.move_tip(57)
	+ b59 = self.next_block(59)
	+ tx = self.create_and_sign_transaction(out[17].tx, out[17].n, 51 * COIN)
	+ b59 = self.update_block(59, [tx])
	+ self.sync_blocks([b59], False, 16,
	+ b'bad-txns-in-belowout', reconnect=True)

	# reset to good chain
	- tip(57)
	- b60 = block(60, spend=out[17])
	- yield accepted()
	- save_spendable_output()
	+ self.move_tip(57)
	+ b60 = self.next_block(60, spend=out[17])
	+ self.sync_blocks([b60], True)
	+ self.save_spendable_output()

	# Test BIP30
	#
	@@ -898,45 +806,51 @@
	# not-fully-spent transaction in the same chain. To test, make identical coinbases;
	# the second one should be rejected.
	#
	- tip(60)
	- b61 = block(61, spend=out[18])
	- b61.vtx[0].vin[0].scriptSig = b60.vtx[
	- 0].vin[0].scriptSig # equalize the coinbases
	+ self.log.info(
	+ "Reject a block with a transaction with a duplicate hash of a previous transaction (BIP30)")
	+ self.move_tip(60)
	+ b61 = self.next_block(61, spend=out[18])
	+ # Equalize the coinbases
	+ b61.vtx[0].vin[0].scriptSig = b60.vtx[0].vin[0].scriptSig
	b61.vtx[0].rehash()
	- b61 = update_block(61, [])
	+ b61 = self.update_block(61, [])
	assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize())
	- yield rejected(RejectResult(16, b'bad-txns-BIP30'))
	+ self.sync_blocks([b61], False, 16, b'bad-txns-BIP30', reconnect=True)

	# Test tx.isFinal is properly rejected (not an exhaustive tx.isFinal test, that should be in data-driven transaction tests)
	#
	# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
	# \-> b62 (18)
	#
	- tip(60)
	- b62 = block(62)
	+ self.log.info(
	+ "Reject a block with a transaction with a nonfinal locktime")
	+ self.move_tip(60)
	+ b62 = self.next_block(62)
	tx = CTransaction()
	tx.nLockTime = 0xffffffff # this locktime is non-final
	assert(out[18].n < len(out[18].tx.vout))
	- tx.vin.append(
	- CTxIn(COutPoint(out[18].tx.sha256, out[18].n))) # don't set nSequence
	+ # don't set nSequence
	+ tx.vin.append(CTxIn(COutPoint(out[18].tx.sha256, out[18].n)))
	tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
	assert(tx.vin[0].nSequence < 0xffffffff)
	tx.calc_sha256()
	- b62 = update_block(62, [tx])
	- yield rejected(RejectResult(16, b'bad-txns-nonfinal'))
	+ b62 = self.update_block(62, [tx])
	+ self.sync_blocks([b62], False, 16, b'bad-txns-nonfinal')

	# Test a non-final coinbase is also rejected
	#
	# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
	# \-> b63 (-)
	#
	- tip(60)
	- b63 = block(63)
	+ self.log.info(
	+ "Reject a block with a coinbase transaction with a nonfinal locktime")
	+ self.move_tip(60)
	+ b63 = self.next_block(63)
	b63.vtx[0].nLockTime = 0xffffffff
	b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
	b63.vtx[0].rehash()
	- b63 = update_block(63, [])
	- yield rejected(RejectResult(16, b'bad-txns-nonfinal'))
	+ b63 = self.update_block(63, [])
	+ self.sync_blocks([b63], False, 16, b'bad-txns-nonfinal')

	# This checks that a block with a bloated VARINT between the block_header and the array of tx such that
	# the block is > LEGACY_MAX_BLOCK_SIZE with the bloated varint, but <= LEGACY_MAX_BLOCK_SIZE without the bloated varint,
	@@ -952,8 +866,10 @@
	# b64a is a bloated block (non-canonical varint)
	# b64 is a good block (same as b64 but w/ canonical varint)
	#
	- tip(60)
	- regular_block = block("64a", spend=out[18])
	+ self.log.info(
	+ "Accept a valid block even if a bloated version of the block has previously been sent")
	+ self.move_tip(60)
	+ regular_block = self.next_block("64a", spend=out[18])

	# make it a "broken_block," with non-canonical serialization
	b64a = CBrokenBlock(regular_block)
	@@ -968,36 +884,41 @@
	script_output = CScript([b'\x00' * script_length])
	tx.vout.append(CTxOut(0, script_output))
	tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
	- b64a = update_block("64a", [tx])
	+ b64a = self.update_block("64a", [tx])
	assert_equal(len(b64a.serialize()), LEGACY_MAX_BLOCK_SIZE + 8)
	- yield TestInstance([[self.tip, None]])
	+ self.sync_blocks([b64a], False, 1, b'error parsing message')

	- # comptool workaround: to make sure b64 is delivered, manually erase
	- # b64a from blockstore
	- self.test.block_store.erase(b64a.sha256)
	+ # bitcoind doesn't disconnect us for sending a bloated block, but if we subsequently
	+ # resend the header message, it won't send us the getdata message again. Just
	+ # disconnect and reconnect and then call sync_blocks.
	+ # TODO: improve this test to be less dependent on P2P DOS behaviour.
	+ node.disconnect_p2ps()
	+ self.reconnect_p2p()

	- tip(60)
	+ self.move_tip(60)
	b64 = CBlock(b64a)
	b64.vtx = copy.deepcopy(b64a.vtx)
	assert_equal(b64.hash, b64a.hash)
	assert_equal(len(b64.serialize()), LEGACY_MAX_BLOCK_SIZE)
	self.blocks[64] = b64
	- update_block(64, [])
	- yield accepted()
	- save_spendable_output()
	+ b64 = self.update_block(64, [])
	+ self.sync_blocks([b64], True)
	+ self.save_spendable_output()

	# Spend an output created in the block itself
	#
	# -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
	#
	- tip(64)
	- block(65)
	- tx1 = create_and_sign_tx(
	+ self.log.info(
	+ "Accept a block with a transaction spending an output created in the same block")
	+ self.move_tip(64)
	+ b65 = self.next_block(65)
	+ tx1 = self.create_and_sign_transaction(
	out[19].tx, out[19].n, out[19].tx.vout[0].nValue)
	- tx2 = create_and_sign_tx(tx1, 0, 0)
	- update_block(65, [tx1, tx2])
	- yield accepted()
	- save_spendable_output()
	+ tx2 = self.create_and_sign_transaction(tx1, 0, 0)
	+ b65 = self.update_block(65, [tx1, tx2])
	+ self.sync_blocks([b65], True)
	+ self.save_spendable_output()

	# Attempt to double-spend a transaction created in a block
	#
	@@ -1005,14 +926,17 @@
	# \-> b67 (20)
	#
	#
	- tip(65)
	- block(67)
	- tx1 = create_and_sign_tx(
	+ self.log.info(
	+ "Reject a block with a transaction double spending a transaction created in the same block")
	+ self.move_tip(65)
	+ b67 = self.next_block(67)
	+ tx1 = self.create_and_sign_transaction(
	out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
	- tx2 = create_and_sign_tx(tx1, 0, 1)
	- tx3 = create_and_sign_tx(tx1, 0, 2)
	- update_block(67, [tx1, tx2, tx3])
	- yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
	+ tx2 = self.create_and_sign_transaction(tx1, 0, 1)
	+ tx3 = self.create_and_sign_transaction(tx1, 0, 2)
	+ b67 = self.update_block(67, [tx1, tx2, tx3])
	+ self.sync_blocks([b67], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)

	# More tests of block subsidy
	#
	@@ -1026,28 +950,34 @@
	# b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee
	# this succeeds
	#
	- tip(65)
	- block(68, additional_coinbase_value=10)
	- tx = create_and_sign_tx(
	+ self.log.info(
	+ "Reject a block trying to claim too much subsidy in the coinbase transaction")
	+ self.move_tip(65)
	+ b68 = self.next_block(68, additional_coinbase_value=10)
	+ tx = self.create_and_sign_transaction(
	out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 9)
	- update_block(68, [tx])
	- yield rejected(RejectResult(16, b'bad-cb-amount'))
	-
	- tip(65)
	- b69 = block(69, additional_coinbase_value=10)
	- tx = create_and_sign_tx(
	+ b68 = self.update_block(68, [tx])
	+ self.sync_blocks([b68], False, 16, b'bad-cb-amount', reconnect=True)
	+
	+ self.log.info(
	+ "Accept a block claiming the correct subsidy in the coinbase transaction")
	+ self.move_tip(65)
	+ b69 = self.next_block(69, additional_coinbase_value=10)
	+ tx = self.create_and_sign_transaction(
	out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 10)
	- update_block(69, [tx])
	- yield accepted()
	- save_spendable_output()
	+ self.update_block(69, [tx])
	+ self.sync_blocks([b69], True)
	+ self.save_spendable_output()

	# Test spending the outpoint of a non-existent transaction
	#
	# -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
	# \-> b70 (21)
	#
	- tip(69)
	- block(70, spend=out[21])
	+ self.log.info(
	+ "Reject a block containing a transaction spending from a non-existent input")
	+ self.move_tip(69)
	+ b70 = self.next_block(70, spend=out[21])
	bogus_tx = CTransaction()
	bogus_tx.sha256 = uint256_from_str(
	b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")
	@@ -1055,9 +985,9 @@
	tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))
	tx.vout.append(CTxOut(1, b""))
	pad_tx(tx)
	- tx.rehash()
	- update_block(70, [tx])
	- yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
	+ b70 = self.update_block(70, [tx])
	+ self.sync_blocks([b70], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)

	# Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
	#
	@@ -1065,13 +995,14 @@
	# \-> b71 (21)
	#
	# b72 is a good block.
	- # b71 is a copy of 72, but re-adds one of its transactions. However, it has the same hash as b71.
	- #
	- tip(69)
	- b72 = block(72)
	- tx1 = create_and_sign_tx(out[21].tx, out[21].n, 2)
	- tx2 = create_and_sign_tx(tx1, 0, 1)
	- b72 = update_block(72, [tx1, tx2]) # now tip is 72
	+ # b71 is a copy of 72, but re-adds one of its transactions. However, it has the same hash as b72.
	+ self.log.info(
	+ "Reject a block containing a duplicate transaction but with the same Merkle root (Merkle tree malleability")
	+ self.move_tip(69)
	+ b72 = self.next_block(72)
	+ tx1 = self.create_and_sign_transaction(out[21].tx, out[21].n, 2)
	+ tx2 = self.create_and_sign_transaction(tx1, 0, 1)
	+ b72 = self.update_block(72, [tx1, tx2]) # now tip is 72
	b71 = copy.deepcopy(b72)
	# add duplicate last transaction
	b71.vtx.append(b72.vtx[-1])
	@@ -1083,11 +1014,13 @@
	assert_equal(len(b72.vtx), 3)
	assert_equal(b72.sha256, b71.sha256)

	- tip(71)
	- yield rejected(RejectResult(16, b'bad-txns-duplicate'))
	- tip(72)
	- yield accepted()
	- save_spendable_output()
	+ self.move_tip(71)
	+ self.sync_blocks([b71], False, 16,
	+ b'bad-txns-duplicate', reconnect=True)
	+
	+ self.move_tip(72)
	+ self.sync_blocks([b72], True)
	+ self.save_spendable_output()

	# Test some invalid scripts and MAX_BLOCK_SIGOPS_PER_MB
	#
	@@ -1105,11 +1038,11 @@
	# bytearray[20,000-20,003]: 521 (max_script_element_size+1, in little-endian format)
	# bytearray[20,004-20,525]: unread data (script_element)
	# bytearray[20,526] : OP_CHECKSIG (this puts us over the limit)
	- #
	- tip(72)
	- b73 = block(73)
	- size = MAX_BLOCK_SIGOPS_PER_MB - 1 + \
	- MAX_SCRIPT_ELEMENT_SIZE + 1 + 5 + 1
	+ self.log.info(
	+ "Reject a block containing too many sigops after a large script element")
	+ self.move_tip(72)
	+ b73 = self.next_block(73)
	+ size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5 + 1
	a = bytearray([OP_CHECKSIG] * size)
	a[MAX_BLOCK_SIGOPS_PER_MB - 1] = int("4e", 16) # OP_PUSHDATA4

	@@ -1119,11 +1052,11 @@
	a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0
	a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0

	- tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))
	- b73 = update_block(73, [tx])
	- assert_equal(
	- get_legacy_sigopcount_block(b73), MAX_BLOCK_SIGOPS_PER_MB + 1)
	- yield rejected(RejectResult(16, b'bad-blk-sigops'))
	+ tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
	+ b73 = self.update_block(73, [tx])
	+ assert_equal(get_legacy_sigopcount_block(
	+ b73), MAX_BLOCK_SIGOPS_PER_MB + 1)
	+ self.sync_blocks([b73], False, 16, b'bad-blk-sigops', reconnect=True)

	# b74/75 - if we push an invalid script element, all prevous sigops are counted,
	# but sigops after the element are not counted.
	@@ -1135,10 +1068,10 @@
	#
	# b74 fails because we put MAX_BLOCK_SIGOPS_PER_MB+1 before the element
	# b75 succeeds because we put MAX_BLOCK_SIGOPS_PER_MB before the element
	- #
	- #
	- tip(72)
	- b74 = block(74)
	+ self.log.info(
	+ "Check sigops are counted correctly after an invalid script element")
	+ self.move_tip(72)
	+ b74 = self.next_block(74)
	size = MAX_BLOCK_SIGOPS_PER_MB - 1 + \
	MAX_SCRIPT_ELEMENT_SIZE + 42 # total = 20,561
	a = bytearray([OP_CHECKSIG] * size)
	@@ -1147,12 +1080,12 @@
	a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff
	a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff
	a[MAX_BLOCK_SIGOPS_PER_MB + 4] = 0xff
	- tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))
	- b74 = update_block(74, [tx])
	- yield rejected(RejectResult(16, b'bad-blk-sigops'))
	+ tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
	+ b74 = self.update_block(74, [tx])
	+ self.sync_blocks([b74], False, 16, b'bad-blk-sigops', reconnect=True)

	- tip(72)
	- b75 = block(75)
	+ self.move_tip(72)
	+ b75 = self.next_block(75)
	size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42
	a = bytearray([OP_CHECKSIG] * size)
	a[MAX_BLOCK_SIGOPS_PER_MB - 1] = 0x4e
	@@ -1160,23 +1093,22 @@
	a[MAX_BLOCK_SIGOPS_PER_MB + 1] = 0xff
	a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff
	a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff
	- tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))
	- b75 = update_block(75, [tx])
	- yield accepted()
	- save_spendable_output()
	-
	- # Check that if we push an element filled with CHECKSIGs, they are not
	- # counted
	- tip(75)
	- b76 = block(76)
	+ tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
	+ b75 = self.update_block(75, [tx])
	+ self.sync_blocks([b75], True)
	+ self.save_spendable_output()
	+
	+ # Check that if we push an element filled with CHECKSIGs, they are not counted
	+ self.move_tip(75)
	+ b76 = self.next_block(76)
	size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5
	a = bytearray([OP_CHECKSIG] * size)
	- a[MAX_BLOCK_SIGOPS_PER_MB -
	- 1] = 0x4e # PUSHDATA4, but leave the following bytes as just checksigs
	- tx = create_and_sign_tx(out[23].tx, 0, 1, CScript(a))
	- b76 = update_block(76, [tx])
	- yield accepted()
	- save_spendable_output()
	+ # PUSHDATA4, but leave the following bytes as just checksigs
	+ a[MAX_BLOCK_SIGOPS_PER_MB - 1] = 0x4e
	+ tx = self.create_and_sign_transaction(out[23].tx, 0, 1, CScript(a))
	+ b76 = self.update_block(76, [tx])
	+ self.sync_blocks([b76], True)
	+ self.save_spendable_output()

	# Test transaction resurrection
	#
	@@ -1195,39 +1127,42 @@
	# To get around this issue, we construct transactions which are not signed and which
	# spend to OP_TRUE. If the standard-ness rules change, this test would need to be
	# updated. (Perhaps to spend to a P2SH OP_TRUE script)
	- #
	- tip(76)
	- block(77)
	- tx77 = create_and_sign_tx(out[24].tx, out[24].n, 10 * COIN)
	- update_block(77, [tx77])
	- yield accepted()
	- save_spendable_output()
	-
	- block(78)
	- tx78 = create_tx(tx77, 0, 9 * COIN)
	- update_block(78, [tx78])
	- yield accepted()
	-
	- block(79)
	- tx79 = create_tx(tx78, 0, 8 * COIN)
	- update_block(79, [tx79])
	- yield accepted()
	+ self.log.info("Test transaction resurrection during a re-org")
	+ self.move_tip(76)
	+ b77 = self.next_block(77)
	+ tx77 = self.create_and_sign_transaction(
	+ out[24].tx, out[24].n, 10 * COIN)
	+ b77 = self.update_block(77, [tx77])
	+ self.sync_blocks([b77], True)
	+ self.save_spendable_output()
	+
	+ b78 = self.next_block(78)
	+ tx78 = self.create_tx(tx77, 0, 9 * COIN)
	+ b78 = self.update_block(78, [tx78])
	+ self.sync_blocks([b78], True)
	+
	+ b79 = self.next_block(79)
	+ tx79 = self.create_tx(tx78, 0, 8 * COIN)
	+ b79 = self.update_block(79, [tx79])
	+ self.sync_blocks([b79], True)

	# mempool should be empty
	assert_equal(len(self.nodes[0].getrawmempool()), 0)

	- tip(77)
	- block(80, spend=out[25])
	- yield rejected()
	- save_spendable_output()
	+ self.move_tip(77)
	+ b80 = self.next_block(80, spend=out[25])
	+ self.sync_blocks([b80], False, request_block=False)
	+ self.save_spendable_output()

	- block(81, spend=out[26])
	- yield rejected() # other chain is same length
	- save_spendable_output()
	+ b81 = self.next_block(81, spend=out[26])
	+ # other chain is same length
	+ self.sync_blocks([b81], False, request_block=False)
	+ self.save_spendable_output()

	- block(82, spend=out[27])
	- yield accepted() # now this chain is longer, triggers re-org
	- save_spendable_output()
	+ b82 = self.next_block(82, spend=out[27])
	+ # now this chain is longer, triggers re-org
	+ self.sync_blocks([b82], True)
	+ self.save_spendable_output()

	# now check that tx78 and tx79 have been put back into the peer's
	# mempool
	@@ -1240,28 +1175,30 @@
	#
	# -> b81 (26) -> b82 (27) -> b83 (28)
	#
	- block(83)
	+ self.log.info(
	+ "Accept a block with invalid opcodes in dead execution paths")
	+ b83 = self.next_block(83)
	op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
	script = CScript(op_codes)
	- tx1 = create_and_sign_tx(
	+ tx1 = self.create_and_sign_transaction(
	out[28].tx, out[28].n, out[28].tx.vout[0].nValue, script)

	- tx2 = create_and_sign_tx(tx1, 0, 0, CScript([OP_TRUE]))
	+ tx2 = self.create_and_sign_transaction(tx1, 0, 0, CScript([OP_TRUE]))
	tx2.vin[0].scriptSig = CScript([OP_FALSE])
	tx2.rehash()

	- update_block(83, [tx1, tx2])
	- yield accepted()
	- save_spendable_output()
	+ b83 = self.update_block(83, [tx1, tx2])
	+ self.sync_blocks([b83], True)
	+ self.save_spendable_output()

	# Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
	#
	# -> b81 (26) -> b82 (27) -> b83 (28) -> b84 (29) -> b87 (30) -> b88 (31)
	# \-> b85 (29) -> b86 (30) \-> b89a (32)
	#
	- #
	- block(84)
	- tx1 = create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN]))
	+ self.log.info("Test re-orging blocks with OP_RETURN in them")
	+ b84 = self.next_block(84)
	+ tx1 = self.create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN]))
	vout_offset = len(tx1.vout)
	tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
	tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
	@@ -1270,84 +1207,196 @@
	tx1.calc_sha256()
	self.sign_tx(tx1, out[29].tx, out[29].n)
	tx1.rehash()
	- tx2 = create_tx(tx1, vout_offset, 0, CScript([OP_RETURN]))
	+ tx2 = self.create_tx(tx1, vout_offset, 0, CScript([OP_RETURN]))
	tx2.vout.append(CTxOut(0, CScript([OP_RETURN])))
	- tx3 = create_tx(tx1, vout_offset + 1, 0, CScript([OP_RETURN]))
	+ tx3 = self.create_tx(tx1, vout_offset + 1, 0, CScript([OP_RETURN]))
	tx3.vout.append(CTxOut(0, CScript([OP_TRUE])))
	- tx4 = create_tx(tx1, vout_offset + 2, 0, CScript([OP_TRUE]))
	+ tx4 = self.create_tx(tx1, vout_offset + 2, 0, CScript([OP_TRUE]))
	tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
	- tx5 = create_tx(tx1, vout_offset + 3, 0, CScript([OP_RETURN]))
	+ tx5 = self.create_tx(tx1, vout_offset + 3, 0, CScript([OP_RETURN]))

	- update_block(84, [tx1, tx2, tx3, tx4, tx5])
	- yield accepted()
	- save_spendable_output()
	+ b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
	+ self.sync_blocks([b84], True)
	+ self.save_spendable_output()

	- tip(83)
	- block(85, spend=out[29])
	- yield rejected()
	+ self.move_tip(83)
	+ b85 = self.next_block(85, spend=out[29])
	+ self.sync_blocks([b85], False) # other chain is same length

	- block(86, spend=out[30])
	- yield accepted()
	+ b86 = self.next_block(86, spend=out[30])
	+ self.sync_blocks([b86], True)

	- tip(84)
	- block(87, spend=out[30])
	- yield rejected()
	- save_spendable_output()
	+ self.move_tip(84)
	+ b87 = self.next_block(87, spend=out[30])
	+ self.sync_blocks([b87], False) # other chain is same length
	+ self.save_spendable_output()

	- block(88, spend=out[31])
	- yield accepted()
	- save_spendable_output()
	+ b88 = self.next_block(88, spend=out[31])
	+ self.sync_blocks([b88], True)
	+ self.save_spendable_output()

	# trying to spend the OP_RETURN output is rejected
	- block("89a", spend=out[32])
	- tx = create_tx(tx1, 0, 0, CScript([OP_TRUE]))
	- update_block("89a", [tx])
	- yield rejected()
	-
	- # Test re-org of a week's worth of blocks (1088 blocks)
	- # This test takes a minute or two and can be accomplished in memory
	- #
	- if self.options.runbarelyexpensive:
	- tip(88)
	- LARGE_REORG_SIZE = 1088
	- test1 = TestInstance(sync_every_block=False)
	- spend = out[32]
	- for i in range(89, LARGE_REORG_SIZE + 89):
	- b = block(i, spend)
	- tx = CTransaction()
	- script_length = LEGACY_MAX_BLOCK_SIZE - len(b.serialize()) - 69
	- script_output = CScript([b'\x00' * script_length])
	- tx.vout.append(CTxOut(0, script_output))
	- tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
	- b = update_block(i, [tx])
	- assert_equal(len(b.serialize()), LEGACY_MAX_BLOCK_SIZE)
	- test1.blocks_and_transactions.append([self.tip, True])
	- save_spendable_output()
	- spend = get_spendable_output()
	-
	- yield test1
	- chain1_tip = i
	-
	- # now create alt chain of same length
	- tip(88)
	- test2 = TestInstance(sync_every_block=False)
	- for i in range(89, LARGE_REORG_SIZE + 89):
	- block("alt" + str(i))
	- test2.blocks_and_transactions.append([self.tip, False])
	- yield test2
	-
	- # extend alt chain to trigger re-org
	- block("alt" + str(chain1_tip + 1))
	- yield accepted()
	-
	- # ... and re-org back to the first chain
	- tip(chain1_tip)
	- block(chain1_tip + 1)
	- yield rejected()
	- block(chain1_tip + 2)
	- yield accepted()
	-
	- chain1_tip += 2
	+ b89a = self.next_block("89a", spend=out[32])
	+ tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
	+ b89a = self.update_block("89a", [tx])
	+ self.sync_blocks([b89a], False, 16,
	+ b'bad-txns-inputs-missingorspent', reconnect=True)
	+
	+ self.log.info(
	+ "Test a re-org of one week's worth of blocks (1088 blocks)")
	+
	+ self.move_tip(88)
	+ LARGE_REORG_SIZE = 1088
	+ blocks = []
	+ spend = out[32]
	+ for i in range(89, LARGE_REORG_SIZE + 89):
	+ b = self.next_block(i, spend)
	+ tx = CTransaction()
	+ script_length = LEGACY_MAX_BLOCK_SIZE - len(b.serialize()) - 69
	+ script_output = CScript([b'\x00' * script_length])
	+ tx.vout.append(CTxOut(0, script_output))
	+ tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
	+ b = self.update_block(i, [tx])
	+ assert_equal(len(b.serialize()), LEGACY_MAX_BLOCK_SIZE)
	+ blocks.append(b)
	+ self.save_spendable_output()
	+ spend = self.get_spendable_output()
	+
	+ self.sync_blocks(blocks, True, timeout=180)
	+ chain1_tip = i
	+
	+ # now create alt chain of same length
	+ self.move_tip(88)
	+ blocks2 = []
	+ for i in range(89, LARGE_REORG_SIZE + 89):
	+ blocks2.append(self.next_block("alt" + str(i)))
	+ self.sync_blocks(blocks2, False, request_block=False)
	+
	+ # extend alt chain to trigger re-org
	+ block = self.next_block("alt" + str(chain1_tip + 1))
	+ self.sync_blocks([block], True, timeout=180)
	+
	+ # ... and re-org back to the first chain
	+ self.move_tip(chain1_tip)
	+ block = self.next_block(chain1_tip + 1)
	+ self.sync_blocks([block], False, request_block=False)
	+ block = self.next_block(chain1_tip + 2)
	+ self.sync_blocks([block], True, timeout=180)
	+
	+ # Helper methods
	+ ################
	+
	+ def add_transactions_to_block(self, block, tx_list):
	+ [tx.rehash() for tx in tx_list]
	+ block.vtx.extend(tx_list)
	+
	+ # this is a little handier to use than the version in blocktools.py
	+ def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE])):
	+ return create_transaction(spend_tx, n, b"", value, script)
	+
	+ # sign a transaction, using the key we know about
	+ # this signs input 0 in tx, which is assumed to be spending output n in spend_tx
	+ def sign_tx(self, tx, spend_tx, n):
	+ scriptPubKey = bytearray(spend_tx.vout[n].scriptPubKey)
	+ if (scriptPubKey[0] == OP_TRUE): # an anyone-can-spend
	+ tx.vin[0].scriptSig = CScript()
	+ return
	+ sighash = SignatureHashForkId(
	+ spend_tx.vout[n].scriptPubKey, tx, 0, SIGHASH_ALL \| SIGHASH_FORKID, spend_tx.vout[n].nValue)
	+ tx.vin[0].scriptSig = CScript(
	+ [self.coinbase_key.sign(sighash) + bytes(bytearray([SIGHASH_ALL \| SIGHASH_FORKID]))])
	+
	+ def create_and_sign_transaction(self, spend_tx, n, value, script=CScript([OP_TRUE])):
	+ tx = self.create_tx(spend_tx, n, value, script)
	+ self.sign_tx(tx, spend_tx, n)
	+ tx.rehash()
	+ return tx
	+
	+ def next_block(self, number, spend=None, additional_coinbase_value=0, script=CScript([OP_TRUE]), solve=True):
	+ if self.tip is None:
	+ base_block_hash = self.genesis_hash
	+ block_time = int(time.time()) + 1
	+ else:
	+ base_block_hash = self.tip.sha256
	+ block_time = self.tip.nTime + 1
	+ # First create the coinbase
	+ height = self.block_heights[base_block_hash] + 1
	+ coinbase = create_coinbase(height, self.coinbase_pubkey)
	+ coinbase.vout[0].nValue += additional_coinbase_value
	+ coinbase.rehash()
	+ if spend is None:
	+ block = create_block(base_block_hash, coinbase, block_time)
	+ else:
	+ # all but one satoshi to fees
	+ coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1
	+ coinbase.rehash()
	+ block = create_block(base_block_hash, coinbase, block_time)
	+ # spend 1 satoshi
	+ tx = create_transaction(spend.tx, spend.n, b"", 1, script)
	+ self.sign_tx(tx, spend.tx, spend.n)
	+ self.add_transactions_to_block(block, [tx])
	+ block.hashMerkleRoot = block.calc_merkle_root()
	+ if solve:
	+ block.solve()
	+ self.tip = block
	+ self.block_heights[block.sha256] = height
	+ assert number not in self.blocks
	+ self.blocks[number] = block
	+ return block
	+
	+ # save the current tip so it can be spent by a later block
	+ def save_spendable_output(self):
	+ self.log.debug("saving spendable output {}".format(self.tip.vtx[0]))
	+ self.spendable_outputs.append(self.tip)
	+
	+ # get an output that we previously marked as spendable
	+ def get_spendable_output(self):
	+ self.log.debug("getting spendable output {}".format(
	+ self.spendable_outputs[0].vtx[0]))
	+ return PreviousSpendableOutput(self.spendable_outputs.pop(0).vtx[0], 0)
	+
	+ # move the tip back to a previous block
	+ def move_tip(self, number):
	+ self.tip = self.blocks[number]
	+
	+ # adds transactions to the block and updates state
	+ def update_block(self, block_number, new_transactions, reorder=True):
	+ block = self.blocks[block_number]
	+ self.add_transactions_to_block(block, new_transactions)
	+ old_sha256 = block.sha256
	+ if reorder:
	+ make_conform_to_ctor(block)
	+ block.hashMerkleRoot = block.calc_merkle_root()
	+ block.solve()
	+ # Update the internal state just like in next_block
	+ self.tip = block
	+ if block.sha256 != old_sha256:
	+ self.block_heights[block.sha256] = self.block_heights[old_sha256]
	+ del self.block_heights[old_sha256]
	+ self.blocks[block_number] = block
	+ return block
	+
	+ def reconnect_p2p(self):
	+ """Add a P2P connection to the node.
	+
	+ The node gets disconnected several times in this test. This helper
	+ method reconnects the p2p and restarts the network thread."""
	+
	+ network_thread_join()
	+ self.nodes[0].disconnect_p2ps()
	+ self.nodes[0].add_p2p_connection(P2PDataStore())
	+ network_thread_start()
	+ self.nodes[0].p2p.wait_for_verack()
	+
	+ def sync_blocks(self, blocks, success=True, reject_code=None, reject_reason=None, request_block=True, reconnect=False, timeout=60):
	+ """Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
	+
	+ Call with success = False if the tip shouldn't advance to the most recent block."""
	+ self.nodes[0].p2p.send_blocks_and_test(blocks, self.nodes[0], success=success, reject_code=reject_code,
	+ reject_reason=reject_reason, request_block=request_block, timeout=timeout)
	+
	+ if reconnect:
	+ self.reconnect_p2p()


	if __name__ == '__main__':
	diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
	--- a/test/functional/test_framework/util.py
	+++ b/test/functional/test_framework/util.py
	@@ -8,6 +8,7 @@
	from binascii import hexlify, unhexlify
	from decimal import Decimal, ROUND_DOWN
	import hashlib
	+import inspect
	import json
	import logging
	import os
	@@ -242,9 +243,9 @@
	if attempts == float('inf') and timeout == float('inf'):
	timeout = 60
	attempt = 0
	- timeout += time.time()
	+ time_end = time.time() + timeout

	- while attempt < attempts and time.time() < timeout:
	+ while attempt < attempts and time.time() < time_end:
	if lock:
	with lock:
	if predicate():
	@@ -256,8 +257,14 @@
	time.sleep(0.05)

	# Print the cause of the timeout
	- assert_greater_than(attempts, attempt)
	- assert_greater_than(timeout, time.time())
	+ predicate_source = inspect.getsourcelines(predicate)
	+ logger.error("wait_until() failed. Predicate: {}".format(predicate_source))
	+ if attempt >= attempts:
	+ raise AssertionError("Predicate {} not true after {} attempts".format(
	+ predicate_source, attempts))
	+ elif time.time() >= time_end:
	+ raise AssertionError(
	+ "Predicate {} not true after {} seconds".format(predicate_source, timeout))
	raise RuntimeError('Unreachable')

	# RPC/P2P connection constants and functions

File Metadata

Mime Type: text/plain
Expires: Mon, May 12, 01:37 (3 h, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5777024
Default Alt Text: D3514.diff (76 KB)

D3514.diffNo OneTemporaryActions

D3514.diffView Options

File Metadata

Event Timeline

D3514.diff
No OneTemporary
Actions

D3514.diff
View Options