18 files changed, 677 insertions, 45 deletions

diff --git a/test/functional/feature_assumevalid.py b/test/functional/feature_assumevalid.py
index 613d2eab14..982fa79915 100755
--- a/test/functional/feature_assumevalid.py
+++ b/test/functional/feature_assumevalid.py
@@ -159,7 +159,7 @@ class AssumeValidTest(BitcoinTestFramework):
         for i in range(2202):
             p2p1.send_message(msg_block(self.blocks[i]))
         # Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
-        p2p1.sync_with_ping(960)
+        p2p1.sync_with_ping(timeout=960)
         assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202)
 
         p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
diff --git a/test/functional/feature_index_prune.py b/test/functional/feature_index_prune.py
index b3bf35b524..66c0a4f615 100755
--- a/test/functional/feature_index_prune.py
+++ b/test/functional/feature_index_prune.py
@@ -31,7 +31,7 @@ class FeatureIndexPruneTest(BitcoinTestFramework):
         expected_stats = {
             'coinstatsindex': {'synced': True, 'best_block_height': height}
         }
-        self.wait_until(lambda: self.nodes[1].getindexinfo() == expected_stats)
+        self.wait_until(lambda: self.nodes[1].getindexinfo() == expected_stats, timeout=150)
 
         expected = {**expected_filter, **expected_stats}
         self.wait_until(lambda: self.nodes[2].getindexinfo() == expected)
diff --git a/test/functional/p2p_block_sync.py b/test/functional/p2p_block_sync.py
index d821edc1b1..6c7f08364e 100755
--- a/test/functional/p2p_block_sync.py
+++ b/test/functional/p2p_block_sync.py
@@ -22,7 +22,7 @@ class BlockSyncTest(BitcoinTestFramework):
         # node0 -> node1 -> node2
         # So node1 has both an inbound and outbound peer.
         # In our test, we will mine a block on node0, and ensure that it makes
-        # to to both node1 and node2.
+        # to both node1 and node2.
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 2)
 
diff --git a/test/functional/p2p_compactblocks.py b/test/functional/p2p_compactblocks.py
index d6c06fdeed..0950579580 100755
--- a/test/functional/p2p_compactblocks.py
+++ b/test/functional/p2p_compactblocks.py
@@ -139,7 +139,7 @@ class TestP2PConn(P2PInterface):
         This is used when we want to send a message into the node that we expect
         will get us disconnected, eg an invalid block."""
         self.send_message(message)
-        self.wait_for_disconnect(timeout)
+        self.wait_for_disconnect(timeout=timeout)
 
 class CompactBlocksTest(BitcoinTestFramework):
     def set_test_params(self):
diff --git a/test/functional/p2p_node_network_limited.py b/test/functional/p2p_node_network_limited.py
index 467bbad09c..8b63d8ee26 100755
--- a/test/functional/p2p_node_network_limited.py
+++ b/test/functional/p2p_node_network_limited.py
@@ -92,7 +92,8 @@ class NodeNetworkLimitedTest(BitcoinTestFramework):
 
         # Wait until the full_node is headers-wise sync
         best_block_hash = pruned_node.getbestblockhash()
-        self.wait_until(lambda: next(filter(lambda x: x['hash'] == best_block_hash, full_node.getchaintips()))['status'] == "headers-only")
+        default_value = {'status': ''}  # No status
+        self.wait_until(lambda: next(filter(lambda x: x['hash'] == best_block_hash, full_node.getchaintips()), default_value)['status'] == "headers-only")
 
         # Now, since the node aims to download a window of 1024 blocks,
         # ensure it requests the blocks below the threshold only (with a
@@ -137,7 +138,7 @@ class NodeNetworkLimitedTest(BitcoinTestFramework):
 
         self.log.info("Requesting block at height 2 (tip-289) must fail (ignored).")
         node.send_getdata_for_block(blocks[0])  # first block outside of the 288+2 limit
-        node.wait_for_disconnect(5)
+        node.wait_for_disconnect(timeout=5)
         self.nodes[0].disconnect_p2ps()
 
         # connect unsynced node 2 with pruned NODE_NETWORK_LIMITED peer
diff --git a/test/functional/p2p_segwit.py b/test/functional/p2p_segwit.py
index 1c0c11d74c..af47c6d9f0 100755
--- a/test/functional/p2p_segwit.py
+++ b/test/functional/p2p_segwit.py
@@ -198,15 +198,15 @@ class TestP2PConn(P2PInterface):
             self.send_message(msg)
         else:
             self.send_message(msg_inv(inv=[CInv(MSG_BLOCK, block.sha256)]))
-            self.wait_for_getheaders()
+            self.wait_for_getheaders(timeout=timeout)
             self.send_message(msg)
-        self.wait_for_getdata([block.sha256])
+        self.wait_for_getdata([block.sha256], timeout=timeout)
 
     def request_block(self, blockhash, inv_type, timeout=60):
         with p2p_lock:
             self.last_message.pop("block", None)
         self.send_message(msg_getdata(inv=[CInv(inv_type, blockhash)]))
-        self.wait_for_block(blockhash, timeout)
+        self.wait_for_block(blockhash, timeout=timeout)
         return self.last_message["block"].block
 
 class SegWitTest(BitcoinTestFramework):
@@ -2056,7 +2056,7 @@ class SegWitTest(BitcoinTestFramework):
         test_transaction_acceptance(self.nodes[0], self.wtx_node, tx2, with_witness=True, accepted=False)
 
         # Expect a request for parent (tx) by txid despite use of WTX peer
-        self.wtx_node.wait_for_getdata([tx.sha256], 60)
+        self.wtx_node.wait_for_getdata([tx.sha256], timeout=60)
         with p2p_lock:
             lgd = self.wtx_node.lastgetdata[:]
         assert_equal(lgd, [CInv(MSG_WITNESS_TX, tx.sha256)])
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py
index dc04696114..ce76008c46 100755
--- a/test/functional/test_framework/p2p.py
+++ b/test/functional/test_framework/p2p.py
@@ -585,22 +585,22 @@ class P2PInterface(P2PConnection):
 
         wait_until_helper_internal(test_function, timeout=timeout, lock=p2p_lock, timeout_factor=self.timeout_factor)
 
-    def wait_for_connect(self, timeout=60):
+    def wait_for_connect(self, *, timeout=60):
         test_function = lambda: self.is_connected
         self.wait_until(test_function, timeout=timeout, check_connected=False)
 
-    def wait_for_disconnect(self, timeout=60):
+    def wait_for_disconnect(self, *, timeout=60):
         test_function = lambda: not self.is_connected
         self.wait_until(test_function, timeout=timeout, check_connected=False)
 
-    def wait_for_reconnect(self, timeout=60):
+    def wait_for_reconnect(self, *, timeout=60):
         def test_function():
             return self.is_connected and self.last_message.get('version') and not self.supports_v2_p2p
         self.wait_until(test_function, timeout=timeout, check_connected=False)
 
     # Message receiving helper methods
 
-    def wait_for_tx(self, txid, timeout=60):
+    def wait_for_tx(self, txid, *, timeout=60):
         def test_function():
             if not self.last_message.get('tx'):
                 return False
@@ -608,13 +608,13 @@ class P2PInterface(P2PConnection):
 
         self.wait_until(test_function, timeout=timeout)
 
-    def wait_for_block(self, blockhash, timeout=60):
+    def wait_for_block(self, blockhash, *, timeout=60):
         def test_function():
             return self.last_message.get("block") and self.last_message["block"].block.rehash() == blockhash
 
         self.wait_until(test_function, timeout=timeout)
 
-    def wait_for_header(self, blockhash, timeout=60):
+    def wait_for_header(self, blockhash, *, timeout=60):
         def test_function():
             last_headers = self.last_message.get('headers')
             if not last_headers:
@@ -623,7 +623,7 @@ class P2PInterface(P2PConnection):
 
         self.wait_until(test_function, timeout=timeout)
 
-    def wait_for_merkleblock(self, blockhash, timeout=60):
+    def wait_for_merkleblock(self, blockhash, *, timeout=60):
         def test_function():
             last_filtered_block = self.last_message.get('merkleblock')
             if not last_filtered_block:
@@ -632,7 +632,7 @@ class P2PInterface(P2PConnection):
 
         self.wait_until(test_function, timeout=timeout)
 
-    def wait_for_getdata(self, hash_list, timeout=60):
+    def wait_for_getdata(self, hash_list, *, timeout=60):
         """Waits for a getdata message.
 
         The object hashes in the inventory vector must match the provided hash_list."""
@@ -644,7 +644,7 @@ class P2PInterface(P2PConnection):
 
         self.wait_until(test_function, timeout=timeout)
 
-    def wait_for_getheaders(self, timeout=60):
+    def wait_for_getheaders(self, *, timeout=60):
         """Waits for a getheaders message.
 
         Receiving any getheaders message will satisfy the predicate. the last_message["getheaders"]
@@ -656,7 +656,7 @@ class P2PInterface(P2PConnection):
 
         self.wait_until(test_function, timeout=timeout)
 
-    def wait_for_inv(self, expected_inv, timeout=60):
+    def wait_for_inv(self, expected_inv, *, timeout=60):
         """Waits for an INV message and checks that the first inv object in the message was as expected."""
         if len(expected_inv) > 1:
             raise NotImplementedError("wait_for_inv() will only verify the first inv object")
@@ -668,7 +668,7 @@ class P2PInterface(P2PConnection):
 
         self.wait_until(test_function, timeout=timeout)
 
-    def wait_for_verack(self, timeout=60):
+    def wait_for_verack(self, *, timeout=60):
         def test_function():
             return "verack" in self.last_message
 
@@ -681,11 +681,11 @@ class P2PInterface(P2PConnection):
             self.send_message(self.on_connection_send_msg)
             self.on_connection_send_msg = None  # Never used again
 
-    def send_and_ping(self, message, timeout=60):
+    def send_and_ping(self, message, *, timeout=60):
         self.send_message(message)
         self.sync_with_ping(timeout=timeout)
 
-    def sync_with_ping(self, timeout=60):
+    def sync_with_ping(self, *, timeout=60):
         """Ensure ProcessMessages and SendMessages is called on this connection"""
         # Sending two pings back-to-back, requires that the node calls
         # `ProcessMessage` twice, and thus ensures `SendMessages` must have
@@ -726,7 +726,7 @@ class NetworkThread(threading.Thread):
         """Start the network thread."""
         self.network_event_loop.run_forever()
 
-    def close(self, timeout=10):
+    def close(self, *, timeout=10):
         """Close the connections and network event loop."""
         self.network_event_loop.call_soon_threadsafe(self.network_event_loop.stop)
         wait_until_helper_internal(lambda: not self.network_event_loop.is_running(), timeout=timeout)
@@ -933,7 +933,7 @@ class P2PTxInvStore(P2PInterface):
         with p2p_lock:
             return list(self.tx_invs_received.keys())
 
-    def wait_for_broadcast(self, txns, timeout=60):
+    def wait_for_broadcast(self, txns, *, timeout=60):
         """Waits for the txns (list of txids) to complete initial broadcast.
         The mempool should mark unbroadcast=False for these transactions.
         """
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index c3884270da..a2f767cc98 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -164,7 +164,7 @@ class BitcoinTestFramework(metaclass=BitcoinTestMetaClass):
                             help="Don't stop bitcoinds after the test execution")
         parser.add_argument("--cachedir", dest="cachedir", default=os.path.abspath(os.path.dirname(os.path.realpath(__file__)) + "/../../cache"),
                             help="Directory for caching pregenerated datadirs (default: %(default)s)")
-        parser.add_argument("--tmpdir", dest="tmpdir", help="Root directory for datadirs")
+        parser.add_argument("--tmpdir", dest="tmpdir", help="Root directory for datadirs (must not exist)")
         parser.add_argument("-l", "--loglevel", dest="loglevel", default="INFO",
                             help="log events at this level and higher to the console. Can be set to DEBUG, INFO, WARNING, ERROR or CRITICAL. Passing --loglevel DEBUG will output all logs to console. Note that logs at all levels are always written to the test_framework.log file in the temporary test directory.")
         parser.add_argument("--tracerpc", dest="trace_rpc", default=False, action="store_true",
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 1408854e02..3f6e47d410 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -181,6 +181,8 @@ BASE_SCRIPTS = [
     'wallet_keypool_topup.py --legacy-wallet',
     'wallet_keypool_topup.py --descriptors',
     'wallet_fast_rescan.py --descriptors',
+    'wallet_gethdkeys.py --descriptors',
+    'wallet_createwalletdescriptor.py --descriptors',
     'interface_zmq.py',
     'rpc_invalid_address_message.py',
     'rpc_validateaddress.py',
diff --git a/test/functional/wallet_abandonconflict.py b/test/functional/wallet_abandonconflict.py
index e69546bb82..dda48aae1b 100755
--- a/test/functional/wallet_abandonconflict.py
+++ b/test/functional/wallet_abandonconflict.py
@@ -231,7 +231,11 @@ class AbandonConflictTest(BitcoinTestFramework):
         balance = newbalance
 
         # Invalidate the block with the double spend. B & C's 10 BTC outputs should no longer be available
-        self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
+        blk = self.nodes[0].getbestblockhash()
+        # mine 10 blocks so that when the blk is invalidated, the transactions are not
+        # returned to the mempool
+        self.generate(self.nodes[1], 10)
+        self.nodes[0].invalidateblock(blk)
         assert_equal(alice.gettransaction(txAB1)["confirmations"], 0)
         newbalance = alice.getbalance()
         assert_equal(newbalance, balance - Decimal("20"))
diff --git a/test/functional/wallet_backwards_compatibility.py b/test/functional/wallet_backwards_compatibility.py
index 4d6e6024c5..ab008a40cd 100755
--- a/test/functional/wallet_backwards_compatibility.py
+++ b/test/functional/wallet_backwards_compatibility.py
@@ -355,6 +355,25 @@ class BackwardsCompatibilityTest(BitcoinTestFramework):
             down_wallet_name = f"re_down_{node.version}"
             down_backup_path = os.path.join(self.options.tmpdir, f"{down_wallet_name}.dat")
             wallet.backupwallet(down_backup_path)
+
+            # Check that taproot descriptors can be added to 0.21 wallets
+            # This must be done after the backup is created so that 0.21 can still load
+            # the backup
+            if self.options.descriptors and self.major_version_equals(node, 21):
+                assert_raises_rpc_error(-12, "No bech32m addresses available", wallet.getnewaddress, address_type="bech32m")
+                xpubs = wallet.gethdkeys(active_only=True)
+                assert_equal(len(xpubs), 1)
+                assert_equal(len(xpubs[0]["descriptors"]), 6)
+                wallet.createwalletdescriptor("bech32m")
+                xpubs = wallet.gethdkeys(active_only=True)
+                assert_equal(len(xpubs), 1)
+                assert_equal(len(xpubs[0]["descriptors"]), 8)
+                tr_descs = [desc["desc"] for desc in xpubs[0]["descriptors"] if desc["desc"].startswith("tr(")]
+                assert_equal(len(tr_descs), 2)
+                for desc in tr_descs:
+                    assert info["hdmasterfingerprint"] in desc
+                wallet.getnewaddress(address_type="bech32m")
+
             wallet.unloadwallet()
 
             # Check that no automatic upgrade broke the downgrading the wallet
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
index 31d3c14e55..56228d2bad 100755
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -681,7 +681,7 @@ class WalletTest(BitcoinTestFramework):
                                  "category": baz["category"],
                                  "vout":     baz["vout"]}
         expected_fields = frozenset({'amount', 'bip125-replaceable', 'confirmations', 'details', 'fee',
-                                     'hex', 'lastprocessedblock', 'time', 'timereceived', 'trusted', 'txid', 'wtxid', 'walletconflicts'})
+                                     'hex', 'lastprocessedblock', 'time', 'timereceived', 'trusted', 'txid', 'wtxid', 'walletconflicts', 'mempoolconflicts'})
         verbose_field = "decoded"
         expected_verbose_fields = expected_fields | {verbose_field}
 
diff --git a/test/functional/wallet_conflicts.py b/test/functional/wallet_conflicts.py
index 802b718cd5..e5739a6a59 100755
--- a/test/functional/wallet_conflicts.py
+++ b/test/functional/wallet_conflicts.py
@@ -9,6 +9,7 @@ Test that wallet correctly tracks transactions that have been conflicted by bloc
 
 from decimal import Decimal
 
+from test_framework.blocktools import COINBASE_MATURITY
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
         assert_equal,
@@ -28,6 +29,20 @@ class TxConflicts(BitcoinTestFramework):
         return next(tx_out["vout"] for tx_out in self.nodes[0].gettransaction(from_tx_id)["details"] if tx_out["amount"] == Decimal(f"{search_value}"))
 
     def run_test(self):
+        """
+        The following tests check the behavior of the wallet when
+        transaction conflicts are created. These conflicts are created
+        using raw transaction RPCs that double-spend UTXOs and have more
+        fees, replacing the original transaction.
+        """
+
+        self.test_block_conflicts()
+        self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 7, self.nodes[2].getnewaddress())
+        self.test_mempool_conflict()
+        self.test_mempool_and_block_conflicts()
+        self.test_descendants_with_mempool_conflicts()
+
+    def test_block_conflicts(self):
         self.log.info("Send tx from which to conflict outputs later")
         txid_conflict_from_1 = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
         txid_conflict_from_2 = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
@@ -123,5 +138,291 @@ class TxConflicts(BitcoinTestFramework):
         assert_equal(former_conflicted["confirmations"], 1)
         assert_equal(former_conflicted["blockheight"], 217)
 
