diff --git a/.arclint b/.arclint
--- a/.arclint
+++ b/.arclint
@@ -23,7 +23,7 @@
             "exclude": [
                 "(^contrib/gitian-builder/)",
                 "(^contrib/apple-sdk-tools/)",
-                "(^test/functional/[a-fmt].*\\.py$)"
+                "(^test/functional/[a-mt].*\\.py$)"
             ],
             "flags": [
                 "--aggressive",
@@ -35,7 +35,7 @@
             "type": "black",
             "version": ">=23.0.0",
             "include": [
-                "(^test/functional/[a-fmt].*\\.py$)"
+                "(^test/functional/[a-mt].*\\.py$)"
             ],
             "flags": [
                 "--preview"
diff --git a/test/functional/interface_bitcoin_cli.py b/test/functional/interface_bitcoin_cli.py
--- a/test/functional/interface_bitcoin_cli.py
+++ b/test/functional/interface_bitcoin_cli.py
@@ -20,11 +20,14 @@
 BLOCKS = 101
 BALANCE = (BLOCKS - 100) * 50000000
 
-JSON_PARSING_ERROR = 'error: Error parsing JSON: foo'
-BLOCKS_VALUE_OF_ZERO = 'error: the first argument (number of blocks to generate, default: 1) must be an integer value greater than zero'
-TOO_MANY_ARGS = 'error: too many arguments (maximum 2 for nblocks and maxtries)'
-WALLET_NOT_LOADED = 'Requested wallet does not exist or is not loaded'
-WALLET_NOT_SPECIFIED = 'Wallet file not specified'
+JSON_PARSING_ERROR = "error: Error parsing JSON: foo"
+BLOCKS_VALUE_OF_ZERO = (
+    "error: the first argument (number of blocks to generate, default: 1) must be an"
+    " integer value greater than zero"
+)
+TOO_MANY_ARGS = "error: too many arguments (maximum 2 for nblocks and maxtries)"
+WALLET_NOT_LOADED = "Requested wallet does not exist or is not loaded"
+WALLET_NOT_SPECIFIED = "Wallet file not specified"
 
 
 class TestBitcoinCli(BitcoinTestFramework):
@@ -40,7 +43,9 @@
         self.generate(self.nodes[0], BLOCKS)
 
         self.log.info(
-            "Compare responses from getblockchaininfo RPC and `bitcoin-cli getblockchaininfo`")
+            "Compare responses from getblockchaininfo RPC and `bitcoin-cli"
+            " getblockchaininfo`"
+        )
         cli_response = self.nodes[0].cli.getblockchaininfo()
         rpc_response = self.nodes[0].getblockchaininfo()
         assert_equal(cli_response, rpc_response)
@@ -48,83 +53,108 @@
         user, password = get_auth_cookie(self.nodes[0].datadir, self.chain)
 
         self.log.info("Test -stdinrpcpass option")
-        assert_equal(BLOCKS, self.nodes[0].cli(
-            f'-rpcuser={user}', '-stdinrpcpass', cli_input=password).getblockcount())
-        assert_raises_process_error(1, "Incorrect rpcuser or rpcpassword", self.nodes[0].cli(
-            f'-rpcuser={user}', '-stdinrpcpass', cli_input="foo").echo)
+        assert_equal(
+            BLOCKS,
+            self.nodes[0]
+            .cli(f"-rpcuser={user}", "-stdinrpcpass", cli_input=password)
+            .getblockcount(),
+        )
+        assert_raises_process_error(
+            1,
+            "Incorrect rpcuser or rpcpassword",
+            self.nodes[0]
+            .cli(f"-rpcuser={user}", "-stdinrpcpass", cli_input="foo")
+            .echo,
+        )
 
         self.log.info("Test -stdin and -stdinrpcpass")
-        assert_equal(["foo", "bar"], self.nodes[0].cli(f'-rpcuser={user}',
-                                                       '-stdin', '-stdinrpcpass', cli_input=f"{password}\nfoo\nbar").echo())
-        assert_raises_process_error(1, "Incorrect rpcuser or rpcpassword", self.nodes[0].cli(
-            f'-rpcuser={user}', '-stdin', '-stdinrpcpass', cli_input="foo").echo)
+        assert_equal(
+            ["foo", "bar"],
+            self.nodes[0]
+            .cli(
+                f"-rpcuser={user}",
+                "-stdin",
+                "-stdinrpcpass",
+                cli_input=f"{password}\nfoo\nbar",
+            )
+            .echo(),
+        )
+        assert_raises_process_error(
+            1,
+            "Incorrect rpcuser or rpcpassword",
+            self.nodes[0]
+            .cli(f"-rpcuser={user}", "-stdin", "-stdinrpcpass", cli_input="foo")
+            .echo,
+        )
 
         self.log.info("Test connecting to a non-existing server")
         assert_raises_process_error(
-            1, "Could not connect to the server", self.nodes[0].cli('-rpcport=1').echo)
+            1, "Could not connect to the server", self.nodes[0].cli("-rpcport=1").echo
+        )
 
         self.log.info("Test connecting with non-existing RPC cookie file")
-        assert_raises_process_error(1, "Could not locate RPC credentials", self.nodes[0].cli(
-            '-rpccookiefile=does-not-exist', '-rpcpassword=').echo)
+        assert_raises_process_error(
+            1,
+            "Could not locate RPC credentials",
+            self.nodes[0].cli("-rpccookiefile=does-not-exist", "-rpcpassword=").echo,
+        )
 
         self.log.info("Test -getinfo with arguments fails")
         assert_raises_process_error(
-            1, "-getinfo takes no arguments", self.nodes[0].cli('-getinfo').help)
+            1, "-getinfo takes no arguments", self.nodes[0].cli("-getinfo").help
+        )
 
-        self.log.info(
-            "Test -getinfo returns expected network and blockchain info")
+        self.log.info("Test -getinfo returns expected network and blockchain info")
         if self.is_wallet_compiled():
             self.nodes[0].encryptwallet(password)
-        cli_get_info = self.nodes[0].cli().send_cli('-getinfo')
+        cli_get_info = self.nodes[0].cli().send_cli("-getinfo")
         network_info = self.nodes[0].getnetworkinfo()
         blockchain_info = self.nodes[0].getblockchaininfo()
-        assert_equal(cli_get_info['version'], network_info['version'])
-        assert_equal(cli_get_info['blocks'], blockchain_info['blocks'])
-        assert_equal(cli_get_info['headers'], blockchain_info['headers'])
-        assert_equal(cli_get_info['timeoffset'], network_info['timeoffset'])
+        assert_equal(cli_get_info["version"], network_info["version"])
+        assert_equal(cli_get_info["blocks"], blockchain_info["blocks"])
+        assert_equal(cli_get_info["headers"], blockchain_info["headers"])
+        assert_equal(cli_get_info["timeoffset"], network_info["timeoffset"])
         assert_equal(
-            cli_get_info['connections'],
+            cli_get_info["connections"],
             {
-                'in': network_info['connections_in'],
-                'out': network_info['connections_out'],
-                'total': network_info['connections']
-            }
+                "in": network_info["connections_in"],
+                "out": network_info["connections_out"],
+                "total": network_info["connections"],
+            },
         )
-        assert_equal(cli_get_info['proxy'],
-                     network_info['networks'][0]['proxy'])
-        assert_equal(cli_get_info['difficulty'], blockchain_info['difficulty'])
-        assert_equal(cli_get_info['chain'], blockchain_info['chain'])
+        assert_equal(cli_get_info["proxy"], network_info["networks"][0]["proxy"])
+        assert_equal(cli_get_info["difficulty"], blockchain_info["difficulty"])
+        assert_equal(cli_get_info["chain"], blockchain_info["chain"])
 
         if self.is_wallet_compiled():
             self.log.info(
-                "Test -getinfo and bitcoin-cli getwalletinfo return expected wallet info")
-            assert_equal(cli_get_info['balance'], BALANCE)
-            assert 'balances' not in cli_get_info.keys()
+                "Test -getinfo and bitcoin-cli getwalletinfo return expected wallet"
+                " info"
+            )
+            assert_equal(cli_get_info["balance"], BALANCE)
+            assert "balances" not in cli_get_info.keys()
             wallet_info = self.nodes[0].getwalletinfo()
-            assert_equal(
-                cli_get_info['keypoolsize'],
-                wallet_info['keypoolsize'])
-            assert_equal(
-                cli_get_info['unlocked_until'],
-                wallet_info['unlocked_until'])
-            assert_equal(cli_get_info['paytxfee'], wallet_info['paytxfee'])
-            assert_equal(cli_get_info['relayfee'], network_info['relayfee'])
+            assert_equal(cli_get_info["keypoolsize"], wallet_info["keypoolsize"])
+            assert_equal(cli_get_info["unlocked_until"], wallet_info["unlocked_until"])
+            assert_equal(cli_get_info["paytxfee"], wallet_info["paytxfee"])
+            assert_equal(cli_get_info["relayfee"], network_info["relayfee"])
             assert_equal(self.nodes[0].cli.getwalletinfo(), wallet_info)
 
             # Setup to test -getinfo, -generate, and -rpcwallet= with multiple
             # wallets.
-            wallets = [self.default_wallet_name, 'Encrypted', 'secret']
+            wallets = [self.default_wallet_name, "Encrypted", "secret"]
             amounts = [
-                BALANCE + Decimal('9999995.50'),
+                BALANCE + Decimal("9999995.50"),
                 Decimal(9000000),
-                Decimal(31000000)]
+                Decimal(31000000),
+            ]
             self.nodes[0].createwallet(wallet_name=wallets[1])
             self.nodes[0].createwallet(wallet_name=wallets[2])
             w1 = self.nodes[0].get_wallet_rpc(wallets[0])
             w2 = self.nodes[0].get_wallet_rpc(wallets[1])
             w3 = self.nodes[0].get_wallet_rpc(wallets[2])
-            rpcwallet2 = f'-rpcwallet={wallets[1]}'
-            rpcwallet3 = f'-rpcwallet={wallets[2]}'
+            rpcwallet2 = f"-rpcwallet={wallets[1]}"
+            rpcwallet3 = f"-rpcwallet={wallets[2]}"
             w1.walletpassphrase(password, self.rpc_timeout)
             w2.encryptwallet(password)
             w1.sendtoaddress(w2.getnewaddress(), amounts[1])
@@ -135,61 +165,72 @@
             self.generate(self.nodes[0], 1)
 
             self.log.info(
-                "Test -getinfo with multiple wallets and -rpcwallet returns specified wallet balance")
+                "Test -getinfo with multiple wallets and -rpcwallet returns specified"
+                " wallet balance"
+            )
             for i in range(len(wallets)):
-                cli_get_info = self.nodes[0].cli(
-                    '-getinfo', f'-rpcwallet={wallets[i]}').send_cli()
-                assert 'balances' not in cli_get_info.keys()
-                assert_equal(cli_get_info['balance'], amounts[i])
+                cli_get_info = (
+                    self.nodes[0].cli("-getinfo", f"-rpcwallet={wallets[i]}").send_cli()
+                )
+                assert "balances" not in cli_get_info.keys()
+                assert_equal(cli_get_info["balance"], amounts[i])
 
             self.log.info(
                 "Test -getinfo with multiple wallets and "
-                "-rpcwallet=non-existing-wallet returns no balances")
-            cli_get_info_keys = self.nodes[0].cli(
-                '-getinfo', '-rpcwallet=does-not-exist').send_cli().keys()
-            assert 'balance' not in cli_get_info_keys
-            assert 'balances' not in cli_get_info_keys
+                "-rpcwallet=non-existing-wallet returns no balances"
+            )
+            cli_get_info_keys = (
+                self.nodes[0]
+                .cli("-getinfo", "-rpcwallet=does-not-exist")
+                .send_cli()
+                .keys()
+            )
+            assert "balance" not in cli_get_info_keys
+            assert "balances" not in cli_get_info_keys
 
             self.log.info(
                 "Test -getinfo with multiple wallets returns all loaded "
-                "wallet names and balances")
+                "wallet names and balances"
+            )
             assert_equal(set(self.nodes[0].listwallets()), set(wallets))
-            cli_get_info = self.nodes[0].cli('-getinfo').send_cli()
-            assert 'balance' not in cli_get_info.keys()
-            assert_equal(cli_get_info['balances'], dict(zip(wallets, amounts)))
+            cli_get_info = self.nodes[0].cli("-getinfo").send_cli()
+            assert "balance" not in cli_get_info.keys()
+            assert_equal(cli_get_info["balances"], dict(zip(wallets, amounts)))
 
             # Unload the default wallet and re-verify.
             self.nodes[0].unloadwallet(wallets[0])
             assert wallets[0] not in self.nodes[0].listwallets()
-            cli_get_info = self.nodes[0].cli('-getinfo').send_cli()
-            assert 'balance' not in cli_get_info.keys()
-            assert_equal(cli_get_info['balances'],
-                         dict(zip(wallets[1:], amounts[1:])))
+            cli_get_info = self.nodes[0].cli("-getinfo").send_cli()
+            assert "balance" not in cli_get_info.keys()
+            assert_equal(cli_get_info["balances"], dict(zip(wallets[1:], amounts[1:])))
 
             self.log.info(
                 "Test -getinfo after unloading all wallets except a "
-                "non-default one returns its balance")
+                "non-default one returns its balance"
+            )
             self.nodes[0].unloadwallet(wallets[2])
             assert_equal(self.nodes[0].listwallets(), [wallets[1]])
 
-            cli_get_info = self.nodes[0].cli('-getinfo').send_cli()
-            assert 'balances' not in cli_get_info.keys()
-            assert_equal(cli_get_info['balance'], amounts[1])
+            cli_get_info = self.nodes[0].cli("-getinfo").send_cli()
+            assert "balances" not in cli_get_info.keys()
+            assert_equal(cli_get_info["balance"], amounts[1])
 
             self.log.info(
                 "Test -getinfo with -rpcwallet=remaining-non-default-wallet"
-                " returns only its balance")
-            cli_get_info = self.nodes[0].cli('-getinfo', rpcwallet2).send_cli()
-            assert 'balances' not in cli_get_info.keys()
-            assert_equal(cli_get_info['balance'], amounts[1])
+                " returns only its balance"
+            )
+            cli_get_info = self.nodes[0].cli("-getinfo", rpcwallet2).send_cli()
+            assert "balances" not in cli_get_info.keys()
+            assert_equal(cli_get_info["balance"], amounts[1])
 
             self.log.info(
-                "Test -getinfo with -rpcwallet=unloaded wallet returns"
-                " no balances")
-            cli_get_info_keys = self.nodes[0].cli(
-                '-getinfo', rpcwallet3).send_cli().keys()
-            assert 'balance' not in cli_get_info_keys
-            assert 'balances' not in cli_get_info_keys
+                "Test -getinfo with -rpcwallet=unloaded wallet returns no balances"
+            )
+            cli_get_info_keys = (
+                self.nodes[0].cli("-getinfo", rpcwallet3).send_cli().keys()
+            )
+            assert "balance" not in cli_get_info_keys
+            assert "balances" not in cli_get_info_keys
 
             # Test bitcoin-cli -generate.
             n1 = 3
@@ -197,64 +238,60 @@
             w2.walletpassphrase(password, self.rpc_timeout)
             blocks = self.nodes[0].getblockcount()
 
-            self.log.info('Test -generate with no args')
-            generate = self.nodes[0].cli('-generate').send_cli()
-            assert_equal(set(generate.keys()), {'address', 'blocks'})
+            self.log.info("Test -generate with no args")
+            generate = self.nodes[0].cli("-generate").send_cli()
+            assert_equal(set(generate.keys()), {"address", "blocks"})
             assert_equal(len(generate["blocks"]), 1)
             assert_equal(self.nodes[0].getblockcount(), blocks + 1)
 
-            self.log.info('Test -generate with bad args')
+            self.log.info("Test -generate with bad args")
             assert_raises_process_error(
-                1, JSON_PARSING_ERROR, self.nodes[0].cli(
-                    '-generate', 'foo').echo)
+                1, JSON_PARSING_ERROR, self.nodes[0].cli("-generate", "foo").echo
+            )
             assert_raises_process_error(
-                1, BLOCKS_VALUE_OF_ZERO, self.nodes[0].cli(
-                    '-generate', 0).echo)
+                1, BLOCKS_VALUE_OF_ZERO, self.nodes[0].cli("-generate", 0).echo
+            )
             assert_raises_process_error(
-                1, TOO_MANY_ARGS, self.nodes[0].cli(
-                    '-generate', 1, 2, 3).echo)
+                1, TOO_MANY_ARGS, self.nodes[0].cli("-generate", 1, 2, 3).echo
+            )
 
-            self.log.info('Test -generate with nblocks')
-            generate = self.nodes[0].cli('-generate', n1).send_cli()
-            assert_equal(set(generate.keys()), {'address', 'blocks'})
+            self.log.info("Test -generate with nblocks")
+            generate = self.nodes[0].cli("-generate", n1).send_cli()
+            assert_equal(set(generate.keys()), {"address", "blocks"})
             assert_equal(len(generate["blocks"]), n1)
             assert_equal(self.nodes[0].getblockcount(), blocks + 1 + n1)
 
-            self.log.info('Test -generate with nblocks and maxtries')
-            generate = self.nodes[0].cli('-generate', n2, 1000000).send_cli()
-            assert_equal(set(generate.keys()), {'address', 'blocks'})
+            self.log.info("Test -generate with nblocks and maxtries")
+            generate = self.nodes[0].cli("-generate", n2, 1000000).send_cli()
+            assert_equal(set(generate.keys()), {"address", "blocks"})
             assert_equal(len(generate["blocks"]), n2)
             assert_equal(self.nodes[0].getblockcount(), blocks + 1 + n1 + n2)
 
-            self.log.info('Test -generate -rpcwallet in single-wallet mode')
-            generate = self.nodes[0].cli(rpcwallet2, '-generate').send_cli()
-            assert_equal(set(generate.keys()), {'address', 'blocks'})
+            self.log.info("Test -generate -rpcwallet in single-wallet mode")
+            generate = self.nodes[0].cli(rpcwallet2, "-generate").send_cli()
+            assert_equal(set(generate.keys()), {"address", "blocks"})
             assert_equal(len(generate["blocks"]), 1)
             assert_equal(self.nodes[0].getblockcount(), blocks + 2 + n1 + n2)
 
-            self.log.info(
-                'Test -generate -rpcwallet=unloaded wallet raises RPC error')
-            assert_raises_rpc_error(-18,
-                                    WALLET_NOT_LOADED,
-                                    self.nodes[0].cli(rpcwallet3,
-                                                      '-generate').echo)
-            assert_raises_rpc_error(-18,
-                                    WALLET_NOT_LOADED,
-                                    self.nodes[0].cli(rpcwallet3,
-                                                      '-generate',
-                                                      'foo').echo)
-            assert_raises_rpc_error(-18,
-                                    WALLET_NOT_LOADED,
-                                    self.nodes[0].cli(rpcwallet3,
-                                                      '-generate',
-                                                      0).echo)
-            assert_raises_rpc_error(-18,
-                                    WALLET_NOT_LOADED,
-                                    self.nodes[0].cli(rpcwallet3,
-                                                      '-generate',
-                                                      1,
-                                                      2,
-                                                      3).echo)
+            self.log.info("Test -generate -rpcwallet=unloaded wallet raises RPC error")
+            assert_raises_rpc_error(
+                -18, WALLET_NOT_LOADED, self.nodes[0].cli(rpcwallet3, "-generate").echo
+            )
+            assert_raises_rpc_error(
+                -18,
+                WALLET_NOT_LOADED,
+                self.nodes[0].cli(rpcwallet3, "-generate", "foo").echo,
+            )
+            assert_raises_rpc_error(
+                -18,
+                WALLET_NOT_LOADED,
+                self.nodes[0].cli(rpcwallet3, "-generate", 0).echo,
+            )
+            assert_raises_rpc_error(
+                -18,
+                WALLET_NOT_LOADED,
+                self.nodes[0].cli(rpcwallet3, "-generate", 1, 2, 3).echo,
+            )
 
             # Test bitcoin-cli -generate with -rpcwallet in multiwallet mode.
             self.nodes[0].loadwallet(wallets[2])
@@ -262,75 +299,83 @@
             n4 = 10
             blocks = self.nodes[0].getblockcount()
 
-            self.log.info('Test -generate -rpcwallet with no args')
-            generate = self.nodes[0].cli(rpcwallet2, '-generate').send_cli()
-            assert_equal(set(generate.keys()), {'address', 'blocks'})
+            self.log.info("Test -generate -rpcwallet with no args")
+            generate = self.nodes[0].cli(rpcwallet2, "-generate").send_cli()
+            assert_equal(set(generate.keys()), {"address", "blocks"})
             assert_equal(len(generate["blocks"]), 1)
             assert_equal(self.nodes[0].getblockcount(), blocks + 1)
 
-            self.log.info('Test -generate -rpcwallet with bad args')
+            self.log.info("Test -generate -rpcwallet with bad args")
             assert_raises_process_error(
-                1, JSON_PARSING_ERROR, self.nodes[0].cli(
-                    rpcwallet2, '-generate', 'foo').echo)
+                1,
+                JSON_PARSING_ERROR,
+                self.nodes[0].cli(rpcwallet2, "-generate", "foo").echo,
+            )
             assert_raises_process_error(
-                1, BLOCKS_VALUE_OF_ZERO, self.nodes[0].cli(
-                    rpcwallet2, '-generate', 0).echo)
+                1,
+                BLOCKS_VALUE_OF_ZERO,
+                self.nodes[0].cli(rpcwallet2, "-generate", 0).echo,
+            )
             assert_raises_process_error(
-                1, TOO_MANY_ARGS, self.nodes[0].cli(
-                    rpcwallet2, '-generate', 1, 2, 3).echo)
-
-            self.log.info('Test -generate -rpcwallet with nblocks')
-            generate = self.nodes[0].cli(
-                rpcwallet2, '-generate', n3).send_cli()
-            assert_equal(set(generate.keys()), {'address', 'blocks'})
+                1,
+                TOO_MANY_ARGS,
+                self.nodes[0].cli(rpcwallet2, "-generate", 1, 2, 3).echo,
+            )
+
+            self.log.info("Test -generate -rpcwallet with nblocks")
+            generate = self.nodes[0].cli(rpcwallet2, "-generate", n3).send_cli()
+            assert_equal(set(generate.keys()), {"address", "blocks"})
             assert_equal(len(generate["blocks"]), n3)
             assert_equal(self.nodes[0].getblockcount(), blocks + 1 + n3)
 
-            self.log.info(
-                'Test -generate -rpcwallet with nblocks and maxtries')
-            generate = self.nodes[0].cli(
-                rpcwallet2, '-generate', n4, 1000000).send_cli()
-            assert_equal(set(generate.keys()), {'address', 'blocks'})
+            self.log.info("Test -generate -rpcwallet with nblocks and maxtries")
+            generate = (
+                self.nodes[0].cli(rpcwallet2, "-generate", n4, 1000000).send_cli()
+            )
+            assert_equal(set(generate.keys()), {"address", "blocks"})
             assert_equal(len(generate["blocks"]), n4)
             assert_equal(self.nodes[0].getblockcount(), blocks + 1 + n3 + n4)
 
             self.log.info(
-                'Test -generate without -rpcwallet in multiwallet mode raises RPC error')
-            assert_raises_rpc_error(-19,
-                                    WALLET_NOT_SPECIFIED,
-                                    self.nodes[0].cli('-generate').echo)
-            assert_raises_rpc_error(-19,
-                                    WALLET_NOT_SPECIFIED,
-                                    self.nodes[0].cli('-generate',
-                                                      'foo').echo)
-            assert_raises_rpc_error(-19, WALLET_NOT_SPECIFIED,
-                                    self.nodes[0].cli('-generate', 0).echo)
-            assert_raises_rpc_error(-19, WALLET_NOT_SPECIFIED,
-                                    self.nodes[0].cli('-generate', 1, 2, 3).echo)
+                "Test -generate without -rpcwallet in multiwallet mode raises RPC error"
+            )
+            assert_raises_rpc_error(
+                -19, WALLET_NOT_SPECIFIED, self.nodes[0].cli("-generate").echo
+            )
+            assert_raises_rpc_error(
+                -19, WALLET_NOT_SPECIFIED, self.nodes[0].cli("-generate", "foo").echo
+            )
+            assert_raises_rpc_error(
+                -19, WALLET_NOT_SPECIFIED, self.nodes[0].cli("-generate", 0).echo
+            )
+            assert_raises_rpc_error(
+                -19, WALLET_NOT_SPECIFIED, self.nodes[0].cli("-generate", 1, 2, 3).echo
+            )
         else:
             self.log.info(
-                "*** Wallet not compiled; cli getwalletinfo and -getinfo wallet tests skipped")
+                "*** Wallet not compiled; cli getwalletinfo and -getinfo wallet tests"
+                " skipped"
+            )
             # maintain block parity with the wallet_compiled conditional branch
             self.generate(self.nodes[0], 25)
 
         self.log.info("Test -version with node stopped")
         self.stop_node(0)
-        cli_response = self.nodes[0].cli().send_cli('-version')
+        cli_response = self.nodes[0].cli().send_cli("-version")
         assert (
             f"{self.config['environment']['PACKAGE_NAME']} RPC client version"
             in cli_response
         )
 
-        self.log.info(
-            "Test -rpcwait option successfully waits for RPC connection")
+        self.log.info("Test -rpcwait option successfully waits for RPC connection")
         # Start node without RPC connection.
         self.nodes[0].start()
         # ensure cookie file is available to avoid race condition
         self.nodes[0].wait_for_cookie_credentials()
-        blocks = self.nodes[0].cli('-rpcwait').send_cli('getblockcount')
+        blocks = self.nodes[0].cli("-rpcwait").send_cli("getblockcount")
         self.nodes[0].wait_for_rpc_connection()
         assert_equal(blocks, BLOCKS + 25)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     TestBitcoinCli().main()
diff --git a/test/functional/interface_http.py b/test/functional/interface_http.py
--- a/test/functional/interface_http.py
+++ b/test/functional/interface_http.py
@@ -11,7 +11,7 @@
 from test_framework.util import assert_equal, str_to_b64str
 
 
-class HTTPBasicsTest (BitcoinTestFramework):
+class HTTPBasicsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 3
         self.supports_cli = False
@@ -21,7 +21,6 @@
         self.setup_nodes()
 
     def run_test(self):
-
         #
         # lowlevel check for http persistent connection #
         #
@@ -31,14 +30,14 @@
 
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
-        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        conn.request("POST", "/", '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert b'"error":null' in out1
         assert conn.sock is not None
         # according to http/1.1 connection must still be open!
 
         # send 2nd request without closing connection
-        conn.request('POST', '/', '{"method": "getchaintips"}', headers)
+        conn.request("POST", "/", '{"method": "getchaintips"}', headers)
         out1 = conn.getresponse().read()
         assert b'"error":null' in out1
         # must also response with a correct json-rpc message
@@ -48,19 +47,21 @@
 
         # same should be if we add keep-alive because this should be the std.
         # behaviour
-        headers = {"Authorization": "Basic " +
-                   str_to_b64str(authpair), "Connection": "keep-alive"}
+        headers = {
+            "Authorization": "Basic " + str_to_b64str(authpair),
+            "Connection": "keep-alive",
+        }
 
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
-        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        conn.request("POST", "/", '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert b'"error":null' in out1
         assert conn.sock is not None
         # according to http/1.1 connection must still be open!
 
         # send 2nd request without closing connection
-        conn.request('POST', '/', '{"method": "getchaintips"}', headers)
+        conn.request("POST", "/", '{"method": "getchaintips"}', headers)
         out1 = conn.getresponse().read()
         assert b'"error":null' in out1
         # must also response with a correct json-rpc message
@@ -69,12 +70,14 @@
         conn.close()
 
         # now do the same with "Connection: close"
-        headers = {"Authorization": "Basic " +
-                   str_to_b64str(authpair), "Connection": "close"}
+        headers = {
+            "Authorization": "Basic " + str_to_b64str(authpair),
+            "Connection": "close",
+        }
 
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
-        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        conn.request("POST", "/", '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert b'"error":null' in out1
         assert conn.sock is None
@@ -87,7 +90,7 @@
 
         conn = http.client.HTTPConnection(urlNode1.hostname, urlNode1.port)
         conn.connect()
-        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        conn.request("POST", "/", '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert b'"error":null' in out1
 
@@ -99,7 +102,7 @@
 
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
-        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        conn.request("POST", "/", '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert b'"error":null' in out1
         assert conn.sock is not None
@@ -109,13 +112,13 @@
         # Check excessive request size
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
-        conn.request('GET', f"/{'x' * 1000}", '', headers)
+        conn.request("GET", f"/{'x' * 1000}", "", headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.NOT_FOUND)
 
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
-        conn.request('GET', f"/{'x' * 10000}", '', headers)
+        conn.request("GET", f"/{'x' * 10000}", "", headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.BAD_REQUEST)
 
@@ -125,49 +128,51 @@
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
         authpair = f"{url.username}:{url.password}"
-        headers = {"Authorization": f"Basic {str_to_b64str(authpair)}",
-                   "Origin": origin}
-        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        headers = {
+            "Authorization": f"Basic {str_to_b64str(authpair)}",
+            "Origin": origin,
+        }
+        conn.request("POST", "/", '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.OK)
         assert_equal(out1.headers["Access-Control-Allow-Origin"], origin)
         assert_equal(out1.headers["Access-Control-Allow-Credentials"], "true")
-        assert_equal(out1.headers["Access-Control-Expose-Headers"],
-                     "WWW-Authenticate")
+        assert_equal(out1.headers["Access-Control-Expose-Headers"], "WWW-Authenticate")
         assert b'"error":null' in out1.read()
 
         # Check Pre-flight CORS request
-        corsheaders = {"Origin": origin,
-                       "Access-Control-Request-Method": "POST"}
-        conn.request('OPTIONS', '/', None, corsheaders)
+        corsheaders = {"Origin": origin, "Access-Control-Request-Method": "POST"}
+        conn.request("OPTIONS", "/", None, corsheaders)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.OK)
         assert_equal(out1.headers["Access-Control-Allow-Origin"], origin)
         assert_equal(out1.headers["Access-Control-Allow-Credentials"], "true")
         assert_equal(out1.headers["Access-Control-Allow-Methods"], "POST")
-        assert_equal(out1.headers["Access-Control-Allow-Headers"],
-                     "authorization,content-type")
-        assert_equal(b'', out1.read())
+        assert_equal(
+            out1.headers["Access-Control-Allow-Headers"], "authorization,content-type"
+        )
+        assert_equal(b"", out1.read())
 
         # Check Standard CORS request to node without CORS, expected failure
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
         authpair = f"{url.username}:{url.password}"
-        headers = {"Authorization": f"Basic {str_to_b64str(authpair)}",
-                   "Origin": origin}
-        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        headers = {
+            "Authorization": f"Basic {str_to_b64str(authpair)}",
+            "Origin": origin,
+        }
+        conn.request("POST", "/", '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.UNAUTHORIZED)
-        assert_equal(b'', out1.read())
+        assert_equal(b"", out1.read())
 
         # Check Pre-flight CORS request to node without CORS, expected failure
-        corsheaders = {"Origin": origin,
-                       "Access-Control-Request-Method": "POST"}
-        conn.request('OPTIONS', '/', None, corsheaders)
+        corsheaders = {"Origin": origin, "Access-Control-Request-Method": "POST"}
+        conn.request("OPTIONS", "/", None, corsheaders)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.METHOD_NOT_ALLOWED)
-        assert_equal(b'JSONRPC server handles only POST requests', out1.read())
+        assert_equal(b"JSONRPC server handles only POST requests", out1.read())
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     HTTPBasicsTest().main()
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -35,11 +35,11 @@
 
 def filter_output_indices_by_value(vouts, value):
     for vout in vouts:
-        if vout['value'] == value:
-            yield vout['n']
+        if vout["value"] == value:
+            yield vout["n"]
 
 
-class RESTTest (BitcoinTestFramework):
+class RESTTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
@@ -49,22 +49,29 @@
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
-    def test_rest_request(self, uri, http_method='GET', req_type=ReqType.JSON,
-                          body='', status=200, ret_type=RetType.JSON):
+    def test_rest_request(
+        self,
+        uri,
+        http_method="GET",
+        req_type=ReqType.JSON,
+        body="",
+        status=200,
+        ret_type=RetType.JSON,
+    ):
         rest_uri = f"/rest{uri}"
         if req_type == ReqType.JSON:
-            rest_uri += '.json'
+            rest_uri += ".json"
         elif req_type == ReqType.BIN:
-            rest_uri += '.bin'
+            rest_uri += ".bin"
         elif req_type == ReqType.HEX:
-            rest_uri += '.hex'
+            rest_uri += ".hex"
 
         conn = http.client.HTTPConnection(self.url.hostname, self.url.port)
-        self.log.debug(f'{http_method} {rest_uri} {body}')
-        if http_method == 'GET':
-            conn.request('GET', rest_uri)
-        elif http_method == 'POST':
-            conn.request('POST', rest_uri, body)
+        self.log.debug(f"{http_method} {rest_uri} {body}")
+        if http_method == "GET":
+            conn.request("GET", rest_uri)
+        elif http_method == "POST":
+            conn.request("POST", rest_uri, body)
         resp = conn.getresponse()
 
         assert_equal(resp.status, status)
@@ -74,7 +81,7 @@
         elif ret_type == RetType.BYTES:
             return resp.read()
         elif ret_type == RetType.JSON:
-            return json.loads(resp.read().decode('utf-8'), parse_float=Decimal)
+            return json.loads(resp.read().decode("utf-8"), parse_float=Decimal)
 
     def run_test(self):
         self.url = urllib.parse.urlparse(self.nodes[0].url)
@@ -88,25 +95,26 @@
 
         assert_equal(self.nodes[0].getbalance(), 50000000)
 
-        txid = self.nodes[0].sendtoaddress(
-            self.nodes[1].getnewaddress(), 100000)
+        txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 100000)
         self.sync_all()
 
         self.log.info("Test the /tx URI")
 
         json_obj = self.test_rest_request(f"/tx/{txid}")
-        assert_equal(json_obj['txid'], txid)
+        assert_equal(json_obj["txid"], txid)
 
         # Check hex format response
         hex_response = self.test_rest_request(
-            f"/tx/{txid}", req_type=ReqType.HEX, ret_type=RetType.OBJ)
-        assert_greater_than_or_equal(int(hex_response.getheader('content-length')),
-                                     json_obj['size'] * 2)
+            f"/tx/{txid}", req_type=ReqType.HEX, ret_type=RetType.OBJ
+        )
+        assert_greater_than_or_equal(
+            int(hex_response.getheader("content-length")), json_obj["size"] * 2
+        )
 
         # Get the vin to later check for utxo (should be spent by then)
-        spent = (json_obj['vin'][0]['txid'], json_obj['vin'][0]['vout'])
+        spent = (json_obj["vin"][0]["txid"], json_obj["vin"][0]["vout"])
         # Get n of 100_000 XEC outpoint
-        n, = filter_output_indices_by_value(json_obj['vout'], Decimal('100000'))
+        (n,) = filter_output_indices_by_value(json_obj["vout"], Decimal("100000"))
         spending = (txid, n)
 
         self.log.info("Query an unspent TXO using the /getutxos URI")
@@ -118,46 +126,49 @@
 
         # Check chainTip response
         json_obj = self.test_rest_request(f"/getutxos/{txid}-{n}")
-        assert_equal(json_obj['chaintipHash'], bb_hash)
+        assert_equal(json_obj["chaintipHash"], bb_hash)
 
         # Make sure there is one utxo
-        assert_equal(len(json_obj['utxos']), 1)
-        assert_equal(json_obj['utxos'][0]['value'], Decimal('100000'))
+        assert_equal(len(json_obj["utxos"]), 1)
+        assert_equal(json_obj["utxos"][0]["value"], Decimal("100000"))
 
         self.log.info("Query a spent TXO using the /getutxos URI")
 
         json_obj = self.test_rest_request(f"/getutxos/{spent[0]}-{spent[1]}")
 
         # Check chainTip response
-        assert_equal(json_obj['chaintipHash'], bb_hash)
+        assert_equal(json_obj["chaintipHash"], bb_hash)
 
         # Make sure there is no utxo in the response because this outpoint has
         # been spent
-        assert_equal(len(json_obj['utxos']), 0)
+        assert_equal(len(json_obj["utxos"]), 0)
 
         # Check bitmap
-        assert_equal(json_obj['bitmap'], "0")
+        assert_equal(json_obj["bitmap"], "0")
 
         self.log.info("Query two TXOs using the /getutxos URI")
 
-        json_obj = self.test_rest_request(
-            f"/getutxos/{txid}-{n}/{spent[0]}-{spent[1]}")
+        json_obj = self.test_rest_request(f"/getutxos/{txid}-{n}/{spent[0]}-{spent[1]}")
 
-        assert_equal(len(json_obj['utxos']), 1)
-        assert_equal(json_obj['bitmap'], "10")
+        assert_equal(len(json_obj["utxos"]), 1)
+        assert_equal(json_obj["bitmap"], "10")
 
-        self.log.info(
-            "Query the TXOs using the /getutxos URI with a binary response")
+        self.log.info("Query the TXOs using the /getutxos URI with a binary response")
 
-        bin_request = b'\x01\x02'
+        bin_request = b"\x01\x02"
         for txid, n in [spending, spent]:
             bin_request += bytes.fromhex(txid)
             bin_request += pack("i", n)
 
         bin_response = self.test_rest_request(
-            "/getutxos", http_method='POST', req_type=ReqType.BIN, body=bin_request, ret_type=RetType.BYTES)
+            "/getutxos",
+            http_method="POST",
+            req_type=ReqType.BIN,
+            body=bin_request,
+            ret_type=RetType.BYTES,
+        )
         output = BytesIO(bin_response)
-        chain_height, = unpack("<i", output.read(4))
+        (chain_height,) = unpack("<i", output.read(4))
         response_hash = output.read(32)[::-1].hex()
 
         # Check if getutxo's chaintip during calculation was fine
@@ -171,52 +182,74 @@
         # found with or without /checkmempool.
 
         # Do a tx and don't sync
-        txid = self.nodes[0].sendtoaddress(
-            self.nodes[1].getnewaddress(), 100000)
+        txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 100000)
         json_obj = self.test_rest_request(f"/tx/{txid}")
         # Get the spent output to later check for utxo (should be spent by
         # then)
-        spent = (json_obj['vin'][0]['txid'], json_obj['vin'][0]['vout'])
+        spent = (json_obj["vin"][0]["txid"], json_obj["vin"][0]["vout"])
         # Get n of 100_000 XEC outpoint
-        n, = filter_output_indices_by_value(json_obj['vout'], Decimal('100000'))
+        (n,) = filter_output_indices_by_value(json_obj["vout"], Decimal("100000"))
 
         json_obj = self.test_rest_request(f"/getutxos/{txid}-{n}")
-        assert_equal(len(json_obj['utxos']), 0)
+        assert_equal(len(json_obj["utxos"]), 0)
 
         json_obj = self.test_rest_request(f"/getutxos/checkmempool/{txid}-{n}")
-        assert_equal(len(json_obj['utxos']), 1)
+        assert_equal(len(json_obj["utxos"]), 1)
 
         json_obj = self.test_rest_request(f"/getutxos/{spent[0]}-{spent[1]}")
-        assert_equal(len(json_obj['utxos']), 1)
+        assert_equal(len(json_obj["utxos"]), 1)
 
         json_obj = self.test_rest_request(
-            f"/getutxos/checkmempool/{spent[0]}-{spent[1]}")
-        assert_equal(len(json_obj['utxos']), 0)
+            f"/getutxos/checkmempool/{spent[0]}-{spent[1]}"
+        )
+        assert_equal(len(json_obj["utxos"]), 0)
 
         self.generate(self.nodes[0], 1)
 
         json_obj = self.test_rest_request(f"/getutxos/{txid}-{n}")
-        assert_equal(len(json_obj['utxos']), 1)
+        assert_equal(len(json_obj["utxos"]), 1)
 
         json_obj = self.test_rest_request(f"/getutxos/checkmempool/{txid}-{n}")
-        assert_equal(len(json_obj['utxos']), 1)
+        assert_equal(len(json_obj["utxos"]), 1)
 
         # Do some invalid requests
-        self.test_rest_request("/getutxos", http_method='POST', req_type=ReqType.JSON,
-                               body='{"checkmempool', status=400, ret_type=RetType.OBJ)
-        self.test_rest_request("/getutxos", http_method='POST', req_type=ReqType.BIN,
-                               body='{"checkmempool', status=400, ret_type=RetType.OBJ)
-        self.test_rest_request("/getutxos/checkmempool", http_method='POST',
-                               req_type=ReqType.JSON, status=400, ret_type=RetType.OBJ)
+        self.test_rest_request(
+            "/getutxos",
+            http_method="POST",
+            req_type=ReqType.JSON,
+            body='{"checkmempool',
+            status=400,
+            ret_type=RetType.OBJ,
+        )
+        self.test_rest_request(
+            "/getutxos",
+            http_method="POST",
+            req_type=ReqType.BIN,
+            body='{"checkmempool',
+            status=400,
+            ret_type=RetType.OBJ,
+        )
+        self.test_rest_request(
+            "/getutxos/checkmempool",
+            http_method="POST",
+            req_type=ReqType.JSON,
+            status=400,
+            ret_type=RetType.OBJ,
+        )
 
         # Test limits
-        long_uri = '/'.join([f"{txid}-{n_}" for n_ in range(20)])
-        self.test_rest_request(f"/getutxos/checkmempool/{long_uri}",
-                               http_method='POST', status=400, ret_type=RetType.OBJ)
+        long_uri = "/".join([f"{txid}-{n_}" for n_ in range(20)])
+        self.test_rest_request(
+            f"/getutxos/checkmempool/{long_uri}",
+            http_method="POST",
+            status=400,
+            ret_type=RetType.OBJ,
+        )
 
-        long_uri = '/'.join([f'{txid}-{n_}' for n_ in range(15)])
+        long_uri = "/".join([f"{txid}-{n_}" for n_ in range(15)])
         self.test_rest_request(
-            f"/getutxos/checkmempool/{long_uri}", http_method='POST', status=200)
+            f"/getutxos/checkmempool/{long_uri}", http_method="POST", status=200
+        )
 
         # Generate block to not affect upcoming tests
         self.generate(self.nodes[0], 1)
@@ -225,112 +258,127 @@
         bb_hash = self.nodes[0].getbestblockhash()
 
         # Check result if block does not exists
-        assert_equal(self.test_rest_request(
-            '/headers/1/0000000000000000000000000000000000000000000000000000000000000000'), [])
+        assert_equal(
+            self.test_rest_request(
+                "/headers/1/0000000000000000000000000000000000000000000000000000000000000000"
+            ),
+            [],
+        )
         self.test_rest_request(
-            '/block/0000000000000000000000000000000000000000000000000000000000000000',
+            "/block/0000000000000000000000000000000000000000000000000000000000000000",
             status=404,
-            ret_type=RetType.OBJ)
+            ret_type=RetType.OBJ,
+        )
 
         # Check result if block is not in the active chain
         self.nodes[0].invalidateblock(bb_hash)
-        assert_equal(
-            self.test_rest_request(
-                f'/headers/1/{bb_hash}'), [])
-        self.test_rest_request(f'/block/{bb_hash}')
+        assert_equal(self.test_rest_request(f"/headers/1/{bb_hash}"), [])
+        self.test_rest_request(f"/block/{bb_hash}")
         self.nodes[0].reconsiderblock(bb_hash)
 
         # Check binary format
         response = self.test_rest_request(
-            f"/block/{bb_hash}", req_type=ReqType.BIN, ret_type=RetType.OBJ)
-        assert_greater_than(int(response.getheader(
-            'content-length')), BLOCK_HEADER_SIZE)
+            f"/block/{bb_hash}", req_type=ReqType.BIN, ret_type=RetType.OBJ
+        )
+        assert_greater_than(
+            int(response.getheader("content-length")), BLOCK_HEADER_SIZE
+        )
         response_bytes = response.read()
 
         # Compare with block header
         response_header = self.test_rest_request(
-            f"/headers/1/{bb_hash}", req_type=ReqType.BIN, ret_type=RetType.OBJ)
-        assert_equal(int(response_header.getheader(
-            'content-length')), BLOCK_HEADER_SIZE)
-        response_header_bytes = response_header.read()
+            f"/headers/1/{bb_hash}", req_type=ReqType.BIN, ret_type=RetType.OBJ
+        )
         assert_equal(
-            response_bytes[0:BLOCK_HEADER_SIZE], response_header_bytes)
+            int(response_header.getheader("content-length")), BLOCK_HEADER_SIZE
+        )
+        response_header_bytes = response_header.read()
+        assert_equal(response_bytes[0:BLOCK_HEADER_SIZE], response_header_bytes)
 
         # Check block hex format
         response_hex = self.test_rest_request(
-            f"/block/{bb_hash}", req_type=ReqType.HEX, ret_type=RetType.OBJ)
-        assert_greater_than(int(response_hex.getheader(
-            'content-length')), BLOCK_HEADER_SIZE * 2)
-        response_hex_bytes = response_hex.read().strip(b'\n')
+            f"/block/{bb_hash}", req_type=ReqType.HEX, ret_type=RetType.OBJ
+        )
+        assert_greater_than(
+            int(response_hex.getheader("content-length")), BLOCK_HEADER_SIZE * 2
+        )
+        response_hex_bytes = response_hex.read().strip(b"\n")
         assert_equal(response_bytes.hex().encode(), response_hex_bytes)
 
         # Compare with hex block header
         response_header_hex = self.test_rest_request(
-            f"/headers/1/{bb_hash}", req_type=ReqType.HEX, ret_type=RetType.OBJ)
+            f"/headers/1/{bb_hash}", req_type=ReqType.HEX, ret_type=RetType.OBJ
+        )
         assert_greater_than(
-            int(response_header_hex.getheader('content-length')), BLOCK_HEADER_SIZE * 2)
-        response_header_hex_bytes = response_header_hex.read(
-            BLOCK_HEADER_SIZE * 2)
-        assert_equal(response_bytes[:BLOCK_HEADER_SIZE].hex().encode(),
-                     response_header_hex_bytes)
+            int(response_header_hex.getheader("content-length")), BLOCK_HEADER_SIZE * 2
+        )
+        response_header_hex_bytes = response_header_hex.read(BLOCK_HEADER_SIZE * 2)
+        assert_equal(
+            response_bytes[:BLOCK_HEADER_SIZE].hex().encode(), response_header_hex_bytes
+        )
 
         # Check json format
         block_json_obj = self.test_rest_request(f"/block/{bb_hash}")
-        assert_equal(block_json_obj['hash'], bb_hash)
-        assert_equal(self.test_rest_request(
-            f"/blockhashbyheight/{block_json_obj['height']}")['blockhash'], bb_hash)
+        assert_equal(block_json_obj["hash"], bb_hash)
+        assert_equal(
+            self.test_rest_request(f"/blockhashbyheight/{block_json_obj['height']}")[
+                "blockhash"
+            ],
+            bb_hash,
+        )
 
         # Check hex/bin format
         resp_hex = self.test_rest_request(
             f"/blockhashbyheight/{block_json_obj['height']}",
             req_type=ReqType.HEX,
-            ret_type=RetType.OBJ)
-        assert_equal(resp_hex.read().decode('utf-8').rstrip(), bb_hash)
+            ret_type=RetType.OBJ,
+        )
+        assert_equal(resp_hex.read().decode("utf-8").rstrip(), bb_hash)
         resp_bytes = self.test_rest_request(
             f"/blockhashbyheight/{block_json_obj['height']}",
             req_type=ReqType.BIN,
-            ret_type=RetType.BYTES)
+            ret_type=RetType.BYTES,
+        )
         blockhash = resp_bytes[::-1].hex()
         assert_equal(blockhash, bb_hash)
 
         # Check invalid blockhashbyheight requests
         resp = self.test_rest_request(
-            "/blockhashbyheight/abc",
-            ret_type=RetType.OBJ,
-            status=400)
-        assert_equal(
-            resp.read().decode('utf-8').rstrip(),
-            "Invalid height: abc")
+            "/blockhashbyheight/abc", ret_type=RetType.OBJ, status=400
+        )
+        assert_equal(resp.read().decode("utf-8").rstrip(), "Invalid height: abc")
         resp = self.test_rest_request(
-            "/blockhashbyheight/1000000",
-            ret_type=RetType.OBJ,
-            status=404)
-        assert_equal(
-            resp.read().decode('utf-8').rstrip(),
-            "Block height out of range")
+            "/blockhashbyheight/1000000", ret_type=RetType.OBJ, status=404
+        )
+        assert_equal(resp.read().decode("utf-8").rstrip(), "Block height out of range")
         resp = self.test_rest_request(
-            "/blockhashbyheight/-1",
-            ret_type=RetType.OBJ,
-            status=400)
-        assert_equal(
-            resp.read().decode('utf-8').rstrip(),
-            "Invalid height: -1")
-        self.test_rest_request(
-            "/blockhashbyheight/",
-            ret_type=RetType.OBJ,
-            status=400)
+            "/blockhashbyheight/-1", ret_type=RetType.OBJ, status=400
+        )
+        assert_equal(resp.read().decode("utf-8").rstrip(), "Invalid height: -1")
+        self.test_rest_request("/blockhashbyheight/", ret_type=RetType.OBJ, status=400)
 
         # Compare with json block header
         json_obj = self.test_rest_request(f"/headers/1/{bb_hash}")
         # Ensure that there is one header in the json response
         assert_equal(len(json_obj), 1)
         # Request/response hash should be the same
-        assert_equal(json_obj[0]['hash'], bb_hash)
+        assert_equal(json_obj[0]["hash"], bb_hash)
 
         # Compare with normal RPC block response
         rpc_block_json = self.nodes[0].getblock(bb_hash)
