diff --git a/test/functional/wallet_abandonconflict.py b/test/functional/wallet_abandonconflict.py
index 695db9725..2cd936846 100755
--- a/test/functional/wallet_abandonconflict.py
+++ b/test/functional/wallet_abandonconflict.py
@@ -1,232 +1,235 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 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 abandontransaction RPC.
 
  The abandontransaction RPC marks a transaction and all its in-wallet
  descendants as abandoned which allows their inputs to be respent. It can be
  used to replace "stuck" or evicted transactions. It only works on transactions
  which are not included in a block and are not currently in the mempool. It has
  no effect on transactions which are already abandoned.
 """
 from decimal import Decimal
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
     satoshi_round,
 )
 
 
 class AbandonConflictTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [["-minrelaytxfee=10"], []]
+        # whitelist peers to speed up tx relay / mempool sync
+        for args in self.extra_args:
+            args.append("-whitelist=noban@127.0.0.1")
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         def total_fees(*txids):
             total = 0
             for txid in txids:
                 # '-=' is because gettransaction(txid)['fee'] returns a negative
                 total -= self.nodes[0].gettransaction(txid)['fee']
             return satoshi_round(total)
 
         self.nodes[1].generate(100)
         self.sync_blocks()
         balance = self.nodes[0].getbalance()
         txA = self.nodes[0].sendtoaddress(
             self.nodes[0].getnewaddress(), Decimal("10000000"))
         txB = self.nodes[0].sendtoaddress(
             self.nodes[0].getnewaddress(), Decimal("10000000"))
         txC = self.nodes[0].sendtoaddress(
             self.nodes[0].getnewaddress(), Decimal("10000000"))
 
         self.sync_mempools()
         self.nodes[1].generate(1)
 
         # Can not abandon non-wallet transaction
         assert_raises_rpc_error(-5, 'Invalid or non-wallet transaction id',
                                 lambda: self.nodes[0].abandontransaction(txid='ff' * 32))
         # Can not abandon confirmed transaction
         assert_raises_rpc_error(-5, 'Transaction not eligible for abandonment',
                                 lambda: self.nodes[0].abandontransaction(txid=txA))
 
         self.sync_blocks()
         newbalance = self.nodes[0].getbalance()
 
         # no more than fees lost
         assert balance - newbalance <= total_fees(txA, txB, txC)
         balance = newbalance
 
         # Disconnect nodes so node0's transactions don't get into node1's
         # mempool
         self.disconnect_nodes(0, 1)
 
         # Identify the 10btc outputs
         nA = next(tx_out["vout"] for tx_out in self.nodes[0].gettransaction(
             txA)["details"] if tx_out["amount"] == Decimal("10000000"))
         nB = next(tx_out["vout"] for tx_out in self.nodes[0].gettransaction(
             txB)["details"] if tx_out["amount"] == Decimal("10000000"))
         nC = next(tx_out["vout"] for tx_out in self.nodes[0].gettransaction(
             txC)["details"] if tx_out["amount"] == Decimal("10000000"))
 
         inputs = []
         # spend 10btc outputs from txA and txB
         inputs.append({"txid": txA, "vout": nA})
         inputs.append({"txid": txB, "vout": nB})
         outputs = {}
 
         outputs[self.nodes[0].getnewaddress()] = Decimal("14999980")
         outputs[self.nodes[1].getnewaddress()] = Decimal("5000000")
         signed = self.nodes[0].signrawtransactionwithwallet(
             self.nodes[0].createrawtransaction(inputs, outputs))
         txAB1 = self.nodes[0].sendrawtransaction(signed["hex"])
 
         # Identify the 14,999,980 XEC output
         nAB = next(tx_out["vout"] for tx_out in self.nodes[0].gettransaction(
             txAB1)["details"] if tx_out["amount"] == Decimal("14999980"))
 
         # Create a child tx spending AB1 and C
         inputs = []
         # Amount 14,999,980 XEC
         inputs.append({"txid": txAB1, "vout": nAB})
         # Amount 10,000,000 XEC
         inputs.append({"txid": txC, "vout": nC})
         outputs = {}
         outputs[self.nodes[0].getnewaddress()] = Decimal("24999600")
         signed2 = self.nodes[0].signrawtransactionwithwallet(
             self.nodes[0].createrawtransaction(inputs, outputs))
         txABC2 = self.nodes[0].sendrawtransaction(signed2["hex"])
 
         # Create a child tx spending ABC2
         signed3_change = Decimal("24999000")
         inputs = [{"txid": txABC2, "vout": 0}]
         outputs = {self.nodes[0].getnewaddress(): signed3_change}
         signed3 = self.nodes[0].signrawtransactionwithwallet(
             self.nodes[0].createrawtransaction(inputs, outputs))
         # note tx is never directly referenced, only abandoned as a child of
         # the above
         self.nodes[0].sendrawtransaction(signed3["hex"])
 
         # In mempool txs from self should increase balance from change
         newbalance = self.nodes[0].getbalance()
         assert_equal(
             newbalance,
             balance -
             Decimal("30000000") +
             signed3_change)
         balance = newbalance
 
         # Restart the node with a higher min relay fee so the parent tx is no longer in mempool
         # TODO: redo with eviction
         self.restart_node(0, extra_args=["-minrelaytxfee=100"])
         assert self.nodes[0].getmempoolinfo()['loaded']
 
         # Verify txs no longer in either node's mempool
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
         assert_equal(len(self.nodes[1].getrawmempool()), 0)
 
         # Transactions which are not in the mempool should only reduce wallet balance.
         # Transaction inputs should still be spent, but the change not yet
         # received.
         newbalance = self.nodes[0].getbalance()
         assert_equal(newbalance, balance - signed3_change)
         # Unconfirmed received funds that are not in mempool also shouldn't show
         # up in unconfirmed balance.  Note that the transactions stored in the wallet
         # are not necessarily in the node's mempool.
         balances = self.nodes[0].getbalances()['mine']
         assert_equal(
             balances['untrusted_pending'] +
             balances['trusted'],
             newbalance)
         # Unconfirmed transactions which are not in the mempool should also
         # not be in listunspent
         assert txABC2 not in [utxo["txid"]
                               for utxo in self.nodes[0].listunspent(0)]
         balance = newbalance
 
         # Abandon original transaction and verify inputs are available again
         # including that the child tx was also abandoned
         self.nodes[0].abandontransaction(txAB1)
         newbalance = self.nodes[0].getbalance()
         assert_equal(newbalance, balance + Decimal("30000000"))
         balance = newbalance
 
         # Verify that even with a low min relay fee, the tx is not re-accepted
         # from wallet on startup once abandoned.
         self.restart_node(0, extra_args=["-minrelaytxfee=10"])
         assert self.nodes[0].getmempoolinfo()['loaded']
 
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
         assert_equal(self.nodes[0].getbalance(), balance)
 
         # If the transaction is re-sent the wallet also unabandons it. The
         # change should be available, and it's child transaction should remain
         # abandoned.
         # NOTE: Abandoned transactions are internal to the wallet, and tracked
         # separately from other indices.
         self.nodes[0].sendrawtransaction(signed["hex"])
         newbalance = self.nodes[0].getbalance()
         assert_equal(
             newbalance,
             balance -
             Decimal("20000000") +
             Decimal("14999980"))
         balance = newbalance
 
         # Send child tx again so it is no longer abandoned.
         self.nodes[0].sendrawtransaction(signed2["hex"])
         newbalance = self.nodes[0].getbalance()
         assert_equal(newbalance, balance - Decimal("10000000")
                      - Decimal("14999980") + Decimal("24999600"))
         balance = newbalance
 
         # Reset to a higher relay fee so that we abandon a transaction
         self.restart_node(0, extra_args=["-minrelaytxfee=100"])
         assert self.nodes[0].getmempoolinfo()['loaded']
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
         newbalance = self.nodes[0].getbalance()
         assert_equal(newbalance, balance - Decimal("24999600"))
         balance = newbalance
 
         # Create a double spend of AB1. Spend it again from only A's 10 output.
         # Mine double spend from node 1.
         inputs = []
         inputs.append({"txid": txA, "vout": nA})
         outputs = {}
         outputs[self.nodes[1].getnewaddress()] = Decimal("9999900")
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
         signed = self.nodes[0].signrawtransactionwithwallet(tx)
         self.nodes[1].sendrawtransaction(signed["hex"])
         self.nodes[1].generate(1)
 
         self.connect_nodes(0, 1)
         self.sync_blocks()
 
         # Verify that B and C's 10,000,000 XEC outputs are available for
         # spending again because AB1 is now conflicted
         newbalance = self.nodes[0].getbalance()
         assert_equal(newbalance, balance + Decimal("20000000"))
         balance = newbalance
 
         # There is currently a minor bug around this and so this test doesn't
         # work.  See Issue #7315
         # Invalidate the block with the double spend and B's 10,000,000 XEC
         # output should no longer be available. Don't think C's should either
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         newbalance = self.nodes[0].getbalance()
         # assert_equal(newbalance, balance - Decimal("10000000"))
         self.log.info(
             "If balance has not declined after invalidateblock then out of mempool wallet tx which is no longer")
         self.log.info(
             "conflicted has not resumed causing its inputs to be seen as spent.  See Issue #7315")
         self.log.info(str(balance) + " -> " + str(newbalance) + " ?")
 
 
 if __name__ == '__main__':
     AbandonConflictTest().main()
diff --git a/test/functional/wallet_balance.py b/test/functional/wallet_balance.py
index 1bfacb21e..5fd9a7ee7 100755
--- a/test/functional/wallet_balance.py
+++ b/test/functional/wallet_balance.py
@@ -1,337 +1,340 @@
 #!/usr/bin/env python3
 # Copyright (c) 2018-2019 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 wallet balance RPC methods."""
 import struct
 from decimal import Decimal
 
 from test_framework.address import (
     ADDRESS_ECREG_UNSPENDABLE as ADDRESS_WATCHONLY,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 
 
 def create_transactions(node, address, amt, fees):
     # Create and sign raw transactions from node to address for amt.
     # Creates a transaction for each fee and returns an array
     # of the raw transactions.
     utxos = [u for u in node.listunspent(0) if u['spendable']]
 
     # Create transactions
     inputs = []
     ins_total = 0
     for utxo in utxos:
         inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
         ins_total += utxo['amount']
         if ins_total >= amt + max(fees):
             break
     # make sure there was enough utxos
     assert ins_total >= amt + max(fees)
 
     txs = []
     for fee in fees:
         outputs = {address: amt}
         # prevent 0 change output
         if ins_total > amt + fee:
             outputs[node.getrawchangeaddress()] = ins_total - amt - fee
         raw_tx = node.createrawtransaction(inputs, outputs, 0)
         raw_tx = node.signrawtransactionwithwallet(raw_tx)
         assert_equal(raw_tx['complete'], True)
         txs.append(raw_tx)
 
     return txs
 
 
 class WalletTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
         self.extra_args = [
             # Limit mempool descendants as a hack to have wallet txs rejected
             # from the mempool
             ['-limitdescendantcount=3'],
             [],
         ]
+        # whitelist peers to speed up tx relay / mempool sync
+        for args in self.extra_args:
+            args.append("-whitelist=noban@127.0.0.1")
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         if not self.options.descriptors:
             # Tests legacy watchonly behavior which is not present (and does
             # not need to be tested) in descriptor wallets
             self.nodes[0].importaddress(ADDRESS_WATCHONLY)
             # Check that nodes don't own any UTXOs
             assert_equal(len(self.nodes[0].listunspent()), 0)
             assert_equal(len(self.nodes[1].listunspent()), 0)
 
             self.log.info("Check that only node 0 is watching an address")
             assert 'watchonly' in self.nodes[0].getbalances()
             assert 'watchonly' not in self.nodes[1].getbalances()
 
         self.log.info("Mining blocks ...")
         self.nodes[0].generate(1)
         self.sync_all()
         self.nodes[1].generate(1)
         self.nodes[1].generatetoaddress(101, ADDRESS_WATCHONLY)
         self.sync_all()
 
         if not self.options.descriptors:
             # Tests legacy watchonly behavior which is not present (and does not
             # need to be tested) in descriptor wallets
             assert_equal(self.nodes[0].getbalances()['mine']['trusted'],
                          50000000)
             assert_equal(self.nodes[0].getwalletinfo()['balance'], 50000000)
             assert_equal(self.nodes[1].getbalances()['mine']['trusted'],
                          50000000)
 
             assert_equal(self.nodes[0].getbalances()['watchonly']['immature'],
                          5000000000)
             assert 'watchonly' not in self.nodes[1].getbalances()
 
             assert_equal(self.nodes[0].getbalance(), 50000000)
             assert_equal(self.nodes[1].getbalance(), 50000000)
 
         self.log.info("Test getbalance with different arguments")
         assert_equal(self.nodes[0].getbalance("*"), 50000000)
         assert_equal(self.nodes[0].getbalance("*", 1), 50000000)
         assert_equal(self.nodes[0].getbalance(minconf=1), 50000000)
 
         if not self.options.descriptors:
             assert_equal(self.nodes[0].getbalance(minconf=0,
                                                   include_watchonly=True),
                          100_000_000)
             assert_equal(self.nodes[0].getbalance("*", 1, True), 100_000_000)
         else:
             assert_equal(self.nodes[0].getbalance(minconf=0,
                                                   include_watchonly=True),
                          50_000_000)
             assert_equal(self.nodes[0].getbalance("*", 1, True), 50_000_000)
 
         assert_equal(
             self.nodes[1].getbalance(
                 minconf=0,
                 include_watchonly=True),
             50000000)
 
         # Send 40 BTC from 0 to 1 and 60 BTC from 1 to 0.
         txs = create_transactions(
             self.nodes[0], self.nodes[1].getnewaddress(), 40000000, [Decimal('10000')])
         self.nodes[0].sendrawtransaction(txs[0]['hex'])
         # sending on both nodes is faster than waiting for propagation
         self.nodes[1].sendrawtransaction(txs[0]['hex'])
 
         self.sync_all()
         txs = create_transactions(self.nodes[1], self.nodes[0].getnewaddress(), 60000000, [
                                   Decimal('10000'), Decimal('20000')])
         self.nodes[1].sendrawtransaction(txs[0]['hex'])
         # sending on both nodes is faster than waiting for propagation
         self.nodes[0].sendrawtransaction(txs[0]['hex'])
         self.sync_all()
 
         # First argument of getbalance must be set to "*"
         assert_raises_rpc_error(-32, "dummy first argument must be excluded or set to \"*\"",
                                 self.nodes[1].getbalance, "")
 
         self.log.info("Test balances with unconfirmed inputs")
 
         # Before `test_balance()`, we have had two nodes with a balance of 50
         # each and then we:
         #
         # 1) Sent 40 from node A to node B with fee 0.01
         # 2) Sent 60 from node B to node A with fee 0.01
         #
         # Then we check the balances:
         #
         # 1) As is
         # 2) With transaction 2 from above with 2x the fee
         #
         # Prior to #16766, in this situation, the node would immediately report
         # a balance of 30 on node B as unconfirmed and trusted.
         #
         # After #16766, we show that balance as unconfirmed.
         #
         # The balance is indeed "trusted" and "confirmed" insofar as removing
         # the mempool transactions would return at least that much money. But
         # the algorithm after #16766 marks it as unconfirmed because the 'taint'
         # tracking of transaction trust for summing balances doesn't consider
         # which inputs belong to a user. In this case, the change output in
         # question could be "destroyed" by replace the 1st transaction above.
         #
         # The post #16766 behavior is correct; we shouldn't be treating those
         # funds as confirmed. If you want to rely on that specific UTXO existing
         # which has given you that balance, you cannot, as a third party
         # spending the other input would destroy that unconfirmed.
         #
         # For example, if the test transactions were:
         #
         # 1) Sent 40 from node A to node B with fee 0.01
         # 2) Sent 10 from node B to node A with fee 0.01
         #
         # Then our node would report a confirmed balance of 40 + 50 - 10 = 80
         # BTC, which is more than would be available if transaction 1 were
         # replaced.
 
         def test_balances(*, fee_node_1=0):
             # getbalances
             expected_balances_0 = {'mine': {'immature': Decimal('0E-2'),
                                             # change from node 0's send
                                             'trusted': Decimal('9990000'),
                                             'untrusted_pending': Decimal('60000000.0')},
                                    'watchonly': {'immature': Decimal('5000000000'),
                                                  'trusted': Decimal('50000000.0'),
                                                  'untrusted_pending': Decimal('0E-2')}}
             expected_balances_1 = {'mine': {'immature': Decimal('0E-2'),
                                             # node 1's send had an unsafe input
                                             'trusted': Decimal('0E-2'),
                                             # Doesn't include output of node
                                             # 0's send since it was spent
                                             'untrusted_pending': Decimal('30000000.0') - fee_node_1}}
             if self.options.descriptors:
                 del expected_balances_0["watchonly"]
             assert_equal(self.nodes[0].getbalances(), expected_balances_0)
             assert_equal(self.nodes[1].getbalances(), expected_balances_1)
             # getbalance without any arguments includes unconfirmed transactions, but not untrusted transactions
             # change from node 0's send
             assert_equal(self.nodes[0].getbalance(), Decimal('9990000'))
             # node 1's send had an unsafe input
             assert_equal(self.nodes[1].getbalance(), Decimal('0'))
             # Same with minconf=0
             assert_equal(
                 self.nodes[0].getbalance(
                     minconf=0),
                 Decimal('9990000'))
             assert_equal(self.nodes[1].getbalance(minconf=0), Decimal('0'))
             # getbalance with a minconf incorrectly excludes coins that have been spent more recently than the minconf blocks ago
             # TODO: fix getbalance tracking of coin spentness depth
             assert_equal(self.nodes[0].getbalance(minconf=1), Decimal('0'))
             assert_equal(self.nodes[1].getbalance(minconf=1), Decimal('0'))
             # getunconfirmedbalance
             # output of node 1's spend
             assert_equal(
                 self.nodes[0].getunconfirmedbalance(),
                 Decimal('60000000'))
 
             # Doesn't include output of node 0's send since it was spent
             assert_equal(
                 self.nodes[1].getunconfirmedbalance(),
                 Decimal('30000000') - fee_node_1)
             # getwalletinfo.unconfirmed_balance
             assert_equal(self.nodes[0].getwalletinfo()[
                          "unconfirmed_balance"], Decimal('60000000'))
             assert_equal(
                 self.nodes[1].getwalletinfo()["unconfirmed_balance"],
                 Decimal('30000000') - fee_node_1)
 
         test_balances(fee_node_1=Decimal('10000'))
 
         # In the original Core version of this test, Node 1 would've bumped
         # the fee by 0.01 here to resend, but this is XEC, so it has 10000 XEC
         # left to spend on goods and services
         self.sync_all()
 
         self.log.info(
             "Test getbalance and getbalances.mine.untrusted_pending with conflicted unconfirmed inputs")
         test_balances(fee_node_1=Decimal('10000'))
 
         self.nodes[1].generatetoaddress(1, ADDRESS_WATCHONLY)
         self.sync_all()
 
         # balances are correct after the transactions are confirmed
         # node 1's send plus change from node 0's send
         balance_node0 = Decimal('69990000')
         # change from node 0's send
         balance_node1 = Decimal('29990000')
         assert_equal(self.nodes[0].getbalances()[
                      'mine']['trusted'], balance_node0)
         assert_equal(self.nodes[1].getbalances()[
                      'mine']['trusted'], balance_node1)
         assert_equal(self.nodes[0].getbalance(), balance_node0)
         assert_equal(self.nodes[1].getbalance(), balance_node1)
 
         # Send total balance away from node 1
         txs = create_transactions(self.nodes[1], self.nodes[0].getnewaddress(
         ), Decimal('29970000'), [Decimal('10000')])
         self.nodes[1].sendrawtransaction(txs[0]['hex'])
         self.nodes[1].generatetoaddress(2, ADDRESS_WATCHONLY)
         self.sync_all()
 
         # getbalance with a minconf incorrectly excludes coins that have been spent more recently than the minconf blocks ago
         # TODO: fix getbalance tracking of coin spentness depth
         # getbalance with minconf=3 should still show the old balance
         assert_equal(self.nodes[1].getbalance(minconf=3), Decimal('0'))
 
         # getbalance with minconf=2 will show the new balance.
         assert_equal(self.nodes[1].getbalance(minconf=2), Decimal('10000'))
 
         # check mempool transactions count for wallet unconfirmed balance after
         # dynamically loading the wallet.
         before = self.nodes[1].getbalances()['mine']['untrusted_pending']
         dst = self.nodes[1].getnewaddress()
         self.nodes[1].unloadwallet(self.default_wallet_name)
         self.nodes[0].sendtoaddress(dst, 100000)
         self.sync_all()
         self.nodes[1].loadwallet(self.default_wallet_name)
         after = self.nodes[1].getbalances()['mine']['untrusted_pending']
         assert_equal(before + Decimal('100000'), after)
 
         # Create 3 more wallet txs, where the last is not accepted to the
         # mempool because it is the third descendant of the tx above
         for _ in range(3):
             # Set amount high enough such that all coins are spent by each tx
             txid = self.nodes[0].sendtoaddress(
                 self.nodes[0].getnewaddress(), 99000000)
 
         self.log.info('Check that wallet txs not in the mempool are untrusted')
         assert txid not in self.nodes[0].getrawmempool()
         assert_equal(self.nodes[0].gettransaction(txid)['trusted'], False)
         assert_equal(self.nodes[0].getbalance(minconf=0), 0)
 
         self.log.info("Test replacement and reorg of non-mempool tx")
         tx_orig = self.nodes[0].gettransaction(txid)['hex']
         # Increase fee by 1 coin
         tx_replace = tx_orig.replace(
             struct.pack("<q", 99 * 10**8).hex(),
             struct.pack("<q", 98 * 10**8).hex(),
         )
         tx_replace = self.nodes[0].signrawtransactionwithwallet(tx_replace)[
             'hex']
         # Total balance is given by the sum of outputs of the tx
         total_amount = sum(
             [o['value'] for o in self.nodes[0].decoderawtransaction(tx_replace)['vout']])
         self.sync_all()
         self.nodes[1].sendrawtransaction(hexstring=tx_replace, maxfeerate=0)
 
         # Now confirm tx_replace
         block_reorg = self.nodes[1].generatetoaddress(1, ADDRESS_WATCHONLY)[0]
         self.sync_all()
         assert_equal(self.nodes[0].getbalance(minconf=0), total_amount)
 
         self.log.info('Put txs back into mempool of node 1 (not node 0)')
         self.nodes[0].invalidateblock(block_reorg)
         self.nodes[1].invalidateblock(block_reorg)
         # wallet txs not in the mempool are untrusted
         assert_equal(self.nodes[0].getbalance(minconf=0), 0)
         self.nodes[0].generatetoaddress(1, ADDRESS_WATCHONLY)
         # wallet txs not in the mempool are untrusted
         assert_equal(self.nodes[0].getbalance(minconf=0), 0)
 
         # Now confirm tx_orig
         self.restart_node(1, ['-persistmempool=0'])
         self.connect_nodes(0, 1)
         self.sync_blocks()
         self.nodes[1].sendrawtransaction(tx_orig)
         self.nodes[1].generatetoaddress(1, ADDRESS_WATCHONLY)
         self.sync_all()
         # The reorg recovered our fee of 1 coin
         assert_equal(
             self.nodes[0].getbalance(
                 minconf=0),
             total_amount +
             1000000)
 
 
 if __name__ == '__main__':
     WalletTest().main()
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
index 0965be248..c932e6880 100755
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -1,672 +1,672 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 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 wallet."""
 from decimal import Decimal
 
 from test_framework.messages import CTransaction, FromHex
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_array_result,
     assert_equal,
     assert_fee_amount,
     assert_raises_rpc_error,
     count_bytes,
 )
 from test_framework.wallet_util import test_address
 
 
 class WalletTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = True
         self.extra_args = [
-            ["-acceptnonstdtxn=1"],
+            ["-acceptnonstdtxn=1", "-whitelist=noban@127.0.0.1"],
         ] * self.num_nodes
         self.supports_cli = False
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.setup_nodes()
         # Only need nodes 0-2 running at start of test
         self.stop_node(3)
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.connect_nodes(0, 2)
         self.sync_all(self.nodes[0:3])
 
     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
         assert_fee_amount(fee, tx_size, fee_per_byte * 1000)
         return curr_balance
 
     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)
 
         self.log.info("Mining blocks...")
 
         self.nodes[0].generate(1)
 
         walletinfo = self.nodes[0].getwalletinfo()
         assert_equal(walletinfo['immature_balance'], 50000000)
         assert_equal(walletinfo['balance'], 0)
 
         self.sync_all(self.nodes[0:3])
         self.nodes[1].generate(101)
         self.sync_all(self.nodes[0:3])
 
         assert_equal(self.nodes[0].getbalance(), 50000000)
         assert_equal(self.nodes[1].getbalance(), 50000000)
         assert_equal(self.nodes[2].getbalance(), 0)
 
         # Check that only first and second nodes have UTXOs
         utxos = self.nodes[0].listunspent()
         assert_equal(len(utxos), 1)
         assert_equal(len(self.nodes[1].listunspent()), 1)
         assert_equal(len(self.nodes[2].listunspent()), 0)
 
         self.log.info("test gettxout")
         confirmed_txid, confirmed_index = utxos[0]["txid"], utxos[0]["vout"]
         # First, outputs that are unspent both in the chain and in the
         # mempool should appear with or without include_mempool
         txout = self.nodes[0].gettxout(
             txid=confirmed_txid, n=confirmed_index, include_mempool=False)
         assert_equal(txout['value'], 50000000)
         txout = self.nodes[0].gettxout(
             txid=confirmed_txid, n=confirmed_index, include_mempool=True)
         assert_equal(txout['value'], 50000000)
 
         # Send 21,000,000 XEC from 0 to 2 using sendtoaddress call.
         self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11000000)
         mempool_txid = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 10000000)
 
         self.log.info("test gettxout (second part)")
         # utxo spent in mempool should be visible if you exclude mempool
         # but invisible if you include mempool
         txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, False)
         assert_equal(txout['value'], 50000000)
         txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, True)
         assert txout is None
         # new utxo from mempool should be invisible if you exclude mempool
         # but visible if you include mempool
         txout = self.nodes[0].gettxout(mempool_txid, 0, False)
         assert txout is None
         txout1 = self.nodes[0].gettxout(mempool_txid, 0, True)
         txout2 = self.nodes[0].gettxout(mempool_txid, 1, True)
         # note the mempool tx will have randomly assigned indices
         # but 10 will go to node2 and the rest will go to node0
         balance = self.nodes[0].getbalance()
         assert_equal(set([txout1['value'], txout2['value']]),
                      set([10000000, balance]))
         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(self.nodes[0:3])
 
         # Exercise locking of unspent outputs
         unspent_0 = self.nodes[2].listunspent()[0]
         unspent_0 = {"txid": unspent_0["txid"], "vout": unspent_0["vout"]}
         assert_raises_rpc_error(-8, "Invalid parameter, expected locked output",
                                 self.nodes[2].lockunspent, True, [unspent_0])
         self.nodes[2].lockunspent(False, [unspent_0])
         assert_raises_rpc_error(-8, "Invalid parameter, output already locked",
                                 self.nodes[2].lockunspent, False, [unspent_0])
         assert_raises_rpc_error(-6, "Insufficient funds",
                                 self.nodes[2].sendtoaddress, self.nodes[2].getnewaddress(), 20000000)
         assert_equal([unspent_0], self.nodes[2].listlockunspent())
         self.nodes[2].lockunspent(True, [unspent_0])
         assert_equal(len(self.nodes[2].listlockunspent()), 0)
         assert_raises_rpc_error(-8, "txid must be of length 64 (not 34, for '0000000000000000000000000000000000')",
                                 self.nodes[2].lockunspent, False,
                                 [{"txid": "0000000000000000000000000000000000", "vout": 0}])
         assert_raises_rpc_error(-8, "txid must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')",
                                 self.nodes[2].lockunspent, False,
                                 [{"txid": "ZZZ0000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
         assert_raises_rpc_error(-8, "Invalid parameter, unknown transaction",
                                 self.nodes[2].lockunspent, False,
                                 [{"txid": "0000000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
         assert_raises_rpc_error(-8, "Invalid parameter, vout index out of bounds",
                                 self.nodes[2].lockunspent, False, [{"txid": unspent_0["txid"], "vout": 999}])
 
         # The lock on a manually selected output is ignored
         unspent_0 = self.nodes[1].listunspent()[0]
         self.nodes[1].lockunspent(False, [unspent_0])
         tx = self.nodes[1].createrawtransaction(
             [unspent_0], {self.nodes[1].getnewaddress(): 1000000})
         tx = self.nodes[1].fundrawtransaction(tx)['hex']
         self.nodes[1].fundrawtransaction(tx, {"lockUnspents": True})
 
         # fundrawtransaction can lock an input
         self.nodes[1].lockunspent(True, [unspent_0])
         assert_equal(len(self.nodes[1].listlockunspent()), 0)
         tx = self.nodes[1].fundrawtransaction(
             tx, {"lockUnspents": True})['hex']
         assert_equal(len(self.nodes[1].listlockunspent()), 1)
 
         # Send transaction
         tx = self.nodes[1].signrawtransactionwithwallet(tx)["hex"]
         self.nodes[1].sendrawtransaction(tx)
         assert_equal(len(self.nodes[1].listlockunspent()), 0)
 
         # Have node1 generate 100 blocks (so node0 can recover the fee)
         self.nodes[1].generate(100)
         self.sync_all(self.nodes[0:3])
 
         # 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(), 100000000 - 21000000)
         assert_equal(self.nodes[2].getbalance(), 21000000)
 
         # 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()] = utxo["amount"] - 3000000
             raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
             txns_to_send.append(
                 self.nodes[0].signrawtransactionwithwallet(raw_tx))
 
         # Have node 1 (miner) send the transactions
         self.nodes[1].sendrawtransaction(
             hexstring=txns_to_send[0]["hex"], maxfeerate=0)
         self.nodes[1].sendrawtransaction(
             hexstring=txns_to_send[1]["hex"], maxfeerate=0)
 
         # Have node1 mine a block to confirm transactions:
         self.nodes[1].generate(1)
         self.sync_all(self.nodes[0:3])
 
         assert_equal(self.nodes[0].getbalance(), 0)
         assert_equal(self.nodes[2].getbalance(), 94000000)
 
         # Verify that a spent output cannot be locked anymore
         spent_0 = {"txid": node0utxos[0]["txid"],
                    "vout": node0utxos[0]["vout"]}
         assert_raises_rpc_error(-8, "Invalid parameter, expected unspent output",
                                 self.nodes[0].lockunspent, False, [spent_0])
 
         # Send 10,000,000 XEC normal
         old_balance = self.nodes[2].getbalance()
         address = self.nodes[0].getnewaddress("test")
         fee_per_byte = Decimal('1000') / 1000
         self.nodes[2].settxfee(fee_per_byte * 1000)
         txid = self.nodes[2].sendtoaddress(address, 10000000, "", "", False)
         self.nodes[2].generate(1)
         self.sync_all(self.nodes[0:3])
         ctx = FromHex(CTransaction(),
                       self.nodes[2].gettransaction(txid)['hex'])
 
         node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), old_balance - Decimal('10000000'),
                                            fee_per_byte, ctx.billable_size())
         assert_equal(self.nodes[0].getbalance(), Decimal('10000000'))
 
         # Send 10,000,000 XEC with subtract fee from amount
         txid = self.nodes[2].sendtoaddress(address, 10000000, "", "", True)
         self.nodes[2].generate(1)
         self.sync_all(self.nodes[0:3])
         node_2_bal -= Decimal('10000000')
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal(
             '20000000'), fee_per_byte, count_bytes(self.nodes[2].gettransaction(txid)['hex']))
 
         self.log.info("Test sendmany")
 
         # Sendmany 10,000,000 XEC
         txid = self.nodes[2].sendmany('', {address: 10000000}, 0, "", [])
         self.nodes[2].generate(1)
         self.sync_all(self.nodes[0:3])
         node_0_bal += Decimal('10000000')
         ctx = FromHex(CTransaction(),
                       self.nodes[2].gettransaction(txid)['hex'])
         node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(
         ), node_2_bal - Decimal('10000000'), fee_per_byte, ctx.billable_size())
         assert_equal(self.nodes[0].getbalance(), node_0_bal)
 
         # Sendmany 10,000,000 XEC with subtract fee from amount
         txid = self.nodes[2].sendmany(
             '', {address: 10000000}, 0, "", [address])
         self.nodes[2].generate(1)
         self.sync_all(self.nodes[0:3])
         node_2_bal -= Decimal('10000000')
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         ctx = FromHex(CTransaction(),
                       self.nodes[2].gettransaction(txid)['hex'])
         node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(
         ), node_0_bal + Decimal('10000000'), fee_per_byte, ctx.billable_size())
 
         self.start_node(3, self.extra_args[3])
         self.connect_nodes(0, 3)
         self.sync_all()
 
         # check if we can list zero value tx as available coins
         # 1. create raw_tx
         # 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(
             query_options={'minimumAmount': '49998000'})[0]
         inputs = [{"txid": usp['txid'], "vout": usp['vout']}]
         outputs = {self.nodes[1].getnewaddress(): 49998000,
                    self.nodes[0].getnewaddress(): 11110000}
 
         rawTx = self.nodes[1].createrawtransaction(inputs, outputs).replace(
             "c0833842", "00000000")  # replace 11.11 with 0.0 (int32)
         signed_raw_tx = self.nodes[1].signrawtransactionwithwallet(rawTx)
         decoded_raw_tx = self.nodes[1].decoderawtransaction(
             signed_raw_tx['hex'])
         zero_value_txid = decoded_raw_tx['txid']
         self.nodes[1].sendrawtransaction(signed_raw_tx['hex'])
 
         self.sync_all()
         self.nodes[1].generate(1)  # mine a block
         self.sync_all()
 
         # zero value tx must be in listunspents output
         unspent_txs = self.nodes[0].listunspent()
         found = False
         for uTx in unspent_txs:
             if uTx['txid'] == zero_value_txid:
                 found = True
                 assert_equal(uTx['amount'], Decimal('0'))
         assert found
 
         # do some -walletbroadcast tests
         self.stop_nodes()
         self.start_node(0, self.extra_args[0] + ["-walletbroadcast=0"])
         self.start_node(1, self.extra_args[1] + ["-walletbroadcast=0"])
         self.start_node(2, self.extra_args[2] + ["-walletbroadcast=0"])
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.connect_nodes(0, 2)
         self.sync_all(self.nodes[0:3])
 
         txid_not_broadcast = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 2000000)
         tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
         self.nodes[1].generate(1)  # mine a block, tx should not be in there
         self.sync_all(self.nodes[0:3])
         # should not be changed because tx was not broadcasted
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # now broadcast from another node, mine a block, sync, and check the
         # balance
         self.nodes[1].sendrawtransaction(tx_obj_not_broadcast['hex'])
         self.nodes[1].generate(1)
         self.sync_all(self.nodes[0:3])
         node_2_bal += 2000000
         tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # create another tx
         txid_not_broadcast = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 2000000)
 
         # restart the nodes with -walletbroadcast=1
         self.stop_nodes()
         self.start_node(0, self.extra_args[0])
         self.start_node(1, self.extra_args[1])
         self.start_node(2, self.extra_args[2])
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
         self.connect_nodes(0, 2)
         self.sync_blocks(self.nodes[0:3])
 
         self.nodes[0].generate(1)
         self.sync_blocks(self.nodes[0:3])
         node_2_bal += 2000000
 
         # tx should be added to balance because after restarting the nodes tx
         # should be broadcasted
         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(), "2000000")
         tx_obj = self.nodes[0].gettransaction(txid)
         assert_equal(tx_obj['amount'], Decimal('-2000000'))
 
         txid = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), "10000")
         tx_obj = self.nodes[0].gettransaction(txid)
         assert_equal(tx_obj['amount'], Decimal('-10000'))
 
         # check if JSON parser can handle scientific notation in strings
         txid = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), "1e3")
         tx_obj = self.nodes[0].gettransaction(txid)
         assert_equal(tx_obj['amount'], Decimal('-1000'))
 
         # General checks for errors from incorrect inputs
         # This will raise an exception because the amount is negative
         assert_raises_rpc_error(-3,
                                 "Amount out of range",
                                 self.nodes[0].sendtoaddress,
                                 self.nodes[2].getnewaddress(),
                                 "-1")
 
         # This will raise an exception because the amount type is wrong
         assert_raises_rpc_error(-3, "Invalid amount",
                                 self.nodes[0].sendtoaddress, self.nodes[2].getnewaddress(), "1f-4")
 
         # This will raise an exception since generate does not accept a string
         assert_raises_rpc_error(-1, "not an integer",
                                 self.nodes[0].generate, "2")
 
         # This will raise an exception for the invalid private key format
         assert_raises_rpc_error(-5,
                                 "Invalid private key encoding",
                                 self.nodes[0].importprivkey,
                                 "invalid")
 
         # This will raise an exception for importing an address with the PS2H
         # flag
         temp_address = self.nodes[1].getnewaddress()
         assert_raises_rpc_error(-5,
                                 "Cannot use the p2sh flag with an address - use a script instead",
                                 self.nodes[0].importaddress,
                                 temp_address,
                                 "label",
                                 False,
                                 True)
 
         # This will raise an exception for attempting to dump the private key
         # of an address you do not own
         assert_raises_rpc_error(-4,
                                 "Private key for address",
                                 self.nodes[0].dumpprivkey,
                                 temp_address)
 
         # This will raise an exception for attempting to get the private key of
         # an invalid Bitcoin address
         assert_raises_rpc_error(-5,
                                 "Invalid Bitcoin address",
                                 self.nodes[0].dumpprivkey,
                                 "invalid")
 
         # This will raise an exception for attempting to set a label for an
         # invalid Bitcoin address
         assert_raises_rpc_error(-5,
                                 "Invalid Bitcoin address",
                                 self.nodes[0].setlabel,
                                 "invalid address",
                                 "label")
 
         # This will raise an exception for importing an invalid address
         assert_raises_rpc_error(-5,
                                 "Invalid Bitcoin address or script",
                                 self.nodes[0].importaddress,
                                 "invalid")
 
         # This will raise an exception for attempting to import a pubkey that
         # isn't in hex
         assert_raises_rpc_error(-5,
                                 "Pubkey must be a hex string",
                                 self.nodes[0].importpubkey,
                                 "not hex")
 
         # This will raise an exception for importing an invalid pubkey
         assert_raises_rpc_error(-5,
                                 "Pubkey is not a valid public key",
                                 self.nodes[0].importpubkey,
                                 "5361746f736869204e616b616d6f746f")
 
         # 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, 1000000)
         self.nodes[0].generate(1)
         self.sync_all(self.nodes[0:3])
 
         # 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].getaddressinfo(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
         coinbase_addr = self.nodes[1].getnewaddress()
         block_hash = self.nodes[0].generatetoaddress(1, coinbase_addr)[0]
         coinbase_txid = self.nodes[0].getblock(block_hash)['tx'][0]
         self.sync_all(self.nodes[0:3])
 
         # Check that the txid and balance is found by node1
         self.nodes[1].gettransaction(coinbase_txid)
 
         # check if wallet or blockchain maintenance changes the balance
         self.sync_all(self.nodes[0:3])
         blocks = self.nodes[0].generate(2)
         self.sync_all(self.nodes[0:3])
         balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
         block_count = self.nodes[0].getblockcount()
 
         # Check modes:
         #   - True: unicode escaped as \u....
         #   - False: unicode directly as UTF-8
         for mode in [True, False]:
             self.nodes[0].rpc.ensure_ascii = mode
             # unicode check: Basic Multilingual Plane, Supplementary Plane
             # respectively
             for label in [u'рыба', u'𝅘𝅥𝅯']:
                 addr = self.nodes[0].getnewaddress()
                 self.nodes[0].setlabel(addr, label)
                 test_address(self.nodes[0], addr, labels=[label])
                 assert label in self.nodes[0].listlabels()
         # restore to default
         self.nodes[0].rpc.ensure_ascii = True
 
         # maintenance tests
         maintenance = [
             '-rescan',
             '-reindex',
         ]
         chainlimit = 6
         for m in maintenance:
             self.log.info("check " + m)
             self.stop_nodes()
             # set lower ancestor limit for later
             self.start_node(
                 0, self.extra_args[0] + [m, "-limitancestorcount=" + str(chainlimit)])
             self.start_node(
                 1, self.extra_args[1] + [m, "-limitancestorcount=" + str(chainlimit)])
             self.start_node(
                 2, self.extra_args[2] + [m, "-limitancestorcount=" + str(chainlimit)])
             if m == '-reindex':
                 # reindex will leave rpc warm up "early"; Wait for it to finish
                 self.wait_until(
                     lambda: [block_count] * 3 ==
                             [self.nodes[i].getblockcount() for i in range(3)])
             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)
 
         # ==Check that wallet prefers to use coins that don't exceed mempool li
 
         # Get all non-zero utxos together
         chain_addrs = [self.nodes[0].getnewaddress(
         ), self.nodes[0].getnewaddress()]
         singletxid = self.nodes[0].sendtoaddress(
             chain_addrs[0], self.nodes[0].getbalance(), "", "", True)
         self.nodes[0].generate(1)
         node0_balance = self.nodes[0].getbalance()
         # Split into two chains
         rawtx = self.nodes[0].createrawtransaction([{"txid": singletxid, "vout": 0}], {
                                                    chain_addrs[0]: node0_balance / 2 - Decimal('10000'), chain_addrs[1]: node0_balance / 2 - Decimal('10000')})
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         singletxid = self.nodes[0].sendrawtransaction(
             hexstring=signedtx["hex"], maxfeerate=0)
         self.nodes[0].generate(1)
 
         # Make a long chain of unconfirmed payments without hitting mempool limit
         # Each tx we make leaves only one output of change on a chain 1 longer
         # Since the amount to send is always much less than the outputs, we only ever need one output
         # So we should be able to generate exactly chainlimit txs for each
         # original output
         sending_addr = self.nodes[1].getnewaddress()
         txid_list = []
         for _ in range(chainlimit * 2):
             txid_list.append(self.nodes[0].sendtoaddress(
                 sending_addr, Decimal('10000')))
         assert_equal(self.nodes[0].getmempoolinfo()['size'], chainlimit * 2)
         assert_equal(len(txid_list), chainlimit * 2)
 
         # Without walletrejectlongchains, we will still generate a txid
         # The tx will be stored in the wallet but not accepted to the mempool
         extra_txid = self.nodes[0].sendtoaddress(
             sending_addr, Decimal('10000'))
         assert extra_txid not in self.nodes[0].getrawmempool()
         assert extra_txid in [tx["txid"]
                               for tx in self.nodes[0].listtransactions()]
         self.nodes[0].abandontransaction(extra_txid)
         total_txs = len(self.nodes[0].listtransactions("*", 99999))
 
         # Try with walletrejectlongchains
         # Double chain limit but require combining inputs, so we pass
         # SelectCoinsMinConf
         self.stop_node(0)
         self.start_node(0,
                         self.extra_args[0] + ["-walletrejectlongchains",
                                               "-limitancestorcount=" + str(2 * chainlimit)])
 
         # wait until the wallet has submitted all transactions to the mempool
         self.wait_until(
             lambda: len(self.nodes[0].getrawmempool()) == chainlimit * 2)
 
         # Prevent potential race condition when calling wallet RPCs right after
         # restart
         self.nodes[0].syncwithvalidationinterfacequeue()
 
         node0_balance = self.nodes[0].getbalance()
         # With walletrejectlongchains we will not create the tx and store it in
         # our wallet.
         assert_raises_rpc_error(-6, "Transaction has too long of a mempool chain",
                                 self.nodes[0].sendtoaddress, sending_addr, node0_balance - Decimal('10000'))
 
         # Verify nothing new in wallet
         assert_equal(total_txs, len(
             self.nodes[0].listtransactions("*", 99999)))
 
         # Test getaddressinfo on external address. Note that these addresses
         # are taken from disablewallet.py
         assert_raises_rpc_error(-5, "Invalid address",
                                 self.nodes[0].getaddressinfo, "3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy")
         address_info = self.nodes[0].getaddressinfo(
             "mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ")
         assert_equal(address_info['address'],
                      "ecregtest:qp8rs4qyd3aazk22eyzwg7fmdfzmxm02pyprkfhvm4")
         assert_equal(address_info["scriptPubKey"],
                      "76a9144e3854046c7bd1594ac904e4793b6a45b36dea0988ac")
         assert not address_info["ismine"]
         assert not address_info["iswatchonly"]
         assert not address_info["isscript"]
         assert not address_info["ischange"]
 
         # Test getaddressinfo 'ischange' field on change address.
         self.nodes[0].generate(1)
         destination = self.nodes[1].getnewaddress()
         txid = self.nodes[0].sendtoaddress(destination, 123000)
         tx = self.nodes[0].decoderawtransaction(
             self.nodes[0].gettransaction(txid)['hex'])
         output_addresses = [vout['scriptPubKey']['addresses'][0]
                             for vout in tx["vout"]]
         assert len(output_addresses) > 1
         for address in output_addresses:
             ischange = self.nodes[0].getaddressinfo(address)['ischange']
             assert_equal(ischange, address != destination)
             if ischange:
                 change = address
         self.nodes[0].setlabel(change, 'foobar')
         assert_equal(self.nodes[0].getaddressinfo(change)['ischange'], False)
 
         # Test gettransaction response with different arguments.
         self.log.info(
             "Testing gettransaction response with different arguments...")
         self.nodes[0].setlabel(change, 'baz')
         baz = self.nodes[0].listtransactions(label="baz", count=1)[0]
         expected_receive_vout = {"label": "baz",
                                  "address": baz["address"],
                                  "amount": baz["amount"],
                                  "category": baz["category"],
                                  "vout": baz["vout"]}
         expected_fields = frozenset({'amount',
                                      'confirmations',
                                      'details',
                                      'fee',
                                      'hex',
                                      'time',
                                      'timereceived',
                                      'trusted',
                                      'txid',
                                      'walletconflicts'})
         verbose_field = "decoded"
         expected_verbose_fields = expected_fields | {verbose_field}
 
         self.log.debug("Testing gettransaction response without verbose")
         tx = self.nodes[0].gettransaction(txid=txid)
         assert_equal(set([*tx]), expected_fields)
         assert_array_result(
             tx["details"], {
                 "category": "receive"}, expected_receive_vout)
 
         self.log.debug(
             "Testing gettransaction response with verbose set to False")
         tx = self.nodes[0].gettransaction(txid=txid, verbose=False)
         assert_equal(set([*tx]), expected_fields)
         assert_array_result(
             tx["details"], {
                 "category": "receive"}, expected_receive_vout)
 
         self.log.debug(
             "Testing gettransaction response with verbose set to True")
         tx = self.nodes[0].gettransaction(txid=txid, verbose=True)
         assert_equal(set([*tx]), expected_verbose_fields)
         assert_array_result(
             tx["details"], {
                 "category": "receive"}, expected_receive_vout)
         assert_equal(
             tx[verbose_field],
             self.nodes[0].decoderawtransaction(
                 tx["hex"]))
 
 
 if __name__ == '__main__':
     WalletTest().main()
diff --git a/test/functional/wallet_groups.py b/test/functional/wallet_groups.py
index 53cf46d64..919378da8 100755
--- a/test/functional/wallet_groups.py
+++ b/test/functional/wallet_groups.py
@@ -1,182 +1,186 @@
 #!/usr/bin/env python3
 # Copyright (c) 2018 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 wallet group functionality."""
 
 from test_framework.messages import CTransaction, FromHex, ToHex
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_approx, assert_equal
 
 
 class WalletGroupTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 5
         self.extra_args = [
             [],
             [],
             ['-avoidpartialspends'],
             # 2.93 XEC is the threshold that causes a node to prefer a
             # non-grouped tx (3 inputs, 2 outputs) to a grouped tx (5 inputs,
             # 2 outputs). The fee for the grouped tx is 294 sats higher than
             # the fee for the non-grouped tx. See tx5 below.
             ["-maxapsfee=2.93"],
             ["-maxapsfee=2.94"]]
+        # whitelist peers to speed up tx relay / mempool sync
+        for args in self.extra_args:
+            args.append("-whitelist=noban@127.0.0.1")
+
         self.rpc_timeout = 120
         self.supports_cli = False
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         # Mine some coins
         self.nodes[0].generate(110)
 
         # Get some addresses from the two nodes
         addr1 = [self.nodes[1].getnewaddress() for _ in range(3)]
         addr2 = [self.nodes[2].getnewaddress() for _ in range(3)]
         addrs = addr1 + addr2
 
         # Send 1 + 0.5 coin to each address
         [self.nodes[0].sendtoaddress(addr, 1000000) for addr in addrs]
         [self.nodes[0].sendtoaddress(addr, 500000) for addr in addrs]
 
         self.nodes[0].generate(1)
         self.sync_all()
 
         # For each node, send 0.2 coins back to 0;
         # - node[1] should pick one 0.5 UTXO and leave the rest
         # - node[2] should pick one (1.0 + 0.5) UTXO group corresponding to a
         #   given address, and leave the rest
         txid1 = self.nodes[1].sendtoaddress(
             self.nodes[0].getnewaddress(), 200000)
         tx1 = self.nodes[1].getrawtransaction(txid1, True)
         # txid1 should have 1 input and 2 outputs
         assert_equal(1, len(tx1["vin"]))
         assert_equal(2, len(tx1["vout"]))
         # one output should be 0.2, the other should be ~0.3
         v = sorted([vout["value"] for vout in tx1["vout"]])
         assert_approx(v[0], vexp=200_000, vspan=100)
         assert_approx(v[1], vexp=300_000, vspan=100)
 
         txid2 = self.nodes[2].sendtoaddress(
             self.nodes[0].getnewaddress(), 200000)
         tx2 = self.nodes[2].getrawtransaction(txid2, True)
         # txid2 should have 2 inputs and 2 outputs
         assert_equal(2, len(tx2["vin"]))
         assert_equal(2, len(tx2["vout"]))
         # one output should be 0.2, the other should be ~1.3
         v = sorted([vout["value"] for vout in tx2["vout"]])
         assert_approx(v[0], vexp=200_000, vspan=100)
         assert_approx(v[1], vexp=1_300_000, vspan=100)
 
         # Test 'avoid partial if warranted, even if disabled'
         self.sync_all()
         self.nodes[0].generate(1)
         # Nodes 1-2 now have confirmed UTXOs (letters denote destinations):
         # Node #1:      Node #2:
         # - A  1.0      - D0 1.0
         # - B0 1.0      - D1 0.5
         # - B1 0.5      - E0 1.0
         # - C0 1.0      - E1 0.5
         # - C1 0.5      - F  ~1.3
         # - D ~0.3
         assert_approx(self.nodes[1].getbalance(), vexp=4_300_000, vspan=100)
         assert_approx(self.nodes[2].getbalance(), vexp=4_300_000, vspan=100)
         # Sending 1.4 btc should pick one 1.0 + one more. For node #1,
         # this could be (A / B0 / C0) + (B1 / C1 / D). We ensure that it is
         # B0 + B1 or C0 + C1, because this avoids partial spends while not being
         # detrimental to transaction cost
         txid3 = self.nodes[1].sendtoaddress(
             self.nodes[0].getnewaddress(), 1400000)
         tx3 = self.nodes[1].getrawtransaction(txid3, True)
         # tx3 should have 2 inputs and 2 outputs
         assert_equal(2, len(tx3["vin"]))
         assert_equal(2, len(tx3["vout"]))
         # the accumulated value should be 1.5, so the outputs should be
         # ~0.1 and 1.4 and should come from the same destination
         values = sorted([vout["value"] for vout in tx3["vout"]])
         assert_approx(values[0], vexp=100_000, vspan=100)
         assert_approx(values[1], vexp=1_400_000, vspan=100)
 
         input_txids = [vin["txid"] for vin in tx3["vin"]]
         input_addrs = [self.nodes[1].gettransaction(
             txid)['details'][0]['address'] for txid in input_txids]
         assert_equal(input_addrs[0], input_addrs[1])
         # Node 2 enforces avoidpartialspends so needs no checking here
 
         # Test wallet option maxapsfee with Node 3
         addr_aps = self.nodes[3].getnewaddress()
         self.nodes[0].sendtoaddress(addr_aps, 1000000)
         self.nodes[0].sendtoaddress(addr_aps, 1000000)
         self.nodes[0].generate(1)
         self.sync_all()
         with self.nodes[3].assert_debug_log([
                 'Fee non-grouped = 225, grouped = 372, using grouped']):
             txid4 = self.nodes[3].sendtoaddress(
                 self.nodes[0].getnewaddress(), 100_000)
         tx4 = self.nodes[3].getrawtransaction(txid4, True)
         # tx4 should have 2 inputs and 2 outputs although one output would
         # have been enough and the transaction caused higher fees
         assert_equal(2, len(tx4["vin"]))
         assert_equal(2, len(tx4["vout"]))
 
         addr_aps2 = self.nodes[3].getnewaddress()
         [self.nodes[0].sendtoaddress(addr_aps2, 1_000_000) for _ in range(5)]
         self.nodes[0].generate(1)
         self.sync_all()
         with self.nodes[3].assert_debug_log([
                 'Fee non-grouped = 519, grouped = 813, using non-grouped']):
             txid5 = self.nodes[3].sendtoaddress(self.nodes[0].getnewaddress(),
                                                 2_950_000)
         tx5 = self.nodes[3].getrawtransaction(txid5, True)
         # tx5 should have 3 inputs (1.0, 1.0, 1.0) and 2 outputs
         assert_equal(3, len(tx5["vin"]))
         assert_equal(2, len(tx5["vout"]))
 
         # Test wallet option maxapsfee with node 4, which sets maxapsfee
         # 1 sat higher, crossing the threshold from non-grouped to grouped.
         addr_aps3 = self.nodes[4].getnewaddress()
         [self.nodes[0].sendtoaddress(addr_aps3, 1_000_000) for _ in range(5)]
         self.nodes[0].generate(1)
         self.sync_all()
         with self.nodes[4].assert_debug_log([
                 'Fee non-grouped = 519, grouped = 813, using grouped']):
             txid6 = self.nodes[4].sendtoaddress(self.nodes[0].getnewaddress(),
                                                 2_950_000)
         tx6 = self.nodes[4].getrawtransaction(txid6, True)
         # tx6 should have 5 inputs and 2 outputs
         assert_equal(5, len(tx6["vin"]))
         assert_equal(2, len(tx6["vout"]))
 
         # Empty out node2's wallet
         self.nodes[2].sendtoaddress(address=self.nodes[0].getnewaddress(
         ), amount=self.nodes[2].getbalance(), subtractfeefromamount=True)
         self.sync_all()
         self.nodes[0].generate(1)
 
         # Fill node2's wallet with 10000 outputs corresponding to the same
         # scriptPubKey
         for _ in range(5):
             raw_tx = self.nodes[0].createrawtransaction(
                 [{"txid": "0" * 64, "vout": 0}], [{addr2[0]: 50_000}])
             tx = FromHex(CTransaction(), raw_tx)
             tx.vin = []
             tx.vout = [tx.vout[0]] * 2000
             funded_tx = self.nodes[0].fundrawtransaction(ToHex(tx))
             signed_tx = self.nodes[0].signrawtransactionwithwallet(
                 funded_tx['hex'])
             self.nodes[0].sendrawtransaction(signed_tx['hex'])
             self.nodes[0].generate(1)
 
         self.sync_all()
 
         # Check that we can create a transaction that only requires ~100 of our
         # utxos, without pulling in all outputs and creating a transaction that
         # is way too big.
         assert self.nodes[2].sendtoaddress(address=addr2[0], amount=5000000)
 
 
 if __name__ == '__main__':
     WalletGroupTest().main()
diff --git a/test/functional/wallet_hd.py b/test/functional/wallet_hd.py
index 36fdea62a..998c8a458 100755
--- a/test/functional/wallet_hd.py
+++ b/test/functional/wallet_hd.py
@@ -1,351 +1,355 @@
 #!/usr/bin/env python3
 # Copyright (c) 2016-2019 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 Hierarchical Deterministic wallet function."""
 
 import os
 import shutil
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 
 
 class WalletHDTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [[], ['-keypool=0']]
+        # whitelist peers to speed up tx relay / mempool sync
+        for args in self.extra_args:
+            args.append("-whitelist=noban@127.0.0.1")
+
         self.supports_cli = False
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         # Make sure we use hd, keep masterkeyid
         hd_fingerprint = self.nodes[1].getaddressinfo(
             self.nodes[1].getnewaddress())['hdmasterfingerprint']
         assert_equal(len(hd_fingerprint), 8)
 
         # create an internal key
         change_addr = self.nodes[1].getrawchangeaddress()
         change_addrV = self.nodes[1].getaddressinfo(change_addr)
         if self.options.descriptors:
             assert_equal(change_addrV["hdkeypath"], "m/44'/1'/0'/1/0")
         else:
             # first internal child key
             assert_equal(change_addrV["hdkeypath"], "m/0'/1'/0'")
 
         # Import a non-HD private key in the HD wallet
         non_hd_add = 'ecregtest:qr09jgufyeae4s97nqp6mv0tv6eymfunygeyv0llfe'
         non_hd_key = 'cS9umN9w6cDMuRVYdbkfE4c7YUFLJRoXMfhQ569uY4odiQbVN8Rt'
         self.nodes[1].importprivkey(non_hd_key)
 
         # This should be enough to keep the master key and the non-HD key
         self.nodes[1].backupwallet(
             os.path.join(self.nodes[1].datadir, "hd.bak"))
         # self.nodes[1].dumpwallet(os.path.join(self.nodes[1].datadir, "hd.dump"))
 
         # Derive some HD addresses and remember the last
         # Also send funds to each add
         self.nodes[0].generate(101)
         hd_add = None
         NUM_HD_ADDS = 10
         for i in range(1, NUM_HD_ADDS + 1):
             hd_add = self.nodes[1].getnewaddress()
             hd_info = self.nodes[1].getaddressinfo(hd_add)
             if self.options.descriptors:
                 assert_equal(hd_info["hdkeypath"], "m/44'/1'/0'/0/" + str(i))
             else:
                 assert_equal(hd_info["hdkeypath"], "m/0'/0'/" + str(i) + "'")
                 assert_equal(hd_info["hdmasterfingerprint"], hd_fingerprint)
             self.nodes[0].sendtoaddress(hd_add, 1000000)
             self.nodes[0].generate(1)
         self.nodes[0].sendtoaddress(non_hd_add, 1000000)
         self.nodes[0].generate(1)
 
         # create an internal key (again)
         change_addr = self.nodes[1].getrawchangeaddress()
         change_addrV = self.nodes[1].getaddressinfo(change_addr)
         if self.options.descriptors:
             assert_equal(change_addrV["hdkeypath"], "m/44'/1'/0'/1/1")
         else:
             # second internal child key
             assert_equal(change_addrV["hdkeypath"], "m/0'/1'/1'")
 
         self.sync_all()
         assert_equal(
             self.nodes[1].getbalance(),
             (NUM_HD_ADDS * 1000000) + 1000000)
 
         self.log.info("Restore backup ...")
         self.stop_node(1)
         # we need to delete the complete regtest directory
         # otherwise node1 would auto-recover all funds in flag the keypool keys
         # as used
         shutil.rmtree(
             os.path.join(
                 self.nodes[1].datadir,
                 self.chain,
                 "blocks"))
         shutil.rmtree(os.path.join(
             self.nodes[1].datadir, self.chain, "chainstate"))
         shutil.copyfile(
             os.path.join(self.nodes[1].datadir, "hd.bak"),
             os.path.join(self.nodes[1].datadir, self.chain, 'wallets',
                          self.default_wallet_name, self.wallet_data_filename))
         self.start_node(1)
 
         # Assert that derivation is deterministic
         hd_add_2 = None
         for i in range(1, NUM_HD_ADDS + 1):
             hd_add_2 = self.nodes[1].getnewaddress()
             hd_info_2 = self.nodes[1].getaddressinfo(hd_add_2)
             if self.options.descriptors:
                 assert_equal(hd_info_2["hdkeypath"], "m/44'/1'/0'/0/" + str(i))
             else:
                 assert_equal(hd_info_2["hdkeypath"], "m/0'/0'/" + str(i) + "'")
             assert_equal(hd_info_2["hdmasterfingerprint"], hd_fingerprint)
         assert_equal(hd_add, hd_add_2)
         self.connect_nodes(0, 1)
         self.sync_all()
 
         # Needs rescan
         self.restart_node(1, extra_args=self.extra_args[1] + ['-rescan'])
         assert_equal(
             self.nodes[1].getbalance(),
             (NUM_HD_ADDS * 1000000) + 1000000)
 
         # Try a RPC based rescan
         self.stop_node(1)
         shutil.rmtree(
             os.path.join(
                 self.nodes[1].datadir,
                 self.chain,
                 "blocks"))
         shutil.rmtree(os.path.join(
             self.nodes[1].datadir, self.chain, "chainstate"))
         shutil.copyfile(
             os.path.join(self.nodes[1].datadir, "hd.bak"),
             os.path.join(self.nodes[1].datadir, self.chain, "wallets",
                          self.default_wallet_name, self.wallet_data_filename))
         self.start_node(1, extra_args=self.extra_args[1])
         self.connect_nodes(0, 1)
         self.sync_all()
         # Wallet automatically scans blocks older than key on startup
         assert_equal(
             self.nodes[1].getbalance(),
             (NUM_HD_ADDS * 1000000) + 1000000)
         out = self.nodes[1].rescanblockchain(0, 1)
         assert_equal(out['start_height'], 0)
         assert_equal(out['stop_height'], 1)
         out = self.nodes[1].rescanblockchain(2, 4)
         assert_equal(out['start_height'], 2)
         assert_equal(out['stop_height'], 4)
         out = self.nodes[1].rescanblockchain(3)
         assert_equal(out['start_height'], 3)
         assert_equal(out['stop_height'], self.nodes[1].getblockcount())
         out = self.nodes[1].rescanblockchain()
         assert_equal(out['start_height'], 0)
         assert_equal(out['stop_height'], self.nodes[1].getblockcount())
         assert_equal(
             self.nodes[1].getbalance(),
             (NUM_HD_ADDS * 1000000) + 1000000)
 
         # send a tx and make sure its using the internal chain for the
         # changeoutput
         txid = self.nodes[1].sendtoaddress(
             self.nodes[0].getnewaddress(), 1000000)
         outs = self.nodes[1].decoderawtransaction(
             self.nodes[1].gettransaction(txid)['hex'])['vout']
         keypath = ""
         for out in outs:
             if out['value'] != 1000000:
                 keypath = self.nodes[1].getaddressinfo(
                     out['scriptPubKey']['addresses'][0])['hdkeypath']
 
         if self.options.descriptors:
             assert_equal(keypath[0:14], "m/44'/1'/0'/1/")
         else:
             assert_equal(keypath[0:7], "m/0'/1'")
 
         if not self.options.descriptors:
             # Generate a new HD seed on node 1 and make sure it is set
             orig_masterkeyid = self.nodes[1].getwalletinfo()['hdseedid']
             self.nodes[1].sethdseed()
             new_masterkeyid = self.nodes[1].getwalletinfo()['hdseedid']
             assert orig_masterkeyid != new_masterkeyid
             addr = self.nodes[1].getnewaddress()
             # Make sure the new address is the first from the keypool
             assert_equal(self.nodes[1].getaddressinfo(
                 addr)['hdkeypath'], 'm/0\'/0\'/0\'')
             # Fill keypool with 1 key
             self.nodes[1].keypoolrefill(1)
 
             # Set a new HD seed on node 1 without flushing the keypool
             new_seed = self.nodes[0].dumpprivkey(self.nodes[0].getnewaddress())
             orig_masterkeyid = new_masterkeyid
             self.nodes[1].sethdseed(False, new_seed)
             new_masterkeyid = self.nodes[1].getwalletinfo()['hdseedid']
             assert orig_masterkeyid != new_masterkeyid
             addr = self.nodes[1].getnewaddress()
             assert_equal(orig_masterkeyid, self.nodes[1].getaddressinfo(
                 addr)['hdseedid'])
             # Make sure the new address continues previous keypool
             assert_equal(self.nodes[1].getaddressinfo(
                 addr)['hdkeypath'], 'm/0\'/0\'/1\'')
 
             # Check that the next address is from the new seed
             self.nodes[1].keypoolrefill(1)
             next_addr = self.nodes[1].getnewaddress()
             assert_equal(new_masterkeyid, self.nodes[1].getaddressinfo(
                 next_addr)['hdseedid'])
             # Make sure the new address is not from previous keypool
             assert_equal(self.nodes[1].getaddressinfo(
                 next_addr)['hdkeypath'], 'm/0\'/0\'/0\'')
             assert next_addr != addr
 
             # Sethdseed parameter validity
             assert_raises_rpc_error(-1, 'sethdseed', self.nodes[0].sethdseed,
                                     False, new_seed, 0)
             assert_raises_rpc_error(-5, "Invalid private key",
                                     self.nodes[1].sethdseed, False, "not_wif")
             assert_raises_rpc_error(
                 -1, "JSON value is not a boolean as expected",
                 self.nodes[1].sethdseed, "Not_bool")
             assert_raises_rpc_error(
                 -1, "JSON value is not a string as expected",
                 self.nodes[1].sethdseed, False, True)
             assert_raises_rpc_error(
                 -5, "Already have this key", self.nodes[1].sethdseed, False,
                 new_seed)
             assert_raises_rpc_error(
                 -5, "Already have this key", self.nodes[1].sethdseed, False,
                 self.nodes[1].dumpprivkey(self.nodes[1].getnewaddress()))
 
             self.log.info(
                 'Test sethdseed restoring with keys outside of the initial keypool')
             self.nodes[0].generate(10)
             # Restart node 1 with keypool of 3 and a different wallet
             self.nodes[1].createwallet(wallet_name='origin', blank=True)
             self.restart_node(1, extra_args=['-keypool=3', '-wallet=origin'])
             self.connect_nodes(0, 1)
 
             # sethdseed restoring and seeing txs to addresses out of the
             # keypool
             origin_rpc = self.nodes[1].get_wallet_rpc('origin')
             seed = self.nodes[0].dumpprivkey(self.nodes[0].getnewaddress())
             origin_rpc.sethdseed(True, seed)
 
             self.nodes[1].createwallet(wallet_name='restore', blank=True)
             restore_rpc = self.nodes[1].get_wallet_rpc('restore')
             # Set to be the same seed as origin_rpc
             restore_rpc.sethdseed(True, seed)
             # Rotate to a new seed, making original `seed` inactive
             restore_rpc.sethdseed(True)
 
             self.nodes[1].createwallet(wallet_name='restore2', blank=True)
             restore2_rpc = self.nodes[1].get_wallet_rpc('restore2')
             # Set to be the same seed as origin_rpc
             restore2_rpc.sethdseed(True, seed)
             # Rotate to a new seed, making original `seed` inactive
             restore2_rpc.sethdseed(True)
 
             # Check persistence of inactive seed by reloading restore. restore2
             # is still loaded to test the case where the wallet is not reloaded
             restore_rpc.unloadwallet()
             self.nodes[1].loadwallet('restore')
             restore_rpc = self.nodes[1].get_wallet_rpc('restore')
 
             # Empty origin keypool and get an address that is beyond the
             # initial keypool
             origin_rpc.getnewaddress()
             origin_rpc.getnewaddress()
             # Last address of initial keypool
             last_addr = origin_rpc.getnewaddress()
             # First address beyond initial keypool
             addr = origin_rpc.getnewaddress()
 
             # Check that the restored seed has last_addr but does not have addr
             info = restore_rpc.getaddressinfo(last_addr)
             assert_equal(info['ismine'], True)
             info = restore_rpc.getaddressinfo(addr)
             assert_equal(info['ismine'], False)
             info = restore2_rpc.getaddressinfo(last_addr)
             assert_equal(info['ismine'], True)
             info = restore2_rpc.getaddressinfo(addr)
             assert_equal(info['ismine'], False)
             # Check that the origin seed has addr
             info = origin_rpc.getaddressinfo(addr)
             assert_equal(info['ismine'], True)
 
             # Send a transaction to addr, which is out of the initial keypool.
             # The wallet that has set a new seed (restore_rpc) should not
             # detect this transaction.
             txid = self.nodes[0].sendtoaddress(addr, 1000000)
             origin_rpc.sendrawtransaction(
                 self.nodes[0].gettransaction(txid)['hex'])
             self.nodes[0].generate(1)
             self.sync_blocks()
             origin_rpc.gettransaction(txid)
             assert_raises_rpc_error(-5,
                                     'Invalid or non-wallet transaction id',
                                     restore_rpc.gettransaction,
                                     txid)
             out_of_kp_txid = txid
 
             # Send a transaction to last_addr, which is in the initial keypool.
             # The wallet that has set a new seed (restore_rpc) should detect
             # this transaction and generate 3 new keys from the initial seed.
             # The previous transaction (out_of_kp_txid) should still not be
             # detected as a rescan is required.
             txid = self.nodes[0].sendtoaddress(last_addr, 1000000)
             origin_rpc.sendrawtransaction(
                 self.nodes[0].gettransaction(txid)['hex'])
             self.nodes[0].generate(1)
             self.sync_blocks()
             origin_rpc.gettransaction(txid)
             restore_rpc.gettransaction(txid)
             assert_raises_rpc_error(-5,
                                     'Invalid or non-wallet transaction id',
                                     restore_rpc.gettransaction,
                                     out_of_kp_txid)
             restore2_rpc.gettransaction(txid)
             assert_raises_rpc_error(-5,
                                     'Invalid or non-wallet transaction id',
                                     restore2_rpc.gettransaction,
                                     out_of_kp_txid)
 
             # After rescanning, restore_rpc should now see out_of_kp_txid and
             # generate an additional key.
             # addr should now be part of restore_rpc and be ismine
             restore_rpc.rescanblockchain()
             restore_rpc.gettransaction(out_of_kp_txid)
             info = restore_rpc.getaddressinfo(addr)
             assert_equal(info['ismine'], True)
             restore2_rpc.rescanblockchain()
             restore2_rpc.gettransaction(out_of_kp_txid)
             info = restore2_rpc.getaddressinfo(addr)
             assert_equal(info['ismine'], True)
 
             # Check again that 3 keys were derived.
             # Empty keypool and get an address that is beyond the initial
             # keypool
             origin_rpc.getnewaddress()
             origin_rpc.getnewaddress()
             last_addr = origin_rpc.getnewaddress()
             addr = origin_rpc.getnewaddress()
 
             # Check that the restored seed has last_addr but does not have addr
             info = restore_rpc.getaddressinfo(last_addr)
             assert_equal(info['ismine'], True)
             info = restore_rpc.getaddressinfo(addr)
             assert_equal(info['ismine'], False)
             info = restore2_rpc.getaddressinfo(last_addr)
             assert_equal(info['ismine'], True)
             info = restore2_rpc.getaddressinfo(addr)
             assert_equal(info['ismine'], False)
 
 
 if __name__ == '__main__':
     WalletHDTest().main()
diff --git a/test/functional/wallet_importdescriptors.py b/test/functional/wallet_importdescriptors.py
index 7e2134e5b..efc8eaa06 100755
--- a/test/functional/wallet_importdescriptors.py
+++ b/test/functional/wallet_importdescriptors.py
@@ -1,493 +1,496 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 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 importdescriptors RPC.
 
 Test importdescriptors by generating keys on node0, importing the corresponding
 descriptors on node1 and then testing the address info for the different address
 variants.
 
 - `get_generate_key()` is called to generate keys and return the privkeys,
   pubkeys and all variants of scriptPubKey and address.
 - `test_importdesc()` is called to send an importdescriptors call to node1, test
   success, and (if unsuccessful) test the error code and error message returned.
 - `test_address()` is called to call getaddressinfo for an address on node1
   and test the values returned."""
 
 from test_framework.address import key_to_p2pkh
 from test_framework.descriptors import descsum_create
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
     find_vout_for_address,
 )
 from test_framework.wallet_util import get_generate_key, test_address
 
 
 class ImportDescriptorsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [[], ["-keypool=5"]]
+        # whitelist peers to speed up tx relay / mempool sync
+        for args in self.extra_args:
+            args.append("-whitelist=noban@127.0.0.1")
         self.setup_clean_chain = True
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def test_importdesc(self, req, success, error_code=None,
                         error_message=None, warnings=None, wallet=None):
         """Run importdescriptors and assert success"""
         if warnings is None:
             warnings = []
         wrpc = self.nodes[1].get_wallet_rpc('w1')
         if wallet is not None:
             wrpc = wallet
 
         result = wrpc.importdescriptors([req])
         observed_warnings = []
         if 'warnings' in result[0]:
             observed_warnings = result[0]['warnings']
         assert_equal(
             "\n".join(
                 sorted(warnings)), "\n".join(
                 sorted(observed_warnings)))
         assert_equal(result[0]['success'], success)
         if error_code is not None:
             assert_equal(result[0]['error']['code'], error_code)
             assert_equal(result[0]['error']['message'], error_message)
 
     def run_test(self):
         self.log.info('Setting up wallets')
         self.nodes[0].createwallet(
             wallet_name='w0',
             disable_private_keys=False)
         w0 = self.nodes[0].get_wallet_rpc('w0')
 
         self.nodes[1].createwallet(
             wallet_name='w1',
             disable_private_keys=True,
             blank=True,
             descriptors=True)
         w1 = self.nodes[1].get_wallet_rpc('w1')
         assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
 
         self.nodes[1].createwallet(
             wallet_name="wpriv",
             disable_private_keys=False,
             blank=True,
             descriptors=True)
         wpriv = self.nodes[1].get_wallet_rpc("wpriv")
         assert_equal(wpriv.getwalletinfo()['keypoolsize'], 0)
 
         self.log.info('Mining coins')
         w0.generatetoaddress(101, w0.getnewaddress())
 
         # RPC importdescriptors -----------------------------------------------
 
         # # Test import fails if no descriptor present
         key = get_generate_key()
         self.log.info("Import should fail if a descriptor is not provided")
         self.test_importdesc({"timestamp": "now"},
                              success=False,
                              error_code=-8,
                              error_message='Descriptor not found.')
 
         # # Test importing of a P2PKH descriptor
         key = get_generate_key()
         self.log.info("Should import a p2pkh descriptor")
         self.test_importdesc({"desc": descsum_create("pkh(" + key.pubkey + ")"),
                               "timestamp": "now",
                               "label": "Descriptor import test"},
                              success=True)
         test_address(w1,
                      key.p2pkh_addr,
                      solvable=True,
                      ismine=True,
                      labels=["Descriptor import test"])
         assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
 
         self.log.info("Internal addresses cannot have labels")
         self.test_importdesc({"desc": descsum_create("pkh(" + key.pubkey + ")"),
                               "timestamp": "now",
                               "internal": True,
                               "label": "Descriptor import test"},
                              success=False,
                              error_code=-8,
                              error_message="Internal addresses should not have a label")
 
         self.log.info("Internal addresses should be detected as such")
         key = get_generate_key()
         addr = key_to_p2pkh(key.pubkey)
         self.test_importdesc({"desc": descsum_create("pkh(" + key.pubkey + ")"),
                               "timestamp": "now",
                               "internal": True},
                              success=True)
         info = w1.getaddressinfo(addr)
         assert_equal(info["ismine"], True)
         assert_equal(info["ischange"], True)
         assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
 
         test_address(w1,
                      key.p2pkh_addr,
                      ismine=True,
                      solvable=True)
 
         # Check persistence of data and that loading works correctly
         w1.unloadwallet()
         self.nodes[1].loadwallet('w1')
         test_address(w1,
                      key.p2pkh_addr,
                      ismine=True,
                      solvable=True)
 
         # # Test importing of a multisig descriptor
         key1 = get_generate_key()
         key2 = get_generate_key()
         self.log.info("Should import a 1-of-2 bare multisig from descriptor")
         self.test_importdesc({"desc": descsum_create("multi(1," + key1.pubkey + "," + key2.pubkey + ")"),
                               "timestamp": "now"},
                              success=True)
         self.log.info(
             "Should not treat individual keys from the imported bare multisig as watchonly")
         test_address(w1,
                      key1.p2pkh_addr,
                      ismine=False)
 
         # # Test ranged descriptors
         xpriv = "tprv8ZgxMBicQKsPeuVhWwi6wuMQGfPKi9Li5GtX35jVNknACgqe3CY4g5xgkfDDJcmtF7o1QnxWDRYw4H5P26PXq7sbcUkEqeR4fg3Kxp2tigg"
         xpub = "tpubD6NzVbkrYhZ4YNXVQbNhMK1WqguFsUXceaVJKbmno2aZ3B6QfbMeraaYvnBSGpV3vxLyTTK9DYT1yoEck4XUScMzXoQ2U2oSmE2JyMedq3H"
         addresses = [
             "2N7yv4p8G8yEaPddJxY41kPihnWvs39qCMf",
             "2MsHxyb2JS3pAySeNUsJ7mNnurtpeenDzLA"]  # hdkeypath=m/0'/0'/0' and 1'
         # wpkh subscripts corresponding to the above addresses
         addresses += ["ecregtest:prvn9ycvgr5atuyh49sua3mapskh2mnnzg7t9yp6dt",
                       "ecregtest:pp3n087yx0njv2e5wcvltahfxqst7l66rutz8ceeat"]
         desc = "sh(pkh(" + xpub + "/0/0/*" + "))"
 
         self.log.info("Ranged descriptors cannot have labels")
         self.test_importdesc({"desc": descsum_create(desc),
                               "timestamp": "now",
                               "range": [0, 100],
                               "label": "test"},
                              success=False,
                              error_code=-8,
                              error_message='Ranged descriptors should not have a label')
 
         self.log.info("Private keys required for private keys enabled wallet")
         self.test_importdesc({"desc": descsum_create(desc),
                               "timestamp": "now",
                               "range": [0, 100]},
                              success=False,
                              error_code=-4,
                              error_message='Cannot import descriptor without private keys to a wallet with private keys enabled',
                              wallet=wpriv)
 
         self.log.info(
             "Ranged descriptor import should warn without a specified range")
         self.test_importdesc({"desc": descsum_create(desc),
                               "timestamp": "now"},
                              success=True,
                              warnings=['Range not given, using default keypool range'])
         assert_equal(w1.getwalletinfo()['keypoolsize'], 0)
 
         # # Test importing of a ranged descriptor with xpriv
         self.log.info(
             "Should not import a ranged descriptor that includes xpriv into a watch-only wallet")
         desc = "sh(pkh(" + xpriv + "/0'/0'/*'" + "))"
         self.test_importdesc({"desc": descsum_create(desc),
                               "timestamp": "now",
                               "range": 1},
                              success=False,
                              error_code=-4,
                              error_message='Cannot import private keys to a wallet with private keys disabled')
 
         self.log.info("Should not import a descriptor with hardened "
                       "derivations when private keys are disabled")
         self.test_importdesc({"desc": descsum_create("pkh(" + xpub + "/1h/*)"),
                               "timestamp": "now",
                               "range": 1},
                              success=False,
                              error_code=-4,
                              error_message='Cannot expand descriptor. Probably because of hardened derivations without private keys provided')
 
         for address in addresses:
             test_address(w1,
                          address,
                          ismine=False,
                          solvable=False)
 
         self.test_importdesc({"desc": descsum_create(desc), "timestamp": "now", "range": -1},
                              success=False, error_code=-8, error_message='End of range is too high')
 
         self.test_importdesc({"desc": descsum_create(desc), "timestamp": "now", "range": [-1, 10]},
                              success=False, error_code=-8, error_message='Range should be greater or equal than 0')
 
         self.test_importdesc({"desc": descsum_create(desc), "timestamp": "now", "range": [(2 << 31 + 1) - 1000000, (2 << 31 + 1)]},
                              success=False, error_code=-8, error_message='End of range is too high')
 
         self.test_importdesc({"desc": descsum_create(desc), "timestamp": "now", "range": [2, 1]},
                              success=False, error_code=-8, error_message='Range specified as [begin,end] must not have begin after end')
 
         self.test_importdesc({"desc": descsum_create(desc), "timestamp": "now", "range": [0, 1000001]},
                              success=False, error_code=-8, error_message='Range is too large')
 
         # Make sure ranged imports import keys in order
         w1 = self.nodes[1].get_wallet_rpc('w1')
         self.log.info('Key ranges should be imported in order')
         xpub = "tpubDAXcJ7s7ZwicqjprRaEWdPoHKrCS215qxGYxpusRLLmJuT69ZSicuGdSfyvyKpvUNYBW1s2U3NSrT6vrCYB9e6nZUEvrqnwXPF8ArTCRXMY"
         addresses = [
             'ecregtest:qp0v86h53rc92hjrlpwzpjtdlgzsxu25svv6g40fpl',  # m/0'/0'/0
             'ecregtest:qqasy0zlkdleqt4pkn8fs4ehm5gnnz6qpgdcpt90fq',  # m/0'/0'/1
             'ecregtest:qp0sp4wlhctvprqvdt2dgvqcfdjssu04xgey0l3syw',  # m/0'/0'/2
             'ecregtest:qrhn24tegn04cptfv4ldhtkduxq55zcwrycjfdj9vr',  # m/0'/0'/3
             'ecregtest:qzpqhett2uwltq803vrxv7zkqhft5vsnmcjeh50v0p',  # m/0'/0'/4
         ]
 
         self.test_importdesc({'desc': descsum_create('sh(pkh([abcdef12/0h/0h]' + xpub + '/*))'),
                               'active': True,
                               'range': [0, 2],
                               'timestamp': 'now'
                               },
                              success=True)
         self.test_importdesc({'desc': descsum_create('pkh([12345678/0h/0h]' + xpub + '/*)'),
                               'active': True,
                               'range': [0, 2],
                               'timestamp': 'now'
                               },
                              success=True)
 
         assert_equal(w1.getwalletinfo()['keypoolsize'], 5)
         for i, expected_addr in enumerate(addresses):
             pkh_addr = w1.getnewaddress('')
             assert_raises_rpc_error(-4,
                                     'This wallet has no available keys',
                                     w1.getrawchangeaddress)
 
             assert_equal(pkh_addr, expected_addr)
             pkh_addr_info = w1.getaddressinfo(pkh_addr)
             assert_equal(pkh_addr_info['desc'][:22],
                          'pkh([12345678/0\'/0\'/{}]'.format(i))
 
             # After retrieving a key, we don't refill the keypool again, so
             # it's one less for each address type
             assert_equal(w1.getwalletinfo()['keypoolsize'], 4)
         w1.keypoolrefill()
         assert_equal(w1.getwalletinfo()['keypoolsize'], 5)
 
         # Check active=False default
         self.log.info('Check imported descriptors are not active by default')
         self.test_importdesc({'desc': descsum_create('pkh([12345678/0h/0h]' + xpub + '/*)'),
                               'range': [0, 2],
                               'timestamp': 'now',
                               'internal': True
                               },
                              success=True)
         assert_raises_rpc_error(-4,
                                 'This wallet has no available keys',
                                 w1.getrawchangeaddress)
 
         # # Test importing a descriptor containing a WIF private key
         wif_priv = "cTe1f5rdT8A8DFgVWTjyPwACsDPJM9ff4QngFxUixCSvvbg1x6sh"
         address = "ecregtest:ppn85zpvym8cdccmgw8km6e48jfhnpa435h3hkyfd6"
         desc = "sh(pkh(" + wif_priv + "))"
         self.log.info(
             "Should import a descriptor with a WIF private key as spendable")
         self.test_importdesc({"desc": descsum_create(desc),
                               "timestamp": "now"},
                              success=True,
                              wallet=wpriv)
         test_address(wpriv,
                      address,
                      solvable=True,
                      ismine=True)
         txid = w0.sendtoaddress(address, 49999996.00)
         w0.generatetoaddress(6, w0.getnewaddress())
         self.sync_blocks()
         tx = wpriv.createrawtransaction([{"txid": txid, "vout": 0}], {
                                         w0.getnewaddress(): 49999000})
         signed_tx = wpriv.signrawtransactionwithwallet(tx)
         w1.sendrawtransaction(signed_tx['hex'])
 
         # Make sure that we can use import and use multisig as addresses
         self.log.info(
             'Test that multisigs can be imported, signed for, and getnewaddress\'d')
         self.nodes[1].createwallet(
             wallet_name="wmulti_priv",
             disable_private_keys=False,
             blank=True,
             descriptors=True)
         wmulti_priv = self.nodes[1].get_wallet_rpc("wmulti_priv")
         assert_equal(wmulti_priv.getwalletinfo()['keypoolsize'], 0)
 
         self.test_importdesc({"desc": "sh(multi(2,tprv8ZgxMBicQKsPevADjDCWsa6DfhkVXicu8NQUzfibwX2MexVwW4tCec5mXdCW8kJwkzBRRmAay1KZya4WsehVvjTGVW6JLqiqd8DdZ4xSg52/84h/0h/0h/*,tprv8ZgxMBicQKsPdSNWUhDiwTScDr6JfkZuLshTRwzvZGnMSnGikV6jxpmdDkC3YRc4T3GD6Nvg9uv6hQg73RVv1EiTXDZwxVbsLugVHU8B1aq/84h/0h/0h/*,tprv8ZgxMBicQKsPeonDt8Ka2mrQmHa61hQ5FQCsvWBTpSNzBFgM58cV2EuXNAHF14VawVpznnme3SuTbA62sGriwWyKifJmXntfNeK7zeqMCj1/84h/0h/0h/*))#f5nqn4ax",
                               "active": True,
                               "range": 1000,
                               "next_index": 0,
                               "timestamp": "now"},
                              success=True,
                              wallet=wmulti_priv)
         self.test_importdesc({"desc": "sh(multi(2,tprv8ZgxMBicQKsPevADjDCWsa6DfhkVXicu8NQUzfibwX2MexVwW4tCec5mXdCW8kJwkzBRRmAay1KZya4WsehVvjTGVW6JLqiqd8DdZ4xSg52/84h/1h/0h/*,tprv8ZgxMBicQKsPdSNWUhDiwTScDr6JfkZuLshTRwzvZGnMSnGikV6jxpmdDkC3YRc4T3GD6Nvg9uv6hQg73RVv1EiTXDZwxVbsLugVHU8B1aq/84h/1h/0h/*,tprv8ZgxMBicQKsPeonDt8Ka2mrQmHa61hQ5FQCsvWBTpSNzBFgM58cV2EuXNAHF14VawVpznnme3SuTbA62sGriwWyKifJmXntfNeK7zeqMCj1/84h/1h/0h/*))#m4e4s5de",
                               "active": True,
                               "internal": True,
                               "range": 1000,
                               "next_index": 0,
                               "timestamp": "now"},
                              success=True,
                              wallet=wmulti_priv)
 
         # Range end (1000) is inclusive, so 1001 addresses generated
         assert_equal(wmulti_priv.getwalletinfo()['keypoolsize'], 1001)
         addr = wmulti_priv.getnewaddress('')
         # Derived at m/84'/0'/0'/0
         assert_equal(
             addr,
             'ecregtest:pzkcf26dw7np58jcspnpxaupgz9csnc3wsf5wdh2a3')
         change_addr = wmulti_priv.getrawchangeaddress()
         assert_equal(
             change_addr,
             'ecregtest:prnkfg7pxe3kpyv3l4v00ft6q3sfseag7vnva0k49n')
 
         assert_equal(wmulti_priv.getwalletinfo()['keypoolsize'], 1000)
         txid = w0.sendtoaddress(addr, 10000000)
         self.nodes[0].generate(6)
         self.sync_all()
 
         self.nodes[1].createwallet(
             wallet_name="wmulti_pub",
             disable_private_keys=True,
             blank=True,
             descriptors=True)
         wmulti_pub = self.nodes[1].get_wallet_rpc("wmulti_pub")
         assert_equal(wmulti_pub.getwalletinfo()['keypoolsize'], 0)
 
         self.test_importdesc({"desc": "sh(multi(2,[7b2d0242/84h/0h/0h]tpubDCJtdt5dgJpdhW4MtaVYDhG4T4tF6jcLR1PxL43q9pq1mxvXgMS9Mzw1HnXG15vxUGQJMMSqCQHMTy3F1eW5VkgVroWzchsPD5BUojrcWs8/*,[59b09cd6/84h/0h/0h]tpubDDBF2BTR6s8drwrfDei8WxtckGuSm1cyoKxYY1QaKSBFbHBYQArWhHPA6eJrzZej6nfHGLSURYSLHr7GuYch8aY5n61tGqgn8b4cXrMuoPH/*,[e81a0532/84h/0h/0h]tpubDCsWoW1kuQB9kG5MXewHqkbjPtqPueRnXju7uM2NK7y3JYb2ajAZ9EiuZXNNuE4661RAfriBWhL8UsnAPpk8zrKKnZw1Ug7X4oHgMdZiU4E/*))#x75vpsak",
                               "active": True,
                               "range": 1000,
                               "next_index": 0,
                               "timestamp": "now"},
                              success=True,
                              wallet=wmulti_pub)
         self.test_importdesc({"desc": "sh(multi(2,[7b2d0242/84h/1h/0h]tpubDCXqdwWZcszwqYJSnZp8eARkxGJfHAk23KDxbztV4BbschfaTfYLTcSkSJ3TN64dRqwa1rnFUScsYormKkGqNbbPwkorQimVevXjxzUV9Gf/*,[59b09cd6/84h/1h/0h]tpubDCYfZY2ceyHzYzMMVPt9MNeiqtQ2T7Uyp9QSFwYXh8Vi9iJFYXcuphJaGXfF3jUQJi5Y3GMNXvM11gaL4txzZgNGK22BFAwMXynnzv4z2Jh/*,[e81a0532/84h/1h/0h]tpubDC6UGqnsQStngYuGD4MKsMy7eD1Yg9NTJfPdvjdG2JE5oZ7EsSL3WHg4Gsw2pR5K39ZwJ46M1wZayhedVdQtMGaUhq5S23PH6fnENK3V1sb/*))#v0t48ucu",
                               "active": True,
                               "internal": True,
                               "range": 1000,
                               "next_index": 0,
                               "timestamp": "now"},
                              success=True,
                              wallet=wmulti_pub)
 
         # The first one was already consumed by previous import and is detected
         # as used
         assert_equal(wmulti_pub.getwalletinfo()['keypoolsize'], 1000)
         addr = wmulti_pub.getnewaddress('')
         # Derived at m/84'/0'/0'/1
         assert_equal(
             addr,
             'ecregtest:pr5xql8r03jp5dvrep22dns59vf7hhykr5nmaucy2h')
         change_addr = wmulti_pub.getrawchangeaddress()
         assert_equal(
             change_addr,
             'ecregtest:prnkfg7pxe3kpyv3l4v00ft6q3sfseag7vnva0k49n')
 
         assert_equal(wmulti_pub.getwalletinfo()['keypoolsize'], 999)
         txid = w0.sendtoaddress(addr, 10000000)
         vout = find_vout_for_address(self.nodes[0], txid, addr)
         self.nodes[0].generate(6)
         self.sync_all()
         assert_equal(wmulti_pub.getbalance(), wmulti_priv.getbalance())
 
         # Make sure that descriptor wallets containing multiple xpubs in a
         # single descriptor load correctly
         wmulti_pub.unloadwallet()
         self.nodes[1].loadwallet('wmulti_pub')
 
         self.log.info("Multisig with distributed keys")
         self.nodes[1].createwallet(
             wallet_name="wmulti_priv1",
             descriptors=True)
         wmulti_priv1 = self.nodes[1].get_wallet_rpc("wmulti_priv1")
         res = wmulti_priv1.importdescriptors([
             {
                 "desc": descsum_create("sh(multi(2,tprv8ZgxMBicQKsPevADjDCWsa6DfhkVXicu8NQUzfibwX2MexVwW4tCec5mXdCW8kJwkzBRRmAay1KZya4WsehVvjTGVW6JLqiqd8DdZ4xSg52/84h/0h/0h/*,[59b09cd6/84h/0h/0h]tpubDDBF2BTR6s8drwrfDei8WxtckGuSm1cyoKxYY1QaKSBFbHBYQArWhHPA6eJrzZej6nfHGLSURYSLHr7GuYch8aY5n61tGqgn8b4cXrMuoPH/*,[e81a0532/84h/0h/0h]tpubDCsWoW1kuQB9kG5MXewHqkbjPtqPueRnXju7uM2NK7y3JYb2ajAZ9EiuZXNNuE4661RAfriBWhL8UsnAPpk8zrKKnZw1Ug7X4oHgMdZiU4E/*))"),
                 "active": True,
                 "range": 1000,
                 "next_index": 0,
                 "timestamp": "now"
             },
             {
                 "desc": descsum_create("sh(multi(2,tprv8ZgxMBicQKsPevADjDCWsa6DfhkVXicu8NQUzfibwX2MexVwW4tCec5mXdCW8kJwkzBRRmAay1KZya4WsehVvjTGVW6JLqiqd8DdZ4xSg52/84h/1h/0h/*,[59b09cd6/84h/1h/0h]tpubDCYfZY2ceyHzYzMMVPt9MNeiqtQ2T7Uyp9QSFwYXh8Vi9iJFYXcuphJaGXfF3jUQJi5Y3GMNXvM11gaL4txzZgNGK22BFAwMXynnzv4z2Jh/*,[e81a0532/84h/1h/0h]tpubDC6UGqnsQStngYuGD4MKsMy7eD1Yg9NTJfPdvjdG2JE5oZ7EsSL3WHg4Gsw2pR5K39ZwJ46M1wZayhedVdQtMGaUhq5S23PH6fnENK3V1sb/*))"),
                 "active": True,
                 "internal": True,
                 "range": 1000,
                 "next_index": 0,
                 "timestamp": "now"
             }])
         assert_equal(res[0]['success'], True)
         assert_equal(
             res[0]['warnings'][0],
             'Not all private keys provided. Some wallet functionality may return unexpected errors')
         assert_equal(res[1]['success'], True)
         assert_equal(
             res[1]['warnings'][0],
             'Not all private keys provided. Some wallet functionality may return unexpected errors')
 
         self.nodes[1].createwallet(
             wallet_name='wmulti_priv2',
             blank=True,
             descriptors=True)
         wmulti_priv2 = self.nodes[1].get_wallet_rpc('wmulti_priv2')
         res = wmulti_priv2.importdescriptors([
             {
                 "desc": descsum_create("sh(multi(2,[7b2d0242/84h/0h/0h]tpubDCJtdt5dgJpdhW4MtaVYDhG4T4tF6jcLR1PxL43q9pq1mxvXgMS9Mzw1HnXG15vxUGQJMMSqCQHMTy3F1eW5VkgVroWzchsPD5BUojrcWs8/*,tprv8ZgxMBicQKsPdSNWUhDiwTScDr6JfkZuLshTRwzvZGnMSnGikV6jxpmdDkC3YRc4T3GD6Nvg9uv6hQg73RVv1EiTXDZwxVbsLugVHU8B1aq/84h/0h/0h/*,[e81a0532/84h/0h/0h]tpubDCsWoW1kuQB9kG5MXewHqkbjPtqPueRnXju7uM2NK7y3JYb2ajAZ9EiuZXNNuE4661RAfriBWhL8UsnAPpk8zrKKnZw1Ug7X4oHgMdZiU4E/*))"),
                 "active": True,
                 "range": 1000,
                 "next_index": 0,
                 "timestamp": "now"
             },
             {
                 "desc": descsum_create("sh(multi(2,[7b2d0242/84h/1h/0h]tpubDCXqdwWZcszwqYJSnZp8eARkxGJfHAk23KDxbztV4BbschfaTfYLTcSkSJ3TN64dRqwa1rnFUScsYormKkGqNbbPwkorQimVevXjxzUV9Gf/*,tprv8ZgxMBicQKsPdSNWUhDiwTScDr6JfkZuLshTRwzvZGnMSnGikV6jxpmdDkC3YRc4T3GD6Nvg9uv6hQg73RVv1EiTXDZwxVbsLugVHU8B1aq/84h/1h/0h/*,[e81a0532/84h/1h/0h]tpubDC6UGqnsQStngYuGD4MKsMy7eD1Yg9NTJfPdvjdG2JE5oZ7EsSL3WHg4Gsw2pR5K39ZwJ46M1wZayhedVdQtMGaUhq5S23PH6fnENK3V1sb/*))"),
                 "active": True,
                 "internal": True,
                 "range": 1000,
                 "next_index": 0,
                 "timestamp": "now"
             }])
         assert_equal(res[0]['success'], True)
         assert_equal(
             res[0]['warnings'][0],
             'Not all private keys provided. Some wallet functionality may return unexpected errors')
         assert_equal(res[1]['success'], True)
         assert_equal(
             res[1]['warnings'][0],
             'Not all private keys provided. Some wallet functionality may return unexpected errors')
 
         rawtx = self.nodes[1].createrawtransaction(
             [{'txid': txid, 'vout': vout}], {w0.getnewaddress(): 9999000})
         tx_signed_1 = wmulti_priv1.signrawtransactionwithwallet(rawtx)
         assert_equal(tx_signed_1['complete'], False)
         tx_signed_2 = wmulti_priv2.signrawtransactionwithwallet(
             tx_signed_1['hex'])
         assert_equal(tx_signed_2['complete'], True)
         self.nodes[1].sendrawtransaction(tx_signed_2['hex'])
 
         self.log.info("Combo descriptors cannot be active")
         self.test_importdesc({"desc": descsum_create("combo(tpubDCJtdt5dgJpdhW4MtaVYDhG4T4tF6jcLR1PxL43q9pq1mxvXgMS9Mzw1HnXG15vxUGQJMMSqCQHMTy3F1eW5VkgVroWzchsPD5BUojrcWs8/*)"),
                               "active": True,
                               "range": 1,
                               "timestamp": "now"},
                              success=False,
                              error_code=-4,
                              error_message="Combo descriptors cannot be set to active")
 
         self.log.info("Descriptors with no type cannot be active")
         self.test_importdesc({"desc": descsum_create("pk(tpubDCJtdt5dgJpdhW4MtaVYDhG4T4tF6jcLR1PxL43q9pq1mxvXgMS9Mzw1HnXG15vxUGQJMMSqCQHMTy3F1eW5VkgVroWzchsPD5BUojrcWs8/*)"),
                               "active": True,
                               "range": 1,
                               "timestamp": "now"},
                              success=True,
                              warnings=["Unknown output type, cannot set descriptor to active."])
 
 
 if __name__ == '__main__':
     ImportDescriptorsTest().main()
diff --git a/test/functional/wallet_listreceivedby.py b/test/functional/wallet_listreceivedby.py
index c4bab5ba3..bcbfbf7ed 100755
--- a/test/functional/wallet_listreceivedby.py
+++ b/test/functional/wallet_listreceivedby.py
@@ -1,194 +1,196 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 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 listreceivedbyaddress RPC."""
 
 from decimal import Decimal
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_array_result,
     assert_equal,
     assert_raises_rpc_error,
 )
 from test_framework.wallet_util import test_address
 
 
 class ReceivedByTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
+        # whitelist peers to speed up tx relay / mempool sync
+        self.extra_args = [["-whitelist=noban@127.0.0.1"]] * self.num_nodes
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
         self.skip_if_no_cli()
 
     def run_test(self):
         # Generate block to get out of IBD
         self.nodes[0].generate(1)
         self.sync_blocks()
 
         # save the number of coinbase reward addresses so far
         num_cb_reward_addresses = len(
             self.nodes[1].listreceivedbyaddress(
                 minconf=0,
                 include_empty=True,
                 include_watchonly=True))
 
         self.log.info("listreceivedbyaddress Test")
 
         # Send from node 0 to 1
         addr = self.nodes[1].getnewaddress()
         txid = self.nodes[0].sendtoaddress(addr, 100000)
         self.sync_all()
 
         # Check not listed in listreceivedbyaddress because has 0 confirmations
         assert_array_result(self.nodes[1].listreceivedbyaddress(),
                             {"address": addr},
                             {},
                             True)
         # Bury Tx under 10 block so it will be returned by
         # listreceivedbyaddress
         self.nodes[1].generate(10)
         self.sync_all()
         assert_array_result(self.nodes[1].listreceivedbyaddress(),
                             {"address": addr},
                             {"address": addr, "label": "", "amount": Decimal("100000"), "confirmations": 10, "txids": [txid, ]})
         # With min confidence < 10
         assert_array_result(self.nodes[1].listreceivedbyaddress(5),
                             {"address": addr},
                             {"address": addr, "label": "", "amount": Decimal("100000"), "confirmations": 10, "txids": [txid, ]})
         # With min confidence > 10, should not find Tx
         assert_array_result(self.nodes[1].listreceivedbyaddress(11), {
                             "address": addr}, {}, True)
 
         # Empty Tx
         empty_addr = self.nodes[1].getnewaddress()
         assert_array_result(self.nodes[1].listreceivedbyaddress(0, True),
                             {"address": empty_addr},
                             {"address": empty_addr, "label": "", "amount": 0, "confirmations": 0, "txids": []})
 
         # Test Address filtering
         # Only on addr
         expected = {"address": addr, "label": "", "amount": Decimal(
             "100000"), "confirmations": 10, "txids": [txid, ]}
         res = self.nodes[1].listreceivedbyaddress(
             minconf=0, include_empty=True, include_watchonly=True, address_filter=addr)
         assert_array_result(res, {"address": addr}, expected)
         assert_equal(len(res), 1)
         # Test for regression on CLI calls with address string (#14173)
         cli_res = self.nodes[1].cli.listreceivedbyaddress(0, True, True, addr)
         assert_array_result(cli_res, {"address": addr}, expected)
         assert_equal(len(cli_res), 1)
         # Error on invalid address
         assert_raises_rpc_error(-4, "address_filter parameter was invalid",
                                 self.nodes[1].listreceivedbyaddress, minconf=0, include_empty=True, include_watchonly=True, address_filter="bamboozling")
         # Another address receive money
         res = self.nodes[1].listreceivedbyaddress(0, True, True)
         # Right now 2 entries
         assert_equal(len(res), 2 + num_cb_reward_addresses)
         other_addr = self.nodes[1].getnewaddress()
         txid2 = self.nodes[0].sendtoaddress(other_addr, 100000)
         self.nodes[0].generate(1)
         self.sync_all()
         # Same test as above should still pass
         expected = {"address": addr, "label": "", "amount": Decimal(
             "100000"), "confirmations": 11, "txids": [txid, ]}
         res = self.nodes[1].listreceivedbyaddress(0, True, True, addr)
         assert_array_result(res, {"address": addr}, expected)
         assert_equal(len(res), 1)
         # Same test as above but with other_addr should still pass
         expected = {"address": other_addr, "label": "", "amount": Decimal(
             "100000"), "confirmations": 1, "txids": [txid2, ]}
         res = self.nodes[1].listreceivedbyaddress(0, True, True, other_addr)
         assert_array_result(res, {"address": other_addr}, expected)
         assert_equal(len(res), 1)
         # Should be two entries though without filter
         res = self.nodes[1].listreceivedbyaddress(0, True, True)
         # Became 3 entries
         assert_equal(len(res), 3 + num_cb_reward_addresses)
 
         # Not on random addr
         # note on node[0]! just a random addr
         other_addr = self.nodes[0].getnewaddress()
         res = self.nodes[1].listreceivedbyaddress(0, True, True, other_addr)
         assert_equal(len(res), 0)
 
         self.log.info("getreceivedbyaddress Test")
 
         # Send from node 0 to 1
         addr = self.nodes[1].getnewaddress()
         txid = self.nodes[0].sendtoaddress(addr, 100000)
         self.sync_all()
 
         # Check balance is 0 because of 0 confirmations
         balance = self.nodes[1].getreceivedbyaddress(addr)
         assert_equal(balance, Decimal("0.0"))
 
         # Check balance is 0.1
         balance = self.nodes[1].getreceivedbyaddress(addr, 0)
         assert_equal(balance, Decimal("100000"))
 
         # 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)
         assert_equal(balance, Decimal("100000"))
 
         # Trying to getreceivedby for an address the wallet doesn't own should
         # return an error
         assert_raises_rpc_error(-4, "Address not found in wallet",
                                 self.nodes[0].getreceivedbyaddress, addr)
 
         self.log.info("listreceivedbylabel + getreceivedbylabel Test")
 
         # set pre-state
         label = ''
         address = self.nodes[1].getnewaddress()
         test_address(self.nodes[1], address, labels=[label])
         received_by_label_json = [
             r for r in self.nodes[1].listreceivedbylabel() if r["label"] == label][0]
         balance_by_label = self.nodes[1].getreceivedbylabel(label)
 
         txid = self.nodes[0].sendtoaddress(addr, 100000)
         self.sync_all()
 
         # listreceivedbylabel should return received_by_label_json because of 0
         # confirmations
         assert_array_result(self.nodes[1].listreceivedbylabel(),
                             {"label": label},
                             received_by_label_json)
 
         # getreceivedbyaddress should return same balance because of 0
         # confirmations
         balance = self.nodes[1].getreceivedbylabel(label)
         assert_equal(balance, balance_by_label)
 
         self.nodes[1].generate(10)
         self.sync_all()
         # listreceivedbylabel should return updated received list
         assert_array_result(self.nodes[1].listreceivedbylabel(),
                             {"label": label},
                             {"label": received_by_label_json["label"], "amount": (received_by_label_json["amount"] + Decimal("100000"))})
 
         # getreceivedbylabel should return updated receive total
         balance = self.nodes[1].getreceivedbylabel(label)
         assert_equal(balance, balance_by_label + Decimal("100000"))
 
         # Create a new label named "mynewlabel" that has a 0 balance
         address = self.nodes[1].getnewaddress()
         self.nodes[1].setlabel(address, "mynewlabel")
         received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel(
             0, True) if r["label"] == "mynewlabel"][0]
 
         # Test includeempty of listreceivedbylabel
         assert_equal(received_by_label_json["amount"], Decimal("0.0"))
 
         # Test getreceivedbylabel for 0 amount labels
         balance = self.nodes[1].getreceivedbylabel("mynewlabel")
         assert_equal(balance, Decimal("0.0"))
 
 
 if __name__ == '__main__':
     ReceivedByTest().main()
