diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index d1509696d..d61882468 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 c914fd844..97ac2ed59 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 6ce777f71..776c5cffe 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 22ea290ff..926d3f0a9 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()