+    def test_mempool_conflict(self):
+        self.nodes[0].createwallet("alice")
+        alice = self.nodes[0].get_wallet_rpc("alice")
+
+        bob = self.nodes[1]
+
+        self.nodes[2].send(outputs=[{alice.getnewaddress() : 25} for _ in range(3)])
+        self.generate(self.nodes[2], 1)
+
+        self.log.info("Test a scenario where a transaction has a mempool conflict")
+
+        unspents = alice.listunspent()
+        assert_equal(len(unspents), 3)
+        assert all([tx["amount"] == 25 for tx in unspents])
+
+        # tx1 spends unspent[0] and unspent[1]
+        raw_tx = alice.createrawtransaction(inputs=[unspents[0], unspents[1]], outputs=[{bob.getnewaddress() : 49.9999}])
+        tx1 = alice.signrawtransactionwithwallet(raw_tx)['hex']
+
+        # tx2 spends unspent[1] and unspent[2], conflicts with tx1
+        raw_tx = alice.createrawtransaction(inputs=[unspents[1], unspents[2]], outputs=[{bob.getnewaddress() : 49.99}])
+        tx2 = alice.signrawtransactionwithwallet(raw_tx)['hex']
+
+        # tx3 spends unspent[2], conflicts with tx2
+        raw_tx = alice.createrawtransaction(inputs=[unspents[2]], outputs=[{bob.getnewaddress() : 24.9899}])
+        tx3 = alice.signrawtransactionwithwallet(raw_tx)['hex']
+
+        # broadcast tx1
+        tx1_txid = alice.sendrawtransaction(tx1)
+
+        assert_equal(alice.listunspent(), [unspents[2]])
+        assert_equal(alice.getbalance(), 25)
+
+        # broadcast tx2, replaces tx1 in mempool
+        tx2_txid = alice.sendrawtransaction(tx2)
+
+        # Check that unspent[0] is now available because the transaction spending it has been replaced in the mempool
+        assert_equal(alice.listunspent(), [unspents[0]])
+        assert_equal(alice.getbalance(), 25)
+
+        assert_equal(alice.gettransaction(tx1_txid)["mempoolconflicts"], [tx2_txid])
+
+        self.log.info("Test scenario where a mempool conflict is removed")
+
+        # broadcast tx3, replaces tx2 in mempool
+        # Now that tx1's conflict has been removed, tx1 is now
+        # not conflicted, and instead is inactive until it is
+        # rebroadcasted. Now unspent[0] is not available, because
+        # tx1 is no longer conflicted.
+        alice.sendrawtransaction(tx3)
+
+        assert_equal(alice.gettransaction(tx1_txid)["mempoolconflicts"], [])
+        assert tx1_txid not in self.nodes[0].getrawmempool()
+
+        # now all of alice's outputs should be considered spent
+        # unspent[0]: spent by inactive tx1
+        # unspent[1]: spent by inactive tx1
+        # unspent[2]: spent by active tx3
+        assert_equal(alice.listunspent(), [])
+        assert_equal(alice.getbalance(), 0)
+
+        # Clean up for next test
+        bob.sendall([self.nodes[2].getnewaddress()])
+        self.generate(self.nodes[2], 1)
+
+        alice.unloadwallet()
+
+    def test_mempool_and_block_conflicts(self):
+        self.nodes[0].createwallet("alice_2")
+        alice = self.nodes[0].get_wallet_rpc("alice_2")
+        bob = self.nodes[1]
+
+        self.nodes[2].send(outputs=[{alice.getnewaddress() : 25} for _ in range(3)])
+        self.generate(self.nodes[2], 1)
+
+        self.log.info("Test a scenario where a transaction has both a block conflict and a mempool conflict")
+        unspents = [{"txid" : element["txid"], "vout" : element["vout"]} for element in alice.listunspent()]
+
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+
+        # alice and bob nodes are disconnected so that transactions can be
+        # created by alice, but broadcasted from bob so that alice's wallet
+        # doesn't know about them
+        self.disconnect_nodes(0, 1)
+
+        # Sends funds to bob
+        raw_tx = alice.createrawtransaction(inputs=[unspents[0]], outputs=[{bob.getnewaddress() : 24.99999}])
+        raw_tx1 = alice.signrawtransactionwithwallet(raw_tx)['hex']
+        tx1_txid = bob.sendrawtransaction(raw_tx1) # broadcast original tx spending unspents[0] only to bob
+
+        # create a conflict to previous tx (also spends unspents[0]), but don't broadcast, sends funds back to alice
+        raw_tx = alice.createrawtransaction(inputs=[unspents[0], unspents[2]], outputs=[{alice.getnewaddress() : 49.999}])
+        tx1_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
+
+        # Sends funds to bob
+        raw_tx = alice.createrawtransaction(inputs=[unspents[1]], outputs=[{bob.getnewaddress() : 24.9999}])
+        raw_tx2 = alice.signrawtransactionwithwallet(raw_tx)['hex']
+        tx2_txid = bob.sendrawtransaction(raw_tx2) # broadcast another original tx spending unspents[1] only to bob
+
+        # create a conflict to previous tx (also spends unspents[1]), but don't broadcast, sends funds to alice
+        raw_tx = alice.createrawtransaction(inputs=[unspents[1]], outputs=[{alice.getnewaddress() : 24.9999}])
+        tx2_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
+
+        bob_unspents = [{"txid" : element, "vout" : 0} for element in [tx1_txid, tx2_txid]]
+
+        # tx1 and tx2 are now in bob's mempool, and they are unconflicted, so bob has these funds
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("49.99989000"))
+
+        # spend both of bob's unspents, child tx of tx1 and tx2
+        raw_tx = bob.createrawtransaction(inputs=[bob_unspents[0], bob_unspents[1]], outputs=[{bob.getnewaddress() : 49.999}])
+        raw_tx3 = bob.signrawtransactionwithwallet(raw_tx)['hex']
+        tx3_txid = bob.sendrawtransaction(raw_tx3) # broadcast tx only to bob
+
+        # alice knows about 0 txs, bob knows about 3
+        assert_equal(len(alice.getrawmempool()), 0)
+        assert_equal(len(bob.getrawmempool()), 3)
+
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("49.99900000"))
+
+        # bob broadcasts tx_1 conflict
+        tx1_conflict_txid = bob.sendrawtransaction(tx1_conflict)
+        assert_equal(len(alice.getrawmempool()), 0)
+        assert_equal(len(bob.getrawmempool()), 2) # tx1_conflict kicks out both tx1, and its child tx3
+
+        assert tx2_txid in bob.getrawmempool()
+        assert tx1_conflict_txid in bob.getrawmempool()
+
+        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"], [tx1_conflict_txid])
+        assert_equal(bob.gettransaction(tx2_txid)["mempoolconflicts"], [])
+        assert_equal(bob.gettransaction(tx3_txid)["mempoolconflicts"], [tx1_conflict_txid])
+
+        # check that tx3 is now conflicted, so the output from tx2 can now be spent
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("24.99990000"))
+
+        # we will be disconnecting this block in the future
+        alice.sendrawtransaction(tx2_conflict)
+        assert_equal(len(alice.getrawmempool()), 1) # currently alice's mempool is only aware of tx2_conflict
+        # 11 blocks are mined so that when they are invalidated, tx_2
+        # does not get put back into the mempool
+        blk = self.generate(self.nodes[0], 11, sync_fun=self.no_op)[0]
+        assert_equal(len(alice.getrawmempool()), 0) # tx2_conflict is now mined
+
+        self.connect_nodes(0, 1)
+        self.sync_blocks()
+        assert_equal(alice.getbestblockhash(), bob.getbestblockhash())
+
+        # now that tx2 has a block conflict, tx1_conflict should be the only tx in bob's mempool
+        assert tx1_conflict_txid in bob.getrawmempool()
+        assert_equal(len(bob.getrawmempool()), 1)
+
+        # tx3 should now also be block-conflicted by tx2_conflict
+        assert_equal(bob.gettransaction(tx3_txid)["confirmations"], -11)
+        # bob has no pending funds, since tx1, tx2, and tx3 are all conflicted
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+        bob.invalidateblock(blk) # remove tx2_conflict
+        # bob should still have no pending funds because tx1 and tx3 are still conflicted, and tx2 has not been re-broadcast
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+        assert_equal(len(bob.getrawmempool()), 1)
+        # check that tx3 is no longer block-conflicted
+        assert_equal(bob.gettransaction(tx3_txid)["confirmations"], 0)
+
+        bob.sendrawtransaction(raw_tx2)
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("24.99990000"))
+
+        # create a conflict to previous tx (also spends unspents[2]), but don't broadcast, sends funds back to alice
+        raw_tx = alice.createrawtransaction(inputs=[unspents[2]], outputs=[{alice.getnewaddress() : 24.99}])
+        tx1_conflict_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
+
+        bob.sendrawtransaction(tx1_conflict_conflict) # kick tx1_conflict out of the mempool
+        bob.sendrawtransaction(raw_tx1) #re-broadcast tx1 because it is no longer conflicted
+
+        # Now bob has no pending funds because tx1 and tx2 are spent by tx3, which hasn't been re-broadcast yet
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+
+        bob.sendrawtransaction(raw_tx3)
+        assert_equal(len(bob.getrawmempool()), 4) # The mempool contains: tx1, tx2, tx1_conflict_conflict, tx3
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("49.99900000"))
+
+        # Clean up for next test
+        bob.reconsiderblock(blk)
+        assert_equal(alice.getbestblockhash(), bob.getbestblockhash())
+        self.sync_mempools()
+        self.generate(self.nodes[2], 1)
+
+        alice.unloadwallet()
+
+    def test_descendants_with_mempool_conflicts(self):
+        self.nodes[0].createwallet("alice_3")
+        alice = self.nodes[0].get_wallet_rpc("alice_3")
+
+        self.nodes[2].send(outputs=[{alice.getnewaddress() : 25} for _ in range(2)])
+        self.generate(self.nodes[2], 1)
+
+        self.nodes[1].createwallet("bob_1")
+        bob = self.nodes[1].get_wallet_rpc("bob_1")
+
+        self.nodes[2].createwallet("carol")
+        carol = self.nodes[2].get_wallet_rpc("carol")
+
+        self.log.info("Test a scenario where a transaction's parent has a mempool conflict")
+
+        unspents = alice.listunspent()
+        assert_equal(len(unspents), 2)
+        assert all([tx["amount"] == 25 for tx in unspents])
+
+        assert_equal(alice.getrawmempool(), [])
+
+        # Alice spends first utxo to bob in tx1
+        raw_tx = alice.createrawtransaction(inputs=[unspents[0]], outputs=[{bob.getnewaddress() : 24.9999}])
+        tx1 = alice.signrawtransactionwithwallet(raw_tx)['hex']
+        tx1_txid = alice.sendrawtransaction(tx1)
+
+        self.sync_mempools()
+
+        assert_equal(alice.getbalance(), 25)
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("24.99990000"))
+
+        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [])
+
+        raw_tx = bob.createrawtransaction(inputs=[bob.listunspent(minconf=0)[0]], outputs=[{carol.getnewaddress() : 24.999}])
+        # Bob creates a child to tx1
+        tx1_child = bob.signrawtransactionwithwallet(raw_tx)['hex']
+        tx1_child_txid = bob.sendrawtransaction(tx1_child)
+
+        self.sync_mempools()
+
+        # Currently neither tx1 nor tx1_child should have any conflicts
+        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [])
+        assert_equal(bob.gettransaction(tx1_child_txid)["mempoolconflicts"],  [])
+        assert tx1_txid in bob.getrawmempool()
+        assert tx1_child_txid in bob.getrawmempool()
+        assert_equal(len(bob.getrawmempool()), 2)
+
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+        assert_equal(carol.getbalances()["mine"]["untrusted_pending"], Decimal("24.99900000"))
+
+        # Alice spends first unspent again, conflicting with tx1
+        raw_tx = alice.createrawtransaction(inputs=[unspents[0], unspents[1]], outputs=[{carol.getnewaddress() : 49.99}])
+        tx1_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
+        tx1_conflict_txid = alice.sendrawtransaction(tx1_conflict)
+
+        self.sync_mempools()
+
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+        assert_equal(carol.getbalances()["mine"]["untrusted_pending"], Decimal("49.99000000"))
+
+        assert tx1_txid not in bob.getrawmempool()
+        assert tx1_child_txid not in bob.getrawmempool()
+        assert tx1_conflict_txid in bob.getrawmempool()
+        assert_equal(len(bob.getrawmempool()), 1)
+
+        # Now both tx1 and tx1_child are conflicted by tx1_conflict
+        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [tx1_conflict_txid])
+        assert_equal(bob.gettransaction(tx1_child_txid)["mempoolconflicts"],  [tx1_conflict_txid])
+
+        # Now create a conflict to tx1_conflict, so that it gets kicked out of the mempool
+        raw_tx = alice.createrawtransaction(inputs=[unspents[1]], outputs=[{carol.getnewaddress() : 24.9895}])
+        tx1_conflict_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
+        tx1_conflict_conflict_txid = alice.sendrawtransaction(tx1_conflict_conflict)
+
+        self.sync_mempools()
+
+        # Now that tx1_conflict has been removed, both tx1 and tx1_child
+        assert_equal(bob.gettransaction(tx1_txid)["mempoolconflicts"],  [])
+        assert_equal(bob.gettransaction(tx1_child_txid)["mempoolconflicts"],  [])
+
+        # Both tx1 and tx1_child are still not in the mempool because they have not be re-broadcasted
+        assert tx1_txid not in bob.getrawmempool()
+        assert tx1_child_txid not in bob.getrawmempool()
+        assert tx1_conflict_txid not in bob.getrawmempool()
+        assert tx1_conflict_conflict_txid in bob.getrawmempool()
+        assert_equal(len(bob.getrawmempool()), 1)
+
+        assert_equal(alice.getbalance(), 0)
+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+        assert_equal(carol.getbalances()["mine"]["untrusted_pending"], Decimal("24.98950000"))
+
+        # Both tx1 and tx1_child can now be re-broadcasted
+        bob.sendrawtransaction(tx1)
+        bob.sendrawtransaction(tx1_child)
+        assert_equal(len(bob.getrawmempool()), 3)
+
+        alice.unloadwallet()
+        bob.unloadwallet()
+        carol.unloadwallet()
+
 if __name__ == '__main__':
     TxConflicts().main()
diff --git a/test/functional/wallet_createwalletdescriptor.py b/test/functional/wallet_createwalletdescriptor.py
new file mode 100755
index 0000000000..18e1703da3
--- /dev/null
+++ b/test/functional/wallet_createwalletdescriptor.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# Copyright (c) 2023 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 createwalletdescriptor RPC."""
+
+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,
+)
+from test_framework.wallet_util import WalletUnlock
+
+
+class WalletCreateDescriptorTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser, descriptors=True, legacy=False)
+
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        self.test_basic()
+        self.test_imported_other_keys()
+        self.test_encrypted()
+
+    def test_basic(self):
+        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
+        self.nodes[0].createwallet("blank", blank=True)
+        wallet = self.nodes[0].get_wallet_rpc("blank")
+
+        xpub_info = def_wallet.gethdkeys(private=True)
+        xpub = xpub_info[0]["xpub"]
+        xprv = xpub_info[0]["xprv"]
+        expected_descs = []
+        for desc in def_wallet.listdescriptors()["descriptors"]:
+            if desc["desc"].startswith("wpkh("):
+                expected_descs.append(desc["desc"])
+
+        assert_raises_rpc_error(-5, "Unable to determine which HD key to use from active descriptors. Please specify with 'hdkey'", wallet.createwalletdescriptor, "bech32")
+        assert_raises_rpc_error(-5, f"Private key for {xpub} is not known", wallet.createwalletdescriptor, type="bech32", hdkey=xpub)
+
+        self.log.info("Test createwalletdescriptor after importing active descriptor to blank wallet")
+        # Import one active descriptor
+        assert_equal(wallet.importdescriptors([{"desc": descsum_create(f"pkh({xprv}/44h/2h/0h/0/0/*)"), "timestamp": "now", "active": True}])[0]["success"], True)
+        assert_equal(len(wallet.listdescriptors()["descriptors"]), 1)
+        assert_equal(len(wallet.gethdkeys()), 1)
+
+        new_descs = wallet.createwalletdescriptor("bech32")["descs"]
+        assert_equal(len(new_descs), 2)
+        assert_equal(len(wallet.gethdkeys()), 1)
+        assert_equal(new_descs, expected_descs)
+
+        self.log.info("Test descriptor creation options")
+        old_descs = set([(d["desc"], d["active"], d["internal"]) for d in wallet.listdescriptors(private=True)["descriptors"]])
+        wallet.createwalletdescriptor(type="bech32m", internal=False)
+        curr_descs = set([(d["desc"], d["active"], d["internal"]) for d in wallet.listdescriptors(private=True)["descriptors"]])
+        new_descs = list(curr_descs - old_descs)
+        assert_equal(len(new_descs), 1)
+        assert_equal(len(wallet.gethdkeys()), 1)
+        assert_equal(new_descs[0][0], descsum_create(f"tr({xprv}/86h/1h/0h/0/*)"))
+        assert_equal(new_descs[0][1], True)
+        assert_equal(new_descs[0][2], False)
+
+        old_descs = curr_descs
+        wallet.createwalletdescriptor(type="bech32m", internal=True)
+        curr_descs = set([(d["desc"], d["active"], d["internal"]) for d in wallet.listdescriptors(private=True)["descriptors"]])
+        new_descs = list(curr_descs - old_descs)
+        assert_equal(len(new_descs), 1)
+        assert_equal(len(wallet.gethdkeys()), 1)
+        assert_equal(new_descs[0][0], descsum_create(f"tr({xprv}/86h/1h/0h/1/*)"))
+        assert_equal(new_descs[0][1], True)
+        assert_equal(new_descs[0][2], True)
+
+    def test_imported_other_keys(self):
+        self.log.info("Test createwalletdescriptor with multiple keys in active descriptors")
+        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
+        self.nodes[0].createwallet("multiple_keys")
+        wallet = self.nodes[0].get_wallet_rpc("multiple_keys")
+
+        wallet_xpub = wallet.gethdkeys()[0]["xpub"]
+
+        xpub_info = def_wallet.gethdkeys(private=True)
+        xpub = xpub_info[0]["xpub"]
+        xprv = xpub_info[0]["xprv"]
+
+        assert_equal(wallet.importdescriptors([{"desc": descsum_create(f"wpkh({xprv}/0/0/*)"), "timestamp": "now", "active": True}])[0]["success"], True)
+        assert_equal(len(wallet.gethdkeys()), 2)
+
+        assert_raises_rpc_error(-5, "Unable to determine which HD key to use from active descriptors. Please specify with 'hdkey'", wallet.createwalletdescriptor, "bech32")
+        assert_raises_rpc_error(-4, "Descriptor already exists", wallet.createwalletdescriptor, type="bech32m", hdkey=wallet_xpub)
+        assert_raises_rpc_error(-5, "Unable to parse HD key. Please provide a valid xpub", wallet.createwalletdescriptor, type="bech32m", hdkey=xprv)
+
+        # Able to replace tr() descriptor with other hd key
+        wallet.createwalletdescriptor(type="bech32m", hdkey=xpub)
+
+    def test_encrypted(self):
+        self.log.info("Test createwalletdescriptor with encrypted wallets")
+        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
+        self.nodes[0].createwallet("encrypted", blank=True, passphrase="pass")
+        wallet = self.nodes[0].get_wallet_rpc("encrypted")
+
+        xpub_info = def_wallet.gethdkeys(private=True)
+        xprv = xpub_info[0]["xprv"]
+
+        with WalletUnlock(wallet, "pass"):
+            assert_equal(wallet.importdescriptors([{"desc": descsum_create(f"wpkh({xprv}/0/0/*)"), "timestamp": "now", "active": True}])[0]["success"], True)
+        assert_equal(len(wallet.gethdkeys()), 1)
+
+        assert_raises_rpc_error(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.", wallet.createwalletdescriptor, type="bech32m")
+
+        with WalletUnlock(wallet, "pass"):
+            wallet.createwalletdescriptor(type="bech32m")
+
+
+
+if __name__ == '__main__':
+    WalletCreateDescriptorTest().main()
diff --git a/test/functional/wallet_gethdkeys.py b/test/functional/wallet_gethdkeys.py
new file mode 100755
index 0000000000..f09b8c875a
--- /dev/null
+++ b/test/functional/wallet_gethdkeys.py
@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# Copyright (c) 2023 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 gethdkeys RPC."""
+
+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,
+)
+from test_framework.wallet_util import WalletUnlock
+
+
+class WalletGetHDKeyTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser, descriptors=True, legacy=False)
+
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        self.test_basic_gethdkeys()
+        self.test_ranged_imports()
+        self.test_lone_key_imports()
+        self.test_ranged_multisig()
+        self.test_mixed_multisig()
+
+    def test_basic_gethdkeys(self):
+        self.log.info("Test gethdkeys basics")
+        self.nodes[0].createwallet("basic")
+        wallet = self.nodes[0].get_wallet_rpc("basic")
+        xpub_info = wallet.gethdkeys()
+        assert_equal(len(xpub_info), 1)
+        assert_equal(xpub_info[0]["has_private"], True)
+
+        assert "xprv" not in xpub_info[0]
+        xpub = xpub_info[0]["xpub"]
+
+        xpub_info = wallet.gethdkeys(private=True)
+        xprv = xpub_info[0]["xprv"]
+        assert_equal(xpub_info[0]["xpub"], xpub)
+        assert_equal(xpub_info[0]["has_private"], True)
+
+        descs = wallet.listdescriptors(True)
+        for desc in descs["descriptors"]:
+            assert xprv in desc["desc"]
+
+        self.log.info("HD pubkey can be retrieved from encrypted wallets")
+        prev_xprv = xprv
+        wallet.encryptwallet("pass")
+        # HD key is rotated on encryption, there should now be 2 HD keys
+        assert_equal(len(wallet.gethdkeys()), 2)
+        # New key is active, should be able to get only that one and its descriptors
+        xpub_info = wallet.gethdkeys(active_only=True)
+        assert_equal(len(xpub_info), 1)
+        assert xpub_info[0]["xpub"] != xpub
+        assert "xprv" not in xpub_info[0]
+        assert_equal(xpub_info[0]["has_private"], True)
+
+        self.log.info("HD privkey can be retrieved from encrypted wallets")
+        assert_raises_rpc_error(-13, "Error: Please enter the wallet passphrase with walletpassphrase first", wallet.gethdkeys, private=True)
+        with WalletUnlock(wallet, "pass"):
+            xpub_info = wallet.gethdkeys(active_only=True, private=True)[0]
+            assert xpub_info["xprv"] != xprv
+            for desc in wallet.listdescriptors(True)["descriptors"]:
+                if desc["active"]:
+                    # After encrypting, HD key was rotated and should appear in all active descriptors
+                    assert xpub_info["xprv"] in desc["desc"]
+                else:
+                    # Inactive descriptors should have the previous HD key
+                    assert prev_xprv in desc["desc"]
+
+    def test_ranged_imports(self):
+        self.log.info("Keys of imported ranged descriptors appear in gethdkeys")
+        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
+        self.nodes[0].createwallet("imports")
+        wallet = self.nodes[0].get_wallet_rpc("imports")
+
+        xpub_info = wallet.gethdkeys()
+        assert_equal(len(xpub_info), 1)
+        active_xpub = xpub_info[0]["xpub"]
+
+        import_xpub = def_wallet.gethdkeys(active_only=True)[0]["xpub"]
+        desc_import = def_wallet.listdescriptors(True)["descriptors"]
+        for desc in desc_import:
+            desc["active"] = False
+        wallet.importdescriptors(desc_import)
+        assert_equal(wallet.gethdkeys(active_only=True), xpub_info)
+
+        xpub_info = wallet.gethdkeys()
+        assert_equal(len(xpub_info), 2)
+        for x in xpub_info:
+            if x["xpub"] == active_xpub:
+                for desc in x["descriptors"]:
+                    assert_equal(desc["active"], True)
+            elif x["xpub"] == import_xpub:
+                for desc in x["descriptors"]:
+                    assert_equal(desc["active"], False)
+            else:
+                assert False
+
+
+    def test_lone_key_imports(self):
+        self.log.info("Non-HD keys do not appear in gethdkeys")
+        self.nodes[0].createwallet("lonekey", blank=True)
+        wallet = self.nodes[0].get_wallet_rpc("lonekey")
+
+        assert_equal(wallet.gethdkeys(), [])
+        wallet.importdescriptors([{"desc": descsum_create("wpkh(cTe1f5rdT8A8DFgVWTjyPwACsDPJM9ff4QngFxUixCSvvbg1x6sh)"), "timestamp": "now"}])
+        assert_equal(wallet.gethdkeys(), [])
+
+        self.log.info("HD keys of non-ranged descriptors should appear in gethdkeys")
+        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
+        xpub_info = def_wallet.gethdkeys(private=True)
+        xpub = xpub_info[0]["xpub"]
+        xprv = xpub_info[0]["xprv"]
+        prv_desc = descsum_create(f"wpkh({xprv})")
+        pub_desc = descsum_create(f"wpkh({xpub})")
+        assert_equal(wallet.importdescriptors([{"desc": prv_desc, "timestamp": "now"}])[0]["success"], True)
+        xpub_info = wallet.gethdkeys()
+        assert_equal(len(xpub_info), 1)
+        assert_equal(xpub_info[0]["xpub"], xpub)
+        assert_equal(len(xpub_info[0]["descriptors"]), 1)
+        assert_equal(xpub_info[0]["descriptors"][0]["desc"], pub_desc)
+        assert_equal(xpub_info[0]["descriptors"][0]["active"], False)
+
+    def test_ranged_multisig(self):
+        self.log.info("HD keys of a multisig appear in gethdkeys")
+        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
+        self.nodes[0].createwallet("ranged_multisig")
+        wallet = self.nodes[0].get_wallet_rpc("ranged_multisig")
+
+        xpub1 = wallet.gethdkeys()[0]["xpub"]
+        xprv1 = wallet.gethdkeys(private=True)[0]["xprv"]
+        xpub2 = def_wallet.gethdkeys()[0]["xpub"]
+
+        prv_multi_desc = descsum_create(f"wsh(multi(2,{xprv1}/*,{xpub2}/*))")
+        pub_multi_desc = descsum_create(f"wsh(multi(2,{xpub1}/*,{xpub2}/*))")
+        assert_equal(wallet.importdescriptors([{"desc": prv_multi_desc, "timestamp": "now"}])[0]["success"], True)
+
+        xpub_info = wallet.gethdkeys()
+        assert_equal(len(xpub_info), 2)
+        for x in xpub_info:
+            if x["xpub"] == xpub1:
+                found_desc = next((d for d in xpub_info[0]["descriptors"] if d["desc"] == pub_multi_desc), None)
+                assert found_desc is not None
+                assert_equal(found_desc["active"], False)
+            elif x["xpub"] == xpub2:
+                assert_equal(len(x["descriptors"]), 1)
+                assert_equal(x["descriptors"][0]["desc"], pub_multi_desc)
+                assert_equal(x["descriptors"][0]["active"], False)
+            else:
+                assert False
+
+    def test_mixed_multisig(self):
+        self.log.info("Non-HD keys of a multisig do not appear in gethdkeys")
+        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
+        self.nodes[0].createwallet("single_multisig")
+        wallet = self.nodes[0].get_wallet_rpc("single_multisig")
+
+        xpub = wallet.gethdkeys()[0]["xpub"]
+        xprv = wallet.gethdkeys(private=True)[0]["xprv"]
+        pub = def_wallet.getaddressinfo(def_wallet.getnewaddress())["pubkey"]
+
+        prv_multi_desc = descsum_create(f"wsh(multi(2,{xprv},{pub}))")
+        pub_multi_desc = descsum_create(f"wsh(multi(2,{xpub},{pub}))")
+        import_res = wallet.importdescriptors([{"desc": prv_multi_desc, "timestamp": "now"}])
+        assert_equal(import_res[0]["success"], True)
+
+        xpub_info = wallet.gethdkeys()
+        assert_equal(len(xpub_info), 1)
+        assert_equal(xpub_info[0]["xpub"], xpub)
+        found_desc = next((d for d in xpub_info[0]["descriptors"] if d["desc"] == pub_multi_desc), None)
+        assert found_desc is not None
+        assert_equal(found_desc["active"], False)
+
+
+if __name__ == '__main__':
+    WalletGetHDKeyTest().main()
diff --git a/test/functional/wallet_groups.py b/test/functional/wallet_groups.py
index 3b407c285d..26477131cf 100755
--- a/test/functional/wallet_groups.py
+++ b/test/functional/wallet_groups.py
@@ -42,11 +42,6 @@ class WalletGroupTest(BitcoinTestFramework):
 
     def run_test(self):
         self.log.info("Setting up")
-        # To take full use of immediate tx relay, all nodes need to be reachable
-        # via inbound peers, i.e. connect first to last to close the circle
-        # (the default test network topology looks like this:
-        #  node0 <-- node1 <-- node2 <-- node3 <-- node4 <-- node5)
-        self.connect_nodes(0, self.num_nodes - 1)
         # Mine some coins
         self.generate(self.nodes[0], COINBASE_MATURITY + 1)
 
diff --git a/test/functional/wallet_importdescriptors.py b/test/functional/wallet_importdescriptors.py
index 420bdffc49..f9d05a2fe4 100755
--- a/test/functional/wallet_importdescriptors.py
+++ b/test/functional/wallet_importdescriptors.py
@@ -688,7 +688,7 @@ class ImportDescriptorsTest(BitcoinTestFramework):
 
         encrypted_wallet.walletpassphrase("passphrase", 99999)
         with concurrent.futures.ThreadPoolExecutor(max_workers=1) as thread:
-            with self.nodes[0].assert_debug_log(expected_msgs=["Rescan started from block 0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206... (slow variant inspecting all blocks)"], timeout=5):
+            with self.nodes[0].assert_debug_log(expected_msgs=["Rescan started from block 0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206... (slow variant inspecting all blocks)"], timeout=10):
                 importing = thread.submit(encrypted_wallet.importdescriptors, requests=[descriptor])
 
             # Set the passphrase timeout to 1 to test that the wallet remains unlocked during the rescan
