diff --git a/test/functional/feature_config_args.py b/test/functional/feature_config_args.py
index 6b9e464195..44ffbf7067 100755
--- a/test/functional/feature_config_args.py
+++ b/test/functional/feature_config_args.py
@@ -1,184 +1,191 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test various command line arguments and configuration file parameters."""
 import os
 
 from test_framework.test_framework import BitcoinTestFramework
 
 
 class ConfArgsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
-    def skip_test_if_missing_module(self):
-        self.skip_if_no_wallet()
-
     def test_config_file_parser(self):
         # Assume node is stopped
 
         inc_conf_file_path = os.path.join(
             self.nodes[0].datadir, 'include.conf')
         with open(os.path.join(self.nodes[0].datadir, 'bitcoin.conf'), 'a', encoding='utf-8') as conf:
             conf.write('includeconf={}\n'.format(inc_conf_file_path))
 
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: Error parsing command line arguments: Invalid parameter -dash_cli',
             extra_args=['-dash_cli=1'],
         )
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('dash_conf=1\n')
         with self.nodes[0].assert_debug_log(expected_msgs=['Ignoring unknown configuration value dash_conf']):
             self.start_node(0)
         self.stop_node(0)
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('-dash=1\n')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: Error reading configuration file: parse error on line 1: -dash=1, options in configuration file must be specified without leading -')
 
         if self.is_wallet_compiled():
             with open(inc_conf_file_path, 'w', encoding='utf8') as conf:
                 conf.write("wallet=foo\n")
             self.nodes[0].assert_start_raises_init_error(
                 expected_msg='Error: Config setting for -wallet only applied on regtest network when in [regtest] section.')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('regtest=0\n')  # mainnet
             conf.write('acceptnonstdtxn=1\n')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: acceptnonstdtxn is not currently supported for main chain')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('nono\n')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: Error reading configuration file: parse error on line 1: nono, if you intended to specify a negated option, use nono=1 instead')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('server=1\nrpcuser=someuser\nrpcpassword=some#pass')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: Error reading configuration file: parse error on line 3, using # in rpcpassword can be ambiguous and should be avoided')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('server=1\nrpcuser=someuser\nmain.rpcpassword=some#pass')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: Error reading configuration file: parse error on line 3, using # in rpcpassword can be ambiguous and should be avoided')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write(
                 'server=1\nrpcuser=someuser\n[main]\nrpcpassword=some#pass')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: Error reading configuration file: parse error on line 4, using # in rpcpassword can be ambiguous and should be avoided')
 
         inc_conf_file2_path = os.path.join(
             self.nodes[0].datadir, 'include2.conf')
         with open(os.path.join(self.nodes[0].datadir, 'bitcoin.conf'), 'a', encoding='utf-8') as conf:
             conf.write('includeconf={}\n'.format(inc_conf_file2_path))
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('testnot.datadir=1\n')
         with open(inc_conf_file2_path, 'w', encoding='utf-8') as conf:
             conf.write('[testnet]\n')
         self.restart_node(0)
         self.nodes[0].stop_node(
             expected_stderr='Warning: ' +
             inc_conf_file_path +
             ':1 Section [testnot] is not recognized.' +
             os.linesep +
             'Warning: ' +
             inc_conf_file2_path +
             ':1 Section [testnet] is not recognized.')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('')  # clear
         with open(inc_conf_file2_path, 'w', encoding='utf-8') as conf:
             conf.write('')  # clear
 
     def test_log_buffer(self):
         with self.nodes[0].assert_debug_log(expected_msgs=['Warning: parsed potentially confusing double-negative -connect=0']):
             self.start_node(0, extra_args=['-noconnect=0'])
         self.stop_node(0)
 
     def test_args_log(self):
         self.log.info('Test config args logging')
         with self.nodes[0].assert_debug_log(
                 expected_msgs=[
                     'Command-line arg: addnode="some.node"',
                     'Command-line arg: rpcauth=****',
                     'Command-line arg: rpcbind=****',
                     'Command-line arg: rpcpassword=****',
                     'Command-line arg: rpcuser=****',
                     'Command-line arg: torpassword=****',
                     'Config file arg: regtest="1"',
                     'Config file arg: [regtest] server="1"',
                 ],
                 unexpected_msgs=[
                     'alice:f7efda5c189b999524f151318c0c86$d5b51b3beffbc0',
                     '127.1.1.1',
                     'secret-rpcuser',
                     'secret-torpassword',
                 ]):
             self.start_node(0, extra_args=[
                 '-addnode=some.node',
                 '-rpcauth=alice:f7efda5c189b999524f151318c0c86$d5b51b3beffbc0',
                 '-rpcbind=127.1.1.1',
                 '-rpcpassword=',
                 '-rpcuser=secret-rpcuser',
                 '-torpassword=secret-torpassword',
             ])
         self.stop_node(0)
 
     def run_test(self):
         self.stop_node(0)
 
         self.test_log_buffer()
         self.test_args_log()
 
         self.test_config_file_parser()
 
         # Remove the -datadir argument so it doesn't override the config file
         self.nodes[0].remove_default_args(["-datadir"])
 
         default_data_dir = self.nodes[0].datadir
         new_data_dir = os.path.join(default_data_dir, 'newdatadir')
         new_data_dir_2 = os.path.join(default_data_dir, 'newdatadir2')
 
         # Check that using -datadir argument on non-existent directory fails
         self.nodes[0].datadir = new_data_dir
         self.nodes[0].assert_start_raises_init_error(
             ['-datadir=' + new_data_dir], 'Error: Specified data directory "' + new_data_dir + '" does not exist.')
 
         # Check that using non-existent datadir in conf file fails
         conf_file = os.path.join(default_data_dir, "bitcoin.conf")
 
         # datadir needs to be set before [regtest] section
         conf_file_contents = open(conf_file, encoding='utf8').read()
         with open(conf_file, 'w', encoding='utf8') as f:
             f.write("datadir=" + new_data_dir + "\n")
             f.write(conf_file_contents)
 
         self.nodes[0].assert_start_raises_init_error(
             ['-conf=' + conf_file], 'Error: Error reading configuration file: specified data directory "' + new_data_dir + '" does not exist.')
 
         # Create the directory and ensure the config file now works
         os.mkdir(new_data_dir)
         self.start_node(0, ['-conf=' + conf_file, '-wallet=w1'])
         self.stop_node(0)
         assert os.path.exists(os.path.join(new_data_dir, 'regtest', 'blocks'))
         if self.is_wallet_compiled():
             assert os.path.exists(os.path.join(
                 new_data_dir, 'regtest', 'wallets', 'w1'))
 
         # Ensure command line argument overrides datadir in conf
         os.mkdir(new_data_dir_2)
         self.nodes[0].datadir = new_data_dir_2
         self.start_node(0, ['-datadir=' + new_data_dir_2,
                             '-conf=' + conf_file, '-wallet=w2'])
-        assert os.path.exists(os.path.join(
-            new_data_dir_2, 'regtest', 'wallets', 'w2'))
+        assert os.path.exists(
+            os.path.join(
+                new_data_dir_2,
+                'regtest',
+                'blocks'))
+        if self.is_wallet_compiled():
+            assert os.path.exists(
+                os.path.join(
+                    new_data_dir_2,
+                    'regtest',
+                    'wallets',
+                    'w2'))
 
 
 if __name__ == '__main__':
     ConfArgsTest().main()
diff --git a/test/functional/feature_notifications.py b/test/functional/feature_notifications.py
index a8bad79458..595c9fbe95 100755
--- a/test/functional/feature_notifications.py
+++ b/test/functional/feature_notifications.py
@@ -1,120 +1,122 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 The Bitcoin Core developers
 # Copyright (c) 2018 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the -alertnotify, -blocknotify and -walletnotify options."""
 import os
 
+from test_framework.address import ADDRESS_BCHREG_UNSPENDABLE
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, connect_nodes_bi, wait_until
 
 FORK_WARNING_MESSAGE = "Warning: Large-work fork detected, forking after block {}"
 
 
 class NotificationsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
 
-    def skip_test_if_missing_module(self):
-        self.skip_if_no_wallet()
-
     def setup_network(self):
         self.alertnotify_dir = os.path.join(self.options.tmpdir, "alertnotify")
         self.blocknotify_dir = os.path.join(self.options.tmpdir, "blocknotify")
         self.walletnotify_dir = os.path.join(
             self.options.tmpdir, "walletnotify")
         os.mkdir(self.alertnotify_dir)
         os.mkdir(self.blocknotify_dir)
         os.mkdir(self.walletnotify_dir)
 
         # -alertnotify and -blocknotify on node0, walletnotify on node1
-        self.extra_args = [["-blockversion=2",
-                            "-alertnotify=echo > {}".format(
-                                os.path.join(self.alertnotify_dir, '%s')),
-                            "-blocknotify=echo > {}".format(os.path.join(self.blocknotify_dir, '%s'))],
-                           ["-blockversion=211",
-                            "-rescan",
-                            "-walletnotify=echo > {}".format(os.path.join(self.walletnotify_dir, '%s'))]]
+        self.extra_args = [["-alertnotify=echo > {}".format(
+            os.path.join(self.alertnotify_dir, '%s')),
+            "-blocknotify=echo > {}".format(os.path.join(self.blocknotify_dir, '%s'))],
+            ["-blockversion=211",
+             "-rescan",
+             "-walletnotify=echo > {}".format(os.path.join(self.walletnotify_dir, '%s'))]]
         super().setup_network()
 
     def run_test(self):
         self.log.info("test -blocknotify")
         block_count = 10
-        blocks = self.nodes[1].generate(block_count)
+        blocks = self.nodes[1].generatetoaddress(
+            block_count,
+            self.nodes[1].getnewaddress() if self.is_wallet_compiled()
+            else ADDRESS_BCHREG_UNSPENDABLE
+        )
 
         # wait at most 10 seconds for expected number of files before reading
         # the content
         wait_until(
             lambda: len(
                 os.listdir(
                     self.blocknotify_dir)) == block_count,
             timeout=10)
 
         # directory content should equal the generated blocks hashes
         assert_equal(sorted(blocks), sorted(os.listdir(self.blocknotify_dir)))
 
-        self.log.info("test -walletnotify")
-        # wait at most 10 seconds for expected number of files before reading
-        # the content
-        wait_until(
-            lambda: len(
-                os.listdir(
-                    self.walletnotify_dir)) == block_count,
-            timeout=10)
-
-        # directory content should equal the generated transaction hashes
-        txids_rpc = list(
-            map(lambda t: t['txid'], self.nodes[1].listtransactions("*", block_count)))
-        assert_equal(
-            sorted(txids_rpc), sorted(
-                os.listdir(
-                    self.walletnotify_dir)))
-        for tx_file in os.listdir(self.walletnotify_dir):
-            os.remove(os.path.join(self.walletnotify_dir, tx_file))
-
-        self.log.info("test -walletnotify after rescan")
-        # restart node to rescan to force wallet notifications
-        self.restart_node(1)
-        connect_nodes_bi(self.nodes[0], self.nodes[1])
-
-        wait_until(
-            lambda: len(
-                os.listdir(
-                    self.walletnotify_dir)) == block_count,
-            timeout=10)
-
-        # directory content should equal the generated transaction hashes
-        txids_rpc = list(
-            map(lambda t: t['txid'], self.nodes[1].listtransactions("*", block_count)))
-        assert_equal(
-            sorted(txids_rpc), sorted(
-                os.listdir(
-                    self.walletnotify_dir)))
+        if self.is_wallet_compiled():
+            self.log.info("test -walletnotify")
+            # wait at most 10 seconds for expected number of files before reading
+            # the content
+            wait_until(
+                lambda: len(
+                    os.listdir(
+                        self.walletnotify_dir)) == block_count,
+                timeout=10)
+
+            # directory content should equal the generated transaction hashes
+            txids_rpc = list(
+                map(lambda t: t['txid'], self.nodes[1].listtransactions("*", block_count)))
+            assert_equal(
+                sorted(txids_rpc), sorted(
+                    os.listdir(
+                        self.walletnotify_dir)))
+            for tx_file in os.listdir(self.walletnotify_dir):
+                os.remove(os.path.join(self.walletnotify_dir, tx_file))
+
+            self.log.info("test -walletnotify after rescan")
+            # restart node to rescan to force wallet notifications
+            self.restart_node(1)
+            connect_nodes_bi(self.nodes[0], self.nodes[1])
+
+            wait_until(
+                lambda: len(
+                    os.listdir(
+                        self.walletnotify_dir)) == block_count,
+                timeout=10)
+
+            # directory content should equal the generated transaction hashes
+            txids_rpc = list(
+                map(lambda t: t['txid'], self.nodes[1].listtransactions("*", block_count)))
+            assert_equal(
+                sorted(txids_rpc), sorted(
+                    os.listdir(
+                        self.walletnotify_dir)))
 
         # Create an invalid chain and ensure the node warns.
         self.log.info("test -alertnotify for forked chain")
         fork_block = self.nodes[0].getbestblockhash()
-        self.nodes[0].generate(1)
+        self.nodes[0].generatetoaddress(1, ADDRESS_BCHREG_UNSPENDABLE)
         invalid_block = self.nodes[0].getbestblockhash()
-        self.nodes[0].generate(7)
+        self.nodes[0].generatetoaddress(7, ADDRESS_BCHREG_UNSPENDABLE)
 
         # Invalidate a large branch, which should trigger an alert.
         self.nodes[0].invalidateblock(invalid_block)
 
         # Give bitcoind 10 seconds to write the alert notification
         wait_until(lambda: len(os.listdir(self.alertnotify_dir)), timeout=10)
 
         # The notification command is unable to properly handle the spaces on
         # windows. Skip the content check in this case.
         if os.name != 'nt':
             assert FORK_WARNING_MESSAGE.format(
                 fork_block) in os.listdir(self.alertnotify_dir)
 
         for notify_file in os.listdir(self.alertnotify_dir):
             os.remove(os.path.join(self.alertnotify_dir, notify_file))
 
 
 if __name__ == '__main__':
     NotificationsTest().main()
diff --git a/test/functional/interface_bitcoin_cli.py b/test/functional/interface_bitcoin_cli.py
index 8b1a0495a3..2712788abb 100755
--- a/test/functional/interface_bitcoin_cli.py
+++ b/test/functional/interface_bitcoin_cli.py
@@ -1,99 +1,104 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test bitcoin-cli"""
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_process_error,
     get_auth_cookie,
 )
 
 
 class TestBitcoinCli(BitcoinTestFramework):
 
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
     def skip_test_if_missing_module(self):
-        self.skip_if_no_wallet()
         self.skip_if_no_cli()
 
     def run_test(self):
         """Main test logic"""
 
         cli_response = self.nodes[0].cli("-version").send_cli()
         assert "Bitcoin ABC RPC client version" in cli_response
 
         self.log.info(
             "Compare responses from gewalletinfo RPC and `bitcoin-cli getwalletinfo`")
-        cli_response = self.nodes[0].cli.getwalletinfo()
-        rpc_response = self.nodes[0].getwalletinfo()
-        assert_equal(cli_response, rpc_response)
+        if self.is_wallet_compiled():
+            cli_response = self.nodes[0].cli.getwalletinfo()
+            rpc_response = self.nodes[0].getwalletinfo()
+            assert_equal(cli_response, rpc_response)
 
         self.log.info(
             "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)
 
         user, password = get_auth_cookie(self.nodes[0].datadir, self.chain)
 
         self.log.info("Test -stdinrpcpass option")
         assert_equal(0, self.nodes[0].cli(
             '-rpcuser={}'.format(user), '-stdinrpcpass', input=password).getblockcount())
         assert_raises_process_error(1, "Incorrect rpcuser or rpcpassword", self.nodes[0].cli(
             '-rpcuser={}'.format(user), '-stdinrpcpass', input="foo").echo)
 
         self.log.info("Test -stdin and -stdinrpcpass")
         assert_equal(["foo", "bar"], self.nodes[0].cli('-rpcuser={}'.format(user),
                                                        '-stdin', '-stdinrpcpass', input=password + "\nfoo\nbar").echo())
         assert_raises_process_error(1, "Incorrect rpcuser or rpcpassword", self.nodes[0].cli(
             '-rpcuser={}'.format(user), '-stdin', '-stdinrpcpass', 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)
 
         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)
 
         self.log.info("Make sure that -getinfo with arguments fails")
         assert_raises_process_error(
             1, "-getinfo takes no arguments", self.nodes[0].cli('-getinfo').help)
 
         self.log.info(
             "Compare responses from `bitcoin-cli -getinfo` and the RPCs data is retrieved from.")
         cli_get_info = self.nodes[0].cli('-getinfo').send_cli()
-        wallet_info = self.nodes[0].getwalletinfo()
+        if self.is_wallet_compiled():
+            wallet_info = self.nodes[0].getwalletinfo()
         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['protocolversion'],
                      network_info['protocolversion'])
-        assert_equal(cli_get_info['walletversion'],
-                     wallet_info['walletversion'])
-        assert_equal(cli_get_info['balance'], wallet_info['balance'])
+        if self.is_wallet_compiled():
+            assert_equal(cli_get_info['walletversion'],
+                         wallet_info['walletversion'])
+            assert_equal(cli_get_info['balance'], wallet_info['balance'])
         assert_equal(cli_get_info['blocks'], blockchain_info['blocks'])
         assert_equal(cli_get_info['timeoffset'], network_info['timeoffset'])
         assert_equal(cli_get_info['connections'], 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['testnet'],
                      blockchain_info['chain'] == "test")
-        assert_equal(cli_get_info['balance'], wallet_info['balance'])
-        assert_equal(cli_get_info['keypoololdest'],
-                     wallet_info['keypoololdest'])
-        assert_equal(cli_get_info['keypoolsize'], wallet_info['keypoolsize'])
-        assert_equal(cli_get_info['paytxfee'], wallet_info['paytxfee'])
-        assert_equal(cli_get_info['relayfee'], network_info['relayfee'])
-        # unlocked_until is not tested because the wallet is not encrypted
+        if self.is_wallet_compiled():
+            assert_equal(cli_get_info['balance'], wallet_info['balance'])
+            assert_equal(cli_get_info['keypoololdest'],
+                         wallet_info['keypoololdest'])
+            assert_equal(
+                cli_get_info['keypoolsize'],
+                wallet_info['keypoolsize'])
+            assert_equal(cli_get_info['paytxfee'], wallet_info['paytxfee'])
+            assert_equal(cli_get_info['relayfee'], network_info['relayfee'])
+            # unlocked_until is not tested because the wallet is not encrypted
 
 
 if __name__ == '__main__':
     TestBitcoinCli().main()
diff --git a/test/functional/interface_zmq.py b/test/functional/interface_zmq.py
index bc668d3261..a13b69603a 100755
--- a/test/functional/interface_zmq.py
+++ b/test/functional/interface_zmq.py
@@ -1,136 +1,138 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the ZMQ notification interface."""
 import struct
 from io import BytesIO
 