-        for key in ['hash', 'confirmations', 'height', 'version', 'merkleroot',
-                    'time', 'nonce', 'bits', 'difficulty', 'chainwork', 'previousblockhash']:
+        for key in [
+            "hash",
+            "confirmations",
+            "height",
+            "version",
+            "merkleroot",
+            "time",
+            "nonce",
+            "bits",
+            "difficulty",
+            "chainwork",
+            "previousblockhash",
+        ]:
             assert_equal(json_obj[0][key], rpc_block_json[key])
 
         # See if we can get 5 headers in one response
@@ -351,39 +399,39 @@
         # Check that there are exactly 3 transactions in the TX memory pool
         # before generating the block
         json_obj = self.test_rest_request("/mempool/info")
-        assert_equal(json_obj['size'], 3)
+        assert_equal(json_obj["size"], 3)
         # The size of the memory pool should be greater than 3x ~100 bytes
-        assert_greater_than(json_obj['bytes'], 300)
+        assert_greater_than(json_obj["bytes"], 300)
 
         # Check that there are our submitted transactions in the TX memory pool
         json_obj = self.test_rest_request("/mempool/contents")
         for i, tx in enumerate(txs):
             assert tx in json_obj
-            assert_equal(json_obj[tx]['spentby'], txs[i + 1:i + 2])
-            assert_equal(json_obj[tx]['depends'], txs[i - 1:i])
+            assert_equal(json_obj[tx]["spentby"], txs[i + 1 : i + 2])
+            assert_equal(json_obj[tx]["depends"], txs[i - 1 : i])
 
         # Now mine the transactions
         newblockhash = self.generate(self.nodes[1], 1)
 
         # Check if the 3 tx show up in the new block
         json_obj = self.test_rest_request(f"/block/{newblockhash[0]}")
-        non_coinbase_txs = {tx['txid']
-                            for tx in json_obj['tx'] if 'coinbase' not in tx['vin'][0]}
+        non_coinbase_txs = {
+            tx["txid"] for tx in json_obj["tx"] if "coinbase" not in tx["vin"][0]
+        }
         assert_equal(non_coinbase_txs, set(txs))
 
         # Check the same but without tx details
-        json_obj = self.test_rest_request(
-            f"/block/notxdetails/{newblockhash[0]}")
+        json_obj = self.test_rest_request(f"/block/notxdetails/{newblockhash[0]}")
         for tx in txs:
-            assert tx in json_obj['tx']
+            assert tx in json_obj["tx"]
 
         self.log.info("Test the /chaininfo URI")
 
         bb_hash = self.nodes[0].getbestblockhash()
 
         json_obj = self.test_rest_request("/chaininfo")
-        assert_equal(json_obj['bestblockhash'], bb_hash)
+        assert_equal(json_obj["bestblockhash"], bb_hash)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     RESTTest().main()
diff --git a/test/functional/interface_rpc.py b/test/functional/interface_rpc.py
--- a/test/functional/interface_rpc.py
+++ b/test/functional/interface_rpc.py
@@ -14,12 +14,10 @@
 from test_framework.util import assert_equal, assert_greater_than_or_equal
 
 
-def expect_http_status(expected_http_status, expected_rpc_code,
-                       fcn, *args):
+def expect_http_status(expected_http_status, expected_rpc_code, fcn, *args):
     try:
         fcn(*args)
-        raise AssertionError(
-            f"Expected RPC error {expected_rpc_code}, got none")
+        raise AssertionError(f"Expected RPC error {expected_rpc_code}, got none")
     except JSONRPCException as exc:
         assert_equal(exc.error["code"], expected_rpc_code)
         assert_equal(exc.http_status, expected_http_status)
@@ -29,7 +27,7 @@
     got_error = False
     while not got_error and stop_queue.empty():
         try:
-            node.cli('getrpcinfo').send_cli()
+            node.cli("getrpcinfo").send_cli()
         except subprocess.CalledProcessError as e:
             error_queue.put(e.output)
             got_error = True
@@ -45,43 +43,43 @@
         self.log.info("Testing getrpcinfo...")
 
         info = self.nodes[0].getrpcinfo()
-        assert_equal(len(info['active_commands']), 1)
+        assert_equal(len(info["active_commands"]), 1)
 
-        command = info['active_commands'][0]
-        assert_equal(command['method'], 'getrpcinfo')
-        assert_greater_than_or_equal(command['duration'], 0)
+        command = info["active_commands"][0]
+        assert_equal(command["method"], "getrpcinfo")
+        assert_greater_than_or_equal(command["duration"], 0)
         assert_equal(
-            info['logpath'],
-            os.path.join(
-                self.nodes[0].datadir,
-                self.chain,
-                'debug.log'))
+            info["logpath"],
+            os.path.join(self.nodes[0].datadir, self.chain, "debug.log"),
+        )
 
     def test_batch_request(self):
         self.log.info("Testing basic JSON-RPC batch request...")
 
-        results = self.nodes[0].batch([
-            # A basic request that will work fine.
-            {"method": "getblockcount", "id": 1},
-            # Request that will fail.  The whole batch request should still
-            # work fine.
-            {"method": "invalidmethod", "id": 2},
-            # Another call that should succeed.
-            {"method": "getblockhash", "id": 3, "params": [0]},
-        ])
+        results = self.nodes[0].batch(
+            [
+                # A basic request that will work fine.
+                {"method": "getblockcount", "id": 1},
+                # Request that will fail.  The whole batch request should still
+                # work fine.
+                {"method": "invalidmethod", "id": 2},
+                # Another call that should succeed.
+                {"method": "getblockhash", "id": 3, "params": [0]},
+            ]
+        )
 
         result_by_id = {}
         for res in results:
             result_by_id[res["id"]] = res
 
-        assert_equal(result_by_id[1]['error'], None)
-        assert_equal(result_by_id[1]['result'], 0)
+        assert_equal(result_by_id[1]["error"], None)
+        assert_equal(result_by_id[1]["result"], 0)
 
-        assert_equal(result_by_id[2]['error']['code'], -32601)
-        assert_equal(result_by_id[2]['result'], None)
+        assert_equal(result_by_id[2]["error"]["code"], -32601)
+        assert_equal(result_by_id[2]["result"], None)
 
-        assert_equal(result_by_id[3]['error'], None)
-        assert result_by_id[3]['result'] is not None
+        assert_equal(result_by_id[3]["error"], None)
+        assert result_by_id[3]["result"] is not None
 
     def test_http_status_codes(self):
         self.log.info("Testing HTTP status codes for JSON-RPC requests...")
@@ -91,19 +89,19 @@
 
     def test_work_queue_exceeded(self):
         if not self.is_cli_compiled():
-            self.log.info(
-                "Skipping test_work_queue_exceeded (CLI not compiled)")
+            self.log.info("Skipping test_work_queue_exceeded (CLI not compiled)")
             return
 
         self.log.info("Testing work queue exceeded...")
-        self.restart_node(0, ['-rpcworkqueue=1', '-rpcthreads=1'])
+        self.restart_node(0, ["-rpcworkqueue=1", "-rpcthreads=1"])
         processes = []
         error_queue = multiprocessing.Queue()
         stop_queue = multiprocessing.Queue()
         for _ in range(3):
             p = multiprocessing.Process(
                 target=test_work_queue_getrpcinfo,
-                args=(self.nodes[0], error_queue, stop_queue))
+                args=(self.nodes[0], error_queue, stop_queue),
+            )
             p.start()
             processes.append(p)
 
@@ -114,8 +112,8 @@
             p.join()
         while not error_queue.empty():
             assert_equal(
-                error_queue.get(),
-                'error: Server response: Work queue depth exceeded\n')
+                error_queue.get(), "error: Server response: Work queue depth exceeded\n"
+            )
 
     def run_test(self):
         self.test_getrpcinfo()
@@ -124,7 +122,7 @@
         self.test_work_queue_exceeded()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Setting the multiprocessing start method to "spawn" causes the test to fail
     # on all platforms. Not setting it causes a failure on Mac OS, because it defaults
     # to spawn (for python 3.8+).
diff --git a/test/functional/interface_usdt_net.py b/test/functional/interface_usdt_net.py
--- a/test/functional/interface_usdt_net.py
+++ b/test/functional/interface_usdt_net.py
@@ -101,15 +101,20 @@
             ]
 
             def __repr__(self):
-                return f"P2PMessage(peer={self.peer_id}, addr={self.peer_addr.decode('utf-8')}, conn_type={self.peer_conn_type.decode('utf-8')}, msg_type={self.msg_type.decode('utf-8')}, msg_size={self.msg_size})"
+                return (
+                    f"P2PMessage(peer={self.peer_id},"
+                    f" addr={self.peer_addr.decode('utf-8')},"
+                    f" conn_type={self.peer_conn_type.decode('utf-8')},"
+                    f" msg_type={self.msg_type.decode('utf-8')},"
+                    f" msg_size={self.msg_size})"
+                )
 
         self.log.info(
-            "hook into the net:inbound_message and net:outbound_message tracepoints")
+            "hook into the net:inbound_message and net:outbound_message tracepoints"
+        )
         ctx = USDT(pid=self.nodes[0].process.pid)
-        ctx.enable_probe(probe="net:inbound_message",
-                         fn_name="trace_inbound_message")
-        ctx.enable_probe(probe="net:outbound_message",
-                         fn_name="trace_outbound_message")
+        ctx.enable_probe(probe="net:inbound_message", fn_name="trace_inbound_message")
+        ctx.enable_probe(probe="net:outbound_message", fn_name="trace_outbound_message")
         bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=0)
 
         # The handle_* function is a ctypes callback function called from C. When
@@ -124,14 +129,17 @@
             nonlocal checked_inbound_version_msg, checked_outbound_version_msg
             if event.msg_type.decode("utf-8") == "version":
                 self.log.info(
-                    f"check_p2p_message(): {'inbound' if inbound else 'outbound'} {event}")
+                    "check_p2p_message():"
+                    f" {'inbound' if inbound else 'outbound'} {event}"
+                )
                 peer = self.nodes[0].getpeerinfo()[0]
                 msg = msg_version()
-                msg.deserialize(BytesIO(bytes(event.msg[:event.msg_size])))
+                msg.deserialize(BytesIO(bytes(event.msg[: event.msg_size])))
                 assert_equal(peer["id"], event.peer_id, peer["id"])
                 assert_equal(peer["addr"], event.peer_addr.decode("utf-8"))
-                assert_equal(peer["connection_type"],
-                             event.peer_conn_type.decode("utf-8"))
+                assert_equal(
+                    peer["connection_type"], event.peer_conn_type.decode("utf-8")
+                )
                 if inbound:
                     checked_inbound_version_msg += 1
                 else:
@@ -153,15 +161,12 @@
         self.nodes[0].add_p2p_connection(test_node)
         bpf.perf_buffer_poll(timeout=200)
 
-        self.log.info(
-            "check that we got both an inbound and outbound version message")
-        assert_equal(EXPECTED_INOUTBOUND_VERSION_MSG,
-                     checked_inbound_version_msg)
-        assert_equal(EXPECTED_INOUTBOUND_VERSION_MSG,
-                     checked_outbound_version_msg)
+        self.log.info("check that we got both an inbound and outbound version message")
+        assert_equal(EXPECTED_INOUTBOUND_VERSION_MSG, checked_inbound_version_msg)
+        assert_equal(EXPECTED_INOUTBOUND_VERSION_MSG, checked_outbound_version_msg)
 
         bpf.cleanup()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     NetTracepointTest().main()
diff --git a/test/functional/interface_usdt_utxocache.py b/test/functional/interface_usdt_utxocache.py
--- a/test/functional/interface_usdt_utxocache.py
+++ b/test/functional/interface_usdt_utxocache.py
@@ -119,7 +119,11 @@
     ]
 
     def __repr__(self):
-        return f"UTXOCacheChange(outpoint={bytes(self.txid[::-1]).hex()}:{self.index}, height={self.height}, value={self.value}, is_coinbase={self.is_coinbase})"
+        return (
+            f"UTXOCacheChange(outpoint={bytes(self.txid[::-1]).hex()}:{self.index},"
+            f" height={self.height}, value={self.value},"
+            f" is_coinbase={self.is_coinbase})"
+        )
 
 
 class UTXOCacheFlush(ctypes.Structure):
@@ -132,11 +136,15 @@
     ]
 
     def __repr__(self):
-        return f"UTXOCacheFlush(duration={self.duration}, mode={FLUSHMODE_NAME[self.mode]}, size={self.size}, memory={self.memory}, for_prune={self.for_prune})"
+        return (
+            f"UTXOCacheFlush(duration={self.duration},"
+            f" mode={FLUSHMODE_NAME[self.mode]}, size={self.size},"
+            f" memory={self.memory}, for_prune={self.for_prune})"
+        )
 
 
 def c_string_to_str(c_string):
