diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -28,6 +28,7 @@
 
 namespace interfaces {
 
+class Handler;
 class Wallet;
 
 //! Interface giving clients (wallet processes, maybe other analysis tools in
@@ -43,6 +44,12 @@
 //!   asynchronously
 //!   (https://github.com/bitcoin/bitcoin/pull/10973#issuecomment-380101269).
 //!
+//! * The isPotentialTip() and waitForNotifications() methods are too low-level
+//!   and should be replaced with a higher level
+//!   waitForNotificationsUpTo(block_hash) method that the wallet can call
+//!   instead
+//!   (https://github.com/bitcoin/bitcoin/pull/10973#discussion_r266995234).
+//!
 //! * The relayTransactions() and submitToMemoryPool() methods could be replaced
 //!   with a higher-level broadcastTransaction method
 //!   (https://github.com/bitcoin/bitcoin/pull/14978#issuecomment-459373984).
@@ -215,6 +222,29 @@
 
     //! Send wallet load notification to the GUI.
     virtual void loadWallet(std::unique_ptr<Wallet> wallet) = 0;
+
+    //! Chain notifications.
+    class Notifications {
+    public:
+        virtual ~Notifications() {}
+        virtual void TransactionAddedToMempool(const CTransactionRef &tx) {}
+        virtual void TransactionRemovedFromMempool(const CTransactionRef &ptx) {
+        }
+        virtual void
+        BlockConnected(const CBlock &block,
+                       const std::vector<CTransactionRef> &tx_conflicted) {}
+        virtual void BlockDisconnected(const CBlock &block) {}
+        virtual void ChainStateFlushed(const CBlockLocator &locator) {}
+        virtual void ResendWalletTransactions(Lock &locked_chain,
+                                              int64_t best_block_time) {}
+    };
+
+    //! Register handler for notifications.
+    virtual std::unique_ptr<Handler>
+    handleNotifications(Notifications &notifications) = 0;
+
+    //! Wait for pending notifications to be handled.
+    virtual void waitForNotifications() = 0;
 };
 
 //! Interface to let node manage chain clients (wallets, or maybe tools for
diff --git a/src/interfaces/chain.cpp b/src/interfaces/chain.cpp
--- a/src/interfaces/chain.cpp
+++ b/src/interfaces/chain.cpp
@@ -6,6 +6,7 @@
 
 #include <chain.h>
 #include <chainparams.h>
+#include <interfaces/handler.h>
 #include <interfaces/wallet.h>
 #include <net.h>
 #include <policy/mempool.h>
@@ -20,6 +21,7 @@
 #include <ui_interface.h>
 #include <util/system.h>
 #include <validation.h>
+#include <validationinterface.h>
 
 #include <memory>
 #include <utility>
@@ -163,6 +165,54 @@
         using UniqueLock::UniqueLock;
     };
 
+    class NotificationsHandlerImpl : public Handler, CValidationInterface {
+    public:
+        explicit NotificationsHandlerImpl(Chain &chain,
+                                          Chain::Notifications &notifications)
+            : m_chain(chain), m_notifications(&notifications) {
+            RegisterValidationInterface(this);
+        }
+        ~NotificationsHandlerImpl() override { disconnect(); }
+        void disconnect() override {
+            if (m_notifications) {
+                m_notifications = nullptr;
+                UnregisterValidationInterface(this);
+            }
+        }
+        void TransactionAddedToMempool(const CTransactionRef &tx) override {
+            m_notifications->TransactionAddedToMempool(tx);
+        }
+        void TransactionRemovedFromMempool(const CTransactionRef &tx) override {
+            m_notifications->TransactionRemovedFromMempool(tx);
+        }
+        void BlockConnected(
+            const std::shared_ptr<const CBlock> &block,
+            const CBlockIndex *index,
+            const std::vector<CTransactionRef> &tx_conflicted) override {
+            m_notifications->BlockConnected(*block, tx_conflicted);
+        }
+        void
+        BlockDisconnected(const std::shared_ptr<const CBlock> &block) override {
+            m_notifications->BlockDisconnected(*block);
+        }
+        void ChainStateFlushed(const CBlockLocator &locator) override {
+            m_notifications->ChainStateFlushed(locator);
+        }
+        void ResendWalletTransactions(int64_t best_block_time,
+                                      CConnman *) override {
+            // `cs_main` is always held when this method is called, so it is
+            // safe to call `assumeLocked`. This is awkward, and the
+            // `assumeLocked` method should be able to be removed entirely if
+            // `ResendWalletTransactions` is replaced by a wallet timer as
+            // suggested in https://github.com/bitcoin/bitcoin/issues/15619
+            auto locked_chain = m_chain.assumeLocked();
+            m_notifications->ResendWalletTransactions(*locked_chain,
+                                                      best_block_time);
+        }
+        Chain &m_chain;
+        Chain::Notifications *m_notifications;
+    };
+
     class ChainImpl : public Chain {
     public:
         std::unique_ptr<Chain::Lock> lock(bool try_lock) override {
@@ -259,6 +309,14 @@
         void loadWallet(std::unique_ptr<Wallet> wallet) override {
             ::uiInterface.LoadWallet(wallet);
         }
+        std::unique_ptr<Handler>
+        handleNotifications(Notifications &notifications) override {
+            return std::make_unique<NotificationsHandlerImpl>(*this,
+                                                              notifications);
+        }
+        void waitForNotifications() override {
+            SyncWithValidationInterfaceQueue();
+        }
     };
 
 } // namespace
