D496.diff
No OneTemporary
Actions

Size

223 KB

Subscribers

None

D496.diff
View Options

	diff --git a/qa/rpc-tests/abc-p2p-fullblocktest.py b/qa/rpc-tests/abc-p2p-fullblocktest.py
	--- a/qa/rpc-tests/abc-p2p-fullblocktest.py
	+++ b/qa/rpc-tests/abc-p2p-fullblocktest.py
	@@ -21,6 +21,7 @@
	from test_framework.cdefs import (ONE_MEGABYTE, LEGACY_MAX_BLOCK_SIZE,
	MAX_BLOCK_SIGOPS_PER_MB, MAX_TX_SIGOPS_COUNT)

	+
	class PreviousSpendableOutput(object):

	def __init__(self, tx=CTransaction(), n=-1):
	diff --git a/qa/rpc-tests/abc-rpc.py b/qa/rpc-tests/abc-rpc.py
	--- a/qa/rpc-tests/abc-rpc.py
	+++ b/qa/rpc-tests/abc-rpc.py
	@@ -15,6 +15,7 @@
	LEGACY_MAX_BLOCK_SIZE,
	DEFAULT_MAX_BLOCK_SIZE)

	+
	class ABC_RPC_Test (BitcoinTestFramework):

	def __init__(self):
	diff --git a/qa/rpc-tests/assumevalid.py b/qa/rpc-tests/assumevalid.py
	--- a/qa/rpc-tests/assumevalid.py
	+++ b/qa/rpc-tests/assumevalid.py
	@@ -16,7 +16,7 @@
	2-101: bury that block with 100 blocks so the coinbase transaction
	output can be spent
	102: a block containing a transaction spending the coinbase
	- transaction output. The transaction has an invalid signature.
	+ transaction output. The transaction has an invalid signature.
	103-2202: bury the bad block with just over two weeks' worth of blocks
	(2100 blocks)

	@@ -38,7 +38,9 @@
	from test_framework.key import CECKey
	from test_framework.script import *

	+
	class BaseNode(SingleNodeConnCB):
	+
	def __init__(self):
	SingleNodeConnCB.__init__(self)
	self.last_inv = None
	@@ -60,10 +62,12 @@

	def send_header_for_blocks(self, new_blocks):
	headers_message = msg_headers()
	- headers_message.headers = [ CBlockHeader(b) for b in new_blocks ]
	+ headers_message.headers = [CBlockHeader(b) for b in new_blocks]
	self.send_message(headers_message)

	+
	class SendHeadersTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.setup_clean_chain = True
	@@ -81,15 +85,17 @@
	# Connect to node0
	node0 = BaseNode()
	connections = []
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
	node0.add_connection(connections[0])

	- NetworkThread().start() # Start up network handling in another thread
	+ NetworkThread().start() # Start up network handling in another thread
	node0.wait_for_verack()

	# Build the blockchain
	self.tip = int(self.nodes[0].getbestblockhash(), 16)
	- self.block_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time'] + 1
	+ self.block_time = self.nodes[0].getblock(
	+ self.nodes[0].getbestblockhash())['time'] + 1

	self.blocks = []

	@@ -100,7 +106,8 @@

	# Create the first block with a coinbase output to our key
	height = 1
	- block = create_block(self.tip, create_coinbase(height, coinbase_pubkey), self.block_time)
	+ block = create_block(self.tip, create_coinbase(
	+ height, coinbase_pubkey), self.block_time)
	self.blocks.append(block)
	self.block_time += 1
	block.solve()
	@@ -111,20 +118,24 @@

	# Bury the block 100 deep so the coinbase output is spendable
	for i in range(100):
	- block = create_block(self.tip, create_coinbase(height), self.block_time)
	+ block = create_block(
	+ self.tip, create_coinbase(height), self.block_time)
	block.solve()
	self.blocks.append(block)
	self.tip = block.sha256
	self.block_time += 1
	height += 1

	- # Create a transaction spending the coinbase output with an invalid (null) signature
	+ # Create a transaction spending the coinbase output with an invalid
	+ # (null) signature
	tx = CTransaction()
	- tx.vin.append(CTxIn(COutPoint(self.block1.vtx[0].sha256, 0), scriptSig=b""))
	- tx.vout.append(CTxOut(49*100000000, CScript([OP_TRUE])))
	+ tx.vin.append(
	+ CTxIn(COutPoint(self.block1.vtx[0].sha256, 0), scriptSig=b""))
	+ tx.vout.append(CTxOut(49 * 100000000, CScript([OP_TRUE])))
	tx.calc_sha256()

	- block102 = create_block(self.tip, create_coinbase(height), self.block_time)
	+ block102 = create_block(
	+ self.tip, create_coinbase(height), self.block_time)
	self.block_time += 1
	block102.vtx.extend([tx])
	block102.hashMerkleRoot = block102.calc_merkle_root()
	@@ -137,7 +148,8 @@

	# Bury the assumed valid block 2100 deep
	for i in range(2100):
	- block = create_block(self.tip, create_coinbase(height), self.block_time)
	+ block = create_block(
	+ self.tip, create_coinbase(height), self.block_time)
	block.nVersion = 4
	block.solve()
	self.blocks.append(block)
	@@ -145,18 +157,21 @@
	self.block_time += 1
	height += 1

	- # Start node1 and node2 with assumevalid so they accept a block with a bad signature.
	+ # Start node1 and node2 with assumevalid so they accept a block with a
	+ # bad signature.
	self.nodes.append(start_node(1, self.options.tmpdir,
	["-debug", "-assumevalid=" + hex(block102.sha256)]))
	node1 = BaseNode() # connects to node1
	- connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1))
	node1.add_connection(connections[1])
	node1.wait_for_verack()

	self.nodes.append(start_node(2, self.options.tmpdir,
	["-debug", "-assumevalid=" + hex(block102.sha256)]))
	node2 = BaseNode() # connects to node2
	- connections.append(NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2))
	node2.add_connection(connections[2])
	node2.wait_for_verack()

	@@ -170,22 +185,25 @@
	# Send 102 blocks to node0. Block 102 will be rejected.
	for i in range(101):
	node0.send_message(msg_block(self.blocks[i]))
	- node0.sync_with_ping() # make sure the most recent block is synced
	+ node0.sync_with_ping() # make sure the most recent block is synced
	node0.send_message(msg_block(self.blocks[101]))
	- assert_equal(self.nodes[0].getblock(self.nodes[0].getbestblockhash())['height'], 101)
	+ assert_equal(self.nodes[0].getblock(
	+ self.nodes[0].getbestblockhash())['height'], 101)

	# Send 3102 blocks to node1. All blocks will be accepted.
	for i in range(2202):
	node1.send_message(msg_block(self.blocks[i]))
	- node1.sync_with_ping() # make sure the most recent block is synced
	- assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202)
	+ node1.sync_with_ping() # make sure the most recent block is synced
	+ assert_equal(self.nodes[1].getblock(
	+ self.nodes[1].getbestblockhash())['height'], 2202)

	# Send 102 blocks to node2. Block 102 will be rejected.
	for i in range(101):
	node2.send_message(msg_block(self.blocks[i]))
	- node2.sync_with_ping() # make sure the most recent block is synced
	+ node2.sync_with_ping() # make sure the most recent block is synced
	node2.send_message(msg_block(self.blocks[101]))
	- assert_equal(self.nodes[2].getblock(self.nodes[2].getbestblockhash())['height'], 101)
	+ assert_equal(self.nodes[2].getblock(
	+ self.nodes[2].getbestblockhash())['height'], 101)

	if __name__ == '__main__':
	SendHeadersTest().main()
	diff --git a/qa/rpc-tests/bip65-cltv.py b/qa/rpc-tests/bip65-cltv.py
	--- a/qa/rpc-tests/bip65-cltv.py
	+++ b/qa/rpc-tests/bip65-cltv.py
	@@ -10,7 +10,9 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class BIP65Test(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.num_nodes = 3
	@@ -19,8 +21,10 @@
	def setup_network(self):
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, []))
	- self.nodes.append(start_node(1, self.options.tmpdir, ["-blockversion=3"]))
	- self.nodes.append(start_node(2, self.options.tmpdir, ["-blockversion=4"]))
	+ self.nodes.append(
	+ start_node(1, self.options.tmpdir, ["-blockversion=3"]))
	+ self.nodes.append(
	+ start_node(2, self.options.tmpdir, ["-blockversion=4"]))
	connect_nodes(self.nodes[1], 0)
	connect_nodes(self.nodes[2], 0)
	self.is_network_split = False
	@@ -64,7 +68,8 @@
	self.nodes[1].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1050):
	- raise AssertionError("Failed to mine a version=3 block after 949 version=4 blocks")
	+ raise AssertionError(
	+ "Failed to mine a version=3 block after 949 version=4 blocks")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	@@ -75,12 +80,14 @@
	# Mine 1 old-version blocks
	try:
	self.nodes[1].generate(1)
	- raise AssertionError("Succeeded to mine a version=3 block after 950 version=4 blocks")
	+ raise AssertionError(
	+ "Succeeded to mine a version=3 block after 950 version=4 blocks")
	except JSONRPCException:
	pass
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1051):
	- raise AssertionError("Accepted a version=3 block after 950 version=4 blocks")
	+ raise AssertionError(
	+ "Accepted a version=3 block after 950 version=4 blocks")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	diff --git a/qa/rpc-tests/bipdersig.py b/qa/rpc-tests/bipdersig.py
	--- a/qa/rpc-tests/bipdersig.py
	+++ b/qa/rpc-tests/bipdersig.py
	@@ -10,7 +10,9 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class BIP66Test(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.num_nodes = 3
	@@ -19,8 +21,10 @@
	def setup_network(self):
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, []))
	- self.nodes.append(start_node(1, self.options.tmpdir, ["-blockversion=2"]))
	- self.nodes.append(start_node(2, self.options.tmpdir, ["-blockversion=3"]))
	+ self.nodes.append(
	+ start_node(1, self.options.tmpdir, ["-blockversion=2"]))
	+ self.nodes.append(
	+ start_node(2, self.options.tmpdir, ["-blockversion=3"]))
	connect_nodes(self.nodes[1], 0)
	connect_nodes(self.nodes[2], 0)
	self.is_network_split = False
	@@ -63,7 +67,8 @@
	self.nodes[1].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1050):
	- raise AssertionError("Failed to mine a version=2 block after 949 version=3 blocks")
	+ raise AssertionError(
	+ "Failed to mine a version=2 block after 949 version=3 blocks")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	@@ -74,12 +79,14 @@
	# Mine 1 old-version blocks
	try:
	self.nodes[1].generate(1)
	- raise AssertionError("Succeeded to mine a version=2 block after 950 version=3 blocks")
	+ raise AssertionError(
	+ "Succeeded to mine a version=2 block after 950 version=3 blocks")
	except JSONRPCException:
	pass
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1051):
	- raise AssertionError("Accepted a version=2 block after 950 version=3 blocks")
	+ raise AssertionError(
	+ "Accepted a version=2 block after 950 version=3 blocks")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	diff --git a/qa/rpc-tests/blockchain.py b/qa/rpc-tests/blockchain.py
	--- a/qa/rpc-tests/blockchain.py
	+++ b/qa/rpc-tests/blockchain.py
	@@ -23,6 +23,7 @@


	class BlockchainTest(BitcoinTestFramework):
	+
	"""
	Test blockchain-related RPC calls:

	diff --git a/qa/rpc-tests/create_cache.py b/qa/rpc-tests/create_cache.py
	--- a/qa/rpc-tests/create_cache.py
	+++ b/qa/rpc-tests/create_cache.py
	@@ -10,6 +10,7 @@

	from test_framework.test_framework import BitcoinTestFramework

	+
	class CreateCache(BitcoinTestFramework):

	def __init__(self):
	diff --git a/qa/rpc-tests/decodescript.py b/qa/rpc-tests/decodescript.py
	--- a/qa/rpc-tests/decodescript.py
	+++ b/qa/rpc-tests/decodescript.py
	@@ -8,7 +8,9 @@
	from test_framework.mininode import *
	from io import BytesIO

	+
	class DecodeScriptTest(BitcoinTestFramework):
	+
	"""Tests decoding scripts via RPC command "decodescript"."""

	def __init__(self):
	@@ -29,18 +31,21 @@
	# below are test cases for all of the standard transaction types

	# 1) P2PK scriptSig
	- # the scriptSig of a public key scriptPubKey simply pushes a signature onto the stack
	+ # the scriptSig of a public key scriptPubKey simply pushes a signature
	+ # onto the stack
	rpc_result = self.nodes[0].decodescript(push_signature)
	assert_equal(signature, rpc_result['asm'])

	# 2) P2PKH scriptSig
	- rpc_result = self.nodes[0].decodescript(push_signature + push_public_key)
	+ rpc_result = self.nodes[0].decodescript(
	+ push_signature + push_public_key)
	assert_equal(signature + ' ' + public_key, rpc_result['asm'])

	# 3) multisig scriptSig
	# this also tests the leading portion of a P2SH multisig scriptSig
	# OP_0 <A sig> <B sig>
	- rpc_result = self.nodes[0].decodescript('00' + push_signature + push_signature)
	+ rpc_result = self.nodes[0].decodescript(
	+ '00' + push_signature + push_signature)
	assert_equal('0 ' + signature + ' ' + signature, rpc_result['asm'])

	# 4) P2SH scriptSig
	@@ -68,27 +73,35 @@

	# 2) P2PKH scriptPubKey
	# OP_DUP OP_HASH160 <PubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
	- rpc_result = self.nodes[0].decodescript('76a9' + push_public_key_hash + '88ac')
	- assert_equal('OP_DUP OP_HASH160 ' + public_key_hash + ' OP_EQUALVERIFY OP_CHECKSIG', rpc_result['asm'])
	+ rpc_result = self.nodes[0].decodescript(
	+ '76a9' + push_public_key_hash + '88ac')
	+ assert_equal('OP_DUP OP_HASH160 ' + public_key_hash +
	+ ' OP_EQUALVERIFY OP_CHECKSIG', rpc_result['asm'])

	# 3) multisig scriptPubKey
	# <m> <A pubkey> <B pubkey> <C pubkey> <n> OP_CHECKMULTISIG
	# just imagine that the pub keys used below are different.
	- # for our purposes here it does not matter that they are the same even though it is unrealistic.
	- rpc_result = self.nodes[0].decodescript('52' + push_public_key + push_public_key + push_public_key + '53ae')
	- assert_equal('2 ' + public_key + ' ' + public_key + ' ' + public_key + ' 3 OP_CHECKMULTISIG', rpc_result['asm'])
	+ # for our purposes here it does not matter that they are the same even
	+ # though it is unrealistic.
	+ rpc_result = self.nodes[0].decodescript(
	+ '52' + push_public_key + push_public_key + push_public_key + '53ae')
	+ assert_equal('2 ' + public_key + ' ' + public_key + ' ' +
	+ public_key + ' 3 OP_CHECKMULTISIG', rpc_result['asm'])

	# 4) P2SH scriptPubKey
	# OP_HASH160 <Hash160(redeemScript)> OP_EQUAL.
	# push_public_key_hash here should actually be the hash of a redeem script.
	# but this works the same for purposes of this test.
	- rpc_result = self.nodes[0].decodescript('a9' + push_public_key_hash + '87')
	- assert_equal('OP_HASH160 ' + public_key_hash + ' OP_EQUAL', rpc_result['asm'])
	+ rpc_result = self.nodes[0].decodescript(
	+ 'a9' + push_public_key_hash + '87')
	+ assert_equal(
	+ 'OP_HASH160 ' + public_key_hash + ' OP_EQUAL', rpc_result['asm'])

	# 5) null data scriptPubKey
	# use a signature look-alike here to make sure that we do not decode random data as a signature.
	# this matters if/when signature sighash decoding comes along.
	- # would want to make sure that no such decoding takes place in this case.
	+ # would want to make sure that no such decoding takes place in this
	+ # case.
	signature_imposter = '48304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001'
	# OP_RETURN <data>
	rpc_result = self.nodes[0].decodescript('6a' + signature_imposter)
	@@ -107,8 +120,10 @@
	# <sender-pubkey> OP_CHECKSIG
	#
	# lock until block 500,000
	- rpc_result = self.nodes[0].decodescript('63' + push_public_key + 'ad670320a107b17568' + push_public_key + 'ac')
	- assert_equal('OP_IF ' + public_key + ' OP_CHECKSIGVERIFY OP_ELSE 500000 OP_CHECKLOCKTIMEVERIFY OP_DROP OP_ENDIF ' + public_key + ' OP_CHECKSIG', rpc_result['asm'])
	+ rpc_result = self.nodes[0].decodescript(
	+ '63' + push_public_key + 'ad670320a107b17568' + push_public_key + 'ac')
	+ assert_equal('OP_IF ' + public_key + ' OP_CHECKSIGVERIFY OP_ELSE 500000 OP_CHECKLOCKTIMEVERIFY OP_DROP OP_ENDIF ' +
	+ public_key + ' OP_CHECKSIG', rpc_result['asm'])

	def decoderawtransaction_asm_sighashtype(self):
	"""Tests decoding scripts via RPC command "decoderawtransaction".
	@@ -116,38 +131,55 @@
	This test is in with the "decodescript" tests because they are testing the same "asm" script decodes.
	"""

	- # this test case uses a random plain vanilla mainnet transaction with a single P2PKH input and output
	+ # this test case uses a random plain vanilla mainnet transaction with a
	+ # single P2PKH input and output
	tx = '0100000001696a20784a2c70143f634e95227dbdfdf0ecd51647052e70854512235f5986ca010000008a47304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb014104d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536ffffffff0100e1f505000000001976a914eb6c6e0cdb2d256a32d97b8df1fc75d1920d9bca88ac00000000'
	rpc_result = self.nodes[0].decoderawtransaction(tx)
	- assert_equal('304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb[ALL] 04d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536', rpc_result['vin'][0]['scriptSig']['asm'])
	+ assert_equal(
	+ '304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb[ALL] 04d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536', rpc_result['vin'][0]['scriptSig']['asm'])

	# this test case uses a mainnet transaction that has a P2SH input and both P2PKH and P2SH outputs.
	# it's from James D'Angelo's awesome introductory videos about multisig: https://www.youtube.com/watch?v=zIbUSaZBJgU and https://www.youtube.com/watch?v=OSA1pwlaypc
	# verify that we have not altered scriptPubKey decoding.
	tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914dc863734a218bfe83ef770ee9d41a27f824a6e5688acee2a02000000000017a9142a5edea39971049a540474c6a99edf0aa4074c588700000000'
	rpc_result = self.nodes[0].decoderawtransaction(tx)
	- assert_equal('8e3730608c3b0bb5df54f09076e196bc292a8e39a78e73b44b6ba08c78f5cbb0', rpc_result['txid'])
	- assert_equal('0 3045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea[ALL] 3045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75[ALL] 5221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53ae', rpc_result['vin'][0]['scriptSig']['asm'])
	- assert_equal('OP_DUP OP_HASH160 dc863734a218bfe83ef770ee9d41a27f824a6e56 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm'])
	- assert_equal('OP_HASH160 2a5edea39971049a540474c6a99edf0aa4074c58 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm'])
	+ assert_equal(
	+ '8e3730608c3b0bb5df54f09076e196bc292a8e39a78e73b44b6ba08c78f5cbb0', rpc_result['txid'])
	+ assert_equal(
	+ '0 3045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea[ALL] 3045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75[ALL] 5221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53ae', rpc_result['vin'][0]['scriptSig']['asm'])
	+ assert_equal(
	+ 'OP_DUP OP_HASH160 dc863734a218bfe83ef770ee9d41a27f824a6e56 OP_EQUALVERIFY OP_CHECKSIG',
	+ rpc_result['vout'][0]['scriptPubKey']['asm'])
	+ assert_equal(
	+ 'OP_HASH160 2a5edea39971049a540474c6a99edf0aa4074c58 OP_EQUAL',
	+ rpc_result['vout'][1]['scriptPubKey']['asm'])
	txSave = CTransaction()
	txSave.deserialize(BytesIO(hex_str_to_bytes(tx)))

	- # make sure that a specifically crafted op_return value will not pass all the IsDERSignature checks and then get decoded as a sighash type
	+ # make sure that a specifically crafted op_return value will not pass
	+ # all the IsDERSignature checks and then get decoded as a sighash type
	tx = '01000000015ded05872fdbda629c7d3d02b194763ce3b9b1535ea884e3c8e765d42e316724020000006b48304502204c10d4064885c42638cbff3585915b322de33762598321145ba033fc796971e2022100bb153ad3baa8b757e30a2175bd32852d2e1cb9080f84d7e32fcdfd667934ef1b012103163c0ff73511ea1743fb5b98384a2ff09dd06949488028fd819f4d83f56264efffffffff0200000000000000000b6a0930060201000201000180380100000000001976a9141cabd296e753837c086da7a45a6c2fe0d49d7b7b88ac00000000'
	rpc_result = self.nodes[0].decoderawtransaction(tx)
	- assert_equal('OP_RETURN 300602010002010001', rpc_result['vout'][0]['scriptPubKey']['asm'])
	+ assert_equal('OP_RETURN 300602010002010001',
	+ rpc_result['vout'][0]['scriptPubKey']['asm'])

	- # verify that we have not altered scriptPubKey processing even of a specially crafted P2PKH pubkeyhash and P2SH redeem script hash that is made to pass the der signature checks
	+ # verify that we have not altered scriptPubKey processing even of a
	+ # specially crafted P2PKH pubkeyhash and P2SH redeem script hash that
	+ # is made to pass the der signature checks
	tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914301102070101010101010102060101010101010188acee2a02000000000017a91430110207010101010101010206010101010101018700000000'
	rpc_result = self.nodes[0].decoderawtransaction(tx)
	- assert_equal('OP_DUP OP_HASH160 3011020701010101010101020601010101010101 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm'])
	- assert_equal('OP_HASH160 3011020701010101010101020601010101010101 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm'])
	+ assert_equal(
	+ 'OP_DUP OP_HASH160 3011020701010101010101020601010101010101 OP_EQUALVERIFY OP_CHECKSIG',
	+ rpc_result['vout'][0]['scriptPubKey']['asm'])
	+ assert_equal(
	+ 'OP_HASH160 3011020701010101010101020601010101010101 OP_EQUAL',
	+ rpc_result['vout'][1]['scriptPubKey']['asm'])

	# some more full transaction tests of varying specific scriptSigs. used instead of
	# tests in decodescript_script_sig because the decodescript RPC is specifically
	# for working on scriptPubKeys (argh!).
	- push_signature = bytes_to_hex_str(txSave.vin[0].scriptSig)[2:(0x48*2+4)]
	+ push_signature = bytes_to_hex_str(
	+ txSave.vin[0].scriptSig)[2:(0x48 * 2 + 4)]
	signature = push_signature[2:]
	der_signature = signature[:-2]
	signature_sighash_decoded = der_signature + '[ALL]'
	@@ -157,24 +189,36 @@

	# 1) P2PK scriptSig
	txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature)
	- rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
	- assert_equal(signature_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
	+ rpc_result = self.nodes[0].decoderawtransaction(
	+ bytes_to_hex_str(txSave.serialize()))
	+ assert_equal(signature_sighash_decoded,
	+ rpc_result['vin'][0]['scriptSig']['asm'])

	- # make sure that the sighash decodes come out correctly for a more complex / lesser used case.
	+ # make sure that the sighash decodes come out correctly for a more
	+ # complex / lesser used case.
	txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature_2)
	- rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
	- assert_equal(signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
	+ rpc_result = self.nodes[0].decoderawtransaction(
	+ bytes_to_hex_str(txSave.serialize()))
	+ assert_equal(signature_2_sighash_decoded,
	+ rpc_result['vin'][0]['scriptSig']['asm'])

	# 2) multisig scriptSig
	- txSave.vin[0].scriptSig = hex_str_to_bytes('00' + push_signature + push_signature_2)
	- rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
	- assert_equal('0 ' + signature_sighash_decoded + ' ' + signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
	+ txSave.vin[0].scriptSig = hex_str_to_bytes(
	+ '00' + push_signature + push_signature_2)
	+ rpc_result = self.nodes[0].decoderawtransaction(
	+ bytes_to_hex_str(txSave.serialize()))
	+ assert_equal('0 ' + signature_sighash_decoded + ' ' +
	+ signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])

	# 3) test a scriptSig that contains more than push operations.
	- # in fact, it contains an OP_RETURN with data specially crafted to cause improper decode if the code does not catch it.
	- txSave.vin[0].scriptSig = hex_str_to_bytes('6a143011020701010101010101020601010101010101')
	- rpc_result = self.nodes[0].decoderawtransaction(bytes_to_hex_str(txSave.serialize()))
	- assert_equal('OP_RETURN 3011020701010101010101020601010101010101', rpc_result['vin'][0]['scriptSig']['asm'])
	+ # in fact, it contains an OP_RETURN with data specially crafted to
	+ # cause improper decode if the code does not catch it.
	+ txSave.vin[0].scriptSig = hex_str_to_bytes(
	+ '6a143011020701010101010101020601010101010101')
	+ rpc_result = self.nodes[0].decoderawtransaction(
	+ bytes_to_hex_str(txSave.serialize()))
	+ assert_equal('OP_RETURN 3011020701010101010101020601010101010101',
	+ rpc_result['vin'][0]['scriptSig']['asm'])

	def run_test(self):
	self.decodescript_script_sig()
	diff --git a/qa/rpc-tests/disablewallet.py b/qa/rpc-tests/disablewallet.py
	--- a/qa/rpc-tests/disablewallet.py
	+++ b/qa/rpc-tests/disablewallet.py
	@@ -19,12 +19,14 @@
	self.num_nodes = 1

	def setup_network(self, split=False):
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, [['-disablewallet']])
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, [['-disablewallet']])
	self.is_network_split = False
	self.sync_all()

	- def run_test (self):
	- # Check regression: https://github.com/bitcoin/bitcoin/issues/6963#issuecomment-154548880
	+ def run_test(self):
	+ # Check regression:
	+ # https://github.com/bitcoin/bitcoin/issues/6963#issuecomment-154548880
	x = self.nodes[0].validateaddress('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
	assert(x['isvalid'] == False)
	x = self.nodes[0].validateaddress('mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ')
	@@ -32,17 +34,20 @@

	# Checking mining to an address without a wallet
	try:
	- self.nodes[0].generatetoaddress(1, 'mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ')
	+ self.nodes[0].generatetoaddress(
	+ 1, 'mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ')
	except JSONRPCException as e:
	assert("Invalid address" not in e.error['message'])
	- assert("ProcessNewBlock, block not accepted" not in e.error['message'])
	+ assert(
	+ "ProcessNewBlock, block not accepted" not in e.error['message'])
	assert("Couldn't create new block" not in e.error['message'])

	try:
	- self.nodes[0].generatetoaddress(1, '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
	+ self.nodes[0].generatetoaddress(
	+ 1, '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
	raise AssertionError("Must not mine to invalid address!")
	except JSONRPCException as e:
	assert("Invalid address" in e.error['message'])

	if __name__ == '__main__':
	- DisableWalletTest ().main ()
	+ DisableWalletTest().main()
	diff --git a/qa/rpc-tests/forknotify.py b/qa/rpc-tests/forknotify.py
	--- a/qa/rpc-tests/forknotify.py
	+++ b/qa/rpc-tests/forknotify.py
	@@ -4,12 +4,13 @@
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	-# Test -alertnotify
	+# Test -alertnotify
	#

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class ForkNotifyTest(BitcoinTestFramework):

	def __init__(self):
	@@ -25,10 +26,10 @@
	with open(self.alert_filename, 'w', encoding='utf8'):
	pass # Just open then close to create zero-length file
	self.nodes.append(start_node(0, self.options.tmpdir,
	- ["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]))
	+ ["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]))
	# Node1 mines block.version=211 blocks
	self.nodes.append(start_node(1, self.options.tmpdir,
	- ["-blockversion=211"]))
	+ ["-blockversion=211"]))
	connect_nodes(self.nodes[1], 0)

	self.is_network_split = False
	@@ -48,7 +49,8 @@
	alert_text = f.read()

	if len(alert_text) == 0:
	- raise AssertionError("-alertnotify did not warn of up-version blocks")
	+ raise AssertionError(
	+ "-alertnotify did not warn of up-version blocks")

	# Mine more up-version blocks, should not get more alerts:
	self.nodes[1].generate(1)
	@@ -60,7 +62,8 @@
	alert_text2 = f.read()

	if alert_text != alert_text2:
	- raise AssertionError("-alertnotify excessive warning of up-version blocks")
	+ raise AssertionError(
	+ "-alertnotify excessive warning of up-version blocks")

	if __name__ == '__main__':
	ForkNotifyTest().main()
	diff --git a/qa/rpc-tests/getblocktemplate_proposals.py b/qa/rpc-tests/getblocktemplate_proposals.py
	--- a/qa/rpc-tests/getblocktemplate_proposals.py
	+++ b/qa/rpc-tests/getblocktemplate_proposals.py
	@@ -10,10 +10,14 @@
	from hashlib import sha256
	from struct import pack

	+
	def b2x(b):
	return b2a_hex(b).decode('ascii')

	-# NOTE: This does not work for signed numbers (set the high bit) or zero (use b'\0')
	+# NOTE: This does not work for signed numbers (set the high bit) or zero
	+# (use b'\0')
	+
	+
	def encodeUNum(n):
	s = bytearray(b'\1')
	while n > 127:
	@@ -23,6 +27,7 @@
	s.append(n)
	return bytes(s)

	+
	def varlenEncode(n):
	if n < 0xfd:
	return pack('<B', n)
	@@ -32,9 +37,11 @@
	return b'\xfe' + pack('<L', n)
	return b'\xff' + pack('<Q', n)

	+
	def dblsha(b):
	return sha256(sha256(b).digest()).digest()

	+
	def genmrklroot(leaflist):
	cur = leaflist
	while len(cur) > 1:
	@@ -42,30 +49,37 @@
	if len(cur) & 1:
	cur.append(cur[-1])
	for i in range(0, len(cur), 2):
	- n.append(dblsha(cur[i] + cur[i+1]))
	+ n.append(dblsha(cur[i] + cur[i + 1]))
	cur = n
	return cur[0]

	+
	def template_to_bytearray(tmpl, txlist):
	blkver = pack('<L', tmpl['version'])
	mrklroot = genmrklroot(list(dblsha(a) for a in txlist))
	timestamp = pack('<L', tmpl['curtime'])
	nonce = b'\0\0\0\0'
	- blk = blkver + a2b_hex(tmpl['previousblockhash'])[::-1] + mrklroot + timestamp + a2b_hex(tmpl['bits'])[::-1] + nonce
	+ blk = blkver + a2b_hex(tmpl['previousblockhash'])[
	+ ::-1] + mrklroot + timestamp + a2b_hex(tmpl['bits'])[::-1] + nonce
	blk += varlenEncode(len(txlist))
	for tx in txlist:
	blk += tx
	return bytearray(blk)

	+
	def template_to_hex(tmpl, txlist):
	return b2x(template_to_bytearray(tmpl, txlist))

	+
	def assert_template(node, tmpl, txlist, expect):
	- rsp = node.getblocktemplate({'data':template_to_hex(tmpl, txlist),'mode':'proposal'})
	+ rsp = node.getblocktemplate(
	+ {'data': template_to_hex(tmpl, txlist), 'mode': 'proposal'})
	if rsp != expect:
	raise AssertionError('unexpected: %s' % (rsp,))

	+
	class GetBlockTemplateProposalTest(BitcoinTestFramework):
	+
	'''
	Test block proposals with getblocktemplate.
	'''
	@@ -81,33 +95,36 @@

	def run_test(self):
	node = self.nodes[0]
	- node.generate(1) # Mine a block to leave initial block download
	+ node.generate(1) # Mine a block to leave initial block download
	tmpl = node.getblocktemplate()
	if 'coinbasetxn' not in tmpl:
	rawcoinbase = encodeUNum(tmpl['height'])
	rawcoinbase += b'\x01-'
	hexcoinbase = b2x(rawcoinbase)
	hexoutval = b2x(pack('<Q', tmpl['coinbasevalue']))
	- tmpl['coinbasetxn'] = {'data': '01000000' + '01' + '0000000000000000000000000000000000000000000000000000000000000000ffffffff' + ('%02x' % (len(rawcoinbase),)) + hexcoinbase + 'fffffffe' + '01' + hexoutval + '00' + '00000000'}
	- txlist = list(bytearray(a2b_hex(a['data'])) for a in (tmpl['coinbasetxn'],) + tuple(tmpl['transactions']))
	+ tmpl['coinbasetxn'] = {'data': '01000000' + '01' + '0000000000000000000000000000000000000000000000000000000000000000ffffffff' + (
	+ '%02x' % (len(rawcoinbase),)) + hexcoinbase + 'fffffffe' + '01' + hexoutval + '00' + '00000000'}
	+ txlist = list(bytearray(a2b_hex(a['data']))
	+ for a in (tmpl['coinbasetxn'],) + tuple(tmpl['transactions']))

	# Test 0: Capability advertised
	assert('proposal' in tmpl['capabilities'])

	# NOTE: This test currently FAILS (regtest mode doesn't enforce block height in coinbase)
	- ## Test 1: Bad height in coinbase
	- #txlist[0][4+1+36+1+1] += 1
	- #assert_template(node, tmpl, txlist, 'FIXME')
	- #txlist[0][4+1+36+1+1] -= 1
	+ # Test 1: Bad height in coinbase
	+ # txlist[0][4+1+36+1+1] += 1
	+ # assert_template(node, tmpl, txlist, 'FIXME')
	+ # txlist[0][4+1+36+1+1] -= 1

	# Test 2: Bad input hash for gen tx
	- txlist[0][4+1] += 1
	+ txlist[0][4 + 1] += 1
	assert_template(node, tmpl, txlist, 'bad-cb-missing')
	- txlist[0][4+1] -= 1
	+ txlist[0][4 + 1] -= 1

	# Test 3: Truncated final tx
	lastbyte = txlist[-1].pop()
	- assert_raises(JSONRPCException, assert_template, node, tmpl, txlist, 'n/a')
	+ assert_raises(
	+ JSONRPCException, assert_template, node, tmpl, txlist, 'n/a')
	txlist[-1].append(lastbyte)

	# Test 4: Add an invalid tx to the end (duplicate of gen tx)
	@@ -117,7 +134,7 @@

	# Test 5: Add an invalid tx to the end (non-duplicate)
	txlist.append(bytearray(txlist[0]))
	- txlist[-1][4+1] = 0xff
	+ txlist[-1][4 + 1] = 0xff
	assert_template(node, tmpl, txlist, 'bad-txns-inputs-missingorspent')
	txlist.pop()

	@@ -128,7 +145,8 @@

	# Test 7: Bad tx count
	txlist.append(b'')
	- assert_raises(JSONRPCException, assert_template, node, tmpl, txlist, 'n/a')
	+ assert_raises(
	+ JSONRPCException, assert_template, node, tmpl, txlist, 'n/a')
	txlist.pop()

	# Test 8: Bad bits
	@@ -139,8 +157,8 @@

	# Test 9: Bad merkle root
	rawtmpl = template_to_bytearray(tmpl, txlist)
	- rawtmpl[4+32] = (rawtmpl[4+32] + 1) % 0x100
	- rsp = node.getblocktemplate({'data':b2x(rawtmpl),'mode':'proposal'})
	+ rawtmpl[4 + 32] = (rawtmpl[4 + 32] + 1) % 0x100
	+ rsp = node.getblocktemplate({'data': b2x(rawtmpl), 'mode': 'proposal'})
	if rsp != 'bad-txnmrklroot':
	raise AssertionError('unexpected: %s' % (rsp,))

	diff --git a/qa/rpc-tests/getchaintips.py b/qa/rpc-tests/getchaintips.py
	--- a/qa/rpc-tests/getchaintips.py
	+++ b/qa/rpc-tests/getchaintips.py
	@@ -10,53 +10,55 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import assert_equal

	+
	class GetChainTipsTest (BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.num_nodes = 4
	self.setup_clean_chain = False

	- def run_test (self):
	+ def run_test(self):

	- tips = self.nodes[0].getchaintips ()
	- assert_equal (len (tips), 1)
	- assert_equal (tips[0]['branchlen'], 0)
	- assert_equal (tips[0]['height'], 200)
	- assert_equal (tips[0]['status'], 'active')
	+ tips = self.nodes[0].getchaintips()
	+ assert_equal(len(tips), 1)
	+ assert_equal(tips[0]['branchlen'], 0)
	+ assert_equal(tips[0]['height'], 200)
	+ assert_equal(tips[0]['status'], 'active')

	# Split the network and build two chains of different lengths.
	- self.split_network ()
	+ self.split_network()
	self.nodes[0].generate(10)
	self.nodes[2].generate(20)
	- self.sync_all ()
	+ self.sync_all()

	- tips = self.nodes[1].getchaintips ()
	- assert_equal (len (tips), 1)
	+ tips = self.nodes[1].getchaintips()
	+ assert_equal(len(tips), 1)
	shortTip = tips[0]
	- assert_equal (shortTip['branchlen'], 0)
	- assert_equal (shortTip['height'], 210)
	- assert_equal (tips[0]['status'], 'active')
	+ assert_equal(shortTip['branchlen'], 0)
	+ assert_equal(shortTip['height'], 210)
	+ assert_equal(tips[0]['status'], 'active')

	- tips = self.nodes[3].getchaintips ()
	- assert_equal (len (tips), 1)
	+ tips = self.nodes[3].getchaintips()
	+ assert_equal(len(tips), 1)
	longTip = tips[0]
	- assert_equal (longTip['branchlen'], 0)
	- assert_equal (longTip['height'], 220)
	- assert_equal (tips[0]['status'], 'active')
	+ assert_equal(longTip['branchlen'], 0)
	+ assert_equal(longTip['height'], 220)
	+ assert_equal(tips[0]['status'], 'active')

	# Join the network halves and check that we now have two tips
	# (at least at the nodes that previously had the short chain).
	- self.join_network ()
	+ self.join_network()

	- tips = self.nodes[0].getchaintips ()
	- assert_equal (len (tips), 2)
	- assert_equal (tips[0], longTip)
	+ tips = self.nodes[0].getchaintips()
	+ assert_equal(len(tips), 2)
	+ assert_equal(tips[0], longTip)

	- assert_equal (tips[1]['branchlen'], 10)
	- assert_equal (tips[1]['status'], 'valid-fork')
	+ assert_equal(tips[1]['branchlen'], 10)
	+ assert_equal(tips[1]['status'], 'valid-fork')
	tips[1]['branchlen'] = 0
	tips[1]['status'] = 'active'
	- assert_equal (tips[1], shortTip)
	+ assert_equal(tips[1], shortTip)

	if __name__ == '__main__':
	- GetChainTipsTest ().main ()
	+ GetChainTipsTest().main()
	diff --git a/qa/rpc-tests/httpbasics.py b/qa/rpc-tests/httpbasics.py
	--- a/qa/rpc-tests/httpbasics.py
	+++ b/qa/rpc-tests/httpbasics.py
	@@ -13,7 +13,9 @@
	import http.client
	import urllib.parse

	+
	class HTTPBasicsTest (BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.num_nodes = 3
	@@ -24,9 +26,9 @@

	def run_test(self):

	- #################################################
	+ #
	# lowlevel check for http persistent connection #
	- #################################################
	+ #
	url = urllib.parse.urlparse(self.nodes[0].url)
	authpair = url.username + ':' + url.password
	headers = {"Authorization": "Basic " + str_to_b64str(authpair)}
	@@ -36,43 +38,53 @@
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	out1 = conn.getresponse().read()
	assert(b'"error":null' in out1)
	- assert(conn.sock!=None) #according to http/1.1 connection must still be open!
	+ assert(conn.sock != None)
	+ # according to http/1.1 connection must still be open!

	- #send 2nd request without closing connection
	+ # send 2nd request without closing connection
	conn.request('POST', '/', '{"method": "getchaintips"}', headers)
	out1 = conn.getresponse().read()
	- assert(b'"error":null' in out1) #must also response with a correct json-rpc message
	- assert(conn.sock!=None) #according to http/1.1 connection must still be open!
	+ assert(b'"error":null' in out1)
	+ # must also response with a correct json-rpc message
	+ assert(conn.sock != None)
	+ # according to http/1.1 connection must still be open!
	conn.close()

	- #same should be if we add keep-alive because this should be the std. behaviour
	- headers = {"Authorization": "Basic " + str_to_b64str(authpair), "Connection": "keep-alive"}
	+ # same should be if we add keep-alive because this should be the std.
	+ # behaviour
	+ headers = {"Authorization": "Basic " +
	+ str_to_b64str(authpair), "Connection": "keep-alive"}

	conn = http.client.HTTPConnection(url.hostname, url.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	out1 = conn.getresponse().read()
	assert(b'"error":null' in out1)
	- assert(conn.sock!=None) #according to http/1.1 connection must still be open!
	+ assert(conn.sock != None)
	+ # according to http/1.1 connection must still be open!

	- #send 2nd request without closing connection
	+ # send 2nd request without closing connection
	conn.request('POST', '/', '{"method": "getchaintips"}', headers)
	out1 = conn.getresponse().read()
	- assert(b'"error":null' in out1) #must also response with a correct json-rpc message
	- assert(conn.sock!=None) #according to http/1.1 connection must still be open!
	+ assert(b'"error":null' in out1)
	+ # must also response with a correct json-rpc message
	+ assert(conn.sock != None)
	+ # according to http/1.1 connection must still be open!
	conn.close()

	- #now do the same with "Connection: close"
	- headers = {"Authorization": "Basic " + str_to_b64str(authpair), "Connection":"close"}
	+ # now do the same with "Connection: close"
	+ headers = {"Authorization": "Basic " +
	+ str_to_b64str(authpair), "Connection": "close"}

	conn = http.client.HTTPConnection(url.hostname, url.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	out1 = conn.getresponse().read()
	assert(b'"error":null' in out1)
	- assert(conn.sock==None) #now the connection must be closed after the response
	+ assert(conn.sock == None)
	+ # now the connection must be closed after the response

	- #node1 (2nd node) is running with disabled keep-alive option
	+ # node1 (2nd node) is running with disabled keep-alive option
	urlNode1 = urllib.parse.urlparse(self.nodes[1].url)
	authpair = urlNode1.username + ':' + urlNode1.password
	headers = {"Authorization": "Basic " + str_to_b64str(authpair)}
	@@ -83,7 +95,8 @@
	out1 = conn.getresponse().read()
	assert(b'"error":null' in out1)

	- #node2 (third node) is running with standard keep-alive parameters which means keep-alive is on
	+ # node2 (third node) is running with standard keep-alive parameters
	+ # which means keep-alive is on
	urlNode2 = urllib.parse.urlparse(self.nodes[2].url)
	authpair = urlNode2.username + ':' + urlNode2.password
	headers = {"Authorization": "Basic " + str_to_b64str(authpair)}
	@@ -93,21 +106,23 @@
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	out1 = conn.getresponse().read()
	assert(b'"error":null' in out1)
	- assert(conn.sock!=None) #connection must be closed because bitcoind should use keep-alive by default
	+ assert(conn.sock != None)
	+ # connection must be closed because bitcoind should use
	+ # keep-alive by default

	# Check excessive request size
	conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
	conn.connect()
	- conn.request('GET', '/' + ('x'*1000), '', headers)
	+ conn.request('GET', '/' + ('x' * 1000), '', headers)
	out1 = conn.getresponse()
	assert_equal(out1.status, http.client.NOT_FOUND)

	conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
	conn.connect()
	- conn.request('GET', '/' + ('x'*10000), '', headers)
	+ conn.request('GET', '/' + ('x' * 10000), '', headers)
	out1 = conn.getresponse()
	assert_equal(out1.status, http.client.BAD_REQUEST)


	if __name__ == '__main__':
	- HTTPBasicsTest ().main ()
	+ HTTPBasicsTest().main()
	diff --git a/qa/rpc-tests/importmulti.py b/qa/rpc-tests/importmulti.py
	--- a/qa/rpc-tests/importmulti.py
	+++ b/qa/rpc-tests/importmulti.py
	@@ -6,7 +6,9 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class ImportMultiTest (BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.num_nodes = 2
	@@ -14,13 +16,14 @@

	def setup_network(self, split=False):
	self.nodes = start_nodes(2, self.options.tmpdir)
	- self.is_network_split=False
	+ self.is_network_split = False

	- def run_test (self):
	+ def run_test(self):
	print ("Mining blocks...")
	self.nodes[0].generate(1)
	self.nodes[1].generate(1)
	- timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
	+ timestamp = self.nodes[1].getblock(
	+ self.nodes[1].getbestblockhash())['mediantime']

	# keyword definition
	PRIV_KEY = 'privkey'
	@@ -28,23 +31,24 @@
	ADDRESS_KEY = 'address'
	SCRIPT_KEY = 'script'

	+ node0_address1 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ node0_address2 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ node0_address3 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())

	- node0_address1 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- node0_address2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- node0_address3 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	-
	- #Check only one address
	+ # Check only one address
	assert_equal(node0_address1['ismine'], True)

	- #Node 1 sync test
	- assert_equal(self.nodes[1].getblockcount(),1)
	+ # Node 1 sync test
	+ assert_equal(self.nodes[1].getblockcount(), 1)

	- #Address Test - before import
	+ # Address Test - before import
	address_info = self.nodes[1].validateaddress(node0_address1['address'])
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], False)

	-
	# RPC importmulti -----------------------------------------------

	# Bitcoin Address
	@@ -98,13 +102,13 @@
	}])
	assert_equal(result[0]['success'], False)
	assert_equal(result[0]['error']['code'], -8)
	- assert_equal(result[0]['error']['message'], 'Internal must be set for hex scriptPubKey')
	+ assert_equal(result[0]['error']['message'],
	+ 'Internal must be set for hex scriptPubKey')
	address_assert = self.nodes[1].validateaddress(address['address'])
	assert_equal(address_assert['iswatchonly'], False)
	assert_equal(address_assert['ismine'], False)
	assert_equal('timestamp' in address_assert, False)

	-
	# Address + Public key + !Internal
	print("Should import an address with public key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	@@ -113,7 +117,7 @@
	"address": address['address']
	},
	"timestamp": "now",
	- "pubkeys": [ address['pubkey'] ]
	+ "pubkeys": [address['pubkey']]
	}])
	assert_equal(result[0]['success'], True)
	address_assert = self.nodes[1].validateaddress(address['address'])
	@@ -121,14 +125,13 @@
	assert_equal(address_assert['ismine'], False)
	assert_equal(address_assert['timestamp'], timestamp)

	-
	# ScriptPubKey + Public key + internal
	print("Should import a scriptPubKey with internal and with public key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	request = [{
	"scriptPubKey": address['scriptPubKey'],
	"timestamp": "now",
	- "pubkeys": [ address['pubkey'] ],
	+ "pubkeys": [address['pubkey']],
	"internal": True
	}]
	result = self.nodes[1].importmulti(request)
	@@ -139,17 +142,19 @@
	assert_equal(address_assert['timestamp'], timestamp)

	# ScriptPubKey + Public key + !internal
	- print("Should not import a scriptPubKey without internal and with public key")
	+ print(
	+ "Should not import a scriptPubKey without internal and with public key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	request = [{
	"scriptPubKey": address['scriptPubKey'],
	"timestamp": "now",
	- "pubkeys": [ address['pubkey'] ]
	+ "pubkeys": [address['pubkey']]
	}]
	result = self.nodes[1].importmulti(request)
	assert_equal(result[0]['success'], False)
	assert_equal(result[0]['error']['code'], -8)
	- assert_equal(result[0]['error']['message'], 'Internal must be set for hex scriptPubKey')
	+ assert_equal(result[0]['error']['message'],
	+ 'Internal must be set for hex scriptPubKey')
	address_assert = self.nodes[1].validateaddress(address['address'])
	assert_equal(address_assert['iswatchonly'], False)
	assert_equal(address_assert['ismine'], False)
	@@ -163,7 +168,7 @@
	"address": address['address']
	},
	"timestamp": "now",
	- "keys": [ self.nodes[0].dumpprivkey(address['address']) ]
	+ "keys": [self.nodes[0].dumpprivkey(address['address'])]
	}])
	assert_equal(result[0]['success'], True)
	address_assert = self.nodes[1].validateaddress(address['address'])
	@@ -172,31 +177,34 @@
	assert_equal(address_assert['timestamp'], timestamp)

	# Address + Private key + watchonly
	- print("Should not import an address with private key and with watchonly")
	+ print(
	+ "Should not import an address with private key and with watchonly")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	result = self.nodes[1].importmulti([{
	"scriptPubKey": {
	"address": address['address']
	},
	"timestamp": "now",
	- "keys": [ self.nodes[0].dumpprivkey(address['address']) ],
	+ "keys": [self.nodes[0].dumpprivkey(address['address'])],
	"watchonly": True
	}])
	assert_equal(result[0]['success'], False)
	assert_equal(result[0]['error']['code'], -8)
	- assert_equal(result[0]['error']['message'], 'Incompatibility found between watchonly and keys')
	+ assert_equal(result[0]['error']['message'],
	+ 'Incompatibility found between watchonly and keys')
	address_assert = self.nodes[1].validateaddress(address['address'])
	assert_equal(address_assert['iswatchonly'], False)
	assert_equal(address_assert['ismine'], False)
	assert_equal('timestamp' in address_assert, False)

	# ScriptPubKey + Private key + internal
	- print("Should import a scriptPubKey with internal and with private key")
	+ print(
	+ "Should import a scriptPubKey with internal and with private key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	result = self.nodes[1].importmulti([{
	"scriptPubKey": address['scriptPubKey'],
	"timestamp": "now",
	- "keys": [ self.nodes[0].dumpprivkey(address['address']) ],
	+ "keys": [self.nodes[0].dumpprivkey(address['address'])],
	"internal": True
	}])
	assert_equal(result[0]['success'], True)
	@@ -206,31 +214,38 @@
	assert_equal(address_assert['timestamp'], timestamp)

	# ScriptPubKey + Private key + !internal
	- print("Should not import a scriptPubKey without internal and with private key")
	+ print(
	+ "Should not import a scriptPubKey without internal and with private key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	result = self.nodes[1].importmulti([{
	"scriptPubKey": address['scriptPubKey'],
	"timestamp": "now",
	- "keys": [ self.nodes[0].dumpprivkey(address['address']) ]
	+ "keys": [self.nodes[0].dumpprivkey(address['address'])]
	}])
	assert_equal(result[0]['success'], False)
	assert_equal(result[0]['error']['code'], -8)
	- assert_equal(result[0]['error']['message'], 'Internal must be set for hex scriptPubKey')
	+ assert_equal(result[0]['error']['message'],
	+ 'Internal must be set for hex scriptPubKey')
	address_assert = self.nodes[1].validateaddress(address['address'])
	assert_equal(address_assert['iswatchonly'], False)
	assert_equal(address_assert['ismine'], False)
	assert_equal('timestamp' in address_assert, False)

	-
	# P2SH address
	- sig_address_1 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_3 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	+ sig_address_1 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_2 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_3 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ multi_sig_script = self.nodes[0].createmultisig(
	+ 2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	self.nodes[1].generate(100)
	- transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
	+ transactionid = self.nodes[1].sendtoaddress(
	+ multi_sig_script['address'], 10.00)
	self.nodes[1].generate(1)
	- timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
	+ timestamp = self.nodes[1].getblock(
	+ self.nodes[1].getbestblockhash())['mediantime']
	transaction = self.nodes[1].gettransaction(transactionid)

	print("Should import a p2sh")
	@@ -241,24 +256,31 @@
	"timestamp": "now",
	}])
	assert_equal(result[0]['success'], True)
	- address_assert = self.nodes[1].validateaddress(multi_sig_script['address'])
	+ address_assert = self.nodes[1].validateaddress(
	+ multi_sig_script['address'])
	assert_equal(address_assert['isscript'], True)
	assert_equal(address_assert['iswatchonly'], True)
	assert_equal(address_assert['timestamp'], timestamp)
	- p2shunspent = self.nodes[1].listunspent(0,999999, [multi_sig_script['address']])[0]
	+ p2shunspent = self.nodes[1].listunspent(
	+ 0, 999999, [multi_sig_script['address']])[0]
	assert_equal(p2shunspent['spendable'], False)
	assert_equal(p2shunspent['solvable'], False)

	-
	# P2SH + Redeem script
	- sig_address_1 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_3 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	+ sig_address_1 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_2 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_3 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ multi_sig_script = self.nodes[0].createmultisig(
	+ 2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	self.nodes[1].generate(100)
	- transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
	+ transactionid = self.nodes[1].sendtoaddress(
	+ multi_sig_script['address'], 10.00)
	self.nodes[1].generate(1)
	- timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
	+ timestamp = self.nodes[1].getblock(
	+ self.nodes[1].getbestblockhash())['mediantime']
	transaction = self.nodes[1].gettransaction(transactionid)

	print("Should import a p2sh with respective redeem script")
	@@ -270,66 +292,82 @@
	"redeemscript": multi_sig_script['redeemScript']
	}])
	assert_equal(result[0]['success'], True)
	- address_assert = self.nodes[1].validateaddress(multi_sig_script['address'])
	+ address_assert = self.nodes[1].validateaddress(
	+ multi_sig_script['address'])
	assert_equal(address_assert['timestamp'], timestamp)

	- p2shunspent = self.nodes[1].listunspent(0,999999, [multi_sig_script['address']])[0]
	+ p2shunspent = self.nodes[1].listunspent(
	+ 0, 999999, [multi_sig_script['address']])[0]
	assert_equal(p2shunspent['spendable'], False)
	assert_equal(p2shunspent['solvable'], True)

	-
	# P2SH + Redeem script + Private Keys + !Watchonly
	- sig_address_1 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_3 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	+ sig_address_1 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_2 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_3 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ multi_sig_script = self.nodes[0].createmultisig(
	+ 2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	self.nodes[1].generate(100)
	- transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
	+ transactionid = self.nodes[1].sendtoaddress(
	+ multi_sig_script['address'], 10.00)
	self.nodes[1].generate(1)
	- timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
	+ timestamp = self.nodes[1].getblock(
	+ self.nodes[1].getbestblockhash())['mediantime']
	transaction = self.nodes[1].gettransaction(transactionid)

	- print("Should import a p2sh with respective redeem script and private keys")
	+ print(
	+ "Should import a p2sh with respective redeem script and private keys")
	result = self.nodes[1].importmulti([{
	"scriptPubKey": {
	"address": multi_sig_script['address']
	},
	"timestamp": "now",
	"redeemscript": multi_sig_script['redeemScript'],
	- "keys": [ self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])]
	+ "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])]
	}])
	assert_equal(result[0]['success'], True)
	- address_assert = self.nodes[1].validateaddress(multi_sig_script['address'])
	+ address_assert = self.nodes[1].validateaddress(
	+ multi_sig_script['address'])
	assert_equal(address_assert['timestamp'], timestamp)

	- p2shunspent = self.nodes[1].listunspent(0,999999, [multi_sig_script['address']])[0]
	+ p2shunspent = self.nodes[1].listunspent(
	+ 0, 999999, [multi_sig_script['address']])[0]
	assert_equal(p2shunspent['spendable'], False)
	assert_equal(p2shunspent['solvable'], True)

	# P2SH + Redeem script + Private Keys + Watchonly
	- sig_address_1 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- sig_address_3 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	- multi_sig_script = self.nodes[0].createmultisig(2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	+ sig_address_1 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_2 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ sig_address_3 = self.nodes[0].validateaddress(
	+ self.nodes[0].getnewaddress())
	+ multi_sig_script = self.nodes[0].createmultisig(
	+ 2, [sig_address_1['address'], sig_address_2['address'], sig_address_3['pubkey']])
	self.nodes[1].generate(100)
	- transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
	+ transactionid = self.nodes[1].sendtoaddress(
	+ multi_sig_script['address'], 10.00)
	self.nodes[1].generate(1)
	transaction = self.nodes[1].gettransaction(transactionid)

	- print("Should import a p2sh with respective redeem script and private keys")
	+ print(
	+ "Should import a p2sh with respective redeem script and private keys")
	result = self.nodes[1].importmulti([{
	"scriptPubKey": {
	"address": multi_sig_script['address']
	},
	"timestamp": "now",
	"redeemscript": multi_sig_script['redeemScript'],
	- "keys": [ self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])],
	+ "keys": [self.nodes[0].dumpprivkey(sig_address_1['address']), self.nodes[0].dumpprivkey(sig_address_2['address'])],
	"watchonly": True
	}])
	assert_equal(result[0]['success'], False)
	assert_equal(result[0]['error']['code'], -8)
	- assert_equal(result[0]['error']['message'], 'Incompatibility found between watchonly and keys')
	-
	+ assert_equal(result[0]['error']['message'],
	+ 'Incompatibility found between watchonly and keys')

	# Address + Public key + !Internal + Wrong pubkey
	print("Should not import an address with a wrong public key")
	@@ -340,7 +378,7 @@
	"address": address['address']
	},
	"timestamp": "now",
	- "pubkeys": [ address2['pubkey'] ]
	+ "pubkeys": [address2['pubkey']]
	}])
	assert_equal(result[0]['success'], False)
	assert_equal(result[0]['error']['code'], -5)
	@@ -350,15 +388,15 @@
	assert_equal(address_assert['ismine'], False)
	assert_equal('timestamp' in address_assert, False)

	-
	# ScriptPubKey + Public key + internal + Wrong pubkey
	- print("Should not import a scriptPubKey with internal and with a wrong public key")
	+ print(
	+ "Should not import a scriptPubKey with internal and with a wrong public key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	address2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	request = [{
	"scriptPubKey": address['scriptPubKey'],
	"timestamp": "now",
	- "pubkeys": [ address2['pubkey'] ],
	+ "pubkeys": [address2['pubkey']],
	"internal": True
	}]
	result = self.nodes[1].importmulti(request)
	@@ -370,7 +408,6 @@
	assert_equal(address_assert['ismine'], False)
	assert_equal('timestamp' in address_assert, False)

	-
	# Address + Private key + !watchonly + Wrong private key
	print("Should not import an address with a wrong private key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	@@ -380,7 +417,7 @@
	"address": address['address']
	},
	"timestamp": "now",
	- "keys": [ self.nodes[0].dumpprivkey(address2['address']) ]
	+ "keys": [self.nodes[0].dumpprivkey(address2['address'])]
	}])
	assert_equal(result[0]['success'], False)
	assert_equal(result[0]['error']['code'], -5)
	@@ -390,15 +427,15 @@
	assert_equal(address_assert['ismine'], False)
	assert_equal('timestamp' in address_assert, False)

	-
	# ScriptPubKey + Private key + internal + Wrong private key
	- print("Should not import a scriptPubKey with internal and with a wrong private key")
	+ print(
	+ "Should not import a scriptPubKey with internal and with a wrong private key")
	address = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	address2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
	result = self.nodes[1].importmulti([{
	"scriptPubKey": address['scriptPubKey'],
	"timestamp": "now",
	- "keys": [ self.nodes[0].dumpprivkey(address2['address']) ],
	+ "keys": [self.nodes[0].dumpprivkey(address2['address'])],
	"internal": True
	}])
	assert_equal(result[0]['success'], False)
	@@ -409,21 +446,24 @@
	assert_equal(address_assert['ismine'], False)
	assert_equal('timestamp' in address_assert, False)

	- # restart nodes to check for proper serialization/deserialization of watch only address
	+ # restart nodes to check for proper serialization/deserialization of
	+ # watch only address
	stop_nodes(self.nodes)
	self.nodes = start_nodes(2, self.options.tmpdir)
	address_assert = self.nodes[1].validateaddress(watchonly_address)
	assert_equal(address_assert['iswatchonly'], True)
	assert_equal(address_assert['ismine'], False)
	- assert_equal(address_assert['timestamp'], watchonly_timestamp);
	+ assert_equal(address_assert['timestamp'], watchonly_timestamp)

	# Bad or missing timestamps
	print("Should throw on invalid or missing timestamp values")
	- assert_raises_message(JSONRPCException, 'Missing required timestamp field for key',
	+ assert_raises_message(
	+ JSONRPCException, 'Missing required timestamp field for key',
	self.nodes[1].importmulti, [{
	"scriptPubKey": address['scriptPubKey'],
	}])
	- assert_raises_message(JSONRPCException, 'Expected number or "now" timestamp value for key. got type string',
	+ assert_raises_message(
	+ JSONRPCException, 'Expected number or "now" timestamp value for key. got type string',
	self.nodes[1].importmulti, [{
	"scriptPubKey": address['scriptPubKey'],
	"timestamp": "",
	@@ -431,4 +471,4 @@


	if __name__ == '__main__':
	- ImportMultiTest ().main ()
	+ ImportMultiTest().main()
	diff --git a/qa/rpc-tests/importprunedfunds.py b/qa/rpc-tests/importprunedfunds.py
	--- a/qa/rpc-tests/importprunedfunds.py
	+++ b/qa/rpc-tests/importprunedfunds.py
	@@ -16,8 +16,8 @@

	def setup_network(self, split=False):
	self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
	- connect_nodes_bi(self.nodes,0,1)
	- self.is_network_split=False
	+ connect_nodes_bi(self.nodes, 0, 1)
	+ self.is_network_split = False
	self.sync_all()

	def run_test(self):
	@@ -25,26 +25,28 @@
	self.nodes[0].generate(101)

	self.sync_all()
	-
	+
	# address
	address1 = self.nodes[0].getnewaddress()
	# pubkey
	address2 = self.nodes[0].getnewaddress()
	- address2_pubkey = self.nodes[0].validateaddress(address2)['pubkey'] # Using pubkey
	+ address2_pubkey = self.nodes[0].validateaddress(
	+ address2)['pubkey'] # Using pubkey
	# privkey
	address3 = self.nodes[0].getnewaddress()
	- address3_privkey = self.nodes[0].dumpprivkey(address3) # Using privkey
	+ address3_privkey = self.nodes[0].dumpprivkey(
	+ address3) # Using privkey

	- #Check only one address
	+ # Check only one address
	address_info = self.nodes[0].validateaddress(address1)
	assert_equal(address_info['ismine'], True)

	self.sync_all()

	- #Node 1 sync test
	- assert_equal(self.nodes[1].getblockcount(),101)
	+ # Node 1 sync test
	+ assert_equal(self.nodes[1].getblockcount(), 101)

	- #Address Test - before import
	+ # Address Test - before import
	address_info = self.nodes[1].validateaddress(address1)
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], False)
	@@ -57,7 +59,7 @@
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], False)

	- #Send funds to self
	+ # Send funds to self
	txnid1 = self.nodes[0].sendtoaddress(address1, 0.1)
	self.nodes[0].generate(1)
	rawtxn1 = self.nodes[0].gettransaction(txnid1)['hex']
	@@ -75,7 +77,7 @@

	self.sync_all()

	- #Import with no affiliated address
	+ # Import with no affiliated address
	try:
	self.nodes[1].importprunedfunds(rawtxn1, proof1)
	except JSONRPCException as e:
	@@ -86,13 +88,13 @@
	balance1 = self.nodes[1].getbalance("", 0, True)
	assert_equal(balance1, Decimal(0))

	- #Import with affiliated address with no rescan
	+ # Import with affiliated address with no rescan
	self.nodes[1].importaddress(address2, "add2", False)
	result2 = self.nodes[1].importprunedfunds(rawtxn2, proof2)
	balance2 = self.nodes[1].getbalance("add2", 0, True)
	assert_equal(balance2, Decimal('0.05'))

	- #Import with private key with no rescan
	+ # Import with private key with no rescan
	self.nodes[1].importprivkey(address3_privkey, "add3", False)
	result3 = self.nodes[1].importprunedfunds(rawtxn3, proof3)
	balance3 = self.nodes[1].getbalance("add3", 0, False)
	@@ -100,7 +102,7 @@
	balance3 = self.nodes[1].getbalance("*", 0, True)
	assert_equal(balance3, Decimal('0.075'))

	- #Addresses Test - after import
	+ # Addresses Test - after import
	address_info = self.nodes[1].validateaddress(address1)
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], False)
	@@ -111,7 +113,7 @@
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], True)

	- #Remove transactions
	+ # Remove transactions
	try:
	self.nodes[1].removeprunedfunds(txnid1)
	except JSONRPCException as e:
	diff --git a/qa/rpc-tests/invalidateblock.py b/qa/rpc-tests/invalidateblock.py
	--- a/qa/rpc-tests/invalidateblock.py
	+++ b/qa/rpc-tests/invalidateblock.py
	@@ -10,9 +10,9 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class InvalidateTest(BitcoinTestFramework):
	-
	-
	+
	def __init__(self):
	super().__init__()
	self.setup_clean_chain = True
	@@ -20,13 +20,14 @@

	def setup_network(self):
	self.nodes = []
	- self.is_network_split = False
	+ self.is_network_split = False
	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug"]))
	self.nodes.append(start_node(1, self.options.tmpdir, ["-debug"]))
	self.nodes.append(start_node(2, self.options.tmpdir, ["-debug"]))
	-
	+
	def run_test(self):
	- print("Make sure we repopulate setBlockIndexCandidates after InvalidateBlock:")
	+ print(
	+ "Make sure we repopulate setBlockIndexCandidates after InvalidateBlock:")
	print("Mine 4 blocks on Node 0")
	self.nodes[0].generate(4)
	assert(self.nodes[0].getblockcount() == 4)
	@@ -37,20 +38,22 @@
	assert(self.nodes[1].getblockcount() == 6)

	print("Connect nodes to force a reorg")
	- connect_nodes_bi(self.nodes,0,1)
	+ connect_nodes_bi(self.nodes, 0, 1)
	sync_blocks(self.nodes[0:2])
	assert(self.nodes[0].getblockcount() == 6)
	badhash = self.nodes[1].getblockhash(2)

	- print("Invalidate block 2 on node 0 and verify we reorg to node 0's original chain")
	+ print(
	+ "Invalidate block 2 on node 0 and verify we reorg to node 0's original chain")
	self.nodes[0].invalidateblock(badhash)
	newheight = self.nodes[0].getblockcount()
	newhash = self.nodes[0].getbestblockhash()
	if (newheight != 4 or newhash != besthash):
	- raise AssertionError("Wrong tip for node0, hash %s, height %d"%(newhash,newheight))
	+ raise AssertionError(
	+ "Wrong tip for node0, hash %s, height %d" % (newhash, newheight))

	print("\nMake sure we won't reorg to a lower work chain:")
	- connect_nodes_bi(self.nodes,1,2)
	+ connect_nodes_bi(self.nodes, 1, 2)
	print("Sync node 2 to node 1 so both have 6 blocks")
	sync_blocks(self.nodes[1:3])
	assert(self.nodes[2].getblockcount() == 6)
	@@ -65,12 +68,13 @@
	print("Verify all nodes are at the right height")
	time.sleep(5)
	for i in range(3):
	- print(i,self.nodes[i].getblockcount())
	+ print(i, self.nodes[i].getblockcount())
	assert(self.nodes[2].getblockcount() == 3)
	assert(self.nodes[0].getblockcount() == 4)
	node1height = self.nodes[1].getblockcount()
	if node1height < 4:
	- raise AssertionError("Node 1 reorged to a lower height: %d"%node1height)
	+ raise AssertionError(
	+ "Node 1 reorged to a lower height: %d" % node1height)

	if __name__ == '__main__':
	InvalidateTest().main()
	diff --git a/qa/rpc-tests/invalidblockrequest.py b/qa/rpc-tests/invalidblockrequest.py
	--- a/qa/rpc-tests/invalidblockrequest.py
	+++ b/qa/rpc-tests/invalidblockrequest.py
	@@ -20,10 +20,13 @@
	'''

	# Use the ComparisonTestFramework with 1 node: only use --testbinary.
	+
	+
	class InvalidBlockRequestTest(ComparisonTestFramework):

	- ''' Can either run this test as 1 node with expected answers, or two and compare them.
	+ ''' 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 __init__(self):
	super().__init__()
	self.num_nodes = 1
	@@ -33,19 +36,20 @@
	test.add_all_connections(self.nodes)
	self.tip = None
	self.block_time = None
	- NetworkThread().start() # Start up network handling in another thread
	+ NetworkThread().start() # Start up network handling in another thread
	test.run()

	def get_tests(self):
	if self.tip is None:
	self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
	- self.block_time = int(time.time())+1
	+ self.block_time = int(time.time()) + 1

	'''
	Create a new block with an anyone-can-spend coinbase
	'''
	height = 1
	- block = create_block(self.tip, create_coinbase(height), self.block_time)
	+ block = create_block(
	+ self.tip, create_coinbase(height), self.block_time)
	self.block_time += 1
	block.solve()
	# Save the coinbase for later
	@@ -59,7 +63,8 @@
	'''
	test = TestInstance(sync_every_block=False)
	for i in range(100):
	- block = create_block(self.tip, create_coinbase(height), self.block_time)
	+ block = create_block(
	+ self.tip, create_coinbase(height), self.block_time)
	block.solve()
	self.tip = block.sha256
	self.block_time += 1
	@@ -71,10 +76,11 @@
	Now we use merkle-root malleability to generate an invalid block with
	same blockheader.
	Manufacture a block with 3 transactions (coinbase, spend of prior
	- coinbase, spend of that spend). Duplicate the 3rd transaction to
	+ coinbase, spend of that spend). Duplicate the 3rd transaction to
	leave merkle root and blockheader unchanged but invalidate the block.
	'''
	- block2 = create_block(self.tip, create_coinbase(height), self.block_time)
	+ block2 = create_block(
	+ self.tip, create_coinbase(height), self.block_time)
	self.block_time += 1

	# b'0x51' is OP_TRUE
	@@ -101,10 +107,11 @@
	'''
	Make sure that a totally screwed up block is not valid.
	'''
	- block3 = create_block(self.tip, create_coinbase(height), self.block_time)
	+ block3 = create_block(
	+ self.tip, create_coinbase(height), self.block_time)
	self.block_time += 1
	- block3.vtx[0].vout[0].nValue = 100 * COIN # Too high!
	- block3.vtx[0].sha256=None
	+ block3.vtx[0].vout[0].nValue = 100 * COIN # Too high!
	+ block3.vtx[0].sha256 = None
	block3.vtx[0].calc_sha256()
	block3.hashMerkleRoot = block3.calc_merkle_root()
	block3.rehash()
	diff --git a/qa/rpc-tests/keypool.py b/qa/rpc-tests/keypool.py
	--- a/qa/rpc-tests/keypool.py
	+++ b/qa/rpc-tests/keypool.py
	@@ -8,15 +8,18 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class KeyPoolTest(BitcoinTestFramework):

	def run_test(self):
	nodes = self.nodes
	addr_before_encrypting = nodes[0].getnewaddress()
	- addr_before_encrypting_data = nodes[0].validateaddress(addr_before_encrypting)
	+ addr_before_encrypting_data = nodes[
	+ 0].validateaddress(addr_before_encrypting)
	wallet_info_old = nodes[0].getwalletinfo()
	- assert(addr_before_encrypting_data['hdmasterkeyid'] == wallet_info_old['hdmasterkeyid'])
	-
	+ assert(addr_before_encrypting_data[
	+ 'hdmasterkeyid'] == wallet_info_old['hdmasterkeyid'])
	+
	# Encrypt wallet and wait to terminate
	nodes[0].encryptwallet('test')
	bitcoind_processes[0].wait()
	@@ -26,14 +29,16 @@
	addr = nodes[0].getnewaddress()
	addr_data = nodes[0].validateaddress(addr)
	wallet_info = nodes[0].getwalletinfo()
	- assert(addr_before_encrypting_data['hdmasterkeyid'] != wallet_info['hdmasterkeyid'])
	+ assert(addr_before_encrypting_data[
	+ 'hdmasterkeyid'] != wallet_info['hdmasterkeyid'])
	assert(addr_data['hdmasterkeyid'] == wallet_info['hdmasterkeyid'])
	-
	+
	try:
	addr = nodes[0].getnewaddress()
	- raise AssertionError('Keypool should be exhausted after one address')
	+ raise AssertionError(
	+ 'Keypool should be exhausted after one address')
	except JSONRPCException as e:
	- assert(e.error['code']==-12)
	+ assert(e.error['code'] == -12)

	# put three new keys in the keypool
	nodes[0].walletpassphrase('test', 12000)
	@@ -51,9 +56,10 @@
	# the next one should fail
	try:
	addr = nodes[0].getrawchangeaddress()
	- raise AssertionError('Keypool should be exhausted after three addresses')
	+ raise AssertionError(
	+ 'Keypool should be exhausted after three addresses')
	except JSONRPCException as e:
	- assert(e.error['code']==-12)
	+ assert(e.error['code'] == -12)

	# refill keypool with three new addresses
	nodes[0].walletpassphrase('test', 1)
	@@ -69,9 +75,10 @@
	nodes[0].generate(1)
	try:
	nodes[0].generate(1)
	- raise AssertionError('Keypool should be exhausted after three addesses')
	+ raise AssertionError(
	+ 'Keypool should be exhausted after three addesses')
	except JSONRPCException as e:
	- assert(e.error['code']==-12)
	+ assert(e.error['code'] == -12)

	def __init__(self):
	super().__init__()
	diff --git a/qa/rpc-tests/listsinceblock.py b/qa/rpc-tests/listsinceblock.py
	--- a/qa/rpc-tests/listsinceblock.py
	+++ b/qa/rpc-tests/listsinceblock.py
	@@ -6,6 +6,7 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import assert_equal

	+
	class ListSinceBlockTest (BitcoinTestFramework):

	def __init__(self):
	@@ -13,7 +14,7 @@
	self.setup_clean_chain = True
	self.num_nodes = 4

	- def run_test (self):
	+ def run_test(self):
	'''
	`listsinceblock` did not behave correctly when handed a block that was
	no longer in the main chain:
	@@ -67,7 +68,8 @@

	self.join_network()

	- # listsinceblock(lastblockhash) should now include tx, as seen from nodes[0]
	+ # listsinceblock(lastblockhash) should now include tx, as seen from
	+ # nodes[0]
	lsbres = self.nodes[0].listsinceblock(lastblockhash)
	found = False
	for tx in lsbres['transactions']:
	diff --git a/qa/rpc-tests/maxblocksinflight.py b/qa/rpc-tests/maxblocksinflight.py
	--- a/qa/rpc-tests/maxblocksinflight.py
	+++ b/qa/rpc-tests/maxblocksinflight.py
	@@ -16,8 +16,10 @@
	'''
	MAX_REQUESTS = 128

	+
	class TestManager(NodeConnCB):
	# set up NodeConnCB callbacks, overriding base class
	+
	def on_getdata(self, conn, message):
	self.log.debug("got getdata %s" % repr(message))
	# Log the requests
	@@ -61,16 +63,20 @@
	for key in self.blockReqCounts:
	total_requests += self.blockReqCounts[key]
	if self.blockReqCounts[key] > 1:
	- raise AssertionError("Error, test failed: block %064x requested more than once" % key)
	+ raise AssertionError(
	+ "Error, test failed: block %064x requested more than once" % key)
	if total_requests > MAX_REQUESTS:
	- raise AssertionError("Error, too many blocks (%d) requested" % total_requests)
	- print("Round %d: success (total requests: %d)" % (count, total_requests))
	+ raise AssertionError(
	+ "Error, too many blocks (%d) requested" % total_requests)
	+ print("Round %d: success (total requests: %d)" %
	+ (count, total_requests))

	self.disconnectOkay = True
	self.connection.disconnect_node()


	class MaxBlocksInFlightTest(BitcoinTestFramework):
	+
	def add_options(self, parser):
	parser.add_option("--testbinary", dest="testbinary",
	default=os.getenv("BITCOIND", "bitcoind"),
	@@ -83,12 +89,14 @@

	def setup_network(self):
	self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	- extra_args=[['-debug', '-whitelist=127.0.0.1']],
	+ extra_args=[
	+ ['-debug', '-whitelist=127.0.0.1']],
	binary=[self.options.testbinary])

	def run_test(self):
	test = TestManager()
	- test.add_new_connection(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test))
	+ test.add_new_connection(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test))
	NetworkThread().start() # Start up network handling in another thread
	test.run()

	diff --git a/qa/rpc-tests/multi_rpc.py b/qa/rpc-tests/multi_rpc.py
	--- a/qa/rpc-tests/multi_rpc.py
	+++ b/qa/rpc-tests/multi_rpc.py
	@@ -14,6 +14,7 @@
	import http.client
	import urllib.parse

	+
	class HTTPBasicsTest (BitcoinTestFramework):

	def __init__(self):
	@@ -23,34 +24,34 @@

	def setup_chain(self):
	super().setup_chain()
	- #Append rpcauth to bitcoin.conf before initialization
	+ # Append rpcauth to bitcoin.conf before initialization
	rpcauth = "rpcauth=rt:93648e835a54c573682c2eb19f882535$7681e9c5b74bdd85e78166031d2058e1069b3ed7ed967c93fc63abba06f31144"
	rpcauth2 = "rpcauth=rt2:f8607b1a88861fac29dfccf9b52ff9f$ff36a0c23c8c62b4846112e50fa888416e94c17bfd4c42f88fd8f55ec6a3137e"
	- with open(os.path.join(self.options.tmpdir+"/node0", "bitcoin.conf"), 'a', encoding='utf8') as f:
	- f.write(rpcauth+"\n")
	- f.write(rpcauth2+"\n")
	+ with open(os.path.join(self.options.tmpdir + "/node0", "bitcoin.conf"), 'a', encoding='utf8') as f:
	+ f.write(rpcauth + "\n")
	+ f.write(rpcauth2 + "\n")

	def setup_network(self):
	self.nodes = self.setup_nodes()

	def run_test(self):

	- ##################################################
	+ #
	# Check correctness of the rpcauth config option #
	- ##################################################
	+ #
	url = urllib.parse.urlparse(self.nodes[0].url)

	- #Old authpair
	+ # Old authpair
	authpair = url.username + ':' + url.password

	- #New authpair generated via share/rpcuser tool
	+ # New authpair generated via share/rpcuser tool
	rpcauth = "rpcauth=rt:93648e835a54c573682c2eb19f882535$7681e9c5b74bdd85e78166031d2058e1069b3ed7ed967c93fc63abba06f31144"
	password = "cA773lm788buwYe4g4WT+05pKyNruVKjQ25x3n0DQcM="

	- #Second authpair with different username
	+ # Second authpair with different username
	rpcauth2 = "rpcauth=rt2:f8607b1a88861fac29dfccf9b52ff9f$ff36a0c23c8c62b4846112e50fa888416e94c17bfd4c42f88fd8f55ec6a3137e"
	password2 = "8/F3uMDw4KSEbw96U3CA1C4X05dkHDN2BPFjTgZW4KI="
	- authpairnew = "rt:"+password
	+ authpairnew = "rt:" + password

	headers = {"Authorization": "Basic " + str_to_b64str(authpair)}

	@@ -58,63 +59,63 @@
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	resp = conn.getresponse()
	- assert_equal(resp.status==401, False)
	+ assert_equal(resp.status == 401, False)
	conn.close()
	-
	- #Use new authpair to confirm both work
	+
	+ # Use new authpair to confirm both work
	headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}

	conn = http.client.HTTPConnection(url.hostname, url.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	resp = conn.getresponse()
	- assert_equal(resp.status==401, False)
	+ assert_equal(resp.status == 401, False)
	conn.close()

	- #Wrong login name with rt's password
	- authpairnew = "rtwrong:"+password
	+ # Wrong login name with rt's password
	+ authpairnew = "rtwrong:" + password
	headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}

	conn = http.client.HTTPConnection(url.hostname, url.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	resp = conn.getresponse()
	- assert_equal(resp.status==401, True)
	+ assert_equal(resp.status == 401, True)
	conn.close()

	- #Wrong password for rt
	- authpairnew = "rt:"+password+"wrong"
	+ # Wrong password for rt
	+ authpairnew = "rt:" + password + "wrong"
	headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}

	conn = http.client.HTTPConnection(url.hostname, url.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	resp = conn.getresponse()
	- assert_equal(resp.status==401, True)
	+ assert_equal(resp.status == 401, True)
	conn.close()

	- #Correct for rt2
	- authpairnew = "rt2:"+password2
	+ # Correct for rt2
	+ authpairnew = "rt2:" + password2
	headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}

	conn = http.client.HTTPConnection(url.hostname, url.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	resp = conn.getresponse()
	- assert_equal(resp.status==401, False)
	+ assert_equal(resp.status == 401, False)
	conn.close()

	- #Wrong password for rt2
	- authpairnew = "rt2:"+password2+"wrong"
	+ # Wrong password for rt2
	+ authpairnew = "rt2:" + password2 + "wrong"
	headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}

	conn = http.client.HTTPConnection(url.hostname, url.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	resp = conn.getresponse()
	- assert_equal(resp.status==401, True)
	+ assert_equal(resp.status == 401, True)
	conn.close()


	if __name__ == '__main__':
	- HTTPBasicsTest ().main ()
	+ HTTPBasicsTest().main()
	diff --git a/qa/rpc-tests/nodehandling.py b/qa/rpc-tests/nodehandling.py
	--- a/qa/rpc-tests/nodehandling.py
	+++ b/qa/rpc-tests/nodehandling.py
	@@ -12,6 +12,7 @@

	import urllib.parse

	+
	class NodeHandlingTest (BitcoinTestFramework):

	def __init__(self):
	@@ -20,23 +21,29 @@
	self.setup_clean_chain = False

	def run_test(self):
	- ###########################
	+ #
	# setban/listbanned tests #
	- ###########################
	- assert_equal(len(self.nodes[2].getpeerinfo()), 4) #we should have 4 nodes at this point
	+ #
	+ assert_equal(len(self.nodes[2].getpeerinfo()), 4)
	+ # we should have 4 nodes at this point
	self.nodes[2].setban("127.0.0.1", "add")
	- time.sleep(3) #wait till the nodes are disconected
	- assert_equal(len(self.nodes[2].getpeerinfo()), 0) #all nodes must be disconnected at this point
	+ time.sleep(3) # wait till the nodes are disconected
	+ assert_equal(len(self.nodes[2].getpeerinfo()), 0)
	+ # all nodes must be disconnected at this point
	assert_equal(len(self.nodes[2].listbanned()), 1)
	self.nodes[2].clearbanned()
	assert_equal(len(self.nodes[2].listbanned()), 0)
	self.nodes[2].setban("127.0.0.0/24", "add")
	assert_equal(len(self.nodes[2].listbanned()), 1)
	try:
	- self.nodes[2].setban("127.0.0.1", "add") #throws exception because 127.0.0.1 is within range 127.0.0.0/24
	+ self.nodes[2].setban("127.0.0.1", "add")
	+ # throws exception because 127.0.0.1 is within
	+ # range 127.0.0.0/24
	except:
	pass
	- assert_equal(len(self.nodes[2].listbanned()), 1) #still only one banned ip because 127.0.0.1 is within the range of 127.0.0.0/24
	+ assert_equal(len(self.nodes[2].listbanned()), 1)
	+ # still only one banned ip because 127.0.0.1 is within the
	+ # range of 127.0.0.0/24
	try:
	self.nodes[2].setban("127.0.0.1", "remove")
	except:
	@@ -47,16 +54,18 @@
	self.nodes[2].clearbanned()
	assert_equal(len(self.nodes[2].listbanned()), 0)

	- ##test persisted banlist
	+ # test persisted banlist
	self.nodes[2].setban("127.0.0.0/32", "add")
	self.nodes[2].setban("127.0.0.0/24", "add")
	- self.nodes[2].setban("192.168.0.1", "add", 1) #ban for 1 seconds
	- self.nodes[2].setban("2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/19", "add", 1000) #ban for 1000 seconds
	+ self.nodes[2].setban("192.168.0.1", "add", 1) # ban for 1 seconds
	+ self.nodes[2].setban(
	+ "2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/19", "add", 1000) # ban for 1000 seconds
	listBeforeShutdown = self.nodes[2].listbanned()
	- assert_equal("192.168.0.1/32", listBeforeShutdown[2]['address']) #must be here
	- time.sleep(2) #make 100% sure we expired 192.168.0.1 node time
	+ assert_equal(
	+ "192.168.0.1/32", listBeforeShutdown[2]['address']) # must be here
	+ time.sleep(2) # make 100% sure we expired 192.168.0.1 node time

	- #stop node
	+ # stop node
	stop_node(self.nodes[2], 2)

	self.nodes[2] = start_node(2, self.options.tmpdir)
	@@ -65,21 +74,21 @@
	assert_equal("127.0.0.0/32", listAfterShutdown[1]['address'])
	assert_equal("/19" in listAfterShutdown[2]['address'], True)

	- ###########################
	+ #
	# RPC disconnectnode test #
	- ###########################
	+ #
	url = urllib.parse.urlparse(self.nodes[1].url)
	- self.nodes[0].disconnectnode(url.hostname+":"+str(p2p_port(1)))
	- time.sleep(2) #disconnecting a node needs a little bit of time
	+ self.nodes[0].disconnectnode(url.hostname + ":" + str(p2p_port(1)))
	+ time.sleep(2) # disconnecting a node needs a little bit of time
	for node in self.nodes[0].getpeerinfo():
	- assert(node['addr'] != url.hostname+":"+str(p2p_port(1)))
	+ assert(node['addr'] != url.hostname + ":" + str(p2p_port(1)))

	- connect_nodes_bi(self.nodes,0,1) #reconnect the node
	+ connect_nodes_bi(self.nodes, 0, 1) # reconnect the node
	found = False
	for node in self.nodes[0].getpeerinfo():
	- if node['addr'] == url.hostname+":"+str(p2p_port(1)):
	+ if node['addr'] == url.hostname + ":" + str(p2p_port(1)):
	found = True
	assert(found)

	if __name__ == '__main__':
	- NodeHandlingTest ().main ()
	+ NodeHandlingTest().main()
	diff --git a/qa/rpc-tests/p2p-compactblocks.py b/qa/rpc-tests/p2p-compactblocks.py
	--- a/qa/rpc-tests/p2p-compactblocks.py
	+++ b/qa/rpc-tests/p2p-compactblocks.py
	@@ -18,7 +18,10 @@
	'''

	# TestNode: A peer we use to send messages to bitcoind, and store responses.
	+
	+
	class TestNode(SingleNodeConnCB):
	+
	def __init__(self):
	SingleNodeConnCB.__init__(self)
	self.last_sendcmpct = []
	@@ -46,7 +49,8 @@
	self.last_cmpctblock = message
	self.block_announced = True
	self.last_cmpctblock.header_and_shortids.header.calc_sha256()
	- self.set_announced_blockhashes.add(self.last_cmpctblock.header_and_shortids.header.sha256)
	+ self.set_announced_blockhashes.add(
	+ self.last_cmpctblock.header_and_shortids.header.sha256)

	def on_headers(self, conn, message):
	self.last_headers = message
	@@ -110,7 +114,9 @@
	return (block_hash in self.set_announced_blockhashes)
	return wait_until(received_hash, timeout=timeout)

	+
	class CompactBlocksTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.setup_clean_chain = True
	@@ -121,16 +127,17 @@
	self.nodes = []

	# Start up two version 1 CB nodes.
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	- [["-debug", "-logtimemicros=1"],
	- ["-debug", "-logtimemicros", "-txindex"]])
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	+ [["-debug", "-logtimemicros=1"],
	+ ["-debug", "-logtimemicros", "-txindex"]])
	connect_nodes(self.nodes[0], 1)

	def build_block_on_tip(self, node):
	height = node.getblockcount()
	tip = node.getbestblockhash()
	mtp = node.getblockheader(tip)['mediantime']
	- block = create_block(int(tip, 16), create_coinbase(height + 1), mtp + 1)
	+ block = create_block(
	+ int(tip, 16), create_coinbase(height + 1), mtp + 1)
	block.nVersion = 4
	block.solve()
	return block
	@@ -178,7 +185,8 @@
	assert(got_message)
	with mininode_lock:
	# Check that the first version received is the preferred one
	- assert_equal(test_node.last_sendcmpct[0].version, preferred_version)
	+ assert_equal(
	+ test_node.last_sendcmpct[0].version, preferred_version)
	# And that we receive versions down to 1.
	assert_equal(test_node.last_sendcmpct[-1].version, 1)
	test_node.last_sendcmpct = []
	@@ -198,11 +206,13 @@
	block_hash, peer.last_cmpctblock, peer.last_inv))

	# We shouldn't get any block announcements via cmpctblock yet.
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is None)

	# Try one more time, this time after requesting headers.
	test_node.request_headers_and_sync(locator=[tip])
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is None and p.last_inv is not None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is None and p.last_inv is not None)

	# Test a few ways of using sendcmpct that should NOT
	# result in compact block announcements.
	@@ -211,10 +221,11 @@

	# Now try a SENDCMPCT message with too-high version
	sendcmpct = msg_sendcmpct()
	- sendcmpct.version = 999 # was: preferred_version+1
	+ sendcmpct.version = 999 # was: preferred_version+1
	sendcmpct.announce = True
	test_node.send_and_ping(sendcmpct)
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is None)

	# Headers sync before next test.
	test_node.request_headers_and_sync(locator=[tip])
	@@ -223,7 +234,8 @@
	sendcmpct.version = preferred_version
	sendcmpct.announce = False
	test_node.send_and_ping(sendcmpct)
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is None)

	# Headers sync before next test.
	test_node.request_headers_and_sync(locator=[tip])
	@@ -232,38 +244,45 @@
	sendcmpct.version = preferred_version
	sendcmpct.announce = True
	test_node.send_and_ping(sendcmpct)
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is not None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is not None)

	# Try one more time (no headers sync should be needed!)
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is not None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is not None)

	# Try one more time, after turning on sendheaders
	test_node.send_and_ping(msg_sendheaders())
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is not None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is not None)

	# Try one more time, after sending a version-1, announce=false message.
	- sendcmpct.version = preferred_version-1
	+ sendcmpct.version = preferred_version - 1
	sendcmpct.announce = False
	test_node.send_and_ping(sendcmpct)
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is not None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is not None)

	# Now turn off announcements
	sendcmpct.version = preferred_version
	sendcmpct.announce = False
	test_node.send_and_ping(sendcmpct)
	- check_announcement_of_new_block(node, test_node, lambda p: p.last_cmpctblock is None and p.last_headers is not None)
	+ check_announcement_of_new_block(
	+ node, test_node, lambda p: p.last_cmpctblock is None and p.last_headers is not None)

	if old_node is not None:
	# Verify that a peer using an older protocol version can receive
	# announcements from this node.
	- sendcmpct.version = 1 # preferred_version-1
	+ sendcmpct.version = 1 # preferred_version-1
	sendcmpct.announce = True
	old_node.send_and_ping(sendcmpct)
	# Header sync
	old_node.request_headers_and_sync(locator=[tip])
	- check_announcement_of_new_block(node, old_node, lambda p: p.last_cmpctblock is not None)
	+ check_announcement_of_new_block(
	+ node, old_node, lambda p: p.last_cmpctblock is not None)

	- # This test actually causes bitcoind to (reasonably!) disconnect us, so do this last.
	+ # This test actually causes bitcoind to (reasonably!) disconnect us, so do
	+ # this last.
	def test_invalid_cmpctblock_message(self):
	self.nodes[0].generate(101)
	block = self.build_block_on_tip(self.nodes[0])
	@@ -275,7 +294,8 @@
	prefilled_txn = PrefilledTransaction(1, block.vtx[0])
	cmpct_block.prefilled_txn = [prefilled_txn]
	self.test_node.send_and_ping(msg_cmpctblock(cmpct_block))
	- assert(int(self.nodes[0].getbestblockhash(), 16) == block.hashPrevBlock)
	+ assert(
	+ int(self.nodes[0].getbestblockhash(), 16) == block.hashPrevBlock)

	# Compare the generated shortids to what we expect based on BIP 152, given
	# bitcoind's choice of nonce.
	@@ -316,8 +336,10 @@
	with mininode_lock:
	assert(test_node.last_cmpctblock is not None)
	# Convert the on-the-wire representation to absolute indexes
	- header_and_shortids = HeaderAndShortIDs(test_node.last_cmpctblock.header_and_shortids)
	- self.check_compactblock_construction_from_block(header_and_shortids, block_hash, block)
	+ header_and_shortids = HeaderAndShortIDs(
	+ test_node.last_cmpctblock.header_and_shortids)
	+ self.check_compactblock_construction_from_block(
	+ header_and_shortids, block_hash, block)

	# Now fetch the compact block using a normal non-announce getdata
	with mininode_lock:
	@@ -333,8 +355,10 @@
	with mininode_lock:
	assert(test_node.last_cmpctblock is not None)
	# Convert the on-the-wire representation to absolute indexes
	- header_and_shortids = HeaderAndShortIDs(test_node.last_cmpctblock.header_and_shortids)
	- self.check_compactblock_construction_from_block(header_and_shortids, block_hash, block)
	+ header_and_shortids = HeaderAndShortIDs(
	+ test_node.last_cmpctblock.header_and_shortids)
	+ self.check_compactblock_construction_from_block(
	+ header_and_shortids, block_hash, block)

	def check_compactblock_construction_from_block(self, header_and_shortids, block_hash, block):
	# Check that we got the right block!
	@@ -358,7 +382,8 @@
	assert(entry.tx.wit.is_null())

	# Check that the cmpctblock message announced all the transactions.
	- assert_equal(len(header_and_shortids.prefilled_txn) + len(header_and_shortids.shortids), len(block.vtx))
	+ assert_equal(len(header_and_shortids.prefilled_txn)
	+ + len(header_and_shortids.shortids), len(block.vtx))

	# And now check that all the shortids are as expected as well.
	# Determine the siphash keys to use.
	@@ -390,12 +415,14 @@

	if announce == "inv":
	test_node.send_message(msg_inv([CInv(2, block.sha256)]))
	- success = wait_until(lambda: test_node.last_getheaders is not None, timeout=30)
	+ success = wait_until(
	+ lambda: test_node.last_getheaders is not None, timeout=30)
	assert(success)
	test_node.send_header_for_blocks([block])
	else:
	test_node.send_header_for_blocks([block])
	- success = wait_until(lambda: test_node.last_getdata is not None, timeout=30)
	+ success = wait_until(
	+ lambda: test_node.last_getdata is not None, timeout=30)
	assert(success)
	assert_equal(len(test_node.last_getdata.inv), 1)
	assert_equal(test_node.last_getdata.inv[0].type, 4)
	@@ -410,13 +437,14 @@
	if version == 2:
	coinbase_hash = block.vtx[0].calc_sha256(True)
	comp_block.shortids = [
	- calculate_shortid(k0, k1, coinbase_hash) ]
	+ calculate_shortid(k0, k1, coinbase_hash)]
	test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
	assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
	# Expect a getblocktxn message.
	with mininode_lock:
	assert(test_node.last_getblocktxn is not None)
	- absolute_indexes = test_node.last_getblocktxn.block_txn_request.to_absolute()
	+ absolute_indexes = test_node.last_getblocktxn.block_txn_request.to_absolute(
	+ )
	assert_equal(absolute_indexes, [0]) # should be a coinbase request

	# Send the coinbase, and verify that the tip advances.
	@@ -449,14 +477,15 @@
	# node needs, and that responding to them causes the block to be
	# reconstructed.
	def test_getblocktxn_requests(self, node, test_node, version):
	- with_witness = (version==2)
	+ with_witness = (version == 2)

	def test_getblocktxn_response(compact_block, peer, expected_result):
	msg = msg_cmpctblock(compact_block.to_p2p())
	peer.send_and_ping(msg)
	with mininode_lock:
	assert(peer.last_getblocktxn is not None)
	- absolute_indexes = peer.last_getblocktxn.block_txn_request.to_absolute()
	+ absolute_indexes = peer.last_getblocktxn.block_txn_request.to_absolute(
	+ )
	assert_equal(absolute_indexes, expected_result)

	def test_tip_after_message(node, peer, msg, tip):
	@@ -468,7 +497,8 @@
	utxo = self.utxos.pop(0)

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

	@@ -476,40 +506,48 @@

	msg_bt = msg_blocktxn()
	if with_witness:
	- msg_bt = msg_witness_blocktxn() # serialize with witnesses
	- msg_bt.block_transactions = BlockTransactions(block.sha256, block.vtx[1:])
	+ msg_bt = msg_witness_blocktxn() # serialize with witnesses
	+ msg_bt.block_transactions = BlockTransactions(
	+ block.sha256, block.vtx[1:])
	test_tip_after_message(node, test_node, msg_bt, block.sha256)

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

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

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

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

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

	# Now provide all transactions to the node before the block is
	# announced and verify reconstruction happens immediately.
	utxo = self.utxos.pop(0)
	block = self.build_block_with_transactions(node, utxo, 10)
	- self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
	+ self.utxos.append(
	+ [block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
	for tx in block.vtx[1:]:
	test_node.send_message(msg_tx(tx))
	test_node.sync_with_ping()
	@@ -523,8 +561,10 @@
	test_node.last_getblocktxn = None

	# Send compact block
	- comp_block.initialize_from_block(block, prefill_list=[0], use_witness=with_witness)
	- test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
	+ comp_block.initialize_from_block(
	+ block, prefill_list=[0], use_witness=with_witness)
	+ test_tip_after_message(
	+ node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
	with mininode_lock:
	# Shouldn't have gotten a request for any transaction
	assert(test_node.last_getblocktxn is None)
	@@ -537,7 +577,8 @@
	utxo = self.utxos.pop(0)

	block = self.build_block_with_transactions(node, utxo, 10)
	- self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
	+ self.utxos.append(
	+ [block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
	# Relay the first 5 transactions from the block in advance
	for tx in block.vtx[1:6]:
	test_node.send_message(msg_tx(tx))
	@@ -549,12 +590,14 @@

	# Send compact block
	comp_block = HeaderAndShortIDs()
	- comp_block.initialize_from_block(block, prefill_list=[0], use_witness=(version == 2))
	+ comp_block.initialize_from_block(
	+ block, prefill_list=[0], use_witness=(version == 2))
	test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
	absolute_indexes = []
	with mininode_lock:
	assert(test_node.last_getblocktxn is not None)
	- absolute_indexes = test_node.last_getblocktxn.block_txn_request.to_absolute()
	+ absolute_indexes = test_node.last_getblocktxn.block_txn_request.to_absolute(
	+ )
	assert_equal(absolute_indexes, [6, 7, 8, 9, 10])

	# Now give an incorrect response.
	@@ -566,23 +609,26 @@
	# verifying that the block isn't marked bad permanently. This is good
	# enough for now.
	msg = msg_blocktxn()
	- if version==2:
	+ if version == 2:
	msg = msg_witness_blocktxn()
	- msg.block_transactions = BlockTransactions(block.sha256, [block.vtx[5]] + block.vtx[7:])
	+ msg.block_transactions = BlockTransactions(
	+ block.sha256, [block.vtx[5]] + block.vtx[7:])
	test_node.send_and_ping(msg)

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

	# We should receive a getdata request
	- success = wait_until(lambda: test_node.last_getdata is not None, timeout=10)
	+ success = wait_until(
	+ lambda: test_node.last_getdata is not None, timeout=10)
	assert(success)
	assert_equal(len(test_node.last_getdata.inv), 1)
	- assert(test_node.last_getdata.inv[0].type == 2 or test_node.last_getdata.inv[0].type == 2\|MSG_WITNESS_FLAG)
	+ assert(test_node.last_getdata.inv[
	+ 0].type == 2 or test_node.last_getdata.inv[0].type == 2 \| MSG_WITNESS_FLAG)
	assert_equal(test_node.last_getdata.inv[0].hash, block.sha256)

	# Deliver the block
	- if version==2:
	+ if version == 2:
	test_node.send_and_ping(msg_witness_block(block))
	else:
	test_node.send_and_ping(msg_block(block))
	@@ -599,19 +645,24 @@
	block = FromHex(CBlock(), node.getblock(block_hash, False))

	msg = msg_getblocktxn()
	- msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [])
	+ msg.block_txn_request = BlockTransactionsRequest(
	+ int(block_hash, 16), [])
	num_to_request = random.randint(1, len(block.vtx))
	- msg.block_txn_request.from_absolute(sorted(random.sample(range(len(block.vtx)), num_to_request)))
	+ msg.block_txn_request.from_absolute(
	+ sorted(random.sample(range(len(block.vtx)), num_to_request)))
	test_node.send_message(msg)
	- success = wait_until(lambda: test_node.last_blocktxn is not None, timeout=10)
	+ success = wait_until(
	+ lambda: test_node.last_blocktxn is not None, timeout=10)
	assert(success)

	[tx.calc_sha256() for tx in block.vtx]
	with mininode_lock:
	- assert_equal(test_node.last_blocktxn.block_transactions.blockhash, int(block_hash, 16))
	+ assert_equal(
	+ test_node.last_blocktxn.block_transactions.blockhash, int(block_hash, 16))
	all_indices = msg.block_txn_request.to_absolute()
	for index in all_indices:
	- tx = test_node.last_blocktxn.block_transactions.transactions.pop(0)
	+ tx = test_node.last_blocktxn.block_transactions.transactions.pop(
	+ 0)
	tx.calc_sha256()
	assert_equal(tx.sha256, block.vtx[index].sha256)
	if version == 1:
	@@ -619,21 +670,24 @@
	assert(tx.wit.is_null())
	else:
	# Check that the witness matches
	- assert_equal(tx.calc_sha256(True), block.vtx[index].calc_sha256(True))
	+ assert_equal(
	+ tx.calc_sha256(True), block.vtx[index].calc_sha256(True))
	test_node.last_blocktxn = None
	current_height -= 1

	# Next request should send a full block response, as we're past the
	# allowed depth for a blocktxn response.
	block_hash = node.getblockhash(current_height)
	- msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [0])
	+ msg.block_txn_request = BlockTransactionsRequest(
	+ int(block_hash, 16), [0])
	with mininode_lock:
	test_node.last_block = None
	test_node.last_blocktxn = None
	test_node.send_and_ping(msg)
	with mininode_lock:
	test_node.last_block.block.calc_sha256()
	- assert_equal(test_node.last_block.block.sha256, int(block_hash, 16))
	+ assert_equal(
	+ test_node.last_block.block.sha256, int(block_hash, 16))
	assert_equal(test_node.last_blocktxn, None)

	def test_compactblocks_not_at_tip(self, node, test_node):
	@@ -647,7 +701,8 @@

	test_node.clear_block_announcement()
	test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
	- success = wait_until(lambda: test_node.last_cmpctblock is not None, timeout=30)
	+ success = wait_until(
	+ lambda: test_node.last_cmpctblock is not None, timeout=30)
	assert(success)

	test_node.clear_block_announcement()
	@@ -657,15 +712,17 @@
	with mininode_lock:
	test_node.last_block = None
	test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
	- success = wait_until(lambda: test_node.last_block is not None, timeout=30)
	+ success = wait_until(
	+ lambda: test_node.last_block is not None, timeout=30)
	assert(success)
	with mininode_lock:
	test_node.last_block.block.calc_sha256()
	- assert_equal(test_node.last_block.block.sha256, int(new_blocks[0], 16))
	+ assert_equal(
	+ test_node.last_block.block.sha256, int(new_blocks[0], 16))

	# Generate an old compactblock, and verify that it's not accepted.
	cur_height = node.getblockcount()
	- hashPrevBlock = int(node.getblockhash(cur_height-5), 16)
	+ hashPrevBlock = int(node.getblockhash(cur_height - 5), 16)
	block = self.build_block_on_tip(node)
	block.hashPrevBlock = hashPrevBlock
	block.solve()
	@@ -708,7 +765,8 @@
	for l in listeners:
	assert(l.last_cmpctblock is not None)
	l.last_cmpctblock.header_and_shortids.header.calc_sha256()
	- assert_equal(l.last_cmpctblock.header_and_shortids.header.sha256, block.sha256)
	+ assert_equal(
	+ l.last_cmpctblock.header_and_shortids.header.sha256, block.sha256)

	# Test that we don't get disconnected if we relay a compact block with valid header,
	# but invalid transactions.
	@@ -724,7 +782,8 @@
	# Now send the compact block with all transactions prefilled, and
	# verify that we don't get disconnected.
	comp_block = HeaderAndShortIDs()
	- comp_block.initialize_from_block(block, prefill_list=[0, 1, 2, 3, 4], use_witness=False)
	+ comp_block.initialize_from_block(
	+ block, prefill_list=[0, 1, 2, 3, 4], use_witness=False)
	msg = msg_cmpctblock(comp_block.to_p2p())
	test_node.send_and_ping(msg)

	@@ -770,7 +829,8 @@
	delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
	assert_equal(int(node.getbestblockhash(), 16), block.sha256)

	- self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
	+ self.utxos.append(
	+ [block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])

	# Now test that delivering an invalid compact block won't break relay

	@@ -779,8 +839,9 @@
	delivery_peer.send_message(msg_tx(tx))
	delivery_peer.sync_with_ping()

	- cmpct_block.prefilled_txn[0].tx.wit.vtxinwit = [ CTxInWitness() ]
	- cmpct_block.prefilled_txn[0].tx.wit.vtxinwit[0].scriptWitness.stack = [ser_uint256(0)]
	+ cmpct_block.prefilled_txn[0].tx.wit.vtxinwit = [CTxInWitness()]
	+ cmpct_block.prefilled_txn[0].tx.wit.vtxinwit[
	+ 0].scriptWitness.stack = [ser_uint256(0)]

	cmpct_block.use_witness = True
	delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
	@@ -799,11 +860,12 @@
	self.old_node = TestNode() # version 1 peer

	connections = []
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.test_node))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.test_node))
	connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1],
	- self.ex_softfork_node, services=NODE_NETWORK))
	+ self.ex_softfork_node, services=NODE_NETWORK))
	connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1],
	- self.old_node, services=NODE_NETWORK))
	+ self.old_node, services=NODE_NETWORK))
	self.test_node.add_connection(connections[0])
	self.ex_softfork_node.add_connection(connections[1])
	self.old_node.add_connection(connections[2])
	@@ -821,19 +883,22 @@
	print("\tTesting SENDCMPCT p2p message... ")
	self.test_sendcmpct(self.nodes[0], self.test_node, 1)
	sync_blocks(self.nodes)
	- self.test_sendcmpct(self.nodes[1], self.ex_softfork_node, 1, old_node=self.old_node)
	+ self.test_sendcmpct(
	+ self.nodes[1], self.ex_softfork_node, 1, old_node=self.old_node)
	sync_blocks(self.nodes)

	print("\tTesting compactblock construction...")
	self.test_compactblock_construction(self.nodes[0], self.test_node)
	sync_blocks(self.nodes)
	- self.test_compactblock_construction(self.nodes[1], self.ex_softfork_node)
	+ self.test_compactblock_construction(
	+ self.nodes[1], self.ex_softfork_node)
	sync_blocks(self.nodes)

	print("\tTesting compactblock requests... ")
	self.test_compactblock_requests(self.nodes[0], self.test_node, 1)
	sync_blocks(self.nodes)
	- self.test_compactblock_requests(self.nodes[1], self.ex_softfork_node, 2)
	+ self.test_compactblock_requests(
	+ self.nodes[1], self.ex_softfork_node, 2)
	sync_blocks(self.nodes)

	print("\tTesting getblocktxn requests...")
	@@ -849,34 +914,42 @@
	self.test_getblocktxn_handler(self.nodes[1], self.old_node, 1)
	sync_blocks(self.nodes)

	- print("\tTesting compactblock requests/announcements not at chain tip...")
	+ print(
	+ "\tTesting compactblock requests/announcements not at chain tip...")
	self.test_compactblocks_not_at_tip(self.nodes[0], self.test_node)
	sync_blocks(self.nodes)
	- self.test_compactblocks_not_at_tip(self.nodes[1], self.ex_softfork_node)
	+ self.test_compactblocks_not_at_tip(
	+ self.nodes[1], self.ex_softfork_node)
	self.test_compactblocks_not_at_tip(self.nodes[1], self.old_node)
	sync_blocks(self.nodes)

	print("\tTesting handling of incorrect blocktxn responses...")
	self.test_incorrect_blocktxn_response(self.nodes[0], self.test_node, 1)
	sync_blocks(self.nodes)
	- self.test_incorrect_blocktxn_response(self.nodes[1], self.ex_softfork_node, 2)
	+ self.test_incorrect_blocktxn_response(
	+ self.nodes[1], self.ex_softfork_node, 2)
	sync_blocks(self.nodes)

	# End-to-end block relay tests
	print("\tTesting end-to-end block relay...")
	self.request_cb_announcements(self.test_node, self.nodes[0])
	self.request_cb_announcements(self.old_node, self.nodes[1])
	- self.request_cb_announcements(self.ex_softfork_node, self.nodes[1], version=2)
	- self.test_end_to_end_block_relay(self.nodes[0], [self.ex_softfork_node, self.test_node, self.old_node])
	- self.test_end_to_end_block_relay(self.nodes[1], [self.ex_softfork_node, self.test_node, self.old_node])
	+ self.request_cb_announcements(
	+ self.ex_softfork_node, self.nodes[1], version=2)
	+ self.test_end_to_end_block_relay(
	+ self.nodes[0], [self.ex_softfork_node, self.test_node, self.old_node])
	+ self.test_end_to_end_block_relay(
	+ self.nodes[1], [self.ex_softfork_node, self.test_node, self.old_node])

	print("\tTesting handling of invalid compact blocks...")
	self.test_invalid_tx_in_compactblock(self.nodes[0], self.test_node)
	- self.test_invalid_tx_in_compactblock(self.nodes[1], self.ex_softfork_node)
	+ self.test_invalid_tx_in_compactblock(
	+ self.nodes[1], self.ex_softfork_node)
	self.test_invalid_tx_in_compactblock(self.nodes[1], self.old_node)

	print("\tTesting reconstructing compact blocks from all peers...")
	- self.test_compactblock_reconstruction_multiple_peers(self.nodes[1], self.ex_softfork_node, self.old_node)
	+ self.test_compactblock_reconstruction_multiple_peers(
	+ self.nodes[1], self.ex_softfork_node, self.old_node)
	sync_blocks(self.nodes)

	print("\tTesting invalid index in cmpctblock message...")
	diff --git a/qa/rpc-tests/p2p-leaktests.py b/qa/rpc-tests/p2p-leaktests.py
	--- a/qa/rpc-tests/p2p-leaktests.py
	+++ b/qa/rpc-tests/p2p-leaktests.py
	@@ -19,7 +19,9 @@

	banscore = 10

	+
	class CLazyNode(NodeConnCB):
	+
	def __init__(self):
	self.connection = None
	self.unexpected_msg = False
	@@ -40,36 +42,61 @@
	self.connected = True

	def on_version(self, conn, message): self.bad_message(message)
	+
	def on_verack(self, conn, message): self.bad_message(message)
	+
	def on_reject(self, conn, message): self.bad_message(message)
	+
	def on_inv(self, conn, message): self.bad_message(message)
	+
	def on_addr(self, conn, message): self.bad_message(message)
	+
	def on_alert(self, conn, message): self.bad_message(message)
	+
	def on_getdata(self, conn, message): self.bad_message(message)
	+
	def on_getblocks(self, conn, message): self.bad_message(message)
	+
	def on_tx(self, conn, message): self.bad_message(message)
	+
	def on_block(self, conn, message): self.bad_message(message)
	+
	def on_getaddr(self, conn, message): self.bad_message(message)
	+
	def on_headers(self, conn, message): self.bad_message(message)
	+
	def on_getheaders(self, conn, message): self.bad_message(message)
	+
	def on_ping(self, conn, message): self.bad_message(message)
	+
	def on_mempool(self, conn): self.bad_message(message)
	+
	def on_pong(self, conn, message): self.bad_message(message)
	+
	def on_feefilter(self, conn, message): self.bad_message(message)
	+
	def on_sendheaders(self, conn, message): self.bad_message(message)
	+
	def on_sendcmpct(self, conn, message): self.bad_message(message)
	+
	def on_cmpctblock(self, conn, message): self.bad_message(message)
	+
	def on_getblocktxn(self, conn, message): self.bad_message(message)
	+
	def on_blocktxn(self, conn, 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):
	+
	def __init__(self):
	super().__init__()

	# 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
	+ # NOTE: implementation-specific check here. Remove if bitcoind ban
	+ # behavior changes
	def on_open(self, conn):
	super().on_open(conn)
	for i in range(banscore):
	@@ -79,34 +106,46 @@

	# 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, conn, message): pass
	+
	def on_verack(self, conn, 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, conn, message):
	self.version_received = True
	conn.send_message(msg_ping())
	conn.send_message(msg_getaddr())

	+
	class P2PLeakTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.num_nodes = 1
	+
	def setup_network(self):
	- extra_args = [['-debug', '-banscore='+str(banscore)]
	+ extra_args = [['-debug', '-banscore=' + str(banscore)]
	for i in range(self.num_nodes)]
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, extra_args)

	def run_test(self):
	no_version_bannode = CNodeNoVersionBan()
	@@ -114,24 +153,28 @@
	no_verack_idlenode = CNodeNoVerackIdle()

	connections = []
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_bannode, send_version=False))
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_idlenode, send_version=False))
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_verack_idlenode))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_bannode, send_version=False))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_idlenode, send_version=False))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_verack_idlenode))
	no_version_bannode.add_connection(connections[0])
	no_version_idlenode.add_connection(connections[1])
	no_verack_idlenode.add_connection(connections[2])

	NetworkThread().start() # Start up network handling in another thread

	- assert(wait_until(lambda: no_version_bannode.connected and no_version_idlenode.connected and no_verack_idlenode.version_received, timeout=10))
	+ assert(
	+ wait_until(lambda: no_version_bannode.connected and no_version_idlenode.connected and no_verack_idlenode.version_received, timeout=10))

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

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

	- #This node should have been banned
	+ # This node should have been banned
	assert(no_version_bannode.connection.state == "closed")

	[conn.disconnect_node() for conn in connections]
	diff --git a/qa/rpc-tests/p2p-mempool.py b/qa/rpc-tests/p2p-mempool.py
	--- a/qa/rpc-tests/p2p-mempool.py
	+++ b/qa/rpc-tests/p2p-mempool.py
	@@ -7,7 +7,9 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class TestNode(NodeConnCB):
	+
	def __init__(self):
	NodeConnCB.__init__(self)
	self.connection = None
	@@ -70,6 +72,7 @@
	self.lastInv = []
	self.send_message(msg_mempool())

	+
	class P2PMempoolTests(BitcoinTestFramework):

	def __init__(self):
	@@ -80,22 +83,23 @@
	def setup_network(self):
	# Start a node with maxuploadtarget of 200 MB (/24h)
	self.nodes = []
	- self.nodes.append(start_node(0, self.options.tmpdir, ["-debug", "-peerbloomfilters=0"]))
	+ self.nodes.append(
	+ start_node(0, self.options.tmpdir, ["-debug", "-peerbloomfilters=0"]))

	def run_test(self):
	- #connect a mininode
	+ # connect a mininode
	aTestNode = TestNode()
	node = NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], aTestNode)
	aTestNode.add_connection(node)
	NetworkThread().start()
	aTestNode.wait_for_verack()

	- #request mempool
	+ # request mempool
	aTestNode.send_mempool()
	aTestNode.wait_for_disconnect()

	- #mininode must be disconnected at this point
	+ # mininode must be disconnected at this point
	assert_equal(len(self.nodes[0].getpeerinfo()), 0)
	-
	+
	if __name__ == '__main__':
	P2PMempoolTests().main()
	diff --git a/qa/rpc-tests/p2p-timeouts.py b/qa/rpc-tests/p2p-timeouts.py
	--- a/qa/rpc-tests/p2p-timeouts.py
	+++ b/qa/rpc-tests/p2p-timeouts.py
	@@ -27,7 +27,9 @@
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	+
	class TestNode(SingleNodeConnCB):
	+
	def __init__(self):
	SingleNodeConnCB.__init__(self)
	self.connected = False
	@@ -43,7 +45,9 @@
	# Don't send a verack in response
	self.received_version = True

	+
	class TimeoutsTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.setup_clean_chain = True
	@@ -53,19 +57,22 @@
	self.nodes = []

	# Start up node0 to be a version 1, pre-segwit node.
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	- [["-debug", "-logtimemicros=1"]])
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	+ [["-debug", "-logtimemicros=1"]])

	def run_test(self):
	# Setup the p2p connections and start up the network thread.
	- self.no_verack_node = TestNode() # never send verack
	- self.no_version_node = TestNode() # never send version (just ping)
	- self.no_send_node = TestNode() # never send anything
	+ self.no_verack_node = TestNode() # never send verack
	+ self.no_version_node = TestNode() # never send version (just ping)
	+ self.no_send_node = TestNode() # never send anything

	connections = []
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_verack_node))
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_version_node, send_version=False))
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_send_node, send_version=False))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_verack_node))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_version_node, send_version=False))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_send_node, send_version=False))
	self.no_verack_node.add_connection(connections[0])
	self.no_version_node.add_connection(connections[1])
	self.no_send_node.add_connection(connections[2])
	diff --git a/qa/rpc-tests/p2p-versionbits-warning.py b/qa/rpc-tests/p2p-versionbits-warning.py
	--- a/qa/rpc-tests/p2p-versionbits-warning.py
	+++ b/qa/rpc-tests/p2p-versionbits-warning.py
	@@ -17,18 +17,22 @@
	soft-forks, and test that warning alerts are generated.
	'''

	-VB_PERIOD = 144 # versionbits period length for regtest
	-VB_THRESHOLD = 108 # versionbits activation threshold for regtest
	+VB_PERIOD = 144 # versionbits period length for regtest
	+VB_THRESHOLD = 108 # versionbits activation threshold for regtest
	VB_TOP_BITS = 0x20000000
	-VB_UNKNOWN_BIT = 27 # Choose a bit unassigned to any deployment
	+VB_UNKNOWN_BIT = 27 # Choose a bit unassigned to any deployment

	WARN_UNKNOWN_RULES_MINED = "Unknown block versions being mined! It's possible unknown rules are in effect"
	-WARN_UNKNOWN_RULES_ACTIVE = "unknown new rules activated (versionbit {})".format(VB_UNKNOWN_BIT)
	+WARN_UNKNOWN_RULES_ACTIVE = "unknown new rules activated (versionbit {})".format(
	+ VB_UNKNOWN_BIT)
	VB_PATTERN = re.compile("^Warning.*versionbit")

	# TestNode: bare-bones "peer". Used mostly as a conduit for a test to sending
	# p2p messages to a node, generating the messages in the main testing logic.
	+
	+
	class TestNode(NodeConnCB):
	+
	def __init__(self):
	NodeConnCB.__init__(self)
	self.connection = None
	@@ -64,6 +68,7 @@


	class VersionBitsWarningTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.setup_clean_chain = True
	@@ -74,18 +79,20 @@
	# Open and close to create zero-length file
	with open(self.alert_filename, 'w', encoding='utf8') as _:
	pass
	- self.extra_args = [["-debug", "-logtimemicros=1", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]]
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args)
	+ self.extra_args = [
	+ ["-debug", "-logtimemicros=1", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]]
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, self.extra_args)

	# Send numblocks blocks via peer with nVersionToUse set.
	def send_blocks_with_version(self, peer, numblocks, nVersionToUse):
	tip = self.nodes[0].getbestblockhash()
	height = self.nodes[0].getblockcount()
	- block_time = self.nodes[0].getblockheader(tip)["time"]+1
	+ block_time = self.nodes[0].getblockheader(tip)["time"] + 1
	tip = int(tip, 16)

	for _ in range(numblocks):
	- block = create_block(tip, create_coinbase(height+1), block_time)
	+ block = create_block(tip, create_coinbase(height + 1), block_time)
	block.nVersion = nVersionToUse
	block.solve()
	peer.send_message(msg_block(block))
	@@ -104,10 +111,11 @@
	test_node = TestNode()

	connections = []
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node))
	test_node.add_connection(connections[0])

	- NetworkThread().start() # Start up network handling in another thread
	+ NetworkThread().start() # Start up network handling in another thread

	# Test logic begins here
	test_node.wait_for_verack()
	@@ -117,8 +125,8 @@

	# 2. Now build one period of blocks on the tip, with < VB_THRESHOLD
	# blocks signaling some unknown bit.
	- nVersion = VB_TOP_BITS \| (1<<VB_UNKNOWN_BIT)
	- self.send_blocks_with_version(test_node, VB_THRESHOLD-1, nVersion)
	+ nVersion = VB_TOP_BITS \| (1 << VB_UNKNOWN_BIT)
	+ self.send_blocks_with_version(test_node, VB_THRESHOLD - 1, nVersion)

	# Fill rest of period with regular version blocks
	self.nodes[0].generate(VB_PERIOD - VB_THRESHOLD + 1)
	@@ -126,7 +134,8 @@
	# get*info()
	assert(not VB_PATTERN.match(self.nodes[0].getinfo()["errors"]))
	assert(not VB_PATTERN.match(self.nodes[0].getmininginfo()["errors"]))
	- assert(not VB_PATTERN.match(self.nodes[0].getnetworkinfo()["warnings"]))
	+ assert(not VB_PATTERN.match(
	+ self.nodes[0].getnetworkinfo()["warnings"]))

	# 3. Now build one period of blocks with >= VB_THRESHOLD blocks signaling
	# some unknown bit
	@@ -137,8 +146,10 @@
	# being of unexpected version.
	# Check that get*info() shows some kind of error.
	assert(WARN_UNKNOWN_RULES_MINED in self.nodes[0].getinfo()["errors"])
	- assert(WARN_UNKNOWN_RULES_MINED in self.nodes[0].getmininginfo()["errors"])
	- assert(WARN_UNKNOWN_RULES_MINED in self.nodes[0].getnetworkinfo()["warnings"])
	+ assert(WARN_UNKNOWN_RULES_MINED in self.nodes[
	+ 0].getmininginfo()["errors"])
	+ assert(WARN_UNKNOWN_RULES_MINED in self.nodes[
	+ 0].getnetworkinfo()["warnings"])

	# Mine a period worth of expected blocks so the generic block-version warning
	# is cleared, and restart the node. This should move the versionbit state
	@@ -148,18 +159,22 @@
	# Empty out the alert file
	with open(self.alert_filename, 'w', encoding='utf8') as _:
	pass
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, self.extra_args)

	# Connecting one block should be enough to generate an error.
	self.nodes[0].generate(1)
	assert(WARN_UNKNOWN_RULES_ACTIVE in self.nodes[0].getinfo()["errors"])
	- assert(WARN_UNKNOWN_RULES_ACTIVE in self.nodes[0].getmininginfo()["errors"])
	- assert(WARN_UNKNOWN_RULES_ACTIVE in self.nodes[0].getnetworkinfo()["warnings"])
	+ assert(WARN_UNKNOWN_RULES_ACTIVE in self.nodes[
	+ 0].getmininginfo()["errors"])
	+ assert(WARN_UNKNOWN_RULES_ACTIVE in self.nodes[
	+ 0].getnetworkinfo()["warnings"])
	stop_nodes(self.nodes)
	self.test_versionbits_in_alert_file()

	# Test framework expects the node to still be running...
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, self.extra_args)

	if __name__ == '__main__':
	VersionBitsWarningTest().main()
	diff --git a/qa/rpc-tests/preciousblock.py b/qa/rpc-tests/preciousblock.py
	--- a/qa/rpc-tests/preciousblock.py
	+++ b/qa/rpc-tests/preciousblock.py
	@@ -15,6 +15,7 @@
	sync_blocks,
	)

	+
	def unidirectional_node_sync_via_rpc(node_src, node_dest):
	blocks_to_copy = []
	blockhash = node_src.getbestblockhash()
	@@ -24,12 +25,14 @@
	break
	except:
	blocks_to_copy.append(blockhash)
	- blockhash = node_src.getblockheader(blockhash, True)['previousblockhash']
	+ blockhash = node_src.getblockheader(
	+ blockhash, True)['previousblockhash']
	blocks_to_copy.reverse()
	for blockhash in blocks_to_copy:
	blockdata = node_src.getblock(blockhash, False)
	assert(node_dest.submitblock(blockdata) in (None, 'inconclusive'))

	+
	def node_sync_via_rpc(nodes):
	for node_src in nodes:
	for node_dest in nodes:
	@@ -37,7 +40,9 @@
	continue
	unidirectional_node_sync_via_rpc(node_src, node_dest)

	+
	class PreciousTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.setup_clean_chain = True
	@@ -64,9 +69,10 @@
	assert_equal(self.nodes[1].getblockcount(), 5)
	assert(hashC != hashG)
	print("Connect nodes and check no reorg occurs")
	- # Submit competing blocks via RPC so any reorg should occur before we proceed (no way to wait on inaction for p2p sync)
	+ # Submit competing blocks via RPC so any reorg should occur before we
	+ # proceed (no way to wait on inaction for p2p sync)
	node_sync_via_rpc(self.nodes[0:2])
	- connect_nodes_bi(self.nodes,0,1)
	+ connect_nodes_bi(self.nodes, 0, 1)
	assert_equal(self.nodes[0].getbestblockhash(), hashC)
	assert_equal(self.nodes[1].getbestblockhash(), hashG)
	print("Make Node0 prefer block G")
	@@ -77,7 +83,8 @@
	assert_equal(self.nodes[0].getbestblockhash(), hashC)
	print("Make Node1 prefer block C")
	self.nodes[1].preciousblock(hashC)
	- sync_chain(self.nodes[0:2]) # wait because node 1 may not have downloaded hashC
	+ sync_chain(self.nodes[0:2])
	+ # wait because node 1 may not have downloaded hashC
	assert_equal(self.nodes[1].getbestblockhash(), hashC)
	print("Make Node1 prefer block G again")
	self.nodes[1].preciousblock(hashG)
	@@ -103,8 +110,8 @@
	hashL = self.nodes[2].getbestblockhash()
	print("Connect nodes and check no reorg occurs")
	node_sync_via_rpc(self.nodes[1:3])
	- connect_nodes_bi(self.nodes,1,2)
	- connect_nodes_bi(self.nodes,0,2)
	+ connect_nodes_bi(self.nodes, 1, 2)
	+ connect_nodes_bi(self.nodes, 0, 2)
	assert_equal(self.nodes[0].getbestblockhash(), hashH)
	assert_equal(self.nodes[1].getbestblockhash(), hashH)
	assert_equal(self.nodes[2].getbestblockhash(), hashL)
	diff --git a/qa/rpc-tests/proxy_test.py b/qa/rpc-tests/proxy_test.py
	--- a/qa/rpc-tests/proxy_test.py
	+++ b/qa/rpc-tests/proxy_test.py
	@@ -43,6 +43,7 @@


	class ProxyTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.num_nodes = 4
	@@ -57,14 +58,16 @@
	self.conf1.auth = False
	# ... one supporting authenticated and unauthenticated (Tor)
	self.conf2 = Socks5Configuration()
	- self.conf2.addr = ('127.0.0.1', RANGE_BEGIN + 1000 + (os.getpid() % 1000))
	+ self.conf2.addr = (
	+ '127.0.0.1', RANGE_BEGIN + 1000 + (os.getpid() % 1000))
	self.conf2.unauth = True
	self.conf2.auth = True
	if self.have_ipv6:
	# ... one on IPv6 with similar configuration
	self.conf3 = Socks5Configuration()
	self.conf3.af = socket.AF_INET6
	- self.conf3.addr = ('::1', RANGE_BEGIN + 2000 + (os.getpid() % 1000))
	+ self.conf3.addr = (
	+ '::1', RANGE_BEGIN + 2000 + (os.getpid() % 1000))
	self.conf3.unauth = True
	self.conf3.auth = True
	else:
	@@ -80,15 +83,20 @@

	def setup_nodes(self):
	# Note: proxies are not used to connect to local nodes
	- # this is because the proxy to use is based on CService.GetNetwork(), which return NET_UNROUTABLE for localhost
	+ # this is because the proxy to use is based on CService.GetNetwork(),
	+ # which return NET_UNROUTABLE for localhost
	args = [
	- ['-listen', '-debug=net', '-debug=proxy', '-proxy=%s:%i' % (self.conf1.addr),'-proxyrandomize=1'],
	- ['-listen', '-debug=net', '-debug=proxy', '-proxy=%s:%i' % (self.conf1.addr),'-onion=%s:%i' % (self.conf2.addr),'-proxyrandomize=0'],
	- ['-listen', '-debug=net', '-debug=proxy', '-proxy=%s:%i' % (self.conf2.addr),'-proxyrandomize=1'],
	+ ['-listen', '-debug=net', '-debug=proxy', '-proxy=%s:%i' %
	+ (self.conf1.addr), '-proxyrandomize=1'],
	+ ['-listen', '-debug=net', '-debug=proxy', '-proxy=%s:%i' %
	+ (self.conf1.addr), '-onion=%s:%i' % (self.conf2.addr), '-proxyrandomize=0'],
	+ ['-listen', '-debug=net', '-debug=proxy', '-proxy=%s:%i' %
	+ (self.conf2.addr), '-proxyrandomize=1'],
	[]
	- ]
	+ ]
	if self.have_ipv6:
	- args[3] = ['-listen', '-debug=net', '-debug=proxy', '-proxy=[%s]:%i' % (self.conf3.addr),'-proxyrandomize=0', '-noonion']
	+ args[3] = ['-listen', '-debug=net', '-debug=proxy', '-proxy=[%s]:%i' %
	+ (self.conf3.addr), '-proxyrandomize=0', '-noonion']
	return start_nodes(self.num_nodes, self.options.tmpdir, extra_args=args)

	def node_test(self, node, proxies, auth, test_onion=True):
	@@ -97,7 +105,8 @@
	node.addnode("15.61.23.23:1234", "onetry")
	cmd = proxies[0].queue.get()
	assert(isinstance(cmd, Socks5Command))
	- # Note: bitcoind's SOCKS5 implementation only sends atyp DOMAINNAME, even if connecting directly to IPv4/IPv6
	+ # Note: bitcoind's SOCKS5 implementation only sends atyp DOMAINNAME,
	+ # even if connecting directly to IPv4/IPv6
	assert_equal(cmd.atyp, AddressType.DOMAINNAME)
	assert_equal(cmd.addr, b"15.61.23.23")
	assert_equal(cmd.port, 1234)
	@@ -108,10 +117,12 @@

	if self.have_ipv6:
	# Test: outgoing IPv6 connection through node
	- node.addnode("[1233:3432:2434:2343:3234:2345:6546:4534]:5443", "onetry")
	+ node.addnode(
	+ "[1233:3432:2434:2343:3234:2345:6546:4534]:5443", "onetry")
	cmd = proxies[1].queue.get()
	assert(isinstance(cmd, Socks5Command))
	- # Note: bitcoind's SOCKS5 implementation only sends atyp DOMAINNAME, even if connecting directly to IPv4/IPv6
	+ # Note: bitcoind's SOCKS5 implementation only sends atyp
	+ # DOMAINNAME, even if connecting directly to IPv4/IPv6
	assert_equal(cmd.atyp, AddressType.DOMAINNAME)
	assert_equal(cmd.addr, b"1233:3432:2434:2343:3234:2345:6546:4534")
	assert_equal(cmd.port, 5443)
	@@ -149,20 +160,25 @@

	def run_test(self):
	# basic -proxy
	- self.node_test(self.nodes[0], [self.serv1, self.serv1, self.serv1, self.serv1], False)
	+ self.node_test(
	+ self.nodes[0], [self.serv1, self.serv1, self.serv1, self.serv1], False)

	# -proxy plus -onion
	- self.node_test(self.nodes[1], [self.serv1, self.serv1, self.serv2, self.serv1], False)
	+ self.node_test(
	+ self.nodes[1], [self.serv1, self.serv1, self.serv2, self.serv1], False)

	# -proxy plus -onion, -proxyrandomize
	- rv = self.node_test(self.nodes[2], [self.serv2, self.serv2, self.serv2, self.serv2], True)
	- # Check that credentials as used for -proxyrandomize connections are unique
	- credentials = set((x.username,x.password) for x in rv)
	+ rv = self.node_test(
	+ self.nodes[2], [self.serv2, self.serv2, self.serv2, self.serv2], True)
	+ # Check that credentials as used for -proxyrandomize connections are
	+ # unique
	+ credentials = set((x.username, x.password) for x in rv)
	assert_equal(len(credentials), len(rv))

	if self.have_ipv6:
	# proxy on IPv6 localhost
	- self.node_test(self.nodes[3], [self.serv3, self.serv3, self.serv3, self.serv3], False, False)
	+ self.node_test(
	+ self.nodes[3], [self.serv3, self.serv3, self.serv3, self.serv3], False, False)

	def networks_dict(d):
	r = {}
	@@ -172,32 +188,31 @@

	# test RPC getnetworkinfo
	n0 = networks_dict(self.nodes[0].getnetworkinfo())
	- for net in ['ipv4','ipv6','onion']:
	+ for net in ['ipv4', 'ipv6', 'onion']:
	assert_equal(n0[net]['proxy'], '%s:%i' % (self.conf1.addr))
	assert_equal(n0[net]['proxy_randomize_credentials'], True)
	assert_equal(n0['onion']['reachable'], True)

	n1 = networks_dict(self.nodes[1].getnetworkinfo())
	- for net in ['ipv4','ipv6']:
	+ for net in ['ipv4', 'ipv6']:
	assert_equal(n1[net]['proxy'], '%s:%i' % (self.conf1.addr))
	assert_equal(n1[net]['proxy_randomize_credentials'], False)
	assert_equal(n1['onion']['proxy'], '%s:%i' % (self.conf2.addr))
	assert_equal(n1['onion']['proxy_randomize_credentials'], False)
	assert_equal(n1['onion']['reachable'], True)
	-
	+
	n2 = networks_dict(self.nodes[2].getnetworkinfo())
	- for net in ['ipv4','ipv6','onion']:
	+ for net in ['ipv4', 'ipv6', 'onion']:
	assert_equal(n2[net]['proxy'], '%s:%i' % (self.conf2.addr))
	assert_equal(n2[net]['proxy_randomize_credentials'], True)
	assert_equal(n2['onion']['reachable'], True)

	if self.have_ipv6:
	n3 = networks_dict(self.nodes[3].getnetworkinfo())
	- for net in ['ipv4','ipv6']:
	+ for net in ['ipv4', 'ipv6']:
	assert_equal(n3[net]['proxy'], '[%s]:%i' % (self.conf3.addr))
	assert_equal(n3[net]['proxy_randomize_credentials'], False)
	assert_equal(n3['onion']['reachable'], False)

	if __name__ == '__main__':
	ProxyTest().main()
	-
	diff --git a/qa/rpc-tests/reindex.py b/qa/rpc-tests/reindex.py
	--- a/qa/rpc-tests/reindex.py
	+++ b/qa/rpc-tests/reindex.py
	@@ -14,6 +14,7 @@
	)
	import time

	+
	class ReindexTest(BitcoinTestFramework):

	def __init__(self):
	@@ -28,8 +29,10 @@
	self.nodes[0].generate(3)
	blockcount = self.nodes[0].getblockcount()
	stop_nodes(self.nodes)
	- extra_args = [["-debug", "-reindex-chainstate" if justchainstate else "-reindex", "-checkblockindex=1"]]
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
	+ extra_args = [
	+ ["-debug", "-reindex-chainstate" if justchainstate else "-reindex", "-checkblockindex=1"]]
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, extra_args)
	while self.nodes[0].getblockcount() < blockcount:
	time.sleep(0.1)
	assert_equal(self.nodes[0].getblockcount(), blockcount)
	diff --git a/qa/rpc-tests/rest.py b/qa/rpc-tests/rest.py
	--- a/qa/rpc-tests/rest.py
	+++ b/qa/rpc-tests/rest.py
	@@ -17,6 +17,7 @@
	import http.client
	import urllib.parse

	+
	def deser_uint256(f):
	r = 0
	for i in range(8):
	@@ -24,8 +25,10 @@
	r += t << (i * 32)
	return r

	-#allows simple http get calls
	-def http_get_call(host, port, path, response_object = 0):
	+# allows simple http get calls
	+
	+
	+def http_get_call(host, port, path, response_object=0):
	conn = http.client.HTTPConnection(host, port)
	conn.request('GET', path)

	@@ -34,8 +37,10 @@

	return conn.getresponse().read().decode('utf-8')

	-#allows simple http post calls with a request body
	-def http_post_call(host, port, path, requestdata = '', response_object = 0):
	+# allows simple http post calls with a request body
	+
	+
	+def http_post_call(host, port, path, requestdata='', response_object=0):
	conn = http.client.HTTPConnection(host, port)
	conn.request('POST', path, requestdata)

	@@ -44,6 +49,7 @@

	return conn.getresponse().read()

	+
	class RESTTest (BitcoinTestFramework):
	FORMAT_SEPARATOR = "."

	@@ -54,10 +60,10 @@

	def setup_network(self, split=False):
	self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
	- connect_nodes_bi(self.nodes,0,1)
	- connect_nodes_bi(self.nodes,1,2)
	- connect_nodes_bi(self.nodes,0,2)
	- self.is_network_split=False
	+ connect_nodes_bi(self.nodes, 0, 1)
	+ connect_nodes_bi(self.nodes, 1, 2)
	+ connect_nodes_bi(self.nodes, 0, 2)
	+ self.is_network_split = False
	self.sync_all()

	def run_test(self):
	@@ -77,61 +83,66 @@
	self.sync_all()
	bb_hash = self.nodes[0].getbestblockhash()

	- assert_equal(self.nodes[1].getbalance(), Decimal("0.1")) #balance now should be 0.1 on node 1
	+ assert_equal(self.nodes[1].getbalance(), Decimal("0.1"))
	+ # balance now should be 0.1 on node 1

	# load the latest 0.1 tx over the REST API
	- json_string = http_get_call(url.hostname, url.port, '/rest/tx/'+txid+self.FORMAT_SEPARATOR+"json")
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/tx/' + txid + self.FORMAT_SEPARATOR + "json")
	json_obj = json.loads(json_string)
	- vintx = json_obj['vin'][0]['txid'] # get the vin to later check for utxo (should be spent by then)
	+ vintx = json_obj['vin'][0]['txid']
	+ # get the vin to later check for utxo (should be spent by then)
	# get n of 0.1 outpoint
	n = 0
	for vout in json_obj['vout']:
	if vout['value'] == 0.1:
	n = vout['n']

	-
	- ######################################
	+ #
	# GETUTXOS: query a unspent outpoint #
	- ######################################
	- json_request = '/checkmempool/'+txid+'-'+str(n)
	- json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
	+ #
	+ json_request = '/checkmempool/' + txid + '-' + str(n)
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)

	- #check chainTip response
	+ # check chainTip response
	assert_equal(json_obj['chaintipHash'], bb_hash)

	- #make sure there is one utxo
	+ # make sure there is one utxo
	assert_equal(len(json_obj['utxos']), 1)
	assert_equal(json_obj['utxos'][0]['value'], 0.1)

	-
	- ################################################
	+ #
	# GETUTXOS: now query a already spent outpoint #
	- ################################################
	- json_request = '/checkmempool/'+vintx+'-0'
	- json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
	+ #
	+ json_request = '/checkmempool/' + vintx + '-0'
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)

	- #check chainTip response
	+ # check chainTip response
	assert_equal(json_obj['chaintipHash'], bb_hash)

	- #make sure there is no utox in the response because this oupoint has been spent
	+ # make sure there is no utox in the response because this oupoint has
	+ # been spent
	assert_equal(len(json_obj['utxos']), 0)

	- #check bitmap
	+ # check bitmap
	assert_equal(json_obj['bitmap'], "0")

	-
	- ##################################################
	+ #
	# GETUTXOS: now check both with the same request #
	- ##################################################
	- json_request = '/checkmempool/'+txid+'-'+str(n)+'/'+vintx+'-0'
	- json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
	+ #
	+ json_request = '/checkmempool/' + \
	+ txid + '-' + str(n) + '/' + vintx + '-0'
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)
	assert_equal(len(json_obj['utxos']), 1)
	assert_equal(json_obj['bitmap'], "10")

	- #test binary response
	+ # test binary response
	bb_hash = self.nodes[0].getbestblockhash()

	binaryRequest = b'\x01\x02'
	@@ -140,169 +151,216 @@
	binaryRequest += hex_str_to_bytes(vintx)
	binaryRequest += pack("i", 0)

	- bin_response = http_post_call(url.hostname, url.port, '/rest/getutxos'+self.FORMAT_SEPARATOR+'bin', binaryRequest)
	+ bin_response = http_post_call(
	+ url.hostname, url.port, '/rest/getutxos' + self.FORMAT_SEPARATOR + 'bin', binaryRequest)
	output = BytesIO()
	output.write(bin_response)
	output.seek(0)
	chainHeight = unpack("i", output.read(4))[0]
	hashFromBinResponse = hex(deser_uint256(output))[2:].zfill(64)

	- assert_equal(bb_hash, hashFromBinResponse) #check if getutxo's chaintip during calculation was fine
	- assert_equal(chainHeight, 102) #chain height must be 102
	-
	+ assert_equal(bb_hash, hashFromBinResponse)
	+ # check if getutxo's chaintip during calculation was fine
	+ assert_equal(chainHeight, 102) # chain height must be 102

	- ############################
	+ #
	# GETUTXOS: mempool checks #
	- ############################
	+ #

	# do a tx and don't sync
	txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
	- json_string = http_get_call(url.hostname, url.port, '/rest/tx/'+txid+self.FORMAT_SEPARATOR+"json")
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/tx/' + txid + self.FORMAT_SEPARATOR + "json")
	json_obj = json.loads(json_string)
	- vintx = json_obj['vin'][0]['txid'] # get the vin to later check for utxo (should be spent by then)
	+ vintx = json_obj['vin'][0]['txid']
	+ # get the vin to later check for utxo (should be spent by then)
	# get n of 0.1 outpoint
	n = 0
	for vout in json_obj['vout']:
	if vout['value'] == 0.1:
	n = vout['n']

	- json_request = '/'+txid+'-'+str(n)
	- json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
	+ json_request = '/' + txid + '-' + str(n)
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)
	- assert_equal(len(json_obj['utxos']), 0) #there should be a outpoint because it has just added to the mempool
	+ assert_equal(len(json_obj['utxos']), 0)
	+ # there should be a outpoint because it has just added to
	+ # the mempool

	- json_request = '/checkmempool/'+txid+'-'+str(n)
	- json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
	+ json_request = '/checkmempool/' + txid + '-' + str(n)
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)
	- assert_equal(len(json_obj['utxos']), 1) #there should be a outpoint because it has just added to the mempool
	+ assert_equal(len(json_obj['utxos']), 1)
	+ # there should be a outpoint because it has just added to
	+ # the mempool

	- #do some invalid requests
	+ # do some invalid requests
	json_request = '{"checkmempool'
	- response = http_post_call(url.hostname, url.port, '/rest/getutxos'+self.FORMAT_SEPARATOR+'json', json_request, True)
	- assert_equal(response.status, 400) #must be a 400 because we send a invalid json request
	+ response = http_post_call(
	+ url.hostname, url.port, '/rest/getutxos' + self.FORMAT_SEPARATOR + 'json', json_request, True)
	+ assert_equal(response.status, 400)
	+ # must be a 400 because we send a invalid json request

	json_request = '{"checkmempool'
	- response = http_post_call(url.hostname, url.port, '/rest/getutxos'+self.FORMAT_SEPARATOR+'bin', json_request, True)
	- assert_equal(response.status, 400) #must be a 400 because we send a invalid bin request
	+ response = http_post_call(
	+ url.hostname, url.port, '/rest/getutxos' + self.FORMAT_SEPARATOR + 'bin', json_request, True)
	+ assert_equal(response.status, 400)
	+ # must be a 400 because we send a invalid bin request

	- response = http_post_call(url.hostname, url.port, '/rest/getutxos/checkmempool'+self.FORMAT_SEPARATOR+'bin', '', True)
	- assert_equal(response.status, 400) #must be a 400 because we send a invalid bin request
	+ response = http_post_call(
	+ url.hostname, url.port, '/rest/getutxos/checkmempool' + self.FORMAT_SEPARATOR + 'bin', '', True)
	+ assert_equal(response.status, 400)
	+ # must be a 400 because we send a invalid bin request

	- #test limits
	+ # test limits
	json_request = '/checkmempool/'
	for x in range(0, 20):
	- json_request += txid+'-'+str(n)+'/'
	+ json_request += txid + '-' + str(n) + '/'
	json_request = json_request.rstrip("/")
	- response = http_post_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json', '', True)
	- assert_equal(response.status, 400) #must be a 400 because we exceeding the limits
	+ response = http_post_call(
	+ url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json', '', True)
	+ assert_equal(response.status, 400)
	+ # must be a 400 because we exceeding the limits

	json_request = '/checkmempool/'
	for x in range(0, 15):
	- json_request += txid+'-'+str(n)+'/'
	+ json_request += txid + '-' + str(n) + '/'
	json_request = json_request.rstrip("/")
	- response = http_post_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json', '', True)
	- assert_equal(response.status, 200) #must be a 200 because we are within the limits
	+ response = http_post_call(
	+ url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json', '', True)
	+ assert_equal(response.status, 200)
	+ # must be a 200 because we are within the limits

	- self.nodes[0].generate(1) #generate block to not affect upcoming tests
	+ self.nodes[0].generate(
	+ 1) # generate block to not affect upcoming tests
	self.sync_all()

	- ################
	+ #
	# /rest/block/ #
	- ################
	+ #

	# check binary format
	- response = http_get_call(url.hostname, url.port, '/rest/block/'+bb_hash+self.FORMAT_SEPARATOR+"bin", True)
	+ response = http_get_call(
	+ url.hostname, url.port, '/rest/block/' + bb_hash + self.FORMAT_SEPARATOR + "bin", True)
	assert_equal(response.status, 200)
	assert_greater_than(int(response.getheader('content-length')), 80)
	response_str = response.read()

	# compare with block header
	- response_header = http_get_call(url.hostname, url.port, '/rest/headers/1/'+bb_hash+self.FORMAT_SEPARATOR+"bin", True)
	+ response_header = http_get_call(
	+ url.hostname, url.port, '/rest/headers/1/' + bb_hash + self.FORMAT_SEPARATOR + "bin", True)
	assert_equal(response_header.status, 200)
	assert_equal(int(response_header.getheader('content-length')), 80)
	response_header_str = response_header.read()
	assert_equal(response_str[0:80], response_header_str)

	# check block hex format
	- response_hex = http_get_call(url.hostname, url.port, '/rest/block/'+bb_hash+self.FORMAT_SEPARATOR+"hex", True)
	+ response_hex = http_get_call(
	+ url.hostname, url.port, '/rest/block/' + bb_hash + self.FORMAT_SEPARATOR + "hex", True)
	assert_equal(response_hex.status, 200)
	assert_greater_than(int(response_hex.getheader('content-length')), 160)
	response_hex_str = response_hex.read()
	- assert_equal(encode(response_str, "hex_codec")[0:160], response_hex_str[0:160])
	+ assert_equal(
	+ encode(response_str, "hex_codec")[0:160], response_hex_str[0:160])

	# compare with hex block header
	- response_header_hex = http_get_call(url.hostname, url.port, '/rest/headers/1/'+bb_hash+self.FORMAT_SEPARATOR+"hex", True)
	+ response_header_hex = http_get_call(
	+ url.hostname, url.port, '/rest/headers/1/' + bb_hash + self.FORMAT_SEPARATOR + "hex", True)
	assert_equal(response_header_hex.status, 200)
	- assert_greater_than(int(response_header_hex.getheader('content-length')), 160)
	+ assert_greater_than(
	+ int(response_header_hex.getheader('content-length')), 160)
	response_header_hex_str = response_header_hex.read()
	assert_equal(response_hex_str[0:160], response_header_hex_str[0:160])
	- assert_equal(encode(response_header_str, "hex_codec")[0:160], response_header_hex_str[0:160])
	+ assert_equal(encode(response_header_str, "hex_codec")[
	+ 0:160], response_header_hex_str[0:160])

	# check json format
	- block_json_string = http_get_call(url.hostname, url.port, '/rest/block/'+bb_hash+self.FORMAT_SEPARATOR+'json')
	+ block_json_string = http_get_call(
	+ url.hostname, url.port, '/rest/block/' + bb_hash + self.FORMAT_SEPARATOR + 'json')
	block_json_obj = json.loads(block_json_string)
	assert_equal(block_json_obj['hash'], bb_hash)

	# compare with json block header
	- response_header_json = http_get_call(url.hostname, url.port, '/rest/headers/1/'+bb_hash+self.FORMAT_SEPARATOR+"json", True)
	+ response_header_json = http_get_call(
	+ url.hostname, url.port, '/rest/headers/1/' + bb_hash + self.FORMAT_SEPARATOR + "json", True)
	assert_equal(response_header_json.status, 200)
	response_header_json_str = response_header_json.read().decode('utf-8')
	json_obj = json.loads(response_header_json_str, parse_float=Decimal)
	- assert_equal(len(json_obj), 1) #ensure that there is one header in the json response
	- assert_equal(json_obj[0]['hash'], bb_hash) #request/response hash should be the same
	+ assert_equal(len(json_obj), 1)
	+ # ensure that there is one header in the json response
	+ assert_equal(json_obj[0]['hash'], bb_hash)
	+ # request/response hash should be the same

	- #compare with normal RPC block response
	+ # compare with normal RPC block response
	rpc_block_json = self.nodes[0].getblock(bb_hash)
	assert_equal(json_obj[0]['hash'], rpc_block_json['hash'])
	- assert_equal(json_obj[0]['confirmations'], rpc_block_json['confirmations'])
	- assert_equal(json_obj[0]['height'], rpc_block_json['height'])
	- assert_equal(json_obj[0]['version'], rpc_block_json['version'])
	- assert_equal(json_obj[0]['merkleroot'], rpc_block_json['merkleroot'])
	+ assert_equal(
	+ json_obj[0]['confirmations'], rpc_block_json['confirmations'])
	+ assert_equal(
	+ json_obj[0]['height'], rpc_block_json['height'])
	+ assert_equal(
	+ json_obj[0]['version'], rpc_block_json['version'])
	+ assert_equal(
	+ json_obj[0]['merkleroot'], rpc_block_json['merkleroot'])
	assert_equal(json_obj[0]['time'], rpc_block_json['time'])
	- assert_equal(json_obj[0]['nonce'], rpc_block_json['nonce'])
	+ assert_equal(
	+ json_obj[0]['nonce'], rpc_block_json['nonce'])
	assert_equal(json_obj[0]['bits'], rpc_block_json['bits'])
	- assert_equal(json_obj[0]['difficulty'], rpc_block_json['difficulty'])
	- assert_equal(json_obj[0]['chainwork'], rpc_block_json['chainwork'])
	- assert_equal(json_obj[0]['previousblockhash'], rpc_block_json['previousblockhash'])
	-
	- #see if we can get 5 headers in one response
	+ assert_equal(
	+ json_obj[0]['difficulty'], rpc_block_json['difficulty'])
	+ assert_equal(
	+ json_obj[0]['chainwork'], rpc_block_json['chainwork'])
	+ assert_equal(
	+ json_obj[0]['previousblockhash'], rpc_block_json['previousblockhash'])
	+
	+ # see if we can get 5 headers in one response
	self.nodes[1].generate(5)
	self.sync_all()
	- response_header_json = http_get_call(url.hostname, url.port, '/rest/headers/5/'+bb_hash+self.FORMAT_SEPARATOR+"json", True)
	+ response_header_json = http_get_call(
	+ url.hostname, url.port, '/rest/headers/5/' + bb_hash + self.FORMAT_SEPARATOR + "json", True)
	assert_equal(response_header_json.status, 200)
	response_header_json_str = response_header_json.read().decode('utf-8')
	json_obj = json.loads(response_header_json_str)
	- assert_equal(len(json_obj), 5) #now we should have 5 header objects
	+ assert_equal(len(json_obj), 5) # now we should have 5 header objects

	# do tx test
	tx_hash = block_json_obj['tx'][0]['txid']
	- json_string = http_get_call(url.hostname, url.port, '/rest/tx/'+tx_hash+self.FORMAT_SEPARATOR+"json")
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/tx/' + tx_hash + self.FORMAT_SEPARATOR + "json")
	json_obj = json.loads(json_string)
	assert_equal(json_obj['txid'], tx_hash)

	# check hex format response
	- hex_string = http_get_call(url.hostname, url.port, '/rest/tx/'+tx_hash+self.FORMAT_SEPARATOR+"hex", True)
	+ hex_string = http_get_call(
	+ url.hostname, url.port, '/rest/tx/' + tx_hash + self.FORMAT_SEPARATOR + "hex", True)
	assert_equal(hex_string.status, 200)
	assert_greater_than(int(response.getheader('content-length')), 10)

	-
	# check block tx details
	# let's make 3 tx and mine them on node 1
	txs = []
	- txs.append(self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11))
	- txs.append(self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11))
	- txs.append(self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11))
	+ txs.append(self.nodes[0].sendtoaddress(
	+ self.nodes[2].getnewaddress(), 11))
	+ txs.append(self.nodes[0].sendtoaddress(
	+ self.nodes[2].getnewaddress(), 11))
	+ txs.append(self.nodes[0].sendtoaddress(
	+ self.nodes[2].getnewaddress(), 11))
	self.sync_all()

	- # check that there are exactly 3 transactions in the TX memory pool before generating the block
	- json_string = http_get_call(url.hostname, url.port, '/rest/mempool/info'+self.FORMAT_SEPARATOR+'json')
	+ # check that there are exactly 3 transactions in the TX memory pool
	+ # before generating the block
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/mempool/info' + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)
	assert_equal(json_obj['size'], 3)
	# the size of the memory pool should be greater than 3x ~100 bytes
	assert_greater_than(json_obj['bytes'], 300)

	# check that there are our submitted transactions in the TX memory pool
	- json_string = http_get_call(url.hostname, url.port, '/rest/mempool/contents'+self.FORMAT_SEPARATOR+'json')
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/mempool/contents' + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)
	for tx in txs:
	assert_equal(tx in json_obj, True)
	@@ -311,25 +369,28 @@
	newblockhash = self.nodes[1].generate(1)
	self.sync_all()

	- #check if the 3 tx show up in the new block
	- json_string = http_get_call(url.hostname, url.port, '/rest/block/'+newblockhash[0]+self.FORMAT_SEPARATOR+'json')
	+ # check if the 3 tx show up in the new block
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/block/' + newblockhash[0] + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)
	for tx in json_obj['tx']:
	- if not 'coinbase' in tx['vin'][0]: #exclude coinbase
	+ if not 'coinbase' in tx['vin'][0]: # exclude coinbase
	assert_equal(tx['txid'] in txs, True)

	- #check the same but without tx details
	- json_string = http_get_call(url.hostname, url.port, '/rest/block/notxdetails/'+newblockhash[0]+self.FORMAT_SEPARATOR+'json')
	+ # check the same but without tx details
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/block/notxdetails/' + newblockhash[0] + self.FORMAT_SEPARATOR + 'json')
	json_obj = json.loads(json_string)
	for tx in txs:
	assert_equal(tx in json_obj['tx'], True)

	- #test rest bestblock
	+ # test rest bestblock
	bb_hash = self.nodes[0].getbestblockhash()

	- json_string = http_get_call(url.hostname, url.port, '/rest/chaininfo.json')
	+ json_string = http_get_call(
	+ url.hostname, url.port, '/rest/chaininfo.json')
	json_obj = json.loads(json_string)
	assert_equal(json_obj['bestblockhash'], bb_hash)

	if __name__ == '__main__':
	- RESTTest ().main ()
	+ RESTTest().main()
	diff --git a/qa/rpc-tests/rpcbind_test.py b/qa/rpc-tests/rpcbind_test.py
	--- a/qa/rpc-tests/rpcbind_test.py
	+++ b/qa/rpc-tests/rpcbind_test.py
	@@ -33,8 +33,9 @@
	base_args = ['-disablewallet', '-nolisten']
	if allow_ips:
	base_args += ['-rpcallowip=' + x for x in allow_ips]
	- binds = ['-rpcbind='+addr for addr in addresses]
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, [base_args + binds], connect_to)
	+ binds = ['-rpcbind=' + addr for addr in addresses]
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, [base_args + binds], connect_to)
	pid = bitcoind_processes[0].pid
	assert_equal(set(get_bind_addrs(pid)), set(expected))
	stop_nodes(self.nodes)
	@@ -44,51 +45,60 @@
	Start a node with rpcallow IP, and request getnetworkinfo
	at a non-localhost IP.
	'''
	- base_args = ['-disablewallet', '-nolisten'] + ['-rpcallowip='+x for x in allow_ips]
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, [base_args])
	+ base_args = ['-disablewallet', '-nolisten'] + [
	+ '-rpcallowip=' + x for x in allow_ips]
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, [base_args])
	# connect to node through non-loopback interface
	node = get_rpc_proxy(rpc_url(0, "%s:%d" % (rpchost, rpcport)), 0)
	node.getnetworkinfo()
	stop_nodes(self.nodes)

	def run_test(self):
	- # due to OS-specific network stats queries, this test works only on Linux
	+ # due to OS-specific network stats queries, this test works only on
	+ # Linux
	assert(sys.platform.startswith('linux'))
	# find the first non-loopback interface for testing
	non_loopback_ip = None
	- for name,ip in all_interfaces():
	+ for name, ip in all_interfaces():
	if ip != '127.0.0.1':
	non_loopback_ip = ip
	break
	if non_loopback_ip is None:
	- assert(not 'This test requires at least one non-loopback IPv4 interface')
	+ assert(
	+ not 'This test requires at least one non-loopback IPv4 interface')
	print("Using interface %s for testing" % non_loopback_ip)

	defaultport = rpc_port(0)

	# check default without rpcallowip (IPv4 and IPv6 localhost)
	self.run_bind_test(None, '127.0.0.1', [],
	- [('127.0.0.1', defaultport), ('::1', defaultport)])
	+ [('127.0.0.1', defaultport), ('::1', defaultport)])
	# check default with rpcallowip (IPv6 any)
	self.run_bind_test(['127.0.0.1'], '127.0.0.1', [],
	- [('::0', defaultport)])
	+ [('::0', defaultport)])
	# check only IPv4 localhost (explicit)
	self.run_bind_test(['127.0.0.1'], '127.0.0.1', ['127.0.0.1'],
	- [('127.0.0.1', defaultport)])
	+ [('127.0.0.1', defaultport)])
	# check only IPv4 localhost (explicit) with alternative port
	- self.run_bind_test(['127.0.0.1'], '127.0.0.1:32171', ['127.0.0.1:32171'],
	+ self.run_bind_test(
	+ ['127.0.0.1'], '127.0.0.1:32171', ['127.0.0.1:32171'],
	[('127.0.0.1', 32171)])
	- # check only IPv4 localhost (explicit) with multiple alternative ports on same host
	- self.run_bind_test(['127.0.0.1'], '127.0.0.1:32171', ['127.0.0.1:32171', '127.0.0.1:32172'],
	+ # check only IPv4 localhost (explicit) with multiple alternative ports
	+ # on same host
	+ self.run_bind_test(
	+ ['127.0.0.1'], '127.0.0.1:32171', [
	+ '127.0.0.1:32171', '127.0.0.1:32172'],
	[('127.0.0.1', 32171), ('127.0.0.1', 32172)])
	# check only IPv6 localhost (explicit)
	self.run_bind_test(['[::1]'], '[::1]', ['[::1]'],
	- [('::1', defaultport)])
	+ [('::1', defaultport)])
	# check both IPv4 and IPv6 localhost (explicit)
	self.run_bind_test(['127.0.0.1'], '127.0.0.1', ['127.0.0.1', '[::1]'],
	- [('127.0.0.1', defaultport), ('::1', defaultport)])
	+ [('127.0.0.1', defaultport), ('::1', defaultport)])
	# check only non-loopback interface
	- self.run_bind_test([non_loopback_ip], non_loopback_ip, [non_loopback_ip],
	+ self.run_bind_test(
	+ [non_loopback_ip], non_loopback_ip, [non_loopback_ip],
	[(non_loopback_ip, defaultport)])

	# Check that with invalid rpcallowip, we are denied
	diff --git a/qa/rpc-tests/rpcnamedargs.py b/qa/rpc-tests/rpcnamedargs.py
	--- a/qa/rpc-tests/rpcnamedargs.py
	+++ b/qa/rpc-tests/rpcnamedargs.py
	@@ -18,6 +18,7 @@


	class NamedArgumentTest(BitcoinTestFramework):
	+
	"""
	Test named arguments on RPC calls.
	"""
	@@ -37,16 +38,18 @@
	h = node.help(command='getinfo')
	assert(h.startswith('getinfo\n'))

	- assert_raises_jsonrpc(-8, 'Unknown named parameter', node.help, random='getinfo')
	+ assert_raises_jsonrpc(
	+ -8, 'Unknown named parameter', node.help, random='getinfo')

	h = node.getblockhash(height=0)
	node.getblock(blockhash=h)

	assert_equal(node.echo(), [])
	- assert_equal(node.echo(arg0=0,arg9=9), [0] + [None]*8 + [9])
	+ assert_equal(node.echo(arg0=0, arg9=9), [0] + [None] * 8 + [9])
	assert_equal(node.echo(arg1=1), [None, 1])
	- assert_equal(node.echo(arg9=None), [None]*10)
	- assert_equal(node.echo(arg0=0,arg3=3,arg9=9), [0] + [None]2 + [3] + [None]5 + [9])
	+ assert_equal(node.echo(arg9=None), [None] * 10)
	+ assert_equal(node.echo(arg0=0, arg3=3, arg9=9),
	+ [0] + [None] * 2 + [3] + [None] * 5 + [9])

	if __name__ == '__main__':
	NamedArgumentTest().main()
	diff --git a/qa/rpc-tests/sendheaders.py b/qa/rpc-tests/sendheaders.py
	--- a/qa/rpc-tests/sendheaders.py
	+++ b/qa/rpc-tests/sendheaders.py
	@@ -11,7 +11,7 @@
	'''
	SendHeadersTest -- test behavior of headers messages to announce blocks.

	-Setup:
	+Setup:

	- Two nodes, two p2p connections to node0. One p2p connection should only ever
	receive inv's (omitted from testing description below, this is our control).
	@@ -82,7 +82,9 @@

	direct_fetch_response_time = 0.05

	+
	class BaseNode(SingleNodeConnCB):
	+
	def __init__(self):
	SingleNodeConnCB.__init__(self)
	self.last_inv = None
	@@ -164,7 +166,7 @@
	hash_headers = []
	if self.last_headers != None:
	# treat headers as a list of block hashes
	- hash_headers = [ x.sha256 for x in self.last_headers.headers ]
	+ hash_headers = [x.sha256 for x in self.last_headers.headers]
	if hash_headers != expect_headers:
	success = False

	@@ -187,7 +189,8 @@
	if hash_list == []:
	return

	- test_function = lambda: self.last_getdata != None and [x.hash for x in self.last_getdata.inv] == hash_list
	+ test_function = lambda: self.last_getdata != None and [
	+ x.hash for x in self.last_getdata.inv] == hash_list
	assert(wait_until(test_function, timeout=timeout))
	return

	@@ -203,7 +206,7 @@

	def send_header_for_blocks(self, new_blocks):
	headers_message = msg_headers()
	- headers_message.headers = [ CBlockHeader(b) for b in new_blocks ]
	+ headers_message.headers = [CBlockHeader(b) for b in new_blocks]
	self.send_message(headers_message)

	def send_getblocks(self, locator):
	@@ -213,16 +216,24 @@

	# InvNode: This peer should only ever receive inv's, because it doesn't ever send a
	# "sendheaders" message.
	+
	+
	class InvNode(BaseNode):
	+
	def __init__(self):
	BaseNode.__init__(self)

	# TestNode: This peer is the one we use for most of the testing.
	+
	+
	class TestNode(BaseNode):
	+
	def __init__(self):
	BaseNode.__init__(self)

	+
	class SendHeadersTest(BitcoinTestFramework):
	+
	def __init__(self):
	super().__init__()
	self.setup_clean_chain = True
	@@ -230,13 +241,14 @@

	def setup_network(self):
	self.nodes = []
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, [["-debug", "-logtimemicros=1"]]*2)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, [["-debug", "-logtimemicros=1"]] * 2)
	connect_nodes(self.nodes[0], 1)

	# mine count blocks and return the new tip
	def mine_blocks(self, count):
	# Clear out last block announcement from each p2p listener
	- [ x.clear_last_announcement() for x in self.p2p_connections ]
	+ [x.clear_last_announcement() for x in self.p2p_connections]
	self.nodes[0].generate(count)
	return int(self.nodes[0].getbestblockhash(), 16)

	@@ -246,16 +258,20 @@
	# to-be-reorged-out blocks are mined, so that we don't break later tests.
	# return the list of block hashes newly mined
	def mine_reorg(self, length):
	- self.nodes[0].generate(length) # make sure all invalidated blocks are node0's
	+ self.nodes[0].generate(
	+ length) # make sure all invalidated blocks are node0's
	sync_blocks(self.nodes, wait=0.1)
	for x in self.p2p_connections:
	- x.wait_for_block_announcement(int(self.nodes[0].getbestblockhash(), 16))
	+ x.wait_for_block_announcement(
	+ int(self.nodes[0].getbestblockhash(), 16))
	x.clear_last_announcement()

	tip_height = self.nodes[1].getblockcount()
	- hash_to_invalidate = self.nodes[1].getblockhash(tip_height-(length-1))
	+ hash_to_invalidate = self.nodes[
	+ 1].getblockhash(tip_height - (length - 1))
	self.nodes[1].invalidateblock(hash_to_invalidate)
	- all_hashes = self.nodes[1].generate(length+1) # Must be longer than the orig chain
	+ all_hashes = self.nodes[1].generate(
	+ length + 1) # Must be longer than the orig chain
	sync_blocks(self.nodes, wait=0.1)
	return [int(x, 16) for x in all_hashes]

	@@ -267,14 +283,16 @@
	self.p2p_connections = [inv_node, test_node]

	connections = []
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], inv_node))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], inv_node))
	# Set nServices to 0 for test_node, so no block download will occur outside of
	# direct fetching
	- connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node, services=0))
	+ connections.append(
	+ NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node, services=0))
	inv_node.add_connection(connections[0])
	test_node.add_connection(connections[1])

	- NetworkThread().start() # Start up network handling in another thread
	+ NetworkThread().start() # Start up network handling in another thread

	# Test logic begins here
	inv_node.wait_for_verack()
	@@ -290,7 +308,8 @@
	tip = self.mine_blocks(1)
	assert_equal(inv_node.check_last_announcement(inv=[tip]), True)
	assert_equal(test_node.check_last_announcement(inv=[tip]), True)
	- # Try a few different responses; none should affect next announcement
	+ # Try a few different responses; none should affect next
	+ # announcement
	if i == 0:
	# first request the block
	test_node.get_data([tip])
	@@ -300,23 +319,27 @@
	test_node.get_headers(locator=[old_tip], hashstop=tip)
	test_node.get_data([tip])
	test_node.wait_for_block(tip)
	- test_node.clear_last_announcement() # since we requested headers...
	+ test_node.clear_last_announcement(
	+ ) # since we requested headers...
	elif i == 2:
	# this time announce own block via headers
	height = self.nodes[0].getblockcount()
	- last_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time']
	+ last_time = self.nodes[0].getblock(
	+ self.nodes[0].getbestblockhash())['time']
	block_time = last_time + 1
	- new_block = create_block(tip, create_coinbase(height+1), block_time)
	+ new_block = create_block(
	+ tip, create_coinbase(height + 1), block_time)
	new_block.solve()
	test_node.send_header_for_blocks([new_block])
	test_node.wait_for_getdata([new_block.sha256], timeout=5)
	test_node.send_message(msg_block(new_block))
	- test_node.sync_with_ping() # make sure this block is processed
	+ test_node.sync_with_ping() # make sure this block is processed
	inv_node.clear_last_announcement()
	test_node.clear_last_announcement()

	print("Part 1: success!")
	- print("Part 2: announce blocks with headers after sendheaders message...")
	+ print(
	+ "Part 2: announce blocks with headers after sendheaders message...")
	# PART 2
	# 2. Send a sendheaders message and test that headers announcements
	# commence and keep working.
	@@ -330,7 +353,7 @@
	assert_equal(inv_node.check_last_announcement(inv=[tip]), True)
	assert_equal(test_node.check_last_announcement(headers=[tip]), True)

	- height = self.nodes[0].getblockcount()+1
	+ height = self.nodes[0].getblockcount() + 1
	block_time += 10 # Advance far enough ahead
	for i in range(10):
	# Mine i blocks, and alternate announcing either via
	@@ -339,8 +362,9 @@
	# with block header, even though the blocks are never requested
	for j in range(2):
	blocks = []
	- for b in range(i+1):
	- blocks.append(create_block(tip, create_coinbase(height), block_time))
	+ for b in range(i + 1):
	+ blocks.append(
	+ create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	@@ -353,18 +377,20 @@
	test_node.send_header_for_blocks(blocks)
	# Test that duplicate inv's won't result in duplicate
	# getdata requests, or duplicate headers announcements
	- [ inv_node.send_block_inv(x.sha256) for x in blocks ]
	- test_node.wait_for_getdata([x.sha256 for x in blocks], timeout=5)
	+ [inv_node.send_block_inv(x.sha256) for x in blocks]
	+ test_node.wait_for_getdata(
	+ [x.sha256 for x in blocks], timeout=5)
	inv_node.sync_with_ping()
	else:
	# Announce via headers
	test_node.send_header_for_blocks(blocks)
	- test_node.wait_for_getdata([x.sha256 for x in blocks], timeout=5)
	+ test_node.wait_for_getdata(
	+ [x.sha256 for x in blocks], timeout=5)
	# Test that duplicate headers won't result in duplicate
	# getdata requests (the check is further down)
	inv_node.send_header_for_blocks(blocks)
	inv_node.sync_with_ping()
	- [ test_node.send_message(msg_block(x)) for x in blocks ]
	+ [test_node.send_message(msg_block(x)) for x in blocks]
	test_node.sync_with_ping()
	inv_node.sync_with_ping()
	# This block should not be announced to the inv node (since it also
	@@ -373,26 +399,31 @@
	assert_equal(inv_node.last_headers, None)
	tip = self.mine_blocks(1)
	assert_equal(inv_node.check_last_announcement(inv=[tip]), True)
	- assert_equal(test_node.check_last_announcement(headers=[tip]), True)
	+ assert_equal(
	+ test_node.check_last_announcement(headers=[tip]), True)
	height += 1
	block_time += 1

	print("Part 2: success!")

	- print("Part 3: headers announcements can stop after large reorg, and resume after headers/inv from peer...")
	+ print(
	+ "Part 3: headers announcements can stop after large reorg, and resume after headers/inv from peer...")

	# PART 3. Headers announcements can stop after large reorg, and resume after
	# getheaders or inv from peer.
	for j in range(2):
	- # First try mining a reorg that can propagate with header announcement
	+ # First try mining a reorg that can propagate with header
	+ # announcement
	new_block_hashes = self.mine_reorg(length=7)
	tip = new_block_hashes[-1]
	assert_equal(inv_node.check_last_announcement(inv=[tip]), True)
	- assert_equal(test_node.check_last_announcement(headers=new_block_hashes), True)
	+ assert_equal(
	+ test_node.check_last_announcement(headers=new_block_hashes), True)

	- block_time += 8
	+ block_time += 8

	- # Mine a too-large reorg, which should be announced with a single inv
	+ # Mine a too-large reorg, which should be announced with a single
	+ # inv
	new_block_hashes = self.mine_reorg(length=8)
	tip = new_block_hashes[-1]
	assert_equal(inv_node.check_last_announcement(inv=[tip]), True)
	@@ -400,12 +431,14 @@

	block_time += 9

	- fork_point = self.nodes[0].getblock("%02x" % new_block_hashes[0])["previousblockhash"]
	+ fork_point = self.nodes[0].getblock(
	+ "%02x" % new_block_hashes[0])["previousblockhash"]
	fork_point = int(fork_point, 16)

	# Use getblocks/getdata
	- test_node.send_getblocks(locator = [fork_point])
	- assert_equal(test_node.check_last_announcement(inv=new_block_hashes), True)
	+ test_node.send_getblocks(locator=[fork_point])
	+ assert_equal(
	+ test_node.check_last_announcement(inv=new_block_hashes), True)
	test_node.get_data(new_block_hashes)
	test_node.wait_for_block(new_block_hashes[-1])

	@@ -413,22 +446,25 @@
	# Mine another block, still should get only an inv
	tip = self.mine_blocks(1)
	assert_equal(inv_node.check_last_announcement(inv=[tip]), True)
	- assert_equal(test_node.check_last_announcement(inv=[tip]), True)
	+ assert_equal(
	+ test_node.check_last_announcement(inv=[tip]), True)
	if i == 0:
	- # Just get the data -- shouldn't cause headers announcements to resume
	+ # Just get the data -- shouldn't cause headers
	+ # announcements to resume
	test_node.get_data([tip])
	test_node.wait_for_block(tip)
	elif i == 1:
	# Send a getheaders message that shouldn't trigger headers announcements
	# to resume (best header sent will be too old)
	- test_node.get_headers(locator=[fork_point], hashstop=new_block_hashes[1])
	+ test_node.get_headers(locator=[
	+ fork_point], hashstop=new_block_hashes[1])
	test_node.get_data([tip])
	test_node.wait_for_block(tip)
	elif i == 2:
	test_node.get_data([tip])
	test_node.wait_for_block(tip)
	# This time, try sending either a getheaders to trigger resumption
	- # of headers announcements, or mine a new block and inv it, also
	+ # of headers announcements, or mine a new block and inv it, also
	# triggering resumption of headers announcements.
	if j == 0:
	test_node.get_headers(locator=[tip], hashstop=0)
	@@ -439,27 +475,30 @@
	# New blocks should now be announced with header
	tip = self.mine_blocks(1)
	assert_equal(inv_node.check_last_announcement(inv=[tip]), True)
	- assert_equal(test_node.check_last_announcement(headers=[tip]), True)
	+ assert_equal(
	+ test_node.check_last_announcement(headers=[tip]), True)

	print("Part 3: success!")

	print("Part 4: Testing direct fetch behavior...")
	tip = self.mine_blocks(1)
	height = self.nodes[0].getblockcount() + 1
	- last_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time']
	+ last_time = self.nodes[0].getblock(
	+ self.nodes[0].getbestblockhash())['time']
	block_time = last_time + 1

	# Create 2 blocks. Send the blocks, then send the headers.
	blocks = []
	for b in range(2):
	- blocks.append(create_block(tip, create_coinbase(height), block_time))
	+ blocks.append(
	+ create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	height += 1
	inv_node.send_message(msg_block(blocks[-1]))

	- inv_node.sync_with_ping() # Make sure blocks are processed
	+ inv_node.sync_with_ping() # Make sure blocks are processed
	test_node.last_getdata = None
	test_node.send_header_for_blocks(blocks)
	test_node.sync_with_ping()
	@@ -470,7 +509,8 @@
	# This time, direct fetch should work
	blocks = []
	for b in range(3):
	- blocks.append(create_block(tip, create_coinbase(height), block_time))
	+ blocks.append(
	+ create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	@@ -478,9 +518,10 @@

	test_node.send_header_for_blocks(blocks)
	test_node.sync_with_ping()
	- test_node.wait_for_getdata([x.sha256 for x in blocks], timeout=direct_fetch_response_time)
	+ test_node.wait_for_getdata(
	+ [x.sha256 for x in blocks], timeout=direct_fetch_response_time)

	- [ test_node.send_message(msg_block(x)) for x in blocks ]
	+ [test_node.send_message(msg_block(x)) for x in blocks]

	test_node.sync_with_ping()

	@@ -491,7 +532,8 @@

	# Create extra blocks for later
	for b in range(20):
	- blocks.append(create_block(tip, create_coinbase(height), block_time))
	+ blocks.append(
	+ create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	@@ -509,13 +551,15 @@
	# both blocks (same work as tip)
	test_node.send_header_for_blocks(blocks[1:2])
	test_node.sync_with_ping()
	- test_node.wait_for_getdata([x.sha256 for x in blocks[0:2]], timeout=direct_fetch_response_time)
	+ test_node.wait_for_getdata(
	+ [x.sha256 for x in blocks[0:2]], timeout=direct_fetch_response_time)

	# Announcing 16 more headers should trigger direct fetch for 14 more
	# blocks
	test_node.send_header_for_blocks(blocks[2:18])
	test_node.sync_with_ping()
	- test_node.wait_for_getdata([x.sha256 for x in blocks[2:16]], timeout=direct_fetch_response_time)
	+ test_node.wait_for_getdata(
	+ [x.sha256 for x in blocks[2:16]], timeout=direct_fetch_response_time)

	# Announcing 1 more header should not trigger any response
	test_node.last_getdata = None
	@@ -527,7 +571,7 @@
	print("Part 4: success!")

	# Now deliver all those blocks we announced.
	- [ test_node.send_message(msg_block(x)) for x in blocks ]
	+ [test_node.send_message(msg_block(x)) for x in blocks]

	print("Part 5: Testing handling of unconnecting headers")
	# First we test that receipt of an unconnecting header doesn't prevent
	@@ -537,7 +581,8 @@
	blocks = []
	# Create two more blocks.
	for j in range(2):
	- blocks.append(create_block(tip, create_coinbase(height), block_time))
	+ blocks.append(
	+ create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	@@ -549,23 +594,26 @@
	test_node.wait_for_getheaders(timeout=1)
	test_node.send_header_for_blocks(blocks)
	test_node.wait_for_getdata([x.sha256 for x in blocks])
	- [ test_node.send_message(msg_block(x)) for x in blocks ]
	+ [test_node.send_message(msg_block(x)) for x in blocks]
	test_node.sync_with_ping()
	- assert_equal(int(self.nodes[0].getbestblockhash(), 16), blocks[1].sha256)
	+ assert_equal(
	+ int(self.nodes[0].getbestblockhash(), 16), blocks[1].sha256)

	blocks = []
	# Now we test that if we repeatedly don't send connecting headers, we
	# don't go into an infinite loop trying to get them to connect.
	MAX_UNCONNECTING_HEADERS = 10
	- for j in range(MAX_UNCONNECTING_HEADERS+1):
	- blocks.append(create_block(tip, create_coinbase(height), block_time))
	+ for j in range(MAX_UNCONNECTING_HEADERS + 1):
	+ blocks.append(
	+ create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	height += 1

	for i in range(1, MAX_UNCONNECTING_HEADERS):
	- # Send a header that doesn't connect, check that we get a getheaders.
	+ # Send a header that doesn't connect, check that we get a
	+ # getheaders.
	with mininode_lock:
	test_node.last_getheaders = None
	test_node.send_header_for_blocks([blocks[i]])
	@@ -579,11 +627,12 @@

	# Now try to see how many unconnecting headers we can send
	# before we get disconnected. Should be 5*MAX_UNCONNECTING_HEADERS
	- for i in range(5*MAX_UNCONNECTING_HEADERS - 1):
	- # Send a header that doesn't connect, check that we get a getheaders.
	+ for i in range(5 * MAX_UNCONNECTING_HEADERS - 1):
	+ # Send a header that doesn't connect, check that we get a
	+ # getheaders.
	with mininode_lock:
	test_node.last_getheaders = None
	- test_node.send_header_for_blocks([blocks[i%len(blocks)]])
	+ test_node.send_header_for_blocks([blocks[i % len(blocks)]])
	test_node.wait_for_getheaders(timeout=1)

	# Eventually this stops working.
	diff --git a/qa/rpc-tests/signmessages.py b/qa/rpc-tests/signmessages.py
	--- a/qa/rpc-tests/signmessages.py
	+++ b/qa/rpc-tests/signmessages.py
	@@ -8,6 +8,7 @@


	class SignMessagesTest(BitcoinTestFramework):
	+
	"""Tests RPC commands for signing and verifying messages."""

	def __init__(self):
	diff --git a/qa/rpc-tests/wallet-accounts.py b/qa/rpc-tests/wallet-accounts.py
	--- a/qa/rpc-tests/wallet-accounts.py
	+++ b/qa/rpc-tests/wallet-accounts.py
	@@ -21,74 +21,75 @@
	self.node_args = [[]]

	def setup_network(self):
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, self.node_args)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, self.node_args)
	self.is_network_split = False

	- def run_test (self):
	+ def run_test(self):
	node = self.nodes[0]
	# Check that there's no UTXO on any of the nodes
	assert_equal(len(node.listunspent()), 0)
	-
	+
	node.generate(101)
	-
	+
	assert_equal(node.getbalance(), 50)
	-
	- accounts = ["a","b","c","d","e"]
	+
	+ accounts = ["a", "b", "c", "d", "e"]
	amount_to_send = 1.0
	account_addresses = dict()
	for account in accounts:
	address = node.getaccountaddress(account)
	account_addresses[account] = address
	-
	+
	node.getnewaddress(account)
	assert_equal(node.getaccount(address), account)
	assert(address in node.getaddressesbyaccount(account))
	-
	+
	node.sendfrom("", address, amount_to_send)
	-
	+
	node.generate(1)
	-
	+
	for i in range(len(accounts)):
	from_account = accounts[i]
	- to_account = accounts[(i+1)%len(accounts)]
	+ to_account = accounts[(i + 1) % len(accounts)]
	to_address = account_addresses[to_account]
	node.sendfrom(from_account, to_address, amount_to_send)
	-
	+
	node.generate(1)
	-
	+
	for account in accounts:
	address = node.getaccountaddress(account)
	assert(address != account_addresses[account])
	assert_equal(node.getreceivedbyaccount(account), 2)
	node.move(account, "", node.getbalance(account))
	-
	+
	node.generate(101)
	-
	+
	expected_account_balances = {"": 5200}
	for account in accounts:
	expected_account_balances[account] = 0
	-
	+
	assert_equal(node.listaccounts(), expected_account_balances)
	-
	+
	assert_equal(node.getbalance(""), 5200)
	-
	+
	for account in accounts:
	address = node.getaccountaddress("")
	node.setaccount(address, account)
	assert(address in node.getaddressesbyaccount(account))
	assert(address not in node.getaddressesbyaccount(""))
	-
	+
	for account in accounts:
	addresses = []
	for x in range(10):
	addresses.append(node.getnewaddress())
	multisig_address = node.addmultisigaddress(5, addresses, account)
	node.sendfrom("", multisig_address, 50)
	-
	+
	node.generate(101)
	-
	+
	for account in accounts:
	assert_equal(node.getbalance(account), 50)

	if __name__ == '__main__':
	- WalletAccountsTest().main ()
	+ WalletAccountsTest().main()
	diff --git a/qa/rpc-tests/wallet-dump.py b/qa/rpc-tests/wallet-dump.py
	--- a/qa/rpc-tests/wallet-dump.py
	+++ b/qa/rpc-tests/wallet-dump.py
	@@ -4,7 +4,8 @@
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import BitcoinTestFramework
	-from test_framework.util import (start_nodes, start_node, assert_equal, bitcoind_processes)
	+from test_framework.util import (
	+ start_nodes, start_node, assert_equal, bitcoind_processes)


	def read_dump(file_name, addrs, hd_master_addr_old):
	@@ -65,17 +66,19 @@
	# longer than the default 30 seconds due to an expensive
	# CWallet::TopUpKeyPool call, and the encryptwallet RPC made later in
	# the test often takes even longer.
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args, timewait=60)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, self.extra_args, timewait=60)

	- def run_test (self):
	+ def run_test(self):
	tmpdir = self.options.tmpdir

	# generate 20 addresses to compare against the dump
	test_addr_count = 20
	addrs = []
	- for i in range(0,test_addr_count):
	+ for i in range(0, test_addr_count):
	addr = self.nodes[0].getnewaddress()
	- vaddr= self.nodes[0].validateaddress(addr) #required to get hd keypath
	+ vaddr = self.nodes[0].validateaddress(
	+ addr) # required to get hd keypath
	addrs.append(vaddr)
	# Should be a no-op:
	self.nodes[0].keypoolrefill()
	@@ -85,11 +88,13 @@

	found_addr, found_addr_chg, found_addr_rsv, hd_master_addr_unenc = \
	read_dump(tmpdir + "/node0/wallet.unencrypted.dump", addrs, None)
	- assert_equal(found_addr, test_addr_count) # all keys must be in the dump
	+ assert_equal(found_addr, test_addr_count)
	+ # all keys must be in the dump
	assert_equal(found_addr_chg, 50) # 50 blocks where mined
	- assert_equal(found_addr_rsv, 90 + 1) # keypool size (TODO: fix off-by-one)
	+ assert_equal(found_addr_rsv, 90 + 1)
	+ # keypool size (TODO: fix off-by-one)

	- #encrypt wallet, restart, unlock and dump
	+ # encrypt wallet, restart, unlock and dump
	self.nodes[0].encryptwallet('test')
	bitcoind_processes[0].wait()
	self.nodes[0] = start_node(0, self.options.tmpdir, self.extra_args[0])
	@@ -99,10 +104,13 @@
	self.nodes[0].dumpwallet(tmpdir + "/node0/wallet.encrypted.dump")

	found_addr, found_addr_chg, found_addr_rsv, hd_master_addr_enc = \
	- read_dump(tmpdir + "/node0/wallet.encrypted.dump", addrs, hd_master_addr_unenc)
	+ read_dump(
	+ tmpdir + "/node0/wallet.encrypted.dump", addrs, hd_master_addr_unenc)
	assert_equal(found_addr, test_addr_count)
	- assert_equal(found_addr_chg, 90 + 1 + 50) # old reserve keys are marked as change now
	- assert_equal(found_addr_rsv, 90 + 1) # keypool size (TODO: fix off-by-one)
	+ assert_equal(found_addr_chg, 90 + 1 + 50)
	+ # old reserve keys are marked as change now
	+ assert_equal(found_addr_rsv, 90 + 1)
	+ # keypool size (TODO: fix off-by-one)

	if __name__ == '__main__':
	- WalletDumpTest().main ()
	+ WalletDumpTest().main()
	diff --git a/qa/rpc-tests/wallet-hd.py b/qa/rpc-tests/wallet-hd.py
	--- a/qa/rpc-tests/wallet-hd.py
	+++ b/qa/rpc-tests/wallet-hd.py
	@@ -23,11 +23,12 @@
	self.node_args = [['-usehd=0'], ['-usehd=1', '-keypool=0']]

	def setup_network(self):
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, self.node_args)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, self.node_args)
	self.is_network_split = False
	connect_nodes_bi(self.nodes, 0, 1)

	- def run_test (self):
	+ def run_test(self):
	tmpdir = self.options.tmpdir

	# Make sure we use hd, keep masterkeyid
	@@ -38,9 +39,9 @@
	non_hd_add = self.nodes[0].getnewaddress()
	self.nodes[1].importprivkey(self.nodes[0].dumpprivkey(non_hd_add))

	- # This should be enough to keep the master key and the non-HD key
	+ # This should be enough to keep the master key and the non-HD key
	self.nodes[1].backupwallet(tmpdir + "/hd.bak")
	- #self.nodes[1].dumpwallet(tmpdir + "/hd.dump")
	+ # self.nodes[1].dumpwallet(tmpdir + "/hd.dump")

	# Derive some HD addresses and remember the last
	# Also send funds to each add
	@@ -50,7 +51,7 @@
	for i in range(num_hd_adds):
	hd_add = self.nodes[1].getnewaddress()
	hd_info = self.nodes[1].validateaddress(hd_add)
	- assert_equal(hd_info["hdkeypath"], "m/0'/0'/"+str(i+1)+"'")
	+ assert_equal(hd_info["hdkeypath"], "m/0'/0'/" + str(i + 1) + "'")
	assert_equal(hd_info["hdmasterkeyid"], masterkeyid)
	self.nodes[0].sendtoaddress(hd_add, 1)
	self.nodes[0].generate(1)
	@@ -63,25 +64,27 @@
	print("Restore backup ...")
	self.stop_node(1)
	os.remove(self.options.tmpdir + "/node1/regtest/wallet.dat")
	- shutil.copyfile(tmpdir + "/hd.bak", tmpdir + "/node1/regtest/wallet.dat")
	+ shutil.copyfile(
	+ tmpdir + "/hd.bak", tmpdir + "/node1/regtest/wallet.dat")
	self.nodes[1] = start_node(1, self.options.tmpdir, self.node_args[1])
	- #connect_nodes_bi(self.nodes, 0, 1)
	+ # connect_nodes_bi(self.nodes, 0, 1)

	# Assert that derivation is deterministic
	hd_add_2 = None
	for _ in range(num_hd_adds):
	hd_add_2 = self.nodes[1].getnewaddress()
	hd_info_2 = self.nodes[1].validateaddress(hd_add_2)
	- assert_equal(hd_info_2["hdkeypath"], "m/0'/0'/"+str(_+1)+"'")
	+ assert_equal(hd_info_2["hdkeypath"], "m/0'/0'/" + str(_ + 1) + "'")
	assert_equal(hd_info_2["hdmasterkeyid"], masterkeyid)
	assert_equal(hd_add, hd_add_2)

	# Needs rescan
	self.stop_node(1)
	- self.nodes[1] = start_node(1, self.options.tmpdir, self.node_args[1] + ['-rescan'])
	- #connect_nodes_bi(self.nodes, 0, 1)
	+ self.nodes[1] = start_node(
	+ 1, self.options.tmpdir, self.node_args[1] + ['-rescan'])
	+ # connect_nodes_bi(self.nodes, 0, 1)
	assert_equal(self.nodes[1].getbalance(), num_hd_adds + 1)


	if __name__ == '__main__':
	- WalletHDTest().main ()
	+ WalletHDTest().main()
	diff --git a/qa/rpc-tests/walletbackup.py b/qa/rpc-tests/walletbackup.py
	--- a/qa/rpc-tests/walletbackup.py
	+++ b/qa/rpc-tests/walletbackup.py
	@@ -37,7 +37,9 @@
	from test_framework.util import *
	from random import randint
	import logging
	-logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO, stream=sys.stdout)
	+logging.basicConfig(
	+ format='%(levelname)s: %(message)s', level=logging.INFO, stream=sys.stdout)
	+

	class WalletBackupTest(BitcoinTestFramework):

	@@ -46,21 +48,23 @@
	self.setup_clean_chain = True
	self.num_nodes = 4
	# nodes 1, 2,3 are spenders, let's give them a keypool=100
	- self.extra_args = [["-keypool=100"], ["-keypool=100"], ["-keypool=100"], []]
	+ self.extra_args = [
	+ ["-keypool=100"], ["-keypool=100"], ["-keypool=100"], []]

	# This mirrors how the network was setup in the bash test
	def setup_network(self, split=False):
	- self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args)
	+ self.nodes = start_nodes(
	+ self.num_nodes, self.options.tmpdir, self.extra_args)
	connect_nodes(self.nodes[0], 3)
	connect_nodes(self.nodes[1], 3)
	connect_nodes(self.nodes[2], 3)
	connect_nodes(self.nodes[2], 0)
	- self.is_network_split=False
	+ self.is_network_split = False
	self.sync_all()

	def one_send(self, from_node, to_address):
	- if (randint(1,2) == 1):
	- amount = Decimal(randint(1,10)) / Decimal(10)
	+ if (randint(1, 2) == 1):
	+ amount = Decimal(randint(1, 10)) / Decimal(10)
	self.nodes[from_node].sendtoaddress(to_address, amount)

	def do_one_round(self):
	@@ -149,9 +153,9 @@
	# 114 are mature, so the sum of all wallets should be 114 * 50 = 5700.
	assert_equal(total, 5700)

	- ##
	+ #
	# Test restoring spender wallets from backups
	- ##
	+ #
	logging.info("Restoring using wallet.dat")
	self.stop_three()
	self.erase_three()
	@@ -161,9 +165,12 @@
	shutil.rmtree(self.options.tmpdir + "/node2/regtest/chainstate")

	# Restore wallets from backup
	- shutil.copyfile(tmpdir + "/node0/wallet.bak", tmpdir + "/node0/regtest/wallet.dat")
	- shutil.copyfile(tmpdir + "/node1/wallet.bak", tmpdir + "/node1/regtest/wallet.dat")
	- shutil.copyfile(tmpdir + "/node2/wallet.bak", tmpdir + "/node2/regtest/wallet.dat")
	+ shutil.copyfile(
	+ tmpdir + "/node0/wallet.bak", tmpdir + "/node0/regtest/wallet.dat")
	+ shutil.copyfile(
	+ tmpdir + "/node1/wallet.bak", tmpdir + "/node1/regtest/wallet.dat")
	+ shutil.copyfile(
	+ tmpdir + "/node2/wallet.bak", tmpdir + "/node2/regtest/wallet.dat")

	logging.info("Re-starting nodes")
	self.start_three()
	@@ -177,7 +184,7 @@
	self.stop_three()
	self.erase_three()

	- #start node2 with no chain
	+ # start node2 with no chain
	shutil.rmtree(self.options.tmpdir + "/node2/regtest/blocks")
	shutil.rmtree(self.options.tmpdir + "/node2/regtest/chainstate")

	diff --git a/qa/rpc-tests/zapwallettxes.py b/qa/rpc-tests/zapwallettxes.py
	--- a/qa/rpc-tests/zapwallettxes.py
	+++ b/qa/rpc-tests/zapwallettxes.py
	@@ -16,62 +16,66 @@

	def setup_network(self, split=False):
	self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
	- connect_nodes_bi(self.nodes,0,1)
	- connect_nodes_bi(self.nodes,1,2)
	- connect_nodes_bi(self.nodes,0,2)
	- self.is_network_split=False
	+ connect_nodes_bi(self.nodes, 0, 1)
	+ connect_nodes_bi(self.nodes, 1, 2)
	+ connect_nodes_bi(self.nodes, 0, 2)
	+ self.is_network_split = False
	self.sync_all()

	- def run_test (self):
	+ def run_test(self):
	print("Mining blocks...")
	self.nodes[0].generate(1)
	self.sync_all()
	self.nodes[1].generate(101)
	self.sync_all()
	-
	+
	assert_equal(self.nodes[0].getbalance(), 50)
	-
	+
	txid0 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
	txid1 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()
	-
	+
	txid2 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
	txid3 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
	-
	+
	tx0 = self.nodes[0].gettransaction(txid0)
	- assert_equal(tx0['txid'], txid0) #tx0 must be available (confirmed)
	-
	+ assert_equal(tx0['txid'], txid0) # tx0 must be available (confirmed)
	+
	tx1 = self.nodes[0].gettransaction(txid1)
	- assert_equal(tx1['txid'], txid1) #tx1 must be available (confirmed)
	-
	+ assert_equal(tx1['txid'], txid1) # tx1 must be available (confirmed)
	+
	tx2 = self.nodes[0].gettransaction(txid2)
	- assert_equal(tx2['txid'], txid2) #tx2 must be available (unconfirmed)
	-
	+ assert_equal(tx2['txid'], txid2) # tx2 must be available (unconfirmed)
	+
	tx3 = self.nodes[0].gettransaction(txid3)
	- assert_equal(tx3['txid'], txid3) #tx3 must be available (unconfirmed)
	-
	- #restart bitcoind
	+ assert_equal(tx3['txid'], txid3) # tx3 must be available (unconfirmed)
	+
	+ # restart bitcoind
	self.nodes[0].stop()
	bitcoind_processes[0].wait()
	- self.nodes[0] = start_node(0,self.options.tmpdir)
	-
	+ self.nodes[0] = start_node(0, self.options.tmpdir)
	+
	tx3 = self.nodes[0].gettransaction(txid3)
	- assert_equal(tx3['txid'], txid3) #tx must be available (unconfirmed)
	-
	+ assert_equal(tx3['txid'], txid3) # tx must be available (unconfirmed)
	+
	self.nodes[0].stop()
	bitcoind_processes[0].wait()
	-
	- #restart bitcoind with zapwallettxes
	- self.nodes[0] = start_node(0,self.options.tmpdir, ["-zapwallettxes=1"])
	-
	+
	+ # restart bitcoind with zapwallettxes
	+ self.nodes[0] = start_node(
	+ 0, self.options.tmpdir, ["-zapwallettxes=1"])
	+
	assert_raises(JSONRPCException, self.nodes[0].gettransaction, [txid3])
	- #there must be a expection because the unconfirmed wallettx0 must be gone by now
	+ # there must be a expection because the unconfirmed wallettx0 must be
	+ # gone by now

	tx0 = self.nodes[0].gettransaction(txid0)
	- assert_equal(tx0['txid'], txid0) #tx0 (confirmed) must still be available because it was confirmed
	+ assert_equal(tx0['txid'], txid0)
	+ # tx0 (confirmed) must still be available because it was
	+ # confirmed


	if __name__ == '__main__':
	- ZapWalletTXesTest ().main ()
	+ ZapWalletTXesTest().main()
	diff --git a/qa/rpc-tests/zmq_test.py b/qa/rpc-tests/zmq_test.py
	--- a/qa/rpc-tests/zmq_test.py
	+++ b/qa/rpc-tests/zmq_test.py
	@@ -12,6 +12,7 @@
	import zmq
	import struct

	+
	class ZMQTest (BitcoinTestFramework):

	def __init__(self):
	@@ -27,11 +28,12 @@
	self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashtx")
	self.zmqSubSocket.connect("tcp://127.0.0.1:%i" % self.port)
	return start_nodes(self.num_nodes, self.options.tmpdir, extra_args=[
	- ['-zmqpubhashtx=tcp://127.0.0.1:'+str(self.port), '-zmqpubhashblock=tcp://127.0.0.1:'+str(self.port)],
	+ ['-zmqpubhashtx=tcp://127.0.0.1:' +
	+ str(self.port), '-zmqpubhashblock=tcp://127.0.0.1:' + str(self.port)],
	[],
	[],
	[]
	- ])
	+ ])

	def run_test(self):
	self.sync_all()
	@@ -46,16 +48,18 @@
	body = msg[1]
	nseq = msg[2]
	msgSequence = struct.unpack('<I', msg[-1])[-1]
	- assert_equal(msgSequence, 0) #must be sequence 0 on hashtx
	+ assert_equal(msgSequence, 0) # must be sequence 0 on hashtx

	msg = self.zmqSubSocket.recv_multipart()
	topic = msg[0]
	body = msg[1]
	msgSequence = struct.unpack('<I', msg[-1])[-1]
	- assert_equal(msgSequence, 0) #must be sequence 0 on hashblock
	+ assert_equal(msgSequence, 0) # must be sequence 0 on hashblock
	blkhash = bytes_to_hex_str(body)

	- assert_equal(genhashes[0], blkhash) #blockhash from generate must be equal to the hash received over zmq
	+ assert_equal(genhashes[0], blkhash)
	+ # blockhash from generate must be equal to the hash
	+ # received over zmq

	n = 10
	genhashes = self.nodes[1].generate(n)
	@@ -63,21 +67,24 @@

	zmqHashes = []
	blockcount = 0
	- for x in range(0,n*2):
	+ for x in range(0, n * 2):
	msg = self.zmqSubSocket.recv_multipart()
	topic = msg[0]
	body = msg[1]
	if topic == b"hashblock":
	zmqHashes.append(bytes_to_hex_str(body))
	msgSequence = struct.unpack('<I', msg[-1])[-1]
	- assert_equal(msgSequence, blockcount+1)
	+ assert_equal(msgSequence, blockcount + 1)
	blockcount += 1

	- for x in range(0,n):
	- assert_equal(genhashes[x], zmqHashes[x]) #blockhash from generate must be equal to the hash received over zmq
	+ for x in range(0, n):
	+ assert_equal(genhashes[x], zmqHashes[x])
	+ # blockhash from generate must be equal to the hash
	+ # received over zmq

	- #test tx from a second node
	- hashRPC = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1.0)
	+ # test tx from a second node
	+ hashRPC = self.nodes[1].sendtoaddress(
	+ self.nodes[0].getnewaddress(), 1.0)
	self.sync_all()

	# now we should receive a zmq msg because the tx was broadcast
	@@ -88,10 +95,12 @@
	if topic == b"hashtx":
	hashZMQ = bytes_to_hex_str(body)
	msgSequence = struct.unpack('<I', msg[-1])[-1]
	- assert_equal(msgSequence, blockcount+1)
	+ assert_equal(msgSequence, blockcount + 1)

	- assert_equal(hashRPC, hashZMQ) #blockhash from generate must be equal to the hash received over zmq
	+ assert_equal(hashRPC, hashZMQ)
	+ # blockhash from generate must be equal to the hash
	+ # received over zmq


	if __name__ == '__main__':
	- ZMQTest ().main ()
	+ ZMQTest().main()

File Metadata

Mime Type: text/plain
Expires: Sat, Mar 1, 10:11 (6 h, 57 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187303
Default Alt Text: D496.diff (223 KB)

D496.diffNo OneTemporaryActions

D496.diffView Options

File Metadata

Event Timeline

D496.diff
No OneTemporary
Actions

D496.diff
View Options