+from test_framework.address import ADDRESS_BCHREG_UNSPENDABLE
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.messages import CTransaction
 from test_framework.util import (
     assert_equal,
     hash256,
 )
 
 ADDRESS = "tcp://127.0.0.1:28332"
 
 
 class ZMQSubscriber:
     def __init__(self, socket, topic):
         self.sequence = 0
         self.socket = socket
         self.topic = topic
 
         import zmq
         self.socket.setsockopt(zmq.SUBSCRIBE, self.topic)
 
     def receive(self):
         topic, body, seq = self.socket.recv_multipart()
         # Topic should match the subscriber topic.
         assert_equal(topic, self.topic)
         # Sequence should be incremental.
         assert_equal(struct.unpack('<I', seq)[-1], self.sequence)
         self.sequence += 1
         return body
 
 
 class ZMQTest (BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_py3_zmq()
         self.skip_if_no_bitcoind_zmq()
-        self.skip_if_no_wallet()
 
     def setup_nodes(self):
         import zmq
 
         # Initialize ZMQ context and socket.
         # All messages are received in the same socket which means that this
         # test fails if the publishing order changes.
         # Note that the publishing order is not defined in the documentation and
         # is subject to change.
         self.zmq_context = zmq.Context()
         socket = self.zmq_context.socket(zmq.SUB)
         socket.set(zmq.RCVTIMEO, 60000)
         socket.connect(ADDRESS)
 
         # Subscribe to all available topics.
         self.hashblock = ZMQSubscriber(socket, b"hashblock")
         self.hashtx = ZMQSubscriber(socket, b"hashtx")
         self.rawblock = ZMQSubscriber(socket, b"rawblock")
         self.rawtx = ZMQSubscriber(socket, b"rawtx")
 
         self.extra_args = [
             ["-zmqpub{}={}".format(sub.topic.decode(), ADDRESS) for sub in [
                 self.hashblock, self.hashtx, self.rawblock, self.rawtx]],
             [],
         ]
         self.add_nodes(self.num_nodes, self.extra_args)
         self.start_nodes()
         self.import_deterministic_coinbase_privkeys()
 
     def run_test(self):
         try:
             self._zmq_test()
         finally:
             # Destroy the ZMQ context.
             self.log.debug("Destroying ZMQ context")
             self.zmq_context.destroy(linger=None)
 
     def _zmq_test(self):
         num_blocks = 5
         self.log.info(
             "Generate {0} blocks (and {0} coinbase txes)".format(num_blocks))
-        genhashes = self.nodes[0].generate(num_blocks)
+        genhashes = self.nodes[0].generatetoaddress(
+            num_blocks, ADDRESS_BCHREG_UNSPENDABLE)
         self.sync_all()
 
         for x in range(num_blocks):
             # Should receive the coinbase txid.
             txid = self.hashtx.receive()
 
             # Should receive the coinbase raw transaction.
             hex = self.rawtx.receive()
             tx = CTransaction()
             tx.deserialize(BytesIO(hex))
             tx.calc_sha256()
             assert_equal(tx.hash, txid.hex())
 
             # Should receive the generated block hash.
             hash = self.hashblock.receive().hex()
             assert_equal(genhashes[x], hash)
             # The block should only have the coinbase txid.
             assert_equal([txid.hex()], self.nodes[1].getblock(hash)["tx"])
 
             # Should receive the generated raw block.
             block = self.rawblock.receive()
             assert_equal(genhashes[x], hash256(block[:80]).hex())
 
-        self.log.info("Wait for tx from second node")
-        payment_txid = self.nodes[1].sendtoaddress(
-            self.nodes[0].getnewaddress(), 1.0)
-        self.sync_all()
+        if self.is_wallet_compiled():
+            self.log.info("Wait for tx from second node")
+            payment_txid = self.nodes[1].sendtoaddress(
+                self.nodes[0].getnewaddress(), 1.0)
+            self.sync_all()
 
-        # Should receive the broadcasted txid.
-        txid = self.hashtx.receive()
-        assert_equal(payment_txid, txid.hex())
+            # Should receive the broadcasted txid.
+            txid = self.hashtx.receive()
+            assert_equal(payment_txid, txid.hex())
 
-        # Should receive the broadcasted raw transaction.
-        hex = self.rawtx.receive()
-        assert_equal(payment_txid, hash256(hex).hex())
+            # Should receive the broadcasted raw transaction.
+            hex = self.rawtx.receive()
+            assert_equal(payment_txid, hash256(hex).hex())
 
         self.log.info("Test the getzmqnotifications RPC")
         assert_equal(self.nodes[0].getzmqnotifications(), [
             {"type": "pubhashblock", "address": ADDRESS},
             {"type": "pubhashtx", "address": ADDRESS},
             {"type": "pubrawblock", "address": ADDRESS},
             {"type": "pubrawtx", "address": ADDRESS},
         ])
 
         assert_equal(self.nodes[1].getzmqnotifications(), [])
 
 
 if __name__ == '__main__':
     ZMQTest().main()
diff --git a/test/functional/test_framework/address.py b/test/functional/test_framework/address.py
index 9270c14a9c..f03b298b5b 100644
--- a/test/functional/test_framework/address.py
+++ b/test/functional/test_framework/address.py
@@ -1,66 +1,68 @@
 #!/usr/bin/env python3
 # Copyright (c) 2016-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Encode and decode BASE58, P2PKH and P2SH addresses."""
 
 from .script import CScript, hash160, hash256
 from .util import hex_str_to_bytes
 
+ADDRESS_BCHREG_UNSPENDABLE = 'bchreg:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqha9s37tt'
+
 chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
 
 def byte_to_base58(b, version):
     result = ''
     str = b.hex()
     str = chr(version).encode('latin-1').hex() + str
     checksum = hash256(hex_str_to_bytes(str)).hex()
     str += checksum[:8]
     value = int('0x' + str, 0)
     while value > 0:
         result = chars[value % 58] + result
         value //= 58
     while (str[:2] == '00'):
         result = chars[0] + result
         str = str[2:]
     return result
 
 # TODO: def base58_decode
 
 
 def keyhash_to_p2pkh(hash, main=False):
     assert (len(hash) == 20)
     version = 0 if main else 111
     return byte_to_base58(hash, version)
 
 
 def scripthash_to_p2sh(hash, main=False):
     assert (len(hash) == 20)
     version = 5 if main else 196
     return byte_to_base58(hash, version)
 
 
 def key_to_p2pkh(key, main=False):
     key = check_key(key)
     return keyhash_to_p2pkh(hash160(key), main)
 
 
 def script_to_p2sh(script, main=False):
     script = check_script(script)
     return scripthash_to_p2sh(hash160(script), main)
 
 
 def check_key(key):
     if (isinstance(key, str)):
         key = hex_str_to_bytes(key)  # Assuming this is hex string
     if (isinstance(key, bytes) and (len(key) == 33 or len(key) == 65)):
         return key
     assert False
 
 
 def check_script(script):
     if (isinstance(script, str)):
         script = hex_str_to_bytes(script)  # Assuming this is hex string
     if (isinstance(script, bytes) or isinstance(script, CScript)):
         return script
     assert False