diff --git a/src/wallet/ismine.cpp b/src/wallet/ismine.cpp
index 8511b8449..8f645a09e 100644
--- a/src/wallet/ismine.cpp
+++ b/src/wallet/ismine.cpp
@@ -1,134 +1,133 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/ismine.h>
 
 #include <key.h>
-#include <keystore.h>
 #include <script/script.h>
 #include <script/sign.h>
-#include <script/standard.h>
+#include <wallet/wallet.h>
 
 typedef std::vector<uint8_t> valtype;
 
 namespace {
 
 /**
  * This is an enum that tracks the execution context of a script, similar to
  * SigVersion in script/interpreter. It is separate however because we want to
  * distinguish between top-level scriptPubKey execution and P2SH redeemScript
  * execution (a distinction that has no impact on consensus rules).
  */
 enum class IsMineSigVersion {
     TOP = 0,  //! scriptPubKey execution
     P2SH = 1, //! P2SH redeemScript
 };
 
 /**
  * This is an internal representation of isminetype + invalidity.
  * Its order is significant, as we return the max of all explored
  * possibilities.
  */
 enum class IsMineResult {
     NO = 0,         //! Not ours
     WATCH_ONLY = 1, //! Included in watch-only balance
     SPENDABLE = 2,  //! Included in all balances
     INVALID = 3,    //! Not spendable by anyone (P2SH inside P2SH)
 };
 
-bool HaveKeys(const std::vector<valtype> &pubkeys, const CKeyStore &keystore) {
+bool HaveKeys(const std::vector<valtype> &pubkeys, const CWallet &keystore) {
     for (const valtype &pubkey : pubkeys) {
         CKeyID keyID = CPubKey(pubkey).GetID();
         if (!keystore.HaveKey(keyID)) {
             return false;
         }
     }
     return true;
 }
 
-IsMineResult IsMineInner(const CKeyStore &keystore, const CScript &scriptPubKey,
+IsMineResult IsMineInner(const CWallet &keystore, const CScript &scriptPubKey,
                          IsMineSigVersion sigversion) {
     IsMineResult ret = IsMineResult::NO;
 
     std::vector<valtype> vSolutions;
     txnouttype whichType = Solver(scriptPubKey, vSolutions);
 
     CKeyID keyID;
     switch (whichType) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             break;
         case TX_PUBKEY:
             keyID = CPubKey(vSolutions[0]).GetID();
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_PUBKEYHASH:
             keyID = CKeyID(uint160(vSolutions[0]));
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_SCRIPTHASH: {
             if (sigversion != IsMineSigVersion::TOP) {
                 // P2SH inside P2SH is invalid.
                 return IsMineResult::INVALID;
             }
             CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
             CScript subscript;
             if (keystore.GetCScript(scriptID, subscript)) {
                 ret = std::max(ret, IsMineInner(keystore, subscript,
                                                 IsMineSigVersion::P2SH));
             }
             break;
         }
         case TX_MULTISIG: {
             // Never treat bare multisig outputs as ours (they can still be made
             // watchonly-though)
             if (sigversion == IsMineSigVersion::TOP) {
                 break;
             }
 
             // Only consider transactions "mine" if we own ALL the keys
             // involved. Multi-signature transactions that are partially owned
             // (somebody else has a key that can spend them) enable
             // spend-out-from-under-you attacks, especially in shared-wallet
             // situations.
             std::vector<valtype> keys(vSolutions.begin() + 1,
                                       vSolutions.begin() + vSolutions.size() -
                                           1);
             if (HaveKeys(keys, keystore)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         }
     }
 
     if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
         ret = std::max(ret, IsMineResult::WATCH_ONLY);
     }
     return ret;
 }
 
 } // namespace
 
-isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey) {
+isminetype IsMine(const CWallet &keystore, const CScript &scriptPubKey) {
     switch (IsMineInner(keystore, scriptPubKey, IsMineSigVersion::TOP)) {
         case IsMineResult::INVALID:
         case IsMineResult::NO:
             return ISMINE_NO;
         case IsMineResult::WATCH_ONLY:
             return ISMINE_WATCH_ONLY;
         case IsMineResult::SPENDABLE:
             return ISMINE_SPENDABLE;
     }
     assert(false);
 }
 
-isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest) {
+isminetype IsMine(const CWallet &keystore, const CTxDestination &dest) {
     CScript script = GetScriptForDestination(dest);
     return IsMine(keystore, script);
 }
diff --git a/src/wallet/ismine.h b/src/wallet/ismine.h
index 9eae2df66..138218fc2 100644
--- a/src/wallet/ismine.h
+++ b/src/wallet/ismine.h
@@ -1,46 +1,46 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_WALLET_ISMINE_H
 #define BITCOIN_WALLET_ISMINE_H
 
 #include <script/standard.h>
 
 #include <bitset>
 #include <cstdint>
 
-class CKeyStore;
+class CWallet;
 class CScript;
 
 /** IsMine() return codes */
 enum isminetype : unsigned int {
     ISMINE_NO = 0,
     ISMINE_WATCH_ONLY = 1 << 0,
     ISMINE_SPENDABLE = 1 << 1,
     ISMINE_ALL = ISMINE_WATCH_ONLY | ISMINE_SPENDABLE,
     ISMINE_ENUM_ELEMENTS,
 };
 
 /** used for bitflags of isminetype */
 typedef uint8_t isminefilter;
 
-isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey);
-isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest);
+isminetype IsMine(const CWallet &wallet, const CScript &scriptPubKey);
+isminetype IsMine(const CWallet &wallet, const CTxDestination &dest);
 
 /**
  * Cachable amount subdivided into watchonly and spendable parts.
  */
 struct CachableAmount {
     // NO and ALL are never (supposed to be) cached
     std::bitset<ISMINE_ENUM_ELEMENTS> m_cached;
     Amount m_value[ISMINE_ENUM_ELEMENTS];
     inline void Reset() { m_cached.reset(); }
     void Set(isminefilter filter, Amount value) {
         m_cached.set(filter);
         m_value[filter] = value;
     }
 };
 
 #endif // BITCOIN_WALLET_ISMINE_H
diff --git a/src/wallet/test/ismine_tests.cpp b/src/wallet/test/ismine_tests.cpp
index 91bdaad7e..e88774a20 100644
--- a/src/wallet/test/ismine_tests.cpp
+++ b/src/wallet/test/ismine_tests.cpp
@@ -1,208 +1,231 @@
 // 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.
 
+#include <chainparams.h>
 #include <key.h>
-#include <keystore.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/standard.h>
 #include <wallet/ismine.h>
+#include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(ismine_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(ismine_standard) {
     CKey keys[2];
     CPubKey pubkeys[2];
     for (int i = 0; i < 2; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CKey uncompressedKey;
     uncompressedKey.MakeNewKey(false);
     CPubKey uncompressedPubkey = uncompressedKey.GetPubKey();
+    std::unique_ptr<interfaces::Chain> chain = interfaces::MakeChain();
 
     CScript scriptPubKey;
     isminetype result;
 
     // P2PK compressed
     {
-        CBasicKeyStore keystore;
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
         scriptPubKey = GetScriptForRawPubKey(pubkeys[0]);
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PK uncompressed
     {
-        CBasicKeyStore keystore;
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
         scriptPubKey = GetScriptForRawPubKey(uncompressedPubkey);
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PKH compressed
     {
-        CBasicKeyStore keystore;
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
         scriptPubKey = GetScriptForDestination(PKHash(pubkeys[0]));
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PKH uncompressed
     {
-        CBasicKeyStore keystore;
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
         scriptPubKey = GetScriptForDestination(PKHash(uncompressedPubkey));
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2SH
     {
-        CBasicKeyStore keystore;
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
 
         CScript redeemScript = GetScriptForDestination(PKHash(pubkeys[0]));
         scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore does not have redeemScript or key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript but no key
         keystore.AddCScript(redeemScript);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript and key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // (P2PKH inside) P2SH inside P2SH (invalid)
     {
-        CBasicKeyStore keystore;
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
 
         CScript redeemscript_inner =
             GetScriptForDestination(PKHash(pubkeys[0]));
         CScript redeemscript =
             GetScriptForDestination(ScriptHash(redeemscript_inner));
         scriptPubKey = GetScriptForDestination(ScriptHash(redeemscript));
 
-        keystore.AddCScript(redeemscript);
-        keystore.AddCScript(redeemscript_inner);
-        keystore.AddCScript(scriptPubKey);
-        keystore.AddKey(keys[0]);
+        BOOST_CHECK(keystore.AddCScript(redeemscript));
+        BOOST_CHECK(keystore.AddCScript(redeemscript_inner));
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // scriptPubKey multisig
     {
-        CBasicKeyStore keystore;
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
 
         scriptPubKey =
             GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
 
         // Keystore does not have any keys
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 1/2 keys
         keystore.AddKey(uncompressedKey);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 2/2 keys
         keystore.AddKey(keys[1]);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 2/2 keys and the script
         keystore.AddCScript(scriptPubKey);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // P2SH multisig
     {
-        CBasicKeyStore keystore;
-        keystore.AddKey(uncompressedKey);
-        keystore.AddKey(keys[1]);
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(uncompressedKey));
+        BOOST_CHECK(keystore.AddKey(keys[1]));
 
         CScript redeemScript =
             GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
         scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore has no redeemScript
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript
-        keystore.AddCScript(redeemScript);
+        BOOST_CHECK(keystore.AddCScript(redeemScript));
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // OP_RETURN
     {
-        CBasicKeyStore keystore;
-        keystore.AddKey(keys[0]);
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
 
         scriptPubKey.clear();
         scriptPubKey << OP_RETURN << ToByteVector(pubkeys[0]);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // Nonstandard
     {
-        CBasicKeyStore keystore;
-        keystore.AddKey(keys[0]);
+        CWallet keystore(Params(), chain.get(), WalletLocation(),
+                         WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
 
         scriptPubKey.clear();
         scriptPubKey << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 941dd8c94..38e846249 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -1,76 +1,77 @@
 #!/usr/bin/env bash
 #
 # 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.
 #
 # Check for circular dependencies
 
 export LC_ALL=C
 
 EXPECTED_CIRCULAR_DEPENDENCIES=(
     "index/txindex -> validation -> index/txindex"
     "qt/addresstablemodel -> qt/walletmodel -> qt/addresstablemodel"
     "qt/bantablemodel -> qt/clientmodel -> qt/bantablemodel"
     "qt/bitcoingui -> qt/utilitydialog -> qt/bitcoingui"
     "qt/bitcoingui -> qt/walletframe -> qt/bitcoingui"
     "qt/bitcoingui -> qt/walletview -> qt/bitcoingui"
     "qt/clientmodel -> qt/peertablemodel -> qt/clientmodel"
     "qt/paymentserver -> qt/walletmodel -> qt/paymentserver"
     "qt/recentrequeststablemodel -> qt/walletmodel -> qt/recentrequeststablemodel"
     "qt/transactiontablemodel -> qt/walletmodel -> qt/transactiontablemodel"
     "qt/walletmodel -> qt/walletmodeltransaction -> qt/walletmodel"
     "txmempool -> validation -> txmempool"
     "wallet/coincontrol -> wallet/wallet -> wallet/coincontrol"
     "wallet/fees -> wallet/wallet -> wallet/fees"
     "wallet/rpcwallet -> wallet/wallet -> wallet/rpcwallet"
     "wallet/wallet -> wallet/walletdb -> wallet/wallet"
+    "wallet/ismine -> wallet/wallet -> wallet/ismine"
     "txmempool -> validation -> validationinterface -> txmempool"
     "avalanche -> validation -> avalanche"
     "chainparams -> protocol -> chainparams"
     "chainparamsbase -> util/system -> chainparamsbase"
     "minerfund -> validation -> minerfund"
     "script/scriptcache -> validation -> script/scriptcache"
     "seeder/bitcoin -> seeder/db -> seeder/bitcoin"
     "chainparams -> protocol -> config -> chainparams"
 )
 
 EXIT_CODE=0
 
 CIRCULAR_DEPENDENCIES=()
 
 IFS=$'\n'
 for CIRC in $(cd src && ../contrib/devtools/circular-dependencies.py {*,*/*,*/*/*}.{h,cpp} | sed -e 's/^Circular dependency: //'); do
     CIRCULAR_DEPENDENCIES+=("$CIRC")
     IS_EXPECTED_CIRC=0
     for EXPECTED_CIRC in "${EXPECTED_CIRCULAR_DEPENDENCIES[@]}"; do
         if [[ "${CIRC}" == "${EXPECTED_CIRC}" ]]; then
             IS_EXPECTED_CIRC=1
             break
         fi
     done
     if [[ ${IS_EXPECTED_CIRC} == 0 ]]; then
         echo "A new circular dependency in the form of \"${CIRC}\" appears to have been introduced."
         echo
         EXIT_CODE=1
     fi
 done
 
 for EXPECTED_CIRC in "${EXPECTED_CIRCULAR_DEPENDENCIES[@]}"; do
     IS_PRESENT_EXPECTED_CIRC=0
     for CIRC in "${CIRCULAR_DEPENDENCIES[@]}"; do
         if [[ "${CIRC}" == "${EXPECTED_CIRC}" ]]; then
             IS_PRESENT_EXPECTED_CIRC=1
             break
         fi
     done
     if [[ ${IS_PRESENT_EXPECTED_CIRC} == 0 ]]; then
         echo "Good job! The circular dependency \"${EXPECTED_CIRC}\" is no longer present."
         echo "Please remove it from EXPECTED_CIRCULAR_DEPENDENCIES in $0"
         echo "to make sure this circular dependency is not accidentally reintroduced."
         echo
         EXIT_CODE=1
     fi
 done
 
 exit ${EXIT_CODE}