diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
index b46f8e0a7..04a9fda00 100644
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -1,357 +1,365 @@
 // 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.
 
 #include <interfaces/node.h>
 
 #include <addrdb.h>
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <interfaces/wallet.h>
 #include <net.h>
 #include <net_processing.h>
 #include <netaddress.h>
 #include <netbase.h>
 #include <node/context.h>
 #include <node/ui_interface.h>
 #include <policy/fees.h>
 #include <policy/settings.h>
 #include <primitives/block.h>
 #include <rpc/server.h>
 #include <shutdown.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <txmempool.h>
 #include <util/ref.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <warnings.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <univalue.h>
 
 #include <boost/signals2/signal.hpp>
 
 class HTTPRPCRequestProcessor;
 class CWallet;
 fs::path GetWalletDir();
 std::vector<fs::path> ListWalletDir();
 std::vector<std::shared_ptr<CWallet>> GetWallets();
 std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
                                     interfaces::Chain &chain,
                                     const std::string &name,
                                     bilingual_str &error,
                                     std::vector<bilingual_str> &warnings);
 WalletCreationStatus CreateWallet(const CChainParams &params,
                                   interfaces::Chain &chain,
                                   const SecureString &passphrase,
                                   uint64_t wallet_creation_flags,
                                   const std::string &name, bilingual_str &error,
                                   std::vector<bilingual_str> &warnings,
                                   std::shared_ptr<CWallet> &result);
 std::unique_ptr<interfaces::Handler>
 HandleLoadWallet(interfaces::Node::LoadWalletFn load_wallet);
 
 namespace interfaces {
 
 namespace {
 
     class NodeImpl : public Node {
     public:
         NodeImpl(NodeContext *context) { setContext(context); }
         void initLogging() override { InitLogging(*Assert(m_context->args)); }
         void initParameterInteraction() override {
             InitParameterInteraction(*Assert(m_context->args));
         }
         std::string getWarnings() override { return GetWarnings(true); }
         bool baseInitialize(Config &config) override {
             return AppInitBasicSetup(gArgs) &&
                    AppInitParameterInteraction(config, gArgs) &&
                    AppInitSanityChecks() && AppInitLockDataDirectory();
         }
         bool
         appInitMain(Config &config, RPCServer &rpcServer,
                     HTTPRPCRequestProcessor &httpRPCRequestProcessor) override {
             m_context->chain = MakeChain(*m_context, config.GetChainParams());
             return AppInitMain(config, rpcServer, httpRPCRequestProcessor,
                                *m_context);
         }
         void appShutdown() override {
             Interrupt(*m_context);
             Shutdown(*m_context);
         }
         void startShutdown() override { StartShutdown(); }
         bool shutdownRequested() override { return ShutdownRequested(); }
         void mapPort(bool use_upnp) override {
             if (use_upnp) {
                 StartMapPort();
             } else {
                 InterruptMapPort();
                 StopMapPort();
             }
         }
         bool getProxy(Network net, proxyType &proxy_info) override {
             return GetProxy(net, proxy_info);
         }
         size_t getNodeCount(CConnman::NumConnections flags) override {
             return m_context->connman ? m_context->connman->GetNodeCount(flags)
                                       : 0;
         }
         bool getNodesStats(NodesStats &stats) override {
             stats.clear();
 
             if (m_context->connman) {
                 std::vector<CNodeStats> stats_temp;
                 m_context->connman->GetNodeStats(stats_temp);
 
                 stats.reserve(stats_temp.size());
                 for (auto &node_stats_temp : stats_temp) {
                     stats.emplace_back(std::move(node_stats_temp), false,
                                        CNodeStateStats());
                 }
 
                 // Try to retrieve the CNodeStateStats for each node.
                 TRY_LOCK(::cs_main, lockMain);
                 if (lockMain) {
                     for (auto &node_stats : stats) {
                         std::get<1>(node_stats) =
                             GetNodeStateStats(std::get<0>(node_stats).nodeid,
                                               std::get<2>(node_stats));
                     }
                 }
                 return true;
             }
             return false;
         }
         bool getBanned(banmap_t &banmap) override {
             if (m_context->banman) {
                 m_context->banman->GetBanned(banmap);
                 return true;
             }
             return false;
         }
         bool ban(const CNetAddr &net_addr, int64_t ban_time_offset) override {
             if (m_context->banman) {
                 m_context->banman->Ban(net_addr, ban_time_offset);
                 return true;
             }
             return false;
         }
         bool unban(const CSubNet &ip) override {
             if (m_context->banman) {
                 m_context->banman->Unban(ip);
                 return true;
             }
             return false;
         }
         bool disconnectByAddress(const CNetAddr &net_addr) override {
             if (m_context->connman) {
                 return m_context->connman->DisconnectNode(net_addr);
             }
             return false;
         }
         bool disconnectById(NodeId id) override {
             if (m_context->connman) {
                 return m_context->connman->DisconnectNode(id);
             }
             return false;
         }
         int64_t getTotalBytesRecv() override {
             return m_context->connman ? m_context->connman->GetTotalBytesRecv()
                                       : 0;
         }
         int64_t getTotalBytesSent() override {
             return m_context->connman ? m_context->connman->GetTotalBytesSent()
                                       : 0;
         }
         size_t getMempoolSize() override {
             return m_context->mempool ? m_context->mempool->size() : 0;
         }
         size_t getMempoolDynamicUsage() override {
             return m_context->mempool ? m_context->mempool->DynamicMemoryUsage()
                                       : 0;
         }
         bool getHeaderTip(int &height, int64_t &block_time) override {
             LOCK(::cs_main);
             if (::pindexBestHeader) {
                 height = ::pindexBestHeader->nHeight;
                 block_time = ::pindexBestHeader->GetBlockTime();
                 return true;
             }
             return false;
         }
         int getNumBlocks() override {
             LOCK(::cs_main);
             return ::ChainActive().Height();
         }
+        BlockHash getBestBlockHash() override {
+            const CBlockIndex *tip =
+                WITH_LOCK(::cs_main, return ::ChainActive().Tip());
+            return tip ? tip->GetBlockHash()
+                       : Params().GenesisBlock().GetHash();
+        }
         int64_t getLastBlockTime() override {
             LOCK(::cs_main);
             if (::ChainActive().Tip()) {
                 return ::ChainActive().Tip()->GetBlockTime();
             }
             // Genesis block's time of current network
             return Params().GenesisBlock().GetBlockTime();
         }
         double getVerificationProgress() override {
             const CBlockIndex *tip;
             {
                 LOCK(::cs_main);
                 tip = ::ChainActive().Tip();
             }
             return GuessVerificationProgress(Params().TxData(), tip);
         }
         bool isInitialBlockDownload() override {
             return ::ChainstateActive().IsInitialBlockDownload();
         }
         bool getReindex() override { return ::fReindex; }
         bool getImporting() override { return ::fImporting; }
         void setNetworkActive(bool active) override {
             if (m_context->connman) {
                 m_context->connman->SetNetworkActive(active);
             }
         }
         bool getNetworkActive() override {
             return m_context->connman && m_context->connman->GetNetworkActive();
         }
         CFeeRate estimateSmartFee() override {
             return m_context->mempool ? m_context->mempool->estimateFee()
                                       : CFeeRate();
         }
         CFeeRate getDustRelayFee() override { return ::dustRelayFee; }
         UniValue executeRpc(Config &config, const std::string &command,
                             const UniValue &params,
                             const std::string &uri) override {
             JSONRPCRequest req(m_context_ref);
             req.params = params;
             req.strMethod = command;
             req.URI = uri;
             return ::tableRPC.execute(config, req);
         }
         std::vector<std::string> listRpcCommands() override {
             return ::tableRPC.listCommands();
         }
         void rpcSetTimerInterfaceIfUnset(RPCTimerInterface *iface) override {
             RPCSetTimerInterfaceIfUnset(iface);
         }
         void rpcUnsetTimerInterface(RPCTimerInterface *iface) override {
             RPCUnsetTimerInterface(iface);
         }
         bool getUnspentOutput(const COutPoint &output, Coin &coin) override {
             LOCK(::cs_main);
             return ::ChainstateActive().CoinsTip().GetCoin(output, coin);
         }
         std::string getWalletDir() override { return GetWalletDir().string(); }
         std::vector<std::string> listWalletDir() override {
             std::vector<std::string> paths;
             for (auto &path : ListWalletDir()) {
                 paths.push_back(path.string());
             }
             return paths;
         }
         std::vector<std::unique_ptr<Wallet>> getWallets() override {
             std::vector<std::unique_ptr<Wallet>> wallets;
             for (auto &client : m_context->chain_clients) {
                 auto client_wallets = client->getWallets();
                 std::move(client_wallets.begin(), client_wallets.end(),
                           std::back_inserter(wallets));
             }
             return wallets;
         }
         std::unique_ptr<Wallet>
         loadWallet(const CChainParams &params, const std::string &name,
                    bilingual_str &error,
                    std::vector<bilingual_str> &warnings) const override {
             return MakeWallet(
                 LoadWallet(params, *m_context->chain, name, error, warnings));
         }
         std::unique_ptr<Wallet>
         createWallet(const CChainParams &params, const SecureString &passphrase,
                      uint64_t wallet_creation_flags, const std::string &name,
                      bilingual_str &error, std::vector<bilingual_str> &warnings,
                      WalletCreationStatus &status) override {
             std::shared_ptr<CWallet> wallet;
             status = CreateWallet(params, *m_context->chain, passphrase,
                                   wallet_creation_flags, name, error, warnings,
                                   wallet);
             return MakeWallet(wallet);
         }
         std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override {
             return MakeHandler(::uiInterface.InitMessage_connect(fn));
         }
         std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override {
             return MakeHandler(::uiInterface.ThreadSafeMessageBox_connect(fn));
         }
         std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override {
             return MakeHandler(::uiInterface.ThreadSafeQuestion_connect(fn));
         }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
             return MakeHandler(::uiInterface.ShowProgress_connect(fn));
         }
         std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) override {
             return HandleLoadWallet(std::move(fn));
         }
         std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(
             NotifyNumConnectionsChangedFn fn) override {
             return MakeHandler(
                 ::uiInterface.NotifyNumConnectionsChanged_connect(fn));
         }
         std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(
             NotifyNetworkActiveChangedFn fn) override {
             return MakeHandler(
                 ::uiInterface.NotifyNetworkActiveChanged_connect(fn));
         }
         std::unique_ptr<Handler>
         handleNotifyAlertChanged(NotifyAlertChangedFn fn) override {
             return MakeHandler(::uiInterface.NotifyAlertChanged_connect(fn));
         }
         std::unique_ptr<Handler>
         handleBannedListChanged(BannedListChangedFn fn) override {
             return MakeHandler(::uiInterface.BannedListChanged_connect(fn));
         }
         std::unique_ptr<Handler>
         handleNotifyBlockTip(NotifyBlockTipFn fn) override {
             return MakeHandler(::uiInterface.NotifyBlockTip_connect(
                 [fn](SynchronizationState sync_state,
                      const CBlockIndex *block) {
-                    fn(sync_state, block->nHeight, block->GetBlockTime(),
+                    fn(sync_state, block->GetBlockHash(), block->nHeight,
+                       block->GetBlockTime(),
                        GuessVerificationProgress(Params().TxData(), block));
                 }));
         }
         std::unique_ptr<Handler>
         handleNotifyHeaderTip(NotifyHeaderTipFn fn) override {
             /* verification progress is unused when a header was received */
             return MakeHandler(::uiInterface.NotifyHeaderTip_connect(
                 [fn](SynchronizationState sync_state,
                      const CBlockIndex *block) {
-                    fn(sync_state, block->nHeight, block->GetBlockTime(), 0);
+                    fn(sync_state, block->GetBlockHash(), block->nHeight,
+                       block->GetBlockTime(), 0);
                 }));
         }
         NodeContext *context() override { return m_context; }
         void setContext(NodeContext *context) override {
             m_context = context;
             if (context) {
                 m_context_ref.Set(*context);
             } else {
                 m_context_ref.Clear();
             }
         }
         NodeContext *m_context{nullptr};
         util::Ref m_context_ref{m_context};
     };
 } // namespace
 
 std::unique_ptr<Node> MakeNode(NodeContext *context) {
     return std::make_unique<NodeImpl>(context);
 }
 
 } // namespace interfaces
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index d0d3fce68..ed4160a78 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -1,263 +1,266 @@
 // 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.
 
 #ifndef BITCOIN_INTERFACES_NODE_H
 #define BITCOIN_INTERFACES_NODE_H
 
 #include <amount.h>     // For Amount
 #include <net.h>        // For CConnman::NumConnections
 #include <net_types.h>  // For banmap_t
 #include <netaddress.h> // For Network
 
 #include <support/allocators/secure.h> // For SecureString
 
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <vector>
 
 class BanMan;
 class CCoinControl;
 class CFeeRate;
 struct CNodeStateStats;
 struct CNodeStats;
 class Coin;
 class Config;
 class HTTPRPCRequestProcessor;
 struct NodeContext;
 class proxyType;
 class RPCServer;
 class RPCTimerInterface;
 enum class SynchronizationState;
 class UniValue;
 enum class WalletCreationStatus;
 struct bilingual_str;
 
 namespace interfaces {
 class Handler;
 class Wallet;
 
 //! Top-level interface for a bitcoin node (bitcoind process).
 class Node {
 public:
     virtual ~Node() {}
 
     //! Init logging.
     virtual void initLogging() = 0;
 
     //! Init parameter interaction.
     virtual void initParameterInteraction() = 0;
 
     //! Get warnings.
     virtual std::string getWarnings() = 0;
 
     //! Initialize app dependencies.
     virtual bool baseInitialize(Config &config) = 0;
 
     //! Start node.
     virtual bool
     appInitMain(Config &config, RPCServer &rpcServer,
                 HTTPRPCRequestProcessor &httpRPCRequestProcessor) = 0;
 
     //! Stop node.
     virtual void appShutdown() = 0;
 
     //! Start shutdown.
     virtual void startShutdown() = 0;
 
     //! Return whether shutdown was requested.
     virtual bool shutdownRequested() = 0;
 
     //! Map port.
     virtual void mapPort(bool use_upnp) = 0;
 
     //! Get proxy.
     virtual bool getProxy(Network net, proxyType &proxy_info) = 0;
 
     //! Get number of connections.
     virtual size_t getNodeCount(CConnman::NumConnections flags) = 0;
 
     //! Get stats for connected nodes.
     using NodesStats =
         std::vector<std::tuple<CNodeStats, bool, CNodeStateStats>>;
     virtual bool getNodesStats(NodesStats &stats) = 0;
 
     //! Get ban map entries.
     virtual bool getBanned(banmap_t &banmap) = 0;
 
     //! Ban node.
     virtual bool ban(const CNetAddr &net_addr, int64_t ban_time_offset) = 0;
 
     //! Unban node.
     virtual bool unban(const CSubNet &ip) = 0;
 
     //! Disconnect node by address.
     virtual bool disconnectByAddress(const CNetAddr &net_addr) = 0;
 
     //! Disconnect node by id.
     virtual bool disconnectById(NodeId id) = 0;
 
     //! Get total bytes recv.
     virtual int64_t getTotalBytesRecv() = 0;
 
     //! Get total bytes sent.
     virtual int64_t getTotalBytesSent() = 0;
 
     //! Get mempool size.
     virtual size_t getMempoolSize() = 0;
 
     //! Get mempool dynamic usage.
     virtual size_t getMempoolDynamicUsage() = 0;
 
     //! Get header tip height and time.
     virtual bool getHeaderTip(int &height, int64_t &block_time) = 0;
 
     //! Get num blocks.
     virtual int getNumBlocks() = 0;
 
+    //! Get best block hash.
+    virtual BlockHash getBestBlockHash() = 0;
+
     //! Get last block time.
     virtual int64_t getLastBlockTime() = 0;
 
     //! Get verification progress.
     virtual double getVerificationProgress() = 0;
 
     //! Is initial block download.
     virtual bool isInitialBlockDownload() = 0;
 
     //! Get reindex.
     virtual bool getReindex() = 0;
 
     //! Get importing.
     virtual bool getImporting() = 0;
 
     //! Set network active.
     virtual void setNetworkActive(bool active) = 0;
 
     //! Get network active.
     virtual bool getNetworkActive() = 0;
 
     //! Estimate smart fee.
     virtual CFeeRate estimateSmartFee() = 0;
 
     //! Get dust relay fee.
     virtual CFeeRate getDustRelayFee() = 0;
 
     //! Execute rpc command.
     virtual UniValue executeRpc(Config &config, const std::string &command,
                                 const UniValue &params,
                                 const std::string &uri) = 0;
 
     //! List rpc commands.
     virtual std::vector<std::string> listRpcCommands() = 0;
 
     //! Set RPC timer interface if unset.
     virtual void rpcSetTimerInterfaceIfUnset(RPCTimerInterface *iface) = 0;
 
     //! Unset RPC timer interface.
     virtual void rpcUnsetTimerInterface(RPCTimerInterface *iface) = 0;
 
     //! Get unspent outputs associated with a transaction.
     virtual bool getUnspentOutput(const COutPoint &output, Coin &coin) = 0;
 
     //! Return default wallet directory.
     virtual std::string getWalletDir() = 0;
 
     //! Return available wallets in wallet directory.
     virtual std::vector<std::string> listWalletDir() = 0;
 
     //! Return interfaces for accessing wallets (if any).
     virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
 
     //! Attempts to load a wallet from file or directory.
     //! The loaded wallet is also notified to handlers previously registered
     //! with handleLoadWallet.
     virtual std::unique_ptr<Wallet>
     loadWallet(const CChainParams &params, const std::string &name,
                bilingual_str &error,
                std::vector<bilingual_str> &warnings) const = 0;
 
     //! Create a wallet from file
     virtual std::unique_ptr<Wallet>
     createWallet(const CChainParams &params, const SecureString &passphrase,
                  uint64_t wallet_creation_flags, const std::string &name,
                  bilingual_str &error, std::vector<bilingual_str> &warnings,
                  WalletCreationStatus &status) = 0;
 
     //! Register handler for init messages.
     using InitMessageFn = std::function<void(const std::string &message)>;
     virtual std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) = 0;
 
     //! Register handler for message box messages.
     using MessageBoxFn =
         std::function<bool(const bilingual_str &message,
                            const std::string &caption, unsigned int style)>;
     virtual std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) = 0;
 
     //! Register handler for question messages.
     using QuestionFn =
         std::function<bool(const bilingual_str &message,
                            const std::string &non_interactive_message,
                            const std::string &caption, unsigned int style)>;
     virtual std::unique_ptr<Handler> handleQuestion(QuestionFn fn) = 0;
 
     //! Register handler for progress messages.
     using ShowProgressFn = std::function<void(
         const std::string &title, int progress, bool resume_possible)>;
     virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
 
     //! Register handler for load wallet messages.
     using LoadWalletFn = std::function<void(std::unique_ptr<Wallet> wallet)>;
     virtual std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) = 0;
 
     //! Register handler for number of connections changed messages.
     using NotifyNumConnectionsChangedFn =
         std::function<void(int new_num_connections)>;
     virtual std::unique_ptr<Handler>
     handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) = 0;
 
     //! Register handler for network active messages.
     using NotifyNetworkActiveChangedFn =
         std::function<void(bool network_active)>;
     virtual std::unique_ptr<Handler>
     handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) = 0;
 
     //! Register handler for notify alert messages.
     using NotifyAlertChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleNotifyAlertChanged(NotifyAlertChangedFn fn) = 0;
 
     //! Register handler for ban list messages.
     using BannedListChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleBannedListChanged(BannedListChangedFn fn) = 0;
 
     //! Register handler for block tip messages.
-    using NotifyBlockTipFn =
-        std::function<void(SynchronizationState, int height, int64_t block_time,
-                           double verification_progress)>;
+    using NotifyBlockTipFn = std::function<void(
+        SynchronizationState, const BlockHash &block_hash, int height,
+        int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler>
     handleNotifyBlockTip(NotifyBlockTipFn fn) = 0;
 
     //! Register handler for header tip messages.
-    using NotifyHeaderTipFn =
-        std::function<void(SynchronizationState, int height, int64_t block_time,
-                           double verification_progress)>;
+    using NotifyHeaderTipFn = std::function<void(
+        SynchronizationState, const BlockHash &block_hash, int height,
+        int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler>
     handleNotifyHeaderTip(NotifyHeaderTipFn fn) = 0;
 
     //! Get and set internal node context. Useful for testing, but not
     //! accessible across processes.
     virtual NodeContext *context() { return nullptr; }
     virtual void setContext(NodeContext *context) {}
 };
 
 //! Return implementation of Node interface.
 std::unique_ptr<Node> MakeNode(NodeContext *context = nullptr);
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_NODE_H
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
index 35b6fb9c5..9b48a3755 100644
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -1,535 +1,535 @@
 // 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.
 
 #include <interfaces/wallet.h>
 
 #include <amount.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <policy/fees.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <util/check.h>
 #include <util/ref.h>
 #include <util/system.h>
 #include <util/ui_change_type.h>
 #include <wallet/context.h>
 #include <wallet/fees.h>
 #include <wallet/ismine.h>
 #include <wallet/load.h>
 #include <wallet/rpcdump.h>
 #include <wallet/wallet.h>
 
 namespace interfaces {
 namespace {
 
     //! Construct wallet tx struct.
     WalletTx MakeWalletTx(CWallet &wallet, const CWalletTx &wtx) {
         WalletTx result;
         result.tx = wtx.tx;
         result.txin_is_mine.reserve(wtx.tx->vin.size());
         for (const auto &txin : wtx.tx->vin) {
             result.txin_is_mine.emplace_back(wallet.IsMine(txin));
         }
         result.txout_is_mine.reserve(wtx.tx->vout.size());
         result.txout_address.reserve(wtx.tx->vout.size());
         result.txout_address_is_mine.reserve(wtx.tx->vout.size());
         for (const auto &txout : wtx.tx->vout) {
             result.txout_is_mine.emplace_back(wallet.IsMine(txout));
             result.txout_address.emplace_back();
             result.txout_address_is_mine.emplace_back(
                 ExtractDestination(txout.scriptPubKey,
                                    result.txout_address.back())
                     ? wallet.IsMine(result.txout_address.back())
                     : ISMINE_NO);
         }
         result.credit = wtx.GetCredit(ISMINE_ALL);
         result.debit = wtx.GetDebit(ISMINE_ALL);
         result.change = wtx.GetChange();
         result.time = wtx.GetTxTime();
         result.value_map = wtx.mapValue;
         result.is_coinbase = wtx.IsCoinBase();
         return result;
     }
 
     //! Construct wallet tx status struct.
     WalletTxStatus MakeWalletTxStatus(CWallet &wallet, const CWalletTx &wtx) {
         WalletTxStatus result;
         result.block_height = wtx.m_confirm.block_height > 0
                                   ? wtx.m_confirm.block_height
                                   : std::numeric_limits<int>::max();
         result.blocks_to_maturity = wtx.GetBlocksToMaturity();
         result.depth_in_main_chain = wtx.GetDepthInMainChain();
         result.time_received = wtx.nTimeReceived;
         result.lock_time = wtx.tx->nLockTime;
         TxValidationState state;
         result.is_final =
             wallet.chain().contextualCheckTransactionForCurrentBlock(*wtx.tx,
                                                                      state);
         result.is_trusted = wtx.IsTrusted();
         result.is_abandoned = wtx.isAbandoned();
         result.is_coinbase = wtx.IsCoinBase();
         result.is_in_main_chain = wtx.IsInMainChain();
         return result;
     }
 
     //! Construct wallet TxOut struct.
     WalletTxOut MakeWalletTxOut(CWallet &wallet, const CWalletTx &wtx, int n,
                                 int depth)
         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));
         return result;
     }
 
     class WalletImpl : public Wallet {
     public:
         explicit WalletImpl(const std::shared_ptr<CWallet> &wallet)
             : m_wallet(wallet) {}
 
         bool encryptWallet(const SecureString &wallet_passphrase) override {
             return m_wallet->EncryptWallet(wallet_passphrase);
         }
         bool isCrypted() override { return m_wallet->IsCrypted(); }
         bool lock() override { return m_wallet->Lock(); }
         bool unlock(const SecureString &wallet_passphrase) override {
             return m_wallet->Unlock(wallet_passphrase);
         }
         bool isLocked() override { return m_wallet->IsLocked(); }
         bool changeWalletPassphrase(
             const SecureString &old_wallet_passphrase,
             const SecureString &new_wallet_passphrase) override {
             return m_wallet->ChangeWalletPassphrase(old_wallet_passphrase,
                                                     new_wallet_passphrase);
         }
         void abortRescan() override { m_wallet->AbortRescan(); }
         bool backupWallet(const std::string &filename) override {
             return m_wallet->BackupWallet(filename);
         }
         std::string getWalletName() override { return m_wallet->GetName(); }
         std::set<CTxDestination>
         getLabelAddresses(const std::string &label) override {
             return m_wallet->GetLabelAddresses(label);
         };
         bool getNewDestination(const OutputType type, const std::string label,
                                CTxDestination &dest) override {
             LOCK(m_wallet->cs_wallet);
             std::string error;
             return m_wallet->GetNewDestination(type, label, dest, error);
         }
         const CChainParams &getChainParams() override {
             return m_wallet->GetChainParams();
         }
         bool getPubKey(const CScript &script, const CKeyID &address,
                        CPubKey &pub_key) override {
             std::unique_ptr<SigningProvider> provider =
                 m_wallet->GetSolvingProvider(script);
             if (provider) {
                 return provider->GetPubKey(address, pub_key);
             }
             return false;
         }
         SigningResult signMessage(const std::string &message,
                                   const PKHash &pkhash,
                                   std::string &str_sig) override {
             return m_wallet->SignMessage(message, pkhash, str_sig);
         }
         bool isSpendable(const CTxDestination &dest) override {
             return m_wallet->IsMine(dest) & ISMINE_SPENDABLE;
         }
         bool haveWatchOnly() override {
             auto spk_man = m_wallet->GetLegacyScriptPubKeyMan();
             if (spk_man) {
                 return spk_man->HaveWatchOnly();
             }
             return false;
         };
         bool setAddressBook(const CTxDestination &dest, const std::string &name,
                             const std::string &purpose) override {
             return m_wallet->SetAddressBook(dest, name, purpose);
         }
         bool delAddressBook(const CTxDestination &dest) override {
             return m_wallet->DelAddressBook(dest);
         }
         bool getAddress(const CTxDestination &dest, std::string *name,
                         isminetype *is_mine, std::string *purpose) override {
             LOCK(m_wallet->cs_wallet);
             auto it = m_wallet->m_address_book.find(dest);
             if (it == m_wallet->m_address_book.end() || it->second.IsChange()) {
                 return false;
             }
             if (name) {
                 *name = it->second.GetLabel();
             }
             if (is_mine) {
                 *is_mine = m_wallet->IsMine(dest);
             }
             if (purpose) {
                 *purpose = it->second.purpose;
             }
             return true;
         }
         std::vector<WalletAddress> getAddresses() override {
             LOCK(m_wallet->cs_wallet);
             std::vector<WalletAddress> result;
             for (const auto &item : m_wallet->m_address_book) {
                 if (item.second.IsChange()) {
                     continue;
                 }
                 result.emplace_back(item.first, m_wallet->IsMine(item.first),
                                     item.second.GetLabel(),
                                     item.second.purpose);
             }
             return result;
         }
         bool addDestData(const CTxDestination &dest, const std::string &key,
                          const std::string &value) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->AddDestData(batch, dest, key, value);
         }
         bool eraseDestData(const CTxDestination &dest,
                            const std::string &key) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->EraseDestData(batch, dest, key);
         }
         std::vector<std::string>
         getDestValues(const std::string &prefix) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->GetDestValues(prefix);
         }
         void lockCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->LockCoin(output);
         }
         void unlockCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->UnlockCoin(output);
         }
         bool isLockedCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsLockedCoin(output);
         }
         void listLockedCoins(std::vector<COutPoint> &outputs) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->ListLockedCoins(outputs);
         }
         CTransactionRef
         createTransaction(const std::vector<CRecipient> &recipients,
                           const CCoinControl &coin_control, bool sign,
                           int &change_pos, Amount &fee,
                           bilingual_str &fail_reason) override {
             LOCK(m_wallet->cs_wallet);
             CTransactionRef tx;
             if (!m_wallet->CreateTransaction(recipients, tx, fee, change_pos,
                                              fail_reason, coin_control, sign)) {
                 return {};
             }
             return tx;
         }
         void commitTransaction(CTransactionRef tx, WalletValueMap value_map,
                                WalletOrderForm order_form) override {
             LOCK(m_wallet->cs_wallet);
             m_wallet->CommitTransaction(std::move(tx), std::move(value_map),
                                         std::move(order_form));
         }
         bool transactionCanBeAbandoned(const TxId &txid) override {
             return m_wallet->TransactionCanBeAbandoned(txid);
         }
         bool abandonTransaction(const TxId &txid) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->AbandonTransaction(txid);
         }
         CTransactionRef getTx(const TxId &txid) override {
             LOCK(m_wallet->cs_wallet);
             auto mi = m_wallet->mapWallet.find(txid);
             if (mi != m_wallet->mapWallet.end()) {
                 return mi->second.tx;
             }
             return {};
         }
         WalletTx getWalletTx(const TxId &txid) override {
             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 {};
         }
         std::vector<WalletTx> getWalletTxs() override {
             LOCK(m_wallet->cs_wallet);
             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));
             }
             return result;
         }
         bool tryGetTxStatus(const TxId &txid,
                             interfaces::WalletTxStatus &tx_status,
                             int &num_blocks, int64_t &block_time) override {
             TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             auto mi = m_wallet->mapWallet.find(txid);
             if (mi == m_wallet->mapWallet.end()) {
                 return false;
             }
             num_blocks = m_wallet->GetLastBlockHeight();
             block_time = -1;
             CHECK_NONFATAL(m_wallet->chain().findBlock(
                 m_wallet->GetLastBlockHash(), FoundBlock().time(block_time)));
             tx_status = MakeWalletTxStatus(*m_wallet, mi->second);
             return true;
         }
         WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status,
                                     WalletOrderForm &order_form,
                                     bool &in_mempool,
                                     int &num_blocks) override {
             LOCK(m_wallet->cs_wallet);
             auto mi = m_wallet->mapWallet.find(txid);
             if (mi != m_wallet->mapWallet.end()) {
                 num_blocks = m_wallet->GetLastBlockHeight();
                 in_mempool = mi->second.InMempool();
                 order_form = mi->second.vOrderForm;
                 tx_status = MakeWalletTxStatus(*m_wallet, mi->second);
                 return MakeWalletTx(*m_wallet, mi->second);
             }
             return {};
         }
         TransactionError fillPSBT(SigHashType sighash_type, bool sign,
                                   bool bip32derivs,
                                   PartiallySignedTransaction &psbtx,
                                   bool &complete) const override {
             return m_wallet->FillPSBT(psbtx, complete, sighash_type, sign,
                                       bip32derivs);
         }
         WalletBalances getBalances() override {
             const auto bal = m_wallet->GetBalance();
             WalletBalances result;
             result.balance = bal.m_mine_trusted;
             result.unconfirmed_balance = bal.m_mine_untrusted_pending;
             result.immature_balance = bal.m_mine_immature;
             result.have_watch_only = haveWatchOnly();
             if (result.have_watch_only) {
                 result.watch_only_balance = bal.m_watchonly_trusted;
                 result.unconfirmed_watch_only_balance =
                     bal.m_watchonly_untrusted_pending;
                 result.immature_watch_only_balance = bal.m_watchonly_immature;
             }
             return result;
         }
         bool tryGetBalances(WalletBalances &balances,
-                            int &num_blocks) override {
+                            BlockHash &block_hash) override {
             TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
-            num_blocks = m_wallet->GetLastBlockHeight();
+            block_hash = m_wallet->GetLastBlockHash();
             balances = getBalances();
             return true;
         }
         Amount getBalance() override {
             return m_wallet->GetBalance().m_mine_trusted;
         }
         Amount getAvailableBalance(const CCoinControl &coin_control) override {
             return m_wallet->GetAvailableBalance(&coin_control);
         }
         isminetype txinIsMine(const CTxIn &txin) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsMine(txin);
         }
         isminetype txoutIsMine(const CTxOut &txout) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsMine(txout);
         }
         Amount getDebit(const CTxIn &txin, isminefilter filter) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->GetDebit(txin, filter);
         }
         Amount getCredit(const CTxOut &txout, isminefilter filter) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->GetCredit(txout, filter);
         }
         CoinsList listCoins() override {
             LOCK(m_wallet->cs_wallet);
             CoinsList result;
             for (const auto &entry : m_wallet->ListCoins()) {
                 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));
                 }
             }
             return result;
         }
         std::vector<WalletTxOut>
         getCoins(const std::vector<COutPoint> &outputs) override {
             LOCK(m_wallet->cs_wallet);
             std::vector<WalletTxOut> result;
             result.reserve(outputs.size());
             for (const auto &output : outputs) {
                 result.emplace_back();
                 auto it = m_wallet->mapWallet.find(output.GetTxId());
                 if (it != m_wallet->mapWallet.end()) {
                     int depth = it->second.GetDepthInMainChain();
                     if (depth >= 0) {
                         result.back() = MakeWalletTxOut(*m_wallet, it->second,
                                                         output.GetN(), depth);
                     }
                 }
             }
             return result;
         }
         bool hdEnabled() override { return m_wallet->IsHDEnabled(); }
         OutputType getDefaultAddressType() override {
             return m_wallet->m_default_address_type;
         }
         bool canGetAddresses() const override {
             return m_wallet->CanGetAddresses();
         }
         bool privateKeysDisabled() override {
             return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
         }
         OutputType getDefaultChangeType() override {
             return m_wallet->m_default_change_type;
         }
         Amount getDefaultMaxTxFee() override {
             return m_wallet->m_default_max_tx_fee;
         }
         void remove() override { RemoveWallet(m_wallet); }
         bool isLegacy() override { return m_wallet->IsLegacy(); }
         std::unique_ptr<Handler> handleUnload(UnloadFn fn) override {
             return MakeHandler(m_wallet->NotifyUnload.connect(fn));
         }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
             return MakeHandler(m_wallet->ShowProgress.connect(fn));
         }
         std::unique_ptr<Handler>
         handleStatusChanged(StatusChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyStatusChanged.connect(
                 [fn](CWallet *) { fn(); }));
         }
         std::unique_ptr<Handler>
         handleAddressBookChanged(AddressBookChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyAddressBookChanged.connect(
                 [fn](CWallet *, const CTxDestination &address,
                      const std::string &label, bool is_mine,
                      const std::string &purpose, ChangeType status) {
                     fn(address, label, is_mine, purpose, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleTransactionChanged(TransactionChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyTransactionChanged.connect(
                 [fn](CWallet *, const TxId &txid, ChangeType status) {
                     fn(txid, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleWatchOnlyChanged(WatchOnlyChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyWatchonlyChanged.connect(fn));
         }
         std::unique_ptr<Handler>
         handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) override {
             return MakeHandler(
                 m_wallet->NotifyCanGetAddressesChanged.connect(fn));
         }
         Amount getRequiredFee(unsigned int tx_bytes) override {
             return GetRequiredFee(*m_wallet, tx_bytes);
         }
         Amount getMinimumFee(unsigned int tx_bytes,
                              const CCoinControl &coin_control) override {
             return GetMinimumFee(*m_wallet, tx_bytes, coin_control);
         }
         CWallet *wallet() override { return m_wallet.get(); }
 
         std::shared_ptr<CWallet> m_wallet;
     };
 
     class WalletClientImpl : public ChainClient {
     public:
         WalletClientImpl(Chain &chain, ArgsManager &args,
                          std::vector<std::string> wallet_filenames)
             : m_wallet_filenames(std::move(wallet_filenames)) {
             m_context.chain = &chain;
             m_context.args = &args;
         }
 
         void registerRpcs(const Span<const CRPCCommand> &commands) {
             for (const CRPCCommand &command : commands) {
                 m_rpc_commands.emplace_back(
                     command.category, command.name,
                     [this, &command](Config &config,
                                      const JSONRPCRequest &request,
                                      UniValue &result, bool last_handler) {
                         return command.actor(config, {request, m_context},
                                              result, last_handler);
                     },
                     command.argNames, command.unique_id);
                 m_rpc_handlers.emplace_back(
                     m_context.chain->handleRpc(m_rpc_commands.back()));
             }
         }
 
         void registerRpcs() override {
             registerRpcs(GetWalletRPCCommands());
             registerRpcs(GetWalletDumpRPCCommands());
         }
         bool verify(const CChainParams &chainParams) override {
             return VerifyWallets(chainParams, *m_context.chain,
                                  m_wallet_filenames);
         }
         bool load(const CChainParams &chainParams) override {
             return LoadWallets(chainParams, *m_context.chain,
                                m_wallet_filenames);
         }
         void start(CScheduler &scheduler) override {
             return StartWallets(scheduler, *Assert(m_context.args));
         }
         void flush() override { return FlushWallets(); }
         void stop() override { return StopWallets(); }
         void setMockTime(int64_t time) override { return SetMockTime(time); }
         std::vector<std::unique_ptr<Wallet>> getWallets() override {
             std::vector<std::unique_ptr<Wallet>> wallets;
             for (const auto &wallet : GetWallets()) {
                 wallets.emplace_back(MakeWallet(wallet));
             }
             return wallets;
         }
         ~WalletClientImpl() override { UnloadWallets(); }
 
         WalletContext m_context;
         const std::vector<std::string> m_wallet_filenames;
         std::vector<std::unique_ptr<Handler>> m_rpc_handlers;
         std::list<CRPCCommand> m_rpc_commands;
     };
 
 } // namespace
 
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet) {
     return wallet ? std::make_unique<WalletImpl>(wallet) : nullptr;
 }
 
 std::unique_ptr<ChainClient>
 MakeWalletClient(Chain &chain, ArgsManager &args,
                  std::vector<std::string> wallet_filenames) {
     return std::make_unique<WalletClientImpl>(chain, args,
                                               std::move(wallet_filenames));
 }
 
 } // namespace interfaces
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 2abcba22d..cafd973d2 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -1,381 +1,383 @@
 // 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.
 
 #ifndef BITCOIN_INTERFACES_WALLET_H
 #define BITCOIN_INTERFACES_WALLET_H
 
-#include <amount.h>                 // For Amount
+#include <amount.h> // For Amount
+#include <primitives/blockhash.h>
 #include <primitives/transaction.h> // For CTxOut
 #include <pubkey.h> // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/sighashtype.h>
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
 #include <util/message.h>
 #include <util/ui_change_type.h>
 
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 class CChainParams;
 class CCoinControl;
 class CKey;
 class CMutableTransaction;
 class COutPoint;
 class CTransaction;
 class CWallet;
 enum class FeeReason;
 enum class OutputType;
 enum class TransactionError;
 enum isminetype : unsigned int;
 struct CRecipient;
 struct PartiallySignedTransaction;
 typedef uint8_t isminefilter;
 struct TxId;
 struct bilingual_str;
 
 namespace interfaces {
 
 class Handler;
 struct WalletAddress;
 struct WalletBalances;
 struct WalletTx;
 struct WalletTxOut;
 struct WalletTxStatus;
 
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
 
 //! Interface for accessing a wallet.
 class Wallet {
 public:
     virtual ~Wallet() {}
 
     //! Encrypt wallet.
     virtual bool encryptWallet(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is encrypted.
     virtual bool isCrypted() = 0;
 
     //! Lock wallet.
     virtual bool lock() = 0;
 
     //! Unlock wallet.
     virtual bool unlock(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is locked.
     virtual bool isLocked() = 0;
 
     //! Change wallet passphrase.
     virtual bool
     changeWalletPassphrase(const SecureString &old_wallet_passphrase,
                            const SecureString &new_wallet_passphrase) = 0;
 
     //! Abort a rescan.
     virtual void abortRescan() = 0;
 
     //! Back up wallet.
     virtual bool backupWallet(const std::string &filename) = 0;
 
     //! Get wallet name.
     virtual std::string getWalletName() = 0;
 
     //! Get chainparams.
     virtual const CChainParams &getChainParams() = 0;
 
     //! Get set of addresses corresponding to a given label.
     virtual std::set<CTxDestination>
     getLabelAddresses(const std::string &label) = 0;
 
     // Get a new address.
     virtual bool getNewDestination(const OutputType type,
                                    const std::string label,
                                    CTxDestination &dest) = 0;
 
     //! Get public key.
     virtual bool getPubKey(const CScript &script, const CKeyID &address,
                            CPubKey &pub_key) = 0;
 
     //! Sign message
     virtual SigningResult signMessage(const std::string &message,
                                       const PKHash &pkhash,
                                       std::string &str_sig) = 0;
 
     //! Return whether wallet has private key.
     virtual bool isSpendable(const CTxDestination &dest) = 0;
 
     //! Return whether wallet has watch only keys.
     virtual bool haveWatchOnly() = 0;
 
     //! Add or update address.
     virtual bool setAddressBook(const CTxDestination &dest,
                                 const std::string &name,
                                 const std::string &purpose) = 0;
 
     // Remove address.
     virtual bool delAddressBook(const CTxDestination &dest) = 0;
 
     //! Look up address in wallet, return whether exists.
     virtual bool getAddress(const CTxDestination &dest, std::string *name,
                             isminetype *is_mine, std::string *purpose) = 0;
 
     //! Get wallet address list.
     virtual std::vector<WalletAddress> getAddresses() = 0;
 
     //! Add dest data.
     virtual bool addDestData(const CTxDestination &dest, const std::string &key,
                              const std::string &value) = 0;
 
     //! Erase dest data.
     virtual bool eraseDestData(const CTxDestination &dest,
                                const std::string &key) = 0;
 
     //! Get dest values with prefix.
     virtual std::vector<std::string>
     getDestValues(const std::string &prefix) = 0;
 
     //! Lock coin.
     virtual void lockCoin(const COutPoint &output) = 0;
 
     //! Unlock coin.
     virtual void unlockCoin(const COutPoint &output) = 0;
 
     //! Return whether coin is locked.
     virtual bool isLockedCoin(const COutPoint &output) = 0;
 
     //! List locked coins.
     virtual void listLockedCoins(std::vector<COutPoint> &outputs) = 0;
 
     //! Create transaction.
     virtual CTransactionRef
     createTransaction(const std::vector<CRecipient> &recipients,
                       const CCoinControl &coin_control, bool sign,
                       int &change_pos, Amount &fee,
                       bilingual_str &fail_reason) = 0;
 
     //! Commit transaction.
     virtual void commitTransaction(CTransactionRef tx, WalletValueMap value_map,
                                    WalletOrderForm order_form) = 0;
 
     //! Return whether transaction can be abandoned.
     virtual bool transactionCanBeAbandoned(const TxId &txid) = 0;
 
     //! Abandon transaction.
     virtual bool abandonTransaction(const TxId &txid) = 0;
 
     //! Get a transaction.
     virtual CTransactionRef getTx(const TxId &txid) = 0;
 
     //! Get transaction information.
     virtual WalletTx getWalletTx(const TxId &txid) = 0;
 
     //! Get list of all wallet transactions.
     virtual std::vector<WalletTx> getWalletTxs() = 0;
 
     //! Try to get updated status for a particular transaction, if possible
     //! without blocking.
     virtual bool tryGetTxStatus(const TxId &txid, WalletTxStatus &tx_status,
                                 int &num_blocks, int64_t &block_time) = 0;
 
     //! Get transaction details.
     virtual WalletTx getWalletTxDetails(const TxId &txid,
                                         WalletTxStatus &tx_status,
                                         WalletOrderForm &order_form,
                                         bool &in_mempool, int &num_blocks) = 0;
 
     //! Fill PSBT.
     virtual TransactionError fillPSBT(SigHashType sighash_type, bool sign,
                                       bool bip32derivs,
                                       PartiallySignedTransaction &psbtx,
                                       bool &complete) const = 0;
 
     //! Get balances.
     virtual WalletBalances getBalances() = 0;
 
     //! Get balances if possible without blocking.
-    virtual bool tryGetBalances(WalletBalances &balances, int &num_blocks) = 0;
+    virtual bool tryGetBalances(WalletBalances &balances,
+                                BlockHash &block_hash) = 0;
 
     //! Get balance.
     virtual Amount getBalance() = 0;
 
     //! Get available balance.
     virtual Amount getAvailableBalance(const CCoinControl &coin_control) = 0;
 
     //! Return whether transaction input belongs to wallet.
     virtual isminetype txinIsMine(const CTxIn &txin) = 0;
 
     //! Return whether transaction output belongs to wallet.
     virtual isminetype txoutIsMine(const CTxOut &txout) = 0;
 
     //! Return debit amount if transaction input belongs to wallet.
     virtual Amount getDebit(const CTxIn &txin, isminefilter filter) = 0;
 
     //! Return credit amount if transaction input belongs to wallet.
     virtual Amount getCredit(const CTxOut &txout, isminefilter filter) = 0;
 
     //! Return AvailableCoins + LockedCoins grouped by wallet address.
     //! (put change in one group with wallet address)
     using CoinsList = std::map<CTxDestination,
                                std::vector<std::tuple<COutPoint, WalletTxOut>>>;
     virtual CoinsList listCoins() = 0;
 
     //! Return wallet transaction output information.
     virtual std::vector<WalletTxOut>
     getCoins(const std::vector<COutPoint> &outputs) = 0;
 
     //! Get required fee.
     virtual Amount getRequiredFee(unsigned int tx_bytes) = 0;
 
     //! Get minimum fee.
     virtual Amount getMinimumFee(unsigned int tx_bytes,
                                  const CCoinControl &coin_control) = 0;
 
     // Return whether HD enabled.
     virtual bool hdEnabled() = 0;
 
     // Return whether the wallet is blank.
     virtual bool canGetAddresses() const = 0;
 
     // Return whether private keys enabled.
     virtual bool privateKeysDisabled() = 0;
 
     // Get default address type.
     virtual OutputType getDefaultAddressType() = 0;
 
     // Get default change type.
     virtual OutputType getDefaultChangeType() = 0;
 
     //! Get max tx fee.
     virtual Amount getDefaultMaxTxFee() = 0;
 
     // Remove wallet.
     virtual void remove() = 0;
 
     //! Return whether is a legacy wallet
     virtual bool isLegacy() = 0;
 
     //! Register handler for unload message.
     using UnloadFn = std::function<void()>;
     virtual std::unique_ptr<Handler> handleUnload(UnloadFn fn) = 0;
 
     //! Register handler for show progress messages.
     using ShowProgressFn =
         std::function<void(const std::string &title, int progress)>;
     virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
 
     //! Register handler for status changed messages.
     using StatusChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleStatusChanged(StatusChangedFn fn) = 0;
 
     //! Register handler for address book changed messages.
     using AddressBookChangedFn = std::function<void(
         const CTxDestination &address, const std::string &label, bool is_mine,
         const std::string &purpose, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleAddressBookChanged(AddressBookChangedFn fn) = 0;
 
     //! Register handler for transaction changed messages.
     using TransactionChangedFn =
         std::function<void(const TxId &txid, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleTransactionChanged(TransactionChangedFn fn) = 0;
 
     //! Register handler for watchonly changed messages.
     using WatchOnlyChangedFn = std::function<void(bool have_watch_only)>;
     virtual std::unique_ptr<Handler>
     handleWatchOnlyChanged(WatchOnlyChangedFn fn) = 0;
 
     //! Register handler for keypool changed messages.
     using CanGetAddressesChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) = 0;
 
     //! Return pointer to internal wallet class, useful for testing.
     virtual CWallet *wallet() { return nullptr; }
 };
 
 //! Information about one wallet address.
 struct WalletAddress {
     CTxDestination dest;
     isminetype is_mine;
     std::string name;
     std::string purpose;
 
     WalletAddress(CTxDestination destIn, isminetype isMineIn,
                   std::string nameIn, std::string purposeIn)
         : dest(std::move(destIn)), is_mine(isMineIn), name(std::move(nameIn)),
           purpose(std::move(purposeIn)) {}
 };
 
 //! Collection of wallet balances.
 struct WalletBalances {
     Amount balance = Amount::zero();
     Amount unconfirmed_balance = Amount::zero();
     Amount immature_balance = Amount::zero();
     bool have_watch_only = false;
     Amount watch_only_balance = Amount::zero();
     Amount unconfirmed_watch_only_balance = Amount::zero();
     Amount immature_watch_only_balance = Amount::zero();
 
     bool balanceChanged(const WalletBalances &prev) const {
         return balance != prev.balance ||
                unconfirmed_balance != prev.unconfirmed_balance ||
                immature_balance != prev.immature_balance ||
                watch_only_balance != prev.watch_only_balance ||
                unconfirmed_watch_only_balance !=
                    prev.unconfirmed_watch_only_balance ||
                immature_watch_only_balance != prev.immature_watch_only_balance;
     }
 };
 
 // Wallet transaction information.
 struct WalletTx {
     CTransactionRef tx;
     std::vector<isminetype> txin_is_mine;
     std::vector<isminetype> txout_is_mine;
     std::vector<CTxDestination> txout_address;
     std::vector<isminetype> txout_address_is_mine;
     Amount credit;
     Amount debit;
     Amount change;
     int64_t time;
     std::map<std::string, std::string> value_map;
     bool is_coinbase;
 };
 
 //! Updated transaction status.
 struct WalletTxStatus {
     int block_height;
     int blocks_to_maturity;
     int depth_in_main_chain;
     unsigned int time_received;
     uint32_t lock_time;
     bool is_final;
     bool is_trusted;
     bool is_abandoned;
     bool is_coinbase;
     bool is_in_main_chain;
 };
 
 //! Wallet transaction output.
 struct WalletTxOut {
     CTxOut txout;
     int64_t time;
     int depth_in_main_chain = -1;
     bool is_spent = false;
 };
 
 //! Return implementation of Wallet interface. This function is defined in
 //! dummywallet.cpp and throws if the wallet component is not compiled.
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet);
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_WALLET_H
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
index 096586ad1..cc989163f 100644
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -1,298 +1,325 @@
 // Copyright (c) 2011-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 <qt/clientmodel.h>
 
 #include <checkpoints.h>
 #include <clientversion.h>
 #include <config.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <net.h>
 #include <netbase.h>
 #include <qt/bantablemodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/peertablemodel.h>
 #include <util/system.h>
 #include <validation.h>
 
 #include <QDebug>
 #include <QThread>
 #include <QTimer>
 
 #include <cstdint>
 
 static int64_t nLastHeaderTipUpdateNotification = 0;
 static int64_t nLastBlockTipUpdateNotification = 0;
 
 ClientModel::ClientModel(interfaces::Node &node, OptionsModel *_optionsModel,
                          QObject *parent)
     : QObject(parent), m_node(node), optionsModel(_optionsModel),
       peerTableModel(nullptr), banTableModel(nullptr),
       m_thread(new QThread(this)) {
     cachedBestHeaderHeight = -1;
     cachedBestHeaderTime = -1;
     peerTableModel = new PeerTableModel(m_node, this);
     banTableModel = new BanTableModel(m_node, this);
 
     QTimer *timer = new QTimer;
     timer->setInterval(MODEL_UPDATE_DELAY);
     connect(timer, &QTimer::timeout, [this] {
         // no locking required at this point
         // the following calls will acquire the required lock
         Q_EMIT mempoolSizeChanged(m_node.getMempoolSize(),
                                   m_node.getMempoolDynamicUsage());
         Q_EMIT bytesChanged(m_node.getTotalBytesRecv(),
                             m_node.getTotalBytesSent());
     });
     connect(m_thread, &QThread::finished, timer, &QObject::deleteLater);
     connect(m_thread, &QThread::started, [timer] { timer->start(); });
     // move timer to thread so that polling doesn't disturb main event loop
     timer->moveToThread(m_thread);
     m_thread->start();
 
     subscribeToCoreSignals();
 }
 
 ClientModel::~ClientModel() {
     unsubscribeFromCoreSignals();
 
     m_thread->quit();
     m_thread->wait();
 }
 
 int ClientModel::getNumConnections(NumConnections flags) const {
     CConnman::NumConnections connections = CConnman::CONNECTIONS_NONE;
 
     if (flags == CONNECTIONS_IN) {
         connections = CConnman::CONNECTIONS_IN;
     } else if (flags == CONNECTIONS_OUT) {
         connections = CConnman::CONNECTIONS_OUT;
     } else if (flags == CONNECTIONS_ALL) {
         connections = CConnman::CONNECTIONS_ALL;
     }
 
     return m_node.getNodeCount(connections);
 }
 
 int ClientModel::getHeaderTipHeight() const {
     if (cachedBestHeaderHeight == -1) {
         // make sure we initially populate the cache via a cs_main lock
         // otherwise we need to wait for a tip update
         int height;
         int64_t blockTime;
         if (m_node.getHeaderTip(height, blockTime)) {
             cachedBestHeaderHeight = height;
             cachedBestHeaderTime = blockTime;
         }
     }
     return cachedBestHeaderHeight;
 }
 
 int64_t ClientModel::getHeaderTipTime() const {
     if (cachedBestHeaderTime == -1) {
         int height;
         int64_t blockTime;
         if (m_node.getHeaderTip(height, blockTime)) {
             cachedBestHeaderHeight = height;
             cachedBestHeaderTime = blockTime;
         }
     }
     return cachedBestHeaderTime;
 }
 
 int ClientModel::getNumBlocks() const {
     if (m_cached_num_blocks == -1) {
         m_cached_num_blocks = m_node.getNumBlocks();
     }
     return m_cached_num_blocks;
 }
 
+BlockHash ClientModel::getBestBlockHash() {
+    BlockHash tip{WITH_LOCK(m_cached_tip_mutex, return m_cached_tip_blocks)};
+
+    if (!tip.IsNull()) {
+        return tip;
+    }
+
+    // Lock order must be: first `cs_main`, then `m_cached_tip_mutex`.
+    // The following will lock `cs_main` (and release it), so we must not
+    // own `m_cached_tip_mutex` here.
+    tip = m_node.getBestBlockHash();
+
+    LOCK(m_cached_tip_mutex);
+    // We checked that `m_cached_tip_blocks` is not null above, but then we
+    // released the mutex `m_cached_tip_mutex`, so it could have changed in the
+    // meantime. Thus, check again.
+    if (m_cached_tip_blocks.IsNull()) {
+        m_cached_tip_blocks = tip;
+    }
+    return m_cached_tip_blocks;
+}
+
 void ClientModel::updateNumConnections(int numConnections) {
     Q_EMIT numConnectionsChanged(numConnections);
 }
 
 void ClientModel::updateNetworkActive(bool networkActive) {
     Q_EMIT networkActiveChanged(networkActive);
 }
 
 void ClientModel::updateAlert() {
     Q_EMIT alertsChanged(getStatusBarWarnings());
 }
 
 enum BlockSource ClientModel::getBlockSource() const {
     if (m_node.getReindex()) {
         return BlockSource::REINDEX;
     } else if (m_node.getImporting()) {
         return BlockSource::DISK;
     } else if (getNumConnections() > 0) {
         return BlockSource::NETWORK;
     }
 
     return BlockSource::NONE;
 }
 
 QString ClientModel::getStatusBarWarnings() const {
     return QString::fromStdString(m_node.getWarnings());
 }
 
 OptionsModel *ClientModel::getOptionsModel() {
     return optionsModel;
 }
 
 PeerTableModel *ClientModel::getPeerTableModel() {
     return peerTableModel;
 }
 
 BanTableModel *ClientModel::getBanTableModel() {
     return banTableModel;
 }
 
 QString ClientModel::formatFullVersion() const {
     return QString::fromStdString(FormatFullVersion());
 }
 
 QString ClientModel::formatSubVersion() const {
     return QString::fromStdString(userAgent(GetConfig()));
 }
 
 bool ClientModel::isReleaseVersion() const {
     return CLIENT_VERSION_IS_RELEASE;
 }
 
 QString ClientModel::formatClientStartupTime() const {
     return QDateTime::fromTime_t(GetStartupTime()).toString();
 }
 
 QString ClientModel::dataDir() const {
     return GUIUtil::boostPathToQString(GetDataDir());
 }
 
 QString ClientModel::blocksDir() const {
     return GUIUtil::boostPathToQString(GetBlocksDir());
 }
 
 void ClientModel::updateBanlist() {
     banTableModel->refresh();
 }
 
 // Handlers for core signals
 static void ShowProgress(ClientModel *clientmodel, const std::string &title,
                          int nProgress) {
     // emits signal "showProgress"
     bool invoked = QMetaObject::invokeMethod(
         clientmodel, "showProgress", Qt::QueuedConnection,
         Q_ARG(QString, QString::fromStdString(title)), Q_ARG(int, nProgress));
     assert(invoked);
 }
 
 static void NotifyNumConnectionsChanged(ClientModel *clientmodel,
                                         int newNumConnections) {
     // Too noisy: qDebug() << "NotifyNumConnectionsChanged: " +
     // QString::number(newNumConnections);
     bool invoked = QMetaObject::invokeMethod(
         clientmodel, "updateNumConnections", Qt::QueuedConnection,
         Q_ARG(int, newNumConnections));
     assert(invoked);
 }
 
 static void NotifyNetworkActiveChanged(ClientModel *clientmodel,
                                        bool networkActive) {
     bool invoked = QMetaObject::invokeMethod(clientmodel, "updateNetworkActive",
                                              Qt::QueuedConnection,
                                              Q_ARG(bool, networkActive));
     assert(invoked);
 }
 
 static void NotifyAlertChanged(ClientModel *clientmodel) {
     qDebug() << "NotifyAlertChanged";
     bool invoked = QMetaObject::invokeMethod(clientmodel, "updateAlert",
                                              Qt::QueuedConnection);
     assert(invoked);
 }
 
 static void BannedListChanged(ClientModel *clientmodel) {
     qDebug() << QString("%1: Requesting update for peer banlist").arg(__func__);
     bool invoked = QMetaObject::invokeMethod(clientmodel, "updateBanlist",
                                              Qt::QueuedConnection);
     assert(invoked);
 }
 
 static void BlockTipChanged(ClientModel *clientmodel,
-                            SynchronizationState sync_state, int height,
+                            SynchronizationState sync_state,
+                            const BlockHash block_hash, int height,
                             int64_t blockTime, double verificationProgress,
                             bool fHeader) {
     if (fHeader) {
         // cache best headers time and height to reduce future cs_main locks
         clientmodel->cachedBestHeaderHeight = height;
         clientmodel->cachedBestHeaderTime = blockTime;
     } else {
         clientmodel->m_cached_num_blocks = height;
+        WITH_LOCK(clientmodel->m_cached_tip_mutex,
+                  clientmodel->m_cached_tip_blocks = block_hash;);
     }
 
     // Throttle GUI notifications about (a) blocks during initial sync, and (b)
     // both blocks and headers during reindex.
     const bool throttle =
         (sync_state != SynchronizationState::POST_INIT && !fHeader) ||
         sync_state == SynchronizationState::INIT_REINDEX;
     const int64_t now = throttle ? GetTimeMillis() : 0;
     int64_t &nLastUpdateNotification = fHeader
                                            ? nLastHeaderTipUpdateNotification
                                            : nLastBlockTipUpdateNotification;
     if (throttle && now < nLastUpdateNotification + MODEL_UPDATE_DELAY) {
         return;
     }
 
     bool invoked = QMetaObject::invokeMethod(
         clientmodel, "numBlocksChanged", Qt::QueuedConnection,
         Q_ARG(int, height), Q_ARG(QDateTime, QDateTime::fromTime_t(blockTime)),
         Q_ARG(double, verificationProgress), Q_ARG(bool, fHeader),
         Q_ARG(SynchronizationState, sync_state));
     assert(invoked);
     nLastUpdateNotification = now;
 }
 
 void ClientModel::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_show_progress = m_node.handleShowProgress(std::bind(
         ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
     m_handler_notify_num_connections_changed =
         m_node.handleNotifyNumConnectionsChanged(std::bind(
             NotifyNumConnectionsChanged, this, std::placeholders::_1));
     m_handler_notify_network_active_changed =
         m_node.handleNotifyNetworkActiveChanged(
             std::bind(NotifyNetworkActiveChanged, this, std::placeholders::_1));
     m_handler_notify_alert_changed =
         m_node.handleNotifyAlertChanged(std::bind(NotifyAlertChanged, this));
     m_handler_banned_list_changed =
         m_node.handleBannedListChanged(std::bind(BannedListChanged, this));
-    m_handler_notify_block_tip = m_node.handleNotifyBlockTip(std::bind(
-        BlockTipChanged, this, std::placeholders::_1, std::placeholders::_2,
-        std::placeholders::_3, std::placeholders::_4, false));
-    m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(std::bind(
-        BlockTipChanged, this, std::placeholders::_1, std::placeholders::_2,
-        std::placeholders::_3, std::placeholders::_4, true));
+    m_handler_notify_block_tip = m_node.handleNotifyBlockTip(
+        std::bind(BlockTipChanged, this, std::placeholders::_1,
+                  std::placeholders::_2, std::placeholders::_3,
+                  std::placeholders::_4, std::placeholders::_5, false));
+    m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(
+        std::bind(BlockTipChanged, this, std::placeholders::_1,
+                  std::placeholders::_2, std::placeholders::_3,
+                  std::placeholders::_4, std::placeholders::_5, true));
 }
 
 void ClientModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_show_progress->disconnect();
     m_handler_notify_num_connections_changed->disconnect();
     m_handler_notify_network_active_changed->disconnect();
     m_handler_notify_alert_changed->disconnect();
     m_handler_banned_list_changed->disconnect();
     m_handler_notify_block_tip->disconnect();
     m_handler_notify_header_tip->disconnect();
 }
 
 bool ClientModel::getProxyInfo(std::string &ip_port) const {
     proxyType ipv4, ipv6;
     if (m_node.getProxy((Network)1, ipv4) &&
         m_node.getProxy((Network)2, ipv6)) {
         ip_port = ipv4.proxy.ToStringIPPort();
         return true;
     }
     return false;
 }
diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
index 4c168667e..370f1cd71 100644
--- a/src/qt/clientmodel.h
+++ b/src/qt/clientmodel.h
@@ -1,124 +1,130 @@
 // Copyright (c) 2011-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_QT_CLIENTMODEL_H
 #define BITCOIN_QT_CLIENTMODEL_H
 
 #include <QDateTime>
 #include <QObject>
 
 #include <atomic>
 #include <memory>
+#include <primitives/blockhash.h>
+#include <sync.h>
 
 class BanTableModel;
 class CBlockIndex;
 class OptionsModel;
 class PeerTableModel;
 
 class CBlockIndex;
 enum class SynchronizationState;
 
 namespace interfaces {
 class Handler;
 class Node;
 } // namespace interfaces
 
 QT_BEGIN_NAMESPACE
 class QTimer;
 QT_END_NAMESPACE
 
 enum class BlockSource { NONE, REINDEX, DISK, NETWORK };
 
 /** Model for Bitcoin network client. */
 class ClientModel : public QObject {
     Q_OBJECT
 
 public:
     enum NumConnections {
         CONNECTIONS_NONE = 0,
         CONNECTIONS_IN = (1U << 0),
         CONNECTIONS_OUT = (1U << 1),
         CONNECTIONS_ALL = (CONNECTIONS_IN | CONNECTIONS_OUT),
     };
 
     explicit ClientModel(interfaces::Node &node, OptionsModel *optionsModel,
                          QObject *parent = nullptr);
     ~ClientModel();
 
     interfaces::Node &node() const { return m_node; }
     OptionsModel *getOptionsModel();
     PeerTableModel *getPeerTableModel();
     BanTableModel *getBanTableModel();
 
     //! Return number of connections, default is in- and outbound (total)
     int getNumConnections(NumConnections flags = CONNECTIONS_ALL) const;
     int getNumBlocks() const;
+    BlockHash getBestBlockHash();
     int getHeaderTipHeight() const;
     int64_t getHeaderTipTime() const;
 
     //! Returns enum BlockSource of the current importing/syncing state
     enum BlockSource getBlockSource() const;
     //! Return warnings to be displayed in status bar
     QString getStatusBarWarnings() const;
 
     QString formatFullVersion() const;
     QString formatSubVersion() const;
     bool isReleaseVersion() const;
     QString formatClientStartupTime() const;
     QString dataDir() const;
     QString blocksDir() const;
 
     bool getProxyInfo(std::string &ip_port) const;
 
     // caches for the best header, number of blocks
     mutable std::atomic<int> cachedBestHeaderHeight;
     mutable std::atomic<int64_t> cachedBestHeaderTime;
     mutable std::atomic<int> m_cached_num_blocks{-1};
 
+    Mutex m_cached_tip_mutex;
+    BlockHash m_cached_tip_blocks GUARDED_BY(m_cached_tip_mutex){};
+
 private:
     interfaces::Node &m_node;
     std::unique_ptr<interfaces::Handler> m_handler_show_progress;
     std::unique_ptr<interfaces::Handler>
         m_handler_notify_num_connections_changed;
     std::unique_ptr<interfaces::Handler>
         m_handler_notify_network_active_changed;
     std::unique_ptr<interfaces::Handler> m_handler_notify_alert_changed;
     std::unique_ptr<interfaces::Handler> m_handler_banned_list_changed;
     std::unique_ptr<interfaces::Handler> m_handler_notify_block_tip;
     std::unique_ptr<interfaces::Handler> m_handler_notify_header_tip;
     OptionsModel *optionsModel;
     PeerTableModel *peerTableModel;
     BanTableModel *banTableModel;
 
     //! A thread to interact with m_node asynchronously
     QThread *const m_thread;
 
     void subscribeToCoreSignals();
     void unsubscribeFromCoreSignals();
 
 Q_SIGNALS:
     void numConnectionsChanged(int count);
     void numBlocksChanged(int count, const QDateTime &blockDate,
                           double nVerificationProgress, bool header,
                           SynchronizationState sync_state);
     void mempoolSizeChanged(long count, size_t mempoolSizeInBytes);
     void networkActiveChanged(bool networkActive);
     void alertsChanged(const QString &warnings);
     void bytesChanged(quint64 totalBytesIn, quint64 totalBytesOut);
 
     //! Fired when a message should be reported to the user
     void message(const QString &title, const QString &message,
                  unsigned int style);
 
     // Show progress dialog e.g. for verifychain
     void showProgress(const QString &title, int nProgress);
 
 public Q_SLOTS:
     void updateNumConnections(int numConnections);
     void updateNetworkActive(bool networkActive);
     void updateAlert();
     void updateBanlist();
 };
 
 #endif // BITCOIN_QT_CLIENTMODEL_H
diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
index bab086589..2dfd45f81 100644
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -1,225 +1,226 @@
 // Copyright (c) 2011-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 <qt/transactionrecord.h>
 
 #include <cashaddrenc.h>
 #include <chain.h>       // For MAX_BLOCK_TIME_GAP
 #include <chainparams.h> // For Params()
 #include <interfaces/wallet.h>
 #include <key_io.h>
 #include <wallet/ismine.h>
 
 #include <QDateTime>
 
 #include <cstdint>
 
 /**
  * Return positive answer if transaction should be shown in list.
  */
 bool TransactionRecord::showTransaction() {
     // There are currently no cases where we hide transactions, but we may want
     // to use this in the future for things like RBF.
     return true;
 }
 
 /**
  * Decompose CWallet transaction to model transaction records.
  */
 QList<TransactionRecord>
 TransactionRecord::decomposeTransaction(const interfaces::WalletTx &wtx) {
     QList<TransactionRecord> parts;
     int64_t nTime = wtx.time;
     Amount nCredit = wtx.credit;
     Amount nDebit = wtx.debit;
     Amount nNet = nCredit - nDebit;
     const TxId &txid = wtx.tx->GetId();
     std::map<std::string, std::string> mapValue = wtx.value_map;
 
     if (nNet > Amount::zero() || wtx.is_coinbase) {
         //
         // Credit
         //
         for (size_t i = 0; i < wtx.tx->vout.size(); i++) {
             const CTxOut &txout = wtx.tx->vout[i];
             isminetype mine = wtx.txout_is_mine[i];
             if (mine) {
                 TransactionRecord sub(txid, nTime);
                 CTxDestination address;
                 sub.idx = i; // vout index
                 sub.credit = txout.nValue;
                 sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
                 if (wtx.txout_address_is_mine[i]) {
                     // Received by Bitcoin Address
                     sub.type = TransactionRecord::RecvWithAddress;
                     sub.address =
                         EncodeCashAddr(wtx.txout_address[i], Params());
                 } else {
                     // Received by IP connection (deprecated features), or a
                     // multisignature or other non-simple transaction
                     sub.type = TransactionRecord::RecvFromOther;
                     sub.address = mapValue["from"];
                 }
                 if (wtx.is_coinbase) {
                     // Generated
                     sub.type = TransactionRecord::Generated;
                 }
 
                 parts.append(sub);
             }
         }
     } else {
         bool involvesWatchAddress = false;
         isminetype fAllFromMe = ISMINE_SPENDABLE;
         for (const isminetype mine : wtx.txin_is_mine) {
             if (mine & ISMINE_WATCH_ONLY) {
                 involvesWatchAddress = true;
             }
             if (fAllFromMe > mine) {
                 fAllFromMe = mine;
             }
         }
 
         isminetype fAllToMe = ISMINE_SPENDABLE;
         for (const isminetype mine : wtx.txout_is_mine) {
             if (mine & ISMINE_WATCH_ONLY) {
                 involvesWatchAddress = true;
             }
             if (fAllToMe > mine) {
                 fAllToMe = mine;
             }
         }
 
         if (fAllFromMe && fAllToMe) {
             // Payment to self
             std::string address;
             for (auto it = wtx.txout_address.begin();
                  it != wtx.txout_address.end(); ++it) {
                 if (it != wtx.txout_address.begin()) {
                     address += ", ";
                 }
                 address += EncodeCashAddr(*it, Params());
             }
             Amount nChange = wtx.change;
             parts.append(TransactionRecord(
                 txid, nTime, TransactionRecord::SendToSelf, address,
                 -(nDebit - nChange), nCredit - nChange));
 
             // maybe pass to TransactionRecord as constructor argument
             parts.last().involvesWatchAddress = involvesWatchAddress;
         } else if (fAllFromMe) {
             //
             // Debit
             //
             Amount nTxFee = nDebit - wtx.tx->GetValueOut();
 
             for (size_t nOut = 0; nOut < wtx.tx->vout.size(); nOut++) {
                 const CTxOut &txout = wtx.tx->vout[nOut];
                 TransactionRecord sub(txid, nTime);
                 sub.idx = nOut;
                 sub.involvesWatchAddress = involvesWatchAddress;
 
                 if (wtx.txout_is_mine[nOut]) {
                     // Ignore parts sent to self, as this is usually the change
                     // from a transaction sent back to our own address.
                     continue;
                 }
 
                 if (!boost::get<CNoDestination>(&wtx.txout_address[nOut])) {
                     // Sent to Bitcoin Address
                     sub.type = TransactionRecord::SendToAddress;
                     sub.address =
                         EncodeCashAddr(wtx.txout_address[nOut], Params());
                 } else {
                     // Sent to IP, or other non-address transaction like OP_EVAL
                     sub.type = TransactionRecord::SendToOther;
                     sub.address = mapValue["to"];
                 }
 
                 Amount nValue = txout.nValue;
                 /* Add fee to first output */
                 if (nTxFee > Amount::zero()) {
                     nValue += nTxFee;
                     nTxFee = Amount::zero();
                 }
                 sub.debit = -1 * nValue;
 
                 parts.append(sub);
             }
         } else {
             //
             // Mixed debit transaction, can't break down payees
             //
             parts.append(TransactionRecord(txid, nTime,
                                            TransactionRecord::Other, "", nNet,
                                            Amount::zero()));
             parts.last().involvesWatchAddress = involvesWatchAddress;
         }
     }
 
     return parts;
 }
 
 void TransactionRecord::updateStatus(const interfaces::WalletTxStatus &wtx,
-                                     int numBlocks, int64_t block_time) {
+                                     const BlockHash &block_hash, int numBlocks,
+                                     int64_t block_time) {
     // Determine transaction status
 
     // Sort order, unrecorded transactions sort to the top
     status.sortKey = strprintf("%010d-%01d-%010u-%03d", wtx.block_height,
                                wtx.is_coinbase ? 1 : 0, wtx.time_received, idx);
     status.countsForBalance = wtx.is_trusted && !(wtx.blocks_to_maturity > 0);
     status.depth = wtx.depth_in_main_chain;
-    status.cur_num_blocks = numBlocks;
+    status.m_cur_block_hash = block_hash;
 
     const bool up_to_date =
         (int64_t(QDateTime::currentMSecsSinceEpoch()) / 1000 - block_time <
          MAX_BLOCK_TIME_GAP);
     if (up_to_date && !wtx.is_final) {
         if (wtx.lock_time < LOCKTIME_THRESHOLD) {
             status.status = TransactionStatus::OpenUntilBlock;
             status.open_for = wtx.lock_time - numBlocks;
         } else {
             status.status = TransactionStatus::OpenUntilDate;
             status.open_for = wtx.lock_time;
         }
     } else if (type == TransactionRecord::Generated) {
         // For generated transactions, determine maturity
         if (wtx.blocks_to_maturity > 0) {
             status.status = TransactionStatus::Immature;
 
             if (wtx.is_in_main_chain) {
                 status.matures_in = wtx.blocks_to_maturity;
             } else {
                 status.status = TransactionStatus::NotAccepted;
             }
         } else {
             status.status = TransactionStatus::Confirmed;
         }
     } else {
         if (status.depth < 0) {
             status.status = TransactionStatus::Conflicted;
         } else if (status.depth == 0) {
             status.status = TransactionStatus::Unconfirmed;
             if (wtx.is_abandoned) {
                 status.status = TransactionStatus::Abandoned;
             }
         } else if (status.depth < RecommendedNumConfirmations) {
             status.status = TransactionStatus::Confirming;
         } else {
             status.status = TransactionStatus::Confirmed;
         }
     }
 }
 
-bool TransactionRecord::statusUpdateNeeded(int numBlocks) const {
-    return status.cur_num_blocks != numBlocks;
+bool TransactionRecord::statusUpdateNeeded(const BlockHash &block_hash) const {
+    return status.m_cur_block_hash != block_hash;
 }
 
 QString TransactionRecord::getTxID() const {
     return QString::fromStdString(txid.ToString());
 }
 
 int TransactionRecord::getOutputIndex() const {
     return idx;
 }
diff --git a/src/qt/transactionrecord.h b/src/qt/transactionrecord.h
index 77b797927..5f4caf70f 100644
--- a/src/qt/transactionrecord.h
+++ b/src/qt/transactionrecord.h
@@ -1,159 +1,162 @@
 // Copyright (c) 2011-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_QT_TRANSACTIONRECORD_H
 #define BITCOIN_QT_TRANSACTIONRECORD_H
 
 #include <amount.h>
+#include <primitives/blockhash.h>
 #include <primitives/txid.h>
 
 #include <QList>
 #include <QString>
 
 namespace interfaces {
 class Node;
 class Wallet;
 struct WalletTx;
 struct WalletTxStatus;
 } // namespace interfaces
 
 /**
  * UI model for transaction status. The transaction status is the part of a
  * transaction that will change over time.
  */
 class TransactionStatus {
 public:
     TransactionStatus()
         : countsForBalance(false), sortKey(""), matures_in(0),
-          status(Unconfirmed), depth(0), open_for(0), cur_num_blocks(-1) {}
+          status(Unconfirmed), depth(0), open_for(0) {}
 
     enum Status {
         /**
          * Have 6 or more confirmations (normal tx) or fully mature (mined tx)
          */
         Confirmed,
         /// Normal (sent/received) transactions
         /** Transaction not yet final, waiting for date */
         OpenUntilDate,
         /** Transaction not yet final, waiting for block */
         OpenUntilBlock,
         /** Not yet mined into a block **/
         Unconfirmed,
         /**
          * Confirmed, but waiting for the recommended number of confirmations
          */
         Confirming,
         /** Conflicts with other transaction or mempool */
         Conflicted,
         /** Abandoned from the wallet */
         Abandoned,
         /// Generated (mined) transactions
         /** Mined but waiting for maturity */
         Immature,
         /** Mined but not accepted */
         NotAccepted
     };
 
     /// Transaction counts towards available balance
     bool countsForBalance;
     /// Sorting key based on status
     std::string sortKey;
 
     /** @name Generated (mined) transactions
        @{*/
     int matures_in;
     /**@}*/
 
     /** @name Reported status
        @{*/
     Status status;
     qint64 depth;
     /**
      * Timestamp if status==OpenUntilDate, otherwise number of additional
      * blocks that need to be mined before finalization
      */
     qint64 open_for;
 
     /**@}*/
 
-    /** Current number of blocks (to know whether cached status is still valid)
+    /**
+     * Current block hash (to know whether cached status is still valid)
      */
-    int cur_num_blocks;
+    BlockHash m_cur_block_hash{};
 };
 
 /**
  * UI model for a transaction. A core transaction can be represented by multiple
  * UI transactions if it has multiple outputs.
  */
 class TransactionRecord {
 public:
     enum Type {
         Other,
         Generated,
         SendToAddress,
         SendToOther,
         RecvWithAddress,
         RecvFromOther,
         SendToSelf
     };
 
     /** Number of confirmation recommended for accepting a transaction */
     static const int RecommendedNumConfirmations = 6;
 
     TransactionRecord()
         : txid(), time(0), type(Other), address(""), debit(), credit(), idx(0) {
     }
 
     TransactionRecord(TxId _txid, qint64 _time)
         : txid(_txid), time(_time), type(Other), address(""), debit(), credit(),
           idx(0) {}
 
     TransactionRecord(TxId _txid, qint64 _time, Type _type,
                       const std::string &_address, const Amount _debit,
                       const Amount _credit)
         : txid(_txid), time(_time), type(_type), address(_address),
           debit(_debit), credit(_credit), idx(0) {}
 
     /** Decompose CWallet transaction to model transaction records.
      */
     static bool showTransaction();
     static QList<TransactionRecord>
     decomposeTransaction(const interfaces::WalletTx &wtx);
 
     /** @name Immutable transaction attributes
       @{*/
     TxId txid;
     qint64 time;
     Type type;
     std::string address;
     Amount debit;
     Amount credit;
     /**@}*/
 
     /** Subtransaction index, for sort key */
     int idx;
 
     /** Status: can change with block chain update */
     TransactionStatus status;
 
     /** Whether the transaction was sent/received with a watch-only address */
     bool involvesWatchAddress;
 
     /** Return the unique identifier for this transaction (part) */
     QString getTxID() const;
 
     /** Return the output index of the subtransaction  */
     int getOutputIndex() const;
 
     /** Update status from core wallet tx.
      */
-    void updateStatus(const interfaces::WalletTxStatus &wtx, int numBlocks,
+    void updateStatus(const interfaces::WalletTxStatus &wtx,
+                      const BlockHash &block_hash, int numBlocks,
                       int64_t block_time);
 
     /** Return whether a status update is needed.
      */
-    bool statusUpdateNeeded(int numBlocks) const;
+    bool statusUpdateNeeded(const BlockHash &block_hash) const;
 };
 
 #endif // BITCOIN_QT_TRANSACTIONRECORD_H
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
index 0e65bf6d8..d9605d72a 100644
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -1,779 +1,780 @@
 // Copyright (c) 2011-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 <qt/transactiontablemodel.h>
 
 #include <core_io.h>
 #include <interfaces/handler.h>
 #include <qt/addresstablemodel.h>
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/transactiondesc.h>
 #include <qt/transactionrecord.h>
 #include <qt/walletmodel.h>
 #include <uint256.h>
 
 #include <algorithm>
 
 #include <QColor>
 #include <QDateTime>
 #include <QDebug>
 #include <QIcon>
 #include <QList>
 
 // Amount column is right-aligned it contains numbers
 static int column_alignments[] = {
     Qt::AlignLeft | Qt::AlignVCenter, /* status */
     Qt::AlignLeft | Qt::AlignVCenter, /* watchonly */
     Qt::AlignLeft | Qt::AlignVCenter, /* date */
     Qt::AlignLeft | Qt::AlignVCenter, /* type */
     Qt::AlignLeft | Qt::AlignVCenter, /* address */
     Qt::AlignRight | Qt::AlignVCenter /* amount */
 };
 
 // Comparison operator for sort/binary search of model tx list
 struct TxLessThan {
     bool operator()(const TransactionRecord &a,
                     const TransactionRecord &b) const {
         return a.txid < b.txid;
     }
     bool operator()(const TransactionRecord &a, const TxId &b) const {
         return a.txid < b;
     }
     bool operator()(const TxId &a, const TransactionRecord &b) const {
         return a < b.txid;
     }
 };
 
 // Private implementation
 class TransactionTablePriv {
 public:
     explicit TransactionTablePriv(TransactionTableModel *_parent)
         : parent(_parent) {}
 
     TransactionTableModel *parent;
 
     /* Local cache of wallet.
      * As it is in the same order as the CWallet, by definition this is sorted
      * by sha256.
      */
     QList<TransactionRecord> cachedWallet;
 
     /**
      * Query entire wallet anew from core.
      */
     void refreshWallet(interfaces::Wallet &wallet) {
         qDebug() << "TransactionTablePriv::refreshWallet";
         cachedWallet.clear();
         for (const auto &wtx : wallet.getWalletTxs()) {
             if (TransactionRecord::showTransaction()) {
                 cachedWallet.append(
                     TransactionRecord::decomposeTransaction(wtx));
             }
         }
     }
 
     /**
      * Update our model of the wallet incrementally, to synchronize our model of
      * the wallet with that of the core.
      * Call with transaction that was added, removed or changed.
      */
     void updateWallet(interfaces::Wallet &wallet, const TxId &txid, int status,
                       bool showTransaction) {
         qDebug() << "TransactionTablePriv::updateWallet: " +
                         QString::fromStdString(txid.ToString()) + " " +
                         QString::number(status);
 
         // Find bounds of this transaction in model
         QList<TransactionRecord>::iterator lower = std::lower_bound(
             cachedWallet.begin(), cachedWallet.end(), txid, TxLessThan());
         QList<TransactionRecord>::iterator upper = std::upper_bound(
             cachedWallet.begin(), cachedWallet.end(), txid, TxLessThan());
         int lowerIndex = (lower - cachedWallet.begin());
         int upperIndex = (upper - cachedWallet.begin());
         bool inModel = (lower != upper);
 
         if (status == CT_UPDATED) {
             // Not in model, but want to show, treat as new.
             if (showTransaction && !inModel) {
                 status = CT_NEW;
             }
             // In model, but want to hide, treat as deleted.
             if (!showTransaction && inModel) {
                 status = CT_DELETED;
             }
         }
 
         qDebug() << "    inModel=" + QString::number(inModel) +
                         " Index=" + QString::number(lowerIndex) + "-" +
                         QString::number(upperIndex) +
                         " showTransaction=" + QString::number(showTransaction) +
                         " derivedStatus=" + QString::number(status);
 
         switch (status) {
             case CT_NEW:
                 if (inModel) {
                     qWarning() << "TransactionTablePriv::updateWallet: "
                                   "Warning: Got CT_NEW, but transaction is "
                                   "already in model";
                     break;
                 }
                 if (showTransaction) {
                     // Find transaction in wallet
                     interfaces::WalletTx wtx = wallet.getWalletTx(txid);
                     if (!wtx.tx) {
                         qWarning() << "TransactionTablePriv::updateWallet: "
                                       "Warning: Got CT_NEW, but transaction is "
                                       "not in wallet";
                         break;
                     }
                     // Added -- insert at the right position
                     QList<TransactionRecord> toInsert =
                         TransactionRecord::decomposeTransaction(wtx);
                     /* only if something to insert */
                     if (!toInsert.isEmpty()) {
                         parent->beginInsertRows(QModelIndex(), lowerIndex,
                                                 lowerIndex + toInsert.size() -
                                                     1);
                         int insert_idx = lowerIndex;
                         for (const TransactionRecord &rec : toInsert) {
                             cachedWallet.insert(insert_idx, rec);
                             insert_idx += 1;
                         }
                         parent->endInsertRows();
                     }
                 }
                 break;
             case CT_DELETED:
                 if (!inModel) {
                     qWarning() << "TransactionTablePriv::updateWallet: "
                                   "Warning: Got CT_DELETED, but transaction is "
                                   "not in model";
                     break;
                 }
                 // Removed -- remove entire transaction from table
                 parent->beginRemoveRows(QModelIndex(), lowerIndex,
                                         upperIndex - 1);
                 cachedWallet.erase(lower, upper);
                 parent->endRemoveRows();
                 break;
             case CT_UPDATED:
                 // Miscellaneous updates -- nothing to do, status update will
                 // take care of this, and is only computed for visible
                 // transactions.
                 break;
         }
     }
 
     int size() { return cachedWallet.size(); }
 
     TransactionRecord *index(interfaces::Wallet &wallet,
-                             const int cur_num_blocks, const int idx) {
+                             const BlockHash &cur_block_hash, const int idx) {
         if (idx >= 0 && idx < cachedWallet.size()) {
             TransactionRecord *rec = &cachedWallet[idx];
 
             // Get required locks upfront. This avoids the GUI from getting
             // stuck if the core is holding the locks for a longer time - for
             // example, during a wallet rescan.
             //
             // If a status update is needed (blocks came in since last check),
             // update the status of this transaction from the wallet. Otherwise,
             // simply re-use the cached status.
             interfaces::WalletTxStatus wtx;
             int numBlocks;
             int64_t block_time;
-            if (rec->statusUpdateNeeded(cur_num_blocks) &&
+            if (rec->statusUpdateNeeded(cur_block_hash) &&
                 wallet.tryGetTxStatus(rec->txid, wtx, numBlocks, block_time)) {
-                rec->updateStatus(wtx, numBlocks, block_time);
+                rec->updateStatus(wtx, cur_block_hash, numBlocks, block_time);
             }
             return rec;
         }
         return nullptr;
     }
 
     QString describe(interfaces::Node &node, interfaces::Wallet &wallet,
                      TransactionRecord *rec, int unit) {
         return TransactionDesc::toHTML(node, wallet, rec, unit);
     }
 
     QString getTxHex(interfaces::Wallet &wallet, TransactionRecord *rec) {
         auto tx = wallet.getTx(rec->txid);
         if (tx) {
             std::string strHex = EncodeHexTx(*tx);
             return QString::fromStdString(strHex);
         }
         return QString();
     }
 };
 
 TransactionTableModel::TransactionTableModel(
     const PlatformStyle *_platformStyle, WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent),
       priv(new TransactionTablePriv(this)),
       fProcessingQueuedTransactions(false), platformStyle(_platformStyle) {
     columns << QString() << QString() << tr("Date") << tr("Type") << tr("Label")
             << BitcoinUnits::getAmountColumnTitle(
                    walletModel->getOptionsModel()->getDisplayUnit());
     priv->refreshWallet(walletModel->wallet());
 
     connect(walletModel->getOptionsModel(), &OptionsModel::displayUnitChanged,
             this, &TransactionTableModel::updateDisplayUnit);
 
     subscribeToCoreSignals();
 }
 
 TransactionTableModel::~TransactionTableModel() {
     unsubscribeFromCoreSignals();
     delete priv;
 }
 
 /** Updates the column title to "Amount (DisplayUnit)" and emits
  * headerDataChanged() signal for table headers to react. */
 void TransactionTableModel::updateAmountColumnTitle() {
     columns[Amount] = BitcoinUnits::getAmountColumnTitle(
         walletModel->getOptionsModel()->getDisplayUnit());
     Q_EMIT headerDataChanged(Qt::Horizontal, Amount, Amount);
 }
 
 void TransactionTableModel::updateTransaction(const QString &hash, int status,
                                               bool showTransaction) {
     TxId updated;
     updated.SetHex(hash.toStdString());
 
     priv->updateWallet(walletModel->wallet(), updated, status, showTransaction);
 }
 
 void TransactionTableModel::updateConfirmations() {
     // Blocks came in since last poll.
     // Invalidate status (number of confirmations) and (possibly) description
     // for all rows. Qt is smart enough to only actually request the data for
     // the visible rows.
     Q_EMIT dataChanged(index(0, Status), index(priv->size() - 1, Status));
     Q_EMIT dataChanged(index(0, ToAddress), index(priv->size() - 1, ToAddress));
 }
 
 int TransactionTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int TransactionTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QString
 TransactionTableModel::formatTxStatus(const TransactionRecord *wtx) const {
     QString status;
 
     switch (wtx->status.status) {
         case TransactionStatus::OpenUntilBlock:
             status = tr("Open for %n more block(s)", "", wtx->status.open_for);
             break;
         case TransactionStatus::OpenUntilDate:
             status = tr("Open until %1")
                          .arg(GUIUtil::dateTimeStr(wtx->status.open_for));
             break;
         case TransactionStatus::Unconfirmed:
             status = tr("Unconfirmed");
             break;
         case TransactionStatus::Abandoned:
             status = tr("Abandoned");
             break;
         case TransactionStatus::Confirming:
             status = tr("Confirming (%1 of %2 recommended confirmations)")
                          .arg(wtx->status.depth)
                          .arg(TransactionRecord::RecommendedNumConfirmations);
             break;
         case TransactionStatus::Confirmed:
             status = tr("Confirmed (%1 confirmations)").arg(wtx->status.depth);
             break;
         case TransactionStatus::Conflicted:
             status = tr("Conflicted");
             break;
         case TransactionStatus::Immature:
             status =
                 tr("Immature (%1 confirmations, will be available after %2)")
                     .arg(wtx->status.depth)
                     .arg(wtx->status.depth + wtx->status.matures_in);
             break;
         case TransactionStatus::NotAccepted:
             status = tr("Generated but not accepted");
             break;
     }
 
     return status;
 }
 
 QString
 TransactionTableModel::formatTxDate(const TransactionRecord *wtx) const {
     if (wtx->time) {
         return GUIUtil::dateTimeStr(wtx->time);
     }
     return QString();
 }
 
 /**
  * Look up address in address book, if found return label (address)  otherwise
  * just return (address)
  */
 QString TransactionTableModel::lookupAddress(const std::string &address,
                                              bool tooltip) const {
     QString label = walletModel->getAddressTableModel()->labelForAddress(
         QString::fromStdString(address));
     QString description;
     if (!label.isEmpty()) {
         description += label;
     }
     if (label.isEmpty() || tooltip) {
         description +=
             QString(" (") + QString::fromStdString(address) + QString(")");
     }
     return description;
 }
 
 QString
 TransactionTableModel::formatTxType(const TransactionRecord *wtx) const {
     switch (wtx->type) {
         case TransactionRecord::RecvWithAddress:
             return tr("Received with");
         case TransactionRecord::RecvFromOther:
             return tr("Received from");
         case TransactionRecord::SendToAddress:
         case TransactionRecord::SendToOther:
             return tr("Sent to");
         case TransactionRecord::SendToSelf:
             return tr("Payment to yourself");
         case TransactionRecord::Generated:
             return tr("Mined");
         default:
             return QString();
     }
 }
 
 QVariant
 TransactionTableModel::txAddressDecoration(const TransactionRecord *wtx) const {
     switch (wtx->type) {
         case TransactionRecord::Generated:
             return QIcon(":/icons/tx_mined");
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::RecvFromOther:
             return QIcon(":/icons/tx_input");
         case TransactionRecord::SendToAddress:
         case TransactionRecord::SendToOther:
             return QIcon(":/icons/tx_output");
         default:
             return QIcon(":/icons/tx_inout");
     }
 }
 
 QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx,
                                                  bool tooltip) const {
     QString watchAddress;
     if (tooltip) {
         // Mark transactions involving watch-only addresses by adding "
         // (watch-only)"
         watchAddress = wtx->involvesWatchAddress
                            ? QString(" (") + tr("watch-only") + QString(")")
                            : "";
     }
 
     switch (wtx->type) {
         case TransactionRecord::RecvFromOther:
             return QString::fromStdString(wtx->address) + watchAddress;
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::SendToAddress:
         case TransactionRecord::Generated:
             return lookupAddress(wtx->address, tooltip) + watchAddress;
         case TransactionRecord::SendToOther:
             return QString::fromStdString(wtx->address) + watchAddress;
         case TransactionRecord::SendToSelf:
             return lookupAddress(wtx->address, tooltip) + watchAddress;
         default:
             return tr("(n/a)") + watchAddress;
     }
 }
 
 QVariant
 TransactionTableModel::addressColor(const TransactionRecord *wtx) const {
     // Show addresses without label in a less visible color
     switch (wtx->type) {
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::SendToAddress:
         case TransactionRecord::Generated: {
             QString label =
                 walletModel->getAddressTableModel()->labelForAddress(
                     QString::fromStdString(wtx->address));
             if (label.isEmpty()) {
                 return COLOR_BAREADDRESS;
             }
         } break;
         case TransactionRecord::SendToSelf:
             return COLOR_BAREADDRESS;
         default:
             break;
     }
     return QVariant();
 }
 
 QString TransactionTableModel::formatTxAmount(
     const TransactionRecord *wtx, bool showUnconfirmed,
     BitcoinUnits::SeparatorStyle separators) const {
     QString str =
         BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(),
                              wtx->credit + wtx->debit, false, separators);
     if (showUnconfirmed) {
         if (!wtx->status.countsForBalance) {
             str = QString("[") + str + QString("]");
         }
     }
     return QString(str);
 }
 
 QVariant
 TransactionTableModel::txStatusDecoration(const TransactionRecord *wtx) const {
     switch (wtx->status.status) {
         case TransactionStatus::OpenUntilBlock:
         case TransactionStatus::OpenUntilDate:
             return COLOR_TX_STATUS_OPENUNTILDATE;
         case TransactionStatus::Unconfirmed:
             return QIcon(":/icons/transaction_0");
         case TransactionStatus::Abandoned:
             return QIcon(":/icons/transaction_abandoned");
         case TransactionStatus::Confirming:
             switch (wtx->status.depth) {
                 case 1:
                     return QIcon(":/icons/transaction_1");
                 case 2:
                     return QIcon(":/icons/transaction_2");
                 case 3:
                     return QIcon(":/icons/transaction_3");
                 case 4:
                     return QIcon(":/icons/transaction_4");
                 default:
                     return QIcon(":/icons/transaction_5");
             };
         case TransactionStatus::Confirmed:
             return QIcon(":/icons/transaction_confirmed");
         case TransactionStatus::Conflicted:
             return QIcon(":/icons/transaction_conflicted");
         case TransactionStatus::Immature: {
             int total = wtx->status.depth + wtx->status.matures_in;
             int part = (wtx->status.depth * 4 / total) + 1;
             return QIcon(QString(":/icons/transaction_%1").arg(part));
         }
         case TransactionStatus::NotAccepted:
             return QIcon(":/icons/transaction_0");
         default:
             return COLOR_BLACK;
     }
 }
 
 QVariant TransactionTableModel::txWatchonlyDecoration(
     const TransactionRecord *wtx) const {
     if (wtx->involvesWatchAddress) {
         return QIcon(":/icons/eye");
     }
 
     return QVariant();
 }
 
 QString
 TransactionTableModel::formatTooltip(const TransactionRecord *rec) const {
     QString tooltip = formatTxStatus(rec) + QString("\n") + formatTxType(rec);
     if (rec->type == TransactionRecord::RecvFromOther ||
         rec->type == TransactionRecord::SendToOther ||
         rec->type == TransactionRecord::SendToAddress ||
         rec->type == TransactionRecord::RecvWithAddress) {
         tooltip += QString(" ") + formatTxToAddress(rec, true);
     }
     return tooltip;
 }
 
 QVariant TransactionTableModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
         return QVariant();
     }
 
     TransactionRecord *rec =
         static_cast<TransactionRecord *>(index.internalPointer());
 
     switch (role) {
         case RawDecorationRole:
             switch (index.column()) {
                 case Status:
                     return txStatusDecoration(rec);
                 case Watchonly:
                     return txWatchonlyDecoration(rec);
                 case ToAddress:
                     return txAddressDecoration(rec);
             }
             break;
         case Qt::DecorationRole: {
             QIcon icon = qvariant_cast<QIcon>(index.data(RawDecorationRole));
             return platformStyle->TextColorIcon(icon);
         }
         case Qt::DisplayRole:
             switch (index.column()) {
                 case Date:
                     return formatTxDate(rec);
                 case Type:
                     return formatTxType(rec);
                 case ToAddress:
                     return formatTxToAddress(rec, false);
                 case Amount:
                     return formatTxAmount(rec, true,
                                           BitcoinUnits::separatorAlways);
             }
             break;
         case Qt::EditRole:
             // Edit role is used for sorting, so return the unformatted values
             switch (index.column()) {
                 case Status:
                     return QString::fromStdString(rec->status.sortKey);
                 case Date:
                     return rec->time;
                 case Type:
                     return formatTxType(rec);
                 case Watchonly:
                     return (rec->involvesWatchAddress ? 1 : 0);
                 case ToAddress:
                     return formatTxToAddress(rec, true);
                 case Amount:
                     return qint64((rec->credit + rec->debit) / SATOSHI);
             }
             break;
         case Qt::ToolTipRole:
             return formatTooltip(rec);
         case Qt::TextAlignmentRole:
             return column_alignments[index.column()];
         case Qt::ForegroundRole:
             // Use the "danger" color for abandoned transactions
             if (rec->status.status == TransactionStatus::Abandoned) {
                 return COLOR_TX_STATUS_DANGER;
             }
             // Non-confirmed (but not immature) as transactions are grey
             if (!rec->status.countsForBalance &&
                 rec->status.status != TransactionStatus::Immature) {
                 return COLOR_UNCONFIRMED;
             }
             if (index.column() == Amount &&
                 (rec->credit + rec->debit) < ::Amount::zero()) {
                 return COLOR_NEGATIVE;
             }
             if (index.column() == ToAddress) {
                 return addressColor(rec);
             }
             break;
         case TypeRole:
             return rec->type;
         case DateRole:
             return QDateTime::fromTime_t(static_cast<uint>(rec->time));
         case WatchonlyRole:
             return rec->involvesWatchAddress;
         case WatchonlyDecorationRole:
             return txWatchonlyDecoration(rec);
         case LongDescriptionRole:
             return priv->describe(
                 walletModel->node(), walletModel->wallet(), rec,
                 walletModel->getOptionsModel()->getDisplayUnit());
         case AddressRole:
             return QString::fromStdString(rec->address);
         case LabelRole:
             return walletModel->getAddressTableModel()->labelForAddress(
                 QString::fromStdString(rec->address));
         case AmountRole:
             return qint64((rec->credit + rec->debit) / SATOSHI);
         case TxIDRole:
             return rec->getTxID();
         case TxHashRole:
             return QString::fromStdString(rec->txid.ToString());
         case TxHexRole:
             return priv->getTxHex(walletModel->wallet(), rec);
         case TxPlainTextRole: {
             QString details;
             QDateTime date =
                 QDateTime::fromTime_t(static_cast<uint>(rec->time));
             QString txLabel =
                 walletModel->getAddressTableModel()->labelForAddress(
                     QString::fromStdString(rec->address));
 
             details.append(date.toString("M/d/yy HH:mm"));
             details.append(" ");
             details.append(formatTxStatus(rec));
             details.append(". ");
             if (!formatTxType(rec).isEmpty()) {
                 details.append(formatTxType(rec));
                 details.append(" ");
             }
             if (!rec->address.empty()) {
                 if (txLabel.isEmpty()) {
                     details.append(tr("(no label)") + " ");
                 } else {
                     details.append("(");
                     details.append(txLabel);
                     details.append(") ");
                 }
                 details.append(QString::fromStdString(rec->address));
                 details.append(" ");
             }
             details.append(
                 formatTxAmount(rec, false, BitcoinUnits::separatorNever));
             return details;
         }
         case ConfirmedRole:
             return rec->status.countsForBalance;
         case FormattedAmountRole:
             // Used for copy/export, so don't include separators
             return formatTxAmount(rec, false, BitcoinUnits::separatorNever);
         case StatusRole:
             return rec->status.status;
     }
     return QVariant();
 }
 
 QVariant TransactionTableModel::headerData(int section,
                                            Qt::Orientation orientation,
                                            int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole) {
             return columns[section];
         } else if (role == Qt::TextAlignmentRole) {
             return column_alignments[section];
         } else if (role == Qt::ToolTipRole) {
             switch (section) {
                 case Status:
                     return tr("Transaction status. Hover over this field to "
                               "show number of confirmations.");
                 case Date:
                     return tr(
                         "Date and time that the transaction was received.");
                 case Type:
                     return tr("Type of transaction.");
                 case Watchonly:
                     return tr("Whether or not a watch-only address is involved "
                               "in this transaction.");
                 case ToAddress:
                     return tr(
                         "User-defined intent/purpose of the transaction.");
                 case Amount:
                     return tr("Amount removed from or added to balance.");
             }
         }
     }
     return QVariant();
 }
 
 QModelIndex TransactionTableModel::index(int row, int column,
                                          const QModelIndex &parent) const {
     Q_UNUSED(parent);
     TransactionRecord *data =
-        priv->index(walletModel->wallet(), walletModel->getNumBlocks(), row);
+        priv->index(walletModel->wallet(),
+                    walletModel->clientModel().getBestBlockHash(), row);
     if (data) {
         return createIndex(row, column, data);
     }
     return QModelIndex();
 }
 
 void TransactionTableModel::updateDisplayUnit() {
     // emit dataChanged to update Amount column with the current unit
     updateAmountColumnTitle();
     Q_EMIT dataChanged(index(0, Amount), index(priv->size() - 1, Amount));
 }
 
 // queue notifications to show a non freezing progress dialog e.g. for rescan
 struct TransactionNotification {
 public:
     TransactionNotification() {}
     TransactionNotification(TxId _txid, ChangeType _status,
                             bool _showTransaction)
         : txid(_txid), status(_status), showTransaction(_showTransaction) {}
 
     void invoke(QObject *ttm) {
         QString strHash = QString::fromStdString(txid.GetHex());
         qDebug() << "NotifyTransactionChanged: " + strHash +
                         " status= " + QString::number(status);
         bool invoked = QMetaObject::invokeMethod(
             ttm, "updateTransaction", Qt::QueuedConnection,
             Q_ARG(QString, strHash), Q_ARG(int, status),
             Q_ARG(bool, showTransaction));
         assert(invoked);
     }
 
 private:
     TxId txid;
     ChangeType status;
     bool showTransaction;
 };
 
 static bool fQueueNotifications = false;
 static std::vector<TransactionNotification> vQueueNotifications;
 
 static void NotifyTransactionChanged(TransactionTableModel *ttm,
                                      const TxId &txid, ChangeType status) {
     // Find transaction in wallet
     // Determine whether to show transaction or not (determine this here so that
     // no relocking is needed in GUI thread)
     bool showTransaction = TransactionRecord::showTransaction();
 
     TransactionNotification notification(txid, status, showTransaction);
 
     if (fQueueNotifications) {
         vQueueNotifications.push_back(notification);
         return;
     }
     notification.invoke(ttm);
 }
 
 static void ShowProgress(TransactionTableModel *ttm, const std::string &title,
                          int nProgress) {
     if (nProgress == 0) {
         fQueueNotifications = true;
     }
 
     if (nProgress == 100) {
         fQueueNotifications = false;
         if (vQueueNotifications.size() > 10) {
             // prevent balloon spam, show maximum 10 balloons
             bool invoked = QMetaObject::invokeMethod(
                 ttm, "setProcessingQueuedTransactions", Qt::QueuedConnection,
                 Q_ARG(bool, true));
             assert(invoked);
         }
 
         for (size_t i = 0; i < vQueueNotifications.size(); ++i) {
             if (vQueueNotifications.size() - i <= 10) {
                 bool invoked = QMetaObject::invokeMethod(
                     ttm, "setProcessingQueuedTransactions",
                     Qt::QueuedConnection, Q_ARG(bool, false));
                 assert(invoked);
             }
 
             vQueueNotifications[i].invoke(ttm);
         }
 
         // clear
         std::vector<TransactionNotification>().swap(vQueueNotifications);
     }
 }
 
 void TransactionTableModel::subscribeToCoreSignals() {
     // Connect signals to wallet
     m_handler_transaction_changed =
         walletModel->wallet().handleTransactionChanged(
             std::bind(NotifyTransactionChanged, this, std::placeholders::_1,
                       std::placeholders::_2));
     m_handler_show_progress =
         walletModel->wallet().handleShowProgress(std::bind(
             ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
 }
 
 void TransactionTableModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from wallet
     m_handler_transaction_changed->disconnect();
     m_handler_show_progress->disconnect();
 }
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index 2a0b5497b..f309f1680 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -1,534 +1,533 @@
 // Copyright (c) 2011-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 <qt/walletmodel.h>
 
 #include <cashaddrenc.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <node/ui_interface.h>
 #include <psbt.h>
 #include <qt/addresstablemodel.h>
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/paymentserver.h>
 #include <qt/recentrequeststablemodel.h>
 #include <qt/transactiontablemodel.h>
 #include <util/system.h> // for GetBoolArg
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/wallet.h> // for CRecipient
 
 #include <QDebug>
 #include <QSet>
 #include <QTimer>
 
 #include <cstdint>
 
 WalletModel::WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
                          ClientModel &client_model,
                          const PlatformStyle *platformStyle, QObject *parent)
     : QObject(parent), m_wallet(std::move(wallet)),
       m_client_model(&client_model), m_node(client_model.node()),
       optionsModel(client_model.getOptionsModel()), addressTableModel(nullptr),
       transactionTableModel(nullptr), recentRequestsTableModel(nullptr),
-      cachedEncryptionStatus(Unencrypted), cachedNumBlocks(0),
-      timer(new QTimer(this)) {
+      cachedEncryptionStatus(Unencrypted), timer(new QTimer(this)) {
     fHaveWatchOnly = m_wallet->haveWatchOnly();
     addressTableModel = new AddressTableModel(this);
     transactionTableModel = new TransactionTableModel(platformStyle, this);
     recentRequestsTableModel = new RecentRequestsTableModel(this);
 
     subscribeToCoreSignals();
 }
 
 WalletModel::~WalletModel() {
     unsubscribeFromCoreSignals();
 }
 
 void WalletModel::startPollBalance() {
     // This timer will be fired repeatedly to update the balance
     connect(timer, &QTimer::timeout, this, &WalletModel::pollBalanceChanged);
     timer->start(MODEL_UPDATE_DELAY);
 }
 
 void WalletModel::setClientModel(ClientModel *client_model) {
     m_client_model = client_model;
     if (!m_client_model) {
         timer->stop();
     }
 }
 
 void WalletModel::updateStatus() {
     EncryptionStatus newEncryptionStatus = getEncryptionStatus();
 
     if (cachedEncryptionStatus != newEncryptionStatus) {
         Q_EMIT encryptionStatusChanged();
     }
 }
 
 void WalletModel::pollBalanceChanged() {
     // Avoid recomputing wallet balances unless a TransactionChanged or
     // BlockTip notification was received.
     if (!fForceCheckBalanceChanged &&
-        cachedNumBlocks == m_client_model->getNumBlocks()) {
+        m_cached_last_update_tip == m_client_model->getBestBlockHash()) {
         return;
     }
 
     // Try to get balances and return early if locks can't be acquired. This
     // avoids the GUI from getting stuck on periodical polls if the core is
     // holding the locks for a longer time - for example, during a wallet
     // rescan.
     interfaces::WalletBalances new_balances;
-    int numBlocks = -1;
-    if (!m_wallet->tryGetBalances(new_balances, numBlocks)) {
+    BlockHash block_hash;
+    if (!m_wallet->tryGetBalances(new_balances, block_hash)) {
         return;
     }
 
-    if (fForceCheckBalanceChanged || numBlocks != cachedNumBlocks) {
+    if (fForceCheckBalanceChanged || block_hash != m_cached_last_update_tip) {
         fForceCheckBalanceChanged = false;
 
         // Balance and number of transactions might have changed
-        cachedNumBlocks = numBlocks;
+        m_cached_last_update_tip = block_hash;
 
         checkBalanceChanged(new_balances);
         if (transactionTableModel) {
             transactionTableModel->updateConfirmations();
         }
     }
 }
 
 void WalletModel::checkBalanceChanged(
     const interfaces::WalletBalances &new_balances) {
     if (new_balances.balanceChanged(m_cached_balances)) {
         m_cached_balances = new_balances;
         Q_EMIT balanceChanged(new_balances);
     }
 }
 
 void WalletModel::updateTransaction() {
     // Balance and number of transactions might have changed
     fForceCheckBalanceChanged = true;
 }
 
 void WalletModel::updateAddressBook(const QString &address,
                                     const QString &label, bool isMine,
                                     const QString &purpose, int status) {
     if (addressTableModel) {
         addressTableModel->updateEntry(address, label, isMine, purpose, status);
     }
 }
 
 void WalletModel::updateWatchOnlyFlag(bool fHaveWatchonly) {
     fHaveWatchOnly = fHaveWatchonly;
     Q_EMIT notifyWatchonlyChanged(fHaveWatchonly);
 }
 
 bool WalletModel::validateAddress(const QString &address) {
     return IsValidDestinationString(address.toStdString(), getChainParams());
 }
 
 WalletModel::SendCoinsReturn
 WalletModel::prepareTransaction(WalletModelTransaction &transaction,
                                 const CCoinControl &coinControl) {
     Amount total = Amount::zero();
     bool fSubtractFeeFromAmount = false;
     QList<SendCoinsRecipient> recipients = transaction.getRecipients();
     std::vector<CRecipient> vecSend;
 
     if (recipients.empty()) {
         return OK;
     }
 
     // Used to detect duplicates
     QSet<QString> setAddress;
     int nAddresses = 0;
 
     // Pre-check input data for validity
     for (const SendCoinsRecipient &rcp : recipients) {
         if (rcp.fSubtractFeeFromAmount) {
             fSubtractFeeFromAmount = true;
         }
 
 #ifdef ENABLE_BIP70
         // PaymentRequest...
         if (rcp.paymentRequest.IsInitialized()) {
             Amount subtotal = Amount::zero();
             const payments::PaymentDetails &details =
                 rcp.paymentRequest.getDetails();
             for (int i = 0; i < details.outputs_size(); i++) {
                 const payments::Output &out = details.outputs(i);
                 if (out.amount() <= 0) {
                     continue;
                 }
 
                 subtotal += int64_t(out.amount()) * SATOSHI;
                 const uint8_t *scriptStr = (const uint8_t *)out.script().data();
                 CScript scriptPubKey(scriptStr,
                                      scriptStr + out.script().size());
                 Amount nAmount = int64_t(out.amount()) * SATOSHI;
                 CRecipient recipient = {scriptPubKey, nAmount,
                                         rcp.fSubtractFeeFromAmount};
                 vecSend.push_back(recipient);
             }
 
             if (subtotal <= Amount::zero()) {
                 return InvalidAmount;
             }
             total += subtotal;
         }
 
         // User-entered bitcoin address / amount:
         else
 #endif
         {
             if (!validateAddress(rcp.address)) {
                 return InvalidAddress;
             }
             if (rcp.amount <= Amount::zero()) {
                 return InvalidAmount;
             }
             setAddress.insert(rcp.address);
             ++nAddresses;
 
             CScript scriptPubKey = GetScriptForDestination(
                 DecodeDestination(rcp.address.toStdString(), getChainParams()));
             CRecipient recipient = {scriptPubKey, Amount(rcp.amount),
                                     rcp.fSubtractFeeFromAmount};
             vecSend.push_back(recipient);
 
             total += rcp.amount;
         }
     }
     if (setAddress.size() != nAddresses) {
         return DuplicateAddress;
     }
 
     Amount nBalance = m_wallet->getAvailableBalance(coinControl);
 
     if (total > nBalance) {
         return AmountExceedsBalance;
     }
 
     Amount nFeeRequired = Amount::zero();
     int nChangePosRet = -1;
     bilingual_str error;
 
     auto &newTx = transaction.getWtx();
     newTx = m_wallet->createTransaction(
         vecSend, coinControl, !wallet().privateKeysDisabled() /* sign */,
         nChangePosRet, nFeeRequired, error);
     transaction.setTransactionFee(nFeeRequired);
     if (fSubtractFeeFromAmount && newTx) {
         transaction.reassignAmounts(nChangePosRet);
     }
 
     if (!newTx) {
         if (!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance) {
             return SendCoinsReturn(AmountWithFeeExceedsBalance);
         }
         Q_EMIT message(tr("Send Coins"),
                        QString::fromStdString(error.translated),
                        CClientUIInterface::MSG_ERROR);
         return TransactionCreationFailed;
     }
 
     // Reject absurdly high fee. (This can never happen because the
     // wallet never creates transactions with fee greater than
     // m_default_max_tx_fee. This merely a belt-and-suspenders check).
     if (nFeeRequired > m_wallet->getDefaultMaxTxFee()) {
         return AbsurdFee;
     }
 
     return SendCoinsReturn(OK);
 }
 
 WalletModel::SendCoinsReturn
 WalletModel::sendCoins(WalletModelTransaction &transaction) {
     /* store serialized transaction */
     QByteArray transaction_array;
 
     std::vector<std::pair<std::string, std::string>> vOrderForm;
     for (const SendCoinsRecipient &rcp : transaction.getRecipients()) {
 #ifdef ENABLE_BIP70
         if (rcp.paymentRequest.IsInitialized()) {
             // Make sure any payment requests involved are still valid.
             if (PaymentServer::verifyExpired(rcp.paymentRequest.getDetails())) {
                 return PaymentRequestExpired;
             }
 
             // Store PaymentRequests in wtx.vOrderForm in wallet.
             std::string value;
             rcp.paymentRequest.SerializeToString(&value);
             vOrderForm.emplace_back("PaymentRequest", std::move(value));
         } else
 #endif
         {
             if (!rcp.message.isEmpty()) {
                 // Message from normal bitcoincash:URI
                 // (bitcoincash:123...?message=example)
                 vOrderForm.emplace_back("Message", rcp.message.toStdString());
             }
         }
     }
 
     auto &newTx = transaction.getWtx();
     wallet().commitTransaction(newTx, {} /* mapValue */, std::move(vOrderForm));
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << *newTx;
     transaction_array.append(&(ssTx[0]), ssTx.size());
 
     // Add addresses / update labels that we've sent to the address book, and
     // emit coinsSent signal for each recipient
     for (const SendCoinsRecipient &rcp : transaction.getRecipients()) {
         // Don't touch the address book when we have a payment request
 #ifdef ENABLE_BIP70
         if (!rcp.paymentRequest.IsInitialized())
 #endif
         {
             std::string strAddress = rcp.address.toStdString();
             CTxDestination dest =
                 DecodeDestination(strAddress, getChainParams());
             std::string strLabel = rcp.label.toStdString();
             // Check if we have a new address or an updated label
             std::string name;
             if (!m_wallet->getAddress(dest, &name, /* is_mine= */ nullptr,
                                       /* purpose= */ nullptr)) {
                 m_wallet->setAddressBook(dest, strLabel, "send");
             } else if (name != strLabel) {
                 // "" means don't change purpose
                 m_wallet->setAddressBook(dest, strLabel, "");
             }
         }
         Q_EMIT coinsSent(this->wallet(), rcp, transaction_array);
     }
 
     // update balance immediately, otherwise there could be a short noticeable
     // delay until pollBalanceChanged hits
     checkBalanceChanged(m_wallet->getBalances());
 
     return SendCoinsReturn(OK);
 }
 
 OptionsModel *WalletModel::getOptionsModel() {
     return optionsModel;
 }
 
 AddressTableModel *WalletModel::getAddressTableModel() {
     return addressTableModel;
 }
 
 TransactionTableModel *WalletModel::getTransactionTableModel() {
     return transactionTableModel;
 }
 
 RecentRequestsTableModel *WalletModel::getRecentRequestsTableModel() {
     return recentRequestsTableModel;
 }
 
 WalletModel::EncryptionStatus WalletModel::getEncryptionStatus() const {
     if (!m_wallet->isCrypted()) {
         return Unencrypted;
     } else if (m_wallet->isLocked()) {
         return Locked;
     } else {
         return Unlocked;
     }
 }
 
 bool WalletModel::setWalletEncrypted(bool encrypted,
                                      const SecureString &passphrase) {
     if (encrypted) {
         return m_wallet->encryptWallet(passphrase);
     }
     return false;
 }
 
 bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase) {
     if (locked) {
         // Lock
         return m_wallet->lock();
     } else {
         // Unlock
         return m_wallet->unlock(passPhrase);
     }
 }
 
 bool WalletModel::changePassphrase(const SecureString &oldPass,
                                    const SecureString &newPass) {
     // Make sure wallet is locked before attempting pass change
     m_wallet->lock();
     return m_wallet->changeWalletPassphrase(oldPass, newPass);
 }
 
 // Handlers for core signals
 static void NotifyUnload(WalletModel *walletModel) {
     qDebug() << "NotifyUnload";
     bool invoked = QMetaObject::invokeMethod(walletModel, "unload");
     assert(invoked);
 }
 
 static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel) {
     qDebug() << "NotifyKeyStoreStatusChanged";
     bool invoked = QMetaObject::invokeMethod(walletmodel, "updateStatus",
                                              Qt::QueuedConnection);
     assert(invoked);
 }
 
 static void NotifyAddressBookChanged(WalletModel *walletmodel,
                                      const CTxDestination &address,
                                      const std::string &label, bool isMine,
                                      const std::string &purpose,
                                      ChangeType status) {
     QString strAddress = QString::fromStdString(
         EncodeCashAddr(address, walletmodel->getChainParams()));
     QString strLabel = QString::fromStdString(label);
     QString strPurpose = QString::fromStdString(purpose);
 
     qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel +
                     " isMine=" + QString::number(isMine) +
                     " purpose=" + strPurpose +
                     " status=" + QString::number(status);
     bool invoked = QMetaObject::invokeMethod(
         walletmodel, "updateAddressBook", Qt::QueuedConnection,
         Q_ARG(QString, strAddress), Q_ARG(QString, strLabel),
         Q_ARG(bool, isMine), Q_ARG(QString, strPurpose), Q_ARG(int, status));
     assert(invoked);
 }
 
 static void NotifyTransactionChanged(WalletModel *walletmodel, const TxId &hash,
                                      ChangeType status) {
     Q_UNUSED(hash);
     Q_UNUSED(status);
     bool invoked = QMetaObject::invokeMethod(walletmodel, "updateTransaction",
                                              Qt::QueuedConnection);
     assert(invoked);
 }
 
 static void ShowProgress(WalletModel *walletmodel, const std::string &title,
                          int nProgress) {
     // emits signal "showProgress"
     bool invoked = QMetaObject::invokeMethod(
         walletmodel, "showProgress", Qt::QueuedConnection,
         Q_ARG(QString, QString::fromStdString(title)), Q_ARG(int, nProgress));
     assert(invoked);
 }
 
 static void NotifyWatchonlyChanged(WalletModel *walletmodel,
                                    bool fHaveWatchonly) {
     bool invoked = QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag",
                                              Qt::QueuedConnection,
                                              Q_ARG(bool, fHaveWatchonly));
     assert(invoked);
 }
 
 static void NotifyCanGetAddressesChanged(WalletModel *walletmodel) {
     bool invoked =
         QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");
     assert(invoked);
 }
 
 void WalletModel::subscribeToCoreSignals() {
     // Connect signals to wallet
     m_handler_unload = m_wallet->handleUnload(std::bind(&NotifyUnload, this));
     m_handler_status_changed = m_wallet->handleStatusChanged(
         std::bind(&NotifyKeyStoreStatusChanged, this));
     m_handler_address_book_changed = m_wallet->handleAddressBookChanged(
         std::bind(NotifyAddressBookChanged, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3,
                   std::placeholders::_4, std::placeholders::_5));
     m_handler_transaction_changed = m_wallet->handleTransactionChanged(
         std::bind(NotifyTransactionChanged, this, std::placeholders::_1,
                   std::placeholders::_2));
     m_handler_show_progress = m_wallet->handleShowProgress(std::bind(
         ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
     m_handler_watch_only_changed = m_wallet->handleWatchOnlyChanged(
         std::bind(NotifyWatchonlyChanged, this, std::placeholders::_1));
     m_handler_can_get_addrs_changed = m_wallet->handleCanGetAddressesChanged(
         std::bind(NotifyCanGetAddressesChanged, this));
 }
 
 void WalletModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from wallet
     m_handler_unload->disconnect();
     m_handler_status_changed->disconnect();
     m_handler_address_book_changed->disconnect();
     m_handler_transaction_changed->disconnect();
     m_handler_show_progress->disconnect();
     m_handler_watch_only_changed->disconnect();
     m_handler_can_get_addrs_changed->disconnect();
 }
 
 // WalletModel::UnlockContext implementation
 WalletModel::UnlockContext WalletModel::requestUnlock() {
     bool was_locked = getEncryptionStatus() == Locked;
     if (was_locked) {
         // Request UI to unlock wallet
         Q_EMIT requireUnlock();
     }
     // If wallet is still locked, unlock was failed or cancelled, mark context
     // as invalid
     bool valid = getEncryptionStatus() != Locked;
 
     return UnlockContext(this, valid, was_locked);
 }
 
 WalletModel::UnlockContext::UnlockContext(WalletModel *_wallet, bool _valid,
                                           bool _relock)
     : wallet(_wallet), valid(_valid), relock(_relock) {}
 
 WalletModel::UnlockContext::~UnlockContext() {
     if (valid && relock) {
         wallet->setWalletLocked(true);
     }
 }
 
 void WalletModel::UnlockContext::CopyFrom(UnlockContext &&rhs) {
     // Transfer context; old object no longer relocks wallet
     *this = rhs;
     rhs.relock = false;
 }
 
 void WalletModel::loadReceiveRequests(
     std::vector<std::string> &vReceiveRequests) {
     // receive request
     vReceiveRequests = m_wallet->getDestValues("rr");
 }
 
 bool WalletModel::saveReceiveRequest(const std::string &sAddress,
                                      const int64_t nId,
                                      const std::string &sRequest) {
     CTxDestination dest = DecodeDestination(sAddress, getChainParams());
 
     std::stringstream ss;
     ss << nId;
     // "rr" prefix = "receive request" in destdata
     std::string key = "rr" + ss.str();
 
     return sRequest.empty() ? m_wallet->eraseDestData(dest, key)
                             : m_wallet->addDestData(dest, key, sRequest);
 }
 
 bool WalletModel::isWalletEnabled() {
     return !gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
 }
 
 QString WalletModel::getWalletName() const {
     return QString::fromStdString(m_wallet->getWalletName());
 }
 
 QString WalletModel::getDisplayName() const {
     const QString name = getWalletName();
     return name.isEmpty() ? "[" + tr("default wallet") + "]" : name;
 }
 
 bool WalletModel::isMultiwallet() {
     return m_node.getWallets().size() > 1;
 }
 
 const CChainParams &WalletModel::getChainParams() const {
     return Params();
 }
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
index 796b72620..6c99088c2 100644
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -1,250 +1,252 @@
 // Copyright (c) 2011-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.
 
 #ifndef BITCOIN_QT_WALLETMODEL_H
 #define BITCOIN_QT_WALLETMODEL_H
 
 #include <chainparams.h>
 #include <interfaces/wallet.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/walletmodeltransaction.h>
 #include <support/allocators/secure.h>
 
 #include <QObject>
 
 #include <memory>
 #include <vector>
 
 class AddressTableModel;
 class ClientModel;
 class OptionsModel;
 class PlatformStyle;
 class RecentRequestsTableModel;
 class SendCoinsRecipient;
 class TransactionTableModel;
 class WalletModelTransaction;
 
 class CCoinControl;
 class CKeyID;
 class COutPoint;
 class COutput;
 class CPubKey;
 
 namespace interfaces {
 class Node;
 } // namespace interfaces
 
 QT_BEGIN_NAMESPACE
 class QTimer;
 QT_END_NAMESPACE
 
 /** Interface to Bitcoin wallet from Qt view code. */
 class WalletModel : public QObject {
     Q_OBJECT
 
 public:
     explicit WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
                          ClientModel &client_model,
                          const PlatformStyle *platformStyle,
                          QObject *parent = nullptr);
     ~WalletModel();
 
     // Returned by sendCoins
     enum StatusCode {
         OK,
         InvalidAmount,
         InvalidAddress,
         AmountExceedsBalance,
         AmountWithFeeExceedsBalance,
         DuplicateAddress,
         // Error returned when wallet is still locked
         TransactionCreationFailed,
         AbsurdFee,
         PaymentRequestExpired
     };
 
     enum EncryptionStatus {
         // !wallet->IsCrypted()
         Unencrypted,
         // wallet->IsCrypted() && wallet->IsLocked()
         Locked,
         // wallet->IsCrypted() && !wallet->IsLocked()
         Unlocked
     };
 
     OptionsModel *getOptionsModel();
     AddressTableModel *getAddressTableModel();
     TransactionTableModel *getTransactionTableModel();
     RecentRequestsTableModel *getRecentRequestsTableModel();
 
     EncryptionStatus getEncryptionStatus() const;
 
     // Check address for validity
     bool validateAddress(const QString &address);
 
     // Return status record for SendCoins, contains error id + information
     struct SendCoinsReturn {
         SendCoinsReturn(StatusCode _status = OK,
                         QString _reasonCommitFailed = "")
             : status(_status), reasonCommitFailed(_reasonCommitFailed) {}
         StatusCode status;
         QString reasonCommitFailed;
     };
 
     // prepare transaction for getting txfee before sending coins
     SendCoinsReturn prepareTransaction(WalletModelTransaction &transaction,
                                        const CCoinControl &coinControl);
 
     // Send coins to a list of recipients
     SendCoinsReturn sendCoins(WalletModelTransaction &transaction);
 
     // Wallet encryption
     bool setWalletEncrypted(bool encrypted, const SecureString &passphrase);
     // Passphrase only needed when unlocking
     bool setWalletLocked(bool locked,
                          const SecureString &passPhrase = SecureString());
     bool changePassphrase(const SecureString &oldPass,
                           const SecureString &newPass);
 
     // RAI object for unlocking wallet, returned by requestUnlock()
     class UnlockContext {
     public:
         UnlockContext(WalletModel *wallet, bool valid, bool relock);
         ~UnlockContext();
 
         bool isValid() const { return valid; }
 
         // Copy constructor is disabled.
         UnlockContext(const UnlockContext &) = delete;
         // Move operator and constructor transfer the context
         UnlockContext(UnlockContext &&obj) { CopyFrom(std::move(obj)); }
         UnlockContext &operator=(UnlockContext &&rhs) {
             CopyFrom(std::move(rhs));
             return *this;
         }
 
     private:
         WalletModel *wallet;
         bool valid;
         // mutable, as it can be set to false by copying
         mutable bool relock;
 
         UnlockContext &operator=(const UnlockContext &) = default;
         void CopyFrom(UnlockContext &&rhs);
     };
 
     UnlockContext requestUnlock();
 
     void loadReceiveRequests(std::vector<std::string> &vReceiveRequests);
     bool saveReceiveRequest(const std::string &sAddress, const int64_t nId,
                             const std::string &sRequest);
 
     static bool isWalletEnabled();
 
     interfaces::Node &node() const { return m_node; }
     interfaces::Wallet &wallet() const { return *m_wallet; }
+    ClientModel &clientModel() const { return *m_client_model; }
     void setClientModel(ClientModel *client_model);
-    int getNumBlocks() const { return cachedNumBlocks; }
 
     const CChainParams &getChainParams() const;
 
     QString getWalletName() const;
     QString getDisplayName() const;
 
     bool isMultiwallet();
 
     AddressTableModel *getAddressTableModel() const {
         return addressTableModel;
     }
 
 private:
     std::unique_ptr<interfaces::Wallet> m_wallet;
     std::unique_ptr<interfaces::Handler> m_handler_unload;
     std::unique_ptr<interfaces::Handler> m_handler_status_changed;
     std::unique_ptr<interfaces::Handler> m_handler_address_book_changed;
     std::unique_ptr<interfaces::Handler> m_handler_transaction_changed;
     std::unique_ptr<interfaces::Handler> m_handler_show_progress;
     std::unique_ptr<interfaces::Handler> m_handler_watch_only_changed;
     std::unique_ptr<interfaces::Handler> m_handler_can_get_addrs_changed;
     ClientModel *m_client_model;
     interfaces::Node &m_node;
 
     bool fHaveWatchOnly;
     bool fForceCheckBalanceChanged{false};
 
     // Wallet has an options model for wallet-specific options (transaction fee,
     // for example)
     OptionsModel *optionsModel;
 
     AddressTableModel *addressTableModel;
     TransactionTableModel *transactionTableModel;
     RecentRequestsTableModel *recentRequestsTableModel;
 
     // Cache some values to be able to detect changes
     interfaces::WalletBalances m_cached_balances;
     EncryptionStatus cachedEncryptionStatus;
-    int cachedNumBlocks;
     QTimer *timer;
 
+    // Block hash denoting when the last balance update was done.
+    BlockHash m_cached_last_update_tip{};
+
     void subscribeToCoreSignals();
     void unsubscribeFromCoreSignals();
     void checkBalanceChanged(const interfaces::WalletBalances &new_balances);
 
 Q_SIGNALS:
     // Signal that balance in wallet changed
     void balanceChanged(const interfaces::WalletBalances &balances);
 
     // Encryption status of wallet changed
     void encryptionStatusChanged();
 
     // Signal emitted when wallet needs to be unlocked
     // It is valid behaviour for listeners to keep the wallet locked after this
     // signal; this means that the unlocking failed or was cancelled.
     void requireUnlock();
 
     // Fired when a message should be reported to the user
     void message(const QString &title, const QString &message,
                  unsigned int style);
 
     // Coins sent: from wallet, to recipient, in (serialized) transaction:
     void coinsSent(interfaces::Wallet &wallet, SendCoinsRecipient recipient,
                    QByteArray transaction);
 
     // Show progress dialog e.g. for rescan
     void showProgress(const QString &title, int nProgress);
 
     // Watch-only address added
     void notifyWatchonlyChanged(bool fHaveWatchonly);
 
     // Signal that wallet is about to be removed
     void unload();
 
     // Notify that there are now keys in the keypool
     void canGetAddressesChanged();
 
 public Q_SLOTS:
     /* Starts a timer to periodically update the balance */
     void startPollBalance();
 
     /* Wallet status might have changed */
     void updateStatus();
     /** New transaction, or transaction changed status. */
     void updateTransaction();
     /** New, updated or removed address book entry. */
     void updateAddressBook(const QString &address, const QString &label,
                            bool isMine, const QString &purpose, int status);
     /** Watch-only added. */
     void updateWatchOnlyFlag(bool fHaveWatchonly);
     /**
      * Current, immature or unconfirmed balance might have changed - emit
      * 'balanceChanged' if so.
      */
     void pollBalanceChanged();
 };
 
 #endif // BITCOIN_QT_WALLETMODEL_H