diff --git a/src/wallet/test/wallet_test_fixture.h b/src/wallet/test/wallet_test_fixture.h
--- a/src/wallet/test/wallet_test_fixture.h
+++ b/src/wallet/test/wallet_test_fixture.h
@@ -19,7 +19,6 @@
 struct WalletTestingSetup : public TestingSetup {
     explicit WalletTestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
-    ~WalletTestingSetup();
 
     std::unique_ptr<interfaces::Chain> m_chain = interfaces::MakeChain();
     CWallet m_wallet;
diff --git a/src/wallet/test/wallet_test_fixture.cpp b/src/wallet/test/wallet_test_fixture.cpp
--- a/src/wallet/test/wallet_test_fixture.cpp
+++ b/src/wallet/test/wallet_test_fixture.cpp
@@ -16,12 +16,9 @@
                                         WalletDatabase::CreateMock()) {
     bool fFirstRun;
     m_wallet.LoadWallet(fFirstRun);
-    RegisterValidationInterface(&m_wallet);
+    m_wallet.m_chain_notifications_handler =
+        m_chain->handleNotifications(m_wallet);
 
     RegisterWalletRPCCommands(tableRPC);
     RegisterDumpRPCCommands(tableRPC);
 }
-
-WalletTestingSetup::~WalletTestingSetup() {
-    UnregisterValidationInterface(&m_wallet);
-}
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -9,6 +9,7 @@
 
 #include <amount.h>
 #include <interfaces/chain.h>
+#include <interfaces/handler.h>
 #include <outputtype.h>
 #include <primitives/blockhash.h>
 #include <script/ismine.h>
@@ -674,7 +675,8 @@
  * transactions and balances, and provides the ability to create new
  * transactions.
  */
-class CWallet final : public CCryptoKeyStore, public CValidationInterface {
+class CWallet final : public CCryptoKeyStore,
+                      private interfaces::Chain::Notifications {
 private:
     static std::atomic<bool> fFlushScheduled;
     std::atomic<bool> fAbortRescan{false};
@@ -876,6 +878,9 @@
 
     std::set<COutPoint> setLockedCoins GUARDED_BY(cs_wallet);
 
+    /** Registered interfaces::Chain::Notifications handler. */
+    std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;
+
     /** Interface for accessing chain state. */
     interfaces::Chain &chain() const { return m_chain; }
 
@@ -1051,11 +1056,9 @@
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void TransactionAddedToMempool(const CTransactionRef &tx) override;
     void
-    BlockConnected(const std::shared_ptr<const CBlock> &pblock,
-                   const CBlockIndex *pindex,
+    BlockConnected(const CBlock &block,
                    const std::vector<CTransactionRef> &vtxConflicted) override;
-    void
-    BlockDisconnected(const std::shared_ptr<const CBlock> &pblock) override;
+    void BlockDisconnected(const CBlock &block) override;
     int64_t RescanFromTime(int64_t startTime,
                            const WalletRescanReserver &reserver, bool update);
 
@@ -1080,9 +1083,8 @@
                                          bool fUpdate);
     void TransactionRemovedFromMempool(const CTransactionRef &ptx) override;
     void ReacceptWalletTransactions();
-    void ResendWalletTransactions(int64_t nBestBlockTime,
-                                  CConnman *connman) override
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    void ResendWalletTransactions(interfaces::Chain::Lock &locked_chain,
+                                  int64_t nBestBlockTime) override;
     // ResendWalletTransactionsBefore may only be called if
     // fBroadcastTransactions!
     std::vector<uint256>
@@ -1442,6 +1444,8 @@
      * Implement lookup of key origin information through wallet key metadata.
      */
     bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override;
+
+    friend struct WalletTestingSetup;
 };
 
 /** A key allocated from the key pool. */
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -102,7 +102,7 @@
     wallet->WalletLogPrintf("Releasing wallet\n");
     wallet->BlockUntilSyncedToCurrentChain();
     wallet->Flush();
-    UnregisterValidationInterface(wallet);
+    wallet->m_chain_notifications_handler.reset();
     delete wallet;
     // Wallet is now released, notify UnloadWallet, if any.
     {
@@ -1286,8 +1286,8 @@
 }
 
 void CWallet::BlockConnected(
-    const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex,
-    const std::vector<CTransactionRef> &vtxConflicted) {
+    const CBlock &block, const std::vector<CTransactionRef> &vtxConflicted) {
+    const BlockHash &block_hash = block.GetHash();
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
@@ -1303,19 +1303,19 @@
         TransactionRemovedFromMempool(ptx);
     }
 
-    for (size_t i = 0; i < pblock->vtx.size(); i++) {
-        SyncTransaction(pblock->vtx[i], pindex->GetBlockHash(), i);
-        TransactionRemovedFromMempool(pblock->vtx[i]);
+    for (size_t i = 0; i < block.vtx.size(); i++) {
+        SyncTransaction(block.vtx[i], block_hash, i);
+        TransactionRemovedFromMempool(block.vtx[i]);
     }
 
-    m_last_block_processed = pindex->GetBlockHash();
+    m_last_block_processed = block_hash;
 }
 
-void CWallet::BlockDisconnected(const std::shared_ptr<const CBlock> &pblock) {
+void CWallet::BlockDisconnected(const CBlock &block) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
-    for (const CTransactionRef &ptx : pblock->vtx) {
+    for (const CTransactionRef &ptx : block.vtx) {
         SyncTransaction(ptx, BlockHash(), 0 /* position in block */);
     }
 }
@@ -1340,7 +1340,7 @@
     // ...otherwise put a callback in the validation interface queue and wait
     // for the queue to drain enough to execute it (indicating we are caught up
     // at least with the time we entered this function).
-    SyncWithValidationInterfaceQueue();
+    chain().waitForNotifications();
 }
 
 isminetype CWallet::IsMine(const CTxIn &txin) const {
@@ -2268,8 +2268,8 @@
     return result;
 }
 
-void CWallet::ResendWalletTransactions(int64_t nBestBlockTime,
-                                       CConnman *connman) {
+void CWallet::ResendWalletTransactions(interfaces::Chain::Lock &locked_chain,
+                                       int64_t nBestBlockTime) {
     // Do this infrequently and randomly to avoid giving away that these are our
     // transactions.
     if (GetTime() < nNextResend || !fBroadcastTransactions) {
@@ -2289,12 +2289,10 @@
 
     nLastResend = GetTime();
 
-    // Temporary. Removed in upcoming lock cleanup
-    auto locked_chain = chain().assumeLocked();
     // Rebroadcast unconfirmed txes older than 5 minutes before the last block
     // was found:
     std::vector<uint256> relayed =
-        ResendWalletTransactionsBefore(*locked_chain, nBestBlockTime - 5 * 60);
+        ResendWalletTransactionsBefore(locked_chain, nBestBlockTime - 5 * 60);
     if (!relayed.empty()) {
         WalletLogPrintf("%s: rebroadcast %u unconfirmed transactions\n",
                         __func__, relayed.size());
@@ -4785,8 +4783,9 @@
     chain.loadWallet(interfaces::MakeWallet(walletInstance));
 
     // Register with the validation interface. It's ok to do this after rescan
-    // since we're still holding cs_main.
-    RegisterValidationInterface(walletInstance.get());
+    // since we're still holding locked_chain.
+    walletInstance->m_chain_notifications_handler =
+        chain.handleNotifications(*walletInstance);
 
     walletInstance->SetBroadcastTransactions(
         gArgs.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));