-    return bytes(c_string).split(b'\x00', 1)[0].decode('ascii')
+    return bytes(c_string).split(b"\x00", 1)[0].decode("ascii")
 
 
 class UTXOCacheTracepointTest(BitcoinTestFramework):
@@ -160,7 +168,7 @@
         self.test_flush()
 
     def test_uncache(self):
-        """ Tests the utxocache:uncache tracepoint API.
+        """Tests the utxocache:uncache tracepoint API.
         https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#tracepoint-utxocacheuncache
         """
         # To trigger an UTXO uncache from the cache, we create an invalid transaction
@@ -178,14 +186,12 @@
 
         # Create a transaction and invalidate it by changing the txid of the previous
         # output to the coinbase txid of the block at height 1.
-        invalid_tx = self.wallet.create_self_transfer(
-            from_node=self.nodes[0])["tx"]
+        invalid_tx = self.wallet.create_self_transfer(from_node=self.nodes[0])["tx"]
         invalid_tx.vin[0].prevout.hash = int(block_1_coinbase_txid, 16)
 
         self.log.info("hooking into the utxocache:uncache tracepoint")
         ctx = USDT(pid=self.nodes[0].process.pid)
-        ctx.enable_probe(probe="utxocache:uncache",
-                         fn_name="trace_utxocache_uncache")
+        ctx.enable_probe(probe="utxocache:uncache", fn_name="trace_utxocache_uncache")
         bpf = BPF(text=utxocache_changes_program, usdt_contexts=[ctx], debug=0)
 
         # The handle_* function is a ctypes callback function called from C. When
@@ -210,26 +216,27 @@
         bpf["utxocache_uncache"].open_perf_buffer(handle_utxocache_uncache)
 
         self.log.info(
-            "testmempoolaccept the invalid transaction to trigger an UTXO-cache uncache")
-        result = self.nodes[0].testmempoolaccept(
-            [invalid_tx.serialize().hex()])[0]
+            "testmempoolaccept the invalid transaction to trigger an UTXO-cache uncache"
+        )
+        result = self.nodes[0].testmempoolaccept([invalid_tx.serialize().hex()])[0]
         assert_equal(result["allowed"], False)
 
         bpf.perf_buffer_poll(timeout=100)
         bpf.cleanup()
 
         self.log.info(
-            f"check that we successfully traced {EXPECTED_HANDLE_UNCACHE_SUCCESS} uncaches")
+            "check that we successfully traced"
+            f" {EXPECTED_HANDLE_UNCACHE_SUCCESS} uncaches"
+        )
         assert_equal(EXPECTED_HANDLE_UNCACHE_SUCCESS, handle_uncache_succeeds)
 
     def test_add_spent(self):
-        """ Tests the utxocache:add utxocache:spent tracepoint API
-            See https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#tracepoint-utxocacheadd
-            and https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#tracepoint-utxocachespent
+        """Tests the utxocache:add utxocache:spent tracepoint API
+        See https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#tracepoint-utxocacheadd
+        and https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#tracepoint-utxocachespent
         """
 
-        self.log.info(
-            "test the utxocache:add and utxocache:spent tracepoint API")
+        self.log.info("test the utxocache:add and utxocache:spent tracepoint API")
 
         self.log.info("create an unconfirmed transaction")
         self.wallet.send_self_transfer(from_node=self.nodes[0])
@@ -246,12 +253,10 @@
         block_hash = self.generate(self.wallet, 1)[0]
         self.nodes[0].invalidateblock(block_hash)
 
-        self.log.info(
-            "hook into the utxocache:add and utxocache:spent tracepoints")
+        self.log.info("hook into the utxocache:add and utxocache:spent tracepoints")
         ctx = USDT(pid=self.nodes[0].process.pid)
         ctx.enable_probe(probe="utxocache:add", fn_name="trace_utxocache_add")
-        ctx.enable_probe(probe="utxocache:spent",
-                         fn_name="trace_utxocache_spent")
+        ctx.enable_probe(probe="utxocache:spent", fn_name="trace_utxocache_spent")
         bpf = BPF(text=utxocache_changes_program, usdt_contexts=[ctx], debug=0)
 
         # The handle_* function is a ctypes callback function called from C. When
@@ -299,54 +304,61 @@
         self.nodes[0].reconsiderblock(block_hash)
 
         block = self.nodes[0].getblock(block_hash, 2)
-        for (block_index, tx) in enumerate(block["tx"]):
+        for block_index, tx in enumerate(block["tx"]):
             for vin in tx["vin"]:
                 if "coinbase" not in vin:
-                    prevout_tx = self.nodes[0].getrawtransaction(
-                        vin["txid"], True)
+                    prevout_tx = self.nodes[0].getrawtransaction(vin["txid"], True)
                     prevout_tx_block = self.nodes[0].getblockheader(
-                        prevout_tx["blockhash"])
+                        prevout_tx["blockhash"]
+                    )
                     spends_coinbase = "coinbase" in prevout_tx["vin"][0]
-                    expected_utxocache_spents.append({
-                        "txid": vin["txid"],
-                        "index": vin["vout"],
-                        "height": prevout_tx_block["height"],
-                        "value": f"{int(prevout_tx['vout'][vin['vout']]['value']):.2f} XEC",
-                        "is_coinbase": spends_coinbase,
-                    })
-            for (i, vout) in enumerate(tx["vout"]):
+                    expected_utxocache_spents.append(
+                        {
+                            "txid": vin["txid"],
+                            "index": vin["vout"],
+                            "height": prevout_tx_block["height"],
+                            "value": (
+                                f"{int(prevout_tx['vout'][vin['vout']]['value']):.2f} XEC"
+                            ),
+                            "is_coinbase": spends_coinbase,
+                        }
+                    )
+            for i, vout in enumerate(tx["vout"]):
                 if vout["scriptPubKey"]["type"] != "nulldata":
-                    expected_utxocache_adds.append({
-                        "txid": tx["txid"],
-                        "index": i,
-                        "height": block["height"],
-                        "value": f"{int(vout['value']):.2f} XEC",
-                        "is_coinbase": block_index == 0,
-                    })
+                    expected_utxocache_adds.append(
+                        {
+                            "txid": tx["txid"],
+                            "index": i,
+                            "height": block["height"],
+                            "value": f"{int(vout['value']):.2f} XEC",
+                            "is_coinbase": block_index == 0,
+                        }
+                    )
 
         assert_equal(EXPECTED_HANDLE_ADD_SUCCESS, len(expected_utxocache_adds))
-        assert_equal(EXPECTED_HANDLE_SPENT_SUCCESS,
-                     len(expected_utxocache_spents))
+        assert_equal(EXPECTED_HANDLE_SPENT_SUCCESS, len(expected_utxocache_spents))
 
         bpf.perf_buffer_poll(timeout=200)
         bpf.cleanup()
 
         self.log.info(
-            f"check that we successfully traced {EXPECTED_HANDLE_ADD_SUCCESS} adds and {EXPECTED_HANDLE_SPENT_SUCCESS} spent")
+            f"check that we successfully traced {EXPECTED_HANDLE_ADD_SUCCESS} adds and"
+            f" {EXPECTED_HANDLE_SPENT_SUCCESS} spent"
+        )
         assert_equal(0, len(expected_utxocache_adds))
         assert_equal(0, len(expected_utxocache_spents))
         assert_equal(EXPECTED_HANDLE_ADD_SUCCESS, handle_add_succeeds)
         assert_equal(EXPECTED_HANDLE_SPENT_SUCCESS, handle_spent_succeeds)
 
     def test_flush(self):
-        """ Tests the utxocache:flush tracepoint API.
-            See https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#tracepoint-utxocacheflush"""
+        """Tests the utxocache:flush tracepoint API.
+        See https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#tracepoint-utxocacheflush
+        """
 
         self.log.info("test the utxocache:flush tracepoint API")
         self.log.info("hook into the utxocache:flush tracepoint")
         ctx = USDT(pid=self.nodes[0].process.pid)
-        ctx.enable_probe(probe="utxocache:flush",
-                         fn_name="trace_utxocache_flush")
+        ctx.enable_probe(probe="utxocache:flush", fn_name="trace_utxocache_flush")
         bpf = BPF(text=utxocache_flushes_program, usdt_contexts=[ctx], debug=0)
 
         # The handle_* function is a ctypes callback function called from C. When
@@ -361,11 +373,13 @@
             nonlocal handle_flush_succeeds
             event = ctypes.cast(data, ctypes.POINTER(UTXOCacheFlush)).contents
             self.log.info(f"handle_utxocache_flush(): {event}")
-            expected_flushes.remove({
-                "mode": FLUSHMODE_NAME[event.mode],
-                "for_prune": event.for_prune,
-                "size": event.size
-            })
+            expected_flushes.remove(
+                {
+                    "mode": FLUSHMODE_NAME[event.mode],
+                    "for_prune": event.for_prune,
+                    "size": event.size,
+                }
+            )
             # sanity checks only
             assert event.memory > 0
             assert event.duration > 0
@@ -380,9 +394,9 @@
         # UTXOs and one that flushes 0 UTXOs. Normally the 0-UTXO-flush is the
         # second flush, however it can happen that the order changes.
         expected_flushes.append(
-            {"mode": "ALWAYS", "for_prune": False, "size": UTXOS_IN_CACHE})
-        expected_flushes.append(
-            {"mode": "ALWAYS", "for_prune": False, "size": 0})
+            {"mode": "ALWAYS", "for_prune": False, "size": UTXOS_IN_CACHE}
+        )
+        expected_flushes.append({"mode": "ALWAYS", "for_prune": False, "size": 0})
         self.stop_node(0)
 
         bpf.perf_buffer_poll(timeout=200)
@@ -401,8 +415,7 @@
         self.log.info("test the utxocache:flush tracepoint API with pruning")
         self.log.info("hook into the utxocache:flush tracepoint")
         ctx = USDT(pid=self.nodes[0].process.pid)
-        ctx.enable_probe(probe="utxocache:flush",
-                         fn_name="trace_utxocache_flush")
+        ctx.enable_probe(probe="utxocache:flush", fn_name="trace_utxocache_flush")
         bpf = BPF(text=utxocache_flushes_program, usdt_contexts=[ctx], debug=0)
         bpf["utxocache_flush"].open_perf_buffer(handle_utxocache_flush)
 
@@ -414,10 +427,12 @@
         bpf.cleanup()
 
         self.log.info(
-            "check that we don't expect additional flushes and that the handle_* function succeeded")
+            "check that we don't expect additional flushes and that the handle_*"
+            " function succeeded"
+        )
         assert_equal(0, len(expected_flushes))
         assert_equal(EXPECTED_HANDLE_FLUSH_SUCCESS, handle_flush_succeeds)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     UTXOCacheTracepointTest().main()
diff --git a/test/functional/interface_usdt_validation.py b/test/functional/interface_usdt_validation.py
--- a/test/functional/interface_usdt_validation.py
+++ b/test/functional/interface_usdt_validation.py
@@ -94,10 +94,10 @@
 
         self.log.info("hook into the validation:block_connected tracepoint")
         ctx = USDT(pid=self.nodes[0].process.pid)
-        ctx.enable_probe(probe="validation:block_connected",
-                         fn_name="trace_block_connected")
-        bpf = BPF(text=validation_blockconnected_program,
-                  usdt_contexts=[ctx], debug=0)
+        ctx.enable_probe(
+            probe="validation:block_connected", fn_name="trace_block_connected"
+        )
+        bpf = BPF(text=validation_blockconnected_program, usdt_contexts=[ctx], debug=0)
 
         def handle_blockconnected(_, data, __):
             nonlocal expected_blocks, blocks_checked
@@ -115,12 +115,12 @@
 
             blocks_checked += 1
 
-        bpf["block_connected"].open_perf_buffer(
-            handle_blockconnected)
+        bpf["block_connected"].open_perf_buffer(handle_blockconnected)
 
         self.log.info(f"mine {BLOCKS_EXPECTED} blocks")
         block_hashes = self.generatetoaddress(
-            self.nodes[0], BLOCKS_EXPECTED, ADDRESS_ECREG_UNSPENDABLE)
+            self.nodes[0], BLOCKS_EXPECTED, ADDRESS_ECREG_UNSPENDABLE
+        )
         for block_hash in block_hashes:
             expected_blocks.append(self.nodes[0].getblock(block_hash, 2))
 
@@ -132,5 +132,5 @@
         assert_equal(0, len(expected_blocks))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     ValidationTracepointTest().main()
diff --git a/test/functional/interface_zmq.py b/test/functional/interface_zmq.py
--- a/test/functional/interface_zmq.py
+++ b/test/functional/interface_zmq.py
@@ -43,7 +43,7 @@
         # Topic should match the subscriber topic.
         assert_equal(topic, self.topic)
         # Sequence should be incremental.
-        received_seq = struct.unpack('<I', seq)[-1]
+        received_seq = struct.unpack("<I", seq)[-1]
         if self.sequence is None:
             self.sequence = received_seq
         else:
@@ -58,8 +58,9 @@
         body = self._receive_from_publisher_and_check()
         hash_str = body[:32].hex()
         label = chr(body[32])
-        mempool_sequence = None if len(
-            body) != 32 + 1 + 8 else struct.unpack("<Q", body[32 + 1:])[0]
+        mempool_sequence = (
+            None if len(body) != 32 + 1 + 8 else struct.unpack("<Q", body[32 + 1 :])[0]
+        )
         if mempool_sequence is not None:
             assert label == "A" or label == "R"
         else:
@@ -78,10 +79,11 @@
 
     def __init__(self, test_framework, node):
         self.block_hash = test_framework.generate(
-            node, 1, sync_fun=test_framework.no_op)[0]
-        coinbase = node.getblock(self.block_hash, 2)['tx'][0]
-        self.tx_hash = coinbase['txid']
-        self.raw_tx = coinbase['hex']
+            node, 1, sync_fun=test_framework.no_op
+        )[0]
+        coinbase = node.getblock(self.block_hash, 2)["tx"][0]
+        self.tx_hash = coinbase["txid"]
+        self.raw_tx = coinbase["hex"]
         self.raw_block = node.getblock(self.block_hash, 0)
 
     def caused_notification(self, notification):
@@ -93,7 +95,7 @@
         )
 
 
-class ZMQTest (BitcoinTestFramework):
+class ZMQTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [["-whitelist=noban@127.0.0.1"]] * self.num_nodes
@@ -125,9 +127,9 @@
 
         self.restart_node(
             0,
-            self.extra_args[0] + [
-                f"-zmqpub{topic}={address}" for topic, address in services
-            ])
+            self.extra_args[0]
+            + [f"-zmqpub{topic}={address}" for topic, address in services],
+        )
 
         for i, sub in enumerate(subscribers):
             sub.socket.connect(services[i][1])
@@ -145,17 +147,16 @@
             recv_failed = False
             for sub in subscribers:
                 try:
-                    while not test_block.caused_notification(
-                            sub.receive().hex()):
+                    while not test_block.caused_notification(sub.receive().hex()):
                         self.log.debug(
-                            "Ignoring sync-up notification for previously generated block.")
+                            "Ignoring sync-up notification for previously generated"
+                            " block."
+                        )
                 except zmq.error.Again:
-                    self.log.debug(
-                        "Didn't receive sync-up notification, trying again.")
+                    self.log.debug("Didn't receive sync-up notification, trying again.")
                     recv_failed = True
             if not recv_failed:
-                self.log.debug(
-                    "ZMQ sync-up completed, all subscribers are ready.")
+                self.log.debug("ZMQ sync-up completed, all subscribers are ready.")
                 break
 
         # set subscriber's desired timeout for the test
@@ -169,14 +170,13 @@
         return subscribers
 
     def test_basic(self):
-
         # Invalid zmq arguments don't take down the node, see #17185.
         self.restart_node(0, ["-zmqpubrawtx=foo", "-zmqpubhashtx=bar"])
 
-        address = 'tcp://127.0.0.1:28332'
+        address = "tcp://127.0.0.1:28332"
         subs = self.setup_zmq_test(
-            [(topic, address)
-             for topic in ["hashblock", "hashtx", "rawblock", "rawtx"]])
+            [(topic, address) for topic in ["hashblock", "hashtx", "rawblock", "rawtx"]]
+        )
 
         hashblock = subs[0]
         hashtx = subs[1]
@@ -184,10 +184,10 @@
         rawtx = subs[3]
 
         num_blocks = 5
-        self.log.info(
-            "Generate {0} blocks (and {0} coinbase txes)".format(num_blocks))
-        genhashes = self.generatetoaddress(self.nodes[0],
-                                           num_blocks, ADDRESS_ECREG_UNSPENDABLE)
+        self.log.info("Generate {0} blocks (and {0} coinbase txes)".format(num_blocks))
+        genhashes = self.generatetoaddress(
+            self.nodes[0], num_blocks, ADDRESS_ECREG_UNSPENDABLE
+        )
 
         for x in range(num_blocks):
             # Should receive the coinbase txid.
@@ -213,7 +213,8 @@
         if self.is_wallet_compiled():
             self.log.info("Wait for tx from second node")
             payment_txid = self.nodes[1].sendtoaddress(
-                self.nodes[0].getnewaddress(), 1000000)
+                self.nodes[0].getnewaddress(), 1000000
+            )
             self.sync_all()
 
             # Should receive the broadcasted txid.
@@ -232,12 +233,15 @@
             assert_equal(payment_txid, txid.hex())
 
         self.log.info("Test the getzmqnotifications RPC")
-        assert_equal(self.nodes[0].getzmqnotifications(), [
-            {"type": "pubhashblock", "address": address, "hwm": 1000},
-            {"type": "pubhashtx", "address": address, "hwm": 1000},
-            {"type": "pubrawblock", "address": address, "hwm": 1000},
-            {"type": "pubrawtx", "address": address, "hwm": 1000},
-        ])
+        assert_equal(
+            self.nodes[0].getzmqnotifications(),
+            [
+                {"type": "pubhashblock", "address": address, "hwm": 1000},
+                {"type": "pubhashtx", "address": address, "hwm": 1000},
+                {"type": "pubrawblock", "address": address, "hwm": 1000},
+                {"type": "pubrawtx", "address": address, "hwm": 1000},
+            ],
+        )
 
         assert_equal(self.nodes[1].getzmqnotifications(), [])
 
@@ -246,31 +250,33 @@
             self.log.info("Skipping reorg test because wallet is disabled")
             return
 
-        address = 'tcp://127.0.0.1:28333'
+        address = "tcp://127.0.0.1:28333"
 
         # Should only notify the tip if a reorg occurs
         hashblock, hashtx = self.setup_zmq_test(
             [(topic, address) for topic in ["hashblock", "hashtx"]],
             # 2 second timeout to check end of notifications
-            recv_timeout=2)
+            recv_timeout=2,
+        )
         self.disconnect_nodes(0, 1)
 
         # Generate 1 block in nodes[0] with 1 mempool tx and receive all
         # notifications
         payment_txid = self.nodes[0].sendtoaddress(
-            self.nodes[0].getnewaddress(), 1000000)
-        disconnect_block = self.generatetoaddress(self.nodes[0],
-                                                  1, ADDRESS_ECREG_UNSPENDABLE, sync_fun=self.no_op)[0]
+            self.nodes[0].getnewaddress(), 1000000
+        )
+        disconnect_block = self.generatetoaddress(
+            self.nodes[0], 1, ADDRESS_ECREG_UNSPENDABLE, sync_fun=self.no_op
+        )[0]
         disconnect_cb = self.nodes[0].getblock(disconnect_block)["tx"][0]
-        assert_equal(
-            self.nodes[0].getbestblockhash(),
-            hashblock.receive().hex())
+        assert_equal(self.nodes[0].getbestblockhash(), hashblock.receive().hex())
         assert_equal(hashtx.receive().hex(), payment_txid)
         assert_equal(hashtx.receive().hex(), disconnect_cb)
 
         # Generate 2 blocks in nodes[1] to a different address to ensure split
-        connect_blocks = self.generatetoaddress(self.nodes[1],
-                                                2, ADDRESS_ECREG_P2SH_OP_TRUE, sync_fun=self.no_op)
+        connect_blocks = self.generatetoaddress(
+            self.nodes[1], 2, ADDRESS_ECREG_P2SH_OP_TRUE, sync_fun=self.no_op
+        )
 
         # nodes[0] will reorg chain after connecting back nodes[1]
         self.connect_nodes(0, 1)
@@ -278,9 +284,7 @@
         self.sync_blocks()
 
         # Should receive nodes[1] tip
-        assert_equal(
-            self.nodes[1].getbestblockhash(),
-            hashblock.receive().hex())
+        assert_equal(self.nodes[1].getbestblockhash(), hashblock.receive().hex())
 
         # During reorg:
         # Get old payment transaction notification from disconnect and
@@ -294,23 +298,21 @@
         for i in [0, 1]:
             assert_equal(
                 hashtx.receive().hex(),
-                self.nodes[1].getblock(
-                    connect_blocks[i])["tx"][0])
+                self.nodes[1].getblock(connect_blocks[i])["tx"][0],
+            )
 
         # If we do a simple invalidate we announce the disconnected coinbase
         self.nodes[0].invalidateblock(connect_blocks[1])
         assert_equal(
-            hashtx.receive().hex(),
-            self.nodes[1].getblock(
-                connect_blocks[1])["tx"][0])
+            hashtx.receive().hex(), self.nodes[1].getblock(connect_blocks[1])["tx"][0]
+        )
         # And the payment transaction again due to mempool entry (it was removed
         # from the mempool due to the reorg)
         assert_equal(hashtx.receive().hex(), payment_txid)
         # And the current tip
         assert_equal(
-            hashtx.receive().hex(),
-            self.nodes[1].getblock(
-                connect_blocks[0])["tx"][0])
+            hashtx.receive().hex(), self.nodes[1].getblock(connect_blocks[0])["tx"][0]
+        )
 
     def create_conflicting_tx(self):
         """Create a transaction that is initially added to node0's mempool
@@ -327,8 +329,10 @@
             tx = self.nodes[1].signrawtransactionwithwallet(
                 self.nodes[1].createrawtransaction(
                     inputs=[{"txid": utxo["txid"], "vout": utxo["vout"]}],
-                    outputs=[{address: 5_000_000},
-                             {change_address: utxo["amount"] - 5_001_000}]
+                    outputs=[
+                        {address: 5_000_000},
+                        {change_address: utxo["amount"] - 5_001_000},
+                    ],
                 )
             )
             return send_node.sendrawtransaction(tx["hex"])
@@ -337,7 +341,8 @@
         txid_to_be_replaced = send_conflicting_transaction(self.nodes[0])
         replacement_txid = send_conflicting_transaction(self.nodes[1])
         block_hash = self.generatetoaddress(
-            self.nodes[1], 1, ADDRESS_ECREG_P2SH_OP_TRUE, sync_fun=self.no_op)[0]
+            self.nodes[1], 1, ADDRESS_ECREG_P2SH_OP_TRUE, sync_fun=self.no_op
+        )[0]
         self.connect_nodes(0, 1)
         self.sync_all()
 
@@ -362,21 +367,21 @@
         seq_num = 1
 
         # Generate 1 block in nodes[0] and receive all notifications
-        dc_block = self.generatetoaddress(self.nodes[0],
-                                          1, ADDRESS_ECREG_UNSPENDABLE, sync_fun=self.no_op)[0]
+        dc_block = self.generatetoaddress(
+            self.nodes[0], 1, ADDRESS_ECREG_UNSPENDABLE, sync_fun=self.no_op
+        )[0]
 
         # Note: We are not notified of any block transactions, coinbase or
         # mined
-        assert_equal((self.nodes[0].getbestblockhash(), "C", None),
-                     seq.receive_sequence())
+        assert_equal(
+            (self.nodes[0].getbestblockhash(), "C", None), seq.receive_sequence()
+        )
 
         # Generate 2 blocks in nodes[1] to a different address to ensure
         # a chain split
         self.generatetoaddress(
-            self.nodes[1],
-            2,
-            ADDRESS_ECREG_P2SH_OP_TRUE,
-            sync_fun=self.no_op)
+            self.nodes[1], 2, ADDRESS_ECREG_P2SH_OP_TRUE, sync_fun=self.no_op
+        )
 
         # nodes[0] will reorg chain after connecting back nodes[1]
         self.connect_nodes(0, 1)
@@ -385,26 +390,29 @@
         # 2 block reorg
         assert_equal((dc_block, "D", None), seq.receive_sequence())
         block_count = self.nodes[1].getblockcount()
-        assert_equal((self.nodes[1].getblockhash(block_count - 1), "C", None),
-                     seq.receive_sequence())
-        assert_equal((self.nodes[1].getblockhash(block_count), "C", None),
-                     seq.receive_sequence())
+        assert_equal(
+            (self.nodes[1].getblockhash(block_count - 1), "C", None),
+            seq.receive_sequence(),
+        )
+        assert_equal(
+            (self.nodes[1].getblockhash(block_count), "C", None), seq.receive_sequence()
+        )
 
         # Rest of test requires wallet functionality
         if self.is_wallet_compiled():
-            (block_hash, txid_to_be_replaced, replacement_txid
-             ) = self.create_conflicting_tx()
-            self.log.info(
-                "Testing sequence notifications with mempool sequence values")
+            (
+                block_hash,
+                txid_to_be_replaced,
+                replacement_txid,
+            ) = self.create_conflicting_tx()
+            self.log.info("Testing sequence notifications with mempool sequence values")
             # Should receive the initially broadcasted txid.
-            assert_equal((txid_to_be_replaced, "A", seq_num),
-                         seq.receive_sequence())
+            assert_equal((txid_to_be_replaced, "A", seq_num), seq.receive_sequence())
             seq_num += 1
 
             self.log.info("Testing a tx removal notification")
             # Next we receive a notification for the transaction removal
-            assert_equal((txid_to_be_replaced, "R", seq_num),
-                         seq.receive_sequence())
+            assert_equal((txid_to_be_replaced, "R", seq_num), seq.receive_sequence())
             seq_num += 1
             # Then we see the block notification
             assert_equal((block_hash, "C", None), seq.receive_sequence())
@@ -414,7 +422,8 @@
 
             self.log.info("Wait for tx from second node")
             payment_txid = self.nodes[1].sendtoaddress(
-                address=self.nodes[0].getnewaddress(), amount=5_000_000)
+                address=self.nodes[0].getnewaddress(), amount=5_000_000
+            )
             self.sync_all()
             assert_equal((payment_txid, "A", seq_num), seq.receive_sequence())
             seq_num += 1
@@ -424,37 +433,40 @@
             # the number of transactions removed from the mempool by the block
             # mining it.
             mempool_size = len(self.nodes[0].getrawmempool())
-            c_block = self.generatetoaddress(self.nodes[0],
-                                             1, ADDRESS_ECREG_UNSPENDABLE)[0]
+            c_block = self.generatetoaddress(
+                self.nodes[0], 1, ADDRESS_ECREG_UNSPENDABLE
+            )[0]
             # Make sure the number of mined transactions matches the number of
             # txs out of mempool
-            mempool_size_delta = mempool_size - \
-                len(self.nodes[0].getrawmempool())
-            assert_equal(len(self.nodes[0].getblock(c_block)["tx"]) - 1,
-                         mempool_size_delta)
+            mempool_size_delta = mempool_size - len(self.nodes[0].getrawmempool())
+            assert_equal(
+                len(self.nodes[0].getblock(c_block)["tx"]) - 1, mempool_size_delta
+            )
             seq_num += mempool_size_delta
             payment_txid_2 = self.nodes[1].sendtoaddress(
-                self.nodes[0].getnewaddress(), 1_000_000)
+                self.nodes[0].getnewaddress(), 1_000_000
+            )
             self.sync_all()
             assert_equal((c_block, "C", None), seq.receive_sequence())
-            assert_equal((payment_txid_2, "A", seq_num),
-                         seq.receive_sequence())
+            assert_equal((payment_txid_2, "A", seq_num), seq.receive_sequence())
             seq_num += 1
 
             # Spot check getrawmempool results that they only show up when
             # asked for
             assert isinstance(self.nodes[0].getrawmempool(), list)
-            assert isinstance(
-                self.nodes[0].getrawmempool(mempool_sequence=False),
-                list)
-            assert "mempool_sequence" not in self.nodes[0].getrawmempool(
-                verbose=True)
+            assert isinstance(self.nodes[0].getrawmempool(mempool_sequence=False), list)
+            assert "mempool_sequence" not in self.nodes[0].getrawmempool(verbose=True)
             assert_raises_rpc_error(
-                -8, "Verbose results cannot contain mempool sequence values.",
-                self.nodes[0].getrawmempool, True, True)
-            assert_equal(self.nodes[0].getrawmempool(
-                mempool_sequence=True)["mempool_sequence"],
-                seq_num)
+                -8,
+                "Verbose results cannot contain mempool sequence values.",
+                self.nodes[0].getrawmempool,
+                True,
+                True,
+            )
+            assert_equal(
+                self.nodes[0].getrawmempool(mempool_sequence=True)["mempool_sequence"],
+                seq_num,
+            )
 
             self.log.info("Testing reorg notifications")
             # Manually invalidate the last block to test mempool re-entry
@@ -470,11 +482,12 @@
 
             # Make sure getrawmempool mempool_sequence results aren't "queued"
             # but immediately reflective of the time they were gathered.
-            assert self.nodes[0].getrawmempool(
-                mempool_sequence=True)["mempool_sequence"] > seq_num
+            assert (
+                self.nodes[0].getrawmempool(mempool_sequence=True)["mempool_sequence"]
+                > seq_num
+            )
 
-            assert_equal((payment_txid_2, "R", seq_num),
-                         seq.receive_sequence())
+            assert_equal((payment_txid_2, "R", seq_num), seq.receive_sequence())
             seq_num += 1
             assert_equal((best_hash, "D", None), seq.receive_sequence())
             assert_equal((payment_txid, "A", seq_num), seq.receive_sequence())
@@ -487,33 +500,35 @@
 
             self.log.info("Evict mempool transaction by block conflict")
             orig_txid = self.nodes[0].sendtoaddress(
-                address=self.nodes[0].getnewaddress(), amount=1_000_000)
+                address=self.nodes[0].getnewaddress(), amount=1_000_000
+            )
 
             # More to be simply mined
             more_tx = []
             for _ in range(5):
-                more_tx.append(self.nodes[0].sendtoaddress(
-                    self.nodes[0].getnewaddress(), 100_000))
+                more_tx.append(
+                    self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 100_000)
+                )
 
             raw_tx = self.nodes[0].getrawtransaction(orig_txid)
             block = create_block(
                 int(self.nodes[0].getbestblockhash(), 16),
-                create_coinbase(self.nodes[0].getblockcount() + 1))
+                create_coinbase(self.nodes[0].getblockcount() + 1),
+            )
             tx = FromHex(CTransaction(), raw_tx)
             block.vtx.append(tx)
             for txid in more_tx:
-                tx = FromHex(CTransaction(),
-                             self.nodes[0].getrawtransaction(txid))
+                tx = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
                 block.vtx.append(tx)
             make_conform_to_ctor(block)
             block.hashMerkleRoot = block.calc_merkle_root()
             block.solve()
-            assert_equal(self.nodes[0].submitblock(block.serialize().hex()),
-                         None)
+            assert_equal(self.nodes[0].submitblock(block.serialize().hex()), None)
             tip = self.nodes[0].getbestblockhash()
             assert_equal(int(tip, 16), block.sha256)
             orig_txid_2 = self.nodes[0].sendtoaddress(
-                address=self.nodes[0].getnewaddress(), amount=1_000_000)
+                address=self.nodes[0].getnewaddress(), amount=1_000_000
+            )
 
             # Flush old notifications until evicted tx original entry
             (hash_str, label, mempool_seq) = seq.receive_sequence()
@@ -525,8 +540,7 @@
             assert_equal(label, "A")
             # More transactions to be simply mined
             for i in range(len(more_tx)):
-                assert_equal((more_tx[i], "A", mempool_seq),
-                             seq.receive_sequence())
+                assert_equal((more_tx[i], "A", mempool_seq), seq.receive_sequence())
                 mempool_seq += 1
 
             # Removed RBF tests
@@ -535,8 +549,7 @@
             assert_equal((tip, "C", None), seq.receive_sequence())
             mempool_seq += len(more_tx)
             # Last tx
-            assert_equal((orig_txid_2, "A", mempool_seq),
-                         seq.receive_sequence())
+            assert_equal((orig_txid_2, "A", mempool_seq), seq.receive_sequence())
             mempool_seq += 1
             self.generatetoaddress(self.nodes[0], 1, ADDRESS_ECREG_UNSPENDABLE)
             # want to make sure we didn't break "consensus" for other tests
@@ -555,8 +568,9 @@
         [seq] = self.setup_zmq_test([("sequence", "tcp://127.0.0.1:28333")])
 
         # In-memory counter, should always start at 1
-        next_mempool_seq = self.nodes[0].getrawmempool(
-            mempool_sequence=True)["mempool_sequence"]
+        next_mempool_seq = self.nodes[0].getrawmempool(mempool_sequence=True)[
+            "mempool_sequence"
+        ]
         assert_equal(next_mempool_seq, 1)
 
         # Some transactions have been happening but we aren't consuming
@@ -565,8 +579,11 @@
         txids = []
         num_txs = 5
         for _ in range(num_txs):
-            txids.append(self.nodes[1].sendtoaddress(
-                address=self.nodes[0].getnewaddress(), amount=1_000_000))
+            txids.append(
+                self.nodes[1].sendtoaddress(
+                    address=self.nodes[0].getnewaddress(), amount=1_000_000
+                )
+            )
         self.sync_all()
 
         # 1) Consume backlog until we get a mempool sequence number
@@ -585,21 +602,24 @@
         # Snapshot may be too old compared to zmq message we read off latest
         while zmq_mem_seq >= get_raw_seq:
             sleep(2)
-            mempool_snapshot = self.nodes[0].getrawmempool(
-                mempool_sequence=True)
+            mempool_snapshot = self.nodes[0].getrawmempool(mempool_sequence=True)
             mempool_view = set(mempool_snapshot["txids"])
             get_raw_seq = mempool_snapshot["mempool_sequence"]
 
         # Things continue to happen in the "interim" while waiting for
         # snapshot results
         for _ in range(num_txs):
-            txids.append(self.nodes[0].sendtoaddress(
-                address=self.nodes[0].getnewaddress(), amount=1_000_000))
+            txids.append(
+                self.nodes[0].sendtoaddress(
+                    address=self.nodes[0].getnewaddress(), amount=1_000_000
+                )
+            )
         self.sync_all()
         self.create_conflicting_tx()
         self.generatetoaddress(self.nodes[0], 1, ADDRESS_ECREG_UNSPENDABLE)
         final_txid = self.nodes[0].sendtoaddress(
-            address=self.nodes[0].getnewaddress(), amount=100_000)
+            address=self.nodes[0].getnewaddress(), amount=100_000
+        )
 
         # 3) Consume ZMQ backlog until we get to "now" for the mempool snapshot
         while True:
@@ -610,9 +630,10 @@
                 zmq_mem_seq = mempool_sequence
                 if zmq_mem_seq > get_raw_seq:
                     raise Exception(
-                        f"We somehow jumped mempool sequence numbers! "
+                        "We somehow jumped mempool sequence numbers! "
                         f"zmq_mem_seq: {zmq_mem_seq} > "
-                        f"get_raw_seq: {get_raw_seq}")
+                        f"get_raw_seq: {get_raw_seq}"
+                    )
 
         # 4) Moving forward, we apply the delta to our local view
         #  remaining txs + conflict (A, R, C) + 1 block connect + 1 final tx
@@ -642,9 +663,9 @@
 
         assert_equal(self.nodes[0].getrawmempool(), [final_txid])
         assert_equal(
-            self.nodes[0].getrawmempool(
-                mempool_sequence=True)["mempool_sequence"],
-            expected_sequence)
+            self.nodes[0].getrawmempool(mempool_sequence=True)["mempool_sequence"],
+            expected_sequence,
+        )
 
         # 5) If you miss a zmq/mempool sequence number, go back to step (2)
 
@@ -655,24 +676,23 @@
         # (note that after the reorg test, syncing would fail due to different
         # chain lengths on node0 and node1; for this test we only need node0, so
         # we can disable syncing blocks on the setup)
-        subscribers = self.setup_zmq_test([
-            ("hashblock", "tcp://127.0.0.1:28334"),
-            ("hashblock", "tcp://127.0.0.1:28335"),
-        ], sync_blocks=False)
+        subscribers = self.setup_zmq_test(
+            [
+                ("hashblock", "tcp://127.0.0.1:28334"),
+                ("hashblock", "tcp://127.0.0.1:28335"),
+            ],
+            sync_blocks=False,
+        )
 
         # Generate 1 block in nodes[0] and receive all notifications
         self.generatetoaddress(
-            self.nodes[0],
-            1,
-            ADDRESS_ECREG_UNSPENDABLE,
-            sync_fun=self.no_op)
+            self.nodes[0], 1, ADDRESS_ECREG_UNSPENDABLE, sync_fun=self.no_op
+        )
 
         # Should receive the same block hash on both subscribers
-        assert_equal(self.nodes[0].getbestblockhash(),
-                     subscribers[0].receive().hex())
-        assert_equal(self.nodes[0].getbestblockhash(),
-                     subscribers[1].receive().hex())
+        assert_equal(self.nodes[0].getbestblockhash(), subscribers[0].receive().hex())
+        assert_equal(self.nodes[0].getbestblockhash(), subscribers[1].receive().hex())
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     ZMQTest().main()