diff --git a/src/checkqueue.h b/src/checkqueue.h
index 63a4e4182..07bb63871 100644
--- a/src/checkqueue.h
+++ b/src/checkqueue.h
@@ -1,242 +1,245 @@
 // Copyright (c) 2012-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_CHECKQUEUE_H
 #define BITCOIN_CHECKQUEUE_H
 
 #include <sync.h>
 #include <tinyformat.h>
 #include <util/threadnames.h>
 
 #include <algorithm>
 #include <vector>
 
 template <typename T> class CCheckQueueControl;
 
 /**
  * Queue for verifications that have to be performed.
  * The verifications are represented by a type T, which must provide an
  * operator(), returning a bool.
  *
  * One thread (the master) is assumed to push batches of verifications onto the
  * queue, where they are processed by N-1 worker threads. When the master is
  * done adding work, it temporarily joins the worker pool as an N'th worker,
  * until all jobs are done.
  */
 template <typename T> class CCheckQueue {
 private:
     //! Mutex to protect the inner state
     Mutex m_mutex;
 
     //! Worker threads block on this when out of work
     std::condition_variable m_worker_cv;
 
     //! Master thread blocks on this when out of work
     std::condition_variable m_master_cv;
 
     //! The queue of elements to be processed.
     //! As the order of booleans doesn't matter, it is used as a LIFO (stack)
     std::vector<T> queue GUARDED_BY(m_mutex);
 
     //! The number of workers (including the master) that are idle.
     int nIdle GUARDED_BY(m_mutex){0};
 
     //! The total number of workers (including the master).
     int nTotal GUARDED_BY(m_mutex){0};
 
     //! The temporary evaluation result.
     bool fAllOk GUARDED_BY(m_mutex){true};
 
     /**
      * Number of verifications that haven't completed yet.
      * This includes elements that are no longer queued, but still in the
      * worker's own batches.
      */
     unsigned int nTodo GUARDED_BY(m_mutex){0};
 
     //! The maximum number of elements to be processed in one batch
     const unsigned int nBatchSize;
 
     std::vector<std::thread> m_worker_threads;
     bool m_request_stop GUARDED_BY(m_mutex){false};
 
     /** Internal function that does bulk of the verification work. */
-    bool Loop(bool fMaster) {
+    bool Loop(bool fMaster) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         std::condition_variable &cond = fMaster ? m_master_cv : m_worker_cv;
         std::vector<T> vChecks;
         vChecks.reserve(nBatchSize);
         unsigned int nNow = 0;
         bool fOk = true;
         do {
             {
                 WAIT_LOCK(m_mutex, lock);
                 // first do the clean-up of the previous loop run (allowing us
                 // to do it in the same critsect)
                 if (nNow) {
                     fAllOk &= fOk;
                     nTodo -= nNow;
                     if (nTodo == 0 && !fMaster) {
                         // We processed the last element; inform the master it
                         // can exit and return the result
                         m_master_cv.notify_one();
                     }
                 } else {
                     // first iteration
                     nTotal++;
                 }
                 // logically, the do loop starts here
                 while (queue.empty() && !m_request_stop) {
                     if (fMaster && nTodo == 0) {
                         nTotal--;
                         bool fRet = fAllOk;
                         // reset the status for new work later
                         fAllOk = true;
                         // return the current status
                         return fRet;
                     }
                     nIdle++;
                     cond.wait(lock); // wait
                     nIdle--;
                 }
                 if (m_request_stop) {
                     return false;
                 }
 
                 // Decide how many work units to process now.
                 // * Do not try to do everything at once, but aim for
                 // increasingly smaller batches so all workers finish
                 // approximately simultaneously.
                 // * Try to account for idle jobs which will instantly start
                 // helping.
                 // * Don't do batches smaller than 1 (duh), or larger than
                 // nBatchSize.
                 nNow = std::max(
                     1U, std::min(nBatchSize, (unsigned int)queue.size() /
                                                  (nTotal + nIdle + 1)));
                 vChecks.resize(nNow);
                 for (unsigned int i = 0; i < nNow; i++) {
                     // We want the lock on the m_mutex to be as short as
                     // possible, so swap jobs from the global queue to the local
                     // batch vector instead of copying.
                     vChecks[i].swap(queue.back());
                     queue.pop_back();
                 }
                 // Check whether we need to do work at all
                 fOk = fAllOk;
             }
             // execute work
             for (T &check : vChecks) {
                 if (fOk) {
                     fOk = check();
                 }
             }
             vChecks.clear();
         } while (true);
     }
 
 public:
     //! Mutex to ensure only one concurrent CCheckQueueControl
     Mutex m_control_mutex;
 
     //! Create a new check queue
     explicit CCheckQueue(unsigned int nBatchSizeIn)
         : nBatchSize(nBatchSizeIn) {}
 
     //! Create a pool of new worker threads.
-    void StartWorkerThreads(const int threads_num) {
+    void StartWorkerThreads(const int threads_num)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         {
             LOCK(m_mutex);
             nIdle = 0;
             nTotal = 0;
             fAllOk = true;
         }
         assert(m_worker_threads.empty());
         for (int n = 0; n < threads_num; ++n) {
             m_worker_threads.emplace_back([this, n]() {
                 util::ThreadRename(strprintf("scriptch.%i", n));
                 Loop(false /* worker thread */);
             });
         }
     }
 
     //! Wait until execution finishes, and return whether all evaluations were
     //! successful.
-    bool Wait() { return Loop(true /* master thread */); }
+    bool Wait() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
+        return Loop(true /* master thread */);
+    }
 
     //! Add a batch of checks to the queue
-    void Add(std::vector<T> &vChecks) {
+    void Add(std::vector<T> &vChecks) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         LOCK(m_mutex);
         for (T &check : vChecks) {
             queue.push_back(T());
             check.swap(queue.back());
         }
         nTodo += vChecks.size();
         if (vChecks.size() == 1) {
             m_worker_cv.notify_one();
         } else if (vChecks.size() > 1) {
             m_worker_cv.notify_all();
         }
     }
 
     //! Stop all of the worker threads.
-    void StopWorkerThreads() {
+    void StopWorkerThreads() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         WITH_LOCK(m_mutex, m_request_stop = true);
         m_worker_cv.notify_all();
         for (std::thread &t : m_worker_threads) {
             t.join();
         }
         m_worker_threads.clear();
         WITH_LOCK(m_mutex, m_request_stop = false);
     }
 
     ~CCheckQueue() { assert(m_worker_threads.empty()); }
 };
 
 /**
  * RAII-style controller object for a CCheckQueue that guarantees the passed
  * queue is finished before continuing.
  */
 template <typename T> class CCheckQueueControl {
 private:
     CCheckQueue<T> *const pqueue;
     bool fDone;
 
 public:
     CCheckQueueControl() = delete;
     CCheckQueueControl(const CCheckQueueControl &) = delete;
     CCheckQueueControl &operator=(const CCheckQueueControl &) = delete;
     explicit CCheckQueueControl(CCheckQueue<T> *const pqueueIn)
         : pqueue(pqueueIn), fDone(false) {
         // passed queue is supposed to be unused, or nullptr
         if (pqueue != nullptr) {
             ENTER_CRITICAL_SECTION(pqueue->m_control_mutex);
         }
     }
 
     bool Wait() {
         if (pqueue == nullptr) {
             return true;
         }
         bool fRet = pqueue->Wait();
         fDone = true;
         return fRet;
     }
 
     void Add(std::vector<T> &vChecks) {
         if (pqueue != nullptr) {
             pqueue->Add(vChecks);
         }
     }
 
     ~CCheckQueueControl() {
         if (!fDone) {
             Wait();
         }
         if (pqueue != nullptr) {
             LEAVE_CRITICAL_SECTION(pqueue->m_control_mutex);
         }
     }
 };
 
 #endif // BITCOIN_CHECKQUEUE_H
diff --git a/src/httpserver.cpp b/src/httpserver.cpp
index 55655b0f2..cc3276b9a 100644
--- a/src/httpserver.cpp
+++ b/src/httpserver.cpp
@@ -1,693 +1,693 @@
 // Copyright (c) 2015-2016 The Bitcoin Core developers
 // Copyright (c) 2018-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <httpserver.h>
 
 #include <chainparamsbase.h>
 #include <compat.h>
 #include <config.h>
 #include <logging.h>
 #include <netbase.h>
 #include <node/ui_interface.h>
 #include <rpc/protocol.h> // For HTTP status codes
 #include <shutdown.h>
 #include <sync.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/threadnames.h>
 #include <util/translation.h>
 
 #include <event2/buffer.h>
 #include <event2/bufferevent.h>
 #include <event2/keyvalq_struct.h>
 #include <event2/thread.h>
 #include <event2/util.h>
 
 #include <support/events.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <deque>
 #include <memory>
 
 /** Maximum size of http request (request line + headers) */
 static const size_t MAX_HEADERS_SIZE = 8192;
 
 /**
  * Maximum HTTP post body size. Twice the maximum block size is added to this
  * value in practice.
  */
 static const size_t MIN_SUPPORTED_BODY_SIZE = 0x02000000;
 
 /** HTTP request work item */
 class HTTPWorkItem final : public HTTPClosure {
 public:
     HTTPWorkItem(Config &_config, std::unique_ptr<HTTPRequest> _req,
                  const std::string &_path, const HTTPRequestHandler &_func)
         : req(std::move(_req)), path(_path), func(_func), config(&_config) {}
 
     void operator()() override { func(*config, req.get(), path); }
 
     std::unique_ptr<HTTPRequest> req;
 
 private:
     std::string path;
     HTTPRequestHandler func;
     Config *config;
 };
 
 /**
  * Simple work queue for distributing work over multiple threads.
  * Work items are simply callable objects.
  */
 template <typename WorkItem> class WorkQueue {
 private:
     /** Mutex protects entire object */
     Mutex cs;
     std::condition_variable cond;
     std::deque<std::unique_ptr<WorkItem>> queue;
     bool running;
     size_t maxDepth;
 
 public:
     explicit WorkQueue(size_t _maxDepth) : running(true), maxDepth(_maxDepth) {}
     /**
      * Precondition: worker threads have all stopped (they have all been joined)
      */
     ~WorkQueue() {}
 
     /** Enqueue a work item */
-    bool Enqueue(WorkItem *item) {
+    bool Enqueue(WorkItem *item) EXCLUSIVE_LOCKS_REQUIRED(!cs) {
         LOCK(cs);
         if (queue.size() >= maxDepth) {
             return false;
         }
         queue.emplace_back(std::unique_ptr<WorkItem>(item));
         cond.notify_one();
         return true;
     }
 
     /** Thread function */
-    void Run() {
+    void Run() EXCLUSIVE_LOCKS_REQUIRED(!cs) {
         while (true) {
             std::unique_ptr<WorkItem> i;
             {
                 WAIT_LOCK(cs, lock);
                 while (running && queue.empty()) {
                     cond.wait(lock);
                 }
                 if (!running) {
                     break;
                 }
                 i = std::move(queue.front());
                 queue.pop_front();
             }
             (*i)();
         }
     }
 
     /** Interrupt and exit loops */
-    void Interrupt() {
+    void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!cs) {
         LOCK(cs);
         running = false;
         cond.notify_all();
     }
 };
 
 struct HTTPPathHandler {
     HTTPPathHandler(std::string _prefix, bool _exactMatch,
                     HTTPRequestHandler _handler)
         : prefix(_prefix), exactMatch(_exactMatch), handler(_handler) {}
     std::string prefix;
     bool exactMatch;
     HTTPRequestHandler handler;
 };
 
 /** HTTP module state */
 
 //! libevent event loop
 static struct event_base *eventBase = nullptr;
 //! HTTP server
 static struct evhttp *eventHTTP = nullptr;
 //! List of subnets to allow RPC connections from
 static std::vector<CSubNet> rpc_allow_subnets;
 //! Work queue for handling longer requests off the event loop thread
 static WorkQueue<HTTPClosure> *workQueue = nullptr;
 //! Handlers for (sub)paths
 static std::vector<HTTPPathHandler> pathHandlers;
 //! Bound listening sockets
 static std::vector<evhttp_bound_socket *> boundSockets;
 
 /** Check if a network address is allowed to access the HTTP server */
 static bool ClientAllowed(const CNetAddr &netaddr) {
     if (!netaddr.IsValid()) {
         return false;
     }
     for (const CSubNet &subnet : rpc_allow_subnets) {
         if (subnet.Match(netaddr)) {
             return true;
         }
     }
     return false;
 }
 
 /** Initialize ACL list for HTTP server */
 static bool InitHTTPAllowList() {
     rpc_allow_subnets.clear();
     CNetAddr localv4;
     CNetAddr localv6;
     LookupHost("127.0.0.1", localv4, false);
     LookupHost("::1", localv6, false);
     // always allow IPv4 local subnet.
     rpc_allow_subnets.push_back(CSubNet(localv4, 8));
     // always allow IPv6 localhost.
     rpc_allow_subnets.push_back(CSubNet(localv6));
     for (const std::string &strAllow : gArgs.GetArgs("-rpcallowip")) {
         CSubNet subnet;
         LookupSubNet(strAllow, subnet);
         if (!subnet.IsValid()) {
             uiInterface.ThreadSafeMessageBox(
                 strprintf(
                     Untranslated("Invalid -rpcallowip subnet specification: "
                                  "%s. Valid are a single IP (e.g. 1.2.3.4), a "
                                  "network/netmask (e.g. 1.2.3.4/255.255.255.0) "
                                  "or a network/CIDR (e.g. 1.2.3.4/24)."),
                     strAllow),
                 "", CClientUIInterface::MSG_ERROR);
             return false;
         }
         rpc_allow_subnets.push_back(subnet);
     }
     std::string strAllowed;
     for (const CSubNet &subnet : rpc_allow_subnets) {
         strAllowed += subnet.ToString() + " ";
     }
     LogPrint(BCLog::HTTP, "Allowing HTTP connections from: %s\n", strAllowed);
     return true;
 }
 
 /** HTTP request method as string - use for logging only */
 std::string RequestMethodString(HTTPRequest::RequestMethod m) {
     switch (m) {
         case HTTPRequest::GET:
             return "GET";
         case HTTPRequest::POST:
             return "POST";
         case HTTPRequest::HEAD:
             return "HEAD";
         case HTTPRequest::PUT:
             return "PUT";
         case HTTPRequest::OPTIONS:
             return "OPTIONS";
         default:
             return "unknown";
     }
 }
 
 /** HTTP request callback */
 static void http_request_cb(struct evhttp_request *req, void *arg) {
     Config &config = *reinterpret_cast<Config *>(arg);
 
     // Disable reading to work around a libevent bug, fixed in 2.2.0.
     if (event_get_version_number() >= 0x02010600 &&
         event_get_version_number() < 0x02020001) {
         evhttp_connection *conn = evhttp_request_get_connection(req);
         if (conn) {
             bufferevent *bev = evhttp_connection_get_bufferevent(conn);
             if (bev) {
                 bufferevent_disable(bev, EV_READ);
             }
         }
     }
     auto hreq = std::make_unique<HTTPRequest>(req);
 
     // Early address-based allow check
     if (!ClientAllowed(hreq->GetPeer())) {
         LogPrint(BCLog::HTTP,
                  "HTTP request from %s rejected: Client network is not allowed "
                  "RPC access\n",
                  hreq->GetPeer().ToString());
         hreq->WriteReply(HTTP_FORBIDDEN);
         return;
     }
 
     // Early reject unknown HTTP methods
     if (hreq->GetRequestMethod() == HTTPRequest::UNKNOWN) {
         LogPrint(BCLog::HTTP,
                  "HTTP request from %s rejected: Unknown HTTP request method\n",
                  hreq->GetPeer().ToString());
         hreq->WriteReply(HTTP_BAD_METHOD);
         return;
     }
 
     LogPrint(BCLog::HTTP, "Received a %s request for %s from %s\n",
              RequestMethodString(hreq->GetRequestMethod()),
              SanitizeString(hreq->GetURI(), SAFE_CHARS_URI).substr(0, 100),
              hreq->GetPeer().ToString());
 
     // Find registered handler for prefix
     std::string strURI = hreq->GetURI();
     std::string path;
     std::vector<HTTPPathHandler>::const_iterator i = pathHandlers.begin();
     std::vector<HTTPPathHandler>::const_iterator iend = pathHandlers.end();
     for (; i != iend; ++i) {
         bool match = false;
         if (i->exactMatch) {
             match = (strURI == i->prefix);
         } else {
             match = (strURI.substr(0, i->prefix.size()) == i->prefix);
         }
         if (match) {
             path = strURI.substr(i->prefix.size());
             break;
         }
     }
 
     // Dispatch to worker thread.
     if (i != iend) {
         std::unique_ptr<HTTPWorkItem> item(
             new HTTPWorkItem(config, std::move(hreq), path, i->handler));
         assert(workQueue);
         if (workQueue->Enqueue(item.get())) {
             /* if true, queue took ownership */
             item.release();
         } else {
             LogPrintf("WARNING: request rejected because http work queue depth "
                       "exceeded, it can be increased with the -rpcworkqueue= "
                       "setting\n");
             item->req->WriteReply(HTTP_SERVICE_UNAVAILABLE,
                                   "Work queue depth exceeded");
         }
     } else {
         hreq->WriteReply(HTTP_NOT_FOUND);
     }
 }
 
 /** Callback to reject HTTP requests after shutdown. */
 static void http_reject_request_cb(struct evhttp_request *req, void *) {
     LogPrint(BCLog::HTTP, "Rejecting request while shutting down\n");
     evhttp_send_error(req, HTTP_SERVUNAVAIL, nullptr);
 }
 
 /** Event dispatcher thread */
 static bool ThreadHTTP(struct event_base *base) {
     util::ThreadRename("http");
     LogPrint(BCLog::HTTP, "Entering http event loop\n");
     event_base_dispatch(base);
     // Event loop will be interrupted by InterruptHTTPServer()
     LogPrint(BCLog::HTTP, "Exited http event loop\n");
     return event_base_got_break(base) == 0;
 }
 
 /** Bind HTTP server to specified addresses */
 static bool HTTPBindAddresses(struct evhttp *http) {
     uint16_t http_port{static_cast<uint16_t>(
         gArgs.GetIntArg("-rpcport", BaseParams().RPCPort()))};
     std::vector<std::pair<std::string, uint16_t>> endpoints;
 
     // Determine what addresses to bind to
     if (!(gArgs.IsArgSet("-rpcallowip") && gArgs.IsArgSet("-rpcbind"))) {
         // Default to loopback if not allowing external IPs.
         endpoints.push_back(std::make_pair("::1", http_port));
         endpoints.push_back(std::make_pair("127.0.0.1", http_port));
         if (gArgs.IsArgSet("-rpcallowip")) {
             LogPrintf("WARNING: option -rpcallowip was specified without "
                       "-rpcbind; this doesn't usually make sense\n");
         }
         if (gArgs.IsArgSet("-rpcbind")) {
             LogPrintf("WARNING: option -rpcbind was ignored because "
                       "-rpcallowip was not specified, refusing to allow "
                       "everyone to connect\n");
         }
     } else if (gArgs.IsArgSet("-rpcbind")) {
         // Specific bind address.
         for (const std::string &strRPCBind : gArgs.GetArgs("-rpcbind")) {
             uint16_t port{http_port};
             std::string host;
             SplitHostPort(strRPCBind, port, host);
             endpoints.push_back(std::make_pair(host, port));
         }
     }
 
     // Bind addresses
     for (std::vector<std::pair<std::string, uint16_t>>::iterator i =
              endpoints.begin();
          i != endpoints.end(); ++i) {
         LogPrint(BCLog::HTTP, "Binding RPC on address %s port %i\n", i->first,
                  i->second);
         evhttp_bound_socket *bind_handle = evhttp_bind_socket_with_handle(
             http, i->first.empty() ? nullptr : i->first.c_str(), i->second);
         if (bind_handle) {
             CNetAddr addr;
             if (i->first.empty() ||
                 (LookupHost(i->first, addr, false) && addr.IsBindAny())) {
                 LogPrintf("WARNING: the RPC server is not safe to expose to "
                           "untrusted networks such as the public internet\n");
             }
             boundSockets.push_back(bind_handle);
         } else {
             LogPrintf("Binding RPC on address %s port %i failed.\n", i->first,
                       i->second);
         }
     }
     return !boundSockets.empty();
 }
 
 /** Simple wrapper to set thread name and run work queue */
 static void HTTPWorkQueueRun(WorkQueue<HTTPClosure> *queue, int worker_num) {
     util::ThreadRename(strprintf("httpworker.%i", worker_num));
     queue->Run();
 }
 
 /** libevent event log callback */
 static void libevent_log_cb(int severity, const char *msg) {
 #ifndef EVENT_LOG_WARN
 // EVENT_LOG_WARN was added in 2.0.19; but before then _EVENT_LOG_WARN existed.
 #define EVENT_LOG_WARN _EVENT_LOG_WARN
 #endif
     // Log warn messages and higher without debug category.
     if (severity >= EVENT_LOG_WARN) {
         LogPrintf("libevent: %s\n", msg);
     } else {
         LogPrint(BCLog::LIBEVENT, "libevent: %s\n", msg);
     }
 }
 
 bool InitHTTPServer(Config &config) {
     if (!InitHTTPAllowList()) {
         return false;
     }
 
     // Redirect libevent's logging to our own log
     event_set_log_callback(&libevent_log_cb);
     // Update libevent's log handling. Returns false if our version of
     // libevent doesn't support debug logging, in which case we should
     // clear the BCLog::LIBEVENT flag.
     if (!UpdateHTTPServerLogging(
             LogInstance().WillLogCategory(BCLog::LIBEVENT))) {
         LogInstance().DisableCategory(BCLog::LIBEVENT);
     }
 
 #ifdef WIN32
     evthread_use_windows_threads();
 #else
     evthread_use_pthreads();
 #endif
 
     raii_event_base base_ctr = obtain_event_base();
 
     /* Create a new evhttp object to handle requests. */
     raii_evhttp http_ctr = obtain_evhttp(base_ctr.get());
     struct evhttp *http = http_ctr.get();
     if (!http) {
         LogPrintf("couldn't create evhttp. Exiting.\n");
         return false;
     }
 
     evhttp_set_timeout(http, gArgs.GetIntArg("-rpcservertimeout",
                                              DEFAULT_HTTP_SERVER_TIMEOUT));
     evhttp_set_max_headers_size(http, MAX_HEADERS_SIZE);
     evhttp_set_max_body_size(http, MIN_SUPPORTED_BODY_SIZE +
                                        2 * config.GetMaxBlockSize());
     evhttp_set_gencb(http, http_request_cb, &config);
 
     // Only POST and OPTIONS are supported, but we return HTTP 405 for the
     // others
     evhttp_set_allowed_methods(
         http, EVHTTP_REQ_GET | EVHTTP_REQ_POST | EVHTTP_REQ_HEAD |
                   EVHTTP_REQ_PUT | EVHTTP_REQ_DELETE | EVHTTP_REQ_OPTIONS);
 
     if (!HTTPBindAddresses(http)) {
         LogPrintf("Unable to bind any endpoint for RPC server\n");
         return false;
     }
 
     LogPrint(BCLog::HTTP, "Initialized HTTP server\n");
     int workQueueDepth = std::max(
         (long)gArgs.GetIntArg("-rpcworkqueue", DEFAULT_HTTP_WORKQUEUE), 1L);
     LogPrintf("HTTP: creating work queue of depth %d\n", workQueueDepth);
 
     workQueue = new WorkQueue<HTTPClosure>(workQueueDepth);
     // transfer ownership to eventBase/HTTP via .release()
     eventBase = base_ctr.release();
     eventHTTP = http_ctr.release();
     return true;
 }
 
 bool UpdateHTTPServerLogging(bool enable) {
 #if LIBEVENT_VERSION_NUMBER >= 0x02010100
     if (enable) {
         event_enable_debug_logging(EVENT_DBG_ALL);
     } else {
         event_enable_debug_logging(EVENT_DBG_NONE);
     }
     return true;
 #else
     // Can't update libevent logging if version < 02010100
     return false;
 #endif
 }
 
 static std::thread g_thread_http;
 static std::vector<std::thread> g_thread_http_workers;
 
 void StartHTTPServer() {
     LogPrint(BCLog::HTTP, "Starting HTTP server\n");
     int rpcThreads = std::max(
         (long)gArgs.GetIntArg("-rpcthreads", DEFAULT_HTTP_THREADS), 1L);
     LogPrintf("HTTP: starting %d worker threads\n", rpcThreads);
     g_thread_http = std::thread(ThreadHTTP, eventBase);
 
     for (int i = 0; i < rpcThreads; i++) {
         g_thread_http_workers.emplace_back(HTTPWorkQueueRun, workQueue, i);
     }
 }
 
 void InterruptHTTPServer() {
     LogPrint(BCLog::HTTP, "Interrupting HTTP server\n");
     if (eventHTTP) {
         // Reject requests on current connections
         evhttp_set_gencb(eventHTTP, http_reject_request_cb, nullptr);
     }
     if (workQueue) {
         workQueue->Interrupt();
     }
 }
 
 void StopHTTPServer() {
     LogPrint(BCLog::HTTP, "Stopping HTTP server\n");
     if (workQueue) {
         LogPrint(BCLog::HTTP, "Waiting for HTTP worker threads to exit\n");
         for (auto &thread : g_thread_http_workers) {
             thread.join();
         }
         g_thread_http_workers.clear();
         delete workQueue;
         workQueue = nullptr;
     }
     // Unlisten sockets, these are what make the event loop running, which means
     // that after this and all connections are closed the event loop will quit.
     for (evhttp_bound_socket *socket : boundSockets) {
         evhttp_del_accept_socket(eventHTTP, socket);
     }
     boundSockets.clear();
     if (eventBase) {
         LogPrint(BCLog::HTTP, "Waiting for HTTP event thread to exit\n");
         if (g_thread_http.joinable()) {
             g_thread_http.join();
         }
     }
     if (eventHTTP) {
         evhttp_free(eventHTTP);
         eventHTTP = nullptr;
     }
     if (eventBase) {
         event_base_free(eventBase);
         eventBase = nullptr;
     }
     LogPrint(BCLog::HTTP, "Stopped HTTP server\n");
 }
 
 struct event_base *EventBase() {
     return eventBase;
 }
 
 static void httpevent_callback_fn(evutil_socket_t, short, void *data) {
     // Static handler: simply call inner handler
     HTTPEvent *self = static_cast<HTTPEvent *>(data);
     self->handler();
     if (self->deleteWhenTriggered) {
         delete self;
     }
 }
 
 HTTPEvent::HTTPEvent(struct event_base *base, bool _deleteWhenTriggered,
                      const std::function<void()> &_handler)
     : deleteWhenTriggered(_deleteWhenTriggered), handler(_handler) {
     ev = event_new(base, -1, 0, httpevent_callback_fn, this);
     assert(ev);
 }
 HTTPEvent::~HTTPEvent() {
     event_free(ev);
 }
 void HTTPEvent::trigger(struct timeval *tv) {
     if (tv == nullptr) {
         // Immediately trigger event in main thread.
         event_active(ev, 0, 0);
     } else {
         // Trigger after timeval passed.
         evtimer_add(ev, tv);
     }
 }
 HTTPRequest::HTTPRequest(struct evhttp_request *_req, bool _replySent)
     : req(_req), replySent(_replySent) {}
 HTTPRequest::~HTTPRequest() {
     if (!replySent) {
         // Keep track of whether reply was sent to avoid request leaks
         LogPrintf("%s: Unhandled request\n", __func__);
         WriteReply(HTTP_INTERNAL_SERVER_ERROR, "Unhandled request");
     }
     // evhttpd cleans up the request, as long as a reply was sent.
 }
 
 std::pair<bool, std::string>
 HTTPRequest::GetHeader(const std::string &hdr) const {
     const struct evkeyvalq *headers = evhttp_request_get_input_headers(req);
     assert(headers);
     const char *val = evhttp_find_header(headers, hdr.c_str());
     if (val) {
         return std::make_pair(true, val);
     } else {
         return std::make_pair(false, "");
     }
 }
 
 std::string HTTPRequest::ReadBody() {
     struct evbuffer *buf = evhttp_request_get_input_buffer(req);
     if (!buf) {
         return "";
     }
     size_t size = evbuffer_get_length(buf);
     /**
      * Trivial implementation: if this is ever a performance bottleneck,
      * internal copying can be avoided in multi-segment buffers by using
      * evbuffer_peek and an awkward loop. Though in that case, it'd be even
      * better to not copy into an intermediate string but use a stream
      * abstraction to consume the evbuffer on the fly in the parsing algorithm.
      */
     const char *data = (const char *)evbuffer_pullup(buf, size);
 
     // returns nullptr in case of empty buffer.
     if (!data) {
         return "";
     }
     std::string rv(data, size);
     evbuffer_drain(buf, size);
     return rv;
 }
 
 void HTTPRequest::WriteHeader(const std::string &hdr,
                               const std::string &value) {
     struct evkeyvalq *headers = evhttp_request_get_output_headers(req);
     assert(headers);
     evhttp_add_header(headers, hdr.c_str(), value.c_str());
 }
 
 /**
  * Closure sent to main thread to request a reply to be sent to a HTTP request.
  * Replies must be sent in the main loop in the main http thread, this cannot be
  * done from worker threads.
  */
 void HTTPRequest::WriteReply(int nStatus, const std::string &strReply) {
     assert(!replySent && req);
     if (ShutdownRequested()) {
         WriteHeader("Connection", "close");
     }
     // Send event to main http thread to send reply message
     struct evbuffer *evb = evhttp_request_get_output_buffer(req);
     assert(evb);
     evbuffer_add(evb, strReply.data(), strReply.size());
     auto req_copy = req;
     HTTPEvent *ev = new HTTPEvent(eventBase, true, [req_copy, nStatus] {
         evhttp_send_reply(req_copy, nStatus, nullptr, nullptr);
         // Re-enable reading from the socket. This is the second part of the
         // libevent workaround above.
         if (event_get_version_number() >= 0x02010600 &&
             event_get_version_number() < 0x02020001) {
             evhttp_connection *conn = evhttp_request_get_connection(req_copy);
             if (conn) {
                 bufferevent *bev = evhttp_connection_get_bufferevent(conn);
                 if (bev) {
                     bufferevent_enable(bev, EV_READ | EV_WRITE);
                 }
             }
         }
     });
     ev->trigger(nullptr);
     replySent = true;
     // transferred back to main thread.
     req = nullptr;
 }
 
 CService HTTPRequest::GetPeer() const {
     evhttp_connection *con = evhttp_request_get_connection(req);
     CService peer;
     if (con) {
         // evhttp retains ownership over returned address string
         const char *address = "";
         uint16_t port = 0;
         evhttp_connection_get_peer(con, (char **)&address, &port);
         peer = LookupNumeric(address, port);
     }
     return peer;
 }
 
 std::string HTTPRequest::GetURI() const {
     return evhttp_request_get_uri(req);
 }
 
 HTTPRequest::RequestMethod HTTPRequest::GetRequestMethod() const {
     switch (evhttp_request_get_command(req)) {
         case EVHTTP_REQ_GET:
             return GET;
         case EVHTTP_REQ_POST:
             return POST;
         case EVHTTP_REQ_HEAD:
             return HEAD;
         case EVHTTP_REQ_PUT:
             return PUT;
         case EVHTTP_REQ_OPTIONS:
             return OPTIONS;
         default:
             return UNKNOWN;
     }
 }
 
 void RegisterHTTPHandler(const std::string &prefix, bool exactMatch,
                          const HTTPRequestHandler &handler) {
     LogPrint(BCLog::HTTP, "Registering HTTP handler for %s (exactmatch %d)\n",
              prefix, exactMatch);
     pathHandlers.push_back(HTTPPathHandler(prefix, exactMatch, handler));
 }
 
 void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch) {
     std::vector<HTTPPathHandler>::iterator i = pathHandlers.begin();
     std::vector<HTTPPathHandler>::iterator iend = pathHandlers.end();
     for (; i != iend; ++i) {
         if (i->prefix == prefix && i->exactMatch == exactMatch) {
             break;
         }
     }
     if (i != iend) {
         LogPrint(BCLog::HTTP,
                  "Unregistering HTTP handler for %s (exactmatch %d)\n", prefix,
                  exactMatch);
         pathHandlers.erase(i);
     }
 }
diff --git a/src/i2p.h b/src/i2p.h
index 3a05bf8cf..b817fbf2b 100644
--- a/src/i2p.h
+++ b/src/i2p.h
@@ -1,283 +1,284 @@
 // Copyright (c) 2020-2020 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_I2P_H
 #define BITCOIN_I2P_H
 
 #include <compat.h>
 #include <fs.h>
 #include <netaddress.h>
 #include <sync.h>
 #include <threadinterrupt.h>
 #include <util/sock.h>
 
 #include <memory>
 #include <optional>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 namespace i2p {
 
 /**
  * Binary data.
  */
 using Binary = std::vector<uint8_t>;
 
 /**
  * An established connection with another peer.
  */
 struct Connection {
     /** Connected socket. */
     std::unique_ptr<Sock> sock;
 
     /** Our I2P address. */
     CService me;
 
     /** The peer's I2P address. */
     CService peer;
 };
 
 namespace sam {
 
     /**
      * The maximum size of an incoming message from the I2P SAM proxy (in
      * bytes). Used to avoid a runaway proxy from sending us an "unlimited"
      * amount of data without a terminator. The longest known message is ~1400
      * bytes, so this is high enough not to be triggered during normal
      * operation, yet low enough to avoid a malicious proxy from filling our
      * memory.
      */
     static constexpr size_t MAX_MSG_SIZE{65536};
 
     /**
      * I2P SAM session.
      */
     class Session {
     public:
         /**
          * Construct a session. This will not initiate any IO, the session will
          * be lazily created later when first used.
          * @param[in] private_key_file Path to a private key file. If the file
          * does not exist then the private key will be generated and saved into
          * the file.
          * @param[in] control_host Location of the SAM proxy.
          * @param[in,out] interrupt If this is signaled then all operations are
          * canceled as soon as possible and executing methods throw an
          * exception. Notice: only a pointer to the `CThreadInterrupt` object is
          * saved, so it must not be destroyed earlier than this `Session`
          * object.
          */
         Session(const fs::path &private_key_file, const CService &control_host,
                 CThreadInterrupt *interrupt);
 
         /**
          * Destroy the session, closing the internally used sockets. The sockets
          * that have been returned by `Accept()` or `Connect()` will not be
          * closed, but they will be closed by the SAM proxy because the session
          * is destroyed. So they will return an error next time we try to read
          * or write to them.
          */
         ~Session();
 
         /**
          * Start listening for an incoming connection.
          * @param[out] conn Upon successful completion the `sock` and `me`
          * members will be set to the listening socket and address.
          * @return true on success
          */
-        bool Listen(Connection &conn);
+        bool Listen(Connection &conn) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
         /**
          * Wait for and accept a new incoming connection.
          * @param[in,out] conn The `sock` member is used for waiting and
          * accepting. Upon successful completion the `peer` member will be set
          * to the address of the incoming peer.
          * @return true on success
          */
-        bool Accept(Connection &conn);
+        bool Accept(Connection &conn) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
         /**
          * Connect to an I2P peer.
          * @param[in] to Peer to connect to.
          * @param[out] conn Established connection. Only set if `true` is
          * returned.
          * @param[out] proxy_error If an error occurs due to proxy or general
          * network failure, then this is set to `true`. If an error occurs due
          * to unreachable peer (likely peer is down), then it is set to `false`.
          * Only set if `false` is returned.
          * @return true on success
          */
-        bool Connect(const CService &to, Connection &conn, bool &proxy_error);
+        bool Connect(const CService &to, Connection &conn, bool &proxy_error)
+            EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
     private:
         /**
          * A reply from the SAM proxy.
          */
         struct Reply {
             /**
              * Full, unparsed reply.
              */
             std::string full;
 
             /**
              * Request, used for detailed error reporting.
              */
             std::string request;
 
             /**
              * A map of keywords from the parsed reply.
              * For example, if the reply is "A=X B C=YZ", then the map will be
              * keys["A"] == "X"
              * keys["B"] == (empty std::optional)
              * keys["C"] == "YZ"
              */
             std::unordered_map<std::string, std::optional<std::string>> keys;
 
             /**
              * Get the value of a given key.
              * For example if the reply is "A=X B" then:
              * Value("A") -> "X"
              * Value("B") -> throws
              * Value("C") -> throws
              * @param[in] key Key whose value to retrieve
              * @returns the key's value
              * @throws std::runtime_error if the key is not present or if it has
              * no value
              */
             std::string Get(const std::string &key) const;
         };
 
         /**
          * Log a message in the `BCLog::I2P` category.
          * @param[in] fmt printf(3)-like format string.
          * @param[in] args printf(3)-like arguments that correspond to `fmt`.
          */
         template <typename... Args>
         void Log(const std::string &fmt, const Args &...args) const;
 
         /**
          * Send request and get a reply from the SAM proxy.
          * @param[in] sock A socket that is connected to the SAM proxy.
          * @param[in] request Raw request to send, a newline terminator is
          * appended to it.
          * @param[in] check_result_ok If true then after receiving the reply a
          * check is made whether it contains "RESULT=OK" and an exception is
          * thrown if it does not.
          * @throws std::runtime_error if an error occurs
          */
         Reply SendRequestAndGetReply(const Sock &sock,
                                      const std::string &request,
                                      bool check_result_ok = true) const;
 
         /**
          * Open a new connection to the SAM proxy.
          * @return a connected socket
          * @throws std::runtime_error if an error occurs
          */
         std::unique_ptr<Sock> Hello() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
         /**
          * Check the control socket for errors and possibly disconnect.
          */
-        void CheckControlSock();
+        void CheckControlSock() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
         /**
          * Generate a new destination with the SAM proxy and set `m_private_key`
          * to it.
          * @param[in] sock Socket to use for talking to the SAM proxy.
          * @throws std::runtime_error if an error occurs
          */
         void DestGenerate(const Sock &sock) EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
         /**
          * Generate a new destination with the SAM proxy, set `m_private_key` to
          * it and save it on disk to `m_private_key_file`.
          * @param[in] sock Socket to use for talking to the SAM proxy.
          * @throws std::runtime_error if an error occurs
          */
         void GenerateAndSavePrivateKey(const Sock &sock)
             EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
         /**
          * Derive own destination from `m_private_key`.
          * @see https://geti2p.net/spec/common-structures#destination
          * @return an I2P destination
          */
         Binary MyDestination() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
         /**
          * Create the session if not already created. Reads the private key file
          * and connects to the SAM proxy.
          * @throws std::runtime_error if an error occurs
          */
         void CreateIfNotCreatedAlready() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
         /**
          * Open a new connection to the SAM proxy and issue "STREAM ACCEPT"
          * request using the existing session id.
          * @return the idle socket that is waiting for a peer to connect to us
          * @throws std::runtime_error if an error occurs
          */
         std::unique_ptr<Sock> StreamAccept() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
         /**
          * Destroy the session, closing the internally used sockets.
          */
         void Disconnect() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
         /**
          * The name of the file where this peer's private key is stored (in
          * binary).
          */
         const fs::path m_private_key_file;
 
         /**
          * The host and port of the SAM control service.
          */
         const CService m_control_host;
 
         /**
          * Cease network activity when this is signaled.
          */
         CThreadInterrupt *const m_interrupt;
 
         /**
          * Mutex protecting the members that can be concurrently accessed.
          */
         mutable Mutex m_mutex;
 
         /**
          * The private key of this peer.
          * @see The reply to the "DEST GENERATE" command in
          * https://geti2p.net/en/docs/api/samv3
          */
         Binary m_private_key GUARDED_BY(m_mutex);
 
         /**
          * SAM control socket.
          * Used to connect to the I2P SAM service and create a session
          * ("SESSION CREATE"). With the established session id we later open
          * other connections to the SAM service to accept incoming I2P
          * connections and make outgoing ones.
          * See https://geti2p.net/en/docs/api/samv3
          */
         std::unique_ptr<Sock> m_control_sock GUARDED_BY(m_mutex);
 
         /**
          * Our .b32.i2p address.
          * Derived from `m_private_key`.
          */
         CService m_my_addr GUARDED_BY(m_mutex);
 
         /**
          * SAM session id.
          */
         std::string m_session_id GUARDED_BY(m_mutex);
     };
 
 } // namespace sam
 } // namespace i2p
 
 #endif // BITCOIN_I2P_H
diff --git a/src/index/blockfilterindex.h b/src/index/blockfilterindex.h
index 37f2214e7..8f4365e9d 100644
--- a/src/index/blockfilterindex.h
+++ b/src/index/blockfilterindex.h
@@ -1,110 +1,110 @@
 // 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_INDEX_BLOCKFILTERINDEX_H
 #define BITCOIN_INDEX_BLOCKFILTERINDEX_H
 
 #include <blockfilter.h>
 #include <chain.h>
 #include <flatfile.h>
 #include <index/base.h>
 #include <util/hasher.h>
 
 /** Interval between compact filter checkpoints. See BIP 157. */
 static constexpr int CFCHECKPT_INTERVAL = 1000;
 
 /**
  * BlockFilterIndex is used to store and retrieve block filters, hashes, and
  * headers for a range of blocks by height. An index is constructed for each
  * supported filter type with its own database (ie. filter data for different
  * types are stored in separate databases).
  *
  * This index is used to serve BIP 157 net requests.
  */
 class BlockFilterIndex final : public BaseIndex {
 private:
     BlockFilterType m_filter_type;
     std::string m_name;
     std::unique_ptr<BaseIndex::DB> m_db;
 
     FlatFilePos m_next_filter_pos;
     std::unique_ptr<FlatFileSeq> m_filter_fileseq;
 
     bool ReadFilterFromDisk(const FlatFilePos &pos, BlockFilter &filter) const;
     size_t WriteFilterToDisk(FlatFilePos &pos, const BlockFilter &filter);
 
     Mutex m_cs_headers_cache;
     /**
      * Cache of block hash to filter header, to avoid disk access when
      * responding to getcfcheckpt.
      */
     std::unordered_map<BlockHash, uint256, FilterHeaderHasher>
         m_headers_cache GUARDED_BY(m_cs_headers_cache);
 
 protected:
     bool Init() override;
 
     bool CommitInternal(CDBBatch &batch) override;
 
     bool WriteBlock(const CBlock &block, const CBlockIndex *pindex) override;
 
     bool Rewind(const CBlockIndex *current_tip,
                 const CBlockIndex *new_tip) override;
 
     BaseIndex::DB &GetDB() const override { return *m_db; }
 
     const char *GetName() const override { return m_name.c_str(); }
 
 public:
     /** Constructs the index, which becomes available to be queried. */
     explicit BlockFilterIndex(BlockFilterType filter_type, size_t n_cache_size,
                               bool f_memory = false, bool f_wipe = false);
 
     BlockFilterType GetFilterType() const { return m_filter_type; }
 
     /** Get a single filter by block. */
     bool LookupFilter(const CBlockIndex *block_index,
                       BlockFilter &filter_out) const;
 
     /** Get a single filter header by block. */
-    bool LookupFilterHeader(const CBlockIndex *block_index,
-                            uint256 &header_out);
+    bool LookupFilterHeader(const CBlockIndex *block_index, uint256 &header_out)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_cs_headers_cache);
 
     /** Get a range of filters between two heights on a chain. */
     bool LookupFilterRange(int start_height, const CBlockIndex *stop_index,
                            std::vector<BlockFilter> &filters_out) const;
 
     /** Get a range of filter hashes between two heights on a chain. */
     bool LookupFilterHashRange(int start_height, const CBlockIndex *stop_index,
                                std::vector<uint256> &hashes_out) const;
 };
 
 /**
  * Get a block filter index by type. Returns nullptr if index has not been
  * initialized or was already destroyed.
  */
 BlockFilterIndex *GetBlockFilterIndex(BlockFilterType filter_type);
 
 /** Iterate over all running block filter indexes, invoking fn on each. */
 void ForEachBlockFilterIndex(std::function<void(BlockFilterIndex &)> fn);
 
 /**
  * Initialize a block filter index for the given type if one does not already
  * exist. Returns true if a new index is created and false if one has already
  * been initialized.
  */
 bool InitBlockFilterIndex(BlockFilterType filter_type, size_t n_cache_size,
                           bool f_memory = false, bool f_wipe = false);
 
 /**
  * Destroy the block filter index with the given type. Returns false if no such
  * index exists. This just releases the allocated memory and closes the database
  * connection, it does not delete the index data.
  */
 bool DestroyBlockFilterIndex(BlockFilterType filter_type);
 
 /** Destroy all open block filter indexes. */
 void DestroyAllBlockFilterIndexes();
 
 #endif // BITCOIN_INDEX_BLOCKFILTERINDEX_H
diff --git a/src/net.h b/src/net.h
index a1a544633..2b1ae3661 100644
--- a/src/net.h
+++ b/src/net.h
@@ -1,1388 +1,1401 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_NET_H
 #define BITCOIN_NET_H
 
 #include <avalanche/proofid.h>
 #include <avalanche/proofradixtreeadapter.h>
 #include <bloom.h>
 #include <chainparams.h>
 #include <compat.h>
 #include <consensus/amount.h>
 #include <crypto/siphash.h>
 #include <hash.h>
 #include <i2p.h>
 #include <logging.h>
 #include <net_permissions.h>
 #include <netaddress.h>
 #include <nodeid.h>
 #include <protocol.h>
 #include <pubkey.h>
 #include <radix.h>
 #include <random.h>
 #include <span.h>
 #include <streams.h>
 #include <sync.h>
 #include <threadinterrupt.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/time.h>
 #include <validation.h> // For cs_main
 
 #include <atomic>
 #include <condition_variable>
 #include <cstdint>
 #include <deque>
 #include <functional>
 #include <list>
 #include <map>
 #include <memory>
 #include <thread>
 #include <vector>
 
 class AddrMan;
 class BanMan;
 class Config;
 class CNode;
 class CScheduler;
 struct bilingual_str;
 
 /** Default for -whitelistrelay. */
 static const bool DEFAULT_WHITELISTRELAY = true;
 /** Default for -whitelistforcerelay. */
 static const bool DEFAULT_WHITELISTFORCERELAY = false;
 
 /**
  * Time after which to disconnect, after waiting for a ping response (or
  * inactivity).
  */
 static constexpr std::chrono::minutes TIMEOUT_INTERVAL{20};
 /** Run the feeler connection loop once every 2 minutes. **/
 static constexpr auto FEELER_INTERVAL = 2min;
 /** Run the extra block-relay-only connection loop once every 5 minutes. **/
 static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min;
 /** Maximum length of the user agent string in `version` message */
 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
 /**
  * Maximum number of automatic outgoing nodes over which we'll relay everything
  * (blocks, tx, addrs, etc)
  */
 static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS = 16;
 /** Maximum number of addnode outgoing nodes */
 static const int MAX_ADDNODE_CONNECTIONS = 8;
 /** Maximum number of block-relay-only outgoing connections */
 static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS = 2;
 /**
  * Maximum number of avalanche enabled outgoing connections by default.
  * Can be overridden with the -maxavalancheoutbound option.
  */
 static const int DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS = 300;
 /** Maximum number of feeler connections */
 static const int MAX_FEELER_CONNECTIONS = 1;
 /** -listen default */
 static const bool DEFAULT_LISTEN = true;
 /**
  * The maximum number of peer connections to maintain.
  * This quantity might not be reachable on some systems, especially on platforms
  * that do not provide a working poll() interface.
  */
 static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 4096;
 /** The default for -maxuploadtarget. 0 = Unlimited */
 static constexpr uint64_t DEFAULT_MAX_UPLOAD_TARGET = 0;
 /** Default for blocks only*/
 static const bool DEFAULT_BLOCKSONLY = false;
 /** -peertimeout default */
 static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60;
 /** Number of file descriptors required for message capture **/
 static const int NUM_FDS_MESSAGE_CAPTURE = 1;
 
 static const bool DEFAULT_FORCEDNSSEED = false;
 static const bool DEFAULT_DNSSEED = true;
 static const bool DEFAULT_FIXEDSEEDS = true;
 static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
 static const size_t DEFAULT_MAXSENDBUFFER = 1 * 1000;
 
 struct AddedNodeInfo {
     std::string strAddedNode;
     CService resolvedAddress;
     bool fConnected;
     bool fInbound;
 };
 
 struct CNodeStats;
 class CClientUIInterface;
 
 struct CSerializedNetMsg {
     CSerializedNetMsg() = default;
     CSerializedNetMsg(CSerializedNetMsg &&) = default;
     CSerializedNetMsg &operator=(CSerializedNetMsg &&) = default;
     // No copying, only moves.
     CSerializedNetMsg(const CSerializedNetMsg &msg) = delete;
     CSerializedNetMsg &operator=(const CSerializedNetMsg &) = delete;
 
     std::vector<uint8_t> data;
     std::string m_type;
 };
 
 const std::vector<std::string> CONNECTION_TYPE_DOC{
     "outbound-full-relay (default automatic connections)",
     "block-relay-only (does not relay transactions or addresses)",
     "inbound (initiated by the peer)",
     "manual (added via addnode RPC or -addnode/-connect configuration options)",
     "addr-fetch (short-lived automatic connection for soliciting addresses)",
     "feeler (short-lived automatic connection for testing addresses)"};
 
 /**
  * Different types of connections to a peer. This enum encapsulates the
  * information we have available at the time of opening or accepting the
  * connection. Aside from INBOUND, all types are initiated by us.
  */
 enum class ConnectionType {
     /**
      * Inbound connections are those initiated by a peer. This is the only
      * property we know at the time of connection, until P2P messages are
      * exchanged.
      */
     INBOUND,
 
     /**
      * These are the default connections that we use to connect with the
      * network. There is no restriction on what is relayed- by default we relay
      * blocks, addresses & transactions. We automatically attempt to open
      * MAX_OUTBOUND_FULL_RELAY_CONNECTIONS using addresses from our AddrMan.
      */
     OUTBOUND_FULL_RELAY,
 
     /**
      * We open manual connections to addresses that users explicitly inputted
      * via the addnode RPC, or the -connect command line argument. Even if a
      * manual connection is misbehaving, we do not automatically disconnect or
      * add it to our discouragement filter.
      */
     MANUAL,
 
     /**
      * Feeler connections are short-lived connections made to check that a node
      * is alive. They can be useful for:
      * - test-before-evict: if one of the peers is considered for eviction from
      *   our AddrMan because another peer is mapped to the same slot in the
      *   tried table, evict only if this longer-known peer is offline.
      * - move node addresses from New to Tried table, so that we have more
      *   connectable addresses in our AddrMan.
      * Note that in the literature ("Eclipse Attacks on Bitcoin’s Peer-to-Peer
      * Network") only the latter feature is referred to as "feeler connections",
      * although in our codebase feeler connections encompass test-before-evict
      * as well.
      * We make these connections approximately every FEELER_INTERVAL:
      * first we resolve previously found collisions if they exist
      * (test-before-evict), otherwise connect to a node from the new table.
      */
     FEELER,
 
     /**
      * We use block-relay-only connections to help prevent against partition
      * attacks. By not relaying transactions or addresses, these connections
      * are harder to detect by a third party, thus helping obfuscate the
      * network topology. We automatically attempt to open
      * MAX_BLOCK_RELAY_ONLY_ANCHORS using addresses from our anchors.dat. Then
      * addresses from our AddrMan if MAX_BLOCK_RELAY_ONLY_CONNECTIONS
      * isn't reached yet.
      */
     BLOCK_RELAY,
 
     /**
      * AddrFetch connections are short lived connections used to solicit
      * addresses from peers. These are initiated to addresses submitted via the
      * -seednode command line argument, or under certain conditions when the
      * AddrMan is empty.
      */
     ADDR_FETCH,
 
     /**
      * Special case of connection to a full relay outbound with avalanche
      * service enabled.
      */
     AVALANCHE_OUTBOUND,
 };
 
 /** Convert ConnectionType enum to a string value */
 std::string ConnectionTypeAsString(ConnectionType conn_type);
 
 /**
  * Look up IP addresses from all interfaces on the machine and add them to the
  * list of local addresses to self-advertise.
  * The loopback interface is skipped and only the first address from each
  * interface is used.
  */
 void Discover();
 
 uint16_t GetListenPort();
 
 enum {
     // unknown
     LOCAL_NONE,
     // address a local interface listens on
     LOCAL_IF,
     // address explicit bound to
     LOCAL_BIND,
     // address reported by UPnP or NAT-PMP
     LOCAL_MAPPED,
     // address explicitly specified (-externalip=)
     LOCAL_MANUAL,
 
     LOCAL_MAX
 };
 
 bool IsPeerAddrLocalGood(CNode *pnode);
 /** Returns a local address that we should advertise to this peer. */
 std::optional<CService> GetLocalAddrForPeer(CNode &node);
 
 /**
  * Mark a network as reachable or unreachable (no automatic connects to it)
  * @note Networks are reachable by default
  */
 void SetReachable(enum Network net, bool reachable);
 /** @returns true if the network is reachable, false otherwise */
 bool IsReachable(enum Network net);
 /** @returns true if the address is in a reachable network, false otherwise */
 bool IsReachable(const CNetAddr &addr);
 
 bool AddLocal(const CService &addr, int nScore = LOCAL_NONE);
 bool AddLocal(const CNetAddr &addr, int nScore = LOCAL_NONE);
 void RemoveLocal(const CService &addr);
 bool SeenLocal(const CService &addr);
 bool IsLocal(const CService &addr);
 bool GetLocal(CService &addr, const CNetAddr *paddrPeer = nullptr);
 CService GetLocalAddress(const CNetAddr &addrPeer);
 
 extern bool fDiscover;
 extern bool fListen;
 
 struct LocalServiceInfo {
     int nScore;
     uint16_t nPort;
 };
 
 extern Mutex g_maplocalhost_mutex;
 extern std::map<CNetAddr, LocalServiceInfo>
     mapLocalHost GUARDED_BY(g_maplocalhost_mutex);
 
 extern const std::string NET_MESSAGE_COMMAND_OTHER;
 // Command, total bytes
 typedef std::map<std::string, uint64_t> mapMsgCmdSize;
 
 /**
  * POD that contains various stats about a node.
  * Usually constructed from CConman::GetNodeStats. Stats are filled from the
  * node using CNode::copyStats.
  */
 struct CNodeStats {
     NodeId nodeid;
     std::chrono::seconds m_last_send;
     std::chrono::seconds m_last_recv;
     std::chrono::seconds m_last_tx_time;
     std::chrono::seconds m_last_proof_time;
     std::chrono::seconds m_last_block_time;
     std::chrono::seconds m_connected;
     int64_t nTimeOffset;
     std::string m_addr_name;
     int nVersion;
     std::string cleanSubVer;
     bool fInbound;
     bool m_bip152_highbandwidth_to;
     bool m_bip152_highbandwidth_from;
     int m_starting_height;
     uint64_t nSendBytes;
     mapMsgCmdSize mapSendBytesPerMsgCmd;
     uint64_t nRecvBytes;
     mapMsgCmdSize mapRecvBytesPerMsgCmd;
     NetPermissionFlags m_permissionFlags;
     std::chrono::microseconds m_last_ping_time;
     std::chrono::microseconds m_min_ping_time;
     // Our address, as reported by the peer
     std::string addrLocal;
     // Address of this peer
     CAddress addr;
     // Bind address of our side of the connection
     CAddress addrBind;
     // Network the peer connected through
     Network m_network;
     uint32_t m_mapped_as;
     ConnectionType m_conn_type;
     std::optional<double> m_availabilityScore;
 };
 
 /**
  * Transport protocol agnostic message container.
  * Ideally it should only contain receive time, payload,
  * type and size.
  */
 class CNetMessage {
 public:
     //! received message data
     CDataStream m_recv;
     //! time of message receipt
     std::chrono::microseconds m_time{0};
     bool m_valid_netmagic = false;
     bool m_valid_header = false;
     bool m_valid_checksum = false;
     //! size of the payload
     uint32_t m_message_size{0};
     //! used wire size of the message (including header/checksum)
     uint32_t m_raw_message_size{0};
     std::string m_type;
 
     CNetMessage(CDataStream &&recv_in) : m_recv(std::move(recv_in)) {}
 
     void SetVersion(int nVersionIn) { m_recv.SetVersion(nVersionIn); }
 };
 
 /**
  * The TransportDeserializer takes care of holding and deserializing the
  * network receive buffer. It can deserialize the network buffer into a
  * transport protocol agnostic CNetMessage (command & payload)
  */
 class TransportDeserializer {
 public:
     // returns true if the current deserialization is complete
     virtual bool Complete() const = 0;
     // set the serialization context version
     virtual void SetVersion(int version) = 0;
     /** read and deserialize data, advances msg_bytes data pointer */
     virtual int Read(const Config &config, Span<const uint8_t> &msg_bytes) = 0;
     // decomposes a message from the context
     virtual CNetMessage GetMessage(const Config &config,
                                    std::chrono::microseconds time) = 0;
     virtual ~TransportDeserializer() {}
 };
 
 class V1TransportDeserializer final : public TransportDeserializer {
 private:
     mutable CHash256 hasher;
     mutable uint256 data_hash;
 
     // Parsing header (false) or data (true)
     bool in_data;
     // Partially received header.
     CDataStream hdrbuf;
     // Complete header.
     CMessageHeader hdr;
     // Received message data.
     CDataStream vRecv;
     uint32_t nHdrPos;
     uint32_t nDataPos;
 
     const uint256 &GetMessageHash() const;
     int readHeader(const Config &config, Span<const uint8_t> msg_bytes);
     int readData(Span<const uint8_t> msg_bytes);
 
     void Reset() {
         vRecv.clear();
         hdrbuf.clear();
         hdrbuf.resize(24);
         in_data = false;
         nHdrPos = 0;
         nDataPos = 0;
         data_hash.SetNull();
         hasher.Reset();
     }
 
 public:
     V1TransportDeserializer(
         const CMessageHeader::MessageMagic &pchMessageStartIn, int nTypeIn,
         int nVersionIn)
         : hdrbuf(nTypeIn, nVersionIn), hdr(pchMessageStartIn),
           vRecv(nTypeIn, nVersionIn) {
         Reset();
     }
 
     bool Complete() const override {
         if (!in_data) {
             return false;
         }
 
         return (hdr.nMessageSize == nDataPos);
     }
 
     void SetVersion(int nVersionIn) override {
         hdrbuf.SetVersion(nVersionIn);
         vRecv.SetVersion(nVersionIn);
     }
     int Read(const Config &config, Span<const uint8_t> &msg_bytes) override {
         int ret = in_data ? readData(msg_bytes) : readHeader(config, msg_bytes);
         if (ret < 0) {
             Reset();
         } else {
             msg_bytes = msg_bytes.subspan(ret);
         }
         return ret;
     }
 
     CNetMessage GetMessage(const Config &config,
                            std::chrono::microseconds time) override;
 };
 
 /**
  * The TransportSerializer prepares messages for the network transport
  */
 class TransportSerializer {
 public:
     // prepare message for transport (header construction, error-correction
     // computation, payload encryption, etc.)
     virtual void prepareForTransport(const Config &config,
                                      CSerializedNetMsg &msg,
                                      std::vector<uint8_t> &header) = 0;
     virtual ~TransportSerializer() {}
 };
 
 class V1TransportSerializer : public TransportSerializer {
 public:
     void prepareForTransport(const Config &config, CSerializedNetMsg &msg,
                              std::vector<uint8_t> &header) override;
 };
 
 /** Information about a peer */
 class CNode {
     friend class CConnman;
     friend struct ConnmanTestMsg;
 
 public:
     std::unique_ptr<TransportDeserializer> m_deserializer;
     std::unique_ptr<TransportSerializer> m_serializer;
 
     // socket
     SOCKET hSocket GUARDED_BY(cs_hSocket);
     /** Total size of all vSendMsg entries. */
     size_t nSendSize GUARDED_BY(cs_vSend){0};
     /** Offset inside the first vSendMsg already sent */
     size_t nSendOffset GUARDED_BY(cs_vSend){0};
     uint64_t nSendBytes GUARDED_BY(cs_vSend){0};
     std::deque<std::vector<uint8_t>> vSendMsg GUARDED_BY(cs_vSend);
     Mutex cs_vSend;
     Mutex cs_hSocket;
     Mutex cs_vRecv;
 
     RecursiveMutex cs_vProcessMsg;
     std::list<CNetMessage> vProcessMsg GUARDED_BY(cs_vProcessMsg);
     size_t nProcessQueueSize{0};
 
     RecursiveMutex cs_sendProcessing;
 
     uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0};
 
     std::atomic<std::chrono::seconds> m_last_send{0s};
     std::atomic<std::chrono::seconds> m_last_recv{0s};
     //! Unix epoch time at peer connection
     const std::chrono::seconds m_connected;
     std::atomic<int64_t> nTimeOffset{0};
     // Address of this peer
     const CAddress addr;
     // Bind address of our side of the connection
     const CAddress addrBind;
     const std::string m_addr_name;
     //! Whether this peer is an inbound onion, i.e. connected via our Tor onion
     //! service.
     const bool m_inbound_onion;
     std::atomic<int> nVersion{0};
     // The nonce provided by the remote host.
     uint64_t nRemoteHostNonce{0};
     // The extra entropy provided by the remote host.
     uint64_t nRemoteExtraEntropy{0};
     /**
      * cleanSubVer is a sanitized string of the user agent byte array we read
      * from the wire. This cleaned string can safely be logged or displayed.
      */
     Mutex m_subver_mutex;
     std::string cleanSubVer GUARDED_BY(m_subver_mutex){};
     // This peer is preferred for eviction.
     bool m_prefer_evict{false};
     bool HasPermission(NetPermissionFlags permission) const {
         return NetPermissions::HasFlag(m_permissionFlags, permission);
     }
     std::atomic_bool fSuccessfullyConnected{false};
     // Setting fDisconnect to true will cause the node to be disconnected the
     // next time DisconnectNodes() runs
     std::atomic_bool fDisconnect{false};
     CSemaphoreGrant grantOutbound;
     std::atomic<int> nRefCount{0};
 
     const uint64_t nKeyedNetGroup;
     std::atomic_bool fPauseRecv{false};
     std::atomic_bool fPauseSend{false};
 
     bool IsOutboundOrBlockRelayConn() const {
         switch (m_conn_type) {
             case ConnectionType::OUTBOUND_FULL_RELAY:
             case ConnectionType::BLOCK_RELAY:
             case ConnectionType::AVALANCHE_OUTBOUND:
                 return true;
             case ConnectionType::INBOUND:
             case ConnectionType::MANUAL:
             case ConnectionType::ADDR_FETCH:
             case ConnectionType::FEELER:
                 return false;
         } // no default case, so the compiler can warn about missing cases
 
         assert(false);
     }
 
     bool IsFullOutboundConn() const {
         return m_conn_type == ConnectionType::OUTBOUND_FULL_RELAY ||
                m_conn_type == ConnectionType::AVALANCHE_OUTBOUND;
     }
 
     bool IsManualConn() const { return m_conn_type == ConnectionType::MANUAL; }
 
     bool IsBlockOnlyConn() const {
         return m_conn_type == ConnectionType::BLOCK_RELAY;
     }
 
     bool IsFeelerConn() const { return m_conn_type == ConnectionType::FEELER; }
 
     bool IsAddrFetchConn() const {
         return m_conn_type == ConnectionType::ADDR_FETCH;
     }
 
     bool IsInboundConn() const {
         return m_conn_type == ConnectionType::INBOUND;
     }
 
     bool IsAvalancheOutboundConnection() const {
         return m_conn_type == ConnectionType::AVALANCHE_OUTBOUND;
     }
 
     bool ExpectServicesFromConn() const {
         switch (m_conn_type) {
             case ConnectionType::INBOUND:
             case ConnectionType::MANUAL:
             case ConnectionType::FEELER:
                 return false;
             case ConnectionType::OUTBOUND_FULL_RELAY:
             case ConnectionType::BLOCK_RELAY:
             case ConnectionType::ADDR_FETCH:
             case ConnectionType::AVALANCHE_OUTBOUND:
                 return true;
         } // no default case, so the compiler can warn about missing cases
 
         assert(false);
     }
 
     /**
      * Get network the peer connected through.
      *
      * Returns Network::NET_ONION for *inbound* onion connections,
      * and CNetAddr::GetNetClass() otherwise. The latter cannot be used directly
      * because it doesn't detect the former, and it's not the responsibility of
      * the CNetAddr class to know the actual network a peer is connected
      * through.
      *
      * @return network the peer connected through.
      */
     Network ConnectedThroughNetwork() const;
 
     // We selected peer as (compact blocks) high-bandwidth peer (BIP152)
     std::atomic<bool> m_bip152_highbandwidth_to{false};
     // Peer selected us as (compact blocks) high-bandwidth peer (BIP152)
     std::atomic<bool> m_bip152_highbandwidth_from{false};
 
     /**
      * Whether this peer provides all services that we want.
      * Used for eviction decisions
      */
     std::atomic_bool m_has_all_wanted_services{false};
 
     /**
      * Whether we should relay transactions to this peer (their version
      * message did not include fRelay=false and this is not a block-relay-only
      * connection). This only changes from false to true. It will never change
      * back to false. Used only in inbound eviction logic.
      */
     std::atomic_bool m_relays_txs{false};
 
     /**
      * Whether this peer has loaded a bloom filter. Used only in inbound
      * eviction logic.
      */
     std::atomic_bool m_bloom_filter_loaded{false};
 
     // True if we know this peer is using Avalanche (at least polling)
     std::atomic<bool> m_avalanche_enabled{false};
 
     mutable Mutex cs_avalanche_pubkey;
     // Pubkey used to verify signatures on Avalanche messages from this peer
     std::optional<CPubKey> m_avalanche_pubkey GUARDED_BY(cs_avalanche_pubkey);
 
     /** The node was polled for count invs */
     void invsPolled(uint32_t count);
 
     /** The node voted for count invs */
     void invsVoted(uint32_t count);
 
     /**
      * The availability score is calculated using an exponentially weighted
      * average.
      * This has several interesting properties:
      *  - The most recent polls/responses have more weight than the previous
      * ones. A node that recently stopped answering will see its ratio
      * decrease quickly.
      *  - This is a low-pass filter, so it causes delay. This means that a
      * node needs to have a track record for the ratio to be high. A node
      * that has been little requested will have a lower ratio than a node
      * that failed to answer a few polls but answered a lot of them.
      *  - It is cheap to compute.
      *
      * This is expected to be called at a fixed interval of
      * AVALANCHE_STATISTICS_REFRESH_PERIOD.
      */
     void updateAvailabilityScore(double decayFactor);
     double getAvailabilityScore() const;
 
     // Store the next time we will consider a getavaaddr message from this peer
     std::chrono::seconds m_nextGetAvaAddr{0};
 
     // The last time the node sent us a faulty message
     std::atomic<std::chrono::seconds> m_avalanche_last_message_fault{0s};
     // How much faulty messages did this node accumulate
     std::atomic<int> m_avalanche_message_fault_counter{0};
 
     SteadyMilliseconds m_last_poll{};
 
     /**
      * UNIX epoch time of the last block received from this peer that we had
      * not yet seen (e.g. not already received from another peer), that passed
      * preliminary validity checks and was saved to disk, even if we don't
      * connect the block or it eventually fails connection. Used as an inbound
      * peer eviction criterium in CConnman::AttemptToEvictConnection.
      */
     std::atomic<std::chrono::seconds> m_last_block_time{0s};
 
     /**
      * UNIX epoch time of the last transaction received from this peer that we
      * had not yet seen (e.g. not already received from another peer) and that
      * was accepted into our mempool. Used as an inbound peer eviction criterium
      * in CConnman::AttemptToEvictConnection.
      */
     std::atomic<std::chrono::seconds> m_last_tx_time{0s};
 
     /**
      * UNIX epoch time of the last proof received from this peer that we
      * had not yet seen (e.g. not already received from another peer) and that
      * was accepted into our proof pool. Used as an inbound peer eviction
      * criterium in CConnman::AttemptToEvictConnection.
      */
     std::atomic<std::chrono::seconds> m_last_proof_time{0s};
 
     /** Last measured round-trip time. Used only for RPC/GUI stats/debugging.*/
     std::atomic<std::chrono::microseconds> m_last_ping_time{0us};
 
     /**
      * Lowest measured round-trip time. Used as an inbound peer eviction
      * criterium in CConnman::AttemptToEvictConnection.
      */
     std::atomic<std::chrono::microseconds> m_min_ping_time{
         std::chrono::microseconds::max()};
 
     CNode(NodeId id, SOCKET hSocketIn, const CAddress &addrIn,
           uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn,
           uint64_t nLocalExtraEntropyIn, const CAddress &addrBindIn,
           const std::string &addrNameIn, ConnectionType conn_type_in,
           bool inbound_onion);
     ~CNode();
     CNode(const CNode &) = delete;
     CNode &operator=(const CNode &) = delete;
 
     /**
      * A ping-pong round trip has completed successfully. Update latest and
      * minimum ping times.
      */
     void PongReceived(std::chrono::microseconds ping_time) {
         m_last_ping_time = ping_time;
         m_min_ping_time = std::min(m_min_ping_time.load(), ping_time);
     }
 
     NodeId GetId() const { return id; }
 
     uint64_t GetLocalNonce() const { return nLocalHostNonce; }
     uint64_t GetLocalExtraEntropy() const { return nLocalExtraEntropy; }
 
     int GetRefCount() const {
         assert(nRefCount >= 0);
         return nRefCount;
     }
 
     /**
      * Receive bytes from the buffer and deserialize them into messages.
      *
      * @param[in]   msg_bytes   The raw data
      * @param[out]  complete    Set True if at least one message has been
      *                          deserialized and is ready to be processed
      * @return  True if the peer should stay connected,
      *          False if the peer should be disconnected from.
      */
     bool ReceiveMsgBytes(const Config &config, Span<const uint8_t> msg_bytes,
-                         bool &complete);
+                         bool &complete) EXCLUSIVE_LOCKS_REQUIRED(!cs_vRecv);
 
     void SetCommonVersion(int greatest_common_version) {
         Assume(m_greatest_common_version == INIT_PROTO_VERSION);
         m_greatest_common_version = greatest_common_version;
     }
     int GetCommonVersion() const { return m_greatest_common_version; }
 
-    CService GetAddrLocal() const LOCKS_EXCLUDED(m_addr_local_mutex);
+    CService GetAddrLocal() const EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex);
     //! May not be called more than once
     void SetAddrLocal(const CService &addrLocalIn)
-        LOCKS_EXCLUDED(m_addr_local_mutex);
+        EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex);
 
     CNode *AddRef() {
         nRefCount++;
         return this;
     }
 
     void Release() { nRefCount--; }
 
-    void CloseSocketDisconnect();
+    void CloseSocketDisconnect() EXCLUSIVE_LOCKS_REQUIRED(!cs_hSocket);
 
-    void copyStats(CNodeStats &stats);
+    void copyStats(CNodeStats &stats)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_subver_mutex, !m_addr_local_mutex,
+                                 !cs_vSend, !cs_vRecv);
 
     std::string ConnectionTypeAsString() const {
         return ::ConnectionTypeAsString(m_conn_type);
     }
 
 private:
     const NodeId id;
     const uint64_t nLocalHostNonce;
     const uint64_t nLocalExtraEntropy;
     const ConnectionType m_conn_type;
     std::atomic<int> m_greatest_common_version{INIT_PROTO_VERSION};
 
     NetPermissionFlags m_permissionFlags{NetPermissionFlags::None};
     // Used only by SocketHandler thread
     std::list<CNetMessage> vRecvMsg;
 
     // Our address, as reported by the peer
     mutable Mutex m_addr_local_mutex;
     CService addrLocal GUARDED_BY(m_addr_local_mutex);
 
     /**
      * The inventories polled and voted counters since last score
      * computation, stored as a pair of uint32_t with the poll counter
      * being the 32 lowest bits and the vote counter the 32 highest bits.
      */
     std::atomic<uint64_t> invCounters{0};
 
     /** The last computed score */
     std::atomic<double> availabilityScore{0.};
 
     mapMsgCmdSize mapSendBytesPerMsgCmd GUARDED_BY(cs_vSend);
     mapMsgCmdSize mapRecvBytesPerMsgCmd GUARDED_BY(cs_vRecv);
 };
 
 /**
  * Interface for message handling
  */
 class NetEventsInterface {
 public:
     /** Initialize a peer (setup state, queue any initial messages) */
     virtual void InitializeNode(const Config &config, CNode &node,
                                 ServiceFlags our_services) = 0;
 
     /** Handle removal of a peer (clear state) */
     virtual void FinalizeNode(const Config &config, const CNode &node) = 0;
 
     /**
      * Process protocol messages received from a given node
      *
      * @param[in]   config          The applicable configuration object.
      * @param[in]   pnode           The node which we have received messages
      * from.
      * @param[in]   interrupt       Interrupt condition for processing threads
      * @return                      True if there is more work to be done
      */
     virtual bool ProcessMessages(const Config &config, CNode *pnode,
                                  std::atomic<bool> &interrupt) = 0;
 
     /**
      * Send queued protocol messages to a given node.
      *
      * @param[in]   config          The applicable configuration object.
      * @param[in]   pnode           The node which we are sending messages to.
      * @return                      True if there is more work to be done
      */
     virtual bool SendMessages(const Config &config, CNode *pnode)
         EXCLUSIVE_LOCKS_REQUIRED(pnode->cs_sendProcessing) = 0;
 
 protected:
     /**
      * Protected destructor so that instances can only be deleted by derived
      * classes. If that restriction is no longer desired, this should be made
      * public and virtual.
      */
     ~NetEventsInterface() = default;
 };
 
 namespace {
 struct CConnmanTest;
 }
 
 class NetEventsInterface;
 class CConnman {
 public:
     enum NumConnections {
         CONNECTIONS_NONE = 0,
         CONNECTIONS_IN = (1U << 0),
         CONNECTIONS_OUT = (1U << 1),
         CONNECTIONS_ALL = (CONNECTIONS_IN | CONNECTIONS_OUT),
     };
 
     struct Options {
         ServiceFlags nLocalServices = NODE_NONE;
         int nMaxConnections = 0;
         int m_max_outbound_full_relay = 0;
         int m_max_outbound_block_relay = 0;
         int m_max_avalanche_outbound = 0;
         int nMaxAddnode = 0;
         int nMaxFeeler = 0;
         CClientUIInterface *uiInterface = nullptr;
         std::vector<NetEventsInterface *> m_msgproc;
         BanMan *m_banman = nullptr;
         unsigned int nSendBufferMaxSize = 0;
         unsigned int nReceiveFloodSize = 0;
         uint64_t nMaxOutboundLimit = 0;
         int64_t m_peer_connect_timeout = DEFAULT_PEER_CONNECT_TIMEOUT;
         std::vector<std::string> vSeedNodes;
         std::vector<NetWhitelistPermissions> vWhitelistedRange;
         std::vector<NetWhitebindPermissions> vWhiteBinds;
         std::vector<CService> vBinds;
         std::vector<CService> onion_binds;
         /// True if the user did not specify -bind= or -whitebind= and thus
         /// we should bind on `0.0.0.0` (IPv4) and `::` (IPv6).
         bool bind_on_any;
         bool m_use_addrman_outgoing = true;
         std::vector<std::string> m_specified_outgoing;
         std::vector<std::string> m_added_nodes;
         bool m_i2p_accept_incoming = true;
     };
 
-    void Init(const Options &connOptions) {
+    void Init(const Options &connOptions)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex) {
         nLocalServices = connOptions.nLocalServices;
         nMaxConnections = connOptions.nMaxConnections;
         m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing;
         nMaxAddnode = connOptions.nMaxAddnode;
         nMaxFeeler = connOptions.nMaxFeeler;
         {
             // Lock cs_main to prevent a potential race with the peer validation
             // logic thread.
             LOCK(::cs_main);
             m_max_outbound_full_relay =
                 std::min(connOptions.m_max_outbound_full_relay,
                          connOptions.nMaxConnections);
             m_max_avalanche_outbound = connOptions.m_max_avalanche_outbound;
             m_max_outbound_block_relay = connOptions.m_max_outbound_block_relay;
             m_max_outbound = m_max_outbound_full_relay +
                              m_max_outbound_block_relay + nMaxFeeler +
                              m_max_avalanche_outbound;
         }
         m_client_interface = connOptions.uiInterface;
         m_banman = connOptions.m_banman;
         m_msgproc = connOptions.m_msgproc;
         nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
         nReceiveFloodSize = connOptions.nReceiveFloodSize;
         m_peer_connect_timeout =
             std::chrono::seconds{connOptions.m_peer_connect_timeout};
         {
             LOCK(cs_totalBytesSent);
             nMaxOutboundLimit = connOptions.nMaxOutboundLimit;
         }
         vWhitelistedRange = connOptions.vWhitelistedRange;
         {
             LOCK(m_added_nodes_mutex);
             m_added_nodes = connOptions.m_added_nodes;
         }
         m_onion_binds = connOptions.onion_binds;
     }
 
     CConnman(const Config &configIn, uint64_t seed0, uint64_t seed1,
              AddrMan &addrmanIn, bool network_active = true);
     ~CConnman();
 
-    bool Start(CScheduler &scheduler, const Options &options);
+    bool Start(CScheduler &scheduler, const Options &options)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_addr_fetches_mutex,
+                                 !mutexMsgProc);
 
     void StopThreads();
     void StopNodes();
     void Stop() {
         StopThreads();
         StopNodes();
     };
 
-    void Interrupt();
+    void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
     bool GetNetworkActive() const { return fNetworkActive; };
     bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; };
     void SetNetworkActive(bool active);
     void OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure,
                                CSemaphoreGrant *grantOutbound,
                                const char *strDest, ConnectionType conn_type);
     bool CheckIncomingNonce(uint64_t nonce);
 
     bool ForNode(NodeId id, std::function<bool(CNode *pnode)> func);
 
     void PushMessage(CNode *pnode, CSerializedNetMsg &&msg);
 
     using NodeFn = std::function<void(CNode *)>;
     void ForEachNode(const NodeFn &func) {
         LOCK(m_nodes_mutex);
         for (auto &&node : m_nodes) {
             if (NodeFullyConnected(node)) {
                 func(node);
             }
         }
     };
 
     void ForEachNode(const NodeFn &func) const {
         LOCK(m_nodes_mutex);
         for (auto &&node : m_nodes) {
             if (NodeFullyConnected(node)) {
                 func(node);
             }
         }
     };
 
     // Addrman functions
     /**
      * Return all or many randomly selected addresses, optionally by network.
      *
      * @param[in] max_addresses  Maximum number of addresses to return
      *                           (0 = all).
      * @param[in] max_pct        Maximum percentage of addresses to return
      *                           (0 = all).
      * @param[in] network        Select only addresses of this network
      *                           (nullopt = all).
      */
     std::vector<CAddress> GetAddresses(size_t max_addresses, size_t max_pct,
                                        std::optional<Network> network) const;
     /**
      * Cache is used to minimize topology leaks, so it should
      * be used for all non-trusted calls, for example, p2p.
      * A non-malicious call (from RPC or a peer with addr permission) should
      * call the function without a parameter to avoid using the cache.
      */
     std::vector<CAddress> GetAddresses(CNode &requestor, size_t max_addresses,
                                        size_t max_pct);
 
     // This allows temporarily exceeding m_max_outbound_full_relay, with the
     // goal of finding a peer that is better than all our current peers.
     void SetTryNewOutboundPeer(bool flag);
     bool GetTryNewOutboundPeer() const;
 
     void StartExtraBlockRelayPeers() {
         LogPrint(BCLog::NET, "net: enabling extra block-relay-only peers\n");
         m_start_extra_block_relay_peers = true;
     }
 
     // Return the number of outbound peers we have in excess of our target (eg,
     // if we previously called SetTryNewOutboundPeer(true), and have since set
     // to false, we may have extra peers that we wish to disconnect). This may
     // return a value less than (num_outbound_connections - num_outbound_slots)
     // in cases where some outbound connections are not yet fully connected, or
     // not yet fully disconnected.
     int GetExtraFullOutboundCount() const;
     // Count the number of block-relay-only peers we have over our limit.
     int GetExtraBlockRelayCount() const;
 
-    bool AddNode(const std::string &node);
-    bool RemoveAddedNode(const std::string &node);
-    std::vector<AddedNodeInfo> GetAddedNodeInfo() const;
+    bool AddNode(const std::string &node)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);
+    bool RemoveAddedNode(const std::string &node)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);
+    std::vector<AddedNodeInfo> GetAddedNodeInfo() const
+        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);
 
     /**
      * Attempts to open a connection. Currently only used from tests.
      *
      * @param[in]   address     Address of node to try connecting to
      * @param[in]   conn_type   ConnectionType::OUTBOUND,
      *                          ConnectionType::BLOCK_RELAY,
      *                          ConnectionType::ADDR_FETCH, or
      *                          ConnectionType::FEELER
      * @return      bool        Returns false if there are no available
      *                          slots for this connection:
      *                          - conn_type not a supported ConnectionType
      *                          - Max total outbound connection capacity filled
      *                          - Max connection capacity for type is filled
      */
     bool AddConnection(const std::string &address, ConnectionType conn_type);
 
     size_t GetNodeCount(NumConnections num) const;
     void GetNodeStats(std::vector<CNodeStats> &vstats) const;
     bool DisconnectNode(const std::string &node);
     bool DisconnectNode(const CSubNet &subnet);
     bool DisconnectNode(const CNetAddr &addr);
     bool DisconnectNode(NodeId id);
 
     //! Used to convey which local services we are offering peers during node
     //! connection.
     //!
     //! The data returned by this is used in CNode construction,
     //! which is used to advertise which services we are offering
     //! that peer during `net_processing.cpp:PushNodeVersion()`.
     ServiceFlags GetLocalServices() const;
 
     uint64_t GetMaxOutboundTarget() const;
     std::chrono::seconds GetMaxOutboundTimeframe() const;
 
     //! check if the outbound target is reached. If param
     //! historicalBlockServingLimit is set true, the function will response true
     //! if the limit for serving historical blocks has been reached.
     bool OutboundTargetReached(bool historicalBlockServingLimit) const;
 
     //! response the bytes left in the current max outbound cycle in case of no
     //! limit, it will always response 0
     uint64_t GetOutboundTargetBytesLeft() const;
 
     //! returns the time in second left in the current max outbound cycle in
     //! case of no limit, it will always return 0
     std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const;
 
     uint64_t GetTotalBytesRecv() const;
     uint64_t GetTotalBytesSent() const;
 
     /** Get a unique deterministic randomizer. */
     CSipHasher GetDeterministicRandomizer(uint64_t id) const;
 
     unsigned int GetReceiveFloodSize() const;
 
-    void WakeMessageHandler();
+    void WakeMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
 
     /**
      * Return true if we should disconnect the peer for failing an inactivity
      * check.
      */
     bool ShouldRunInactivityChecks(const CNode &node,
                                    std::chrono::seconds now) const;
 
 private:
     struct ListenSocket {
     public:
         SOCKET socket;
         inline void AddSocketPermissionFlags(NetPermissionFlags &flags) const {
             NetPermissions::AddFlag(flags, m_permissions);
         }
         ListenSocket(SOCKET socket_, NetPermissionFlags permissions_)
             : socket(socket_), m_permissions(permissions_) {}
 
     private:
         NetPermissionFlags m_permissions;
     };
 
     bool BindListenPort(const CService &bindAddr, bilingual_str &strError,
                         NetPermissionFlags permissions);
     bool Bind(const CService &addr, unsigned int flags,
               NetPermissionFlags permissions);
     bool InitBinds(const Options &options);
 
-    void ThreadOpenAddedConnections();
-    void AddAddrFetch(const std::string &strDest);
-    void ProcessAddrFetch();
+    void ThreadOpenAddedConnections()
+        EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);
+    void AddAddrFetch(const std::string &strDest)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex);
+    void ProcessAddrFetch() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex);
     void
     ThreadOpenConnections(std::vector<std::string> connect,
                           std::function<void(const CAddress &, ConnectionType)>
-                              mockOpenConnection);
-    void ThreadMessageHandler();
+                              mockOpenConnection)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_added_nodes_mutex,
+                                 !m_nodes_mutex);
+    void ThreadMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
     void ThreadI2PAcceptIncoming();
     void AcceptConnection(const ListenSocket &hListenSocket);
 
     /**
      * Create a `CNode` object from a socket that has just been accepted and add
      * the node to the `m_nodes` member.
      * @param[in] hSocket Connected socket to communicate with the peer.
      * @param[in] permissionFlags The peer's permissions.
      * @param[in] addr_bind The address and port at our side of the connection.
      * @param[in] addr The address and port at the peer's side of the connection
      */
     void CreateNodeFromAcceptedSocket(SOCKET hSocket,
                                       NetPermissionFlags permissionFlags,
                                       const CAddress &addr_bind,
                                       const CAddress &addr);
 
     void DisconnectNodes();
     void NotifyNumConnectionsChanged();
     /** Return true if the peer is inactive and should be disconnected. */
     bool InactivityCheck(const CNode &node) const;
     bool GenerateSelectSet(std::set<SOCKET> &recv_set,
                            std::set<SOCKET> &send_set,
                            std::set<SOCKET> &error_set);
     void SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set,
                       std::set<SOCKET> &error_set);
-    void SocketHandler();
-    void ThreadSocketHandler();
-    void ThreadDNSAddressSeed();
+    void SocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
+    void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
+    void ThreadDNSAddressSeed()
+        EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_nodes_mutex);
 
     uint64_t CalculateKeyedNetGroup(const CAddress &ad) const;
 
     CNode *FindNode(const CNetAddr &ip);
     CNode *FindNode(const CSubNet &subNet);
     CNode *FindNode(const std::string &addrName);
     CNode *FindNode(const CService &addr);
 
     /**
      * Determine whether we're already connected to a given address, in order to
      * avoid initiating duplicate connections.
      */
     bool AlreadyConnectedToAddress(const CAddress &addr);
 
     bool AttemptToEvictConnection();
     CNode *ConnectNode(CAddress addrConnect, const char *pszDest,
                        bool fCountFailure, ConnectionType conn_type);
     void AddWhitelistPermissionFlags(NetPermissionFlags &flags,
                                      const CNetAddr &addr) const;
 
     void DeleteNode(CNode *pnode);
 
     NodeId GetNewNodeId();
 
     size_t SocketSendData(CNode &node) const
         EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend);
     void DumpAddresses();
 
     // Network stats
     void RecordBytesRecv(uint64_t bytes);
     void RecordBytesSent(uint64_t bytes);
 
     /**
      * Return vector of current BLOCK_RELAY peers.
      */
     std::vector<CAddress> GetCurrentBlockRelayOnlyConns() const;
 
     // Whether the node should be passed out in ForEach* callbacks
     static bool NodeFullyConnected(const CNode *pnode);
 
     const Config *config;
 
     // Network usage totals
     mutable RecursiveMutex cs_totalBytesSent;
     std::atomic<uint64_t> nTotalBytesRecv{0};
     uint64_t nTotalBytesSent GUARDED_BY(cs_totalBytesSent){0};
 
     // outbound limit & stats
     uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(cs_totalBytesSent){0};
     std::chrono::seconds
         nMaxOutboundCycleStartTime GUARDED_BY(cs_totalBytesSent){0};
     uint64_t nMaxOutboundLimit GUARDED_BY(cs_totalBytesSent);
 
     // P2P timeout in seconds
     std::chrono::seconds m_peer_connect_timeout;
 
     // Whitelisted ranges. Any node connecting from these is automatically
     // whitelisted (as well as those connecting to whitelisted binds).
     std::vector<NetWhitelistPermissions> vWhitelistedRange;
 
     unsigned int nSendBufferMaxSize{0};
     unsigned int nReceiveFloodSize{0};
 
     std::vector<ListenSocket> vhListenSocket;
     std::atomic<bool> fNetworkActive{true};
     bool fAddressesInitialized{false};
     AddrMan &addrman;
     std::deque<std::string> m_addr_fetches GUARDED_BY(m_addr_fetches_mutex);
     Mutex m_addr_fetches_mutex;
     std::vector<std::string> m_added_nodes GUARDED_BY(m_added_nodes_mutex);
     mutable Mutex m_added_nodes_mutex;
     std::vector<CNode *> m_nodes GUARDED_BY(m_nodes_mutex);
     std::list<CNode *> m_nodes_disconnected;
     mutable RecursiveMutex m_nodes_mutex;
     std::atomic<NodeId> nLastNodeId{0};
     unsigned int nPrevNodeCount{0};
 
     /**
      * Cache responses to addr requests to minimize privacy leak.
      * Attack example: scraping addrs in real-time may allow an attacker
      * to infer new connections of the victim by detecting new records
      * with fresh timestamps (per self-announcement).
      */
     struct CachedAddrResponse {
         std::vector<CAddress> m_addrs_response_cache;
         std::chrono::microseconds m_cache_entry_expiration{0};
     };
 
     /**
      * Addr responses stored in different caches
      * per (network, local socket) prevent cross-network node identification.
      * If a node for example is multi-homed under Tor and IPv6,
      * a single cache (or no cache at all) would let an attacker
      * to easily detect that it is the same node by comparing responses.
      * Indexing by local socket prevents leakage when a node has multiple
      * listening addresses on the same network.
      *
      * The used memory equals to 1000 CAddress records (or around 40 bytes) per
      * distinct Network (up to 5) we have/had an inbound peer from,
      * resulting in at most ~196 KB. Every separate local socket may
      * add up to ~196 KB extra.
      */
     std::map<uint64_t, CachedAddrResponse> m_addr_response_caches;
 
     /**
      * Services this node offers.
      *
      * This data is replicated in each Peer instance we create.
      *
      * This data is not marked const, but after being set it should not
      * change.
      *
      * \sa Peer::m_our_services
      */
     ServiceFlags nLocalServices;
 
     std::unique_ptr<CSemaphore> semOutbound;
     std::unique_ptr<CSemaphore> semAddnode;
     int nMaxConnections;
 
     // How many full-relay (tx, block, addr) outbound peers we want
     int m_max_outbound_full_relay;
 
     // How many block-relay only outbound peers we want
     // We do not relay tx or addr messages with these peers
     int m_max_outbound_block_relay;
 
     // How many avalanche enabled outbound peers we want
     int m_max_avalanche_outbound;
 
     int nMaxAddnode;
     int nMaxFeeler;
     int m_max_outbound;
     bool m_use_addrman_outgoing;
     CClientUIInterface *m_client_interface;
     // FIXME m_msgproc is a terrible name
     std::vector<NetEventsInterface *> m_msgproc;
     /**
      * Pointer to this node's banman. May be nullptr - check existence before
      * dereferencing.
      */
     BanMan *m_banman;
 
     /**
      * Addresses that were saved during the previous clean shutdown. We'll
      * attempt to make block-relay-only connections to them.
      */
     std::vector<CAddress> m_anchors;
 
     /** SipHasher seeds for deterministic randomness */
     const uint64_t nSeed0, nSeed1;
 
     /** flag for waking the message processor. */
     bool fMsgProcWake GUARDED_BY(mutexMsgProc);
 
     std::condition_variable condMsgProc;
     Mutex mutexMsgProc;
     std::atomic<bool> flagInterruptMsgProc{false};
 
     /**
      * This is signaled when network activity should cease.
      * A pointer to it is saved in `m_i2p_sam_session`, so make sure that
      * the lifetime of `interruptNet` is not shorter than
      * the lifetime of `m_i2p_sam_session`.
      */
     CThreadInterrupt interruptNet;
 
     /**
      * I2P SAM session.
      * Used to accept incoming and make outgoing I2P connections.
      */
     std::unique_ptr<i2p::sam::Session> m_i2p_sam_session;
 
     std::thread threadDNSAddressSeed;
     std::thread threadSocketHandler;
     std::thread threadOpenAddedConnections;
     std::thread threadOpenConnections;
     std::thread threadMessageHandler;
     std::thread threadI2PAcceptIncoming;
 
     /**
      * flag for deciding to connect to an extra outbound peer, in excess of
      * m_max_outbound_full_relay. This takes the place of a feeler connection.
      */
     std::atomic_bool m_try_another_outbound_peer;
 
     /**
      * flag for initiating extra block-relay-only peer connections.
      * this should only be enabled after initial chain sync has occurred,
      * as these connections are intended to be short-lived and low-bandwidth.
      */
     std::atomic_bool m_start_extra_block_relay_peers{false};
 
     /**
      * A vector of -bind=<address>:<port>=onion arguments each of which is
      * an address and port that are designated for incoming Tor connections.
      */
     std::vector<CService> m_onion_binds;
 
     friend struct ::CConnmanTest;
     friend struct ConnmanTestMsg;
 };
 
 std::string getSubVersionEB(uint64_t MaxBlockSize);
 std::string userAgent(const Config &config);
 
 /** Dump binary message to file, with timestamp */
 void CaptureMessageToFile(const CAddress &addr, const std::string &msg_type,
                           Span<const uint8_t> data, bool is_incoming);
 
 /**
  * Defaults to `CaptureMessageToFile()`, but can be overridden by unit tests.
  */
 extern std::function<void(const CAddress &addr, const std::string &msg_type,
                           Span<const uint8_t> data, bool is_incoming)>
     CaptureMessage;
 
 struct NodeEvictionCandidate {
     NodeId id;
     std::chrono::seconds m_connected;
     std::chrono::microseconds m_min_ping_time;
     std::chrono::seconds m_last_block_time;
     std::chrono::seconds m_last_proof_time;
     std::chrono::seconds m_last_tx_time;
     bool fRelevantServices;
     bool m_relay_txs;
     bool fBloomFilter;
     uint64_t nKeyedNetGroup;
     bool prefer_evict;
     bool m_is_local;
     Network m_network;
     double availabilityScore;
 };
 
 /**
  * Select an inbound peer to evict after filtering out (protecting) peers having
  * distinct, difficult-to-forge characteristics. The protection logic picks out
  * fixed numbers of desirable peers per various criteria, followed by (mostly)
  * ratios of desirable or disadvantaged peers. If any eviction candidates
  * remain, the selection logic chooses a peer to evict.
  */
 [[nodiscard]] std::optional<NodeId>
 SelectNodeToEvict(std::vector<NodeEvictionCandidate> &&vEvictionCandidates);
 
 /**
  * Protect desirable or disadvantaged inbound peers from eviction by ratio.
  *
  * This function protects half of the peers which have been connected the
  * longest, to replicate the non-eviction implicit behavior and preclude attacks
  * that start later.
  *
  * Half of these protected spots (1/4 of the total) are reserved for the
  * following categories of peers, sorted by longest uptime, even if they're not
  * longest uptime overall:
  *
  * - onion peers connected via our tor control service
  *
  * - localhost peers, as manually configured hidden services not using
  *   `-bind=addr[:port]=onion` will not be detected as inbound onion connections
  *
  * - I2P peers
  *
  * This helps protect these privacy network peers, which tend to be otherwise
  * disadvantaged under our eviction criteria for their higher min ping times
  * relative to IPv4/IPv6 peers, and favorise the diversity of peer connections.
  */
 void ProtectEvictionCandidatesByRatio(
     std::vector<NodeEvictionCandidate> &vEvictionCandidates);
 
 #endif // BITCOIN_NET_H
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index bb4e907a4..55d98b9ab 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -1,7567 +1,7592 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <net_processing.h>
 
 #include <addrman.h>
 #include <avalanche/avalanche.h>
 #include <avalanche/compactproofs.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/processor.h>
 #include <avalanche/proof.h>
 #include <avalanche/statistics.h>
 #include <avalanche/validation.h>
 #include <banman.h>
 #include <blockencodings.h>
 #include <blockfilter.h>
 #include <blockvalidity.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
 #include <invrequest.h>
 #include <merkleblock.h>
 #include <netbase.h>
 #include <netmessagemaker.h>
 #include <node/blockstorage.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <reverse_iterator.h>
 #include <scheduler.h>
 #include <streams.h>
 #include <tinyformat.h>
 #include <txmempool.h>
 #include <txorphanage.h>
 #include <util/check.h> // For NDEBUG compile time check
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/trace.h>
 #include <validation.h>
 
 #include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <functional>
 #include <future>
 #include <memory>
 #include <typeinfo>
 
 using node::fImporting;
 using node::fPruneMode;
 using node::fReindex;
 using node::ReadBlockFromDisk;
 
 /** How long to cache transactions in mapRelay for normal relay */
 static constexpr auto RELAY_TX_CACHE_TIME = 15min;
 /**
  * How long a transaction has to be in the mempool before it can
  * unconditionally be relayed (even when not in mapRelay).
  */
 static constexpr auto UNCONDITIONAL_RELAY_DELAY = 2min;
 /**
  * Headers download timeout.
  * Timeout = base + per_header * (expected number of headers)
  */
 static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_BASE = 15min;
 static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER = 1ms;
 /**
  * Protect at least this many outbound peers from disconnection due to
  * slow/behind headers chain.
  */
 static constexpr int32_t MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT = 4;
 /** Timeout for (unprotected) outbound peers to sync to our chainwork */
 static constexpr auto CHAIN_SYNC_TIMEOUT{20min};
 /** How frequently to check for stale tips */
 static constexpr auto STALE_CHECK_INTERVAL{10min};
 /** How frequently to check for extra outbound peers and disconnect. */
 static constexpr auto EXTRA_PEER_CHECK_INTERVAL{45s};
 /**
  * Minimum time an outbound-peer-eviction candidate must be connected for, in
  * order to evict
  */
 static constexpr auto MINIMUM_CONNECT_TIME{30s};
 /** SHA256("main address relay")[0:8] */
 static constexpr uint64_t RANDOMIZER_ID_ADDRESS_RELAY = 0x3cac0035b5866b90ULL;
 /// Age after which a stale block will no longer be served if requested as
 /// protection against fingerprinting. Set to one month, denominated in seconds.
 static constexpr int STALE_RELAY_AGE_LIMIT = 30 * 24 * 60 * 60;
 /// Age after which a block is considered historical for purposes of rate
 /// limiting block relay. Set to one week, denominated in seconds.
 static constexpr int HISTORICAL_BLOCK_AGE = 7 * 24 * 60 * 60;
 /**
  * Time between pings automatically sent out for latency probing and keepalive.
  */
 static constexpr auto PING_INTERVAL{2min};
 /** The maximum number of entries in a locator */
 static const unsigned int MAX_LOCATOR_SZ = 101;
 /** The maximum number of entries in an 'inv' protocol message */
 static const unsigned int MAX_INV_SZ = 50000;
 static_assert(MAX_PROTOCOL_MESSAGE_LENGTH > MAX_INV_SZ * sizeof(CInv),
               "Max protocol message length must be greater than largest "
               "possible INV message");
 
 /** Minimum time between 2 successives getavaaddr messages from the same peer */
 static constexpr auto GETAVAADDR_INTERVAL{2min};
 
 /**
  * If no proof was requested from a compact proof message after this timeout
  * expired, the proof radix tree can be cleaned up.
  */
 static constexpr auto AVALANCHE_AVAPROOFS_TIMEOUT{2min};
 
 struct DataRequestParameters {
     /**
      * Maximum number of in-flight data requests from a peer. It is not a hard
      * limit, but the threshold at which point the overloaded_peer_delay kicks
      * in.
      */
     const size_t max_peer_request_in_flight;
 
     /**
      * Maximum number of inventories to consider for requesting, per peer. It
      * provides a reasonable DoS limit to per-peer memory usage spent on
      * announcements, while covering peers continuously sending INVs at the
      * maximum rate (by our own policy, see INVENTORY_BROADCAST_PER_SECOND) for
      * several minutes, while not receiving the actual data (from any peer) in
      * response to requests for them.
      */
     const size_t max_peer_announcements;
 
     /** How long to delay requesting data from non-preferred peers */
     const std::chrono::seconds nonpref_peer_delay;
 
     /**
      * How long to delay requesting data from overloaded peers (see
      * max_peer_request_in_flight).
      */
     const std::chrono::seconds overloaded_peer_delay;
 
     /**
      * How long to wait (in microseconds) before a data request from an
      * additional peer.
      */
     const std::chrono::microseconds getdata_interval;
 
     /**
      * Permission flags a peer requires to bypass the request limits tracking
      * limits and delay penalty.
      */
     const NetPermissionFlags bypass_request_limits_permissions;
 };
 
 static constexpr DataRequestParameters TX_REQUEST_PARAMS{
     100,                       // max_peer_request_in_flight
     5000,                      // max_peer_announcements
     std::chrono::seconds(2),   // nonpref_peer_delay
     std::chrono::seconds(2),   // overloaded_peer_delay
     std::chrono::seconds(60),  // getdata_interval
     NetPermissionFlags::Relay, // bypass_request_limits_permissions
 };
 
 static constexpr DataRequestParameters PROOF_REQUEST_PARAMS{
     100,                      // max_peer_request_in_flight
     5000,                     // max_peer_announcements
     std::chrono::seconds(2),  // nonpref_peer_delay
     std::chrono::seconds(2),  // overloaded_peer_delay
     std::chrono::seconds(60), // getdata_interval
     NetPermissionFlags::
         BypassProofRequestLimits, // bypass_request_limits_permissions
 };
 
 /**
  * Limit to avoid sending big packets. Not used in processing incoming GETDATA
  * for compatibility.
  */
 static const unsigned int MAX_GETDATA_SZ = 1000;
 /**
  * Number of blocks that can be requested at any given time from a single peer.
  */
 static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
 /**
  * Time during which a peer must stall block download progress before being
  * disconnected.
  */
 static constexpr auto BLOCK_STALLING_TIMEOUT{2s};
 /**
  * Number of headers sent in one getheaders result. We rely on the assumption
  * that if a peer sends
  *  less than this number, we reached its tip. Changing this value is a protocol
  * upgrade.
  */
 static const unsigned int MAX_HEADERS_RESULTS = 2000;
 /**
  * Maximum depth of blocks we're willing to serve as compact blocks to peers
  *  when requested. For older blocks, a regular BLOCK response will be sent.
  */
 static const int MAX_CMPCTBLOCK_DEPTH = 5;
 /**
  * Maximum depth of blocks we're willing to respond to GETBLOCKTXN requests
  * for.
  */
 static const int MAX_BLOCKTXN_DEPTH = 10;
 /**
  * Size of the "block download window": how far ahead of our current height do
  * we fetch? Larger windows tolerate larger download speed differences between
  * peer, but increase the potential degree of disordering of blocks on disk
  * (which make reindexing and pruning harder). We'll probably
  *  want to make this a per-peer adaptive value at some point.
  */
 static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;
 /**
  * Block download timeout base, expressed in multiples of the block interval
  * (i.e. 10 min)
  */
 static constexpr double BLOCK_DOWNLOAD_TIMEOUT_BASE = 1;
 /**
  * Additional block download timeout per parallel downloading peer (i.e. 5 min)
  */
 static constexpr double BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 0.5;
 /**
  * Maximum number of headers to announce when relaying blocks with headers
  * message.
  */
 static const unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8;
 /** Maximum number of unconnecting headers announcements before DoS score */
 static const int MAX_UNCONNECTING_HEADERS = 10;
 /** Minimum blocks required to signal NODE_NETWORK_LIMITED */
 static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288;
 /**
  * Average delay between local address broadcasts.
  */
 static constexpr auto AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL{24h};
 /**
  * Average delay between peer address broadcasts.
  */
 static constexpr auto AVG_ADDRESS_BROADCAST_INTERVAL{30s};
 /** Delay between rotating the peers we relay a particular address to */
 static constexpr auto ROTATE_ADDR_RELAY_DEST_INTERVAL{24h};
 /**
  * Average delay between trickled inventory transmissions for inbound peers.
  * Blocks and peers with NetPermissionFlags::NoBan permission bypass this.
  */
 static constexpr auto INBOUND_INVENTORY_BROADCAST_INTERVAL{5s};
 /**
  * Maximum rate of inventory items to send per second.
  * Limits the impact of low-fee transaction floods.
  */
 static constexpr unsigned int INVENTORY_BROADCAST_PER_SECOND = 7;
 /** Maximum number of inventory items to send per transmission. */
 static constexpr unsigned int INVENTORY_BROADCAST_MAX_PER_MB =
     INVENTORY_BROADCAST_PER_SECOND *
     count_seconds(INBOUND_INVENTORY_BROADCAST_INTERVAL);
 /** The number of most recently announced transactions a peer can request. */
 static constexpr unsigned int INVENTORY_MAX_RECENT_RELAY = 3500;
 /**
  * Verify that INVENTORY_MAX_RECENT_RELAY is enough to cache everything
  * typically relayed before unconditional relay from the mempool kicks in. This
  * is only a lower bound, and it should be larger to account for higher inv rate
  * to outbound peers, and random variations in the broadcast mechanism.
  */
 static_assert(INVENTORY_MAX_RECENT_RELAY >= INVENTORY_BROADCAST_PER_SECOND *
                                                 UNCONDITIONAL_RELAY_DELAY /
                                                 std::chrono::seconds{1},
               "INVENTORY_RELAY_MAX too low");
 
 /**
  * Average delay between feefilter broadcasts
  */
 static constexpr auto AVG_FEEFILTER_BROADCAST_INTERVAL{10min};
 /**
  * Maximum feefilter broadcast delay after significant change.
  */
 static constexpr auto MAX_FEEFILTER_CHANGE_DELAY{5min};
 /**
  * Maximum number of compact filters that may be requested with one
  * getcfilters. See BIP 157.
  */
 static constexpr uint32_t MAX_GETCFILTERS_SIZE = 1000;
 /**
  * Maximum number of cf hashes that may be requested with one getcfheaders. See
  * BIP 157.
  */
 static constexpr uint32_t MAX_GETCFHEADERS_SIZE = 2000;
 /**
  * the maximum percentage of addresses from our addrman to return in response
  * to a getaddr message.
  */
 static constexpr size_t MAX_PCT_ADDR_TO_SEND = 23;
 /** The maximum number of address records permitted in an ADDR message. */
 static constexpr size_t MAX_ADDR_TO_SEND{1000};
 /**
  * The maximum rate of address records we're willing to process on average. Can
  * be bypassed using the NetPermissionFlags::Addr permission.
  */
 static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};
 /**
  * The soft limit of the address processing token bucket (the regular
  * MAX_ADDR_RATE_PER_SECOND based increments won't go above this, but the
  * MAX_ADDR_TO_SEND increment following GETADDR is exempt from this limit).
  */
 static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};
 /** The compactblocks version we support. See BIP 152. */
 static constexpr uint64_t CMPCTBLOCKS_VERSION{1};
 
 inline size_t GetMaxAddrToSend() {
     return gArgs.GetIntArg("-maxaddrtosend", MAX_ADDR_TO_SEND);
 }
 
 // Internal stuff
 namespace {
 /**
  * Blocks that are in flight, and that are in the queue to be downloaded.
  */
 struct QueuedBlock {
     /**
      * BlockIndex. We must have this since we only request blocks when we've
      * already validated the header.
      */
     const CBlockIndex *pindex;
     /** Optional, used for CMPCTBLOCK downloads */
     std::unique_ptr<PartiallyDownloadedBlock> partialBlock;
 };
 
 /**
  * Data structure for an individual peer. This struct is not protected by
  * cs_main since it does not contain validation-critical data.
  *
  * Memory is owned by shared pointers and this object is destructed when
  * the refcount drops to zero.
  *
  * Mutexes inside this struct must not be held when locking m_peer_mutex.
  *
  * TODO: move most members from CNodeState to this structure.
  * TODO: move remaining application-layer data members from CNode to this
  * structure.
  */
 struct Peer {
     /** Same id as the CNode object for this peer */
     const NodeId m_id{0};
 
     /**
      * Services we offered to this peer.
      *
      * This is supplied by CConnman during peer initialization. It's const
      * because there is no protocol defined for renegotiating services
      * initially offered to a peer. The set of local services we offer should
      * not change after initialization.
      *
      * An interesting example of this is NODE_NETWORK and initial block
      * download: a node which starts up from scratch doesn't have any blocks
      * to serve, but still advertises NODE_NETWORK because it will eventually
      * fulfill this role after IBD completes. P2P code is written in such a
      * way that it can gracefully handle peers who don't make good on their
      * service advertisements.
      */
     const ServiceFlags m_our_services;
 
     /** Services this peer offered to us. */
     std::atomic<ServiceFlags> m_their_services{NODE_NONE};
 
     /** Protects misbehavior data members */
     Mutex m_misbehavior_mutex;
     /** Accumulated misbehavior score for this peer */
     int m_misbehavior_score GUARDED_BY(m_misbehavior_mutex){0};
     /** Whether this peer should be disconnected and marked as discouraged
      * (unless it has NetPermissionFlags::NoBan permission). */
     bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false};
 
     /** Protects block inventory data members */
     Mutex m_block_inv_mutex;
     /**
      * List of blocks that we'll anounce via an `inv` message.
      * There is no final sorting before sending, as they are always sent
      * immediately and in the order requested.
      */
     std::vector<BlockHash> m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex);
     /**
      * Unfiltered list of blocks that we'd like to announce via a `headers`
      * message. If we can't announce via a `headers` message, we'll fall back to
      * announcing via `inv`.
      */
     std::vector<BlockHash>
         m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex);
 
     /**
      * The final block hash that we sent in an `inv` message to this peer.
      * When the peer requests this block, we send an `inv` message to trigger
      * the peer to request the next sequence of block hashes.
      * Most peers use headers-first syncing, which doesn't use this mechanism
      */
     BlockHash m_continuation_block GUARDED_BY(m_block_inv_mutex){};
 
     /** This peer's reported block height when we connected */
     std::atomic<int> m_starting_height{-1};
 
     /** The pong reply we're expecting, or 0 if no pong expected. */
     std::atomic<uint64_t> m_ping_nonce_sent{0};
     /** When the last ping was sent, or 0 if no ping was ever sent */
     std::atomic<std::chrono::microseconds> m_ping_start{0us};
     /** Whether a ping has been requested by the user */
     std::atomic<bool> m_ping_queued{false};
 
     /**
      * The feerate in the most recent BIP133 `feefilter` message sent to the
      * peer.
      * It is *not* a p2p protocol violation for the peer to send us
      * transactions with a lower fee rate than this. See BIP133.
      */
     Amount m_fee_filter_sent{Amount::zero()};
     std::chrono::microseconds m_next_send_feefilter{0};
 
     struct TxRelay {
         mutable RecursiveMutex m_bloom_filter_mutex;
         /**
          * Whether the peer wishes to receive transaction announcements.
          *
          * This is initially set based on the fRelay flag in the received
          * `version` message. If initially set to false, it can only be flipped
          * to true if we have offered the peer NODE_BLOOM services and it sends
          * us a `filterload` or `filterclear` message. See BIP37.
          */
         bool m_relay_txs GUARDED_BY(m_bloom_filter_mutex){false};
         /**
          * A bloom filter for which transactions to announce to the peer.
          * See BIP37.
          */
         std::unique_ptr<CBloomFilter>
             m_bloom_filter PT_GUARDED_BY(m_bloom_filter_mutex)
                 GUARDED_BY(m_bloom_filter_mutex){nullptr};
 
         mutable RecursiveMutex m_tx_inventory_mutex;
         /**
          * A filter of all the txids that the peer has announced to us or we
          * have announced to the peer. We use this to avoid announcing
          * the same txid to a peer that already has the transaction.
          */
         CRollingBloomFilter m_tx_inventory_known_filter
             GUARDED_BY(m_tx_inventory_mutex){50000, 0.000001};
         /**
          * Set of transaction ids we still have to announce. We use the
          * mempool to sort transactions in dependency order before relay, so
          * this does not have to be sorted.
          */
         std::set<TxId> m_tx_inventory_to_send GUARDED_BY(m_tx_inventory_mutex);
         /**
          * Whether the peer has requested us to send our complete mempool. Only
          * permitted if the peer has NetPermissionFlags::Mempool.
          * See BIP35.
          */
         bool m_send_mempool GUARDED_BY(m_tx_inventory_mutex){false};
         /** The last time a BIP35 `mempool` request was serviced. */
         std::atomic<std::chrono::seconds> m_last_mempool_req{0s};
         /**
          * The next time after which we will send an `inv` message containing
          * transaction announcements to this peer.
          */
         std::chrono::microseconds m_next_inv_send_time{0};
 
         /**
          * Minimum fee rate with which to filter transaction announcements to
          * this node. See BIP133.
          */
         std::atomic<Amount> m_fee_filter_received{Amount::zero()};
     };
 
     /*
      * Initializes a TxRelay struct for this peer. Can be called at most once
      * for a peer.
      */
     TxRelay *SetTxRelay() {
         LOCK(m_tx_relay_mutex);
         Assume(!m_tx_relay);
         m_tx_relay = std::make_unique<Peer::TxRelay>();
         return m_tx_relay.get();
     };
 
     TxRelay *GetTxRelay() {
         return WITH_LOCK(m_tx_relay_mutex, return m_tx_relay.get());
     };
 
     struct ProofRelay {
         mutable RecursiveMutex m_proof_inventory_mutex;
         std::set<avalanche::ProofId>
             m_proof_inventory_to_send GUARDED_BY(m_proof_inventory_mutex);
         // Prevent sending proof invs if the peer already knows about them
         CRollingBloomFilter m_proof_inventory_known_filter
             GUARDED_BY(m_proof_inventory_mutex){10000, 0.000001};
         std::chrono::microseconds m_next_inv_send_time{0};
 
         RadixTree<const avalanche::Proof, avalanche::ProofRadixTreeAdapter>
             sharedProofs;
         std::atomic<std::chrono::seconds> lastSharedProofsUpdate{0s};
         std::atomic<bool> compactproofs_requested{false};
     };
 
     /**
      * Proof relay data. Will be a nullptr if we're not relaying
      * proofs with this peer
      */
     const std::unique_ptr<ProofRelay> m_proof_relay;
 
     /**
      * A vector of addresses to send to the peer, limited to MAX_ADDR_TO_SEND.
      */
     std::vector<CAddress> m_addrs_to_send;
     /**
      * Probabilistic filter to track recent addr messages relayed with this
      * peer. Used to avoid relaying redundant addresses to this peer.
      *
      *  We initialize this filter for outbound peers (other than
      *  block-relay-only connections) or when an inbound peer sends us an
      *  address related message (ADDR, ADDRV2, GETADDR).
      *
      *  Presence of this filter must correlate with m_addr_relay_enabled.
      **/
     std::unique_ptr<CRollingBloomFilter> m_addr_known;
     /**
      * Whether we are participating in address relay with this connection.
      *
      * We set this bool to true for outbound peers (other than
      * block-relay-only connections), or when an inbound peer sends us an
      * address related message (ADDR, ADDRV2, GETADDR).
      *
      * We use this bool to decide whether a peer is eligible for gossiping
      * addr messages. This avoids relaying to peers that are unlikely to
      * forward them, effectively blackholing self announcements. Reasons
      * peers might support addr relay on the link include that they connected
      * to us as a block-relay-only peer or they are a light client.
      *
      * This field must correlate with whether m_addr_known has been
      * initialized.
      */
     std::atomic_bool m_addr_relay_enabled{false};
     /** Whether a getaddr request to this peer is outstanding. */
     bool m_getaddr_sent{false};
     /** Guards address sending timers. */
     mutable Mutex m_addr_send_times_mutex;
     /** Time point to send the next ADDR message to this peer. */
     std::chrono::microseconds
         m_next_addr_send GUARDED_BY(m_addr_send_times_mutex){0};
     /** Time point to possibly re-announce our local address to this peer. */
     std::chrono::microseconds
         m_next_local_addr_send GUARDED_BY(m_addr_send_times_mutex){0};
     /**
      * Whether the peer has signaled support for receiving ADDRv2 (BIP155)
      * messages, indicating a preference to receive ADDRv2 instead of ADDR ones.
      */
     std::atomic_bool m_wants_addrv2{false};
     /** Whether this peer has already sent us a getaddr message. */
     bool m_getaddr_recvd{false};
     /** Guards m_addr_token_bucket */
     mutable Mutex m_addr_token_bucket_mutex;
     /**
      * Number of addresses that can be processed from this peer. Start at 1
      * to permit self-announcement.
      */
     double m_addr_token_bucket GUARDED_BY(m_addr_token_bucket_mutex){1.0};
     /** When m_addr_token_bucket was last updated */
     std::chrono::microseconds m_addr_token_timestamp{
         GetTime<std::chrono::microseconds>()};
     /** Total number of addresses that were dropped due to rate limiting. */
     std::atomic<uint64_t> m_addr_rate_limited{0};
     /**
      * Total number of addresses that were processed (excludes rate-limited
      * ones).
      */
     std::atomic<uint64_t> m_addr_processed{0};
 
     /**
      * Set of txids to reconsider once their parent transactions have been
      * accepted
      */
     std::set<TxId> m_orphan_work_set GUARDED_BY(g_cs_orphans);
 
     /** Protects m_getdata_requests **/
     Mutex m_getdata_requests_mutex;
     /** Work queue of items requested by this peer **/
     std::deque<CInv> m_getdata_requests GUARDED_BY(m_getdata_requests_mutex);
 
     explicit Peer(NodeId id, ServiceFlags our_services)
         : m_id(id), m_our_services{our_services},
           m_proof_relay(isAvalancheEnabled(gArgs)
                             ? std::make_unique<ProofRelay>()
                             : nullptr) {}
 
 private:
     Mutex m_tx_relay_mutex;
 
     /**
      * Transaction relay data. Will be a nullptr if we're not relaying
      * transactions with this peer (e.g. if it's a block-relay-only peer or
      * the peer has sent us fRelay=false with bloom filters disabled).
      */
     std::unique_ptr<TxRelay> m_tx_relay GUARDED_BY(m_tx_relay_mutex);
 };
 
 using PeerRef = std::shared_ptr<Peer>;
 
 /**
  * Maintain validation-specific state about nodes, protected by cs_main, instead
  * by CNode's own locks. This simplifies asynchronous operation, where
  * processing of incoming data is done after the ProcessMessage call returns,
  * and we're no longer holding the node's locks.
  */
 struct CNodeState {
     //! The best known block we know this peer has announced.
     const CBlockIndex *pindexBestKnownBlock{nullptr};
     //! The hash of the last unknown block this peer has announced.
     BlockHash hashLastUnknownBlock{};
     //! The last full block we both have.
     const CBlockIndex *pindexLastCommonBlock{nullptr};
     //! The best header we have sent our peer.
     const CBlockIndex *pindexBestHeaderSent{nullptr};
     //! Length of current-streak of unconnecting headers announcements
     int nUnconnectingHeaders{0};
     //! Whether we've started headers synchronization with this peer.
     bool fSyncStarted{false};
     //! When to potentially disconnect peer for stalling headers download
     std::chrono::microseconds m_headers_sync_timeout{0us};
     //! Since when we're stalling block download progress (in microseconds), or
     //! 0.
     std::chrono::microseconds m_stalling_since{0us};
     std::list<QueuedBlock> vBlocksInFlight;
     //! When the first entry in vBlocksInFlight started downloading. Don't care
     //! when vBlocksInFlight is empty.
     std::chrono::microseconds m_downloading_since{0us};
     int nBlocksInFlight{0};
     //! Whether we consider this a preferred download peer.
     bool fPreferredDownload{false};
     //! Whether this peer wants invs or headers (when possible) for block
     //! announcements.
     bool fPreferHeaders{false};
     /**
      * Whether this peer wants invs or cmpctblocks (when possible) for block
      * announcements.
      */
     bool m_requested_hb_cmpctblocks{false};
     /** Whether this peer will send us cmpctblocks if we request them. */
     bool m_provides_cmpctblocks{false};
 
     /**
      * State used to enforce CHAIN_SYNC_TIMEOUT and EXTRA_PEER_CHECK_INTERVAL
      * logic.
      *
      * Both are only in effect for outbound, non-manual, non-protected
      * connections. Any peer protected (m_protect = true) is not chosen for
      * eviction. A peer is marked as protected if all of these are true:
      *   - its connection type is IsBlockOnlyConn() == false
      *   - it gave us a valid connecting header
      *   - we haven't reached MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT yet
      *   - it has a better chain than we have
      *
      * CHAIN_SYNC_TIMEOUT:  if a peer's best known block has less work than our
      * tip, set a timeout CHAIN_SYNC_TIMEOUT in the future:
      *   - If at timeout their best known block now has more work than our tip
      * when the timeout was set, then either reset the timeout or clear it
      * (after comparing against our current tip's work)
      *   - If at timeout their best known block still has less work than our tip
      * did when the timeout was set, then send a getheaders message, and set a
      * shorter timeout, HEADERS_RESPONSE_TIME seconds in future. If their best
      * known block is still behind when that new timeout is reached, disconnect.
      *
      * EXTRA_PEER_CHECK_INTERVAL: after each interval, if we have too many
      * outbound peers, drop the outbound one that least recently announced us a
      * new block.
      */
     struct ChainSyncTimeoutState {
         //! A timeout used for checking whether our peer has sufficiently
         //! synced.
         std::chrono::seconds m_timeout{0s};
         //! A header with the work we require on our peer's chain.
         const CBlockIndex *m_work_header{nullptr};
         //! After timeout is reached, set to true after sending getheaders.
         bool m_sent_getheaders{false};
         //! Whether this peer is protected from disconnection due to a bad/slow
         //! chain.
         bool m_protect{false};
     };
 
     ChainSyncTimeoutState m_chain_sync;
 
     //! Time of last new block announcement
     int64_t m_last_block_announcement{0};
 
     //! Whether this peer is an inbound connection
     const bool m_is_inbound;
 
     //! A rolling bloom filter of all announced tx CInvs to this peer.
     CRollingBloomFilter m_recently_announced_invs =
         CRollingBloomFilter{INVENTORY_MAX_RECENT_RELAY, 0.000001};
 
     //! A rolling bloom filter of all announced Proofs CInvs to this peer.
     CRollingBloomFilter m_recently_announced_proofs =
         CRollingBloomFilter{INVENTORY_MAX_RECENT_RELAY, 0.000001};
 
     CNodeState(bool is_inbound) : m_is_inbound(is_inbound) {}
 };
 
 class PeerManagerImpl final : public PeerManager {
 public:
     PeerManagerImpl(CConnman &connman, AddrMan &addrman, BanMan *banman,
                     ChainstateManager &chainman, CTxMemPool &pool,
                     bool ignore_incoming_txs);
 
     /** Overridden from CValidationInterface. */
     void BlockConnected(const std::shared_ptr<const CBlock> &pblock,
-                        const CBlockIndex *pindexConnected) override;
+                        const CBlockIndex *pindexConnected) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_recent_confirmed_transactions_mutex);
     void BlockDisconnected(const std::shared_ptr<const CBlock> &block,
-                           const CBlockIndex *pindex) override;
+                           const CBlockIndex *pindex) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_recent_confirmed_transactions_mutex);
     void UpdatedBlockTip(const CBlockIndex *pindexNew,
                          const CBlockIndex *pindexFork,
-                         bool fInitialDownload) override;
+                         bool fInitialDownload) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void BlockChecked(const CBlock &block,
-                      const BlockValidationState &state) override;
+                      const BlockValidationState &state) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void NewPoWValidBlock(const CBlockIndex *pindex,
                           const std::shared_ptr<const CBlock> &pblock) override;
 
     /** Implement NetEventsInterface */
     void InitializeNode(const Config &config, CNode &node,
-                        ServiceFlags our_services) override;
-    void FinalizeNode(const Config &config, const CNode &node) override;
+                        ServiceFlags our_services) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void FinalizeNode(const Config &config, const CNode &node) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     bool ProcessMessages(const Config &config, CNode *pfrom,
-                         std::atomic<bool> &interrupt) override;
+                         std::atomic<bool> &interrupt) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex,
+                                 !m_recent_confirmed_transactions_mutex);
     bool SendMessages(const Config &config, CNode *pto) override
-        EXCLUSIVE_LOCKS_REQUIRED(pto->cs_sendProcessing);
+        EXCLUSIVE_LOCKS_REQUIRED(pto->cs_sendProcessing)
+            EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex,
+                                     !m_recent_confirmed_transactions_mutex);
 
     /** Implement PeerManager */
     void StartScheduledTasks(CScheduler &scheduler) override;
     void CheckForStaleTipAndEvictPeers() override;
     std::optional<std::string>
     FetchBlock(const Config &config, NodeId peer_id,
                const CBlockIndex &block_index) override;
-    bool GetNodeStateStats(NodeId nodeid,
-                           CNodeStateStats &stats) const override;
+    bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) const override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     bool IgnoresIncomingTxs() override { return m_ignore_incoming_txs; }
-    void SendPings() override;
-    void RelayTransaction(const TxId &txid) override;
-    void RelayProof(const avalanche::ProofId &proofid) override;
+    void SendPings() override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void RelayTransaction(const TxId &txid) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void RelayProof(const avalanche::ProofId &proofid) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void SetBestHeight(int height) override { m_best_height = height; };
     void Misbehaving(const NodeId pnode, const int howmuch,
-                     const std::string &message) override;
+                     const std::string &message) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void ProcessMessage(const Config &config, CNode &pfrom,
                         const std::string &msg_type, CDataStream &vRecv,
                         const std::chrono::microseconds time_received,
-                        const std::atomic<bool> &interruptMsgProc) override;
+                        const std::atomic<bool> &interruptMsgProc) override
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex,
+                                 !m_recent_confirmed_transactions_mutex);
     void UpdateLastBlockAnnounceTime(NodeId node,
                                      int64_t time_in_seconds) override;
 
 private:
     /**
      * Consider evicting an outbound peer based on the amount of time they've
      * been behind our tip.
      */
     void ConsiderEviction(CNode &pto, std::chrono::seconds time_in_seconds)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     /**
      * If we have extra outbound peers, try to disconnect the one with the
      * oldest block announcement.
      */
     void EvictExtraOutboundPeers(std::chrono::seconds now)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Retrieve unbroadcast transactions from the mempool and reattempt
      * sending to peers
      */
-    void ReattemptInitialBroadcast(CScheduler &scheduler);
+    void ReattemptInitialBroadcast(CScheduler &scheduler)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     /**
      * Update the avalanche statistics for all the nodes
      */
     void UpdateAvalancheStatistics() const;
 
     /**
      * Process periodic avalanche network messaging and cleanups.
      */
     void AvalanchePeriodicNetworking(CScheduler &scheduler) const;
 
     /**
      * Get a shared pointer to the Peer object.
      * May return an empty shared_ptr if the Peer object can't be found.
      */
-    PeerRef GetPeerRef(NodeId id) const;
+    PeerRef GetPeerRef(NodeId id) const EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     /**
      * Get a shared pointer to the Peer object and remove it from m_peer_map.
      * May return an empty shared_ptr if the Peer object can't be found.
      */
-    PeerRef RemovePeer(NodeId id);
+    PeerRef RemovePeer(NodeId id) EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     // overloaded variant of above to operate on CNode*s
-    void Misbehaving(const CNode &node, int howmuch,
-                     const std::string &message) {
+    void Misbehaving(const CNode &node, int howmuch, const std::string &message)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex) {
         Misbehaving(node.GetId(), howmuch, message);
     }
 
     /**
      * Potentially mark a node discouraged based on the contents of a
      * BlockValidationState object
      *
      * @param[in] via_compact_block this bool is passed in because
      * net_processing should punish peers differently depending on whether the
      * data was provided in a compact block message or not. If the compact block
      * had a valid header, but contained invalid txs, the peer should not be
      * punished. See BIP 152.
      *
      * @return Returns true if the peer was punished (probably disconnected)
      */
     bool MaybePunishNodeForBlock(NodeId nodeid,
                                  const BlockValidationState &state,
                                  bool via_compact_block,
-                                 const std::string &message = "");
+                                 const std::string &message = "")
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     /**
      * Potentially disconnect and discourage a node based on the contents of a
      * TxValidationState object
      *
      * @return Returns true if the peer was punished (probably disconnected)
      */
     bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState &state,
-                              const std::string &message = "");
+                              const std::string &message = "")
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     /**
      * Maybe disconnect a peer and discourage future connections from its
      * address.
      *
      * @param[in]   pnode     The node to check.
      * @param[in]   peer      The peer object to check.
      * @return                True if the peer was marked for disconnection in
      * this function
      */
     bool MaybeDiscourageAndDisconnect(CNode &pnode, Peer &peer);
 
     void ProcessOrphanTx(const Config &config, std::set<TxId> &orphan_work_set)
-        EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_cs_orphans);
+        EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_cs_orphans)
+            EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     /** Process a single headers message from a peer. */
     void ProcessHeadersMessage(const Config &config, CNode &pfrom,
                                const Peer &peer,
                                const std::vector<CBlockHeader> &headers,
-                               bool via_compact_block);
+                               bool via_compact_block)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     void SendBlockTransactions(CNode &pfrom, const CBlock &block,
-                               const BlockTransactionsRequest &req);
+                               const BlockTransactionsRequest &req)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     /**
      * Register with InvRequestTracker that a TX INV has been received from a
      * peer. The announcement parameters are decided in PeerManager and then
      * passed to InvRequestTracker.
      */
     void AddTxAnnouncement(const CNode &node, const TxId &txid,
                            std::chrono::microseconds current_time)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /**
      * Register with InvRequestTracker that a PROOF INV has been received from a
      * peer. The announcement parameters are decided in PeerManager and then
      * passed to InvRequestTracker.
      */
     void
     AddProofAnnouncement(const CNode &node, const avalanche::ProofId &proofid,
                          std::chrono::microseconds current_time, bool preferred)
         EXCLUSIVE_LOCKS_REQUIRED(cs_proofrequest);
 
     /** Send a version message to a peer */
     void PushNodeVersion(const Config &config, CNode &pnode, const Peer &peer);
 
     /**
      * Send a ping message every PING_INTERVAL or if requested via RPC. May mark
      * the peer to be disconnected if a ping has timed out.
      * We use mockable time for ping timeouts, so setmocktime may cause pings
      * to time out.
      */
     void MaybeSendPing(CNode &node_to, Peer &peer,
                        std::chrono::microseconds now);
 
     /** Send `addr` messages on a regular schedule. */
     void MaybeSendAddr(CNode &node, Peer &peer,
                        std::chrono::microseconds current_time);
 
     /** Send `feefilter` message. */
     void MaybeSendFeefilter(CNode &node, Peer &peer,
                             std::chrono::microseconds current_time);
 
     /**
      * Relay (gossip) an address to a few randomly chosen nodes.
      *
      * @param[in] originator   The id of the peer that sent us the address. We
      *                         don't want to relay it back.
      * @param[in] addr         Address to relay.
      * @param[in] fReachable   Whether the address' network is reachable. We
      *                         relay unreachable addresses less.
      */
-    void RelayAddress(NodeId originator, const CAddress &addr, bool fReachable);
+    void RelayAddress(NodeId originator, const CAddress &addr, bool fReachable)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     const CChainParams &m_chainparams;
     CConnman &m_connman;
     AddrMan &m_addrman;
     /**
      * Pointer to this node's banman. May be nullptr - check existence before
      * dereferencing.
      */
     BanMan *const m_banman;
     ChainstateManager &m_chainman;
     CTxMemPool &m_mempool;
     InvRequestTracker<TxId> m_txrequest GUARDED_BY(::cs_main);
 
     Mutex cs_proofrequest;
     InvRequestTracker<avalanche::ProofId>
         m_proofrequest GUARDED_BY(cs_proofrequest);
 
     /** The height of the best chain */
     std::atomic<int> m_best_height{-1};
 
     /** Next time to check for stale tip */
     std::chrono::seconds m_stale_tip_check_time{0s};
 
     /** Whether this node is running in blocks only mode */
     const bool m_ignore_incoming_txs;
 
     /**
      * Whether we've completed initial sync yet, for determining when to turn
      * on extra block-relay-only peers.
      */
     bool m_initial_sync_finished{false};
 
     /**
      * Protects m_peer_map. This mutex must not be locked while holding a lock
      * on any of the mutexes inside a Peer object.
      */
     mutable Mutex m_peer_mutex;
     /**
      * Map of all Peer objects, keyed by peer id. This map is protected
      * by the m_peer_mutex. Once a shared pointer reference is
      * taken, the lock may be released. Individual fields are protected by
      * their own locks.
      */
     std::map<NodeId, PeerRef> m_peer_map GUARDED_BY(m_peer_mutex);
 
     /** Map maintaining per-node state. */
     std::map<NodeId, CNodeState> m_node_states GUARDED_BY(cs_main);
 
     /**
      * Get a pointer to a const CNodeState, used when not mutating the
      * CNodeState object.
      */
     const CNodeState *State(NodeId pnode) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     /** Get a pointer to a mutable CNodeState. */
     CNodeState *State(NodeId pnode) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     std::atomic<std::chrono::microseconds> m_next_inv_to_inbounds{0us};
 
     /** Number of nodes with fSyncStarted. */
     int nSyncStarted GUARDED_BY(cs_main) = 0;
 
     /**
      * Sources of received blocks, saved to be able to punish them when
      * processing happens afterwards.
      * Set mapBlockSource[hash].second to false if the node should not be
      * punished if the block is invalid.
      */
     std::map<BlockHash, std::pair<NodeId, bool>>
         mapBlockSource GUARDED_BY(cs_main);
 
     /** Number of outbound peers with m_chain_sync.m_protect. */
     int m_outbound_peers_with_protect_from_disconnect GUARDED_BY(cs_main) = 0;
 
     /** Number of preferable block download peers. */
     int m_num_preferred_download_peers GUARDED_BY(cs_main){0};
 
-    bool AlreadyHaveTx(const TxId &txid) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool AlreadyHaveTx(const TxId &txid)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_main,
+                                 !m_recent_confirmed_transactions_mutex);
 
     /**
      * Filter for transactions that were recently rejected by the mempool.
      * These are not rerequested until the chain tip changes, at which point
      * the entire filter is reset.
      *
      * Without this filter we'd be re-requesting txs from each of our peers,
      * increasing bandwidth consumption considerably. For instance, with 100
      * peers, half of which relay a tx we don't accept, that might be a 50x
      * bandwidth increase. A flooding attacker attempting to roll-over the
      * filter using minimum-sized, 60byte, transactions might manage to send
      * 1000/sec if we have fast peers, so we pick 120,000 to give our peers a
      * two minute window to send invs to us.
      *
      * Decreasing the false positive rate is fairly cheap, so we pick one in a
      * million to make it highly unlikely for users to have issues with this
      * filter.
      *
      * Memory used: 1.3 MB
      */
     CRollingBloomFilter m_recent_rejects GUARDED_BY(::cs_main){120'000,
                                                                0.000'001};
     uint256 hashRecentRejectsChainTip GUARDED_BY(cs_main);
 
     /**
      * Filter for transactions that have been recently confirmed.
      * We use this to avoid requesting transactions that have already been
      * confirmed.
      */
     mutable Mutex m_recent_confirmed_transactions_mutex;
     CRollingBloomFilter m_recent_confirmed_transactions
         GUARDED_BY(m_recent_confirmed_transactions_mutex){24'000, 0.000'001};
 
     /**
      * For sending `inv`s to inbound peers, we use a single (exponentially
      * distributed) timer for all peers. If we used a separate timer for each
      * peer, a spy node could make multiple inbound connections to us to
      * accurately determine when we received the transaction (and potentially
      * determine the transaction's origin).
      */
     std::chrono::microseconds
     NextInvToInbounds(std::chrono::microseconds now,
                       std::chrono::seconds average_interval);
 
     // All of the following cache a recent block, and are protected by
     // m_most_recent_block_mutex
     RecursiveMutex m_most_recent_block_mutex;
     std::shared_ptr<const CBlock>
         m_most_recent_block GUARDED_BY(m_most_recent_block_mutex);
     std::shared_ptr<const CBlockHeaderAndShortTxIDs>
         m_most_recent_compact_block GUARDED_BY(m_most_recent_block_mutex);
     BlockHash m_most_recent_block_hash GUARDED_BY(m_most_recent_block_mutex);
 
     /**
      * Height of the highest block announced using BIP 152 high-bandwidth mode.
      */
     int m_highest_fast_announce{0};
 
     /** Have we requested this block from a peer */
     bool IsBlockRequested(const BlockHash &hash)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Remove this block from our tracked requested blocks. Called if:
      *  - the block has been received from a peer
      *  - the request for the block has timed out
      */
     void RemoveBlockRequest(const BlockHash &hash)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Mark a block as in flight
      * Returns false, still setting pit, if the block was already in flight from
      * the same peer pit will only be valid as long as the same cs_main lock is
      * being held
      */
     bool BlockRequested(const Config &config, NodeId nodeid,
                         const CBlockIndex &block,
                         std::list<QueuedBlock>::iterator **pit = nullptr)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     bool TipMayBeStale() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Update pindexLastCommonBlock and add not-in-flight missing successors to
      * vBlocks, until it has at most count entries.
      */
     void FindNextBlocksToDownload(NodeId nodeid, unsigned int count,
                                   std::vector<const CBlockIndex *> &vBlocks,
                                   NodeId &nodeStaller)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     std::map<BlockHash, std::pair<NodeId, std::list<QueuedBlock>::iterator>>
         mapBlocksInFlight GUARDED_BY(cs_main);
 
     /** When our tip was last updated. */
     std::atomic<std::chrono::seconds> m_last_tip_update{0s};
 
     /**
      * Determine whether or not a peer can request a transaction, and return it
      * (or nullptr if not found or not allowed).
      */
     CTransactionRef FindTxForGetData(const CNode &peer, const TxId &txid,
                                      const std::chrono::seconds mempool_req,
                                      const std::chrono::seconds now)
         LOCKS_EXCLUDED(cs_main);
 
     void ProcessGetData(const Config &config, CNode &pfrom, Peer &peer,
                         const std::atomic<bool> &interruptMsgProc)
         EXCLUSIVE_LOCKS_REQUIRED(peer.m_getdata_requests_mutex)
             LOCKS_EXCLUDED(cs_main);
 
     /** Process a new block. Perform any post-processing housekeeping */
     void ProcessBlock(const Config &config, CNode &node,
                       const std::shared_ptr<const CBlock> &block,
                       bool force_processing);
 
     /** Relay map. */
     typedef std::map<TxId, CTransactionRef> MapRelay;
     MapRelay mapRelay GUARDED_BY(cs_main);
 
     /**
      * Expiration-time ordered list of (expire time, relay map entry) pairs,
      * protected by cs_main).
      */
     std::deque<std::pair<std::chrono::microseconds, MapRelay::iterator>>
         g_relay_expiration GUARDED_BY(cs_main);
 
     /**
      * When a peer sends us a valid block, instruct it to announce blocks to us
      * using CMPCTBLOCK if possible by adding its nodeid to the end of
      * lNodesAnnouncingHeaderAndIDs, and keeping that list under a certain size
      * by removing the first element if necessary.
      */
     void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /** Stack of nodes which we have set to announce using compact blocks */
     std::list<NodeId> lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main);
 
     /** Number of peers from which we're downloading blocks. */
     int m_peers_downloading_from GUARDED_BY(cs_main) = 0;
 
     /** Storage for orphan information */
     TxOrphanage m_orphanage;
 
     void AddToCompactExtraTransactions(const CTransactionRef &tx)
         EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans);
 
     /**
      * Orphan/conflicted/etc transactions that are kept for compact block
      * reconstruction.
      * The last
      * -blockreconstructionextratxn/DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN of
      * these are kept in a ring buffer
      */
     std::vector<std::pair<TxHash, CTransactionRef>>
         vExtraTxnForCompact GUARDED_BY(g_cs_orphans);
     /** Offset into vExtraTxnForCompact to insert the next tx */
     size_t vExtraTxnForCompactIt GUARDED_BY(g_cs_orphans) = 0;
 
     /**
      * Check whether the last unknown block a peer advertised is not yet known.
      */
     void ProcessBlockAvailability(NodeId nodeid)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     /**
      * Update tracking information about which blocks a peer is assumed to have.
      */
     void UpdateBlockAvailability(NodeId nodeid, const BlockHash &hash)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     bool CanDirectFetch() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * To prevent fingerprinting attacks, only send blocks/headers outside of
      * the active chain if they are no more than a month older (both in time,
      * and in best equivalent proof of work) than the best header chain we know
      * about and we fully-validated them at some point.
      */
     bool BlockRequestAllowed(const CBlockIndex *pindex)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     bool AlreadyHaveBlock(const BlockHash &block_hash)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     bool AlreadyHaveProof(const avalanche::ProofId &proofid);
     void ProcessGetBlockData(const Config &config, CNode &pfrom, Peer &peer,
                              const CInv &inv);
 
     /**
      * Validation logic for compact filters request handling.
      *
      * May disconnect from the peer in the case of a bad request.
      *
      * @param[in]   node            The node that we received the request from
      * @param[in]   peer            The peer that we received the request from
      * @param[in]   filter_type     The filter type the request is for. Must be
      *                              basic filters.
      * @param[in]   start_height    The start height for the request
      * @param[in]   stop_hash       The stop_hash for the request
      * @param[in]   max_height_diff The maximum number of items permitted to
      *                              request, as specified in BIP 157
      * @param[out]  stop_index      The CBlockIndex for the stop_hash block, if
      *                              the request can be serviced.
      * @param[out]  filter_index    The filter index, if the request can be
      *                              serviced.
      * @return                      True if the request can be serviced.
      */
     bool PrepareBlockFilterRequest(CNode &node, Peer &peer,
                                    BlockFilterType filter_type,
                                    uint32_t start_height,
                                    const BlockHash &stop_hash,
                                    uint32_t max_height_diff,
                                    const CBlockIndex *&stop_index,
                                    BlockFilterIndex *&filter_index);
 
     /**
      * Handle a cfilters request.
      *
      * May disconnect from the peer in the case of a bad request.
      *
      * @param[in]   node            The node that we received the request from
      * @param[in]   peer            The peer that we received the request from
      * @param[in]   vRecv           The raw message received
      */
     void ProcessGetCFilters(CNode &node, Peer &peer, CDataStream &vRecv);
     /**
      * Handle a cfheaders request.
      *
      * May disconnect from the peer in the case of a bad request.
      *
      * @param[in]   node            The node that we received the request from
      * @param[in]   peer            The peer that we received the request from
      * @param[in]   vRecv           The raw message received
      */
     void ProcessGetCFHeaders(CNode &node, Peer &peer, CDataStream &vRecv);
     /**
      * Handle a getcfcheckpt request.
      *
      * May disconnect from the peer in the case of a bad request.
      *
      * @param[in]   node            The node that we received the request from
      * @param[in]   peer            The peer that we received the request from
      * @param[in]   vRecv           The raw message received
      */
     void ProcessGetCFCheckPt(CNode &node, Peer &peer, CDataStream &vRecv);
 
     /**
      * Decide a response for an Avalanche poll about the given block.
      *
      * @param[in]   hash            The hash of the block being polled for
      * @return                      Our current vote for the block
      */
     uint32_t GetAvalancheVoteForBlock(const BlockHash &hash) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Decide a response for an Avalanche poll about the given transaction.
      *
      * @param[in] id       The id of the transaction being polled for
      * @return             Our current vote for the transaction
      */
     uint32_t GetAvalancheVoteForTx(const TxId &id) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     /**
      * Checks if address relay is permitted with peer. If needed, initializes
      * the m_addr_known bloom filter and sets m_addr_relay_enabled to true.
      *
      *  @return   True if address relay is enabled with peer
      *            False if address relay is disallowed
      */
     bool SetupAddressRelay(const CNode &node, Peer &peer);
 
     /**
      * Manage reception of an avalanche proof.
      *
      * @return   False if the peer is misbehaving, true otherwise
      */
     bool ReceivedAvalancheProof(CNode &node, Peer &peer,
-                                const avalanche::ProofRef &proof);
+                                const avalanche::ProofRef &proof)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
     avalanche::ProofRef FindProofForGetData(const CNode &peer,
                                             const avalanche::ProofId &proofid,
                                             const std::chrono::seconds now);
 
     bool isPreferredDownloadPeer(const CNode &pfrom);
 };
 
 const CNodeState *PeerManagerImpl::State(NodeId pnode) const
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     std::map<NodeId, CNodeState>::const_iterator it = m_node_states.find(pnode);
     if (it == m_node_states.end()) {
         return nullptr;
     }
 
     return &it->second;
 }
 
 CNodeState *PeerManagerImpl::State(NodeId pnode)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     return const_cast<CNodeState *>(std::as_const(*this).State(pnode));
 }
 
 /**
  * Whether the peer supports the address. For example, a peer that does not
  * implement BIP155 cannot receive Tor v3 addresses because it requires
  * ADDRv2 (BIP155) encoding.
  */
 static bool IsAddrCompatible(const Peer &peer, const CAddress &addr) {
     return peer.m_wants_addrv2 || addr.IsAddrV1Compatible();
 }
 
 static void AddAddressKnown(Peer &peer, const CAddress &addr) {
     assert(peer.m_addr_known);
     peer.m_addr_known->insert(addr.GetKey());
 }
 
 static void PushAddress(Peer &peer, const CAddress &addr,
                         FastRandomContext &insecure_rand) {
     // Known checking here is only to save space from duplicates.
     // Before sending, we'll filter it again for known addresses that were
     // added after addresses were pushed.
     assert(peer.m_addr_known);
     if (addr.IsValid() && !peer.m_addr_known->contains(addr.GetKey()) &&
         IsAddrCompatible(peer, addr)) {
         if (peer.m_addrs_to_send.size() >= GetMaxAddrToSend()) {
             peer.m_addrs_to_send[insecure_rand.randrange(
                 peer.m_addrs_to_send.size())] = addr;
         } else {
             peer.m_addrs_to_send.push_back(addr);
         }
     }
 }
 
 static void AddKnownTx(Peer &peer, const TxId &txid) {
     auto tx_relay = peer.GetTxRelay();
     if (!tx_relay) {
         return;
     }
 
     LOCK(tx_relay->m_tx_inventory_mutex);
     tx_relay->m_tx_inventory_known_filter.insert(txid);
 }
 
 static void AddKnownProof(Peer &peer, const avalanche::ProofId &proofid) {
     if (peer.m_proof_relay != nullptr) {
         LOCK(peer.m_proof_relay->m_proof_inventory_mutex);
         peer.m_proof_relay->m_proof_inventory_known_filter.insert(proofid);
     }
 }
 
 bool PeerManagerImpl::isPreferredDownloadPeer(const CNode &pfrom) {
     LOCK(cs_main);
     const CNodeState *state = State(pfrom.GetId());
     return state && state->fPreferredDownload;
 }
 /** Whether this peer can serve us blocks. */
 static bool CanServeBlocks(const Peer &peer) {
     return peer.m_their_services & (NODE_NETWORK | NODE_NETWORK_LIMITED);
 }
 
 /**
  * Whether this peer can only serve limited recent blocks (e.g. because
  * it prunes old blocks)
  */
 static bool IsLimitedPeer(const Peer &peer) {
     return (!(peer.m_their_services & NODE_NETWORK) &&
             (peer.m_their_services & NODE_NETWORK_LIMITED));
 }
 
 std::chrono::microseconds
 PeerManagerImpl::NextInvToInbounds(std::chrono::microseconds now,
                                    std::chrono::seconds average_interval) {
     if (m_next_inv_to_inbounds.load() < now) {
         // If this function were called from multiple threads simultaneously
         // it would possible that both update the next send variable, and return
         // a different result to their caller. This is not possible in practice
         // as only the net processing thread invokes this function.
         m_next_inv_to_inbounds = GetExponentialRand(now, average_interval);
     }
     return m_next_inv_to_inbounds;
 }
 
 bool PeerManagerImpl::IsBlockRequested(const BlockHash &hash) {
     return mapBlocksInFlight.find(hash) != mapBlocksInFlight.end();
 }
 
 void PeerManagerImpl::RemoveBlockRequest(const BlockHash &hash) {
     auto it = mapBlocksInFlight.find(hash);
 
     if (it == mapBlocksInFlight.end()) {
         // Block was not requested
         return;
     }
 
     auto [node_id, list_it] = it->second;
     CNodeState *state = State(node_id);
     assert(state != nullptr);
 
     if (state->vBlocksInFlight.begin() == list_it) {
         // First block on the queue was received, update the start download time
         // for the next one
         state->m_downloading_since = std::max(
             state->m_downloading_since, GetTime<std::chrono::microseconds>());
     }
     state->vBlocksInFlight.erase(list_it);
 
     state->nBlocksInFlight--;
     if (state->nBlocksInFlight == 0) {
         // Last validated block on the queue was received.
         m_peers_downloading_from--;
     }
     state->m_stalling_since = 0us;
     mapBlocksInFlight.erase(it);
 }
 
 bool PeerManagerImpl::BlockRequested(const Config &config, NodeId nodeid,
                                      const CBlockIndex &block,
                                      std::list<QueuedBlock>::iterator **pit) {
     const BlockHash &hash{block.GetBlockHash()};
 
     CNodeState *state = State(nodeid);
     assert(state != nullptr);
 
     // Short-circuit most stuff in case it is from the same node.
     std::map<BlockHash,
              std::pair<NodeId, std::list<QueuedBlock>::iterator>>::iterator
         itInFlight = mapBlocksInFlight.find(hash);
     if (itInFlight != mapBlocksInFlight.end() &&
         itInFlight->second.first == nodeid) {
         if (pit) {
             *pit = &itInFlight->second.second;
         }
         return false;
     }
 
     // Make sure it's not listed somewhere already.
     RemoveBlockRequest(hash);
 
     std::list<QueuedBlock>::iterator it = state->vBlocksInFlight.insert(
         state->vBlocksInFlight.end(),
         {&block, std::unique_ptr<PartiallyDownloadedBlock>(
                      pit ? new PartiallyDownloadedBlock(config, &m_mempool)
                          : nullptr)});
     state->nBlocksInFlight++;
     if (state->nBlocksInFlight == 1) {
         // We're starting a block download (batch) from this peer.
         state->m_downloading_since = GetTime<std::chrono::microseconds>();
         m_peers_downloading_from++;
     }
 
     itInFlight = mapBlocksInFlight
                      .insert(std::make_pair(hash, std::make_pair(nodeid, it)))
                      .first;
 
     if (pit) {
         *pit = &itInFlight->second.second;
     }
 
     return true;
 }
 
 void PeerManagerImpl::MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid) {
     AssertLockHeld(cs_main);
 
     // Never request high-bandwidth mode from peers if we're blocks-only. Our
     // mempool will not contain the transactions necessary to reconstruct the
     // compact block.
     if (m_ignore_incoming_txs) {
         return;
     }
 
     CNodeState *nodestate = State(nodeid);
     if (!nodestate) {
         LogPrint(BCLog::NET, "node state unavailable: peer=%d\n", nodeid);
         return;
     }
     if (!nodestate->m_provides_cmpctblocks) {
         return;
     }
     int num_outbound_hb_peers = 0;
     for (std::list<NodeId>::iterator it = lNodesAnnouncingHeaderAndIDs.begin();
          it != lNodesAnnouncingHeaderAndIDs.end(); it++) {
         if (*it == nodeid) {
             lNodesAnnouncingHeaderAndIDs.erase(it);
             lNodesAnnouncingHeaderAndIDs.push_back(nodeid);
             return;
         }
         CNodeState *state = State(*it);
         if (state != nullptr && !state->m_is_inbound) {
             ++num_outbound_hb_peers;
         }
     }
     if (nodestate->m_is_inbound) {
         // If we're adding an inbound HB peer, make sure we're not removing
         // our last outbound HB peer in the process.
         if (lNodesAnnouncingHeaderAndIDs.size() >= 3 &&
             num_outbound_hb_peers == 1) {
             CNodeState *remove_node =
                 State(lNodesAnnouncingHeaderAndIDs.front());
             if (remove_node != nullptr && !remove_node->m_is_inbound) {
                 // Put the HB outbound peer in the second slot, so that it
                 // doesn't get removed.
                 std::swap(lNodesAnnouncingHeaderAndIDs.front(),
                           *std::next(lNodesAnnouncingHeaderAndIDs.begin()));
             }
         }
     }
     m_connman.ForNode(nodeid, [this](CNode *pfrom) EXCLUSIVE_LOCKS_REQUIRED(
                                   ::cs_main) {
         AssertLockHeld(::cs_main);
         if (lNodesAnnouncingHeaderAndIDs.size() >= 3) {
             // As per BIP152, we only get 3 of our peers to announce
             // blocks using compact encodings.
             m_connman.ForNode(
                 lNodesAnnouncingHeaderAndIDs.front(), [this](CNode *pnodeStop) {
                     m_connman.PushMessage(
                         pnodeStop, CNetMsgMaker(pnodeStop->GetCommonVersion())
                                        .Make(NetMsgType::SENDCMPCT,
                                              /*high_bandwidth=*/false,
                                              /*version=*/CMPCTBLOCKS_VERSION));
                     // save BIP152 bandwidth state: we select peer to be
                     // low-bandwidth
                     pnodeStop->m_bip152_highbandwidth_to = false;
                     return true;
                 });
             lNodesAnnouncingHeaderAndIDs.pop_front();
         }
         m_connman.PushMessage(pfrom,
                               CNetMsgMaker(pfrom->GetCommonVersion())
                                   .Make(NetMsgType::SENDCMPCT,
                                         /*high_bandwidth=*/true,
                                         /*version=*/CMPCTBLOCKS_VERSION));
         // save BIP152 bandwidth state: we select peer to be high-bandwidth
         pfrom->m_bip152_highbandwidth_to = true;
         lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId());
         return true;
     });
 }
 
 bool PeerManagerImpl::TipMayBeStale() {
     AssertLockHeld(cs_main);
     const Consensus::Params &consensusParams = m_chainparams.GetConsensus();
     if (m_last_tip_update.load() == 0s) {
         m_last_tip_update = GetTime<std::chrono::seconds>();
     }
     return m_last_tip_update.load() <
                GetTime<std::chrono::seconds>() -
                    std::chrono::seconds{consensusParams.nPowTargetSpacing *
                                         3} &&
            mapBlocksInFlight.empty();
 }
 
 bool PeerManagerImpl::CanDirectFetch() {
     return m_chainman.ActiveChain().Tip()->GetBlockTime() >
            GetAdjustedTime() -
                m_chainparams.GetConsensus().nPowTargetSpacing * 20;
 }
 
 static bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     if (state->pindexBestKnownBlock &&
         pindex == state->pindexBestKnownBlock->GetAncestor(pindex->nHeight)) {
         return true;
     }
     if (state->pindexBestHeaderSent &&
         pindex == state->pindexBestHeaderSent->GetAncestor(pindex->nHeight)) {
         return true;
     }
     return false;
 }
 
 void PeerManagerImpl::ProcessBlockAvailability(NodeId nodeid) {
     CNodeState *state = State(nodeid);
     assert(state != nullptr);
 
     if (!state->hashLastUnknownBlock.IsNull()) {
         const CBlockIndex *pindex =
             m_chainman.m_blockman.LookupBlockIndex(state->hashLastUnknownBlock);
         if (pindex && pindex->nChainWork > 0) {
             if (state->pindexBestKnownBlock == nullptr ||
                 pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) {
                 state->pindexBestKnownBlock = pindex;
             }
             state->hashLastUnknownBlock.SetNull();
         }
     }
 }
 
 void PeerManagerImpl::UpdateBlockAvailability(NodeId nodeid,
                                               const BlockHash &hash) {
     CNodeState *state = State(nodeid);
     assert(state != nullptr);
 
     ProcessBlockAvailability(nodeid);
 
     const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash);
     if (pindex && pindex->nChainWork > 0) {
         // An actually better block was announced.
         if (state->pindexBestKnownBlock == nullptr ||
             pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) {
             state->pindexBestKnownBlock = pindex;
         }
     } else {
         // An unknown block was announced; just assume that the latest one is
         // the best one.
         state->hashLastUnknownBlock = hash;
     }
 }
 
 void PeerManagerImpl::FindNextBlocksToDownload(
     NodeId nodeid, unsigned int count,
     std::vector<const CBlockIndex *> &vBlocks, NodeId &nodeStaller) {
     if (count == 0) {
         return;
     }
 
     vBlocks.reserve(vBlocks.size() + count);
     CNodeState *state = State(nodeid);
     assert(state != nullptr);
 
     // Make sure pindexBestKnownBlock is up to date, we'll need it.
     ProcessBlockAvailability(nodeid);
 
     if (state->pindexBestKnownBlock == nullptr ||
         state->pindexBestKnownBlock->nChainWork <
             m_chainman.ActiveChain().Tip()->nChainWork ||
         state->pindexBestKnownBlock->nChainWork < nMinimumChainWork) {
         // This peer has nothing interesting.
         return;
     }
 
     if (state->pindexLastCommonBlock == nullptr) {
         // Bootstrap quickly by guessing a parent of our best tip is the forking
         // point. Guessing wrong in either direction is not a problem.
         state->pindexLastCommonBlock =
             m_chainman
                 .ActiveChain()[std::min(state->pindexBestKnownBlock->nHeight,
                                         m_chainman.ActiveChain().Height())];
     }
 
     // If the peer reorganized, our previous pindexLastCommonBlock may not be an
     // ancestor of its current tip anymore. Go back enough to fix that.
     state->pindexLastCommonBlock = LastCommonAncestor(
         state->pindexLastCommonBlock, state->pindexBestKnownBlock);
     if (state->pindexLastCommonBlock == state->pindexBestKnownBlock) {
         return;
     }
 
     std::vector<const CBlockIndex *> vToFetch;
     const CBlockIndex *pindexWalk = state->pindexLastCommonBlock;
     // Never fetch further than the best block we know the peer has, or more
     // than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last linked block we have in
     // common with this peer. The +1 is so we can detect stalling, namely if we
     // would be able to download that next block if the window were 1 larger.
     int nWindowEnd =
         state->pindexLastCommonBlock->nHeight + BLOCK_DOWNLOAD_WINDOW;
     int nMaxHeight =
         std::min<int>(state->pindexBestKnownBlock->nHeight, nWindowEnd + 1);
     NodeId waitingfor = -1;
     while (pindexWalk->nHeight < nMaxHeight) {
         // Read up to 128 (or more, if more blocks than that are needed)
         // successors of pindexWalk (towards pindexBestKnownBlock) into
         // vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as
         // expensive as iterating over ~100 CBlockIndex* entries anyway.
         int nToFetch = std::min(nMaxHeight - pindexWalk->nHeight,
                                 std::max<int>(count - vBlocks.size(), 128));
         vToFetch.resize(nToFetch);
         pindexWalk = state->pindexBestKnownBlock->GetAncestor(
             pindexWalk->nHeight + nToFetch);
         vToFetch[nToFetch - 1] = pindexWalk;
         for (unsigned int i = nToFetch - 1; i > 0; i--) {
             vToFetch[i - 1] = vToFetch[i]->pprev;
         }
 
         // Iterate over those blocks in vToFetch (in forward direction), adding
         // the ones that are not yet downloaded and not in flight to vBlocks. In
         // the meantime, update pindexLastCommonBlock as long as all ancestors
         // are already downloaded, or if it's already part of our chain (and
         // therefore don't need it even if pruned).
         for (const CBlockIndex *pindex : vToFetch) {
             if (!pindex->IsValid(BlockValidity::TREE)) {
                 // We consider the chain that this peer is on invalid.
                 return;
             }
             if (pindex->nStatus.hasData() ||
                 m_chainman.ActiveChain().Contains(pindex)) {
                 if (pindex->HaveTxsDownloaded()) {
                     state->pindexLastCommonBlock = pindex;
                 }
             } else if (!IsBlockRequested(pindex->GetBlockHash())) {
                 // The block is not already downloaded, and not yet in flight.
                 if (pindex->nHeight > nWindowEnd) {
                     // We reached the end of the window.
                     if (vBlocks.size() == 0 && waitingfor != nodeid) {
                         // We aren't able to fetch anything, but we would be if
                         // the download window was one larger.
                         nodeStaller = waitingfor;
                     }
                     return;
                 }
                 vBlocks.push_back(pindex);
                 if (vBlocks.size() == count) {
                     return;
                 }
             } else if (waitingfor == -1) {
                 // This is the first already-in-flight block.
                 waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first;
             }
         }
     }
 }
 
 } // namespace
 
 template <class InvId>
 static bool TooManyAnnouncements(const CNode &node,
                                  const InvRequestTracker<InvId> &requestTracker,
                                  const DataRequestParameters &requestParams) {
     return !node.HasPermission(
                requestParams.bypass_request_limits_permissions) &&
            requestTracker.Count(node.GetId()) >=
                requestParams.max_peer_announcements;
 }
 
 /**
  * Compute the request time for this announcement, current time plus delays for:
  *   - nonpref_peer_delay for announcements from non-preferred connections
  *   - overloaded_peer_delay for announcements from peers which have at least
  *     max_peer_request_in_flight requests in flight (and don't have
  * NetPermissionFlags::Relay).
  */
 template <class InvId>
 static std::chrono::microseconds
 ComputeRequestTime(const CNode &node,
                    const InvRequestTracker<InvId> &requestTracker,
                    const DataRequestParameters &requestParams,
                    std::chrono::microseconds current_time, bool preferred) {
     auto delay = std::chrono::microseconds{0};
 
     if (!preferred) {
         delay += requestParams.nonpref_peer_delay;
     }
 
     if (!node.HasPermission(requestParams.bypass_request_limits_permissions) &&
         requestTracker.CountInFlight(node.GetId()) >=
             requestParams.max_peer_request_in_flight) {
         delay += requestParams.overloaded_peer_delay;
     }
 
     return current_time + delay;
 }
 
 void PeerManagerImpl::PushNodeVersion(const Config &config, CNode &pnode,
                                       const Peer &peer) {
     uint64_t my_services{peer.m_our_services};
     const int64_t nTime{count_seconds(GetTime<std::chrono::seconds>())};
     uint64_t nonce = pnode.GetLocalNonce();
     const int nNodeStartingHeight{m_best_height};
     NodeId nodeid = pnode.GetId();
     CAddress addr = pnode.addr;
     uint64_t extraEntropy = pnode.GetLocalExtraEntropy();
 
     CService addr_you =
         addr.IsRoutable() && !IsProxy(addr) && addr.IsAddrV1Compatible()
             ? addr
             : CService();
     uint64_t your_services{addr.nServices};
 
     const bool tx_relay = !m_ignore_incoming_txs && !pnode.IsBlockOnlyConn() &&
                           !pnode.IsFeelerConn();
     m_connman.PushMessage(
         // your_services, addr_you: Together the pre-version-31402 serialization
         //     of CAddress "addrYou" (without nTime)
         // my_services, CService(): Together the pre-version-31402 serialization
         //     of CAddress "addrMe" (without nTime)
         &pnode, CNetMsgMaker(INIT_PROTO_VERSION)
                     .Make(NetMsgType::VERSION, PROTOCOL_VERSION, my_services,
                           nTime, your_services, addr_you, my_services,
                           CService(), nonce, userAgent(config),
                           nNodeStartingHeight, tx_relay, extraEntropy));
 
     if (fLogIPs) {
         LogPrint(BCLog::NET,
                  "send version message: version %d, blocks=%d, them=%s, "
                  "txrelay=%d, peer=%d\n",
                  PROTOCOL_VERSION, nNodeStartingHeight, addr_you.ToString(),
                  tx_relay, nodeid);
     } else {
         LogPrint(BCLog::NET,
                  "send version message: version %d, blocks=%d, "
                  "txrelay=%d, peer=%d\n",
                  PROTOCOL_VERSION, nNodeStartingHeight, tx_relay, nodeid);
     }
 }
 
 void PeerManagerImpl::AddTxAnnouncement(
     const CNode &node, const TxId &txid,
     std::chrono::microseconds current_time) {
     // For m_txrequest and state
     AssertLockHeld(::cs_main);
 
     if (TooManyAnnouncements(node, m_txrequest, TX_REQUEST_PARAMS)) {
         return;
     }
 
     const bool preferred = isPreferredDownloadPeer(node);
     auto reqtime = ComputeRequestTime(node, m_txrequest, TX_REQUEST_PARAMS,
                                       current_time, preferred);
 
     m_txrequest.ReceivedInv(node.GetId(), txid, preferred, reqtime);
 }
 
 void PeerManagerImpl::AddProofAnnouncement(
     const CNode &node, const avalanche::ProofId &proofid,
     std::chrono::microseconds current_time, bool preferred) {
     // For m_proofrequest
     AssertLockHeld(cs_proofrequest);
 
     if (TooManyAnnouncements(node, m_proofrequest, PROOF_REQUEST_PARAMS)) {
         return;
     }
 
     auto reqtime = ComputeRequestTime(
         node, m_proofrequest, PROOF_REQUEST_PARAMS, current_time, preferred);
 
     m_proofrequest.ReceivedInv(node.GetId(), proofid, preferred, reqtime);
 }
 
 void PeerManagerImpl::UpdateLastBlockAnnounceTime(NodeId node,
                                                   int64_t time_in_seconds) {
     LOCK(cs_main);
     CNodeState *state = State(node);
     if (state) {
         state->m_last_block_announcement = time_in_seconds;
     }
 }
 
 void PeerManagerImpl::InitializeNode(const Config &config, CNode &node,
                                      ServiceFlags our_services) {
     NodeId nodeid = node.GetId();
     {
         LOCK(cs_main);
         m_node_states.emplace_hint(m_node_states.end(),
                                    std::piecewise_construct,
                                    std::forward_as_tuple(nodeid),
                                    std::forward_as_tuple(node.IsInboundConn()));
         assert(m_txrequest.Count(nodeid) == 0);
     }
     PeerRef peer = std::make_shared<Peer>(nodeid, our_services);
     {
         LOCK(m_peer_mutex);
         m_peer_map.emplace_hint(m_peer_map.end(), nodeid, peer);
     }
     if (!node.IsInboundConn()) {
         PushNodeVersion(config, node, *peer);
     }
 }
 
 void PeerManagerImpl::ReattemptInitialBroadcast(CScheduler &scheduler) {
     std::set<TxId> unbroadcast_txids = m_mempool.GetUnbroadcastTxs();
 
     for (const TxId &txid : unbroadcast_txids) {
         // Sanity check: all unbroadcast txns should exist in the mempool
         if (m_mempool.exists(txid)) {
             RelayTransaction(txid);
         } else {
             m_mempool.RemoveUnbroadcastTx(txid, true);
         }
     }
 
     if (g_avalanche && isAvalancheEnabled(gArgs)) {
         // Get and sanitize the list of proofids to broadcast. The RelayProof
         // call is done in a second loop to avoid locking cs_vNodes while
         // cs_peerManager is locked which would cause a potential deadlock due
         // to reversed lock order.
         auto unbroadcasted_proofids =
             g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
                 auto unbroadcasted_proofids = pm.getUnbroadcastProofs();
 
                 auto it = unbroadcasted_proofids.begin();
                 while (it != unbroadcasted_proofids.end()) {
                     // Sanity check: all unbroadcast proofs should be bound to a
                     // peer in the peermanager
                     if (!pm.isBoundToPeer(*it)) {
                         pm.removeUnbroadcastProof(*it);
                         it = unbroadcasted_proofids.erase(it);
                         continue;
                     }
 
                     ++it;
                 }
 
                 return unbroadcasted_proofids;
             });
 
         // Remaining proofids are the ones to broadcast
         for (const auto &proofid : unbroadcasted_proofids) {
             RelayProof(proofid);
         }
     }
 
     // Schedule next run for 10-15 minutes in the future.
     // We add randomness on every cycle to avoid the possibility of P2P
     // fingerprinting.
     const auto reattemptBroadcastInterval = 10min + GetRandMillis(5min);
     scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); },
                               reattemptBroadcastInterval);
 }
 
 void PeerManagerImpl::UpdateAvalancheStatistics() const {
     m_connman.ForEachNode([](CNode *pnode) {
         pnode->updateAvailabilityScore(AVALANCHE_STATISTICS_DECAY_FACTOR);
     });
 
     if (!g_avalanche) {
         // Not enabled or not ready yet
         return;
     }
 
     // Generate a peer availability score by computing an exponentially
     // weighted moving average of the average of node availability scores.
     // This ensures the peer score is bound to the lifetime of its proof which
     // incentivizes stable network activity.
     g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
         pm.updateAvailabilityScores(
             AVALANCHE_STATISTICS_DECAY_FACTOR, [&](NodeId nodeid) -> double {
                 double score{0.0};
                 m_connman.ForNode(nodeid, [&](CNode *pavanode) {
                     score = pavanode->getAvailabilityScore();
                     return true;
                 });
                 return score;
             });
     });
 }
 
 void PeerManagerImpl::AvalanchePeriodicNetworking(CScheduler &scheduler) const {
     const auto now = GetTime<std::chrono::seconds>();
     std::vector<NodeId> avanode_ids;
     bool fQuorumEstablished;
     bool fShouldRequestMoreNodes;
 
     if (!g_avalanche) {
         // Not enabled or not ready yet, retry later
         goto scheduleLater;
     }
 
     g_avalanche->sendDelayedAvahello();
 
     fQuorumEstablished = g_avalanche->isQuorumEstablished();
     fShouldRequestMoreNodes =
         g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
             return pm.shouldRequestMoreNodes();
         });
 
     m_connman.ForEachNode([&](CNode *pnode) {
         // Build a list of the avalanche peers nodeids
         if (pnode->m_avalanche_enabled &&
             (!fQuorumEstablished || !pnode->IsInboundConn())) {
             avanode_ids.push_back(pnode->GetId());
         }
 
         PeerRef peer = GetPeerRef(pnode->GetId());
         if (peer == nullptr) {
             return;
         }
         // If a proof radix tree timed out, cleanup
         if (peer->m_proof_relay &&
             now > (peer->m_proof_relay->lastSharedProofsUpdate.load() +
                    AVALANCHE_AVAPROOFS_TIMEOUT)) {
             peer->m_proof_relay->sharedProofs = {};
         }
     });
 
     if (avanode_ids.empty()) {
         // No node is available for messaging, retry later
         goto scheduleLater;
     }
 
     Shuffle(avanode_ids.begin(), avanode_ids.end(), FastRandomContext());
 
     // Request avalanche addresses from our peers
     for (NodeId avanodeId : avanode_ids) {
         m_connman.ForNode(avanodeId, [&](CNode *pavanode) {
             m_connman.PushMessage(pavanode,
                                   CNetMsgMaker(pavanode->GetCommonVersion())
                                       .Make(NetMsgType::GETAVAADDR));
             PeerRef peer = GetPeerRef(avanodeId);
             WITH_LOCK(peer->m_addr_token_bucket_mutex,
                       peer->m_addr_token_bucket += GetMaxAddrToSend());
             return true;
         });
 
         // If we have no reason to believe that we need more nodes, only request
         // addresses from one of our peers.
         if (fQuorumEstablished && !fShouldRequestMoreNodes) {
             break;
         }
     }
 
     if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
         // Don't request proofs while in IBD. We're likely to orphan them
         // because we don't have the UTXOs.
         goto scheduleLater;
     }
 
     // If we never had an avaproofs message yet, be kind and only request to a
     // subset of our peers as we expect a ton of avaproofs message in the
     // process.
     if (g_avalanche->getAvaproofsNodeCounter() == 0) {
         avanode_ids.resize(std::min<size_t>(avanode_ids.size(), 3));
     }
 
     for (NodeId nodeid : avanode_ids) {
         // Send a getavaproofs to all of our peers
         m_connman.ForNode(nodeid, [&](CNode *pavanode) {
             PeerRef peer = GetPeerRef(nodeid);
             if (peer->m_proof_relay) {
                 m_connman.PushMessage(pavanode,
                                       CNetMsgMaker(pavanode->GetCommonVersion())
                                           .Make(NetMsgType::GETAVAPROOFS));
 
                 peer->m_proof_relay->compactproofs_requested = true;
             }
             return true;
         });
     }
 
 scheduleLater:
     // Schedule next run for 2-5 minutes in the future.
     // We add randomness on every cycle to avoid the possibility of P2P
     // fingerprinting.
     const auto avalanchePeriodicNetworkingInterval = 2min + GetRandMillis(3min);
     scheduler.scheduleFromNow([&] { AvalanchePeriodicNetworking(scheduler); },
                               avalanchePeriodicNetworkingInterval);
 }
 
 void PeerManagerImpl::FinalizeNode(const Config &config, const CNode &node) {
     NodeId nodeid = node.GetId();
     int misbehavior{0};
     {
         LOCK(cs_main);
         {
             // We remove the PeerRef from g_peer_map here, but we don't always
             // destruct the Peer. Sometimes another thread is still holding a
             // PeerRef, so the refcount is >= 1. Be careful not to do any
             // processing here that assumes Peer won't be changed before it's
             // destructed.
             PeerRef peer = RemovePeer(nodeid);
             assert(peer != nullptr);
             misbehavior = WITH_LOCK(peer->m_misbehavior_mutex,
                                     return peer->m_misbehavior_score);
             LOCK(m_peer_mutex);
             m_peer_map.erase(nodeid);
         }
         CNodeState *state = State(nodeid);
         assert(state != nullptr);
 
         if (state->fSyncStarted) {
             nSyncStarted--;
         }
 
         for (const QueuedBlock &entry : state->vBlocksInFlight) {
             mapBlocksInFlight.erase(entry.pindex->GetBlockHash());
         }
         WITH_LOCK(g_cs_orphans, m_orphanage.EraseForPeer(nodeid));
         m_txrequest.DisconnectedPeer(nodeid);
         m_num_preferred_download_peers -= state->fPreferredDownload;
         m_peers_downloading_from -= (state->nBlocksInFlight != 0);
         assert(m_peers_downloading_from >= 0);
         m_outbound_peers_with_protect_from_disconnect -=
             state->m_chain_sync.m_protect;
         assert(m_outbound_peers_with_protect_from_disconnect >= 0);
 
         m_node_states.erase(nodeid);
 
         if (m_node_states.empty()) {
             // Do a consistency check after the last peer is removed.
             assert(mapBlocksInFlight.empty());
             assert(m_num_preferred_download_peers == 0);
             assert(m_peers_downloading_from == 0);
             assert(m_outbound_peers_with_protect_from_disconnect == 0);
             assert(m_txrequest.Size() == 0);
             assert(m_orphanage.Size() == 0);
         }
     }
 
     if (node.fSuccessfullyConnected && misbehavior == 0 &&
         !node.IsBlockOnlyConn() && !node.IsInboundConn()) {
         // Only change visible addrman state for full outbound peers. We don't
         // call Connected() for feeler connections since they don't have
         // fSuccessfullyConnected set.
         m_addrman.Connected(node.addr);
     }
 
     WITH_LOCK(cs_proofrequest, m_proofrequest.DisconnectedPeer(nodeid));
 
     LogPrint(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid);
 }
 
 PeerRef PeerManagerImpl::GetPeerRef(NodeId id) const {
     LOCK(m_peer_mutex);
     auto it = m_peer_map.find(id);
     return it != m_peer_map.end() ? it->second : nullptr;
 }
 
 PeerRef PeerManagerImpl::RemovePeer(NodeId id) {
     PeerRef ret;
     LOCK(m_peer_mutex);
     auto it = m_peer_map.find(id);
     if (it != m_peer_map.end()) {
         ret = std::move(it->second);
         m_peer_map.erase(it);
     }
     return ret;
 }
 
 bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid,
                                         CNodeStateStats &stats) const {
     {
         LOCK(cs_main);
         const CNodeState *state = State(nodeid);
         if (state == nullptr) {
             return false;
         }
         stats.nSyncHeight = state->pindexBestKnownBlock
                                 ? state->pindexBestKnownBlock->nHeight
                                 : -1;
         stats.nCommonHeight = state->pindexLastCommonBlock
                                   ? state->pindexLastCommonBlock->nHeight
                                   : -1;
         for (const QueuedBlock &queue : state->vBlocksInFlight) {
             if (queue.pindex) {
                 stats.vHeightInFlight.push_back(queue.pindex->nHeight);
             }
         }
     }
 
     PeerRef peer = GetPeerRef(nodeid);
     if (peer == nullptr) {
         return false;
     }
     stats.their_services = peer->m_their_services;
     stats.m_starting_height = peer->m_starting_height;
     // It is common for nodes with good ping times to suddenly become lagged,
     // due to a new block arriving or other large transfer.
     // Merely reporting pingtime might fool the caller into thinking the node
     // was still responsive, since pingtime does not update until the ping is
     // complete, which might take a while. So, if a ping is taking an unusually
     // long time in flight, the caller can immediately detect that this is
     // happening.
     auto ping_wait{0us};
     if ((0 != peer->m_ping_nonce_sent) &&
         (0 != peer->m_ping_start.load().count())) {
         ping_wait =
             GetTime<std::chrono::microseconds>() - peer->m_ping_start.load();
     }
 
     if (auto tx_relay = peer->GetTxRelay()) {
         stats.m_relay_txs = WITH_LOCK(tx_relay->m_bloom_filter_mutex,
                                       return tx_relay->m_relay_txs);
         stats.m_fee_filter_received = tx_relay->m_fee_filter_received.load();
     } else {
         stats.m_relay_txs = false;
         stats.m_fee_filter_received = Amount::zero();
     }
 
     stats.m_ping_wait = ping_wait;
     stats.m_addr_processed = peer->m_addr_processed.load();
     stats.m_addr_rate_limited = peer->m_addr_rate_limited.load();
     stats.m_addr_relay_enabled = peer->m_addr_relay_enabled.load();
 
     return true;
 }
 
 void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef &tx) {
     size_t max_extra_txn = gArgs.GetIntArg(
         "-blockreconstructionextratxn", DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN);
     if (max_extra_txn <= 0) {
         return;
     }
 
     if (!vExtraTxnForCompact.size()) {
         vExtraTxnForCompact.resize(max_extra_txn);
     }
 
     vExtraTxnForCompact[vExtraTxnForCompactIt] =
         std::make_pair(tx->GetHash(), tx);
     vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % max_extra_txn;
 }
 
 void PeerManagerImpl::Misbehaving(const NodeId pnode, const int howmuch,
                                   const std::string &message) {
     assert(howmuch > 0);
 
     PeerRef peer = GetPeerRef(pnode);
     if (peer == nullptr) {
         return;
     }
 
     LOCK(peer->m_misbehavior_mutex);
     const int score_before{peer->m_misbehavior_score};
     peer->m_misbehavior_score += howmuch;
     const int score_now{peer->m_misbehavior_score};
 
     const std::string message_prefixed =
         message.empty() ? "" : (": " + message);
     std::string warning;
 
     if (score_now >= DISCOURAGEMENT_THRESHOLD &&
         score_before < DISCOURAGEMENT_THRESHOLD) {
         warning = " DISCOURAGE THRESHOLD EXCEEDED";
         peer->m_should_discourage = true;
     }
 
     LogPrint(BCLog::NET, "Misbehaving: peer=%d (%d -> %d)%s%s\n", pnode,
              score_before, score_now, warning, message_prefixed);
 }
 
 bool PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid,
                                               const BlockValidationState &state,
                                               bool via_compact_block,
                                               const std::string &message) {
     switch (state.GetResult()) {
         case BlockValidationResult::BLOCK_RESULT_UNSET:
             break;
         // The node is providing invalid data:
         case BlockValidationResult::BLOCK_CONSENSUS:
         case BlockValidationResult::BLOCK_MUTATED:
             if (!via_compact_block) {
                 Misbehaving(nodeid, 100, message);
                 return true;
             }
             break;
         case BlockValidationResult::BLOCK_CACHED_INVALID: {
             LOCK(cs_main);
             CNodeState *node_state = State(nodeid);
             if (node_state == nullptr) {
                 break;
             }
 
             // Ban outbound (but not inbound) peers if on an invalid chain.
             // Exempt HB compact block peers. Manual connections are always
             // protected from discouragement.
             if (!via_compact_block && !node_state->m_is_inbound) {
                 Misbehaving(nodeid, 100, message);
                 return true;
             }
             break;
         }
         case BlockValidationResult::BLOCK_INVALID_HEADER:
         case BlockValidationResult::BLOCK_CHECKPOINT:
         case BlockValidationResult::BLOCK_INVALID_PREV:
             Misbehaving(nodeid, 100, message);
             return true;
         case BlockValidationResult::BLOCK_FINALIZATION:
             // TODO: Use the state object to report this is probably not the
             // best idea. This is effectively unreachable, unless there is a bug
             // somewhere.
             Misbehaving(nodeid, 20, message);
             return true;
         // Conflicting (but not necessarily invalid) data or different policy:
         case BlockValidationResult::BLOCK_MISSING_PREV:
             // TODO: Handle this much more gracefully (10 DoS points is super
             // arbitrary)
             Misbehaving(nodeid, 10, message);
             return true;
         case BlockValidationResult::BLOCK_RECENT_CONSENSUS_CHANGE:
         case BlockValidationResult::BLOCK_TIME_FUTURE:
             break;
     }
     if (message != "") {
         LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message);
     }
     return false;
 }
 
 bool PeerManagerImpl::MaybePunishNodeForTx(NodeId nodeid,
                                            const TxValidationState &state,
                                            const std::string &message) {
     switch (state.GetResult()) {
         case TxValidationResult::TX_RESULT_UNSET:
             break;
         // The node is providing invalid data:
         case TxValidationResult::TX_CONSENSUS:
             Misbehaving(nodeid, 100, message);
             return true;
         // Conflicting (but not necessarily invalid) data or different policy:
         case TxValidationResult::TX_RECENT_CONSENSUS_CHANGE:
         case TxValidationResult::TX_INPUTS_NOT_STANDARD:
         case TxValidationResult::TX_NOT_STANDARD:
         case TxValidationResult::TX_MISSING_INPUTS:
         case TxValidationResult::TX_PREMATURE_SPEND:
         case TxValidationResult::TX_CONFLICT:
         case TxValidationResult::TX_MEMPOOL_POLICY:
         case TxValidationResult::TX_NO_MEMPOOL:
             break;
     }
     if (message != "") {
         LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message);
     }
     return false;
 }
 
 bool PeerManagerImpl::BlockRequestAllowed(const CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
     if (m_chainman.ActiveChain().Contains(pindex)) {
         return true;
     }
     return pindex->IsValid(BlockValidity::SCRIPTS) &&
            (m_chainman.m_best_header != nullptr) &&
            (m_chainman.m_best_header->GetBlockTime() - pindex->GetBlockTime() <
             STALE_RELAY_AGE_LIMIT) &&
            (GetBlockProofEquivalentTime(
                 *m_chainman.m_best_header, *pindex, *m_chainman.m_best_header,
                 m_chainparams.GetConsensus()) < STALE_RELAY_AGE_LIMIT);
 }
 
 std::optional<std::string>
 PeerManagerImpl::FetchBlock(const Config &config, NodeId peer_id,
                             const CBlockIndex &block_index) {
     if (fImporting) {
         return "Importing...";
     }
     if (fReindex) {
         return "Reindexing...";
     }
 
     LOCK(cs_main);
     // Ensure this peer exists and hasn't been disconnected
     CNodeState *state = State(peer_id);
     if (state == nullptr) {
         return "Peer does not exist";
     }
     // Mark block as in-flight unless it already is (for this peer).
     // If a block was already in-flight for a different peer, its BLOCKTXN
     // response will be dropped.
     if (!BlockRequested(config, peer_id, block_index)) {
         return "Already requested from this peer";
     }
 
     // Construct message to request the block
     const BlockHash &hash{block_index.GetBlockHash()};
     const std::vector<CInv> invs{CInv(MSG_BLOCK, hash)};
 
     // Send block request message to the peer
     if (!m_connman.ForNode(peer_id, [this, &invs](CNode *node) {
             const CNetMsgMaker msgMaker(node->GetCommonVersion());
             this->m_connman.PushMessage(
                 node, msgMaker.Make(NetMsgType::GETDATA, invs));
             return true;
         })) {
         return "Node not fully connected";
     }
 
     LogPrint(BCLog::NET, "Requesting block %s from peer=%d\n", hash.ToString(),
              peer_id);
     return std::nullopt;
 }
 
 std::unique_ptr<PeerManager> PeerManager::make(CConnman &connman,
                                                AddrMan &addrman, BanMan *banman,
                                                ChainstateManager &chainman,
                                                CTxMemPool &pool,
                                                bool ignore_incoming_txs) {
     return std::make_unique<PeerManagerImpl>(connman, addrman, banman, chainman,
                                              pool, ignore_incoming_txs);
 }
 
 PeerManagerImpl::PeerManagerImpl(CConnman &connman, AddrMan &addrman,
                                  BanMan *banman, ChainstateManager &chainman,
                                  CTxMemPool &pool, bool ignore_incoming_txs)
     : m_chainparams(chainman.GetParams()), m_connman(connman),
       m_addrman(addrman), m_banman(banman), m_chainman(chainman),
       m_mempool(pool), m_ignore_incoming_txs(ignore_incoming_txs) {}
 
 void PeerManagerImpl::StartScheduledTasks(CScheduler &scheduler) {
     // Stale tip checking and peer eviction are on two different timers, but we
     // don't want them to get out of sync due to drift in the scheduler, so we
     // combine them in one function and schedule at the quicker (peer-eviction)
     // timer.
     static_assert(
         EXTRA_PEER_CHECK_INTERVAL < STALE_CHECK_INTERVAL,
         "peer eviction timer should be less than stale tip check timer");
     scheduler.scheduleEvery(
         [this]() {
             this->CheckForStaleTipAndEvictPeers();
             return true;
         },
         std::chrono::seconds{EXTRA_PEER_CHECK_INTERVAL});
 
     // schedule next run for 10-15 minutes in the future
     const auto reattemptBroadcastInterval = 10min + GetRandMillis(5min);
     scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); },
                               reattemptBroadcastInterval);
 
     // Update the avalanche statistics on a schedule
     scheduler.scheduleEvery(
         [this]() {
             UpdateAvalancheStatistics();
             return true;
         },
         AVALANCHE_STATISTICS_REFRESH_PERIOD);
 
     // schedule next run for 2-5 minutes in the future
     const auto avalanchePeriodicNetworkingInterval = 2min + GetRandMillis(3min);
     scheduler.scheduleFromNow([&] { AvalanchePeriodicNetworking(scheduler); },
                               avalanchePeriodicNetworkingInterval);
 }
 
 /**
  * Evict orphan txn pool entries based on a newly connected
  * block, remember the recently confirmed transactions, and delete tracked
  * announcements for them. Also save the time of the last tip update.
  */
 void PeerManagerImpl::BlockConnected(
     const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex) {
     m_orphanage.EraseForBlock(*pblock);
     m_last_tip_update = GetTime<std::chrono::seconds>();
 
     {
         LOCK(m_recent_confirmed_transactions_mutex);
         for (const CTransactionRef &ptx : pblock->vtx) {
             m_recent_confirmed_transactions.insert(ptx->GetId());
         }
     }
     {
         LOCK(cs_main);
         for (const auto &ptx : pblock->vtx) {
             m_txrequest.ForgetInvId(ptx->GetId());
         }
     }
 }
 
 void PeerManagerImpl::BlockDisconnected(
     const std::shared_ptr<const CBlock> &block, const CBlockIndex *pindex) {
     // To avoid relay problems with transactions that were previously
     // confirmed, clear our filter of recently confirmed transactions whenever
     // there's a reorg.
     // This means that in a 1-block reorg (where 1 block is disconnected and
     // then another block reconnected), our filter will drop to having only one
     // block's worth of transactions in it, but that should be fine, since
     // presumably the most common case of relaying a confirmed transaction
     // should be just after a new block containing it is found.
     LOCK(m_recent_confirmed_transactions_mutex);
     m_recent_confirmed_transactions.reset();
 }
 
 /**
  * Maintain state about the best-seen block and fast-announce a compact block
  * to compatible peers.
  */
 void PeerManagerImpl::NewPoWValidBlock(
     const CBlockIndex *pindex, const std::shared_ptr<const CBlock> &pblock) {
     std::shared_ptr<const CBlockHeaderAndShortTxIDs> pcmpctblock =
         std::make_shared<const CBlockHeaderAndShortTxIDs>(*pblock);
     const CNetMsgMaker msgMaker(PROTOCOL_VERSION);
 
     LOCK(cs_main);
 
     if (pindex->nHeight <= m_highest_fast_announce) {
         return;
     }
     m_highest_fast_announce = pindex->nHeight;
 
     BlockHash hashBlock(pblock->GetHash());
     const std::shared_future<CSerializedNetMsg> lazy_ser{
         std::async(std::launch::deferred, [&] {
             return msgMaker.Make(NetMsgType::CMPCTBLOCK, *pcmpctblock);
         })};
 
     {
         LOCK(m_most_recent_block_mutex);
         m_most_recent_block_hash = hashBlock;
         m_most_recent_block = pblock;
         m_most_recent_compact_block = pcmpctblock;
     }
 
     m_connman.ForEachNode(
         [this, pindex, &lazy_ser, &hashBlock](CNode *pnode)
             EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
                 AssertLockHeld(::cs_main);
 
                 if (pnode->GetCommonVersion() < INVALID_CB_NO_BAN_VERSION ||
                     pnode->fDisconnect) {
                     return;
                 }
                 ProcessBlockAvailability(pnode->GetId());
                 CNodeState &state = *State(pnode->GetId());
                 // If the peer has, or we announced to them the previous block
                 // already, but we don't think they have this one, go ahead and
                 // announce it.
                 if (state.m_requested_hb_cmpctblocks &&
                     !PeerHasHeader(&state, pindex) &&
                     PeerHasHeader(&state, pindex->pprev)) {
                     LogPrint(BCLog::NET,
                              "%s sending header-and-ids %s to peer=%d\n",
                              "PeerManager::NewPoWValidBlock",
                              hashBlock.ToString(), pnode->GetId());
 
                     const CSerializedNetMsg &ser_cmpctblock{lazy_ser.get()};
                     m_connman.PushMessage(
                         pnode, CSerializedNetMsg{ser_cmpctblock.data,
                                                  ser_cmpctblock.m_type});
                     state.pindexBestHeaderSent = pindex;
                 }
             });
 }
 
 /**
  * Update our best height and announce any block hashes which weren't previously
  * in m_chainman.ActiveChain() to our peers.
  */
 void PeerManagerImpl::UpdatedBlockTip(const CBlockIndex *pindexNew,
                                       const CBlockIndex *pindexFork,
                                       bool fInitialDownload) {
     SetBestHeight(pindexNew->nHeight);
     SetServiceFlagsIBDCache(!fInitialDownload);
 
     // Don't relay inventory during initial block download.
     if (fInitialDownload) {
         return;
     }
 
     // Find the hashes of all blocks that weren't previously in the best chain.
     std::vector<BlockHash> vHashes;
     const CBlockIndex *pindexToAnnounce = pindexNew;
     while (pindexToAnnounce != pindexFork) {
         vHashes.push_back(pindexToAnnounce->GetBlockHash());
         pindexToAnnounce = pindexToAnnounce->pprev;
         if (vHashes.size() == MAX_BLOCKS_TO_ANNOUNCE) {
             // Limit announcements in case of a huge reorganization. Rely on the
             // peer's synchronization mechanism in that case.
             break;
         }
     }
 
     {
         LOCK(m_peer_mutex);
         for (auto &it : m_peer_map) {
             Peer &peer = *it.second;
             LOCK(peer.m_block_inv_mutex);
             for (const BlockHash &hash : reverse_iterate(vHashes)) {
                 peer.m_blocks_for_headers_relay.push_back(hash);
             }
         }
     }
 
     m_connman.WakeMessageHandler();
 }
 
 /**
  * Handle invalid block rejection and consequent peer banning, maintain which
  * peers announce compact blocks.
  */
 void PeerManagerImpl::BlockChecked(const CBlock &block,
                                    const BlockValidationState &state) {
     LOCK(cs_main);
 
     const BlockHash hash = block.GetHash();
     std::map<BlockHash, std::pair<NodeId, bool>>::iterator it =
         mapBlockSource.find(hash);
 
     // If the block failed validation, we know where it came from and we're
     // still connected to that peer, maybe punish.
     if (state.IsInvalid() && it != mapBlockSource.end() &&
         State(it->second.first)) {
         MaybePunishNodeForBlock(/*nodeid=*/it->second.first, state,
                                 /*via_compact_block=*/!it->second.second);
     }
     // Check that:
     // 1. The block is valid
     // 2. We're not in initial block download
     // 3. This is currently the best block we're aware of. We haven't updated
     //    the tip yet so we have no way to check this directly here. Instead we
     //    just check that there are currently no other blocks in flight.
     else if (state.IsValid() &&
              !m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
              mapBlocksInFlight.count(hash) == mapBlocksInFlight.size()) {
         if (it != mapBlockSource.end()) {
             MaybeSetPeerAsAnnouncingHeaderAndIDs(it->second.first);
         }
     }
 
     if (it != mapBlockSource.end()) {
         mapBlockSource.erase(it);
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Messages
 //
 
 bool PeerManagerImpl::AlreadyHaveTx(const TxId &txid) {
     if (m_chainman.ActiveChain().Tip()->GetBlockHash() !=
         hashRecentRejectsChainTip) {
         // If the chain tip has changed previously rejected transactions
         // might be now valid, e.g. due to a nLockTime'd tx becoming
         // valid, or a double-spend. Reset the rejects filter and give
         // those txs a second chance.
         hashRecentRejectsChainTip =
             m_chainman.ActiveChain().Tip()->GetBlockHash();
         m_recent_rejects.reset();
     }
 
     if (m_orphanage.HaveTx(txid)) {
         return true;
     }
 
     {
         LOCK(m_recent_confirmed_transactions_mutex);
         if (m_recent_confirmed_transactions.contains(txid)) {
             return true;
         }
     }
 
     return m_recent_rejects.contains(txid) || m_mempool.exists(txid);
 }
 
 bool PeerManagerImpl::AlreadyHaveBlock(const BlockHash &block_hash) {
     return m_chainman.m_blockman.LookupBlockIndex(block_hash) != nullptr;
 }
 
 bool PeerManagerImpl::AlreadyHaveProof(const avalanche::ProofId &proofid) {
     assert(g_avalanche);
 
     auto localProof = g_avalanche->getLocalProof();
     if (localProof && localProof->getId() == proofid) {
         return true;
     }
 
     return g_avalanche->withPeerManager([&proofid](avalanche::PeerManager &pm) {
         return pm.exists(proofid) || pm.isInvalid(proofid);
     });
 }
 
 void PeerManagerImpl::SendPings() {
     LOCK(m_peer_mutex);
     for (auto &it : m_peer_map) {
         it.second->m_ping_queued = true;
     }
 }
 
 void PeerManagerImpl::RelayTransaction(const TxId &txid) {
     LOCK(m_peer_mutex);
     for (auto &it : m_peer_map) {
         Peer &peer = *it.second;
         auto tx_relay = peer.GetTxRelay();
         if (!tx_relay) {
             continue;
         }
         LOCK(tx_relay->m_tx_inventory_mutex);
         if (!tx_relay->m_tx_inventory_known_filter.contains(txid)) {
             tx_relay->m_tx_inventory_to_send.insert(txid);
         }
     }
 }
 
 void PeerManagerImpl::RelayProof(const avalanche::ProofId &proofid) {
     LOCK(m_peer_mutex);
     for (auto &it : m_peer_map) {
         Peer &peer = *it.second;
 
         if (!peer.m_proof_relay) {
             continue;
         }
         LOCK(peer.m_proof_relay->m_proof_inventory_mutex);
         if (!peer.m_proof_relay->m_proof_inventory_known_filter.contains(
                 proofid)) {
             peer.m_proof_relay->m_proof_inventory_to_send.insert(proofid);
         }
     }
 }
 
 void PeerManagerImpl::RelayAddress(NodeId originator, const CAddress &addr,
                                    bool fReachable) {
     // We choose the same nodes within a given 24h window (if the list of
     // connected nodes does not change) and we don't relay to nodes that already
     // know an address. So within 24h we will likely relay a given address once.
     // This is to prevent a peer from unjustly giving their address better
     // propagation by sending it to us repeatedly.
 
     if (!fReachable && !addr.IsRelayable()) {
         return;
     }
 
     // Relay to a limited number of other nodes
     // Use deterministic randomness to send to the same nodes for 24 hours
     // at a time so the m_addr_knowns of the chosen nodes prevent repeats
     const uint64_t hash_addr{CServiceHash(0, 0)(addr)};
     const auto current_time{GetTime<std::chrono::seconds>()};
     // Adding address hash makes exact rotation time different per address,
     // while preserving periodicity.
     const uint64_t time_addr{
         (static_cast<uint64_t>(count_seconds(current_time)) + hash_addr) /
         count_seconds(ROTATE_ADDR_RELAY_DEST_INTERVAL)};
 
     const CSipHasher hasher{
         m_connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY)
             .Write(hash_addr)
             .Write(time_addr)};
     FastRandomContext insecure_rand;
 
     // Relay reachable addresses to 2 peers. Unreachable addresses are relayed
     // randomly to 1 or 2 peers.
     unsigned int nRelayNodes = (fReachable || (hasher.Finalize() & 1)) ? 2 : 1;
     std::array<std::pair<uint64_t, Peer *>, 2> best{
         {{0, nullptr}, {0, nullptr}}};
     assert(nRelayNodes <= best.size());
 
     LOCK(m_peer_mutex);
 
     for (auto &[id, peer] : m_peer_map) {
         if (peer->m_addr_relay_enabled && id != originator &&
             IsAddrCompatible(*peer, addr)) {
             uint64_t hashKey = CSipHasher(hasher).Write(id).Finalize();
             for (unsigned int i = 0; i < nRelayNodes; i++) {
                 if (hashKey > best[i].first) {
                     std::copy(best.begin() + i, best.begin() + nRelayNodes - 1,
                               best.begin() + i + 1);
                     best[i] = std::make_pair(hashKey, peer.get());
                     break;
                 }
             }
         }
     };
 
     for (unsigned int i = 0; i < nRelayNodes && best[i].first != 0; i++) {
         PushAddress(*best[i].second, addr, insecure_rand);
     }
 }
 
 void PeerManagerImpl::ProcessGetBlockData(const Config &config, CNode &pfrom,
                                           Peer &peer, const CInv &inv) {
     const BlockHash hash(inv.hash);
 
     std::shared_ptr<const CBlock> a_recent_block;
     std::shared_ptr<const CBlockHeaderAndShortTxIDs> a_recent_compact_block;
     {
         LOCK(m_most_recent_block_mutex);
         a_recent_block = m_most_recent_block;
         a_recent_compact_block = m_most_recent_compact_block;
     }
 
     bool need_activate_chain = false;
     {
         LOCK(cs_main);
         const CBlockIndex *pindex =
             m_chainman.m_blockman.LookupBlockIndex(hash);
         if (pindex) {
             if (pindex->HaveTxsDownloaded() &&
                 !pindex->IsValid(BlockValidity::SCRIPTS) &&
                 pindex->IsValid(BlockValidity::TREE)) {
                 // If we have the block and all of its parents, but have not yet
                 // validated it, we might be in the middle of connecting it (ie
                 // in the unlock of cs_main before ActivateBestChain but after
                 // AcceptBlock). In this case, we need to run ActivateBestChain
                 // prior to checking the relay conditions below.
                 need_activate_chain = true;
             }
         }
     } // release cs_main before calling ActivateBestChain
     if (need_activate_chain) {
         BlockValidationState state;
         if (!m_chainman.ActiveChainstate().ActivateBestChain(config, state,
                                                              a_recent_block)) {
             LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
                      state.ToString());
         }
     }
 
     LOCK(cs_main);
     const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash);
     if (!pindex) {
         return;
     }
     if (!BlockRequestAllowed(pindex)) {
         LogPrint(BCLog::NET,
                  "%s: ignoring request from peer=%i for old "
                  "block that isn't in the main chain\n",
                  __func__, pfrom.GetId());
         return;
     }
     const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
     // Disconnect node in case we have reached the outbound limit for serving
     // historical blocks.
     if (m_connman.OutboundTargetReached(true) &&
         (((m_chainman.m_best_header != nullptr) &&
           (m_chainman.m_best_header->GetBlockTime() - pindex->GetBlockTime() >
            HISTORICAL_BLOCK_AGE)) ||
          inv.IsMsgFilteredBlk()) &&
         // nodes with the download permission may exceed target
         !pfrom.HasPermission(NetPermissionFlags::Download)) {
         LogPrint(BCLog::NET,
                  "historical block serving limit reached, disconnect peer=%d\n",
                  pfrom.GetId());
         pfrom.fDisconnect = true;
         return;
     }
     // Avoid leaking prune-height by never sending blocks below the
     // NODE_NETWORK_LIMITED threshold.
     // Add two blocks buffer extension for possible races
     if (!pfrom.HasPermission(NetPermissionFlags::NoBan) &&
         ((((peer.m_our_services & NODE_NETWORK_LIMITED) ==
            NODE_NETWORK_LIMITED) &&
           ((peer.m_our_services & NODE_NETWORK) != NODE_NETWORK) &&
           (m_chainman.ActiveChain().Tip()->nHeight - pindex->nHeight >
            (int)NODE_NETWORK_LIMITED_MIN_BLOCKS + 2)))) {
         LogPrint(BCLog::NET,
                  "Ignore block request below NODE_NETWORK_LIMITED "
                  "threshold, disconnect peer=%d\n",
                  pfrom.GetId());
 
         // disconnect node and prevent it from stalling (would otherwise wait
         // for the missing block)
         pfrom.fDisconnect = true;
         return;
     }
     // Pruned nodes may have deleted the block, so check whether it's available
     // before trying to send.
     if (!pindex->nStatus.hasData()) {
         return;
     }
     std::shared_ptr<const CBlock> pblock;
     if (a_recent_block && a_recent_block->GetHash() == pindex->GetBlockHash()) {
         pblock = a_recent_block;
     } else {
         // Send block from disk
         std::shared_ptr<CBlock> pblockRead = std::make_shared<CBlock>();
         if (!ReadBlockFromDisk(*pblockRead, pindex,
                                m_chainparams.GetConsensus())) {
             assert(!"cannot load block from disk");
         }
         pblock = pblockRead;
     }
     if (inv.IsMsgBlk()) {
         m_connman.PushMessage(&pfrom,
                               msgMaker.Make(NetMsgType::BLOCK, *pblock));
     } else if (inv.IsMsgFilteredBlk()) {
         bool sendMerkleBlock = false;
         CMerkleBlock merkleBlock;
         if (auto tx_relay = peer.GetTxRelay()) {
             LOCK(tx_relay->m_bloom_filter_mutex);
             if (tx_relay->m_bloom_filter) {
                 sendMerkleBlock = true;
                 merkleBlock = CMerkleBlock(*pblock, *tx_relay->m_bloom_filter);
             }
         }
         if (sendMerkleBlock) {
             m_connman.PushMessage(
                 &pfrom, msgMaker.Make(NetMsgType::MERKLEBLOCK, merkleBlock));
             // CMerkleBlock just contains hashes, so also push any
             // transactions in the block the client did not see. This avoids
             // hurting performance by pointlessly requiring a round-trip.
             // Note that there is currently no way for a node to request any
             // single transactions we didn't send here - they must either
             // disconnect and retry or request the full block. Thus, the
             // protocol spec specified allows for us to provide duplicate
             // txn here, however we MUST always provide at least what the
             // remote peer needs.
             typedef std::pair<size_t, uint256> PairType;
             for (PairType &pair : merkleBlock.vMatchedTxn) {
                 m_connman.PushMessage(
                     &pfrom,
                     msgMaker.Make(NetMsgType::TX, *pblock->vtx[pair.first]));
             }
         }
         // else
         // no response
     } else if (inv.IsMsgCmpctBlk()) {
         // If a peer is asking for old blocks, we're almost guaranteed they
         // won't have a useful mempool to match against a compact block, and
         // we don't feel like constructing the object for them, so instead
         // we respond with the full, non-compact block.
         int nSendFlags = 0;
         if (CanDirectFetch() &&
             pindex->nHeight >=
                 m_chainman.ActiveChain().Height() - MAX_CMPCTBLOCK_DEPTH) {
             CBlockHeaderAndShortTxIDs cmpctblock(*pblock);
             m_connman.PushMessage(
                 &pfrom,
                 msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, cmpctblock));
         } else {
             m_connman.PushMessage(
                 &pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCK, *pblock));
         }
     }
 
     {
         LOCK(peer.m_block_inv_mutex);
         // Trigger the peer node to send a getblocks request for the next
         // batch of inventory.
         if (hash == peer.m_continuation_block) {
             // Send immediately. This must send even if redundant, and
             // we want it right after the last block so they don't wait for
             // other stuff first.
             std::vector<CInv> vInv;
             vInv.push_back(CInv(
                 MSG_BLOCK, m_chainman.ActiveChain().Tip()->GetBlockHash()));
             m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::INV, vInv));
             peer.m_continuation_block = BlockHash();
         }
     }
 }
 
 CTransactionRef
 PeerManagerImpl::FindTxForGetData(const CNode &peer, const TxId &txid,
                                   const std::chrono::seconds mempool_req,
                                   const std::chrono::seconds now) {
     auto txinfo = m_mempool.info(txid);
     if (txinfo.tx) {
         // If a TX could have been INVed in reply to a MEMPOOL request,
         // or is older than UNCONDITIONAL_RELAY_DELAY, permit the request
         // unconditionally.
         if ((mempool_req.count() && txinfo.m_time <= mempool_req) ||
             txinfo.m_time <= now - UNCONDITIONAL_RELAY_DELAY) {
             return std::move(txinfo.tx);
         }
     }
 
     {
         LOCK(cs_main);
 
         // Otherwise, the transaction must have been announced recently.
         if (State(peer.GetId())->m_recently_announced_invs.contains(txid)) {
             // If it was, it can be relayed from either the mempool...
             if (txinfo.tx) {
                 return std::move(txinfo.tx);
             }
             // ... or the relay pool.
             auto mi = mapRelay.find(txid);
             if (mi != mapRelay.end()) {
                 return mi->second;
             }
         }
     }
 
     return {};
 }
 
 //! Determine whether or not a peer can request a proof, and return it (or
 //! nullptr if not found or not allowed).
 avalanche::ProofRef
 PeerManagerImpl::FindProofForGetData(const CNode &peer,
                                      const avalanche::ProofId &proofid,
                                      const std::chrono::seconds now) {
     avalanche::ProofRef proof;
 
     bool send_unconditionally =
         g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
             return pm.forPeer(proofid, [&](const avalanche::Peer &peer) {
                 proof = peer.proof;
 
                 // If we know that proof for long enough, allow for requesting
                 // it.
                 return peer.registration_time <=
                        now - UNCONDITIONAL_RELAY_DELAY;
             });
         });
 
     if (!proof) {
         // Always send our local proof if it gets requested, assuming it's
         // valid. This will make it easier to bind with peers upon startup where
         // the status of our proof is unknown pending for a block. Note that it
         // still needs to have been announced first (presumably via an avahello
         // message).
         proof = g_avalanche->getLocalProof();
     }
 
     // We don't have this proof
     if (!proof) {
         return avalanche::ProofRef();
     }
 
     if (send_unconditionally) {
         return proof;
     }
 
     // Otherwise, the proofs must have been announced recently.
     LOCK(cs_main);
     if (State(peer.GetId())->m_recently_announced_proofs.contains(proofid)) {
         return proof;
     }
 
     return avalanche::ProofRef();
 }
 
 void PeerManagerImpl::ProcessGetData(
     const Config &config, CNode &pfrom, Peer &peer,
     const std::atomic<bool> &interruptMsgProc) {
     AssertLockNotHeld(cs_main);
 
     auto tx_relay = peer.GetTxRelay();
 
     std::deque<CInv>::iterator it = peer.m_getdata_requests.begin();
     std::vector<CInv> vNotFound;
     const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
 
     const auto now{GetTime<std::chrono::seconds>()};
     // Get last mempool request time
     const auto mempool_req = tx_relay != nullptr
                                  ? tx_relay->m_last_mempool_req.load()
                                  : std::chrono::seconds::min();
 
     // Process as many TX or AVA_PROOF items from the front of the getdata
     // queue as possible, since they're common and it's efficient to batch
     // process them.
     while (it != peer.m_getdata_requests.end()) {
         if (interruptMsgProc) {
             return;
         }
         // The send buffer provides backpressure. If there's no space in
         // the buffer, pause processing until the next call.
         if (pfrom.fPauseSend) {
             break;
         }
 
         const CInv &inv = *it;
 
         if (it->IsMsgProof()) {
             const avalanche::ProofId proofid(inv.hash);
             auto proof = FindProofForGetData(pfrom, proofid, now);
             if (proof) {
                 m_connman.PushMessage(
                     &pfrom, msgMaker.Make(NetMsgType::AVAPROOF, *proof));
                 g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
                     pm.removeUnbroadcastProof(proofid);
                 });
             } else {
                 vNotFound.push_back(inv);
             }
 
             ++it;
             continue;
         }
 
         if (it->IsMsgTx()) {
             if (tx_relay == nullptr) {
                 // Ignore GETDATA requests for transactions from
                 // block-relay-only peers and peers that asked us not to
                 // announce transactions.
                 continue;
             }
 
             const TxId txid(inv.hash);
             CTransactionRef tx =
                 FindTxForGetData(pfrom, txid, mempool_req, now);
             if (tx) {
                 int nSendFlags = 0;
                 m_connman.PushMessage(
                     &pfrom, msgMaker.Make(nSendFlags, NetMsgType::TX, *tx));
                 m_mempool.RemoveUnbroadcastTx(txid);
                 // As we're going to send tx, make sure its unconfirmed parents
                 // are made requestable.
                 std::vector<TxId> parent_ids_to_add;
                 {
                     LOCK(m_mempool.cs);
                     auto txiter = m_mempool.GetIter(tx->GetId());
                     if (txiter) {
                         const CTxMemPoolEntry::Parents &parents =
                             (*txiter)->GetMemPoolParentsConst();
                         parent_ids_to_add.reserve(parents.size());
                         for (const CTxMemPoolEntry &parent : parents) {
                             if (parent.GetTime() >
                                 now - UNCONDITIONAL_RELAY_DELAY) {
                                 parent_ids_to_add.push_back(
                                     parent.GetTx().GetId());
                             }
                         }
                     }
                 }
                 for (const TxId &parent_txid : parent_ids_to_add) {
                     // Relaying a transaction with a recent but unconfirmed
                     // parent.
                     if (WITH_LOCK(tx_relay->m_tx_inventory_mutex,
                                   return !tx_relay->m_tx_inventory_known_filter
                                               .contains(parent_txid))) {
                         LOCK(cs_main);
                         State(pfrom.GetId())
                             ->m_recently_announced_invs.insert(parent_txid);
                     }
                 }
             } else {
                 vNotFound.push_back(inv);
             }
 
             ++it;
             continue;
         }
 
         // It's neither a proof nor a transaction
         break;
     }
 
     // Only process one BLOCK item per call, since they're uncommon and can be
     // expensive to process.
     if (it != peer.m_getdata_requests.end() && !pfrom.fPauseSend) {
         const CInv &inv = *it++;
         if (inv.IsGenBlkMsg()) {
             ProcessGetBlockData(config, pfrom, peer, inv);
         }
         // else: If the first item on the queue is an unknown type, we erase it
         // and continue processing the queue on the next call.
     }
 
     peer.m_getdata_requests.erase(peer.m_getdata_requests.begin(), it);
 
     if (!vNotFound.empty()) {
         // Let the peer know that we didn't find what it asked for, so it
         // doesn't have to wait around forever. SPV clients care about this
         // message: it's needed when they are recursively walking the
         // dependencies of relevant unconfirmed transactions. SPV clients want
         // to do that because they want to know about (and store and rebroadcast
         // and risk analyze) the dependencies of transactions relevant to them,
         // without having to download the entire memory pool. Also, other nodes
         // can use these messages to automatically request a transaction from
         // some other peer that annnounced it, and stop waiting for us to
         // respond. In normal operation, we often send NOTFOUND messages for
         // parents of transactions that we relay; if a peer is missing a parent,
         // they may assume we have them and request the parents from us.
         m_connman.PushMessage(&pfrom,
                               msgMaker.Make(NetMsgType::NOTFOUND, vNotFound));
     }
 }
 
 void PeerManagerImpl::SendBlockTransactions(
     CNode &pfrom, const CBlock &block, const BlockTransactionsRequest &req) {
     BlockTransactions resp(req);
     for (size_t i = 0; i < req.indices.size(); i++) {
         if (req.indices[i] >= block.vtx.size()) {
             Misbehaving(pfrom, 100,
                         "getblocktxn with out-of-bounds tx indices");
             return;
         }
         resp.txn[i] = block.vtx[req.indices[i]];
     }
     LOCK(cs_main);
     const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
     int nSendFlags = 0;
     m_connman.PushMessage(
         &pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCKTXN, resp));
 }
 
 void PeerManagerImpl::ProcessHeadersMessage(
     const Config &config, CNode &pfrom, const Peer &peer,
     const std::vector<CBlockHeader> &headers, bool via_compact_block) {
     const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
     size_t nCount = headers.size();
 
     if (nCount == 0) {
         // Nothing interesting. Stop asking this peers for more headers.
         return;
     }
 
     bool received_new_header = false;
     const CBlockIndex *pindexLast = nullptr;
     {
         LOCK(cs_main);
         CNodeState *nodestate = State(pfrom.GetId());
 
         // If this looks like it could be a block announcement (nCount <
         // MAX_BLOCKS_TO_ANNOUNCE), use special logic for handling headers that
         // don't connect:
         // - Send a getheaders message in response to try to connect the chain.
         // - The peer can send up to MAX_UNCONNECTING_HEADERS in a row that
         // don't connect before giving DoS points
         // - Once a headers message is received that is valid and does connect,
         // nUnconnectingHeaders gets reset back to 0.
         if (!m_chainman.m_blockman.LookupBlockIndex(headers[0].hashPrevBlock) &&
             nCount < MAX_BLOCKS_TO_ANNOUNCE) {
             nodestate->nUnconnectingHeaders++;
             m_connman.PushMessage(
                 &pfrom, msgMaker.Make(NetMsgType::GETHEADERS,
                                       m_chainman.ActiveChain().GetLocator(
                                           m_chainman.m_best_header),
                                       uint256()));
             LogPrint(
                 BCLog::NET,
                 "received header %s: missing prev block %s, sending getheaders "
                 "(%d) to end (peer=%d, nUnconnectingHeaders=%d)\n",
                 headers[0].GetHash().ToString(),
                 headers[0].hashPrevBlock.ToString(),
                 m_chainman.m_best_header->nHeight, pfrom.GetId(),
                 nodestate->nUnconnectingHeaders);
             // Set hashLastUnknownBlock for this peer, so that if we eventually
             // get the headers - even from a different peer - we can use this
             // peer to download.
             UpdateBlockAvailability(pfrom.GetId(), headers.back().GetHash());
 
             if (nodestate->nUnconnectingHeaders % MAX_UNCONNECTING_HEADERS ==
                 0) {
                 // The peer is sending us many headers we can't connect.
                 Misbehaving(pfrom, 20,
                             strprintf("%d non-connecting headers",
                                       nodestate->nUnconnectingHeaders));
             }
             return;
         }
 
         BlockHash hashLastBlock;
         for (const CBlockHeader &header : headers) {
             if (!hashLastBlock.IsNull() &&
                 header.hashPrevBlock != hashLastBlock) {
                 Misbehaving(pfrom, 20, "non-continuous headers sequence");
                 return;
             }
             hashLastBlock = header.GetHash();
         }
 
         // If we don't have the last header, then they'll have given us
         // something new (if these headers are valid).
         if (!m_chainman.m_blockman.LookupBlockIndex(hashLastBlock)) {
             received_new_header = true;
         }
     }
 
     BlockValidationState state;
     if (!m_chainman.ProcessNewBlockHeaders(config, headers, state,
                                            &pindexLast)) {
         if (state.IsInvalid()) {
             MaybePunishNodeForBlock(pfrom.GetId(), state, via_compact_block,
                                     "invalid header received");
             return;
         }
     }
 
     {
         LOCK(cs_main);
         CNodeState *nodestate = State(pfrom.GetId());
         if (nodestate->nUnconnectingHeaders > 0) {
             LogPrint(BCLog::NET,
                      "peer=%d: resetting nUnconnectingHeaders (%d -> 0)\n",
                      pfrom.GetId(), nodestate->nUnconnectingHeaders);
         }
         nodestate->nUnconnectingHeaders = 0;
 
         assert(pindexLast);
         UpdateBlockAvailability(pfrom.GetId(), pindexLast->GetBlockHash());
 
         // From here, pindexBestKnownBlock should be guaranteed to be non-null,
         // because it is set in UpdateBlockAvailability. Some nullptr checks are
         // still present, however, as belt-and-suspenders.
 
         if (received_new_header &&
             pindexLast->nChainWork >
                 m_chainman.ActiveChain().Tip()->nChainWork) {
             nodestate->m_last_block_announcement = GetTime();
         }
 
         if (nCount == MAX_HEADERS_RESULTS) {
             // Headers message had its maximum size; the peer may have more
             // headers.
             // TODO: optimize: if pindexLast is an ancestor of
             // m_chainman.ActiveChain().Tip or m_chainman.m_best_header,
             // continue from there instead.
             LogPrint(
                 BCLog::NET,
                 "more getheaders (%d) to end to peer=%d (startheight:%d)\n",
                 pindexLast->nHeight, pfrom.GetId(), peer.m_starting_height);
             m_connman.PushMessage(
                 &pfrom,
                 msgMaker.Make(NetMsgType::GETHEADERS,
                               m_chainman.ActiveChain().GetLocator(pindexLast),
                               uint256()));
         }
 
         // If this set of headers is valid and ends in a block with at least as
         // much work as our tip, download as much as possible.
         if (CanDirectFetch() && pindexLast->IsValid(BlockValidity::TREE) &&
             m_chainman.ActiveChain().Tip()->nChainWork <=
                 pindexLast->nChainWork) {
             std::vector<const CBlockIndex *> vToFetch;
             const CBlockIndex *pindexWalk = pindexLast;
             // Calculate all the blocks we'd need to switch to pindexLast, up to
             // a limit.
             while (pindexWalk &&
                    !m_chainman.ActiveChain().Contains(pindexWalk) &&
                    vToFetch.size() <= MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
                 if (!pindexWalk->nStatus.hasData() &&
                     !IsBlockRequested(pindexWalk->GetBlockHash())) {
                     // We don't have this block, and it's not yet in flight.
                     vToFetch.push_back(pindexWalk);
                 }
                 pindexWalk = pindexWalk->pprev;
             }
             // If pindexWalk still isn't on our main chain, we're looking at a
             // very large reorg at a time we think we're close to caught up to
             // the main chain -- this shouldn't really happen. Bail out on the
             // direct fetch and rely on parallel download instead.
             if (!m_chainman.ActiveChain().Contains(pindexWalk)) {
                 LogPrint(
                     BCLog::NET, "Large reorg, won't direct fetch to %s (%d)\n",
                     pindexLast->GetBlockHash().ToString(), pindexLast->nHeight);
             } else {
                 std::vector<CInv> vGetData;
                 // Download as much as possible, from earliest to latest.
                 for (const CBlockIndex *pindex : reverse_iterate(vToFetch)) {
                     if (nodestate->nBlocksInFlight >=
                         MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
                         // Can't download any more from this peer
                         break;
                     }
                     vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
                     BlockRequested(config, pfrom.GetId(), *pindex);
                     LogPrint(BCLog::NET, "Requesting block %s from  peer=%d\n",
                              pindex->GetBlockHash().ToString(), pfrom.GetId());
                 }
                 if (vGetData.size() > 1) {
                     LogPrint(BCLog::NET,
                              "Downloading blocks toward %s (%d) via headers "
                              "direct fetch\n",
                              pindexLast->GetBlockHash().ToString(),
                              pindexLast->nHeight);
                 }
                 if (vGetData.size() > 0) {
                     if (!m_ignore_incoming_txs &&
                         nodestate->m_provides_cmpctblocks &&
                         vGetData.size() == 1 && mapBlocksInFlight.size() == 1 &&
                         pindexLast->pprev->IsValid(BlockValidity::CHAIN)) {
                         // In any case, we want to download using a compact
                         // block, not a regular one.
                         vGetData[0] = CInv(MSG_CMPCT_BLOCK, vGetData[0].hash);
                     }
                     m_connman.PushMessage(
                         &pfrom, msgMaker.Make(NetMsgType::GETDATA, vGetData));
                 }
             }
         }
         // If we're in IBD, we want outbound peers that will serve us a useful
         // chain. Disconnect peers that are on chains with insufficient work.
         if (m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
             nCount != MAX_HEADERS_RESULTS) {
             // When nCount < MAX_HEADERS_RESULTS, we know we have no more
             // headers to fetch from this peer.
             if (nodestate->pindexBestKnownBlock &&
                 nodestate->pindexBestKnownBlock->nChainWork <
                     nMinimumChainWork) {
                 // This peer has too little work on their headers chain to help
                 // us sync -- disconnect if it is an outbound disconnection
                 // candidate.
                 // Note: We compare their tip to nMinimumChainWork (rather than
                 // m_chainman.ActiveChain().Tip()) because we won't start block
                 // download until we have a headers chain that has at least
                 // nMinimumChainWork, even if a peer has a chain past our tip,
                 // as an anti-DoS measure.
                 if (pfrom.IsOutboundOrBlockRelayConn()) {
                     LogPrintf("Disconnecting outbound peer %d -- headers "
                               "chain has insufficient work\n",
                               pfrom.GetId());
                     pfrom.fDisconnect = true;
                 }
             }
         }
 
         // If this is an outbound full-relay peer, check to see if we should
         // protect it from the bad/lagging chain logic.
         // Note that outbound block-relay peers are excluded from this
         // protection, and thus always subject to eviction under the bad/lagging
         // chain logic.
         // See ChainSyncTimeoutState.
         if (!pfrom.fDisconnect && pfrom.IsFullOutboundConn() &&
             nodestate->pindexBestKnownBlock != nullptr) {
             if (m_outbound_peers_with_protect_from_disconnect <
                     MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT &&
                 nodestate->pindexBestKnownBlock->nChainWork >=
                     m_chainman.ActiveChain().Tip()->nChainWork &&
                 !nodestate->m_chain_sync.m_protect) {
                 LogPrint(BCLog::NET,
                          "Protecting outbound peer=%d from eviction\n",
                          pfrom.GetId());
                 nodestate->m_chain_sync.m_protect = true;
                 ++m_outbound_peers_with_protect_from_disconnect;
             }
         }
     }
 }
 
 /**
  * Reconsider orphan transactions after a parent has been accepted to the
  * mempool.
  *
  * @param[in,out]  orphan_work_set  The set of orphan transactions to
  *    reconsider. Generally only one orphan will be reconsidered on each call of
  *    this function. This set may be added to if accepting an orphan causes its
  *    children to be reconsidered.
  */
 void PeerManagerImpl::ProcessOrphanTx(const Config &config,
                                       std::set<TxId> &orphan_work_set) {
     AssertLockHeld(cs_main);
     AssertLockHeld(g_cs_orphans);
     while (!orphan_work_set.empty()) {
         const TxId orphanTxId = *orphan_work_set.begin();
         orphan_work_set.erase(orphan_work_set.begin());
 
         const auto [porphanTx, from_peer] = m_orphanage.GetTx(orphanTxId);
         if (porphanTx == nullptr) {
             continue;
         }
 
         const MempoolAcceptResult result =
             m_chainman.ProcessTransaction(porphanTx);
         const TxValidationState &state = result.m_state;
         if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
             LogPrint(BCLog::MEMPOOL, "   accepted orphan tx %s\n",
                      orphanTxId.ToString());
             RelayTransaction(orphanTxId);
             m_orphanage.AddChildrenToWorkSet(*porphanTx, orphan_work_set);
             m_orphanage.EraseTx(orphanTxId);
             break;
         } else if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS) {
             if (state.IsInvalid()) {
                 LogPrint(BCLog::MEMPOOL,
                          "   invalid orphan tx %s from peer=%d. %s\n",
                          orphanTxId.ToString(), from_peer, state.ToString());
                 // Punish peer that gave us an invalid orphan tx
                 MaybePunishNodeForTx(from_peer, state);
             }
             // Has inputs but not accepted to mempool
             // Probably non-standard or insufficient fee
             LogPrint(BCLog::MEMPOOL, "   removed orphan tx %s\n",
                      orphanTxId.ToString());
 
             m_recent_rejects.insert(orphanTxId);
 
             m_orphanage.EraseTx(orphanTxId);
             break;
         }
     }
 }
 
 bool PeerManagerImpl::PrepareBlockFilterRequest(
     CNode &node, Peer &peer, BlockFilterType filter_type, uint32_t start_height,
     const BlockHash &stop_hash, uint32_t max_height_diff,
     const CBlockIndex *&stop_index, BlockFilterIndex *&filter_index) {
     const bool supported_filter_type =
         (filter_type == BlockFilterType::BASIC &&
          (peer.m_our_services & NODE_COMPACT_FILTERS));
     if (!supported_filter_type) {
         LogPrint(BCLog::NET,
                  "peer %d requested unsupported block filter type: %d\n",
                  node.GetId(), static_cast<uint8_t>(filter_type));
         node.fDisconnect = true;
         return false;
     }
 
     {
         LOCK(cs_main);
         stop_index = m_chainman.m_blockman.LookupBlockIndex(stop_hash);
 
         // Check that the stop block exists and the peer would be allowed to
         // fetch it.
         if (!stop_index || !BlockRequestAllowed(stop_index)) {
             LogPrint(BCLog::NET, "peer %d requested invalid block hash: %s\n",
                      node.GetId(), stop_hash.ToString());
             node.fDisconnect = true;
             return false;
         }
     }
 
     uint32_t stop_height = stop_index->nHeight;
     if (start_height > stop_height) {
         LogPrint(
             BCLog::NET,
             "peer %d sent invalid getcfilters/getcfheaders with " /* Continued
                                                                    */
             "start height %d and stop height %d\n",
             node.GetId(), start_height, stop_height);
         node.fDisconnect = true;
         return false;
     }
     if (stop_height - start_height >= max_height_diff) {
         LogPrint(BCLog::NET,
                  "peer %d requested too many cfilters/cfheaders: %d / %d\n",
                  node.GetId(), stop_height - start_height + 1, max_height_diff);
         node.fDisconnect = true;
         return false;
     }
 
     filter_index = GetBlockFilterIndex(filter_type);
     if (!filter_index) {
         LogPrint(BCLog::NET, "Filter index for supported type %s not found\n",
                  BlockFilterTypeName(filter_type));
         return false;
     }
 
     return true;
 }
 
 void PeerManagerImpl::ProcessGetCFilters(CNode &node, Peer &peer,
                                          CDataStream &vRecv) {
     uint8_t filter_type_ser;
     uint32_t start_height;
     BlockHash stop_hash;
 
     vRecv >> filter_type_ser >> start_height >> stop_hash;
 
     const BlockFilterType filter_type =
         static_cast<BlockFilterType>(filter_type_ser);
 
     const CBlockIndex *stop_index;
     BlockFilterIndex *filter_index;
     if (!PrepareBlockFilterRequest(node, peer, filter_type, start_height,
                                    stop_hash, MAX_GETCFILTERS_SIZE, stop_index,
                                    filter_index)) {
         return;
     }
 
     std::vector<BlockFilter> filters;
     if (!filter_index->LookupFilterRange(start_height, stop_index, filters)) {
         LogPrint(BCLog::NET,
                  "Failed to find block filter in index: filter_type=%s, "
                  "start_height=%d, stop_hash=%s\n",
                  BlockFilterTypeName(filter_type), start_height,
                  stop_hash.ToString());
         return;
     }
 
     for (const auto &filter : filters) {
         CSerializedNetMsg msg = CNetMsgMaker(node.GetCommonVersion())
                                     .Make(NetMsgType::CFILTER, filter);
         m_connman.PushMessage(&node, std::move(msg));
     }
 }
 
 void PeerManagerImpl::ProcessGetCFHeaders(CNode &node, Peer &peer,
                                           CDataStream &vRecv) {
     uint8_t filter_type_ser;
     uint32_t start_height;
     BlockHash stop_hash;
 
     vRecv >> filter_type_ser >> start_height >> stop_hash;
 
     const BlockFilterType filter_type =
         static_cast<BlockFilterType>(filter_type_ser);
 
     const CBlockIndex *stop_index;
     BlockFilterIndex *filter_index;
     if (!PrepareBlockFilterRequest(node, peer, filter_type, start_height,
                                    stop_hash, MAX_GETCFHEADERS_SIZE, stop_index,
                                    filter_index)) {
         return;
     }
 
     uint256 prev_header;
     if (start_height > 0) {
         const CBlockIndex *const prev_block =
             stop_index->GetAncestor(static_cast<int>(start_height - 1));
         if (!filter_index->LookupFilterHeader(prev_block, prev_header)) {
             LogPrint(BCLog::NET,
                      "Failed to find block filter header in index: "
                      "filter_type=%s, block_hash=%s\n",
                      BlockFilterTypeName(filter_type),
                      prev_block->GetBlockHash().ToString());
             return;
         }
     }
 
     std::vector<uint256> filter_hashes;
     if (!filter_index->LookupFilterHashRange(start_height, stop_index,
                                              filter_hashes)) {
         LogPrint(BCLog::NET,
                  "Failed to find block filter hashes in index: filter_type=%s, "
                  "start_height=%d, stop_hash=%s\n",
                  BlockFilterTypeName(filter_type), start_height,
                  stop_hash.ToString());
         return;
     }
 
     CSerializedNetMsg msg =
         CNetMsgMaker(node.GetCommonVersion())
             .Make(NetMsgType::CFHEADERS, filter_type_ser,
                   stop_index->GetBlockHash(), prev_header, filter_hashes);
     m_connman.PushMessage(&node, std::move(msg));
 }
 
 void PeerManagerImpl::ProcessGetCFCheckPt(CNode &node, Peer &peer,
                                           CDataStream &vRecv) {
     uint8_t filter_type_ser;
     BlockHash stop_hash;
 
     vRecv >> filter_type_ser >> stop_hash;
 
     const BlockFilterType filter_type =
         static_cast<BlockFilterType>(filter_type_ser);
 
     const CBlockIndex *stop_index;
     BlockFilterIndex *filter_index;
     if (!PrepareBlockFilterRequest(
             node, peer, filter_type, /*start_height=*/0, stop_hash,
             /*max_height_diff=*/std::numeric_limits<uint32_t>::max(),
             stop_index, filter_index)) {
         return;
     }
 
     std::vector<uint256> headers(stop_index->nHeight / CFCHECKPT_INTERVAL);
 
     // Populate headers.
     const CBlockIndex *block_index = stop_index;
     for (int i = headers.size() - 1; i >= 0; i--) {
         int height = (i + 1) * CFCHECKPT_INTERVAL;
         block_index = block_index->GetAncestor(height);
 
         if (!filter_index->LookupFilterHeader(block_index, headers[i])) {
             LogPrint(BCLog::NET,
                      "Failed to find block filter header in index: "
                      "filter_type=%s, block_hash=%s\n",
                      BlockFilterTypeName(filter_type),
                      block_index->GetBlockHash().ToString());
             return;
         }
     }
 
     CSerializedNetMsg msg = CNetMsgMaker(node.GetCommonVersion())
                                 .Make(NetMsgType::CFCHECKPT, filter_type_ser,
                                       stop_index->GetBlockHash(), headers);
     m_connman.PushMessage(&node, std::move(msg));
 }
 
 bool IsAvalancheMessageType(const std::string &msg_type) {
     return msg_type == NetMsgType::AVAHELLO ||
            msg_type == NetMsgType::AVAPOLL ||
            msg_type == NetMsgType::AVARESPONSE ||
            msg_type == NetMsgType::AVAPROOF ||
            msg_type == NetMsgType::GETAVAADDR ||
            msg_type == NetMsgType::GETAVAPROOFS ||
            msg_type == NetMsgType::AVAPROOFS ||
            msg_type == NetMsgType::AVAPROOFSREQ;
 }
 
 uint32_t
 PeerManagerImpl::GetAvalancheVoteForBlock(const BlockHash &hash) const {
     AssertLockHeld(cs_main);
 
     const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash);
 
     // Unknown block.
     if (!pindex) {
         return -1;
     }
 
     // Invalid block
     if (pindex->nStatus.isInvalid()) {
         return 1;
     }
 
     // Parked block
     if (pindex->nStatus.isOnParkedChain()) {
         return 2;
     }
 
     const CBlockIndex *pindexTip = m_chainman.ActiveChain().Tip();
     const CBlockIndex *pindexFork = LastCommonAncestor(pindex, pindexTip);
 
     // Active block.
     if (pindex == pindexFork) {
         return 0;
     }
 
     // Fork block.
     if (pindexFork != pindexTip) {
         return 3;
     }
 
     // Missing block data.
     if (!pindex->nStatus.hasData()) {
         return -2;
     }
 
     // This block is built on top of the tip, we have the data, it
     // is pending connection or rejection.
     return -3;
 };
 
 uint32_t PeerManagerImpl::GetAvalancheVoteForTx(const TxId &id) const {
     // Accepted in mempool, or in a recent block
     if (m_mempool.exists(id) ||
         WITH_LOCK(m_recent_confirmed_transactions_mutex,
                   return m_recent_confirmed_transactions.contains(id))) {
         return 0;
     }
 
     // Invalid tx
     if (m_recent_rejects.contains(id)) {
         return 1;
     }
 
     // Orphan tx
     if (m_orphanage.HaveTx(id)) {
         return 2;
     }
 
     // Unknown tx
     return -1;
 };
 
 /**
  * Decide a response for an Avalanche poll about the given proof.
  *
  * @param[in] id   The id of the proof being polled for
  * @return         Our current vote for the proof
  */
 static uint32_t getAvalancheVoteForProof(const avalanche::ProofId &id) {
     assert(g_avalanche);
 
     return g_avalanche->withPeerManager([&id](avalanche::PeerManager &pm) {
         // Rejected proof
         if (pm.isInvalid(id)) {
             return 1;
         }
 
         // The proof is actively bound to a peer
         if (pm.isBoundToPeer(id)) {
             return 0;
         }
 
         // Unknown proof
         if (!pm.exists(id)) {
             return -1;
         }
 
         // Immature proof
         if (pm.isImmature(id)) {
             return 2;
         }
 
         // Not immature, but in conflict with an actively bound proof
         if (pm.isInConflictingPool(id)) {
             return 3;
         }
 
         // The proof is known, not rejected, not immature, not a conflict, but
         // for some reason unbound. This should not happen if the above pools
         // are managed correctly, but added for robustness.
         return -2;
     });
 };
 
 void PeerManagerImpl::ProcessBlock(const Config &config, CNode &node,
                                    const std::shared_ptr<const CBlock> &block,
                                    bool force_processing) {
     bool new_block{false};
     m_chainman.ProcessNewBlock(config, block, force_processing, &new_block);
     if (new_block) {
         node.m_last_block_time = GetTime<std::chrono::seconds>();
     } else {
         LOCK(cs_main);
         mapBlockSource.erase(block->GetHash());
     }
 }
 
 void PeerManagerImpl::ProcessMessage(
     const Config &config, CNode &pfrom, const std::string &msg_type,
     CDataStream &vRecv, const std::chrono::microseconds time_received,
     const std::atomic<bool> &interruptMsgProc) {
     LogPrint(BCLog::NETDEBUG, "received: %s (%u bytes) peer=%d\n",
              SanitizeString(msg_type), vRecv.size(), pfrom.GetId());
 
     PeerRef peer = GetPeerRef(pfrom.GetId());
     if (peer == nullptr) {
         return;
     }
 
     if (IsAvalancheMessageType(msg_type)) {
         if (!g_avalanche) {
             LogPrint(BCLog::AVALANCHE,
                      "Avalanche is not initialized, ignoring %s message\n",
                      msg_type);
             return;
         }
 
         if (!isAvalancheEnabled(gArgs)) {
             // If avalanche is not enabled, ignore avalanche messages
             return;
         }
     }
 
     if (msg_type == NetMsgType::VERSION) {
         // Each connection can only send one version message
         if (pfrom.nVersion != 0) {
             Misbehaving(pfrom, 1, "redundant version message");
             return;
         }
 
         int64_t nTime;
         CService addrMe;
         uint64_t nNonce = 1;
         ServiceFlags nServices;
         int nVersion;
         std::string cleanSubVer;
         int starting_height = -1;
         bool fRelay = true;
         uint64_t nExtraEntropy = 1;
 
         vRecv >> nVersion >> Using<CustomUintFormatter<8>>(nServices) >> nTime;
         if (nTime < 0) {
             nTime = 0;
         }
         // Ignore the addrMe service bits sent by the peer
         vRecv.ignore(8);
         vRecv >> addrMe;
         if (!pfrom.IsInboundConn()) {
             m_addrman.SetServices(pfrom.addr, nServices);
         }
         if (pfrom.ExpectServicesFromConn() &&
             !HasAllDesirableServiceFlags(nServices)) {
             LogPrint(BCLog::NET,
                      "peer=%d does not offer the expected services "
                      "(%08x offered, %08x expected); disconnecting\n",
                      pfrom.GetId(), nServices,
                      GetDesirableServiceFlags(nServices));
             pfrom.fDisconnect = true;
             return;
         }
 
         if (pfrom.IsAvalancheOutboundConnection() &&
             !(nServices & NODE_AVALANCHE)) {
             LogPrint(
                 BCLog::AVALANCHE,
                 "peer=%d does not offer the avalanche service; disconnecting\n",
                 pfrom.GetId());
             pfrom.fDisconnect = true;
             return;
         }
 
         if (nVersion < MIN_PEER_PROTO_VERSION) {
             // disconnect from peers older than this proto version
             LogPrint(BCLog::NET,
                      "peer=%d using obsolete version %i; disconnecting\n",
                      pfrom.GetId(), nVersion);
             pfrom.fDisconnect = true;
             return;
         }
 
         if (!vRecv.empty()) {
             // The version message includes information about the sending node
             // which we don't use:
             //   - 8 bytes (service bits)
             //   - 16 bytes (ipv6 address)
             //   - 2 bytes (port)
             vRecv.ignore(26);
             vRecv >> nNonce;
         }
         if (!vRecv.empty()) {
             std::string strSubVer;
             vRecv >> LIMITED_STRING(strSubVer, MAX_SUBVERSION_LENGTH);
             cleanSubVer = SanitizeString(strSubVer);
         }
         if (!vRecv.empty()) {
             vRecv >> starting_height;
         }
         if (!vRecv.empty()) {
             vRecv >> fRelay;
         }
         if (!vRecv.empty()) {
             vRecv >> nExtraEntropy;
         }
         // Disconnect if we connected to ourself
         if (pfrom.IsInboundConn() && !m_connman.CheckIncomingNonce(nNonce)) {
             LogPrintf("connected to self at %s, disconnecting\n",
                       pfrom.addr.ToString());
             pfrom.fDisconnect = true;
             return;
         }
 
         if (pfrom.IsInboundConn() && addrMe.IsRoutable()) {
             SeenLocal(addrMe);
         }
 
         // Inbound peers send us their version message when they connect.
         // We send our version message in response.
         if (pfrom.IsInboundConn()) {
             PushNodeVersion(config, pfrom, *peer);
         }
 
         // Change version
         const int greatest_common_version =
             std::min(nVersion, PROTOCOL_VERSION);
         pfrom.SetCommonVersion(greatest_common_version);
         pfrom.nVersion = nVersion;
 
         const CNetMsgMaker msg_maker(greatest_common_version);
 
         m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::VERACK));
 
         // Signal ADDRv2 support (BIP155).
         m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::SENDADDRV2));
 
         pfrom.m_has_all_wanted_services =
             HasAllDesirableServiceFlags(nServices);
         peer->m_their_services = nServices;
         pfrom.SetAddrLocal(addrMe);
         {
             LOCK(pfrom.m_subver_mutex);
             pfrom.cleanSubVer = cleanSubVer;
         }
         peer->m_starting_height = starting_height;
 
         // We only initialize the m_tx_relay data structure if:
         // - this isn't an outbound block-relay-only connection; and
         // - fRelay=true or we're offering NODE_BLOOM to this peer
         //   (NODE_BLOOM means that the peer may turn on tx relay later)
         if (!pfrom.IsBlockOnlyConn() &&
             (fRelay || (peer->m_our_services & NODE_BLOOM))) {
             auto *const tx_relay = peer->SetTxRelay();
             {
                 LOCK(tx_relay->m_bloom_filter_mutex);
                 // set to true after we get the first filter* message
                 tx_relay->m_relay_txs = fRelay;
             }
             if (fRelay) {
                 pfrom.m_relays_txs = true;
             }
         }
 
         pfrom.nRemoteHostNonce = nNonce;
         pfrom.nRemoteExtraEntropy = nExtraEntropy;
 
         // Potentially mark this peer as a preferred download peer.
         {
             LOCK(cs_main);
             CNodeState *state = State(pfrom.GetId());
             state->fPreferredDownload =
                 (!pfrom.IsInboundConn() ||
                  pfrom.HasPermission(NetPermissionFlags::NoBan)) &&
                 !pfrom.IsAddrFetchConn() && CanServeBlocks(*peer);
             m_num_preferred_download_peers += state->fPreferredDownload;
         }
 
         // Self advertisement & GETADDR logic
         if (!pfrom.IsInboundConn() && SetupAddressRelay(pfrom, *peer)) {
             // For outbound peers, we try to relay our address (so that other
             // nodes can try to find us more quickly, as we have no guarantee
             // that an outbound peer is even aware of how to reach us) and do a
             // one-time address fetch (to help populate/update our addrman). If
             // we're starting up for the first time, our addrman may be pretty
             // empty and no one will know who we are, so these mechanisms are
             // important to help us connect to the network.
             //
             // We skip this for block-relay-only peers. We want to avoid
             // potentially leaking addr information and we do not want to
             // indicate to the peer that we will participate in addr relay.
             if (fListen &&
                 !m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
                 CAddress addr{GetLocalAddress(pfrom.addr), peer->m_our_services,
                               (uint32_t)GetAdjustedTime()};
                 FastRandomContext insecure_rand;
                 if (addr.IsRoutable()) {
                     LogPrint(BCLog::NET,
                              "ProcessMessages: advertising address %s\n",
                              addr.ToString());
                     PushAddress(*peer, addr, insecure_rand);
                 } else if (IsPeerAddrLocalGood(&pfrom)) {
                     // Override just the address with whatever the peer sees us
                     // as. Leave the port in addr as it was returned by
                     // GetLocalAddress() above, as this is an outbound
                     // connection and the peer cannot observe our listening
                     // port.
                     addr.SetIP(addrMe);
                     LogPrint(BCLog::NET,
                              "ProcessMessages: advertising address %s\n",
                              addr.ToString());
                     PushAddress(*peer, addr, insecure_rand);
                 }
             }
 
             // Get recent addresses
             m_connman.PushMessage(&pfrom, CNetMsgMaker(greatest_common_version)
                                               .Make(NetMsgType::GETADDR));
             peer->m_getaddr_sent = true;
             // When requesting a getaddr, accept an additional MAX_ADDR_TO_SEND
             // addresses in response (bypassing the
             // MAX_ADDR_PROCESSING_TOKEN_BUCKET limit).
             WITH_LOCK(peer->m_addr_token_bucket_mutex,
                       peer->m_addr_token_bucket += GetMaxAddrToSend());
         }
 
         if (!pfrom.IsInboundConn()) {
             // For non-inbound connections, we update the addrman to record
             // connection success so that addrman will have an up-to-date
             // notion of which peers are online and available.
             //
             // While we strive to not leak information about block-relay-only
             // connections via the addrman, not moving an address to the tried
             // table is also potentially detrimental because new-table entries
             // are subject to eviction in the event of addrman collisions.  We
             // mitigate the information-leak by never calling
             // AddrMan::Connected() on block-relay-only peers; see
             // FinalizeNode().
             //
             // This moves an address from New to Tried table in Addrman,
             // resolves tried-table collisions, etc.
             m_addrman.Good(pfrom.addr);
         }
 
         std::string remoteAddr;
         if (fLogIPs) {
             remoteAddr = ", peeraddr=" + pfrom.addr.ToString();
         }
 
         LogPrint(BCLog::NET,
                  "receive version message: [%s] %s: version %d, blocks=%d, "
                  "us=%s, txrelay=%d, peer=%d%s\n",
                  pfrom.addr.ToString(), cleanSubVer, pfrom.nVersion,
                  peer->m_starting_height, addrMe.ToString(), fRelay,
                  pfrom.GetId(), remoteAddr);
 
         int64_t currentTime = GetTime();
         int64_t nTimeOffset = nTime - currentTime;
         pfrom.nTimeOffset = nTimeOffset;
         if (nTime < int64_t(m_chainparams.GenesisBlock().nTime)) {
             // Ignore time offsets that are improbable (before the Genesis
             // block) and may underflow our adjusted time.
             Misbehaving(pfrom, 20,
                         "Ignoring invalid timestamp in version message");
         } else if (!pfrom.IsInboundConn()) {
             // Don't use timedata samples from inbound peers to make it
             // harder for others to tamper with our adjusted time.
             AddTimeData(pfrom.addr, nTimeOffset);
         }
 
         // Feeler connections exist only to verify if address is online.
         if (pfrom.IsFeelerConn()) {
             LogPrint(BCLog::NET,
                      "feeler connection completed peer=%d; disconnecting\n",
                      pfrom.GetId());
             pfrom.fDisconnect = true;
         }
         return;
     }
 
     if (pfrom.nVersion == 0) {
         // Must have a version message before anything else
         Misbehaving(pfrom, 10, "non-version message before version handshake");
         return;
     }
 
     // At this point, the outgoing message serialization version can't change.
     const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
 
     if (msg_type == NetMsgType::VERACK) {
         if (pfrom.fSuccessfullyConnected) {
             LogPrint(BCLog::NET,
                      "ignoring redundant verack message from peer=%d\n",
                      pfrom.GetId());
             return;
         }
 
         if (!pfrom.IsInboundConn()) {
             LogPrintf(
                 "New outbound peer connected: version: %d, blocks=%d, "
                 "peer=%d%s (%s)\n",
                 pfrom.nVersion.load(), peer->m_starting_height, pfrom.GetId(),
                 (fLogIPs ? strprintf(", peeraddr=%s", pfrom.addr.ToString())
                          : ""),
                 pfrom.ConnectionTypeAsString());
         }
 
         if (pfrom.GetCommonVersion() >= SENDHEADERS_VERSION) {
             // Tell our peer we prefer to receive headers rather than inv's
             // We send this to non-NODE NETWORK peers as well, because even
             // non-NODE NETWORK peers can announce blocks (such as pruning
             // nodes)
             m_connman.PushMessage(&pfrom,
                                   msgMaker.Make(NetMsgType::SENDHEADERS));
         }
 
         if (pfrom.GetCommonVersion() >= SHORT_IDS_BLOCKS_VERSION) {
             // Tell our peer we are willing to provide version 1
             // cmpctblocks. However, we do not request new block announcements
             // using cmpctblock messages. We send this to non-NODE NETWORK peers
             // as well, because they may wish to request compact blocks from us.
             m_connman.PushMessage(
                 &pfrom,
                 msgMaker.Make(NetMsgType::SENDCMPCT, /*high_bandwidth=*/false,
                               /*version=*/CMPCTBLOCKS_VERSION));
         }
 
         if (g_avalanche && isAvalancheEnabled(gArgs)) {
             if (g_avalanche->sendHello(&pfrom)) {
                 auto localProof = g_avalanche->getLocalProof();
 
                 if (localProof) {
                     AddKnownProof(*peer, localProof->getId());
                     // Add our proof id to the list or the recently announced
                     // proof INVs to this peer. This is used for filtering which
                     // INV can be requested for download.
                     LOCK(cs_main);
                     State(pfrom.GetId())
                         ->m_recently_announced_proofs.insert(
                             localProof->getId());
                 }
             }
         }
 
         pfrom.fSuccessfullyConnected = true;
         return;
     }
 
     if (!pfrom.fSuccessfullyConnected) {
         // Must have a verack message before anything else
         Misbehaving(pfrom, 10, "non-verack message before version handshake");
         return;
     }
 
     if (msg_type == NetMsgType::ADDR || msg_type == NetMsgType::ADDRV2) {
         int stream_version = vRecv.GetVersion();
         if (msg_type == NetMsgType::ADDRV2) {
             // Add ADDRV2_FORMAT to the version so that the CNetAddr and
             // CAddress unserialize methods know that an address in v2 format is
             // coming.
             stream_version |= ADDRV2_FORMAT;
         }
 
         OverrideStream<CDataStream> s(&vRecv, vRecv.GetType(), stream_version);
         std::vector<CAddress> vAddr;
 
         s >> vAddr;
 
         if (!SetupAddressRelay(pfrom, *peer)) {
             LogPrint(BCLog::NET, "ignoring %s message from %s peer=%d\n",
                      msg_type, pfrom.ConnectionTypeAsString(), pfrom.GetId());
             return;
         }
 
         if (vAddr.size() > GetMaxAddrToSend()) {
             Misbehaving(
                 pfrom, 20,
                 strprintf("%s message size = %u", msg_type, vAddr.size()));
             return;
         }
 
         // Store the new addresses
         std::vector<CAddress> vAddrOk;
         int64_t nNow = GetAdjustedTime();
         int64_t nSince = nNow - 10 * 60;
 
         // Update/increment addr rate limiting bucket.
         const auto current_time = GetTime<std::chrono::microseconds>();
         {
             LOCK(peer->m_addr_token_bucket_mutex);
             if (peer->m_addr_token_bucket < MAX_ADDR_PROCESSING_TOKEN_BUCKET) {
                 // Don't increment bucket if it's already full
                 const auto time_diff =
                     std::max(current_time - peer->m_addr_token_timestamp, 0us);
                 const double increment =
                     CountSecondsDouble(time_diff) * MAX_ADDR_RATE_PER_SECOND;
                 peer->m_addr_token_bucket =
                     std::min<double>(peer->m_addr_token_bucket + increment,
                                      MAX_ADDR_PROCESSING_TOKEN_BUCKET);
             }
         }
         peer->m_addr_token_timestamp = current_time;
 
         const bool rate_limited =
             !pfrom.HasPermission(NetPermissionFlags::Addr);
         uint64_t num_proc = 0;
         uint64_t num_rate_limit = 0;
         Shuffle(vAddr.begin(), vAddr.end(), FastRandomContext());
         for (CAddress &addr : vAddr) {
             if (interruptMsgProc) {
                 return;
             }
 
             {
                 LOCK(peer->m_addr_token_bucket_mutex);
                 // Apply rate limiting.
                 if (peer->m_addr_token_bucket < 1.0) {
                     if (rate_limited) {
                         ++num_rate_limit;
                         continue;
                     }
                 } else {
                     peer->m_addr_token_bucket -= 1.0;
                 }
             }
 
             // We only bother storing full nodes, though this may include things
             // which we would not make an outbound connection to, in part
             // because we may make feeler connections to them.
             if (!MayHaveUsefulAddressDB(addr.nServices) &&
                 !HasAllDesirableServiceFlags(addr.nServices)) {
                 continue;
             }
 
             if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60) {
                 addr.nTime = nNow - 5 * 24 * 60 * 60;
             }
             AddAddressKnown(*peer, addr);
             if (m_banman &&
                 (m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr))) {
                 // Do not process banned/discouraged addresses beyond
                 // remembering we received them
                 continue;
             }
             ++num_proc;
             bool fReachable = IsReachable(addr);
             if (addr.nTime > nSince && !peer->m_getaddr_sent &&
                 vAddr.size() <= 10 && addr.IsRoutable()) {
                 // Relay to a limited number of other nodes
                 RelayAddress(pfrom.GetId(), addr, fReachable);
             }
             // Do not store addresses outside our network
             if (fReachable) {
                 vAddrOk.push_back(addr);
             }
         }
         peer->m_addr_processed += num_proc;
         peer->m_addr_rate_limited += num_rate_limit;
         LogPrint(BCLog::NET,
                  "Received addr: %u addresses (%u processed, %u rate-limited) "
                  "from peer=%d\n",
                  vAddr.size(), num_proc, num_rate_limit, pfrom.GetId());
 
         m_addrman.Add(vAddrOk, pfrom.addr, 2 * 60 * 60);
         if (vAddr.size() < 1000) {
             peer->m_getaddr_sent = false;
         }
 
         // AddrFetch: Require multiple addresses to avoid disconnecting on
         // self-announcements
         if (pfrom.IsAddrFetchConn() && vAddr.size() > 1) {
             LogPrint(BCLog::NET,
                      "addrfetch connection completed peer=%d; disconnecting\n",
                      pfrom.GetId());
             pfrom.fDisconnect = true;
         }
         return;
     }
 
     if (msg_type == NetMsgType::SENDADDRV2) {
         peer->m_wants_addrv2 = true;
         return;
     }
 
     if (msg_type == NetMsgType::SENDHEADERS) {
         LOCK(cs_main);
         State(pfrom.GetId())->fPreferHeaders = true;
         return;
     }
 
     if (msg_type == NetMsgType::SENDCMPCT) {
         bool sendcmpct_hb{false};
         uint64_t sendcmpct_version{0};
         vRecv >> sendcmpct_hb >> sendcmpct_version;
 
         if (sendcmpct_version != CMPCTBLOCKS_VERSION) {
             return;
         }
 
         LOCK(cs_main);
         CNodeState *nodestate = State(pfrom.GetId());
         nodestate->m_provides_cmpctblocks = true;
         nodestate->m_requested_hb_cmpctblocks = sendcmpct_hb;
         // save whether peer selects us as BIP152 high-bandwidth peer
         // (receiving sendcmpct(1) signals high-bandwidth,
         // sendcmpct(0) low-bandwidth)
         pfrom.m_bip152_highbandwidth_from = sendcmpct_hb;
         return;
     }
 
     if (msg_type == NetMsgType::INV) {
         std::vector<CInv> vInv;
         vRecv >> vInv;
         if (vInv.size() > MAX_INV_SZ) {
             Misbehaving(pfrom, 20,
                         strprintf("inv message size = %u", vInv.size()));
             return;
         }
 
         // Reject tx INVs when the -blocksonly setting is enabled, or this is a
         // block-relay-only peer
         bool reject_tx_invs{m_ignore_incoming_txs || pfrom.IsBlockOnlyConn()};
 
         // Allow peers with relay permission to send data other than blocks
         // in blocks only mode
         if (pfrom.HasPermission(NetPermissionFlags::Relay)) {
             reject_tx_invs = false;
         }
 
         const auto current_time{GetTime<std::chrono::microseconds>()};
         std::optional<BlockHash> best_block;
 
         auto logInv = [&](const CInv &inv, bool fAlreadyHave) {
             LogPrint(BCLog::NET, "got inv: %s  %s peer=%d\n", inv.ToString(),
                      fAlreadyHave ? "have" : "new", pfrom.GetId());
         };
 
         for (CInv &inv : vInv) {
             if (interruptMsgProc) {
                 return;
             }
 
             if (inv.IsMsgBlk()) {
                 LOCK(cs_main);
                 const bool fAlreadyHave = AlreadyHaveBlock(BlockHash(inv.hash));
                 logInv(inv, fAlreadyHave);
 
                 const BlockHash hash{inv.hash};
                 UpdateBlockAvailability(pfrom.GetId(), hash);
                 if (!fAlreadyHave && !fImporting && !fReindex &&
                     !IsBlockRequested(hash)) {
                     // Headers-first is the primary method of announcement on
                     // the network. If a node fell back to sending blocks by
                     // inv, it's probably for a re-org. The final block hash
                     // provided should be the highest, so send a getheaders and
                     // then fetch the blocks we need to catch up.
                     best_block = std::move(hash);
                 }
 
                 continue;
             }
 
             if (inv.IsMsgProof()) {
                 const avalanche::ProofId proofid(inv.hash);
                 const bool fAlreadyHave = AlreadyHaveProof(proofid);
                 logInv(inv, fAlreadyHave);
                 AddKnownProof(*peer, proofid);
 
                 if (!fAlreadyHave && g_avalanche && isAvalancheEnabled(gArgs) &&
                     !m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
                     const bool preferred = isPreferredDownloadPeer(pfrom);
 
                     LOCK(cs_proofrequest);
                     AddProofAnnouncement(pfrom, proofid, current_time,
                                          preferred);
                 }
                 continue;
             }
 
             if (inv.IsMsgTx()) {
                 LOCK(cs_main);
                 const TxId txid(inv.hash);
                 const bool fAlreadyHave = AlreadyHaveTx(txid);
                 logInv(inv, fAlreadyHave);
 
                 AddKnownTx(*peer, txid);
                 if (reject_tx_invs) {
                     LogPrint(BCLog::NET,
                              "transaction (%s) inv sent in violation of "
                              "protocol, disconnecting peer=%d\n",
                              txid.ToString(), pfrom.GetId());
                     pfrom.fDisconnect = true;
                     return;
                 } else if (!fAlreadyHave && !m_chainman.ActiveChainstate()
                                                  .IsInitialBlockDownload()) {
                     AddTxAnnouncement(pfrom, txid, current_time);
                 }
 
                 continue;
             }
 
             LogPrint(BCLog::NET,
                      "Unknown inv type \"%s\" received from peer=%d\n",
                      inv.ToString(), pfrom.GetId());
         }
 
         if (best_block) {
             LOCK(m_chainman.GetMutex());
             m_connman.PushMessage(
                 &pfrom, msgMaker.Make(NetMsgType::GETHEADERS,
                                       m_chainman.ActiveChain().GetLocator(
                                           m_chainman.m_best_header),
                                       *best_block));
             LogPrint(BCLog::NET, "getheaders (%d) %s to peer=%d\n",
                      m_chainman.m_best_header->nHeight, best_block->ToString(),
                      pfrom.GetId());
         }
 
         return;
     }
 
     if (msg_type == NetMsgType::GETDATA) {
         std::vector<CInv> vInv;
         vRecv >> vInv;
         if (vInv.size() > MAX_INV_SZ) {
             Misbehaving(pfrom, 20,
                         strprintf("getdata message size = %u", vInv.size()));
             return;
         }
 
         LogPrint(BCLog::NET, "received getdata (%u invsz) peer=%d\n",
                  vInv.size(), pfrom.GetId());
 
         if (vInv.size() > 0) {
             LogPrint(BCLog::NET, "received getdata for: %s peer=%d\n",
                      vInv[0].ToString(), pfrom.GetId());
         }
 
         {
             LOCK(peer->m_getdata_requests_mutex);
             peer->m_getdata_requests.insert(peer->m_getdata_requests.end(),
                                             vInv.begin(), vInv.end());
             ProcessGetData(config, pfrom, *peer, interruptMsgProc);
         }
 
         return;
     }
 
     if (msg_type == NetMsgType::GETBLOCKS) {
         CBlockLocator locator;
         uint256 hashStop;
         vRecv >> locator >> hashStop;
 
         if (locator.vHave.size() > MAX_LOCATOR_SZ) {
             LogPrint(BCLog::NET,
                      "getblocks locator size %lld > %d, disconnect peer=%d\n",
                      locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.GetId());
             pfrom.fDisconnect = true;
             return;
         }
 
         // We might have announced the currently-being-connected tip using a
         // compact block, which resulted in the peer sending a getblocks
         // request, which we would otherwise respond to without the new block.
         // To avoid this situation we simply verify that we are on our best
         // known chain now. This is super overkill, but we handle it better
         // for getheaders requests, and there are no known nodes which support
         // compact blocks but still use getblocks to request blocks.
         {
             std::shared_ptr<const CBlock> a_recent_block;
             {
                 LOCK(m_most_recent_block_mutex);
                 a_recent_block = m_most_recent_block;
             }
             BlockValidationState state;
             if (!m_chainman.ActiveChainstate().ActivateBestChain(
                     config, state, a_recent_block)) {
                 LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
                          state.ToString());
             }
         }
 
         LOCK(cs_main);
 
         // Find the last block the caller has in the main chain
         const CBlockIndex *pindex =
             m_chainman.ActiveChainstate().FindForkInGlobalIndex(locator);
 
         // Send the rest of the chain
         if (pindex) {
             pindex = m_chainman.ActiveChain().Next(pindex);
         }
         int nLimit = 500;
         LogPrint(BCLog::NET, "getblocks %d to %s limit %d from peer=%d\n",
                  (pindex ? pindex->nHeight : -1),
                  hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit,
                  pfrom.GetId());
         for (; pindex; pindex = m_chainman.ActiveChain().Next(pindex)) {
             if (pindex->GetBlockHash() == hashStop) {
                 LogPrint(BCLog::NET, "  getblocks stopping at %d %s\n",
                          pindex->nHeight, pindex->GetBlockHash().ToString());
                 break;
             }
             // If pruning, don't inv blocks unless we have on disk and are
             // likely to still have for some reasonable time window (1 hour)
             // that block relay might require.
             const int nPrunedBlocksLikelyToHave =
                 MIN_BLOCKS_TO_KEEP -
                 3600 / m_chainparams.GetConsensus().nPowTargetSpacing;
             if (fPruneMode &&
                 (!pindex->nStatus.hasData() ||
                  pindex->nHeight <= m_chainman.ActiveChain().Tip()->nHeight -
                                         nPrunedBlocksLikelyToHave)) {
                 LogPrint(
                     BCLog::NET,
                     " getblocks stopping, pruned or too old block at %d %s\n",
                     pindex->nHeight, pindex->GetBlockHash().ToString());
                 break;
             }
             WITH_LOCK(
                 peer->m_block_inv_mutex,
                 peer->m_blocks_for_inv_relay.push_back(pindex->GetBlockHash()));
             if (--nLimit <= 0) {
                 // When this block is requested, we'll send an inv that'll
                 // trigger the peer to getblocks the next batch of inventory.
                 LogPrint(BCLog::NET, "  getblocks stopping at limit %d %s\n",
                          pindex->nHeight, pindex->GetBlockHash().ToString());
                 WITH_LOCK(peer->m_block_inv_mutex, {
                     peer->m_continuation_block = pindex->GetBlockHash();
                 });
                 break;
             }
         }
         return;
     }
 
     if (msg_type == NetMsgType::GETBLOCKTXN) {
         BlockTransactionsRequest req;
         vRecv >> req;
 
         std::shared_ptr<const CBlock> recent_block;
         {
             LOCK(m_most_recent_block_mutex);
             if (m_most_recent_block_hash == req.blockhash) {
                 recent_block = m_most_recent_block;
             }
             // Unlock m_most_recent_block_mutex to avoid cs_main lock inversion
         }
         if (recent_block) {
             SendBlockTransactions(pfrom, *recent_block, req);
             return;
         }
 
         {
             LOCK(cs_main);
 
             const CBlockIndex *pindex =
                 m_chainman.m_blockman.LookupBlockIndex(req.blockhash);
             if (!pindex || !pindex->nStatus.hasData()) {
                 LogPrint(
                     BCLog::NET,
                     "Peer %d sent us a getblocktxn for a block we don't have\n",
                     pfrom.GetId());
                 return;
             }
 
             if (pindex->nHeight >=
                 m_chainman.ActiveChain().Height() - MAX_BLOCKTXN_DEPTH) {
                 CBlock block;
                 bool ret = ReadBlockFromDisk(block, pindex,
                                              m_chainparams.GetConsensus());
                 assert(ret);
 
                 SendBlockTransactions(pfrom, block, req);
                 return;
             }
         }
 
         // If an older block is requested (should never happen in practice,
         // but can happen in tests) send a block response instead of a
         // blocktxn response. Sending a full block response instead of a
         // small blocktxn response is preferable in the case where a peer
         // might maliciously send lots of getblocktxn requests to trigger
         // expensive disk reads, because it will require the peer to
         // actually receive all the data read from disk over the network.
         LogPrint(BCLog::NET,
                  "Peer %d sent us a getblocktxn for a block > %i deep\n",
                  pfrom.GetId(), MAX_BLOCKTXN_DEPTH);
         CInv inv;
         inv.type = MSG_BLOCK;
         inv.hash = req.blockhash;
         WITH_LOCK(peer->m_getdata_requests_mutex,
                   peer->m_getdata_requests.push_back(inv));
         // The message processing loop will go around again (without pausing)
         // and we'll respond then (without cs_main)
         return;
     }
 
     if (msg_type == NetMsgType::GETHEADERS) {
         CBlockLocator locator;
         BlockHash hashStop;
         vRecv >> locator >> hashStop;
 
         if (locator.vHave.size() > MAX_LOCATOR_SZ) {
             LogPrint(BCLog::NET,
                      "getheaders locator size %lld > %d, disconnect peer=%d\n",
                      locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.GetId());
             pfrom.fDisconnect = true;
             return;
         }
 
         LOCK(cs_main);
         if (m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
             !pfrom.HasPermission(NetPermissionFlags::Download)) {
             LogPrint(BCLog::NET,
                      "Ignoring getheaders from peer=%d because node is in "
                      "initial block download\n",
                      pfrom.GetId());
             return;
         }
 
         CNodeState *nodestate = State(pfrom.GetId());
         const CBlockIndex *pindex = nullptr;
         if (locator.IsNull()) {
             // If locator is null, return the hashStop block
             pindex = m_chainman.m_blockman.LookupBlockIndex(hashStop);
             if (!pindex) {
                 return;
             }
 
             if (!BlockRequestAllowed(pindex)) {
                 LogPrint(BCLog::NET,
                          "%s: ignoring request from peer=%i for old block "
                          "header that isn't in the main chain\n",
                          __func__, pfrom.GetId());
                 return;
             }
         } else {
             // Find the last block the caller has in the main chain
             pindex =
                 m_chainman.ActiveChainstate().FindForkInGlobalIndex(locator);
             if (pindex) {
                 pindex = m_chainman.ActiveChain().Next(pindex);
             }
         }
 
         // we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx
         // count at the end
         std::vector<CBlock> vHeaders;
         int nLimit = MAX_HEADERS_RESULTS;
         LogPrint(BCLog::NET, "getheaders %d to %s from peer=%d\n",
                  (pindex ? pindex->nHeight : -1),
                  hashStop.IsNull() ? "end" : hashStop.ToString(),
                  pfrom.GetId());
         for (; pindex; pindex = m_chainman.ActiveChain().Next(pindex)) {
             vHeaders.push_back(pindex->GetBlockHeader());
             if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop) {
                 break;
             }
         }
         // pindex can be nullptr either if we sent
         // m_chainman.ActiveChain().Tip() OR if our peer has
         // m_chainman.ActiveChain().Tip() (and thus we are sending an empty
         // headers message). In both cases it's safe to update
         // pindexBestHeaderSent to be our tip.
         //
         // It is important that we simply reset the BestHeaderSent value here,
         // and not max(BestHeaderSent, newHeaderSent). We might have announced
         // the currently-being-connected tip using a compact block, which
         // resulted in the peer sending a headers request, which we respond to
         // without the new block. By resetting the BestHeaderSent, we ensure we
         // will re-announce the new block via headers (or compact blocks again)
         // in the SendMessages logic.
         nodestate->pindexBestHeaderSent =
             pindex ? pindex : m_chainman.ActiveChain().Tip();
         m_connman.PushMessage(&pfrom,
                               msgMaker.Make(NetMsgType::HEADERS, vHeaders));
         return;
     }
 
     if (msg_type == NetMsgType::TX) {
         // Stop processing the transaction early if
         // 1) We are in blocks only mode and peer has no relay permission; OR
         // 2) This peer is a block-relay-only peer
         if ((m_ignore_incoming_txs &&
              !pfrom.HasPermission(NetPermissionFlags::Relay)) ||
             pfrom.IsBlockOnlyConn()) {
             LogPrint(BCLog::NET,
                      "transaction sent in violation of protocol peer=%d\n",
                      pfrom.GetId());
             pfrom.fDisconnect = true;
             return;
         }
 
         CTransactionRef ptx;
         vRecv >> ptx;
         const CTransaction &tx = *ptx;
         const TxId &txid = tx.GetId();
         AddKnownTx(*peer, txid);
 
         LOCK2(cs_main, g_cs_orphans);
 
         m_txrequest.ReceivedResponse(pfrom.GetId(), txid);
 
         if (AlreadyHaveTx(txid)) {
             if (pfrom.HasPermission(NetPermissionFlags::ForceRelay)) {
                 // Always relay transactions received from peers with
                 // forcerelay permission, even if they were already in the
                 // mempool, allowing the node to function as a gateway for
                 // nodes hidden behind it.
                 if (!m_mempool.exists(tx.GetId())) {
                     LogPrintf("Not relaying non-mempool transaction %s from "
                               "forcerelay peer=%d\n",
                               tx.GetId().ToString(), pfrom.GetId());
                 } else {
                     LogPrintf("Force relaying tx %s from peer=%d\n",
                               tx.GetId().ToString(), pfrom.GetId());
                     RelayTransaction(tx.GetId());
                 }
             }
             return;
         }
 
         const MempoolAcceptResult result = m_chainman.ProcessTransaction(ptx);
         const TxValidationState &state = result.m_state;
 
         if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
             // As this version of the transaction was acceptable, we can forget
             // about any requests for it.
             m_txrequest.ForgetInvId(tx.GetId());
             RelayTransaction(tx.GetId());
             m_orphanage.AddChildrenToWorkSet(tx, peer->m_orphan_work_set);
 
             pfrom.m_last_tx_time = GetTime<std::chrono::seconds>();
 
             LogPrint(BCLog::MEMPOOL,
                      "AcceptToMemoryPool: peer=%d: accepted %s "
                      "(poolsz %u txn, %u kB)\n",
                      pfrom.GetId(), tx.GetId().ToString(), m_mempool.size(),
                      m_mempool.DynamicMemoryUsage() / 1000);
 
             // Recursively process any orphan transactions that depended on this
             // one
             ProcessOrphanTx(config, peer->m_orphan_work_set);
         } else if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
             // It may be the case that the orphans parents have all been
             // rejected.
             bool fRejectedParents = false;
 
             // Deduplicate parent txids, so that we don't have to loop over
             // the same parent txid more than once down below.
             std::vector<TxId> unique_parents;
             unique_parents.reserve(tx.vin.size());
             for (const CTxIn &txin : tx.vin) {
                 // We start with all parents, and then remove duplicates below.
                 unique_parents.push_back(txin.prevout.GetTxId());
             }
             std::sort(unique_parents.begin(), unique_parents.end());
             unique_parents.erase(
                 std::unique(unique_parents.begin(), unique_parents.end()),
                 unique_parents.end());
             for (const TxId &parent_txid : unique_parents) {
                 if (m_recent_rejects.contains(parent_txid)) {
                     fRejectedParents = true;
                     break;
                 }
             }
             if (!fRejectedParents) {
                 const auto current_time{GetTime<std::chrono::microseconds>()};
 
                 for (const TxId &parent_txid : unique_parents) {
                     // FIXME: MSG_TX should use a TxHash, not a TxId.
                     AddKnownTx(*peer, parent_txid);
                     if (!AlreadyHaveTx(parent_txid)) {
                         AddTxAnnouncement(pfrom, parent_txid, current_time);
                     }
                 }
 
                 if (m_orphanage.AddTx(ptx, pfrom.GetId())) {
                     AddToCompactExtraTransactions(ptx);
                 }
 
                 // Once added to the orphan pool, a tx is considered
                 // AlreadyHave, and we shouldn't request it anymore.
                 m_txrequest.ForgetInvId(tx.GetId());
 
                 // DoS prevention: do not allow m_orphanage to grow
                 // unbounded (see CVE-2012-3789)
                 unsigned int nMaxOrphanTx = (unsigned int)std::max(
                     int64_t(0),
                     gArgs.GetIntArg("-maxorphantx",
                                     DEFAULT_MAX_ORPHAN_TRANSACTIONS));
                 unsigned int nEvicted = m_orphanage.LimitOrphans(nMaxOrphanTx);
                 if (nEvicted > 0) {
                     LogPrint(BCLog::MEMPOOL,
                              "orphanage overflow, removed %u tx\n", nEvicted);
                 }
             } else {
                 LogPrint(BCLog::MEMPOOL,
                          "not keeping orphan with rejected parents %s\n",
                          tx.GetId().ToString());
                 // We will continue to reject this tx since it has rejected
                 // parents so avoid re-requesting it from other peers.
                 m_recent_rejects.insert(tx.GetId());
                 m_txrequest.ForgetInvId(tx.GetId());
             }
         } else {
             m_recent_rejects.insert(tx.GetId());
             m_txrequest.ForgetInvId(tx.GetId());
 
             if (RecursiveDynamicUsage(*ptx) < 100000) {
                 AddToCompactExtraTransactions(ptx);
             }
         }
 
         // If a tx has been detected by m_recent_rejects, we will have reached
         // this point and the tx will have been ignored. Because we haven't
         // submitted the tx to our mempool, we won't have computed a DoS
         // score for it or determined exactly why we consider it invalid.
         //
         // This means we won't penalize any peer subsequently relaying a DoSy
         // tx (even if we penalized the first peer who gave it to us) because
         // we have to account for m_recent_rejects showing false positives. In
         // other words, we shouldn't penalize a peer if we aren't *sure* they
         // submitted a DoSy tx.
         //
         // Note that m_recent_rejects doesn't just record DoSy or invalid
         // transactions, but any tx not accepted by the mempool, which may be
         // due to node policy (vs. consensus). So we can't blanket penalize a
         // peer simply for relaying a tx that our m_recent_rejects has caught,
         // regardless of false positives.
 
         if (state.IsInvalid()) {
             LogPrint(BCLog::MEMPOOLREJ,
                      "%s from peer=%d was not accepted: %s\n",
                      tx.GetHash().ToString(), pfrom.GetId(), state.ToString());
             MaybePunishNodeForTx(pfrom.GetId(), state);
         }
         return;
     }
 
     if (msg_type == NetMsgType::CMPCTBLOCK) {
         // Ignore cmpctblock received while importing
         if (fImporting || fReindex) {
             LogPrint(BCLog::NET,
                      "Unexpected cmpctblock message received from peer %d\n",
                      pfrom.GetId());
             return;
         }
 
         CBlockHeaderAndShortTxIDs cmpctblock;
         try {
             vRecv >> cmpctblock;
         } catch (std::ios_base::failure &e) {
             // This block has non contiguous or overflowing indexes
             Misbehaving(pfrom, 100, "cmpctblock-bad-indexes");
             return;
         }
 
         bool received_new_header = false;
 
         {
             LOCK(cs_main);
 
             if (!m_chainman.m_blockman.LookupBlockIndex(
                     cmpctblock.header.hashPrevBlock)) {
                 // Doesn't connect (or is genesis), instead of DoSing in
                 // AcceptBlockHeader, request deeper headers
                 if (!m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
                     m_connman.PushMessage(
                         &pfrom,
                         msgMaker.Make(NetMsgType::GETHEADERS,
                                       m_chainman.ActiveChain().GetLocator(
                                           m_chainman.m_best_header),
                                       uint256()));
                 }
                 return;
             }
 
             if (!m_chainman.m_blockman.LookupBlockIndex(
                     cmpctblock.header.GetHash())) {
                 received_new_header = true;
             }
         }
 
         const CBlockIndex *pindex = nullptr;
         BlockValidationState state;
         if (!m_chainman.ProcessNewBlockHeaders(config, {cmpctblock.header},
                                                state, &pindex)) {
             if (state.IsInvalid()) {
                 MaybePunishNodeForBlock(pfrom.GetId(), state,
                                         /*via_compact_block*/ true,
                                         "invalid header via cmpctblock");
                 return;
             }
         }
 
         // When we succeed in decoding a block's txids from a cmpctblock
         // message we typically jump to the BLOCKTXN handling code, with a
         // dummy (empty) BLOCKTXN message, to re-use the logic there in
         // completing processing of the putative block (without cs_main).
         bool fProcessBLOCKTXN = false;
         CDataStream blockTxnMsg(SER_NETWORK, PROTOCOL_VERSION);
 
         // If we end up treating this as a plain headers message, call that as
         // well
         // without cs_main.
         bool fRevertToHeaderProcessing = false;
 
         // Keep a CBlock for "optimistic" compactblock reconstructions (see
         // below)
         std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
         bool fBlockReconstructed = false;
 
         {
             LOCK2(cs_main, g_cs_orphans);
             // If AcceptBlockHeader returned true, it set pindex
             assert(pindex);
             UpdateBlockAvailability(pfrom.GetId(), pindex->GetBlockHash());
 
             CNodeState *nodestate = State(pfrom.GetId());
 
             // If this was a new header with more work than our tip, update the
             // peer's last block announcement time
             if (received_new_header &&
                 pindex->nChainWork >
                     m_chainman.ActiveChain().Tip()->nChainWork) {
                 nodestate->m_last_block_announcement = GetTime();
             }
 
             std::map<BlockHash,
                      std::pair<NodeId, std::list<QueuedBlock>::iterator>>::
                 iterator blockInFlightIt =
                     mapBlocksInFlight.find(pindex->GetBlockHash());
             bool fAlreadyInFlight = blockInFlightIt != mapBlocksInFlight.end();
 
             if (pindex->nStatus.hasData()) {
                 // Nothing to do here
                 return;
             }
 
             if (pindex->nChainWork <=
                     m_chainman.ActiveChain()
                         .Tip()
                         ->nChainWork || // We know something better
                 pindex->nTx != 0) {
                 // We had this block at some point, but pruned it
                 if (fAlreadyInFlight) {
                     // We requested this block for some reason, but our mempool
                     // will probably be useless so we just grab the block via
                     // normal getdata.
                     std::vector<CInv> vInv(1);
                     vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash());
                     m_connman.PushMessage(
                         &pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv));
                 }
                 return;
             }
 
             // If we're not close to tip yet, give up and let parallel block
             // fetch work its magic.
             if (!fAlreadyInFlight && !CanDirectFetch()) {
                 return;
             }
 
             // We want to be a bit conservative just to be extra careful about
             // DoS possibilities in compact block processing...
             if (pindex->nHeight <= m_chainman.ActiveChain().Height() + 2) {
                 if ((!fAlreadyInFlight && nodestate->nBlocksInFlight <
                                               MAX_BLOCKS_IN_TRANSIT_PER_PEER) ||
                     (fAlreadyInFlight &&
                      blockInFlightIt->second.first == pfrom.GetId())) {
                     std::list<QueuedBlock>::iterator *queuedBlockIt = nullptr;
                     if (!BlockRequested(config, pfrom.GetId(), *pindex,
                                         &queuedBlockIt)) {
                         if (!(*queuedBlockIt)->partialBlock) {
                             (*queuedBlockIt)
                                 ->partialBlock.reset(
                                     new PartiallyDownloadedBlock(config,
                                                                  &m_mempool));
                         } else {
                             // The block was already in flight using compact
                             // blocks from the same peer.
                             LogPrint(BCLog::NET, "Peer sent us compact block "
                                                  "we were already syncing!\n");
                             return;
                         }
                     }
 
                     PartiallyDownloadedBlock &partialBlock =
                         *(*queuedBlockIt)->partialBlock;
                     ReadStatus status =
                         partialBlock.InitData(cmpctblock, vExtraTxnForCompact);
                     if (status == READ_STATUS_INVALID) {
                         // Reset in-flight state in case Misbehaving does not
                         // result in a disconnect
                         RemoveBlockRequest(pindex->GetBlockHash());
                         Misbehaving(pfrom, 100, "invalid compact block");
                         return;
                     } else if (status == READ_STATUS_FAILED) {
                         // Duplicate txindices, the block is now in-flight, so
                         // just request it.
                         std::vector<CInv> vInv(1);
                         vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash());
                         m_connman.PushMessage(
                             &pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv));
                         return;
                     }
 
                     BlockTransactionsRequest req;
                     for (size_t i = 0; i < cmpctblock.BlockTxCount(); i++) {
                         if (!partialBlock.IsTxAvailable(i)) {
                             req.indices.push_back(i);
                         }
                     }
                     if (req.indices.empty()) {
                         // Dirty hack to jump to BLOCKTXN code (TODO: move
                         // message handling into their own functions)
                         BlockTransactions txn;
                         txn.blockhash = cmpctblock.header.GetHash();
                         blockTxnMsg << txn;
                         fProcessBLOCKTXN = true;
                     } else {
                         req.blockhash = pindex->GetBlockHash();
                         m_connman.PushMessage(
                             &pfrom,
                             msgMaker.Make(NetMsgType::GETBLOCKTXN, req));
                     }
                 } else {
                     // This block is either already in flight from a different
                     // peer, or this peer has too many blocks outstanding to
                     // download from. Optimistically try to reconstruct anyway
                     // since we might be able to without any round trips.
                     PartiallyDownloadedBlock tempBlock(config, &m_mempool);
                     ReadStatus status =
                         tempBlock.InitData(cmpctblock, vExtraTxnForCompact);
                     if (status != READ_STATUS_OK) {
                         // TODO: don't ignore failures
                         return;
                     }
                     std::vector<CTransactionRef> dummy;
                     status = tempBlock.FillBlock(*pblock, dummy);
                     if (status == READ_STATUS_OK) {
                         fBlockReconstructed = true;
                     }
                 }
             } else {
                 if (fAlreadyInFlight) {
                     // We requested this block, but its far into the future, so
                     // our mempool will probably be useless - request the block
                     // normally.
                     std::vector<CInv> vInv(1);
                     vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash());
                     m_connman.PushMessage(
                         &pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv));
                     return;
                 } else {
                     // If this was an announce-cmpctblock, we want the same
                     // treatment as a header message.
                     fRevertToHeaderProcessing = true;
                 }
             }
         } // cs_main
 
         if (fProcessBLOCKTXN) {
             return ProcessMessage(config, pfrom, NetMsgType::BLOCKTXN,
                                   blockTxnMsg, time_received, interruptMsgProc);
         }
 
         if (fRevertToHeaderProcessing) {
             // Headers received from HB compact block peers are permitted to be
             // relayed before full validation (see BIP 152), so we don't want to
             // disconnect the peer if the header turns out to be for an invalid
             // block. Note that if a peer tries to build on an invalid chain,
             // that will be detected and the peer will be banned.
             return ProcessHeadersMessage(config, pfrom, *peer,
                                          {cmpctblock.header},
                                          /*via_compact_block=*/true);
         }
 
         if (fBlockReconstructed) {
             // If we got here, we were able to optimistically reconstruct a
             // block that is in flight from some other peer.
             {
                 LOCK(cs_main);
                 mapBlockSource.emplace(pblock->GetHash(),
                                        std::make_pair(pfrom.GetId(), false));
             }
             // Setting force_processing to true means that we bypass some of
             // our anti-DoS protections in AcceptBlock, which filters
             // unrequested blocks that might be trying to waste our resources
             // (eg disk space). Because we only try to reconstruct blocks when
             // we're close to caught up (via the CanDirectFetch() requirement
             // above, combined with the behavior of not requesting blocks until
             // we have a chain with at least nMinimumChainWork), and we ignore
             // compact blocks with less work than our tip, it is safe to treat
             // reconstructed compact blocks as having been requested.
             ProcessBlock(config, pfrom, pblock, /*force_processing=*/true);
             // hold cs_main for CBlockIndex::IsValid()
             LOCK(cs_main);
             if (pindex->IsValid(BlockValidity::TRANSACTIONS)) {
                 // Clear download state for this block, which is in process from
                 // some other peer. We do this after calling. ProcessNewBlock so
                 // that a malleated cmpctblock announcement can't be used to
                 // interfere with block relay.
                 RemoveBlockRequest(pblock->GetHash());
             }
         }
         return;
     }
 
     if (msg_type == NetMsgType::BLOCKTXN) {
         // Ignore blocktxn received while importing
         if (fImporting || fReindex) {
             LogPrint(BCLog::NET,
                      "Unexpected blocktxn message received from peer %d\n",
                      pfrom.GetId());
             return;
         }
 
         BlockTransactions resp;
         vRecv >> resp;
 
         std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
         bool fBlockRead = false;
         {
             LOCK(cs_main);
 
             std::map<BlockHash,
                      std::pair<NodeId, std::list<QueuedBlock>::iterator>>::
                 iterator it = mapBlocksInFlight.find(resp.blockhash);
             if (it == mapBlocksInFlight.end() ||
                 !it->second.second->partialBlock ||
                 it->second.first != pfrom.GetId()) {
                 LogPrint(BCLog::NET,
                          "Peer %d sent us block transactions for block "
                          "we weren't expecting\n",
                          pfrom.GetId());
                 return;
             }
 
             PartiallyDownloadedBlock &partialBlock =
                 *it->second.second->partialBlock;
             ReadStatus status = partialBlock.FillBlock(*pblock, resp.txn);
             if (status == READ_STATUS_INVALID) {
                 // Reset in-flight state in case of Misbehaving does not
                 // result in a disconnect.
                 RemoveBlockRequest(resp.blockhash);
                 Misbehaving(
                     pfrom, 100,
                     "invalid compact block/non-matching block transactions");
                 return;
             } else if (status == READ_STATUS_FAILED) {
                 // Might have collided, fall back to getdata now :(
                 std::vector<CInv> invs;
                 invs.push_back(CInv(MSG_BLOCK, resp.blockhash));
                 m_connman.PushMessage(&pfrom,
                                       msgMaker.Make(NetMsgType::GETDATA, invs));
             } else {
                 // Block is either okay, or possibly we received
                 // READ_STATUS_CHECKBLOCK_FAILED.
                 // Note that CheckBlock can only fail for one of a few reasons:
                 // 1. bad-proof-of-work (impossible here, because we've already
                 //    accepted the header)
                 // 2. merkleroot doesn't match the transactions given (already
                 //    caught in FillBlock with READ_STATUS_FAILED, so
                 //    impossible here)
                 // 3. the block is otherwise invalid (eg invalid coinbase,
                 //    block is too big, too many sigChecks, etc).
                 // So if CheckBlock failed, #3 is the only possibility.
                 // Under BIP 152, we don't DoS-ban unless proof of work is
                 // invalid (we don't require all the stateless checks to have
                 // been run). This is handled below, so just treat this as
                 // though the block was successfully read, and rely on the
                 // handling in ProcessNewBlock to ensure the block index is
                 // updated, etc.
 
                 // it is now an empty pointer
                 RemoveBlockRequest(resp.blockhash);
                 fBlockRead = true;
                 // mapBlockSource is used for potentially punishing peers and
                 // updating which peers send us compact blocks, so the race
                 // between here and cs_main in ProcessNewBlock is fine.
                 // BIP 152 permits peers to relay compact blocks after
                 // validating the header only; we should not punish peers
                 // if the block turns out to be invalid.
                 mapBlockSource.emplace(resp.blockhash,
                                        std::make_pair(pfrom.GetId(), false));
             }
         } // Don't hold cs_main when we call into ProcessNewBlock
         if (fBlockRead) {
             // Since we requested this block (it was in mapBlocksInFlight),
             // force it to be processed, even if it would not be a candidate for
             // new tip (missing previous block, chain not long enough, etc)
             // This bypasses some anti-DoS logic in AcceptBlock (eg to prevent
             // disk-space attacks), but this should be safe due to the
             // protections in the compact block handler -- see related comment
             // in compact block optimistic reconstruction handling.
             ProcessBlock(config, pfrom, pblock, /*force_processing=*/true);
         }
         return;
     }
 
     if (msg_type == NetMsgType::HEADERS) {
         // Ignore headers received while importing
         if (fImporting || fReindex) {
             LogPrint(BCLog::NET,
                      "Unexpected headers message received from peer %d\n",
                      pfrom.GetId());
             return;
         }
 
         std::vector<CBlockHeader> headers;
 
         // Bypass the normal CBlock deserialization, as we don't want to risk
         // deserializing 2000 full blocks.
         unsigned int nCount = ReadCompactSize(vRecv);
         if (nCount > MAX_HEADERS_RESULTS) {
             Misbehaving(pfrom, 20,
                         strprintf("too-many-headers: headers message size = %u",
                                   nCount));
             return;
         }
         headers.resize(nCount);
         for (unsigned int n = 0; n < nCount; n++) {
             vRecv >> headers[n];
             // Ignore tx count; assume it is 0.
             ReadCompactSize(vRecv);
         }
 
         return ProcessHeadersMessage(config, pfrom, *peer, headers,
                                      /*via_compact_block=*/false);
     }
 
     if (msg_type == NetMsgType::BLOCK) {
         // Ignore block received while importing
         if (fImporting || fReindex) {
             LogPrint(BCLog::NET,
                      "Unexpected block message received from peer %d\n",
                      pfrom.GetId());
             return;
         }
 
         std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
         vRecv >> *pblock;
 
         LogPrint(BCLog::NET, "received block %s peer=%d\n",
                  pblock->GetHash().ToString(), pfrom.GetId());
 
         // Process all blocks from whitelisted peers, even if not requested,
         // unless we're still syncing with the network. Such an unrequested
         // block may still be processed, subject to the conditions in
         // AcceptBlock().
         bool forceProcessing =
             pfrom.HasPermission(NetPermissionFlags::NoBan) &&
             !m_chainman.ActiveChainstate().IsInitialBlockDownload();
         const BlockHash hash = pblock->GetHash();
         {
             LOCK(cs_main);
             // Always process the block if we requested it, since we may
             // need it even when it's not a candidate for a new best tip.
             forceProcessing = IsBlockRequested(hash);
             RemoveBlockRequest(hash);
             // mapBlockSource is only used for punishing peers and setting
             // which peers send us compact blocks, so the race between here and
             // cs_main in ProcessNewBlock is fine.
             mapBlockSource.emplace(hash, std::make_pair(pfrom.GetId(), true));
         }
         ProcessBlock(config, pfrom, pblock, forceProcessing);
         return;
     }
 
     if (msg_type == NetMsgType::AVAHELLO) {
         {
             LOCK(pfrom.cs_avalanche_pubkey);
             if (pfrom.m_avalanche_pubkey.has_value()) {
                 LogPrint(
                     BCLog::AVALANCHE,
                     "Ignoring avahello from peer %d: already in our node set\n",
                     pfrom.GetId());
                 return;
             }
 
             avalanche::Delegation delegation;
             vRecv >> delegation;
 
             // A delegation with an all zero limited id indicates that the peer
             // has no proof, so we're done.
             if (delegation.getLimitedProofId() != uint256::ZERO) {
                 avalanche::DelegationState state;
                 CPubKey pubkey;
                 if (!delegation.verify(state, pubkey)) {
                     Misbehaving(pfrom, 100, "invalid-delegation");
                     return;
                 }
                 pfrom.m_avalanche_pubkey = std::move(pubkey);
 
                 CHashWriter sighasher(SER_GETHASH, 0);
                 sighasher << delegation.getId();
                 sighasher << pfrom.nRemoteHostNonce;
                 sighasher << pfrom.GetLocalNonce();
                 sighasher << pfrom.nRemoteExtraEntropy;
                 sighasher << pfrom.GetLocalExtraEntropy();
 
                 SchnorrSig sig;
                 vRecv >> sig;
                 if (!(*pfrom.m_avalanche_pubkey)
                          .VerifySchnorr(sighasher.GetHash(), sig)) {
                     Misbehaving(pfrom, 100, "invalid-avahello-signature");
                     return;
                 }
 
                 // If we don't know this proof already, add it to the tracker so
                 // it can be requested.
                 const avalanche::ProofId proofid(delegation.getProofId());
                 if (!AlreadyHaveProof(proofid)) {
                     const bool preferred = isPreferredDownloadPeer(pfrom);
                     LOCK(cs_proofrequest);
                     AddProofAnnouncement(pfrom, proofid,
                                          GetTime<std::chrono::microseconds>(),
                                          preferred);
                 }
 
                 // Don't check the return value. If it fails we probably don't
                 // know about the proof yet.
                 g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
                     return pm.addNode(pfrom.GetId(), proofid);
                 });
             }
 
             pfrom.m_avalanche_enabled = true;
         }
 
         // Send getavaaddr and getavaproofs to our avalanche outbound or
         // manual connections
         if (!pfrom.IsInboundConn()) {
             m_connman.PushMessage(&pfrom,
                                   msgMaker.Make(NetMsgType::GETAVAADDR));
             WITH_LOCK(peer->m_addr_token_bucket_mutex,
                       peer->m_addr_token_bucket += GetMaxAddrToSend());
 
             if (peer->m_proof_relay &&
                 !m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
                 m_connman.PushMessage(&pfrom,
                                       msgMaker.Make(NetMsgType::GETAVAPROOFS));
                 peer->m_proof_relay->compactproofs_requested = true;
             }
         }
 
         return;
     }
 
     if (msg_type == NetMsgType::AVAPOLL) {
         const auto now = Now<SteadyMilliseconds>();
         const int64_t cooldown =
             gArgs.GetIntArg("-avacooldown", AVALANCHE_DEFAULT_COOLDOWN);
 
         const auto last_poll = pfrom.m_last_poll;
         pfrom.m_last_poll = now;
 
         if (now < last_poll + std::chrono::milliseconds(cooldown)) {
             LogPrint(BCLog::AVALANCHE,
                      "Ignoring repeated avapoll from peer %d: cooldown not "
                      "elapsed\n",
                      pfrom.GetId());
             return;
         }
 
         const bool quorum_established =
             g_avalanche && g_avalanche->isQuorumEstablished();
 
         uint64_t round;
         Unserialize(vRecv, round);
 
         unsigned int nCount = ReadCompactSize(vRecv);
         if (nCount > AVALANCHE_MAX_ELEMENT_POLL) {
             Misbehaving(
                 pfrom, 20,
                 strprintf("too-many-ava-poll: poll message size = %u", nCount));
             return;
         }
 
         std::vector<avalanche::Vote> votes;
         votes.reserve(nCount);
 
         for (unsigned int n = 0; n < nCount; n++) {
             CInv inv;
             vRecv >> inv;
 
             // Default vote for unknown inv type
             uint32_t vote = -1;
 
             // We don't vote definitively until we have an established quorum
             if (!quorum_established) {
                 votes.emplace_back(vote, inv.hash);
                 continue;
             }
 
             // If inv's type is known, get a vote for its hash
             switch (inv.type) {
                 case MSG_TX: {
                     if (gArgs.GetBoolArg("-avalanchepreconsensus", false)) {
                         vote = WITH_LOCK(cs_main, return GetAvalancheVoteForTx(
                                                       TxId(inv.hash)));
                     }
                 } break;
                 case MSG_BLOCK: {
                     vote = WITH_LOCK(cs_main, return GetAvalancheVoteForBlock(
                                                   BlockHash(inv.hash)));
                 } break;
                 case MSG_AVA_PROOF: {
                     vote =
                         getAvalancheVoteForProof(avalanche::ProofId(inv.hash));
                 } break;
                 default: {
                     LogPrint(BCLog::AVALANCHE,
                              "poll inv type %d unknown from peer=%d\n",
                              inv.type, pfrom.GetId());
                 }
             }
 
             votes.emplace_back(vote, inv.hash);
         }
 
         // Send the query to the node.
         g_avalanche->sendResponse(
             &pfrom, avalanche::Response(round, cooldown, std::move(votes)));
         return;
     }
 
     if (msg_type == NetMsgType::AVARESPONSE) {
         // As long as QUIC is not implemented, we need to sign response and
         // verify response's signatures in order to avoid any manipulation of
         // messages at the transport level.
         CHashVerifier<CDataStream> verifier(&vRecv);
         avalanche::Response response;
         verifier >> response;
 
         SchnorrSig sig;
         vRecv >> sig;
 
         {
             LOCK(pfrom.cs_avalanche_pubkey);
             if (!pfrom.m_avalanche_pubkey.has_value() ||
                 !(*pfrom.m_avalanche_pubkey)
                      .VerifySchnorr(verifier.GetHash(), sig)) {
                 Misbehaving(pfrom, 100, "invalid-ava-response-signature");
                 return;
             }
         }
 
         auto now = GetTime<std::chrono::seconds>();
 
         std::vector<avalanche::VoteItemUpdate> updates;
         int banscore{0};
         std::string error;
         if (!g_avalanche->registerVotes(pfrom.GetId(), response, updates,
                                         banscore, error)) {
             if (banscore > 0) {
                 // If the banscore was set, just increase the node ban score
                 Misbehaving(pfrom, banscore, error);
                 return;
             }
 
             // Otherwise the node may have got a network issue. Increase the
             // fault counter instead and only ban if we reached a threshold.
             // This allows for fault tolerance should there be a temporary
             // outage while still preventing DoS'ing behaviors, as the counter
             // is reset if no fault occured over some time period.
             pfrom.m_avalanche_message_fault_counter++;
             pfrom.m_avalanche_last_message_fault = now;
 
             // Allow up to 12 messages before increasing the ban score. Since
             // the queries are cleared after 10s, this is at least 2 minutes
             // of network outage tolerance over the 1h window.
             if (pfrom.m_avalanche_message_fault_counter > 12) {
                 Misbehaving(pfrom, 2, error);
                 return;
             }
         }
 
         // If no fault occurred within the last hour, reset the fault counter
         if (now > (pfrom.m_avalanche_last_message_fault.load() + 1h)) {
             pfrom.m_avalanche_message_fault_counter = 0;
         }
 
         pfrom.invsVoted(response.GetVotes().size());
 
         auto logVoteUpdate = [](const auto &voteUpdate,
                                 const std::string &voteItemTypeStr,
                                 const auto &voteItemId) {
             std::string voteOutcome;
             switch (voteUpdate.getStatus()) {
                 case avalanche::VoteStatus::Invalid:
                     voteOutcome = "invalidated";
                     break;
                 case avalanche::VoteStatus::Rejected:
                     voteOutcome = "rejected";
                     break;
                 case avalanche::VoteStatus::Accepted:
                     voteOutcome = "accepted";
                     break;
                 case avalanche::VoteStatus::Finalized:
                     voteOutcome = "finalized";
                     break;
                 case avalanche::VoteStatus::Stale:
                     voteOutcome = "stalled";
                     break;
 
                     // No default case, so the compiler can warn about missing
                     // cases
             }
 
             LogPrint(BCLog::AVALANCHE, "Avalanche %s %s %s\n", voteOutcome,
                      voteItemTypeStr, voteItemId.ToString());
         };
 
         bool shouldActivateBestChain = false;
 
         for (const auto &u : updates) {
             const avalanche::AnyVoteItem &item = u.getVoteItem();
 
             // Don't use a visitor here as we want to ignore unsupported item
             // types. This comes in handy when adding new types.
             if (auto pitem = std::get_if<const avalanche::ProofRef>(&item)) {
                 avalanche::ProofRef proof = *pitem;
                 const avalanche::ProofId &proofid = proof->getId();
 
                 logVoteUpdate(u, "proof", proofid);
 
                 auto rejectionMode =
                     avalanche::PeerManager::RejectionMode::DEFAULT;
                 auto nextCooldownTimePoint = GetTime<std::chrono::seconds>();
                 switch (u.getStatus()) {
                     case avalanche::VoteStatus::Invalid:
                         g_avalanche->withPeerManager(
                             [&](avalanche::PeerManager &pm) {
                                 pm.setInvalid(proofid);
                             });
                         // Fallthrough
                     case avalanche::VoteStatus::Stale:
                         // Invalidate mode removes the proof from all proof
                         // pools
                         rejectionMode =
                             avalanche::PeerManager::RejectionMode::INVALIDATE;
                         // Fallthrough
                     case avalanche::VoteStatus::Rejected:
                         if (!g_avalanche->withPeerManager(
                                 [&](avalanche::PeerManager &pm) {
                                     return pm.rejectProof(proofid,
                                                           rejectionMode);
                                 })) {
                             LogPrint(BCLog::AVALANCHE,
                                      "ERROR: Failed to reject proof: %s\n",
                                      proofid.GetHex());
                         }
                         break;
                     case avalanche::VoteStatus::Finalized:
                         nextCooldownTimePoint +=
                             std::chrono::seconds(gArgs.GetIntArg(
                                 "-avalanchepeerreplacementcooldown",
                                 AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN));
                     case avalanche::VoteStatus::Accepted:
                         if (!g_avalanche->withPeerManager(
                                 [&](avalanche::PeerManager &pm) {
                                     pm.registerProof(
                                         proof,
                                         avalanche::PeerManager::
                                             RegistrationMode::FORCE_ACCEPT);
                                     return pm.forPeer(
                                         proofid,
                                         [&](const avalanche::Peer &peer) {
                                             pm.updateNextPossibleConflictTime(
                                                 peer.peerid,
                                                 nextCooldownTimePoint);
                                             if (u.getStatus() ==
                                                 avalanche::VoteStatus::
                                                     Finalized) {
                                                 pm.setFinalized(peer.peerid);
                                             }
                                             // Only fail if the peer was not
                                             // created
                                             return true;
                                         });
                                 })) {
                             LogPrint(BCLog::AVALANCHE,
                                      "ERROR: Failed to accept proof: %s\n",
                                      proofid.GetHex());
                         }
                         break;
                 }
             }
 
             if (auto pitem = std::get_if<const CBlockIndex *>(&item)) {
                 CBlockIndex *pindex = const_cast<CBlockIndex *>(*pitem);
 
                 shouldActivateBestChain = true;
 
                 logVoteUpdate(u, "block", pindex->GetBlockHash());
 
                 switch (u.getStatus()) {
                     case avalanche::VoteStatus::Invalid:
                     case avalanche::VoteStatus::Rejected: {
                         BlockValidationState state;
                         m_chainman.ActiveChainstate().ParkBlock(config, state,
                                                                 pindex);
                         if (!state.IsValid()) {
                             LogPrintf("ERROR: Database error: %s\n",
                                       state.GetRejectReason());
                             return;
                         }
                     } break;
                     case avalanche::VoteStatus::Accepted: {
                         LOCK(cs_main);
                         m_chainman.ActiveChainstate().UnparkBlock(pindex);
                     } break;
                     case avalanche::VoteStatus::Finalized: {
                         {
                             LOCK(cs_main);
                             m_chainman.ActiveChainstate().UnparkBlock(pindex);
                         }
                         m_chainman.ActiveChainstate().AvalancheFinalizeBlock(
                             pindex);
                     } break;
                     case avalanche::VoteStatus::Stale:
                         // Fall back on Nakamoto consensus in the absence of
                         // Avalanche votes for other competing or descendant
                         // blocks.
                         break;
                 }
             }
         }
 
         if (shouldActivateBestChain) {
             BlockValidationState state;
             if (!m_chainman.ActiveChainstate().ActivateBestChain(config,
                                                                  state)) {
                 LogPrintf("failed to activate chain (%s)\n", state.ToString());
             }
         }
 
         return;
     }
 
     if (msg_type == NetMsgType::AVAPROOF) {
         auto proof = RCUPtr<avalanche::Proof>::make();
         vRecv >> *proof;
 
         ReceivedAvalancheProof(pfrom, *peer, proof);
 
         return;
     }
 
     if (msg_type == NetMsgType::GETAVAPROOFS) {
         if (peer->m_proof_relay == nullptr) {
             return;
         }
 
         peer->m_proof_relay->lastSharedProofsUpdate =
             GetTime<std::chrono::seconds>();
 
         peer->m_proof_relay->sharedProofs =
             g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
                 return pm.getShareableProofsSnapshot();
             });
 
         avalanche::CompactProofs compactProofs(
             peer->m_proof_relay->sharedProofs);
         m_connman.PushMessage(
             &pfrom, msgMaker.Make(NetMsgType::AVAPROOFS, compactProofs));
 
         return;
     }
 
     if (msg_type == NetMsgType::AVAPROOFS) {
         if (peer->m_proof_relay == nullptr) {
             return;
         }
 
         // Only process the compact proofs if we requested them
         if (!peer->m_proof_relay->compactproofs_requested) {
             LogPrint(BCLog::AVALANCHE, "Ignoring unsollicited avaproofs\n");
             return;
         }
         peer->m_proof_relay->compactproofs_requested = false;
 
         avalanche::CompactProofs compactProofs;
         try {
             vRecv >> compactProofs;
         } catch (std::ios_base::failure &e) {
             // This compact proofs have non contiguous or overflowing indexes
             Misbehaving(pfrom, 100, "avaproofs-bad-indexes");
             return;
         }
 
         // If there are prefilled proofs, process them first
         std::set<uint32_t> prefilledIndexes;
         for (const auto &prefilledProof : compactProofs.getPrefilledProofs()) {
             if (!ReceivedAvalancheProof(pfrom, *peer, prefilledProof.proof)) {
                 // If we got an invalid proof, the peer is getting banned and we
                 // can bail out.
                 return;
             }
         }
 
         // If there is no shortid, avoid parsing/responding/accounting for the
         // message.
         if (compactProofs.getShortIDs().size() == 0) {
             LogPrint(BCLog::AVALANCHE,
                      "Got an avaproofs message with no shortid (peer %d)\n",
                      pfrom.GetId());
             return;
         }
 
         // To determine the chance that the number of entries in a bucket
         // exceeds N, we use the fact that the number of elements in a single
         // bucket is binomially distributed (with n = the number of shorttxids
         // S, and p = 1 / the number of buckets), that in the worst case the
         // number of buckets is equal to S (due to std::unordered_map having a
         // default load factor of 1.0), and that the chance for any bucket to
         // exceed N elements is at most buckets * (the chance that any given
         // bucket is above N elements). Thus:
         //   P(max_elements_per_bucket > N) <=
         //     S * (1 - cdf(binomial(n=S,p=1/S), N))
         // If we assume up to 21000000, allowing 15 elements per bucket should
         // only fail once per ~2.5 million avaproofs transfers (per peer and
         // connection).
         // TODO re-evaluate the bucket count to a more realistic value.
         // TODO: In the case of a shortid-collision, we should request all the
         // proofs which collided. For now, we only request one, which is not
         // that bad considering this event is expected to be very rare.
         auto shortIdProcessor =
             avalanche::ProofShortIdProcessor(compactProofs.getPrefilledProofs(),
                                              compactProofs.getShortIDs(), 15);
 
         if (shortIdProcessor.hasOutOfBoundIndex()) {
             // This should be catched by deserialization, but catch it here as
             // well as a good measure.
             Misbehaving(pfrom, 100, "avaproofs-bad-indexes");
             return;
         }
         if (!shortIdProcessor.isEvenlyDistributed()) {
             // This is suspicious, don't ban but bail out
             return;
         }
 
         size_t proofCount = 0;
         std::vector<std::pair<avalanche::ProofId, bool>> remoteProofsStatus;
         g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
             pm.forEachPeer([&](const avalanche::Peer &peer) {
                 assert(peer.proof);
                 uint64_t shortid = compactProofs.getShortID(peer.getProofId());
 
                 int added =
                     shortIdProcessor.matchKnownItem(shortid, peer.proof);
 
                 // No collision
                 if (added >= 0) {
                     // Because we know the proof, we can determine if our peer
                     // has it (added = 1) or not (added = 0) and update the
                     // remote proof status accordingly.
                     remoteProofsStatus.emplace_back(peer.getProofId(),
                                                     added > 0);
                 }
 
                 proofCount += added;
 
                 // In order to properly determine which proof is missing, we
                 // need to keep scanning for all our proofs.
                 return true;
             });
         });
 
         avalanche::ProofsRequest req;
         for (size_t i = 0; i < compactProofs.size(); i++) {
             if (shortIdProcessor.getItem(i) == nullptr) {
                 req.indices.push_back(i);
             }
         }
 
         m_connman.PushMessage(&pfrom,
                               msgMaker.Make(NetMsgType::AVAPROOFSREQ, req));
 
         const NodeId nodeid = pfrom.GetId();
 
         // We want to keep a count of how many nodes we successfully requested
         // avaproofs from as this is used to determine when we are confident our
         // quorum is close enough to the other participants.
         g_avalanche->avaproofsSent(nodeid);
 
         if (pfrom.IsAvalancheOutboundConnection() || pfrom.IsManualConn()) {
             g_avalanche->withPeerManager(
                 [&remoteProofsStatus, nodeid](avalanche::PeerManager &pm) {
                     for (const auto &[proofid, present] : remoteProofsStatus) {
                         pm.saveRemoteProof(proofid, nodeid, present);
                     }
                 });
         }
 
         return;
     }
 
     if (msg_type == NetMsgType::AVAPROOFSREQ) {
         if (peer->m_proof_relay == nullptr) {
             return;
         }
 
         avalanche::ProofsRequest proofreq;
         vRecv >> proofreq;
 
         auto requestedIndiceIt = proofreq.indices.begin();
         uint32_t treeIndice = 0;
         peer->m_proof_relay->sharedProofs.forEachLeaf([&](const auto &proof) {
             if (requestedIndiceIt == proofreq.indices.end()) {
                 // No more indice to process
                 return false;
             }
 
             if (treeIndice++ == *requestedIndiceIt) {
                 m_connman.PushMessage(
                     &pfrom, msgMaker.Make(NetMsgType::AVAPROOF, *proof));
                 requestedIndiceIt++;
             }
 
             return true;
         });
 
         peer->m_proof_relay->sharedProofs = {};
         return;
     }
 
     if (msg_type == NetMsgType::GETADDR) {
         // This asymmetric behavior for inbound and outbound connections was
         // introduced to prevent a fingerprinting attack: an attacker can send
         // specific fake addresses to users' AddrMan and later request them by
         // sending getaddr messages. Making nodes which are behind NAT and can
         // only make outgoing connections ignore the getaddr message mitigates
         // the attack.
         if (!pfrom.IsInboundConn()) {
             LogPrint(BCLog::NET,
                      "Ignoring \"getaddr\" from %s connection. peer=%d\n",
                      pfrom.ConnectionTypeAsString(), pfrom.GetId());
             return;
         }
 
         // Since this must be an inbound connection, SetupAddressRelay will
         // never fail.
         Assume(SetupAddressRelay(pfrom, *peer));
 
         // Only send one GetAddr response per connection to reduce resource
         // waste and discourage addr stamping of INV announcements.
         if (peer->m_getaddr_recvd) {
             LogPrint(BCLog::NET, "Ignoring repeated \"getaddr\". peer=%d\n",
                      pfrom.GetId());
             return;
         }
         peer->m_getaddr_recvd = true;
 
         peer->m_addrs_to_send.clear();
         std::vector<CAddress> vAddr;
         const size_t maxAddrToSend = GetMaxAddrToSend();
         if (pfrom.HasPermission(NetPermissionFlags::Addr)) {
             vAddr = m_connman.GetAddresses(maxAddrToSend, MAX_PCT_ADDR_TO_SEND,
                                            /* network */ std::nullopt);
         } else {
             vAddr = m_connman.GetAddresses(pfrom, maxAddrToSend,
                                            MAX_PCT_ADDR_TO_SEND);
         }
         FastRandomContext insecure_rand;
         for (const CAddress &addr : vAddr) {
             PushAddress(*peer, addr, insecure_rand);
         }
         return;
     }
 
     if (msg_type == NetMsgType::GETAVAADDR) {
         auto now = GetTime<std::chrono::seconds>();
         if (now < pfrom.m_nextGetAvaAddr) {
             // Prevent a peer from exhausting our resources by spamming
             // getavaaddr messages.
             LogPrint(BCLog::AVALANCHE,
                      "Ignoring repeated getavaaddr from peer %d\n",
                      pfrom.GetId());
             return;
         }
 
         // Only accept a getavaaddr every GETAVAADDR_INTERVAL at most
         pfrom.m_nextGetAvaAddr = now + GETAVAADDR_INTERVAL;
 
         if (!SetupAddressRelay(pfrom, *peer)) {
             LogPrint(BCLog::AVALANCHE,
                      "Ignoring getavaaddr message from %s peer=%d\n",
                      pfrom.ConnectionTypeAsString(), pfrom.GetId());
             return;
         }
 
         auto availabilityScoreComparator = [](const CNode *lhs,
                                               const CNode *rhs) {
             double scoreLhs = lhs->getAvailabilityScore();
             double scoreRhs = rhs->getAvailabilityScore();
 
             if (scoreLhs != scoreRhs) {
                 return scoreLhs > scoreRhs;
             }
 
             return lhs < rhs;
         };
 
         // Get up to MAX_ADDR_TO_SEND addresses of the nodes which are the
         // most active in the avalanche network. Account for 0 availability as
         // well so we can send addresses even if we did not start polling yet.
         std::set<const CNode *, decltype(availabilityScoreComparator)> avaNodes(
             availabilityScoreComparator);
         m_connman.ForEachNode([&](const CNode *pnode) {
             if (!pnode->m_avalanche_enabled ||
                 pnode->getAvailabilityScore() < 0.) {
                 return;
             }
 
             avaNodes.insert(pnode);
             if (avaNodes.size() > GetMaxAddrToSend()) {
                 avaNodes.erase(std::prev(avaNodes.end()));
             }
         });
 
         peer->m_addrs_to_send.clear();
         FastRandomContext insecure_rand;
         for (const CNode *pnode : avaNodes) {
             PushAddress(*peer, pnode->addr, insecure_rand);
         }
 
         return;
     }
 
     if (msg_type == NetMsgType::MEMPOOL) {
         if (!(peer->m_our_services & NODE_BLOOM) &&
             !pfrom.HasPermission(NetPermissionFlags::Mempool)) {
             if (!pfrom.HasPermission(NetPermissionFlags::NoBan)) {
                 LogPrint(BCLog::NET,
                          "mempool request with bloom filters disabled, "
                          "disconnect peer=%d\n",
                          pfrom.GetId());
                 pfrom.fDisconnect = true;
             }
             return;
         }
 
         if (m_connman.OutboundTargetReached(false) &&
             !pfrom.HasPermission(NetPermissionFlags::Mempool)) {
             if (!pfrom.HasPermission(NetPermissionFlags::NoBan)) {
                 LogPrint(BCLog::NET,
                          "mempool request with bandwidth limit reached, "
                          "disconnect peer=%d\n",
                          pfrom.GetId());
                 pfrom.fDisconnect = true;
             }
             return;
         }
 
         if (auto tx_relay = peer->GetTxRelay()) {
             LOCK(tx_relay->m_tx_inventory_mutex);
             tx_relay->m_send_mempool = true;
         }
         return;
     }
 
     if (msg_type == NetMsgType::PING) {
         if (pfrom.GetCommonVersion() > BIP0031_VERSION) {
             uint64_t nonce = 0;
             vRecv >> nonce;
             // Echo the message back with the nonce. This allows for two useful
             // features:
             //
             // 1) A remote node can quickly check if the connection is
             // operational.
             // 2) Remote nodes can measure the latency of the network thread. If
             // this node is overloaded it won't respond to pings quickly and the
             // remote node can avoid sending us more work, like chain download
             // requests.
             //
             // The nonce stops the remote getting confused between different
             // pings: without it, if the remote node sends a ping once per
             // second and this node takes 5 seconds to respond to each, the 5th
             // ping the remote sends would appear to return very quickly.
             m_connman.PushMessage(&pfrom,
                                   msgMaker.Make(NetMsgType::PONG, nonce));
         }
         return;
     }
 
     if (msg_type == NetMsgType::PONG) {
         const auto ping_end = time_received;
         uint64_t nonce = 0;
         size_t nAvail = vRecv.in_avail();
         bool bPingFinished = false;
         std::string sProblem;
 
         if (nAvail >= sizeof(nonce)) {
             vRecv >> nonce;
 
             // Only process pong message if there is an outstanding ping (old
             // ping without nonce should never pong)
             if (peer->m_ping_nonce_sent != 0) {
                 if (nonce == peer->m_ping_nonce_sent) {
                     // Matching pong received, this ping is no longer
                     // outstanding
                     bPingFinished = true;
                     const auto ping_time = ping_end - peer->m_ping_start.load();
                     if (ping_time.count() >= 0) {
                         // Let connman know about this successful ping-pong
                         pfrom.PongReceived(ping_time);
                     } else {
                         // This should never happen
                         sProblem = "Timing mishap";
                     }
                 } else {
                     // Nonce mismatches are normal when pings are overlapping
                     sProblem = "Nonce mismatch";
                     if (nonce == 0) {
                         // This is most likely a bug in another implementation
                         // somewhere; cancel this ping
                         bPingFinished = true;
                         sProblem = "Nonce zero";
                     }
                 }
             } else {
                 sProblem = "Unsolicited pong without ping";
             }
         } else {
             // This is most likely a bug in another implementation somewhere;
             // cancel this ping
             bPingFinished = true;
             sProblem = "Short payload";
         }
 
         if (!(sProblem.empty())) {
             LogPrint(BCLog::NET,
                      "pong peer=%d: %s, %x expected, %x received, %u bytes\n",
                      pfrom.GetId(), sProblem, peer->m_ping_nonce_sent, nonce,
                      nAvail);
         }
         if (bPingFinished) {
             peer->m_ping_nonce_sent = 0;
         }
         return;
     }
 
     if (msg_type == NetMsgType::FILTERLOAD) {
         if (!(peer->m_our_services & NODE_BLOOM)) {
             LogPrint(BCLog::NET,
                      "filterload received despite not offering bloom services "
                      "from peer=%d; disconnecting\n",
                      pfrom.GetId());
             pfrom.fDisconnect = true;
             return;
         }
         CBloomFilter filter;
         vRecv >> filter;
 
         if (!filter.IsWithinSizeConstraints()) {
             // There is no excuse for sending a too-large filter
             Misbehaving(pfrom, 100, "too-large bloom filter");
         } else if (auto tx_relay = peer->GetTxRelay()) {
             {
                 LOCK(tx_relay->m_bloom_filter_mutex);
                 tx_relay->m_bloom_filter.reset(new CBloomFilter(filter));
                 tx_relay->m_relay_txs = true;
             }
             pfrom.m_bloom_filter_loaded = true;
         }
         return;
     }
 
     if (msg_type == NetMsgType::FILTERADD) {
         if (!(peer->m_our_services & NODE_BLOOM)) {
             LogPrint(BCLog::NET,
                      "filteradd received despite not offering bloom services "
                      "from peer=%d; disconnecting\n",
                      pfrom.GetId());
             pfrom.fDisconnect = true;
             return;
         }
         std::vector<uint8_t> vData;
         vRecv >> vData;
 
         // Nodes must NEVER send a data item > 520 bytes (the max size for a
         // script data object, and thus, the maximum size any matched object can
         // have) in a filteradd message.
         bool bad = false;
         if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE) {
             bad = true;
         } else if (auto tx_relay = peer->GetTxRelay()) {
             LOCK(tx_relay->m_bloom_filter_mutex);
             if (tx_relay->m_bloom_filter) {
                 tx_relay->m_bloom_filter->insert(vData);
             } else {
                 bad = true;
             }
         }
         if (bad) {
             // The structure of this code doesn't really allow for a good error
             // code. We'll go generic.
             Misbehaving(pfrom, 100, "bad filteradd message");
         }
         return;
     }
 
     if (msg_type == NetMsgType::FILTERCLEAR) {
         if (!(peer->m_our_services & NODE_BLOOM)) {
             LogPrint(BCLog::NET,
                      "filterclear received despite not offering bloom services "
                      "from peer=%d; disconnecting\n",
                      pfrom.GetId());
             pfrom.fDisconnect = true;
             return;
         }
         auto tx_relay = peer->GetTxRelay();
         if (!tx_relay) {
             return;
         }
 
         {
             LOCK(tx_relay->m_bloom_filter_mutex);
             tx_relay->m_bloom_filter = nullptr;
             tx_relay->m_relay_txs = true;
         }
         pfrom.m_bloom_filter_loaded = false;
         pfrom.m_relays_txs = true;
         return;
     }
 
     if (msg_type == NetMsgType::FEEFILTER) {
         Amount newFeeFilter = Amount::zero();
         vRecv >> newFeeFilter;
         if (MoneyRange(newFeeFilter)) {
             if (auto tx_relay = peer->GetTxRelay()) {
                 tx_relay->m_fee_filter_received = newFeeFilter;
             }
             LogPrint(BCLog::NET, "received: feefilter of %s from peer=%d\n",
                      CFeeRate(newFeeFilter).ToString(), pfrom.GetId());
         }
         return;
     }
 
     if (msg_type == NetMsgType::GETCFILTERS) {
         ProcessGetCFilters(pfrom, *peer, vRecv);
         return;
     }
 
     if (msg_type == NetMsgType::GETCFHEADERS) {
         ProcessGetCFHeaders(pfrom, *peer, vRecv);
         return;
     }
 
     if (msg_type == NetMsgType::GETCFCHECKPT) {
         ProcessGetCFCheckPt(pfrom, *peer, vRecv);
         return;
     }
 
     if (msg_type == NetMsgType::NOTFOUND) {
         std::vector<CInv> vInv;
         vRecv >> vInv;
         // A peer might send up to 1 notfound per getdata request, but no more
         if (vInv.size() <= PROOF_REQUEST_PARAMS.max_peer_announcements +
                                TX_REQUEST_PARAMS.max_peer_announcements +
                                MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
             for (CInv &inv : vInv) {
                 if (inv.IsMsgTx()) {
                     // If we receive a NOTFOUND message for a tx we requested,
                     // mark the announcement for it as completed in
                     // InvRequestTracker.
                     LOCK(::cs_main);
                     m_txrequest.ReceivedResponse(pfrom.GetId(), TxId(inv.hash));
                     continue;
                 }
                 if (inv.IsMsgProof()) {
                     LOCK(cs_proofrequest);
                     m_proofrequest.ReceivedResponse(
                         pfrom.GetId(), avalanche::ProofId(inv.hash));
                 }
             }
         }
         return;
     }
 
     // Ignore unknown commands for extensibility
     LogPrint(BCLog::NET, "Unknown command \"%s\" from peer=%d\n",
              SanitizeString(msg_type), pfrom.GetId());
     return;
 }
 
 bool PeerManagerImpl::MaybeDiscourageAndDisconnect(CNode &pnode, Peer &peer) {
     {
         LOCK(peer.m_misbehavior_mutex);
 
         // There's nothing to do if the m_should_discourage flag isn't set
         if (!peer.m_should_discourage) {
             return false;
         }
 
         peer.m_should_discourage = false;
     } // peer.m_misbehavior_mutex
 
     if (pnode.HasPermission(NetPermissionFlags::NoBan)) {
         // We never disconnect or discourage peers for bad behavior if they have
         // NetPermissionFlags::NoBan permission
         LogPrintf("Warning: not punishing noban peer %d!\n", peer.m_id);
         return false;
     }
 
     if (pnode.IsManualConn()) {
         // We never disconnect or discourage manual peers for bad behavior
         LogPrintf("Warning: not punishing manually connected peer %d!\n",
                   peer.m_id);
         return false;
     }
 
     if (pnode.addr.IsLocal()) {
         // We disconnect local peers for bad behavior but don't discourage
         // (since that would discourage all peers on the same local address)
         LogPrint(BCLog::NET,
                  "Warning: disconnecting but not discouraging %s peer %d!\n",
                  pnode.m_inbound_onion ? "inbound onion" : "local", peer.m_id);
         pnode.fDisconnect = true;
         return true;
     }
 
     // Normal case: Disconnect the peer and discourage all nodes sharing the
     // address
     LogPrint(BCLog::NET, "Disconnecting and discouraging peer %d!\n",
              peer.m_id);
     if (m_banman) {
         m_banman->Discourage(pnode.addr);
     }
     m_connman.DisconnectNode(pnode.addr);
     return true;
 }
 
 bool PeerManagerImpl::ProcessMessages(const Config &config, CNode *pfrom,
                                       std::atomic<bool> &interruptMsgProc) {
     //
     // Message format
     //  (4) message start
     //  (12) command
     //  (4) size
     //  (4) checksum
     //  (x) data
     //
     bool fMoreWork = false;
 
     PeerRef peer = GetPeerRef(pfrom->GetId());
     if (peer == nullptr) {
         return false;
     }
 
     {
         LOCK(peer->m_getdata_requests_mutex);
         if (!peer->m_getdata_requests.empty()) {
             ProcessGetData(config, *pfrom, *peer, interruptMsgProc);
         }
     }
 
     {
         LOCK2(cs_main, g_cs_orphans);
         if (!peer->m_orphan_work_set.empty()) {
             ProcessOrphanTx(config, peer->m_orphan_work_set);
         }
     }
 
     if (pfrom->fDisconnect) {
         return false;
     }
 
     // this maintains the order of responses and prevents m_getdata_requests
     // from growing unbounded
     {
         LOCK(peer->m_getdata_requests_mutex);
         if (!peer->m_getdata_requests.empty()) {
             return true;
         }
     }
 
     {
         LOCK(g_cs_orphans);
         if (!peer->m_orphan_work_set.empty()) {
             return true;
         }
     }
 
     // Don't bother if send buffer is too full to respond anyway
     if (pfrom->fPauseSend) {
         return false;
     }
 
     std::list<CNetMessage> msgs;
     {
         LOCK(pfrom->cs_vProcessMsg);
         if (pfrom->vProcessMsg.empty()) {
             return false;
         }
         // Just take one message
         msgs.splice(msgs.begin(), pfrom->vProcessMsg,
                     pfrom->vProcessMsg.begin());
         pfrom->nProcessQueueSize -= msgs.front().m_raw_message_size;
         pfrom->fPauseRecv =
             pfrom->nProcessQueueSize > m_connman.GetReceiveFloodSize();
         fMoreWork = !pfrom->vProcessMsg.empty();
     }
     CNetMessage &msg(msgs.front());
 
     TRACE6(net, inbound_message, pfrom->GetId(), pfrom->m_addr_name.c_str(),
            pfrom->ConnectionTypeAsString().c_str(), msg.m_type.c_str(),
            msg.m_recv.size(), msg.m_recv.data());
 
     if (gArgs.GetBoolArg("-capturemessages", false)) {
         CaptureMessage(pfrom->addr, msg.m_type, MakeUCharSpan(msg.m_recv),
                        /*is_incoming=*/true);
     }
 
     msg.SetVersion(pfrom->GetCommonVersion());
 
     // Check network magic
     if (!msg.m_valid_netmagic) {
         LogPrint(BCLog::NET,
                  "PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n",
                  SanitizeString(msg.m_type), pfrom->GetId());
 
         // Make sure we discourage where that come from for some time.
         if (m_banman) {
             m_banman->Discourage(pfrom->addr);
         }
         m_connman.DisconnectNode(pfrom->addr);
 
         pfrom->fDisconnect = true;
         return false;
     }
 
     // Check header
     if (!msg.m_valid_header) {
         LogPrint(BCLog::NET, "PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n",
                  SanitizeString(msg.m_type), pfrom->GetId());
         return fMoreWork;
     }
 
     // Checksum
     CDataStream &vRecv = msg.m_recv;
     if (!msg.m_valid_checksum) {
         LogPrint(BCLog::NET, "%s(%s, %u bytes): CHECKSUM ERROR peer=%d\n",
                  __func__, SanitizeString(msg.m_type), msg.m_message_size,
                  pfrom->GetId());
         if (m_banman) {
             m_banman->Discourage(pfrom->addr);
         }
         m_connman.DisconnectNode(pfrom->addr);
         return fMoreWork;
     }
 
     try {
         ProcessMessage(config, *pfrom, msg.m_type, vRecv, msg.m_time,
                        interruptMsgProc);
         if (interruptMsgProc) {
             return false;
         }
 
         {
             LOCK(peer->m_getdata_requests_mutex);
             if (!peer->m_getdata_requests.empty()) {
                 fMoreWork = true;
             }
         }
     } catch (const std::exception &e) {
         LogPrint(BCLog::NET, "%s(%s, %u bytes): Exception '%s' (%s) caught\n",
                  __func__, SanitizeString(msg.m_type), msg.m_message_size,
                  e.what(), typeid(e).name());
     } catch (...) {
         LogPrint(BCLog::NET, "%s(%s, %u bytes): Unknown exception caught\n",
                  __func__, SanitizeString(msg.m_type), msg.m_message_size);
     }
 
     return fMoreWork;
 }
 
 void PeerManagerImpl::ConsiderEviction(CNode &pto,
                                        std::chrono::seconds time_in_seconds) {
     AssertLockHeld(cs_main);
 
     CNodeState &state = *State(pto.GetId());
     const CNetMsgMaker msgMaker(pto.GetCommonVersion());
 
     if (!state.m_chain_sync.m_protect && pto.IsOutboundOrBlockRelayConn() &&
         state.fSyncStarted) {
         // This is an outbound peer subject to disconnection if they don't
         // announce a block with as much work as the current tip within
         // CHAIN_SYNC_TIMEOUT + HEADERS_RESPONSE_TIME seconds (note: if their
         // chain has more work than ours, we should sync to it, unless it's
         // invalid, in which case we should find that out and disconnect from
         // them elsewhere).
         if (state.pindexBestKnownBlock != nullptr &&
             state.pindexBestKnownBlock->nChainWork >=
                 m_chainman.ActiveChain().Tip()->nChainWork) {
             if (state.m_chain_sync.m_timeout != 0s) {
                 state.m_chain_sync.m_timeout = 0s;
                 state.m_chain_sync.m_work_header = nullptr;
                 state.m_chain_sync.m_sent_getheaders = false;
             }
         } else if (state.m_chain_sync.m_timeout == 0s ||
                    (state.m_chain_sync.m_work_header != nullptr &&
                     state.pindexBestKnownBlock != nullptr &&
                     state.pindexBestKnownBlock->nChainWork >=
                         state.m_chain_sync.m_work_header->nChainWork)) {
             // Our best block known by this peer is behind our tip, and we're
             // either noticing that for the first time, OR this peer was able to
             // catch up to some earlier point where we checked against our tip.
             // Either way, set a new timeout based on current tip.
             state.m_chain_sync.m_timeout = time_in_seconds + CHAIN_SYNC_TIMEOUT;
             state.m_chain_sync.m_work_header = m_chainman.ActiveChain().Tip();
             state.m_chain_sync.m_sent_getheaders = false;
         } else if (state.m_chain_sync.m_timeout > 0s &&
                    time_in_seconds > state.m_chain_sync.m_timeout) {
             // No evidence yet that our peer has synced to a chain with work
             // equal to that of our tip, when we first detected it was behind.
             // Send a single getheaders message to give the peer a chance to
             // update us.
             if (state.m_chain_sync.m_sent_getheaders) {
                 // They've run out of time to catch up!
                 LogPrintf(
                     "Disconnecting outbound peer %d for old chain, best known "
                     "block = %s\n",
                     pto.GetId(),
                     state.pindexBestKnownBlock != nullptr
                         ? state.pindexBestKnownBlock->GetBlockHash().ToString()
                         : "<none>");
                 pto.fDisconnect = true;
             } else {
                 assert(state.m_chain_sync.m_work_header);
                 LogPrint(
                     BCLog::NET,
                     "sending getheaders to outbound peer=%d to verify chain "
                     "work (current best known block:%s, benchmark blockhash: "
                     "%s)\n",
                     pto.GetId(),
                     state.pindexBestKnownBlock != nullptr
                         ? state.pindexBestKnownBlock->GetBlockHash().ToString()
                         : "<none>",
                     state.m_chain_sync.m_work_header->GetBlockHash()
                         .ToString());
                 m_connman.PushMessage(
                     &pto,
                     msgMaker.Make(NetMsgType::GETHEADERS,
                                   m_chainman.ActiveChain().GetLocator(
                                       state.m_chain_sync.m_work_header->pprev),
                                   uint256()));
                 state.m_chain_sync.m_sent_getheaders = true;
                 constexpr auto HEADERS_RESPONSE_TIME{2min};
                 // Bump the timeout to allow a response, which could clear the
                 // timeout (if the response shows the peer has synced), reset
                 // the timeout (if the peer syncs to the required work but not
                 // to our tip), or result in disconnect (if we advance to the
                 // timeout and pindexBestKnownBlock has not sufficiently
                 // progressed)
                 state.m_chain_sync.m_timeout =
                     time_in_seconds + HEADERS_RESPONSE_TIME;
             }
         }
     }
 }
 
 void PeerManagerImpl::EvictExtraOutboundPeers(std::chrono::seconds now) {
     // If we have any extra block-relay-only peers, disconnect the youngest
     // unless it's given us a block -- in which case, compare with the
     // second-youngest, and out of those two, disconnect the peer who least
     // recently gave us a block.
     // The youngest block-relay-only peer would be the extra peer we connected
     // to temporarily in order to sync our tip; see net.cpp.
     // Note that we use higher nodeid as a measure for most recent connection.
     if (m_connman.GetExtraBlockRelayCount() > 0) {
         std::pair<NodeId, std::chrono::seconds> youngest_peer{-1, 0},
             next_youngest_peer{-1, 0};
 
         m_connman.ForEachNode([&](CNode *pnode) {
             if (!pnode->IsBlockOnlyConn() || pnode->fDisconnect) {
                 return;
             }
             if (pnode->GetId() > youngest_peer.first) {
                 next_youngest_peer = youngest_peer;
                 youngest_peer.first = pnode->GetId();
                 youngest_peer.second = pnode->m_last_block_time;
             }
         });
 
         NodeId to_disconnect = youngest_peer.first;
         if (youngest_peer.second > next_youngest_peer.second) {
             // Our newest block-relay-only peer gave us a block more recently;
             // disconnect our second youngest.
             to_disconnect = next_youngest_peer.first;
         }
 
         m_connman.ForNode(
             to_disconnect,
             [&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
                 AssertLockHeld(::cs_main);
                 // Make sure we're not getting a block right now, and that we've
                 // been connected long enough for this eviction to happen at
                 // all. Note that we only request blocks from a peer if we learn
                 // of a valid headers chain with at least as much work as our
                 // tip.
                 CNodeState *node_state = State(pnode->GetId());
                 if (node_state == nullptr ||
                     (now - pnode->m_connected >= MINIMUM_CONNECT_TIME &&
                      node_state->nBlocksInFlight == 0)) {
                     pnode->fDisconnect = true;
                     LogPrint(BCLog::NET,
                              "disconnecting extra block-relay-only peer=%d "
                              "(last block received at time %d)\n",
                              pnode->GetId(),
                              count_seconds(pnode->m_last_block_time));
                     return true;
                 } else {
                     LogPrint(
                         BCLog::NET,
                         "keeping block-relay-only peer=%d chosen for eviction "
                         "(connect time: %d, blocks_in_flight: %d)\n",
                         pnode->GetId(), count_seconds(pnode->m_connected),
                         node_state->nBlocksInFlight);
                 }
                 return false;
             });
     }
 
     // Check whether we have too many OUTBOUND_FULL_RELAY peers
     if (m_connman.GetExtraFullOutboundCount() <= 0) {
         return;
     }
 
     // If we have more OUTBOUND_FULL_RELAY peers than we target, disconnect one.
     // Pick the OUTBOUND_FULL_RELAY peer that least recently announced us a new
     // block, with ties broken by choosing the more recent connection (higher
     // node id)
     NodeId worst_peer = -1;
     int64_t oldest_block_announcement = std::numeric_limits<int64_t>::max();
 
     m_connman.ForEachNode([&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(
                               ::cs_main) {
         AssertLockHeld(::cs_main);
 
         // Only consider OUTBOUND_FULL_RELAY peers that are not already marked
         // for disconnection
         if (!pnode->IsFullOutboundConn() || pnode->fDisconnect) {
             return;
         }
         CNodeState *state = State(pnode->GetId());
         if (state == nullptr) {
             // shouldn't be possible, but just in case
             return;
         }
         // Don't evict our protected peers
         if (state->m_chain_sync.m_protect) {
             return;
         }
         if (state->m_last_block_announcement < oldest_block_announcement ||
             (state->m_last_block_announcement == oldest_block_announcement &&
              pnode->GetId() > worst_peer)) {
             worst_peer = pnode->GetId();
             oldest_block_announcement = state->m_last_block_announcement;
         }
     });
 
     if (worst_peer == -1) {
         return;
     }
 
     bool disconnected = m_connman.ForNode(
         worst_peer, [&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
             AssertLockHeld(::cs_main);
 
             // Only disconnect a peer that has been connected to us for some
             // reasonable fraction of our check-frequency, to give it time for
             // new information to have arrived. Also don't disconnect any peer
             // we're trying to download a block from.
             CNodeState &state = *State(pnode->GetId());
             if (now - pnode->m_connected > MINIMUM_CONNECT_TIME &&
                 state.nBlocksInFlight == 0) {
                 LogPrint(BCLog::NET,
                          "disconnecting extra outbound peer=%d (last block "
                          "announcement received at time %d)\n",
                          pnode->GetId(), oldest_block_announcement);
                 pnode->fDisconnect = true;
                 return true;
             } else {
                 LogPrint(BCLog::NET,
                          "keeping outbound peer=%d chosen for eviction "
                          "(connect time: %d, blocks_in_flight: %d)\n",
                          pnode->GetId(), count_seconds(pnode->m_connected),
                          state.nBlocksInFlight);
                 return false;
             }
         });
 
     if (disconnected) {
         // If we disconnected an extra peer, that means we successfully
         // connected to at least one peer after the last time we detected a
         // stale tip. Don't try any more extra peers until we next detect a
         // stale tip, to limit the load we put on the network from these extra
         // connections.
         m_connman.SetTryNewOutboundPeer(false);
     }
 }
 
 void PeerManagerImpl::CheckForStaleTipAndEvictPeers() {
     LOCK(cs_main);
 
     auto now{GetTime<std::chrono::seconds>()};
 
     EvictExtraOutboundPeers(now);
 
     if (now > m_stale_tip_check_time) {
         // Check whether our tip is stale, and if so, allow using an extra
         // outbound peer.
         if (!fImporting && !fReindex && m_connman.GetNetworkActive() &&
             m_connman.GetUseAddrmanOutgoing() && TipMayBeStale()) {
             LogPrintf("Potential stale tip detected, will try using extra "
                       "outbound peer (last tip update: %d seconds ago)\n",
                       count_seconds(now - m_last_tip_update.load()));
             m_connman.SetTryNewOutboundPeer(true);
         } else if (m_connman.GetTryNewOutboundPeer()) {
             m_connman.SetTryNewOutboundPeer(false);
         }
         m_stale_tip_check_time = now + STALE_CHECK_INTERVAL;
     }
 
     if (!m_initial_sync_finished && CanDirectFetch()) {
         m_connman.StartExtraBlockRelayPeers();
         m_initial_sync_finished = true;
     }
 }
 
 void PeerManagerImpl::MaybeSendPing(CNode &node_to, Peer &peer,
                                     std::chrono::microseconds now) {
     if (m_connman.ShouldRunInactivityChecks(
             node_to, std::chrono::duration_cast<std::chrono::seconds>(now)) &&
         peer.m_ping_nonce_sent &&
         now > peer.m_ping_start.load() + TIMEOUT_INTERVAL) {
         // The ping timeout is using mocktime. To disable the check during
         // testing, increase -peertimeout.
         LogPrint(BCLog::NET, "ping timeout: %fs peer=%d\n",
                  0.000001 * count_microseconds(now - peer.m_ping_start.load()),
                  peer.m_id);
         node_to.fDisconnect = true;
         return;
     }
 
     const CNetMsgMaker msgMaker(node_to.GetCommonVersion());
     bool pingSend = false;
 
     if (peer.m_ping_queued) {
         // RPC ping request by user
         pingSend = true;
     }
 
     if (peer.m_ping_nonce_sent == 0 &&
         now > peer.m_ping_start.load() + PING_INTERVAL) {
         // Ping automatically sent as a latency probe & keepalive.
         pingSend = true;
     }
 
     if (pingSend) {
         uint64_t nonce;
         do {
             nonce = GetRand<uint64_t>();
         } while (nonce == 0);
         peer.m_ping_queued = false;
         peer.m_ping_start = now;
         if (node_to.GetCommonVersion() > BIP0031_VERSION) {
             peer.m_ping_nonce_sent = nonce;
             m_connman.PushMessage(&node_to,
                                   msgMaker.Make(NetMsgType::PING, nonce));
         } else {
             // Peer is too old to support ping command with nonce, pong will
             // never arrive.
             peer.m_ping_nonce_sent = 0;
             m_connman.PushMessage(&node_to, msgMaker.Make(NetMsgType::PING));
         }
     }
 }
 
 void PeerManagerImpl::MaybeSendAddr(CNode &node, Peer &peer,
                                     std::chrono::microseconds current_time) {
     // Nothing to do for non-address-relay peers
     if (!peer.m_addr_relay_enabled) {
         return;
     }
 
     LOCK(peer.m_addr_send_times_mutex);
     if (fListen && !m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
         peer.m_next_local_addr_send < current_time) {
         // If we've sent before, clear the bloom filter for the peer, so
         // that our self-announcement will actually go out. This might
         // be unnecessary if the bloom filter has already rolled over
         // since our last self-announcement, but there is only a small
         // bandwidth cost that we can incur by doing this (which happens
         // once a day on average).
         if (peer.m_next_local_addr_send != 0us) {
             peer.m_addr_known->reset();
         }
         if (std::optional<CService> local_service = GetLocalAddrForPeer(node)) {
             CAddress local_addr{*local_service, peer.m_our_services,
                                 (uint32_t)GetAdjustedTime()};
             FastRandomContext insecure_rand;
             PushAddress(peer, local_addr, insecure_rand);
         }
         peer.m_next_local_addr_send = GetExponentialRand(
             current_time, AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL);
     }
 
     // We sent an `addr` message to this peer recently. Nothing more to do.
     if (current_time <= peer.m_next_addr_send) {
         return;
     }
 
     peer.m_next_addr_send =
         GetExponentialRand(current_time, AVG_ADDRESS_BROADCAST_INTERVAL);
 
     const size_t max_addr_to_send = GetMaxAddrToSend();
     if (!Assume(peer.m_addrs_to_send.size() <= max_addr_to_send)) {
         // Should be impossible since we always check size before adding to
         // m_addrs_to_send. Recover by trimming the vector.
         peer.m_addrs_to_send.resize(max_addr_to_send);
     }
 
     // Remove addr records that the peer already knows about, and add new
     // addrs to the m_addr_known filter on the same pass.
     auto addr_already_known = [&peer](const CAddress &addr) {
         bool ret = peer.m_addr_known->contains(addr.GetKey());
         if (!ret) {
             peer.m_addr_known->insert(addr.GetKey());
         }
         return ret;
     };
     peer.m_addrs_to_send.erase(std::remove_if(peer.m_addrs_to_send.begin(),
                                               peer.m_addrs_to_send.end(),
                                               addr_already_known),
                                peer.m_addrs_to_send.end());
 
     // No addr messages to send
     if (peer.m_addrs_to_send.empty()) {
         return;
     }
 
     const char *msg_type;
     int make_flags;
     if (peer.m_wants_addrv2) {
         msg_type = NetMsgType::ADDRV2;
         make_flags = ADDRV2_FORMAT;
     } else {
         msg_type = NetMsgType::ADDR;
         make_flags = 0;
     }
     m_connman.PushMessage(
         &node, CNetMsgMaker(node.GetCommonVersion())
                    .Make(make_flags, msg_type, peer.m_addrs_to_send));
     peer.m_addrs_to_send.clear();
 
     // we only send the big addr message once
     if (peer.m_addrs_to_send.capacity() > 40) {
         peer.m_addrs_to_send.shrink_to_fit();
     }
 }
 
 void PeerManagerImpl::MaybeSendFeefilter(
     CNode &pto, Peer &peer, std::chrono::microseconds current_time) {
     if (m_ignore_incoming_txs) {
         return;
     }
     if (pto.GetCommonVersion() < FEEFILTER_VERSION) {
         return;
     }
     // peers with the forcerelay permission should not filter txs to us
     if (pto.HasPermission(NetPermissionFlags::ForceRelay)) {
         return;
     }
     // Don't send feefilter messages to outbound block-relay-only peers since
     // they should never announce transactions to us, regardless of feefilter
     // state.
     if (pto.IsBlockOnlyConn()) {
         return;
     }
 
     Amount currentFilter =
         m_mempool
             .GetMinFee(
                 gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) *
                 1000000)
             .GetFeePerK();
     static FeeFilterRounder g_filter_rounder{
         CFeeRate{DEFAULT_MIN_RELAY_TX_FEE_PER_KB}};
 
     if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
         // Received tx-inv messages are discarded when the active
         // chainstate is in IBD, so tell the peer to not send them.
         currentFilter = MAX_MONEY;
     } else {
         static const Amount MAX_FILTER{g_filter_rounder.round(MAX_MONEY)};
         if (peer.m_fee_filter_sent == MAX_FILTER) {
             // Send the current filter if we sent MAX_FILTER previously
             // and made it out of IBD.
             peer.m_next_send_feefilter = 0us;
         }
     }
     if (current_time > peer.m_next_send_feefilter) {
         Amount filterToSend = g_filter_rounder.round(currentFilter);
         // We always have a fee filter of at least minRelayTxFee
         filterToSend = std::max(filterToSend, ::minRelayTxFee.GetFeePerK());
         if (filterToSend != peer.m_fee_filter_sent) {
             m_connman.PushMessage(
                 &pto, CNetMsgMaker(pto.GetCommonVersion())
                           .Make(NetMsgType::FEEFILTER, filterToSend));
             peer.m_fee_filter_sent = filterToSend;
         }
         peer.m_next_send_feefilter =
             GetExponentialRand(current_time, AVG_FEEFILTER_BROADCAST_INTERVAL);
     }
     // If the fee filter has changed substantially and it's still more than
     // MAX_FEEFILTER_CHANGE_DELAY until scheduled broadcast, then move the
     // broadcast to within MAX_FEEFILTER_CHANGE_DELAY.
     else if (current_time + MAX_FEEFILTER_CHANGE_DELAY <
                  peer.m_next_send_feefilter &&
              (currentFilter < 3 * peer.m_fee_filter_sent / 4 ||
               currentFilter > 4 * peer.m_fee_filter_sent / 3)) {
         peer.m_next_send_feefilter =
             current_time + GetRandomDuration<std::chrono::microseconds>(
                                MAX_FEEFILTER_CHANGE_DELAY);
     }
 }
 
 namespace {
 class CompareInvMempoolOrder {
     CTxMemPool *mp;
 
 public:
     explicit CompareInvMempoolOrder(CTxMemPool *_mempool) : mp(_mempool) {}
 
     bool operator()(std::set<TxId>::iterator a, std::set<TxId>::iterator b) {
         /**
          * As std::make_heap produces a max-heap, we want the entries which
          * are topologically earlier to sort later.
          */
         return mp->CompareTopologically(*b, *a);
     }
 };
 } // namespace
 
 bool PeerManagerImpl::SetupAddressRelay(const CNode &node, Peer &peer) {
     // We don't participate in addr relay with outbound block-relay-only
     // connections to prevent providing adversaries with the additional
     // information of addr traffic to infer the link.
     if (node.IsBlockOnlyConn()) {
         return false;
     }
 
     if (!peer.m_addr_relay_enabled.exchange(true)) {
         // First addr message we have received from the peer, initialize
         // m_addr_known
         peer.m_addr_known = std::make_unique<CRollingBloomFilter>(5000, 0.001);
     }
 
     return true;
 }
 
 bool PeerManagerImpl::SendMessages(const Config &config, CNode *pto) {
     PeerRef peer = GetPeerRef(pto->GetId());
     if (!peer) {
         return false;
     }
     const Consensus::Params &consensusParams = m_chainparams.GetConsensus();
 
     // We must call MaybeDiscourageAndDisconnect first, to ensure that we'll
     // disconnect misbehaving peers even before the version handshake is
     // complete.
     if (MaybeDiscourageAndDisconnect(*pto, *peer)) {
         return true;
     }
 
     // Don't send anything until the version handshake is complete
     if (!pto->fSuccessfullyConnected || pto->fDisconnect) {
         return true;
     }
 
     // If we get here, the outgoing message serialization version is set and
     // can't change.
     const CNetMsgMaker msgMaker(pto->GetCommonVersion());
 
     const auto current_time{GetTime<std::chrono::microseconds>()};
 
     if (pto->IsAddrFetchConn() &&
         current_time - pto->m_connected > 10 * AVG_ADDRESS_BROADCAST_INTERVAL) {
         LogPrint(BCLog::NET,
                  "addrfetch connection timeout; disconnecting peer=%d\n",
                  pto->GetId());
         pto->fDisconnect = true;
         return true;
     }
 
     MaybeSendPing(*pto, *peer, current_time);
 
     // MaybeSendPing may have marked peer for disconnection
     if (pto->fDisconnect) {
         return true;
     }
 
     bool fFetch;
 
     MaybeSendAddr(*pto, *peer, current_time);
 
     {
         LOCK(cs_main);
 
         CNodeState &state = *State(pto->GetId());
 
         // Start block sync
         if (m_chainman.m_best_header == nullptr) {
             m_chainman.m_best_header = m_chainman.ActiveChain().Tip();
         }
 
         // Download if this is a nice peer, or we have no nice peers and this
         // one might do.
         fFetch = state.fPreferredDownload ||
                  (m_num_preferred_download_peers == 0 &&
                   CanServeBlocks(*peer) && !pto->IsAddrFetchConn());
 
         if (!state.fSyncStarted && CanServeBlocks(*peer) && !fImporting &&
             !fReindex) {
             // Only actively request headers from a single peer, unless we're
             // close to today.
             if ((nSyncStarted == 0 && fFetch) ||
                 m_chainman.m_best_header->GetBlockTime() >
                     GetAdjustedTime() - 24 * 60 * 60) {
                 state.fSyncStarted = true;
                 state.m_headers_sync_timeout =
                     current_time + HEADERS_DOWNLOAD_TIMEOUT_BASE +
                     (
                         // Convert HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER to
                         // microseconds before scaling to maintain precision
                         std::chrono::microseconds{
                             HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER} *
                         (GetAdjustedTime() -
                          m_chainman.m_best_header->GetBlockTime()) /
                         consensusParams.nPowTargetSpacing);
                 nSyncStarted++;
                 const CBlockIndex *pindexStart = m_chainman.m_best_header;
                 /**
                  * If possible, start at the block preceding the currently best
                  * known header. This ensures that we always get a non-empty
                  * list of headers back as long as the peer is up-to-date. With
                  * a non-empty response, we can initialise the peer's known best
                  * block. This wouldn't be possible if we requested starting at
                  * m_best_header and got back an empty response.
                  */
                 if (pindexStart->pprev) {
                     pindexStart = pindexStart->pprev;
                 }
 
                 LogPrint(
                     BCLog::NET,
                     "initial getheaders (%d) to peer=%d (startheight:%d)\n",
                     pindexStart->nHeight, pto->GetId(),
                     peer->m_starting_height);
                 m_connman.PushMessage(
                     pto, msgMaker.Make(
                              NetMsgType::GETHEADERS,
                              m_chainman.ActiveChain().GetLocator(pindexStart),
                              uint256()));
             }
         }
 
         //
         // Try sending block announcements via headers
         //
         {
             // If we have less than MAX_BLOCKS_TO_ANNOUNCE in our list of block
             // hashes we're relaying, and our peer wants headers announcements,
             // then find the first header not yet known to our peer but would
             // connect, and send. If no header would connect, or if we have too
             // many blocks, or if the peer doesn't want headers, just add all to
             // the inv queue.
             LOCK(peer->m_block_inv_mutex);
             std::vector<CBlock> vHeaders;
             bool fRevertToInv =
                 ((!state.fPreferHeaders &&
                   (!state.m_requested_hb_cmpctblocks ||
                    peer->m_blocks_for_headers_relay.size() > 1)) ||
                  peer->m_blocks_for_headers_relay.size() >
                      MAX_BLOCKS_TO_ANNOUNCE);
             // last header queued for delivery
             const CBlockIndex *pBestIndex = nullptr;
             // ensure pindexBestKnownBlock is up-to-date
             ProcessBlockAvailability(pto->GetId());
 
             if (!fRevertToInv) {
                 bool fFoundStartingHeader = false;
                 // Try to find first header that our peer doesn't have, and then
                 // send all headers past that one. If we come across an headers
                 // that aren't on m_chainman.ActiveChain(), give up.
                 for (const BlockHash &hash : peer->m_blocks_for_headers_relay) {
                     const CBlockIndex *pindex =
                         m_chainman.m_blockman.LookupBlockIndex(hash);
                     assert(pindex);
                     if (m_chainman.ActiveChain()[pindex->nHeight] != pindex) {
                         // Bail out if we reorged away from this block
                         fRevertToInv = true;
                         break;
                     }
                     if (pBestIndex != nullptr && pindex->pprev != pBestIndex) {
                         // This means that the list of blocks to announce don't
                         // connect to each other. This shouldn't really be
                         // possible to hit during regular operation (because
                         // reorgs should take us to a chain that has some block
                         // not on the prior chain, which should be caught by the
                         // prior check), but one way this could happen is by
                         // using invalidateblock / reconsiderblock repeatedly on
                         // the tip, causing it to be added multiple times to
                         // m_blocks_for_headers_relay. Robustly deal with this
                         // rare situation by reverting to an inv.
                         fRevertToInv = true;
                         break;
                     }
                     pBestIndex = pindex;
                     if (fFoundStartingHeader) {
                         // add this to the headers message
                         vHeaders.push_back(pindex->GetBlockHeader());
                     } else if (PeerHasHeader(&state, pindex)) {
                         // Keep looking for the first new block.
                         continue;
                     } else if (pindex->pprev == nullptr ||
                                PeerHasHeader(&state, pindex->pprev)) {
                         // Peer doesn't have this header but they do have the
                         // prior one. Start sending headers.
                         fFoundStartingHeader = true;
                         vHeaders.push_back(pindex->GetBlockHeader());
                     } else {
                         // Peer doesn't have this header or the prior one --
                         // nothing will connect, so bail out.
                         fRevertToInv = true;
                         break;
                     }
                 }
             }
             if (!fRevertToInv && !vHeaders.empty()) {
                 if (vHeaders.size() == 1 && state.m_requested_hb_cmpctblocks) {
                     // We only send up to 1 block as header-and-ids, as
                     // otherwise probably means we're doing an initial-ish-sync
                     // or they're slow.
                     LogPrint(BCLog::NET,
                              "%s sending header-and-ids %s to peer=%d\n",
                              __func__, vHeaders.front().GetHash().ToString(),
                              pto->GetId());
 
                     bool fGotBlockFromCache = false;
                     {
                         LOCK(m_most_recent_block_mutex);
                         if (m_most_recent_block_hash ==
                             pBestIndex->GetBlockHash()) {
                             CBlockHeaderAndShortTxIDs cmpctblock(
                                 *m_most_recent_block);
                             m_connman.PushMessage(
                                 pto, msgMaker.Make(NetMsgType::CMPCTBLOCK,
                                                    cmpctblock));
                             fGotBlockFromCache = true;
                         }
                     }
                     if (!fGotBlockFromCache) {
                         CBlock block;
                         bool ret = ReadBlockFromDisk(block, pBestIndex,
                                                      consensusParams);
                         assert(ret);
                         CBlockHeaderAndShortTxIDs cmpctblock(block);
                         m_connman.PushMessage(
                             pto,
                             msgMaker.Make(NetMsgType::CMPCTBLOCK, cmpctblock));
                     }
                     state.pindexBestHeaderSent = pBestIndex;
                 } else if (state.fPreferHeaders) {
                     if (vHeaders.size() > 1) {
                         LogPrint(BCLog::NET,
                                  "%s: %u headers, range (%s, %s), to peer=%d\n",
                                  __func__, vHeaders.size(),
                                  vHeaders.front().GetHash().ToString(),
                                  vHeaders.back().GetHash().ToString(),
                                  pto->GetId());
                     } else {
                         LogPrint(BCLog::NET,
                                  "%s: sending header %s to peer=%d\n", __func__,
                                  vHeaders.front().GetHash().ToString(),
                                  pto->GetId());
                     }
                     m_connman.PushMessage(
                         pto, msgMaker.Make(NetMsgType::HEADERS, vHeaders));
                     state.pindexBestHeaderSent = pBestIndex;
                 } else {
                     fRevertToInv = true;
                 }
             }
             if (fRevertToInv) {
                 // If falling back to using an inv, just try to inv the tip. The
                 // last entry in m_blocks_for_headers_relay was our tip at some
                 // point in the past.
                 if (!peer->m_blocks_for_headers_relay.empty()) {
                     const BlockHash &hashToAnnounce =
                         peer->m_blocks_for_headers_relay.back();
                     const CBlockIndex *pindex =
                         m_chainman.m_blockman.LookupBlockIndex(hashToAnnounce);
                     assert(pindex);
 
                     // Warn if we're announcing a block that is not on the main
                     // chain. This should be very rare and could be optimized
                     // out. Just log for now.
                     if (m_chainman.ActiveChain()[pindex->nHeight] != pindex) {
                         LogPrint(
                             BCLog::NET,
                             "Announcing block %s not on main chain (tip=%s)\n",
                             hashToAnnounce.ToString(),
                             m_chainman.ActiveChain()
                                 .Tip()
                                 ->GetBlockHash()
                                 .ToString());
                     }
 
                     // If the peer's chain has this block, don't inv it back.
                     if (!PeerHasHeader(&state, pindex)) {
                         peer->m_blocks_for_inv_relay.push_back(hashToAnnounce);
                         LogPrint(BCLog::NET,
                                  "%s: sending inv peer=%d hash=%s\n", __func__,
                                  pto->GetId(), hashToAnnounce.ToString());
                     }
                 }
             }
             peer->m_blocks_for_headers_relay.clear();
         }
     } // release cs_main
 
     //
     // Message: inventory
     //
     std::vector<CInv> vInv;
     auto addInvAndMaybeFlush = [&](uint32_t type, const uint256 &hash) {
         vInv.emplace_back(type, hash);
         if (vInv.size() == MAX_INV_SZ) {
             m_connman.PushMessage(
                 pto, msgMaker.Make(NetMsgType::INV, std::move(vInv)));
             vInv.clear();
         }
     };
 
     {
         LOCK(cs_main);
 
         {
             LOCK(peer->m_block_inv_mutex);
 
             vInv.reserve(std::max<size_t>(peer->m_blocks_for_inv_relay.size(),
                                           INVENTORY_BROADCAST_MAX_PER_MB *
                                               config.GetMaxBlockSize() /
                                               1000000));
 
             // Add blocks
             for (const BlockHash &hash : peer->m_blocks_for_inv_relay) {
                 addInvAndMaybeFlush(MSG_BLOCK, hash);
             }
             peer->m_blocks_for_inv_relay.clear();
         }
 
         auto computeNextInvSendTime =
             [&](std::chrono::microseconds &next) -> bool {
             bool fSendTrickle = pto->HasPermission(NetPermissionFlags::NoBan);
 
             if (next < current_time) {
                 fSendTrickle = true;
                 if (pto->IsInboundConn()) {
                     next = NextInvToInbounds(
                         current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL);
                 } else {
                     // Skip delay for outbound peers, as there is less privacy
                     // concern for them.
                     next = current_time;
                 }
             }
 
             return fSendTrickle;
         };
 
         // Add proofs to inventory
         if (peer->m_proof_relay != nullptr) {
             LOCK(peer->m_proof_relay->m_proof_inventory_mutex);
 
             if (computeNextInvSendTime(
                     peer->m_proof_relay->m_next_inv_send_time)) {
                 auto it =
                     peer->m_proof_relay->m_proof_inventory_to_send.begin();
                 while (it !=
                        peer->m_proof_relay->m_proof_inventory_to_send.end()) {
                     const avalanche::ProofId proofid = *it;
 
                     it = peer->m_proof_relay->m_proof_inventory_to_send.erase(
                         it);
 
                     if (peer->m_proof_relay->m_proof_inventory_known_filter
                             .contains(proofid)) {
                         continue;
                     }
 
                     peer->m_proof_relay->m_proof_inventory_known_filter.insert(
                         proofid);
                     addInvAndMaybeFlush(MSG_AVA_PROOF, proofid);
                     State(pto->GetId())
                         ->m_recently_announced_proofs.insert(proofid);
                 }
             }
         }
 
         if (auto tx_relay = peer->GetTxRelay()) {
             LOCK(tx_relay->m_tx_inventory_mutex);
             // Check whether periodic sends should happen
             const bool fSendTrickle =
                 computeNextInvSendTime(tx_relay->m_next_inv_send_time);
 
             // Time to send but the peer has requested we not relay
             // transactions.
             if (fSendTrickle) {
                 LOCK(tx_relay->m_bloom_filter_mutex);
                 if (!tx_relay->m_relay_txs) {
                     tx_relay->m_tx_inventory_to_send.clear();
                 }
             }
 
             // Respond to BIP35 mempool requests
             if (fSendTrickle && tx_relay->m_send_mempool) {
                 auto vtxinfo = m_mempool.infoAll();
                 tx_relay->m_send_mempool = false;
                 const CFeeRate filterrate{
                     tx_relay->m_fee_filter_received.load()};
 
                 LOCK(tx_relay->m_bloom_filter_mutex);
 
                 for (const auto &txinfo : vtxinfo) {
                     const TxId &txid = txinfo.tx->GetId();
                     tx_relay->m_tx_inventory_to_send.erase(txid);
                     // Don't send transactions that peers will not put into
                     // their mempool
                     if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) {
                         continue;
                     }
                     if (tx_relay->m_bloom_filter &&
                         !tx_relay->m_bloom_filter->IsRelevantAndUpdate(
                             *txinfo.tx)) {
                         continue;
                     }
                     tx_relay->m_tx_inventory_known_filter.insert(txid);
                     // Responses to MEMPOOL requests bypass the
                     // m_recently_announced_invs filter.
                     addInvAndMaybeFlush(MSG_TX, txid);
                 }
                 tx_relay->m_last_mempool_req =
                     std::chrono::duration_cast<std::chrono::seconds>(
                         current_time);
             }
 
             // Determine transactions to relay
             if (fSendTrickle) {
                 // Produce a vector with all candidates for sending
                 std::vector<std::set<TxId>::iterator> vInvTx;
                 vInvTx.reserve(tx_relay->m_tx_inventory_to_send.size());
                 for (std::set<TxId>::iterator it =
                          tx_relay->m_tx_inventory_to_send.begin();
                      it != tx_relay->m_tx_inventory_to_send.end(); it++) {
                     vInvTx.push_back(it);
                 }
                 const CFeeRate filterrate{
                     tx_relay->m_fee_filter_received.load()};
                 // Send out the inventory in the order of admission to our
                 // mempool, which is guaranteed to be a topological sort order.
                 // A heap is used so that not all items need sorting if only a
                 // few are being sent.
                 CompareInvMempoolOrder compareInvMempoolOrder(&m_mempool);
                 std::make_heap(vInvTx.begin(), vInvTx.end(),
                                compareInvMempoolOrder);
                 // No reason to drain out at many times the network's
                 // capacity, especially since we have many peers and some
                 // will draw much shorter delays.
                 unsigned int nRelayedTransactions = 0;
                 LOCK(tx_relay->m_bloom_filter_mutex);
                 while (!vInvTx.empty() &&
                        nRelayedTransactions < INVENTORY_BROADCAST_MAX_PER_MB *
                                                   config.GetMaxBlockSize() /
                                                   1000000) {
                     // Fetch the top element from the heap
                     std::pop_heap(vInvTx.begin(), vInvTx.end(),
                                   compareInvMempoolOrder);
                     std::set<TxId>::iterator it = vInvTx.back();
                     vInvTx.pop_back();
                     const TxId txid = *it;
                     // Remove it from the to-be-sent set
                     tx_relay->m_tx_inventory_to_send.erase(it);
                     // Check if not in the filter already
                     if (tx_relay->m_tx_inventory_known_filter.contains(txid)) {
                         continue;
                     }
                     // Not in the mempool anymore? don't bother sending it.
                     auto txinfo = m_mempool.info(txid);
                     if (!txinfo.tx) {
                         continue;
                     }
                     // Peer told you to not send transactions at that
                     // feerate? Don't bother sending it.
                     if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) {
                         continue;
                     }
                     if (tx_relay->m_bloom_filter &&
                         !tx_relay->m_bloom_filter->IsRelevantAndUpdate(
                             *txinfo.tx)) {
                         continue;
                     }
                     // Send
                     State(pto->GetId())->m_recently_announced_invs.insert(txid);
                     addInvAndMaybeFlush(MSG_TX, txid);
                     nRelayedTransactions++;
                     {
                         // Expire old relay messages
                         while (!g_relay_expiration.empty() &&
                                g_relay_expiration.front().first <
                                    current_time) {
                             mapRelay.erase(g_relay_expiration.front().second);
                             g_relay_expiration.pop_front();
                         }
 
                         auto ret = mapRelay.insert(
                             std::make_pair(txid, std::move(txinfo.tx)));
                         if (ret.second) {
                             g_relay_expiration.push_back(std::make_pair(
                                 current_time + RELAY_TX_CACHE_TIME, ret.first));
                         }
                     }
                     tx_relay->m_tx_inventory_known_filter.insert(txid);
                 }
             }
         }
     } // release cs_main
 
     if (!vInv.empty()) {
         m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
     }
 
     {
         LOCK(cs_main);
 
         CNodeState &state = *State(pto->GetId());
 
         // Detect whether we're stalling
         if (state.m_stalling_since.count() &&
             state.m_stalling_since < current_time - BLOCK_STALLING_TIMEOUT) {
             // Stalling only triggers when the block download window cannot
             // move. During normal steady state, the download window should be
             // much larger than the to-be-downloaded set of blocks, so
             // disconnection should only happen during initial block download.
             LogPrintf("Peer=%d is stalling block download, disconnecting\n",
                       pto->GetId());
             pto->fDisconnect = true;
             return true;
         }
         // In case there is a block that has been in flight from this peer for
         // block_interval * (1 + 0.5 * N) (with N the number of peers from which
         // we're downloading validated blocks), disconnect due to timeout.
         // We compensate for other peers to prevent killing off peers due to our
         // own downstream link being saturated. We only count validated
         // in-flight blocks so peers can't advertise non-existing block hashes
         // to unreasonably increase our timeout.
         if (state.vBlocksInFlight.size() > 0) {
             QueuedBlock &queuedBlock = state.vBlocksInFlight.front();
             int nOtherPeersWithValidatedDownloads =
                 m_peers_downloading_from - 1;
             if (current_time >
                 state.m_downloading_since +
                     std::chrono::seconds{consensusParams.nPowTargetSpacing} *
                         (BLOCK_DOWNLOAD_TIMEOUT_BASE +
                          BLOCK_DOWNLOAD_TIMEOUT_PER_PEER *
                              nOtherPeersWithValidatedDownloads)) {
                 LogPrintf("Timeout downloading block %s from peer=%d, "
                           "disconnecting\n",
                           queuedBlock.pindex->GetBlockHash().ToString(),
                           pto->GetId());
                 pto->fDisconnect = true;
                 return true;
             }
         }
 
         // Check for headers sync timeouts
         if (state.fSyncStarted &&
             state.m_headers_sync_timeout < std::chrono::microseconds::max()) {
             // Detect whether this is a stalling initial-headers-sync peer
             if (m_chainman.m_best_header->GetBlockTime() <=
                 GetAdjustedTime() - 24 * 60 * 60) {
                 if (current_time > state.m_headers_sync_timeout &&
                     nSyncStarted == 1 &&
                     (m_num_preferred_download_peers -
                          state.fPreferredDownload >=
                      1)) {
                     // Disconnect a peer (without NetPermissionFlags::NoBan
                     // permission) if it is our only sync peer, and we have
                     // others we could be using instead. Note: If all our peers
                     // are inbound, then we won't disconnect our sync peer for
                     // stalling; we have bigger problems if we can't get any
                     // outbound peers.
                     if (!pto->HasPermission(NetPermissionFlags::NoBan)) {
                         LogPrintf("Timeout downloading headers from peer=%d, "
                                   "disconnecting\n",
                                   pto->GetId());
                         pto->fDisconnect = true;
                         return true;
                     } else {
                         LogPrintf("Timeout downloading headers from noban "
                                   "peer=%d, not disconnecting\n",
                                   pto->GetId());
                         // Reset the headers sync state so that we have a chance
                         // to try downloading from a different peer. Note: this
                         // will also result in at least one more getheaders
                         // message to be sent to this peer (eventually).
                         state.fSyncStarted = false;
                         nSyncStarted--;
                         state.m_headers_sync_timeout = 0us;
                     }
                 }
             } else {
                 // After we've caught up once, reset the timeout so we can't
                 // trigger disconnect later.
                 state.m_headers_sync_timeout = std::chrono::microseconds::max();
             }
         }
 
         // Check that outbound peers have reasonable chains GetTime() is used by
         // this anti-DoS logic so we can test this using mocktime.
         ConsiderEviction(*pto, GetTime<std::chrono::seconds>());
     } // release cs_main
 
     std::vector<CInv> vGetData;
 
     //
     // Message: getdata (blocks)
     //
     {
         LOCK(cs_main);
 
         CNodeState &state = *State(pto->GetId());
 
         if (CanServeBlocks(*peer) &&
             ((fFetch && !IsLimitedPeer(*peer)) ||
              !m_chainman.ActiveChainstate().IsInitialBlockDownload()) &&
             state.nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
             std::vector<const CBlockIndex *> vToDownload;
             NodeId staller = -1;
             FindNextBlocksToDownload(pto->GetId(),
                                      MAX_BLOCKS_IN_TRANSIT_PER_PEER -
                                          state.nBlocksInFlight,
                                      vToDownload, staller);
             for (const CBlockIndex *pindex : vToDownload) {
                 vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
                 BlockRequested(config, pto->GetId(), *pindex);
                 LogPrint(BCLog::NET, "Requesting block %s (%d) peer=%d\n",
                          pindex->GetBlockHash().ToString(), pindex->nHeight,
                          pto->GetId());
             }
             if (state.nBlocksInFlight == 0 && staller != -1) {
                 if (State(staller)->m_stalling_since == 0us) {
                     State(staller)->m_stalling_since = current_time;
                     LogPrint(BCLog::NET, "Stall started peer=%d\n", staller);
                 }
             }
         }
     } // release cs_main
 
     auto addGetDataAndMaybeFlush = [&](uint32_t type, const uint256 &hash) {
         CInv inv(type, hash);
         LogPrint(BCLog::NET, "Requesting %s from peer=%d\n", inv.ToString(),
                  pto->GetId());
         vGetData.push_back(std::move(inv));
         if (vGetData.size() >= MAX_GETDATA_SZ) {
             m_connman.PushMessage(
                 pto, msgMaker.Make(NetMsgType::GETDATA, std::move(vGetData)));
             vGetData.clear();
         }
     };
 
     //
     // Message: getdata (proof)
     //
     {
         LOCK(cs_proofrequest);
         std::vector<std::pair<NodeId, avalanche::ProofId>> expired;
         auto requestable =
             m_proofrequest.GetRequestable(pto->GetId(), current_time, &expired);
         for (const auto &entry : expired) {
             LogPrint(BCLog::AVALANCHE,
                      "timeout of inflight proof %s from peer=%d\n",
                      entry.second.ToString(), entry.first);
         }
         for (const auto &proofid : requestable) {
             if (!AlreadyHaveProof(proofid)) {
                 addGetDataAndMaybeFlush(MSG_AVA_PROOF, proofid);
                 m_proofrequest.RequestedData(
                     pto->GetId(), proofid,
                     current_time + PROOF_REQUEST_PARAMS.getdata_interval);
             } else {
                 // We have already seen this proof, no need to download.
                 // This is just a belt-and-suspenders, as this should
                 // already be called whenever a proof becomes
                 // AlreadyHaveProof().
                 m_proofrequest.ForgetInvId(proofid);
             }
         }
     } // release cs_proofrequest
 
     //
     // Message: getdata (transactions)
     //
     {
         LOCK(cs_main);
         std::vector<std::pair<NodeId, TxId>> expired;
         auto requestable =
             m_txrequest.GetRequestable(pto->GetId(), current_time, &expired);
         for (const auto &entry : expired) {
             LogPrint(BCLog::NET, "timeout of inflight tx %s from peer=%d\n",
                      entry.second.ToString(), entry.first);
         }
         for (const TxId &txid : requestable) {
             if (!AlreadyHaveTx(txid)) {
                 addGetDataAndMaybeFlush(MSG_TX, txid);
                 m_txrequest.RequestedData(
                     pto->GetId(), txid,
                     current_time + TX_REQUEST_PARAMS.getdata_interval);
             } else {
                 // We have already seen this transaction, no need to download.
                 // This is just a belt-and-suspenders, as this should already be
                 // called whenever a transaction becomes AlreadyHaveTx().
                 m_txrequest.ForgetInvId(txid);
             }
         }
 
         if (!vGetData.empty()) {
             m_connman.PushMessage(pto,
                                   msgMaker.Make(NetMsgType::GETDATA, vGetData));
         }
 
     } // release cs_main
     MaybeSendFeefilter(*pto, *peer, current_time);
     return true;
 }
 
 bool PeerManagerImpl::ReceivedAvalancheProof(CNode &node, Peer &peer,
                                              const avalanche::ProofRef &proof) {
     assert(proof != nullptr);
 
     const avalanche::ProofId &proofid = proof->getId();
 
     AddKnownProof(peer, proofid);
 
     if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
         // We cannot reliably verify proofs during IBD, so bail out early and
         // keep the inventory as pending so it can be requested when the node
         // has synced.
         return true;
     }
 
     const NodeId nodeid = node.GetId();
 
     auto saveProofIfOutbound = [](const CNode &node,
                                   const avalanche::ProofId &proofid,
                                   const NodeId nodeid) -> bool {
         if (node.IsAvalancheOutboundConnection() || node.IsManualConn()) {
             LogPrint(BCLog::AVALANCHE, "Saving remote proof %s\n",
                      proofid.ToString());
             return g_avalanche->withPeerManager(
                 [&](avalanche::PeerManager &pm) {
                     return pm.saveRemoteProof(proofid, nodeid, true);
                 });
         }
 
         return false;
     };
 
     {
         LOCK(cs_proofrequest);
         m_proofrequest.ReceivedResponse(nodeid, proofid);
 
         if (AlreadyHaveProof(proofid)) {
             m_proofrequest.ForgetInvId(proofid);
             saveProofIfOutbound(node, proofid, nodeid);
             return true;
         }
     }
 
     // registerProof should not be called while cs_proofrequest because it
     // holds cs_main and that creates a potential deadlock during shutdown
 
     avalanche::ProofRegistrationState state;
     if (g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
             return pm.registerProof(proof, state);
         })) {
         WITH_LOCK(cs_proofrequest, m_proofrequest.ForgetInvId(proofid));
         RelayProof(proofid);
 
         node.m_last_proof_time = GetTime<std::chrono::seconds>();
 
         LogPrint(BCLog::NET, "New avalanche proof: peer=%d, proofid %s\n",
                  nodeid, proofid.ToString());
     }
 
     if (state.GetResult() == avalanche::ProofRegistrationResult::INVALID) {
         g_avalanche->withPeerManager(
             [&](avalanche::PeerManager &pm) { pm.setInvalid(proofid); });
         Misbehaving(nodeid, 100, state.GetRejectReason());
         return false;
     }
 
     if (state.GetResult() == avalanche::ProofRegistrationResult::MISSING_UTXO) {
         // This is possible that a proof contains a utxo we don't know yet, so
         // don't ban for this.
         return false;
     }
 
     if (!g_avalanche->reconcileOrFinalize(proof)) {
         LogPrint(BCLog::AVALANCHE,
                  "Not polling the avalanche proof (%s): peer=%d, proofid %s\n",
                  state.IsValid() ? "not-worth-polling"
                                  : state.GetRejectReason(),
                  nodeid, proofid.ToString());
     }
 
     saveProofIfOutbound(node, proofid, nodeid);
 
     return true;
 }
diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
index 46dd0f2a6..f6084b434 100644
--- a/src/qt/clientmodel.h
+++ b/src/qt/clientmodel.h
@@ -1,130 +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();
+    BlockHash getBestBlockHash() EXCLUSIVE_LOCKS_REQUIRED(!m_cached_tip_mutex);
     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: hash, number of blocks and block time
     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/random.cpp b/src/random.cpp
index 99462500a..7b5170513 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -1,797 +1,800 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <random.h>
 
 #ifdef WIN32
 #include <compat.h> // for Windows API
 #include <wincrypt.h>
 #endif
 #include <compat/cpuid.h>
 #include <crypto/sha256.h>
 #include <crypto/sha512.h>
 #include <logging.h> // for LogPrintf()
 #include <randomenv.h>
 #include <span.h>
 #include <support/allocators/secure.h>
 #include <support/cleanse.h>
 #include <sync.h>      // for Mutex
 #include <util/time.h> // for GetTimeMicros()
 
 #include <cmath>
 #include <cstdlib>
 #include <memory>
 #include <thread>
 
 #ifndef WIN32
 #include <fcntl.h>
 #include <sys/time.h>
 #endif
 
 #ifdef HAVE_SYS_GETRANDOM
 #include <linux/random.h>
 #include <sys/syscall.h>
 #endif
 #if defined(HAVE_GETENTROPY) ||                                                \
     (defined(HAVE_GETENTROPY_RAND) && defined(MAC_OSX))
 #include <unistd.h>
 #endif
 #if defined(HAVE_GETENTROPY_RAND) && defined(MAC_OSX)
 #include <sys/random.h>
 #endif
 #ifdef HAVE_SYSCTL_ARND
 #include <sys/sysctl.h>
 #endif
 
 [[noreturn]] static void RandFailure() {
     LogPrintf("Failed to read randomness, aborting\n");
     std::abort();
 }
 
 static inline int64_t GetPerformanceCounter() noexcept {
 // Read the hardware time stamp counter when available.
 // See https://en.wikipedia.org/wiki/Time_Stamp_Counter for more information.
 #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
     return __rdtsc();
 #elif !defined(_MSC_VER) && defined(__i386__)
     uint64_t r = 0;
     // Constrain the r variable to the eax:edx pair.
     __asm__ volatile("rdtsc" : "=A"(r));
     return r;
 #elif !defined(_MSC_VER) && (defined(__x86_64__) || defined(__amd64__))
     uint64_t r1 = 0, r2 = 0;
     // Constrain r1 to rax and r2 to rdx.
     __asm__ volatile("rdtsc" : "=a"(r1), "=d"(r2));
     return (r2 << 32) | r1;
 #else
     // Fall back to using C++11 clock (usually microsecond or nanosecond
     // precision)
     return std::chrono::high_resolution_clock::now().time_since_epoch().count();
 #endif
 }
 
 #ifdef HAVE_GETCPUID
 static bool g_rdrand_supported = false;
 static bool g_rdseed_supported = false;
 static constexpr uint32_t CPUID_F1_ECX_RDRAND = 0x40000000;
 static constexpr uint32_t CPUID_F7_EBX_RDSEED = 0x00040000;
 #ifdef bit_RDRND
 static_assert(CPUID_F1_ECX_RDRAND == bit_RDRND,
               "Unexpected value for bit_RDRND");
 #endif
 #ifdef bit_RDSEED
 static_assert(CPUID_F7_EBX_RDSEED == bit_RDSEED,
               "Unexpected value for bit_RDSEED");
 #endif
 
 static void InitHardwareRand() {
     uint32_t eax, ebx, ecx, edx;
     GetCPUID(1, 0, eax, ebx, ecx, edx);
     if (ecx & CPUID_F1_ECX_RDRAND) {
         g_rdrand_supported = true;
     }
     GetCPUID(7, 0, eax, ebx, ecx, edx);
     if (ebx & CPUID_F7_EBX_RDSEED) {
         g_rdseed_supported = true;
     }
 }
 
 static void ReportHardwareRand() {
     // This must be done in a separate function, as InitHardwareRand() may be
     // indirectly called from global constructors, before logging is
     // initialized.
     if (g_rdseed_supported) {
         LogPrintf("Using RdSeed as additional entropy source\n");
     }
     if (g_rdrand_supported) {
         LogPrintf("Using RdRand as an additional entropy source\n");
     }
 }
 
 /**
  * Read 64 bits of entropy using rdrand.
  *
  * Must only be called when RdRand is supported.
  */
 static uint64_t GetRdRand() noexcept {
     // RdRand may very rarely fail. Invoke it up to 10 times in a loop to reduce
     // this risk.
 #ifdef __i386__
     uint8_t ok;
     // Initialize to 0 to silence a compiler warning that r1 or r2 may be used
     // uninitialized. Even if rdrand fails (!ok) it will set the output to 0,
     // but there is no way that the compiler could know that.
     uint32_t r1 = 0, r2 = 0;
     for (int i = 0; i < 10; ++i) {
         // rdrand %eax
         __asm__ volatile(".byte 0x0f, 0xc7, 0xf0; setc %1"
                          : "=a"(r1), "=q"(ok)::"cc");
         if (ok) {
             break;
         }
     }
     for (int i = 0; i < 10; ++i) {
         // rdrand %eax
         __asm__ volatile(".byte 0x0f, 0xc7, 0xf0; setc %1"
                          : "=a"(r2), "=q"(ok)::"cc");
         if (ok) {
             break;
         }
     }
     return (uint64_t(r2) << 32) | r1;
 #elif defined(__x86_64__) || defined(__amd64__)
     uint8_t ok;
     uint64_t r1 = 0; // See above why we initialize to 0.
     for (int i = 0; i < 10; ++i) {
         // rdrand %rax
         __asm__ volatile(".byte 0x48, 0x0f, 0xc7, 0xf0; setc %1"
                          : "=a"(r1), "=q"(ok)::"cc");
         if (ok) {
             break;
         }
     }
     return r1;
 #else
 #error "RdRand is only supported on x86 and x86_64"
 #endif
 }
 
 /**
  * Read 64 bits of entropy using rdseed.
  *
  * Must only be called when RdSeed is supported.
  */
 static uint64_t GetRdSeed() noexcept {
     // RdSeed may fail when the HW RNG is overloaded. Loop indefinitely until
     // enough entropy is gathered, but pause after every failure.
 #ifdef __i386__
     uint8_t ok;
     uint32_t r1, r2;
     do {
         // rdseed %eax
         __asm__ volatile(".byte 0x0f, 0xc7, 0xf8; setc %1"
                          : "=a"(r1), "=q"(ok)::"cc");
         if (ok) {
             break;
         }
         __asm__ volatile("pause");
     } while (true);
     do {
         // rdseed %eax
         __asm__ volatile(".byte 0x0f, 0xc7, 0xf8; setc %1"
                          : "=a"(r2), "=q"(ok)::"cc");
         if (ok) {
             break;
         }
         __asm__ volatile("pause");
     } while (true);
     return (uint64_t(r2) << 32) | r1;
 #elif defined(__x86_64__) || defined(__amd64__)
     uint8_t ok;
     uint64_t r1;
     do {
         // rdseed %rax
         __asm__ volatile(".byte 0x48, 0x0f, 0xc7, 0xf8; setc %1"
                          : "=a"(r1), "=q"(ok)::"cc");
         if (ok) {
             break;
         }
         __asm__ volatile("pause");
     } while (true);
     return r1;
 #else
 #error "RdSeed is only supported on x86 and x86_64"
 #endif
 }
 
 #else
 /**
  * Access to other hardware random number generators could be added here later,
  * assuming it is sufficiently fast (in the order of a few hundred CPU cycles).
  * Slower sources should probably be invoked separately, and/or only from
  * RandAddPeriodic (which is called once a minute).
  */
 static void InitHardwareRand() {}
 static void ReportHardwareRand() {}
 #endif
 
 /**
  * Add 64 bits of entropy gathered from hardware to hasher. Do nothing if not
  * supported.
  */
 static void SeedHardwareFast(CSHA512 &hasher) noexcept {
 #if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
     if (g_rdrand_supported) {
         uint64_t out = GetRdRand();
         hasher.Write((const uint8_t *)&out, sizeof(out));
         return;
     }
 #endif
 }
 
 /**
  * Add 256 bits of entropy gathered from hardware to hasher. Do nothing if not
  * supported.
  */
 static void SeedHardwareSlow(CSHA512 &hasher) noexcept {
 #if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
     // When we want 256 bits of entropy, prefer RdSeed over RdRand, as it's
     // guaranteed to produce independent randomness on every call.
     if (g_rdseed_supported) {
         for (int i = 0; i < 4; ++i) {
             uint64_t out = GetRdSeed();
             hasher.Write((const uint8_t *)&out, sizeof(out));
         }
         return;
     }
     // When falling back to RdRand, XOR the result of 1024 results.
     // This guarantees a reseeding occurs between each.
     if (g_rdrand_supported) {
         for (int i = 0; i < 4; ++i) {
             uint64_t out = 0;
             for (int j = 0; j < 1024; ++j) {
                 out ^= GetRdRand();
             }
             hasher.Write((const uint8_t *)&out, sizeof(out));
         }
         return;
     }
 #endif
 }
 
 /**
  * Use repeated SHA512 to strengthen the randomness in seed32, and feed into
  * hasher.
  */
 static void Strengthen(const uint8_t (&seed)[32], int microseconds,
                        CSHA512 &hasher) noexcept {
     CSHA512 inner_hasher;
     inner_hasher.Write(seed, sizeof(seed));
 
     // Hash loop
     uint8_t buffer[64];
     int64_t stop = GetTimeMicros() + microseconds;
     do {
         for (int i = 0; i < 1000; ++i) {
             inner_hasher.Finalize(buffer);
             inner_hasher.Reset();
             inner_hasher.Write(buffer, sizeof(buffer));
         }
         // Benchmark operation and feed it into outer hasher.
         int64_t perf = GetPerformanceCounter();
         hasher.Write((const uint8_t *)&perf, sizeof(perf));
     } while (GetTimeMicros() < stop);
 
     // Produce output from inner state and feed it to outer hasher.
     inner_hasher.Finalize(buffer);
     hasher.Write(buffer, sizeof(buffer));
     // Try to clean up.
     inner_hasher.Reset();
     memory_cleanse(buffer, sizeof(buffer));
 }
 
 #ifndef WIN32
 /**
  * Fallback: get 32 bytes of system entropy from /dev/urandom. The most
  * compatible way to get cryptographic randomness on UNIX-ish platforms.
  */
 static void GetDevURandom(uint8_t *ent32) {
     int f = open("/dev/urandom", O_RDONLY);
     if (f == -1) {
         RandFailure();
     }
     int have = 0;
     do {
         ssize_t n = read(f, ent32 + have, NUM_OS_RANDOM_BYTES - have);
         if (n <= 0 || n + have > NUM_OS_RANDOM_BYTES) {
             close(f);
             RandFailure();
         }
         have += n;
     } while (have < NUM_OS_RANDOM_BYTES);
     close(f);
 }
 #endif
 
 /** Get 32 bytes of system entropy. */
 void GetOSRand(uint8_t *ent32) {
 #if defined(WIN32)
     HCRYPTPROV hProvider;
     int ret = CryptAcquireContextW(&hProvider, nullptr, nullptr, PROV_RSA_FULL,
                                    CRYPT_VERIFYCONTEXT);
     if (!ret) {
         RandFailure();
     }
     ret = CryptGenRandom(hProvider, NUM_OS_RANDOM_BYTES, ent32);
     if (!ret) {
         RandFailure();
     }
     CryptReleaseContext(hProvider, 0);
 #elif defined(HAVE_SYS_GETRANDOM)
     /**
      * Linux. From the getrandom(2) man page:
      * "If the urandom source has been initialized, reads of up to 256 bytes
      * will always return as many bytes as requested and will not be interrupted
      * by signals."
      */
     int rv = syscall(SYS_getrandom, ent32, NUM_OS_RANDOM_BYTES, 0);
     if (rv != NUM_OS_RANDOM_BYTES) {
         if (rv < 0 && errno == ENOSYS) {
             /* Fallback for kernel <3.17: the return value will be -1 and errno
              * ENOSYS if the syscall is not available, in that case fall back
              * to /dev/urandom.
              */
             GetDevURandom(ent32);
         } else {
             RandFailure();
         }
     }
 #elif defined(HAVE_GETENTROPY) && defined(__OpenBSD__)
     /**
      * On OpenBSD this can return up to 256 bytes of entropy, will return an
      * error if more are requested.
      * The call cannot return less than the requested number of bytes.
      * getentropy is explicitly limited to openbsd here, as a similar (but not
      * the same) function may exist on other platforms via glibc.
      */
     if (getentropy(ent32, NUM_OS_RANDOM_BYTES) != 0) {
         RandFailure();
     }
     // Silence a compiler warning about unused function.
     (void)GetDevURandom;
 #elif defined(HAVE_GETENTROPY_RAND) && defined(MAC_OSX)
     /**
      * getentropy() is available on macOS 10.12 and later.
      */
     if (getentropy(ent32, NUM_OS_RANDOM_BYTES) != 0) {
         RandFailure();
     }
     // Silence a compiler warning about unused function.
     (void)GetDevURandom;
 #elif defined(HAVE_SYSCTL_ARND)
     /**
      * FreeBSD and similar. It is possible for the call to return less bytes
      * than requested, so need to read in a loop.
      */
     static const int name[2] = {CTL_KERN, KERN_ARND};
     int have = 0;
     do {
         size_t len = NUM_OS_RANDOM_BYTES - have;
         if (sysctl(name, std::size(name), ent32 + have, &len, nullptr, 0) !=
             0) {
             RandFailure();
         }
         have += len;
     } while (have < NUM_OS_RANDOM_BYTES);
     // Silence a compiler warning about unused function.
     (void)GetDevURandom;
 #else
     /**
      * Fall back to /dev/urandom if there is no specific method implemented to
      * get system entropy for this OS.
      */
     GetDevURandom(ent32);
 #endif
 }
 
 namespace {
 
 class RNGState {
     Mutex m_mutex;
     /**
      * The RNG state consists of 256 bits of entropy, taken from the output of
      * one operation's SHA512 output, and fed as input to the next one.
      * Carrying 256 bits of entropy should be sufficient to guarantee
      * unpredictability as long as any entropy source was ever unpredictable
      * to an attacker. To protect against situations where an attacker might
      * observe the RNG's state, fresh entropy is always mixed when
      * GetStrongRandBytes is called.
      */
     uint8_t m_state[32] GUARDED_BY(m_mutex) = {0};
     uint64_t m_counter GUARDED_BY(m_mutex) = 0;
     bool m_strongly_seeded GUARDED_BY(m_mutex) = false;
 
     Mutex m_events_mutex;
     CSHA256 m_events_hasher GUARDED_BY(m_events_mutex);
 
 public:
     RNGState() noexcept { InitHardwareRand(); }
 
     ~RNGState() {}
 
-    void AddEvent(uint32_t event_info) noexcept {
+    void AddEvent(uint32_t event_info) noexcept
+        EXCLUSIVE_LOCKS_REQUIRED(!m_events_mutex) {
         LOCK(m_events_mutex);
 
         m_events_hasher.Write((const uint8_t *)&event_info, sizeof(event_info));
         // Get the low four bytes of the performance counter. This translates to
         // roughly the subsecond part.
         uint32_t perfcounter = (GetPerformanceCounter() & 0xffffffff);
         m_events_hasher.Write((const uint8_t *)&perfcounter,
                               sizeof(perfcounter));
     }
 
     /**
      * Feed (the hash of) all events added through AddEvent() to hasher.
      */
-    void SeedEvents(CSHA512 &hasher) noexcept {
+    void SeedEvents(CSHA512 &hasher) noexcept
+        EXCLUSIVE_LOCKS_REQUIRED(!m_events_mutex) {
         // We use only SHA256 for the events hashing to get the ASM speedups we
         // have for SHA256, since we want it to be fast as network peers may be
         // able to trigger it repeatedly.
         LOCK(m_events_mutex);
 
         uint8_t events_hash[32];
         m_events_hasher.Finalize(events_hash);
         hasher.Write(events_hash, 32);
 
         // Re-initialize the hasher with the finalized state to use later.
         m_events_hasher.Reset();
         m_events_hasher.Write(events_hash, 32);
     }
 
     /**
      * Extract up to 32 bytes of entropy from the RNG state, mixing in new
      * entropy from hasher.
      *
      * If this function has never been called with strong_seed = true, false is
      * returned.
      */
     bool MixExtract(uint8_t *out, size_t num, CSHA512 &&hasher,
-                    bool strong_seed) noexcept {
+                    bool strong_seed) noexcept
+        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         assert(num <= 32);
         uint8_t buf[64];
         static_assert(sizeof(buf) == CSHA512::OUTPUT_SIZE,
                       "Buffer needs to have hasher's output size");
         bool ret;
         {
             LOCK(m_mutex);
             ret = (m_strongly_seeded |= strong_seed);
             // Write the current state of the RNG into the hasher
             hasher.Write(m_state, 32);
             // Write a new counter number into the state
             hasher.Write((const uint8_t *)&m_counter, sizeof(m_counter));
             ++m_counter;
             // Finalize the hasher
             hasher.Finalize(buf);
             // Store the last 32 bytes of the hash output as new RNG state.
             memcpy(m_state, buf + 32, 32);
         }
         // If desired, copy (up to) the first 32 bytes of the hash output as
         // output.
         if (num) {
             assert(out != nullptr);
             memcpy(out, buf, num);
         }
         // Best effort cleanup of internal state
         hasher.Reset();
         memory_cleanse(buf, 64);
         return ret;
     }
 };
 
 RNGState &GetRNGState() noexcept {
     // This C++11 idiom relies on the guarantee that static variable are
     // initialized on first call, even when multiple parallel calls are
     // permitted.
     static std::vector<RNGState, secure_allocator<RNGState>> g_rng(1);
     return g_rng[0];
 }
 } // namespace
 
 /**
  * A note on the use of noexcept in the seeding functions below:
  *
  * None of the RNG code should ever throw any exception.
  */
 
 static void SeedTimestamp(CSHA512 &hasher) noexcept {
     int64_t perfcounter = GetPerformanceCounter();
     hasher.Write((const uint8_t *)&perfcounter, sizeof(perfcounter));
 }
 
 static void SeedFast(CSHA512 &hasher) noexcept {
     uint8_t buffer[32];
 
     // Stack pointer to indirectly commit to thread/callstack
     const uint8_t *ptr = buffer;
     hasher.Write((const uint8_t *)&ptr, sizeof(ptr));
 
     // Hardware randomness is very fast when available; use it always.
     SeedHardwareFast(hasher);
 
     // High-precision timestamp
     SeedTimestamp(hasher);
 }
 
 static void SeedSlow(CSHA512 &hasher, RNGState &rng) noexcept {
     uint8_t buffer[32];
 
     // Everything that the 'fast' seeder includes
     SeedFast(hasher);
 
     // OS randomness
     GetOSRand(buffer);
     hasher.Write(buffer, sizeof(buffer));
 
     // Add the events hasher into the mix
     rng.SeedEvents(hasher);
 
     // High-precision timestamp.
     //
     // Note that we also commit to a timestamp in the Fast seeder, so we
     // indirectly commit to a benchmark of all the entropy gathering sources in
     // this function).
     SeedTimestamp(hasher);
 }
 
 /** Extract entropy from rng, strengthen it, and feed it into hasher. */
 static void SeedStrengthen(CSHA512 &hasher, RNGState &rng,
                            int microseconds) noexcept {
     // Generate 32 bytes of entropy from the RNG, and a copy of the entropy
     // already in hasher.
     uint8_t strengthen_seed[32];
     rng.MixExtract(strengthen_seed, sizeof(strengthen_seed), CSHA512(hasher),
                    false);
     // Strengthen the seed, and feed it into hasher.
     Strengthen(strengthen_seed, microseconds, hasher);
 }
 
 static void SeedPeriodic(CSHA512 &hasher, RNGState &rng) noexcept {
     // Everything that the 'fast' seeder includes
     SeedFast(hasher);
 
     // High-precision timestamp
     SeedTimestamp(hasher);
 
     // Add the events hasher into the mix
     rng.SeedEvents(hasher);
 
     // Dynamic environment data (performance monitoring, ...)
     auto old_size = hasher.Size();
     RandAddDynamicEnv(hasher);
     LogPrint(BCLog::RAND,
              "Feeding %i bytes of dynamic environment data into RNG\n",
              hasher.Size() - old_size);
 
     // Strengthen for 10ms
     SeedStrengthen(hasher, rng, 10000);
 }
 
 static void SeedStartup(CSHA512 &hasher, RNGState &rng) noexcept {
     // Gather 256 bits of hardware randomness, if available
     SeedHardwareSlow(hasher);
 
     // Everything that the 'slow' seeder includes.
     SeedSlow(hasher, rng);
 
     // Dynamic environment data (performance monitoring, ...)
     auto old_size = hasher.Size();
     RandAddDynamicEnv(hasher);
 
     // Static environment data
     RandAddStaticEnv(hasher);
     LogPrint(BCLog::RAND, "Feeding %i bytes of environment data into RNG\n",
              hasher.Size() - old_size);
 
     // Strengthen for 100ms
     SeedStrengthen(hasher, rng, 100000);
 }
 
 enum class RNGLevel {
     FAST,     //!< Automatically called by GetRandBytes
     SLOW,     //!< Automatically called by GetStrongRandBytes
     PERIODIC, //!< Called by RandAddPeriodic()
 };
 
 static void ProcRand(uint8_t *out, int num, RNGLevel level) noexcept {
     // Make sure the RNG is initialized first (as all Seed* function possibly
     // need hwrand to be available).
     RNGState &rng = GetRNGState();
 
     assert(num <= 32);
 
     CSHA512 hasher;
     switch (level) {
         case RNGLevel::FAST:
             SeedFast(hasher);
             break;
         case RNGLevel::SLOW:
             SeedSlow(hasher, rng);
             break;
         case RNGLevel::PERIODIC:
             SeedPeriodic(hasher, rng);
             break;
     }
 
     // Combine with and update state
     if (!rng.MixExtract(out, num, std::move(hasher), false)) {
         // On the first invocation, also seed with SeedStartup().
         CSHA512 startup_hasher;
         SeedStartup(startup_hasher, rng);
         rng.MixExtract(out, num, std::move(startup_hasher), true);
     }
 }
 
 void GetRandBytes(Span<uint8_t> bytes) noexcept {
     ProcRand(bytes.data(), bytes.size(), RNGLevel::FAST);
 }
 void GetStrongRandBytes(Span<uint8_t> bytes) noexcept {
     ProcRand(bytes.data(), bytes.size(), RNGLevel::SLOW);
 }
 void RandAddPeriodic() noexcept {
     ProcRand(nullptr, 0, RNGLevel::PERIODIC);
 }
 
 void RandAddEvent(const uint32_t event_info) noexcept {
     GetRNGState().AddEvent(event_info);
 }
 
 bool g_mock_deterministic_tests{false};
 
 uint64_t GetRandInternal(uint64_t nMax) noexcept {
     return FastRandomContext(g_mock_deterministic_tests).randrange(nMax);
 }
 
 uint256 GetRandHash() noexcept {
     uint256 hash;
     GetRandBytes(hash);
     return hash;
 }
 
 void FastRandomContext::RandomSeed() {
     uint256 seed = GetRandHash();
     rng.SetKey(seed.begin(), 32);
     requires_seed = false;
 }
 
 uint160 FastRandomContext::rand160() noexcept {
     if (bytebuf_size < 20) {
         FillByteBuffer();
     }
     uint160 ret;
     memcpy(ret.begin(), bytebuf + 64 - bytebuf_size, 20);
     bytebuf_size -= 20;
     return ret;
 }
 
 uint256 FastRandomContext::rand256() noexcept {
     if (bytebuf_size < 32) {
         FillByteBuffer();
     }
     uint256 ret;
     memcpy(ret.begin(), bytebuf + 64 - bytebuf_size, 32);
     bytebuf_size -= 32;
     return ret;
 }
 std::vector<uint8_t> FastRandomContext::randbytes(size_t len) {
     if (requires_seed) {
         RandomSeed();
     }
     std::vector<uint8_t> ret(len);
     if (len > 0) {
         rng.Keystream(ret.data(), len);
     }
     return ret;
 }
 
 FastRandomContext::FastRandomContext(const uint256 &seed) noexcept
     : requires_seed(false), bytebuf_size(0), bitbuf_size(0) {
     rng.SetKey(seed.begin(), 32);
 }
 
 bool Random_SanityCheck() {
     uint64_t start = GetPerformanceCounter();
 
     /**
      * This does not measure the quality of randomness, but it does test that
      * GetOSRand() overwrites all 32 bytes of the output given a maximum number
      * of tries.
      */
     static const ssize_t MAX_TRIES = 1024;
     uint8_t data[NUM_OS_RANDOM_BYTES];
     /* Tracks which bytes have been overwritten at least once */
     bool overwritten[NUM_OS_RANDOM_BYTES] = {};
     int num_overwritten;
     int tries = 0;
     /**
      * Loop until all bytes have been overwritten at least once, or max number
      * tries reached.
      */
     do {
         memset(data, 0, NUM_OS_RANDOM_BYTES);
         GetOSRand(data);
         for (int x = 0; x < NUM_OS_RANDOM_BYTES; ++x) {
             overwritten[x] |= (data[x] != 0);
         }
 
         num_overwritten = 0;
         for (int x = 0; x < NUM_OS_RANDOM_BYTES; ++x) {
             if (overwritten[x]) {
                 num_overwritten += 1;
             }
         }
 
         tries += 1;
     } while (num_overwritten < NUM_OS_RANDOM_BYTES && tries < MAX_TRIES);
     /* If this failed, bailed out after too many tries */
     if (num_overwritten != NUM_OS_RANDOM_BYTES) {
         return false;
     }
 
     // Check that GetPerformanceCounter increases at least during a GetOSRand()
     // call + 1ms sleep.
     std::this_thread::sleep_for(std::chrono::milliseconds(1));
     uint64_t stop = GetPerformanceCounter();
     if (stop == start) {
         return false;
     }
 
     // We called GetPerformanceCounter. Use it as entropy.
     CSHA512 to_add;
     to_add.Write((const uint8_t *)&start, sizeof(start));
     to_add.Write((const uint8_t *)&stop, sizeof(stop));
     GetRNGState().MixExtract(nullptr, 0, std::move(to_add), false);
 
     return true;
 }
 
 FastRandomContext::FastRandomContext(bool fDeterministic) noexcept
     : requires_seed(!fDeterministic), bytebuf_size(0), bitbuf_size(0) {
     if (!fDeterministic) {
         return;
     }
     uint256 seed;
     rng.SetKey(seed.begin(), 32);
 }
 
 FastRandomContext &
 FastRandomContext::operator=(FastRandomContext &&from) noexcept {
     requires_seed = from.requires_seed;
     rng = from.rng;
     std::copy(std::begin(from.bytebuf), std::end(from.bytebuf),
               std::begin(bytebuf));
     bytebuf_size = from.bytebuf_size;
     bitbuf = from.bitbuf;
     bitbuf_size = from.bitbuf_size;
     from.requires_seed = true;
     from.bytebuf_size = 0;
     from.bitbuf_size = 0;
     return *this;
 }
 
 void RandomInit() {
     // Invoke RNG code to trigger initialization (if not already performed)
     ProcRand(nullptr, 0, RNGLevel::FAST);
 
     ReportHardwareRand();
 }
 
 std::chrono::microseconds
 GetExponentialRand(std::chrono::microseconds now,
                    std::chrono::seconds average_interval) {
     double unscaled = -std::log1p(GetRand(uint64_t{1} << 48) *
                                   -0.0000000000000035527136788 /* -1/2^48 */);
     return now + std::chrono::duration_cast<std::chrono::microseconds>(
                      unscaled * average_interval + 0.5us);
 }
diff --git a/src/scheduler.h b/src/scheduler.h
index 6d4c74fa9..d7f5988e5 100644
--- a/src/scheduler.h
+++ b/src/scheduler.h
@@ -1,171 +1,179 @@
 // Copyright (c) 2015 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_SCHEDULER_H
 #define BITCOIN_SCHEDULER_H
 
 #include <attributes.h>
 #include <sync.h>
 #include <threadsafety.h>
 
 #include <chrono>
 #include <condition_variable>
 #include <cstddef>
 #include <functional>
 #include <list>
 #include <map>
 #include <thread>
 #include <utility>
 
 /**
  * Simple class for background tasks that should be run periodically or once
  * "after a while"
  *
  * Usage:
  *
  * CScheduler* s = new CScheduler();
  *  * Assuming a: void doSomething() { }
  * s->scheduleFromNow(doSomething, std::chrono::milliseconds{11});
  * s->scheduleFromNow([=] { this->func(argument); },
  *                    std::chrono::milliseconds{3});
  * std::thread *t = new std::thread([?] { s->serviceQueue(); });
  *
  * ... then at program shutdown, make sure to call stop() to clean up the
  * thread(s) running serviceQueue:
  * s->stop();
  * t->join();
  * delete t;
  * delete s; // Must be done after thread is interrupted/joined.
  */
 class CScheduler {
 public:
     CScheduler();
     ~CScheduler();
 
     std::thread m_service_thread;
 
     typedef std::function<void()> Function;
     typedef std::function<bool()> Predicate;
 
     /** Call func at/after time t */
-    void schedule(Function f, std::chrono::steady_clock::time_point t);
+    void schedule(Function f, std::chrono::steady_clock::time_point t)
+        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
     /** Call f once after the delta has passed */
-    void scheduleFromNow(Function f, std::chrono::milliseconds delta) {
+    void scheduleFromNow(Function f, std::chrono::milliseconds delta)
+        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex) {
         schedule(std::move(f), std::chrono::steady_clock::now() + delta);
     }
 
     /**
      * Repeat p until it return false. First run is after delta has passed once.
      *
      * The timing is not exact: Every time p is finished, it is rescheduled to
      * run again after delta. If you need more accurate scheduling, don't use
      * this method.
      */
-    void scheduleEvery(Predicate p, std::chrono::milliseconds delta);
+    void scheduleEvery(Predicate p, std::chrono::milliseconds delta)
+        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
     /**
      * Mock the scheduler to fast forward in time.
      * Iterates through items on taskQueue and reschedules them
      * to be delta_seconds sooner.
      */
-    void MockForward(std::chrono::seconds delta_seconds);
+    void MockForward(std::chrono::seconds delta_seconds)
+        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
     /**
      * Services the queue 'forever'. Should be run in a thread.
      */
-    void serviceQueue();
+    void serviceQueue() EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
     /**
      * Tell any threads running serviceQueue to stop as soon as the current
      * task is done
      */
-    void stop() {
+    void stop() EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex) {
         WITH_LOCK(newTaskMutex, stopRequested = true);
         newTaskScheduled.notify_all();
         if (m_service_thread.joinable()) {
             m_service_thread.join();
         }
     }
 
     /**
      * Tell any threads running serviceQueue to stop when there is no work
      * left to be done
      */
-    void StopWhenDrained() {
+    void StopWhenDrained() EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex) {
         WITH_LOCK(newTaskMutex, stopWhenEmpty = true);
         newTaskScheduled.notify_all();
         if (m_service_thread.joinable()) {
             m_service_thread.join();
         }
     }
 
     /**
      * Returns number of tasks waiting to be serviced,
      * and first and last task times
      */
     size_t getQueueInfo(std::chrono::steady_clock::time_point &first,
-                        std::chrono::steady_clock::time_point &last) const;
+                        std::chrono::steady_clock::time_point &last) const
+        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
     /** Returns true if there are threads actively running in serviceQueue() */
-    bool AreThreadsServicingQueue() const;
+    bool AreThreadsServicingQueue() const
+        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
 private:
     mutable Mutex newTaskMutex;
     std::condition_variable newTaskScheduled;
     std::multimap<std::chrono::steady_clock::time_point, Function>
         taskQueue GUARDED_BY(newTaskMutex);
     int nThreadsServicingQueue GUARDED_BY(newTaskMutex){0};
     bool stopRequested GUARDED_BY(newTaskMutex){false};
     bool stopWhenEmpty GUARDED_BY(newTaskMutex){false};
     bool shouldStop() const EXCLUSIVE_LOCKS_REQUIRED(newTaskMutex) {
         return stopRequested || (stopWhenEmpty && taskQueue.empty());
     }
 };
 
 /**
  * Class used by CScheduler clients which may schedule multiple jobs
  * which are required to be run serially. Jobs may not be run on the
  * same thread, but no two jobs will be executed
  * at the same time and memory will be release-acquire consistent
  * (the scheduler will internally do an acquire before invoking a callback
  * as well as a release at the end). In practice this means that a callback
  * B() will be able to observe all of the effects of callback A() which executed
  * before it.
  */
 class SingleThreadedSchedulerClient {
 private:
     CScheduler &m_scheduler;
 
     Mutex m_callbacks_mutex;
     std::list<std::function<void()>>
         m_callbacks_pending GUARDED_BY(m_callbacks_mutex);
     bool m_are_callbacks_running GUARDED_BY(m_callbacks_mutex) = false;
 
-    void MaybeScheduleProcessQueue();
-    void ProcessQueue();
+    void MaybeScheduleProcessQueue()
+        EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
+    void ProcessQueue() EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
 
 public:
     explicit SingleThreadedSchedulerClient(CScheduler &scheduler LIFETIMEBOUND)
         : m_scheduler{scheduler} {}
 
     /**
      * Add a callback to be executed. Callbacks are executed serially
      * and memory is release-acquire consistent between callback executions.
      * Practially, this means that callbacks can behave as if they are executed
      * in order by a single thread.
      */
-    void AddToProcessQueue(std::function<void()> func);
+    void AddToProcessQueue(std::function<void()> func)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
 
     /**
      * Processes all remaining queue members on the calling thread, blocking
      * until queue is empty.
      * Must be called after the CScheduler has no remaining processing threads!
      */
-    void EmptyQueue();
+    void EmptyQueue() EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
 
-    size_t CallbacksPending();
+    size_t CallbacksPending() EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
 };
 
 #endif // BITCOIN_SCHEDULER_H
diff --git a/src/sync.h b/src/sync.h
index d7fa98c36..c6523daf1 100644
--- a/src/sync.h
+++ b/src/sync.h
@@ -1,384 +1,396 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SYNC_H
 #define BITCOIN_SYNC_H
 
 #ifdef DEBUG_LOCKCONTENTION
 #include <logging.h>
 #include <logging/timer.h>
 #endif
 
 #include <threadsafety.h>
 #include <util/macros.h>
 
 #include <condition_variable>
 #include <mutex>
 #include <string>
 #include <thread>
 
 /////////////////////////////////////////////////
 //                                             //
 // THE SIMPLE DEFINITION, EXCLUDING DEBUG CODE //
 //                                             //
 /////////////////////////////////////////////////
 
 /*
 RecursiveMutex mutex;
     std::recursive_mutex mutex;
 
 LOCK(mutex);
     std::unique_lock<std::recursive_mutex> criticalblock(mutex);
 
 LOCK2(mutex1, mutex2);
     std::unique_lock<std::recursive_mutex> criticalblock1(mutex1);
     std::unique_lock<std::recursive_mutex> criticalblock2(mutex2);
 
 TRY_LOCK(mutex, name);
     std::unique_lock<std::recursive_mutex> name(mutex, std::try_to_lock_t);
 
 ENTER_CRITICAL_SECTION(mutex); // no RAII
     mutex.lock();
 
 LEAVE_CRITICAL_SECTION(mutex); // no RAII
     mutex.unlock();
  */
 
 ///////////////////////////////
 //                           //
 // THE ACTUAL IMPLEMENTATION //
 //                           //
 ///////////////////////////////
 
 #ifdef DEBUG_LOCKORDER
 template <typename MutexType>
 void EnterCritical(const char *pszName, const char *pszFile, int nLine,
                    MutexType *cs, bool fTry = false);
 void LeaveCritical();
 void CheckLastCritical(void *cs, std::string &lockname, const char *guardname,
                        const char *file, int line);
 std::string LocksHeld();
 template <typename MutexType>
 void AssertLockHeldInternal(const char *pszName, const char *pszFile, int nLine,
                             MutexType *cs) EXCLUSIVE_LOCKS_REQUIRED(cs);
 template <typename MutexType>
 void AssertLockNotHeldInternal(const char *pszName, const char *pszFile,
                                int nLine, MutexType *cs) LOCKS_EXCLUDED(cs);
 void DeleteLock(void *cs);
 bool LockStackEmpty();
 
 /**
  * Call abort() if a potential lock order deadlock bug is detected, instead of
  * just logging information and throwing a logic_error. Defaults to true, and
  * set to false in DEBUG_LOCKORDER unit tests.
  */
 extern bool g_debug_lockorder_abort;
 #else
 template <typename MutexType>
 inline void EnterCritical(const char *pszName, const char *pszFile, int nLine,
                           MutexType *cs, bool fTry = false) {}
 inline void LeaveCritical() {}
 inline void CheckLastCritical(void *cs, std::string &lockname,
                               const char *guardname, const char *file,
                               int line) {}
 template <typename MutexType>
 inline void AssertLockHeldInternal(const char *pszName, const char *pszFile,
                                    int nLine, MutexType *cs)
     EXCLUSIVE_LOCKS_REQUIRED(cs) {}
 template <typename MutexType>
 void AssertLockNotHeldInternal(const char *pszName, const char *pszFile,
                                int nLine, MutexType *cs) LOCKS_EXCLUDED(cs) {}
 inline void DeleteLock(void *cs) {}
 inline bool LockStackEmpty() {
     return true;
 }
 #endif
-#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
-#define AssertLockNotHeld(cs)                                                  \
-    AssertLockNotHeldInternal(#cs, __FILE__, __LINE__, &cs)
 
 /**
  * Template mixin that adds -Wthread-safety locking annotations and lock order
  * checking to a subset of the mutex API.
  */
 template <typename PARENT> class LOCKABLE AnnotatedMixin : public PARENT {
 public:
     ~AnnotatedMixin() { DeleteLock((void *)this); }
 
     void lock() EXCLUSIVE_LOCK_FUNCTION() { PARENT::lock(); }
 
     void unlock() UNLOCK_FUNCTION() { PARENT::unlock(); }
 
     bool try_lock() EXCLUSIVE_TRYLOCK_FUNCTION(true) {
         return PARENT::try_lock();
     }
 
     using UniqueLock = std::unique_lock<PARENT>;
 #ifdef __clang__
     //! For negative capabilities in the Clang Thread Safety Analysis.
     //! A negative requirement uses the EXCLUSIVE_LOCKS_REQUIRED attribute, in
     //! conjunction with the ! operator, to indicate that a mutex should not be
     //! held.
     const AnnotatedMixin &operator!() const { return *this; }
 #endif // __clang__
 };
 
 /**
  * Wrapped mutex: supports recursive locking, but no waiting
  * TODO: We should move away from using the recursive lock by default.
  */
 using RecursiveMutex = AnnotatedMixin<std::recursive_mutex>;
 
 /** Wrapped mutex: supports waiting but not recursive locking */
-typedef AnnotatedMixin<std::mutex> Mutex;
+using Mutex = AnnotatedMixin<std::mutex>;
+
+#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
+
+inline void AssertLockNotHeldInline(const char *name, const char *file,
+                                    int line, Mutex *cs)
+    EXCLUSIVE_LOCKS_REQUIRED(!cs) {
+    AssertLockNotHeldInternal(name, file, line, cs);
+}
+inline void AssertLockNotHeldInline(const char *name, const char *file,
+                                    int line, RecursiveMutex *cs)
+    LOCKS_EXCLUDED(cs) {
+    AssertLockNotHeldInternal(name, file, line, cs);
+}
+#define AssertLockNotHeld(cs)                                                  \
+    AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
 
 /** Wrapper around std::unique_lock style lock for Mutex. */
 template <typename Mutex, typename Base = typename Mutex::UniqueLock>
 class SCOPED_LOCKABLE UniqueLock : public Base {
 private:
     void Enter(const char *pszName, const char *pszFile, int nLine) {
         EnterCritical(pszName, pszFile, nLine, Base::mutex());
 #ifdef DEBUG_LOCKCONTENTION
         if (Base::try_lock()) {
             return;
         }
         LOG_TIME_MICROS_WITH_CATEGORY(
             strprintf("lock contention %s, %s:%d", pszName, pszFile, nLine),
             BCLog::LOCK);
 #endif
         Base::lock();
     }
 
     bool TryEnter(const char *pszName, const char *pszFile, int nLine) {
         EnterCritical(pszName, pszFile, nLine, Base::mutex(), true);
         if (Base::try_lock()) {
             return true;
         }
         LeaveCritical();
         return false;
     }
 
 public:
     UniqueLock(Mutex &mutexIn, const char *pszName, const char *pszFile,
                int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn)
         : Base(mutexIn, std::defer_lock) {
         if (fTry) {
             TryEnter(pszName, pszFile, nLine);
         } else {
             Enter(pszName, pszFile, nLine);
         }
     }
 
     UniqueLock(Mutex *pmutexIn, const char *pszName, const char *pszFile,
                int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(pmutexIn) {
         if (!pmutexIn) {
             return;
         }
 
         *static_cast<Base *>(this) = Base(*pmutexIn, std::defer_lock);
         if (fTry) {
             TryEnter(pszName, pszFile, nLine);
         } else {
             Enter(pszName, pszFile, nLine);
         }
     }
 
     ~UniqueLock() UNLOCK_FUNCTION() {
         if (Base::owns_lock()) {
             LeaveCritical();
         }
     }
 
     operator bool() { return Base::owns_lock(); }
 
 protected:
     // needed for reverse_lock
     UniqueLock() {}
 
 public:
     /**
      * An RAII-style reverse lock. Unlocks on construction and locks on
      * destruction.
      */
     class reverse_lock {
     public:
         explicit reverse_lock(UniqueLock &_lock, const char *_guardname,
                               const char *_file, int _line)
             : lock(_lock), file(_file), line(_line) {
             CheckLastCritical((void *)lock.mutex(), lockname, _guardname, _file,
                               _line);
             lock.unlock();
             LeaveCritical();
             lock.swap(templock);
         }
 
         ~reverse_lock() {
             templock.swap(lock);
             EnterCritical(lockname.c_str(), file.c_str(), line, lock.mutex());
             lock.lock();
         }
 
     private:
         reverse_lock(reverse_lock const &);
         reverse_lock &operator=(reverse_lock const &);
 
         UniqueLock &lock;
         UniqueLock templock;
         std::string lockname;
         const std::string file;
         const int line;
     };
     friend class reverse_lock;
 };
 
 #define REVERSE_LOCK(g)                                                        \
     typename std::decay<decltype(g)>::type::reverse_lock PASTE2(               \
         revlock, __COUNTER__)(g, #g, __FILE__, __LINE__)
 
 template <typename MutexArg>
 using DebugLock = UniqueLock<typename std::remove_reference<
     typename std::remove_pointer<MutexArg>::type>::type>;
 
 #define LOCK(cs)                                                               \
     DebugLock<decltype(cs)> PASTE2(criticalblock,                              \
                                    __COUNTER__)(cs, #cs, __FILE__, __LINE__)
 #define LOCK2(cs1, cs2)                                                        \
     DebugLock<decltype(cs1)> criticalblock1(cs1, #cs1, __FILE__, __LINE__);    \
     DebugLock<decltype(cs2)> criticalblock2(cs2, #cs2, __FILE__, __LINE__);
 #define TRY_LOCK(cs, name)                                                     \
     DebugLock<decltype(cs)> name(cs, #cs, __FILE__, __LINE__, true)
 #define WAIT_LOCK(cs, name)                                                    \
     DebugLock<decltype(cs)> name(cs, #cs, __FILE__, __LINE__)
 
 #define ENTER_CRITICAL_SECTION(cs)                                             \
     {                                                                          \
         EnterCritical(#cs, __FILE__, __LINE__, &cs);                           \
         (cs).lock();                                                           \
     }
 
 #define LEAVE_CRITICAL_SECTION(cs)                                             \
     {                                                                          \
         std::string lockname;                                                  \
         CheckLastCritical((void *)(&cs), lockname, #cs, __FILE__, __LINE__);   \
         (cs).unlock();                                                         \
         LeaveCritical();                                                       \
     }
 
 //! Run code while locking a mutex.
 //!
 //! Examples:
 //!
 //!   WITH_LOCK(cs, shared_val = shared_val + 1);
 //!
 //!   int val = WITH_LOCK(cs, return shared_val);
 //!
 //! Note:
 //!
 //! Since the return type deduction follows that of decltype(auto), while the
 //! deduced type of:
 //!
 //!   WITH_LOCK(cs, return {int i = 1; return i;});
 //!
 //! is int, the deduced type of:
 //!
 //!   WITH_LOCK(cs, return {int j = 1; return (j);});
 //!
 //! is &int, a reference to a local variable
 //!
 //! The above is detectable at compile-time with the -Wreturn-local-addr flag in
 //! gcc and the -Wreturn-stack-address flag in clang, both enabled by default.
 #define WITH_LOCK(cs, code)                                                    \
     [&]() -> decltype(auto) {                                                  \
         LOCK(cs);                                                              \
         code;                                                                  \
     }()
 
 class CSemaphore {
 private:
     std::condition_variable condition;
     std::mutex mutex;
     int value;
 
 public:
     explicit CSemaphore(int init) : value(init) {}
 
     void wait() {
         std::unique_lock<std::mutex> lock(mutex);
         condition.wait(lock, [&]() { return value >= 1; });
         value--;
     }
 
     bool try_wait() {
         std::lock_guard<std::mutex> lock(mutex);
         if (value < 1) {
             return false;
         }
         value--;
         return true;
     }
 
     void post() {
         {
             std::lock_guard<std::mutex> lock(mutex);
             value++;
         }
         condition.notify_one();
     }
 };
 
 /** RAII-style semaphore lock */
 class CSemaphoreGrant {
 private:
     CSemaphore *sem;
     bool fHaveGrant;
 
 public:
     void Acquire() {
         if (fHaveGrant) {
             return;
         }
         sem->wait();
         fHaveGrant = true;
     }
 
     void Release() {
         if (!fHaveGrant) {
             return;
         }
         sem->post();
         fHaveGrant = false;
     }
 
     bool TryAcquire() {
         if (!fHaveGrant && sem->try_wait()) {
             fHaveGrant = true;
         }
         return fHaveGrant;
     }
 
     void MoveTo(CSemaphoreGrant &grant) {
         grant.Release();
         grant.sem = sem;
         grant.fHaveGrant = fHaveGrant;
         fHaveGrant = false;
     }
 
     CSemaphoreGrant() : sem(nullptr), fHaveGrant(false) {}
 
     explicit CSemaphoreGrant(CSemaphore &sema, bool fTry = false)
         : sem(&sema), fHaveGrant(false) {
         if (fTry) {
             TryAcquire();
         } else {
             Acquire();
         }
     }
 
     ~CSemaphoreGrant() { Release(); }
 
     operator bool() const { return fHaveGrant; }
 };
 
 #endif // BITCOIN_SYNC_H
diff --git a/src/threadinterrupt.h b/src/threadinterrupt.h
index 1eb8a1896..616fe5381 100644
--- a/src/threadinterrupt.h
+++ b/src/threadinterrupt.h
@@ -1,35 +1,38 @@
 // Copyright (c) 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_THREADINTERRUPT_H
 #define BITCOIN_THREADINTERRUPT_H
 
 #include <sync.h>
 
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
 
 /**
  * A helper class for interruptible sleeps. Calling operator() will interrupt
  * any current sleep, and after that point operator bool() will return true
  * until reset.
  */
 class CThreadInterrupt {
 public:
     CThreadInterrupt();
     explicit operator bool() const;
-    void operator()();
+    void operator()() EXCLUSIVE_LOCKS_REQUIRED(!mut);
     void reset();
-    bool sleep_for(std::chrono::milliseconds rel_time);
-    bool sleep_for(std::chrono::seconds rel_time);
-    bool sleep_for(std::chrono::minutes rel_time);
+    bool sleep_for(std::chrono::milliseconds rel_time)
+        EXCLUSIVE_LOCKS_REQUIRED(!mut);
+    bool sleep_for(std::chrono::seconds rel_time)
+        EXCLUSIVE_LOCKS_REQUIRED(!mut);
+    bool sleep_for(std::chrono::minutes rel_time)
+        EXCLUSIVE_LOCKS_REQUIRED(!mut);
 
 private:
     std::condition_variable cond;
     Mutex mut;
     std::atomic<bool> flag;
 };
 
 #endif // BITCOIN_THREADINTERRUPT_H
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
index bd3a7415d..f91b93b0b 100644
--- a/src/validationinterface.cpp
+++ b/src/validationinterface.cpp
@@ -1,292 +1,295 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <validationinterface.h>
 
 #include <attributes.h>
 #include <chain.h>
 #include <consensus/validation.h>
 #include <logging.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <scheduler.h>
 
 #include <future>
 #include <tuple>
 #include <unordered_map>
 #include <utility>
 
 /**
  * MainSignalsImpl manages a list of shared_ptr<CValidationInterface>
  * callbacks.
  *
  * A std::unordered_map is used to track what callbacks are currently
  * registered, and a std::list is used to store the callbacks that are
  * currently registered as well as any callbacks that are just unregistered
  * and about to be deleted when they are done executing.
  */
 class MainSignalsImpl {
 private:
     Mutex m_mutex;
     //! List entries consist of a callback pointer and reference count. The
     //! count is equal to the number of current executions of that entry, plus 1
     //! if it's registered. It cannot be 0 because that would imply it is
     //! unregistered and also not being executed (so shouldn't exist).
     struct ListEntry {
         std::shared_ptr<CValidationInterface> callbacks;
         int count = 1;
     };
     std::list<ListEntry> m_list GUARDED_BY(m_mutex);
     std::unordered_map<CValidationInterface *, std::list<ListEntry>::iterator>
         m_map GUARDED_BY(m_mutex);
 
 public:
     // We are not allowed to assume the scheduler only runs in one thread,
     // but must ensure all callbacks happen in-order, so we end up creating
     // our own queue here :(
     SingleThreadedSchedulerClient m_schedulerClient;
 
     explicit MainSignalsImpl(CScheduler &scheduler LIFETIMEBOUND)
         : m_schedulerClient(scheduler) {}
 
-    void Register(std::shared_ptr<CValidationInterface> callbacks) {
+    void Register(std::shared_ptr<CValidationInterface> callbacks)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         LOCK(m_mutex);
         auto inserted = m_map.emplace(callbacks.get(), m_list.end());
         if (inserted.second) {
             inserted.first->second = m_list.emplace(m_list.end());
         }
         inserted.first->second->callbacks = std::move(callbacks);
     }
 
-    void Unregister(CValidationInterface *callbacks) {
+    void Unregister(CValidationInterface *callbacks)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         LOCK(m_mutex);
         auto it = m_map.find(callbacks);
         if (it != m_map.end()) {
             if (!--it->second->count) {
                 m_list.erase(it->second);
             }
             m_map.erase(it);
         }
     }
 
     //! Clear unregisters every previously registered callback, erasing every
     //! map entry. After this call, the list may still contain callbacks that
     //! are currently executing, but it will be cleared when they are done
     //! executing.
-    void Clear() {
+    void Clear() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         LOCK(m_mutex);
         for (const auto &entry : m_map) {
             if (!--entry.second->count) {
                 m_list.erase(entry.second);
             }
         }
         m_map.clear();
     }
 
-    template <typename F> void Iterate(F &&f) {
+    template <typename F>
+    void Iterate(F &&f) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
         WAIT_LOCK(m_mutex, lock);
         for (auto it = m_list.begin(); it != m_list.end();) {
             ++it->count;
             {
                 REVERSE_LOCK(lock);
                 f(*it->callbacks);
             }
             it = --it->count ? std::next(it) : m_list.erase(it);
         }
     }
 };
 
 static CMainSignals g_signals;
 
 void CMainSignals::RegisterBackgroundSignalScheduler(CScheduler &scheduler) {
     assert(!m_internals);
     m_internals = std::make_unique<MainSignalsImpl>(scheduler);
 }
 
 void CMainSignals::UnregisterBackgroundSignalScheduler() {
     m_internals.reset(nullptr);
 }
 
 void CMainSignals::FlushBackgroundCallbacks() {
     if (m_internals) {
         m_internals->m_schedulerClient.EmptyQueue();
     }
 }
 
 size_t CMainSignals::CallbacksPending() {
     if (!m_internals) {
         return 0;
     }
     return m_internals->m_schedulerClient.CallbacksPending();
 }
 
 CMainSignals &GetMainSignals() {
     return g_signals;
 }
 
 void RegisterSharedValidationInterface(
     std::shared_ptr<CValidationInterface> callbacks) {
     // Each connection captures the shared_ptr to ensure that each callback is
     // executed before the subscriber is destroyed. For more details see #18338.
     g_signals.m_internals->Register(std::move(callbacks));
 }
 
 void RegisterValidationInterface(CValidationInterface *callbacks) {
     // Create a shared_ptr with a no-op deleter - CValidationInterface lifecycle
     // is managed by the caller.
     RegisterSharedValidationInterface(
         {callbacks, [](CValidationInterface *) {}});
 }
 
 void UnregisterSharedValidationInterface(
     std::shared_ptr<CValidationInterface> callbacks) {
     UnregisterValidationInterface(callbacks.get());
 }
 
 void UnregisterValidationInterface(CValidationInterface *callbacks) {
     if (g_signals.m_internals) {
         g_signals.m_internals->Unregister(callbacks);
     }
 }
 
 void UnregisterAllValidationInterfaces() {
     if (!g_signals.m_internals) {
         return;
     }
     g_signals.m_internals->Clear();
 }
 
 void CallFunctionInValidationInterfaceQueue(std::function<void()> func) {
     g_signals.m_internals->m_schedulerClient.AddToProcessQueue(std::move(func));
 }
 
 void SyncWithValidationInterfaceQueue() {
     AssertLockNotHeld(cs_main);
     // Block until the validation queue drains
     std::promise<void> promise;
     CallFunctionInValidationInterfaceQueue([&promise] { promise.set_value(); });
     promise.get_future().wait();
 }
 
 // Use a macro instead of a function for conditional logging to prevent
 // evaluating arguments when logging is not enabled.
 //
 // NOTE: The lambda captures all local variables by value.
 #define ENQUEUE_AND_LOG_EVENT(event, fmt, name, ...)                           \
     do {                                                                       \
         auto local_name = (name);                                              \
         LOG_EVENT("Enqueuing " fmt, local_name, __VA_ARGS__);                  \
         m_internals->m_schedulerClient.AddToProcessQueue([=] {                 \
             LOG_EVENT(fmt, local_name, __VA_ARGS__);                           \
             event();                                                           \
         });                                                                    \
     } while (0)
 
 #define LOG_EVENT(fmt, ...) LogPrint(BCLog::VALIDATION, fmt "\n", __VA_ARGS__)
 
 void CMainSignals::UpdatedBlockTip(const CBlockIndex *pindexNew,
                                    const CBlockIndex *pindexFork,
                                    bool fInitialDownload) {
     // Dependencies exist that require UpdatedBlockTip events to be delivered in
     // the order in which the chain actually updates. One way to ensure this is
     // for the caller to invoke this signal in the same critical section where
     // the chain is updated
 
     auto event = [pindexNew, pindexFork, fInitialDownload, this] {
         m_internals->Iterate([&](CValidationInterface &callbacks) {
             callbacks.UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload);
         });
     };
     ENQUEUE_AND_LOG_EVENT(
         event, "%s: new block hash=%s fork block hash=%s (in IBD=%s)", __func__,
         pindexNew->GetBlockHash().ToString(),
         pindexFork ? pindexFork->GetBlockHash().ToString() : "null",
         fInitialDownload);
 }
 
 void CMainSignals::TransactionAddedToMempool(
     const CTransactionRef &tx,
     std::shared_ptr<const std::vector<Coin>> spent_coins,
     uint64_t mempool_sequence) {
     auto event = [tx, spent_coins, mempool_sequence, this] {
         m_internals->Iterate([&](CValidationInterface &callbacks) {
             callbacks.TransactionAddedToMempool(tx, spent_coins,
                                                 mempool_sequence);
         });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s", __func__,
                           tx->GetHash().ToString());
 }
 
 void CMainSignals::TransactionRemovedFromMempool(const CTransactionRef &tx,
                                                  MemPoolRemovalReason reason,
                                                  uint64_t mempool_sequence) {
     auto event = [tx, reason, mempool_sequence, this] {
         m_internals->Iterate([&](CValidationInterface &callbacks) {
             callbacks.TransactionRemovedFromMempool(tx, reason,
                                                     mempool_sequence);
         });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s", __func__,
                           tx->GetHash().ToString());
 }
 
 void CMainSignals::BlockConnected(const std::shared_ptr<const CBlock> &pblock,
                                   const CBlockIndex *pindex) {
     auto event = [pblock, pindex, this] {
         m_internals->Iterate([&](CValidationInterface &callbacks) {
             callbacks.BlockConnected(pblock, pindex);
         });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s block height=%d", __func__,
                           pblock->GetHash().ToString(), pindex->nHeight);
 }
 
 void CMainSignals::BlockDisconnected(
     const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex) {
     auto event = [pblock, pindex, this] {
         m_internals->Iterate([&](CValidationInterface &callbacks) {
             callbacks.BlockDisconnected(pblock, pindex);
         });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
                           pblock->GetHash().ToString());
 }
 
 void CMainSignals::ChainStateFlushed(const CBlockLocator &locator) {
     auto event = [locator, this] {
         m_internals->Iterate([&](CValidationInterface &callbacks) {
             callbacks.ChainStateFlushed(locator);
         });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
                           locator.IsNull() ? "null"
                                            : locator.vHave.front().ToString());
 }
 
 void CMainSignals::BlockChecked(const CBlock &block,
                                 const BlockValidationState &state) {
     LOG_EVENT("%s: block hash=%s state=%s", __func__,
               block.GetHash().ToString(), state.ToString());
     m_internals->Iterate([&](CValidationInterface &callbacks) {
         callbacks.BlockChecked(block, state);
     });
 }
 
 void CMainSignals::NewPoWValidBlock(
     const CBlockIndex *pindex, const std::shared_ptr<const CBlock> &block) {
     LOG_EVENT("%s: block hash=%s", __func__, block->GetHash().ToString());
     m_internals->Iterate([&](CValidationInterface &callbacks) {
         callbacks.NewPoWValidBlock(pindex, block);
     });
 }
 
 void CMainSignals::BlockFinalized(const CBlockIndex *pindex) {
     LOG_EVENT("%s: block hash=%s", __func__,
               pindex ? pindex->GetBlockHash().ToString() : "null");
     m_internals->Iterate([&](CValidationInterface &callbacks) {
         callbacks.BlockFinalized(pindex);
     });
 }