Differential D2078 Diff 5854 test/functional/p2p-compactblocks.py

Changeset View

Standalone View

test/functional/p2p-compactblocks.py

#!/usr/bin/env python3		#!/usr/bin/env python3
# Copyright (c) 2016 The Bitcoin Core developers		# Copyright (c) 2016 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.

from test_framework.mininode import *		from test_framework.mininode import *
from test_framework.test_framework import BitcoinTestFramework		from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *		from test_framework.util import *
from test_framework.blocktools import create_block, create_coinbase		from test_framework.blocktools import create_block, create_coinbase
from test_framework.script import CScript, OP_TRUE		from test_framework.script import CScript, OP_TRUE
		from test_framework.txtools import pad_tx

'''		'''
CompactBlocksTest -- test compact blocks (BIP 152)		CompactBlocksTest -- test compact blocks (BIP 152)

Only testing Version 1 compact blocks (txids)		Only testing Version 1 compact blocks (txids)
'''		'''

# TestNode: A peer we use to send messages to bitcoind, and store responses.		# TestNode: A peer we use to send messages to bitcoind, and store responses.
▲ Show 20 Lines • Show All 389 Lines • ▼ Show 20 Lines	def test_compactblock_requests(self, node, test_node, version):
# Send the coinbase, and verify that the tip advances.		# Send the coinbase, and verify that the tip advances.
msg = msg_blocktxn()		msg = msg_blocktxn()
msg.block_transactions.blockhash = block.sha256		msg.block_transactions.blockhash = block.sha256
msg.block_transactions.transactions = [block.vtx[0]]		msg.block_transactions.transactions = [block.vtx[0]]
test_node.send_and_ping(msg)		test_node.send_and_ping(msg)
assert_equal(int(node.getbestblockhash(), 16), block.sha256)		assert_equal(int(node.getbestblockhash(), 16), block.sha256)

# Create a chain of transactions from given utxo, and add to a new block.		# Create a chain of transactions from given utxo, and add to a new block.
		# Note that num_transactions is number of transactions not including the
		# coinbase.
def build_block_with_transactions(self, node, utxo, num_transactions):		def build_block_with_transactions(self, node, utxo, num_transactions):
block = self.build_block_on_tip(node)		block = self.build_block_on_tip(node)

for i in range(num_transactions):		for i in range(num_transactions):
tx = CTransaction()		tx = CTransaction()
tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b''))		tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b''))
tx.vout.append(CTxOut(utxo[2] - 1000, CScript([OP_TRUE])))		tx.vout.append(CTxOut(utxo[2] - 1000, CScript([OP_TRUE])))
		pad_tx(tx)
tx.rehash()		tx.rehash()
utxo = [tx.sha256, 0, tx.vout[0].nValue]		utxo = [tx.sha256, 0, tx.vout[0].nValue]
block.vtx.append(tx)		block.vtx.append(tx)

		ordered_txs = block.vtx
		block.vtx = [block.vtx[0]] + \
		sorted(block.vtx[1:], key=lambda tx: tx.get_id())
block.hashMerkleRoot = block.calc_merkle_root()		block.hashMerkleRoot = block.calc_merkle_root()
block.solve()		block.solve()
return block		return block, ordered_txs

# Test that we only receive getblocktxn requests for transactions that the		# Test that we only receive getblocktxn requests for transactions that the
# node needs, and that responding to them causes the block to be		# node needs, and that responding to them causes the block to be
# reconstructed.		# reconstructed.
def test_getblocktxn_requests(self, node, test_node, version):		def test_getblocktxn_requests(self, node, test_node, version):
def test_getblocktxn_response(compact_block, peer, expected_result):		def test_getblocktxn_response(compact_block, peer, expected_result):
msg = msg_cmpctblock(compact_block.to_p2p())		msg = msg_cmpctblock(compact_block.to_p2p())
peer.send_and_ping(msg)		peer.send_and_ping(msg)
with mininode_lock:		with mininode_lock:
		print(peer.last_message)
assert("getblocktxn" in peer.last_message)		assert("getblocktxn" in peer.last_message)
absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute(		absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute(
)		)
assert_equal(absolute_indexes, expected_result)		assert_equal(absolute_indexes, expected_result)

def test_tip_after_message(node, peer, msg, tip):		def test_tip_after_message(node, peer, msg, tip):
peer.send_and_ping(msg)		peer.send_and_ping(msg)
assert_equal(int(node.getbestblockhash(), 16), tip)		assert_equal(int(node.getbestblockhash(), 16), tip)

# First try announcing compactblocks that won't reconstruct, and verify		# First try announcing compactblocks that won't reconstruct, and verify
# that we receive getblocktxn messages back.		# that we receive getblocktxn messages back.
utxo = self.utxos.pop(0)		utxo = self.utxos.pop(0)

block = self.build_block_with_transactions(node, utxo, 5)		block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
self.utxos.append(		self.utxos.append(
[block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])		[ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
comp_block = HeaderAndShortIDs()		comp_block = HeaderAndShortIDs()
comp_block.initialize_from_block(block)		comp_block.initialize_from_block(block)

test_getblocktxn_response(comp_block, test_node, [1, 2, 3, 4, 5])		test_getblocktxn_response(comp_block, test_node, [1, 2, 3, 4, 5])

msg_bt = msg_blocktxn()		msg_bt = msg_blocktxn()
msg_bt.block_transactions = BlockTransactions(		msg_bt.block_transactions = BlockTransactions(
block.sha256, block.vtx[1:])		block.sha256, block.vtx[1:])
test_tip_after_message(node, test_node, msg_bt, block.sha256)		test_tip_after_message(node, test_node, msg_bt, block.sha256)

utxo = self.utxos.pop(0)		utxo = self.utxos.pop(0)
block = self.build_block_with_transactions(node, utxo, 5)		block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
self.utxos.append(		self.utxos.append(
[block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])		[ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])

# Now try interspersing the prefilled transactions		# Now try interspersing the prefilled transactions
comp_block.initialize_from_block(		comp_block.initialize_from_block(
block, prefill_list=[0, 1, 5])		block, prefill_list=[0, 1, 5])
test_getblocktxn_response(comp_block, test_node, [2, 3, 4])		test_getblocktxn_response(comp_block, test_node, [2, 3, 4])
msg_bt.block_transactions = BlockTransactions(		msg_bt.block_transactions = BlockTransactions(
block.sha256, block.vtx[2:5])		block.sha256, block.vtx[2:5])
test_tip_after_message(node, test_node, msg_bt, block.sha256)		test_tip_after_message(node, test_node, msg_bt, block.sha256)

# Now try giving one transaction ahead of time.		# Now try giving one transaction ahead of time.
utxo = self.utxos.pop(0)		utxo = self.utxos.pop(0)
block = self.build_block_with_transactions(node, utxo, 5)		block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
self.utxos.append(		self.utxos.append(
[block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])		[ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
test_node.send_and_ping(msg_tx(block.vtx[1]))		test_node.send_and_ping(msg_tx(ordered_txs[1]))
assert(block.vtx[1].hash in node.getrawmempool())		assert(ordered_txs[1].hash in node.getrawmempool())
		test_node.send_and_ping(msg_tx(ordered_txs[1]))

# Prefill 4 out of the 6 transactions, and verify that only the one		# Prefill 4 out of the 6 transactions, and verify that only the one
# that was not in the mempool is requested.		# that was not in the mempool is requested.
comp_block.initialize_from_block(block, prefill_list=[0, 2, 3, 4])		prefill_list = [0, 1, 2, 3, 4, 5]
test_getblocktxn_response(comp_block, test_node, [5])		prefill_list.remove(block.vtx.index(ordered_txs[1]))
		expected_index = block.vtx.index(ordered_txs[-1])
		prefill_list.remove(expected_index)
		comp_block.initialize_from_block(block, prefill_list=prefill_list)
		test_getblocktxn_response(comp_block, test_node, [expected_index])

msg_bt.block_transactions = BlockTransactions(		msg_bt.block_transactions = BlockTransactions(
block.sha256, [block.vtx[5]])		block.sha256, [ordered_txs[5]])
test_tip_after_message(node, test_node, msg_bt, block.sha256)		test_tip_after_message(node, test_node, msg_bt, block.sha256)

# Now provide all transactions to the node before the block is		# Now provide all transactions to the node before the block is
# announced and verify reconstruction happens immediately.		# announced and verify reconstruction happens immediately.
utxo = self.utxos.pop(0)		utxo = self.utxos.pop(0)
block = self.build_block_with_transactions(node, utxo, 10)		block, ordered_txs = self.build_block_with_transactions(node, utxo, 10)
self.utxos.append(		self.utxos.append(
[block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])		[ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
for tx in block.vtx[1:]:		for tx in block.vtx[1:]:
test_node.send_message(msg_tx(tx))		test_node.send_message(msg_tx(tx))
test_node.sync_with_ping()		test_node.sync_with_ping()
# Make sure all transactions were accepted.		# Make sure all transactions were accepted.
mempool = node.getrawmempool()		mempool = node.getrawmempool()
for tx in block.vtx[1:]:		for tx in block.vtx[1:]:
assert(tx.hash in mempool)		assert(tx.hash in mempool)

Show All 11 Lines	class CompactBlocksTest(BitcoinTestFramework):

# Incorrectly responding to a getblocktxn shouldn't cause the block to be		# Incorrectly responding to a getblocktxn shouldn't cause the block to be
# permanently failed.		# permanently failed.
def test_incorrect_blocktxn_response(self, node, test_node, version):		def test_incorrect_blocktxn_response(self, node, test_node, version):
if (len(self.utxos) == 0):		if (len(self.utxos) == 0):
self.make_utxos()		self.make_utxos()
utxo = self.utxos.pop(0)		utxo = self.utxos.pop(0)

block = self.build_block_with_transactions(node, utxo, 10)		block, ordered_txs = self.build_block_with_transactions(node, utxo, 10)
self.utxos.append(		self.utxos.append(
[block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])		[ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
# Relay the first 5 transactions from the block in advance		# Relay the first 5 transactions from the block in advance
for tx in block.vtx[1:6]:		for tx in ordered_txs[1:6]:
test_node.send_message(msg_tx(tx))		test_node.send_message(msg_tx(tx))
test_node.sync_with_ping()		test_node.sync_with_ping()
# Make sure all transactions were accepted.		# Make sure all transactions were accepted.
mempool = node.getrawmempool()		mempool = node.getrawmempool()
for tx in block.vtx[1:6]:		for tx in ordered_txs[1:6]:
assert(tx.hash in mempool)		assert(tx.hash in mempool)

# Send compact block		# Send compact block
comp_block = HeaderAndShortIDs()		comp_block = HeaderAndShortIDs()
comp_block.initialize_from_block(block, prefill_list=[0])		comp_block.initialize_from_block(block, prefill_list=[0])
test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))		test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
absolute_indexes = []		absolute_indices = []
with mininode_lock:		with mininode_lock:
assert("getblocktxn" in test_node.last_message)		assert("getblocktxn" in test_node.last_message)
absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute(		absolute_indices = test_node.last_message["getblocktxn"].block_txn_request.to_absolute(
)		)
assert_equal(absolute_indexes, [6, 7, 8, 9, 10])		expected_indices = []
		for i in [6, 7, 8, 9, 10]:
		expected_indices.append(block.vtx.index(ordered_txs[i]))
		assert_equal(absolute_indices, sorted(expected_indices))

# Now give an incorrect response.		# Now give an incorrect response.
# Note that it's possible for bitcoind to be smart enough to know we're		# Note that it's possible for bitcoind to be smart enough to know we're
# lying, since it could check to see if the shortid matches what we're		# lying, since it could check to see if the shortid matches what we're
# sending, and eg disconnect us for misbehavior. If that behavior		# sending, and eg disconnect us for misbehavior. If that behavior
# change were made, we could just modify this test by having a		# change were made, we could just modify this test by having a
# different peer provide the block further down, so that we're still		# different peer provide the block further down, so that we're still
# verifying that the block isn't marked bad permanently. This is good		# verifying that the block isn't marked bad permanently. This is good
# enough for now.		# enough for now.
msg = msg_blocktxn()		msg = msg_blocktxn()
msg.block_transactions = BlockTransactions(		msg.block_transactions = BlockTransactions(
block.sha256, [block.vtx[5]] + block.vtx[7:])		block.sha256, [ordered_txs[5]] + ordered_txs[7:])
test_node.send_and_ping(msg)		test_node.send_and_ping(msg)

# Tip should not have updated		# Tip should not have updated
assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)		assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)

# We should receive a getdata request		# We should receive a getdata request
wait_until(lambda: "getdata" in test_node.last_message,		wait_until(lambda: "getdata" in test_node.last_message,
timeout=10, lock=mininode_lock)		timeout=10, lock=mininode_lock)
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines	def test_compactblocks_not_at_tip(self, node, test_node):
test_node.last_message.pop("blocktxn", None)		test_node.last_message.pop("blocktxn", None)
test_node.send_and_ping(msg)		test_node.send_and_ping(msg)
with mininode_lock:		with mininode_lock:
assert "blocktxn" not in test_node.last_message		assert "blocktxn" not in test_node.last_message

def test_end_to_end_block_relay(self, node, listeners):		def test_end_to_end_block_relay(self, node, listeners):
utxo = self.utxos.pop(0)		utxo = self.utxos.pop(0)

block = self.build_block_with_transactions(node, utxo, 10)		block, _ = self.build_block_with_transactions(node, utxo, 10)

[l.clear_block_announcement() for l in listeners]		[l.clear_block_announcement() for l in listeners]

node.submitblock(ToHex(block))		node.submitblock(ToHex(block))

for l in listeners:		for l in listeners:
wait_until(lambda: l.received_block_announcement(),		wait_until(lambda: l.received_block_announcement(),
timeout=30, lock=mininode_lock)		timeout=30, lock=mininode_lock)
with mininode_lock:		with mininode_lock:
for l in listeners:		for l in listeners:
assert "cmpctblock" in l.last_message		assert "cmpctblock" in l.last_message
l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256(		l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256(
)		)
assert_equal(		assert_equal(
l.last_message["cmpctblock"].header_and_shortids.header.sha256, block.sha256)		l.last_message["cmpctblock"].header_and_shortids.header.sha256, block.sha256)

# Test that we don't get disconnected if we relay a compact block with valid header,		# Test that we don't get disconnected if we relay a compact block with valid header,
# but invalid transactions.		# but invalid transactions.
def test_invalid_tx_in_compactblock(self, node, test_node):		def test_invalid_tx_in_compactblock(self, node, test_node):
assert(len(self.utxos))		assert(len(self.utxos))
utxo = self.utxos[0]		utxo = self.utxos[0]

block = self.build_block_with_transactions(node, utxo, 5)		block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
del block.vtx[3]		block.vtx.remove(ordered_txs[3])
block.hashMerkleRoot = block.calc_merkle_root()		block.hashMerkleRoot = block.calc_merkle_root()
block.solve()		block.solve()

# Now send the compact block with all transactions prefilled, and		# Now send the compact block with all transactions prefilled, and
# verify that we don't get disconnected.		# verify that we don't get disconnected.
comp_block = HeaderAndShortIDs()		comp_block = HeaderAndShortIDs()
comp_block.initialize_from_block(block, prefill_list=[0, 1, 2, 3, 4])		comp_block.initialize_from_block(block, prefill_list=[0, 1, 2, 3, 4])
msg = msg_cmpctblock(comp_block.to_p2p())		msg = msg_cmpctblock(comp_block.to_p2p())
Show All 14 Lines	def request_cb_announcements(self, peer, node, version=1):
msg.announce = True		msg.announce = True
peer.send_and_ping(msg)		peer.send_and_ping(msg)

def test_compactblock_reconstruction_multiple_peers(self, node, stalling_peer, delivery_peer):		def test_compactblock_reconstruction_multiple_peers(self, node, stalling_peer, delivery_peer):
assert(len(self.utxos))		assert(len(self.utxos))

def announce_cmpct_block(node, peer):		def announce_cmpct_block(node, peer):
utxo = self.utxos.pop(0)		utxo = self.utxos.pop(0)
block = self.build_block_with_transactions(node, utxo, 5)		block, _ = self.build_block_with_transactions(node, utxo, 5)

cmpct_block = HeaderAndShortIDs()		cmpct_block = HeaderAndShortIDs()
cmpct_block.initialize_from_block(block)		cmpct_block.initialize_from_block(block)
msg = msg_cmpctblock(cmpct_block.to_p2p())		msg = msg_cmpctblock(cmpct_block.to_p2p())
peer.send_and_ping(msg)		peer.send_and_ping(msg)
with mininode_lock:		with mininode_lock:
assert "getblocktxn" in peer.last_message		assert "getblocktxn" in peer.last_message
return block, cmpct_block		return block, cmpct_block
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines