No OneTemporary
Actions

Size

478 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/qa/rpc-tests/abandonconflict.py b/qa/rpc-tests/abandonconflict.py
	index b6c4b9db48..c50c3cc562 100755
	--- a/qa/rpc-tests/abandonconflict.py
	+++ b/qa/rpc-tests/abandonconflict.py
	@@ -1,156 +1,160 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.


	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	import urllib.parse

	class AbandonConflictTest(BitcoinTestFramework):
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 2
	+ self.setup_clean_chain = False

	def setup_network(self):
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.00001"]))
	self.nodes.append(start_node(1, self.options.tmpdir, ["-debug","-logtimemicros"]))
	connect_nodes(self.nodes[0], 1)

	def run_test(self):
	self.nodes[1].generate(100)
	sync_blocks(self.nodes)
	balance = self.nodes[0].getbalance()
	txA = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
	txB = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
	txC = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
	sync_mempools(self.nodes)
	self.nodes[1].generate(1)

	sync_blocks(self.nodes)
	newbalance = self.nodes[0].getbalance()
	assert(balance - newbalance < Decimal("0.001")) #no more than fees lost
	balance = newbalance

	url = urllib.parse.urlparse(self.nodes[1].url)
	self.nodes[0].disconnectnode(url.hostname+":"+str(p2p_port(1)))

	# Identify the 10btc outputs
	nA = next(i for i, vout in enumerate(self.nodes[0].getrawtransaction(txA, 1)["vout"]) if vout["value"] == Decimal("10"))
	nB = next(i for i, vout in enumerate(self.nodes[0].getrawtransaction(txB, 1)["vout"]) if vout["value"] == Decimal("10"))
	nC = next(i for i, vout in enumerate(self.nodes[0].getrawtransaction(txC, 1)["vout"]) if vout["value"] == Decimal("10"))

	inputs =[]
	# spend 10btc outputs from txA and txB
	inputs.append({"txid":txA, "vout":nA})
	inputs.append({"txid":txB, "vout":nB})
	outputs = {}

	outputs[self.nodes[0].getnewaddress()] = Decimal("14.99998")
	outputs[self.nodes[1].getnewaddress()] = Decimal("5")
	signed = self.nodes[0].signrawtransaction(self.nodes[0].createrawtransaction(inputs, outputs))
	txAB1 = self.nodes[0].sendrawtransaction(signed["hex"])

	# Identify the 14.99998btc output
	nAB = next(i for i, vout in enumerate(self.nodes[0].getrawtransaction(txAB1, 1)["vout"]) if vout["value"] == Decimal("14.99998"))

	#Create a child tx spending AB1 and C
	inputs = []
	inputs.append({"txid":txAB1, "vout":nAB})
	inputs.append({"txid":txC, "vout":nC})
	outputs = {}
	outputs[self.nodes[0].getnewaddress()] = Decimal("24.9996")
	signed2 = self.nodes[0].signrawtransaction(self.nodes[0].createrawtransaction(inputs, outputs))
	txABC2 = self.nodes[0].sendrawtransaction(signed2["hex"])

	# In mempool txs from self should increase balance from change
	newbalance = self.nodes[0].getbalance()
	assert(newbalance == balance - Decimal("30") + Decimal("24.9996"))
	balance = newbalance

	# Restart the node with a higher min relay fee so the parent tx is no longer in mempool
	# TODO: redo with eviction
	# Note had to make sure tx did not have AllowFree priority
	stop_node(self.nodes[0],0)
	self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.0001"])

	# Verify txs no longer in mempool
	assert(len(self.nodes[0].getrawmempool()) == 0)

	# Not in mempool txs from self should only reduce balance
	# inputs are still spent, but change not received
	newbalance = self.nodes[0].getbalance()
	assert(newbalance == balance - Decimal("24.9996"))
	# Unconfirmed received funds that are not in mempool, also shouldn't show
	# up in unconfirmed balance
	unconfbalance = self.nodes[0].getunconfirmedbalance() + self.nodes[0].getbalance()
	assert(unconfbalance == newbalance)
	# Also shouldn't show up in listunspent
	assert(not txABC2 in [utxo["txid"] for utxo in self.nodes[0].listunspent(0)])
	balance = newbalance

	# Abandon original transaction and verify inputs are available again
	# including that the child tx was also abandoned
	self.nodes[0].abandontransaction(txAB1)
	newbalance = self.nodes[0].getbalance()
	assert(newbalance == balance + Decimal("30"))
	balance = newbalance

	# Verify that even with a low min relay fee, the tx is not reaccepted from wallet on startup once abandoned
	stop_node(self.nodes[0],0)
	self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.00001"])
	assert(len(self.nodes[0].getrawmempool()) == 0)
	assert(self.nodes[0].getbalance() == balance)

	# But if its received again then it is unabandoned
	# And since now in mempool, the change is available
	# But its child tx remains abandoned
	self.nodes[0].sendrawtransaction(signed["hex"])
	newbalance = self.nodes[0].getbalance()
	assert(newbalance == balance - Decimal("20") + Decimal("14.99998"))
	balance = newbalance

	# Send child tx again so its unabandoned
	self.nodes[0].sendrawtransaction(signed2["hex"])
	newbalance = self.nodes[0].getbalance()
	assert(newbalance == balance - Decimal("10") - Decimal("14.99998") + Decimal("24.9996"))
	balance = newbalance

	# Remove using high relay fee again
	stop_node(self.nodes[0],0)
	self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-logtimemicros","-minrelaytxfee=0.0001"])
	assert(len(self.nodes[0].getrawmempool()) == 0)
	newbalance = self.nodes[0].getbalance()
	assert(newbalance == balance - Decimal("24.9996"))
	balance = newbalance

	# Create a double spend of AB1 by spending again from only A's 10 output
	# Mine double spend from node 1
	inputs =[]
	inputs.append({"txid":txA, "vout":nA})
	outputs = {}
	outputs[self.nodes[1].getnewaddress()] = Decimal("9.9999")
	tx = self.nodes[0].createrawtransaction(inputs, outputs)
	signed = self.nodes[0].signrawtransaction(tx)
	self.nodes[1].sendrawtransaction(signed["hex"])
	self.nodes[1].generate(1)

	connect_nodes(self.nodes[0], 1)
	sync_blocks(self.nodes)

	# Verify that B and C's 10 BTC outputs are available for spending again because AB1 is now conflicted
	newbalance = self.nodes[0].getbalance()
	assert(newbalance == balance + Decimal("20"))
	balance = newbalance

	# There is currently a minor bug around this and so this test doesn't work. See Issue #7315
	# Invalidate the block with the double spend and B's 10 BTC output should no longer be available
	# Don't think C's should either
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
	newbalance = self.nodes[0].getbalance()
	#assert(newbalance == balance - Decimal("10"))
	print("If balance has not declined after invalidateblock then out of mempool wallet tx which is no longer")
	print("conflicted has not resumed causing its inputs to be seen as spent. See Issue #7315")
	print(str(balance) + " -> " + str(newbalance) + " ?")

	if __name__ == '__main__':
	AbandonConflictTest().main()
	diff --git a/qa/rpc-tests/bip65-cltv-p2p.py b/qa/rpc-tests/bip65-cltv-p2p.py
	index 60923b9dda..754b6873b7 100755
	--- a/qa/rpc-tests/bip65-cltv-p2p.py
	+++ b/qa/rpc-tests/bip65-cltv-p2p.py
	@@ -1,180 +1,181 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import ComparisonTestFramework
	from test_framework.util import *
	from test_framework.mininode import CTransaction, NetworkThread
	from test_framework.blocktools import create_coinbase, create_block
	from test_framework.comptool import TestInstance, TestManager
	from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP
	from io import BytesIO
	import time

	def cltv_invalidate(tx):
	'''Modify the signature in vin 0 of the tx to fail CLTV

	Prepends -1 CLTV DROP in the scriptSig itself.
	'''
	tx.vin[0].scriptSig = CScript([OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP] +
	list(CScript(tx.vin[0].scriptSig)))

	'''
	This test is meant to exercise BIP65 (CHECKLOCKTIMEVERIFY)
	Connect to a single node.
	Mine 2 (version 3) blocks (save the coinbases for later).
	Generate 98 more version 3 blocks, verify the node accepts.
	Mine 749 version 4 blocks, verify the node accepts.
	Check that the new CLTV rules are not enforced on the 750th version 4 block.
	Check that the new CLTV rules are enforced on the 751st version 4 block.
	Mine 199 new version blocks.
	Mine 1 old-version block.
	Mine 1 new version block.
	Mine 1 old version block, see that the node rejects.
	'''

	class BIP65Test(ComparisonTestFramework):

	def __init__(self):
	+ super().__init__()
	self.num_nodes = 1

	def setup_network(self):
	# Must set the blockversion for this test
	- self.nodes = start_nodes(1, self.options.tmpdir,
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	extra_args=[['-debug', '-whitelist=127.0.0.1', '-blockversion=3']],
	binary=[self.options.testbinary])

	def run_test(self):
	test = TestManager(self, self.options.tmpdir)
	test.add_all_connections(self.nodes)
	NetworkThread().start() # Start up network handling in another thread
	test.run()

	def create_transaction(self, node, coinbase, to_address, amount):
	from_txid = node.getblock(coinbase)['tx'][0]
	inputs = [{ "txid" : from_txid, "vout" : 0}]
	outputs = { to_address : amount }
	rawtx = node.createrawtransaction(inputs, outputs)
	signresult = node.signrawtransaction(rawtx)
	tx = CTransaction()
	f = BytesIO(hex_str_to_bytes(signresult['hex']))
	tx.deserialize(f)
	return tx

	def get_tests(self):

	self.coinbase_blocks = self.nodes[0].generate(2)
	height = 3 # height of the next block to build
	self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
	self.nodeaddress = self.nodes[0].getnewaddress()
	self.last_block_time = int(time.time())

	''' 98 more version 3 blocks '''
	test_blocks = []
	for i in range(98):
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.rehash()
	block.solve()
	test_blocks.append([block, True])
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance(test_blocks, sync_every_block=False)

	''' Mine 749 version 4 blocks '''
	test_blocks = []
	for i in range(749):
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 4
	block.rehash()
	block.solve()
	test_blocks.append([block, True])
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance(test_blocks, sync_every_block=False)

	'''
	Check that the new CLTV rules are not enforced in the 750th
	version 3 block.
	'''
	spendtx = self.create_transaction(self.nodes[0],
	self.coinbase_blocks[0], self.nodeaddress, 1.0)
	cltv_invalidate(spendtx)
	spendtx.rehash()

	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 4
	block.vtx.append(spendtx)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()

	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	'''
	Check that the new CLTV rules are enforced in the 751st version 4
	block.
	'''
	spendtx = self.create_transaction(self.nodes[0],
	self.coinbase_blocks[1], self.nodeaddress, 1.0)
	cltv_invalidate(spendtx)
	spendtx.rehash()

	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 4
	block.vtx.append(spendtx)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()
	self.last_block_time += 1
	yield TestInstance([[block, False]])

	''' Mine 199 new version blocks on last valid tip '''
	test_blocks = []
	for i in range(199):
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 4
	block.rehash()
	block.solve()
	test_blocks.append([block, True])
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance(test_blocks, sync_every_block=False)

	''' Mine 1 old version block '''
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.rehash()
	block.solve()
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	''' Mine 1 new version block '''
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 4
	block.rehash()
	block.solve()
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	''' Mine 1 old version block, should be invalid '''
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.rehash()
	block.solve()
	self.last_block_time += 1
	yield TestInstance([[block, False]])

	if __name__ == '__main__':
	BIP65Test().main()
	diff --git a/qa/rpc-tests/bip65-cltv.py b/qa/rpc-tests/bip65-cltv.py
	index 9d83fc947b..abba7fc20e 100755
	--- a/qa/rpc-tests/bip65-cltv.py
	+++ b/qa/rpc-tests/bip65-cltv.py
	@@ -1,87 +1,91 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test the CHECKLOCKTIMEVERIFY (BIP65) soft-fork logic
	#

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

	class BIP65Test(BitcoinTestFramework):
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 3
	+ self.setup_clean_chain = False

	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"]))
	connect_nodes(self.nodes[1], 0)
	connect_nodes(self.nodes[2], 0)
	self.is_network_split = False
	self.sync_all()

	def run_test(self):
	cnt = self.nodes[0].getblockcount()

	# Mine some old-version blocks
	self.nodes[1].generate(100)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 100):
	raise AssertionError("Failed to mine 100 version=3 blocks")

	# Mine 750 new-version blocks
	for i in range(15):
	self.nodes[2].generate(50)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 850):
	raise AssertionError("Failed to mine 750 version=4 blocks")

	# TODO: check that new CHECKLOCKTIMEVERIFY rules are not enforced

	# Mine 1 new-version block
	self.nodes[2].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 851):
	raise AssertionError("Failed to mine a version=4 blocks")

	# TODO: check that new CHECKLOCKTIMEVERIFY rules are enforced

	# Mine 198 new-version blocks
	for i in range(2):
	self.nodes[2].generate(99)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1049):
	raise AssertionError("Failed to mine 198 version=4 blocks")

	# Mine 1 old-version block
	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")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1051):
	raise AssertionError("Failed to mine a version=4 block")

	# 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")
	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")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1052):
	raise AssertionError("Failed to mine a version=4 block")

	if __name__ == '__main__':
	BIP65Test().main()
	diff --git a/qa/rpc-tests/bip68-112-113-p2p.py b/qa/rpc-tests/bip68-112-113-p2p.py
	index eedb60e3a0..8ba0704384 100755
	--- a/qa/rpc-tests/bip68-112-113-p2p.py
	+++ b/qa/rpc-tests/bip68-112-113-p2p.py
	@@ -1,538 +1,539 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import ComparisonTestFramework
	from test_framework.util import *
	from test_framework.mininode import ToHex, CTransaction, NetworkThread
	from test_framework.blocktools import create_coinbase, create_block
	from test_framework.comptool import TestInstance, TestManager
	from test_framework.script import *
	from io import BytesIO
	import time

	'''
	This test is meant to exercise activation of the first version bits soft fork
	This soft fork will activate the following BIPS:
	BIP 68 - nSequence relative lock times
	BIP 112 - CHECKSEQUENCEVERIFY
	BIP 113 - MedianTimePast semantics for nLockTime

	regtest lock-in with 108/144 block signalling
	activation after a further 144 blocks

	mine 82 blocks whose coinbases will be used to generate inputs for our tests
	mine 61 blocks to transition from DEFINED to STARTED
	mine 144 blocks only 100 of which are signaling readiness in order to fail to change state this period
	mine 144 blocks with 108 signaling and verify STARTED->LOCKED_IN
	mine 140 blocks and seed block chain with the 82 inputs will use for our tests at height 572
	mine 3 blocks and verify still at LOCKED_IN and test that enforcement has not triggered
	mine 1 block and test that enforcement has triggered (which triggers ACTIVE)
	Test BIP 113 is enforced
	Mine 4 blocks so next height is 580 and test BIP 68 is enforced for time and height
	Mine 1 block so next height is 581 and test BIP 68 now passes time but not height
	Mine 1 block so next height is 582 and test BIP 68 now passes time and height
	Test that BIP 112 is enforced

	Various transactions will be used to test that the BIPs rules are not enforced before the soft fork activates
	And that after the soft fork activates transactions pass and fail as they should according to the rules.
	For each BIP, transactions of versions 1 and 2 will be tested.
	----------------
	BIP 113:
	bip113tx - modify the nLocktime variable

	BIP 68:
	bip68txs - 16 txs with nSequence relative locktime of 10 with various bits set as per the relative_locktimes below

	BIP 112:
	bip112txs_vary_nSequence - 16 txs with nSequence relative_locktimes of 10 evaluated against 10 OP_CSV OP_DROP
	bip112txs_vary_nSequence_9 - 16 txs with nSequence relative_locktimes of 9 evaluated against 10 OP_CSV OP_DROP
	bip112txs_vary_OP_CSV - 16 txs with nSequence = 10 evaluated against varying {relative_locktimes of 10} OP_CSV OP_DROP
	bip112txs_vary_OP_CSV_9 - 16 txs with nSequence = 9 evaluated against varying {relative_locktimes of 10} OP_CSV OP_DROP
	bip112tx_special - test negative argument to OP_CSV
	'''

	base_relative_locktime = 10
	seq_disable_flag = 1<<31
	seq_random_high_bit = 1<<25
	seq_type_flag = 1<<22
	seq_random_low_bit = 1<<18

	# b31,b25,b22,b18 represent the 31st, 25th, 22nd and 18th bits respectively in the nSequence field
	# relative_locktimes[b31][b25][b22][b18] is a base_relative_locktime with the indicated bits set if their indices are 1
	relative_locktimes = []
	for b31 in range(2):
	b25times = []
	for b25 in range(2):
	b22times = []
	for b22 in range(2):
	b18times = []
	for b18 in range(2):
	rlt = base_relative_locktime
	if (b31):
	rlt = rlt \| seq_disable_flag
	if (b25):
	rlt = rlt \| seq_random_high_bit
	if (b22):
	rlt = rlt \| seq_type_flag
	if (b18):
	rlt = rlt \| seq_random_low_bit
	b18times.append(rlt)
	b22times.append(b18times)
	b25times.append(b22times)
	relative_locktimes.append(b25times)

	def all_rlt_txs(txarray):
	txs = []
	for b31 in range(2):
	for b25 in range(2):
	for b22 in range(2):
	for b18 in range(2):
	txs.append(txarray[b31][b25][b22][b18])
	return txs

	class BIP68_112_113Test(ComparisonTestFramework):
	def __init__(self):
	+ super().__init__()
	self.num_nodes = 1

	def setup_network(self):
	# Must set the blockversion for this test
	- self.nodes = start_nodes(1, self.options.tmpdir,
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	extra_args=[['-debug', '-whitelist=127.0.0.1', '-blockversion=4']],
	binary=[self.options.testbinary])

	def run_test(self):
	test = TestManager(self, self.options.tmpdir)
	test.add_all_connections(self.nodes)
	NetworkThread().start() # Start up network handling in another thread
	test.run()

	def send_generic_input_tx(self, node, coinbases):
	amount = Decimal("49.99")
	return node.sendrawtransaction(ToHex(self.sign_transaction(node, self.create_transaction(node, node.getblock(coinbases.pop())['tx'][0], self.nodeaddress, amount))))

	def create_transaction(self, node, txid, to_address, amount):
	inputs = [{ "txid" : txid, "vout" : 0}]
	outputs = { to_address : amount }
	rawtx = node.createrawtransaction(inputs, outputs)
	tx = CTransaction()
	f = BytesIO(hex_str_to_bytes(rawtx))
	tx.deserialize(f)
	return tx

	def sign_transaction(self, node, unsignedtx):
	rawtx = ToHex(unsignedtx)
	signresult = node.signrawtransaction(rawtx)
	tx = CTransaction()
	f = BytesIO(hex_str_to_bytes(signresult['hex']))
	tx.deserialize(f)
	return tx

	def generate_blocks(self, number, version, test_blocks = []):
	for i in range(number):
	block = self.create_test_block([], version)
	test_blocks.append([block, True])
	self.last_block_time += 600
	self.tip = block.sha256
	self.tipheight += 1
	return test_blocks

	def create_test_block(self, txs, version = 536870912):
	block = create_block(self.tip, create_coinbase(self.tipheight + 1), self.last_block_time + 600)
	block.nVersion = version
	block.vtx.extend(txs)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()
	return block

	def create_bip68txs(self, bip68inputs, txversion, locktime_delta = 0):
	txs = []
	assert(len(bip68inputs) >= 16)
	i = 0
	for b31 in range(2):
	b25txs = []
	for b25 in range(2):
	b22txs = []
	for b22 in range(2):
	b18txs = []
	for b18 in range(2):
	tx = self.create_transaction(self.nodes[0], bip68inputs[i], self.nodeaddress, Decimal("49.98"))
	i += 1
	tx.nVersion = txversion
	tx.vin[0].nSequence = relative_locktimes[b31][b25][b22][b18] + locktime_delta
	b18txs.append(self.sign_transaction(self.nodes[0], tx))
	b22txs.append(b18txs)
	b25txs.append(b22txs)
	txs.append(b25txs)
	return txs

	def create_bip112special(self, input, txversion):
	tx = self.create_transaction(self.nodes[0], input, self.nodeaddress, Decimal("49.98"))
	tx.nVersion = txversion
	signtx = self.sign_transaction(self.nodes[0], tx)
	signtx.vin[0].scriptSig = CScript([-1, OP_NOP3, OP_DROP] + list(CScript(signtx.vin[0].scriptSig)))
	return signtx

	def create_bip112txs(self, bip112inputs, varyOP_CSV, txversion, locktime_delta = 0):
	txs = []
	assert(len(bip112inputs) >= 16)
	i = 0
	for b31 in range(2):
	b25txs = []
	for b25 in range(2):
	b22txs = []
	for b22 in range(2):
	b18txs = []
	for b18 in range(2):
	tx = self.create_transaction(self.nodes[0], bip112inputs[i], self.nodeaddress, Decimal("49.98"))
	i += 1
	if (varyOP_CSV): # if varying OP_CSV, nSequence is fixed
	tx.vin[0].nSequence = base_relative_locktime + locktime_delta
	else: # vary nSequence instead, OP_CSV is fixed
	tx.vin[0].nSequence = relative_locktimes[b31][b25][b22][b18] + locktime_delta
	tx.nVersion = txversion
	signtx = self.sign_transaction(self.nodes[0], tx)
	if (varyOP_CSV):
	signtx.vin[0].scriptSig = CScript([relative_locktimes[b31][b25][b22][b18], OP_NOP3, OP_DROP] + list(CScript(signtx.vin[0].scriptSig)))
	else:
	signtx.vin[0].scriptSig = CScript([base_relative_locktime, OP_NOP3, OP_DROP] + list(CScript(signtx.vin[0].scriptSig)))
	b18txs.append(signtx)
	b22txs.append(b18txs)
	b25txs.append(b22txs)
	txs.append(b25txs)
	return txs

	def get_tests(self):
	long_past_time = int(time.time()) - 600 * 1000 # enough to build up to 1000 blocks 10 minutes apart without worrying about getting into the future
	self.nodes[0].setmocktime(long_past_time - 100) # enough so that the generated blocks will still all be before long_past_time
	self.coinbase_blocks = self.nodes[0].generate(1 + 16 + 2*32 + 1) # 82 blocks generated for inputs
	self.nodes[0].setmocktime(0) # set time back to present so yielded blocks aren't in the future as we advance last_block_time
	self.tipheight = 82 # height of the next block to build
	self.last_block_time = long_past_time
	self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
	self.nodeaddress = self.nodes[0].getnewaddress()

	assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'defined')
	test_blocks = self.generate_blocks(61, 4)
	yield TestInstance(test_blocks, sync_every_block=False) # 1
	# Advanced from DEFINED to STARTED, height = 143
	assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'started')

	# Fail to achieve LOCKED_IN 100 out of 144 signal bit 0
	# using a variety of bits to simulate multiple parallel softforks
	test_blocks = self.generate_blocks(50, 536870913) # 0x20000001 (signalling ready)
	test_blocks = self.generate_blocks(20, 4, test_blocks) # 0x00000004 (signalling not)
	test_blocks = self.generate_blocks(50, 536871169, test_blocks) # 0x20000101 (signalling ready)
	test_blocks = self.generate_blocks(24, 536936448, test_blocks) # 0x20010000 (signalling not)
	yield TestInstance(test_blocks, sync_every_block=False) # 2
	# Failed to advance past STARTED, height = 287
	assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'started')

	# 108 out of 144 signal bit 0 to achieve lock-in
	# using a variety of bits to simulate multiple parallel softforks
	test_blocks = self.generate_blocks(58, 536870913) # 0x20000001 (signalling ready)
	test_blocks = self.generate_blocks(26, 4, test_blocks) # 0x00000004 (signalling not)
	test_blocks = self.generate_blocks(50, 536871169, test_blocks) # 0x20000101 (signalling ready)
	test_blocks = self.generate_blocks(10, 536936448, test_blocks) # 0x20010000 (signalling not)
	yield TestInstance(test_blocks, sync_every_block=False) # 3
	# Advanced from STARTED to LOCKED_IN, height = 431
	assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'locked_in')

	# 140 more version 4 blocks
	test_blocks = self.generate_blocks(140, 4)
	yield TestInstance(test_blocks, sync_every_block=False) # 4

	### Inputs at height = 572
	# Put inputs for all tests in the chain at height 572 (tip now = 571) (time increases by 600s per block)
	# Note we reuse inputs for v1 and v2 txs so must test these separately
	# 16 normal inputs
	bip68inputs = []
	for i in range(16):
	bip68inputs.append(self.send_generic_input_tx(self.nodes[0], self.coinbase_blocks))
	# 2 sets of 16 inputs with 10 OP_CSV OP_DROP (actually will be prepended to spending scriptSig)
	bip112basicinputs = []
	for j in range(2):
	inputs = []
	for i in range(16):
	inputs.append(self.send_generic_input_tx(self.nodes[0], self.coinbase_blocks))
	bip112basicinputs.append(inputs)
	# 2 sets of 16 varied inputs with (relative_lock_time) OP_CSV OP_DROP (actually will be prepended to spending scriptSig)
	bip112diverseinputs = []
	for j in range(2):
	inputs = []
	for i in range(16):
	inputs.append(self.send_generic_input_tx(self.nodes[0], self.coinbase_blocks))
	bip112diverseinputs.append(inputs)
	# 1 special input with -1 OP_CSV OP_DROP (actually will be prepended to spending scriptSig)
	bip112specialinput = self.send_generic_input_tx(self.nodes[0], self.coinbase_blocks)
	# 1 normal input
	bip113input = self.send_generic_input_tx(self.nodes[0], self.coinbase_blocks)

	self.nodes[0].setmocktime(self.last_block_time + 600)
	inputblockhash = self.nodes[0].generate(1)[0] # 1 block generated for inputs to be in chain at height 572
	self.nodes[0].setmocktime(0)
	self.tip = int("0x" + inputblockhash, 0)
	self.tipheight += 1
	self.last_block_time += 600
	assert_equal(len(self.nodes[0].getblock(inputblockhash,True)["tx"]), 82+1)

	# 2 more version 4 blocks
	test_blocks = self.generate_blocks(2, 4)
	yield TestInstance(test_blocks, sync_every_block=False) # 5
	# Not yet advanced to ACTIVE, height = 574 (will activate for block 576, not 575)
	assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'locked_in')

	# Test both version 1 and version 2 transactions for all tests
	# BIP113 test transaction will be modified before each use to put in appropriate block time
	bip113tx_v1 = self.create_transaction(self.nodes[0], bip113input, self.nodeaddress, Decimal("49.98"))
	bip113tx_v1.vin[0].nSequence = 0xFFFFFFFE
	bip113tx_v2 = self.create_transaction(self.nodes[0], bip113input, self.nodeaddress, Decimal("49.98"))
	bip113tx_v2.vin[0].nSequence = 0xFFFFFFFE
	bip113tx_v2.nVersion = 2

	# For BIP68 test all 16 relative sequence locktimes
	bip68txs_v1 = self.create_bip68txs(bip68inputs, 1)
	bip68txs_v2 = self.create_bip68txs(bip68inputs, 2)

	# For BIP112 test:
	# 16 relative sequence locktimes of 10 against 10 OP_CSV OP_DROP inputs
	bip112txs_vary_nSequence_v1 = self.create_bip112txs(bip112basicinputs[0], False, 1)
	bip112txs_vary_nSequence_v2 = self.create_bip112txs(bip112basicinputs[0], False, 2)
	# 16 relative sequence locktimes of 9 against 10 OP_CSV OP_DROP inputs
	bip112txs_vary_nSequence_9_v1 = self.create_bip112txs(bip112basicinputs[1], False, 1, -1)
	bip112txs_vary_nSequence_9_v2 = self.create_bip112txs(bip112basicinputs[1], False, 2, -1)
	# sequence lock time of 10 against 16 (relative_lock_time) OP_CSV OP_DROP inputs
	bip112txs_vary_OP_CSV_v1 = self.create_bip112txs(bip112diverseinputs[0], True, 1)
	bip112txs_vary_OP_CSV_v2 = self.create_bip112txs(bip112diverseinputs[0], True, 2)
	# sequence lock time of 9 against 16 (relative_lock_time) OP_CSV OP_DROP inputs
	bip112txs_vary_OP_CSV_9_v1 = self.create_bip112txs(bip112diverseinputs[1], True, 1, -1)
	bip112txs_vary_OP_CSV_9_v2 = self.create_bip112txs(bip112diverseinputs[1], True, 2, -1)
	# -1 OP_CSV OP_DROP input
	bip112tx_special_v1 = self.create_bip112special(bip112specialinput, 1)
	bip112tx_special_v2 = self.create_bip112special(bip112specialinput, 2)


	### TESTING ###
	##################################
	### Before Soft Forks Activate ###
	##################################
	# All txs should pass
	### Version 1 txs ###
	success_txs = []
	# add BIP113 tx and -1 CSV tx
	bip113tx_v1.nLockTime = self.last_block_time - 600 * 5 # = MTP of prior block (not <) but < time put on current block
	bip113signed1 = self.sign_transaction(self.nodes[0], bip113tx_v1)
	success_txs.append(bip113signed1)
	success_txs.append(bip112tx_special_v1)
	# add BIP 68 txs
	success_txs.extend(all_rlt_txs(bip68txs_v1))
	# add BIP 112 with seq=10 txs
	success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_v1))
	success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_v1))
	# try BIP 112 with seq=9 txs
	success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v1))
	success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_9_v1))
	yield TestInstance([[self.create_test_block(success_txs), True]]) # 6
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	### Version 2 txs ###
	success_txs = []
	# add BIP113 tx and -1 CSV tx
	bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 # = MTP of prior block (not <) but < time put on current block
	bip113signed2 = self.sign_transaction(self.nodes[0], bip113tx_v2)
	success_txs.append(bip113signed2)
	success_txs.append(bip112tx_special_v2)
	# add BIP 68 txs
	success_txs.extend(all_rlt_txs(bip68txs_v2))
	# add BIP 112 with seq=10 txs
	success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_v2))
	success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_v2))
	# try BIP 112 with seq=9 txs
	success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v2))
	success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_9_v2))
	yield TestInstance([[self.create_test_block(success_txs), True]]) # 7
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())


	# 1 more version 4 block to get us to height 575 so the fork should now be active for the next block
	test_blocks = self.generate_blocks(1, 4)
	yield TestInstance(test_blocks, sync_every_block=False) # 8
	assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'active')


	#################################
	### After Soft Forks Activate ###
	#################################
	### BIP 113 ###
	# BIP 113 tests should now fail regardless of version number if nLockTime isn't satisfied by new rules
	bip113tx_v1.nLockTime = self.last_block_time - 600 * 5 # = MTP of prior block (not <) but < time put on current block
	bip113signed1 = self.sign_transaction(self.nodes[0], bip113tx_v1)
	bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 # = MTP of prior block (not <) but < time put on current block
	bip113signed2 = self.sign_transaction(self.nodes[0], bip113tx_v2)
	for bip113tx in [bip113signed1, bip113signed2]:
	yield TestInstance([[self.create_test_block([bip113tx]), False]]) # 9,10
	# BIP 113 tests should now pass if the locktime is < MTP
	bip113tx_v1.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block
	bip113signed1 = self.sign_transaction(self.nodes[0], bip113tx_v1)
	bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block
	bip113signed2 = self.sign_transaction(self.nodes[0], bip113tx_v2)
	for bip113tx in [bip113signed1, bip113signed2]:
	yield TestInstance([[self.create_test_block([bip113tx]), True]]) # 11,12
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	# Next block height = 580 after 4 blocks of random version
	test_blocks = self.generate_blocks(4, 1234)
	yield TestInstance(test_blocks, sync_every_block=False) # 13

	### BIP 68 ###
	### Version 1 txs ###
	# All still pass
	success_txs = []
	success_txs.extend(all_rlt_txs(bip68txs_v1))
	yield TestInstance([[self.create_test_block(success_txs), True]]) # 14
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	### Version 2 txs ###
	bip68success_txs = []
	# All txs with SEQUENCE_LOCKTIME_DISABLE_FLAG set pass
	for b25 in range(2):
	for b22 in range(2):
	for b18 in range(2):
	bip68success_txs.append(bip68txs_v2[1][b25][b22][b18])
	yield TestInstance([[self.create_test_block(bip68success_txs), True]]) # 15
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
	# All txs without flag fail as we are at delta height = 8 < 10 and delta time = 8 * 600 < 10 * 512
	bip68timetxs = []
	for b25 in range(2):
	for b18 in range(2):
	bip68timetxs.append(bip68txs_v2[0][b25][1][b18])
	for tx in bip68timetxs:
	yield TestInstance([[self.create_test_block([tx]), False]]) # 16 - 19
	bip68heighttxs = []
	for b25 in range(2):
	for b18 in range(2):
	bip68heighttxs.append(bip68txs_v2[0][b25][0][b18])
	for tx in bip68heighttxs:
	yield TestInstance([[self.create_test_block([tx]), False]]) # 20 - 23

	# Advance one block to 581
	test_blocks = self.generate_blocks(1, 1234)
	yield TestInstance(test_blocks, sync_every_block=False) # 24

	# Height txs should fail and time txs should now pass 9 * 600 > 10 * 512
	bip68success_txs.extend(bip68timetxs)
	yield TestInstance([[self.create_test_block(bip68success_txs), True]]) # 25
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
	for tx in bip68heighttxs:
	yield TestInstance([[self.create_test_block([tx]), False]]) # 26 - 29

	# Advance one block to 582
	test_blocks = self.generate_blocks(1, 1234)
	yield TestInstance(test_blocks, sync_every_block=False) # 30

	# All BIP 68 txs should pass
	bip68success_txs.extend(bip68heighttxs)
	yield TestInstance([[self.create_test_block(bip68success_txs), True]]) # 31
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())


	### BIP 112 ###
	### Version 1 txs ###
	# -1 OP_CSV tx should fail
	yield TestInstance([[self.create_test_block([bip112tx_special_v1]), False]]) #32
	# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV, version 1 txs should still pass
	success_txs = []
	for b25 in range(2):
	for b22 in range(2):
	for b18 in range(2):
	success_txs.append(bip112txs_vary_OP_CSV_v1[1][b25][b22][b18])
	success_txs.append(bip112txs_vary_OP_CSV_9_v1[1][b25][b22][b18])
	yield TestInstance([[self.create_test_block(success_txs), True]]) # 33
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	# If SEQUENCE_LOCKTIME_DISABLE_FLAG is unset in argument to OP_CSV, version 1 txs should now fail
	fail_txs = []
	fail_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_v1))
	fail_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v1))
	for b25 in range(2):
	for b22 in range(2):
	for b18 in range(2):
	fail_txs.append(bip112txs_vary_OP_CSV_v1[0][b25][b22][b18])
	fail_txs.append(bip112txs_vary_OP_CSV_9_v1[0][b25][b22][b18])

	for tx in fail_txs:
	yield TestInstance([[self.create_test_block([tx]), False]]) # 34 - 81

	### Version 2 txs ###
	# -1 OP_CSV tx should fail
	yield TestInstance([[self.create_test_block([bip112tx_special_v2]), False]]) #82

	# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV, version 2 txs should pass (all sequence locks are met)
	success_txs = []
	for b25 in range(2):
	for b22 in range(2):
	for b18 in range(2):
	success_txs.append(bip112txs_vary_OP_CSV_v2[1][b25][b22][b18]) # 8/16 of vary_OP_CSV
	success_txs.append(bip112txs_vary_OP_CSV_9_v2[1][b25][b22][b18]) # 8/16 of vary_OP_CSV_9

	yield TestInstance([[self.create_test_block(success_txs), True]]) # 83
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	## SEQUENCE_LOCKTIME_DISABLE_FLAG is unset in argument to OP_CSV for all remaining txs ##
	# All txs with nSequence 9 should fail either due to earlier mismatch or failing the CSV check
	fail_txs = []
	fail_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v2)) # 16/16 of vary_nSequence_9
	for b25 in range(2):
	for b22 in range(2):
	for b18 in range(2):
	fail_txs.append(bip112txs_vary_OP_CSV_9_v2[0][b25][b22][b18]) # 16/16 of vary_OP_CSV_9

	for tx in fail_txs:
	yield TestInstance([[self.create_test_block([tx]), False]]) # 84 - 107

	# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in nSequence, tx should fail
	fail_txs = []
	for b25 in range(2):
	for b22 in range(2):
	for b18 in range(2):
	fail_txs.append(bip112txs_vary_nSequence_v2[1][b25][b22][b18]) # 8/16 of vary_nSequence
	for tx in fail_txs:
	yield TestInstance([[self.create_test_block([tx]), False]]) # 108-115

	# If sequencelock types mismatch, tx should fail
	fail_txs = []
	for b25 in range(2):
	for b18 in range(2):
	fail_txs.append(bip112txs_vary_nSequence_v2[0][b25][1][b18]) # 12/16 of vary_nSequence
	fail_txs.append(bip112txs_vary_OP_CSV_v2[0][b25][1][b18]) # 12/16 of vary_OP_CSV
	for tx in fail_txs:
	yield TestInstance([[self.create_test_block([tx]), False]]) # 116-123

	# Remaining txs should pass, just test masking works properly
	success_txs = []
	for b25 in range(2):
	for b18 in range(2):
	success_txs.append(bip112txs_vary_nSequence_v2[0][b25][0][b18]) # 16/16 of vary_nSequence
	success_txs.append(bip112txs_vary_OP_CSV_v2[0][b25][0][b18]) # 16/16 of vary_OP_CSV
	yield TestInstance([[self.create_test_block(success_txs), True]]) # 124
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	# Additional test, of checking that comparison of two time types works properly
	time_txs = []
	for b25 in range(2):
	for b18 in range(2):
	tx = bip112txs_vary_OP_CSV_v2[0][b25][1][b18]
	tx.vin[0].nSequence = base_relative_locktime \| seq_type_flag
	signtx = self.sign_transaction(self.nodes[0], tx)
	time_txs.append(signtx)
	yield TestInstance([[self.create_test_block(time_txs), True]]) # 125
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	### Missing aspects of test
	## Testing empty stack fails


	if __name__ == '__main__':
	BIP68_112_113Test().main()
	diff --git a/qa/rpc-tests/bip68-sequence.py b/qa/rpc-tests/bip68-sequence.py
	index 717f7562cd..a12bf10ebd 100755
	--- a/qa/rpc-tests/bip68-sequence.py
	+++ b/qa/rpc-tests/bip68-sequence.py
	@@ -1,424 +1,428 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test BIP68 implementation
	#

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.script import *
	from test_framework.mininode import *
	from test_framework.blocktools import *

	SEQUENCE_LOCKTIME_DISABLE_FLAG = (1<<31)
	SEQUENCE_LOCKTIME_TYPE_FLAG = (1<<22) # this means use time (0 means height)
	SEQUENCE_LOCKTIME_GRANULARITY = 9 # this is a bit-shift
	SEQUENCE_LOCKTIME_MASK = 0x0000ffff

	# RPC error for non-BIP68 final transactions
	NOT_FINAL_ERROR = "64: non-BIP68-final"

	class BIP68Test(BitcoinTestFramework):
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 2
	+ self.setup_clean_chain = False

	def setup_network(self):
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug", "-blockprioritysize=0"]))
	self.nodes.append(start_node(1, self.options.tmpdir, ["-debug", "-blockprioritysize=0", "-acceptnonstdtxn=0"]))
	self.is_network_split = False
	self.relayfee = self.nodes[0].getnetworkinfo()["relayfee"]
	connect_nodes(self.nodes[0], 1)

	def run_test(self):
	# Generate some coins
	self.nodes[0].generate(110)

	print("Running test disable flag")
	self.test_disable_flag()

	print("Running test sequence-lock-confirmed-inputs")
	self.test_sequence_lock_confirmed_inputs()

	print("Running test sequence-lock-unconfirmed-inputs")
	self.test_sequence_lock_unconfirmed_inputs()

	print("Running test BIP68 not consensus before versionbits activation")
	self.test_bip68_not_consensus()

	print("Verifying nVersion=2 transactions aren't standard")
	self.test_version2_relay(before_activation=True)

	print("Activating BIP68 (and 112/113)")
	self.activateCSV()

	print("Verifying nVersion=2 transactions are now standard")
	self.test_version2_relay(before_activation=False)

	print("Passed\n")

	# Test that BIP68 is not in effect if tx version is 1, or if
	# the first sequence bit is set.
	def test_disable_flag(self):
	# Create some unconfirmed inputs
	new_addr = self.nodes[0].getnewaddress()
	self.nodes[0].sendtoaddress(new_addr, 2) # send 2 BTC

	utxos = self.nodes[0].listunspent(0, 0)
	assert(len(utxos) > 0)

	utxo = utxos[0]

	tx1 = CTransaction()
	value = int(satoshi_round(utxo["amount"] - self.relayfee)*COIN)

	# Check that the disable flag disables relative locktime.
	# If sequence locks were used, this would require 1 block for the
	# input to mature.
	sequence_value = SEQUENCE_LOCKTIME_DISABLE_FLAG \| 1
	tx1.vin = [CTxIn(COutPoint(int(utxo["txid"], 16), utxo["vout"]), nSequence=sequence_value)]
	tx1.vout = [CTxOut(value, CScript([b'a']))]

	tx1_signed = self.nodes[0].signrawtransaction(ToHex(tx1))["hex"]
	tx1_id = self.nodes[0].sendrawtransaction(tx1_signed)
	tx1_id = int(tx1_id, 16)

	# This transaction will enable sequence-locks, so this transaction should
	# fail
	tx2 = CTransaction()
	tx2.nVersion = 2
	sequence_value = sequence_value & 0x7fffffff
	tx2.vin = [CTxIn(COutPoint(tx1_id, 0), nSequence=sequence_value)]
	tx2.vout = [CTxOut(int(value-self.relayfee*COIN), CScript([b'a']))]
	tx2.rehash()

	try:
	self.nodes[0].sendrawtransaction(ToHex(tx2))
	except JSONRPCException as exp:
	assert_equal(exp.error["message"], NOT_FINAL_ERROR)
	else:
	assert(False)

	# Setting the version back down to 1 should disable the sequence lock,
	# so this should be accepted.
	tx2.nVersion = 1

	self.nodes[0].sendrawtransaction(ToHex(tx2))

	# Calculate the median time past of a prior block ("confirmations" before
	# the current tip).
	def get_median_time_past(self, confirmations):
	block_hash = self.nodes[0].getblockhash(self.nodes[0].getblockcount()-confirmations)
	return self.nodes[0].getblockheader(block_hash)["mediantime"]

	# Test that sequence locks are respected for transactions spending confirmed inputs.
	def test_sequence_lock_confirmed_inputs(self):
	# Create lots of confirmed utxos, and use them to generate lots of random
	# transactions.
	max_outputs = 50
	addresses = []
	while len(addresses) < max_outputs:
	addresses.append(self.nodes[0].getnewaddress())
	while len(self.nodes[0].listunspent()) < 200:
	import random
	random.shuffle(addresses)
	num_outputs = random.randint(1, max_outputs)
	outputs = {}
	for i in range(num_outputs):
	outputs[addresses[i]] = random.randint(1, 20)*0.01
	self.nodes[0].sendmany("", outputs)
	self.nodes[0].generate(1)

	utxos = self.nodes[0].listunspent()

	# Try creating a lot of random transactions.
	# Each time, choose a random number of inputs, and randomly set
	# some of those inputs to be sequence locked (and randomly choose
	# between height/time locking). Small random chance of making the locks
	# all pass.
	for i in range(400):
	# Randomly choose up to 10 inputs
	num_inputs = random.randint(1, 10)
	random.shuffle(utxos)

	# Track whether any sequence locks used should fail
	should_pass = True

	# Track whether this transaction was built with sequence locks
	using_sequence_locks = False

	tx = CTransaction()
	tx.nVersion = 2
	value = 0
	for j in range(num_inputs):
	sequence_value = 0xfffffffe # this disables sequence locks

	# 50% chance we enable sequence locks
	if random.randint(0,1):
	using_sequence_locks = True

	# 10% of the time, make the input sequence value pass
	input_will_pass = (random.randint(1,10) == 1)
	sequence_value = utxos[j]["confirmations"]
	if not input_will_pass:
	sequence_value += 1
	should_pass = False

	# Figure out what the median-time-past was for the confirmed input
	# Note that if an input has N confirmations, we're going back N blocks
	# from the tip so that we're looking up MTP of the block
	# PRIOR to the one the input appears in, as per the BIP68 spec.
	orig_time = self.get_median_time_past(utxos[j]["confirmations"])
	cur_time = self.get_median_time_past(0) # MTP of the tip

	# can only timelock this input if it's not too old -- otherwise use height
	can_time_lock = True
	if ((cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY) >= SEQUENCE_LOCKTIME_MASK:
	can_time_lock = False

	# if time-lockable, then 50% chance we make this a time lock
	if random.randint(0,1) and can_time_lock:
	# Find first time-lock value that fails, or latest one that succeeds
	time_delta = sequence_value << SEQUENCE_LOCKTIME_GRANULARITY
	if input_will_pass and time_delta > cur_time - orig_time:
	sequence_value = ((cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY)
	elif (not input_will_pass and time_delta <= cur_time - orig_time):
	sequence_value = ((cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY)+1
	sequence_value \|= SEQUENCE_LOCKTIME_TYPE_FLAG
	tx.vin.append(CTxIn(COutPoint(int(utxos[j]["txid"], 16), utxos[j]["vout"]), nSequence=sequence_value))
	value += utxos[j]["amount"]*COIN
	# Overestimate the size of the tx - signatures should be less than 120 bytes, and leave 50 for the output
	tx_size = len(ToHex(tx))//2 + 120*num_inputs + 50
	tx.vout.append(CTxOut(int(value-self.relayfeetx_sizeCOIN/1000), CScript([b'a'])))
	rawtx = self.nodes[0].signrawtransaction(ToHex(tx))["hex"]

	try:
	self.nodes[0].sendrawtransaction(rawtx)
	except JSONRPCException as exp:
	assert(not should_pass and using_sequence_locks)
	assert_equal(exp.error["message"], NOT_FINAL_ERROR)
	else:
	assert(should_pass or not using_sequence_locks)
	# Recalculate utxos if we successfully sent the transaction
	utxos = self.nodes[0].listunspent()

	# Test that sequence locks on unconfirmed inputs must have nSequence
	# height or time of 0 to be accepted.
	# Then test that BIP68-invalid transactions are removed from the mempool
	# after a reorg.
	def test_sequence_lock_unconfirmed_inputs(self):
	# Store height so we can easily reset the chain at the end of the test
	cur_height = self.nodes[0].getblockcount()

	# Create a mempool tx.
	txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2)
	tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
	tx1.rehash()

	# Anyone-can-spend mempool tx.
	# Sequence lock of 0 should pass.
	tx2 = CTransaction()
	tx2.nVersion = 2
	tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
	tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee*COIN), CScript([b'a']))]
	tx2_raw = self.nodes[0].signrawtransaction(ToHex(tx2))["hex"]
	tx2 = FromHex(tx2, tx2_raw)
	tx2.rehash()

	self.nodes[0].sendrawtransaction(tx2_raw)

	# Create a spend of the 0th output of orig_tx with a sequence lock
	# of 1, and test what happens when submitting.
	# orig_tx.vout[0] must be an anyone-can-spend output
	def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
	sequence_value = 1
	if not use_height_lock:
	sequence_value \|= SEQUENCE_LOCKTIME_TYPE_FLAG

	tx = CTransaction()
	tx.nVersion = 2
	tx.vin = [CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)]
	tx.vout = [CTxOut(int(orig_tx.vout[0].nValue - relayfee*COIN), CScript([b'a']))]
	tx.rehash()

	try:
	node.sendrawtransaction(ToHex(tx))
	except JSONRPCException as exp:
	assert_equal(exp.error["message"], NOT_FINAL_ERROR)
	assert(orig_tx.hash in node.getrawmempool())
	else:
	# orig_tx must not be in mempool
	assert(orig_tx.hash not in node.getrawmempool())
	return tx

	test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=True)
	test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)

	# Now mine some blocks, but make sure tx2 doesn't get mined.
	# Use prioritisetransaction to lower the effective feerate to 0
	self.nodes[0].prioritisetransaction(tx2.hash, -1e15, int(-self.relayfee*COIN))
	cur_time = int(time.time())
	for i in range(10):
	self.nodes[0].setmocktime(cur_time + 600)
	self.nodes[0].generate(1)
	cur_time += 600

	assert(tx2.hash in self.nodes[0].getrawmempool())

	test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=True)
	test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)

	# Mine tx2, and then try again
	self.nodes[0].prioritisetransaction(tx2.hash, 1e15, int(self.relayfee*COIN))

	# Advance the time on the node so that we can test timelocks
	self.nodes[0].setmocktime(cur_time+600)
	self.nodes[0].generate(1)
	assert(tx2.hash not in self.nodes[0].getrawmempool())

	# Now that tx2 is not in the mempool, a sequence locked spend should
	# succeed
	tx3 = test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
	assert(tx3.hash in self.nodes[0].getrawmempool())

	self.nodes[0].generate(1)
	assert(tx3.hash not in self.nodes[0].getrawmempool())

	# One more test, this time using height locks
	tx4 = test_nonzero_locks(tx3, self.nodes[0], self.relayfee, use_height_lock=True)
	assert(tx4.hash in self.nodes[0].getrawmempool())

	# Now try combining confirmed and unconfirmed inputs
	tx5 = test_nonzero_locks(tx4, self.nodes[0], self.relayfee, use_height_lock=True)
	assert(tx5.hash not in self.nodes[0].getrawmempool())

	utxos = self.nodes[0].listunspent()
	tx5.vin.append(CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]), nSequence=1))
	tx5.vout[0].nValue += int(utxos[0]["amount"]*COIN)
	raw_tx5 = self.nodes[0].signrawtransaction(ToHex(tx5))["hex"]

	try:
	self.nodes[0].sendrawtransaction(raw_tx5)
	except JSONRPCException as exp:
	assert_equal(exp.error["message"], NOT_FINAL_ERROR)
	else:
	assert(False)

	# Test mempool-BIP68 consistency after reorg
	#
	# State of the transactions in the last blocks:
	# ... -> [ tx2 ] -> [ tx3 ]
	# tip-1 tip
	# And currently tx4 is in the mempool.
	#
	# If we invalidate the tip, tx3 should get added to the mempool, causing
	# tx4 to be removed (fails sequence-lock).
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
	assert(tx4.hash not in self.nodes[0].getrawmempool())
	assert(tx3.hash in self.nodes[0].getrawmempool())

	# Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
	# diagram above).
	# This would cause tx2 to be added back to the mempool, which in turn causes
	# tx3 to be removed.
	tip = int(self.nodes[0].getblockhash(self.nodes[0].getblockcount()-1), 16)
	height = self.nodes[0].getblockcount()
	for i in range(2):
	block = create_block(tip, create_coinbase(height), cur_time)
	block.nVersion = 3
	block.rehash()
	block.solve()
	tip = block.sha256
	height += 1
	self.nodes[0].submitblock(ToHex(block))
	cur_time += 1

	mempool = self.nodes[0].getrawmempool()
	assert(tx3.hash not in mempool)
	assert(tx2.hash in mempool)

	# Reset the chain and get rid of the mocktimed-blocks
	self.nodes[0].setmocktime(0)
	self.nodes[0].invalidateblock(self.nodes[0].getblockhash(cur_height+1))
	self.nodes[0].generate(10)

	# Make sure that BIP68 isn't being used to validate blocks, prior to
	# versionbits activation. If more blocks are mined prior to this test
	# being run, then it's possible the test has activated the soft fork, and
	# this test should be moved to run earlier, or deleted.
	def test_bip68_not_consensus(self):
	assert(get_bip9_status(self.nodes[0], 'csv')['status'] != 'active')
	txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2)

	tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
	tx1.rehash()

	# Make an anyone-can-spend transaction
	tx2 = CTransaction()
	tx2.nVersion = 1
	tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
	tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee*COIN), CScript([b'a']))]

	# sign tx2
	tx2_raw = self.nodes[0].signrawtransaction(ToHex(tx2))["hex"]
	tx2 = FromHex(tx2, tx2_raw)
	tx2.rehash()

	self.nodes[0].sendrawtransaction(ToHex(tx2))

	# Now make an invalid spend of tx2 according to BIP68
	sequence_value = 100 # 100 block relative locktime

	tx3 = CTransaction()
	tx3.nVersion = 2
	tx3.vin = [CTxIn(COutPoint(tx2.sha256, 0), nSequence=sequence_value)]
	tx3.vout = [CTxOut(int(tx2.vout[0].nValue - self.relayfee*COIN), CScript([b'a']))]
	tx3.rehash()

	try:
	self.nodes[0].sendrawtransaction(ToHex(tx3))
	except JSONRPCException as exp:
	assert_equal(exp.error["message"], NOT_FINAL_ERROR)
	else:
	assert(False)

	# make a block that violates bip68; ensure that the tip updates
	tip = int(self.nodes[0].getbestblockhash(), 16)
	block = create_block(tip, create_coinbase(self.nodes[0].getblockcount()+1))
	block.nVersion = 3
	block.vtx.extend([tx1, tx2, tx3])
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()

	self.nodes[0].submitblock(ToHex(block))
	assert_equal(self.nodes[0].getbestblockhash(), block.hash)

	def activateCSV(self):
	# activation should happen at block height 432 (3 periods)
	min_activation_height = 432
	height = self.nodes[0].getblockcount()
	assert(height < 432)
	self.nodes[0].generate(432-height)
	assert(get_bip9_status(self.nodes[0], 'csv')['status'] == 'active')
	sync_blocks(self.nodes)

	# Use self.nodes[1] to test standardness relay policy
	def test_version2_relay(self, before_activation):
	inputs = [ ]
	outputs = { self.nodes[1].getnewaddress() : 1.0 }
	rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
	rawtxfund = self.nodes[1].fundrawtransaction(rawtx)['hex']
	tx = FromHex(CTransaction(), rawtxfund)
	tx.nVersion = 2
	tx_signed = self.nodes[1].signrawtransaction(ToHex(tx))["hex"]
	try:
	tx_id = self.nodes[1].sendrawtransaction(tx_signed)
	assert(before_activation == False)
	except:
	assert(before_activation)


	if __name__ == '__main__':
	BIP68Test().main()
	diff --git a/qa/rpc-tests/bip9-softforks.py b/qa/rpc-tests/bip9-softforks.py
	index a8fb878dcb..aae258315e 100755
	--- a/qa/rpc-tests/bip9-softforks.py
	+++ b/qa/rpc-tests/bip9-softforks.py
	@@ -1,215 +1,216 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.blockstore import BlockStore
	from test_framework.test_framework import ComparisonTestFramework
	from test_framework.util import *
	from test_framework.mininode import CTransaction, NetworkThread
	from test_framework.blocktools import create_coinbase, create_block
	from test_framework.comptool import TestInstance, TestManager
	from test_framework.script import CScript, OP_1NEGATE, OP_NOP3, OP_DROP
	from io import BytesIO
	import time
	import itertools

	'''
	This test is meant to exercise BIP forks
	Connect to a single node.
	regtest lock-in with 108/144 block signalling
	activation after a further 144 blocks
	mine 2 block and save coinbases for later use
	mine 141 blocks to transition from DEFINED to STARTED
	mine 100 blocks signalling readiness and 44 not in order to fail to change state this period
	mine 108 blocks signalling readiness and 36 blocks not signalling readiness (STARTED->LOCKED_IN)
	mine a further 143 blocks (LOCKED_IN)
	test that enforcement has not triggered (which triggers ACTIVE)
	test that enforcement has triggered
	'''


	class BIP9SoftForksTest(ComparisonTestFramework):

	def __init__(self):
	+ super().__init__()
	self.num_nodes = 1

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

	def run_test(self):
	self.test = TestManager(self, self.options.tmpdir)
	self.test.add_all_connections(self.nodes)
	NetworkThread().start() # Start up network handling in another thread
	self.test.run()

	def create_transaction(self, node, coinbase, to_address, amount):
	from_txid = node.getblock(coinbase)['tx'][0]
	inputs = [{ "txid" : from_txid, "vout" : 0}]
	outputs = { to_address : amount }
	rawtx = node.createrawtransaction(inputs, outputs)
	tx = CTransaction()
	f = BytesIO(hex_str_to_bytes(rawtx))
	tx.deserialize(f)
	tx.nVersion = 2
	return tx

	def sign_transaction(self, node, tx):
	signresult = node.signrawtransaction(bytes_to_hex_str(tx.serialize()))
	tx = CTransaction()
	f = BytesIO(hex_str_to_bytes(signresult['hex']))
	tx.deserialize(f)
	return tx

	def generate_blocks(self, number, version, test_blocks = []):
	for i in range(number):
	block = create_block(self.tip, create_coinbase(self.height), self.last_block_time + 1)
	block.nVersion = version
	block.rehash()
	block.solve()
	test_blocks.append([block, True])
	self.last_block_time += 1
	self.tip = block.sha256
	self.height += 1
	return test_blocks

	def get_bip9_status(self, key):
	info = self.nodes[0].getblockchaininfo()
	return info['bip9_softforks'][key]

	def test_BIP(self, bipName, activated_version, invalidate, invalidatePostSignature):
	# generate some coins for later
	self.coinbase_blocks = self.nodes[0].generate(2)
	self.height = 3 # height of the next block to build
	self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
	self.nodeaddress = self.nodes[0].getnewaddress()
	self.last_block_time = int(time.time())

	assert_equal(self.get_bip9_status(bipName)['status'], 'defined')

	# Test 1
	# Advance from DEFINED to STARTED
	test_blocks = self.generate_blocks(141, 4)
	yield TestInstance(test_blocks, sync_every_block=False)

	assert_equal(self.get_bip9_status(bipName)['status'], 'started')

	# Test 2
	# Fail to achieve LOCKED_IN 100 out of 144 signal bit 1
	# using a variety of bits to simulate multiple parallel softforks
	test_blocks = self.generate_blocks(50, activated_version) # 0x20000001 (signalling ready)
	test_blocks = self.generate_blocks(20, 4, test_blocks) # 0x00000004 (signalling not)
	test_blocks = self.generate_blocks(50, activated_version, test_blocks) # 0x20000101 (signalling ready)
	test_blocks = self.generate_blocks(24, 4, test_blocks) # 0x20010000 (signalling not)
	yield TestInstance(test_blocks, sync_every_block=False)

	assert_equal(self.get_bip9_status(bipName)['status'], 'started')

	# Test 3
	# 108 out of 144 signal bit 1 to achieve LOCKED_IN
	# using a variety of bits to simulate multiple parallel softforks
	test_blocks = self.generate_blocks(58, activated_version) # 0x20000001 (signalling ready)
	test_blocks = self.generate_blocks(26, 4, test_blocks) # 0x00000004 (signalling not)
	test_blocks = self.generate_blocks(50, activated_version, test_blocks) # 0x20000101 (signalling ready)
	test_blocks = self.generate_blocks(10, 4, test_blocks) # 0x20010000 (signalling not)
	yield TestInstance(test_blocks, sync_every_block=False)

	assert_equal(self.get_bip9_status(bipName)['status'], 'locked_in')

	# Test 4
	# 143 more version 536870913 blocks (waiting period-1)
	test_blocks = self.generate_blocks(143, 4)
	yield TestInstance(test_blocks, sync_every_block=False)

	assert_equal(self.get_bip9_status(bipName)['status'], 'locked_in')

	# Test 5
	# Check that the new rule is enforced
	spendtx = self.create_transaction(self.nodes[0],
	self.coinbase_blocks[0], self.nodeaddress, 1.0)
	invalidate(spendtx)
	spendtx = self.sign_transaction(self.nodes[0], spendtx)
	spendtx.rehash()
	invalidatePostSignature(spendtx)
	spendtx.rehash()
	block = create_block(self.tip, create_coinbase(self.height), self.last_block_time + 1)
	block.nVersion = activated_version
	block.vtx.append(spendtx)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()

	self.last_block_time += 1
	self.tip = block.sha256
	self.height += 1
	yield TestInstance([[block, True]])

	assert_equal(self.get_bip9_status(bipName)['status'], 'active')

	# Test 6
	# Check that the new sequence lock rules are enforced
	spendtx = self.create_transaction(self.nodes[0],
	self.coinbase_blocks[1], self.nodeaddress, 1.0)
	invalidate(spendtx)
	spendtx = self.sign_transaction(self.nodes[0], spendtx)
	spendtx.rehash()
	invalidatePostSignature(spendtx)
	spendtx.rehash()

	block = create_block(self.tip, create_coinbase(self.height), self.last_block_time + 1)
	block.nVersion = 5
	block.vtx.append(spendtx)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()
	self.last_block_time += 1
	yield TestInstance([[block, False]])

	# Restart all
	self.test.block_store.close()
	stop_nodes(self.nodes)
	wait_bitcoinds()
	shutil.rmtree(self.options.tmpdir)
	self.setup_chain()
	self.setup_network()
	self.test.block_store = BlockStore(self.options.tmpdir)
	self.test.clear_all_connections()
	self.test.add_all_connections(self.nodes)
	NetworkThread().start() # Start up network handling in another thread


	def get_tests(self):
	for test in itertools.chain(
	self.test_BIP('csv', 536870913, self.sequence_lock_invalidate, self.donothing),
	self.test_BIP('csv', 536870913, self.mtp_invalidate, self.donothing),
	self.test_BIP('csv', 536870913, self.donothing, self.csv_invalidate)
	):
	yield test

	def donothing(self, tx):
	return

	def csv_invalidate(self, tx):
	'''Modify the signature in vin 0 of the tx to fail CSV
	Prepends -1 CSV DROP in the scriptSig itself.
	'''
	tx.vin[0].scriptSig = CScript([OP_1NEGATE, OP_NOP3, OP_DROP] +
	list(CScript(tx.vin[0].scriptSig)))

	def sequence_lock_invalidate(self, tx):
	'''Modify the nSequence to make it fails once sequence lock rule is activated (high timespan)
	'''
	tx.vin[0].nSequence = 0x00FFFFFF
	tx.nLockTime = 0

	def mtp_invalidate(self, tx):
	'''Modify the nLockTime to make it fails once MTP rule is activated
	'''
	# Disable Sequence lock, Activate nLockTime
	tx.vin[0].nSequence = 0x90FFFFFF
	tx.nLockTime = self.last_block_time

	if __name__ == '__main__':
	BIP9SoftForksTest().main()
	diff --git a/qa/rpc-tests/bipdersig-p2p.py b/qa/rpc-tests/bipdersig-p2p.py
	index c462730840..4e4936a4ae 100755
	--- a/qa/rpc-tests/bipdersig-p2p.py
	+++ b/qa/rpc-tests/bipdersig-p2p.py
	@@ -1,188 +1,189 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import ComparisonTestFramework
	from test_framework.util import *
	from test_framework.mininode import CTransaction, NetworkThread
	from test_framework.blocktools import create_coinbase, create_block
	from test_framework.comptool import TestInstance, TestManager
	from test_framework.script import CScript
	from io import BytesIO
	import time

	# A canonical signature consists of:
	# <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype>
	def unDERify(tx):
	'''
	Make the signature in vin 0 of a tx non-DER-compliant,
	by adding padding after the S-value.
	'''
	scriptSig = CScript(tx.vin[0].scriptSig)
	newscript = []
	for i in scriptSig:
	if (len(newscript) == 0):
	newscript.append(i[0:-1] + b'\0' + i[-1:])
	else:
	newscript.append(i)
	tx.vin[0].scriptSig = CScript(newscript)

	'''
	This test is meant to exercise BIP66 (DER SIG).
	Connect to a single node.
	Mine 2 (version 2) blocks (save the coinbases for later).
	Generate 98 more version 2 blocks, verify the node accepts.
	Mine 749 version 3 blocks, verify the node accepts.
	Check that the new DERSIG rules are not enforced on the 750th version 3 block.
	Check that the new DERSIG rules are enforced on the 751st version 3 block.
	Mine 199 new version blocks.
	Mine 1 old-version block.
	Mine 1 new version block.
	Mine 1 old version block, see that the node rejects.
	'''

	class BIP66Test(ComparisonTestFramework):

	def __init__(self):
	+ super().__init__()
	self.num_nodes = 1

	def setup_network(self):
	# Must set the blockversion for this test
	- self.nodes = start_nodes(1, self.options.tmpdir,
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	extra_args=[['-debug', '-whitelist=127.0.0.1', '-blockversion=2']],
	binary=[self.options.testbinary])

	def run_test(self):
	test = TestManager(self, self.options.tmpdir)
	test.add_all_connections(self.nodes)
	NetworkThread().start() # Start up network handling in another thread
	test.run()

	def create_transaction(self, node, coinbase, to_address, amount):
	from_txid = node.getblock(coinbase)['tx'][0]
	inputs = [{ "txid" : from_txid, "vout" : 0}]
	outputs = { to_address : amount }
	rawtx = node.createrawtransaction(inputs, outputs)
	signresult = node.signrawtransaction(rawtx)
	tx = CTransaction()
	f = BytesIO(hex_str_to_bytes(signresult['hex']))
	tx.deserialize(f)
	return tx

	def get_tests(self):

	self.coinbase_blocks = self.nodes[0].generate(2)
	height = 3 # height of the next block to build
	self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
	self.nodeaddress = self.nodes[0].getnewaddress()
	self.last_block_time = int(time.time())

	''' 98 more version 2 blocks '''
	test_blocks = []
	for i in range(98):
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 2
	block.rehash()
	block.solve()
	test_blocks.append([block, True])
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance(test_blocks, sync_every_block=False)

	''' Mine 749 version 3 blocks '''
	test_blocks = []
	for i in range(749):
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.rehash()
	block.solve()
	test_blocks.append([block, True])
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance(test_blocks, sync_every_block=False)

	'''
	Check that the new DERSIG rules are not enforced in the 750th
	version 3 block.
	'''
	spendtx = self.create_transaction(self.nodes[0],
	self.coinbase_blocks[0], self.nodeaddress, 1.0)
	unDERify(spendtx)
	spendtx.rehash()

	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.vtx.append(spendtx)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()

	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	'''
	Check that the new DERSIG rules are enforced in the 751st version 3
	block.
	'''
	spendtx = self.create_transaction(self.nodes[0],
	self.coinbase_blocks[1], self.nodeaddress, 1.0)
	unDERify(spendtx)
	spendtx.rehash()

	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.vtx.append(spendtx)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	block.solve()
	self.last_block_time += 1
	yield TestInstance([[block, False]])

	''' Mine 199 new version blocks on last valid tip '''
	test_blocks = []
	for i in range(199):
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.rehash()
	block.solve()
	test_blocks.append([block, True])
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance(test_blocks, sync_every_block=False)

	''' Mine 1 old version block '''
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 2
	block.rehash()
	block.solve()
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	''' Mine 1 new version block '''
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 3
	block.rehash()
	block.solve()
	self.last_block_time += 1
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	''' Mine 1 old version block, should be invalid '''
	block = create_block(self.tip, create_coinbase(height), self.last_block_time + 1)
	block.nVersion = 2
	block.rehash()
	block.solve()
	self.last_block_time += 1
	yield TestInstance([[block, False]])

	if __name__ == '__main__':
	BIP66Test().main()
	diff --git a/qa/rpc-tests/bipdersig.py b/qa/rpc-tests/bipdersig.py
	index f2d2c14a72..17c2ced79a 100755
	--- a/qa/rpc-tests/bipdersig.py
	+++ b/qa/rpc-tests/bipdersig.py
	@@ -1,87 +1,91 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test the BIP66 changeover logic
	#

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

	class BIP66Test(BitcoinTestFramework):
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 3
	+ self.setup_clean_chain = False

	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"]))
	connect_nodes(self.nodes[1], 0)
	connect_nodes(self.nodes[2], 0)
	self.is_network_split = False
	self.sync_all()

	def run_test(self):
	cnt = self.nodes[0].getblockcount()

	# Mine some old-version blocks
	self.nodes[1].generate(100)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 100):
	raise AssertionError("Failed to mine 100 version=2 blocks")

	# Mine 750 new-version blocks
	for i in range(15):
	self.nodes[2].generate(50)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 850):
	raise AssertionError("Failed to mine 750 version=3 blocks")

	# TODO: check that new DERSIG rules are not enforced

	# Mine 1 new-version block
	self.nodes[2].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 851):
	raise AssertionError("Failed to mine a version=3 blocks")

	# TODO: check that new DERSIG rules are enforced

	# Mine 198 new-version blocks
	for i in range(2):
	self.nodes[2].generate(99)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1049):
	raise AssertionError("Failed to mine 198 version=3 blocks")

	# Mine 1 old-version block
	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")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1051):
	raise AssertionError("Failed to mine a version=3 block")

	# 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")
	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")

	# Mine 1 new-version blocks
	self.nodes[2].generate(1)
	self.sync_all()
	if (self.nodes[0].getblockcount() != cnt + 1052):
	raise AssertionError("Failed to mine a version=3 block")

	if __name__ == '__main__':
	BIP66Test().main()
	diff --git a/qa/rpc-tests/blockchain.py b/qa/rpc-tests/blockchain.py
	index c84047b5dd..410b85d15e 100755
	--- a/qa/rpc-tests/blockchain.py
	+++ b/qa/rpc-tests/blockchain.py
	@@ -1,89 +1,89 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test RPC calls related to blockchain state. Tests correspond to code in
	# rpc/blockchain.cpp.
	#

	from decimal import Decimal

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.authproxy import JSONRPCException
	from test_framework.util import (
	- initialize_chain,
	assert_equal,
	assert_raises,
	assert_is_hex_string,
	assert_is_hash_string,
	start_nodes,
	connect_nodes_bi,
	)


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

	- gettxoutsetinfo
	- verifychain

	"""

	- def setup_chain(self):
	- print("Initializing test directory " + self.options.tmpdir)
	- initialize_chain(self.options.tmpdir)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = False
	+ self.num_nodes = 2

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

	def run_test(self):
	self._test_gettxoutsetinfo()
	self._test_getblockheader()
	self.nodes[0].verifychain(4, 0)

	def _test_gettxoutsetinfo(self):
	node = self.nodes[0]
	res = node.gettxoutsetinfo()

	assert_equal(res['total_amount'], Decimal('8725.00000000'))
	assert_equal(res['transactions'], 200)
	assert_equal(res['height'], 200)
	assert_equal(res['txouts'], 200)
	assert_equal(res['bytes_serialized'], 13924),
	assert_equal(len(res['bestblock']), 64)
	assert_equal(len(res['hash_serialized']), 64)

	def _test_getblockheader(self):
	node = self.nodes[0]

	assert_raises(
	JSONRPCException, lambda: node.getblockheader('nonsense'))

	besthash = node.getbestblockhash()
	secondbesthash = node.getblockhash(199)
	header = node.getblockheader(besthash)

	assert_equal(header['hash'], besthash)
	assert_equal(header['height'], 200)
	assert_equal(header['confirmations'], 1)
	assert_equal(header['previousblockhash'], secondbesthash)
	assert_is_hex_string(header['chainwork'])
	assert_is_hash_string(header['hash'])
	assert_is_hash_string(header['previousblockhash'])
	assert_is_hash_string(header['merkleroot'])
	assert_is_hash_string(header['bits'], length=None)
	assert isinstance(header['time'], int)
	assert isinstance(header['mediantime'], int)
	assert isinstance(header['nonce'], int)
	assert isinstance(header['version'], int)
	assert isinstance(int(header['versionHex'], 16), int)
	assert isinstance(header['difficulty'], Decimal)

	if __name__ == '__main__':
	BlockchainTest().main()
	diff --git a/qa/rpc-tests/decodescript.py b/qa/rpc-tests/decodescript.py
	index 0037542e62..24768c2655 100755
	--- a/qa/rpc-tests/decodescript.py
	+++ b/qa/rpc-tests/decodescript.py
	@@ -1,184 +1,185 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.mininode import *
	from io import BytesIO

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

	- def setup_chain(self):
	- print('Initializing test directory ' + self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

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

	def decodescript_script_sig(self):
	signature = '304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001'
	push_signature = '48' + signature
	public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2'
	push_public_key = '21' + public_key

	# 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
	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)
	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)
	assert_equal('0 ' + signature + ' ' + signature, rpc_result['asm'])

	# 4) P2SH scriptSig
	# an empty P2SH redeemScript is valid and makes for a very simple test case.
	# thus, such a spending scriptSig would just need to pass the outer redeemScript
	# hash test and leave true on the top of the stack.
	rpc_result = self.nodes[0].decodescript('5100')
	assert_equal('1 0', rpc_result['asm'])

	# 5) null data scriptSig - no such thing because null data scripts can not be spent.
	# thus, no test case for that standard transaction type is here.

	def decodescript_script_pub_key(self):
	public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2'
	push_public_key = '21' + public_key
	public_key_hash = '11695b6cd891484c2d49ec5aa738ec2b2f897777'
	push_public_key_hash = '14' + public_key_hash

	# below are test cases for all of the standard transaction types

	# 1) P2PK scriptPubKey
	# <pubkey> OP_CHECKSIG
	rpc_result = self.nodes[0].decodescript(push_public_key + 'ac')
	assert_equal(public_key + ' OP_CHECKSIG', rpc_result['asm'])

	# 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'])

	# 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'])

	# 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'])

	# 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.
	signature_imposter = '48304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001'
	# OP_RETURN <data>
	rpc_result = self.nodes[0].decodescript('6a' + signature_imposter)
	assert_equal('OP_RETURN ' + signature_imposter[2:], rpc_result['asm'])

	# 6) a CLTV redeem script. redeem scripts are in-effect scriptPubKey scripts, so adding a test here.
	# OP_NOP2 is also known as OP_CHECKLOCKTIMEVERIFY.
	# 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.
	#
	# OP_IF
	# <receiver-pubkey> OP_CHECKSIGVERIFY
	# OP_ELSE
	# <lock-until> OP_CHECKLOCKTIMEVERIFY OP_DROP
	# OP_ENDIF
	# <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'])

	def decoderawtransaction_asm_sighashtype(self):
	"""Tests decoding scripts via RPC command "decoderawtransaction".

	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
	tx = '0100000001696a20784a2c70143f634e95227dbdfdf0ecd51647052e70854512235f5986ca010000008a47304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb014104d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536ffffffff0100e1f505000000001976a914eb6c6e0cdb2d256a32d97b8df1fc75d1920d9bca88ac00000000'
	rpc_result = self.nodes[0].decoderawtransaction(tx)
	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'])
	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
	tx = '01000000015ded05872fdbda629c7d3d02b194763ce3b9b1535ea884e3c8e765d42e316724020000006b48304502204c10d4064885c42638cbff3585915b322de33762598321145ba033fc796971e2022100bb153ad3baa8b757e30a2175bd32852d2e1cb9080f84d7e32fcdfd667934ef1b012103163c0ff73511ea1743fb5b98384a2ff09dd06949488028fd819f4d83f56264efffffffff0200000000000000000b6a0930060201000201000180380100000000001976a9141cabd296e753837c086da7a45a6c2fe0d49d7b7b88ac00000000'
	rpc_result = self.nodes[0].decoderawtransaction(tx)
	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
	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'])

	# 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)]
	signature = push_signature[2:]
	der_signature = signature[:-2]
	signature_sighash_decoded = der_signature + '[ALL]'
	signature_2 = der_signature + '82'
	push_signature_2 = '48' + signature_2
	signature_2_sighash_decoded = der_signature + '[NONE\|ANYONECANPAY]'

	# 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'])

	# 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'])

	# 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'])

	# 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'])

	def run_test(self):
	self.decodescript_script_sig()
	self.decodescript_script_pub_key()
	self.decoderawtransaction_asm_sighashtype()

	if __name__ == '__main__':
	DecodeScriptTest().main()
	diff --git a/qa/rpc-tests/disablewallet.py b/qa/rpc-tests/disablewallet.py
	index b25d2ba335..36c147edad 100755
	--- a/qa/rpc-tests/disablewallet.py
	+++ b/qa/rpc-tests/disablewallet.py
	@@ -1,47 +1,48 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Exercise API with -disablewallet.
	#

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


	class DisableWalletTest (BitcoinTestFramework):

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

	def setup_network(self, split=False):
	- self.nodes = start_nodes(1, 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
	x = self.nodes[0].validateaddress('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
	assert(x['isvalid'] == False)
	x = self.nodes[0].validateaddress('mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ')
	assert(x['isvalid'] == True)

	# Checking mining to an address without a wallet
	try:
	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("Couldn't create new block" not in e.error['message'])

	try:
	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 ()
	diff --git a/qa/rpc-tests/forknotify.py b/qa/rpc-tests/forknotify.py
	index 421f3dd872..5a3f75c808 100755
	--- a/qa/rpc-tests/forknotify.py
	+++ b/qa/rpc-tests/forknotify.py
	@@ -1,61 +1,66 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test -alertnotify
	#

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

	class ForkNotifyTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 2
	+ self.setup_clean_chain = False
	+
	alert_filename = None # Set by setup_network

	def setup_network(self):
	self.nodes = []
	self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
	with open(self.alert_filename, 'w') as f:
	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 + "\""]))
	# Node1 mines block.version=211 blocks
	self.nodes.append(start_node(1, self.options.tmpdir,
	["-blockversion=211"]))
	connect_nodes(self.nodes[1], 0)

	self.is_network_split = False
	self.sync_all()

	def run_test(self):
	# Mine 51 up-version blocks
	self.nodes[1].generate(51)
	self.sync_all()
	# -alertnotify should trigger on the 51'st,
	# but mine and sync another to give
	# -alertnotify time to write
	self.nodes[1].generate(1)
	self.sync_all()

	with open(self.alert_filename, 'r') as f:
	alert_text = f.read()

	if len(alert_text) == 0:
	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)
	self.sync_all()
	self.nodes[1].generate(1)
	self.sync_all()

	with open(self.alert_filename, 'r') as f:
	alert_text2 = f.read()

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

	if __name__ == '__main__':
	ForkNotifyTest().main()
	diff --git a/qa/rpc-tests/fundrawtransaction.py b/qa/rpc-tests/fundrawtransaction.py
	index 74849603f7..57b850a6a9 100755
	--- a/qa/rpc-tests/fundrawtransaction.py
	+++ b/qa/rpc-tests/fundrawtransaction.py
	@@ -1,682 +1,683 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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

	# Create one-input, one-output, no-fee transaction:
	class RawTransactionsTest(BitcoinTestFramework):

	- def setup_chain(self):
	- print(("Initializing test directory "+self.options.tmpdir))
	- initialize_chain_clean(self.options.tmpdir, 4)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 4

	def setup_network(self, split=False):
	- self.nodes = start_nodes(4, self.options.tmpdir)
	+ 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)
	connect_nodes_bi(self.nodes,0,3)

	self.is_network_split=False
	self.sync_all()

	def run_test(self):
	print("Mining blocks...")

	min_relay_tx_fee = self.nodes[0].getnetworkinfo()['relayfee']
	# This test is not meant to test fee estimation and we'd like
	# to be sure all txs are sent at a consistent desired feerate
	for node in self.nodes:
	node.settxfee(min_relay_tx_fee)

	# if the fee's positive delta is higher than this value tests will fail,
	# neg. delta always fail the tests.
	# The size of the signature of every input may be at most 2 bytes larger
	# than a minimum sized signature.

	# = 2 bytes * minRelayTxFeePerByte
	feeTolerance = 2 * min_relay_tx_fee/1000

	self.nodes[2].generate(1)
	self.sync_all()
	self.nodes[0].generate(121)
	self.sync_all()

	watchonly_address = self.nodes[0].getnewaddress()
	watchonly_pubkey = self.nodes[0].validateaddress(watchonly_address)["pubkey"]
	watchonly_amount = Decimal(200)
	self.nodes[3].importpubkey(watchonly_pubkey, "", True)
	watchonly_txid = self.nodes[0].sendtoaddress(watchonly_address, watchonly_amount)
	self.nodes[0].sendtoaddress(self.nodes[3].getnewaddress(), watchonly_amount / 10)

	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.5)
	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 5.0)

	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()

	###############
	# simple test #
	###############
	inputs = [ ]
	outputs = { self.nodes[0].getnewaddress() : 1.0 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	assert(len(dec_tx['vin']) > 0) #test if we have enought inputs

	##############################
	# simple test with two coins #
	##############################
	inputs = [ ]
	outputs = { self.nodes[0].getnewaddress() : 2.2 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	assert(len(dec_tx['vin']) > 0) #test if we have enough inputs

	##############################
	# simple test with two coins #
	##############################
	inputs = [ ]
	outputs = { self.nodes[0].getnewaddress() : 2.6 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	assert(len(dec_tx['vin']) > 0)
	assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')


	################################
	# simple test with two outputs #
	################################
	inputs = [ ]
	outputs = { self.nodes[0].getnewaddress() : 2.6, self.nodes[1].getnewaddress() : 2.5 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	totalOut = 0
	for out in dec_tx['vout']:
	totalOut += out['value']

	assert(len(dec_tx['vin']) > 0)
	assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '')


	#########################################################################
	# test a fundrawtransaction with a VIN greater than the required amount #
	#########################################################################
	utx = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 5.0:
	utx = aUtx
	break

	assert(utx!=False)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
	outputs = { self.nodes[0].getnewaddress() : 1.0 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	totalOut = 0
	for out in dec_tx['vout']:
	totalOut += out['value']

	assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee


	#####################################################################
	# test a fundrawtransaction with which will not get a change output #
	#####################################################################
	utx = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 5.0:
	utx = aUtx
	break

	assert(utx!=False)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
	outputs = { self.nodes[0].getnewaddress() : Decimal(5.0) - fee - feeTolerance }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	totalOut = 0
	for out in dec_tx['vout']:
	totalOut += out['value']

	assert_equal(rawtxfund['changepos'], -1)
	assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee


	####################################################
	# test a fundrawtransaction with an invalid option #
	####################################################
	utx = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 5.0:
	utx = aUtx
	break

	assert_equal(utx!=False, True)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']} ]
	outputs = { self.nodes[0].getnewaddress() : Decimal(4.0) }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])

	try:
	self.nodes[2].fundrawtransaction(rawtx, {'foo': 'bar'})
	raise AssertionError("Accepted invalid option foo")
	except JSONRPCException as e:
	assert("Unexpected key foo" in e.error['message'])


	############################################################
	# test a fundrawtransaction with an invalid change address #
	############################################################
	utx = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 5.0:
	utx = aUtx
	break

	assert_equal(utx!=False, True)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']} ]
	outputs = { self.nodes[0].getnewaddress() : Decimal(4.0) }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])

	try:
	self.nodes[2].fundrawtransaction(rawtx, {'changeAddress': 'foobar'})
	raise AssertionError("Accepted invalid bitcoin address")
	except JSONRPCException as e:
	assert("changeAddress must be a valid bitcoin address" in e.error['message'])



	############################################################
	# test a fundrawtransaction with a provided change address #
	############################################################
	utx = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 5.0:
	utx = aUtx
	break

	assert_equal(utx!=False, True)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']} ]
	outputs = { self.nodes[0].getnewaddress() : Decimal(4.0) }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])

	change = self.nodes[2].getnewaddress()
	rawtxfund = self.nodes[2].fundrawtransaction(rawtx, {'changeAddress': change, 'changePosition': 0})
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	out = dec_tx['vout'][0];
	assert_equal(change, out['scriptPubKey']['addresses'][0])



	#########################################################################
	# test a fundrawtransaction with a VIN smaller than the required amount #
	#########################################################################
	utx = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 1.0:
	utx = aUtx
	break

	assert(utx!=False)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
	outputs = { self.nodes[0].getnewaddress() : 1.0 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)

	# 4-byte version + 1-byte vin count + 36-byte prevout then script_len
	rawtx = rawtx[:82] + "0100" + rawtx[84:]

	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
	assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	totalOut = 0
	matchingOuts = 0
	for i, out in enumerate(dec_tx['vout']):
	totalOut += out['value']
	if out['scriptPubKey']['addresses'][0] in outputs:
	matchingOuts+=1
	else:
	assert_equal(i, rawtxfund['changepos'])

	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
	assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])

	assert_equal(matchingOuts, 1)
	assert_equal(len(dec_tx['vout']), 2)


	###########################################
	# test a fundrawtransaction with two VINs #
	###########################################
	utx = False
	utx2 = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 1.0:
	utx = aUtx
	if aUtx['amount'] == 5.0:
	utx2 = aUtx


	assert(utx!=False)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
	outputs = { self.nodes[0].getnewaddress() : 6.0 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	totalOut = 0
	matchingOuts = 0
	for out in dec_tx['vout']:
	totalOut += out['value']
	if out['scriptPubKey']['addresses'][0] in outputs:
	matchingOuts+=1

	assert_equal(matchingOuts, 1)
	assert_equal(len(dec_tx['vout']), 2)

	matchingIns = 0
	for vinOut in dec_tx['vin']:
	for vinIn in inputs:
	if vinIn['txid'] == vinOut['txid']:
	matchingIns+=1

	assert_equal(matchingIns, 2) #we now must see two vins identical to vins given as params

	#########################################################
	# test a fundrawtransaction with two VINs and two vOUTs #
	#########################################################
	utx = False
	utx2 = False
	listunspent = self.nodes[2].listunspent()
	for aUtx in listunspent:
	if aUtx['amount'] == 1.0:
	utx = aUtx
	if aUtx['amount'] == 5.0:
	utx2 = aUtx


	assert(utx!=False)

	inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
	outputs = { self.nodes[0].getnewaddress() : 6.0, self.nodes[0].getnewaddress() : 1.0 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)
	assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	fee = rawtxfund['fee']
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
	totalOut = 0
	matchingOuts = 0
	for out in dec_tx['vout']:
	totalOut += out['value']
	if out['scriptPubKey']['addresses'][0] in outputs:
	matchingOuts+=1

	assert_equal(matchingOuts, 2)
	assert_equal(len(dec_tx['vout']), 3)

	##############################################
	# test a fundrawtransaction with invalid vin #
	##############################################
	listunspent = self.nodes[2].listunspent()
	inputs = [ {'txid' : "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1", 'vout' : 0} ] #invalid vin!
	outputs = { self.nodes[0].getnewaddress() : 1.0}
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)

	try:
	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	raise AssertionError("Spent more than available")
	except JSONRPCException as e:
	assert("Insufficient" in e.error['message'])


	############################################################
	#compare fee of a standard pubkeyhash transaction
	inputs = []
	outputs = {self.nodes[1].getnewaddress():1.1}
	rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[0].fundrawtransaction(rawTx)

	#create same transaction over sendtoaddress
	txId = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1.1)
	signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']

	#compare fee
	feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
	assert(feeDelta >= 0 and feeDelta <= feeTolerance)
	############################################################

	############################################################
	#compare fee of a standard pubkeyhash transaction with multiple outputs
	inputs = []
	outputs = {self.nodes[1].getnewaddress():1.1,self.nodes[1].getnewaddress():1.2,self.nodes[1].getnewaddress():0.1,self.nodes[1].getnewaddress():1.3,self.nodes[1].getnewaddress():0.2,self.nodes[1].getnewaddress():0.3}
	rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[0].fundrawtransaction(rawTx)
	#create same transaction over sendtoaddress
	txId = self.nodes[0].sendmany("", outputs)
	signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']

	#compare fee
	feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
	assert(feeDelta >= 0 and feeDelta <= feeTolerance)
	############################################################


	############################################################
	#compare fee of a 2of2 multisig p2sh transaction

	# create 2of2 addr
	addr1 = self.nodes[1].getnewaddress()
	addr2 = self.nodes[1].getnewaddress()

	addr1Obj = self.nodes[1].validateaddress(addr1)
	addr2Obj = self.nodes[1].validateaddress(addr2)

	mSigObj = self.nodes[1].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])

	inputs = []
	outputs = {mSigObj:1.1}
	rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[0].fundrawtransaction(rawTx)

	#create same transaction over sendtoaddress
	txId = self.nodes[0].sendtoaddress(mSigObj, 1.1)
	signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']

	#compare fee
	feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
	assert(feeDelta >= 0 and feeDelta <= feeTolerance)
	############################################################


	############################################################
	#compare fee of a standard pubkeyhash transaction

	# create 4of5 addr
	addr1 = self.nodes[1].getnewaddress()
	addr2 = self.nodes[1].getnewaddress()
	addr3 = self.nodes[1].getnewaddress()
	addr4 = self.nodes[1].getnewaddress()
	addr5 = self.nodes[1].getnewaddress()

	addr1Obj = self.nodes[1].validateaddress(addr1)
	addr2Obj = self.nodes[1].validateaddress(addr2)
	addr3Obj = self.nodes[1].validateaddress(addr3)
	addr4Obj = self.nodes[1].validateaddress(addr4)
	addr5Obj = self.nodes[1].validateaddress(addr5)

	mSigObj = self.nodes[1].addmultisigaddress(4, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey'], addr4Obj['pubkey'], addr5Obj['pubkey']])

	inputs = []
	outputs = {mSigObj:1.1}
	rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[0].fundrawtransaction(rawTx)

	#create same transaction over sendtoaddress
	txId = self.nodes[0].sendtoaddress(mSigObj, 1.1)
	signedFee = self.nodes[0].getrawmempool(True)[txId]['fee']

	#compare fee
	feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
	assert(feeDelta >= 0 and feeDelta <= feeTolerance)
	############################################################


	############################################################
	# spend a 2of2 multisig transaction over fundraw

	# create 2of2 addr
	addr1 = self.nodes[2].getnewaddress()
	addr2 = self.nodes[2].getnewaddress()

	addr1Obj = self.nodes[2].validateaddress(addr1)
	addr2Obj = self.nodes[2].validateaddress(addr2)

	mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])


	# send 1.2 BTC to msig addr
	txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
	self.sync_all()
	self.nodes[1].generate(1)
	self.sync_all()

	oldBalance = self.nodes[1].getbalance()
	inputs = []
	outputs = {self.nodes[1].getnewaddress():1.1}
	rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[2].fundrawtransaction(rawTx)

	signedTx = self.nodes[2].signrawtransaction(fundedTx['hex'])
	txId = self.nodes[2].sendrawtransaction(signedTx['hex'])
	self.sync_all()
	self.nodes[1].generate(1)
	self.sync_all()

	# make sure funds are received at node1
	assert_equal(oldBalance+Decimal('1.10000000'), self.nodes[1].getbalance())

	############################################################
	# locked wallet test
	self.nodes[1].encryptwallet("test")
	self.nodes.pop(1)
	stop_nodes(self.nodes)
	wait_bitcoinds()

	- self.nodes = start_nodes(4, self.options.tmpdir)
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir)
	# This test is not meant to test fee estimation and we'd like
	# to be sure all txs are sent at a consistent desired feerate
	for node in self.nodes:
	node.settxfee(min_relay_tx_fee)

	connect_nodes_bi(self.nodes,0,1)
	connect_nodes_bi(self.nodes,1,2)
	connect_nodes_bi(self.nodes,0,2)
	connect_nodes_bi(self.nodes,0,3)
	self.is_network_split=False
	self.sync_all()

	try:
	self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1.2)
	raise AssertionError("Wallet unlocked without passphrase")
	except JSONRPCException as e:
	assert('walletpassphrase' in e.error['message'])

	oldBalance = self.nodes[0].getbalance()

	inputs = []
	outputs = {self.nodes[0].getnewaddress():1.1}
	rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[1].fundrawtransaction(rawTx)

	#now we need to unlock
	self.nodes[1].walletpassphrase("test", 100)
	signedTx = self.nodes[1].signrawtransaction(fundedTx['hex'])
	txId = self.nodes[1].sendrawtransaction(signedTx['hex'])
	self.sync_all()
	self.nodes[1].generate(1)
	self.sync_all()

	# make sure funds are received at node1
	assert_equal(oldBalance+Decimal('51.10000000'), self.nodes[0].getbalance())


	###############################################
	# multiple (~19) inputs tx test \| Compare fee #
	###############################################

	#empty node1, send some small coins from node0 to node1
	self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True)
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()

	for i in range(0,20):
	self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01)
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()

	#fund a tx with ~20 small inputs
	inputs = []
	outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
	rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[1].fundrawtransaction(rawTx)

	#create same transaction over sendtoaddress
	txId = self.nodes[1].sendmany("", outputs)
	signedFee = self.nodes[1].getrawmempool(True)[txId]['fee']

	#compare fee
	feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
	assert(feeDelta >= 0 and feeDelta <= feeTolerance*19) #~19 inputs


	#############################################
	# multiple (~19) inputs tx test \| sign/send #
	#############################################

	#again, empty node1, send some small coins from node0 to node1
	self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True)
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()

	for i in range(0,20):
	self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01)
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()

	#fund a tx with ~20 small inputs
	oldBalance = self.nodes[0].getbalance()

	inputs = []
	outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
	rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
	fundedTx = self.nodes[1].fundrawtransaction(rawTx)
	fundedAndSignedTx = self.nodes[1].signrawtransaction(fundedTx['hex'])
	txId = self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex'])
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()
	assert_equal(oldBalance+Decimal('50.19000000'), self.nodes[0].getbalance()) #0.19+block reward

	#####################################################
	# test fundrawtransaction with OP_RETURN and no vin #
	#####################################################

	rawtx = "0100000000010000000000000000066a047465737400000000"
	dec_tx = self.nodes[2].decoderawtransaction(rawtx)

	assert_equal(len(dec_tx['vin']), 0)
	assert_equal(len(dec_tx['vout']), 1)

	rawtxfund = self.nodes[2].fundrawtransaction(rawtx)
	dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex'])

	assert_greater_than(len(dec_tx['vin']), 0) # at least one vin
	assert_equal(len(dec_tx['vout']), 2) # one change output added


	##################################################
	# test a fundrawtransaction using only watchonly #
	##################################################

	inputs = []
	outputs = {self.nodes[2].getnewaddress() : watchonly_amount / 2}
	rawtx = self.nodes[3].createrawtransaction(inputs, outputs)

	result = self.nodes[3].fundrawtransaction(rawtx, {'includeWatching': True })
	res_dec = self.nodes[0].decoderawtransaction(result["hex"])
	assert_equal(len(res_dec["vin"]), 1)
	assert_equal(res_dec["vin"][0]["txid"], watchonly_txid)

	assert("fee" in result.keys())
	assert_greater_than(result["changepos"], -1)

	###############################################################
	# test fundrawtransaction using the entirety of watched funds #
	###############################################################

	inputs = []
	outputs = {self.nodes[2].getnewaddress() : watchonly_amount}
	rawtx = self.nodes[3].createrawtransaction(inputs, outputs)

	# Backward compatibility test (2nd param is includeWatching)
	result = self.nodes[3].fundrawtransaction(rawtx, True)
	res_dec = self.nodes[0].decoderawtransaction(result["hex"])
	assert_equal(len(res_dec["vin"]), 2)
	assert(res_dec["vin"][0]["txid"] == watchonly_txid or res_dec["vin"][1]["txid"] == watchonly_txid)

	assert_greater_than(result["fee"], 0)
	assert_greater_than(result["changepos"], -1)
	assert_equal(result["fee"] + res_dec["vout"][result["changepos"]]["value"], watchonly_amount / 10)

	signedtx = self.nodes[3].signrawtransaction(result["hex"])
	assert(not signedtx["complete"])
	signedtx = self.nodes[0].signrawtransaction(signedtx["hex"])
	assert(signedtx["complete"])
	self.nodes[0].sendrawtransaction(signedtx["hex"])


	if __name__ == '__main__':
	RawTransactionsTest().main()
	diff --git a/qa/rpc-tests/getblocktemplate_longpoll.py b/qa/rpc-tests/getblocktemplate_longpoll.py
	index e443347077..3cddf4046a 100755
	--- a/qa/rpc-tests/getblocktemplate_longpoll.py
	+++ b/qa/rpc-tests/getblocktemplate_longpoll.py
	@@ -1,69 +1,74 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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

	import threading

	class LongpollThread(threading.Thread):
	def __init__(self, node):
	threading.Thread.__init__(self)
	# query current longpollid
	templat = node.getblocktemplate()
	self.longpollid = templat['longpollid']
	# create a new connection to the node, we can't use the same
	# connection from two threads
	self.node = get_rpc_proxy(node.url, 1, timeout=600)

	def run(self):
	self.node.getblocktemplate({'longpollid':self.longpollid})

	class GetBlockTemplateLPTest(BitcoinTestFramework):
	'''
	Test longpolling with getblocktemplate.
	'''

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 4
	+ self.setup_clean_chain = False
	+
	def run_test(self):
	print("Warning: this test will take about 70 seconds in the best case. Be patient.")
	self.nodes[0].generate(10)
	templat = self.nodes[0].getblocktemplate()
	longpollid = templat['longpollid']
	# longpollid should not change between successive invocations if nothing else happens
	templat2 = self.nodes[0].getblocktemplate()
	assert(templat2['longpollid'] == longpollid)

	# Test 1: test that the longpolling wait if we do nothing
	thr = LongpollThread(self.nodes[0])
	thr.start()
	# check that thread still lives
	thr.join(5) # wait 5 seconds or until thread exits
	assert(thr.is_alive())

	# Test 2: test that longpoll will terminate if another node generates a block
	self.nodes[1].generate(1) # generate a block on another node
	# check that thread will exit now that new transaction entered mempool
	thr.join(5) # wait 5 seconds or until thread exits
	assert(not thr.is_alive())

	# Test 3: test that longpoll will terminate if we generate a block ourselves
	thr = LongpollThread(self.nodes[0])
	thr.start()
	self.nodes[0].generate(1) # generate a block on another node
	thr.join(5) # wait 5 seconds or until thread exits
	assert(not thr.is_alive())

	# Test 4: test that introducing a new transaction into the mempool will terminate the longpoll
	thr = LongpollThread(self.nodes[0])
	thr.start()
	# generate a random transaction and submit it
	(txid, txhex, fee) = random_transaction(self.nodes, Decimal("1.1"), Decimal("0.0"), Decimal("0.001"), 20)
	# after one minute, every 10 seconds the mempool is probed, so in 80 seconds it should have returned
	thr.join(60 + 20)
	assert(not thr.is_alive())

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

	diff --git a/qa/rpc-tests/getblocktemplate_proposals.py b/qa/rpc-tests/getblocktemplate_proposals.py
	index 1ad2af4c2e..7a4f8f8fdc 100755
	--- a/qa/rpc-tests/getblocktemplate_proposals.py
	+++ b/qa/rpc-tests/getblocktemplate_proposals.py
	@@ -1,154 +1,163 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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

	from binascii import a2b_hex, b2a_hex
	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')
	def encodeUNum(n):
	s = bytearray(b'\1')
	while n > 127:
	s[0] += 1
	s.append(n % 256)
	n //= 256
	s.append(n)
	return bytes(s)

	def varlenEncode(n):
	if n < 0xfd:
	return pack('<B', n)
	if n <= 0xffff:
	return b'\xfd' + pack('<H', n)
	if n <= 0xffffffff:
	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:
	n = []
	if len(cur) & 1:
	cur.append(cur[-1])
	for i in range(0, len(cur), 2):
	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 += 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'})
	if rsp != expect:
	raise AssertionError('unexpected: %s' % (rsp,))

	class GetBlockTemplateProposalTest(BitcoinTestFramework):
	'''
	Test block proposals with getblocktemplate.
	'''

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 2
	+ self.setup_clean_chain = False
	+
	+ def setup_network(self):
	+ self.nodes = self.setup_nodes()
	+ connect_nodes_bi(self.nodes, 0, 1)
	+
	def run_test(self):
	node = self.nodes[0]
	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']))

	# 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 2: Bad input hash for gen tx
	txlist[0][4+1] += 1
	assert_template(node, tmpl, txlist, 'bad-cb-missing')
	txlist[0][4+1] -= 1

	# Test 3: Truncated final tx
	lastbyte = txlist[-1].pop()
	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)
	txlist.append(txlist[0])
	assert_template(node, tmpl, txlist, 'bad-txns-duplicate')
	txlist.pop()

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

	# Test 6: Future tx lock time
	txlist[0][-4:] = b'\xff\xff\xff\xff'
	assert_template(node, tmpl, txlist, 'bad-txns-nonfinal')
	txlist[0][-4:] = b'\0\0\0\0'

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

	# Test 8: Bad bits
	realbits = tmpl['bits']
	tmpl['bits'] = '1c0000ff' # impossible in the real world
	assert_template(node, tmpl, txlist, 'bad-diffbits')
	tmpl['bits'] = realbits

	# 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'})
	if rsp != 'bad-txnmrklroot':
	raise AssertionError('unexpected: %s' % (rsp,))

	# Test 10: Bad timestamps
	realtime = tmpl['curtime']
	tmpl['curtime'] = 0x7fffffff
	assert_template(node, tmpl, txlist, 'time-too-new')
	tmpl['curtime'] = 0
	assert_template(node, tmpl, txlist, 'time-too-old')
	tmpl['curtime'] = realtime

	# Test 11: Valid block
	assert_template(node, tmpl, txlist, None)

	# Test 12: Orphan block
	tmpl['previousblockhash'] = 'ff00' * 16
	assert_template(node, tmpl, txlist, 'inconclusive-not-best-prevblk')

	if __name__ == '__main__':
	GetBlockTemplateProposalTest().main()
	diff --git a/qa/rpc-tests/getchaintips.py b/qa/rpc-tests/getchaintips.py
	index da354b0c97..1c66b8c289 100755
	--- a/qa/rpc-tests/getchaintips.py
	+++ b/qa/rpc-tests/getchaintips.py
	@@ -1,59 +1,62 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Exercise the getchaintips API. We introduce a network split, work
	# on chains of different lengths, and join the network together again.
	# This gives us two tips, verify that it works.

	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):
	- BitcoinTestFramework.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')

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

	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')

	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')

	# 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 ()

	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')
	tips[1]['branchlen'] = 0
	tips[1]['status'] = 'active'
	assert_equal (tips[1], shortTip)

	if __name__ == '__main__':
	GetChainTipsTest ().main ()
	diff --git a/qa/rpc-tests/httpbasics.py b/qa/rpc-tests/httpbasics.py
	index c62edc8e13..10bc927e1a 100755
	--- a/qa/rpc-tests/httpbasics.py
	+++ b/qa/rpc-tests/httpbasics.py
	@@ -1,108 +1,113 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test rpc http basics
	#

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

	import http.client
	import urllib.parse

	class HTTPBasicsTest (BitcoinTestFramework):
	- def setup_nodes(self):
	- return start_nodes(4, self.options.tmpdir)
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 3
	+ self.setup_clean_chain = False
	+
	+ def setup_network(self):
	+ self.nodes = self.setup_nodes()

	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)}

	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!

	#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!
	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"}

	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!

	#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!
	conn.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

	#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)}

	conn = http.client.HTTPConnection(urlNode1.hostname, urlNode1.port)
	conn.connect()
	conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
	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
	urlNode2 = urllib.parse.urlparse(self.nodes[2].url)
	authpair = urlNode2.username + ':' + urlNode2.password
	headers = {"Authorization": "Basic " + str_to_b64str(authpair)}

	conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
	conn.connect()
	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

	# Check excessive request size
	conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
	conn.connect()
	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)
	out1 = conn.getresponse()
	assert_equal(out1.status, http.client.BAD_REQUEST)


	if __name__ == '__main__':
	HTTPBasicsTest ().main ()
	diff --git a/qa/rpc-tests/importprunedfunds.py b/qa/rpc-tests/importprunedfunds.py
	index def1d891c3..761c9af90c 100755
	--- a/qa/rpc-tests/importprunedfunds.py
	+++ b/qa/rpc-tests/importprunedfunds.py
	@@ -1,142 +1,143 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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

	class ImportPrunedFundsTest(BitcoinTestFramework):

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 4)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 4

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

	def run_test (self):
	import time
	begintime = int(time.time())

	print("Mining blocks...")
	self.nodes[0].generate(101)

	# sync
	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
	# privkey
	address3 = self.nodes[0].getnewaddress()
	address3_privkey = self.nodes[0].dumpprivkey(address3) # Using privkey

	#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)

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

	address_info = self.nodes[1].validateaddress(address2)
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], False)

	address_info = self.nodes[1].validateaddress(address3)
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], False)

	#Send funds to self
	txnid1 = self.nodes[0].sendtoaddress(address1, 0.1)
	self.nodes[0].generate(1)
	rawtxn1 = self.nodes[0].gettransaction(txnid1)['hex']
	proof1 = self.nodes[0].gettxoutproof([txnid1])

	txnid2 = self.nodes[0].sendtoaddress(address2, 0.05)
	self.nodes[0].generate(1)
	rawtxn2 = self.nodes[0].gettransaction(txnid2)['hex']
	proof2 = self.nodes[0].gettxoutproof([txnid2])


	txnid3 = self.nodes[0].sendtoaddress(address3, 0.025)
	self.nodes[0].generate(1)
	rawtxn3 = self.nodes[0].gettransaction(txnid3)['hex']
	proof3 = self.nodes[0].gettxoutproof([txnid3])

	self.sync_all()

	#Import with no affiliated address
	try:
	result1 = self.nodes[1].importprunedfunds(rawtxn1, proof1, "")
	except JSONRPCException as e:
	assert('No addresses' in e.error['message'])
	else:
	assert(False)


	balance1 = self.nodes[1].getbalance("", 0, True)
	assert_equal(balance1, Decimal(0))

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

	#Import with private key with no rescan
	self.nodes[1].importprivkey(address3_privkey, "", False)
	result3 = self.nodes[1].importprunedfunds(rawtxn3, proof3, "")
	balance3 = Decimal(self.nodes[1].getbalance("", 0, False))
	assert_equal(balance3, Decimal('0.025'))
	balance3 = Decimal(self.nodes[1].getbalance("", 0, True))
	assert_equal(balance3, Decimal('0.075'))

	#Addresses Test - after import
	address_info = self.nodes[1].validateaddress(address1)
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], False)
	address_info = self.nodes[1].validateaddress(address2)
	assert_equal(address_info['iswatchonly'], True)
	assert_equal(address_info['ismine'], False)
	address_info = self.nodes[1].validateaddress(address3)
	assert_equal(address_info['iswatchonly'], False)
	assert_equal(address_info['ismine'], True)

	#Remove transactions

	try:
	self.nodes[1].removeprunedfunds(txnid1)
	except JSONRPCException as e:
	assert('does not exist' in e.error['message'])
	else:
	assert(False)


	balance1 = Decimal(self.nodes[1].getbalance("", 0, True))
	assert_equal(balance1, Decimal('0.075'))


	self.nodes[1].removeprunedfunds(txnid2)
	balance2 = Decimal(self.nodes[1].getbalance("", 0, True))
	assert_equal(balance2, Decimal('0.025'))

	self.nodes[1].removeprunedfunds(txnid3)
	balance3 = Decimal(self.nodes[1].getbalance("", 0, True))
	assert_equal(balance3, Decimal('0.0'))

	if __name__ == '__main__':
	ImportPrunedFundsTest ().main ()
	diff --git a/qa/rpc-tests/invalidateblock.py b/qa/rpc-tests/invalidateblock.py
	index 2e3a449f5e..0faadd33ab 100755
	--- a/qa/rpc-tests/invalidateblock.py
	+++ b/qa/rpc-tests/invalidateblock.py
	@@ -1,75 +1,76 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test InvalidateBlock code
	#

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

	class InvalidateTest(BitcoinTestFramework):


	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 3)
	-
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 3
	+
	def setup_network(self):
	self.nodes = []
	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("Mine 4 blocks on Node 0")
	self.nodes[0].generate(4)
	assert(self.nodes[0].getblockcount() == 4)
	besthash = self.nodes[0].getbestblockhash()

	print("Mine competing 6 blocks on Node 1")
	self.nodes[1].generate(6)
	assert(self.nodes[1].getblockcount() == 6)

	print("Connect nodes to force a reorg")
	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")
	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))

	print("\nMake sure we won't reorg to a lower work chain:")
	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)
	print("Invalidate block 5 on node 1 so its tip is now at 4")
	self.nodes[1].invalidateblock(self.nodes[1].getblockhash(5))
	assert(self.nodes[1].getblockcount() == 4)
	print("Invalidate block 3 on node 2, so its tip is now 2")
	self.nodes[2].invalidateblock(self.nodes[2].getblockhash(3))
	assert(self.nodes[2].getblockcount() == 2)
	print("..and then mine a block")
	self.nodes[2].generate(1)
	print("Verify all nodes are at the right height")
	time.sleep(5)
	for i in range(3):
	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)

	if __name__ == '__main__':
	InvalidateTest().main()
	diff --git a/qa/rpc-tests/invalidblockrequest.py b/qa/rpc-tests/invalidblockrequest.py
	index 78dc7199da..3d8107a76c 100755
	--- a/qa/rpc-tests/invalidblockrequest.py
	+++ b/qa/rpc-tests/invalidblockrequest.py
	@@ -1,116 +1,117 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import ComparisonTestFramework
	from test_framework.util import *
	from test_framework.comptool import TestManager, TestInstance, RejectResult
	from test_framework.blocktools import *
	import copy
	import time


	'''
	In this test we connect to one node over p2p, and test block requests:
	1) Valid blocks should be requested and become chain tip.
	2) Invalid block with duplicated transaction should be re-requested.
	3) Invalid block with bad coinbase value should be rejected and not
	re-requested.
	'''

	# 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.
	Change the "outcome" variable from each TestInstance object to only do the comparison. '''
	def __init__(self):
	+ super().__init__()
	self.num_nodes = 1

	def run_test(self):
	test = TestManager(self, self.options.tmpdir)
	test.add_all_connections(self.nodes)
	self.tip = None
	self.block_time = None
	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

	'''
	Create a new block with an anyone-can-spend coinbase
	'''
	height = 1
	block = create_block(self.tip, create_coinbase(height), self.block_time)
	self.block_time += 1
	block.solve()
	# Save the coinbase for later
	self.block1 = block
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	'''
	Now we need that block to mature so we can spend the coinbase.
	'''
	test = TestInstance(sync_every_block=False)
	for i in range(100):
	block = create_block(self.tip, create_coinbase(height), self.block_time)
	block.solve()
	self.tip = block.sha256
	self.block_time += 1
	test.blocks_and_transactions.append([block, True])
	height += 1
	yield test

	'''
	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
	leave merkle root and blockheader unchanged but invalidate the block.
	'''
	block2 = create_block(self.tip, create_coinbase(height), self.block_time)
	self.block_time += 1

	# b'0x51' is OP_TRUE
	tx1 = create_transaction(self.block1.vtx[0], 0, b'\x51', 50 * COIN)
	tx2 = create_transaction(tx1, 0, b'\x51', 50 * COIN)

	block2.vtx.extend([tx1, tx2])
	block2.hashMerkleRoot = block2.calc_merkle_root()
	block2.rehash()
	block2.solve()
	orig_hash = block2.sha256
	block2_orig = copy.deepcopy(block2)

	# Mutate block 2
	block2.vtx.append(tx2)
	assert_equal(block2.hashMerkleRoot, block2.calc_merkle_root())
	assert_equal(orig_hash, block2.rehash())
	assert(block2_orig.vtx != block2.vtx)

	self.tip = block2.sha256
	yield TestInstance([[block2, RejectResult(16, b'bad-txns-duplicate')], [block2_orig, True]])
	height += 1

	'''
	Make sure that a totally screwed up block is not valid.
	'''
	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].calc_sha256()
	block3.hashMerkleRoot = block3.calc_merkle_root()
	block3.rehash()
	block3.solve()

	yield TestInstance([[block3, RejectResult(16, b'bad-cb-amount')]])


	if __name__ == '__main__':
	InvalidBlockRequestTest().main()
	diff --git a/qa/rpc-tests/invalidtxrequest.py b/qa/rpc-tests/invalidtxrequest.py
	index d4200b0e88..93205d79de 100755
	--- a/qa/rpc-tests/invalidtxrequest.py
	+++ b/qa/rpc-tests/invalidtxrequest.py
	@@ -1,71 +1,72 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import ComparisonTestFramework
	from test_framework.comptool import TestManager, TestInstance, RejectResult
	from test_framework.blocktools import *
	import time


	'''
	In this test we connect to one node over p2p, and test tx requests.
	'''

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

	''' Can either run this test as 1 node with expected answers, or two and compare them.
	Change the "outcome" variable from each TestInstance object to only do the comparison. '''
	def __init__(self):
	+ super().__init__()
	self.num_nodes = 1

	def run_test(self):
	test = TestManager(self, self.options.tmpdir)
	test.add_all_connections(self.nodes)
	self.tip = None
	self.block_time = None
	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

	'''
	Create a new block with an anyone-can-spend coinbase
	'''
	height = 1
	block = create_block(self.tip, create_coinbase(height), self.block_time)
	self.block_time += 1
	block.solve()
	# Save the coinbase for later
	self.block1 = block
	self.tip = block.sha256
	height += 1
	yield TestInstance([[block, True]])

	'''
	Now we need that block to mature so we can spend the coinbase.
	'''
	test = TestInstance(sync_every_block=False)
	for i in range(100):
	block = create_block(self.tip, create_coinbase(height), self.block_time)
	block.solve()
	self.tip = block.sha256
	self.block_time += 1
	test.blocks_and_transactions.append([block, True])
	height += 1
	yield test

	# b'\x64' is OP_NOTIF
	# Transaction will be rejected with code 16 (REJECT_INVALID)
	tx1 = create_transaction(self.block1.vtx[0], 0, b'\x64', 50 * COIN - 12000)
	yield TestInstance([[tx1, RejectResult(16, b'mandatory-script-verify-flag-failed')]])

	# TODO: test further transactions...

	if __name__ == '__main__':
	InvalidTxRequestTest().main()
	diff --git a/qa/rpc-tests/keypool.py b/qa/rpc-tests/keypool.py
	index bdc144bfbc..c75303ecbf 100755
	--- a/qa/rpc-tests/keypool.py
	+++ b/qa/rpc-tests/keypool.py
	@@ -1,76 +1,75 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Exercise the wallet keypool, and interaction with wallet encryption/locking

	-# Add python-bitcoinrpc to module search path:
	-
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	class KeyPoolTest(BitcoinTestFramework):

	def run_test(self):
	nodes = self.nodes
	# Encrypt wallet and wait to terminate
	nodes[0].encryptwallet('test')
	bitcoind_processes[0].wait()
	# Restart node 0
	nodes[0] = start_node(0, self.options.tmpdir)
	# Keep creating keys
	addr = nodes[0].getnewaddress()
	try:
	addr = nodes[0].getnewaddress()
	raise AssertionError('Keypool should be exhausted after one address')
	except JSONRPCException as e:
	assert(e.error['code']==-12)

	# put three new keys in the keypool
	nodes[0].walletpassphrase('test', 12000)
	nodes[0].keypoolrefill(3)
	nodes[0].walletlock()

	# drain the keys
	addr = set()
	addr.add(nodes[0].getrawchangeaddress())
	addr.add(nodes[0].getrawchangeaddress())
	addr.add(nodes[0].getrawchangeaddress())
	addr.add(nodes[0].getrawchangeaddress())
	# assert that four unique addresses were returned
	assert(len(addr) == 4)
	# the next one should fail
	try:
	addr = nodes[0].getrawchangeaddress()
	raise AssertionError('Keypool should be exhausted after three addresses')
	except JSONRPCException as e:
	assert(e.error['code']==-12)

	# refill keypool with three new addresses
	nodes[0].walletpassphrase('test', 1)
	nodes[0].keypoolrefill(3)
	# test walletpassphrase timeout
	time.sleep(1.1)
	assert_equal(nodes[0].getwalletinfo()["unlocked_until"], 0)

	# drain them by mining
	nodes[0].generate(1)
	nodes[0].generate(1)
	nodes[0].generate(1)
	nodes[0].generate(1)
	try:
	nodes[0].generate(1)
	raise AssertionError('Keypool should be exhausted after three addesses')
	except JSONRPCException as e:
	assert(e.error['code']==-12)

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain(self.options.tmpdir)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = False
	+ self.num_nodes = 1

	def setup_network(self):
	- self.nodes = start_nodes(1, self.options.tmpdir)
	+ self.nodes = self.setup_nodes()

	if __name__ == '__main__':
	KeyPoolTest().main()
	diff --git a/qa/rpc-tests/listtransactions.py b/qa/rpc-tests/listtransactions.py
	index 8dad687edd..5ec6ce17e0 100755
	--- a/qa/rpc-tests/listtransactions.py
	+++ b/qa/rpc-tests/listtransactions.py
	@@ -1,200 +1,204 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Exercise the listtransactions API

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.mininode import CTransaction, COIN
	from io import BytesIO

	def txFromHex(hexstring):
	tx = CTransaction()
	f = BytesIO(hex_str_to_bytes(hexstring))
	tx.deserialize(f)
	return tx

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

	def setup_nodes(self):
	#This test requires mocktime
	enable_mocktime()
	- return start_nodes(4, self.options.tmpdir)
	+ return start_nodes(self.num_nodes, self.options.tmpdir)

	def run_test(self):
	# Simple send, 0 to 1:
	txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
	self.sync_all()
	assert_array_result(self.nodes[0].listtransactions(),
	{"txid":txid},
	{"category":"send","account":"","amount":Decimal("-0.1"),"confirmations":0})
	assert_array_result(self.nodes[1].listtransactions(),
	{"txid":txid},
	{"category":"receive","account":"","amount":Decimal("0.1"),"confirmations":0})
	# mine a block, confirmations should change:
	self.nodes[0].generate(1)
	self.sync_all()
	assert_array_result(self.nodes[0].listtransactions(),
	{"txid":txid},
	{"category":"send","account":"","amount":Decimal("-0.1"),"confirmations":1})
	assert_array_result(self.nodes[1].listtransactions(),
	{"txid":txid},
	{"category":"receive","account":"","amount":Decimal("0.1"),"confirmations":1})

	# send-to-self:
	txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 0.2)
	assert_array_result(self.nodes[0].listtransactions(),
	{"txid":txid, "category":"send"},
	{"amount":Decimal("-0.2")})
	assert_array_result(self.nodes[0].listtransactions(),
	{"txid":txid, "category":"receive"},
	{"amount":Decimal("0.2")})

	# sendmany from node1: twice to self, twice to node2:
	send_to = { self.nodes[0].getnewaddress() : 0.11,
	self.nodes[1].getnewaddress() : 0.22,
	self.nodes[0].getaccountaddress("from1") : 0.33,
	self.nodes[1].getaccountaddress("toself") : 0.44 }
	txid = self.nodes[1].sendmany("", send_to)
	self.sync_all()
	assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.11")},
	{"txid":txid} )
	assert_array_result(self.nodes[0].listtransactions(),
	{"category":"receive","amount":Decimal("0.11")},
	{"txid":txid} )
	assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.22")},
	{"txid":txid} )
	assert_array_result(self.nodes[1].listtransactions(),
	{"category":"receive","amount":Decimal("0.22")},
	{"txid":txid} )
	assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.33")},
	{"txid":txid} )
	assert_array_result(self.nodes[0].listtransactions(),
	{"category":"receive","amount":Decimal("0.33")},
	{"txid":txid, "account" : "from1"} )
	assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.44")},
	{"txid":txid, "account" : ""} )
	assert_array_result(self.nodes[1].listtransactions(),
	{"category":"receive","amount":Decimal("0.44")},
	{"txid":txid, "account" : "toself"} )

	multisig = self.nodes[1].createmultisig(1, [self.nodes[1].getnewaddress()])
	self.nodes[0].importaddress(multisig["redeemScript"], "watchonly", False, True)
	txid = self.nodes[1].sendtoaddress(multisig["address"], 0.1)
	self.nodes[1].generate(1)
	self.sync_all()
	assert(len(self.nodes[0].listtransactions("watchonly", 100, 0, False)) == 0)
	assert_array_result(self.nodes[0].listtransactions("watchonly", 100, 0, True),
	{"category":"receive","amount":Decimal("0.1")},
	{"txid":txid, "account" : "watchonly"} )

	self.run_rbf_opt_in_test()

	# Check that the opt-in-rbf flag works properly, for sent and received
	# transactions.
	def run_rbf_opt_in_test(self):
	# Check whether a transaction signals opt-in RBF itself
	def is_opt_in(node, txid):
	rawtx = node.getrawtransaction(txid, 1)
	for x in rawtx["vin"]:
	if x["sequence"] < 0xfffffffe:
	return True
	return False

	# Find an unconfirmed output matching a certain txid
	def get_unconfirmed_utxo_entry(node, txid_to_match):
	utxo = node.listunspent(0, 0)
	for i in utxo:
	if i["txid"] == txid_to_match:
	return i
	return None

	# 1. Chain a few transactions that don't opt-in.
	txid_1 = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
	assert(not is_opt_in(self.nodes[0], txid_1))
	assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_1}, {"bip125-replaceable":"no"})
	sync_mempools(self.nodes)
	assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_1}, {"bip125-replaceable":"no"})

	# Tx2 will build off txid_1, still not opting in to RBF.
	utxo_to_use = get_unconfirmed_utxo_entry(self.nodes[1], txid_1)

	# Create tx2 using createrawtransaction
	inputs = [{"txid":utxo_to_use["txid"], "vout":utxo_to_use["vout"]}]
	outputs = {self.nodes[0].getnewaddress(): 0.999}
	tx2 = self.nodes[1].createrawtransaction(inputs, outputs)
	tx2_signed = self.nodes[1].signrawtransaction(tx2)["hex"]
	txid_2 = self.nodes[1].sendrawtransaction(tx2_signed)

	# ...and check the result
	assert(not is_opt_in(self.nodes[1], txid_2))
	assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_2}, {"bip125-replaceable":"no"})
	sync_mempools(self.nodes)
	assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_2}, {"bip125-replaceable":"no"})

	# Tx3 will opt-in to RBF
	utxo_to_use = get_unconfirmed_utxo_entry(self.nodes[0], txid_2)
	inputs = [{"txid": txid_2, "vout":utxo_to_use["vout"]}]
	outputs = {self.nodes[1].getnewaddress(): 0.998}
	tx3 = self.nodes[0].createrawtransaction(inputs, outputs)
	tx3_modified = txFromHex(tx3)
	tx3_modified.vin[0].nSequence = 0
	tx3 = bytes_to_hex_str(tx3_modified.serialize())
	tx3_signed = self.nodes[0].signrawtransaction(tx3)['hex']
	txid_3 = self.nodes[0].sendrawtransaction(tx3_signed)

	assert(is_opt_in(self.nodes[0], txid_3))
	assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_3}, {"bip125-replaceable":"yes"})
	sync_mempools(self.nodes)
	assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_3}, {"bip125-replaceable":"yes"})

	# Tx4 will chain off tx3. Doesn't signal itself, but depends on one
	# that does.
	utxo_to_use = get_unconfirmed_utxo_entry(self.nodes[1], txid_3)
	inputs = [{"txid": txid_3, "vout":utxo_to_use["vout"]}]
	outputs = {self.nodes[0].getnewaddress(): 0.997}
	tx4 = self.nodes[1].createrawtransaction(inputs, outputs)
	tx4_signed = self.nodes[1].signrawtransaction(tx4)["hex"]
	txid_4 = self.nodes[1].sendrawtransaction(tx4_signed)

	assert(not is_opt_in(self.nodes[1], txid_4))
	assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"yes"})
	sync_mempools(self.nodes)
	assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"yes"})

	# Replace tx3, and check that tx4 becomes unknown
	tx3_b = tx3_modified
	tx3_b.vout[0].nValue -= int(Decimal("0.004") * COIN) # bump the fee
	tx3_b = bytes_to_hex_str(tx3_b.serialize())
	tx3_b_signed = self.nodes[0].signrawtransaction(tx3_b)['hex']
	txid_3b = self.nodes[0].sendrawtransaction(tx3_b_signed, True)
	assert(is_opt_in(self.nodes[0], txid_3b))

	assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"unknown"})
	sync_mempools(self.nodes)
	assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"unknown"})

	# Check gettransaction as well:
	for n in self.nodes[0:2]:
	assert_equal(n.gettransaction(txid_1)["bip125-replaceable"], "no")
	assert_equal(n.gettransaction(txid_2)["bip125-replaceable"], "no")
	assert_equal(n.gettransaction(txid_3)["bip125-replaceable"], "yes")
	assert_equal(n.gettransaction(txid_3b)["bip125-replaceable"], "yes")
	assert_equal(n.gettransaction(txid_4)["bip125-replaceable"], "unknown")

	# After mining a transaction, it's no longer BIP125-replaceable
	self.nodes[0].generate(1)
	assert(txid_3b not in self.nodes[0].getrawmempool())
	assert_equal(self.nodes[0].gettransaction(txid_3b)["bip125-replaceable"], "no")
	assert_equal(self.nodes[0].gettransaction(txid_4)["bip125-replaceable"], "unknown")


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

	diff --git a/qa/rpc-tests/maxblocksinflight.py b/qa/rpc-tests/maxblocksinflight.py
	index 6f105a77e3..1df1c484be 100755
	--- a/qa/rpc-tests/maxblocksinflight.py
	+++ b/qa/rpc-tests/maxblocksinflight.py
	@@ -1,95 +1,96 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.mininode import *
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	import logging

	'''
	In this test we connect to one node over p2p, send it numerous inv's, and
	compare the resulting number of getdata requests to a max allowed value. We
	test for exceeding 128 blocks in flight, which was the limit an 0.9 client will
	reach. [0.10 clients shouldn't request more than 16 from a single peer.]
	'''
	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
	for inv in message.inv:
	if inv.hash not in self.blockReqCounts:
	self.blockReqCounts[inv.hash] = 0
	self.blockReqCounts[inv.hash] += 1

	def on_close(self, conn):
	if not self.disconnectOkay:
	raise EarlyDisconnectError(0)

	def __init__(self):
	NodeConnCB.__init__(self)
	self.log = logging.getLogger("BlockRelayTest")

	def add_new_connection(self, connection):
	self.connection = connection
	self.blockReqCounts = {}
	self.disconnectOkay = False

	def run(self):
	self.connection.rpc.generate(1) # Leave IBD

	numBlocksToGenerate = [8, 16, 128, 1024]
	for count in range(len(numBlocksToGenerate)):
	current_invs = []
	for i in range(numBlocksToGenerate[count]):
	current_invs.append(CInv(2, random.randrange(0, 1 << 256)))
	if len(current_invs) >= 50000:
	self.connection.send_message(msg_inv(current_invs))
	current_invs = []
	if len(current_invs) > 0:
	self.connection.send_message(msg_inv(current_invs))

	# Wait and see how many blocks were requested
	time.sleep(2)

	total_requests = 0
	with mininode_lock:
	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)
	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))

	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"),
	help="Binary to test max block requests behavior")

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

	def setup_network(self):
	- self.nodes = start_nodes(1, self.options.tmpdir,
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir,
	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))
	NetworkThread().start() # Start up network handling in another thread
	test.run()

	if __name__ == '__main__':
	MaxBlocksInFlightTest().main()
	diff --git a/qa/rpc-tests/maxuploadtarget.py b/qa/rpc-tests/maxuploadtarget.py
	index ec802d8155..42235a5119 100755
	--- a/qa/rpc-tests/maxuploadtarget.py
	+++ b/qa/rpc-tests/maxuploadtarget.py
	@@ -1,264 +1,266 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.mininode import *
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	import time

	'''
	Test behavior of -maxuploadtarget.

	* Verify that getdata requests for old blocks (>1week) are dropped
	if uploadtarget has been reached.
	* Verify that getdata requests for recent blocks are respecteved even
	if uploadtarget has been reached.
	* Verify that the upload counters are reset after 24 hours.
	'''

	# 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
	self.ping_counter = 1
	self.last_pong = msg_pong()
	self.block_receive_map = {}

	def add_connection(self, conn):
	self.connection = conn
	self.peer_disconnected = False

	def on_inv(self, conn, message):
	pass

	# Track the last getdata message we receive (used in the test)
	def on_getdata(self, conn, message):
	self.last_getdata = message

	def on_block(self, conn, message):
	message.block.calc_sha256()
	try:
	self.block_receive_map[message.block.sha256] += 1
	except KeyError as e:
	self.block_receive_map[message.block.sha256] = 1

	# Spin until verack message is received from the node.
	# We use this to signal that our test can begin. This
	# is called from the testing thread, so it needs to acquire
	# the global lock.
	def wait_for_verack(self):
	def veracked():
	return self.verack_received
	return wait_until(veracked, timeout=10)

	def wait_for_disconnect(self):
	def disconnected():
	return self.peer_disconnected
	return wait_until(disconnected, timeout=10)

	# Wrapper for the NodeConn's send_message function
	def send_message(self, message):
	self.connection.send_message(message)

	def on_pong(self, conn, message):
	self.last_pong = message

	def on_close(self, conn):
	self.peer_disconnected = True

	# Sync up with the node after delivery of a block
	def sync_with_ping(self, timeout=30):
	def received_pong():
	return (self.last_pong.nonce == self.ping_counter)
	self.connection.send_message(msg_ping(nonce=self.ping_counter))
	success = wait_until(received_pong, timeout)
	self.ping_counter += 1
	return success

	class MaxUploadTest(BitcoinTestFramework):
	- def __init__(self):
	- self.utxo = []
	- self.txouts = gen_return_txouts()

	def add_options(self, parser):
	parser.add_option("--testbinary", dest="testbinary",
	default=os.getenv("BITCOIND", "bitcoind"),
	help="bitcoind binary to test")

	- def setup_chain(self):
	- initialize_chain_clean(self.options.tmpdir, 2)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 2
	+
	+ self.utxo = []
	+ self.txouts = gen_return_txouts()

	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", "-maxuploadtarget=200", "-blockmaxsize=999000"]))

	def mine_full_block(self, node, address):
	# Want to create a full block
	# We'll generate a 66k transaction below, and 14 of them is close to the 1MB block limit
	for j in range(14):
	if len(self.utxo) < 14:
	self.utxo = node.listunspent()
	inputs=[]
	outputs = {}
	t = self.utxo.pop()
	inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
	remchange = t["amount"] - Decimal("0.001000")
	outputs[address]=remchange
	# Create a basic transaction that will send change back to ourself after account for a fee
	# And then insert the 128 generated transaction outs in the middle rawtx[92] is where the #
	# of txouts is stored and is the only thing we overwrite from the original transaction
	rawtx = node.createrawtransaction(inputs, outputs)
	newtx = rawtx[0:92]
	newtx = newtx + self.txouts
	newtx = newtx + rawtx[94:]
	# Appears to be ever so slightly faster to sign with SIGHASH_NONE
	signresult = node.signrawtransaction(newtx,None,None,"NONE")
	txid = node.sendrawtransaction(signresult["hex"], True)
	# Mine a full sized block which will be these transactions we just created
	node.generate(1)

	def run_test(self):
	# Before we connect anything, we first set the time on the node
	# to be in the past, otherwise things break because the CNode
	# time counters can't be reset backward after initialization
	old_time = int(time.time() - 26060247)
	self.nodes[0].setmocktime(old_time)

	# Generate some old blocks
	self.nodes[0].generate(130)

	# test_nodes[0] will only request old blocks
	# test_nodes[1] will only request new blocks
	# test_nodes[2] will test resetting the counters
	test_nodes = []
	connections = []

	for i in range(3):
	test_nodes.append(TestNode())
	connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_nodes[i]))
	test_nodes[i].add_connection(connections[i])

	NetworkThread().start() # Start up network handling in another thread
	[x.wait_for_verack() for x in test_nodes]

	# Test logic begins here

	# Now mine a big block
	self.mine_full_block(self.nodes[0], self.nodes[0].getnewaddress())

	# Store the hash; we'll request this later
	big_old_block = self.nodes[0].getbestblockhash()
	old_block_size = self.nodes[0].getblock(big_old_block, True)['size']
	big_old_block = int(big_old_block, 16)

	# Advance to two days ago
	self.nodes[0].setmocktime(int(time.time()) - 26060*24)

	# Mine one more block, so that the prior block looks old
	self.mine_full_block(self.nodes[0], self.nodes[0].getnewaddress())

	# We'll be requesting this new block too
	big_new_block = self.nodes[0].getbestblockhash()
	new_block_size = self.nodes[0].getblock(big_new_block)['size']
	big_new_block = int(big_new_block, 16)

	# test_nodes[0] will test what happens if we just keep requesting the
	# the same big old block too many times (expect: disconnect)

	getdata_request = msg_getdata()
	getdata_request.inv.append(CInv(2, big_old_block))

	max_bytes_per_day = 20010241024
	daily_buffer = 144 * MAX_BLOCK_SIZE
	max_bytes_available = max_bytes_per_day - daily_buffer
	success_count = max_bytes_available // old_block_size

	# 144MB will be reserved for relaying new blocks, so expect this to
	# succeed for ~70 tries.
	for i in range(success_count):
	test_nodes[0].send_message(getdata_request)
	test_nodes[0].sync_with_ping()
	assert_equal(test_nodes[0].block_receive_map[big_old_block], i+1)

	assert_equal(len(self.nodes[0].getpeerinfo()), 3)
	# At most a couple more tries should succeed (depending on how long
	# the test has been running so far).
	for i in range(3):
	test_nodes[0].send_message(getdata_request)
	test_nodes[0].wait_for_disconnect()
	assert_equal(len(self.nodes[0].getpeerinfo()), 2)
	print("Peer 0 disconnected after downloading old block too many times")

	# Requesting the current block on test_nodes[1] should succeed indefinitely,
	# even when over the max upload target.
	# We'll try 200 times
	getdata_request.inv = [CInv(2, big_new_block)]
	for i in range(200):
	test_nodes[1].send_message(getdata_request)
	test_nodes[1].sync_with_ping()
	assert_equal(test_nodes[1].block_receive_map[big_new_block], i+1)

	print("Peer 1 able to repeatedly download new block")

	# But if test_nodes[1] tries for an old block, it gets disconnected too.
	getdata_request.inv = [CInv(2, big_old_block)]
	test_nodes[1].send_message(getdata_request)
	test_nodes[1].wait_for_disconnect()
	assert_equal(len(self.nodes[0].getpeerinfo()), 1)

	print("Peer 1 disconnected after trying to download old block")

	print("Advancing system time on node to clear counters...")

	# If we advance the time by 24 hours, then the counters should reset,
	# and test_nodes[2] should be able to retrieve the old block.
	self.nodes[0].setmocktime(int(time.time()))
	test_nodes[2].sync_with_ping()
	test_nodes[2].send_message(getdata_request)
	test_nodes[2].sync_with_ping()
	assert_equal(test_nodes[2].block_receive_map[big_old_block], 1)

	print("Peer 2 able to download old block")

	[c.disconnect_node() for c in connections]

	#stop and start node 0 with 1MB maxuploadtarget, whitelist 127.0.0.1
	print("Restarting nodes with -whitelist=127.0.0.1")
	stop_node(self.nodes[0], 0)
	self.nodes[0] = start_node(0, self.options.tmpdir, ["-debug", "-whitelist=127.0.0.1", "-maxuploadtarget=1", "-blockmaxsize=999000"])

	#recreate/reconnect 3 test nodes
	test_nodes = []
	connections = []

	for i in range(3):
	test_nodes.append(TestNode())
	connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_nodes[i]))
	test_nodes[i].add_connection(connections[i])

	NetworkThread().start() # Start up network handling in another thread
	[x.wait_for_verack() for x in test_nodes]

	#retrieve 20 blocks which should be enough to break the 1MB limit
	getdata_request.inv = [CInv(2, big_new_block)]
	for i in range(20):
	test_nodes[1].send_message(getdata_request)
	test_nodes[1].sync_with_ping()
	assert_equal(test_nodes[1].block_receive_map[big_new_block], i+1)

	getdata_request.inv = [CInv(2, big_old_block)]
	test_nodes[1].send_message(getdata_request)
	test_nodes[1].wait_for_disconnect()
	assert_equal(len(self.nodes[0].getpeerinfo()), 3) #node is still connected because of the whitelist

	print("Peer 1 still connected after trying to download old block (whitelisted)")

	[c.disconnect_node() for c in connections]

	if __name__ == '__main__':
	MaxUploadTest().main()
	diff --git a/qa/rpc-tests/mempool_limit.py b/qa/rpc-tests/mempool_limit.py
	index bc208709e9..c1c5558a95 100755
	--- a/qa/rpc-tests/mempool_limit.py
	+++ b/qa/rpc-tests/mempool_limit.py
	@@ -1,54 +1,54 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Test mempool limiting together/eviction with the wallet

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

	class MempoolLimitTest(BitcoinTestFramework):

	- def __init__(self):
	- self.txouts = gen_return_txouts()
	-
	def setup_network(self):
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, ["-maxmempool=5", "-spendzeroconfchange=0", "-debug"]))
	self.is_network_split = False
	self.sync_all()
	self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 2)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 2
	+
	+ self.txouts = gen_return_txouts()

	def run_test(self):
	txids = []
	utxos = create_confirmed_utxos(self.relayfee, self.nodes[0], 90)

	#create a mempool tx that will be evicted
	us0 = utxos.pop()
	inputs = [{ "txid" : us0["txid"], "vout" : us0["vout"]}]
	outputs = {self.nodes[0].getnewaddress() : 0.0001}
	tx = self.nodes[0].createrawtransaction(inputs, outputs)
	self.nodes[0].settxfee(self.relayfee) # specifically fund this tx with low fee
	txF = self.nodes[0].fundrawtransaction(tx)
	self.nodes[0].settxfee(0) # return to automatic fee selection
	txFS = self.nodes[0].signrawtransaction(txF['hex'])
	txid = self.nodes[0].sendrawtransaction(txFS['hex'])

	relayfee = self.nodes[0].getnetworkinfo()['relayfee']
	base_fee = relayfee*100
	for i in range (4):
	txids.append([])
	txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[30i:30i+30], (i+1)*base_fee)

	# by now, the tx should be evicted, check confirmation state
	assert(txid not in self.nodes[0].getrawmempool())
	txdata = self.nodes[0].gettransaction(txid)
	assert(txdata['confirmations'] == 0) #confirmation should still be 0

	if __name__ == '__main__':
	MempoolLimitTest().main()
	diff --git a/qa/rpc-tests/mempool_packages.py b/qa/rpc-tests/mempool_packages.py
	index 7ac85c1b6d..693ff593b3 100755
	--- a/qa/rpc-tests/mempool_packages.py
	+++ b/qa/rpc-tests/mempool_packages.py
	@@ -1,211 +1,215 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Test descendant package tracking code

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.mininode import COIN

	MAX_ANCESTORS = 25
	MAX_DESCENDANTS = 25

	class MempoolPackagesTest(BitcoinTestFramework):
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 2
	+ self.setup_clean_chain = False

	def setup_network(self):
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, ["-maxorphantx=1000", "-relaypriority=0", "-debug"]))
	self.nodes.append(start_node(1, self.options.tmpdir, ["-maxorphantx=1000", "-relaypriority=0", "-limitancestorcount=5", "-debug"]))
	connect_nodes(self.nodes[0], 1)
	self.is_network_split = False
	self.sync_all()

	# Build a transaction that spends parent_txid:vout
	# Return amount sent
	def chain_transaction(self, node, parent_txid, vout, value, fee, num_outputs):
	send_value = satoshi_round((value - fee)/num_outputs)
	inputs = [ {'txid' : parent_txid, 'vout' : vout} ]
	outputs = {}
	for i in range(num_outputs):
	outputs[node.getnewaddress()] = send_value
	rawtx = node.createrawtransaction(inputs, outputs)
	signedtx = node.signrawtransaction(rawtx)
	txid = node.sendrawtransaction(signedtx['hex'])
	fulltx = node.getrawtransaction(txid, 1)
	assert(len(fulltx['vout']) == num_outputs) # make sure we didn't generate a change output
	return (txid, send_value)

	def run_test(self):
	''' Mine some blocks and have them mature. '''
	self.nodes[0].generate(101)
	utxo = self.nodes[0].listunspent(10)
	txid = utxo[0]['txid']
	vout = utxo[0]['vout']
	value = utxo[0]['amount']

	fee = Decimal("0.0001")
	# MAX_ANCESTORS transactions off a confirmed tx should be fine
	chain = []
	for i in range(MAX_ANCESTORS):
	(txid, sent_value) = self.chain_transaction(self.nodes[0], txid, 0, value, fee, 1)
	value = sent_value
	chain.append(txid)

	# Check mempool has MAX_ANCESTORS transactions in it, and descendant
	# count and fees should look correct
	mempool = self.nodes[0].getrawmempool(True)
	assert_equal(len(mempool), MAX_ANCESTORS)
	descendant_count = 1
	descendant_fees = 0
	descendant_size = 0

	for x in reversed(chain):
	assert_equal(mempool[x]['descendantcount'], descendant_count)
	descendant_fees += mempool[x]['fee']
	assert_equal(mempool[x]['modifiedfee'], mempool[x]['fee'])
	assert_equal(mempool[x]['descendantfees'], descendant_fees * COIN)
	descendant_size += mempool[x]['size']
	assert_equal(mempool[x]['descendantsize'], descendant_size)
	descendant_count += 1

	# Check that descendant modified fees includes fee deltas from
	# prioritisetransaction
	self.nodes[0].prioritisetransaction(chain[-1], 0, 1000)
	mempool = self.nodes[0].getrawmempool(True)

	descendant_fees = 0
	for x in reversed(chain):
	descendant_fees += mempool[x]['fee']
	assert_equal(mempool[x]['descendantfees'], descendant_fees * COIN + 1000)

	# Adding one more transaction on to the chain should fail.
	try:
	self.chain_transaction(self.nodes[0], txid, vout, value, fee, 1)
	except JSONRPCException as e:
	print("too-long-ancestor-chain successfully rejected")

	# Check that prioritising a tx before it's added to the mempool works
	# First clear the mempool by mining a block.
	self.nodes[0].generate(1)
	sync_blocks(self.nodes)
	assert_equal(len(self.nodes[0].getrawmempool()), 0)
	# Prioritise a transaction that has been mined, then add it back to the
	# mempool by using invalidateblock.
	self.nodes[0].prioritisetransaction(chain[-1], 0, 2000)
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
	# Keep node1's tip synced with node0
	self.nodes[1].invalidateblock(self.nodes[1].getbestblockhash())

	# Now check that the transaction is in the mempool, with the right modified fee
	mempool = self.nodes[0].getrawmempool(True)

	descendant_fees = 0
	for x in reversed(chain):
	descendant_fees += mempool[x]['fee']
	if (x == chain[-1]):
	assert_equal(mempool[x]['modifiedfee'], mempool[x]['fee']+satoshi_round(0.00002))
	assert_equal(mempool[x]['descendantfees'], descendant_fees * COIN + 2000)

	# TODO: check that node1's mempool is as expected

	# TODO: test ancestor size limits

	# Now test descendant chain limits
	txid = utxo[1]['txid']
	value = utxo[1]['amount']
	vout = utxo[1]['vout']

	transaction_package = []
	# First create one parent tx with 10 children
	(txid, sent_value) = self.chain_transaction(self.nodes[0], txid, vout, value, fee, 10)
	parent_transaction = txid
	for i in range(10):
	transaction_package.append({'txid': txid, 'vout': i, 'amount': sent_value})

	for i in range(MAX_DESCENDANTS):
	utxo = transaction_package.pop(0)
	try:
	(txid, sent_value) = self.chain_transaction(self.nodes[0], utxo['txid'], utxo['vout'], utxo['amount'], fee, 10)
	for j in range(10):
	transaction_package.append({'txid': txid, 'vout': j, 'amount': sent_value})
	if i == MAX_DESCENDANTS - 2:
	mempool = self.nodes[0].getrawmempool(True)
	assert_equal(mempool[parent_transaction]['descendantcount'], MAX_DESCENDANTS)
	except JSONRPCException as e:
	print(e.error['message'])
	assert_equal(i, MAX_DESCENDANTS - 1)
	print("tx that would create too large descendant package successfully rejected")

	# TODO: check that node1's mempool is as expected

	# TODO: test descendant size limits

	# Test reorg handling
	# First, the basics:
	self.nodes[0].generate(1)
	sync_blocks(self.nodes)
	self.nodes[1].invalidateblock(self.nodes[0].getbestblockhash())
	self.nodes[1].reconsiderblock(self.nodes[0].getbestblockhash())

	# Now test the case where node1 has a transaction T in its mempool that
	# depends on transactions A and B which are in a mined block, and the
	# block containing A and B is disconnected, AND B is not accepted back
	# into node1's mempool because its ancestor count is too high.

	# Create 8 transactions, like so:
	# Tx0 -> Tx1 (vout0)
	# \--> Tx2 (vout1) -> Tx3 -> Tx4 -> Tx5 -> Tx6 -> Tx7
	#
	# Mine them in the next block, then generate a new tx8 that spends
	# Tx1 and Tx7, and add to node1's mempool, then disconnect the
	# last block.

	# Create tx0 with 2 outputs
	utxo = self.nodes[0].listunspent()
	txid = utxo[0]['txid']
	value = utxo[0]['amount']
	vout = utxo[0]['vout']

	send_value = satoshi_round((value - fee)/2)
	inputs = [ {'txid' : txid, 'vout' : vout} ]
	outputs = {}
	for i in range(2):
	outputs[self.nodes[0].getnewaddress()] = send_value
	rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
	signedtx = self.nodes[0].signrawtransaction(rawtx)
	txid = self.nodes[0].sendrawtransaction(signedtx['hex'])
	tx0_id = txid
	value = send_value

	# Create tx1
	(tx1_id, tx1_value) = self.chain_transaction(self.nodes[0], tx0_id, 0, value, fee, 1)

	# Create tx2-7
	vout = 1
	txid = tx0_id
	for i in range(6):
	(txid, sent_value) = self.chain_transaction(self.nodes[0], txid, vout, value, fee, 1)
	vout = 0
	value = sent_value

	# Mine these in a block
	self.nodes[0].generate(1)
	self.sync_all()

	# Now generate tx8, with a big fee
	inputs = [ {'txid' : tx1_id, 'vout': 0}, {'txid' : txid, 'vout': 0} ]
	outputs = { self.nodes[0].getnewaddress() : send_value + value - 4*fee }
	rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
	signedtx = self.nodes[0].signrawtransaction(rawtx)
	txid = self.nodes[0].sendrawtransaction(signedtx['hex'])
	sync_mempools(self.nodes)

	# Now try to disconnect the tip on each node...
	self.nodes[1].invalidateblock(self.nodes[1].getbestblockhash())
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
	sync_blocks(self.nodes)

	if __name__ == '__main__':
	MempoolPackagesTest().main()
	diff --git a/qa/rpc-tests/mempool_reorg.py b/qa/rpc-tests/mempool_reorg.py
	index 608e9d0a06..301b094eb0 100755
	--- a/qa/rpc-tests/mempool_reorg.py
	+++ b/qa/rpc-tests/mempool_reorg.py
	@@ -1,97 +1,101 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test re-org scenarios with a mempool that contains transactions
	# that spend (directly or indirectly) coinbase transactions.
	#

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

	# Create one-input, one-output, no-fee transaction:
	class MempoolCoinbaseTest(BitcoinTestFramework):
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 2
	+ self.setup_clean_chain = False

	alert_filename = None # Set by setup_network

	def setup_network(self):
	args = ["-checkmempool", "-debug=mempool"]
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, args))
	self.nodes.append(start_node(1, self.options.tmpdir, args))
	connect_nodes(self.nodes[1], 0)
	self.is_network_split = False
	self.sync_all()

	def run_test(self):
	start_count = self.nodes[0].getblockcount()

	# Mine three blocks. After this, nodes[0] blocks
	# 101, 102, and 103 are spend-able.
	new_blocks = self.nodes[1].generate(4)
	self.sync_all()

	node0_address = self.nodes[0].getnewaddress()
	node1_address = self.nodes[1].getnewaddress()

	# Three scenarios for re-orging coinbase spends in the memory pool:
	# 1. Direct coinbase spend : spend_101
	# 2. Indirect (coinbase spend in chain, child in mempool) : spend_102 and spend_102_1
	# 3. Indirect (coinbase and child both in chain) : spend_103 and spend_103_1
	# Use invalidatblock to make all of the above coinbase spends invalid (immature coinbase),
	# and make sure the mempool code behaves correctly.
	b = [ self.nodes[0].getblockhash(n) for n in range(101, 105) ]
	coinbase_txids = [ self.nodes[0].getblock(h)['tx'][0] for h in b ]
	spend_101_raw = create_tx(self.nodes[0], coinbase_txids[1], node1_address, 49.99)
	spend_102_raw = create_tx(self.nodes[0], coinbase_txids[2], node0_address, 49.99)
	spend_103_raw = create_tx(self.nodes[0], coinbase_txids[3], node0_address, 49.99)

	# Create a block-height-locked transaction which will be invalid after reorg
	timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 49.99})
	# Set the time lock
	timelock_tx = timelock_tx.replace("ffffffff", "11111111", 1)
	timelock_tx = timelock_tx[:-8] + hex(self.nodes[0].getblockcount() + 2)[2:] + "000000"
	timelock_tx = self.nodes[0].signrawtransaction(timelock_tx)["hex"]
	assert_raises(JSONRPCException, self.nodes[0].sendrawtransaction, timelock_tx)

	# Broadcast and mine spend_102 and 103:
	spend_102_id = self.nodes[0].sendrawtransaction(spend_102_raw)
	spend_103_id = self.nodes[0].sendrawtransaction(spend_103_raw)
	self.nodes[0].generate(1)
	assert_raises(JSONRPCException, self.nodes[0].sendrawtransaction, timelock_tx)

	# Create 102_1 and 103_1:
	spend_102_1_raw = create_tx(self.nodes[0], spend_102_id, node1_address, 49.98)
	spend_103_1_raw = create_tx(self.nodes[0], spend_103_id, node1_address, 49.98)

	# Broadcast and mine 103_1:
	spend_103_1_id = self.nodes[0].sendrawtransaction(spend_103_1_raw)
	last_block = self.nodes[0].generate(1)
	timelock_tx_id = self.nodes[0].sendrawtransaction(timelock_tx)

	# ... now put spend_101 and spend_102_1 in memory pools:
	spend_101_id = self.nodes[0].sendrawtransaction(spend_101_raw)
	spend_102_1_id = self.nodes[0].sendrawtransaction(spend_102_1_raw)

	self.sync_all()

	assert_equal(set(self.nodes[0].getrawmempool()), {spend_101_id, spend_102_1_id, timelock_tx_id})

	for node in self.nodes:
	node.invalidateblock(last_block[0])
	assert_equal(set(self.nodes[0].getrawmempool()), {spend_101_id, spend_102_1_id, spend_103_1_id})

	# Use invalidateblock to re-org back and make all those coinbase spends
	# immature/invalid:
	for node in self.nodes:
	node.invalidateblock(new_blocks[0])

	self.sync_all()

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

	if __name__ == '__main__':
	MempoolCoinbaseTest().main()
	diff --git a/qa/rpc-tests/mempool_resurrect_test.py b/qa/rpc-tests/mempool_resurrect_test.py
	index b4d9f0a1a2..3db12cbf76 100755
	--- a/qa/rpc-tests/mempool_resurrect_test.py
	+++ b/qa/rpc-tests/mempool_resurrect_test.py
	@@ -1,76 +1,81 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test resurrection of mined transactions when
	# the blockchain is re-organized.
	#

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

	# Create one-input, one-output, no-fee transaction:
	class MempoolCoinbaseTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 1
	+ self.setup_clean_chain = False
	+
	def setup_network(self):
	# Just need one node for this test
	args = ["-checkmempool", "-debug=mempool"]
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, args))
	self.is_network_split = False

	def run_test(self):
	node0_address = self.nodes[0].getnewaddress()
	# Spend block 1/2/3's coinbase transactions
	# Mine a block.
	# Create three more transactions, spending the spends
	# Mine another block.
	# ... make sure all the transactions are confirmed
	# Invalidate both blocks
	# ... make sure all the transactions are put back in the mempool
	# Mine a new block
	# ... make sure all the transactions are confirmed again.

	b = [ self.nodes[0].getblockhash(n) for n in range(1, 4) ]
	coinbase_txids = [ self.nodes[0].getblock(h)['tx'][0] for h in b ]
	spends1_raw = [ create_tx(self.nodes[0], txid, node0_address, 49.99) for txid in coinbase_txids ]
	spends1_id = [ self.nodes[0].sendrawtransaction(tx) for tx in spends1_raw ]

	blocks = []
	blocks.extend(self.nodes[0].generate(1))

	spends2_raw = [ create_tx(self.nodes[0], txid, node0_address, 49.98) for txid in spends1_id ]
	spends2_id = [ self.nodes[0].sendrawtransaction(tx) for tx in spends2_raw ]

	blocks.extend(self.nodes[0].generate(1))

	# mempool should be empty, all txns confirmed
	assert_equal(set(self.nodes[0].getrawmempool()), set())
	for txid in spends1_id+spends2_id:
	tx = self.nodes[0].gettransaction(txid)
	assert(tx["confirmations"] > 0)

	# Use invalidateblock to re-org back; all transactions should
	# end up unconfirmed and back in the mempool
	for node in self.nodes:
	node.invalidateblock(blocks[0])

	# mempool should be empty, all txns confirmed
	assert_equal(set(self.nodes[0].getrawmempool()), set(spends1_id+spends2_id))
	for txid in spends1_id+spends2_id:
	tx = self.nodes[0].gettransaction(txid)
	assert(tx["confirmations"] == 0)

	# Generate another block, they should all get mined
	self.nodes[0].generate(1)
	# mempool should be empty, all txns confirmed
	assert_equal(set(self.nodes[0].getrawmempool()), set())
	for txid in spends1_id+spends2_id:
	tx = self.nodes[0].gettransaction(txid)
	assert(tx["confirmations"] > 0)


	if __name__ == '__main__':
	MempoolCoinbaseTest().main()
	diff --git a/qa/rpc-tests/mempool_spendcoinbase.py b/qa/rpc-tests/mempool_spendcoinbase.py
	index c23f5ef10a..d5e4bf52d2 100755
	--- a/qa/rpc-tests/mempool_spendcoinbase.py
	+++ b/qa/rpc-tests/mempool_spendcoinbase.py
	@@ -1,58 +1,63 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test spending coinbase transactions.
	# The coinbase transaction in block N can appear in block
	# N+100... so is valid in the mempool when the best block
	# height is N+99.
	# This test makes sure coinbase spends that will be mature
	# in the next block are accepted into the memory pool,
	# but less mature coinbase spends are NOT.
	#

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

	# Create one-input, one-output, no-fee transaction:
	class MempoolSpendCoinbaseTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 1
	+ self.setup_clean_chain = False
	+
	def setup_network(self):
	# Just need one node for this test
	args = ["-checkmempool", "-debug=mempool"]
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, args))
	self.is_network_split = False

	def run_test(self):
	chain_height = self.nodes[0].getblockcount()
	assert_equal(chain_height, 200)
	node0_address = self.nodes[0].getnewaddress()

	# Coinbase at height chain_height-100+1 ok in mempool, should
	# get mined. Coinbase at height chain_height-100+2 is
	# is too immature to spend.
	b = [ self.nodes[0].getblockhash(n) for n in range(101, 103) ]
	coinbase_txids = [ self.nodes[0].getblock(h)['tx'][0] for h in b ]
	spends_raw = [ create_tx(self.nodes[0], txid, node0_address, 49.99) for txid in coinbase_txids ]

	spend_101_id = self.nodes[0].sendrawtransaction(spends_raw[0])

	# coinbase at height 102 should be too immature to spend
	assert_raises(JSONRPCException, self.nodes[0].sendrawtransaction, spends_raw[1])

	# mempool should have just spend_101:
	assert_equal(self.nodes[0].getrawmempool(), [ spend_101_id ])

	# mine a block, spend_101 should get confirmed
	self.nodes[0].generate(1)
	assert_equal(set(self.nodes[0].getrawmempool()), set())

	# ... and now height 102 can be spent:
	spend_102_id = self.nodes[0].sendrawtransaction(spends_raw[1])
	assert_equal(self.nodes[0].getrawmempool(), [ spend_102_id ])

	if __name__ == '__main__':
	MempoolSpendCoinbaseTest().main()
	diff --git a/qa/rpc-tests/merkle_blocks.py b/qa/rpc-tests/merkle_blocks.py
	index 9419d9a714..b2155d7fc3 100755
	--- a/qa/rpc-tests/merkle_blocks.py
	+++ b/qa/rpc-tests/merkle_blocks.py
	@@ -1,87 +1,88 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test merkleblock fetch/validation
	#

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

	class MerkleBlockTest(BitcoinTestFramework):

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 4)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 4

	def setup_network(self):
	self.nodes = []
	# Nodes 0/1 are "wallet" nodes
	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug"]))
	self.nodes.append(start_node(1, self.options.tmpdir, ["-debug"]))
	# Nodes 2/3 are used for testing
	self.nodes.append(start_node(2, self.options.tmpdir, ["-debug"]))
	self.nodes.append(start_node(3, self.options.tmpdir, ["-debug", "-txindex"]))
	connect_nodes(self.nodes[0], 1)
	connect_nodes(self.nodes[0], 2)
	connect_nodes(self.nodes[0], 3)

	self.is_network_split = False
	self.sync_all()

	def run_test(self):
	print("Mining blocks...")
	self.nodes[0].generate(105)
	self.sync_all()

	chain_height = self.nodes[1].getblockcount()
	assert_equal(chain_height, 105)
	assert_equal(self.nodes[1].getbalance(), 0)
	assert_equal(self.nodes[2].getbalance(), 0)

	node0utxos = self.nodes[0].listunspent(1)
	tx1 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99})
	txid1 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransaction(tx1)["hex"])
	tx2 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99})
	txid2 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransaction(tx2)["hex"])
	assert_raises(JSONRPCException, self.nodes[0].gettxoutproof, [txid1])

	self.nodes[0].generate(1)
	blockhash = self.nodes[0].getblockhash(chain_height + 1)
	self.sync_all()

	txlist = []
	blocktxn = self.nodes[0].getblock(blockhash, True)["tx"]
	txlist.append(blocktxn[1])
	txlist.append(blocktxn[2])

	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1])), [txid1])
	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1, txid2])), txlist)
	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1, txid2], blockhash)), txlist)

	txin_spent = self.nodes[1].listunspent(1).pop()
	tx3 = self.nodes[1].createrawtransaction([txin_spent], {self.nodes[0].getnewaddress(): 49.98})
	self.nodes[0].sendrawtransaction(self.nodes[1].signrawtransaction(tx3)["hex"])
	self.nodes[0].generate(1)
	self.sync_all()

	txid_spent = txin_spent["txid"]
	txid_unspent = txid1 if txin_spent["txid"] != txid1 else txid2

	# We can't find the block from a fully-spent tx
	assert_raises(JSONRPCException, self.nodes[2].gettxoutproof, [txid_spent])
	# ...but we can if we specify the block
	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid_spent], blockhash)), [txid_spent])
	# ...or if the first tx is not fully-spent
	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid_unspent])), [txid_unspent])
	try:
	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1, txid2])), txlist)
	except JSONRPCException:
	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid2, txid1])), txlist)
	# ...or if we have a -txindex
	assert_equal(self.nodes[2].verifytxoutproof(self.nodes[3].gettxoutproof([txid_spent])), [txid_spent])

	if __name__ == '__main__':
	MerkleBlockTest().main()
	diff --git a/qa/rpc-tests/multi_rpc.py b/qa/rpc-tests/multi_rpc.py
	index 577d80949d..24373b257d 100755
	--- a/qa/rpc-tests/multi_rpc.py
	+++ b/qa/rpc-tests/multi_rpc.py
	@@ -1,114 +1,120 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test mulitple rpc user config option rpcauth
	#

	from test_framework.test_framework import BitcoinTestFramework
	-from test_framework.util import *
	+from test_framework.util import str_to_b64str, assert_equal

	+import os
	import http.client
	import urllib.parse

	class HTTPBasicsTest (BitcoinTestFramework):
	- def setup_nodes(self):
	- return start_nodes(4, self.options.tmpdir)
	+
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = False
	+ self.num_nodes = 1

	def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain(self.options.tmpdir)
	+ super().setup_chain()
	#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') 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
	authpair = url.username + ':' + url.password

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

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

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

	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)
	conn.close()

	#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)
	conn.close()

	#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)
	conn.close()

	#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)
	conn.close()

	#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)
	conn.close()

	#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)
	conn.close()


	if __name__ == '__main__':
	HTTPBasicsTest ().main ()
	diff --git a/qa/rpc-tests/nodehandling.py b/qa/rpc-tests/nodehandling.py
	index 1b6ba021a0..e9682c4908 100755
	--- a/qa/rpc-tests/nodehandling.py
	+++ b/qa/rpc-tests/nodehandling.py
	@@ -1,80 +1,86 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test node handling
	#

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

	import http.client
	import urllib.parse

	class NodeHandlingTest (BitcoinTestFramework):
	+
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 4
	+ 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
	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
	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
	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
	try:
	self.nodes[2].setban("127.0.0.1", "remove")
	except:
	pass
	assert_equal(len(self.nodes[2].listbanned()), 1)
	self.nodes[2].setban("127.0.0.0/24", "remove")
	assert_equal(len(self.nodes[2].listbanned()), 0)
	self.nodes[2].clearbanned()
	assert_equal(len(self.nodes[2].listbanned()), 0)

	##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
	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

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

	self.nodes[2] = start_node(2, self.options.tmpdir)
	listAfterShutdown = self.nodes[2].listbanned()
	assert_equal("127.0.0.0/24", listAfterShutdown[0]['address'])
	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
	for node in self.nodes[0].getpeerinfo():
	assert(node['addr'] != url.hostname+":"+str(p2p_port(1)))

	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)):
	found = True
	assert(found)

	if __name__ == '__main__':
	NodeHandlingTest ().main ()
	diff --git a/qa/rpc-tests/p2p-acceptblock.py b/qa/rpc-tests/p2p-acceptblock.py
	index 21e4c2f468..015ec34eff 100755
	--- a/qa/rpc-tests/p2p-acceptblock.py
	+++ b/qa/rpc-tests/p2p-acceptblock.py
	@@ -1,289 +1,291 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.mininode import *
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	import time
	from test_framework.blocktools import create_block, create_coinbase

	'''
	AcceptBlockTest -- test processing of unrequested blocks.

	Since behavior differs when receiving unrequested blocks from whitelisted peers
	versus non-whitelisted peers, this tests the behavior of both (effectively two
	separate tests running in parallel).

	Setup: two nodes, node0 and node1, not connected to each other. Node0 does not
	whitelist localhost, but node1 does. They will each be on their own chain for
	this test.

	We have one NodeConn connection to each, test_node and white_node respectively.

	The test:
	1. Generate one block on each node, to leave IBD.

	2. Mine a new block on each tip, and deliver to each node from node's peer.
	The tip should advance.

	3. Mine a block that forks the previous block, and deliver to each node from
	corresponding peer.
	Node0 should not process this block (just accept the header), because it is
	unrequested and doesn't have more work than the tip.
	Node1 should process because this is coming from a whitelisted peer.

	4. Send another block that builds on the forking block.
	Node0 should process this block but be stuck on the shorter chain, because
	it's missing an intermediate block.
	Node1 should reorg to this longer chain.

	4b.Send 288 more blocks on the longer chain.
	Node0 should process all but the last block (too far ahead in height).
	Send all headers to Node1, and then send the last block in that chain.
	Node1 should accept the block because it's coming from a whitelisted peer.

	5. Send a duplicate of the block in #3 to Node0.
	Node0 should not process the block because it is unrequested, and stay on
	the shorter chain.

	6. Send Node0 an inv for the height 3 block produced in #4 above.
	Node0 should figure out that Node0 has the missing height 2 block and send a
	getdata.

	7. Send Node0 the missing block again.
	Node0 should process and the tip should advance.
	'''

	# 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
	self.ping_counter = 1
	self.last_pong = msg_pong()

	def add_connection(self, conn):
	self.connection = conn

	# Track the last getdata message we receive (used in the test)
	def on_getdata(self, conn, message):
	self.last_getdata = message

	# Spin until verack message is received from the node.
	# We use this to signal that our test can begin. This
	# is called from the testing thread, so it needs to acquire
	# the global lock.
	def wait_for_verack(self):
	while True:
	with mininode_lock:
	if self.verack_received:
	return
	time.sleep(0.05)

	# Wrapper for the NodeConn's send_message function
	def send_message(self, message):
	self.connection.send_message(message)

	def on_pong(self, conn, message):
	self.last_pong = message

	# Sync up with the node after delivery of a block
	def sync_with_ping(self, timeout=30):
	self.connection.send_message(msg_ping(nonce=self.ping_counter))
	received_pong = False
	sleep_time = 0.05
	while not received_pong and timeout > 0:
	time.sleep(sleep_time)
	timeout -= sleep_time
	with mininode_lock:
	if self.last_pong.nonce == self.ping_counter:
	received_pong = True
	self.ping_counter += 1
	return received_pong


	class AcceptBlockTest(BitcoinTestFramework):
	def add_options(self, parser):
	parser.add_option("--testbinary", dest="testbinary",
	default=os.getenv("BITCOIND", "bitcoind"),
	help="bitcoind binary to test")

	- def setup_chain(self):
	- initialize_chain_clean(self.options.tmpdir, 2)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 2

	def setup_network(self):
	# Node0 will be used to test behavior of processing unrequested blocks
	# from peers which are not whitelisted, while Node1 will be used for
	# the whitelisted case.
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug"],
	binary=self.options.testbinary))
	self.nodes.append(start_node(1, self.options.tmpdir,
	["-debug", "-whitelist=127.0.0.1"],
	binary=self.options.testbinary))

	def run_test(self):
	# Setup the p2p connections and start up the network thread.
	test_node = TestNode() # connects to node0 (not whitelisted)
	white_node = TestNode() # connects to node1 (whitelisted)

	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(1), self.nodes[1], white_node))
	test_node.add_connection(connections[0])
	white_node.add_connection(connections[1])

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

	# Test logic begins here
	test_node.wait_for_verack()
	white_node.wait_for_verack()

	# 1. Have both nodes mine a block (leave IBD)
	[ n.generate(1) for n in self.nodes ]
	tips = [ int("0x" + n.getbestblockhash(), 0) for n in self.nodes ]

	# 2. Send one block that builds on each tip.
	# This should be accepted.
	blocks_h2 = [] # the height 2 blocks on each node's chain
	block_time = int(time.time()) + 1
	for i in range(2):
	blocks_h2.append(create_block(tips[i], create_coinbase(2), block_time))
	blocks_h2[i].solve()
	block_time += 1
	test_node.send_message(msg_block(blocks_h2[0]))
	white_node.send_message(msg_block(blocks_h2[1]))

	[ x.sync_with_ping() for x in [test_node, white_node] ]
	assert_equal(self.nodes[0].getblockcount(), 2)
	assert_equal(self.nodes[1].getblockcount(), 2)
	print("First height 2 block accepted by both nodes")

	# 3. Send another block that builds on the original tip.
	blocks_h2f = [] # Blocks at height 2 that fork off the main chain
	for i in range(2):
	blocks_h2f.append(create_block(tips[i], create_coinbase(2), blocks_h2[i].nTime+1))
	blocks_h2f[i].solve()
	test_node.send_message(msg_block(blocks_h2f[0]))
	white_node.send_message(msg_block(blocks_h2f[1]))

	[ x.sync_with_ping() for x in [test_node, white_node] ]
	for x in self.nodes[0].getchaintips():
	if x['hash'] == blocks_h2f[0].hash:
	assert_equal(x['status'], "headers-only")

	for x in self.nodes[1].getchaintips():
	if x['hash'] == blocks_h2f[1].hash:
	assert_equal(x['status'], "valid-headers")

	print("Second height 2 block accepted only from whitelisted peer")

	# 4. Now send another block that builds on the forking chain.
	blocks_h3 = []
	for i in range(2):
	blocks_h3.append(create_block(blocks_h2f[i].sha256, create_coinbase(3), blocks_h2f[i].nTime+1))
	blocks_h3[i].solve()
	test_node.send_message(msg_block(blocks_h3[0]))
	white_node.send_message(msg_block(blocks_h3[1]))

	[ x.sync_with_ping() for x in [test_node, white_node] ]
	# Since the earlier block was not processed by node0, the new block
	# can't be fully validated.
	for x in self.nodes[0].getchaintips():
	if x['hash'] == blocks_h3[0].hash:
	assert_equal(x['status'], "headers-only")

	# But this block should be accepted by node0 since it has more work.
	try:
	self.nodes[0].getblock(blocks_h3[0].hash)
	print("Unrequested more-work block accepted from non-whitelisted peer")
	except:
	raise AssertionError("Unrequested more work block was not processed")

	# Node1 should have accepted and reorged.
	assert_equal(self.nodes[1].getblockcount(), 3)
	print("Successfully reorged to length 3 chain from whitelisted peer")

	# 4b. Now mine 288 more blocks and deliver; all should be processed but
	# the last (height-too-high) on node0. Node1 should process the tip if
	# we give it the headers chain leading to the tip.
	tips = blocks_h3
	headers_message = msg_headers()
	all_blocks = [] # node0's blocks
	for j in range(2):
	for i in range(288):
	next_block = create_block(tips[j].sha256, create_coinbase(i + 4), tips[j].nTime+1)
	next_block.solve()
	if j==0:
	test_node.send_message(msg_block(next_block))
	all_blocks.append(next_block)
	else:
	headers_message.headers.append(CBlockHeader(next_block))
	tips[j] = next_block

	time.sleep(2)
	for x in all_blocks:
	try:
	self.nodes[0].getblock(x.hash)
	if x == all_blocks[287]:
	raise AssertionError("Unrequested block too far-ahead should have been ignored")
	except:
	if x == all_blocks[287]:
	print("Unrequested block too far-ahead not processed")
	else:
	raise AssertionError("Unrequested block with more work should have been accepted")

	headers_message.headers.pop() # Ensure the last block is unrequested
	white_node.send_message(headers_message) # Send headers leading to tip
	white_node.send_message(msg_block(tips[1])) # Now deliver the tip
	try:
	white_node.sync_with_ping()
	self.nodes[1].getblock(tips[1].hash)
	print("Unrequested block far ahead of tip accepted from whitelisted peer")
	except:
	raise AssertionError("Unrequested block from whitelisted peer not accepted")

	# 5. Test handling of unrequested block on the node that didn't process
	# Should still not be processed (even though it has a child that has more
	# work).
	test_node.send_message(msg_block(blocks_h2f[0]))

	# Here, if the sleep is too short, the test could falsely succeed (if the
	# node hasn't processed the block by the time the sleep returns, and then
	# the node processes it and incorrectly advances the tip).
	# But this would be caught later on, when we verify that an inv triggers
	# a getdata request for this block.
	test_node.sync_with_ping()
	assert_equal(self.nodes[0].getblockcount(), 2)
	print("Unrequested block that would complete more-work chain was ignored")

	# 6. Try to get node to request the missing block.
	# Poke the node with an inv for block at height 3 and see if that
	# triggers a getdata on block 2 (it should if block 2 is missing).
	with mininode_lock:
	# Clear state so we can check the getdata request
	test_node.last_getdata = None
	test_node.send_message(msg_inv([CInv(2, blocks_h3[0].sha256)]))

	test_node.sync_with_ping()
	with mininode_lock:
	getdata = test_node.last_getdata

	# Check that the getdata includes the right block
	assert_equal(getdata.inv[0].hash, blocks_h2f[0].sha256)
	print("Inv at tip triggered getdata for unprocessed block")

	# 7. Send the missing block for the third time (now it is requested)
	test_node.send_message(msg_block(blocks_h2f[0]))

	test_node.sync_with_ping()
	assert_equal(self.nodes[0].getblockcount(), 290)
	print("Successfully reorged to longer chain from non-whitelisted peer")

	[ c.disconnect_node() for c in connections ]

	if __name__ == '__main__':
	AcceptBlockTest().main()
	diff --git a/qa/rpc-tests/p2p-feefilter.py b/qa/rpc-tests/p2p-feefilter.py
	index 5fb51ed0fe..cd0501a314 100755
	--- a/qa/rpc-tests/p2p-feefilter.py
	+++ b/qa/rpc-tests/p2p-feefilter.py
	@@ -1,99 +1,105 @@
	#!/usr/bin/env python3
	# Copyright (c) 2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.
	#

	from test_framework.mininode import *
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	import time

	'''
	FeeFilterTest -- test processing of feefilter messages
	'''

	def hashToHex(hash):
	return format(hash, '064x')

	# Wait up to 60 secs to see if the testnode has received all the expected invs
	def allInvsMatch(invsExpected, testnode):
	for x in range(60):
	with mininode_lock:
	if (sorted(invsExpected) == sorted(testnode.txinvs)):
	return True;
	time.sleep(1)
	return False;

	# TestNode: bare-bones "peer". Used to track which invs are received from a node
	# and to send the node feefilter messages.
	class TestNode(SingleNodeConnCB):
	def __init__(self):
	SingleNodeConnCB.__init__(self)
	self.txinvs = []

	def on_inv(self, conn, message):
	for i in message.inv:
	if (i.type == 1):
	self.txinvs.append(hashToHex(i.hash))

	def clear_invs(self):
	with mininode_lock:
	self.txinvs = []

	def send_filter(self, feerate):
	self.send_message(msg_feefilter(feerate))
	self.sync_with_ping()

	class FeeFilterTest(BitcoinTestFramework):
	+
	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 2
	+ self.setup_clean_chain = False
	+
	def setup_network(self):
	# Node1 will be used to generate txs which should be relayed from Node0
	# to our test node
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug", "-logtimemicros"]))
	self.nodes.append(start_node(1, self.options.tmpdir, ["-debug", "-logtimemicros"]))
	connect_nodes(self.nodes[0], 1)

	def run_test(self):
	node1 = self.nodes[1]
	# Get out of IBD
	node1.generate(1)
	sync_blocks(self.nodes)

	# Setup the p2p connections and start up the network thread.
	test_node = TestNode()
	connection = NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node)
	test_node.add_connection(connection)
	NetworkThread().start()
	test_node.wait_for_verack()

	# Test that invs are received for all txs at feerate of 20 sat/byte
	node1.settxfee(Decimal("0.00020000"))
	txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
	assert(allInvsMatch(txids, test_node))
	test_node.clear_invs()

	# Set a filter of 15 sat/byte
	test_node.send_filter(15000)

	# Test that txs are still being received (paying 20 sat/byte)
	txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
	assert(allInvsMatch(txids, test_node))
	test_node.clear_invs()

	# Change tx fee rate to 10 sat/byte and test they are no longer received
	node1.settxfee(Decimal("0.00010000"))
	[node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
	sync_mempools(self.nodes) # must be sure node 0 has received all txs
	time.sleep(10) # wait 10 secs to be sure its doesn't relay any
	assert(allInvsMatch([], test_node))
	test_node.clear_invs()

	# Remove fee filter and check that txs are received again
	test_node.send_filter(0)
	txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
	assert(allInvsMatch(txids, test_node))
	test_node.clear_invs()

	if __name__ == '__main__':
	FeeFilterTest().main()
	diff --git a/qa/rpc-tests/p2p-fullblocktest.py b/qa/rpc-tests/p2p-fullblocktest.py
	index 56df8ffd01..aa0501c5e9 100755
	--- a/qa/rpc-tests/p2p-fullblocktest.py
	+++ b/qa/rpc-tests/p2p-fullblocktest.py
	@@ -1,399 +1,400 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.test_framework import ComparisonTestFramework
	from test_framework.util import *
	from test_framework.comptool import TestManager, TestInstance, RejectResult
	from test_framework.blocktools import *
	import time
	from test_framework.key import CECKey
	from test_framework.script import CScript, SignatureHash, SIGHASH_ALL, OP_TRUE, OP_FALSE

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

	'''
	This reimplements tests from the bitcoinj/FullBlockTestGenerator used
	by the pull-tester.

	We use the testing framework in which we expect a particular answer from
	each test.
	'''

	class FullBlockTest(ComparisonTestFramework):

	''' Can either run this test as 1 node with expected answers, or two and compare them.
	Change the "outcome" variable from each TestInstance object to only do the comparison. '''
	def __init__(self):
	+ super().__init__()
	self.num_nodes = 1
	self.block_heights = {}
	self.coinbase_key = CECKey()
	self.coinbase_key.set_secretbytes(b"horsebattery")
	self.coinbase_pubkey = self.coinbase_key.get_pubkey()
	self.block_time = int(time.time())+1
	self.tip = None
	self.blocks = {}

	def run_test(self):
	test = TestManager(self, self.options.tmpdir)
	test.add_all_connections(self.nodes)
	NetworkThread().start() # Start up network handling in another thread
	test.run()

	def add_transactions_to_block(self, block, tx_list):
	[ tx.rehash() for tx in tx_list ]
	block.vtx.extend(tx_list)
	block.hashMerkleRoot = block.calc_merkle_root()
	block.rehash()
	return block

	# Create a block on top of self.tip, and advance self.tip to point to the new block
	# if spend is specified, then 1 satoshi will be spent from that to an anyone-can-spend output,
	# and rest will go to fees.
	def next_block(self, number, spend=None, additional_coinbase_value=0, script=None):
	if self.tip == None:
	base_block_hash = self.genesis_hash
	else:
	base_block_hash = self.tip.sha256
	# First create the coinbase
	height = self.block_heights[base_block_hash] + 1
	coinbase = create_coinbase(height, self.coinbase_pubkey)
	coinbase.vout[0].nValue += additional_coinbase_value
	if (spend != None):
	coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1 # all but one satoshi to fees
	coinbase.rehash()
	block = create_block(base_block_hash, coinbase, self.block_time)
	if (spend != None):
	tx = CTransaction()
	tx.vin.append(CTxIn(COutPoint(spend.tx.sha256, spend.n), b"", 0xffffffff)) # no signature yet
	# This copies the java comparison tool testing behavior: the first
	# txout has a garbage scriptPubKey, "to make sure we're not
	# pre-verifying too much" (?)
	tx.vout.append(CTxOut(0, CScript([random.randint(0,255), height & 255])))
	if script == None:
	tx.vout.append(CTxOut(1, CScript([OP_TRUE])))
	else:
	tx.vout.append(CTxOut(1, script))
	# Now sign it if necessary
	scriptSig = b""
	scriptPubKey = bytearray(spend.tx.vout[spend.n].scriptPubKey)
	if (scriptPubKey[0] == OP_TRUE): # looks like an anyone-can-spend
	scriptSig = CScript([OP_TRUE])
	else:
	# We have to actually sign it
	(sighash, err) = SignatureHash(spend.tx.vout[spend.n].scriptPubKey, tx, 0, SIGHASH_ALL)
	scriptSig = CScript([self.coinbase_key.sign(sighash) + bytes(bytearray([SIGHASH_ALL]))])
	tx.vin[0].scriptSig = scriptSig
	# Now add the transaction to the block
	block = self.add_transactions_to_block(block, [tx])
	block.solve()
	self.tip = block
	self.block_heights[block.sha256] = height
	self.block_time += 1
	assert number not in self.blocks
	self.blocks[number] = block
	return block

	def get_tests(self):
	self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
	self.block_heights[self.genesis_hash] = 0
	spendable_outputs = []

	# save the current tip so it can be spent by a later block
	def save_spendable_output():
	spendable_outputs.append(self.tip)

	# get an output that we previous marked as spendable
	def get_spendable_output():
	return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)

	# returns a test case that asserts that the current tip was accepted
	def accepted():
	return TestInstance([[self.tip, True]])

	# returns a test case that asserts that the current tip was rejected
	def rejected(reject = None):
	if reject is None:
	return TestInstance([[self.tip, False]])
	else:
	return TestInstance([[self.tip, reject]])

	# move the tip back to a previous block
	def tip(number):
	self.tip = self.blocks[number]

	# add transactions to a block produced by next_block
	def update_block(block_number, new_transactions):
	block = self.blocks[block_number]
	old_hash = block.sha256
	self.add_transactions_to_block(block, new_transactions)
	block.solve()
	# Update the internal state just like in next_block
	self.tip = block
	self.block_heights[block.sha256] = self.block_heights[old_hash]
	del self.block_heights[old_hash]
	self.blocks[block_number] = block
	return block

	# creates a new block and advances the tip to that block
	block = self.next_block


	# Create a new block
	block(0)
	save_spendable_output()
	yield accepted()


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


	# Start by building a couple of blocks on top (which output is spent is
	# in parentheses):
	# genesis -> b1 (0) -> b2 (1)
	out0 = get_spendable_output()
	block(1, spend=out0)
	save_spendable_output()
	yield accepted()

	out1 = get_spendable_output()
	b2 = block(2, spend=out1)
	yield accepted()


	# so fork like this:
	#
	# genesis -> b1 (0) -> b2 (1)
	# \-> b3 (1)
	#
	# Nothing should happen at this point. We saw b2 first so it takes priority.
	tip(1)
	b3 = block(3, spend=out1)
	txout_b3 = PreviousSpendableOutput(b3.vtx[1], 1)
	yield rejected()


	# Now we add another block to make the alternative chain longer.
	#
	# genesis -> b1 (0) -> b2 (1)
	# \-> b3 (1) -> b4 (2)
	out2 = get_spendable_output()
	block(4, spend=out2)
	yield accepted()


	# ... and back to the first chain.
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b3 (1) -> b4 (2)
	tip(2)
	block(5, spend=out2)
	save_spendable_output()
	yield rejected()

	out3 = get_spendable_output()
	block(6, spend=out3)
	yield accepted()


	# Try to create a fork that double-spends
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b7 (2) -> b8 (4)
	# \-> b3 (1) -> b4 (2)
	tip(5)
	block(7, spend=out2)
	yield rejected()

	out4 = get_spendable_output()
	block(8, spend=out4)
	yield rejected()


	# Try to create a block that has too much fee
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b9 (4)
	# \-> b3 (1) -> b4 (2)
	tip(6)
	block(9, spend=out4, additional_coinbase_value=1)
	yield rejected(RejectResult(16, b'bad-cb-amount'))


	# Create a fork that ends in a block with too much fee (the one that causes the reorg)
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b10 (3) -> b11 (4)
	# \-> b3 (1) -> b4 (2)
	tip(5)
	block(10, spend=out3)
	yield rejected()

	block(11, spend=out4, additional_coinbase_value=1)
	yield rejected(RejectResult(16, b'bad-cb-amount'))


	# Try again, but with a valid fork first
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b14 (5)
	# (b12 added last)
	# \-> b3 (1) -> b4 (2)
	tip(5)
	b12 = block(12, spend=out3)
	save_spendable_output()
	#yield TestInstance([[b12, False]])
	b13 = block(13, spend=out4)
	# Deliver the block header for b12, and the block b13.
	# b13 should be accepted but the tip won't advance until b12 is delivered.
	yield TestInstance([[CBlockHeader(b12), None], [b13, False]])

	save_spendable_output()
	out5 = get_spendable_output()
	# b14 is invalid, but the node won't know that until it tries to connect
	# Tip still can't advance because b12 is missing
	block(14, spend=out5, additional_coinbase_value=1)
	yield rejected()

	yield TestInstance([[b12, True, b13.sha256]]) # New tip should be b13.

	# Add a block with MAX_BLOCK_SIGOPS and one with one more sigop
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b16 (6)
	# \-> b3 (1) -> b4 (2)

	# Test that a block with a lot of checksigs is okay
	lots_of_checksigs = CScript([OP_CHECKSIG] * (1000000 // 50 - 1))
	tip(13)
	block(15, spend=out5, script=lots_of_checksigs)
	yield accepted()


	# Test that a block with too many checksigs is rejected
	out6 = get_spendable_output()
	too_many_checksigs = CScript([OP_CHECKSIG] * (1000000 // 50))
	block(16, spend=out6, script=too_many_checksigs)
	yield rejected(RejectResult(16, b'bad-blk-sigops'))


	# Attempt to spend a transaction created on a different fork
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])
	# \-> b3 (1) -> b4 (2)
	tip(15)
	block(17, spend=txout_b3)
	yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))

	# Attempt to spend a transaction created on a different fork (on a fork this time)
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5)
	# \-> b18 (b3.vtx[1]) -> b19 (6)
	# \-> b3 (1) -> b4 (2)
	tip(13)
	block(18, spend=txout_b3)
	yield rejected()

	block(19, spend=out6)
	yield rejected()

	# Attempt to spend a coinbase at depth too low
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)
	# \-> b3 (1) -> b4 (2)
	tip(15)
	out7 = get_spendable_output()
	block(20, spend=out7)
	yield rejected(RejectResult(16, b'bad-txns-premature-spend-of-coinbase'))

	# Attempt to spend a coinbase at depth too low (on a fork this time)
	# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
	# \-> b12 (3) -> b13 (4) -> b15 (5)
	# \-> b21 (6) -> b22 (5)
	# \-> b3 (1) -> b4 (2)
	tip(13)
	block(21, spend=out6)
	yield rejected()

	block(22, spend=out5)
	yield rejected()

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

	# Make the next block one byte bigger and check that it fails
	tip(15)
	b24 = block(24, spend=out6)
	script_length = MAX_BLOCK_SIZE - len(b24.serialize()) - 69
	script_output = CScript([b'\x00' * (script_length+1)])
	tx.vout = [CTxOut(0, script_output)]
	b24 = update_block(24, [tx])
	assert_equal(len(b24.serialize()), MAX_BLOCK_SIZE+1)
	yield rejected(RejectResult(16, b'bad-blk-length'))

	b25 = block(25, spend=out7)
	yield rejected()

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

	# Extend the b26 chain to make sure bitcoind isn't accepting b26
	b27 = block(27, spend=out7)
	yield rejected()

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

	# Extend the b28 chain to make sure bitcoind isn't accepted b28
	b29 = block(29, spend=out7)
	# TODO: Should get a reject message back with "bad-prevblk", except
	# there's a bug that prevents this from being detected. Just note
	# failure for now, and add the reject result later.
	yield rejected()

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


	if __name__ == '__main__':
	FullBlockTest().main()
	diff --git a/qa/rpc-tests/p2p-versionbits-warning.py b/qa/rpc-tests/p2p-versionbits-warning.py
	index 8c8c2358f7..962cafef0b 100755
	--- a/qa/rpc-tests/p2p-versionbits-warning.py
	+++ b/qa/rpc-tests/p2p-versionbits-warning.py
	@@ -1,159 +1,161 @@
	#!/usr/bin/env python3
	# Copyright (c) 2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.mininode import *
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	import time
	from test_framework.blocktools import create_block, create_coinbase

	'''
	Test version bits' warning system.

	Generate chains with block versions that appear to be signalling unknown
	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_TOP_BITS = 0x20000000
	VB_UNKNOWN_BIT = 27 # Choose a bit unassigned to any deployment

	# 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
	self.ping_counter = 1
	self.last_pong = msg_pong()

	def add_connection(self, conn):
	self.connection = conn

	def on_inv(self, conn, message):
	pass

	# Wrapper for the NodeConn's send_message function
	def send_message(self, message):
	self.connection.send_message(message)

	def on_pong(self, conn, message):
	self.last_pong = message

	# Sync up with the node after delivery of a block
	def sync_with_ping(self, timeout=30):
	self.connection.send_message(msg_ping(nonce=self.ping_counter))
	received_pong = False
	sleep_time = 0.05
	while not received_pong and timeout > 0:
	time.sleep(sleep_time)
	timeout -= sleep_time
	with mininode_lock:
	if self.last_pong.nonce == self.ping_counter:
	received_pong = True
	self.ping_counter += 1
	return received_pong


	class VersionBitsWarningTest(BitcoinTestFramework):
	- def setup_chain(self):
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

	def setup_network(self):
	self.nodes = []
	self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
	# Open and close to create zero-length file
	with open(self.alert_filename, 'w') as f:
	pass
	self.node_options = ["-debug", "-logtimemicros=1", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]
	self.nodes.append(start_node(0, self.options.tmpdir, self.node_options))

	import re
	self.vb_pattern = re.compile("^Warning.*versionbit")

	# 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
	tip = int(tip, 16)

	for i in range(numblocks):
	block = create_block(tip, create_coinbase(height+1), block_time)
	block.nVersion = nVersionToUse
	block.solve()
	peer.send_message(msg_block(block))
	block_time += 1
	height += 1
	tip = block.sha256
	peer.sync_with_ping()

	def test_versionbits_in_alert_file(self):
	with open(self.alert_filename, 'r') as f:
	alert_text = f.read()
	assert(self.vb_pattern.match(alert_text))

	def run_test(self):
	# Setup the p2p connection and start up the network thread.
	test_node = TestNode()

	connections = []
	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

	# Test logic begins here
	test_node.wait_for_verack()

	# 1. Have the node mine one period worth of blocks
	self.nodes[0].generate(VB_PERIOD)

	# 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)

	# Fill rest of period with regular version blocks
	self.nodes[0].generate(VB_PERIOD - VB_THRESHOLD + 1)
	# Check that we're not getting any versionbit-related errors in
	# getinfo()
	assert(not self.vb_pattern.match(self.nodes[0].getinfo()["errors"]))

	# 3. Now build one period of blocks with >= VB_THRESHOLD blocks signaling
	# some unknown bit
	self.send_blocks_with_version(test_node, VB_THRESHOLD, nVersion)
	self.nodes[0].generate(VB_PERIOD - VB_THRESHOLD)
	# Might not get a versionbits-related alert yet, as we should
	# have gotten a different alert due to more than 51/100 blocks
	# being of unexpected version.
	# Check that getinfo() shows some kind of error.
	assert(len(self.nodes[0].getinfo()["errors"]) != 0)

	# 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
	# to ACTIVE.
	self.nodes[0].generate(VB_PERIOD)
	stop_node(self.nodes[0], 0)
	wait_bitcoinds()
	# Empty out the alert file
	with open(self.alert_filename, 'w') as f:
	pass
	self.nodes[0] = start_node(0, self.options.tmpdir, ["-debug", "-logtimemicros=1", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""])

	# Connecting one block should be enough to generate an error.
	self.nodes[0].generate(1)
	assert(len(self.nodes[0].getinfo()["errors"]) != 0)
	stop_node(self.nodes[0], 0)
	wait_bitcoinds()
	self.test_versionbits_in_alert_file()

	# Test framework expects the node to still be running...
	self.nodes[0] = start_node(0, self.options.tmpdir, ["-debug", "-logtimemicros=1", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""])


	if __name__ == '__main__':
	VersionBitsWarningTest().main()
	diff --git a/qa/rpc-tests/prioritise_transaction.py b/qa/rpc-tests/prioritise_transaction.py
	index 6ab88602b5..e1771231c0 100755
	--- a/qa/rpc-tests/prioritise_transaction.py
	+++ b/qa/rpc-tests/prioritise_transaction.py
	@@ -1,143 +1,143 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test PrioritiseTransaction code
	#

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.mininode import COIN, MAX_BLOCK_SIZE

	class PrioritiseTransactionTest(BitcoinTestFramework):

	def __init__(self):
	- self.txouts = gen_return_txouts()
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ self.txouts = gen_return_txouts()

	def setup_network(self):
	self.nodes = []
	self.is_network_split = False

	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug", "-printpriority=1"]))
	self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']

	def run_test(self):
	utxo_count = 90
	utxos = create_confirmed_utxos(self.relayfee, self.nodes[0], utxo_count)
	base_fee = self.relayfee*100 # our transactions are smaller than 100kb
	txids = []

	# Create 3 batches of transactions at 3 different fee rate levels
	range_size = utxo_count // 3
	for i in range(3):
	txids.append([])
	start_range = i * range_size
	end_range = start_range + range_size
	txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[start_range:end_range], (i+1)*base_fee)

	# Make sure that the size of each group of transactions exceeds
	# MAX_BLOCK_SIZE -- otherwise the test needs to be revised to create
	# more transactions.
	mempool = self.nodes[0].getrawmempool(True)
	sizes = [0, 0, 0]
	for i in range(3):
	for j in txids[i]:
	assert(j in mempool)
	sizes[i] += mempool[j]['size']
	assert(sizes[i] > MAX_BLOCK_SIZE) # Fail => raise utxo_count

	# add a fee delta to something in the cheapest bucket and make sure it gets mined
	# also check that a different entry in the cheapest bucket is NOT mined (lower
	# the priority to ensure its not mined due to priority)
	self.nodes[0].prioritisetransaction(txids[0][0], 0, int(3base_feeCOIN))
	self.nodes[0].prioritisetransaction(txids[0][1], -1e15, 0)

	self.nodes[0].generate(1)

	mempool = self.nodes[0].getrawmempool()
	print("Assert that prioritised transaction was mined")
	assert(txids[0][0] not in mempool)
	assert(txids[0][1] in mempool)

	high_fee_tx = None
	for x in txids[2]:
	if x not in mempool:
	high_fee_tx = x

	# Something high-fee should have been mined!
	assert(high_fee_tx != None)

	# Add a prioritisation before a tx is in the mempool (de-prioritising a
	# high-fee transaction so that it's now low fee).
	self.nodes[0].prioritisetransaction(high_fee_tx, -1e15, -int(2base_feeCOIN))

	# Add everything back to mempool
	self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())

	# Check to make sure our high fee rate tx is back in the mempool
	mempool = self.nodes[0].getrawmempool()
	assert(high_fee_tx in mempool)

	# Now verify the modified-high feerate transaction isn't mined before
	# the other high fee transactions. Keep mining until our mempool has
	# decreased by all the high fee size that we calculated above.
	while (self.nodes[0].getmempoolinfo()['bytes'] > sizes[0] + sizes[1]):
	self.nodes[0].generate(1)

	# High fee transaction should not have been mined, but other high fee rate
	# transactions should have been.
	mempool = self.nodes[0].getrawmempool()
	print("Assert that de-prioritised transaction is still in mempool")
	assert(high_fee_tx in mempool)
	for x in txids[2]:
	if (x != high_fee_tx):
	assert(x not in mempool)

	# Create a free, low priority transaction. Should be rejected.
	utxo_list = self.nodes[0].listunspent()
	assert(len(utxo_list) > 0)
	utxo = utxo_list[0]

	inputs = []
	outputs = {}
	inputs.append({"txid" : utxo["txid"], "vout" : utxo["vout"]})
	outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee
	raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
	tx_hex = self.nodes[0].signrawtransaction(raw_tx)["hex"]
	txid = self.nodes[0].sendrawtransaction(tx_hex)

	# A tx that spends an in-mempool tx has 0 priority, so we can use it to
	# test the effect of using prioritise transaction for mempool acceptance
	inputs = []
	inputs.append({"txid": txid, "vout": 0})
	outputs = {}
	outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee
	raw_tx2 = self.nodes[0].createrawtransaction(inputs, outputs)
	tx2_hex = self.nodes[0].signrawtransaction(raw_tx2)["hex"]
	tx2_id = self.nodes[0].decoderawtransaction(tx2_hex)["txid"]

	try:
	self.nodes[0].sendrawtransaction(tx2_hex)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26) # insufficient fee
	assert(tx2_id not in self.nodes[0].getrawmempool())
	else:
	assert(False)

	# This is a less than 1000-byte transaction, so just set the fee
	# to be the minimum for a 1000 byte transaction and check that it is
	# accepted.
	self.nodes[0].prioritisetransaction(tx2_id, 0, int(self.relayfee*COIN))

	print("Assert that prioritised free transaction is accepted to mempool")
	assert_equal(self.nodes[0].sendrawtransaction(tx2_hex), tx2_id)
	assert(tx2_id in self.nodes[0].getrawmempool())

	if __name__ == '__main__':
	PrioritiseTransactionTest().main()
	diff --git a/qa/rpc-tests/proxy_test.py b/qa/rpc-tests/proxy_test.py
	index 6c7b201d56..27160cae07 100755
	--- a/qa/rpc-tests/proxy_test.py
	+++ b/qa/rpc-tests/proxy_test.py
	@@ -1,191 +1,195 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	import socket

	from test_framework.socks5 import Socks5Configuration, Socks5Command, Socks5Server, AddressType
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.netutil import test_ipv6_local
	'''
	Test plan:
	- Start bitcoind's with different proxy configurations
	- Use addnode to initiate connections
	- Verify that proxies are connected to, and the right connection command is given
	- Proxy configurations to test on bitcoind side:
	- `-proxy` (proxy everything)
	- `-onion` (proxy just onions)
	- `-proxyrandomize` Circuit randomization
	- Proxy configurations to test on proxy side,
	- support no authentication (other proxy)
	- support no authentication + user/pass authentication (Tor)
	- proxy on IPv6

	- Create various proxies (as threads)
	- Create bitcoinds that connect to them
	- Manipulate the bitcoinds using addnode (onetry) an observe effects

	addnode connect to IPv4
	addnode connect to IPv6
	addnode connect to onion
	addnode connect to generic DNS name
	'''


	class ProxyTest(BitcoinTestFramework):
	def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 4
	+ self.setup_clean_chain = False
	+
	self.have_ipv6 = test_ipv6_local()
	# Create two proxies on different ports
	# ... one unauthenticated
	self.conf1 = Socks5Configuration()
	self.conf1.addr = ('127.0.0.1', 13000 + (os.getpid() % 1000))
	self.conf1.unauth = True
	self.conf1.auth = False
	# ... one supporting authenticated and unauthenticated (Tor)
	self.conf2 = Socks5Configuration()
	self.conf2.addr = ('127.0.0.1', 14000 + (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', 15000 + (os.getpid() % 1000))
	self.conf3.unauth = True
	self.conf3.auth = True
	else:
	print("Warning: testing without local IPv6 support")

	self.serv1 = Socks5Server(self.conf1)
	self.serv1.start()
	self.serv2 = Socks5Server(self.conf2)
	self.serv2.start()
	if self.have_ipv6:
	self.serv3 = Socks5Server(self.conf3)
	self.serv3.start()

	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
	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'],
	[]
	]
	if self.have_ipv6:
	args[3] = ['-listen', '-debug=net', '-debug=proxy', '-proxy=[%s]:%i' % (self.conf3.addr),'-proxyrandomize=0', '-noonion']
	- return start_nodes(4, self.options.tmpdir, extra_args=args)
	+ return start_nodes(self.num_nodes, self.options.tmpdir, extra_args=args)

	def node_test(self, node, proxies, auth, test_onion=True):
	rv = []
	# Test: outgoing IPv4 connection through node
	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
	assert_equal(cmd.atyp, AddressType.DOMAINNAME)
	assert_equal(cmd.addr, b"15.61.23.23")
	assert_equal(cmd.port, 1234)
	if not auth:
	assert_equal(cmd.username, None)
	assert_equal(cmd.password, None)
	rv.append(cmd)

	if self.have_ipv6:
	# Test: outgoing IPv6 connection through node
	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
	assert_equal(cmd.atyp, AddressType.DOMAINNAME)
	assert_equal(cmd.addr, b"1233:3432:2434:2343:3234:2345:6546:4534")
	assert_equal(cmd.port, 5443)
	if not auth:
	assert_equal(cmd.username, None)
	assert_equal(cmd.password, None)
	rv.append(cmd)

	if test_onion:
	# Test: outgoing onion connection through node
	node.addnode("bitcoinostk4e4re.onion:8333", "onetry")
	cmd = proxies[2].queue.get()
	assert(isinstance(cmd, Socks5Command))
	assert_equal(cmd.atyp, AddressType.DOMAINNAME)
	assert_equal(cmd.addr, b"bitcoinostk4e4re.onion")
	assert_equal(cmd.port, 8333)
	if not auth:
	assert_equal(cmd.username, None)
	assert_equal(cmd.password, None)
	rv.append(cmd)

	# Test: outgoing DNS name connection through node
	node.addnode("node.noumenon:8333", "onetry")
	cmd = proxies[3].queue.get()
	assert(isinstance(cmd, Socks5Command))
	assert_equal(cmd.atyp, AddressType.DOMAINNAME)
	assert_equal(cmd.addr, b"node.noumenon")
	assert_equal(cmd.port, 8333)
	if not auth:
	assert_equal(cmd.username, None)
	assert_equal(cmd.password, None)
	rv.append(cmd)

	return rv

	def run_test(self):
	# basic -proxy
	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)

	# -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)
	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)

	def networks_dict(d):
	r = {}
	for x in d['networks']:
	r[x['name']] = x
	return r

	# test RPC getnetworkinfo
	n0 = networks_dict(self.nodes[0].getnetworkinfo())
	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']:
	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']:
	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']:
	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/pruning.py b/qa/rpc-tests/pruning.py
	index 92d33bd20e..4c0530b355 100755
	--- a/qa/rpc-tests/pruning.py
	+++ b/qa/rpc-tests/pruning.py
	@@ -1,341 +1,341 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test pruning code
	# ********
	# WARNING:
	# This test uses 4GB of disk space.
	# This test takes 30 mins or more (up to 2 hours)
	# ********

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

	def calc_usage(blockdir):
	return sum(os.path.getsize(blockdir+f) for f in os.listdir(blockdir) if os.path.isfile(blockdir+f)) / (1024. * 1024.)

	class PruneTest(BitcoinTestFramework):

	def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 3
	+
	self.utxo = []
	self.address = ["",""]
	self.txouts = gen_return_txouts()

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 3)
	-
	def setup_network(self):
	self.nodes = []
	self.is_network_split = False

	# Create nodes 0 and 1 to mine
	self.nodes.append(start_node(0, self.options.tmpdir, ["-debug","-maxreceivebuffer=20000","-blockmaxsize=999000", "-checkblocks=5"], timewait=900))
	self.nodes.append(start_node(1, self.options.tmpdir, ["-debug","-maxreceivebuffer=20000","-blockmaxsize=999000", "-checkblocks=5"], timewait=900))

	# Create node 2 to test pruning
	self.nodes.append(start_node(2, self.options.tmpdir, ["-debug","-maxreceivebuffer=20000","-prune=550"], timewait=900))
	self.prunedir = self.options.tmpdir+"/node2/regtest/blocks/"

	self.address[0] = self.nodes[0].getnewaddress()
	self.address[1] = self.nodes[1].getnewaddress()

	# Determine default relay fee
	self.relayfee = self.nodes[0].getnetworkinfo()["relayfee"]

	connect_nodes(self.nodes[0], 1)
	connect_nodes(self.nodes[1], 2)
	connect_nodes(self.nodes[2], 0)
	sync_blocks(self.nodes[0:3])

	def create_big_chain(self):
	# Start by creating some coinbases we can spend later
	self.nodes[1].generate(200)
	sync_blocks(self.nodes[0:2])
	self.nodes[0].generate(150)
	# Then mine enough full blocks to create more than 550MiB of data
	for i in range(645):
	self.mine_full_block(self.nodes[0], self.address[0])

	sync_blocks(self.nodes[0:3])

	def test_height_min(self):
	if not os.path.isfile(self.prunedir+"blk00000.dat"):
	raise AssertionError("blk00000.dat is missing, pruning too early")
	print("Success")
	print("Though we're already using more than 550MiB, current usage:", calc_usage(self.prunedir))
	print("Mining 25 more blocks should cause the first block file to be pruned")
	# Pruning doesn't run until we're allocating another chunk, 20 full blocks past the height cutoff will ensure this
	for i in range(25):
	self.mine_full_block(self.nodes[0],self.address[0])

	waitstart = time.time()
	while os.path.isfile(self.prunedir+"blk00000.dat"):
	time.sleep(0.1)
	if time.time() - waitstart > 10:
	raise AssertionError("blk00000.dat not pruned when it should be")

	print("Success")
	usage = calc_usage(self.prunedir)
	print("Usage should be below target:", usage)
	if (usage > 550):
	raise AssertionError("Pruning target not being met")

	def create_chain_with_staleblocks(self):
	# Create stale blocks in manageable sized chunks
	print("Mine 24 (stale) blocks on Node 1, followed by 25 (main chain) block reorg from Node 0, for 12 rounds")

	for j in range(12):
	# Disconnect node 0 so it can mine a longer reorg chain without knowing about node 1's soon-to-be-stale chain
	# Node 2 stays connected, so it hears about the stale blocks and then reorg's when node0 reconnects
	# Stopping node 0 also clears its mempool, so it doesn't have node1's transactions to accidentally mine
	stop_node(self.nodes[0],0)
	self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug","-maxreceivebuffer=20000","-blockmaxsize=999000", "-checkblocks=5"], timewait=900)
	# Mine 24 blocks in node 1
	self.utxo = self.nodes[1].listunspent()
	for i in range(24):
	if j == 0:
	self.mine_full_block(self.nodes[1],self.address[1])
	else:
	self.nodes[1].generate(1) #tx's already in mempool from previous disconnects

	# Reorg back with 25 block chain from node 0
	self.utxo = self.nodes[0].listunspent()
	for i in range(25):
	self.mine_full_block(self.nodes[0],self.address[0])

	# Create connections in the order so both nodes can see the reorg at the same time
	connect_nodes(self.nodes[1], 0)
	connect_nodes(self.nodes[2], 0)
	sync_blocks(self.nodes[0:3])

	print("Usage can be over target because of high stale rate:", calc_usage(self.prunedir))

	def reorg_test(self):
	# Node 1 will mine a 300 block chain starting 287 blocks back from Node 0 and Node 2's tip
	# This will cause Node 2 to do a reorg requiring 288 blocks of undo data to the reorg_test chain
	# Reboot node 1 to clear its mempool (hopefully make the invalidate faster)
	# Lower the block max size so we don't keep mining all our big mempool transactions (from disconnected blocks)
	stop_node(self.nodes[1],1)
	self.nodes[1]=start_node(1, self.options.tmpdir, ["-debug","-maxreceivebuffer=20000","-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"], timewait=900)

	height = self.nodes[1].getblockcount()
	print("Current block height:", height)

	invalidheight = height-287
	badhash = self.nodes[1].getblockhash(invalidheight)
	print("Invalidating block at height:",invalidheight,badhash)
	self.nodes[1].invalidateblock(badhash)

	# We've now switched to our previously mined-24 block fork on node 1, but thats not what we want
	# So invalidate that fork as well, until we're on the same chain as node 0/2 (but at an ancestor 288 blocks ago)
	mainchainhash = self.nodes[0].getblockhash(invalidheight - 1)
	curhash = self.nodes[1].getblockhash(invalidheight - 1)
	while curhash != mainchainhash:
	self.nodes[1].invalidateblock(curhash)
	curhash = self.nodes[1].getblockhash(invalidheight - 1)

	assert(self.nodes[1].getblockcount() == invalidheight - 1)
	print("New best height", self.nodes[1].getblockcount())

	# Reboot node1 to clear those giant tx's from mempool
	stop_node(self.nodes[1],1)
	self.nodes[1]=start_node(1, self.options.tmpdir, ["-debug","-maxreceivebuffer=20000","-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"], timewait=900)

	print("Generating new longer chain of 300 more blocks")
	self.nodes[1].generate(300)

	print("Reconnect nodes")
	connect_nodes(self.nodes[0], 1)
	connect_nodes(self.nodes[2], 1)
	sync_blocks(self.nodes[0:3])

	print("Verify height on node 2:",self.nodes[2].getblockcount())
	print("Usage possibly still high bc of stale blocks in block files:", calc_usage(self.prunedir))

	print("Mine 220 more blocks so we have requisite history (some blocks will be big and cause pruning of previous chain)")
	self.nodes[0].generate(220) #node 0 has many large tx's in its mempool from the disconnects
	sync_blocks(self.nodes[0:3])

	usage = calc_usage(self.prunedir)
	print("Usage should be below target:", usage)
	if (usage > 550):
	raise AssertionError("Pruning target not being met")

	return invalidheight,badhash

	def reorg_back(self):
	# Verify that a block on the old main chain fork has been pruned away
	try:
	self.nodes[2].getblock(self.forkhash)
	raise AssertionError("Old block wasn't pruned so can't test redownload")
	except JSONRPCException as e:
	print("Will need to redownload block",self.forkheight)

	# Verify that we have enough history to reorg back to the fork point
	# Although this is more than 288 blocks, because this chain was written more recently
	# and only its other 299 small and 220 large block are in the block files after it,
	# its expected to still be retained
	self.nodes[2].getblock(self.nodes[2].getblockhash(self.forkheight))

	first_reorg_height = self.nodes[2].getblockcount()
	curchainhash = self.nodes[2].getblockhash(self.mainchainheight)
	self.nodes[2].invalidateblock(curchainhash)
	goalbestheight = self.mainchainheight
	goalbesthash = self.mainchainhash2

	# As of 0.10 the current block download logic is not able to reorg to the original chain created in
	# create_chain_with_stale_blocks because it doesn't know of any peer thats on that chain from which to
	# redownload its missing blocks.
	# Invalidate the reorg_test chain in node 0 as well, it can successfully switch to the original chain
	# because it has all the block data.
	# However it must mine enough blocks to have a more work chain than the reorg_test chain in order
	# to trigger node 2's block download logic.
	# At this point node 2 is within 288 blocks of the fork point so it will preserve its ability to reorg
	if self.nodes[2].getblockcount() < self.mainchainheight:
	blocks_to_mine = first_reorg_height + 1 - self.mainchainheight
	print("Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed:", blocks_to_mine)
	self.nodes[0].invalidateblock(curchainhash)
	assert(self.nodes[0].getblockcount() == self.mainchainheight)
	assert(self.nodes[0].getbestblockhash() == self.mainchainhash2)
	goalbesthash = self.nodes[0].generate(blocks_to_mine)[-1]
	goalbestheight = first_reorg_height + 1

	print("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
	waitstart = time.time()
	while self.nodes[2].getblockcount() < goalbestheight:
	time.sleep(0.1)
	if time.time() - waitstart > 900:
	raise AssertionError("Node 2 didn't reorg to proper height")
	assert(self.nodes[2].getbestblockhash() == goalbesthash)
	# Verify we can now have the data for a block previously pruned
	assert(self.nodes[2].getblock(self.forkhash)["height"] == self.forkheight)

	def mine_full_block(self, node, address):
	# Want to create a full block
	# We'll generate a 66k transaction below, and 14 of them is close to the 1MB block limit
	for j in range(14):
	if len(self.utxo) < 14:
	self.utxo = node.listunspent()
	inputs=[]
	outputs = {}
	t = self.utxo.pop()
	inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
	remchange = t["amount"] - 100*self.relayfee # Fee must be above min relay rate for 66kb tx
	outputs[address]=remchange
	# Create a basic transaction that will send change back to ourself after account for a fee
	# And then insert the 128 generated transaction outs in the middle rawtx[92] is where the #
	# of txouts is stored and is the only thing we overwrite from the original transaction
	rawtx = node.createrawtransaction(inputs, outputs)
	newtx = rawtx[0:92]
	newtx = newtx + self.txouts
	newtx = newtx + rawtx[94:]
	# Appears to be ever so slightly faster to sign with SIGHASH_NONE
	signresult = node.signrawtransaction(newtx,None,None,"NONE")
	txid = node.sendrawtransaction(signresult["hex"], True)
	# Mine a full sized block which will be these transactions we just created
	node.generate(1)


	def run_test(self):
	print("Warning! This test requires 4GB of disk space and takes over 30 mins (up to 2 hours)")
	print("Mining a big blockchain of 995 blocks")
	self.create_big_chain()
	# Chain diagram key:
	# * blocks on main chain
	# +,&,$,@ blocks on other forks
	# X invalidated block
	# N1 Node 1
	#
	# Start by mining a simple chain that all nodes have
	# N0=N1=N2 *...(995)

	print("Check that we haven't started pruning yet because we're below PruneAfterHeight")
	self.test_height_min()
	# Extend this chain past the PruneAfterHeight
	# N0=N1=N2 *...(1020)

	print("Check that we'll exceed disk space target if we have a very high stale block rate")
	self.create_chain_with_staleblocks()
	# Disconnect N0
	# And mine a 24 block chain on N1 and a separate 25 block chain on N0
	# N1=N2 *...+...+(1044)
	# N0 ......**(1045)
	#
	# reconnect nodes causing reorg on N1 and N2
	# N1=N2 *...(1020) ...*(1045)
	# \
	# +...+(1044)
	#
	# repeat this process until you have 12 stale forks hanging off the
	# main chain on N1 and N2
	# N0 ***********************...*************************(1320)
	#
	# N1=N2 *...(1020) ...(1045) .. ..*(1295) ...**(1320)
	# \ \ \
	# +...+(1044) &.. $...$(1319)

	# Save some current chain state for later use
	self.mainchainheight = self.nodes[2].getblockcount() #1320
	self.mainchainhash2 = self.nodes[2].getblockhash(self.mainchainheight)

	print("Check that we can survive a 288 block reorg still")
	(self.forkheight,self.forkhash) = self.reorg_test() #(1033, )
	# Now create a 288 block reorg by mining a longer chain on N1
	# First disconnect N1
	# Then invalidate 1033 on main chain and 1032 on fork so height is 1032 on main chain
	# N1 *...(1020) ...(1032)X..
	# \
	# ++...+(1031)X..
	#
	# Now mine 300 more blocks on N1
	# N1 *...(1020) ...(1032) @@...@(1332)
	# \ \
	# \ X...
	# \ \
	# ++...+(1031)X.. ..
	#
	# Reconnect nodes and mine 220 more blocks on N1
	# N1 *...(1020) ...(1032) @@...@@@(1552)
	# \ \
	# \ X...
	# \ \
	# ++...+(1031)X.. ..
	#
	# N2 *...(1020) ...(1032) @@...@@@(1552)
	# \ \
	# \ ...*(1320)
	# \ \
	# ++...++(1044) ..
	#
	# N0 ********************(1032) @@...@@@(1552)
	# \
	# ...*(1320)

	print("Test that we can rerequest a block we previously pruned if needed for a reorg")
	self.reorg_back()
	# Verify that N2 still has block 1033 on current chain (@), but not on main chain (*)
	# Invalidate 1033 on current chain (@) on N2 and we should be able to reorg to
	# original main chain (*), but will require redownload of some blocks
	# In order to have a peer we think we can download from, must also perform this invalidation
	# on N0 and mine a new longest chain to trigger.
	# Final result:
	# N0 ******************(1032) ...****(1553)
	# \
	# X@...@@@(1552)
	#
	# N2 *...(1020) ...(1032) ...**(1553)
	# \ \
	# \ X@...@@@(1552)
	# \
	# +..
	#
	# N1 doesn't change because 1033 on main chain (*) is invalid

	print("Done")

	if __name__ == '__main__':
	PruneTest().main()
	diff --git a/qa/rpc-tests/rawtransactions.py b/qa/rpc-tests/rawtransactions.py
	index 7f7b6887a8..df02c1697f 100755
	--- a/qa/rpc-tests/rawtransactions.py
	+++ b/qa/rpc-tests/rawtransactions.py
	@@ -1,141 +1,142 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test re-org scenarios with a mempool that contains transactions
	# that spend (directly or indirectly) coinbase transactions.
	#

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

	# Create one-input, one-output, no-fee transaction:
	class RawTransactionsTest(BitcoinTestFramework):

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 3)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 3

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

	#connect to a local machine for debugging
	#url = "http://bitcoinrpc:DP6DvqZtqXarpeNWyN3LZTFchCCyCUuHwNF7E8pX99x1@%s:%d" % ('127.0.0.1', 18332)
	#proxy = AuthServiceProxy(url)
	#proxy.url = url # store URL on proxy for info
	#self.nodes.append(proxy)

	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):

	#prepare some coins for multiple *rawtransaction commands
	self.nodes[2].generate(1)
	self.sync_all()
	self.nodes[0].generate(101)
	self.sync_all()
	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(),1.5)
	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(),1.0)
	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(),5.0)
	self.sync_all()
	self.nodes[0].generate(5)
	self.sync_all()

	#########################################
	# sendrawtransaction with missing input #
	#########################################
	inputs = [ {'txid' : "1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000", 'vout' : 1}] #won't exists
	outputs = { self.nodes[0].getnewaddress() : 4.998 }
	rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
	rawtx = self.nodes[2].signrawtransaction(rawtx)

	try:
	rawtx = self.nodes[2].sendrawtransaction(rawtx['hex'])
	except JSONRPCException as e:
	assert("Missing inputs" in e.error['message'])
	else:
	assert(False)


	#########################
	# RAW TX MULTISIG TESTS #
	#########################
	# 2of2 test
	addr1 = self.nodes[2].getnewaddress()
	addr2 = self.nodes[2].getnewaddress()

	addr1Obj = self.nodes[2].validateaddress(addr1)
	addr2Obj = self.nodes[2].validateaddress(addr2)

	mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])
	mSigObjValid = self.nodes[2].validateaddress(mSigObj)

	#use balance deltas instead of absolute values
	bal = self.nodes[2].getbalance()

	# send 1.2 BTC to msig adr
	txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()
	assert_equal(self.nodes[2].getbalance(), bal+Decimal('1.20000000')) #node2 has both keys of the 2of2 ms addr., tx should affect the balance


	# 2of3 test from different nodes
	bal = self.nodes[2].getbalance()
	addr1 = self.nodes[1].getnewaddress()
	addr2 = self.nodes[2].getnewaddress()
	addr3 = self.nodes[2].getnewaddress()

	addr1Obj = self.nodes[1].validateaddress(addr1)
	addr2Obj = self.nodes[2].validateaddress(addr2)
	addr3Obj = self.nodes[2].validateaddress(addr3)

	mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey']])
	mSigObjValid = self.nodes[2].validateaddress(mSigObj)

	txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
	decTx = self.nodes[0].gettransaction(txId)
	rawTx = self.nodes[0].decoderawtransaction(decTx['hex'])
	sPK = rawTx['vout'][0]['scriptPubKey']['hex']
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()

	#THIS IS A INCOMPLETE FEATURE
	#NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND COUNT AT BALANCE CALCULATION
	assert_equal(self.nodes[2].getbalance(), bal) #for now, assume the funds of a 2of3 multisig tx are not marked as spendable

	txDetails = self.nodes[0].gettransaction(txId, True)
	rawTx = self.nodes[0].decoderawtransaction(txDetails['hex'])
	vout = False
	for outpoint in rawTx['vout']:
	if outpoint['value'] == Decimal('2.20000000'):
	vout = outpoint
	break

	bal = self.nodes[0].getbalance()
	inputs = [{ "txid" : txId, "vout" : vout['n'], "scriptPubKey" : vout['scriptPubKey']['hex']}]
	outputs = { self.nodes[0].getnewaddress() : 2.19 }
	rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
	rawTxPartialSigned = self.nodes[1].signrawtransaction(rawTx, inputs)
	assert_equal(rawTxPartialSigned['complete'], False) #node1 only has one key, can't comp. sign the tx

	rawTxSigned = self.nodes[2].signrawtransaction(rawTx, inputs)
	assert_equal(rawTxSigned['complete'], True) #node2 can sign the tx compl., own two of three keys
	self.nodes[2].sendrawtransaction(rawTxSigned['hex'])
	rawTx = self.nodes[0].decoderawtransaction(rawTxSigned['hex'])
	self.sync_all()
	self.nodes[0].generate(1)
	self.sync_all()
	assert_equal(self.nodes[0].getbalance(), bal+Decimal('50.00000000')+Decimal('2.19000000')) #block reward + tx

	if __name__ == '__main__':
	RawTransactionsTest().main()
	diff --git a/qa/rpc-tests/receivedby.py b/qa/rpc-tests/receivedby.py
	index a3f97669ea..4f17b661cb 100755
	--- a/qa/rpc-tests/receivedby.py
	+++ b/qa/rpc-tests/receivedby.py
	@@ -1,145 +1,150 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Exercise the listreceivedbyaddress API

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


	def get_sub_array_from_array(object_array, to_match):
	'''
	Finds and returns a sub array from an array of arrays.
	to_match should be a unique idetifier of a sub array
	'''
	num_matched = 0
	for item in object_array:
	all_match = True
	for key,value in to_match.items():
	if item[key] != value:
	all_match = False
	if not all_match:
	continue
	return item
	return []

	class ReceivedByTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 4
	+ self.setup_clean_chain = False
	+
	def setup_nodes(self):
	#This test requires mocktime
	enable_mocktime()
	- return start_nodes(4, self.options.tmpdir)
	+ return start_nodes(self.num_nodes, self.options.tmpdir)

	def run_test(self):
	'''
	listreceivedbyaddress Test
	'''
	# Send from node 0 to 1
	addr = self.nodes[1].getnewaddress()
	txid = self.nodes[0].sendtoaddress(addr, 0.1)
	self.sync_all()

	#Check not listed in listreceivedbyaddress because has 0 confirmations
	assert_array_result(self.nodes[1].listreceivedbyaddress(),
	{"address":addr},
	{ },
	True)
	#Bury Tx under 10 block so it will be returned by listreceivedbyaddress
	self.nodes[1].generate(10)
	self.sync_all()
	assert_array_result(self.nodes[1].listreceivedbyaddress(),
	{"address":addr},
	{"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]})
	#With min confidence < 10
	assert_array_result(self.nodes[1].listreceivedbyaddress(5),
	{"address":addr},
	{"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]})
	#With min confidence > 10, should not find Tx
	assert_array_result(self.nodes[1].listreceivedbyaddress(11),{"address":addr},{ },True)

	#Empty Tx
	addr = self.nodes[1].getnewaddress()
	assert_array_result(self.nodes[1].listreceivedbyaddress(0,True),
	{"address":addr},
	{"address":addr, "account":"", "amount":0, "confirmations":0, "txids":[]})

	'''
	getreceivedbyaddress Test
	'''
	# Send from node 0 to 1
	addr = self.nodes[1].getnewaddress()
	txid = self.nodes[0].sendtoaddress(addr, 0.1)
	self.sync_all()

	#Check balance is 0 because of 0 confirmations
	balance = self.nodes[1].getreceivedbyaddress(addr)
	if balance != Decimal("0.0"):
	raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))

	#Check balance is 0.1
	balance = self.nodes[1].getreceivedbyaddress(addr,0)
	if balance != Decimal("0.1"):
	raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))

	#Bury Tx under 10 block so it will be returned by the default getreceivedbyaddress
	self.nodes[1].generate(10)
	self.sync_all()
	balance = self.nodes[1].getreceivedbyaddress(addr)
	if balance != Decimal("0.1"):
	raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))

	'''
	listreceivedbyaccount + getreceivedbyaccount Test
	'''
	#set pre-state
	addrArr = self.nodes[1].getnewaddress()
	account = self.nodes[1].getaccount(addrArr)
	received_by_account_json = get_sub_array_from_array(self.nodes[1].listreceivedbyaccount(),{"account":account})
	if len(received_by_account_json) == 0:
	raise AssertionError("No accounts found in node")
	balance_by_account = rec_by_accountArr = self.nodes[1].getreceivedbyaccount(account)

	txid = self.nodes[0].sendtoaddress(addr, 0.1)
	self.sync_all()

	# listreceivedbyaccount should return received_by_account_json because of 0 confirmations
	assert_array_result(self.nodes[1].listreceivedbyaccount(),
	{"account":account},
	received_by_account_json)

	# getreceivedbyaddress should return same balance because of 0 confirmations
	balance = self.nodes[1].getreceivedbyaccount(account)
	if balance != balance_by_account:
	raise AssertionError("Wrong balance returned by getreceivedbyaccount, %0.2f"%(balance))

	self.nodes[1].generate(10)
	self.sync_all()
	# listreceivedbyaccount should return updated account balance
	assert_array_result(self.nodes[1].listreceivedbyaccount(),
	{"account":account},
	{"account":received_by_account_json["account"], "amount":(received_by_account_json["amount"] + Decimal("0.1"))})

	# getreceivedbyaddress should return updates balance
	balance = self.nodes[1].getreceivedbyaccount(account)
	if balance != balance_by_account + Decimal("0.1"):
	raise AssertionError("Wrong balance returned by getreceivedbyaccount, %0.2f"%(balance))

	#Create a new account named "mynewaccount" that has a 0 balance
	self.nodes[1].getaccountaddress("mynewaccount")
	received_by_account_json = get_sub_array_from_array(self.nodes[1].listreceivedbyaccount(0,True),{"account":"mynewaccount"})
	if len(received_by_account_json) == 0:
	raise AssertionError("No accounts found in node")

	# Test includeempty of listreceivedbyaccount
	if received_by_account_json["amount"] != Decimal("0.0"):
	raise AssertionError("Wrong balance returned by listreceivedbyaccount, %0.2f"%(received_by_account_json["amount"]))

	# Test getreceivedbyaccount for 0 amount accounts
	balance = self.nodes[1].getreceivedbyaccount("mynewaccount")
	if balance != Decimal("0.0"):
	raise AssertionError("Wrong balance returned by getreceivedbyaccount, %0.2f"%(balance))

	if __name__ == '__main__':
	ReceivedByTest().main()
	diff --git a/qa/rpc-tests/reindex.py b/qa/rpc-tests/reindex.py
	index 39564b32ba..87e6239b59 100755
	--- a/qa/rpc-tests/reindex.py
	+++ b/qa/rpc-tests/reindex.py
	@@ -1,32 +1,33 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test -reindex with CheckBlockIndex
	#
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	class ReindexTest(BitcoinTestFramework):

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

	def setup_network(self):
	self.nodes = []
	self.is_network_split = False
	self.nodes.append(start_node(0, self.options.tmpdir))

	def run_test(self):
	self.nodes[0].generate(3)
	stop_node(self.nodes[0], 0)
	wait_bitcoinds()
	self.nodes[0]=start_node(0, self.options.tmpdir, ["-debug", "-reindex", "-checkblockindex=1"])
	assert_equal(self.nodes[0].getblockcount(), 3)
	print("Success")

	if __name__ == '__main__':
	ReindexTest().main()
	diff --git a/qa/rpc-tests/replace-by-fee.py b/qa/rpc-tests/replace-by-fee.py
	index 4afc3981da..34c0f9d795 100755
	--- a/qa/rpc-tests/replace-by-fee.py
	+++ b/qa/rpc-tests/replace-by-fee.py
	@@ -1,585 +1,590 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test replace by fee code
	#

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.script import *
	from test_framework.mininode import *

	MAX_REPLACEMENT_LIMIT = 100

	def txToHex(tx):
	return bytes_to_hex_str(tx.serialize())

	def make_utxo(node, amount, confirmed=True, scriptPubKey=CScript([1])):
	"""Create a txout with a given amount and scriptPubKey

	Mines coins as needed.

	confirmed - txouts created will be confirmed in the blockchain;
	unconfirmed otherwise.
	"""
	fee = 1*COIN
	while node.getbalance() < satoshi_round((amount + fee)/COIN):
	node.generate(100)
	#print (node.getbalance(), amount, fee)

	new_addr = node.getnewaddress()
	#print new_addr
	txid = node.sendtoaddress(new_addr, satoshi_round((amount+fee)/COIN))
	tx1 = node.getrawtransaction(txid, 1)
	txid = int(txid, 16)
	i = None

	for i, txout in enumerate(tx1['vout']):
	#print i, txout['scriptPubKey']['addresses']
	if txout['scriptPubKey']['addresses'] == [new_addr]:
	#print i
	break
	assert i is not None

	tx2 = CTransaction()
	tx2.vin = [CTxIn(COutPoint(txid, i))]
	tx2.vout = [CTxOut(amount, scriptPubKey)]
	tx2.rehash()

	signed_tx = node.signrawtransaction(txToHex(tx2))

	txid = node.sendrawtransaction(signed_tx['hex'], True)

	# If requested, ensure txouts are confirmed.
	if confirmed:
	mempool_size = len(node.getrawmempool())
	while mempool_size > 0:
	node.generate(1)
	new_size = len(node.getrawmempool())
	# Error out if we have something stuck in the mempool, as this
	# would likely be a bug.
	assert(new_size < mempool_size)
	mempool_size = new_size

	return COutPoint(int(txid, 16), 0)

	class ReplaceByFeeTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 1
	+ self.setup_clean_chain = False
	+
	def setup_network(self):
	self.nodes = []
	self.nodes.append(start_node(0, self.options.tmpdir, ["-maxorphantx=1000", "-debug",
	"-relaypriority=0", "-whitelist=127.0.0.1",
	"-limitancestorcount=50",
	"-limitancestorsize=101",
	"-limitdescendantcount=200",
	"-limitdescendantsize=101"
	]))
	self.is_network_split = False

	def run_test(self):
	make_utxo(self.nodes[0], 1*COIN)

	print("Running test simple doublespend...")
	self.test_simple_doublespend()

	print("Running test doublespend chain...")
	self.test_doublespend_chain()

	print("Running test doublespend tree...")
	self.test_doublespend_tree()

	print("Running test replacement feeperkb...")
	self.test_replacement_feeperkb()

	print("Running test spends of conflicting outputs...")
	self.test_spends_of_conflicting_outputs()

	print("Running test new unconfirmed inputs...")
	self.test_new_unconfirmed_inputs()

	print("Running test too many replacements...")
	self.test_too_many_replacements()

	print("Running test opt-in...")
	self.test_opt_in()

	print("Running test prioritised transactions...")
	self.test_prioritised_transactions()

	print("Passed\n")

	def test_simple_doublespend(self):
	"""Simple doublespend"""
	tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))

	tx1a = CTransaction()
	tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx1a_hex = txToHex(tx1a)
	tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)

	# Should fail because we haven't changed the fee
	tx1b = CTransaction()
	tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1b.vout = [CTxOut(1*COIN, CScript([b'b']))]
	tx1b_hex = txToHex(tx1b)

	try:
	tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26) # insufficient fee
	else:
	assert(False)

	# Extra 0.1 BTC fee
	tx1b = CTransaction()
	tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1b.vout = [CTxOut(int(0.9*COIN), CScript([b'b']))]
	tx1b_hex = txToHex(tx1b)
	tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)

	mempool = self.nodes[0].getrawmempool()

	assert (tx1a_txid not in mempool)
	assert (tx1b_txid in mempool)

	assert_equal(tx1b_hex, self.nodes[0].getrawtransaction(tx1b_txid))

	def test_doublespend_chain(self):
	"""Doublespend of a long chain"""

	initial_nValue = 50*COIN
	tx0_outpoint = make_utxo(self.nodes[0], initial_nValue)

	prevout = tx0_outpoint
	remaining_value = initial_nValue
	chain_txids = []
	while remaining_value > 10*COIN:
	remaining_value -= 1*COIN
	tx = CTransaction()
	tx.vin = [CTxIn(prevout, nSequence=0)]
	tx.vout = [CTxOut(remaining_value, CScript([1]))]
	tx_hex = txToHex(tx)
	txid = self.nodes[0].sendrawtransaction(tx_hex, True)
	chain_txids.append(txid)
	prevout = COutPoint(int(txid, 16), 0)

	# Whether the double-spend is allowed is evaluated by including all
	# child fees - 40 BTC - so this attempt is rejected.
	dbl_tx = CTransaction()
	dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	dbl_tx.vout = [CTxOut(initial_nValue - 30*COIN, CScript([1]))]
	dbl_tx_hex = txToHex(dbl_tx)

	try:
	self.nodes[0].sendrawtransaction(dbl_tx_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26) # insufficient fee
	else:
	assert(False) # transaction mistakenly accepted!

	# Accepted with sufficient fee
	dbl_tx = CTransaction()
	dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	dbl_tx.vout = [CTxOut(1*COIN, CScript([1]))]
	dbl_tx_hex = txToHex(dbl_tx)
	self.nodes[0].sendrawtransaction(dbl_tx_hex, True)

	mempool = self.nodes[0].getrawmempool()
	for doublespent_txid in chain_txids:
	assert(doublespent_txid not in mempool)

	def test_doublespend_tree(self):
	"""Doublespend of a big tree of transactions"""

	initial_nValue = 50*COIN
	tx0_outpoint = make_utxo(self.nodes[0], initial_nValue)

	def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _total_txs=None):
	if _total_txs is None:
	_total_txs = [0]
	if _total_txs[0] >= max_txs:
	return

	txout_value = (initial_value - fee) // tree_width
	if txout_value < fee:
	return

	vout = [CTxOut(txout_value, CScript([i+1]))
	for i in range(tree_width)]
	tx = CTransaction()
	tx.vin = [CTxIn(prevout, nSequence=0)]
	tx.vout = vout
	tx_hex = txToHex(tx)

	assert(len(tx.serialize()) < 100000)
	txid = self.nodes[0].sendrawtransaction(tx_hex, True)
	yield tx
	_total_txs[0] += 1

	txid = int(txid, 16)

	for i, txout in enumerate(tx.vout):
	for x in branch(COutPoint(txid, i), txout_value,
	max_txs,
	tree_width=tree_width, fee=fee,
	_total_txs=_total_txs):
	yield x

	fee = int(0.0001*COIN)
	n = MAX_REPLACEMENT_LIMIT
	tree_txs = list(branch(tx0_outpoint, initial_nValue, n, fee=fee))
	assert_equal(len(tree_txs), n)

	# Attempt double-spend, will fail because too little fee paid
	dbl_tx = CTransaction()
	dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	dbl_tx.vout = [CTxOut(initial_nValue - fee*n, CScript([1]))]
	dbl_tx_hex = txToHex(dbl_tx)
	try:
	self.nodes[0].sendrawtransaction(dbl_tx_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26) # insufficient fee
	else:
	assert(False)

	# 1 BTC fee is enough
	dbl_tx = CTransaction()
	dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	dbl_tx.vout = [CTxOut(initial_nValue - feen - 1COIN, CScript([1]))]
	dbl_tx_hex = txToHex(dbl_tx)
	self.nodes[0].sendrawtransaction(dbl_tx_hex, True)

	mempool = self.nodes[0].getrawmempool()

	for tx in tree_txs:
	tx.rehash()
	assert (tx.hash not in mempool)

	# Try again, but with more total transactions than the "max txs
	# double-spent at once" anti-DoS limit.
	for n in (MAX_REPLACEMENT_LIMIT+1, MAX_REPLACEMENT_LIMIT*2):
	fee = int(0.0001*COIN)
	tx0_outpoint = make_utxo(self.nodes[0], initial_nValue)
	tree_txs = list(branch(tx0_outpoint, initial_nValue, n, fee=fee))
	assert_equal(len(tree_txs), n)

	dbl_tx = CTransaction()
	dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	dbl_tx.vout = [CTxOut(initial_nValue - 2feen, CScript([1]))]
	dbl_tx_hex = txToHex(dbl_tx)
	try:
	self.nodes[0].sendrawtransaction(dbl_tx_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	assert_equal("too many potential replacements" in exp.error['message'], True)
	else:
	assert(False)

	for tx in tree_txs:
	tx.rehash()
	self.nodes[0].getrawtransaction(tx.hash)

	def test_replacement_feeperkb(self):
	"""Replacement requires fee-per-KB to be higher"""
	tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))

	tx1a = CTransaction()
	tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx1a_hex = txToHex(tx1a)
	tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)

	# Higher fee, but the fee per KB is much lower, so the replacement is
	# rejected.
	tx1b = CTransaction()
	tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1b.vout = [CTxOut(int(0.001COIN), CScript([b'a'999000]))]
	tx1b_hex = txToHex(tx1b)

	try:
	tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26) # insufficient fee
	else:
	assert(False)

	def test_spends_of_conflicting_outputs(self):
	"""Replacements that spend conflicting tx outputs are rejected"""
	utxo1 = make_utxo(self.nodes[0], int(1.2*COIN))
	utxo2 = make_utxo(self.nodes[0], 3*COIN)

	tx1a = CTransaction()
	tx1a.vin = [CTxIn(utxo1, nSequence=0)]
	tx1a.vout = [CTxOut(int(1.1*COIN), CScript([b'a']))]
	tx1a_hex = txToHex(tx1a)
	tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)

	tx1a_txid = int(tx1a_txid, 16)

	# Direct spend an output of the transaction we're replacing.
	tx2 = CTransaction()
	tx2.vin = [CTxIn(utxo1, nSequence=0), CTxIn(utxo2, nSequence=0)]
	tx2.vin.append(CTxIn(COutPoint(tx1a_txid, 0), nSequence=0))
	tx2.vout = tx1a.vout
	tx2_hex = txToHex(tx2)

	try:
	tx2_txid = self.nodes[0].sendrawtransaction(tx2_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	else:
	assert(False)

	# Spend tx1a's output to test the indirect case.
	tx1b = CTransaction()
	tx1b.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)]
	tx1b.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx1b_hex = txToHex(tx1b)
	tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
	tx1b_txid = int(tx1b_txid, 16)

	tx2 = CTransaction()
	tx2.vin = [CTxIn(utxo1, nSequence=0), CTxIn(utxo2, nSequence=0),
	CTxIn(COutPoint(tx1b_txid, 0))]
	tx2.vout = tx1a.vout
	tx2_hex = txToHex(tx2)

	try:
	tx2_txid = self.nodes[0].sendrawtransaction(tx2_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	else:
	assert(False)

	def test_new_unconfirmed_inputs(self):
	"""Replacements that add new unconfirmed inputs are rejected"""
	confirmed_utxo = make_utxo(self.nodes[0], int(1.1*COIN))
	unconfirmed_utxo = make_utxo(self.nodes[0], int(0.1*COIN), False)

	tx1 = CTransaction()
	tx1.vin = [CTxIn(confirmed_utxo)]
	tx1.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx1_hex = txToHex(tx1)
	tx1_txid = self.nodes[0].sendrawtransaction(tx1_hex, True)

	tx2 = CTransaction()
	tx2.vin = [CTxIn(confirmed_utxo), CTxIn(unconfirmed_utxo)]
	tx2.vout = tx1.vout
	tx2_hex = txToHex(tx2)

	try:
	tx2_txid = self.nodes[0].sendrawtransaction(tx2_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	else:
	assert(False)

	def test_too_many_replacements(self):
	"""Replacements that evict too many transactions are rejected"""
	# Try directly replacing more than MAX_REPLACEMENT_LIMIT
	# transactions

	# Start by creating a single transaction with many outputs
	initial_nValue = 10*COIN
	utxo = make_utxo(self.nodes[0], initial_nValue)
	fee = int(0.0001*COIN)
	split_value = int((initial_nValue-fee)/(MAX_REPLACEMENT_LIMIT+1))
	actual_fee = initial_nValue - split_value*(MAX_REPLACEMENT_LIMIT+1)

	outputs = []
	for i in range(MAX_REPLACEMENT_LIMIT+1):
	outputs.append(CTxOut(split_value, CScript([1])))

	splitting_tx = CTransaction()
	splitting_tx.vin = [CTxIn(utxo, nSequence=0)]
	splitting_tx.vout = outputs
	splitting_tx_hex = txToHex(splitting_tx)

	txid = self.nodes[0].sendrawtransaction(splitting_tx_hex, True)
	txid = int(txid, 16)

	# Now spend each of those outputs individually
	for i in range(MAX_REPLACEMENT_LIMIT+1):
	tx_i = CTransaction()
	tx_i.vin = [CTxIn(COutPoint(txid, i), nSequence=0)]
	tx_i.vout = [CTxOut(split_value-fee, CScript([b'a']))]
	tx_i_hex = txToHex(tx_i)
	self.nodes[0].sendrawtransaction(tx_i_hex, True)

	# Now create doublespend of the whole lot; should fail.
	# Need a big enough fee to cover all spending transactions and have
	# a higher fee rate
	double_spend_value = (split_value-100fee)(MAX_REPLACEMENT_LIMIT+1)
	inputs = []
	for i in range(MAX_REPLACEMENT_LIMIT+1):
	inputs.append(CTxIn(COutPoint(txid, i), nSequence=0))
	double_tx = CTransaction()
	double_tx.vin = inputs
	double_tx.vout = [CTxOut(double_spend_value, CScript([b'a']))]
	double_tx_hex = txToHex(double_tx)

	try:
	self.nodes[0].sendrawtransaction(double_tx_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	assert_equal("too many potential replacements" in exp.error['message'], True)
	else:
	assert(False)

	# If we remove an input, it should pass
	double_tx = CTransaction()
	double_tx.vin = inputs[0:-1]
	double_tx.vout = [CTxOut(double_spend_value, CScript([b'a']))]
	double_tx_hex = txToHex(double_tx)
	self.nodes[0].sendrawtransaction(double_tx_hex, True)

	def test_opt_in(self):
	""" Replacing should only work if orig tx opted in """
	tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))

	# Create a non-opting in transaction
	tx1a = CTransaction()
	tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0xffffffff)]
	tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx1a_hex = txToHex(tx1a)
	tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)

	# Shouldn't be able to double-spend
	tx1b = CTransaction()
	tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1b.vout = [CTxOut(int(0.9*COIN), CScript([b'b']))]
	tx1b_hex = txToHex(tx1b)

	try:
	tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	else:
	print(tx1b_txid)
	assert(False)

	tx1_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))

	# Create a different non-opting in transaction
	tx2a = CTransaction()
	tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0xfffffffe)]
	tx2a.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx2a_hex = txToHex(tx2a)
	tx2a_txid = self.nodes[0].sendrawtransaction(tx2a_hex, True)

	# Still shouldn't be able to double-spend
	tx2b = CTransaction()
	tx2b.vin = [CTxIn(tx1_outpoint, nSequence=0)]
	tx2b.vout = [CTxOut(int(0.9*COIN), CScript([b'b']))]
	tx2b_hex = txToHex(tx2b)

	try:
	tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	else:
	assert(False)

	# Now create a new transaction that spends from tx1a and tx2a
	# opt-in on one of the inputs
	# Transaction should be replaceable on either input

	tx1a_txid = int(tx1a_txid, 16)
	tx2a_txid = int(tx2a_txid, 16)

	tx3a = CTransaction()
	tx3a.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0xffffffff),
	CTxIn(COutPoint(tx2a_txid, 0), nSequence=0xfffffffd)]
	tx3a.vout = [CTxOut(int(0.9COIN), CScript([b'c'])), CTxOut(int(0.9COIN), CScript([b'd']))]
	tx3a_hex = txToHex(tx3a)

	self.nodes[0].sendrawtransaction(tx3a_hex, True)

	tx3b = CTransaction()
	tx3b.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)]
	tx3b.vout = [CTxOut(int(0.5*COIN), CScript([b'e']))]
	tx3b_hex = txToHex(tx3b)

	tx3c = CTransaction()
	tx3c.vin = [CTxIn(COutPoint(tx2a_txid, 0), nSequence=0)]
	tx3c.vout = [CTxOut(int(0.5*COIN), CScript([b'f']))]
	tx3c_hex = txToHex(tx3c)

	self.nodes[0].sendrawtransaction(tx3b_hex, True)
	# If tx3b was accepted, tx3c won't look like a replacement,
	# but make sure it is accepted anyway
	self.nodes[0].sendrawtransaction(tx3c_hex, True)

	def test_prioritised_transactions(self):
	# Ensure that fee deltas used via prioritisetransaction are
	# correctly used by replacement logic

	# 1. Check that feeperkb uses modified fees
	tx0_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))

	tx1a = CTransaction()
	tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx1a_hex = txToHex(tx1a)
	tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)

	# Higher fee, but the actual fee per KB is much lower.
	tx1b = CTransaction()
	tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
	tx1b.vout = [CTxOut(int(0.001COIN), CScript([b'a'740000]))]
	tx1b_hex = txToHex(tx1b)

	# Verify tx1b cannot replace tx1a.
	try:
	tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	else:
	assert(False)

	# Use prioritisetransaction to set tx1a's fee to 0.
	self.nodes[0].prioritisetransaction(tx1a_txid, 0, int(-0.1*COIN))

	# Now tx1b should be able to replace tx1a
	tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)

	assert(tx1b_txid in self.nodes[0].getrawmempool())

	# 2. Check that absolute fee checks use modified fee.
	tx1_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))

	tx2a = CTransaction()
	tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0)]
	tx2a.vout = [CTxOut(1*COIN, CScript([b'a']))]
	tx2a_hex = txToHex(tx2a)
	tx2a_txid = self.nodes[0].sendrawtransaction(tx2a_hex, True)

	# Lower fee, but we'll prioritise it
	tx2b = CTransaction()
	tx2b.vin = [CTxIn(tx1_outpoint, nSequence=0)]
	tx2b.vout = [CTxOut(int(1.01*COIN), CScript([b'a']))]
	tx2b.rehash()
	tx2b_hex = txToHex(tx2b)

	# Verify tx2b cannot replace tx2a.
	try:
	tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True)
	except JSONRPCException as exp:
	assert_equal(exp.error['code'], -26)
	else:
	assert(False)

	# Now prioritise tx2b to have a higher modified fee
	self.nodes[0].prioritisetransaction(tx2b.hash, 0, int(0.1*COIN))

	# tx2b should now be accepted
	tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True)

	assert(tx2b_txid in self.nodes[0].getrawmempool())

	if __name__ == '__main__':
	ReplaceByFeeTest().main()
	diff --git a/qa/rpc-tests/rest.py b/qa/rpc-tests/rest.py
	index ec9515528e..c9c2eaf7f3 100755
	--- a/qa/rpc-tests/rest.py
	+++ b/qa/rpc-tests/rest.py
	@@ -1,334 +1,335 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test REST interface
	#


	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from struct import *
	from io import BytesIO
	from codecs import encode

	import http.client
	import urllib.parse

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

	#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)

	if response_object:
	return conn.getresponse()

	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):
	conn = http.client.HTTPConnection(host, port)
	conn.request('POST', path, requestdata)

	if response_object:
	return conn.getresponse()

	return conn.getresponse().read()

	class RESTTest (BitcoinTestFramework):
	FORMAT_SEPARATOR = "."

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 3)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 3

	def setup_network(self, split=False):
	- self.nodes = start_nodes(3, self.options.tmpdir)
	+ 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
	self.sync_all()

	def run_test(self):
	url = urllib.parse.urlparse(self.nodes[0].url)
	print("Mining blocks...")

	self.nodes[0].generate(1)
	self.sync_all()
	self.nodes[2].generate(100)
	self.sync_all()

	assert_equal(self.nodes[0].getbalance(), 50)

	txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
	self.sync_all()
	self.nodes[2].generate(1)
	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

	# 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_obj = json.loads(json_string)
	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_obj = json.loads(json_string)

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

	#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_obj = json.loads(json_string)

	#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
	assert_equal(len(json_obj['utxos']), 0)

	#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_obj = json.loads(json_string)
	assert_equal(len(json_obj['utxos']), 1)
	assert_equal(json_obj['bitmap'], "10")

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

	binaryRequest = b'\x01\x02'
	binaryRequest += hex_str_to_bytes(txid)
	binaryRequest += pack("i", n)
	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)
	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


	############################
	# 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_obj = json.loads(json_string)
	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_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

	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

	#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, 500) #must be a 500 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, 500) #must be a 500 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, 500) #must be a 500 because we send a invalid bin request

	#test limits
	json_request = '/checkmempool/'
	for x in range(0, 20):
	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, 500) #must be a 500 because we exceeding the limits

	json_request = '/checkmempool/'
	for x in range(0, 15):
	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 500 because we exceeding the limits

	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)
	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)
	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)
	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])

	# 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)
	assert_equal(response_header_hex.status, 200)
	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])

	# check json format
	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)
	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

	#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]['time'], rpc_block_json['time'])
	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
	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)
	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

	# 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_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)
	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))
	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')
	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_obj = json.loads(json_string)
	for tx in txs:
	assert_equal(tx in json_obj, True)

	# now mine the transactions
	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')
	json_obj = json.loads(json_string)
	for tx in json_obj['tx']:
	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')
	json_obj = json.loads(json_string)
	for tx in txs:
	assert_equal(tx in json_obj['tx'], True)

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

	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 ()
	diff --git a/qa/rpc-tests/rpcbind_test.py b/qa/rpc-tests/rpcbind_test.py
	index 7b7c01f993..572273566b 100755
	--- a/qa/rpc-tests/rpcbind_test.py
	+++ b/qa/rpc-tests/rpcbind_test.py
	@@ -1,147 +1,147 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Test for -rpcbind, as well as -rpcallowip and -rpcconnect

	# TODO extend this test from the test framework (like all other tests)

	import tempfile
	import traceback

	from test_framework.util import *
	from test_framework.netutil import *

	def run_bind_test(tmpdir, allow_ips, connect_to, addresses, expected):
	'''
	Start a node with requested rpcallowip and rpcbind parameters,
	then try to connect, and check if the set of bound addresses
	matches the expected set.
	'''
	expected = [(addr_to_hex(addr), port) for (addr, port) in expected]
	base_args = ['-disablewallet', '-nolisten']
	if allow_ips:
	base_args += ['-rpcallowip=' + x for x in allow_ips]
	binds = ['-rpcbind='+addr for addr in addresses]
	- nodes = start_nodes(1, tmpdir, [base_args + binds], connect_to)
	+ nodes = start_nodes(self.num_nodes, tmpdir, [base_args + binds], connect_to)
	try:
	pid = bitcoind_processes[0].pid
	assert_equal(set(get_bind_addrs(pid)), set(expected))
	finally:
	stop_nodes(nodes)
	wait_bitcoinds()

	def run_allowip_test(tmpdir, allow_ips, rpchost, rpcport):
	'''
	Start a node with rpcwallow IP, and request getinfo
	at a non-localhost IP.
	'''
	base_args = ['-disablewallet', '-nolisten'] + ['-rpcallowip='+x for x in allow_ips]
	- nodes = start_nodes(1, tmpdir, [base_args])
	+ nodes = start_nodes(self.num_nodes, tmpdir, [base_args])
	try:
	# connect to node through non-loopback interface
	url = "http://rt:rt@%s:%d" % (rpchost, rpcport,)
	node = get_rpc_proxy(url, 1)
	node.getinfo()
	finally:
	node = None # make sure connection will be garbage collected and closed
	stop_nodes(nodes)
	wait_bitcoinds()


	def run_test(tmpdir):
	assert(sys.platform.startswith('linux')) # due to OS-specific network stats queries, this test works only on Linux
	# find the first non-loopback interface for testing
	non_loopback_ip = None
	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')
	print("Using interface %s for testing" % non_loopback_ip)

	defaultport = rpc_port(0)

	# check default without rpcallowip (IPv4 and IPv6 localhost)
	run_bind_test(tmpdir, None, '127.0.0.1', [],
	[('127.0.0.1', defaultport), ('::1', defaultport)])
	# check default with rpcallowip (IPv6 any)
	run_bind_test(tmpdir, ['127.0.0.1'], '127.0.0.1', [],
	[('::0', defaultport)])
	# check only IPv4 localhost (explicit)
	run_bind_test(tmpdir, ['127.0.0.1'], '127.0.0.1', ['127.0.0.1'],
	[('127.0.0.1', defaultport)])
	# check only IPv4 localhost (explicit) with alternative port
	run_bind_test(tmpdir, ['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
	run_bind_test(tmpdir, ['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)
	run_bind_test(tmpdir, ['[::1]'], '[::1]', ['[::1]'],
	[('::1', defaultport)])
	# check both IPv4 and IPv6 localhost (explicit)
	run_bind_test(tmpdir, ['127.0.0.1'], '127.0.0.1', ['127.0.0.1', '[::1]'],
	[('127.0.0.1', defaultport), ('::1', defaultport)])
	# check only non-loopback interface
	run_bind_test(tmpdir, [non_loopback_ip], non_loopback_ip, [non_loopback_ip],
	[(non_loopback_ip, defaultport)])

	# Check that with invalid rpcallowip, we are denied
	run_allowip_test(tmpdir, [non_loopback_ip], non_loopback_ip, defaultport)
	try:
	run_allowip_test(tmpdir, ['1.1.1.1'], non_loopback_ip, defaultport)
	assert(not 'Connection not denied by rpcallowip as expected')
	except ValueError:
	pass

	def main():
	import optparse

	parser = optparse.OptionParser(usage="%prog [options]")
	parser.add_option("--nocleanup", dest="nocleanup", default=False, action="store_true",
	help="Leave bitcoinds and test.* datadir on exit or error")
	parser.add_option("--srcdir", dest="srcdir", default="../../src",
	help="Source directory containing bitcoind/bitcoin-cli (default: %default%)")
	parser.add_option("--tmpdir", dest="tmpdir", default=tempfile.mkdtemp(prefix="test"),
	help="Root directory for datadirs")
	(options, args) = parser.parse_args()

	os.environ['PATH'] = options.srcdir+":"+os.environ['PATH']

	check_json_precision()

	success = False
	nodes = []
	try:
	print("Initializing test directory "+options.tmpdir)
	if not os.path.isdir(options.tmpdir):
	os.makedirs(options.tmpdir)
	initialize_chain(options.tmpdir)

	run_test(options.tmpdir)

	success = True

	except AssertionError as e:
	print("Assertion failed: "+e.message)
	except Exception as e:
	print("Unexpected exception caught during testing: "+str(e))
	traceback.print_tb(sys.exc_info()[2])

	if not options.nocleanup:
	print("Cleaning up")
	wait_bitcoinds()
	shutil.rmtree(options.tmpdir)

	if success:
	print("Tests successful")
	sys.exit(0)
	else:
	print("Failed")
	sys.exit(1)

	if __name__ == '__main__':
	main()
	diff --git a/qa/rpc-tests/sendheaders.py b/qa/rpc-tests/sendheaders.py
	index 96d1da729b..6ab17d59b3 100755
	--- a/qa/rpc-tests/sendheaders.py
	+++ b/qa/rpc-tests/sendheaders.py
	@@ -1,516 +1,518 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	from test_framework.mininode import *
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from test_framework.blocktools import create_block, create_coinbase

	'''
	SendHeadersTest -- test behavior of headers messages to announce blocks.

	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).
	Second node is used for creating reorgs.

	Part 1: No headers announcements before "sendheaders"
	a. node mines a block [expect: inv]
	send getdata for the block [expect: block]
	b. node mines another block [expect: inv]
	send getheaders and getdata [expect: headers, then block]
	c. node mines another block [expect: inv]
	peer mines a block, announces with header [expect: getdata]
	d. node mines another block [expect: inv]

	Part 2: After "sendheaders", headers announcements should generally work.
	a. peer sends sendheaders [expect: no response]
	peer sends getheaders with current tip [expect: no response]
	b. node mines a block [expect: tip header]
	c. for N in 1, ..., 10:
	* for announce-type in {inv, header}
	- peer mines N blocks, announces with announce-type
	[ expect: getheaders/getdata or getdata, deliver block(s) ]
	- node mines a block [ expect: 1 header ]

	Part 3: Headers announcements stop after large reorg and resume after getheaders or inv from peer.
	- For response-type in {inv, getheaders}
	* node mines a 7 block reorg [ expect: headers announcement of 8 blocks ]
	* node mines an 8-block reorg [ expect: inv at tip ]
	* peer responds with getblocks/getdata [expect: inv, blocks ]
	* node mines another block [ expect: inv at tip, peer sends getdata, expect: block ]
	* node mines another block at tip [ expect: inv ]
	* peer responds with getheaders with an old hashstop more than 8 blocks back [expect: headers]
	* peer requests block [ expect: block ]
	* node mines another block at tip [ expect: inv, peer sends getdata, expect: block ]
	* peer sends response-type [expect headers if getheaders, getheaders/getdata if mining new block]
	* node mines 1 block [expect: 1 header, peer responds with getdata]

	Part 4: Test direct fetch behavior
	a. Announce 2 old block headers.
	Expect: no getdata requests.
	b. Announce 3 new blocks via 1 headers message.
	Expect: one getdata request for all 3 blocks.
	(Send blocks.)
	c. Announce 1 header that forks off the last two blocks.
	Expect: no response.
	d. Announce 1 more header that builds on that fork.
	Expect: one getdata request for two blocks.
	e. Announce 16 more headers that build on that fork.
	Expect: getdata request for 14 more blocks.
	f. Announce 1 more header that builds on that fork.
	Expect: no response.
	'''

	class BaseNode(NodeConnCB):
	def __init__(self):
	NodeConnCB.__init__(self)
	self.connection = None
	self.last_inv = None
	self.last_headers = None
	self.last_block = None
	self.ping_counter = 1
	self.last_pong = msg_pong(0)
	self.last_getdata = None
	self.sleep_time = 0.05
	self.block_announced = False

	def clear_last_announcement(self):
	with mininode_lock:
	self.block_announced = False
	self.last_inv = None
	self.last_headers = None

	def add_connection(self, conn):
	self.connection = conn

	# Request data for a list of block hashes
	def get_data(self, block_hashes):
	msg = msg_getdata()
	for x in block_hashes:
	msg.inv.append(CInv(2, x))
	self.connection.send_message(msg)

	def get_headers(self, locator, hashstop):
	msg = msg_getheaders()
	msg.locator.vHave = locator
	msg.hashstop = hashstop
	self.connection.send_message(msg)

	def send_block_inv(self, blockhash):
	msg = msg_inv()
	msg.inv = [CInv(2, blockhash)]
	self.connection.send_message(msg)

	# Wrapper for the NodeConn's send_message function
	def send_message(self, message):
	self.connection.send_message(message)

	def on_inv(self, conn, message):
	self.last_inv = message
	self.block_announced = True

	def on_headers(self, conn, message):
	self.last_headers = message
	self.block_announced = True

	def on_block(self, conn, message):
	self.last_block = message.block
	self.last_block.calc_sha256()

	def on_getdata(self, conn, message):
	self.last_getdata = message

	def on_pong(self, conn, message):
	self.last_pong = message

	# Test whether the last announcement we received had the
	# right header or the right inv
	# inv and headers should be lists of block hashes
	def check_last_announcement(self, headers=None, inv=None):
	expect_headers = headers if headers != None else []
	expect_inv = inv if inv != None else []
	test_function = lambda: self.block_announced
	self.sync(test_function)
	with mininode_lock:
	self.block_announced = False

	success = True
	compare_inv = []
	if self.last_inv != None:
	compare_inv = [x.hash for x in self.last_inv.inv]
	if compare_inv != expect_inv:
	success = False

	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 ]
	if hash_headers != expect_headers:
	success = False

	self.last_inv = None
	self.last_headers = None
	return success

	# Syncing helpers
	def sync(self, test_function, timeout=60):
	while timeout > 0:
	with mininode_lock:
	if test_function():
	return
	time.sleep(self.sleep_time)
	timeout -= self.sleep_time
	raise AssertionError("Sync failed to complete")

	def sync_with_ping(self, timeout=60):
	self.send_message(msg_ping(nonce=self.ping_counter))
	test_function = lambda: self.last_pong.nonce == self.ping_counter
	self.sync(test_function, timeout)
	self.ping_counter += 1
	return

	def wait_for_block(self, blockhash, timeout=60):
	test_function = lambda: self.last_block != None and self.last_block.sha256 == blockhash
	self.sync(test_function, timeout)
	return

	def wait_for_getdata(self, hash_list, timeout=60):
	if hash_list == []:
	return

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

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

	def send_getblocks(self, locator):
	getblocks_message = msg_getblocks()
	getblocks_message.locator.vHave = locator
	self.send_message(getblocks_message)

	# 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 setup_chain(self):
	- initialize_chain_clean(self.options.tmpdir, 2)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 2

	def setup_network(self):
	self.nodes = []
	- self.nodes = start_nodes(2, 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 ]
	self.nodes[0].generate(count)
	return int(self.nodes[0].getbestblockhash(), 16)

	# mine a reorg that invalidates length blocks (replacing them with
	# length+1 blocks).
	# Note: we clear the state of our p2p connections after the
	# 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
	sync_blocks(self.nodes, wait=0.1)
	[x.clear_last_announcement() for x in self.p2p_connections]

	tip_height = self.nodes[1].getblockcount()
	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
	sync_blocks(self.nodes, wait=0.1)
	return [int(x, 16) for x in all_hashes]

	def run_test(self):
	# Setup the p2p connections and start up the network thread.
	inv_node = InvNode()
	test_node = TestNode()

	self.p2p_connections = [inv_node, test_node]

	connections = []
	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))
	inv_node.add_connection(connections[0])
	test_node.add_connection(connections[1])

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

	# Test logic begins here
	inv_node.wait_for_verack()
	test_node.wait_for_verack()

	tip = int(self.nodes[0].getbestblockhash(), 16)

	# PART 1
	# 1. Mine a block; expect inv announcements each time
	print("Part 1: headers don't start before sendheaders message...")
	for i in range(4):
	old_tip = tip
	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
	if i == 0:
	# first request the block
	test_node.get_data([tip])
	test_node.wait_for_block(tip, timeout=5)
	elif i == 1:
	# next try requesting header and block
	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...
	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']
	block_time = last_time + 1
	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
	inv_node.clear_last_announcement()
	test_node.clear_last_announcement()

	print("Part 1: success!")
	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.
	test_node.send_message(msg_sendheaders())
	prev_tip = int(self.nodes[0].getbestblockhash(), 16)
	test_node.get_headers(locator=[prev_tip], hashstop=0)
	test_node.sync_with_ping()

	# Now that we've synced headers, headers announcements should work
	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)

	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
	# inv (of tip) or via headers. After each, new blocks
	# mined by the node should successfully be announced
	# 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))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	height += 1
	if j == 0:
	# Announce via inv
	test_node.send_block_inv(tip)
	test_node.wait_for_getdata([tip], timeout=5)
	# Test that duplicate inv's won't result in duplicate
	# getdata requests, or duplicate headers announcements
	inv_node.send_block_inv(tip)
	# Should have received a getheaders as well!
	test_node.send_header_for_blocks(blocks)
	test_node.wait_for_getdata([x.sha256 for x in blocks[0:-1]], timeout=5)
	[ inv_node.send_block_inv(x.sha256) for x in blocks[0:-1] ]
	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 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.sync_with_ping()
	inv_node.sync_with_ping()
	# This block should not be announced to the inv node (since it also
	# broadcast it)
	assert_equal(inv_node.last_inv, None)
	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)
	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...")

	# 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
	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)

	block_time += 8

	# 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)
	assert_equal(test_node.check_last_announcement(inv=[tip]), True)

	block_time += 9

	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.get_data(new_block_hashes)
	test_node.wait_for_block(new_block_hashes[-1])

	for i in range(3):
	# 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)
	if i == 0:
	# 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_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
	# triggering resumption of headers announcements.
	if j == 0:
	test_node.get_headers(locator=[tip], hashstop=0)
	test_node.sync_with_ping()
	else:
	test_node.send_block_inv(tip)
	test_node.sync_with_ping()
	# 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)

	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']
	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[-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
	test_node.last_getdata = None
	test_node.send_header_for_blocks(blocks)
	test_node.sync_with_ping()
	# should not have received any getdata messages
	with mininode_lock:
	assert_equal(test_node.last_getdata, None)

	# This time, direct fetch should work
	blocks = []
	for b in range(3):
	blocks.append(create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	height += 1

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

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

	test_node.sync_with_ping()

	# Now announce a header that forks the last two blocks
	tip = blocks[0].sha256
	height -= 1
	blocks = []

	# Create extra blocks for later
	for b in range(20):
	blocks.append(create_block(tip, create_coinbase(height), block_time))
	blocks[-1].solve()
	tip = blocks[-1].sha256
	block_time += 1
	height += 1

	# Announcing one block on fork should not trigger direct fetch
	# (less work than tip)
	test_node.last_getdata = None
	test_node.send_header_for_blocks(blocks[0:1])
	test_node.sync_with_ping()
	with mininode_lock:
	assert_equal(test_node.last_getdata, None)

	# Announcing one more block on fork should trigger direct fetch for
	# 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=test_node.sleep_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=test_node.sleep_time)

	# Announcing 1 more header should not trigger any response
	test_node.last_getdata = None
	test_node.send_header_for_blocks(blocks[18:19])
	test_node.sync_with_ping()
	with mininode_lock:
	assert_equal(test_node.last_getdata, None)

	print("Part 4: success!")

	# Finally, check that the inv node never received a getdata request,
	# throughout the test
	assert_equal(inv_node.last_getdata, None)

	if __name__ == '__main__':
	SendHeadersTest().main()
	diff --git a/qa/rpc-tests/signmessages.py b/qa/rpc-tests/signmessages.py
	index 4a47c0ca1e..31b6f14a26 100755
	--- a/qa/rpc-tests/signmessages.py
	+++ b/qa/rpc-tests/signmessages.py
	@@ -1,40 +1,41 @@
	#!/usr/bin/env python3
	# Copyright (c) 2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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


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

	- def setup_chain(self):
	- print('Initializing test directory ' + self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

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

	def run_test(self):
	message = 'This is just a test message'

	# Test the signing with a privkey
	privKey = 'cUeKHd5orzT3mz8P9pxyREHfsWtVfgsfDjiZZBcjUBAaGk1BTj7N'
	address = 'mpLQjfK79b7CCV4VMJWEWAj5Mpx8Up5zxB'
	signature = self.nodes[0].signmessagewithprivkey(privKey, message)

	# Verify the message
	assert(self.nodes[0].verifymessage(address, signature, message))

	# Test the signing with an address with wallet
	address = self.nodes[0].getnewaddress()
	signature = self.nodes[0].signmessage(address, message)

	# Verify the message
	assert(self.nodes[0].verifymessage(address, signature, message))

	if __name__ == '__main__':
	SignMessagesTest().main()
	diff --git a/qa/rpc-tests/signrawtransactions.py b/qa/rpc-tests/signrawtransactions.py
	index a06ac53191..c61a280616 100755
	--- a/qa/rpc-tests/signrawtransactions.py
	+++ b/qa/rpc-tests/signrawtransactions.py
	@@ -1,109 +1,110 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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


	class SignRawTransactionsTest(BitcoinTestFramework):
	"""Tests transaction signing via RPC command "signrawtransaction"."""

	- def setup_chain(self):
	- print('Initializing test directory ' + self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 1)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 1

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

	def successful_signing_test(self):
	"""Creates and signs a valid raw transaction with one input.

	Expected results:

	1) The transaction has a complete set of signatures
	2) No script verification error occurred"""
	privKeys = ['cUeKHd5orzT3mz8P9pxyREHfsWtVfgsfDjiZZBcjUBAaGk1BTj7N']

	inputs = [
	# Valid pay-to-pubkey script
	{'txid': '9b907ef1e3c26fc71fe4a4b3580bc75264112f95050014157059c736f0202e71', 'vout': 0,
	'scriptPubKey': '76a91460baa0f494b38ce3c940dea67f3804dc52d1fb9488ac'}
	]

	outputs = {'mpLQjfK79b7CCV4VMJWEWAj5Mpx8Up5zxB': 0.1}

	rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
	rawTxSigned = self.nodes[0].signrawtransaction(rawTx, inputs, privKeys)

	# 1) The transaction has a complete set of signatures
	assert 'complete' in rawTxSigned
	assert_equal(rawTxSigned['complete'], True)

	# 2) No script verification error occurred
	assert 'errors' not in rawTxSigned

	def script_verification_error_test(self):
	"""Creates and signs a raw transaction with valid (vin 0), invalid (vin 1) and one missing (vin 2) input script.

	Expected results:

	3) The transaction has no complete set of signatures
	4) Two script verification errors occurred
	5) Script verification errors have certain properties ("txid", "vout", "scriptSig", "sequence", "error")
	6) The verification errors refer to the invalid (vin 1) and missing input (vin 2)"""
	privKeys = ['cUeKHd5orzT3mz8P9pxyREHfsWtVfgsfDjiZZBcjUBAaGk1BTj7N']

	inputs = [
	# Valid pay-to-pubkey script
	{'txid': '9b907ef1e3c26fc71fe4a4b3580bc75264112f95050014157059c736f0202e71', 'vout': 0},
	# Invalid script
	{'txid': '5b8673686910442c644b1f4993d8f7753c7c8fcb5c87ee40d56eaeef25204547', 'vout': 7},
	# Missing scriptPubKey
	{'txid': '9b907ef1e3c26fc71fe4a4b3580bc75264112f95050014157059c736f0202e71', 'vout': 1},
	]

	scripts = [
	# Valid pay-to-pubkey script
	{'txid': '9b907ef1e3c26fc71fe4a4b3580bc75264112f95050014157059c736f0202e71', 'vout': 0,
	'scriptPubKey': '76a91460baa0f494b38ce3c940dea67f3804dc52d1fb9488ac'},
	# Invalid script
	{'txid': '5b8673686910442c644b1f4993d8f7753c7c8fcb5c87ee40d56eaeef25204547', 'vout': 7,
	'scriptPubKey': 'badbadbadbad'}
	]

	outputs = {'mpLQjfK79b7CCV4VMJWEWAj5Mpx8Up5zxB': 0.1}

	rawTx = self.nodes[0].createrawtransaction(inputs, outputs)
	rawTxSigned = self.nodes[0].signrawtransaction(rawTx, scripts, privKeys)

	# 3) The transaction has no complete set of signatures
	assert 'complete' in rawTxSigned
	assert_equal(rawTxSigned['complete'], False)

	# 4) Two script verification errors occurred
	assert 'errors' in rawTxSigned
	assert_equal(len(rawTxSigned['errors']), 2)

	# 5) Script verification errors have certain properties
	assert 'txid' in rawTxSigned['errors'][0]
	assert 'vout' in rawTxSigned['errors'][0]
	assert 'scriptSig' in rawTxSigned['errors'][0]
	assert 'sequence' in rawTxSigned['errors'][0]
	assert 'error' in rawTxSigned['errors'][0]

	# 6) The verification errors refer to the invalid (vin 1) and missing input (vin 2)
	assert_equal(rawTxSigned['errors'][0]['txid'], inputs[1]['txid'])
	assert_equal(rawTxSigned['errors'][0]['vout'], inputs[1]['vout'])
	assert_equal(rawTxSigned['errors'][1]['txid'], inputs[2]['txid'])
	assert_equal(rawTxSigned['errors'][1]['vout'], inputs[2]['vout'])

	def run_test(self):
	self.successful_signing_test()
	self.script_verification_error_test()


	if __name__ == '__main__':
	SignRawTransactionsTest().main()
	diff --git a/qa/rpc-tests/smartfees.py b/qa/rpc-tests/smartfees.py
	index 8fcb99c1b7..d76fba4b07 100755
	--- a/qa/rpc-tests/smartfees.py
	+++ b/qa/rpc-tests/smartfees.py
	@@ -1,262 +1,267 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test fee estimation code
	#

	from collections import OrderedDict
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *

	# Construct 2 trivial P2SH's and the ScriptSigs that spend them
	# So we can create many many transactions without needing to spend
	# time signing.
	P2SH_1 = "2MySexEGVzZpRgNQ1JdjdP5bRETznm3roQ2" # P2SH of "OP_1 OP_DROP"
	P2SH_2 = "2NBdpwq8Aoo1EEKEXPNrKvr5xQr3M9UfcZA" # P2SH of "OP_2 OP_DROP"
	# Associated ScriptSig's to spend satisfy P2SH_1 and P2SH_2
	# 4 bytes of OP_TRUE and push 2-byte redeem script of "OP_1 OP_DROP" or "OP_2 OP_DROP"
	SCRIPT_SIG = ["0451025175", "0451025275"]

	def small_txpuzzle_randfee(from_node, conflist, unconflist, amount, min_fee, fee_increment):
	'''
	Create and send a transaction with a random fee.
	The transaction pays to a trivial P2SH script, and assumes that its inputs
	are of the same form.
	The function takes a list of confirmed outputs and unconfirmed outputs
	and attempts to use the confirmed list first for its inputs.
	It adds the newly created outputs to the unconfirmed list.
	Returns (raw transaction, fee)
	'''
	# It's best to exponentially distribute our random fees
	# because the buckets are exponentially spaced.
	# Exponentially distributed from 1-128 * fee_increment
	rand_fee = float(fee_increment)(1.1892*random.randint(0,28))
	# Total fee ranges from min_fee to min_fee + 127*fee_increment
	fee = min_fee - fee_increment + satoshi_round(rand_fee)
	inputs = []
	total_in = Decimal("0.00000000")
	while total_in <= (amount + fee) and len(conflist) > 0:
	t = conflist.pop(0)
	total_in += t["amount"]
	inputs.append({ "txid" : t["txid"], "vout" : t["vout"]} )
	if total_in <= amount + fee:
	while total_in <= (amount + fee) and len(unconflist) > 0:
	t = unconflist.pop(0)
	total_in += t["amount"]
	inputs.append({ "txid" : t["txid"], "vout" : t["vout"]} )
	if total_in <= amount + fee:
	raise RuntimeError("Insufficient funds: need %d, have %d"%(amount+fee, total_in))
	outputs = {}
	outputs = OrderedDict([(P2SH_1, total_in - amount - fee),
	(P2SH_2, amount)])
	rawtx = from_node.createrawtransaction(inputs, outputs)
	# createrawtransaction constructs a transaction that is ready to be signed.
	# These transactions don't need to be signed, but we still have to insert the ScriptSig
	# that will satisfy the ScriptPubKey.
	completetx = rawtx[0:10]
	inputnum = 0
	for inp in inputs:
	completetx += rawtx[10+82inputnum:82+82inputnum]
	completetx += SCRIPT_SIG[inp["vout"]]
	completetx += rawtx[84+82inputnum:92+82inputnum]
	inputnum += 1
	completetx += rawtx[10+82*inputnum:]
	txid = from_node.sendrawtransaction(completetx, True)
	unconflist.append({ "txid" : txid, "vout" : 0 , "amount" : total_in - amount - fee})
	unconflist.append({ "txid" : txid, "vout" : 1 , "amount" : amount})

	return (completetx, fee)

	def split_inputs(from_node, txins, txouts, initial_split = False):
	'''
	We need to generate a lot of very small inputs so we can generate a ton of transactions
	and they will have low priority.
	This function takes an input from txins, and creates and sends a transaction
	which splits the value into 2 outputs which are appended to txouts.
	'''
	prevtxout = txins.pop()
	inputs = []
	inputs.append({ "txid" : prevtxout["txid"], "vout" : prevtxout["vout"] })
	half_change = satoshi_round(prevtxout["amount"]/2)
	rem_change = prevtxout["amount"] - half_change - Decimal("0.00001000")
	outputs = OrderedDict([(P2SH_1, half_change), (P2SH_2, rem_change)])
	rawtx = from_node.createrawtransaction(inputs, outputs)
	# If this is the initial split we actually need to sign the transaction
	# Otherwise we just need to insert the property ScriptSig
	if (initial_split) :
	completetx = from_node.signrawtransaction(rawtx)["hex"]
	else :
	completetx = rawtx[0:82] + SCRIPT_SIG[prevtxout["vout"]] + rawtx[84:]
	txid = from_node.sendrawtransaction(completetx, True)
	txouts.append({ "txid" : txid, "vout" : 0 , "amount" : half_change})
	txouts.append({ "txid" : txid, "vout" : 1 , "amount" : rem_change})

	def check_estimates(node, fees_seen, max_invalid, print_estimates = True):
	'''
	This function calls estimatefee and verifies that the estimates
	meet certain invariants.
	'''
	all_estimates = [ node.estimatefee(i) for i in range(1,26) ]
	if print_estimates:
	print([str(all_estimates[e-1]) for e in [1,2,3,6,15,25]])
	delta = 1.0e-6 # account for rounding error
	last_e = max(fees_seen)
	for e in [x for x in all_estimates if x >= 0]:
	# Estimates should be within the bounds of what transactions fees actually were:
	if float(e)+delta < min(fees_seen) or float(e)-delta > max(fees_seen):
	raise AssertionError("Estimated fee (%f) out of range (%f,%f)"
	%(float(e), min(fees_seen), max(fees_seen)))
	# Estimates should be monotonically decreasing
	if float(e)-delta > last_e:
	raise AssertionError("Estimated fee (%f) larger than last fee (%f) for lower number of confirms"
	%(float(e),float(last_e)))
	last_e = e
	valid_estimate = False
	invalid_estimates = 0
	for i,e in enumerate(all_estimates): # estimate is for i+1
	if e >= 0:
	valid_estimate = True
	# estimatesmartfee should return the same result
	assert_equal(node.estimatesmartfee(i+1)["feerate"], e)

	else:
	invalid_estimates += 1

	# estimatesmartfee should still be valid
	approx_estimate = node.estimatesmartfee(i+1)["feerate"]
	answer_found = node.estimatesmartfee(i+1)["blocks"]
	assert(approx_estimate > 0)
	assert(answer_found > i+1)

	# Once we're at a high enough confirmation count that we can give an estimate
	# We should have estimates for all higher confirmation counts
	if valid_estimate:
	raise AssertionError("Invalid estimate appears at higher confirm count than valid estimate")

	# Check on the expected number of different confirmation counts
	# that we might not have valid estimates for
	if invalid_estimates > max_invalid:
	raise AssertionError("More than (%d) invalid estimates"%(max_invalid))
	return all_estimates


	class EstimateFeeTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 3
	+ self.setup_clean_chain = False
	+
	def setup_network(self):
	'''
	We'll setup the network to have 3 nodes that all mine with different parameters.
	But first we need to use one node to create a lot of small low priority outputs
	which we will use to generate our transactions.
	'''
	self.nodes = []
	# Use node0 to mine blocks for input splitting
	self.nodes.append(start_node(0, self.options.tmpdir, ["-maxorphantx=1000",
	"-relaypriority=0", "-whitelist=127.0.0.1"]))

	print("This test is time consuming, please be patient")
	print("Splitting inputs to small size so we can generate low priority tx's")
	self.txouts = []
	self.txouts2 = []
	# Split a coinbase into two transaction puzzle outputs
	split_inputs(self.nodes[0], self.nodes[0].listunspent(0), self.txouts, True)

	# Mine
	while (len(self.nodes[0].getrawmempool()) > 0):
	self.nodes[0].generate(1)

	# Repeatedly split those 2 outputs, doubling twice for each rep
	# Use txouts to monitor the available utxo, since these won't be tracked in wallet
	reps = 0
	while (reps < 5):
	#Double txouts to txouts2
	while (len(self.txouts)>0):
	split_inputs(self.nodes[0], self.txouts, self.txouts2)
	while (len(self.nodes[0].getrawmempool()) > 0):
	self.nodes[0].generate(1)
	#Double txouts2 to txouts
	while (len(self.txouts2)>0):
	split_inputs(self.nodes[0], self.txouts2, self.txouts)
	while (len(self.nodes[0].getrawmempool()) > 0):
	self.nodes[0].generate(1)
	reps += 1
	print("Finished splitting")

	# Now we can connect the other nodes, didn't want to connect them earlier
	# so the estimates would not be affected by the splitting transactions
	# Node1 mines small blocks but that are bigger than the expected transaction rate,
	# and allows free transactions.
	# NOTE: the CreateNewBlock code starts counting block size at 1,000 bytes,
	# (17k is room enough for 110 or so transactions)
	self.nodes.append(start_node(1, self.options.tmpdir,
	["-blockprioritysize=1500", "-blockmaxsize=17000",
	"-maxorphantx=1000", "-relaypriority=0", "-debug=estimatefee"]))
	connect_nodes(self.nodes[1], 0)

	# Node2 is a stingy miner, that
	# produces too small blocks (room for only 55 or so transactions)
	node2args = ["-blockprioritysize=0", "-blockmaxsize=8000", "-maxorphantx=1000", "-relaypriority=0"]

	self.nodes.append(start_node(2, self.options.tmpdir, node2args))
	connect_nodes(self.nodes[0], 2)
	connect_nodes(self.nodes[2], 1)

	self.is_network_split = False
	self.sync_all()

	def transact_and_mine(self, numblocks, mining_node):
	min_fee = Decimal("0.00001")
	# We will now mine numblocks blocks generating on average 100 transactions between each block
	# We shuffle our confirmed txout set before each set of transactions
	# small_txpuzzle_randfee will use the transactions that have inputs already in the chain when possible
	# resorting to tx's that depend on the mempool when those run out
	for i in range(numblocks):
	random.shuffle(self.confutxo)
	for j in range(random.randrange(100-50,100+50)):
	from_index = random.randint(1,2)
	(txhex, fee) = small_txpuzzle_randfee(self.nodes[from_index], self.confutxo,
	self.memutxo, Decimal("0.005"), min_fee, min_fee)
	tx_kbytes = (len(txhex) // 2) / 1000.0
	self.fees_per_kb.append(float(fee)/tx_kbytes)
	sync_mempools(self.nodes[0:3],.1)
	mined = mining_node.getblock(mining_node.generate(1)[0],True)["tx"]
	sync_blocks(self.nodes[0:3],.1)
	# update which txouts are confirmed
	newmem = []
	for utx in self.memutxo:
	if utx["txid"] in mined:
	self.confutxo.append(utx)
	else:
	newmem.append(utx)
	self.memutxo = newmem

	def run_test(self):
	self.fees_per_kb = []
	self.memutxo = []
	self.confutxo = self.txouts # Start with the set of confirmed txouts after splitting
	print("Will output estimates for 1/2/3/6/15/25 blocks")

	for i in range(2):
	print("Creating transactions and mining them with a block size that can't keep up")
	# Create transactions and mine 10 small blocks with node 2, but create txs faster than we can mine
	self.transact_and_mine(10, self.nodes[2])
	check_estimates(self.nodes[1], self.fees_per_kb, 14)

	print("Creating transactions and mining them at a block size that is just big enough")
	# Generate transactions while mining 10 more blocks, this time with node1
	# which mines blocks with capacity just above the rate that transactions are being created
	self.transact_and_mine(10, self.nodes[1])
	check_estimates(self.nodes[1], self.fees_per_kb, 2)

	# Finish by mining a normal-sized block:
	while len(self.nodes[1].getrawmempool()) > 0:
	self.nodes[1].generate(1)

	sync_blocks(self.nodes[0:3],.1)
	print("Final estimates after emptying mempools")
	check_estimates(self.nodes[1], self.fees_per_kb, 2)

	if __name__ == '__main__':
	EstimateFeeTest().main()
	diff --git a/qa/rpc-tests/test_framework/test_framework.py b/qa/rpc-tests/test_framework/test_framework.py
	index 3480de6c6e..b9b803429d 100755
	--- a/qa/rpc-tests/test_framework/test_framework.py
	+++ b/qa/rpc-tests/test_framework/test_framework.py
	@@ -1,205 +1,206 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	# Base class for RPC testing

	import logging
	import optparse
	import os
	import sys
	import shutil
	import tempfile
	import traceback

	from .util import (
	initialize_chain,
	- assert_equal,
	start_nodes,
	connect_nodes_bi,
	sync_blocks,
	sync_mempools,
	stop_nodes,
	wait_bitcoinds,
	enable_coverage,
	check_json_precision,
	initialize_chain_clean,
	PortSeed,
	)
	from .authproxy import JSONRPCException


	class BitcoinTestFramework(object):

	- # These may be over-ridden by subclasses:
	+ def __init__(self):
	+ self.num_nodes = 4
	+ self.setup_clean_chain = False
	+ self.nodes = None
	+
	def run_test(self):
	- for node in self.nodes:
	- assert_equal(node.getblockcount(), 200)
	- assert_equal(node.getbalance(), 25*50)
	+ raise NotImplementedError

	def add_options(self, parser):
	pass

	def setup_chain(self):
	print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain(self.options.tmpdir)
	+ if self.setup_clean_chain:
	+ initialize_chain_clean(self.options.tmpdir, self.num_nodes)
	+ else:
	+ initialize_chain(self.options.tmpdir, self.num_nodes)

	def setup_nodes(self):
	- return start_nodes(4, self.options.tmpdir)
	+ return start_nodes(self.num_nodes, self.options.tmpdir)

	def setup_network(self, split = False):
	self.nodes = self.setup_nodes()

	# Connect the nodes as a "chain". This allows us
	# to split the network between nodes 1 and 2 to get
	# two halves that can work on competing chains.

	# If we joined network halves, connect the nodes from the joint
	# on outward. This ensures that chains are properly reorganised.
	if not split:
	connect_nodes_bi(self.nodes, 1, 2)
	sync_blocks(self.nodes[1:3])
	sync_mempools(self.nodes[1:3])

	connect_nodes_bi(self.nodes, 0, 1)
	connect_nodes_bi(self.nodes, 2, 3)
	self.is_network_split = split
	self.sync_all()

	def split_network(self):
	"""
	Split the network of four nodes into nodes 0/1 and 2/3.
	"""
	assert not self.is_network_split
	stop_nodes(self.nodes)
	wait_bitcoinds()
	self.setup_network(True)

	def sync_all(self):
	if self.is_network_split:
	sync_blocks(self.nodes[:2])
	sync_blocks(self.nodes[2:])
	sync_mempools(self.nodes[:2])
	sync_mempools(self.nodes[2:])
	else:
	sync_blocks(self.nodes)
	sync_mempools(self.nodes)

	def join_network(self):
	"""
	Join the (previously split) network halves together.
	"""
	assert self.is_network_split
	stop_nodes(self.nodes)
	wait_bitcoinds()
	self.setup_network(False)

	def main(self):

	parser = optparse.OptionParser(usage="%prog [options]")
	parser.add_option("--nocleanup", dest="nocleanup", default=False, action="store_true",
	help="Leave bitcoinds and test.* datadir on exit or error")
	parser.add_option("--noshutdown", dest="noshutdown", default=False, action="store_true",
	help="Don't stop bitcoinds after the test execution")
	parser.add_option("--srcdir", dest="srcdir", default=os.path.normpath(os.path.dirname(os.path.realpath(__file__))+"/../../../src"),
	help="Source directory containing bitcoind/bitcoin-cli (default: %default)")
	parser.add_option("--tmpdir", dest="tmpdir", default=tempfile.mkdtemp(prefix="test"),
	help="Root directory for datadirs")
	parser.add_option("--tracerpc", dest="trace_rpc", default=False, action="store_true",
	help="Print out all RPC calls as they are made")
	parser.add_option("--portseed", dest="port_seed", default=os.getpid(), type='int',
	help="The seed to use for assigning port numbers (default: current process id)")
	parser.add_option("--coveragedir", dest="coveragedir",
	help="Write tested RPC commands into this directory")
	self.add_options(parser)
	(self.options, self.args) = parser.parse_args()

	if self.options.trace_rpc:
	logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)

	if self.options.coveragedir:
	enable_coverage(self.options.coveragedir)

	PortSeed.n = self.options.port_seed

	os.environ['PATH'] = self.options.srcdir+":"+self.options.srcdir+"/qt:"+os.environ['PATH']

	check_json_precision()

	success = False
	try:
	if not os.path.isdir(self.options.tmpdir):
	os.makedirs(self.options.tmpdir)
	self.setup_chain()

	self.setup_network()

	self.run_test()

	success = True

	except JSONRPCException as e:
	print("JSONRPC error: "+e.error['message'])
	traceback.print_tb(sys.exc_info()[2])
	except AssertionError as e:
	print("Assertion failed: " + str(e))
	traceback.print_tb(sys.exc_info()[2])
	except KeyError as e:
	print("key not found: "+ str(e))
	traceback.print_tb(sys.exc_info()[2])
	except Exception as e:
	print("Unexpected exception caught during testing: " + repr(e))
	traceback.print_tb(sys.exc_info()[2])
	except KeyboardInterrupt as e:
	print("Exiting after " + repr(e))

	if not self.options.noshutdown:
	print("Stopping nodes")
	stop_nodes(self.nodes)
	wait_bitcoinds()
	else:
	print("Note: bitcoinds were not stopped and may still be running")

	if not self.options.nocleanup and not self.options.noshutdown:
	print("Cleaning up")
	shutil.rmtree(self.options.tmpdir)

	if success:
	print("Tests successful")
	sys.exit(0)
	else:
	print("Failed")
	sys.exit(1)


	# Test framework for doing p2p comparison testing, which sets up some bitcoind
	# binaries:
	# 1 binary: test binary
	# 2 binaries: 1 test binary, 1 ref binary
	# n>2 binaries: 1 test binary, n-1 ref binaries

	class ComparisonTestFramework(BitcoinTestFramework):

	- # Can override the num_nodes variable to indicate how many nodes to run.
	def __init__(self):
	+ super().__init__()
	self.num_nodes = 2
	+ self.setup_clean_chain = True

	def add_options(self, parser):
	parser.add_option("--testbinary", dest="testbinary",
	default=os.getenv("BITCOIND", "bitcoind"),
	help="bitcoind binary to test")
	parser.add_option("--refbinary", dest="refbinary",
	default=os.getenv("BITCOIND", "bitcoind"),
	help="bitcoind binary to use for reference nodes (if any)")

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, self.num_nodes)
	-
	def setup_network(self):
	self.nodes = start_nodes(
	self.num_nodes, self.options.tmpdir,
	extra_args=[['-debug', '-whitelist=127.0.0.1']] * self.num_nodes,
	binary=[self.options.testbinary] +
	[self.options.refbinary]*(self.num_nodes-1))
	diff --git a/qa/rpc-tests/test_framework/util.py b/qa/rpc-tests/test_framework/util.py
	index 6784177aaa..0e522e78d4 100644
	--- a/qa/rpc-tests/test_framework/util.py
	+++ b/qa/rpc-tests/test_framework/util.py
	@@ -1,614 +1,621 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.


	#
	# Helpful routines for regression testing
	#

	import os
	import sys

	from binascii import hexlify, unhexlify
	from base64 import b64encode
	from decimal import Decimal, ROUND_DOWN
	import json
	import http.client
	import random
	import shutil
	import subprocess
	import time
	import re
	import errno

	from . import coverage
	from .authproxy import AuthServiceProxy, JSONRPCException

	COVERAGE_DIR = None

	# The maximum number of nodes a single test can spawn
	MAX_NODES = 8
	# Don't assign rpc or p2p ports lower than this
	PORT_MIN = 11000
	# The number of ports to "reserve" for p2p and rpc, each
	PORT_RANGE = 5000


	class PortSeed:
	# Must be initialized with a unique integer for each process
	n = None

	#Set Mocktime default to OFF.
	#MOCKTIME is only needed for scripts that use the
	#cached version of the blockchain. If the cached
	#version of the blockchain is used without MOCKTIME
	#then the mempools will not sync due to IBD.
	MOCKTIME = 0

	def enable_mocktime():
	#For backwared compatibility of the python scripts
	#with previous versions of the cache, set MOCKTIME
	#to Jan 1, 2014 + (201 * 10 * 60)
	global MOCKTIME
	MOCKTIME = 1388534400 + (201 * 10 * 60)

	def disable_mocktime():
	global MOCKTIME
	MOCKTIME = 0

	def get_mocktime():
	return MOCKTIME

	def enable_coverage(dirname):
	"""Maintain a log of which RPC calls are made during testing."""
	global COVERAGE_DIR
	COVERAGE_DIR = dirname


	def get_rpc_proxy(url, node_number, timeout=None):
	"""
	Args:
	url (str): URL of the RPC server to call
	node_number (int): the node number (or id) that this calls to

	Kwargs:
	timeout (int): HTTP timeout in seconds

	Returns:
	AuthServiceProxy. convenience object for making RPC calls.

	"""
	proxy_kwargs = {}
	if timeout is not None:
	proxy_kwargs['timeout'] = timeout

	proxy = AuthServiceProxy(url, **proxy_kwargs)
	proxy.url = url # store URL on proxy for info

	coverage_logfile = coverage.get_filename(
	COVERAGE_DIR, node_number) if COVERAGE_DIR else None

	return coverage.AuthServiceProxyWrapper(proxy, coverage_logfile)


	def p2p_port(n):
	assert(n <= MAX_NODES)
	return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)

	def rpc_port(n):
	return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)

	def check_json_precision():
	"""Make sure json library being used does not lose precision converting BTC values"""
	n = Decimal("20000000.00000003")
	satoshis = int(json.loads(json.dumps(float(n)))*1.0e8)
	if satoshis != 2000000000000003:
	raise RuntimeError("JSON encode/decode loses precision")

	def count_bytes(hex_string):
	return len(bytearray.fromhex(hex_string))

	def bytes_to_hex_str(byte_str):
	return hexlify(byte_str).decode('ascii')

	def hex_str_to_bytes(hex_str):
	return unhexlify(hex_str.encode('ascii'))

	def str_to_b64str(string):
	return b64encode(string.encode('utf-8')).decode('ascii')

	def sync_blocks(rpc_connections, wait=1):
	"""
	Wait until everybody has the same block count
	"""
	while True:
	counts = [ x.getblockcount() for x in rpc_connections ]
	if counts == [ counts[0] ]*len(counts):
	break
	time.sleep(wait)

	def sync_mempools(rpc_connections, wait=1):
	"""
	Wait until everybody has the same transactions in their memory
	pools
	"""
	while True:
	pool = set(rpc_connections[0].getrawmempool())
	num_match = 1
	for i in range(1, len(rpc_connections)):
	if set(rpc_connections[i].getrawmempool()) == pool:
	num_match = num_match+1
	if num_match == len(rpc_connections):
	break
	time.sleep(wait)

	bitcoind_processes = {}

	def initialize_datadir(dirname, n):
	datadir = os.path.join(dirname, "node"+str(n))
	if not os.path.isdir(datadir):
	os.makedirs(datadir)
	with open(os.path.join(datadir, "bitcoin.conf"), 'w') as f:
	f.write("regtest=1\n")
	f.write("rpcuser=rt\n")
	f.write("rpcpassword=rt\n")
	f.write("port="+str(p2p_port(n))+"\n")
	f.write("rpcport="+str(rpc_port(n))+"\n")
	f.write("listenonion=0\n")
	return datadir

	def rpc_url(i, rpchost=None):
	return "http://rt:rt@%s:%d" % (rpchost or '127.0.0.1', rpc_port(i))

	def wait_for_bitcoind_start(process, url, i):
	'''
	Wait for bitcoind to start. This means that RPC is accessible and fully initialized.
	Raise an exception if bitcoind exits during initialization.
	'''
	while True:
	if process.poll() is not None:
	raise Exception('bitcoind exited with status %i during initialization' % process.returncode)
	try:
	rpc = get_rpc_proxy(url, i)
	blocks = rpc.getblockcount()
	break # break out of loop on success
	except IOError as e:
	if e.errno != errno.ECONNREFUSED: # Port not yet open?
	raise # unknown IO error
	except JSONRPCException as e: # Initialization phase
	if e.error['code'] != -28: # RPC in warmup?
	raise # unkown JSON RPC exception
	time.sleep(0.25)

	-def initialize_chain(test_dir):
	+def initialize_chain(test_dir, num_nodes):
	"""
	- Create (or copy from cache) a 200-block-long chain and
	- 4 wallets.
	+ Create a cache of a 200-block-long chain (with wallet) for MAX_NODES
	+ Afterward, create num_nodes copies from the cache
	"""

	- if (not os.path.isdir(os.path.join("cache","node0"))
	- or not os.path.isdir(os.path.join("cache","node1"))
	- or not os.path.isdir(os.path.join("cache","node2"))
	- or not os.path.isdir(os.path.join("cache","node3"))):
	+ assert num_nodes <= MAX_NODES
	+ create_cache = False
	+ for i in range(MAX_NODES):
	+ if not os.path.isdir(os.path.join('cache', 'node'+str(i))):
	+ create_cache = True
	+ break
	+
	+ if create_cache:

	#find and delete old cache directories if any exist
	- for i in range(4):
	+ for i in range(MAX_NODES):
	if os.path.isdir(os.path.join("cache","node"+str(i))):
	shutil.rmtree(os.path.join("cache","node"+str(i)))

	# Create cache directories, run bitcoinds:
	- for i in range(4):
	+ for i in range(MAX_NODES):
	datadir=initialize_datadir("cache", i)
	args = [ os.getenv("BITCOIND", "bitcoind"), "-server", "-keypool=1", "-datadir="+datadir, "-discover=0" ]
	if i > 0:
	args.append("-connect=127.0.0.1:"+str(p2p_port(0)))
	bitcoind_processes[i] = subprocess.Popen(args)
	if os.getenv("PYTHON_DEBUG", ""):
	print("initialize_chain: bitcoind started, waiting for RPC to come up")
	wait_for_bitcoind_start(bitcoind_processes[i], rpc_url(i), i)
	if os.getenv("PYTHON_DEBUG", ""):
	print("initialize_chain: RPC succesfully started")

	rpcs = []
	- for i in range(4):
	+ for i in range(MAX_NODES):
	try:
	rpcs.append(get_rpc_proxy(rpc_url(i), i))
	except:
	sys.stderr.write("Error connecting to "+url+"\n")
	sys.exit(1)

	- # Create a 200-block-long chain; each of the 4 nodes
	+ # Create a 200-block-long chain; each of the 4 first nodes
	# gets 25 mature blocks and 25 immature.
	+ # Note: To preserve compatibility with older versions of
	+ # initialize_chain, only 4 nodes will generate coins.
	+ #
	# blocks are created with timestamps 10 minutes apart
	# starting from 2010 minutes in the past
	enable_mocktime()
	block_time = get_mocktime() - (201 * 10 * 60)
	for i in range(2):
	for peer in range(4):
	for j in range(25):
	set_node_times(rpcs, block_time)
	rpcs[peer].generate(1)
	block_time += 10*60
	# Must sync before next peer starts generating blocks
	sync_blocks(rpcs)

	# Shut them down, and clean up cache directories:
	stop_nodes(rpcs)
	wait_bitcoinds()
	disable_mocktime()
	- for i in range(4):
	+ for i in range(MAX_NODES):
	os.remove(log_filename("cache", i, "debug.log"))
	os.remove(log_filename("cache", i, "db.log"))
	os.remove(log_filename("cache", i, "peers.dat"))
	os.remove(log_filename("cache", i, "fee_estimates.dat"))

	- for i in range(4):
	+ for i in range(num_nodes):
	from_dir = os.path.join("cache", "node"+str(i))
	to_dir = os.path.join(test_dir, "node"+str(i))
	shutil.copytree(from_dir, to_dir)
	initialize_datadir(test_dir, i) # Overwrite port/rpcport in bitcoin.conf

	def initialize_chain_clean(test_dir, num_nodes):
	"""
	Create an empty blockchain and num_nodes wallets.
	Useful if a test case wants complete control over initialization.
	"""
	for i in range(num_nodes):
	datadir=initialize_datadir(test_dir, i)


	def _rpchost_to_args(rpchost):
	'''Convert optional IP:port spec to rpcconnect/rpcport args'''
	if rpchost is None:
	return []

	match = re.match('(\[[0-9a-fA-f:]+\]\|[^:]+)(?::([0-9]+))?$', rpchost)
	if not match:
	raise ValueError('Invalid RPC host spec ' + rpchost)

	rpcconnect = match.group(1)
	rpcport = match.group(2)

	if rpcconnect.startswith('['): # remove IPv6 [...] wrapping
	rpcconnect = rpcconnect[1:-1]

	rv = ['-rpcconnect=' + rpcconnect]
	if rpcport:
	rv += ['-rpcport=' + rpcport]
	return rv

	def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
	"""
	Start a bitcoind and return RPC connection to it
	"""
	datadir = os.path.join(dirname, "node"+str(i))
	if binary is None:
	binary = os.getenv("BITCOIND", "bitcoind")
	args = [ binary, "-datadir="+datadir, "-server", "-keypool=1", "-discover=0", "-rest", "-mocktime="+str(get_mocktime()) ]
	if extra_args is not None: args.extend(extra_args)
	bitcoind_processes[i] = subprocess.Popen(args)
	if os.getenv("PYTHON_DEBUG", ""):
	print("start_node: bitcoind started, waiting for RPC to come up")
	url = rpc_url(i, rpchost)
	wait_for_bitcoind_start(bitcoind_processes[i], url, i)
	if os.getenv("PYTHON_DEBUG", ""):
	print("start_node: RPC succesfully started")
	proxy = get_rpc_proxy(url, i, timeout=timewait)

	if COVERAGE_DIR:
	coverage.write_all_rpc_commands(COVERAGE_DIR, proxy)

	return proxy

	def start_nodes(num_nodes, dirname, extra_args=None, rpchost=None, binary=None):
	"""
	Start multiple bitcoinds, return RPC connections to them
	"""
	if extra_args is None: extra_args = [ None for _ in range(num_nodes) ]
	if binary is None: binary = [ None for _ in range(num_nodes) ]
	rpcs = []
	try:
	for i in range(num_nodes):
	rpcs.append(start_node(i, dirname, extra_args[i], rpchost, binary=binary[i]))
	except: # If one node failed to start, stop the others
	stop_nodes(rpcs)
	raise
	return rpcs

	def log_filename(dirname, n_node, logname):
	return os.path.join(dirname, "node"+str(n_node), "regtest", logname)

	def stop_node(node, i):
	try:
	node.stop()
	except http.client.CannotSendRequest as e:
	print("WARN: Unable to stop node: " + repr(e))
	bitcoind_processes[i].wait()
	del bitcoind_processes[i]

	def stop_nodes(nodes):
	for node in nodes:
	try:
	node.stop()
	except http.client.CannotSendRequest as e:
	print("WARN: Unable to stop node: " + repr(e))
	del nodes[:] # Emptying array closes connections as a side effect

	def set_node_times(nodes, t):
	for node in nodes:
	node.setmocktime(t)

	def wait_bitcoinds():
	# Wait for all bitcoinds to cleanly exit
	for bitcoind in bitcoind_processes.values():
	bitcoind.wait()
	bitcoind_processes.clear()

	def connect_nodes(from_connection, node_num):
	ip_port = "127.0.0.1:"+str(p2p_port(node_num))
	from_connection.addnode(ip_port, "onetry")
	# poll until version handshake complete to avoid race conditions
	# with transaction relaying
	while any(peer['version'] == 0 for peer in from_connection.getpeerinfo()):
	time.sleep(0.1)

	def connect_nodes_bi(nodes, a, b):
	connect_nodes(nodes[a], b)
	connect_nodes(nodes[b], a)

	def find_output(node, txid, amount):
	"""
	Return index to output of txid with value amount
	Raises exception if there is none.
	"""
	txdata = node.getrawtransaction(txid, 1)
	for i in range(len(txdata["vout"])):
	if txdata["vout"][i]["value"] == amount:
	return i
	raise RuntimeError("find_output txid %s : %s not found"%(txid,str(amount)))


	def gather_inputs(from_node, amount_needed, confirmations_required=1):
	"""
	Return a random set of unspent txouts that are enough to pay amount_needed
	"""
	assert(confirmations_required >=0)
	utxo = from_node.listunspent(confirmations_required)
	random.shuffle(utxo)
	inputs = []
	total_in = Decimal("0.00000000")
	while total_in < amount_needed and len(utxo) > 0:
	t = utxo.pop()
	total_in += t["amount"]
	inputs.append({ "txid" : t["txid"], "vout" : t["vout"], "address" : t["address"] } )
	if total_in < amount_needed:
	raise RuntimeError("Insufficient funds: need %d, have %d"%(amount_needed, total_in))
	return (total_in, inputs)

	def make_change(from_node, amount_in, amount_out, fee):
	"""
	Create change output(s), return them
	"""
	outputs = {}
	amount = amount_out+fee
	change = amount_in - amount
	if change > amount*2:
	# Create an extra change output to break up big inputs
	change_address = from_node.getnewaddress()
	# Split change in two, being careful of rounding:
	outputs[change_address] = Decimal(change/2).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
	change = amount_in - amount - outputs[change_address]
	if change > 0:
	outputs[from_node.getnewaddress()] = change
	return outputs

	def send_zeropri_transaction(from_node, to_node, amount, fee):
	"""
	Create&broadcast a zero-priority transaction.
	Returns (txid, hex-encoded-txdata)
	Ensures transaction is zero-priority by first creating a send-to-self,
	then using its output
	"""

	# Create a send-to-self with confirmed inputs:
	self_address = from_node.getnewaddress()
	(total_in, inputs) = gather_inputs(from_node, amount+fee*2)
	outputs = make_change(from_node, total_in, amount+fee, fee)
	outputs[self_address] = float(amount+fee)

	self_rawtx = from_node.createrawtransaction(inputs, outputs)
	self_signresult = from_node.signrawtransaction(self_rawtx)
	self_txid = from_node.sendrawtransaction(self_signresult["hex"], True)

	vout = find_output(from_node, self_txid, amount+fee)
	# Now immediately spend the output to create a 1-input, 1-output
	# zero-priority transaction:
	inputs = [ { "txid" : self_txid, "vout" : vout } ]
	outputs = { to_node.getnewaddress() : float(amount) }

	rawtx = from_node.createrawtransaction(inputs, outputs)
	signresult = from_node.signrawtransaction(rawtx)
	txid = from_node.sendrawtransaction(signresult["hex"], True)

	return (txid, signresult["hex"])

	def random_zeropri_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
	"""
	Create a random zero-priority transaction.
	Returns (txid, hex-encoded-transaction-data, fee)
	"""
	from_node = random.choice(nodes)
	to_node = random.choice(nodes)
	fee = min_fee + fee_increment*random.randint(0,fee_variants)
	(txid, txhex) = send_zeropri_transaction(from_node, to_node, amount, fee)
	return (txid, txhex, fee)

	def random_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
	"""
	Create a random transaction.
	Returns (txid, hex-encoded-transaction-data, fee)
	"""
	from_node = random.choice(nodes)
	to_node = random.choice(nodes)
	fee = min_fee + fee_increment*random.randint(0,fee_variants)

	(total_in, inputs) = gather_inputs(from_node, amount+fee)
	outputs = make_change(from_node, total_in, amount, fee)
	outputs[to_node.getnewaddress()] = float(amount)

	rawtx = from_node.createrawtransaction(inputs, outputs)
	signresult = from_node.signrawtransaction(rawtx)
	txid = from_node.sendrawtransaction(signresult["hex"], True)

	return (txid, signresult["hex"], fee)

	def assert_equal(thing1, thing2):
	if thing1 != thing2:
	raise AssertionError("%s != %s"%(str(thing1),str(thing2)))

	def assert_greater_than(thing1, thing2):
	if thing1 <= thing2:
	raise AssertionError("%s <= %s"%(str(thing1),str(thing2)))

	def assert_raises(exc, fun, args, *kwds):
	try:
	fun(args, *kwds)
	except exc:
	pass
	except Exception as e:
	raise AssertionError("Unexpected exception raised: "+type(e).__name__)
	else:
	raise AssertionError("No exception raised")

	def assert_is_hex_string(string):
	try:
	int(string, 16)
	except Exception as e:
	raise AssertionError(
	"Couldn't interpret %r as hexadecimal; raised: %s" % (string, e))

	def assert_is_hash_string(string, length=64):
	if not isinstance(string, str):
	raise AssertionError("Expected a string, got type %r" % type(string))
	elif length and len(string) != length:
	raise AssertionError(
	"String of length %d expected; got %d" % (length, len(string)))
	elif not re.match('[abcdef0-9]+$', string):
	raise AssertionError(
	"String %r contains invalid characters for a hash." % string)

	def assert_array_result(object_array, to_match, expected, should_not_find = False):
	"""
	Pass in array of JSON objects, a dictionary with key/value pairs
	to match against, and another dictionary with expected key/value
	pairs.
	If the should_not_find flag is true, to_match should not be found
	in object_array
	"""
	if should_not_find == True:
	assert_equal(expected, { })
	num_matched = 0
	for item in object_array:
	all_match = True
	for key,value in to_match.items():
	if item[key] != value:
	all_match = False
	if not all_match:
	continue
	elif should_not_find == True:
	num_matched = num_matched+1
	for key,value in expected.items():
	if item[key] != value:
	raise AssertionError("%s : expected %s=%s"%(str(item), str(key), str(value)))
	num_matched = num_matched+1
	if num_matched == 0 and should_not_find != True:
	raise AssertionError("No objects matched %s"%(str(to_match)))
	if num_matched > 0 and should_not_find == True:
	raise AssertionError("Objects were found %s"%(str(to_match)))

	def satoshi_round(amount):
	return Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)

	# Helper to create at least "count" utxos
	# Pass in a fee that is sufficient for relay and mining new transactions.
	def create_confirmed_utxos(fee, node, count):
	node.generate(int(0.5*count)+101)
	utxos = node.listunspent()
	iterations = count - len(utxos)
	addr1 = node.getnewaddress()
	addr2 = node.getnewaddress()
	if iterations <= 0:
	return utxos
	for i in range(iterations):
	t = utxos.pop()
	inputs = []
	inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
	outputs = {}
	send_value = t['amount'] - fee
	outputs[addr1] = satoshi_round(send_value/2)
	outputs[addr2] = satoshi_round(send_value/2)
	raw_tx = node.createrawtransaction(inputs, outputs)
	signed_tx = node.signrawtransaction(raw_tx)["hex"]
	txid = node.sendrawtransaction(signed_tx)

	while (node.getmempoolinfo()['size'] > 0):
	node.generate(1)

	utxos = node.listunspent()
	assert(len(utxos) >= count)
	return utxos

	# Create large OP_RETURN txouts that can be appended to a transaction
	# to make it large (helper for constructing large transactions).
	def gen_return_txouts():
	# Some pre-processing to create a bunch of OP_RETURN txouts to insert into transactions we create
	# So we have big transactions (and therefore can't fit very many into each block)
	# create one script_pubkey
	script_pubkey = "6a4d0200" #OP_RETURN OP_PUSH2 512 bytes
	for i in range (512):
	script_pubkey = script_pubkey + "01"
	# concatenate 128 txouts of above script_pubkey which we'll insert before the txout for change
	txouts = "81"
	for k in range(128):
	# add txout value
	txouts = txouts + "0000000000000000"
	# add length of script_pubkey
	txouts = txouts + "fd0402"
	# add script_pubkey
	txouts = txouts + script_pubkey
	return txouts

	def create_tx(node, coinbase, to_address, amount):
	inputs = [{ "txid" : coinbase, "vout" : 0}]
	outputs = { to_address : amount }
	rawtx = node.createrawtransaction(inputs, outputs)
	signresult = node.signrawtransaction(rawtx)
	assert_equal(signresult["complete"], True)
	return signresult["hex"]

	# Create a spend of each passed-in utxo, splicing in "txouts" to each raw
	# transaction to make it large. See gen_return_txouts() above.
	def create_lots_of_big_transactions(node, txouts, utxos, fee):
	addr = node.getnewaddress()
	txids = []
	for i in range(len(utxos)):
	t = utxos.pop()
	inputs = []
	inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
	outputs = {}
	send_value = t['amount'] - fee
	outputs[addr] = satoshi_round(send_value)
	rawtx = node.createrawtransaction(inputs, outputs)
	newtx = rawtx[0:92]
	newtx = newtx + txouts
	newtx = newtx + rawtx[94:]
	signresult = node.signrawtransaction(newtx, None, None, "NONE")
	txid = node.sendrawtransaction(signresult["hex"], True)
	txids.append(txid)
	return txids

	def get_bip9_status(node, key):
	info = node.getblockchaininfo()
	return info['bip9_softforks'][key]
	diff --git a/qa/rpc-tests/txn_clone.py b/qa/rpc-tests/txn_clone.py
	index 5710c29aa6..22f850ece6 100755
	--- a/qa/rpc-tests/txn_clone.py
	+++ b/qa/rpc-tests/txn_clone.py
	@@ -1,154 +1,159 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test proper accounting with an equivalent malleability clone
	#

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

	class TxnMallTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 4
	+ self.setup_clean_chain = False
	+
	def add_options(self, parser):
	parser.add_option("--mineblock", dest="mine_block", default=False, action="store_true",
	help="Test double-spend of 1-confirmed transaction")

	def setup_network(self):
	# Start with split network:
	return super(TxnMallTest, self).setup_network(True)

	def run_test(self):
	# All nodes should start with 1,250 BTC:
	starting_balance = 1250
	for i in range(4):
	assert_equal(self.nodes[i].getbalance(), starting_balance)
	self.nodes[i].getnewaddress("") # bug workaround, coins generated assigned to first getnewaddress!

	# Assign coins to foo and bar accounts:
	self.nodes[0].settxfee(.001)

	node0_address_foo = self.nodes[0].getnewaddress("foo")
	fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 1219)
	fund_foo_tx = self.nodes[0].gettransaction(fund_foo_txid)

	node0_address_bar = self.nodes[0].getnewaddress("bar")
	fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 29)
	fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid)

	assert_equal(self.nodes[0].getbalance(""),
	starting_balance - 1219 - 29 + fund_foo_tx["fee"] + fund_bar_tx["fee"])

	# Coins are sent to node1_address
	node1_address = self.nodes[1].getnewaddress("from0")

	# Send tx1, and another transaction tx2 that won't be cloned
	txid1 = self.nodes[0].sendfrom("foo", node1_address, 40, 0)
	txid2 = self.nodes[0].sendfrom("bar", node1_address, 20, 0)

	# Construct a clone of tx1, to be malleated
	rawtx1 = self.nodes[0].getrawtransaction(txid1,1)
	clone_inputs = [{"txid":rawtx1["vin"][0]["txid"],"vout":rawtx1["vin"][0]["vout"]}]
	clone_outputs = {rawtx1["vout"][0]["scriptPubKey"]["addresses"][0]:rawtx1["vout"][0]["value"],
	rawtx1["vout"][1]["scriptPubKey"]["addresses"][0]:rawtx1["vout"][1]["value"]}
	clone_locktime = rawtx1["locktime"]
	clone_raw = self.nodes[0].createrawtransaction(clone_inputs, clone_outputs, clone_locktime)

	# createrawtransaction randomizes the order of its outputs, so swap them if necessary.
	# output 0 is at version+#inputs+input+sigstub+sequence+#outputs
	# 40 BTC serialized is 00286bee00000000
	pos0 = 2*(4+1+36+1+4+1)
	hex40 = "00286bee00000000"
	output_len = 16 + 2 + 2 * int("0x" + clone_raw[pos0 + 16 : pos0 + 16 + 2], 0)
	if (rawtx1["vout"][0]["value"] == 40 and clone_raw[pos0 : pos0 + 16] != hex40 or
	rawtx1["vout"][0]["value"] != 40 and clone_raw[pos0 : pos0 + 16] == hex40):
	output0 = clone_raw[pos0 : pos0 + output_len]
	output1 = clone_raw[pos0 + output_len : pos0 + 2 * output_len]
	clone_raw = clone_raw[:pos0] + output1 + output0 + clone_raw[pos0 + 2 * output_len:]

	# Use a different signature hash type to sign. This creates an equivalent but malleated clone.
	# Don't send the clone anywhere yet
	tx1_clone = self.nodes[0].signrawtransaction(clone_raw, None, None, "ALL\|ANYONECANPAY")
	assert_equal(tx1_clone["complete"], True)

	# Have node0 mine a block, if requested:
	if (self.options.mine_block):
	self.nodes[0].generate(1)
	sync_blocks(self.nodes[0:2])

	tx1 = self.nodes[0].gettransaction(txid1)
	tx2 = self.nodes[0].gettransaction(txid2)

	# Node0's balance should be starting balance, plus 50BTC for another
	# matured block, minus tx1 and tx2 amounts, and minus transaction fees:
	expected = starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"]
	if self.options.mine_block: expected += 50
	expected += tx1["amount"] + tx1["fee"]
	expected += tx2["amount"] + tx2["fee"]
	assert_equal(self.nodes[0].getbalance(), expected)

	# foo and bar accounts should be debited:
	assert_equal(self.nodes[0].getbalance("foo", 0), 1219 + tx1["amount"] + tx1["fee"])
	assert_equal(self.nodes[0].getbalance("bar", 0), 29 + tx2["amount"] + tx2["fee"])

	if self.options.mine_block:
	assert_equal(tx1["confirmations"], 1)
	assert_equal(tx2["confirmations"], 1)
	# Node1's "from0" balance should be both transaction amounts:
	assert_equal(self.nodes[1].getbalance("from0"), -(tx1["amount"] + tx2["amount"]))
	else:
	assert_equal(tx1["confirmations"], 0)
	assert_equal(tx2["confirmations"], 0)

	# Send clone and its parent to miner
	self.nodes[2].sendrawtransaction(fund_foo_tx["hex"])
	txid1_clone = self.nodes[2].sendrawtransaction(tx1_clone["hex"])
	# ... mine a block...
	self.nodes[2].generate(1)

	# Reconnect the split network, and sync chain:
	connect_nodes(self.nodes[1], 2)
	self.nodes[2].sendrawtransaction(fund_bar_tx["hex"])
	self.nodes[2].sendrawtransaction(tx2["hex"])
	self.nodes[2].generate(1) # Mine another block to make sure we sync
	sync_blocks(self.nodes)

	# Re-fetch transaction info:
	tx1 = self.nodes[0].gettransaction(txid1)
	tx1_clone = self.nodes[0].gettransaction(txid1_clone)
	tx2 = self.nodes[0].gettransaction(txid2)

	# Verify expected confirmations
	assert_equal(tx1["confirmations"], -2)
	assert_equal(tx1_clone["confirmations"], 2)
	assert_equal(tx2["confirmations"], 1)

	# Check node0's total balance; should be same as before the clone, + 100 BTC for 2 matured,
	# less possible orphaned matured subsidy
	expected += 100
	if (self.options.mine_block):
	expected -= 50
	assert_equal(self.nodes[0].getbalance(), expected)
	assert_equal(self.nodes[0].getbalance("*", 0), expected)

	# Check node0's individual account balances.
	# "foo" should have been debited by the equivalent clone of tx1
	assert_equal(self.nodes[0].getbalance("foo"), 1219 + tx1["amount"] + tx1["fee"])
	# "bar" should have been debited by (possibly unconfirmed) tx2
	assert_equal(self.nodes[0].getbalance("bar", 0), 29 + tx2["amount"] + tx2["fee"])
	# "" should have starting balance, less funding txes, plus subsidies
	assert_equal(self.nodes[0].getbalance("", 0), starting_balance
	- 1219
	+ fund_foo_tx["fee"]
	- 29
	+ fund_bar_tx["fee"]
	+ 100)

	# Node1's "from0" account balance
	assert_equal(self.nodes[1].getbalance("from0", 0), -(tx1["amount"] + tx2["amount"]))

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

	diff --git a/qa/rpc-tests/txn_doublespend.py b/qa/rpc-tests/txn_doublespend.py
	index 1fbb207e22..84944c3c19 100755
	--- a/qa/rpc-tests/txn_doublespend.py
	+++ b/qa/rpc-tests/txn_doublespend.py
	@@ -1,142 +1,147 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test proper accounting with a double-spend conflict
	#

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

	class TxnMallTest(BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 4
	+ self.setup_clean_chain = False
	+
	def add_options(self, parser):
	parser.add_option("--mineblock", dest="mine_block", default=False, action="store_true",
	help="Test double-spend of 1-confirmed transaction")

	def setup_network(self):
	# Start with split network:
	return super(TxnMallTest, self).setup_network(True)

	def run_test(self):
	# All nodes should start with 1,250 BTC:
	starting_balance = 1250
	for i in range(4):
	assert_equal(self.nodes[i].getbalance(), starting_balance)
	self.nodes[i].getnewaddress("") # bug workaround, coins generated assigned to first getnewaddress!

	# Assign coins to foo and bar accounts:
	node0_address_foo = self.nodes[0].getnewaddress("foo")
	fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 1219)
	fund_foo_tx = self.nodes[0].gettransaction(fund_foo_txid)

	node0_address_bar = self.nodes[0].getnewaddress("bar")
	fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 29)
	fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid)

	assert_equal(self.nodes[0].getbalance(""),
	starting_balance - 1219 - 29 + fund_foo_tx["fee"] + fund_bar_tx["fee"])

	# Coins are sent to node1_address
	node1_address = self.nodes[1].getnewaddress("from0")

	# First: use raw transaction API to send 1240 BTC to node1_address,
	# but don't broadcast:
	doublespend_fee = Decimal('-.02')
	rawtx_input_0 = {}
	rawtx_input_0["txid"] = fund_foo_txid
	rawtx_input_0["vout"] = find_output(self.nodes[0], fund_foo_txid, 1219)
	rawtx_input_1 = {}
	rawtx_input_1["txid"] = fund_bar_txid
	rawtx_input_1["vout"] = find_output(self.nodes[0], fund_bar_txid, 29)
	inputs = [rawtx_input_0, rawtx_input_1]
	change_address = self.nodes[0].getnewaddress()
	outputs = {}
	outputs[node1_address] = 1240
	outputs[change_address] = 1248 - 1240 + doublespend_fee
	rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
	doublespend = self.nodes[0].signrawtransaction(rawtx)
	assert_equal(doublespend["complete"], True)

	# Create two spends using 1 50 BTC coin each
	txid1 = self.nodes[0].sendfrom("foo", node1_address, 40, 0)
	txid2 = self.nodes[0].sendfrom("bar", node1_address, 20, 0)

	# Have node0 mine a block:
	if (self.options.mine_block):
	self.nodes[0].generate(1)
	sync_blocks(self.nodes[0:2])

	tx1 = self.nodes[0].gettransaction(txid1)
	tx2 = self.nodes[0].gettransaction(txid2)

	# Node0's balance should be starting balance, plus 50BTC for another
	# matured block, minus 40, minus 20, and minus transaction fees:
	expected = starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"]
	if self.options.mine_block: expected += 50
	expected += tx1["amount"] + tx1["fee"]
	expected += tx2["amount"] + tx2["fee"]
	assert_equal(self.nodes[0].getbalance(), expected)

	# foo and bar accounts should be debited:
	assert_equal(self.nodes[0].getbalance("foo", 0), 1219+tx1["amount"]+tx1["fee"])
	assert_equal(self.nodes[0].getbalance("bar", 0), 29+tx2["amount"]+tx2["fee"])

	if self.options.mine_block:
	assert_equal(tx1["confirmations"], 1)
	assert_equal(tx2["confirmations"], 1)
	# Node1's "from0" balance should be both transaction amounts:
	assert_equal(self.nodes[1].getbalance("from0"), -(tx1["amount"]+tx2["amount"]))
	else:
	assert_equal(tx1["confirmations"], 0)
	assert_equal(tx2["confirmations"], 0)

	# Now give doublespend and its parents to miner:
	self.nodes[2].sendrawtransaction(fund_foo_tx["hex"])
	self.nodes[2].sendrawtransaction(fund_bar_tx["hex"])
	doublespend_txid = self.nodes[2].sendrawtransaction(doublespend["hex"])
	# ... mine a block...
	self.nodes[2].generate(1)

	# Reconnect the split network, and sync chain:
	connect_nodes(self.nodes[1], 2)
	self.nodes[2].generate(1) # Mine another block to make sure we sync
	sync_blocks(self.nodes)
	assert_equal(self.nodes[0].gettransaction(doublespend_txid)["confirmations"], 2)

	# Re-fetch transaction info:
	tx1 = self.nodes[0].gettransaction(txid1)
	tx2 = self.nodes[0].gettransaction(txid2)

	# Both transactions should be conflicted
	assert_equal(tx1["confirmations"], -2)
	assert_equal(tx2["confirmations"], -2)

	# Node0's total balance should be starting balance, plus 100BTC for
	# two more matured blocks, minus 1240 for the double-spend, plus fees (which are
	# negative):
	expected = starting_balance + 100 - 1240 + fund_foo_tx["fee"] + fund_bar_tx["fee"] + doublespend_fee
	assert_equal(self.nodes[0].getbalance(), expected)
	assert_equal(self.nodes[0].getbalance("*"), expected)

	# Final "" balance is starting_balance - amount moved to accounts - doublespend + subsidies +
	# fees (which are negative)
	assert_equal(self.nodes[0].getbalance("foo"), 1219)
	assert_equal(self.nodes[0].getbalance("bar"), 29)
	assert_equal(self.nodes[0].getbalance(""), starting_balance
	-1219
	- 29
	-1240
	+ 100
	+ fund_foo_tx["fee"]
	+ fund_bar_tx["fee"]
	+ doublespend_fee)

	# Node1's "from0" account balance should be just the doublespend:
	assert_equal(self.nodes[1].getbalance("from0"), 1240)

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

	diff --git a/qa/rpc-tests/wallet.py b/qa/rpc-tests/wallet.py
	index 42ce0a7260..2d24ced97c 100755
	--- a/qa/rpc-tests/wallet.py
	+++ b/qa/rpc-tests/wallet.py
	@@ -1,341 +1,342 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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

	class WalletTest (BitcoinTestFramework):

	def check_fee_amount(self, curr_balance, balance_with_fee, fee_per_byte, tx_size):
	"""Return curr_balance after asserting the fee was in range"""
	fee = balance_with_fee - curr_balance
	target_fee = fee_per_byte * tx_size
	if fee < target_fee:
	raise AssertionError("Fee of %s BTC too low! (Should be %s BTC)"%(str(fee), str(target_fee)))
	# allow the node's estimation to be at most 2 bytes off
	if fee > fee_per_byte * (tx_size + 2):
	raise AssertionError("Fee of %s BTC too high! (Should be %s BTC)"%(str(fee), str(target_fee)))
	return curr_balance

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 4)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 4

	def setup_network(self, split=False):
	self.nodes = start_nodes(3, 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
	self.sync_all()

	def run_test (self):

	# Check that there's no UTXO on none of the nodes
	assert_equal(len(self.nodes[0].listunspent()), 0)
	assert_equal(len(self.nodes[1].listunspent()), 0)
	assert_equal(len(self.nodes[2].listunspent()), 0)

	print("Mining blocks...")

	self.nodes[0].generate(1)

	walletinfo = self.nodes[0].getwalletinfo()
	assert_equal(walletinfo['immature_balance'], 50)
	assert_equal(walletinfo['balance'], 0)

	self.sync_all()
	self.nodes[1].generate(101)
	self.sync_all()

	assert_equal(self.nodes[0].getbalance(), 50)
	assert_equal(self.nodes[1].getbalance(), 50)
	assert_equal(self.nodes[2].getbalance(), 0)

	# Check that only first and second nodes have UTXOs
	assert_equal(len(self.nodes[0].listunspent()), 1)
	assert_equal(len(self.nodes[1].listunspent()), 1)
	assert_equal(len(self.nodes[2].listunspent()), 0)

	# Send 21 BTC from 0 to 2 using sendtoaddress call.
	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
	self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)

	walletinfo = self.nodes[0].getwalletinfo()
	assert_equal(walletinfo['immature_balance'], 0)

	# Have node0 mine a block, thus it will collect its own fee.
	self.nodes[0].generate(1)
	self.sync_all()

	# Exercise locking of unspent outputs
	unspent_0 = self.nodes[2].listunspent()[0]
	unspent_0 = {"txid": unspent_0["txid"], "vout": unspent_0["vout"]}
	self.nodes[2].lockunspent(False, [unspent_0])
	assert_raises(JSONRPCException, self.nodes[2].sendtoaddress, self.nodes[2].getnewaddress(), 20)
	assert_equal([unspent_0], self.nodes[2].listlockunspent())
	self.nodes[2].lockunspent(True, [unspent_0])
	assert_equal(len(self.nodes[2].listlockunspent()), 0)

	# Have node1 generate 100 blocks (so node0 can recover the fee)
	self.nodes[1].generate(100)
	self.sync_all()

	# node0 should end up with 100 btc in block rewards plus fees, but
	# minus the 21 plus fees sent to node2
	assert_equal(self.nodes[0].getbalance(), 100-21)
	assert_equal(self.nodes[2].getbalance(), 21)

	# Node0 should have two unspent outputs.
	# Create a couple of transactions to send them to node2, submit them through
	# node1, and make sure both node0 and node2 pick them up properly:
	node0utxos = self.nodes[0].listunspent(1)
	assert_equal(len(node0utxos), 2)

	# create both transactions
	txns_to_send = []
	for utxo in node0utxos:
	inputs = []
	outputs = {}
	inputs.append({ "txid" : utxo["txid"], "vout" : utxo["vout"]})
	outputs[self.nodes[2].getnewaddress("from1")] = utxo["amount"] - 3
	raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
	txns_to_send.append(self.nodes[0].signrawtransaction(raw_tx))

	# Have node 1 (miner) send the transactions
	self.nodes[1].sendrawtransaction(txns_to_send[0]["hex"], True)
	self.nodes[1].sendrawtransaction(txns_to_send[1]["hex"], True)

	# Have node1 mine a block to confirm transactions:
	self.nodes[1].generate(1)
	self.sync_all()

	assert_equal(self.nodes[0].getbalance(), 0)
	assert_equal(self.nodes[2].getbalance(), 94)
	assert_equal(self.nodes[2].getbalance("from1"), 94-21)

	# Send 10 BTC normal
	address = self.nodes[0].getnewaddress("test")
	fee_per_byte = Decimal('0.001') / 1000
	self.nodes[2].settxfee(fee_per_byte * 1000)
	txid = self.nodes[2].sendtoaddress(address, 10, "", "", False)
	self.nodes[2].generate(1)
	self.sync_all()
	node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), Decimal('84'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
	assert_equal(self.nodes[0].getbalance(), Decimal('10'))

	# Send 10 BTC with subtract fee from amount
	txid = self.nodes[2].sendtoaddress(address, 10, "", "", True)
	self.nodes[2].generate(1)
	self.sync_all()
	node_2_bal -= Decimal('10')
	assert_equal(self.nodes[2].getbalance(), node_2_bal)
	node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))

	# Sendmany 10 BTC
	txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [])
	self.nodes[2].generate(1)
	self.sync_all()
	node_0_bal += Decimal('10')
	node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal('10'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
	assert_equal(self.nodes[0].getbalance(), node_0_bal)

	# Sendmany 10 BTC with subtract fee from amount
	txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [address])
	self.nodes[2].generate(1)
	self.sync_all()
	node_2_bal -= Decimal('10')
	assert_equal(self.nodes[2].getbalance(), node_2_bal)
	node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal('10'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))

	# Test ResendWalletTransactions:
	# Create a couple of transactions, then start up a fourth
	# node (nodes[3]) and ask nodes[0] to rebroadcast.
	# EXPECT: nodes[3] should have those transactions in its mempool.
	txid1 = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
	txid2 = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1)
	sync_mempools(self.nodes)

	self.nodes.append(start_node(3, self.options.tmpdir))
	connect_nodes_bi(self.nodes, 0, 3)
	sync_blocks(self.nodes)

	relayed = self.nodes[0].resendwallettransactions()
	assert_equal(set(relayed), {txid1, txid2})
	sync_mempools(self.nodes)

	assert(txid1 in self.nodes[3].getrawmempool())

	# Exercise balance rpcs
	assert_equal(self.nodes[0].getwalletinfo()["unconfirmed_balance"], 1)
	assert_equal(self.nodes[0].getunconfirmedbalance(), 1)

	#check if we can list zero value tx as available coins
	#1. create rawtx
	#2. hex-changed one output to 0.0
	#3. sign and send
	#4. check if recipient (node0) can list the zero value tx
	usp = self.nodes[1].listunspent()
	inputs = [{"txid":usp[0]['txid'], "vout":usp[0]['vout']}]
	outputs = {self.nodes[1].getnewaddress(): 49.998, self.nodes[0].getnewaddress(): 11.11}

	rawTx = self.nodes[1].createrawtransaction(inputs, outputs).replace("c0833842", "00000000") #replace 11.11 with 0.0 (int32)
	decRawTx = self.nodes[1].decoderawtransaction(rawTx)
	signedRawTx = self.nodes[1].signrawtransaction(rawTx)
	decRawTx = self.nodes[1].decoderawtransaction(signedRawTx['hex'])
	zeroValueTxid= decRawTx['txid']
	sendResp = self.nodes[1].sendrawtransaction(signedRawTx['hex'])

	self.sync_all()
	self.nodes[1].generate(1) #mine a block
	self.sync_all()

	unspentTxs = self.nodes[0].listunspent() #zero value tx must be in listunspents output
	found = False
	for uTx in unspentTxs:
	if uTx['txid'] == zeroValueTxid:
	found = True
	assert_equal(uTx['amount'], Decimal('0'))
	assert(found)

	#do some -walletbroadcast tests
	stop_nodes(self.nodes)
	wait_bitcoinds()
	self.nodes = start_nodes(3, self.options.tmpdir, [["-walletbroadcast=0"],["-walletbroadcast=0"],["-walletbroadcast=0"]])
	connect_nodes_bi(self.nodes,0,1)
	connect_nodes_bi(self.nodes,1,2)
	connect_nodes_bi(self.nodes,0,2)
	self.sync_all()

	txIdNotBroadcasted = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)
	txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
	self.nodes[1].generate(1) #mine a block, tx should not be in there
	self.sync_all()
	assert_equal(self.nodes[2].getbalance(), node_2_bal) #should not be changed because tx was not broadcasted

	#now broadcast from another node, mine a block, sync, and check the balance
	self.nodes[1].sendrawtransaction(txObjNotBroadcasted['hex'])
	self.nodes[1].generate(1)
	self.sync_all()
	node_2_bal += 2
	txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
	assert_equal(self.nodes[2].getbalance(), node_2_bal)

	#create another tx
	txIdNotBroadcasted = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)

	#restart the nodes with -walletbroadcast=1
	stop_nodes(self.nodes)
	wait_bitcoinds()
	self.nodes = start_nodes(3, self.options.tmpdir)
	connect_nodes_bi(self.nodes,0,1)
	connect_nodes_bi(self.nodes,1,2)
	connect_nodes_bi(self.nodes,0,2)
	sync_blocks(self.nodes)

	self.nodes[0].generate(1)
	sync_blocks(self.nodes)
	node_2_bal += 2

	#tx should be added to balance because after restarting the nodes tx should be broadcastet
	assert_equal(self.nodes[2].getbalance(), node_2_bal)

	#send a tx with value in a string (PR#6380 +)
	txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "2")
	txObj = self.nodes[0].gettransaction(txId)
	assert_equal(txObj['amount'], Decimal('-2'))

	txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "0.0001")
	txObj = self.nodes[0].gettransaction(txId)
	assert_equal(txObj['amount'], Decimal('-0.0001'))

	#check if JSON parser can handle scientific notation in strings
	txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1e-4")
	txObj = self.nodes[0].gettransaction(txId)
	assert_equal(txObj['amount'], Decimal('-0.0001'))

	try:
	txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1f-4")
	except JSONRPCException as e:
	assert("Invalid amount" in e.error['message'])
	else:
	raise AssertionError("Must not parse invalid amounts")


	try:
	self.nodes[0].generate("2")
	raise AssertionError("Must not accept strings as numeric")
	except JSONRPCException as e:
	assert("not an integer" in e.error['message'])

	# Import address and private key to check correct behavior of spendable unspents
	# 1. Send some coins to generate new UTXO
	address_to_import = self.nodes[2].getnewaddress()
	txid = self.nodes[0].sendtoaddress(address_to_import, 1)
	self.nodes[0].generate(1)
	self.sync_all()

	# 2. Import address from node2 to node1
	self.nodes[1].importaddress(address_to_import)

	# 3. Validate that the imported address is watch-only on node1
	assert(self.nodes[1].validateaddress(address_to_import)["iswatchonly"])

	# 4. Check that the unspents after import are not spendable
	assert_array_result(self.nodes[1].listunspent(),
	{"address": address_to_import},
	{"spendable": False})

	# 5. Import private key of the previously imported address on node1
	priv_key = self.nodes[2].dumpprivkey(address_to_import)
	self.nodes[1].importprivkey(priv_key)

	# 6. Check that the unspents are now spendable on node1
	assert_array_result(self.nodes[1].listunspent(),
	{"address": address_to_import},
	{"spendable": True})

	# Mine a block from node0 to an address from node1
	cbAddr = self.nodes[1].getnewaddress()
	blkHash = self.nodes[0].generatetoaddress(1, cbAddr)[0]
	cbTxId = self.nodes[0].getblock(blkHash)['tx'][0]
	self.sync_all()

	# Check that the txid and balance is found by node1
	self.nodes[1].gettransaction(cbTxId)

	#check if wallet or blochchain maintenance changes the balance
	self.sync_all()
	blocks = self.nodes[0].generate(2)
	self.sync_all()
	balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
	block_count = self.nodes[0].getblockcount()

	maintenance = [
	'-rescan',
	'-reindex',
	'-zapwallettxes=1',
	'-zapwallettxes=2',
	'-salvagewallet',
	]
	for m in maintenance:
	print("check " + m)
	stop_nodes(self.nodes)
	wait_bitcoinds()
	self.nodes = start_nodes(3, self.options.tmpdir, [[m]] * 3)
	while m == '-reindex' and [block_count] * 3 != [self.nodes[i].getblockcount() for i in range(3)]:
	# reindex will leave rpc warm up "early"; Wait for it to finish
	time.sleep(0.1)
	assert_equal(balance_nodes, [self.nodes[i].getbalance() for i in range(3)])

	# Exercise listsinceblock with the last two blocks
	coinbase_tx_1 = self.nodes[0].listsinceblock(blocks[0])
	assert_equal(coinbase_tx_1["lastblock"], blocks[1])
	assert_equal(len(coinbase_tx_1["transactions"]), 1)
	assert_equal(coinbase_tx_1["transactions"][0]["blockhash"], blocks[1])
	assert_equal(len(self.nodes[0].listsinceblock(blocks[1])["transactions"]), 0)

	if __name__ == '__main__':
	WalletTest ().main ()
	diff --git a/qa/rpc-tests/walletbackup.py b/qa/rpc-tests/walletbackup.py
	index c3d53669c9..b991d5c761 100755
	--- a/qa/rpc-tests/walletbackup.py
	+++ b/qa/rpc-tests/walletbackup.py
	@@ -1,200 +1,201 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	"""
	Exercise the wallet backup code. Ported from walletbackup.sh.

	Test case is:
	4 nodes. 1 2 and 3 send transactions between each other,
	fourth node is a miner.
	1 2 3 each mine a block to start, then
	Miner creates 100 blocks so 1 2 3 each have 50 mature
	coins to spend.
	Then 5 iterations of 1/2/3 sending coins amongst
	themselves to get transactions in the wallets,
	and the miner mining one block.

	Wallets are backed up using dumpwallet/backupwallet.
	Then 5 more iterations of transactions and mining a block.

	Miner then generates 101 more blocks, so any
	transaction fees paid mature.

	Sanity check:
	Sum(1,2,3,4 balances) == 114*50

	1/2/3 are shutdown, and their wallets erased.
	Then restore using wallet.dat backup. And
	confirm 1/2/3/4 balances are same as before.

	Shutdown again, restore using importwallet,
	and confirm again balances are correct.
	"""

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	from random import randint
	import logging
	logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO, stream=sys.stdout)

	class WalletBackupTest(BitcoinTestFramework):

	- def setup_chain(self):
	- logging.info("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 4)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 4

	# This mirrors how the network was setup in the bash test
	def setup_network(self, split=False):
	# nodes 1, 2,3 are spenders, let's give them a keypool=100
	extra_args = [["-keypool=100"], ["-keypool=100"], ["-keypool=100"], []]
	- self.nodes = start_nodes(4, self.options.tmpdir, extra_args)
	+ self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, 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.sync_all()

	def one_send(self, from_node, to_address):
	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):
	a0 = self.nodes[0].getnewaddress()
	a1 = self.nodes[1].getnewaddress()
	a2 = self.nodes[2].getnewaddress()

	self.one_send(0, a1)
	self.one_send(0, a2)
	self.one_send(1, a0)
	self.one_send(1, a2)
	self.one_send(2, a0)
	self.one_send(2, a1)

	# Have the miner (node3) mine a block.
	# Must sync mempools before mining.
	sync_mempools(self.nodes)
	self.nodes[3].generate(1)

	# As above, this mirrors the original bash test.
	def start_three(self):
	self.nodes[0] = start_node(0, self.options.tmpdir)
	self.nodes[1] = start_node(1, self.options.tmpdir)
	self.nodes[2] = start_node(2, self.options.tmpdir)
	connect_nodes(self.nodes[0], 3)
	connect_nodes(self.nodes[1], 3)
	connect_nodes(self.nodes[2], 3)
	connect_nodes(self.nodes[2], 0)

	def stop_three(self):
	stop_node(self.nodes[0], 0)
	stop_node(self.nodes[1], 1)
	stop_node(self.nodes[2], 2)

	def erase_three(self):
	os.remove(self.options.tmpdir + "/node0/regtest/wallet.dat")
	os.remove(self.options.tmpdir + "/node1/regtest/wallet.dat")
	os.remove(self.options.tmpdir + "/node2/regtest/wallet.dat")

	def run_test(self):
	logging.info("Generating initial blockchain")
	self.nodes[0].generate(1)
	sync_blocks(self.nodes)
	self.nodes[1].generate(1)
	sync_blocks(self.nodes)
	self.nodes[2].generate(1)
	sync_blocks(self.nodes)
	self.nodes[3].generate(100)
	sync_blocks(self.nodes)

	assert_equal(self.nodes[0].getbalance(), 50)
	assert_equal(self.nodes[1].getbalance(), 50)
	assert_equal(self.nodes[2].getbalance(), 50)
	assert_equal(self.nodes[3].getbalance(), 0)

	logging.info("Creating transactions")
	# Five rounds of sending each other transactions.
	for i in range(5):
	self.do_one_round()

	logging.info("Backing up")
	tmpdir = self.options.tmpdir
	self.nodes[0].backupwallet(tmpdir + "/node0/wallet.bak")
	self.nodes[0].dumpwallet(tmpdir + "/node0/wallet.dump")
	self.nodes[1].backupwallet(tmpdir + "/node1/wallet.bak")
	self.nodes[1].dumpwallet(tmpdir + "/node1/wallet.dump")
	self.nodes[2].backupwallet(tmpdir + "/node2/wallet.bak")
	self.nodes[2].dumpwallet(tmpdir + "/node2/wallet.dump")

	logging.info("More transactions")
	for i in range(5):
	self.do_one_round()

	# Generate 101 more blocks, so any fees paid mature
	self.nodes[3].generate(101)
	self.sync_all()

	balance0 = self.nodes[0].getbalance()
	balance1 = self.nodes[1].getbalance()
	balance2 = self.nodes[2].getbalance()
	balance3 = self.nodes[3].getbalance()
	total = balance0 + balance1 + balance2 + balance3

	# At this point, there are 214 blocks (103 for setup, then 10 rounds, then 101.)
	# 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()

	# Start node2 with no chain
	shutil.rmtree(self.options.tmpdir + "/node2/regtest/blocks")
	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")

	logging.info("Re-starting nodes")
	self.start_three()
	sync_blocks(self.nodes)

	assert_equal(self.nodes[0].getbalance(), balance0)
	assert_equal(self.nodes[1].getbalance(), balance1)
	assert_equal(self.nodes[2].getbalance(), balance2)

	logging.info("Restoring using dumped wallet")
	self.stop_three()
	self.erase_three()

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

	self.start_three()

	assert_equal(self.nodes[0].getbalance(), 0)
	assert_equal(self.nodes[1].getbalance(), 0)
	assert_equal(self.nodes[2].getbalance(), 0)

	self.nodes[0].importwallet(tmpdir + "/node0/wallet.dump")
	self.nodes[1].importwallet(tmpdir + "/node1/wallet.dump")
	self.nodes[2].importwallet(tmpdir + "/node2/wallet.dump")

	sync_blocks(self.nodes)

	assert_equal(self.nodes[0].getbalance(), balance0)
	assert_equal(self.nodes[1].getbalance(), balance1)
	assert_equal(self.nodes[2].getbalance(), balance2)


	if __name__ == '__main__':
	WalletBackupTest().main()
	diff --git a/qa/rpc-tests/zapwallettxes.py b/qa/rpc-tests/zapwallettxes.py
	index 2f8214f87c..17ba53a844 100755
	--- a/qa/rpc-tests/zapwallettxes.py
	+++ b/qa/rpc-tests/zapwallettxes.py
	@@ -1,76 +1,77 @@
	#!/usr/bin/env python3
	# Copyright (c) 2014-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

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


	class ZapWalletTXesTest (BitcoinTestFramework):

	- def setup_chain(self):
	- print("Initializing test directory "+self.options.tmpdir)
	- initialize_chain_clean(self.options.tmpdir, 3)
	+ def __init__(self):
	+ super().__init__()
	+ self.setup_clean_chain = True
	+ self.num_nodes = 3

	def setup_network(self, split=False):
	- self.nodes = start_nodes(3, self.options.tmpdir)
	+ 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
	self.sync_all()

	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)

	tx1 = self.nodes[0].gettransaction(txid1)
	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)

	tx3 = self.nodes[0].gettransaction(txid3)
	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)

	tx3 = self.nodes[0].gettransaction(txid3)
	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"])

	assert_raises(JSONRPCException, self.nodes[0].gettransaction, [txid3])
	#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


	if __name__ == '__main__':
	ZapWalletTXesTest ().main ()
	diff --git a/qa/rpc-tests/zmq_test.py b/qa/rpc-tests/zmq_test.py
	index f5617a084d..3a116317fe 100755
	--- a/qa/rpc-tests/zmq_test.py
	+++ b/qa/rpc-tests/zmq_test.py
	@@ -1,96 +1,100 @@
	#!/usr/bin/env python3
	# Copyright (c) 2015-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#
	# Test ZMQ interface
	#

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import *
	import zmq
	import struct

	import http.client
	import urllib.parse

	class ZMQTest (BitcoinTestFramework):

	+ def __init__(self):
	+ super().__init__()
	+ self.num_nodes = 4
	+
	port = 28332

	def setup_nodes(self):
	self.zmqContext = zmq.Context()
	self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)
	self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashblock")
	self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashtx")
	self.zmqSubSocket.connect("tcp://127.0.0.1:%i" % self.port)
	- return start_nodes(4, self.options.tmpdir, extra_args=[
	+ 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)],
	[],
	[],
	[]
	])

	def run_test(self):
	self.sync_all()

	genhashes = self.nodes[0].generate(1)
	self.sync_all()

	print("listen...")
	msg = self.zmqSubSocket.recv_multipart()
	topic = msg[0]
	assert_equal(topic, b"hashtx")
	body = msg[1]
	nseq = msg[2]
	msgSequence = struct.unpack('<I', msg[-1])[-1]
	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
	blkhash = bytes_to_hex_str(body)

	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)
	self.sync_all()

	zmqHashes = []
	blockcount = 0
	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)
	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

	#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
	msg = self.zmqSubSocket.recv_multipart()
	topic = msg[0]
	body = msg[1]
	hashZMQ = ""
	if topic == b"hashtx":
	hashZMQ = bytes_to_hex_str(body)
	msgSequence = struct.unpack('<I', msg[-1])[-1]
	assert_equal(msgSequence, blockcount+1)

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


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

File Metadata

Mime Type: text/x-diff
Expires: Thu, May 22, 03:53 (15 h, 25 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5866417
Default Alt Text: (478 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions