diff --git a/test/functional/wallet_balance.py b/test/functional/wallet_balance.py
index c2f803d89..1bfacb21e 100755
--- a/test/functional/wallet_balance.py
+++ b/test/functional/wallet_balance.py
@@ -1,339 +1,337 @@
 #!/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'],
             [],
         ]
 
     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)
-        self.sync_blocks()
-        self.nodes[0].syncwithvalidationinterfacequeue()
         # 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_importmulti.py b/test/functional/wallet_importmulti.py
index b63b157f0..96afaebc4 100755
--- a/test/functional/wallet_importmulti.py
+++ b/test/functional/wallet_importmulti.py
@@ -1,787 +1,788 @@
 #!/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 importmulti RPC.
 
 Test importmulti by generating keys on node0, importing the scriptPubKeys and
 addresses on node1 and then testing the address info for the different address
 variants.
 
 - `get_key()` and `get_multisig()` are called to generate keys on node0 and
   return the privkeys, pubkeys and all variants of scriptPubKey and address.
 - `test_importmulti()` is called to send an importmulti 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.descriptors import descsum_create
 from test_framework.script import OP_NOP, CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
 )
 from test_framework.wallet_util import get_key, get_multisig, test_address
 
 
 class ImportMultiTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self, split=False):
         self.setup_nodes()
 
     def test_importmulti(self, req, success, error_code=None,
                          error_message=None, warnings=None):
         """Run importmulti and assert success"""
         if warnings is None:
             warnings = []
         result = self.nodes[1].importmulti([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("Mining blocks...")
         self.nodes[0].generate(1)
         self.nodes[1].generate(1)
         timestamp = self.nodes[1].getblock(
             self.nodes[1].getbestblockhash())['mediantime']
+        # Sync the timestamp to the wallet, so that importmulti works
         self.nodes[1].syncwithvalidationinterfacequeue()
 
         node0_address1 = self.nodes[0].getaddressinfo(
             self.nodes[0].getnewaddress())
 
         # Check only one address
         assert_equal(node0_address1['ismine'], True)
 
         # Node 1 sync test
         assert_equal(self.nodes[1].getblockcount(), 1)
 
         # Address Test - before import
         address_info = self.nodes[1].getaddressinfo(node0_address1['address'])
         assert_equal(address_info['iswatchonly'], False)
         assert_equal(address_info['ismine'], False)
 
         # RPC importmulti -----------------------------------------------
 
         # Bitcoin Address (implicit non-internal)
         self.log.info("Should import an address")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now"},
                               success=True)
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      timestamp=timestamp,
                      ischange=False)
         watchonly_address = key.p2pkh_addr
         watchonly_timestamp = timestamp
 
         self.log.info("Should not import an invalid address")
         self.test_importmulti({"scriptPubKey": {"address": "not valid address"},
                                "timestamp": "now"},
                               success=False,
                               error_code=-5,
                               error_message='Invalid address \"not valid address\"')
 
         # ScriptPubKey + internal
         self.log.info("Should import a scriptPubKey with internal flag")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "internal": True},
                               success=True)
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      timestamp=timestamp,
                      ischange=True)
 
         # ScriptPubKey + internal + label
         self.log.info(
             "Should not allow a label to be specified when internal is true")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "internal": True,
                                "label": "Unsuccessful labelling for internal addresses"},
                               success=False,
                               error_code=-8,
                               error_message='Internal addresses should not have a label')
 
         # Nonstandard scriptPubKey + !internal
         self.log.info(
             "Should not import a nonstandard scriptPubKey without internal flag")
         nonstandardScriptPubKey = key.p2pkh_script + CScript([OP_NOP]).hex()
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey,
                                "timestamp": "now"},
                               success=False,
                               error_code=-8,
                               error_message='Internal must be set to true for nonstandard scriptPubKey imports.')
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=False,
                      ismine=False,
                      timestamp=None)
 
         # Address + Public key + !Internal(explicit)
         self.log.info("Should import an address with public key")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "pubkeys": [key.pubkey],
                                "internal": False},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      timestamp=timestamp)
 
         # ScriptPubKey + Public key + internal
         self.log.info(
             "Should import a scriptPubKey with internal and with public key")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "pubkeys": [key.pubkey],
                                "internal": True},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      timestamp=timestamp)
 
         # Nonstandard scriptPubKey + Public key + !internal
         self.log.info(
             "Should not import a nonstandard scriptPubKey without internal and with public key")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey,
                                "timestamp": "now",
                                "pubkeys": [key.pubkey]},
                               success=False,
                               error_code=-8,
                               error_message='Internal must be set to true for nonstandard scriptPubKey imports.')
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=False,
                      ismine=False,
                      timestamp=None)
 
         # Address + Private key + !watchonly
         self.log.info("Should import an address with private key")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "keys": [key.privkey]},
                               success=True)
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=False,
                      ismine=True,
                      timestamp=timestamp)
 
         self.log.info(
             "Should not import an address with private key if is already imported")
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "keys": [key.privkey]},
                               success=False,
                               error_code=-4,
                               error_message='The wallet already contains the private key for this address or script ("' + key.p2pkh_script + '")')
 
         # Address + Private key + watchonly
         self.log.info(
             "Should import an address with private key and with watchonly")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "keys": [key.privkey],
                                "watchonly": True},
                               success=True,
                               warnings=["All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=False,
                      ismine=True,
                      timestamp=timestamp)
 
         # ScriptPubKey + Private key + internal
         self.log.info(
             "Should import a scriptPubKey with internal and with private key")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "keys": [key.privkey],
                                "internal": True},
                               success=True)
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=False,
                      ismine=True,
                      timestamp=timestamp)
 
         # Nonstandard scriptPubKey + Private key + !internal
         self.log.info(
             "Should not import a nonstandard scriptPubKey without internal and with private key")
         key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey,
                                "timestamp": "now",
                                "keys": [key.privkey]},
                               success=False,
                               error_code=-8,
                               error_message='Internal must be set to true for nonstandard scriptPubKey imports.')
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=False,
                      ismine=False,
                      timestamp=None)
 
         # P2SH address
         multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
         timestamp = self.nodes[1].getblock(
             self.nodes[1].getbestblockhash())['mediantime']
         self.nodes[1].syncwithvalidationinterfacequeue()
 
         self.log.info("Should import a p2sh")
         self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr},
                                "timestamp": "now"},
                               success=True)
         test_address(self.nodes[1],
                      multisig.p2sh_addr,
                      isscript=True,
                      iswatchonly=True,
                      timestamp=timestamp)
         p2shunspent = self.nodes[1].listunspent(
             0, 999999, [multisig.p2sh_addr])[0]
         assert_equal(p2shunspent['spendable'], False)
         assert_equal(p2shunspent['solvable'], False)
 
         # P2SH + Redeem script
         multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
         timestamp = self.nodes[1].getblock(
             self.nodes[1].getbestblockhash())['mediantime']
         self.nodes[1].syncwithvalidationinterfacequeue()
 
         self.log.info("Should import a p2sh with respective redeem script")
         self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr},
                                "timestamp": "now",
                                "redeemscript": multisig.redeem_script},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(
             self.nodes[1],
             multisig.p2sh_addr,
             timestamp=timestamp,
             iswatchonly=True,
             ismine=False,
             solvable=True)
 
         p2shunspent = self.nodes[1].listunspent(
             0, 999999, [multisig.p2sh_addr])[0]
         assert_equal(p2shunspent['spendable'], False)
         assert_equal(p2shunspent['solvable'], True)
 
         # P2SH + Redeem script + Private Keys + !Watchonly
         multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
         timestamp = self.nodes[1].getblock(
             self.nodes[1].getbestblockhash())['mediantime']
         self.nodes[1].syncwithvalidationinterfacequeue()
 
         self.log.info(
             "Should import a p2sh with respective redeem script and private keys")
         self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr},
                                "timestamp": "now",
                                "redeemscript": multisig.redeem_script,
                                "keys": multisig.privkeys[0:2]},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      multisig.p2sh_addr,
                      timestamp=timestamp,
                      ismine=False,
                      iswatchonly=True,
                      solvable=True)
 
         p2shunspent = self.nodes[1].listunspent(
             0, 999999, [multisig.p2sh_addr])[0]
         assert_equal(p2shunspent['spendable'], False)
         assert_equal(p2shunspent['solvable'], True)
 
         # P2SH + Redeem script + Private Keys + Watchonly
         multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
         timestamp = self.nodes[1].getblock(
             self.nodes[1].getbestblockhash())['mediantime']
         self.nodes[1].syncwithvalidationinterfacequeue()
 
         self.log.info(
             "Should import a p2sh with respective redeem script and private keys")
         self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr},
                                "timestamp": "now",
                                "redeemscript": multisig.redeem_script,
                                "keys": multisig.privkeys[0:2],
                                "watchonly": True},
                               success=True)
         test_address(self.nodes[1],
                      multisig.p2sh_addr,
                      iswatchonly=True,
                      ismine=False,
                      solvable=True,
                      timestamp=timestamp)
 
         # Address + Public key + !Internal + Wrong pubkey
         self.log.info(
             "Should not import an address with the wrong public key as non-solvable")
         key = get_key(self.nodes[0])
         wrong_key = get_key(self.nodes[0]).pubkey
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "pubkeys": [wrong_key]},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      solvable=False,
                      timestamp=timestamp)
 
         # ScriptPubKey + Public key + internal + Wrong pubkey
         self.log.info(
             "Should import a scriptPubKey with internal and with a wrong public key as non-solvable")
         key = get_key(self.nodes[0])
         wrong_key = get_key(self.nodes[0]).pubkey
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "pubkeys": [wrong_key],
                                "internal": True},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      solvable=False,
                      timestamp=timestamp)
 
         # Address + Private key + !watchonly + Wrong private key
         self.log.info(
             "Should import an address with a wrong private key as non-solvable")
         key = get_key(self.nodes[0])
         wrong_privkey = get_key(self.nodes[0]).privkey
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "keys": [wrong_privkey]},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      solvable=False,
                      timestamp=timestamp)
 
         # ScriptPubKey + Private key + internal + Wrong private key
         self.log.info(
             "Should import a scriptPubKey with internal and with a wrong private key as non-solvable")
         key = get_key(self.nodes[0])
         wrong_privkey = get_key(self.nodes[0]).privkey
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "keys": [wrong_privkey],
                                "internal": True},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      iswatchonly=True,
                      ismine=False,
                      solvable=False,
                      timestamp=timestamp)
 
         # Importing existing watch only address with new timestamp should
         # replace saved timestamp.
         assert_greater_than(timestamp, watchonly_timestamp)
         self.log.info("Should replace previously saved watch only timestamp.")
         self.test_importmulti({"scriptPubKey": {"address": watchonly_address},
                                "timestamp": "now"},
                               success=True)
         test_address(self.nodes[1],
                      watchonly_address,
                      iswatchonly=True,
                      ismine=False,
                      timestamp=timestamp)
         watchonly_timestamp = timestamp
 
         # restart nodes to check for proper serialization/deserialization of
         # watch only address
         self.stop_nodes()
         self.start_nodes()
         test_address(self.nodes[1],
                      watchonly_address,
                      iswatchonly=True,
                      ismine=False,
                      timestamp=watchonly_timestamp)
 
         # Bad or missing timestamps
         self.log.info("Should throw on invalid or missing timestamp values")
         assert_raises_rpc_error(-3, 'Missing required timestamp field for key',
                                 self.nodes[1].importmulti, [{"scriptPubKey": key.p2pkh_script}])
         assert_raises_rpc_error(-3, 'Expected number or "now" timestamp value for key. got type string',
                                 self.nodes[1].importmulti, [{
                                     "scriptPubKey": key.p2pkh_script,
                                     "timestamp": ""
                                 }])
 
         # Test that importing of a P2PKH address via descriptor without
         # checksum fails
         key = get_key(self.nodes[0])
         self.log.info(
             "Should fail to import a p2pkh address from descriptor with no checksum")
         self.test_importmulti({"desc": "pkh(" + key.pubkey + ")",
                                "timestamp": "now",
                                "label": "Descriptor import test"},
                               success=False,
                               error_code=-5,
                               error_message='Missing checksum')
 
         # Test ranged descriptor fails if range is not specified
         xpriv = "tprv8ZgxMBicQKsPeuVhWwi6wuMQGfPKi9Li5GtX35jVNknACgqe3CY4g5xgkfDDJcmtF7o1QnxWDRYw4H5P26PXq7sbcUkEqeR4fg3Kxp2tigg"
         # hdkeypath=m/0'/0'/0' and 1'
         addresses = [
             "ecregtest:prvn9ycvgr5atuyh49sua3mapskh2mnnzg7t9yp6dt",
             "ecregtest:pp3n087yx0njv2e5wcvltahfxqst7l66rutz8ceeat"]
         # pkh subscripts corresponding to the above addresses
         addresses += [
             "ecregtest:qqdkxd2xnzftq2p8wr3sqqyw8lntap7tncs546s6pr",
             "ecregtest:qpyryy83jfaec5u0gpzldk6teadsuq8zlyqh5l30uq",
         ]
         desc = "sh(pkh(" + xpriv + "/0'/0'/*'" + "))"
         self.log.info(
             "Ranged descriptor import should fail without a specified range")
         self.test_importmulti({"desc": descsum_create(desc),
                                "timestamp": "now"},
                               success=False,
                               error_code=-8,
                               error_message='Descriptor is ranged, please specify the range')
 
         # Test importing of a ranged descriptor with xpriv
         self.log.info(
             "Should import the ranged descriptor with specified range as solvable")
         self.test_importmulti({"desc": descsum_create(desc),
                                "timestamp": "now",
                                "range": 1},
                               success=True)
         for address in addresses:
             test_address(self.nodes[1], address, solvable=True, ismine=True)
 
         self.test_importmulti({"desc": descsum_create(desc), "timestamp": "now", "range": -1},
                               success=False, error_code=-8, error_message='End of range is too high')
 
         self.test_importmulti({"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_importmulti({"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_importmulti({"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_importmulti({"desc": descsum_create(desc), "timestamp": "now", "range": [0, 1000001]},
                               success=False, error_code=-8, error_message='Range is too large')
 
         # Test importing a descriptor containing a WIF private key
         wif_priv = "cTe1f5rdT8A8DFgVWTjyPwACsDPJM9ff4QngFxUixCSvvbg1x6sh"
         # Note: in Core's test, this address refers to the sh(wpkh()) address.
         # For a sh(pkh()) this does not refer to a key, so we use the subscript
         # address instead, which returns the same privkey.
         address = "ecregtest:qzh6rch6st3wjvp0h2ud87gn7xnxvf6h8yrk8gcg8t"
         desc = "sh(pkh(" + wif_priv + "))"
         self.log.info(
             "Should import a descriptor with a WIF private key as spendable")
         self.test_importmulti({"desc": descsum_create(desc),
                                "timestamp": "now"},
                               success=True)
         test_address(self.nodes[1],
                      address,
                      solvable=True,
                      ismine=True)
 
         # dump the private key to ensure it matches what was imported
         privkey = self.nodes[1].dumpprivkey(address)
         assert_equal(privkey, wif_priv)
 
         # Test importing of a P2PKH address via descriptor
         key = get_key(self.nodes[0])
         p2pkh_label = "P2PKH descriptor import"
         self.log.info("Should import a p2pkh address from descriptor")
         self.test_importmulti({"desc": descsum_create("pkh(" + key.pubkey + ")"),
                                "timestamp": "now",
                                "label": p2pkh_label},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         test_address(self.nodes[1],
                      key.p2pkh_addr,
                      solvable=True,
                      ismine=False,
                      labels=[p2pkh_label])
 
         # Test import fails if both desc and scriptPubKey are provided
         key = get_key(self.nodes[0])
         self.log.info(
             "Import should fail if both scriptPubKey and desc are provided")
         self.test_importmulti({"desc": descsum_create("pkh(" + key.pubkey + ")"),
                                "scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now"},
                               success=False,
                               error_code=-8,
                               error_message='Both a descriptor and a scriptPubKey should not be provided.')
 
         # Test import fails if neither desc nor scriptPubKey are present
         key = get_key(self.nodes[0])
         self.log.info(
             "Import should fail if neither a descriptor nor a scriptPubKey are provided")
         self.test_importmulti({"timestamp": "now"},
                               success=False,
                               error_code=-8,
                               error_message='Either a descriptor or scriptPubKey must be provided.')
 
         # Test importing of a multisig via descriptor
         key1 = get_key(self.nodes[0])
         key2 = get_key(self.nodes[0])
         self.log.info("Should import a 1-of-2 bare multisig from descriptor")
         self.test_importmulti({"desc": descsum_create("multi(1," + key1.pubkey + "," + key2.pubkey + ")"),
                                "timestamp": "now"},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
         self.log.info(
             "Should not treat individual keys from the imported bare multisig as watchonly")
         test_address(self.nodes[1],
                      key1.p2pkh_addr,
                      ismine=False,
                      iswatchonly=False)
 
         # Import pubkeys with key origin info
         self.log.info(
             "Addresses should have hd keypath and master key id after import with key origin")
         pub_addr = self.nodes[1].getnewaddress()
         pub_addr = self.nodes[1].getnewaddress()
         info = self.nodes[1].getaddressinfo(pub_addr)
         pub = info['pubkey']
         pub_keypath = info['hdkeypath']
         pub_fpr = info['hdmasterfingerprint']
         result = self.nodes[0].importmulti(
             [{
                 'desc': descsum_create("pkh([" + pub_fpr + pub_keypath[1:] + "]" + pub + ")"),
                 "timestamp": "now",
             }]
         )
         assert result[0]['success']
         pub_import_info = self.nodes[0].getaddressinfo(pub_addr)
         assert_equal(pub_import_info['hdmasterfingerprint'], pub_fpr)
         assert_equal(pub_import_info['pubkey'], pub)
         assert_equal(pub_import_info['hdkeypath'], pub_keypath)
 
         # Import privkeys with key origin info
         priv_addr = self.nodes[1].getnewaddress()
         info = self.nodes[1].getaddressinfo(priv_addr)
         priv = self.nodes[1].dumpprivkey(priv_addr)
         priv_keypath = info['hdkeypath']
         priv_fpr = info['hdmasterfingerprint']
         result = self.nodes[0].importmulti(
             [{
                 'desc': descsum_create("pkh([" + priv_fpr + priv_keypath[1:] + "]" + priv + ")"),
                 "timestamp": "now",
             }]
         )
         assert result[0]['success']
         priv_import_info = self.nodes[0].getaddressinfo(priv_addr)
         assert_equal(priv_import_info['hdmasterfingerprint'], priv_fpr)
         assert_equal(priv_import_info['hdkeypath'], priv_keypath)
 
         # Make sure the key origin info are still there after a restart
         self.stop_nodes()
         self.start_nodes()
         import_info = self.nodes[0].getaddressinfo(pub_addr)
         assert_equal(import_info['hdmasterfingerprint'], pub_fpr)
         assert_equal(import_info['hdkeypath'], pub_keypath)
         import_info = self.nodes[0].getaddressinfo(priv_addr)
         assert_equal(import_info['hdmasterfingerprint'], priv_fpr)
         assert_equal(import_info['hdkeypath'], priv_keypath)
 
         # Check legacy import does not import key origin info
         self.log.info("Legacy imports don't have key origin info")
         pub_addr = self.nodes[1].getnewaddress()
         info = self.nodes[1].getaddressinfo(pub_addr)
         pub = info['pubkey']
         result = self.nodes[0].importmulti(
             [{
                 'scriptPubKey': {'address': pub_addr},
                 'pubkeys': [pub],
                 "timestamp": "now",
             }]
         )
         assert result[0]['success']
         pub_import_info = self.nodes[0].getaddressinfo(pub_addr)
         assert_equal(pub_import_info['pubkey'], pub)
         assert 'hdmasterfingerprint' not in pub_import_info
         assert 'hdkeypath' not in pub_import_info
 
         # Import some public keys to the keypool of a no privkey wallet
         self.log.info("Adding pubkey to keypool of disableprivkey wallet")
         self.nodes[1].createwallet(
             wallet_name="noprivkeys",
             disable_private_keys=True)
         wrpc = self.nodes[1].get_wallet_rpc("noprivkeys")
 
         addr1 = self.nodes[0].getnewaddress()
         addr2 = self.nodes[0].getnewaddress()
         pub1 = self.nodes[0].getaddressinfo(addr1)['pubkey']
         pub2 = self.nodes[0].getaddressinfo(addr2)['pubkey']
         result = wrpc.importmulti(
             [{
                 'desc': descsum_create('pkh(' + pub1 + ')'),
                 'keypool': True,
                 "timestamp": "now",
             },
                 {
                 'desc': descsum_create('pkh(' + pub2 + ')'),
                 'keypool': True,
                 "timestamp": "now",
             }]
         )
         assert result[0]['success']
         assert result[1]['success']
         assert_equal(wrpc.getwalletinfo()["keypoolsize"], 2)
         newaddr1 = wrpc.getnewaddress()
         assert_equal(addr1, newaddr1)
         newaddr2 = wrpc.getnewaddress()
         assert_equal(addr2, newaddr2)
 
         # Import some public keys to the internal keypool of a no privkey
         # wallet
         self.log.info(
             "Adding pubkey to internal keypool of disableprivkey wallet")
         addr1 = self.nodes[0].getnewaddress()
         addr2 = self.nodes[0].getnewaddress()
         pub1 = self.nodes[0].getaddressinfo(addr1)['pubkey']
         pub2 = self.nodes[0].getaddressinfo(addr2)['pubkey']
         result = wrpc.importmulti(
             [{
                 'desc': descsum_create('pkh(' + pub1 + ')'),
                 'keypool': True,
                 'internal': True,
                 "timestamp": "now",
             },
                 {
                 'desc': descsum_create('pkh(' + pub2 + ')'),
                 'keypool': True,
                 'internal': True,
                 "timestamp": "now",
             }]
         )
         assert result[0]['success']
         assert result[1]['success']
         assert_equal(wrpc.getwalletinfo()["keypoolsize_hd_internal"], 2)
         newaddr1 = wrpc.getrawchangeaddress()
         assert_equal(addr1, newaddr1)
         newaddr2 = wrpc.getrawchangeaddress()
         assert_equal(addr2, newaddr2)
 
         # Import a multisig and make sure the keys don't go into the keypool
         self.log.info(
             'Imported scripts with pubkeys shoud not have their pubkeys go into the keypool')
         addr1 = self.nodes[0].getnewaddress()
         addr2 = self.nodes[0].getnewaddress()
         pub1 = self.nodes[0].getaddressinfo(addr1)['pubkey']
         pub2 = self.nodes[0].getaddressinfo(addr2)['pubkey']
         result = wrpc.importmulti(
             [{
                 'desc': descsum_create('sh(multi(2,' + pub1 + ',' + pub2 + '))'),
                 'keypool': True,
                 "timestamp": "now",
             }]
         )
         assert result[0]['success']
         assert_equal(wrpc.getwalletinfo()["keypoolsize"], 0)
 
         # Cannot import those pubkeys to keypool of wallet with privkeys
         self.log.info(
             "Pubkeys cannot be added to the keypool of a wallet with private keys")
         wrpc = self.nodes[1].get_wallet_rpc(self.default_wallet_name)
         assert wrpc.getwalletinfo()['private_keys_enabled']
         result = wrpc.importmulti(
             [{
                 'desc': descsum_create('pkh(' + pub1 + ')'),
                 'keypool': True,
                 "timestamp": "now",
             }]
         )
         assert_equal(result[0]['error']['code'], -8)
         assert_equal(
             result[0]['error']['message'],
             "Keys can only be imported to the keypool when private keys are disabled")
 
         # Make sure ranged imports import keys in order
         self.log.info('Key ranges should be imported in order')
         wrpc = self.nodes[1].get_wallet_rpc("noprivkeys")
         assert_equal(wrpc.getwalletinfo()["keypoolsize"], 0)
         assert_equal(wrpc.getwalletinfo()["private_keys_enabled"], False)
         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
         ]
         result = wrpc.importmulti(
             [{
                 'desc': descsum_create('pkh([80002067/0h/0h]' + xpub + '/*)'),
                 'keypool': True,
                 'timestamp': 'now',
                 'range': [0, 4],
             }]
         )
         self.log.info(result)
         for i in range(0, 5):
             addr = wrpc.getnewaddress('')
             assert_equal(addr, addresses[i])
 
 
 if __name__ == '__main__':
     ImportMultiTest().main()
diff --git a/test/functional/wallet_resendwallettransactions.py b/test/functional/wallet_resendwallettransactions.py
index 4382cad22..782d78127 100755
--- a/test/functional/wallet_resendwallettransactions.py
+++ b/test/functional/wallet_resendwallettransactions.py
@@ -1,81 +1,83 @@
 #!/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 that the wallet resends transactions periodically."""
 import time
 
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.messages import ToHex
 from test_framework.p2p import P2PTxInvStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
 
 class ResendWalletTransactionsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         node = self.nodes[0]  # alias
 
         peer_first = node.add_p2p_connection(P2PTxInvStore())
 
         self.log.info("Create a new transaction and wait until it's broadcast")
         txid = node.sendtoaddress(node.getnewaddress(), 1_000_000)
 
         # Wallet rebroadcast is first scheduled 1 sec after startup (see
         # nNextResend in ResendWalletTransactions()). Tell scheduler to call
         # MaybeResendWalletTxn now to initialize nNextResend before the first
         # setmocktime call below.
         node.mockscheduler(1)
 
         # Can take a few seconds due to transaction trickling
         peer_first.wait_for_broadcast([txid])
 
         # Add a second peer since txs aren't rebroadcast to the same peer (see
         # filterInventoryKnown)
         peer_second = node.add_p2p_connection(P2PTxInvStore())
 
         self.log.info("Create a block")
         # Create and submit a block without the transaction.
         # Transactions are only rebroadcast if there has been a block at least five minutes
         # after the last time we tried to broadcast. Use mocktime and give an
         # extra minute to be sure.
         block_time = int(time.time()) + 6 * 60
         node.setmocktime(block_time)
         block = create_block(int(node.getbestblockhash(), 16), create_coinbase(
             node.getblockcount() + 1), block_time)
         block.rehash()
         block.solve()
         node.submitblock(ToHex(block))
 
+        # Set correct m_best_block_time, which is used in
+        # ResendWalletTransactions
         node.syncwithvalidationinterfacequeue()
         now = int(time.time())
 
         # Transaction should not be rebroadcast within first 12 hours
         # Leave 2 mins for buffer
         twelve_hrs = 12 * 60 * 60
         two_min = 2 * 60
         node.setmocktime(now + twelve_hrs - two_min)
         # Tell scheduler to call MaybeResendWalletTxn now
         node.mockscheduler(1)
         assert_equal(int(txid, 16) in peer_second.get_invs(), False)
 
         self.log.info("Bump time & check that transaction is rebroadcast")
         # Transaction should be rebroadcast approximately 24 hours in the future,
         # but can range from 12-36. So bump 36 hours to be sure.
         with node.assert_debug_log(['ResendWalletTransactions: resubmit 1 unconfirmed transactions']):
             node.setmocktime(now + 36 * 60 * 60)
             # Tell scheduler to call MaybeResendWalletTxn now.
             node.mockscheduler(1)
         # Give some time for trickle to occur
         node.setmocktime(now + 36 * 60 * 60 + 600)
         peer_second.wait_for_broadcast([txid])
 
 
 if __name__ == '__main__':
     ResendWalletTransactionsTest().main()