diff --git a/test/fuzz/test_runner.py b/test/fuzz/test_runner.py
index b3edb0e253..558d63e85c 100755
--- a/test/fuzz/test_runner.py
+++ b/test/fuzz/test_runner.py
@@ -104,9 +104,11 @@ def main():
         logging.error("Must have fuzz executable built")
         sys.exit(1)
 
+    fuzz_bin=os.getenv("BITCOINFUZZ", default=os.path.join(config["environment"]["BUILDDIR"], 'src', 'test', 'fuzz', 'fuzz'))
+
     # Build list of tests
     test_list_all = parse_test_list(
-        fuzz_bin=os.path.join(config["environment"]["BUILDDIR"], 'src', 'test', 'fuzz', 'fuzz'),
+        fuzz_bin=fuzz_bin,
         source_dir=config['environment']['SRCDIR'],
     )
 
@@ -151,7 +153,7 @@ def main():
     try:
         help_output = subprocess.run(
             args=[
-                os.path.join(config["environment"]["BUILDDIR"], 'src', 'test', 'fuzz', 'fuzz'),
+                fuzz_bin,
                 '-help=1',
             ],
             env=get_fuzz_env(target=test_list_selection[0], source_dir=config['environment']['SRCDIR']),
@@ -173,7 +175,7 @@ def main():
             return generate_corpus(
                 fuzz_pool=fuzz_pool,
                 src_dir=config['environment']['SRCDIR'],
-                build_dir=config["environment"]["BUILDDIR"],
+                fuzz_bin=fuzz_bin,
                 corpus_dir=args.corpus_dir,
                 targets=test_list_selection,
             )
@@ -184,7 +186,7 @@ def main():
                 corpus=args.corpus_dir,
                 test_list=test_list_selection,
                 src_dir=config['environment']['SRCDIR'],
-                build_dir=config["environment"]["BUILDDIR"],
+                fuzz_bin=fuzz_bin,
                 merge_dirs=[Path(m_dir) for m_dir in args.m_dir],
             )
             return