diff --git a/test/functional/wallet_listsinceblock.py b/test/functional/wallet_listsinceblock.py
index 374a4df05..32f6db662 100755
--- a/test/functional/wallet_listsinceblock.py
+++ b/test/functional/wallet_listsinceblock.py
@@ -1,350 +1,353 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 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 listsinceblock RPC."""
 
 from test_framework import cashaddr
 from test_framework.key import ECKey
 from test_framework.script import hash160
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_array_result,
     assert_equal,
     assert_raises_rpc_error,
 )
 from test_framework.wallet_util import bytes_to_wif
 
 
 class ListSinceBlockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = True
         self.extra_args = [["-noparkdeepreorg"], ["-noparkdeepreorg"], [], []]
+        # whitelist peers to speed up tx relay / mempool sync
+        for args in self.extra_args:
+            args.append("-whitelist=noban@127.0.0.1")
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         # All nodes are in IBD from genesis, so they'll need the miner (node2) to be an outbound connection, or have
         # only one connection. (See fPreferredDownload in net_processing)
         self.connect_nodes(1, 2)
         self.nodes[2].generate(101)
         self.sync_all()
 
         self.test_no_blockhash()
         self.test_invalid_blockhash()
         self.test_reorg()
         self.test_double_spend()
         self.test_double_send()
         self.test_targetconfirmations()
 
     def test_no_blockhash(self):
         self.log.info("Test no blockhash")
         txid = self.nodes[2].sendtoaddress(
             self.nodes[0].getnewaddress(), 1000000)
         blockhash, = self.nodes[2].generate(1)
         blockheight = self.nodes[2].getblockheader(blockhash)['height']
         self.sync_all()
 
         txs = self.nodes[0].listtransactions()
         assert_array_result(txs, {"txid": txid}, {
             "category": "receive",
             "amount": 1000000,
             "blockhash": blockhash,
             "blockheight": blockheight,
             "confirmations": 1,
         })
         assert_equal(
             self.nodes[0].listsinceblock(),
             {"lastblock": blockhash,
              "removed": [],
              "transactions": txs})
         assert_equal(
             self.nodes[0].listsinceblock(""),
             {"lastblock": blockhash,
              "removed": [],
              "transactions": txs})
 
     def test_invalid_blockhash(self):
         self.log.info("Test invalid blockhash")
         assert_raises_rpc_error(-5, "Block not found", self.nodes[0].listsinceblock,
                                 "42759cde25462784395a337460bde75f58e73d3f08bd31fdc3507cbac856a2c4")
         assert_raises_rpc_error(-5, "Block not found", self.nodes[0].listsinceblock,
                                 "0000000000000000000000000000000000000000000000000000000000000000")
         assert_raises_rpc_error(-8, "blockhash must be of length 64 (not 11, for 'invalid-hex')", self.nodes[0].listsinceblock,
                                 "invalid-hex")
         assert_raises_rpc_error(-8, "blockhash must be hexadecimal string (not 'Z000000000000000000000000000000000000000000000000000000000000000')", self.nodes[0].listsinceblock,
                                 "Z000000000000000000000000000000000000000000000000000000000000000")
 
     def test_targetconfirmations(self):
         '''
         This tests when the value of target_confirmations exceeds the number of
         blocks in the main chain. In this case, the genesis block hash should be
         given for the `lastblock` property. If target_confirmations is < 1, then
         a -8 invalid parameter error is thrown.
         '''
         self.log.info("Test target_confirmations")
         blockhash, = self.nodes[2].generate(1)
         blockheight = self.nodes[2].getblockheader(blockhash)['height']
         self.sync_all()
 
         assert_equal(
             self.nodes[0].getblockhash(0),
             self.nodes[0].listsinceblock(blockhash, blockheight + 1)['lastblock'])
         assert_equal(
             self.nodes[0].getblockhash(0),
             self.nodes[0].listsinceblock(blockhash, blockheight + 1000)['lastblock'])
         assert_raises_rpc_error(-8, "Invalid parameter",
                                 self.nodes[0].listsinceblock, blockhash, 0)
 
     def test_reorg(self):
         '''
         `listsinceblock` did not behave correctly when handed a block that was
         no longer in the main chain:
 
              ab0
           /       \
         aa1 [tx0]   bb1
          |           |
         aa2         bb2
          |           |
         aa3         bb3
                      |
                     bb4
 
         Consider a client that has only seen block `aa3` above. It asks the node
         to `listsinceblock aa3`. But at some point prior the main chain switched
         to the bb chain.
 
         Previously: listsinceblock would find height=4 for block aa3 and compare
         this to height=5 for the tip of the chain (bb4). It would then return
         results restricted to bb3-bb4.
 
         Now: listsinceblock finds the fork at ab0 and returns results in the
         range bb1-bb4.
 
         This test only checks that [tx0] is present.
         '''
         self.log.info("Test reorg")
 
         # Split network into two
         self.split_network()
 
         # send to nodes[0] from nodes[2]
         senttx = self.nodes[2].sendtoaddress(
             self.nodes[0].getnewaddress(), 1000000)
 
         # generate on both sides
         nodes1_last_blockhash = self.nodes[1].generate(6)[-1]
         nodes2_first_blockhash = self.nodes[2].generate(7)[0]
         self.log.debug(
             "nodes[1] last blockhash = {}".format(nodes1_last_blockhash))
         self.log.debug(
             "nodes[2] first blockhash = {}".format(nodes2_first_blockhash))
 
         self.sync_all(self.nodes[:2])
         self.sync_all(self.nodes[2:])
 
         self.join_network()
 
         # listsinceblock(nodes1_last_blockhash) should now include tx as seen from nodes[0]
         # and return the block height which listsinceblock now exposes since
         # rABC6098a1cb2b25.
         transactions = self.nodes[0].listsinceblock(
             nodes1_last_blockhash)['transactions']
         found = next(tx for tx in transactions if tx['txid'] == senttx)
         assert_equal(
             found['blockheight'],
             self.nodes[0].getblockheader(nodes2_first_blockhash)['height'])
 
     def test_double_spend(self):
         '''
         This tests the case where the same UTXO is spent twice on two separate
         blocks as part of a reorg.
 
              ab0
           /       \
         aa1 [tx1]   bb1 [tx2]
          |           |
         aa2         bb2
          |           |
         aa3         bb3
                      |
                     bb4
 
         Problematic case:
 
         1. User 1 receives XEC in tx1 from utxo1 in block aa1.
         2. User 2 receives XEC in tx2 from utxo1 (same) in block bb1
         3. User 1 sees 2 confirmations at block aa3.
         4. Reorg into bb chain.
         5. User 1 asks `listsinceblock aa3` and does not see that tx1 is now
            invalidated.
 
         Currently the solution to this is to detect that a reorg'd block is
         asked for in listsinceblock, and to iterate back over existing blocks up
         until the fork point, and to include all transactions that relate to the
         node wallet.
         '''
         self.log.info("Test double spend")
 
         self.sync_all()
 
         # share utxo between nodes[1] and nodes[2]
         eckey = ECKey()
         eckey.generate()
         privkey = bytes_to_wif(eckey.get_bytes())
         address = cashaddr.encode_full("ecregtest", cashaddr.PUBKEY_TYPE,
                                        hash160(eckey.get_pubkey().get_bytes()))
         self.nodes[2].sendtoaddress(address, 10_000_000)
         self.nodes[2].generate(6)
         self.sync_all()
         self.nodes[2].importprivkey(privkey)
         utxos = self.nodes[2].listunspent()
         utxo = [u for u in utxos if u["address"] == address][0]
         self.nodes[1].importprivkey(privkey)
 
         # Split network into two
         self.split_network()
 
         # send from nodes[1] using utxo to nodes[0]
         change = '{:.2f}'.format(float(utxo['amount']) - 1000300.00)
         recipient_dict = {
             self.nodes[0].getnewaddress(): 1000000,
             self.nodes[1].getnewaddress(): change,
         }
         utxo_dicts = [{
             'txid': utxo['txid'],
             'vout': utxo['vout'],
         }]
         txid1 = self.nodes[1].sendrawtransaction(
             self.nodes[1].signrawtransactionwithwallet(
                 self.nodes[1].createrawtransaction(utxo_dicts, recipient_dict))['hex'])
 
         # send from nodes[2] using utxo to nodes[3]
         recipient_dict2 = {
             self.nodes[3].getnewaddress(): 1000000,
             self.nodes[2].getnewaddress(): change,
         }
         self.nodes[2].sendrawtransaction(
             self.nodes[2].signrawtransactionwithwallet(
                 self.nodes[2].createrawtransaction(utxo_dicts, recipient_dict2))['hex'])
 
         # generate on both sides
         lastblockhash = self.nodes[1].generate(3)[2]
         self.nodes[2].generate(4)
 
         self.join_network()
 
         self.sync_all()
 
         # gettransaction should work for txid1
         assert self.nodes[0].gettransaction(
             txid1)['txid'] == txid1, "gettransaction failed to find txid1"
 
         # listsinceblock(lastblockhash) should now include txid1, as seen from
         # nodes[0]
         lsbres = self.nodes[0].listsinceblock(lastblockhash)
         assert any(tx['txid'] == txid1 for tx in lsbres['removed'])
 
         # but it should not include 'removed' if include_removed=false
         lsbres2 = self.nodes[0].listsinceblock(
             blockhash=lastblockhash, include_removed=False)
         assert 'removed' not in lsbres2
 
     def test_double_send(self):
         '''
         This tests the case where the same transaction is submitted twice on two
         separate blocks as part of a reorg. The former will vanish and the
         latter will appear as the true transaction (with confirmations dropping
         as a result).
 
              ab0
           /       \
         aa1 [tx1]   bb1
          |           |
         aa2         bb2
          |           |
         aa3         bb3 [tx1]
                      |
                     bb4
 
         Asserted:
 
         1. tx1 is listed in listsinceblock.
         2. It is included in 'removed' as it was removed, even though it is now
            present in a different block.
         3. It is listed with a confirmation count of 2 (bb3, bb4), not
            3 (aa1, aa2, aa3).
         '''
         self.log.info("Test double send")
 
         self.sync_all()
 
         # Split network into two
         self.split_network()
 
         # create and sign a transaction
         utxos = self.nodes[2].listunspent()
         utxo = utxos[0]
         change = '{:.2f}'.format(float(utxo['amount']) - 1000300.00)
         recipient_dict = {
             self.nodes[0].getnewaddress(): 1000000,
             self.nodes[2].getnewaddress(): change,
         }
         utxo_dicts = [{
             'txid': utxo['txid'],
             'vout': utxo['vout'],
         }]
         signedtxres = self.nodes[2].signrawtransactionwithwallet(
             self.nodes[2].createrawtransaction(utxo_dicts, recipient_dict))
         assert signedtxres['complete']
 
         signedtx = signedtxres['hex']
 
         # send from nodes[1]; this will end up in aa1
         txid1 = self.nodes[1].sendrawtransaction(signedtx)
 
         # generate bb1-bb2 on right side
         self.nodes[2].generate(2)
 
         # send from nodes[2]; this will end up in bb3
         txid2 = self.nodes[2].sendrawtransaction(signedtx)
 
         assert_equal(txid1, txid2)
 
         # generate on both sides
         lastblockhash = self.nodes[1].generate(3)[2]
         self.nodes[2].generate(2)
 
         self.join_network()
 
         self.sync_all()
 
         # gettransaction should work for txid1
         tx1 = self.nodes[0].gettransaction(txid1)
         assert_equal(
             tx1['blockheight'],
             self.nodes[0].getblockheader(
                 tx1['blockhash'])['height'])
 
         # listsinceblock(lastblockhash) should now include txid1 in transactions
         # as well as in removed
         lsbres = self.nodes[0].listsinceblock(lastblockhash)
         assert any(tx['txid'] == txid1 for tx in lsbres['transactions'])
         assert any(tx['txid'] == txid1 for tx in lsbres['removed'])
 
         # find transaction and ensure confirmations is valid
         for tx in lsbres['transactions']:
             if tx['txid'] == txid1:
                 assert_equal(tx['confirmations'], 2)
 
         # the same check for the removed array; confirmations should STILL be 2
         for tx in lsbres['removed']:
             if tx['txid'] == txid1:
                 assert_equal(tx['confirmations'], 2)
 
 
 if __name__ == '__main__':
     ListSinceBlockTest().main()