Differential D3514 Diff 9902 test/functional/feature_block.py

Changeset View

Standalone View

test/functional/feature_block.py

#!/usr/bin/env python3		#!/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		# Copyright (c) 2017 The Bitcoin developers
# Distributed under the MIT software license, see the accompanying		# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.		# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test block processing.		"""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.
"""

import copy		import copy
import struct		import struct
import time		import time

from test_framework.blocktools import (		from test_framework.blocktools import (
create_block,		create_block,
create_coinbase,		create_coinbase,
create_transaction,		create_transaction,
get_legacy_sigopcount_block,		get_legacy_sigopcount_block,
make_conform_to_ctor,		make_conform_to_ctor,
)		)
from test_framework.cdefs import LEGACY_MAX_BLOCK_SIZE, MAX_BLOCK_SIGOPS_PER_MB		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.key import CECKey
from test_framework.messages import (		from test_framework.messages import (
CBlock,		CBlock,
CBlockHeader,
COIN,		COIN,
COutPoint,		COutPoint,
CTransaction,		CTransaction,
CTxIn,		CTxIn,
CTxOut,		CTxOut,
ser_uint256,
uint256_from_compact,		uint256_from_compact,
uint256_from_str,		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 (		from test_framework.script import (
CScript,		CScript,
hash160,		hash160,
MAX_SCRIPT_ELEMENT_SIZE,		MAX_SCRIPT_ELEMENT_SIZE,
OP_2DUP,		OP_2DUP,
OP_CHECKMULTISIG,		OP_CHECKMULTISIG,
OP_CHECKMULTISIGVERIFY,		OP_CHECKMULTISIGVERIFY,
OP_CHECKSIG,		OP_CHECKSIG,
OP_CHECKSIGVERIFY,		OP_CHECKSIGVERIFY,
OP_ELSE,		OP_ELSE,
OP_ENDIF,		OP_ENDIF,
OP_EQUAL,		OP_EQUAL,
OP_FALSE,		OP_FALSE,
OP_HASH160,		OP_HASH160,
OP_IF,		OP_IF,
OP_INVALIDOPCODE,		OP_INVALIDOPCODE,
OP_RETURN,		OP_RETURN,
OP_TRUE,		OP_TRUE,
SIGHASH_ALL,		SIGHASH_ALL,
SIGHASH_FORKID,		SIGHASH_FORKID,
SignatureHashForkId,		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.txtools import pad_tx
from test_framework.util import assert_equal		from test_framework.util import assert_equal


class PreviousSpendableOutput():		class PreviousSpendableOutput():
def __init__(self, tx=CTransaction(), n=-1):		def __init__(self, tx=CTransaction(), n=-1):
self.tx = tx		self.tx = tx
self.n = n # the output we're spending		self.n = n # the output we're spending

# Use this class for tests that require behavior other than normal "mininode" behavior.		# Use this class for tests that require behavior other than normal "mininode" behavior.
# For now, it is used to serialize a bloated varint (b64).		# For now, it is used to serialize a bloated varint (b64).


class CBrokenBlock(CBlock):		class CBrokenBlock(CBlock):

def __init__(self, header=None):
super(CBrokenBlock, self).__init__(header)

def initialize(self, base_block):		def initialize(self, base_block):
self.vtx = copy.deepcopy(base_block.vtx)		self.vtx = copy.deepcopy(base_block.vtx)
self.hashMerkleRoot = self.calc_merkle_root()		self.hashMerkleRoot = self.calc_merkle_root()

def serialize(self):		def serialize(self):
r = b""		r = b""
r += super(CBlock, self).serialize()		r += super(CBlock, self).serialize()
r += struct.pack("<BQ", 255, len(self.vtx))		r += struct.pack("<BQ", 255, len(self.vtx))
for tx in self.vtx:		for tx in self.vtx:
r += tx.serialize()		r += tx.serialize()
return r		return r

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


class FullBlockTest(ComparisonTestFramework):		class FullBlockTest(BitcoinTestFramework):
# 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.
def set_test_params(self):		def set_test_params(self):
self.num_nodes = 1		self.num_nodes = 1
self.extra_args = [['-whitelist=127.0.0.1',
'-noparkdeepreorg', '-maxreorgdepth=-1']]
self.setup_clean_chain = True		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.block_heights = {}
self.coinbase_key = CECKey()		self.coinbase_key = CECKey()
self.coinbase_key.set_secretbytes(b"horsebattery")		self.coinbase_key.set_secretbytes(b"horsebattery")
self.coinbase_pubkey = self.coinbase_key.get_pubkey()		self.coinbase_pubkey = self.coinbase_key.get_pubkey()
self.tip = None		self.tip = None
self.blocks = {}		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)
markblundebergAuthorUnsubmitted Done Inline Actions Not clear to me why this was needed... (from D1907) It has been taken out of the new `next_block` markblundeberg: Not clear to me why this was needed... (from D1907) It has been taken out of the new…
coinbase.rehash()
block = create_block(base_block_hash, coinbase, block_time)
# spend 1 satoshi
markblundebergAuthorUnsubmitted Done Inline Actions move these back markblundeberg: move these back
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)
markblundebergAuthorUnsubmitted Done Inline Actions This is also unnecessary. A block with only one non-coinbase transaction is always canonically ordered. markblundeberg: This is also unnecessary. A block with only one non-coinbase transaction is always canonically…
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.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
self.block_heights[self.genesis_hash] = 0		self.block_heights[self.genesis_hash] = 0
spendable_outputs = []		self.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

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

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

# collect spendable outputs now to avoid cluttering the code later on		# collect spendable outputs now to avoid cluttering the code later on
out = []		out = []
for i in range(33):		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		# Start by building a couple of blocks on top (which output is spent is
# in parentheses):		# in parentheses):
# genesis -> b1 (0) -> b2 (1)		# genesis -> b1 (0) -> b2 (1)
block(1, spend=out[0])		b1 = self.next_block(1, spend=out[0])
save_spendable_output()		self.save_spendable_output()
yield accepted()

block(2, spend=out[1])
yield accepted()
save_spendable_output()

# so fork like this:		b2 = self.next_block(2, spend=out[1])
		self.save_spendable_output()

		self.sync_blocks([b1, b2])

		# Fork like this:
#		#
# genesis -> b1 (0) -> b2 (1)		# genesis -> b1 (0) -> b2 (1)
# \-> b3 (1)		# \-> b3 (1)
#		#
# Nothing should happen at this point. We saw b2 first so it takes		# Nothing should happen at this point. We saw b2 first so it takes priority.
# priority.		self.log.info("Don't reorg to a chain of the same length")
tip(1)		self.move_tip(1)
b3 = block(3, spend=out[1])		b3 = self.next_block(3, spend=out[1])
txout_b3 = PreviousSpendableOutput(b3.vtx[1], 0)		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.		# Now we add another block to make the alternative chain longer.
#		#
# genesis -> b1 (0) -> b2 (1)		# genesis -> b1 (0) -> b2 (1)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
block(4, spend=out[2])		self.log.info("Reorg to a longer chain")
yield accepted()		b4 = self.next_block(4, spend=out[2])
		self.sync_blocks([b4])

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

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

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

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

# Try to create a block that has too much fee		# Try to create a block that has too much fee
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b9 (4)		# \-> b9 (4)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(6)		self.log.info(
block(9, spend=out[4], additional_coinbase_value=1)		"Reject a block where the miner creates too much coinbase reward")
yield rejected(RejectResult(16, b'bad-cb-amount'))		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)		# 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)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b10 (3) -> b11 (4)		# \-> b10 (3) -> b11 (4)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(5)		self.log.info(
block(10, spend=out[3])		"Reject a chain where the miner creates too much coinbase reward, even if the chain is longer")
yield rejected()		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)		b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1)
yield rejected(RejectResult(16, b'bad-cb-amount'))		self.sync_blocks([b11], False, 16, b'bad-cb-amount', reconnect=True)

# Try again, but with a valid fork first		# Try again, but with a valid fork first
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b14 (5)		# \-> b12 (3) -> b13 (4) -> b14 (5)
# (b12 added last)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(5)		self.log.info(
b12 = block(12, spend=out[3])		"Reject a chain where the miner creates too much coinbase reward, even if the chain is longer (on a forked chain)")
save_spendable_output()		self.move_tip(5)
b13 = block(13, spend=out[4])		b12 = self.next_block(12, spend=out[3])
# Deliver the block header for b12, and the block b13.		self.save_spendable_output()
# b13 should be accepted but the tip won't advance until b12 is		b13 = self.next_block(13, spend=out[4])
# delivered.		self.save_spendable_output()
yield TestInstance([[CBlockHeader(b12), None], [b13, False]])		b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1)
		self.sync_blocks([b12, b13, b14], False, 16,
save_spendable_output()		b'bad-cb-amount', reconnect=True)
# 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.		# 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		# Add a block with MAX_BLOCK_SIGOPS_PER_MB and one with one more sigop
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b16 (6)		# \-> b12 (3) -> b13 (4) -> b15 (5) -> b16 (6)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
		self.log.info("Accept a block with lots of checksigs")
# Test that a block with a lot of checksigs is okay
lots_of_checksigs = CScript(		lots_of_checksigs = CScript(
[OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB - 1))		[OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB - 1))
tip(13)		self.move_tip(13)
block(15, spend=out[5], script=lots_of_checksigs)		b15 = self.next_block(15, spend=out[5], script=lots_of_checksigs)
yield accepted()		self.save_spendable_output()
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))		too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB))
block(16, spend=out[6], script=too_many_checksigs)		b16 = self.next_block(16, spend=out[6], script=too_many_checksigs)
yield rejected(RejectResult(16, b'bad-blk-sigops'))		self.sync_blocks([b16], False, 16, b'bad-blk-sigops', reconnect=True)

# Attempt to spend a transaction created on a different fork		# Attempt to spend a transaction created on a different fork
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])		# \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(15)		self.log.info("Reject a block with a spend from a re-org'ed out tx")
block(17, spend=txout_b3)		self.move_tip(15)
yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))		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)		# Attempt to spend a transaction created on a different fork (on a fork this time)
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5)		# \-> b12 (3) -> b13 (4) -> b15 (5)
# \-> b18 (b3.vtx[1]) -> b19 (6)		# \-> b18 (b3.vtx[1]) -> b19 (6)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(13)		self.log.info(
block(18, spend=txout_b3)		"Reject a block with a spend from a re-org'ed out tx (on a forked chain)")
yield rejected()		self.move_tip(13)
		b18 = self.next_block(18, spend=txout_b3)
block(19, spend=out[6])		self.sync_blocks([b18], False)
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		# Attempt to spend a coinbase at depth too low
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)		# \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(15)		self.log.info("Reject a block spending an immature coinbase.")
block(20, spend=out[7])		self.move_tip(15)
yield rejected(RejectResult(16, b'bad-txns-premature-spend-of-coinbase'))		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)		# Attempt to spend a coinbase at depth too low (on a fork this time)
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5)		# \-> b12 (3) -> b13 (4) -> b15 (5)
# \-> b21 (6) -> b22 (5)		# \-> b21 (6) -> b22 (5)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(13)		self.log.info(
block(21, spend=out[6])		"Reject a block spending an immature coinbase (on a forked chain)")
yield rejected()		self.move_tip(13)
		b21 = self.next_block(21, spend=out[6])
block(22, spend=out[5])		self.sync_blocks([b21], False)
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		# 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)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)		# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)
# \-> b24 (6) -> b25 (7)		# \-> b24 (6) -> b25 (7)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(15)		self.log.info("Accept a block of size LEGACY_MAX_BLOCK_SIZE")
b23 = block(23, spend=out[6])		self.move_tip(15)
		b23 = self.next_block(23, spend=out[6])
tx = CTransaction()		tx = CTransaction()
script_length = LEGACY_MAX_BLOCK_SIZE - len(b23.serialize()) - 69		script_length = LEGACY_MAX_BLOCK_SIZE - len(b23.serialize()) - 69
script_output = CScript([b'\x00' * script_length])		script_output = CScript([b'\x00' * script_length])
tx.vout.append(CTxOut(0, script_output))		tx.vout.append(CTxOut(0, script_output))
tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))		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		# Make sure the math above worked out to produce a max-sized block
assert_equal(len(b23.serialize()), LEGACY_MAX_BLOCK_SIZE)		assert_equal(len(b23.serialize()), LEGACY_MAX_BLOCK_SIZE)
yield accepted()		self.sync_blocks([b23], True)
save_spendable_output()		self.save_spendable_output()

		markblundebergAuthorUnsubmitted Done Inline Actions (Note: we do not have the b24/b25 too-large block rejection here.) markblundeberg: (Note: we do not have the b24/b25 too-large block rejection here.)
# Create blocks with a coinbase input script size out of range		# Create blocks with a coinbase input script size out of range
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)		# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7)		# \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7)
# \-> ... (6) -> ... (7)		# \-> ... (6) -> ... (7)
# \-> b3 (1) -> b4 (2)		# \-> b3 (1) -> b4 (2)
tip(15)		self.log.info(
b26 = block(26, spend=out[6])		"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].vin[0].scriptSig = b'\x00'
b26.vtx[0].rehash()		b26.vtx[0].rehash()
# update_block causes the merkle root to get updated, even with no new		# update_block causes the merkle root to get updated, even with no new
# transactions, and updates the required state.		# transactions, and updates the required state.
b26 = update_block(26, [])		b26 = self.update_block(26, [])
yield rejected(RejectResult(16, b'bad-cb-length'))		self.sync_blocks([b26], False, 16, b'bad-cb-length', reconnect=True)

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

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

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

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

# b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY		# b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY
#		#
# genesis -> ... -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10)		# genesis -> ... -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10)
# \-> b36 (11)		# \-> b36 (11)
# \-> b34 (10)		# \-> b34 (10)
# \-> b32 (9)		# \-> b32 (9)
#		#

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

# this goes over the limit because the coinbase has one sigop		# 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(		too_many_multisigs = CScript(
[OP_CHECKMULTISIG] * (MAX_BLOCK_SIGOPS_PER_MB // 20))		[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(		assert_equal(get_legacy_sigopcount_block(
b32), MAX_BLOCK_SIGOPS_PER_MB + 1)		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		# CHECKMULTISIGVERIFY
tip(31)		self.log.info(
lots_of_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * (		"Accept a block with the max number of OP_CHECKMULTISIGVERIFY sigops")
(MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)		self.move_tip(31)
block(33, spend=out[9], script=lots_of_multisigs)		lots_of_multisigs = CScript(
yield accepted()		[OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)
save_spendable_output()		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(		too_many_multisigs = CScript(
[OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB // 20))		[OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB // 20))
block(34, spend=out[10], script=too_many_multisigs)		b34 = self.next_block(34, spend=out[10], script=too_many_multisigs)
yield rejected(RejectResult(16, b'bad-blk-sigops'))		self.sync_blocks([b34], False, 16, b'bad-blk-sigops', reconnect=True)

# CHECKSIGVERIFY		# 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(		lots_of_checksigs = CScript(
[OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB - 1))		[OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB - 1))
b35 = block(35, spend=out[10], script=lots_of_checksigs)		b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs)
yield accepted()		self.sync_blocks([b35], True)
save_spendable_output()		self.save_spendable_output()

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

# Check spending of a transaction in a block which failed to connect		# Check spending of a transaction in a block which failed to connect
#		#
# b6 (3)		# b6 (3)
# b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10)		# b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10)
# \-> b37 (11)		# \-> b37 (11)
# \-> b38 (11/37)		# \-> b38 (11/37)
#		#

# save 37's spendable output, but then double-spend out11 to invalidate		# save 37's spendable output, but then double-spend out11 to invalidate the block
# the block		self.log.info(
tip(35)		"Reject a block spending transaction from a block which failed to connect")
b37 = block(37, spend=out[11])		self.move_tip(35)
		b37 = self.next_block(37, spend=out[11])
txout_b37 = PreviousSpendableOutput(b37.vtx[1], 0)		txout_b37 = PreviousSpendableOutput(b37.vtx[1], 0)
tx = create_and_sign_tx(out[11].tx, out[11].n, 0)		tx = self.create_and_sign_transaction(out[11].tx, out[11].n, 0)
b37 = update_block(37, [tx])		b37 = self.update_block(37, [tx])
yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))		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		# attempt to spend b37's first non-coinbase tx, at which point b37 was still considered valid
tip(35)		self.move_tip(35)
block(38, spend=txout_b37)		b38 = self.next_block(38, spend=txout_b37)
yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))		self.sync_blocks([b38], False, 16,
		b'bad-txns-inputs-missingorspent', reconnect=True)

# Check P2SH SigOp counting		# Check P2SH SigOp counting
#		#
#		#
# 13 (4) -> b15 (5) -> b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b41 (12)		# 13 (4) -> b15 (5) -> b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b41 (12)
# \-> b40 (12)		# \-> b40 (12)
#		#
# b39 - create some P2SH outputs that will require 6 sigops to spend:		# b39 - create some P2SH outputs that will require 6 sigops to spend:
#		#
# redeem_script = COINBASE_PUBKEY, (OP_2DUP+OP_CHECKSIGVERIFY) * 5, OP_CHECKSIG		# redeem_script = COINBASE_PUBKEY, (OP_2DUP+OP_CHECKSIGVERIFY) * 5, OP_CHECKSIG
# p2sh_script = OP_HASH160, ripemd160(sha256(script)), OP_EQUAL		# p2sh_script = OP_HASH160, ripemd160(sha256(script)), OP_EQUAL
#		#
tip(35)		self.log.info("Check P2SH SIGOPS are correctly counted")
b39 = block(39)		self.move_tip(35)
		b39 = self.next_block(39)
b39_outputs = 0		b39_outputs = 0
b39_sigops_per_output = 6		b39_sigops_per_output = 6

# Build the redeem script, hash it, use hash to create the p2sh script		# Build the redeem script, hash it, use hash to create the p2sh script
redeem_script = CScript([self.coinbase_pubkey] + [		redeem_script = CScript([self.coinbase_pubkey] + [
OP_2DUP, OP_CHECKSIGVERIFY] * 5 + [OP_CHECKSIG])		OP_2DUP, OP_CHECKSIGVERIFY] * 5 + [OP_CHECKSIG])
redeem_script_hash = hash160(redeem_script)		redeem_script_hash = hash160(redeem_script)
p2sh_script = CScript([OP_HASH160, redeem_script_hash, OP_EQUAL])		p2sh_script = CScript([OP_HASH160, redeem_script_hash, OP_EQUAL])

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

# Until block is full, add tx's with 1 satoshi to p2sh_script, the rest		# Until block is full, add tx's with 1 satoshi to p2sh_script, the rest
# to OP_TRUE		# to OP_TRUE
tx_new = None		tx_new = None
tx_last = tx		tx_last = tx
tx_last_n = len(tx.vout) - 1		tx_last_n = len(tx.vout) - 1
total_size = len(b39.serialize())		total_size = len(b39.serialize())
while(total_size < LEGACY_MAX_BLOCK_SIZE):		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(		tx_new.vout.append(
CTxOut(tx_last.vout[tx_last_n].nValue - 1, CScript([OP_TRUE])))		CTxOut(tx_last.vout[tx_last_n].nValue - 1, CScript([OP_TRUE])))
tx_new.rehash()		tx_new.rehash()
total_size += len(tx_new.serialize())		total_size += len(tx_new.serialize())
if total_size >= LEGACY_MAX_BLOCK_SIZE:		if total_size >= LEGACY_MAX_BLOCK_SIZE:
break		break
b39.vtx.append(tx_new) # add tx to block		b39.vtx.append(tx_new) # add tx to block
tx_last = tx_new		tx_last = tx_new
tx_last_n = len(tx_new.vout) - 1		tx_last_n = len(tx_new.vout) - 1
b39_outputs += 1		b39_outputs += 1

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

# Test sigops in P2SH redeem scripts		# Test sigops in P2SH redeem scripts
#		#
# b40 creates 3333 tx's spending the 6-sigop P2SH outputs from b39 for a total of 19998 sigops.		# b40 creates 3333 tx's spending the 6-sigop P2SH outputs from b39 for a total of 19998 sigops.
# The first tx has one sigop and then at the end we add 2 more to put us just over the max.		# The first tx has one sigop and then at the end we add 2 more to put us just over the max.
#		#
# b41 does the same, less one, so it has the maximum sigops permitted.		# b41 does the same, less one, so it has the maximum sigops permitted.
#		#
tip(39)		self.log.info("Reject a block with too many P2SH sigops")
b40 = block(40, spend=out[12])		self.move_tip(39)
		b40 = self.next_block(40, spend=out[12])
sigops = get_legacy_sigopcount_block(b40)		sigops = get_legacy_sigopcount_block(b40)
numTxs = (MAX_BLOCK_SIGOPS_PER_MB - sigops) // b39_sigops_per_output		numTxs = (MAX_BLOCK_SIGOPS_PER_MB - sigops) // b39_sigops_per_output
assert_equal(numTxs <= b39_outputs, True)		assert_equal(numTxs <= b39_outputs, True)

lastOutpoint = COutPoint(b40.vtx[1].sha256, 0)		lastOutpoint = COutPoint(b40.vtx[1].sha256, 0)
lastAmount = b40.vtx[1].vout[0].nValue		lastAmount = b40.vtx[1].vout[0].nValue
new_txs = []		new_txs = []
for i in range(1, numTxs + 1):		for i in range(1, numTxs + 1):
Show All 21 Lines	def run_test(self):
b40_sigops_to_fill = MAX_BLOCK_SIGOPS_PER_MB - \		b40_sigops_to_fill = MAX_BLOCK_SIGOPS_PER_MB - \
(numTxs * b39_sigops_per_output + sigops) + 1		(numTxs * b39_sigops_per_output + sigops) + 1
tx = CTransaction()		tx = CTransaction()
tx.vin.append(CTxIn(lastOutpoint, b''))		tx.vin.append(CTxIn(lastOutpoint, b''))
tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b40_sigops_to_fill)))		tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b40_sigops_to_fill)))
pad_tx(tx)		pad_tx(tx)
tx.rehash()		tx.rehash()
new_txs.append(tx)		new_txs.append(tx)
update_block(40, new_txs)		self.update_block(40, new_txs)
yield rejected(RejectResult(16, b'bad-blk-sigops'))		self.sync_blocks([b40], False, 16, b'bad-blk-sigops', reconnect=True)

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

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

# Test a number of really invalid scenarios		# Test a number of really invalid scenarios
#		#
# -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b44 (14)		# -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b44 (14)
# \-> ??? (15)		# \-> ??? (15)

# The next few blocks are going to be created "by hand" since they'll do funky things, such as having		# 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		# the first transaction be non-coinbase, etc. The purpose of b44 is to make sure this works.
# make sure this works.		self.log.info("Build block 44 manually")
height = self.block_heights[self.tip.sha256] + 1		height = self.block_heights[self.tip.sha256] + 1
coinbase = create_coinbase(height, self.coinbase_pubkey)		coinbase = create_coinbase(height, self.coinbase_pubkey)
b44 = CBlock()		b44 = CBlock()
b44.nTime = self.tip.nTime + 1		b44.nTime = self.tip.nTime + 1
b44.hashPrevBlock = self.tip.sha256		b44.hashPrevBlock = self.tip.sha256
b44.nBits = 0x207fffff		b44.nBits = 0x207fffff
b44.vtx.append(coinbase)		b44.vtx.append(coinbase)
b44.hashMerkleRoot = b44.calc_merkle_root()		b44.hashMerkleRoot = b44.calc_merkle_root()
b44.solve()		b44.solve()
self.tip = b44		self.tip = b44
self.block_heights[b44.sha256] = height		self.block_heights[b44.sha256] = height
self.blocks[44] = b44		self.blocks[44] = b44
yield accepted()		self.sync_blocks([b44], True)

# A block with a non-coinbase as the first tx		self.log.info("Reject a block with a non-coinbase as the first tx")
non_coinbase = create_tx(out[15].tx, out[15].n, 1)		non_coinbase = self.create_tx(out[15].tx, out[15].n, 1)
b45 = CBlock()		b45 = CBlock()
b45.nTime = self.tip.nTime + 1		b45.nTime = self.tip.nTime + 1
b45.hashPrevBlock = self.tip.sha256		b45.hashPrevBlock = self.tip.sha256
b45.nBits = 0x207fffff		b45.nBits = 0x207fffff
b45.vtx.append(non_coinbase)		b45.vtx.append(non_coinbase)
b45.hashMerkleRoot = b45.calc_merkle_root()		b45.hashMerkleRoot = b45.calc_merkle_root()
b45.calc_sha256()		b45.calc_sha256()
b45.solve()		b45.solve()
self.block_heights[b45.sha256] = self.block_heights[		self.block_heights[b45.sha256] = self.block_heights[
self.tip.sha256] + 1		self.tip.sha256] + 1
self.tip = b45		self.tip = b45
self.blocks[45] = 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		self.log.info("Reject a block with no transactions")
tip(44)		self.move_tip(44)
b46 = CBlock()		b46 = CBlock()
b46.nTime = b44.nTime + 1		b46.nTime = b44.nTime + 1
b46.hashPrevBlock = b44.sha256		b46.hashPrevBlock = b44.sha256
b46.nBits = 0x207fffff		b46.nBits = 0x207fffff
b46.vtx = []		b46.vtx = []
b46.hashMerkleRoot = 0		b46.hashMerkleRoot = 0
b46.solve()		b46.solve()
self.block_heights[b46.sha256] = self.block_heights[b44.sha256] + 1		self.block_heights[b46.sha256] = self.block_heights[b44.sha256] + 1
self.tip = b46		self.tip = b46
assert 46 not in self.blocks		assert 46 not in self.blocks
self.blocks[46] = b46		self.blocks[46] = b46
s = ser_uint256(b46.hashMerkleRoot)		self.sync_blocks([b46], False, 16, b'bad-cb-missing', reconnect=True)
yield rejected(RejectResult(16, b'bad-cb-missing'))

# A block with invalid work		self.log.info("Reject a block with invalid work")
tip(44)		self.move_tip(44)
b47 = block(47, solve=False)		b47 = self.next_block(47, solve=False)
target = uint256_from_compact(b47.nBits)		target = uint256_from_compact(b47.nBits)
while b47.sha256 < target: # changed > to <		while b47.sha256 < target:
b47.nNonce += 1		b47.nNonce += 1
b47.rehash()		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		self.log.info("Reject a block with a timestamp >2 hours in the future")
tip(44)		self.move_tip(44)
b48 = block(48, solve=False)		b48 = self.next_block(48, solve=False)
b48.nTime = int(time.time()) + 60 * 60 * 3		b48.nTime = int(time.time()) + 60 * 60 * 3
b48.solve()		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		self.log.info("Reject a block with invalid merkle hash")
tip(44)		self.move_tip(44)
b49 = block(49)		b49 = self.next_block(49)
b49.hashMerkleRoot += 1		b49.hashMerkleRoot += 1
b49.solve()		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		self.log.info("Reject a block with incorrect POW limit")
tip(44)		self.move_tip(44)
b50 = block(50)		b50 = self.next_block(50)
b50.nBits = b50.nBits - 1		b50.nBits = b50.nBits - 1
b50.solve()		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		self.log.info("Reject a block with two coinbase transactions")
tip(44)		self.move_tip(44)
b51 = block(51)		b51 = self.next_block(51)
cb2 = create_coinbase(51, self.coinbase_pubkey)		cb2 = create_coinbase(51, self.coinbase_pubkey)
b51 = update_block(51, [cb2])		b51 = self.update_block(51, [cb2])
yield rejected(RejectResult(16, b'bad-tx-coinbase'))		self.sync_blocks([b51], False, 16, b'bad-tx-coinbase', reconnect=True)
		markblundebergAuthorUnsubmitted Done Inline Actions note our error message here differs... markblundeberg: note our error message here differs...

# A block w/ duplicate txns		self.log.info("Reject a block with duplicate transactions")
tip(44)		# Note: txns have to be in the right position in the merkle tree to trigger this error
		markblundebergAuthorUnsubmitted Done Inline Actions Note to self: remove this comment! Our test here is different in function. The duplicate check we perform here is for CTOR blocks only. Core's duplicate check is just checking merkle malleation. markblundeberg: Note to self: remove this comment! Our test here is different in function. The duplicate check…
b52 = block(52, spend=out[15])		self.move_tip(44)
b52 = update_block(52, [b52.vtx[1]])		b52 = self.next_block(52, spend=out[15])
yield rejected(RejectResult(16, b'tx-duplicate'))		b52 = self.update_block(52, [b52.vtx[1]])
		self.sync_blocks([b52], False, 16, b'tx-duplicate', reconnect=True)

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

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

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

# Test CVE-2012-2459		# Test Merkle tree malleability
#		#
# -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)		# -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)
# \-> b57 (16)		# \-> b57 (16)
# \-> b56p2 (16)		# \-> b56p2 (16)
# \-> b56 (16)		# \-> b56 (16)
#		#
# Merkle tree malleability (CVE-2012-2459): repeating sequences of transactions in a block without		# Merkle tree malleability (CVE-2012-2459): repeating sequences of transactions in a block without
# affecting the merkle root of a block, while still invalidating it.		# affecting the merkle root of a block, while still invalidating it.
Show All 11 Lines	def run_test(self):
# Merkle root calculation will duplicate as necessary.		# Merkle root calculation will duplicate as necessary.
# Result: OK.		# Result: OK.
#		#
# b56p2 copies b57p2 but adds both tx3 and tx4. The purpose of the test is to make sure the code catches		# b56p2 copies b57p2 but adds both tx3 and tx4. The purpose of the test is to make sure the code catches
# duplicate txns that are not next to one another with the "bad-txns-duplicate" error (which indicates		# duplicate txns that are not next to one another with the "bad-txns-duplicate" error (which indicates
# that the error was caught early, avoiding a DOS vulnerability.)		# that the error was caught early, avoiding a DOS vulnerability.)

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

# b56 - copy b57, add a duplicate tx		# 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)		b56 = copy.deepcopy(b57)
self.blocks[56] = b56		self.blocks[56] = b56
assert_equal(len(b56.vtx), 3)		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)		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		# b57p2 - a good block with 6 tx'es, don't submit until end
tip(55)		self.move_tip(55)
b57p2 = block("57p2")		b57p2 = self.next_block("57p2")
tx = create_and_sign_tx(out[16].tx, out[16].n, 1)		tx = self.create_and_sign_transaction(out[16].tx, out[16].n, 1)
tx1 = create_tx(tx, 0, 1)		tx1 = self.create_tx(tx, 0, 1)
tx2 = create_tx(tx1, 0, 1)		tx2 = self.create_tx(tx1, 0, 1)
tx3 = create_tx(tx2, 0, 1)		tx3 = self.create_tx(tx2, 0, 1)
tx4 = create_tx(tx3, 0, 1)		tx4 = self.create_tx(tx3, 0, 1)
b57p2 = update_block("57p2", [tx, tx1, tx2, tx3, tx4])		b57p2 = self.update_block("57p2", [tx, tx1, tx2, tx3, tx4])

# b56p2 - copy b57p2, duplicate two non-consecutive tx's		# 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)		b56p2 = copy.deepcopy(b57p2)
self.blocks["b56p2"] = b56p2		self.blocks["b56p2"] = b56p2
assert_equal(len(b56p2.vtx), 6)		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)
		markblundebergAuthorUnsubmitted Done Inline Actions Our tail repeat here is different from CTOR as well... markblundeberg: Our tail repeat here is different from CTOR as well...
assert_equal(b56p2.hash, b57p2.hash)		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")		self.move_tip("57p2")
yield accepted()		self.sync_blocks([b57p2], True)

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

# Test a few invalid tx types		# Test a few invalid tx types
#		#
# -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)		# -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> ??? (17)		# \-> ??? (17)
#		#

# tx with prevout.n out of range		# tx with prevout.n out of range
tip(57)		self.log.info(
b58 = block(58, spend=out[17])		"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()		tx = CTransaction()
assert(len(out[17].tx.vout) < 42)		assert(len(out[17].tx.vout) < 42)
tx.vin.append(		tx.vin.append(
CTxIn(COutPoint(out[17].tx.sha256, 42), CScript([OP_TRUE]), 0xffffffff))		CTxIn(COutPoint(out[17].tx.sha256, 42), CScript([OP_TRUE]), 0xffffffff))
tx.vout.append(CTxOut(0, b""))		tx.vout.append(CTxOut(0, b""))
pad_tx(tx)		pad_tx(tx)
tx.calc_sha256()		tx.calc_sha256()
b58 = update_block(58, [tx])		b58 = self.update_block(58, [tx])
yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))		self.sync_blocks([b58], False, 16,
		b'bad-txns-inputs-missingorspent', reconnect=True)
# tx with output value > input value out of range
tip(57)		# tx with output value > input value
b59 = block(59)		self.log.info(
tx = create_and_sign_tx(out[17].tx, out[17].n, 51 * COIN)		"Reject a block with a transaction with outputs > inputs")
b59 = update_block(59, [tx])		self.move_tip(57)
yield rejected(RejectResult(16, b'bad-txns-in-belowout'))		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		# reset to good chain
tip(57)		self.move_tip(57)
b60 = block(60, spend=out[17])		b60 = self.next_block(60, spend=out[17])
yield accepted()		self.sync_blocks([b60], True)
save_spendable_output()		self.save_spendable_output()

# Test BIP30		# Test BIP30
#		#
# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)		# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> b61 (18)		# \-> b61 (18)
#		#
# Blocks are not allowed to contain a transaction whose id matches that of an earlier,		# Blocks are not allowed to contain a transaction whose id matches that of an earlier,
# not-fully-spent transaction in the same chain. To test, make identical coinbases;		# not-fully-spent transaction in the same chain. To test, make identical coinbases;
# the second one should be rejected.		# the second one should be rejected.
#		#
tip(60)		self.log.info(
b61 = block(61, spend=out[18])		"Reject a block with a transaction with a duplicate hash of a previous transaction (BIP30)")
b61.vtx[0].vin[0].scriptSig = b60.vtx[		self.move_tip(60)
0].vin[0].scriptSig # equalize the coinbases		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.vtx[0].rehash()
b61 = update_block(61, [])		b61 = self.update_block(61, [])
assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize())		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)		# 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)		# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> b62 (18)		# \-> b62 (18)
#		#
tip(60)		self.log.info(
b62 = block(62)		"Reject a block with a transaction with a nonfinal locktime")
		self.move_tip(60)
		b62 = self.next_block(62)
tx = CTransaction()		tx = CTransaction()
tx.nLockTime = 0xffffffff # this locktime is non-final		tx.nLockTime = 0xffffffff # this locktime is non-final
assert(out[18].n < len(out[18].tx.vout))		assert(out[18].n < len(out[18].tx.vout))
tx.vin.append(		# don't set nSequence
		markblundebergAuthorUnsubmitted Done Inline Actions linter did this ... I guess it's nice to have markblundeberg: linter did this ... I guess it's nice to have
CTxIn(COutPoint(out[18].tx.sha256, out[18].n))) # don't set nSequence		tx.vin.append(CTxIn(COutPoint(out[18].tx.sha256, out[18].n)))
tx.vout.append(CTxOut(0, CScript([OP_TRUE])))		tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
assert(tx.vin[0].nSequence < 0xffffffff)		assert(tx.vin[0].nSequence < 0xffffffff)
tx.calc_sha256()		tx.calc_sha256()
b62 = update_block(62, [tx])		b62 = self.update_block(62, [tx])
yield rejected(RejectResult(16, b'bad-txns-nonfinal'))		self.sync_blocks([b62], False, 16, b'bad-txns-nonfinal')

# Test a non-final coinbase is also rejected		# Test a non-final coinbase is also rejected
#		#
# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)		# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
# \-> b63 (-)		# \-> b63 (-)
#		#
tip(60)		self.log.info(
b63 = block(63)		"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].nLockTime = 0xffffffff
b63.vtx[0].vin[0].nSequence = 0xDEADBEEF		b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
b63.vtx[0].rehash()		b63.vtx[0].rehash()
b63 = update_block(63, [])		b63 = self.update_block(63, [])
yield rejected(RejectResult(16, b'bad-txns-nonfinal'))		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		# 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,		# the block is > LEGACY_MAX_BLOCK_SIZE with the bloated varint, but <= LEGACY_MAX_BLOCK_SIZE without the bloated varint,
# does not cause a subsequent, identical block with canonical encoding to be rejected. The test does not		# does not cause a subsequent, identical block with canonical encoding to be rejected. The test does not
# care whether the bloated block is accepted or rejected; it only cares that the second block is accepted.		# care whether the bloated block is accepted or rejected; it only cares that the second block is accepted.
#		#
# What matters is that the receiving node should not reject the bloated block, and then reject the canonical		# What matters is that the receiving node should not reject the bloated block, and then reject the canonical
# block on the basis that it's the same as an already-rejected block (which would be a consensus failure.)		# block on the basis that it's the same as an already-rejected block (which would be a consensus failure.)
#		#
# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18)		# -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18)
# \		# \
# b64a (18)		# b64a (18)
# b64a is a bloated block (non-canonical varint)		# b64a is a bloated block (non-canonical varint)
# b64 is a good block (same as b64 but w/ canonical varint)		# b64 is a good block (same as b64 but w/ canonical varint)
#		#
tip(60)		self.log.info(
regular_block = block("64a", spend=out[18])		"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		# make it a "broken_block," with non-canonical serialization
b64a = CBrokenBlock(regular_block)		b64a = CBrokenBlock(regular_block)
b64a.initialize(regular_block)		b64a.initialize(regular_block)
self.blocks["64a"] = b64a		self.blocks["64a"] = b64a
self.tip = b64a		self.tip = b64a
tx = CTransaction()		tx = CTransaction()

# use canonical serialization to calculate size		# use canonical serialization to calculate size
script_length = LEGACY_MAX_BLOCK_SIZE - \		script_length = LEGACY_MAX_BLOCK_SIZE - \
len(b64a.normal_serialize()) - 69		len(b64a.normal_serialize()) - 69
script_output = CScript([b'\x00' * script_length])		script_output = CScript([b'\x00' * script_length])
tx.vout.append(CTxOut(0, script_output))		tx.vout.append(CTxOut(0, script_output))
tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))		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)		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')
		markblundebergAuthorUnsubmitted Done Inline Actions Note with our large block limit, this test unfortunately does not do exactly what we want. To be fully mimicking Core here, we should make a 32 MB block that goes over with non-canonical varint. markblundeberg: Note with our large block limit, this test unfortunately does not do exactly what we want. To…

# comptool workaround: to make sure b64 is delivered, manually erase		# bitcoind doesn't disconnect us for sending a bloated block, but if we subsequently
# b64a from blockstore		# resend the header message, it won't send us the getdata message again. Just
self.test.block_store.erase(b64a.sha256)		# 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 = CBlock(b64a)
b64.vtx = copy.deepcopy(b64a.vtx)		b64.vtx = copy.deepcopy(b64a.vtx)
assert_equal(b64.hash, b64a.hash)		assert_equal(b64.hash, b64a.hash)
assert_equal(len(b64.serialize()), LEGACY_MAX_BLOCK_SIZE)		assert_equal(len(b64.serialize()), LEGACY_MAX_BLOCK_SIZE)
self.blocks[64] = b64		self.blocks[64] = b64
update_block(64, [])		b64 = self.update_block(64, [])
yield accepted()		self.sync_blocks([b64], True)
save_spendable_output()		self.save_spendable_output()

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

		markblundebergAuthorUnsubmitted Done Inline Actions (b66 test skipped here, since we don't have TTOR it doesn't apply) markblundeberg: (b66 test skipped here, since we don't have TTOR it doesn't apply)
# Attempt to double-spend a transaction created in a block		# Attempt to double-spend a transaction created in a block
#		#
# -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)		# -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
# \-> b67 (20)		# \-> b67 (20)
#		#
#		#
tip(65)		self.log.info(
block(67)		"Reject a block with a transaction double spending a transaction creted in the same block")
		markblundebergAuthorUnsubmitted Done Inline Actions typo 'creted' markblundeberg: typo 'creted'
tx1 = create_and_sign_tx(		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)		out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
tx2 = create_and_sign_tx(tx1, 0, 1)		tx2 = self.create_and_sign_transaction(tx1, 0, 1)
tx3 = create_and_sign_tx(tx1, 0, 2)		tx3 = self.create_and_sign_transaction(tx1, 0, 2)
update_block(67, [tx1, tx2, tx3])		b67 = self.update_block(67, [tx1, tx2, tx3])
yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))		self.sync_blocks([b67], False, 16,
		b'bad-txns-inputs-missingorspent', reconnect=True)

# More tests of block subsidy		# More tests of block subsidy
#		#
# -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)		# -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
# \-> b68 (20)		# \-> b68 (20)
#		#
# b68 - coinbase with an extra 10 satoshis,		# b68 - coinbase with an extra 10 satoshis,
# creates a tx that has 9 satoshis from out[20] go to fees		# creates a tx that has 9 satoshis from out[20] go to fees
# this fails because the coinbase is trying to claim 1 satoshi too much in fees		# this fails because the coinbase is trying to claim 1 satoshi too much in fees
#		#
# b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee		# b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee
# this succeeds		# this succeeds
#		#
tip(65)		self.log.info(
block(68, additional_coinbase_value=10)		"Reject a block trying to claim too much subsidy in the coinbase transaction")
tx = create_and_sign_tx(		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)		out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 9)
update_block(68, [tx])		b68 = self.update_block(68, [tx])
yield rejected(RejectResult(16, b'bad-cb-amount'))		self.sync_blocks([b68], False, 16, b'bad-cb-amount', reconnect=True)

tip(65)		self.log.info(
b69 = block(69, additional_coinbase_value=10)		"Accept a block claiming the correct subsidy in the coinbase transaction")
tx = create_and_sign_tx(		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)		out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 10)
update_block(69, [tx])		self.update_block(69, [tx])
yield accepted()		self.sync_blocks([b69], True)
save_spendable_output()		self.save_spendable_output()

# Test spending the outpoint of a non-existent transaction		# Test spending the outpoint of a non-existent transaction
#		#
# -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)		# -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
# \-> b70 (21)		# \-> b70 (21)
#		#
tip(69)		self.log.info(
block(70, spend=out[21])		"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 = CTransaction()
bogus_tx.sha256 = uint256_from_str(		bogus_tx.sha256 = uint256_from_str(
b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")		b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")
tx = CTransaction()		tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))		tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))
tx.vout.append(CTxOut(1, b""))		tx.vout.append(CTxOut(1, b""))
pad_tx(tx)		pad_tx(tx)
tx.rehash()		b70 = self.update_block(70, [tx])
update_block(70, [tx])		self.sync_blocks([b70], False, 16,
yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))		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)		# Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
#		#
# -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20) -> b72 (21)		# -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20) -> b72 (21)
# \-> b71 (21)		# \-> b71 (21)
#		#
# b72 is a good block.		# 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.		# b71 is a copy of 72, but re-adds one of its transactions. However, it has the same hash as b72.
#		self.log.info(
tip(69)		"Reject a block containing a duplicate transaction but with the same Merkle root (Merkle tree malleability")
b72 = block(72)		self.move_tip(69)
tx1 = create_and_sign_tx(out[21].tx, out[21].n, 2)		b72 = self.next_block(72)
tx2 = create_and_sign_tx(tx1, 0, 1)		tx1 = self.create_and_sign_transaction(out[21].tx, out[21].n, 2)
b72 = update_block(72, [tx1, tx2]) # now tip is 72		tx2 = self.create_and_sign_transaction(tx1, 0, 1)
		b72 = self.update_block(72, [tx1, tx2]) # now tip is 72
b71 = copy.deepcopy(b72)		b71 = copy.deepcopy(b72)
# add duplicate last transaction		# add duplicate last transaction
b71.vtx.append(b72.vtx[-1])		b71.vtx.append(b72.vtx[-1])
		markblundebergAuthorUnsubmitted Done Inline Actions different from CTOR markblundeberg: different from CTOR
# b71 builds off b69		# b71 builds off b69
self.block_heights[b71.sha256] = self.block_heights[b69.sha256] + 1		self.block_heights[b71.sha256] = self.block_heights[b69.sha256] + 1
self.blocks[71] = b71		self.blocks[71] = b71

assert_equal(len(b71.vtx), 4)		assert_equal(len(b71.vtx), 4)
assert_equal(len(b72.vtx), 3)		assert_equal(len(b72.vtx), 3)
assert_equal(b72.sha256, b71.sha256)		assert_equal(b72.sha256, b71.sha256)

tip(71)		self.move_tip(71)
		markblundebergAuthorUnsubmitted Done Inline Actions (this is unnecessary, right?) markblundeberg: (this is unnecessary, right?)
yield rejected(RejectResult(16, b'bad-txns-duplicate'))		self.sync_blocks([b71], False, 16,
tip(72)		b'bad-txns-duplicate', reconnect=True)
yield accepted()
save_spendable_output()		self.move_tip(72)
		self.sync_blocks([b72], True)
		self.save_spendable_output()

# Test some invalid scripts and MAX_BLOCK_SIGOPS_PER_MB		# Test some invalid scripts and MAX_BLOCK_SIGOPS_PER_MB
#		#
# -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20) -> b72 (21)		# -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20) -> b72 (21)
# \-> b** (22)		# \-> b** (22)
#		#

# b73 - tx with excessive sigops that are placed after an excessively large script element.		# b73 - tx with excessive sigops that are placed after an excessively large script element.
# The purpose of the test is to make sure those sigops are counted.		# The purpose of the test is to make sure those sigops are counted.
#		#
# script is a bytearray of size 20,526		# script is a bytearray of size 20,526
#		#
# bytearray[0-19,998] : OP_CHECKSIG		# bytearray[0-19,998] : OP_CHECKSIG
# bytearray[19,999] : OP_PUSHDATA4		# bytearray[19,999] : OP_PUSHDATA4
# bytearray[20,000-20,003]: 521 (max_script_element_size+1, in little-endian format)		# 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,004-20,525]: unread data (script_element)
# bytearray[20,526] : OP_CHECKSIG (this puts us over the limit)		# bytearray[20,526] : OP_CHECKSIG (this puts us over the limit)
#		self.log.info(
tip(72)		"Reject a block containing too many sigops after a large script element")
b73 = block(73)		self.move_tip(72)
size = MAX_BLOCK_SIGOPS_PER_MB - 1 + \		b73 = self.next_block(73)
MAX_SCRIPT_ELEMENT_SIZE + 1 + 5 + 1		size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5 + 1
a = bytearray([OP_CHECKSIG] * size)		a = bytearray([OP_CHECKSIG] * size)
a[MAX_BLOCK_SIGOPS_PER_MB - 1] = int("4e", 16) # OP_PUSHDATA4		a[MAX_BLOCK_SIGOPS_PER_MB - 1] = int("4e", 16) # OP_PUSHDATA4

element_size = MAX_SCRIPT_ELEMENT_SIZE + 1		element_size = MAX_SCRIPT_ELEMENT_SIZE + 1
a[MAX_BLOCK_SIGOPS_PER_MB] = element_size % 256		a[MAX_BLOCK_SIGOPS_PER_MB] = element_size % 256
a[MAX_BLOCK_SIGOPS_PER_MB + 1] = element_size // 256		a[MAX_BLOCK_SIGOPS_PER_MB + 1] = element_size // 256
a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0		a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0
a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0		a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0

tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))		tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
b73 = update_block(73, [tx])		b73 = self.update_block(73, [tx])
assert_equal(		assert_equal(get_legacy_sigopcount_block(
get_legacy_sigopcount_block(b73), MAX_BLOCK_SIGOPS_PER_MB + 1)		b73), MAX_BLOCK_SIGOPS_PER_MB + 1)
yield rejected(RejectResult(16, b'bad-blk-sigops'))		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,		# b74/75 - if we push an invalid script element, all prevous sigops are counted,
# but sigops after the element are not counted.		# but sigops after the element are not counted.
		markblundebergAuthorUnsubmitted Done Inline Actions This is a fascinating and scary consensus rule... makes me hate sigops even more :-D markblundeberg: This is a fascinating and scary consensus rule... makes me hate sigops even more :-D
#		#
# The invalid script element is that the push_data indicates that		# The invalid script element is that the push_data indicates that
# there will be a large amount of data (0xffffff bytes), but we only		# there will be a large amount of data (0xffffff bytes), but we only
# provide a much smaller number. These bytes are CHECKSIGS so they would		# provide a much smaller number. These bytes are CHECKSIGS so they would
# cause b75 to fail for excessive sigops, if those bytes were counted.		# cause b75 to fail for excessive sigops, if those bytes were counted.
#		#
# b74 fails because we put MAX_BLOCK_SIGOPS_PER_MB+1 before the element		# 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		# b75 succeeds because we put MAX_BLOCK_SIGOPS_PER_MB before the element
#		self.log.info(
#		"Check sigops are counted correctly after an invalid script element")
tip(72)		self.move_tip(72)
b74 = block(74)		b74 = self.next_block(74)
size = MAX_BLOCK_SIGOPS_PER_MB - 1 + \		size = MAX_BLOCK_SIGOPS_PER_MB - 1 + \
MAX_SCRIPT_ELEMENT_SIZE + 42 # total = 20,561		MAX_SCRIPT_ELEMENT_SIZE + 42 # total = 20,561
a = bytearray([OP_CHECKSIG] * size)		a = bytearray([OP_CHECKSIG] * size)
a[MAX_BLOCK_SIGOPS_PER_MB] = 0x4e		a[MAX_BLOCK_SIGOPS_PER_MB] = 0x4e
a[MAX_BLOCK_SIGOPS_PER_MB + 1] = 0xfe		a[MAX_BLOCK_SIGOPS_PER_MB + 1] = 0xfe
a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff		a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff
a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff		a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff
a[MAX_BLOCK_SIGOPS_PER_MB + 4] = 0xff		a[MAX_BLOCK_SIGOPS_PER_MB + 4] = 0xff
tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))		tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
b74 = update_block(74, [tx])		b74 = self.update_block(74, [tx])
yield rejected(RejectResult(16, b'bad-blk-sigops'))		self.sync_blocks([b74], False, 16, b'bad-blk-sigops', reconnect=True)

tip(72)		self.move_tip(72)
b75 = block(75)		b75 = self.next_block(75)
size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42		size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42
a = bytearray([OP_CHECKSIG] * size)		a = bytearray([OP_CHECKSIG] * size)
a[MAX_BLOCK_SIGOPS_PER_MB - 1] = 0x4e		a[MAX_BLOCK_SIGOPS_PER_MB - 1] = 0x4e
a[MAX_BLOCK_SIGOPS_PER_MB] = 0xff		a[MAX_BLOCK_SIGOPS_PER_MB] = 0xff
a[MAX_BLOCK_SIGOPS_PER_MB + 1] = 0xff		a[MAX_BLOCK_SIGOPS_PER_MB + 1] = 0xff
a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff		a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff
a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff		a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff
tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))		tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
b75 = update_block(75, [tx])		b75 = self.update_block(75, [tx])
yield accepted()		self.sync_blocks([b75], True)
save_spendable_output()		self.save_spendable_output()

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

# Test transaction resurrection		# Test transaction resurrection
#		#
# -> b77 (24) -> b78 (25) -> b79 (26)		# -> b77 (24) -> b78 (25) -> b79 (26)
# \-> b80 (25) -> b81 (26) -> b82 (27)		# \-> b80 (25) -> b81 (26) -> b82 (27)
#		#
# b78 creates a tx, which is spent in b79. After b82, both should be in mempool		# b78 creates a tx, which is spent in b79. After b82, both should be in mempool
#		#
# The tx'es must be unsigned and pass the node's mempool policy. It is unsigned for the		# The tx'es must be unsigned and pass the node's mempool policy. It is unsigned for the
# rather obscure reason that the Python signature code does not distinguish between		# rather obscure reason that the Python signature code does not distinguish between
# Low-S and High-S values (whereas the bitcoin code has custom code which does so);		# Low-S and High-S values (whereas the bitcoin code has custom code which does so);
# as a result of which, the odds are 50% that the python code will use the right		# as a result of which, the odds are 50% that the python code will use the right
# value and the transaction will be accepted into the mempool. Until we modify the		# value and the transaction will be accepted into the mempool. Until we modify the
# test framework to support low-S signing, we are out of luck.		# test framework to support low-S signing, we are out of luck.
#		#
# To get around this issue, we construct transactions which are not signed and which		# 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		# 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)		# updated. (Perhaps to spend to a P2SH OP_TRUE script)
#		self.log.info("Test transaction resurrection during a re-org")
tip(76)		self.move_tip(76)
block(77)		b77 = self.next_block(77)
tx77 = create_and_sign_tx(out[24].tx, out[24].n, 10 * COIN)		tx77 = self.create_and_sign_transaction(
update_block(77, [tx77])		out[24].tx, out[24].n, 10 * COIN)
yield accepted()		b77 = self.update_block(77, [tx77])
save_spendable_output()		self.sync_blocks([b77], True)
		self.save_spendable_output()
block(78)
tx78 = create_tx(tx77, 0, 9 * COIN)		b78 = self.next_block(78)
update_block(78, [tx78])		tx78 = self.create_tx(tx77, 0, 9 * COIN)
yield accepted()		b78 = self.update_block(78, [tx78])
		self.sync_blocks([b78], True)
block(79)
tx79 = create_tx(tx78, 0, 8 * COIN)		b79 = self.next_block(79)
update_block(79, [tx79])		tx79 = self.create_tx(tx78, 0, 8 * COIN)
yield accepted()		b79 = self.update_block(79, [tx79])
		self.sync_blocks([b79], True)

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

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

block(81, spend=out[26])		b81 = self.next_block(81, spend=out[26])
yield rejected() # other chain is same length		# other chain is same length
save_spendable_output()		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		b82 = self.next_block(82, spend=out[27])
save_spendable_output()		# 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		# now check that tx78 and tx79 have been put back into the peer's
# mempool		# mempool
mempool = self.nodes[0].getrawmempool()		mempool = self.nodes[0].getrawmempool()
assert_equal(len(mempool), 2)		assert_equal(len(mempool), 2)
assert(tx78.hash in mempool)		assert(tx78.hash in mempool)
assert(tx79.hash in mempool)		assert(tx79.hash in mempool)

# Test invalid opcodes in dead execution paths.		# Test invalid opcodes in dead execution paths.
#		#
# -> b81 (26) -> b82 (27) -> b83 (28)		# -> 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]		op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
script = CScript(op_codes)		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)		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.vin[0].scriptSig = CScript([OP_FALSE])
tx2.rehash()		tx2.rehash()

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

# Reorg on/off blocks that have OP_RETURN in them (and try to spend them)		# 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)		# -> b81 (26) -> b82 (27) -> b83 (28) -> b84 (29) -> b87 (30) -> b88 (31)
# \-> b85 (29) -> b86 (30) \-> b89a (32)		# \-> b85 (29) -> b86 (30) \-> b89a (32)
#		#
#		self.log.info("Test re-orging blocks with OP_RETURN in them")
block(84)		b84 = self.next_block(84)
tx1 = create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN]))		tx1 = self.create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN]))
vout_offset = len(tx1.vout)		vout_offset = len(tx1.vout)
		markblundebergAuthorUnsubmitted Done Inline Actions this vout_offset business comes from pad_tx adding an extra output during create_tx markblundeberg: this vout_offset business comes from pad_tx adding an extra output during create_tx
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))		tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))		tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))		tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))		tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.calc_sha256()		tx1.calc_sha256()
self.sign_tx(tx1, out[29].tx, out[29].n)		self.sign_tx(tx1, out[29].tx, out[29].n)
tx1.rehash()		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])))		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])))		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])))		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])		b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
yield accepted()		self.sync_blocks([b84], True)
save_spendable_output()		self.save_spendable_output()

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

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

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

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

# trying to spend the OP_RETURN output is rejected		# trying to spend the OP_RETURN output is rejected
block("89a", spend=out[32])		b89a = self.next_block("89a", spend=out[32])
tx = create_tx(tx1, 0, 0, CScript([OP_TRUE]))		tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
update_block("89a", [tx])		b89a = self.update_block("89a", [tx])
yield rejected()		self.sync_blocks([b89a], False, 16,
		b'bad-txns-inputs-missingorspent', reconnect=True)

# Test re-org of a week's worth of blocks (1088 blocks)		self.log.info(
# This test takes a minute or two and can be accomplished in memory		"Test a re-org of one week's worth of blocks (1088 blocks)")
#
if self.options.runbarelyexpensive:		self.move_tip(88)
tip(88)
LARGE_REORG_SIZE = 1088		LARGE_REORG_SIZE = 1088
test1 = TestInstance(sync_every_block=False)		blocks = []
spend = out[32]		spend = out[32]
for i in range(89, LARGE_REORG_SIZE + 89):		for i in range(89, LARGE_REORG_SIZE + 89):
b = block(i, spend)		b = self.next_block(i, spend)
tx = CTransaction()		tx = CTransaction()
script_length = LEGACY_MAX_BLOCK_SIZE - len(b.serialize()) - 69		script_length = LEGACY_MAX_BLOCK_SIZE - len(b.serialize()) - 69
script_output = CScript([b'\x00' * script_length])		script_output = CScript([b'\x00' * script_length])
tx.vout.append(CTxOut(0, script_output))		tx.vout.append(CTxOut(0, script_output))
tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))		tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
b = update_block(i, [tx])		b = self.update_block(i, [tx])
assert_equal(len(b.serialize()), LEGACY_MAX_BLOCK_SIZE)		assert_equal(len(b.serialize()), LEGACY_MAX_BLOCK_SIZE)
test1.blocks_and_transactions.append([self.tip, True])		blocks.append(b)
save_spendable_output()		self.save_spendable_output()
spend = get_spendable_output()		spend = self.get_spendable_output()

yield test1		self.sync_blocks(blocks, True, timeout=180)
chain1_tip = i		chain1_tip = i

# now create alt chain of same length		# now create alt chain of same length
tip(88)		self.move_tip(88)
test2 = TestInstance(sync_every_block=False)		blocks2 = []
for i in range(89, LARGE_REORG_SIZE + 89):		for i in range(89, LARGE_REORG_SIZE + 89):
block("alt" + str(i))		blocks2.append(self.next_block("alt" + str(i)))
test2.blocks_and_transactions.append([self.tip, False])		self.sync_blocks(blocks2, False, request_block=False)
yield test2

# extend alt chain to trigger re-org		# extend alt chain to trigger re-org
block("alt" + str(chain1_tip + 1))		block = self.next_block("alt" + str(chain1_tip + 1))
yield accepted()		self.sync_blocks([block], True, timeout=180)

# ... and re-org back to the first chain		# ... and re-org back to the first chain
tip(chain1_tip)		self.move_tip(chain1_tip)
block(chain1_tip + 1)		block = self.next_block(chain1_tip + 1)
yield rejected()		self.sync_blocks([block], False, request_block=False)
block(chain1_tip + 2)		block = self.next_block(chain1_tip + 2)
yield accepted()		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([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)
		tx = create_transaction(
		spend.tx, spend.n, b"", 1, script) # spend 1 satoshi
		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)

chain1_tip += 2		if reconnect:
		self.reconnect_p2p()


if __name__ == '__main__':		if __name__ == '__main__':
FullBlockTest().main()		FullBlockTest().main()