@@ -194,7 +196,7 @@ def main():
             corpus=args.corpus_dir,
             test_list=test_list_selection,
             src_dir=config['environment']['SRCDIR'],
-            build_dir=config["environment"]["BUILDDIR"],
+            fuzz_bin=fuzz_bin,
             using_libfuzzer=using_libfuzzer,
             use_valgrind=args.valgrind,
             empty_min_time=args.empty_min_time,
@@ -237,7 +239,7 @@ def transform_rpc_target(targets, src_dir):
     return targets
 
 
-def generate_corpus(*, fuzz_pool, src_dir, build_dir, corpus_dir, targets):
+def generate_corpus(*, fuzz_pool, src_dir, fuzz_bin, corpus_dir, targets):
     """Generates new corpus.
 
     Run {targets} without input, and outputs the generated corpus to
@@ -270,7 +272,7 @@ def generate_corpus(*, fuzz_pool, src_dir, build_dir, corpus_dir, targets):
         os.makedirs(target_corpus_dir, exist_ok=True)
         use_value_profile = int(random.random() < .3)
         command = [
-            os.path.join(build_dir, 'src', 'test', 'fuzz', 'fuzz'),
+            fuzz_bin,
             "-rss_limit_mb=8000",
             "-max_total_time=6000",
             "-reload=0",
@@ -283,12 +285,12 @@ def generate_corpus(*, fuzz_pool, src_dir, build_dir, corpus_dir, targets):
         future.result()
 
 
-def merge_inputs(*, fuzz_pool, corpus, test_list, src_dir, build_dir, merge_dirs):
+def merge_inputs(*, fuzz_pool, corpus, test_list, src_dir, fuzz_bin, merge_dirs):
     logging.info(f"Merge the inputs from the passed dir into the corpus_dir. Passed dirs {merge_dirs}")
     jobs = []
     for t in test_list:
         args = [
-            os.path.join(build_dir, 'src', 'test', 'fuzz', 'fuzz'),
+            fuzz_bin,
             '-rss_limit_mb=8000',
             '-set_cover_merge=1',
             # set_cover_merge is used instead of -merge=1 to reduce the overall
@@ -325,13 +327,13 @@ def merge_inputs(*, fuzz_pool, corpus, test_list, src_dir, build_dir, merge_dirs
         future.result()
 
 
-def run_once(*, fuzz_pool, corpus, test_list, src_dir, build_dir, using_libfuzzer, use_valgrind, empty_min_time):
+def run_once(*, fuzz_pool, corpus, test_list, src_dir, fuzz_bin, using_libfuzzer, use_valgrind, empty_min_time):
     jobs = []
     for t in test_list:
         corpus_path = corpus / t
         os.makedirs(corpus_path, exist_ok=True)
         args = [
-            os.path.join(build_dir, 'src', 'test', 'fuzz', 'fuzz'),
+            fuzz_bin,
         ]
         empty_dir = not any(corpus_path.iterdir())
         if using_libfuzzer: