diff --git a/test/functional/test_framework/wallet_util.py b/test/functional/test_framework/wallet_util.py
new file mode 100755
--- /dev/null
+++ b/test/functional/test_framework/wallet_util.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# Copyright (c) 2018 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Useful util functions for testing the wallet"""
+from collections import namedtuple
+
+from test_framework.address import (
+    key_to_p2pkh,
+    script_to_p2sh,
+)
+from test_framework.script import (
+    CScript,
+    OP_2,
+    OP_3,
+    OP_CHECKMULTISIG,
+    OP_CHECKSIG,
+    OP_DUP,
+    OP_EQUAL,
+    OP_EQUALVERIFY,
+    OP_HASH160,
+    hash160,
+)
+from test_framework.util import hex_str_to_bytes
+
+Key = namedtuple('Key', ['privkey',
+                         'pubkey',
+                         'p2pkh_script',
+                         'p2pkh_addr'])
+
+Multisig = namedtuple('Multisig', ['privkeys',
+                                   'pubkeys',
+                                   'p2sh_script',
+                                   'p2sh_addr',
+                                   'redeem_script'])
+
+
+def get_key(node):
+    """Generate a fresh key on node
+
+    Returns a named tuple of privkey, pubkey and all address and scripts."""
+    addr = node.getnewaddress()
+    pubkey = node.getaddressinfo(addr)['pubkey']
+    pkh = hash160(hex_str_to_bytes(pubkey))
+    return Key(privkey=node.dumpprivkey(addr),
+               pubkey=pubkey,
+               p2pkh_script=CScript(
+                   [OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG]).hex(),
+               p2pkh_addr=key_to_p2pkh(pubkey))
+
+
+def get_multisig(node):
+    """Generate a fresh 2-of-3 multisig on node
+
+    Returns a named tuple of privkeys, pubkeys and all address and scripts."""
+    addrs = []
+    pubkeys = []
+    for _ in range(3):
+        addr = node.getaddressinfo(node.getnewaddress())
+        addrs.append(addr['address'])
+        pubkeys.append(addr['pubkey'])
+    script_code = CScript([OP_2] + [hex_str_to_bytes(pubkey)
+                                    for pubkey in pubkeys] + [OP_3, OP_CHECKMULTISIG])
+    return Multisig(privkeys=[node.dumpprivkey(addr) for addr in addrs],
+                    pubkeys=pubkeys,
+                    p2sh_script=CScript(
+                        [OP_HASH160, hash160(script_code), OP_EQUAL]).hex(),
+                    p2sh_addr=script_to_p2sh(script_code),
+                    redeem_script=script_code.hex())
+
+
+def test_address(node, address, **kwargs):
+    """Get address info for `address` and test whether the returned values are as expected."""
+    addr_info = node.getaddressinfo(address)
+    for key, value in kwargs.items():
+        if value is None:
+            if key in addr_info.keys():
+                raise AssertionError(
+                    "key {} unexpectedly returned in getaddressinfo.".format(key))
+        elif addr_info[key] != value:
+            raise AssertionError(
+                "key {} value {} did not match expected value {}".format(
+                    key, addr_info[key], value))
diff --git a/test/functional/wallet_import_with_label.py b/test/functional/wallet_import_with_label.py
--- a/test/functional/wallet_import_with_label.py
+++ b/test/functional/wallet_import_with_label.py
@@ -21,10 +21,8 @@
 )
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    hex_str_to_bytes,
-)
+from test_framework.util import hex_str_to_bytes
+from test_framework.wallet_util import test_address
 
 
 class ImportWithLabel(BitcoinTestFramework):
@@ -45,11 +43,11 @@
         address = self.nodes[0].getnewaddress()
         label = "Test Label"
         self.nodes[1].importaddress(address, label)
-        address_assert = self.nodes[1].getaddressinfo(address)
-
-        assert_equal(address_assert["iswatchonly"], True)
-        assert_equal(address_assert["ismine"], False)
-        assert_equal(address_assert["label"], label)
+        test_address(self.nodes[1],
+                     address,
+                     iswatchonly=True,
+                     ismine=False,
+                     label=label)
 
         self.log.info(
             "Import the watch-only address's private key without a "
@@ -58,7 +56,9 @@
         priv_key = self.nodes[0].dumpprivkey(address)
         self.nodes[1].importprivkey(priv_key)
 
-        assert_equal(label, self.nodes[1].getaddressinfo(address)["label"])
+        test_address(self.nodes[1],
+                     address,
+                     label=label)
 
         self.log.info(
             "Test importaddress without label and importprivkey with label."
@@ -66,11 +66,11 @@
         self.log.info("Import a watch-only address without a label.")
         address2 = self.nodes[0].getnewaddress()
         self.nodes[1].importaddress(address2)
-        address_assert2 = self.nodes[1].getaddressinfo(address2)
-
-        assert_equal(address_assert2["iswatchonly"], True)
-        assert_equal(address_assert2["ismine"], False)
-        assert_equal(address_assert2["label"], "")
+        test_address(self.nodes[1],
+                     address2,
+                     iswatchonly=True,
+                     ismine=False,
+                     label="")
 
         self.log.info(
             "Import the watch-only address's private key with a "
@@ -80,7 +80,9 @@
         label2 = "Test Label 2"
         self.nodes[1].importprivkey(priv_key2, label2)
 
-        assert_equal(label2, self.nodes[1].getaddressinfo(address2)["label"])
+        test_address(self.nodes[1],
+                     address2,
+                     label=label2)
 
         self.log.info(
             "Test importaddress with label and importprivkey with label.")
@@ -88,11 +90,11 @@
         address3 = self.nodes[0].getnewaddress()
         label3_addr = "Test Label 3 for importaddress"
         self.nodes[1].importaddress(address3, label3_addr)
-        address_assert3 = self.nodes[1].getaddressinfo(address3)
-
-        assert_equal(address_assert3["iswatchonly"], True)
-        assert_equal(address_assert3["ismine"], False)
-        assert_equal(address_assert3["label"], label3_addr)
+        test_address(self.nodes[1],
+                     address3,
+                     iswatchonly=True,
+                     ismine=False,
+                     label=label3_addr)
 
         self.log.info(
             "Import the watch-only address's private key with a "
@@ -102,9 +104,9 @@
         label3_priv = "Test Label 3 for importprivkey"
         self.nodes[1].importprivkey(priv_key3, label3_priv)
 
-        assert_equal(
-            label3_priv,
-            self.nodes[1].getaddressinfo(address3)["label"])
+        test_address(self.nodes[1],
+                     address3,
+                     label=label3_priv)
 
         self.log.info(
             "Test importprivkey won't label new dests with the same "
@@ -114,15 +116,12 @@
         address4 = self.nodes[0].getnewaddress()
         label4_addr = "Test Label 4 for importaddress"
         self.nodes[1].importaddress(address4, label4_addr)
-        address_assert4 = self.nodes[1].getaddressinfo(address4)
-
-        assert_equal(address_assert4["iswatchonly"], True)
-        assert_equal(address_assert4["ismine"], False)
-        assert_equal(address_assert4["label"], label4_addr)
-
-        self.log.info("Asserts address has no embedded field with dests.")
-
-        assert_equal(address_assert4.get("embedded"), None)
+        test_address(self.nodes[1],
+                     address4,
+                     iswatchonly=True,
+                     ismine=False,
+                     label=label4_addr,
+                     embedded=None)
 
         self.log.info(
             "Import the watch-only address's private key without a "
@@ -146,16 +145,15 @@
             "keys": [priv_key4],
         }])
 
-        p2shaddrinfo = self.nodes[1].getaddressinfo(p2shaddr4)
-
-        assert p2shaddrinfo.get("embedded")
-
-        embedded_addrinfo = self.nodes[1].getaddressinfo(
-            p2shaddrinfo["embedded"]["address"]
-        )
+        test_address(self.nodes[1],
+                     p2shaddr4,
+                     label="")
 
-        assert_equal(p2shaddrinfo["label"], "")
-        assert_equal(embedded_addrinfo["label"], label4_addr)
+        embedded_addr = self.nodes[1].getaddressinfo(
+            p2shaddr4)['embedded']['address']
+        test_address(self.nodes[1],
+                     embedded_addr,
+                     label=label4_addr)
 
         self.stop_nodes()
 
diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py
--- a/test/functional/wallet_importmulti.py
+++ b/test/functional/wallet_importmulti.py
@@ -14,43 +14,22 @@
   success, and (if unsuccessful) test the error code and error message returned.
 - `test_address()` is called to call getaddressinfo for an address on node1
   and test the values returned."""
-from collections import namedtuple
 
-from test_framework.address import (
-    key_to_p2pkh,
-    script_to_p2sh,
-)
 from test_framework.script import (
     CScript,
-    OP_2,
-    OP_3,
-    OP_CHECKMULTISIG,
-    OP_CHECKSIG,
-    OP_DUP,
-    OP_EQUAL,
-    OP_EQUALVERIFY,
-    OP_HASH160,
     OP_NOP,
-    hash160,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
-    hex_str_to_bytes,
 )
-
-Key = namedtuple('Key', ['privkey',
-                         'pubkey',
-                         'p2pkh_script',
-                         'p2pkh_addr'])
-
-Multisig = namedtuple('Multisig', ['privkeys',
-                                   'pubkeys',
-                                   'p2sh_script',
-                                   'p2sh_addr',
-                                   'redeem_script'])
+from test_framework.wallet_util import (
+    get_key,
+    get_multisig,
+    test_address,
+)
 
 
 class ImportMultiTest(BitcoinTestFramework):
@@ -64,38 +43,6 @@
     def setup_network(self, split=False):
         self.setup_nodes()
 
-    def get_key(self):
-        """Generate a fresh key on node0
-
-        Returns a named tuple of privkey, pubkey and all address and scripts."""
-        addr = self.nodes[0].getnewaddress()
-        pubkey = self.nodes[0].getaddressinfo(addr)['pubkey']
-        pkh = hash160(hex_str_to_bytes(pubkey))
-        return Key(privkey=self.nodes[0].dumpprivkey(addr),
-                   pubkey=pubkey,
-                   p2pkh_script=CScript(
-                       [OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG]).hex(),
-                   p2pkh_addr=key_to_p2pkh(pubkey))
-
-    def get_multisig(self):
-        """Generate a fresh 2-of-3 multisig on node0
-
-        Returns a named tuple of privkeys, pubkeys and all address and scripts."""
-        addrs = []
-        pubkeys = []
-        for _ in range(3):
-            addr = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress())
-            addrs.append(addr['address'])
-            pubkeys.append(addr['pubkey'])
-        script_code = CScript([OP_2] + [hex_str_to_bytes(pubkey)
-                                        for pubkey in pubkeys] + [OP_3, OP_CHECKMULTISIG])
-        return Multisig(privkeys=[self.nodes[0].dumpprivkey(addr) for addr in addrs],
-                        pubkeys=pubkeys,
-                        p2sh_script=CScript(
-                            [OP_HASH160, hash160(script_code), OP_EQUAL]).hex(),
-                        p2sh_addr=script_to_p2sh(script_code),
-                        redeem_script=script_code.hex())
-
     def test_importmulti(self, req, success, error_code=None,
                          error_message=None, warnings=[]):
         """Run importmulti and assert success"""
@@ -112,19 +59,6 @@
             assert_equal(result[0]['error']['code'], error_code)
             assert_equal(result[0]['error']['message'], error_message)
 
-    def test_address(self, address, **kwargs):
-        """Get address info for `address` and test whether the returned values are as expected."""
-        addr_info = self.nodes[1].getaddressinfo(address)
-        for key, value in kwargs.items():
-            if value is None:
-                if key in addr_info.keys():
-                    raise AssertionError(
-                        "key {} unexpectedly returned in getaddressinfo.".format(key))
-            elif addr_info[key] != value:
-                raise AssertionError(
-                    "key {} value {} did not match expected value {}".format(
-                        key, addr_info[key], value))
-
     def run_test(self):
         self.log.info("Mining blocks...")
         self.nodes[0].generate(1)
@@ -150,15 +84,16 @@
 
         # Bitcoin Address (implicit non-internal)
         self.log.info("Should import an address")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now"},
                               success=True)
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          timestamp=timestamp,
-                          ischange=False)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     timestamp=timestamp,
+                     ischange=False)
         watchonly_address = key.p2pkh_addr
         watchonly_timestamp = timestamp
 
@@ -171,21 +106,22 @@
 
         # ScriptPubKey + internal
         self.log.info("Should import a scriptPubKey with internal flag")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "internal": True},
                               success=True)
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          timestamp=timestamp,
-                          ischange=True)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     timestamp=timestamp,
+                     ischange=True)
 
         # ScriptPubKey + internal + label
         self.log.info(
             "Should not allow a label to be specified when internal is true")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "internal": True,
@@ -198,72 +134,77 @@
         self.log.info(
             "Should not import a nonstandard scriptPubKey without internal flag")
         nonstandardScriptPubKey = key.p2pkh_script + CScript([OP_NOP]).hex()
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey,
                                "timestamp": "now"},
                               success=False,
                               error_code=-8,
                               error_message='Internal must be set to true for nonstandard scriptPubKey imports.')
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=False,
-                          ismine=False,
-                          timestamp=None)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=False,
+                     ismine=False,
+                     timestamp=None)
 
         # Address + Public key + !Internal(explicit)
         self.log.info("Should import an address with public key")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "pubkeys": [key.pubkey],
                                "internal": False},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     timestamp=timestamp)
 
         # ScriptPubKey + Public key + internal
         self.log.info(
             "Should import a scriptPubKey with internal and with public key")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "pubkeys": [key.pubkey],
                                "internal": True},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     timestamp=timestamp)
 
         # Nonstandard scriptPubKey + Public key + !internal
         self.log.info(
             "Should not import a nonstandard scriptPubKey without internal and with public key")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey,
                                "timestamp": "now",
                                "pubkeys": [key.pubkey]},
                               success=False,
                               error_code=-8,
                               error_message='Internal must be set to true for nonstandard scriptPubKey imports.')
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=False,
-                          ismine=False,
-                          timestamp=None)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=False,
+                     ismine=False,
+                     timestamp=None)
 
         # Address + Private key + !watchonly
         self.log.info("Should import an address with private key")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "keys": [key.privkey]},
                               success=True)
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=False,
-                          ismine=True,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=False,
+                     ismine=True,
+                     timestamp=timestamp)
 
         self.log.info(
             "Should not import an address with private key if is already imported")
@@ -277,49 +218,52 @@
         # Address + Private key + watchonly
         self.log.info(
             "Should import an address with private key and with watchonly")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "keys": [key.privkey],
                                "watchonly": True},
                               success=True,
                               warnings=["All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."])
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=False,
-                          ismine=True,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=False,
+                     ismine=True,
+                     timestamp=timestamp)
 
         # ScriptPubKey + Private key + internal
         self.log.info(
             "Should import a scriptPubKey with internal and with private key")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "keys": [key.privkey],
                                "internal": True},
                               success=True)
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=False,
-                          ismine=True,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=False,
+                     ismine=True,
+                     timestamp=timestamp)
 
         # Nonstandard scriptPubKey + Private key + !internal
         self.log.info(
             "Should not import a nonstandard scriptPubKey without internal and with private key")
-        key = self.get_key()
+        key = get_key(self.nodes[0])
         self.test_importmulti({"scriptPubKey": nonstandardScriptPubKey,
                                "timestamp": "now",
                                "keys": [key.privkey]},
                               success=False,
                               error_code=-8,
                               error_message='Internal must be set to true for nonstandard scriptPubKey imports.')
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=False,
-                          ismine=False,
-                          timestamp=None)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=False,
+                     ismine=False,
+                     timestamp=None)
 
         # P2SH address
-        multisig = self.get_multisig()
+        multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
@@ -330,17 +274,18 @@
         self.test_importmulti({"scriptPubKey": {"address": multisig.p2sh_addr},
                                "timestamp": "now"},
                               success=True)
-        self.test_address(multisig.p2sh_addr,
-                          isscript=True,
-                          iswatchonly=True,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     multisig.p2sh_addr,
+                     isscript=True,
+                     iswatchonly=True,
+                     timestamp=timestamp)
         p2shunspent = self.nodes[1].listunspent(
             0, 999999, [multisig.p2sh_addr])[0]
         assert_equal(p2shunspent['spendable'], False)
         assert_equal(p2shunspent['solvable'], False)
 
         # P2SH + Redeem script
-        multisig = self.get_multisig()
+        multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
@@ -353,12 +298,8 @@
                                "redeemscript": multisig.redeem_script},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(
-            multisig.p2sh_addr,
-            timestamp=timestamp,
-            iswatchonly=True,
-            ismine=False,
-            solvable=True)
+        test_address(self.nodes[1],
+                     multisig.p2sh_addr, timestamp=timestamp, iswatchonly=True, ismine=False, solvable=True)
 
         p2shunspent = self.nodes[1].listunspent(
             0, 999999, [multisig.p2sh_addr])[0]
@@ -366,7 +307,7 @@
         assert_equal(p2shunspent['solvable'], True)
 
         # P2SH + Redeem script + Private Keys + !Watchonly
-        multisig = self.get_multisig()
+        multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
@@ -381,11 +322,12 @@
                                "keys": multisig.privkeys[0:2]},
                               success=True,
                               warnings=["Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(multisig.p2sh_addr,
-                          timestamp=timestamp,
-                          ismine=False,
-                          iswatchonly=True,
-                          solvable=True)
+        test_address(self.nodes[1],
+                     multisig.p2sh_addr,
+                     timestamp=timestamp,
+                     ismine=False,
+                     iswatchonly=True,
+                     solvable=True)
 
         p2shunspent = self.nodes[1].listunspent(
             0, 999999, [multisig.p2sh_addr])[0]
@@ -393,7 +335,7 @@
         assert_equal(p2shunspent['solvable'], True)
 
         # P2SH + Redeem script + Private Keys + Watchonly
-        multisig = self.get_multisig()
+        multisig = get_multisig(self.nodes[0])
         self.nodes[1].generate(100)
         self.nodes[1].sendtoaddress(multisig.p2sh_addr, 10.00)
         self.nodes[1].generate(1)
@@ -408,77 +350,82 @@
                                "keys": multisig.privkeys[0:2],
                                "watchonly": True},
                               success=True)
-        self.test_address(multisig.p2sh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          solvable=True,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     multisig.p2sh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     solvable=True,
+                     timestamp=timestamp)
 
         # Address + Public key + !Internal + Wrong pubkey
         self.log.info(
             "Should not import an address with the wrong public key as non-solvable")
-        key = self.get_key()
-        wrong_key = self.get_key().pubkey
+        key = get_key(self.nodes[0])
+        wrong_key = get_key(self.nodes[0]).pubkey
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "pubkeys": [wrong_key]},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          solvable=False,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     solvable=False,
+                     timestamp=timestamp)
 
         # ScriptPubKey + Public key + internal + Wrong pubkey
         self.log.info(
             "Should import a scriptPubKey with internal and with a wrong public key as non-solvable")
-        key = self.get_key()
-        wrong_key = self.get_key().pubkey
+        key = get_key(self.nodes[0])
+        wrong_key = get_key(self.nodes[0]).pubkey
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "pubkeys": [wrong_key],
                                "internal": True},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          solvable=False,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     solvable=False,
+                     timestamp=timestamp)
 
         # Address + Private key + !watchonly + Wrong private key
         self.log.info(
             "Should import an address with a wrong private key as non-solvable")
-        key = self.get_key()
-        wrong_privkey = self.get_key().privkey
+        key = get_key(self.nodes[0])
+        wrong_privkey = get_key(self.nodes[0]).privkey
         self.test_importmulti({"scriptPubKey": {"address": key.p2pkh_addr},
                                "timestamp": "now",
                                "keys": [wrong_privkey]},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          solvable=False,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     solvable=False,
+                     timestamp=timestamp)
 
         # ScriptPubKey + Private key + internal + Wrong private key
         self.log.info(
             "Should import a scriptPubKey with internal and with a wrong private key as non-solvable")
-        key = self.get_key()
-        wrong_privkey = self.get_key().privkey
+        key = get_key(self.nodes[0])
+        wrong_privkey = get_key(self.nodes[0]).privkey
         self.test_importmulti({"scriptPubKey": key.p2pkh_script,
                                "timestamp": "now",
                                "keys": [wrong_privkey],
                                "internal": True},
                               success=True,
                               warnings=["Importing as non-solvable: some required keys are missing. If this is intentional, don't provide any keys, pubkeys or redeemscript.", "Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."])
-        self.test_address(key.p2pkh_addr,
-                          iswatchonly=True,
-                          ismine=False,
-                          solvable=False,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     key.p2pkh_addr,
+                     iswatchonly=True,
+                     ismine=False,
+                     solvable=False,
+                     timestamp=timestamp)
 
         # Importing existing watch only address with new timestamp should
         # replace saved timestamp.
@@ -487,20 +434,22 @@
         self.test_importmulti({"scriptPubKey": {"address": watchonly_address},
                                "timestamp": "now"},
                               success=True)
-        self.test_address(watchonly_address,
-                          iswatchonly=True,
-                          ismine=False,
-                          timestamp=timestamp)
+        test_address(self.nodes[1],
+                     watchonly_address,
+                     iswatchonly=True,
+                     ismine=False,
+                     timestamp=timestamp)
         watchonly_timestamp = timestamp
 
         # restart nodes to check for proper serialization/deserialization of
         # watch only address
         self.stop_nodes()
         self.start_nodes()
-        self.test_address(watchonly_address,
-                          iswatchonly=True,
-                          ismine=False,
-                          timestamp=watchonly_timestamp)
+        test_address(self.nodes[1],
+                     watchonly_address,
+                     iswatchonly=True,
+                     ismine=False,
+                     timestamp=watchonly_timestamp)
 
         # Bad or missing timestamps
         self.log.info("Should throw on invalid or missing timestamp values")