No OneTemporary
Actions

Size

28 KB

Subscribers

None

View Options

	diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
	index d1509696d8..d618824683 100755
	--- a/test/functional/mempool_packages.py
	+++ b/test/functional/mempool_packages.py
	@@ -1,262 +1,262 @@
	#!/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 set_test_params(self):
	self.num_nodes = 2
	self.extra_args = [["-maxorphantx=1000"],
	["-maxorphantx=1000", "-limitancestorcount=5"]]

	# 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)
	# make sure we didn't generate a change output
	assert(len(fulltx['vout']) == num_outputs)
	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

	descendants = []
	ancestors = list(chain)
	for x in reversed(chain):
	# Check that getmempoolentry is consistent with getrawmempool
	entry = self.nodes[0].getmempoolentry(x)
	assert_equal(entry, mempool[x])

	# Check that the descendant calculations are correct
	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 getmempooldescendants is correct
	assert_equal(sorted(descendants), sorted(
	self.nodes[0].getmempooldescendants(x)))
	descendants.append(x)

	# Check that getmempoolancestors is correct
	ancestors.remove(x)
	assert_equal(sorted(ancestors), sorted(
	self.nodes[0].getmempoolancestors(x)))

	# Check that getmempoolancestors/getmempooldescendants correctly handle verbose=true
	v_ancestors = self.nodes[0].getmempoolancestors(chain[-1], True)
	assert_equal(len(v_ancestors), len(chain) - 1)
	for x in v_ancestors.keys():
	assert_equal(mempool[x], v_ancestors[x])
	assert(chain[-1] not in v_ancestors.keys())

	v_descendants = self.nodes[0].getmempooldescendants(chain[0], True)
	assert_equal(len(v_descendants), len(chain) - 1)
	for x in v_descendants.keys():
	assert_equal(mempool[x], v_descendants[x])
	assert(chain[0] not in v_descendants.keys())

	# Check that ancestor modified fees includes fee deltas from
	# prioritisetransaction
	self.nodes[0].prioritisetransaction(chain[0], 0, 1000)
	mempool = self.nodes[0].getrawmempool(True)
	ancestor_fees = 0
	for x in chain:
	ancestor_fees += mempool[x]['fee']
	assert_equal(mempool[x]['ancestorfees'],
	ancestor_fees * COIN + 1000)

	# Undo the prioritisetransaction for later tests
	self.nodes[0].prioritisetransaction(chain[0], 0, -1000)

	# 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.
	assert_raises_rpc_error(-26, "too-long-mempool-chain",
	self.chain_transaction, self.nodes[0], txid, vout, value, fee, 1)

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

	# Sign and send up to MAX_DESCENDANT transactions chained off the parent tx
	for i in range(MAX_DESCENDANTS - 1):
	utxo = transaction_package.pop(0)
	(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})

	mempool = self.nodes[0].getrawmempool(True)
	assert_equal(mempool[parent_transaction]
	['descendantcount'], MAX_DESCENDANTS)

	# Sending one more chained transaction will fail
	utxo = transaction_package.pop(0)
	assert_raises_rpc_error(-26, "too-long-mempool-chain", self.chain_transaction,
	self.nodes[0], utxo['txid'], utxo['vout'], utxo['amount'], fee, 10)

	# 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(
	+ tx1_id, _ = 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/test/functional/preciousblock.py b/test/functional/preciousblock.py
	index c914fd8443..97ac2ed596 100755
	--- a/test/functional/preciousblock.py
	+++ b/test/functional/preciousblock.py
	@@ -1,128 +1,128 @@
	#!/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 PreciousBlock code
	#

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import (
	assert_equal,
	connect_nodes_bi,
	sync_chain,
	sync_blocks,
	)


	def unidirectional_node_sync_via_rpc(node_src, node_dest):
	blocks_to_copy = []
	blockhash = node_src.getbestblockhash()
	while True:
	try:
	assert(len(node_dest.getblock(blockhash, False)) > 0)
	break
	except:
	blocks_to_copy.append(blockhash)
	blockhash = node_src.getblockheader(
	blockhash, True)['previousblockhash']
	blocks_to_copy.reverse()
	for blockhash in blocks_to_copy:
	blockdata = node_src.getblock(blockhash, False)
	assert(node_dest.submitblock(blockdata) in (None, 'inconclusive'))


	def node_sync_via_rpc(nodes):
	for node_src in nodes:
	for node_dest in nodes:
	if node_src is node_dest:
	continue
	unidirectional_node_sync_via_rpc(node_src, node_dest)


	class PreciousTest(BitcoinTestFramework):
	def set_test_params(self):
	self.setup_clean_chain = True
	self.num_nodes = 3
	self.extra_args = [["-noparkdeepreorg"],
	["-noparkdeepreorg"], ["-noparkdeepreorg"]]

	def setup_network(self):
	self.setup_nodes()

	def run_test(self):
	self.log.info(
	"Ensure submitblock can in principle reorg to a competing chain")
	self.nodes[0].generate(1)
	assert_equal(self.nodes[0].getblockcount(), 1)
	- (hashY, hashZ) = self.nodes[1].generate(2)
	+ hashZ = self.nodes[1].generate(2)[-1]
	assert_equal(self.nodes[1].getblockcount(), 2)
	node_sync_via_rpc(self.nodes[0:3])
	assert_equal(self.nodes[0].getbestblockhash(), hashZ)

	self.log.info("Mine blocks A-B-C on Node 0")
	- (hashA, hashB, hashC) = self.nodes[0].generate(3)
	+ hashC = self.nodes[0].generate(3)[-1]
	assert_equal(self.nodes[0].getblockcount(), 5)
	self.log.info("Mine competing blocks E-F-G on Node 1")
	- (hashE, hashF, hashG) = self.nodes[1].generate(3)
	+ hashG = self.nodes[1].generate(3)[-1]
	assert_equal(self.nodes[1].getblockcount(), 5)
	assert(hashC != hashG)
	self.log.info("Connect nodes and check no reorg occurs")
	# Submit competing blocks via RPC so any reorg should occur before we
	# proceed (no way to wait on inaction for p2p sync)
	node_sync_via_rpc(self.nodes[0:2])
	connect_nodes_bi(self.nodes, 0, 1)
	assert_equal(self.nodes[0].getbestblockhash(), hashC)
	assert_equal(self.nodes[1].getbestblockhash(), hashG)
	self.log.info("Make Node0 prefer block G")
	self.nodes[0].preciousblock(hashG)
	assert_equal(self.nodes[0].getbestblockhash(), hashG)
	self.log.info("Make Node0 prefer block C again")
	self.nodes[0].preciousblock(hashC)
	assert_equal(self.nodes[0].getbestblockhash(), hashC)
	self.log.info("Make Node1 prefer block C")
	self.nodes[1].preciousblock(hashC)
	sync_chain(self.nodes[0:2])
	# wait because node 1 may not have downloaded hashC
	assert_equal(self.nodes[1].getbestblockhash(), hashC)
	self.log.info("Make Node1 prefer block G again")
	self.nodes[1].preciousblock(hashG)
	assert_equal(self.nodes[1].getbestblockhash(), hashG)
	self.log.info("Make Node0 prefer block G again")
	self.nodes[0].preciousblock(hashG)
	assert_equal(self.nodes[0].getbestblockhash(), hashG)
	self.log.info("Make Node1 prefer block C again")
	self.nodes[1].preciousblock(hashC)
	assert_equal(self.nodes[1].getbestblockhash(), hashC)
	self.log.info(
	"Mine another block (E-F-G-)H on Node 0 and reorg Node 1")
	self.nodes[0].generate(1)
	assert_equal(self.nodes[0].getblockcount(), 6)
	sync_blocks(self.nodes[0:2])
	hashH = self.nodes[0].getbestblockhash()
	assert_equal(self.nodes[1].getbestblockhash(), hashH)
	self.log.info("Node1 should not be able to prefer block C anymore")
	self.nodes[1].preciousblock(hashC)
	assert_equal(self.nodes[1].getbestblockhash(), hashH)
	self.log.info("Mine competing blocks I-J-K-L on Node 2")
	self.nodes[2].generate(4)
	assert_equal(self.nodes[2].getblockcount(), 6)
	hashL = self.nodes[2].getbestblockhash()
	self.log.info("Connect nodes and check no reorg occurs")
	node_sync_via_rpc(self.nodes[1:3])
	connect_nodes_bi(self.nodes, 1, 2)
	connect_nodes_bi(self.nodes, 0, 2)
	assert_equal(self.nodes[0].getbestblockhash(), hashH)
	assert_equal(self.nodes[1].getbestblockhash(), hashH)
	assert_equal(self.nodes[2].getbestblockhash(), hashL)
	self.log.info("Make Node1 prefer block L")
	self.nodes[1].preciousblock(hashL)
	assert_equal(self.nodes[1].getbestblockhash(), hashL)
	self.log.info("Make Node2 prefer block H")
	self.nodes[2].preciousblock(hashH)
	assert_equal(self.nodes[2].getbestblockhash(), hashH)


	if __name__ == '__main__':
	PreciousTest().main()
	diff --git a/test/functional/test_framework/socks5.py b/test/functional/test_framework/socks5.py
	index 6ce777f715..776c5cffe0 100644
	--- a/test/functional/test_framework/socks5.py
	+++ b/test/functional/test_framework/socks5.py
	@@ -1,175 +1,175 @@
	#!/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.
	"""Dummy Socks5 server for testing."""

	import socket
	import threading
	import queue
	import logging

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

	# Protocol constants


	class Command:
	CONNECT = 0x01


	class AddressType:
	IPV4 = 0x01
	DOMAINNAME = 0x03
	IPV6 = 0x04

	# Utility functions


	def recvall(s, n):
	"""Receive n bytes from a socket, or fail."""
	rv = bytearray()
	while n > 0:
	d = s.recv(n)
	if not d:
	raise IOError('Unexpected end of stream')
	rv.extend(d)
	n -= len(d)
	return rv

	# Implementation classes


	class Socks5Configuration():
	"""Proxy configuration."""

	def __init__(self):
	self.addr = None # Bind address (must be set)
	self.af = socket.AF_INET # Bind address family
	self.unauth = False # Support unauthenticated
	self.auth = False # Support authentication


	class Socks5Command():
	"""Information about an incoming socks5 command."""

	def __init__(self, cmd, atyp, addr, port, username, password):
	self.cmd = cmd # Command (one of Command.*)
	self.atyp = atyp # Address type (one of AddressType.*)
	self.addr = addr # Address
	self.port = port # Port to connect to
	self.username = username
	self.password = password

	def __repr__(self):
	return 'Socks5Command(%s,%s,%s,%s,%s,%s)' % (self.cmd, self.atyp, self.addr, self.port, self.username, self.password)


	class Socks5Connection():
	def __init__(self, serv, conn, peer):
	self.serv = serv
	self.conn = conn
	self.peer = peer

	def handle(self):
	"""Handle socks5 request according to RFC192."""
	try:
	# Verify socks version
	ver = recvall(self.conn, 1)[0]
	if ver != 0x05:
	raise IOError('Invalid socks version %i' % ver)
	# Choose authentication method
	nmethods = recvall(self.conn, 1)[0]
	methods = bytearray(recvall(self.conn, nmethods))
	method = None
	if 0x02 in methods and self.serv.conf.auth:
	method = 0x02 # username/password
	elif 0x00 in methods and self.serv.conf.unauth:
	method = 0x00 # unauthenticated
	if method is None:
	raise IOError('No supported authentication method was offered')
	# Send response
	self.conn.sendall(bytearray([0x05, method]))
	# Read authentication (optional)
	username = None
	password = None
	if method == 0x02:
	ver = recvall(self.conn, 1)[0]
	if ver != 0x01:
	raise IOError('Invalid auth packet version %i' % ver)
	ulen = recvall(self.conn, 1)[0]
	username = str(recvall(self.conn, ulen))
	plen = recvall(self.conn, 1)[0]
	password = str(recvall(self.conn, plen))
	# Send authentication response
	self.conn.sendall(bytearray([0x01, 0x00]))

	# Read connect request
	- (ver, cmd, rsv, atyp) = recvall(self.conn, 4)
	+ ver, cmd, _, atyp = recvall(self.conn, 4)
	if ver != 0x05:
	raise IOError(
	'Invalid socks version %i in connect request' % ver)
	if cmd != Command.CONNECT:
	raise IOError('Unhandled command %i in connect request' % cmd)

	if atyp == AddressType.IPV4:
	addr = recvall(self.conn, 4)
	elif atyp == AddressType.DOMAINNAME:
	n = recvall(self.conn, 1)[0]
	addr = recvall(self.conn, n)
	elif atyp == AddressType.IPV6:
	addr = recvall(self.conn, 16)
	else:
	raise IOError('Unknown address type %i' % atyp)
	port_hi, port_lo = recvall(self.conn, 2)
	port = (port_hi << 8) \| port_lo

	# Send dummy response
	self.conn.sendall(
	bytearray([0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))

	cmdin = Socks5Command(cmd, atyp, addr, port, username, password)
	self.serv.queue.put(cmdin)
	logger.info('Proxy: %s', cmdin)
	# Fall through to disconnect
	except Exception as e:
	logger.exception("socks5 request handling failed.")
	self.serv.queue.put(e)
	finally:
	self.conn.close()


	class Socks5Server():
	def __init__(self, conf):
	self.conf = conf
	self.s = socket.socket(conf.af)
	self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
	self.s.bind(conf.addr)
	self.s.listen(5)
	self.running = False
	self.thread = None
	self.queue = queue.Queue() # report connections and exceptions to client

	def run(self):
	while self.running:
	(sockconn, peer) = self.s.accept()
	if self.running:
	conn = Socks5Connection(self, sockconn, peer)
	thread = threading.Thread(None, conn.handle)
	thread.daemon = True
	thread.start()

	def start(self):
	assert(not self.running)
	self.running = True
	self.thread = threading.Thread(None, self.run)
	self.thread.daemon = True
	self.thread.start()

	def stop(self):
	self.running = False
	# connect to self to end run loop
	s = socket.socket(self.conf.af)
	s.connect(self.conf.addr)
	s.close()
	self.thread.join()
	diff --git a/test/functional/wallet_dump.py b/test/functional/wallet_dump.py
	index 22ea290ff9..926d3f0a92 100755
	--- a/test/functional/wallet_dump.py
	+++ b/test/functional/wallet_dump.py
	@@ -1,122 +1,122 @@
	#!/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.
	"""Test the dumpwallet RPC."""

	import os

	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import (assert_equal, assert_raises_rpc_error)


	def read_dump(file_name, addrs, hd_master_addr_old):
	"""
	Read the given dump, count the addrs that match, count change and reserve.
	Also check that the old hd_master is inactive
	"""
	with open(file_name, encoding='utf8') as inputfile:
	found_addr = 0
	found_addr_chg = 0
	found_addr_rsv = 0
	hd_master_addr_ret = None
	for line in inputfile:
	# only read non comment lines
	if line[0] != "#" and len(line) > 10:
	# split out some data
	key_label, comment = line.split("#")
	# key = key_label.split(" ")[0]
	keytype = key_label.split(" ")[2]
	if len(comment) > 1:
	addr_keypath = comment.split(" addr=")[1]
	addr = addr_keypath.split(" ")[0]
	keypath = None
	if keytype == "inactivehdmaster=1":
	# ensure the old master is still available
	assert(hd_master_addr_old == addr)
	elif keytype == "hdmaster=1":
	# ensure we have generated a new hd master key
	assert(hd_master_addr_old != addr)
	hd_master_addr_ret = addr
	else:
	keypath = addr_keypath.rstrip().split("hdkeypath=")[1]

	# count key types
	for addrObj in addrs:
	if addrObj['address'] == addr and addrObj['hdkeypath'] == keypath and keytype == "label=":
	found_addr += 1
	break
	elif keytype == "change=1":
	found_addr_chg += 1
	break
	elif keytype == "reserve=1":
	found_addr_rsv += 1
	break
	return found_addr, found_addr_chg, found_addr_rsv, hd_master_addr_ret


	class WalletDumpTest(BitcoinTestFramework):
	def set_test_params(self):
	self.num_nodes = 1
	self.extra_args = [["-keypool=90"]]

	def setup_network(self, split=False):
	# Use 1 minute timeout because the initial getnewaddress RPC can take
	# longer than the default 30 seconds due to an expensive
	# CWallet::TopUpKeyPool call, and the encryptwallet RPC made later in
	# the test often takes even longer.
	self.add_nodes(self.num_nodes, self.extra_args, timewait=60)
	self.start_nodes()

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

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

	# dump unencrypted wallet
	result = self.nodes[0].dumpwallet(
	tmpdir + "/node0/wallet.unencrypted.dump")
	assert_equal(result['filename'], os.path.abspath(
	tmpdir + "/node0/wallet.unencrypted.dump"))

	found_addr, found_addr_chg, found_addr_rsv, hd_master_addr_unenc = \
	read_dump(tmpdir + "/node0/wallet.unencrypted.dump", addrs, None)
	# all keys must be in the dump
	assert_equal(found_addr, test_addr_count)
	# 50 blocks where mined
	assert_equal(found_addr_chg, 50)
	# 90 keys plus 100% internal keys
	assert_equal(found_addr_rsv, 90 * 2)

	# encrypt wallet, restart, unlock and dump
	self.nodes[0].node_encrypt_wallet('test')
	self.start_node(0)
	self.nodes[0].walletpassphrase('test', 10)
	# Should be a no-op:
	self.nodes[0].keypoolrefill()
	self.nodes[0].dumpwallet(tmpdir + "/node0/wallet.encrypted.dump")

	- found_addr, found_addr_chg, found_addr_rsv, hd_master_addr_enc = \
	+ found_addr, found_addr_chg, found_addr_rsv, _ = \
	read_dump(tmpdir + "/node0/wallet.encrypted.dump",
	addrs, hd_master_addr_unenc)
	assert_equal(found_addr, test_addr_count)
	# old reserve keys are marked as change now
	assert_equal(found_addr_chg, 90 * 2 + 50)
	assert_equal(found_addr_rsv, 90 * 2)

	# Overwriting should fail
	assert_raises_rpc_error(-8, "already exists",
	self.nodes[0].dumpwallet, tmpdir + "/node0/wallet.unencrypted.dump")


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

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 08:35 (20 h, 53 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187094
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions