No OneTemporary
Actions

Size

84 KB

Subscribers

None

View Options

	diff --git a/test/functional/p2p_invalid_messages.py b/test/functional/p2p_invalid_messages.py
	index 0fe9f83c8..38d11813e 100755
	--- a/test/functional/p2p_invalid_messages.py
	+++ b/test/functional/p2p_invalid_messages.py
	@@ -1,234 +1,234 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2019 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.
	"""Test node responses to invalid network messages."""
	import asyncio
	import struct

	from test_framework import messages
	from test_framework.mininode import P2PDataStore, NetworkThread
	from test_framework.test_framework import BitcoinTestFramework


	class msg_unrecognized:
	"""Nonsensical message. Modeled after similar types in test_framework.messages."""

	- command = b'badmsg'
	+ msgtype = b'badmsg'

	def __init__(self, *, str_data):
	self.str_data = str_data.encode() if not isinstance(str_data, bytes) else str_data

	def serialize(self):
	return messages.ser_string(self.str_data)

	def __repr__(self):
	- return "{}(data={})".format(self.command, self.str_data)
	+ return "{}(data={})".format(self.msgtype, self.str_data)


	class InvalidMessagesTest(BitcoinTestFramework):
	def set_test_params(self):
	self.num_nodes = 1
	self.setup_clean_chain = True

	def run_test(self):
	"""
	. Test msg header
	0. Send a bunch of large (2MB) messages of an unrecognized type. Check to see
	that it isn't an effective DoS against the node.

	1. Send an oversized (2MB+) message and check that we're disconnected.

	2. Send a few messages with an incorrect data size in the header, ensure the
	messages are ignored.
	"""
	self.test_magic_bytes()
	self.test_checksum()
	self.test_size()
	- self.test_command()
	+ self.test_msgtype()

	node = self.nodes[0]
	self.node = node
	node.add_p2p_connection(P2PDataStore())
	conn2 = node.add_p2p_connection(P2PDataStore())

	# 2MB, per MAX_PROTOCOL_MESSAGE_LENGTH
	msg_limit = 2 * 1024 * 1024
	# Account for the 4-byte length prefix
	valid_data_limit = msg_limit - 5

	#
	# 0.
	#
	# Send as large a message as is valid, ensure we aren't disconnected but
	# also can't exhaust resources.
	#
	msg_at_size = msg_unrecognized(str_data="b" * valid_data_limit)
	assert len(msg_at_size.serialize()) == msg_limit

	self.log.info(
	"Sending a bunch of large, junk messages to test memory exhaustion. May take a bit...")

	# Run a bunch of times to test for memory exhaustion.
	for _ in range(80):
	node.p2p.send_message(msg_at_size)

	# Check that, even though the node is being hammered by nonsense from one
	# connection, it can still service other peers in a timely way.
	for _ in range(20):
	conn2.sync_with_ping(timeout=2)

	# Peer 1, despite serving up a bunch of nonsense, should still be
	# connected.
	self.log.info("Waiting for node to drop junk messages.")
	node.p2p.sync_with_ping(timeout=320)
	assert node.p2p.is_connected

	#
	# 1.
	#
	# Send an oversized message, ensure we're disconnected.
	#
	msg_over_size = msg_unrecognized(str_data="b" * (valid_data_limit + 1))
	assert len(msg_over_size.serialize()) == (msg_limit + 1)

	with node.assert_debug_log(["Oversized header detected"]):
	# An unknown message type (or any message type) over
	# MAX_PROTOCOL_MESSAGE_LENGTH should result in a disconnect.
	node.p2p.send_message(msg_over_size)
	node.p2p.wait_for_disconnect(timeout=4)

	node.disconnect_p2ps()
	conn = node.add_p2p_connection(P2PDataStore())
	conn.wait_for_verack()

	#
	# 2.
	#
	# Send messages with an incorrect data size in the header.
	#
	actual_size = 100
	msg = msg_unrecognized(str_data="b" * actual_size)

	# TODO: handle larger-than cases. I haven't been able to pin down what
	# behavior to expect.
	for wrong_size in (2, 77, 78, 79):
	self.log.info(
	"Sending a message with incorrect size of {}".format(wrong_size))

	# Unmodified message should submit okay.
	node.p2p.send_and_ping(msg)

	# A message lying about its data size results in a disconnect when the incorrect
	# data size is less than the actual size.
	#
	# TODO: why does behavior change at 78 bytes?
	#
	node.p2p.send_raw_message(
	self._tweak_msg_data_size(
	msg, wrong_size))

	# For some reason unknown to me, we sometimes have to push additional data to the
	# peer in order for it to realize a disconnect.
	try:
	node.p2p.send_message(messages.msg_ping(nonce=123123))
	except IOError:
	pass

	node.p2p.wait_for_disconnect(timeout=10)
	node.disconnect_p2ps()
	node.add_p2p_connection(P2PDataStore())

	# Node is still up.
	conn = node.add_p2p_connection(P2PDataStore())

	def test_magic_bytes(self):
	conn = self.nodes[0].add_p2p_connection(P2PDataStore())

	async def swap_magic_bytes():
	# Need to ignore all incoming messages from now, since they come
	# with "invalid" magic bytes
	conn._on_data = lambda: None
	conn.magic_bytes = b'\x00\x11\x22\x32'

	# Call .result() to block until the atomic swap is complete, otherwise
	# we might run into races later on
	asyncio.run_coroutine_threadsafe(
	swap_magic_bytes(),
	NetworkThread.network_event_loop).result()

	with self.nodes[0].assert_debug_log(['PROCESSMESSAGE: INVALID MESSAGESTART ping']):
	conn.send_message(messages.msg_ping(nonce=0xff))
	conn.wait_for_disconnect(timeout=1)
	self.nodes[0].disconnect_p2ps()

	def test_checksum(self):
	conn = self.nodes[0].add_p2p_connection(P2PDataStore())
	with self.nodes[0].assert_debug_log(['CHECKSUM ERROR (badmsg, 2 bytes), expected 78df0a04 was ffffffff']):
	msg = conn.build_message(msg_unrecognized(str_data="d"))
	cut_len = (
	# magic
	4 +
	- # command
	+ # msgtype
	12 +
	# len
	4
	)
	# modify checksum
	msg = msg[:cut_len] + b'\xff' * 4 + msg[cut_len + 4:]
	self.nodes[0].p2p.send_raw_message(msg)
	conn.wait_for_disconnect()
	self.nodes[0].disconnect_p2ps()

	def test_size(self):
	conn = self.nodes[0].add_p2p_connection(P2PDataStore())
	with self.nodes[0].assert_debug_log(['']):
	msg = conn.build_message(msg_unrecognized(str_data="d"))
	cut_len = (
	# magic
	4 +
	# command
	12
	)
	# modify len to MAX_SIZE + 1
	msg = msg[:cut_len] + \
	struct.pack("<I", 0x02000000 + 1) + msg[cut_len + 4:]
	self.nodes[0].p2p.send_raw_message(msg)
	conn.wait_for_disconnect(timeout=1)
	self.nodes[0].disconnect_p2ps()

	- def test_command(self):
	+ def test_msgtype(self):
	conn = self.nodes[0].add_p2p_connection(P2PDataStore())
	with self.nodes[0].assert_debug_log(['PROCESSMESSAGE: ERRORS IN HEADER']):
	msg = msg_unrecognized(str_data="d")
	- msg.command = b'\xff' * 12
	+ msg.msgtype = b'\xff' * 12
	msg = conn.build_message(msg)
	- # Modify command
	+ # Modify msgtype
	msg = msg[:7] + b'\x00' + msg[7 + 1:]
	self.nodes[0].p2p.send_raw_message(msg)
	conn.sync_with_ping(timeout=1)
	self.nodes[0].disconnect_p2ps()

	def _tweak_msg_data_size(self, message, wrong_size):
	"""
	Return a raw message based on another message but with an incorrect data size in
	the message header.
	"""
	raw_msg = self.node.p2p.build_message(message)

	bad_size_bytes = struct.pack("<I", wrong_size)
	num_header_bytes_before_size = 4 + 12

	# Replace the correct data size in the message with an incorrect one.
	raw_msg_with_wrong_size = (
	raw_msg[:num_header_bytes_before_size] +
	bad_size_bytes +
	raw_msg[(num_header_bytes_before_size + len(bad_size_bytes)):]
	)
	assert len(raw_msg) == len(raw_msg_with_wrong_size)

	return raw_msg_with_wrong_size


	if __name__ == '__main__':
	InvalidMessagesTest().main()
	diff --git a/test/functional/p2p_leak.py b/test/functional/p2p_leak.py
	index ea620e00a..f25245d9e 100755
	--- a/test/functional/p2p_leak.py
	+++ b/test/functional/p2p_leak.py
	@@ -1,177 +1,177 @@
	#!/usr/bin/env python3
	# Copyright (c) 2017-2019 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.
	"""Test message sending before handshake completion.

	A node should never send anything other than VERSION/VERACK/REJECT until it's
	received a VERACK.

	This test connects to a node and sends it a few messages, trying to entice it
	into sending us something it shouldn't.
	"""

	import time

	from test_framework.messages import (
	msg_getaddr,
	msg_ping,
	msg_verack,
	)
	from test_framework.mininode import (
	mininode_lock,
	P2PInterface,
	)
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import wait_until

	banscore = 10


	class CLazyNode(P2PInterface):
	def __init__(self):
	super().__init__()
	self.unexpected_msg = False
	self.ever_connected = False

	def bad_message(self, message):
	self.unexpected_msg = True
	self.log.info(
	- "should not have received message: {}".format(message.command))
	+ "should not have received message: {}".format(message.msgtype))

	def on_open(self):
	self.ever_connected = True

	def on_version(self, message): self.bad_message(message)

	def on_verack(self, message): self.bad_message(message)

	def on_reject(self, message): self.bad_message(message)

	def on_inv(self, message): self.bad_message(message)

	def on_addr(self, message): self.bad_message(message)

	def on_getdata(self, message): self.bad_message(message)

	def on_getblocks(self, message): self.bad_message(message)

	def on_tx(self, message): self.bad_message(message)

	def on_block(self, message): self.bad_message(message)

	def on_getaddr(self, message): self.bad_message(message)

	def on_headers(self, message): self.bad_message(message)

	def on_getheaders(self, message): self.bad_message(message)

	def on_ping(self, message): self.bad_message(message)

	def on_mempool(self, message): self.bad_message(message)

	def on_pong(self, message): self.bad_message(message)

	def on_feefilter(self, message): self.bad_message(message)

	def on_sendheaders(self, message): self.bad_message(message)

	def on_sendcmpct(self, message): self.bad_message(message)

	def on_cmpctblock(self, message): self.bad_message(message)

	def on_getblocktxn(self, message): self.bad_message(message)

	def on_blocktxn(self, message): self.bad_message(message)

	# Node that never sends a version. We'll use this to send a bunch of messages
	# anyway, and eventually get disconnected.


	class CNodeNoVersionBan(CLazyNode):
	# send a bunch of veracks without sending a message. This should get us disconnected.
	# NOTE: implementation-specific check here. Remove if bitcoind ban
	# behavior changes
	def on_open(self):
	super().on_open()
	for i in range(banscore):
	self.send_message(msg_verack())

	def on_reject(self, message): pass

	# Node that never sends a version. This one just sits idle and hopes to receive
	# any message (it shouldn't!)


	class CNodeNoVersionIdle(CLazyNode):
	def __init__(self):
	super().__init__()

	# Node that sends a version but not a verack.


	class CNodeNoVerackIdle(CLazyNode):
	def __init__(self):
	self.version_received = False
	super().__init__()

	def on_reject(self, message): pass

	def on_verack(self, message): pass
	# When version is received, don't reply with a verack. Instead, see if the
	# node will give us a message that it shouldn't. This is not an exhaustive
	# list!

	def on_version(self, message):
	self.version_received = True
	self.send_message(msg_ping())
	self.send_message(msg_getaddr())


	class P2PLeakTest(BitcoinTestFramework):
	def set_test_params(self):
	self.num_nodes = 1
	self.extra_args = [['-banscore=' + str(banscore)]]

	def run_test(self):
	no_version_bannode = self.nodes[0].add_p2p_connection(
	CNodeNoVersionBan(), send_version=False, wait_for_verack=False)
	no_version_idlenode = self.nodes[0].add_p2p_connection(
	CNodeNoVersionIdle(), send_version=False, wait_for_verack=False)
	no_verack_idlenode = self.nodes[0].add_p2p_connection(
	CNodeNoVerackIdle(), wait_for_verack=False)

	# Wait until we got the verack in response to the version. Though, don't wait for the other node to receive the
	# verack, since we never sent one
	no_verack_idlenode.wait_for_verack()

	wait_until(lambda: no_version_bannode.ever_connected,
	timeout=10, lock=mininode_lock)
	wait_until(lambda: no_version_idlenode.ever_connected,
	timeout=10, lock=mininode_lock)
	wait_until(lambda: no_verack_idlenode.version_received,
	timeout=10, lock=mininode_lock)

	# Mine a block and make sure that it's not sent to the connected nodes
	self.nodes[0].generatetoaddress(
	1, self.nodes[0].get_deterministic_priv_key().address)

	# Give the node enough time to possibly leak out a message
	time.sleep(5)

	# This node should have been banned
	assert not no_version_bannode.is_connected

	self.nodes[0].disconnect_p2ps()

	# Wait until all connections are closed
	wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 0)

	# Make sure no unexpected messages came in
	assert not no_version_bannode.unexpected_msg
	assert not no_version_idlenode.unexpected_msg
	assert not no_verack_idlenode.unexpected_msg


	if __name__ == '__main__':
	P2PLeakTest().main()
	diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
	index 5b3160d1f..55dfb9e3d 100755
	--- a/test/functional/test_framework/messages.py
	+++ b/test/functional/test_framework/messages.py
	@@ -1,1526 +1,1526 @@
	#!/usr/bin/env python3
	# Copyright (c) 2010 ArtForz -- public domain half-a-node
	# Copyright (c) 2012 Jeff Garzik
	# Copyright (c) 2010-2019 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.
	"""Bitcoin test framework primitive and message structures

	CBlock, CTransaction, CBlockHeader, CTxIn, CTxOut, etc....:
	data structures that should map to corresponding structures in
	bitcoin/primitives

	msg_block, msg_tx, msg_headers, etc.:
	data structures that represent network messages

	ser_, deser_: functions that handle serialization/deserialization.

	Classes use __slots__ to ensure extraneous attributes aren't accidentally added
	by tests, compromising their intended effect.
	"""
	from codecs import encode
	import copy
	import hashlib
	from io import BytesIO
	import random
	import socket
	import struct
	import time

	from test_framework.siphash import siphash256
	from test_framework.util import hex_str_to_bytes, assert_equal


	MIN_VERSION_SUPPORTED = 60001
	# past bip-31 for ping/pong
	MY_VERSION = 70014
	MY_SUBVERSION = b"/python-mininode-tester:0.0.3/"
	# from version 70001 onwards, fRelay should be appended to version
	# messages (BIP37)
	MY_RELAY = 1

	MAX_LOCATOR_SZ = 101
	MAX_BLOCK_BASE_SIZE = 1000000

	# 1 BCH in satoshis
	COIN = 100000000

	NODE_NETWORK = (1 << 0)
	NODE_GETUTXO = (1 << 1)
	NODE_BLOOM = (1 << 2)
	# NODE_WITNESS = (1 << 3)
	NODE_XTHIN = (1 << 4)
	NODE_BITCOIN_CASH = (1 << 5)
	NODE_NETWORK_LIMITED = (1 << 10)
	NODE_AVALANCHE = (1 << 24)

	MSG_TX = 1
	MSG_BLOCK = 2
	MSG_FILTERED_BLOCK = 3
	MSG_CMPCTBLOCK = 4
	MSG_TYPE_MASK = 0xffffffff >> 2


	# Serialization/deserialization tools

	def sha256(s):
	return hashlib.new('sha256', s).digest()


	def hash256(s):
	return sha256(sha256(s))


	def ser_compact_size(size):
	r = b""
	if size < 253:
	r = struct.pack("B", size)
	elif size < 0x10000:
	r = struct.pack("<BH", 253, size)
	elif size < 0x100000000:
	r = struct.pack("<BI", 254, size)
	else:
	r = struct.pack("<BQ", 255, size)
	return r


	def deser_compact_size(f):
	nit = struct.unpack("<B", f.read(1))[0]
	if nit == 253:
	nit = struct.unpack("<H", f.read(2))[0]
	elif nit == 254:
	nit = struct.unpack("<I", f.read(4))[0]
	elif nit == 255:
	nit = struct.unpack("<Q", f.read(8))[0]
	return nit


	def deser_string(f):
	nit = deser_compact_size(f)
	return f.read(nit)


	def ser_string(s):
	return ser_compact_size(len(s)) + s


	def deser_uint256(f):
	r = 0
	for i in range(8):
	t = struct.unpack("<I", f.read(4))[0]
	r += t << (i * 32)
	return r


	def ser_uint256(u):
	rs = b""
	for i in range(8):
	rs += struct.pack("<I", u & 0xFFFFFFFF)
	u >>= 32
	return rs


	def uint256_from_str(s):
	r = 0
	t = struct.unpack("<IIIIIIII", s[:32])
	for i in range(8):
	r += t[i] << (i * 32)
	return r


	def uint256_from_compact(c):
	nbytes = (c >> 24) & 0xFF
	v = (c & 0xFFFFFF) << (8 * (nbytes - 3))
	return v


	def deser_vector(f, c):
	nit = deser_compact_size(f)
	r = []
	for i in range(nit):
	t = c()
	t.deserialize(f)
	r.append(t)
	return r


	# ser_function_name: Allow for an alternate serialization function on the
	# entries in the vector.
	def ser_vector(v, ser_function_name=None):
	r = ser_compact_size(len(v))
	for i in v:
	if ser_function_name:
	r += getattr(i, ser_function_name)()
	else:
	r += i.serialize()
	return r


	def deser_uint256_vector(f):
	nit = deser_compact_size(f)
	r = []
	for i in range(nit):
	t = deser_uint256(f)
	r.append(t)
	return r


	def ser_uint256_vector(v):
	r = ser_compact_size(len(v))
	for i in v:
	r += ser_uint256(i)
	return r


	def deser_string_vector(f):
	nit = deser_compact_size(f)
	r = []
	for i in range(nit):
	t = deser_string(f)
	r.append(t)
	return r


	def ser_string_vector(v):
	r = ser_compact_size(len(v))
	for sv in v:
	r += ser_string(sv)
	return r


	def FromHex(obj, hex_string):
	"""Deserialize from a hex string representation (eg from RPC)"""
	obj.deserialize(BytesIO(hex_str_to_bytes(hex_string)))
	return obj


	def ToHex(obj):
	"""Convert a binary-serializable object to hex
	(eg for submission via RPC)"""
	return obj.serialize().hex()


	# Objects that map to bitcoind objects, which can be serialized/deserialized

	class CAddress:
	__slots__ = ("ip", "nServices", "pchReserved", "port", "time")

	def __init__(self):
	self.time = 0
	self.nServices = 1
	self.pchReserved = b"\x00" * 10 + b"\xff" * 2
	self.ip = "0.0.0.0"
	self.port = 0

	def deserialize(self, f, with_time=True):
	if with_time:
	self.time = struct.unpack("<i", f.read(4))[0]
	self.nServices = struct.unpack("<Q", f.read(8))[0]
	self.pchReserved = f.read(12)
	self.ip = socket.inet_ntoa(f.read(4))
	self.port = struct.unpack(">H", f.read(2))[0]

	def serialize(self, with_time=True):
	r = b""
	if with_time:
	r += struct.pack("<i", self.time)
	r += struct.pack("<Q", self.nServices)
	r += self.pchReserved
	r += socket.inet_aton(self.ip)
	r += struct.pack(">H", self.port)
	return r

	def __repr__(self):
	return "CAddress(nServices={} ip={} port={})".format(
	self.nServices, self.ip, self.port)


	class CInv:
	__slots__ = ("hash", "type")

	typemap = {
	0: "Error",
	MSG_TX: "TX",
	MSG_BLOCK: "Block",
	MSG_FILTERED_BLOCK: "filtered Block",
	MSG_CMPCTBLOCK: "CompactBlock"
	}

	def __init__(self, t=0, h=0):
	self.type = t
	self.hash = h

	def deserialize(self, f):
	self.type = struct.unpack("<i", f.read(4))[0]
	self.hash = deser_uint256(f)

	def serialize(self):
	r = b""
	r += struct.pack("<i", self.type)
	r += ser_uint256(self.hash)
	return r

	def __repr__(self):
	return "CInv(type={} hash={:064x})".format(
	self.typemap[self.type], self.hash)


	class CBlockLocator:
	__slots__ = ("nVersion", "vHave")

	def __init__(self):
	self.nVersion = MY_VERSION
	self.vHave = []

	def deserialize(self, f):
	self.nVersion = struct.unpack("<i", f.read(4))[0]
	self.vHave = deser_uint256_vector(f)

	def serialize(self):
	r = b""
	r += struct.pack("<i", self.nVersion)
	r += ser_uint256_vector(self.vHave)
	return r

	def __repr__(self):
	return "CBlockLocator(nVersion={} vHave={})".format(
	self.nVersion, repr(self.vHave))


	class COutPoint:
	__slots__ = ("hash", "n")

	def __init__(self, hash=0, n=0):
	self.hash = hash
	self.n = n

	def deserialize(self, f):
	self.hash = deser_uint256(f)
	self.n = struct.unpack("<I", f.read(4))[0]

	def serialize(self):
	r = b""
	r += ser_uint256(self.hash)
	r += struct.pack("<I", self.n)
	return r

	def __repr__(self):
	return "COutPoint(hash={:064x} n={})".format(self.hash, self.n)


	class CTxIn:
	__slots__ = ("nSequence", "prevout", "scriptSig")

	def __init__(self, outpoint=None, scriptSig=b"", nSequence=0):
	if outpoint is None:
	self.prevout = COutPoint()
	else:
	self.prevout = outpoint
	self.scriptSig = scriptSig
	self.nSequence = nSequence

	def deserialize(self, f):
	self.prevout = COutPoint()
	self.prevout.deserialize(f)
	self.scriptSig = deser_string(f)
	self.nSequence = struct.unpack("<I", f.read(4))[0]

	def serialize(self):
	r = b""
	r += self.prevout.serialize()
	r += ser_string(self.scriptSig)
	r += struct.pack("<I", self.nSequence)
	return r

	def __repr__(self):
	return "CTxIn(prevout={} scriptSig={} nSequence={})".format(
	repr(self.prevout), self.scriptSig.hex(), self.nSequence)


	class CTxOut:
	__slots__ = ("nValue", "scriptPubKey")

	def __init__(self, nValue=0, scriptPubKey=b""):
	self.nValue = nValue
	self.scriptPubKey = scriptPubKey

	def deserialize(self, f):
	self.nValue = struct.unpack("<q", f.read(8))[0]
	self.scriptPubKey = deser_string(f)

	def serialize(self):
	r = b""
	r += struct.pack("<q", self.nValue)
	r += ser_string(self.scriptPubKey)
	return r

	def __repr__(self):
	return "CTxOut(nValue={}.{:08d} scriptPubKey={})".format(
	self.nValue // COIN, self.nValue % COIN, self.scriptPubKey.hex())


	class CTransaction:
	__slots__ = ("hash", "nLockTime", "nVersion", "sha256", "vin", "vout")

	def __init__(self, tx=None):
	if tx is None:
	self.nVersion = 1
	self.vin = []
	self.vout = []
	self.nLockTime = 0
	self.sha256 = None
	self.hash = None
	else:
	self.nVersion = tx.nVersion
	self.vin = copy.deepcopy(tx.vin)
	self.vout = copy.deepcopy(tx.vout)
	self.nLockTime = tx.nLockTime
	self.sha256 = tx.sha256
	self.hash = tx.hash

	def deserialize(self, f):
	self.nVersion = struct.unpack("<i", f.read(4))[0]
	self.vin = deser_vector(f, CTxIn)
	self.vout = deser_vector(f, CTxOut)
	self.nLockTime = struct.unpack("<I", f.read(4))[0]
	self.sha256 = None
	self.hash = None

	def billable_size(self):
	"""
	Returns the size used for billing the against the transaction
	"""
	return len(self.serialize())

	def serialize(self):
	r = b""
	r += struct.pack("<i", self.nVersion)
	r += ser_vector(self.vin)
	r += ser_vector(self.vout)
	r += struct.pack("<I", self.nLockTime)
	return r

	# Recalculate the txid
	def rehash(self):
	self.sha256 = None
	self.calc_sha256()
	return self.hash

	# self.sha256 and self.hash -- those are expected to be the txid.
	def calc_sha256(self):
	if self.sha256 is None:
	self.sha256 = uint256_from_str(hash256(self.serialize()))
	self.hash = encode(
	hash256(self.serialize())[::-1], 'hex_codec').decode('ascii')

	def get_id(self):
	# For now, just forward the hash.
	self.calc_sha256()
	return self.hash

	def is_valid(self):
	self.calc_sha256()
	for tout in self.vout:
	if tout.nValue < 0 or tout.nValue > 21000000 * COIN:
	return False
	return True

	def __repr__(self):
	return "CTransaction(nVersion={} vin={} vout={} nLockTime={})".format(
	self.nVersion, repr(self.vin), repr(self.vout), self.nLockTime)


	class CBlockHeader:
	__slots__ = ("hash", "hashMerkleRoot", "hashPrevBlock", "nBits", "nNonce",
	"nTime", "nVersion", "sha256")

	def __init__(self, header=None):
	if header is None:
	self.set_null()
	else:
	self.nVersion = header.nVersion
	self.hashPrevBlock = header.hashPrevBlock
	self.hashMerkleRoot = header.hashMerkleRoot
	self.nTime = header.nTime
	self.nBits = header.nBits
	self.nNonce = header.nNonce
	self.sha256 = header.sha256
	self.hash = header.hash
	self.calc_sha256()

	def set_null(self):
	self.nVersion = 1
	self.hashPrevBlock = 0
	self.hashMerkleRoot = 0
	self.nTime = 0
	self.nBits = 0
	self.nNonce = 0
	self.sha256 = None
	self.hash = None

	def deserialize(self, f):
	self.nVersion = struct.unpack("<i", f.read(4))[0]
	self.hashPrevBlock = deser_uint256(f)
	self.hashMerkleRoot = deser_uint256(f)
	self.nTime = struct.unpack("<I", f.read(4))[0]
	self.nBits = struct.unpack("<I", f.read(4))[0]
	self.nNonce = struct.unpack("<I", f.read(4))[0]
	self.sha256 = None
	self.hash = None

	def serialize(self):
	r = b""
	r += struct.pack("<i", self.nVersion)
	r += ser_uint256(self.hashPrevBlock)
	r += ser_uint256(self.hashMerkleRoot)
	r += struct.pack("<I", self.nTime)
	r += struct.pack("<I", self.nBits)
	r += struct.pack("<I", self.nNonce)
	return r

	def calc_sha256(self):
	if self.sha256 is None:
	r = b""
	r += struct.pack("<i", self.nVersion)
	r += ser_uint256(self.hashPrevBlock)
	r += ser_uint256(self.hashMerkleRoot)
	r += struct.pack("<I", self.nTime)
	r += struct.pack("<I", self.nBits)
	r += struct.pack("<I", self.nNonce)
	self.sha256 = uint256_from_str(hash256(r))
	self.hash = encode(hash256(r)[::-1], 'hex_codec').decode('ascii')

	def rehash(self):
	self.sha256 = None
	self.calc_sha256()
	return self.sha256

	def __repr__(self):
	return "CBlockHeader(nVersion={} hashPrevBlock={:064x} hashMerkleRoot={:064x} nTime={} nBits={:08x} nNonce={:08x})".format(
	self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
	self.nTime, self.nBits, self.nNonce)


	BLOCK_HEADER_SIZE = len(CBlockHeader().serialize())
	assert_equal(BLOCK_HEADER_SIZE, 80)


	class CBlock(CBlockHeader):
	__slots__ = ("vtx",)

	def __init__(self, header=None):
	super(CBlock, self).__init__(header)
	self.vtx = []

	def deserialize(self, f):
	super(CBlock, self).deserialize(f)
	self.vtx = deser_vector(f, CTransaction)

	def serialize(self):
	r = b""
	r += super(CBlock, self).serialize()
	r += ser_vector(self.vtx)
	return r

	# Calculate the merkle root given a vector of transaction hashes
	def get_merkle_root(self, hashes):
	while len(hashes) > 1:
	newhashes = []
	for i in range(0, len(hashes), 2):
	i2 = min(i + 1, len(hashes) - 1)
	newhashes.append(hash256(hashes[i] + hashes[i2]))
	hashes = newhashes
	return uint256_from_str(hashes[0])

	def calc_merkle_root(self):
	hashes = []
	for tx in self.vtx:
	tx.calc_sha256()
	hashes.append(ser_uint256(tx.sha256))
	return self.get_merkle_root(hashes)

	def is_valid(self):
	self.calc_sha256()
	target = uint256_from_compact(self.nBits)
	if self.sha256 > target:
	return False
	for tx in self.vtx:
	if not tx.is_valid():
	return False
	if self.calc_merkle_root() != self.hashMerkleRoot:
	return False
	return True

	def solve(self):
	self.rehash()
	target = uint256_from_compact(self.nBits)
	while self.sha256 > target:
	self.nNonce += 1
	self.rehash()

	def __repr__(self):
	return "CBlock(nVersion={} hashPrevBlock={:064x} hashMerkleRoot={:064x} nTime={} nBits={:08x} nNonce={:08x} vtx={})".format(
	self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
	self.nTime, self.nBits, self.nNonce, repr(self.vtx))


	class PrefilledTransaction:
	__slots__ = ("index", "tx")

	def __init__(self, index=0, tx=None):
	self.index = index
	self.tx = tx

	def deserialize(self, f):
	self.index = deser_compact_size(f)
	self.tx = CTransaction()
	self.tx.deserialize(f)

	def serialize(self):
	r = b""
	r += ser_compact_size(self.index)
	r += self.tx.serialize()
	return r

	def __repr__(self):
	return "PrefilledTransaction(index={}, tx={})".format(
	self.index, repr(self.tx))


	# This is what we send on the wire, in a cmpctblock message.
	class P2PHeaderAndShortIDs:
	__slots__ = ("header", "nonce", "prefilled_txn", "prefilled_txn_length",
	"shortids", "shortids_length")

	def __init__(self):
	self.header = CBlockHeader()
	self.nonce = 0
	self.shortids_length = 0
	self.shortids = []
	self.prefilled_txn_length = 0
	self.prefilled_txn = []

	def deserialize(self, f):
	self.header.deserialize(f)
	self.nonce = struct.unpack("<Q", f.read(8))[0]
	self.shortids_length = deser_compact_size(f)
	for i in range(self.shortids_length):
	# shortids are defined to be 6 bytes in the spec, so append
	# two zero bytes and read it in as an 8-byte number
	self.shortids.append(
	struct.unpack("<Q", f.read(6) + b'\x00\x00')[0])
	self.prefilled_txn = deser_vector(f, PrefilledTransaction)
	self.prefilled_txn_length = len(self.prefilled_txn)

	def serialize(self):
	r = b""
	r += self.header.serialize()
	r += struct.pack("<Q", self.nonce)
	r += ser_compact_size(self.shortids_length)
	for x in self.shortids:
	# We only want the first 6 bytes
	r += struct.pack("<Q", x)[0:6]
	r += ser_vector(self.prefilled_txn)
	return r

	def __repr__(self):
	return "P2PHeaderAndShortIDs(header={}, nonce={}, shortids_length={}, shortids={}, prefilled_txn_length={}, prefilledtxn={}".format(
	repr(self.header), self.nonce, self.shortids_length,
	repr(self.shortids), self.prefilled_txn_length,
	repr(self.prefilled_txn))


	def calculate_shortid(k0, k1, tx_hash):
	"""Calculate the BIP 152-compact blocks shortid for a given
	transaction hash"""
	expected_shortid = siphash256(k0, k1, tx_hash)
	expected_shortid &= 0x0000ffffffffffff
	return expected_shortid


	# This version gets rid of the array lengths, and reinterprets the differential
	# encoding into indices that can be used for lookup.
	class HeaderAndShortIDs:
	__slots__ = ("header", "nonce", "prefilled_txn", "shortids")

	def __init__(self, p2pheaders_and_shortids=None):
	self.header = CBlockHeader()
	self.nonce = 0
	self.shortids = []
	self.prefilled_txn = []

	if p2pheaders_and_shortids is not None:
	self.header = p2pheaders_and_shortids.header
	self.nonce = p2pheaders_and_shortids.nonce
	self.shortids = p2pheaders_and_shortids.shortids
	last_index = -1
	for x in p2pheaders_and_shortids.prefilled_txn:
	self.prefilled_txn.append(
	PrefilledTransaction(x.index + last_index + 1, x.tx))
	last_index = self.prefilled_txn[-1].index

	def to_p2p(self):
	ret = P2PHeaderAndShortIDs()
	ret.header = self.header
	ret.nonce = self.nonce
	ret.shortids_length = len(self.shortids)
	ret.shortids = self.shortids
	ret.prefilled_txn_length = len(self.prefilled_txn)
	ret.prefilled_txn = []
	last_index = -1
	for x in self.prefilled_txn:
	ret.prefilled_txn.append(
	PrefilledTransaction(x.index - last_index - 1, x.tx))
	last_index = x.index
	return ret

	def get_siphash_keys(self):
	header_nonce = self.header.serialize()
	header_nonce += struct.pack("<Q", self.nonce)
	hash_header_nonce_as_str = sha256(header_nonce)
	key0 = struct.unpack("<Q", hash_header_nonce_as_str[0:8])[0]
	key1 = struct.unpack("<Q", hash_header_nonce_as_str[8:16])[0]
	return [key0, key1]

	# Version 2 compact blocks use wtxid in shortids (rather than txid)
	def initialize_from_block(self, block, nonce=0, prefill_list=None):
	if prefill_list is None:
	prefill_list = [0]
	self.header = CBlockHeader(block)
	self.nonce = nonce
	self.prefilled_txn = [PrefilledTransaction(i, block.vtx[i])
	for i in prefill_list]
	self.shortids = []
	[k0, k1] = self.get_siphash_keys()
	for i in range(len(block.vtx)):
	if i not in prefill_list:
	tx_hash = block.vtx[i].sha256
	self.shortids.append(calculate_shortid(k0, k1, tx_hash))

	def __repr__(self):
	return "HeaderAndShortIDs(header={}, nonce={}, shortids={}, prefilledtxn={}".format(
	repr(self.header), self.nonce, repr(self.shortids),
	repr(self.prefilled_txn))


	class BlockTransactionsRequest:
	__slots__ = ("blockhash", "indexes")

	def __init__(self, blockhash=0, indexes=None):
	self.blockhash = blockhash
	self.indexes = indexes if indexes is not None else []

	def deserialize(self, f):
	self.blockhash = deser_uint256(f)
	indexes_length = deser_compact_size(f)
	for i in range(indexes_length):
	self.indexes.append(deser_compact_size(f))

	def serialize(self):
	r = b""
	r += ser_uint256(self.blockhash)
	r += ser_compact_size(len(self.indexes))
	for x in self.indexes:
	r += ser_compact_size(x)
	return r

	# helper to set the differentially encoded indexes from absolute ones
	def from_absolute(self, absolute_indexes):
	self.indexes = []
	last_index = -1
	for x in absolute_indexes:
	self.indexes.append(x - last_index - 1)
	last_index = x

	def to_absolute(self):
	absolute_indexes = []
	last_index = -1
	for x in self.indexes:
	absolute_indexes.append(x + last_index + 1)
	last_index = absolute_indexes[-1]
	return absolute_indexes

	def __repr__(self):
	return "BlockTransactionsRequest(hash={:064x} indexes={})".format(
	self.blockhash, repr(self.indexes))


	class BlockTransactions:
	__slots__ = ("blockhash", "transactions")

	def __init__(self, blockhash=0, transactions=None):
	self.blockhash = blockhash
	self.transactions = transactions if transactions is not None else []

	def deserialize(self, f):
	self.blockhash = deser_uint256(f)
	self.transactions = deser_vector(f, CTransaction)

	def serialize(self):
	r = b""
	r += ser_uint256(self.blockhash)
	r += ser_vector(self.transactions)
	return r

	def __repr__(self):
	return "BlockTransactions(hash={:064x} transactions={})".format(
	self.blockhash, repr(self.transactions))


	class AvalanchePoll():
	__slots__ = ("round", "invs")

	def __init__(self, round=0, invs=None):
	self.round = round
	self.invs = invs if invs is not None else []

	def deserialize(self, f):
	self.round = struct.unpack("<q", f.read(8))[0]
	self.invs = deser_vector(f, CInv)

	def serialize(self):
	r = b""
	r += struct.pack("<q", self.round)
	r += ser_vector(self.invs)
	return r

	def __repr__(self):
	return "AvalanchePoll(round={}, invs={})".format(
	self.round, repr(self.invs))


	class AvalancheVote():
	__slots__ = ("error", "hash")

	def __init__(self, e=0, h=0):
	self.error = e
	self.hash = h

	def deserialize(self, f):
	self.error = struct.unpack("<i", f.read(4))[0]
	self.hash = deser_uint256(f)

	def serialize(self):
	r = b""
	r += struct.pack("<i", self.error)
	r += ser_uint256(self.hash)
	return r

	def __repr__(self):
	return "AvalancheVote(error={}, hash={:064x})".format(
	self.error, self.hash)


	class AvalancheResponse():
	__slots__ = ("round", "cooldown", "votes")

	def __init__(self, round=0, cooldown=0, votes=None):
	self.round = round
	self.cooldown = cooldown
	self.votes = votes if votes is not None else []

	def deserialize(self, f):
	self.round = struct.unpack("<q", f.read(8))[0]
	self.cooldown = struct.unpack("<i", f.read(4))[0]
	self.votes = deser_vector(f, AvalancheVote)

	def serialize(self):
	r = b""
	r += struct.pack("<q", self.round)
	r += struct.pack("<i", self.cooldown)
	r += ser_vector(self.votes)
	return r

	def get_hash(self):
	return hash256(self.serialize())

	def __repr__(self):
	return "AvalancheResponse(round={}, cooldown={}, votes={})".format(
	self.round, self.cooldown, repr(self.votes))


	class TCPAvalancheResponse():
	__slots__ = ("response", "sig")

	def __init__(self, response=AvalancheResponse(), sig=b"\0" * 64):
	self.response = response
	self.sig = sig

	def deserialize(self, f):
	self.response.deserialize(f)
	self.sig = f.read(64)

	def serialize(self):
	r = b""
	r += self.response.serialize()
	r += self.sig
	return r

	def __repr__(self):
	return "TCPAvalancheResponse(response={}, sig={})".format(
	repr(self.response), self.sig)


	class CPartialMerkleTree:
	__slots__ = ("nTransactions", "vBits", "vHash")

	def __init__(self):
	self.nTransactions = 0
	self.vHash = []
	self.vBits = []

	def deserialize(self, f):
	self.nTransactions = struct.unpack("<i", f.read(4))[0]
	self.vHash = deser_uint256_vector(f)
	vBytes = deser_string(f)
	self.vBits = []
	for i in range(len(vBytes) * 8):
	self.vBits.append(vBytes[i // 8] & (1 << (i % 8)) != 0)

	def serialize(self):
	r = b""
	r += struct.pack("<i", self.nTransactions)
	r += ser_uint256_vector(self.vHash)
	vBytesArray = bytearray([0x00] * ((len(self.vBits) + 7) // 8))
	for i in range(len(self.vBits)):
	vBytesArray[i // 8] \|= self.vBits[i] << (i % 8)
	r += ser_string(bytes(vBytesArray))
	return r

	def __repr__(self):
	return "CPartialMerkleTree(nTransactions={}, vHash={}, vBits={})".format(
	self.nTransactions, repr(self.vHash), repr(self.vBits))


	class CMerkleBlock:
	__slots__ = ("header", "txn")

	def __init__(self):
	self.header = CBlockHeader()
	self.txn = CPartialMerkleTree()

	def deserialize(self, f):
	self.header.deserialize(f)
	self.txn.deserialize(f)

	def serialize(self):
	r = b""
	r += self.header.serialize()
	r += self.txn.serialize()
	return r

	def __repr__(self):
	return "CMerkleBlock(header={}, txn={})".format(
	repr(self.header), repr(self.txn))


	# Objects that correspond to messages on the wire

	class msg_version:
	__slots__ = ("addrFrom", "addrTo", "nNonce", "nRelay", "nServices",
	"nStartingHeight", "nTime", "nVersion", "strSubVer")
	- command = b"version"
	+ msgtype = b"version"

	def __init__(self):
	self.nVersion = MY_VERSION
	self.nServices = 1
	self.nTime = int(time.time())
	self.addrTo = CAddress()
	self.addrFrom = CAddress()
	self.nNonce = random.getrandbits(64)
	self.strSubVer = MY_SUBVERSION
	self.nStartingHeight = -1
	self.nRelay = MY_RELAY

	def deserialize(self, f):
	self.nVersion = struct.unpack("<i", f.read(4))[0]
	self.nServices = struct.unpack("<Q", f.read(8))[0]
	self.nTime = struct.unpack("<q", f.read(8))[0]
	self.addrTo = CAddress()
	self.addrTo.deserialize(f, False)

	self.addrFrom = CAddress()
	self.addrFrom.deserialize(f, False)
	self.nNonce = struct.unpack("<Q", f.read(8))[0]
	self.strSubVer = deser_string(f)

	self.nStartingHeight = struct.unpack("<i", f.read(4))[0]

	if self.nVersion >= 70001:
	# Relay field is optional for version 70001 onwards
	try:
	self.nRelay = struct.unpack("<b", f.read(1))[0]
	except Exception:
	self.nRelay = 0
	else:
	self.nRelay = 0

	def serialize(self):
	r = b""
	r += struct.pack("<i", self.nVersion)
	r += struct.pack("<Q", self.nServices)
	r += struct.pack("<q", self.nTime)
	r += self.addrTo.serialize(False)
	r += self.addrFrom.serialize(False)
	r += struct.pack("<Q", self.nNonce)
	r += ser_string(self.strSubVer)
	r += struct.pack("<i", self.nStartingHeight)
	r += struct.pack("<b", self.nRelay)
	return r

	def __repr__(self):
	return 'msg_version(nVersion={} nServices={} nTime={} addrTo={} addrFrom={} nNonce=0x{:016X} strSubVer={} nStartingHeight={} nRelay={})'.format(
	self.nVersion, self.nServices, self.nTime,
	repr(self.addrTo), repr(self.addrFrom), self.nNonce,
	self.strSubVer, self.nStartingHeight, self.nRelay)


	class msg_verack:
	__slots__ = ()
	- command = b"verack"
	+ msgtype = b"verack"

	def __init__(self):
	pass

	def deserialize(self, f):
	pass

	def serialize(self):
	return b""

	def __repr__(self):
	return "msg_verack()"


	class msg_addr:
	__slots__ = ("addrs",)
	- command = b"addr"
	+ msgtype = b"addr"

	def __init__(self):
	self.addrs = []

	def deserialize(self, f):
	self.addrs = deser_vector(f, CAddress)

	def serialize(self):
	return ser_vector(self.addrs)

	def __repr__(self):
	return "msg_addr(addrs={})".format(repr(self.addrs))


	class msg_inv:
	__slots__ = ("inv",)
	- command = b"inv"
	+ msgtype = b"inv"

	def __init__(self, inv=None):
	if inv is None:
	self.inv = []
	else:
	self.inv = inv

	def deserialize(self, f):
	self.inv = deser_vector(f, CInv)

	def serialize(self):
	return ser_vector(self.inv)

	def __repr__(self):
	return "msg_inv(inv={})".format(repr(self.inv))


	class msg_getdata:
	__slots__ = ("inv",)
	- command = b"getdata"
	+ msgtype = b"getdata"

	def __init__(self, inv=None):
	self.inv = inv if inv is not None else []

	def deserialize(self, f):
	self.inv = deser_vector(f, CInv)

	def serialize(self):
	return ser_vector(self.inv)

	def __repr__(self):
	return "msg_getdata(inv={})".format(repr(self.inv))


	class msg_getblocks:
	__slots__ = ("locator", "hashstop")
	- command = b"getblocks"
	+ msgtype = b"getblocks"

	def __init__(self):
	self.locator = CBlockLocator()
	self.hashstop = 0

	def deserialize(self, f):
	self.locator = CBlockLocator()
	self.locator.deserialize(f)
	self.hashstop = deser_uint256(f)

	def serialize(self):
	r = b""
	r += self.locator.serialize()
	r += ser_uint256(self.hashstop)
	return r

	def __repr__(self):
	return "msg_getblocks(locator={} hashstop={:064x})".format(
	repr(self.locator), self.hashstop)


	class msg_tx:
	__slots__ = ("tx",)
	- command = b"tx"
	+ msgtype = b"tx"

	def __init__(self, tx=CTransaction()):
	self.tx = tx

	def deserialize(self, f):
	self.tx.deserialize(f)

	def serialize(self):
	return self.tx.serialize()

	def __repr__(self):
	return "msg_tx(tx={})".format(repr(self.tx))


	class msg_block:
	__slots__ = ("block",)
	- command = b"block"
	+ msgtype = b"block"

	def __init__(self, block=None):
	if block is None:
	self.block = CBlock()
	else:
	self.block = block

	def deserialize(self, f):
	self.block.deserialize(f)

	def serialize(self):
	return self.block.serialize()

	def __repr__(self):
	return "msg_block(block={})".format(repr(self.block))


	# for cases where a user needs tighter control over what is sent over the wire
	-# note that the user must supply the name of the command, and the data
	+# note that the user must supply the name of the msgtype, and the data
	class msg_generic:
	- __slots__ = ("command", "data")
	+ __slots__ = ("msgtype", "data")

	- def __init__(self, command, data=None):
	- self.command = command
	+ def __init__(self, msgtype, data=None):
	+ self.msgtype = msgtype
	self.data = data

	def serialize(self):
	return self.data

	def __repr__(self):
	return "msg_generic()"


	class msg_getaddr:
	__slots__ = ()
	- command = b"getaddr"
	+ msgtype = b"getaddr"

	def __init__(self):
	pass

	def deserialize(self, f):
	pass

	def serialize(self):
	return b""

	def __repr__(self):
	return "msg_getaddr()"


	class msg_ping:
	__slots__ = ("nonce",)
	- command = b"ping"
	+ msgtype = b"ping"

	def __init__(self, nonce=0):
	self.nonce = nonce

	def deserialize(self, f):
	self.nonce = struct.unpack("<Q", f.read(8))[0]

	def serialize(self):
	r = b""
	r += struct.pack("<Q", self.nonce)
	return r

	def __repr__(self):
	return "msg_ping(nonce={:08x})".format(self.nonce)


	class msg_pong:
	__slots__ = ("nonce",)
	- command = b"pong"
	+ msgtype = b"pong"

	def __init__(self, nonce=0):
	self.nonce = nonce

	def deserialize(self, f):
	self.nonce = struct.unpack("<Q", f.read(8))[0]

	def serialize(self):
	r = b""
	r += struct.pack("<Q", self.nonce)
	return r

	def __repr__(self):
	return "msg_pong(nonce={:08x})".format(self.nonce)


	class msg_mempool:
	__slots__ = ()
	- command = b"mempool"
	+ msgtype = b"mempool"

	def __init__(self):
	pass

	def deserialize(self, f):
	pass

	def serialize(self):
	return b""

	def __repr__(self):
	return "msg_mempool()"


	class msg_notfound:
	__slots__ = ("vec", )
	- command = b"notfound"
	+ msgtype = b"notfound"

	def __init__(self, vec=None):
	self.vec = vec or []

	def deserialize(self, f):
	self.vec = deser_vector(f, CInv)

	def serialize(self):
	return ser_vector(self.vec)

	def __repr__(self):
	return "msg_notfound(vec={})".format(repr(self.vec))


	class msg_sendheaders:
	__slots__ = ()
	- command = b"sendheaders"
	+ msgtype = b"sendheaders"

	def __init__(self):
	pass

	def deserialize(self, f):
	pass

	def serialize(self):
	return b""

	def __repr__(self):
	return "msg_sendheaders()"


	# getheaders message has
	# number of entries
	# vector of hashes
	# hash_stop (hash of last desired block header, 0 to get as many as possible)
	class msg_getheaders:
	__slots__ = ("hashstop", "locator",)
	- command = b"getheaders"
	+ msgtype = b"getheaders"

	def __init__(self):
	self.locator = CBlockLocator()
	self.hashstop = 0

	def deserialize(self, f):
	self.locator = CBlockLocator()
	self.locator.deserialize(f)
	self.hashstop = deser_uint256(f)

	def serialize(self):
	r = b""
	r += self.locator.serialize()
	r += ser_uint256(self.hashstop)
	return r

	def __repr__(self):
	return "msg_getheaders(locator={}, stop={:064x})".format(
	repr(self.locator), self.hashstop)


	# headers message has
	# <count> <vector of block headers>
	class msg_headers:
	__slots__ = ("headers",)
	- command = b"headers"
	+ msgtype = b"headers"

	def __init__(self, headers=None):
	self.headers = headers if headers is not None else []

	def deserialize(self, f):
	# comment in bitcoind indicates these should be deserialized as blocks
	blocks = deser_vector(f, CBlock)
	for x in blocks:
	self.headers.append(CBlockHeader(x))

	def serialize(self):
	blocks = [CBlock(x) for x in self.headers]
	return ser_vector(blocks)

	def __repr__(self):
	return "msg_headers(headers={})".format(repr(self.headers))


	class msg_merkleblock:
	__slots__ = ("merkleblock",)
	- command = b"merkleblock"
	+ msgtype = b"merkleblock"

	def __init__(self, merkleblock=None):
	if merkleblock is None:
	self.merkleblock = CMerkleBlock()
	else:
	self.merkleblock = merkleblock

	def deserialize(self, f):
	self.merkleblock.deserialize(f)

	def serialize(self):
	return self.merkleblock.serialize()

	def __repr__(self):
	return "msg_merkleblock(merkleblock={})".format(repr(self.merkleblock))


	class msg_filterload:
	__slots__ = ("data", "nHashFuncs", "nTweak", "nFlags")
	- command = b"filterload"
	+ msgtype = b"filterload"

	def __init__(self, data=b'00', nHashFuncs=0, nTweak=0, nFlags=0):
	self.data = data
	self.nHashFuncs = nHashFuncs
	self.nTweak = nTweak
	self.nFlags = nFlags

	def deserialize(self, f):
	self.data = deser_string(f)
	self.nHashFuncs = struct.unpack("<I", f.read(4))[0]
	self.nTweak = struct.unpack("<I", f.read(4))[0]
	self.nFlags = struct.unpack("<B", f.read(1))[0]

	def serialize(self):
	r = b""
	r += ser_string(self.data)
	r += struct.pack("<I", self.nHashFuncs)
	r += struct.pack("<I", self.nTweak)
	r += struct.pack("<B", self.nFlags)
	return r

	def __repr__(self):
	return "msg_filterload(data={}, nHashFuncs={}, nTweak={}, nFlags={})".format(
	self.data, self.nHashFuncs, self.nTweak, self.nFlags)


	class msg_filteradd:
	__slots__ = ("data")
	- command = b"filteradd"
	+ msgtype = b"filteradd"

	def __init__(self, data):
	self.data = data

	def deserialize(self, f):
	self.data = deser_string(f)

	def serialize(self):
	r = b""
	r += ser_string(self.data)
	return r

	def __repr__(self):
	return "msg_filteradd(data={})".format(self.data)


	class msg_filterclear:
	__slots__ = ()
	- command = b"filterclear"
	+ msgtype = b"filterclear"

	def __init__(self):
	pass

	def deserialize(self, f):
	pass

	def serialize(self):
	return b""

	def __repr__(self):
	return "msg_filterclear()"


	class msg_feefilter:
	__slots__ = ("feerate",)
	- command = b"feefilter"
	+ msgtype = b"feefilter"

	def __init__(self, feerate=0):
	self.feerate = feerate

	def deserialize(self, f):
	self.feerate = struct.unpack("<Q", f.read(8))[0]

	def serialize(self):
	r = b""
	r += struct.pack("<Q", self.feerate)
	return r

	def __repr__(self):
	return "msg_feefilter(feerate={:08x})".format(self.feerate)


	class msg_sendcmpct:
	__slots__ = ("announce", "version")
	- command = b"sendcmpct"
	+ msgtype = b"sendcmpct"

	def __init__(self):
	self.announce = False
	self.version = 1

	def deserialize(self, f):
	self.announce = struct.unpack("<?", f.read(1))[0]
	self.version = struct.unpack("<Q", f.read(8))[0]

	def serialize(self):
	r = b""
	r += struct.pack("<?", self.announce)
	r += struct.pack("<Q", self.version)
	return r

	def __repr__(self):
	return "msg_sendcmpct(announce={}, version={})".format(
	self.announce, self.version)


	class msg_cmpctblock:
	__slots__ = ("header_and_shortids",)
	- command = b"cmpctblock"
	+ msgtype = b"cmpctblock"

	def __init__(self, header_and_shortids=None):
	self.header_and_shortids = header_and_shortids

	def deserialize(self, f):
	self.header_and_shortids = P2PHeaderAndShortIDs()
	self.header_and_shortids.deserialize(f)

	def serialize(self):
	r = b""
	r += self.header_and_shortids.serialize()
	return r

	def __repr__(self):
	return "msg_cmpctblock(HeaderAndShortIDs={})".format(
	repr(self.header_and_shortids))


	class msg_getblocktxn:
	__slots__ = ("block_txn_request",)
	- command = b"getblocktxn"
	+ msgtype = b"getblocktxn"

	def __init__(self):
	self.block_txn_request = None

	def deserialize(self, f):
	self.block_txn_request = BlockTransactionsRequest()
	self.block_txn_request.deserialize(f)

	def serialize(self):
	r = b""
	r += self.block_txn_request.serialize()
	return r

	def __repr__(self):
	return "msg_getblocktxn(block_txn_request={})".format(
	repr(self.block_txn_request))


	class msg_blocktxn:
	__slots__ = ("block_transactions",)
	- command = b"blocktxn"
	+ msgtype = b"blocktxn"

	def __init__(self):
	self.block_transactions = BlockTransactions()

	def deserialize(self, f):
	self.block_transactions.deserialize(f)

	def serialize(self):
	r = b""
	r += self.block_transactions.serialize()
	return r

	def __repr__(self):
	return "msg_blocktxn(block_transactions={})".format(
	repr(self.block_transactions))


	class msg_avapoll():
	__slots__ = ("poll",)
	- command = b"avapoll"
	+ msgtype = b"avapoll"

	def __init__(self):
	self.poll = AvalanchePoll()

	def deserialize(self, f):
	self.poll.deserialize(f)

	def serialize(self):
	r = b""
	r += self.poll.serialize()
	return r

	def __repr__(self):
	return "msg_avapoll(poll={})".format(repr(self.poll))


	class msg_avaresponse():
	__slots__ = ("response",)
	- command = b"avaresponse"
	+ msgtype = b"avaresponse"

	def __init__(self):
	self.response = AvalancheResponse()

	def deserialize(self, f):
	self.response.deserialize(f)

	def serialize(self):
	r = b""
	r += self.response.serialize()
	return r

	def __repr__(self):
	return "msg_avaresponse(response={})".format(repr(self.response))


	class msg_tcpavaresponse():
	__slots__ = ("response",)
	- command = b"avaresponse"
	+ msgtype = b"avaresponse"

	def __init__(self):
	self.response = TCPAvalancheResponse()

	def deserialize(self, f):
	self.response.deserialize(f)

	def serialize(self):
	r = b""
	r += self.response.serialize()
	return r

	def __repr__(self):
	return "msg_tcpavaresponse(response={})".format(repr(self.response))
	diff --git a/test/functional/test_framework/mininode.py b/test/functional/test_framework/mininode.py
	index 0a087e6d0..2db7b2bce 100755
	--- a/test/functional/test_framework/mininode.py
	+++ b/test/functional/test_framework/mininode.py
	@@ -1,723 +1,723 @@
	#!/usr/bin/env python3
	# Copyright (c) 2010 ArtForz -- public domain half-a-node
	# Copyright (c) 2012 Jeff Garzik
	# Copyright (c) 2010-2019 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.
	"""Bitcoin P2P network half-a-node.

	This python code was modified from ArtForz' public domain half-a-node, as
	found in the mini-node branch of http://github.com/jgarzik/pynode.

	P2PConnection: A low-level connection object to a node's P2P interface
	P2PInterface: A high-level interface object for communicating to a node over P2P
	P2PDataStore: A p2p interface class that keeps a store of transactions and blocks
	and can respond correctly to getdata and getheaders messages"""
	import asyncio
	from collections import defaultdict
	from io import BytesIO
	import logging
	import struct
	import sys
	import threading

	from test_framework.messages import (
	CBlockHeader,
	MIN_VERSION_SUPPORTED,
	msg_addr,
	msg_avapoll,
	msg_tcpavaresponse,
	msg_block,
	MSG_BLOCK,
	msg_blocktxn,
	msg_cmpctblock,
	msg_feefilter,
	msg_filteradd,
	msg_filterclear,
	msg_filterload,
	msg_getaddr,
	msg_getblocks,
	msg_getblocktxn,
	msg_getdata,
	msg_getheaders,
	msg_headers,
	msg_inv,
	msg_mempool,
	msg_merkleblock,
	msg_notfound,
	msg_ping,
	msg_pong,
	msg_sendcmpct,
	msg_sendheaders,
	msg_tx,
	MSG_TX,
	MSG_TYPE_MASK,
	msg_verack,
	msg_version,
	NODE_NETWORK,
	sha256,
	)
	from test_framework.util import wait_until

	logger = logging.getLogger("TestFramework.mininode")

	MESSAGEMAP = {
	b"addr": msg_addr,
	b"avapoll": msg_avapoll,
	b"avaresponse": msg_tcpavaresponse,
	b"block": msg_block,
	b"blocktxn": msg_blocktxn,
	b"cmpctblock": msg_cmpctblock,
	b"feefilter": msg_feefilter,
	b"filteradd": msg_filteradd,
	b"filterclear": msg_filterclear,
	b"filterload": msg_filterload,
	b"getaddr": msg_getaddr,
	b"getblocks": msg_getblocks,
	b"getblocktxn": msg_getblocktxn,
	b"getdata": msg_getdata,
	b"getheaders": msg_getheaders,
	b"headers": msg_headers,
	b"inv": msg_inv,
	b"mempool": msg_mempool,
	b"merkleblock": msg_merkleblock,
	b"notfound": msg_notfound,
	b"ping": msg_ping,
	b"pong": msg_pong,
	b"sendcmpct": msg_sendcmpct,
	b"sendheaders": msg_sendheaders,
	b"tx": msg_tx,
	b"verack": msg_verack,
	b"version": msg_version,
	}

	MAGIC_BYTES = {
	"mainnet": b"\xe3\xe1\xf3\xe8",
	"testnet3": b"\xf4\xe5\xf3\xf4",
	"regtest": b"\xda\xb5\xbf\xfa",
	}


	class P2PConnection(asyncio.Protocol):
	"""A low-level connection object to a node's P2P interface.

	This class is responsible for:

	- opening and closing the TCP connection to the node
	- reading bytes from and writing bytes to the socket
	- deserializing and serializing the P2P message header
	- logging messages as they are sent and received

	This class contains no logic for handing the P2P message payloads. It must be
	sub-classed and the on_message() callback overridden."""

	def __init__(self):
	# The underlying transport of the connection.
	# Should only call methods on this from the NetworkThread, c.f.
	# call_soon_threadsafe
	self._transport = None

	@property
	def is_connected(self):
	return self._transport is not None

	def peer_connect(self, dstaddr, dstport, *, net):
	assert not self.is_connected
	self.dstaddr = dstaddr
	self.dstport = dstport
	# The initial message to send after the connection was made:
	self.on_connection_send_msg = None
	self.on_connection_send_msg_is_raw = False
	self.recvbuf = b""
	self.magic_bytes = MAGIC_BYTES[net]
	logger.debug('Connecting to Bitcoin Node: {}:{}'.format(
	self.dstaddr, self.dstport))

	loop = NetworkThread.network_event_loop
	conn_gen_unsafe = loop.create_connection(
	lambda: self, host=self.dstaddr, port=self.dstport)

	def conn_gen(): return loop.call_soon_threadsafe(
	loop.create_task, conn_gen_unsafe)
	return conn_gen

	def peer_disconnect(self):
	# Connection could have already been closed by other end.
	NetworkThread.network_event_loop.call_soon_threadsafe(
	lambda: self._transport and self._transport.abort())

	# Connection and disconnection methods

	def connection_made(self, transport):
	"""asyncio callback when a connection is opened."""
	assert not self._transport
	logger.debug("Connected & Listening: {}:{}".format(
	self.dstaddr, self.dstport))
	self._transport = transport
	if self.on_connection_send_msg:
	if self.on_connection_send_msg_is_raw:
	self.send_raw_message(self.on_connection_send_msg)
	else:
	self.send_message(self.on_connection_send_msg)
	# Never used again
	self.on_connection_send_msg = None
	self.on_open()

	def connection_lost(self, exc):
	"""asyncio callback when a connection is closed."""
	if exc:
	logger.warning("Connection lost to {}:{} due to {}".format(
	self.dstaddr, self.dstport, exc))
	else:
	logger.debug("Closed connection to: {}:{}".format(
	self.dstaddr, self.dstport))
	self._transport = None
	self.recvbuf = b""
	self.on_close()

	# Socket read methods

	def data_received(self, t):
	"""asyncio callback when data is read from the socket."""
	with mininode_lock:
	if len(t) > 0:
	self.recvbuf += t

	while True:
	msg = self._on_data()
	if msg is None:
	break
	self.on_message(msg)

	def _on_data(self):
	"""Try to read P2P messages from the recv buffer.

	This method reads data from the buffer in a loop. It deserializes,
	parses and verifies the P2P header, then passes the P2P payload to
	the on_message callback for processing."""
	try:
	with mininode_lock:
	if len(self.recvbuf) < 4:
	return None
	if self.recvbuf[:4] != self.magic_bytes:
	raise ValueError(
	"magic bytes mismatch: {} != {}".format(
	repr(
	self.magic_bytes), repr(
	self.recvbuf)))
	if len(self.recvbuf) < 4 + 12 + 4 + 4:
	return None
	- command = self.recvbuf[4:4 + 12].split(b"\x00", 1)[0]
	+ msgtype = self.recvbuf[4:4 + 12].split(b"\x00", 1)[0]
	msglen = struct.unpack(
	"<i", self.recvbuf[4 + 12:4 + 12 + 4])[0]
	checksum = self.recvbuf[4 + 12 + 4:4 + 12 + 4 + 4]
	if len(self.recvbuf) < 4 + 12 + 4 + 4 + msglen:
	return None
	msg = self.recvbuf[4 + 12 + 4 + 4:4 + 12 + 4 + 4 + msglen]
	h = sha256(sha256(msg))
	if checksum != h[:4]:
	raise ValueError("got bad checksum " + repr(self.recvbuf))
	self.recvbuf = self.recvbuf[4 + 12 + 4 + 4 + msglen:]
	- if command not in MESSAGEMAP:
	- raise ValueError("Received unknown command from {}:{}: '{}' {}".format(
	- self.dstaddr, self.dstport, command, repr(msg)))
	+ if msgtype not in MESSAGEMAP:
	+ raise ValueError("Received unknown msgtype from {}:{}: '{}' {}".format(
	+ self.dstaddr, self.dstport, msgtype, repr(msg)))
	f = BytesIO(msg)
	- m = MESSAGEMAP[command]()
	+ m = MESSAGEMAP[msgtype]()
	m.deserialize(f)
	self._log_message("receive", m)
	return m
	except Exception as e:
	logger.exception('Error reading message:', repr(e))
	raise

	def on_message(self, message):
	"""Callback for processing a P2P payload. Must be overridden by derived class."""
	raise NotImplementedError

	# Socket write methods

	def send_message(self, message):
	"""Send a P2P message over the socket.

	This method takes a P2P payload, builds the P2P header and adds
	the message to the send buffer to be sent over the socket."""
	if not self.is_connected:
	raise IOError('Not connected')
	tmsg = self.build_message(message)
	self._log_message("send", message)
	return self.send_raw_message(tmsg)

	def send_raw_message(self, raw_message_bytes):
	"""Send any raw message over the socket.

	This method adds a raw message to the send buffer to be sent over the
	socket."""
	if not self.is_connected:
	raise IOError('Not connected')

	def maybe_write():
	if not self._transport:
	return
	if self._transport.is_closing():
	return
	self._transport.write(raw_message_bytes)
	NetworkThread.network_event_loop.call_soon_threadsafe(maybe_write)

	# Class utility methods

	def build_message(self, message):
	"""Build a serialized P2P message"""
	- command = message.command
	+ msgtype = message.msgtype
	data = message.serialize()
	tmsg = self.magic_bytes
	- tmsg += command
	- tmsg += b"\x00" * (12 - len(command))
	+ tmsg += msgtype
	+ tmsg += b"\x00" * (12 - len(msgtype))
	tmsg += struct.pack("<I", len(data))
	th = sha256(data)
	h = sha256(th)
	tmsg += h[:4]
	tmsg += data
	return tmsg

	def _log_message(self, direction, msg):
	"""Logs a message being sent or received over the connection."""
	if direction == "send":
	log_message = "Send message to "
	elif direction == "receive":
	log_message = "Received message from "
	log_message += "{}:{}: {}".format(
	self.dstaddr, self.dstport, repr(msg)[:500])
	if len(log_message) > 500:
	log_message += "... (msg truncated)"
	logger.debug(log_message)


	class P2PInterface(P2PConnection):
	"""A high-level P2P interface class for communicating with a Bitcoin Cash node.

	This class provides high-level callbacks for processing P2P message
	payloads, as well as convenience methods for interacting with the
	node over P2P.

	Individual testcases should subclass this and override the on_* methods
	if they want to alter message handling behaviour."""

	def __init__(self):
	super().__init__()

	# Track number of messages of each type received and the most recent
	# message of each type
	self.message_count = defaultdict(int)
	self.last_message = {}

	# A count of the number of ping messages we've sent to the node
	self.ping_counter = 1

	# The network services received from the peer
	self.nServices = 0

	def peer_connect(self, *args, services=NODE_NETWORK,
	send_version=True, **kwargs):
	create_conn = super().peer_connect(args, *kwargs)

	if send_version:
	# Send a version msg
	vt = msg_version()
	vt.nServices = services
	vt.addrTo.ip = self.dstaddr
	vt.addrTo.port = self.dstport
	vt.addrFrom.ip = "0.0.0.0"
	vt.addrFrom.port = 0
	# Will be sent soon after connection_made
	self.on_connection_send_msg = vt

	return create_conn

	# Message receiving methods

	def on_message(self, message):
	"""Receive message and dispatch message to appropriate callback.

	We keep a count of how many of each message type has been received
	and the most recent message of each type."""
	with mininode_lock:
	try:
	- command = message.command.decode('ascii')
	- self.message_count[command] += 1
	- self.last_message[command] = message
	- getattr(self, 'on_' + command)(message)
	+ msgtype = message.msgtype.decode('ascii')
	+ self.message_count[msgtype] += 1
	+ self.last_message[msgtype] = message
	+ getattr(self, 'on_' + msgtype)(message)
	except Exception:
	print("ERROR delivering {} ({})".format(
	repr(message), sys.exc_info()[0]))
	raise

	# Callback methods. Can be overridden by subclasses in individual test
	# cases to provide custom message handling behaviour.

	def on_open(self):
	pass

	def on_close(self):
	pass

	def on_addr(self, message): pass

	def on_avapoll(self, message): pass

	def on_avaresponse(self, message): pass

	def on_block(self, message): pass

	def on_blocktxn(self, message): pass

	def on_cmpctblock(self, message): pass

	def on_feefilter(self, message): pass

	def on_filteradd(self, message): pass

	def on_filterclear(self, message): pass

	def on_filterload(self, message): pass

	def on_getaddr(self, message): pass

	def on_getblocks(self, message): pass

	def on_getblocktxn(self, message): pass

	def on_getdata(self, message): pass

	def on_getheaders(self, message): pass

	def on_headers(self, message): pass

	def on_mempool(self, message): pass

	def on_merkleblock(self, message): pass

	def on_notfound(self, message): pass

	def on_pong(self, message): pass

	def on_reject(self, message): pass

	def on_sendcmpct(self, message): pass

	def on_sendheaders(self, message): pass

	def on_tx(self, message): pass

	def on_inv(self, message):
	want = msg_getdata()
	for i in message.inv:
	if i.type != 0:
	want.inv.append(i)
	if len(want.inv):
	self.send_message(want)

	def on_ping(self, message):
	self.send_message(msg_pong(message.nonce))

	def on_verack(self, message):
	pass

	def on_version(self, message):
	assert message.nVersion >= MIN_VERSION_SUPPORTED, "Version {} received. Test framework only supports versions greater than {}".format(
	message.nVersion, MIN_VERSION_SUPPORTED)
	self.send_message(msg_verack())
	self.nServices = message.nServices

	# Connection helper methods

	def wait_for_disconnect(self, timeout=60):
	def test_function(): return not self.is_connected
	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	# Message receiving helper methods

	def wait_for_tx(self, txid, timeout=60):
	def test_function():
	assert self.is_connected
	if not self.last_message.get('tx'):
	return False
	return self.last_message['tx'].tx.rehash() == txid

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	def wait_for_block(self, blockhash, timeout=60):
	def test_function():
	assert self.is_connected
	return self.last_message.get(
	"block") and self.last_message["block"].block.rehash() == blockhash

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	def wait_for_header(self, blockhash, timeout=60):
	def test_function():
	assert self.is_connected
	last_headers = self.last_message.get('headers')
	if not last_headers:
	return False
	return last_headers.headers[0].rehash() == int(blockhash, 16)

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	def wait_for_merkleblock(self, blockhash, timeout=60):
	def test_function():
	assert self.is_connected
	last_filtered_block = self.last_message.get('merkleblock')
	if not last_filtered_block:
	return False
	return last_filtered_block.merkleblock.header.rehash() == int(blockhash, 16)

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	def wait_for_getdata(self, timeout=60):
	"""Waits for a getdata message.

	Receiving any getdata message will satisfy the predicate. the last_message["getdata"]
	value must be explicitly cleared before calling this method, or this will return
	immediately with success. TODO: change this method to take a hash value and only
	return true if the correct block/tx has been requested."""

	def test_function():
	assert self.is_connected
	return self.last_message.get("getdata")

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	def wait_for_getheaders(self, timeout=60):
	"""Waits for a getheaders message.

	Receiving any getheaders message will satisfy the predicate. the last_message["getheaders"]
	value must be explicitly cleared before calling this method, or this will return
	immediately with success. TODO: change this method to take a hash value and only
	return true if the correct block header has been requested."""

	def test_function():
	assert self.is_connected
	return self.last_message.get("getheaders")

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	def wait_for_inv(self, expected_inv, timeout=60):
	"""Waits for an INV message and checks that the first inv object in the message was as expected."""
	if len(expected_inv) > 1:
	raise NotImplementedError(
	"wait_for_inv() will only verify the first inv object")

	def test_function():
	assert self.is_connected
	return self.last_message.get("inv") and \
	self.last_message["inv"].inv[0].type == expected_inv[0].type and \
	self.last_message["inv"].inv[0].hash == expected_inv[0].hash

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	def wait_for_verack(self, timeout=60):
	def test_function():
	return self.message_count["verack"]

	wait_until(test_function, timeout=timeout, lock=mininode_lock)

	# Message sending helper functions

	def send_and_ping(self, message, timeout=60):
	self.send_message(message)
	self.sync_with_ping(timeout=timeout)

	# Sync up with the node
	def sync_with_ping(self, timeout=60):
	self.send_message(msg_ping(nonce=self.ping_counter))

	def test_function():
	assert self.is_connected
	return self.last_message.get(
	"pong") and self.last_message["pong"].nonce == self.ping_counter

	wait_until(test_function, timeout=timeout, lock=mininode_lock)
	self.ping_counter += 1


	# One lock for synchronizing all data access between the networking thread (see
	# NetworkThread below) and the thread running the test logic. For simplicity,
	# P2PConnection acquires this lock whenever delivering a message to a P2PInterface.
	# This lock should be acquired in the thread running the test logic to synchronize
	# access to any data shared with the P2PInterface or P2PConnection.
	mininode_lock = threading.RLock()


	class NetworkThread(threading.Thread):
	network_event_loop = None

	def __init__(self):
	super().__init__(name="NetworkThread")
	# There is only one event loop and no more than one thread must be
	# created
	assert not self.network_event_loop

	NetworkThread.network_event_loop = asyncio.new_event_loop()

	def run(self):
	"""Start the network thread."""
	self.network_event_loop.run_forever()

	def close(self, timeout=10):
	"""Close the connections and network event loop."""
	self.network_event_loop.call_soon_threadsafe(
	self.network_event_loop.stop)
	wait_until(lambda: not self.network_event_loop.is_running(),
	timeout=timeout)
	self.network_event_loop.close()
	self.join(timeout)
	# Safe to remove event loop.
	NetworkThread.network_event_loop = None


	class P2PDataStore(P2PInterface):
	"""A P2P data store class.

	Keeps a block and transaction store and responds correctly to getdata and getheaders requests."""

	def __init__(self):
	super().__init__()
	# store of blocks. key is block hash, value is a CBlock object
	self.block_store = {}
	self.last_block_hash = ''
	# store of txs. key is txid, value is a CTransaction object
	self.tx_store = {}
	self.getdata_requests = []

	def on_getdata(self, message):
	"""Check for the tx/block in our stores and if found, reply with an inv message."""
	for inv in message.inv:
	self.getdata_requests.append(inv.hash)
	if (inv.type & MSG_TYPE_MASK) == MSG_TX and inv.hash in self.tx_store.keys():
	self.send_message(msg_tx(self.tx_store[inv.hash]))
	elif (inv.type & MSG_TYPE_MASK) == MSG_BLOCK and inv.hash in self.block_store.keys():
	self.send_message(msg_block(self.block_store[inv.hash]))
	else:
	logger.debug(
	'getdata message type {} received.'.format(hex(inv.type)))

	def on_getheaders(self, message):
	"""Search back through our block store for the locator, and reply with a headers message if found."""

	locator, hash_stop = message.locator, message.hashstop

	# Assume that the most recent block added is the tip
	if not self.block_store:
	return

	headers_list = [self.block_store[self.last_block_hash]]
	maxheaders = 2000
	while headers_list[-1].sha256 not in locator.vHave:
	# Walk back through the block store, adding headers to headers_list
	# as we go.
	prev_block_hash = headers_list[-1].hashPrevBlock
	if prev_block_hash in self.block_store:
	prev_block_header = CBlockHeader(
	self.block_store[prev_block_hash])
	headers_list.append(prev_block_header)
	if prev_block_header.sha256 == hash_stop:
	# if this is the hashstop header, stop here
	break
	else:
	logger.debug('block hash {} not found in block store'.format(
	hex(prev_block_hash)))
	break

	# Truncate the list if there are too many headers
	headers_list = headers_list[:-maxheaders - 1:-1]
	response = msg_headers(headers_list)

	if response is not None:
	self.send_message(response)

	def send_blocks_and_test(self, blocks, node, *, success=True, force_send=False,
	reject_reason=None, expect_disconnect=False, timeout=60):
	"""Send blocks to test node and test whether the tip advances.

	- add all blocks to our block_store
	- send a headers message for the final block
	- the on_getheaders handler will ensure that any getheaders are responded to
	- if force_send is False: wait for getdata for each of the blocks. The on_getdata handler will
	ensure that any getdata messages are responded to. Otherwise send the full block unsolicited.
	- if success is True: assert that the node's tip advances to the most recent block
	- if success is False: assert that the node's tip doesn't advance
	- if reject_reason is set: assert that the correct reject message is logged"""

	with mininode_lock:
	for block in blocks:
	self.block_store[block.sha256] = block
	self.last_block_hash = block.sha256

	def test():
	if force_send:
	for b in blocks:
	self.send_message(msg_block(block=b))

	else:
	self.send_message(
	msg_headers([CBlockHeader(block) for block in blocks]))
	wait_until(
	lambda: blocks[-1].sha256 in self.getdata_requests, timeout=timeout, lock=mininode_lock)

	if expect_disconnect:
	self.wait_for_disconnect(timeout=timeout)
	else:
	self.sync_with_ping(timeout=timeout)

	if success:
	wait_until(lambda: node.getbestblockhash() ==
	blocks[-1].hash, timeout=timeout)
	else:
	assert node.getbestblockhash() != blocks[-1].hash

	if reject_reason:
	with node.assert_debug_log(expected_msgs=[reject_reason]):
	test()
	else:
	test()

	def send_txs_and_test(self, txs, node, *, success=True,
	expect_disconnect=False, reject_reason=None):
	"""Send txs to test node and test whether they're accepted to the mempool.

	- add all txs to our tx_store
	- send tx messages for all txs
	- if success is True/False: assert that the txs are/are not accepted to the mempool
	- if expect_disconnect is True: Skip the sync with ping
	- if reject_reason is set: assert that the correct reject message is logged."""

	with mininode_lock:
	for tx in txs:
	self.tx_store[tx.sha256] = tx

	def test():
	for tx in txs:
	self.send_message(msg_tx(tx))

	if expect_disconnect:
	self.wait_for_disconnect()
	else:
	self.sync_with_ping()

	raw_mempool = node.getrawmempool()
	if success:
	# Check that all txs are now in the mempool
	for tx in txs:
	assert tx.hash in raw_mempool, "{} not found in mempool".format(
	tx.hash)
	else:
	# Check that none of the txs are now in the mempool
	for tx in txs:
	assert tx.hash not in raw_mempool, "{} tx found in mempool".format(
	tx.hash)

	if reject_reason:
	with node.assert_debug_log(expected_msgs=[reject_reason]):
	test()
	else:
	test()

File Metadata

Mime Type: text/x-diff
Expires: Thu, Apr 17, 03:26 (8 h, 8 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5508699
Default Alt Text: (84 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions