No OneTemporary
Actions

Size

71 KB

Subscribers

None

View Options

	diff --git a/qa/rpc-tests/getblocktemplate_longpoll.py b/qa/rpc-tests/getblocktemplate_longpoll.py
	index 3e85957ae2..e2a839f718 100755
	--- a/qa/rpc-tests/getblocktemplate_longpoll.py
	+++ b/qa/rpc-tests/getblocktemplate_longpoll.py
	@@ -1,91 +1,69 @@
	#!/usr/bin/env python2
	# Copyright (c) 2014-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 BitcoinTestFramework
	from test_framework.util import *

	-
	-def check_array_result(object_array, to_match, expected):
	- """
	- Pass in array of JSON objects, a dictionary with key/value pairs
	- to match against, and another dictionary with expected key/value
	- pairs.
	- """
	- 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
	- 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:
	- raise AssertionError("No objects matched %s"%(str(to_match)))
	-
	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 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 07bfe69c6d..be119031ba 100755
	--- a/qa/rpc-tests/getblocktemplate_proposals.py
	+++ b/qa/rpc-tests/getblocktemplate_proposals.py
	@@ -1,176 +1,154 @@
	#!/usr/bin/env python2
	# Copyright (c) 2014-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 BitcoinTestFramework
	from test_framework.util import *

	from binascii import a2b_hex, b2a_hex
	from hashlib import sha256
	from struct import pack

	-
	-def check_array_result(object_array, to_match, expected):
	- """
	- Pass in array of JSON objects, a dictionary with key/value pairs
	- to match against, and another dictionary with expected key/value
	- pairs.
	- """
	- 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
	- 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:
	- raise AssertionError("No objects matched %s"%(str(to_match)))
	-
	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_bytes(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 blk

	def template_to_hex(tmpl, txlist):
	return b2x(template_to_bytes(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 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_bytes(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/keypool.py b/qa/rpc-tests/keypool.py
	index 5253d49c30..b86c085e00 100755
	--- a/qa/rpc-tests/keypool.py
	+++ b/qa/rpc-tests/keypool.py
	@@ -1,98 +1,76 @@
	#!/usr/bin/env python2
	# Copyright (c) 2014-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.

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

	-
	-def check_array_result(object_array, to_match, expected):
	- """
	- Pass in array of JSON objects, a dictionary with key/value pairs
	- to match against, and another dictionary with expected key/value
	- pairs.
	- """
	- 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
	- 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:
	- raise AssertionError("No objects matched %s"%(str(to_match)))
	-
	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 setup_network(self):
	self.nodes = start_nodes(1, self.options.tmpdir)

	if __name__ == '__main__':
	KeyPoolTest().main()
	diff --git a/qa/rpc-tests/listtransactions.py b/qa/rpc-tests/listtransactions.py
	index 0783a1f3d3..4e5809f4a7 100755
	--- a/qa/rpc-tests/listtransactions.py
	+++ b/qa/rpc-tests/listtransactions.py
	@@ -1,221 +1,200 @@
	#!/usr/bin/env python2
	# Copyright (c) 2014-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.

	# 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

	-def check_array_result(object_array, to_match, expected):
	- """
	- Pass in array of JSON objects, a dictionary with key/value pairs
	- to match against, and another dictionary with expected key/value
	- pairs.
	- """
	- 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
	- 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:
	- raise AssertionError("No objects matched %s"%(str(to_match)))
	-
	class ListTransactionsTest(BitcoinTestFramework):

	def setup_nodes(self):
	#This test requires mocktime
	enable_mocktime()
	return start_nodes(4, 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()
	- check_array_result(self.nodes[0].listtransactions(),
	+ assert_array_result(self.nodes[0].listtransactions(),
	{"txid":txid},
	{"category":"send","account":"","amount":Decimal("-0.1"),"confirmations":0})
	- check_array_result(self.nodes[1].listtransactions(),
	+ 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()
	- check_array_result(self.nodes[0].listtransactions(),
	+ assert_array_result(self.nodes[0].listtransactions(),
	{"txid":txid},
	{"category":"send","account":"","amount":Decimal("-0.1"),"confirmations":1})
	- check_array_result(self.nodes[1].listtransactions(),
	+ 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)
	- check_array_result(self.nodes[0].listtransactions(),
	+ assert_array_result(self.nodes[0].listtransactions(),
	{"txid":txid, "category":"send"},
	{"amount":Decimal("-0.2")})
	- check_array_result(self.nodes[0].listtransactions(),
	+ 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()
	- check_array_result(self.nodes[1].listtransactions(),
	+ assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.11")},
	{"txid":txid} )
	- check_array_result(self.nodes[0].listtransactions(),
	+ assert_array_result(self.nodes[0].listtransactions(),
	{"category":"receive","amount":Decimal("0.11")},
	{"txid":txid} )
	- check_array_result(self.nodes[1].listtransactions(),
	+ assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.22")},
	{"txid":txid} )
	- check_array_result(self.nodes[1].listtransactions(),
	+ assert_array_result(self.nodes[1].listtransactions(),
	{"category":"receive","amount":Decimal("0.22")},
	{"txid":txid} )
	- check_array_result(self.nodes[1].listtransactions(),
	+ assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.33")},
	{"txid":txid} )
	- check_array_result(self.nodes[0].listtransactions(),
	+ assert_array_result(self.nodes[0].listtransactions(),
	{"category":"receive","amount":Decimal("0.33")},
	{"txid":txid, "account" : "from1"} )
	- check_array_result(self.nodes[1].listtransactions(),
	+ assert_array_result(self.nodes[1].listtransactions(),
	{"category":"send","amount":Decimal("-0.44")},
	{"txid":txid, "account" : ""} )
	- check_array_result(self.nodes[1].listtransactions(),
	+ 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)
	- check_array_result(self.nodes[0].listtransactions("watchonly", 100, 0, True),
	+ 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))
	- check_array_result(self.nodes[0].listtransactions(), {"txid": txid_1}, {"bip125-replaceable":"no"})
	+ assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_1}, {"bip125-replaceable":"no"})
	sync_mempools(self.nodes)
	- check_array_result(self.nodes[1].listtransactions(), {"txid": txid_1}, {"bip125-replaceable":"no"})
	+ 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))
	- check_array_result(self.nodes[1].listtransactions(), {"txid": txid_2}, {"bip125-replaceable":"no"})
	+ assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_2}, {"bip125-replaceable":"no"})
	sync_mempools(self.nodes)
	- check_array_result(self.nodes[0].listtransactions(), {"txid": txid_2}, {"bip125-replaceable":"no"})
	+ 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))
	- check_array_result(self.nodes[0].listtransactions(), {"txid": txid_3}, {"bip125-replaceable":"yes"})
	+ assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_3}, {"bip125-replaceable":"yes"})
	sync_mempools(self.nodes)
	- check_array_result(self.nodes[1].listtransactions(), {"txid": txid_3}, {"bip125-replaceable":"yes"})
	+ 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))
	- check_array_result(self.nodes[1].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"yes"})
	+ assert_array_result(self.nodes[1].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"yes"})
	sync_mempools(self.nodes)
	- check_array_result(self.nodes[0].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"yes"})
	+ 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))

	- check_array_result(self.nodes[0].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"unknown"})
	+ assert_array_result(self.nodes[0].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"unknown"})
	sync_mempools(self.nodes)
	- check_array_result(self.nodes[1].listtransactions(), {"txid": txid_4}, {"bip125-replaceable":"unknown"})
	+ 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/receivedby.py b/qa/rpc-tests/receivedby.py
	index 606426b394..7d8231f5e4 100755
	--- a/qa/rpc-tests/receivedby.py
	+++ b/qa/rpc-tests/receivedby.py
	@@ -1,171 +1,145 @@
	#!/usr/bin/env python2
	# Copyright (c) 2014-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.

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

	-def check_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:
	- 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
	- 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 was matched %s"%(str(to_match)))
	-
	class ReceivedByTest(BitcoinTestFramework):

	def setup_nodes(self):
	#This test requires mocktime
	enable_mocktime()
	return start_nodes(4, 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
	- check_array_result(self.nodes[1].listreceivedbyaddress(),
	+ 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()
	- check_array_result(self.nodes[1].listreceivedbyaddress(),
	+ assert_array_result(self.nodes[1].listreceivedbyaddress(),
	{"address":addr},
	{"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]})
	#With min confidence < 10
	- check_array_result(self.nodes[1].listreceivedbyaddress(5),
	+ 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
	- check_array_result(self.nodes[1].listreceivedbyaddress(11),{"address":addr},{ },True)
	+ assert_array_result(self.nodes[1].listreceivedbyaddress(11),{"address":addr},{ },True)

	#Empty Tx
	addr = self.nodes[1].getnewaddress()
	- check_array_result(self.nodes[1].listreceivedbyaddress(0,True),
	+ 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
	- check_array_result(self.nodes[1].listreceivedbyaccount(),
	+ 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
	- check_array_result(self.nodes[1].listreceivedbyaccount(),
	+ 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/test_framework/util.py b/qa/rpc-tests/test_framework/util.py
	index 8b720b54a1..27891f7f4c 100644
	--- a/qa/rpc-tests/test_framework/util.py
	+++ b/qa/rpc-tests/test_framework/util.py
	@@ -1,564 +1,593 @@
	# Copyright (c) 2014-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.


	#
	# Helpful routines for regression testing
	#

	# Add python-bitcoinrpc to module search path:
	import os
	import sys

	from binascii import hexlify, unhexlify
	from base64 import b64encode
	from decimal import Decimal, ROUND_DOWN
	import json
	import random
	import shutil
	import subprocess
	import time
	import re
	import errno

	from . import coverage
	from .authproxy import AuthServiceProxy, JSONRPCException

	COVERAGE_DIR = 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):
	return 11000 + n + os.getpid()%999
	def rpc_port(n):
	return 12000 + n + os.getpid()%999

	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):
	"""
	Create (or copy from cache) a 200-block-long chain and
	4 wallets.
	"""

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

	#find and delete old cache directories if any exist
	for i in range(4):
	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):
	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):
	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
	# gets 25 mature blocks and 25 immature.
	# 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):
	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):
	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 i in range(num_nodes) ]
	if binary is None: binary = [ None for i 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):
	node.stop()
	bitcoind_processes[i].wait()
	del bitcoind_processes[i]

	def stop_nodes(nodes):
	for node in nodes:
	node.stop()
	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, basestring):
	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:
	+ 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 xrange(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 xrange (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 xrange(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 xrange(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/wallet.py b/qa/rpc-tests/wallet.py
	index 8fdcea50b6..555f836482 100755
	--- a/qa/rpc-tests/wallet.py
	+++ b/qa/rpc-tests/wallet.py
	@@ -1,304 +1,341 @@
	#!/usr/bin/env python2
	# Copyright (c) 2014-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 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 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 ()

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 10:21 (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187336
Default Alt Text: (71 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions