diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -61,8 +61,8 @@
     };
 
     //! Construct wallet tx struct.
-    static WalletTx MakeWalletTx(CWallet &wallet, const CWalletTx &wtx)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+    static WalletTx MakeWalletTx(interfaces::Chain::Lock &locked_chain,
+                                 CWallet &wallet, const CWalletTx &wtx) {
         WalletTx result;
         result.tx = wtx.tx;
         result.txin_is_mine.reserve(wtx.tx->vin.size());
@@ -81,7 +81,7 @@
                     ? IsMine(wallet, result.txout_address.back())
                     : ISMINE_NO);
         }
-        result.credit = wtx.GetCredit(ISMINE_ALL);
+        result.credit = wtx.GetCredit(locked_chain, ISMINE_ALL);
         result.debit = wtx.GetDebit(ISMINE_ALL);
         result.change = wtx.GetChange();
         result.time = wtx.GetTxTime();
@@ -91,33 +91,39 @@
     }
 
     //! Construct wallet tx status struct.
-    static WalletTxStatus MakeWalletTxStatus(const CWalletTx &wtx)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+    static WalletTxStatus
+    MakeWalletTxStatus(interfaces::Chain::Lock &locked_chain,
+                       const CWalletTx &wtx) {
+        // Temporary, for CheckFinalTx below. Removed in upcoming commit.
+        LockAnnotation lock(::cs_main);
+
         WalletTxStatus result;
         CBlockIndex *block = LookupBlockIndex(wtx.hashBlock);
         result.block_height =
             (block ? block->nHeight : std::numeric_limits<int>::max());
-        result.blocks_to_maturity = wtx.GetBlocksToMaturity();
-        result.depth_in_main_chain = wtx.GetDepthInMainChain();
+        result.blocks_to_maturity = wtx.GetBlocksToMaturity(locked_chain);
+        result.depth_in_main_chain = wtx.GetDepthInMainChain(locked_chain);
         result.time_received = wtx.nTimeReceived;
         result.lock_time = wtx.tx->nLockTime;
         result.is_final = CheckFinalTx(*wtx.tx);
-        result.is_trusted = wtx.IsTrusted();
+        result.is_trusted = wtx.IsTrusted(locked_chain);
         result.is_abandoned = wtx.isAbandoned();
         result.is_coinbase = wtx.IsCoinBase();
-        result.is_in_main_chain = wtx.IsInMainChain();
+        result.is_in_main_chain = wtx.IsInMainChain(locked_chain);
         return result;
     }
 
     //! Construct wallet TxOut struct.
-    static WalletTxOut MakeWalletTxOut(CWallet &wallet, const CWalletTx &wtx,
+    static WalletTxOut MakeWalletTxOut(interfaces::Chain::Lock &locked_chain,
+                                       CWallet &wallet, const CWalletTx &wtx,
                                        int n, int depth)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main, wallet.cs_wallet) {
+        EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
         WalletTxOut result;
         result.txout = wtx.tx->vout[n];
         result.time = wtx.GetTxTime();
         result.depth_in_main_chain = depth;
-        result.is_spent = wallet.IsSpent(COutPoint(wtx.GetId(), n));
+        result.is_spent =
+            wallet.IsSpent(locked_chain, COutPoint(wtx.GetId(), n));
         return result;
     }
 
@@ -245,9 +251,9 @@
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             auto pending = std::make_unique<PendingWalletTxImpl>(m_wallet);
-            if (!m_wallet.CreateTransaction(recipients, pending->m_tx,
-                                            pending->m_key, fee, change_pos,
-                                            fail_reason, coin_control, sign)) {
+            if (!m_wallet.CreateTransaction(
+                    *locked_chain, recipients, pending->m_tx, pending->m_key,
+                    fee, change_pos, fail_reason, coin_control, sign)) {
                 return {};
             }
             return pending;
@@ -258,7 +264,7 @@
         bool abandonTransaction(const TxId &txid) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
-            return m_wallet.AbandonTransaction(txid);
+            return m_wallet.AbandonTransaction(*locked_chain, txid);
         }
         CTransactionRef getTx(const TxId &txid) override {
             auto locked_chain = m_wallet.chain().lock();
@@ -274,7 +280,7 @@
             LOCK(m_wallet.cs_wallet);
             auto mi = m_wallet.mapWallet.find(txid);
             if (mi != m_wallet.mapWallet.end()) {
-                return MakeWalletTx(m_wallet, mi->second);
+                return MakeWalletTx(*locked_chain, m_wallet, mi->second);
             }
             return {};
         }
@@ -284,7 +290,8 @@
             std::vector<WalletTx> result;
             result.reserve(m_wallet.mapWallet.size());
             for (const auto &entry : m_wallet.mapWallet) {
-                result.emplace_back(MakeWalletTx(m_wallet, entry.second));
+                result.emplace_back(
+                    MakeWalletTx(*locked_chain, m_wallet, entry.second));
             }
             return result;
         }
@@ -305,7 +312,7 @@
             }
             num_blocks = ::chainActive.Height();
             block_time = ::chainActive.Tip()->GetBlockTime();
-            tx_status = MakeWalletTxStatus(mi->second);
+            tx_status = MakeWalletTxStatus(*locked_chain, mi->second);
             return true;
         }
         WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status,
@@ -319,8 +326,8 @@
                 num_blocks = ::chainActive.Height();
                 in_mempool = mi->second.InMempool();
                 order_form = mi->second.vOrderForm;
-                tx_status = MakeWalletTxStatus(mi->second);
-                return MakeWalletTx(m_wallet, mi->second);
+                tx_status = MakeWalletTxStatus(*locked_chain, mi->second);
+                return MakeWalletTx(*locked_chain, m_wallet, mi->second);
             }
             return {};
         }
@@ -382,12 +389,13 @@
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             CoinsList result;
-            for (const auto &entry : m_wallet.ListCoins()) {
+            for (const auto &entry : m_wallet.ListCoins(*locked_chain)) {
                 auto &group = result[entry.first];
                 for (const auto &coin : entry.second) {
                     group.emplace_back(COutPoint(coin.tx->GetId(), coin.i),
-                                       MakeWalletTxOut(m_wallet, *coin.tx,
-                                                       coin.i, coin.nDepth));
+                                       MakeWalletTxOut(*locked_chain, m_wallet,
+                                                       *coin.tx, coin.i,
+                                                       coin.nDepth));
                 }
             }
             return result;
@@ -402,10 +410,11 @@
                 result.emplace_back();
                 auto it = m_wallet.mapWallet.find(output.GetTxId());
                 if (it != m_wallet.mapWallet.end()) {
-                    int depth = it->second.GetDepthInMainChain();
+                    int depth = it->second.GetDepthInMainChain(*locked_chain);
                     if (depth >= 0) {
-                        result.back() = MakeWalletTxOut(m_wallet, it->second,
-                                                        output.GetN(), depth);
+                        result.back() =
+                            MakeWalletTxOut(*locked_chain, m_wallet, it->second,
+                                            output.GetN(), depth);
                     }
                 }
             }
diff --git a/src/threadsafety.h b/src/threadsafety.h
--- a/src/threadsafety.h
+++ b/src/threadsafety.h
@@ -61,4 +61,12 @@
 #define ASSERT_EXCLUSIVE_LOCK(...)
 #endif // __GNUC__
 
+// Utility class for indicating to compiler thread analysis that a mutex is
+// locked (when it couldn't be determined otherwise).
+struct SCOPED_LOCKABLE LockAnnotation {
+    template <typename Mutex>
+    explicit LockAnnotation(Mutex &mutex) EXCLUSIVE_LOCK_FUNCTION(mutex) {}
+    ~LockAnnotation() UNLOCK_FUNCTION() {}
+};
+
 #endif // BITCOIN_THREADSAFETY_H
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -921,7 +921,7 @@
 
     std::map<CTxDestination, int64_t> mapKeyBirth;
     const std::map<CKeyID, int64_t> &mapKeyPool = pwallet->GetAllReserveKeys();
-    pwallet->GetKeyBirthTimes(mapKeyBirth);
+    pwallet->GetKeyBirthTimes(*locked_chain, mapKeyBirth);
 
     std::set<CScriptID> scripts = pwallet->GetCScripts();
     // TODO: include scripts in GetKeyBirthTimes() output instead of separate
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -116,9 +116,10 @@
     }
 }
 
-static void WalletTxToJSON(interfaces::Chain &chain, const CWalletTx &wtx,
-                           UniValue &entry) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
-    int confirms = wtx.GetDepthInMainChain();
+static void WalletTxToJSON(interfaces::Chain &chain,
+                           interfaces::Chain::Lock &locked_chain,
+                           const CWalletTx &wtx, UniValue &entry) {
+    int confirms = wtx.GetDepthInMainChain(locked_chain);
     entry.pushKV("confirmations", confirms);
     if (wtx.IsCoinBase()) {
         entry.pushKV("generated", true);
@@ -129,7 +130,7 @@
         entry.pushKV("blocktime",
                      LookupBlockIndex(wtx.hashBlock)->GetBlockTime());
     } else {
-        entry.pushKV("trusted", wtx.IsTrusted());
+        entry.pushKV("trusted", wtx.IsTrusted(locked_chain));
     }
     uint256 hash = wtx.GetId();
     entry.pushKV("txid", hash.GetHex());
@@ -559,7 +560,8 @@
     return ret;
 }
 
-static CTransactionRef SendMoney(CWallet *const pwallet,
+static CTransactionRef SendMoney(interfaces::Chain::Lock &locked_chain,
+                                 CWallet *const pwallet,
                                  const CTxDestination &address, Amount nValue,
                                  bool fSubtractFeeFromAmount,
                                  mapValue_t mapValue, std::string fromAccount) {
@@ -594,8 +596,9 @@
 
     CCoinControl coinControl;
     CTransactionRef tx;
-    if (!pwallet->CreateTransaction(vecSend, tx, reservekey, nFeeRequired,
-                                    nChangePosRet, strError, coinControl)) {
+    if (!pwallet->CreateTransaction(locked_chain, vecSend, tx, reservekey,
+                                    nFeeRequired, nChangePosRet, strError,
+                                    coinControl)) {
         if (!fSubtractFeeFromAmount && nValue + nFeeRequired > curBalance) {
             strError = strprintf("Error: This transaction requires a "
                                  "transaction fee of at least %s",
@@ -704,7 +707,7 @@
     EnsureWalletIsUnlocked(pwallet);
 
     CTransactionRef tx =
-        SendMoney(pwallet, dest, nAmount, fSubtractFeeFromAmount,
+        SendMoney(*locked_chain, pwallet, dest, nAmount, fSubtractFeeFromAmount,
                   std::move(mapValue), {} /* fromAccount */);
     return tx->GetId().GetHex();
 }
@@ -752,7 +755,8 @@
     LOCK(pwallet->cs_wallet);
 
     UniValue jsonGroupings(UniValue::VARR);
-    std::map<CTxDestination, Amount> balances = pwallet->GetAddressBalances();
+    std::map<CTxDestination, Amount> balances =
+        pwallet->GetAddressBalances(*locked_chain);
     for (const std::set<CTxDestination> &grouping :
          pwallet->GetAddressGroupings()) {
         UniValue jsonGrouping(UniValue::VARR);
@@ -894,6 +898,9 @@
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
+    // Temporary, for ContextualCheckTransactionForCurrentBlock below. Removed
+    // in upcoming commit.
+    LockAnnotation lock(::cs_main);
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -929,7 +936,7 @@
 
         for (const CTxOut &txout : wtx.tx->vout) {
             if (txout.scriptPubKey == scriptPubKey) {
-                if (wtx.GetDepthInMainChain() >= nMinDepth) {
+                if (wtx.GetDepthInMainChain(*locked_chain) >= nMinDepth) {
                     nAmount += txout.nValue;
                 }
             }
@@ -994,6 +1001,9 @@
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
+    // Temporary, for ContextualCheckTransactionForCurrentBlock below. Removed
+    // in upcoming commit.
+    LockAnnotation lock(::cs_main);
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -1022,7 +1032,7 @@
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) &&
                 IsMine(*pwallet, address) && setAddress.count(address)) {
-                if (wtx.GetDepthInMainChain() >= nMinDepth) {
+                if (wtx.GetDepthInMainChain(*locked_chain) >= nMinDepth) {
                     nAmount += txout.nValue;
                 }
             }
@@ -1386,7 +1396,7 @@
                            "Account has insufficient funds");
     }
 
-    CTransactionRef tx = SendMoney(pwallet, dest, nAmount, false,
+    CTransactionRef tx = SendMoney(*locked_chain, pwallet, dest, nAmount, false,
                                    std::move(mapValue), std::move(label));
     return tx->GetId().GetHex();
 }
@@ -1648,9 +1658,9 @@
     std::string strFailReason;
     CTransactionRef tx;
     CCoinControl coinControl;
-    bool fCreated =
-        pwallet->CreateTransaction(vecSend, tx, keyChange, nFeeRequired,
-                                   nChangePosRet, strFailReason, coinControl);
+    bool fCreated = pwallet->CreateTransaction(
+        *locked_chain, vecSend, tx, keyChange, nFeeRequired, nChangePosRet,
+        strFailReason, coinControl);
     if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);
     }
@@ -1766,9 +1776,14 @@
     tallyitem() {}
 };
 
-static UniValue ListReceived(const Config &config, CWallet *const pwallet,
-                             const UniValue &params, bool by_label)
-    EXCLUSIVE_LOCKS_REQUIRED(cs_main, pwallet->cs_wallet) {
+static UniValue
+ListReceived(const Config &config, interfaces::Chain::Lock &locked_chain,
+             CWallet *const pwallet, const UniValue &params, bool by_label)
+    EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
+    // Temporary, for ContextualCheckTransactionForCurrentBlock below. Removed
+    // in upcoming commit.
+    LockAnnotation lock(::cs_main);
+
     // Minimum confirmations
     int nMinDepth = 1;
     if (!params[0].isNull()) {
@@ -1811,7 +1826,7 @@
             continue;
         }
 
-        int nDepth = wtx.GetDepthInMainChain();
+        int nDepth = wtx.GetDepthInMainChain(locked_chain);
         if (nDepth < nMinDepth) {
             continue;
         }
@@ -1987,7 +2002,7 @@
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
-    return ListReceived(config, pwallet, request.params, false);
+    return ListReceived(config, *locked_chain, pwallet, request.params, false);
 }
 
 static UniValue listreceivedbylabel(const Config &config,
@@ -2055,7 +2070,7 @@
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
-    return ListReceived(config, pwallet, request.params, true);
+    return ListReceived(config, *locked_chain, pwallet, request.params, true);
 }
 
 static void MaybePushAddress(UniValue &entry, const CTxDestination &dest) {
@@ -2075,11 +2090,11 @@
  * @param  ret        The UniValue into which the result is stored.
  * @param  filter     The "is mine" filter bool.
  */
-static void ListTransactions(CWallet *const pwallet, const CWalletTx &wtx,
+static void ListTransactions(interfaces::Chain::Lock &locked_chain,
+                             CWallet *const pwallet, const CWalletTx &wtx,
                              const std::string &strAccount, int nMinDepth,
                              bool fLong, UniValue &ret,
-                             const isminefilter &filter)
-    EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+                             const isminefilter &filter) {
     Amount nFee;
     std::string strSentAccount;
     std::list<COutputEntry> listReceived;
@@ -2112,7 +2127,7 @@
             entry.pushKV("vout", s.vout);
             entry.pushKV("fee", ValueFromAmount(-1 * nFee));
             if (fLong) {
-                WalletTxToJSON(pwallet->chain(), wtx, entry);
+                WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
             }
             entry.pushKV("abandoned", wtx.isAbandoned());
             ret.push_back(entry);
@@ -2120,7 +2135,8 @@
     }
 
     // Received
-    if (listReceived.size() > 0 && wtx.GetDepthInMainChain() >= nMinDepth) {
+    if (listReceived.size() > 0 &&
+        wtx.GetDepthInMainChain(locked_chain) >= nMinDepth) {
         for (const COutputEntry &r : listReceived) {
             std::string account;
             if (pwallet->mapAddressBook.count(r.destination)) {
@@ -2137,9 +2153,9 @@
                 }
                 MaybePushAddress(entry, r.destination);
                 if (wtx.IsCoinBase()) {
-                    if (wtx.GetDepthInMainChain() < 1) {
+                    if (wtx.GetDepthInMainChain(locked_chain) < 1) {
                         entry.pushKV("category", "orphan");
-                    } else if (wtx.IsImmatureCoinBase()) {
+                    } else if (wtx.IsImmatureCoinBase(locked_chain)) {
                         entry.pushKV("category", "immature");
                     } else {
                         entry.pushKV("category", "generate");
@@ -2153,7 +2169,7 @@
                 }
                 entry.pushKV("vout", r.vout);
                 if (fLong) {
-                    WalletTxToJSON(pwallet->chain(), wtx, entry);
+                    WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
                 }
                 ret.push_back(entry);
             }
@@ -2412,7 +2428,8 @@
          it != txOrdered.rend(); ++it) {
         CWalletTx *const pwtx = (*it).second.first;
         if (pwtx != nullptr) {
-            ListTransactions(pwallet, *pwtx, strAccount, 0, true, ret, filter);
+            ListTransactions(*locked_chain, pwallet, *pwtx, strAccount, 0, true,
+                             ret, filter);
         }
         if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
             CAccountingEntry *const pacentry = (*it).second.second;
@@ -2540,8 +2557,8 @@
         std::string strSentAccount;
         std::list<COutputEntry> listReceived;
         std::list<COutputEntry> listSent;
-        int nDepth = wtx.GetDepthInMainChain();
-        if (wtx.IsImmatureCoinBase() || nDepth < 0) {
+        int nDepth = wtx.GetDepthInMainChain(*locked_chain);
+        if (wtx.IsImmatureCoinBase(*locked_chain) || nDepth < 0) {
             continue;
         }
         wtx.GetAmounts(listReceived, listSent, nFee, strSentAccount,
@@ -2744,8 +2761,9 @@
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         CWalletTx tx = pairWtx.second;
 
-        if (depth == -1 || tx.GetDepthInMainChain() < depth) {
-            ListTransactions(pwallet, tx, "*", 0, true, transactions, filter);
+        if (depth == -1 || tx.GetDepthInMainChain(*locked_chain) < depth) {
+            ListTransactions(*locked_chain, pwallet, tx, "*", 0, true,
+                             transactions, filter);
         }
     }
 
@@ -2766,8 +2784,8 @@
                 // We want all transactions regardless of confirmation count to
                 // appear here, even negative confirmation ones, hence the big
                 // negative.
-                ListTransactions(pwallet, it->second, "*", -100000000, true,
-                                 removed, filter);
+                ListTransactions(*locked_chain, pwallet, it->second, "*",
+                                 -100000000, true, removed, filter);
             }
         }
         paltindex = paltindex->pprev;
@@ -2906,7 +2924,7 @@
     }
     const CWalletTx &wtx = it->second;
 
-    Amount nCredit = wtx.GetCredit(filter);
+    Amount nCredit = wtx.GetCredit(*locked_chain, filter);
     Amount nDebit = wtx.GetDebit(filter);
     Amount nNet = nCredit - nDebit;
     Amount nFee = (wtx.IsFromMe(filter) ? wtx.tx->GetValueOut() - nDebit
@@ -2917,10 +2935,11 @@
         entry.pushKV("fee", ValueFromAmount(nFee));
     }
 
-    WalletTxToJSON(pwallet->chain(), wtx, entry);
+    WalletTxToJSON(pwallet->chain(), *locked_chain, wtx, entry);
 
     UniValue details(UniValue::VARR);
-    ListTransactions(pwallet, wtx, "*", 0, false, details, filter);
+    ListTransactions(*locked_chain, pwallet, wtx, "*", 0, false, details,
+                     filter);
     entry.pushKV("details", details);
 
     std::string strHex = EncodeHexTx(*wtx.tx, RPCSerializationFlags());
@@ -2976,7 +2995,7 @@
                            "Invalid or non-wallet transaction id");
     }
 
-    if (!pwallet->AbandonTransaction(txid)) {
+    if (!pwallet->AbandonTransaction(*locked_chain, txid)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not eligible for abandonment");
     }
@@ -3484,7 +3503,7 @@
                                "Invalid parameter, vout index out of bounds");
         }
 
-        if (pwallet->IsSpent(output)) {
+        if (pwallet->IsSpent(*locked_chain, output)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, expected unspent output");
         }
@@ -3988,8 +4007,8 @@
                                              "-walletbroadcast");
     }
 
-    std::vector<uint256> txids =
-        pwallet->ResendWalletTransactionsBefore(GetTime(), g_connman.get());
+    std::vector<uint256> txids = pwallet->ResendWalletTransactionsBefore(
+        *locked_chain, GetTime(), g_connman.get());
     UniValue result(UniValue::VARR);
     for (const uint256 &txid : txids) {
         result.push_back(txid.ToString());
@@ -4173,8 +4192,8 @@
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
-        pwallet->AvailableCoins(vecOutputs, !include_unsafe, nullptr,
-                                nMinimumAmount, nMaximumAmount,
+        pwallet->AvailableCoins(*locked_chain, vecOutputs, !include_unsafe,
+                                nullptr, nMinimumAmount, nMaximumAmount,
                                 nMinimumSumAmount, nMaximumCount, nMinDepth,
                                 nMaxDepth);
     }
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -219,13 +219,13 @@
 
     // Call GetImmatureCredit() once before adding the key to the wallet to
     // cache the current immature credit amount, which is 0.
-    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), Amount::zero());
+    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(*locked_chain), Amount::zero());
 
     // Invalidate the cached value, add the key, and make sure a new immature
     // credit amount is calculated.
     wtx.MarkDirty();
     wallet.AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
-    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), 50 * COIN);
+    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(*locked_chain), 50 * COIN);
 }
 
 static int64_t AddTx(CWallet &wallet, uint32_t lockTime, int64_t mockTime,
@@ -322,8 +322,9 @@
         int changePos = -1;
         std::string error;
         CCoinControl dummy;
-        BOOST_CHECK(wallet->CreateTransaction({recipient}, tx, reservekey, fee,
-                                              changePos, error, dummy));
+        BOOST_CHECK(wallet->CreateTransaction(*m_locked_chain, {recipient}, tx,
+                                              reservekey, fee, changePos, error,
+                                              dummy));
         CValidationState state;
         BOOST_CHECK(wallet->CommitTransaction(tx, {}, {}, {}, reservekey,
                                               nullptr, state));
@@ -357,7 +358,7 @@
     std::map<CTxDestination, std::vector<COutput>> list;
     {
         LOCK2(cs_main, wallet->cs_wallet);
-        list = wallet->ListCoins();
+        list = wallet->ListCoins(*m_locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
     BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(),
@@ -375,7 +376,7 @@
                      false /* subtract fee */});
     {
         LOCK2(cs_main, wallet->cs_wallet);
-        list = wallet->ListCoins();
+        list = wallet->ListCoins(*m_locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
     BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(),
@@ -386,7 +387,7 @@
     {
         LOCK2(cs_main, wallet->cs_wallet);
         std::vector<COutput> available;
-        wallet->AvailableCoins(available);
+        wallet->AvailableCoins(*m_locked_chain, available);
         BOOST_CHECK_EQUAL(available.size(), 2U);
     }
     for (const auto &group : list) {
@@ -398,14 +399,14 @@
     {
         LOCK2(cs_main, wallet->cs_wallet);
         std::vector<COutput> available;
-        wallet->AvailableCoins(available);
+        wallet->AvailableCoins(*m_locked_chain, available);
         BOOST_CHECK_EQUAL(available.size(), 0U);
     }
     // Confirm ListCoins still returns same result as before, despite coins
     // being locked.
     {
         LOCK2(cs_main, wallet->cs_wallet);
-        list = wallet->ListCoins();
+        list = wallet->ListCoins(*m_locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
     BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(),
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -8,6 +8,7 @@
 #define BITCOIN_WALLET_WALLET_H
 
 #include <amount.h>
+#include <interfaces/chain.h>
 #include <outputtype.h>
 #include <primitives/blockhash.h>
 #include <script/ismine.h>
@@ -35,10 +36,6 @@
 #include <utility>
 #include <vector>
 
-namespace interfaces {
-class Chain;
-} // namespace interfaces
-
 bool AddWallet(const std::shared_ptr<CWallet> &wallet);
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet);
 bool HasWallets();
@@ -281,9 +278,9 @@
      *  0  : in memory pool, waiting to be included in a block
      * >=1 : this many blocks deep in the main chain
      */
-    int GetDepthInMainChain() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    bool IsInMainChain() const EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
-        return GetDepthInMainChain() > 0;
+    int GetDepthInMainChain(interfaces::Chain::Lock &locked_chain) const;
+    bool IsInMainChain(interfaces::Chain::Lock &locked_chain) const {
+        return GetDepthInMainChain(locked_chain) > 0;
     }
 
     /**
@@ -291,7 +288,7 @@
      *  0 : is not a coinbase transaction, or is a mature coinbase transaction
      * >0 : is a coinbase transaction which matures in this many blocks
      */
-    int GetBlocksToMaturity() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    int GetBlocksToMaturity(interfaces::Chain::Lock &locked_chain) const;
     bool hashUnset() const {
         return (hashBlock.IsNull() || hashBlock == ABANDON_HASH);
     }
@@ -300,7 +297,7 @@
 
     TxId GetId() const { return tx->GetId(); }
     bool IsCoinBase() const { return tx->IsCoinBase(); }
-    bool IsImmatureCoinBase() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool IsImmatureCoinBase(interfaces::Chain::Lock &locked_chain) const;
 };
 
 // Get the marginal bytes of spending the specified output
@@ -486,21 +483,21 @@
 
     //! filter decides which addresses will count towards the debit
     Amount GetDebit(const isminefilter &filter) const;
-    Amount GetCredit(const isminefilter &filter) const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    Amount GetImmatureCredit(bool fUseCache = true) const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    Amount
+    Amount GetCredit(interfaces::Chain::Lock &locked_chain,
+                     const isminefilter &filter) const;
+    Amount GetImmatureCredit(interfaces::Chain::Lock &locked_chain,
+                             bool fUseCache = true) const;
     // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
     // annotation "EXCLUSIVE_LOCKS_REQUIRED(cs_main, pwallet->cs_wallet)". The
     // annotation "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid
     // having to resolve the issue of member access into incomplete type
     // CWallet.
-    GetAvailableCredit(bool fUseCache = true,
-                       const isminefilter &filter = ISMINE_SPENDABLE) const
-        NO_THREAD_SAFETY_ANALYSIS;
-    Amount GetImmatureWatchOnlyCredit(const bool fUseCache = true) const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    Amount GetAvailableCredit(interfaces::Chain::Lock &locked_chain,
+                              bool fUseCache = true,
+                              const isminefilter &filter = ISMINE_SPENDABLE)
+        const NO_THREAD_SAFETY_ANALYSIS;
+    Amount GetImmatureWatchOnlyCredit(interfaces::Chain::Lock &locked_chain,
+                                      const bool fUseCache = true) const;
     Amount GetChange() const;
 
     // Get the marginal bytes if spending the specified output from this
@@ -523,20 +520,20 @@
     bool IsEquivalentTo(const CWalletTx &tx) const;
 
     bool InMempool() const;
-    bool IsTrusted() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool IsTrusted(interfaces::Chain::Lock &locked_chain) const;
 
     int64_t GetTxTime() const;
 
     // RelayWalletTransaction may only be called if fBroadcastTransactions!
-    bool RelayWalletTransaction(CConnman *connman)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool RelayWalletTransaction(interfaces::Chain::Lock &locked_chain,
+                                CConnman *connman);
 
     /**
      * Pass this transaction to the mempool. Fails if absolute fee exceeds
      * absurd fee.
      */
-    bool AcceptToMemoryPool(const Amount nAbsurdFee, CValidationState &state)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool AcceptToMemoryPool(interfaces::Chain::Lock &locked_chain,
+                            const Amount nAbsurdFee, CValidationState &state);
 
     // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
     // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The annotation
@@ -955,7 +952,8 @@
     /**
      * populate vCoins with vector of available COutputs.
      */
-    void AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe = true,
+    void AvailableCoins(interfaces::Chain::Lock &locked_chain,
+                        std::vector<COutput> &vCoins, bool fOnlySafe = true,
                         const CCoinControl *coinControl = nullptr,
                         const Amount nMinimumAmount = SATOSHI,
                         const Amount nMaximumAmount = MAX_MONEY,
@@ -963,14 +961,15 @@
                         const uint64_t nMaximumCount = 0,
                         const int nMinDepth = 0,
                         const int nMaxDepth = 9999999) const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main, cs_wallet);
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /**
      * Return list of available coins and locked coins grouped by non-change
      * output address.
      */
-    std::map<CTxDestination, std::vector<COutput>> ListCoins() const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main, cs_wallet);
+    std::map<CTxDestination, std::vector<COutput>>
+    ListCoins(interfaces::Chain::Lock &locked_chain) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /**
      * Find non-change parent output.
@@ -993,8 +992,9 @@
                             const CoinSelectionParams &coin_selection_params,
                             bool &bnb_used) const;
 
-    bool IsSpent(const COutPoint &outpoint) const
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main, cs_wallet);
+    bool IsSpent(interfaces::Chain::Lock &locked_chain,
+                 const COutPoint &outpoint) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     std::vector<OutputGroup> GroupOutputs(const std::vector<COutput> &outputs,
                                           bool single_coin) const;
 
@@ -1091,7 +1091,8 @@
                                 const SecureString &strNewWalletPassphrase);
     bool EncryptWallet(const SecureString &strWalletPassphrase);
 
-    void GetKeyBirthTimes(std::map<CTxDestination, int64_t> &mapKeyBirth) const
+    void GetKeyBirthTimes(interfaces::Chain::Lock &locked_chain,
+                          std::map<CTxDestination, int64_t> &mapKeyBirth) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     unsigned int ComputeTimeSmart(const CWalletTx &wtx) const;
 
@@ -1133,9 +1134,9 @@
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     // ResendWalletTransactionsBefore may only be called if
     // fBroadcastTransactions!
-    std::vector<uint256> ResendWalletTransactionsBefore(int64_t nTime,
-                                                        CConnman *connman)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    std::vector<uint256>
+    ResendWalletTransactionsBefore(interfaces::Chain::Lock &locked_chain,
+                                   int64_t nTime, CConnman *connman);
     Amount GetBalance(const isminefilter &filter = ISMINE_SPENDABLE,
                       const int min_depth = 0) const;
     Amount GetUnconfirmedBalance() const;
@@ -1167,7 +1168,8 @@
      * @note passing nChangePosInOut as -1 will result in setting a random
      * position
      */
-    bool CreateTransaction(const std::vector<CRecipient> &vecSend,
+    bool CreateTransaction(interfaces::Chain::Lock &locked_chain,
+                           const std::vector<CRecipient> &vecSend,
                            CTransactionRef &tx, CReserveKey &reservekey,
                            Amount &nFeeRet, int &nChangePosInOut,
                            std::string &strFailReason,
@@ -1244,8 +1246,8 @@
 
     std::set<std::set<CTxDestination>> GetAddressGroupings()
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
-    std::map<CTxDestination, Amount> GetAddressBalances()
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    std::map<CTxDestination, Amount>
+    GetAddressBalances(interfaces::Chain::Lock &locked_chain);
 
     std::set<CTxDestination> GetLabelAddresses(const std::string &label) const;
     void DeleteLabel(const std::string &label);
@@ -1364,7 +1366,8 @@
      * Mark a transaction (and it in-wallet descendants) as abandoned so its
      * inputs may be respent.
      */
-    bool AbandonTransaction(const TxId &txid);
+    bool AbandonTransaction(interfaces::Chain::Lock &locked_chain,
+                            const TxId &txid);
 
     //! Verify wallet naming and perform salvage on the wallet if required
     static bool Verify(const CChainParams &chainParams,
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -672,7 +672,8 @@
 /**
  * Outpoint is spent if any non-conflicted transaction, spends it:
  */
-bool CWallet::IsSpent(const COutPoint &outpoint) const {
+bool CWallet::IsSpent(interfaces::Chain::Lock &locked_chain,
+                      const COutPoint &outpoint) const {
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range =
         mapTxSpends.equal_range(outpoint);
 
@@ -680,7 +681,7 @@
         const TxId &wtxid = it->second;
         std::map<TxId, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
         if (mit != mapWallet.end()) {
-            int depth = mit->second.GetDepthInMainChain();
+            int depth = mit->second.GetDepthInMainChain(locked_chain);
             if (depth > 0 || (depth == 0 && !mit->second.isAbandoned())) {
                 // Spent
                 return true;
@@ -1171,8 +1172,8 @@
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
     const CWalletTx *wtx = GetWalletTx(txid);
-    return wtx && !wtx->isAbandoned() && wtx->GetDepthInMainChain() == 0 &&
-           !wtx->InMempool();
+    return wtx && !wtx->isAbandoned() &&
+           wtx->GetDepthInMainChain(*locked_chain) == 0 && !wtx->InMempool();
 }
 
 void CWallet::MarkInputsDirty(const CTransactionRef &tx) {
@@ -1184,7 +1185,8 @@
     }
 }
 
-bool CWallet::AbandonTransaction(const TxId &txid) {
+bool CWallet::AbandonTransaction(interfaces::Chain::Lock &locked_chain,
+                                 const TxId &txid) {
     // Temporary. Removed in upcoming lock cleanup
     auto locked_chain_recursive = chain().lock();
     LOCK(cs_wallet);
@@ -1198,7 +1200,7 @@
     auto it = mapWallet.find(txid);
     assert(it != mapWallet.end());
     CWalletTx &origtx = it->second;
-    if (origtx.GetDepthInMainChain() != 0 || origtx.InMempool()) {
+    if (origtx.GetDepthInMainChain(locked_chain) != 0 || origtx.InMempool()) {
         return false;
     }
 
@@ -1211,7 +1213,7 @@
         it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
-        int currentconfirm = wtx.GetDepthInMainChain();
+        int currentconfirm = wtx.GetDepthInMainChain(locked_chain);
         // If the orig tx was not in block, none of its spends can be.
         assert(currentconfirm <= 0);
         // If (currentconfirm < 0) {Tx and spends are already conflicted, no
@@ -1278,7 +1280,7 @@
         auto it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
-        int currentconfirm = wtx.GetDepthInMainChain();
+        int currentconfirm = wtx.GetDepthInMainChain(*locked_chain);
         if (conflictconfirms < currentconfirm) {
             // Block is 'more conflicted' than current confirm; update.
             // Mark transaction as conflicted with this block.
@@ -2001,7 +2003,7 @@
         CWalletTx &wtx = item.second;
         assert(wtx.GetId() == wtxid);
 
-        int nDepth = wtx.GetDepthInMainChain();
+        int nDepth = wtx.GetDepthInMainChain(*locked_chain);
 
         if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
             mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
@@ -2012,19 +2014,21 @@
     for (const std::pair<const int64_t, CWalletTx *> &item : mapSorted) {
         CWalletTx &wtx = *(item.second);
         CValidationState state;
-        wtx.AcceptToMemoryPool(maxTxFee, state);
+        wtx.AcceptToMemoryPool(*locked_chain, maxTxFee, state);
     }
 }
 
-bool CWalletTx::RelayWalletTransaction(CConnman *connman) {
+bool CWalletTx::RelayWalletTransaction(interfaces::Chain::Lock &locked_chain,
+                                       CConnman *connman) {
     assert(pwallet->GetBroadcastTransactions());
-    if (IsCoinBase() || isAbandoned() || GetDepthInMainChain() != 0) {
+    if (IsCoinBase() || isAbandoned() ||
+        GetDepthInMainChain(locked_chain) != 0) {
         return false;
     }
 
     CValidationState state;
     // GetDepthInMainChain already catches known conflicts.
-    if (InMempool() || AcceptToMemoryPool(maxTxFee, state)) {
+    if (InMempool() || AcceptToMemoryPool(locked_chain, maxTxFee, state)) {
         pwallet->WalletLogPrintf("Relaying wtx %s\n", GetId().ToString());
         if (connman) {
             CInv inv(MSG_TX, GetId());
@@ -2077,10 +2081,11 @@
     return debit;
 }
 
-Amount CWalletTx::GetCredit(const isminefilter &filter) const {
+Amount CWalletTx::GetCredit(interfaces::Chain::Lock &locked_chain,
+                            const isminefilter &filter) const {
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
-    if (IsImmatureCoinBase()) {
+    if (IsImmatureCoinBase(locked_chain)) {
         return Amount::zero();
     }
 
@@ -2109,8 +2114,9 @@
     return credit;
 }
 
-Amount CWalletTx::GetImmatureCredit(bool fUseCache) const {
-    if (IsImmatureCoinBase() && IsInMainChain()) {
+Amount CWalletTx::GetImmatureCredit(interfaces::Chain::Lock &locked_chain,
+                                    bool fUseCache) const {
+    if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
         if (fUseCache && fImmatureCreditCached) {
             return nImmatureCreditCached;
         }
@@ -2123,7 +2129,8 @@
     return Amount::zero();
 }
 
-Amount CWalletTx::GetAvailableCredit(bool fUseCache,
+Amount CWalletTx::GetAvailableCredit(interfaces::Chain::Lock &locked_chain,
+                                     bool fUseCache,
                                      const isminefilter &filter) const {
     if (pwallet == nullptr) {
         return Amount::zero();
@@ -2131,7 +2138,7 @@
 
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
-    if (IsImmatureCoinBase()) {
+    if (IsImmatureCoinBase(locked_chain)) {
         return Amount::zero();
     }
 
@@ -2153,7 +2160,7 @@
     Amount nCredit = Amount::zero();
     const TxId &txid = GetId();
     for (uint32_t i = 0; i < tx->vout.size(); i++) {
-        if (!pwallet->IsSpent(COutPoint(txid, i))) {
+        if (!pwallet->IsSpent(locked_chain, COutPoint(txid, i))) {
             const CTxOut &txout = tx->vout[i];
             nCredit += pwallet->GetCredit(txout, filter);
             if (!MoneyRange(nCredit)) {
@@ -2170,8 +2177,10 @@
     return nCredit;
 }
 
-Amount CWalletTx::GetImmatureWatchOnlyCredit(const bool fUseCache) const {
-    if (IsImmatureCoinBase() && IsInMainChain()) {
+Amount
+CWalletTx::GetImmatureWatchOnlyCredit(interfaces::Chain::Lock &locked_chain,
+                                      const bool fUseCache) const {
+    if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
         if (fUseCache && fImmatureWatchCreditCached) {
             return nImmatureWatchCreditCached;
         }
@@ -2198,13 +2207,16 @@
     return fInMempool;
 }
 
-bool CWalletTx::IsTrusted() const {
+bool CWalletTx::IsTrusted(interfaces::Chain::Lock &locked_chain) const {
+    // Temporary, for CheckFinalTx below. Removed in upcoming commit.
+    LockAnnotation lock(::cs_main);
+
     // Quick answer in most cases
     if (!CheckFinalTx(*tx)) {
         return false;
     }
 
-    int nDepth = GetDepthInMainChain();
+    int nDepth = GetDepthInMainChain(locked_chain);
     if (nDepth >= 1) {
         return true;
     }
@@ -2256,7 +2268,8 @@
 }
 
 std::vector<uint256>
-CWallet::ResendWalletTransactionsBefore(int64_t nTime, CConnman *connman) {
+CWallet::ResendWalletTransactionsBefore(interfaces::Chain::Lock &locked_chain,
+                                        int64_t nTime, CConnman *connman) {
     std::vector<uint256> result;
 
     LOCK(cs_wallet);
@@ -2275,7 +2288,7 @@
 
     for (const std::pair<const unsigned int, CWalletTx *> &item : mapSorted) {
         CWalletTx &wtx = *item.second;
-        if (wtx.RelayWalletTransaction(connman)) {
+        if (wtx.RelayWalletTransaction(locked_chain, connman)) {
             result.push_back(wtx.GetId());
         }
     }
@@ -2308,8 +2321,8 @@
     auto locked_chain = chain().assumeLocked();
     // Rebroadcast unconfirmed txes older than 5 minutes before the last block
     // was found:
-    std::vector<uint256> relayed =
-        ResendWalletTransactionsBefore(nBestBlockTime - 5 * 60, connman);
+    std::vector<uint256> relayed = ResendWalletTransactionsBefore(
+        *locked_chain, nBestBlockTime - 5 * 60, connman);
     if (!relayed.empty()) {
         WalletLogPrintf("%s: rebroadcast %u unconfirmed transactions\n",
                         __func__, relayed.size());
@@ -2331,8 +2344,9 @@
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
-        if (pcoin->IsTrusted() && pcoin->GetDepthInMainChain() >= min_depth) {
-            nTotal += pcoin->GetAvailableCredit(true, filter);
+        if (pcoin->IsTrusted(*locked_chain) &&
+            pcoin->GetDepthInMainChain(*locked_chain) >= min_depth) {
+            nTotal += pcoin->GetAvailableCredit(*locked_chain, true, filter);
         }
     }
 
@@ -2346,9 +2360,10 @@
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
-        if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 &&
+        if (!pcoin->IsTrusted(*locked_chain) &&
+            pcoin->GetDepthInMainChain(*locked_chain) == 0 &&
             pcoin->InMempool()) {
-            nTotal += pcoin->GetAvailableCredit();
+            nTotal += pcoin->GetAvailableCredit(*locked_chain);
         }
     }
 
@@ -2362,7 +2377,7 @@
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
-        nTotal += pcoin->GetImmatureCredit();
+        nTotal += pcoin->GetImmatureCredit(*locked_chain);
     }
 
     return nTotal;
@@ -2375,9 +2390,11 @@
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
-        if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 &&
+        if (!pcoin->IsTrusted(*locked_chain) &&
+            pcoin->GetDepthInMainChain(*locked_chain) == 0 &&
             pcoin->InMempool()) {
-            nTotal += pcoin->GetAvailableCredit(true, ISMINE_WATCH_ONLY);
+            nTotal += pcoin->GetAvailableCredit(*locked_chain, true,
+                                                ISMINE_WATCH_ONLY);
         }
     }
 
@@ -2391,7 +2408,7 @@
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
-        nTotal += pcoin->GetImmatureWatchOnlyCredit();
+        nTotal += pcoin->GetImmatureWatchOnlyCredit(*locked_chain);
     }
 
     return nTotal;
@@ -2405,14 +2422,17 @@
 // trusted.
 Amount CWallet::GetLegacyBalance(const isminefilter &filter, int minDepth,
                                  const std::string *account) const {
+    // Temporary, for CheckFinalTx below. Removed in upcoming commit.
+    LockAnnotation lock(::cs_main);
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount balance = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx &wtx = entry.second;
-        const int depth = wtx.GetDepthInMainChain();
-        if (depth < 0 || !CheckFinalTx(*wtx.tx) || wtx.IsImmatureCoinBase()) {
+        const int depth = wtx.GetDepthInMainChain(*locked_chain);
+        if (depth < 0 || !CheckFinalTx(*wtx.tx) ||
+            wtx.IsImmatureCoinBase(*locked_chain)) {
             continue;
         }
 
@@ -2449,7 +2469,7 @@
 
     Amount balance = Amount::zero();
     std::vector<COutput> vCoins;
-    AvailableCoins(vCoins, true, coinControl);
+    AvailableCoins(*locked_chain, vCoins, true, coinControl);
     for (const COutput &out : vCoins) {
         if (out.fSpendable) {
             balance += out.tx->tx->vout[out.i].nValue;
@@ -2458,7 +2478,8 @@
     return balance;
 }
 
-void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe,
+void CWallet::AvailableCoins(interfaces::Chain::Lock &locked_chain,
+                             std::vector<COutput> &vCoins, bool fOnlySafe,
                              const CCoinControl *coinControl,
                              const Amount nMinimumAmount,
                              const Amount nMaximumAmount,
@@ -2479,11 +2500,11 @@
             continue;
         }
 
-        if (pcoin->IsImmatureCoinBase()) {
+        if (pcoin->IsImmatureCoinBase(locked_chain)) {
             continue;
         }
 
-        int nDepth = pcoin->GetDepthInMainChain();
+        int nDepth = pcoin->GetDepthInMainChain(locked_chain);
         if (nDepth < 0) {
             continue;
         }
@@ -2495,7 +2516,7 @@
             continue;
         }
 
-        bool safeTx = pcoin->IsTrusted();
+        bool safeTx = pcoin->IsTrusted(locked_chain);
 
         // Bitcoin-ABC: Removed check that prevents consideration of coins from
         // transactions that are replacing other transactions. This check based
@@ -2543,7 +2564,7 @@
                 continue;
             }
 
-            if (IsSpent(outpoint)) {
+            if (IsSpent(locked_chain, outpoint)) {
                 continue;
             }
 
@@ -2580,14 +2601,15 @@
     }
 }
 
-std::map<CTxDestination, std::vector<COutput>> CWallet::ListCoins() const {
+std::map<CTxDestination, std::vector<COutput>>
+CWallet::ListCoins(interfaces::Chain::Lock &locked_chain) const {
     AssertLockHeld(cs_main);
     AssertLockHeld(cs_wallet);
 
     std::map<CTxDestination, std::vector<COutput>> result;
     std::vector<COutput> availableCoins;
 
-    AvailableCoins(availableCoins);
+    AvailableCoins(locked_chain, availableCoins);
 
     for (const auto &coin : availableCoins) {
         CTxDestination address;
@@ -2604,7 +2626,7 @@
     for (const auto &output : lockedCoins) {
         auto it = mapWallet.find(output.GetTxId());
         if (it != mapWallet.end()) {
-            int depth = it->second.GetDepthInMainChain();
+            int depth = it->second.GetDepthInMainChain(locked_chain);
             if (depth >= 0 && output.GetN() < it->second.tx->vout.size() &&
                 IsMine(it->second.tx->vout[output.GetN()]) ==
                     ISMINE_SPENDABLE) {
@@ -2911,7 +2933,7 @@
 
     CReserveKey reservekey(this);
     CTransactionRef tx_new;
-    if (!CreateTransaction(vecSend, tx_new, reservekey, nFeeRet,
+    if (!CreateTransaction(*locked_chain, vecSend, tx_new, reservekey, nFeeRet,
                            nChangePosInOut, strFailReason, coinControl,
                            false)) {
         return false;
@@ -2963,7 +2985,8 @@
     return m_default_address_type;
 }
 
-bool CWallet::CreateTransaction(const std::vector<CRecipient> &vecSend,
+bool CWallet::CreateTransaction(interfaces::Chain::Lock &locked_chainIn,
+                                const std::vector<CRecipient> &vecSend,
                                 CTransactionRef &tx, CReserveKey &reservekey,
                                 Amount &nFeeRet, int &nChangePosInOut,
                                 std::string &strFailReason,
@@ -3030,7 +3053,7 @@
         LOCK(cs_wallet);
 
         std::vector<COutput> vAvailableCoins;
-        AvailableCoins(vAvailableCoins, true, &coinControl);
+        AvailableCoins(*locked_chain, vAvailableCoins, true, &coinControl);
         // Parameters for coin selection, init with dummy
         CoinSelectionParams coin_selection_params;
 
@@ -3433,14 +3456,14 @@
 
     if (fBroadcastTransactions) {
         // Broadcast
-        if (!wtx.AcceptToMemoryPool(maxTxFee, state)) {
+        if (!wtx.AcceptToMemoryPool(*locked_chain, maxTxFee, state)) {
             WalletLogPrintf("CommitTransaction(): Transaction cannot be "
                             "broadcast immediately, %s\n",
                             FormatStateMessage(state));
             // TODO: if we expect the failure to be long term or permanent,
             // instead delete wtx from the wallet and return failure.
         } else {
-            wtx.RelayWalletTransaction(connman);
+            wtx.RelayWalletTransaction(*locked_chain, connman);
         }
     }
 
@@ -3893,22 +3916,23 @@
     return oldestKey;
 }
 
-std::map<CTxDestination, Amount> CWallet::GetAddressBalances() {
+std::map<CTxDestination, Amount>
+CWallet::GetAddressBalances(interfaces::Chain::Lock &locked_chain) {
     std::map<CTxDestination, Amount> balances;
 
     LOCK(cs_wallet);
     for (const auto &walletEntry : mapWallet) {
         const CWalletTx *pcoin = &walletEntry.second;
 
-        if (!pcoin->IsTrusted()) {
+        if (!pcoin->IsTrusted(locked_chain)) {
             continue;
         }
 
-        if (pcoin->IsImmatureCoinBase()) {
+        if (pcoin->IsImmatureCoinBase(locked_chain)) {
             continue;
         }
 
-        int nDepth = pcoin->GetDepthInMainChain();
+        int nDepth = pcoin->GetDepthInMainChain(locked_chain);
         if (nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? 0 : 1)) {
             continue;
         }
@@ -3923,7 +3947,7 @@
                 continue;
             }
 
-            Amount n = IsSpent(COutPoint(walletEntry.first, i))
+            Amount n = IsSpent(locked_chain, COutPoint(walletEntry.first, i))
                            ? Amount::zero()
                            : pcoin->tx->vout[i].nValue;
 
@@ -4181,6 +4205,7 @@
 /** @} */ // end of Actions
 
 void CWallet::GetKeyBirthTimes(
+    interfaces::Chain::Lock &locked_chain,
     std::map<CTxDestination, int64_t> &mapKeyBirth) const {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
@@ -4716,6 +4741,8 @@
     // Try to top up keypool. No-op if the wallet is locked.
     walletInstance->TopUpKeyPool();
 
+    // Temporary, for FindForkInGlobalIndex below. Removed in upcoming commit.
+    LockAnnotation lock(::cs_main);
     auto locked_chain = chain.lock();
     LOCK(walletInstance->cs_wallet);
 
@@ -4860,7 +4887,8 @@
     nIndex = posInBlock;
 }
 
-int CMerkleTx::GetDepthInMainChain() const {
+int CMerkleTx::GetDepthInMainChain(
+    interfaces::Chain::Lock &locked_chain) const {
     if (hashUnset()) {
         return 0;
     }
@@ -4877,21 +4905,28 @@
            (chainActive.Height() - pindex->nHeight + 1);
 }
 
-int CMerkleTx::GetBlocksToMaturity() const {
+int CMerkleTx::GetBlocksToMaturity(
+    interfaces::Chain::Lock &locked_chain) const {
     if (!IsCoinBase()) {
         return 0;
     }
 
-    return std::max(0, (COINBASE_MATURITY + 1) - GetDepthInMainChain());
+    return std::max(0, (COINBASE_MATURITY + 1) -
+                           GetDepthInMainChain(locked_chain));
 }
 
-bool CMerkleTx::IsImmatureCoinBase() const {
+bool CMerkleTx::IsImmatureCoinBase(
+    interfaces::Chain::Lock &locked_chain) const {
     // note GetBlocksToMaturity is 0 for non-coinbase tx
-    return GetBlocksToMaturity() > 0;
+    return GetBlocksToMaturity(locked_chain) > 0;
 }
 
-bool CWalletTx::AcceptToMemoryPool(const Amount nAbsurdFee,
+bool CWalletTx::AcceptToMemoryPool(interfaces::Chain::Lock &locked_chain,
+                                   const Amount nAbsurdFee,
                                    CValidationState &state) {
+    // Temporary, for AcceptToMemoryPool below. Removed in upcoming commit.
+    LockAnnotation lock(::cs_main);
+
     // We must set fInMempool here - while it will be re-set to true by the
     // entered-mempool callback, if we did not there would be a race where a
     // user could call sendmoney in a loop and hit spurious out of funds errors