diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
index 77a5c6396..0df8ca7f4 100644
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -1,1332 +1,1342 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/peermanager.h>
 
 #include <arith_uint256.h>
 #include <avalanche/avalanche.h>
 #include <avalanche/delegation.h>
 #include <avalanche/validation.h>
 #include <cashaddrenc.h>
 #include <logging.h>
 #include <random.h>
 #include <scheduler.h>
 #include <uint256.h>
 #include <util/fastrange.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h> // For ChainstateManager
 
 #include <algorithm>
 #include <cassert>
 #include <cmath>
 #include <limits>
 
 namespace avalanche {
 static constexpr uint64_t PEERS_DUMP_VERSION{1};
 
 bool PeerManager::addNode(NodeId nodeid, const ProofId &proofid) {
     auto &pview = peers.get<by_proofid>();
     auto it = pview.find(proofid);
     if (it == pview.end()) {
         // If the node exists, it is actually updating its proof to an unknown
         // one. In this case we need to remove it so it is not both active and
         // pending at the same time.
         removeNode(nodeid);
         pendingNodes.emplace(proofid, nodeid);
         return false;
     }
 
     return addOrUpdateNode(peers.project<0>(it), nodeid);
 }
 
 bool PeerManager::addOrUpdateNode(const PeerSet::iterator &it, NodeId nodeid) {
     assert(it != peers.end());
 
     const PeerId peerid = it->peerid;
 
     auto nit = nodes.find(nodeid);
     if (nit == nodes.end()) {
         if (!nodes.emplace(nodeid, peerid).second) {
             return false;
         }
     } else {
         const PeerId oldpeerid = nit->peerid;
         if (!nodes.modify(nit, [&](Node &n) { n.peerid = peerid; })) {
             return false;
         }
 
         // We actually have this node already, we need to update it.
         bool success = removeNodeFromPeer(peers.find(oldpeerid));
         assert(success);
     }
 
     // Then increase the node counter, and create the slot if needed
     bool success = addNodeToPeer(it);
     assert(success);
 
     // If the added node was in the pending set, remove it
     pendingNodes.get<by_nodeid>().erase(nodeid);
 
     // If the proof was in the dangling pool, remove it
     const ProofId &proofid = it->getProofId();
     if (danglingProofPool.getProof(proofid)) {
         danglingProofPool.removeProof(proofid);
     }
 
     // We know for sure there is at least 1 node. Note that this can fail if
     // there is more than 1, in this case it's a no-op.
     shareableProofs.insert(it->proof);
 
     return true;
 }
 
 bool PeerManager::addNodeToPeer(const PeerSet::iterator &it) {
     assert(it != peers.end());
     return peers.modify(it, [&](Peer &p) {
         if (p.node_count++ > 0) {
             // We are done.
             return;
         }
 
         // We need to allocate this peer.
         p.index = uint32_t(slots.size());
         const uint32_t score = p.getScore();
         const uint64_t start = slotCount;
         slots.emplace_back(start, score, it->peerid);
         slotCount = start + score;
 
         // Add to our allocated score when we allocate a new peer in the slots
         connectedPeersScore += score;
     });
 }
 
 bool PeerManager::removeNode(NodeId nodeid) {
     // Remove all the remote proofs from this node
     auto &remoteProofsView = remoteProofs.get<by_nodeid>();
     auto [begin, end] = remoteProofsView.equal_range(nodeid);
     remoteProofsView.erase(begin, end);
 
     if (pendingNodes.get<by_nodeid>().erase(nodeid) > 0) {
         // If this was a pending node, there is nothing else to do.
         return true;
     }
 
     auto it = nodes.find(nodeid);
     if (it == nodes.end()) {
         return false;
     }
 
     const PeerId peerid = it->peerid;
     nodes.erase(it);
 
     // Keep the track of the reference count.
     bool success = removeNodeFromPeer(peers.find(peerid));
     assert(success);
 
     return true;
 }
 
 bool PeerManager::removeNodeFromPeer(const PeerSet::iterator &it,
                                      uint32_t count) {
     // It is possible for nodes to be dangling. If there was an inflight query
     // when the peer gets removed, the node was not erased. In this case there
     // is nothing to do.
     if (it == peers.end()) {
         return true;
     }
 
     assert(count <= it->node_count);
     if (count == 0) {
         // This is a NOOP.
         return false;
     }
 
     const uint32_t new_count = it->node_count - count;
     if (!peers.modify(it, [&](Peer &p) { p.node_count = new_count; })) {
         return false;
     }
 
     if (new_count > 0) {
         // We are done.
         return true;
     }
 
     // There are no more nodes left, we need to clean up. Remove from the radix
     // tree (unless it's our local proof), subtract allocated score and remove
     // from slots.
     if (!localProof || it->getProofId() != localProof->getId()) {
         const auto removed = shareableProofs.remove(it->getProofId());
         assert(removed);
     }
 
     const size_t i = it->index;
     assert(i < slots.size());
     assert(connectedPeersScore >= slots[i].getScore());
     connectedPeersScore -= slots[i].getScore();
 
     if (i + 1 == slots.size()) {
         slots.pop_back();
         slotCount = slots.empty() ? 0 : slots.back().getStop();
     } else {
         fragmentation += slots[i].getScore();
         slots[i] = slots[i].withPeerId(NO_PEER);
     }
 
     return true;
 }
 
 bool PeerManager::updateNextRequestTime(NodeId nodeid,
                                         SteadyMilliseconds timeout) {
     auto it = nodes.find(nodeid);
     if (it == nodes.end()) {
         return false;
     }
 
     return nodes.modify(it, [&](Node &n) { n.nextRequestTime = timeout; });
 }
 
 bool PeerManager::latchAvaproofsSent(NodeId nodeid) {
     auto it = nodes.find(nodeid);
     if (it == nodes.end()) {
         return false;
     }
 
     return !it->avaproofsSent &&
            nodes.modify(it, [&](Node &n) { n.avaproofsSent = true; });
 }
 
 static bool isImmatureState(const ProofValidationState &state) {
     return state.GetResult() == ProofValidationResult::IMMATURE_UTXO;
 }
 
 bool PeerManager::updateNextPossibleConflictTime(
     PeerId peerid, const std::chrono::seconds &nextTime) {
     auto it = peers.find(peerid);
     if (it == peers.end()) {
         // No such peer
         return false;
     }
 
     // Make sure we don't move the time in the past.
     peers.modify(it, [&](Peer &p) {
         p.nextPossibleConflictTime =
             std::max(p.nextPossibleConflictTime, nextTime);
     });
 
     return it->nextPossibleConflictTime == nextTime;
 }
 
 bool PeerManager::setFinalized(PeerId peerid) {
     auto it = peers.find(peerid);
     if (it == peers.end()) {
         // No such peer
         return false;
     }
 
     peers.modify(it, [&](Peer &p) { p.hasFinalized = true; });
 
     return true;
 }
 
 template <typename ProofContainer>
 void PeerManager::moveToConflictingPool(const ProofContainer &proofs) {
     auto &peersView = peers.get<by_proofid>();
     for (const ProofRef &proof : proofs) {
         auto it = peersView.find(proof->getId());
         if (it != peersView.end()) {
             removePeer(it->peerid);
         }
 
         conflictingProofPool.addProofIfPreferred(proof);
     }
 }
 
 bool PeerManager::registerProof(const ProofRef &proof,
                                 ProofRegistrationState &registrationState,
                                 RegistrationMode mode) {
     assert(proof);
 
     const ProofId &proofid = proof->getId();
 
     auto invalidate = [&](ProofRegistrationResult result,
                           const std::string &message) {
         return registrationState.Invalid(
             result, message, strprintf("proofid: %s", proofid.ToString()));
     };
 
     if ((mode != RegistrationMode::FORCE_ACCEPT ||
          !isInConflictingPool(proofid)) &&
         exists(proofid)) {
         // In default mode, we expect the proof to be unknown, i.e. in none of
         // the pools.
         // In forced accept mode, the proof can be in the conflicting pool.
         return invalidate(ProofRegistrationResult::ALREADY_REGISTERED,
                           "proof-already-registered");
     }
 
     if (danglingProofPool.getProof(proofid) &&
         pendingNodes.count(proofid) == 0) {
         // Don't attempt to register a proof that we already evicted because it
         // was dangling, but rather attempt to retrieve an associated node.
         needMoreNodes = true;
         return invalidate(ProofRegistrationResult::DANGLING, "dangling-proof");
     }
 
     // Check the proof's validity.
     ProofValidationState validationState;
     if (!WITH_LOCK(cs_main, return proof->verify(stakeUtxoDustThreshold,
                                                  chainman, validationState))) {
         if (isImmatureState(validationState)) {
             immatureProofPool.addProofIfPreferred(proof);
             if (immatureProofPool.countProofs() >
                 AVALANCHE_MAX_IMMATURE_PROOFS) {
                 // Adding this proof exceeds the immature pool limit, so evict
                 // the lowest scoring proof.
                 immatureProofPool.removeProof(
                     immatureProofPool.getLowestScoreProof()->getId());
             }
 
             return invalidate(ProofRegistrationResult::IMMATURE,
                               "immature-proof");
         }
 
         if (validationState.GetResult() ==
             ProofValidationResult::MISSING_UTXO) {
             return invalidate(ProofRegistrationResult::MISSING_UTXO,
                               "utxo-missing-or-spent");
         }
 
         // Reject invalid proof.
         return invalidate(ProofRegistrationResult::INVALID, "invalid-proof");
     }
 
     auto now = GetTime<std::chrono::seconds>();
     auto nextCooldownTimePoint =
         now + std::chrono::seconds(gArgs.GetIntArg(
                   "-avalancheconflictingproofcooldown",
                   AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN));
 
     ProofPool::ConflictingProofSet conflictingProofs;
     switch (validProofPool.addProofIfNoConflict(proof, conflictingProofs)) {
         case ProofPool::AddProofStatus::REJECTED: {
             if (mode != RegistrationMode::FORCE_ACCEPT) {
                 auto bestPossibleConflictTime = std::chrono::seconds(0);
                 auto &pview = peers.get<by_proofid>();
                 for (auto &conflictingProof : conflictingProofs) {
                     auto it = pview.find(conflictingProof->getId());
                     assert(it != pview.end());
 
                     // Search the most recent time over the peers
                     bestPossibleConflictTime = std::max(
                         bestPossibleConflictTime, it->nextPossibleConflictTime);
 
                     updateNextPossibleConflictTime(it->peerid,
                                                    nextCooldownTimePoint);
                 }
 
                 if (bestPossibleConflictTime > now) {
                     // Cooldown not elapsed, reject the proof.
                     return invalidate(
                         ProofRegistrationResult::COOLDOWN_NOT_ELAPSED,
                         "cooldown-not-elapsed");
                 }
 
                 // Give the proof a chance to replace the conflicting ones.
                 if (validProofPool.addProofIfPreferred(proof)) {
                     // If we have overridden other proofs due to conflict,
                     // remove the peers and attempt to move them to the
                     // conflicting pool.
                     moveToConflictingPool(conflictingProofs);
 
                     // Replacement is successful, continue to peer creation
                     break;
                 }
 
                 // Not the preferred proof, or replacement is not enabled
                 return conflictingProofPool.addProofIfPreferred(proof) ==
                                ProofPool::AddProofStatus::REJECTED
                            ? invalidate(ProofRegistrationResult::REJECTED,
                                         "rejected-proof")
                            : invalidate(ProofRegistrationResult::CONFLICTING,
                                         "conflicting-utxos");
             }
 
             conflictingProofPool.removeProof(proofid);
 
             // Move the conflicting proofs from the valid pool to the
             // conflicting pool
             moveToConflictingPool(conflictingProofs);
 
             auto status = validProofPool.addProofIfNoConflict(proof);
             assert(status == ProofPool::AddProofStatus::SUCCEED);
 
             break;
         }
         case ProofPool::AddProofStatus::DUPLICATED:
             // If the proof was already in the pool, don't duplicate the peer.
             return invalidate(ProofRegistrationResult::ALREADY_REGISTERED,
                               "proof-already-registered");
         case ProofPool::AddProofStatus::SUCCEED:
             break;
 
             // No default case, so the compiler can warn about missing cases
     }
 
     // At this stage we are going to create a peer so the proof should never
     // exist in the conflicting pool, but use belt and suspenders.
     conflictingProofPool.removeProof(proofid);
 
     // New peer means new peerid!
     const PeerId peerid = nextPeerId++;
 
     // We have no peer for this proof, time to create it.
     auto inserted = peers.emplace(peerid, proof, nextCooldownTimePoint);
     assert(inserted.second);
 
     if (localProof && proof->getId() == localProof->getId()) {
         // Add it to the shareable proofs even if there is no node, we are the
         // node. Otherwise it will be inserted after a node is attached to the
         // proof.
         shareableProofs.insert(proof);
     }
 
     // Add to our registered score when adding to the peer list
     totalPeersScore += proof->getScore();
 
     // If there are nodes waiting for this proof, add them
     auto &pendingNodesView = pendingNodes.get<by_proofid>();
     auto range = pendingNodesView.equal_range(proofid);
 
     // We want to update the nodes then remove them from the pending set. That
     // will invalidate the range iterators, so we need to save the node ids
     // first before we can loop over them.
     std::vector<NodeId> nodeids;
     nodeids.reserve(std::distance(range.first, range.second));
     std::transform(range.first, range.second, std::back_inserter(nodeids),
                    [](const PendingNode &n) { return n.nodeid; });
 
     for (const NodeId &nodeid : nodeids) {
         addOrUpdateNode(inserted.first, nodeid);
     }
 
     return true;
 }
 
 bool PeerManager::rejectProof(const ProofId &proofid, RejectionMode mode) {
     if (isDangling(proofid) && mode == RejectionMode::INVALIDATE) {
         danglingProofPool.removeProof(proofid);
         return true;
     }
 
     if (!exists(proofid)) {
         return false;
     }
 
     if (immatureProofPool.removeProof(proofid)) {
         return true;
     }
 
     if (mode == RejectionMode::DEFAULT &&
         conflictingProofPool.getProof(proofid)) {
         // In default mode we keep the proof in the conflicting pool
         return true;
     }
 
     if (mode == RejectionMode::INVALIDATE &&
         conflictingProofPool.removeProof(proofid)) {
         // In invalidate mode we remove the proof completely
         return true;
     }
 
     auto &pview = peers.get<by_proofid>();
     auto it = pview.find(proofid);
     assert(it != pview.end());
 
     const ProofRef proof = it->proof;
 
     if (!removePeer(it->peerid)) {
         return false;
     }
 
     // If there was conflicting proofs, attempt to pull them back
     for (const SignedStake &ss : proof->getStakes()) {
         const ProofRef conflictingProof =
             conflictingProofPool.getProof(ss.getStake().getUTXO());
         if (!conflictingProof) {
             continue;
         }
 
         conflictingProofPool.removeProof(conflictingProof->getId());
         registerProof(conflictingProof);
     }
 
     if (mode == RejectionMode::DEFAULT) {
         conflictingProofPool.addProofIfPreferred(proof);
     }
 
     return true;
 }
 
 void PeerManager::cleanupDanglingProofs(
     std::unordered_set<ProofRef, SaltedProofHasher> &registeredProofs) {
     registeredProofs.clear();
     const auto now = GetTime<std::chrono::seconds>();
 
     std::vector<ProofRef> newlyDanglingProofs;
     for (const Peer &peer : peers) {
         // If the peer is not our local proof, has been registered for some
         // time and has no node attached, discard it.
         if ((!localProof || peer.getProofId() != localProof->getId()) &&
             peer.node_count == 0 &&
             (peer.registration_time + Peer::DANGLING_TIMEOUT) <= now) {
             // Check the remotes status to determine if we should set the proof
             // as dangling. This prevents from dropping a proof on our own due
             // to a network issue. If the remote presence status is inconclusive
             // we assume our own position (missing = false).
             if (!getRemotePresenceStatus(peer.getProofId()).value_or(false)) {
                 newlyDanglingProofs.push_back(peer.proof);
             }
         }
     }
 
     // Similarly, check if we have dangling proofs that could be pulled back
     // because the network says so.
     std::vector<ProofRef> previouslyDanglingProofs;
     danglingProofPool.forEachProof([&](const ProofRef &proof) {
         if (getRemotePresenceStatus(proof->getId()).value_or(false)) {
             previouslyDanglingProofs.push_back(proof);
         }
     });
     for (const ProofRef &proof : previouslyDanglingProofs) {
         danglingProofPool.removeProof(proof->getId());
         if (registerProof(proof)) {
             registeredProofs.insert(proof);
         }
     }
 
     for (const ProofRef &proof : newlyDanglingProofs) {
         rejectProof(proof->getId(), RejectionMode::INVALIDATE);
         if (danglingProofPool.addProofIfPreferred(proof)) {
             // If the proof is added, it means there is no better conflicting
             // dangling proof and this is not a duplicated, so it's worth
             // printing a message to the log.
             LogPrint(BCLog::AVALANCHE,
                      "Proof dangling for too long (no connected node): %s\n",
                      proof->getId().GetHex());
         }
     }
 
     // If we have dangling proof, this is a good indicator that we need to
     // request more nodes from our peers.
     needMoreNodes = !newlyDanglingProofs.empty();
 }
 
 NodeId PeerManager::selectNode() {
     for (int retry = 0; retry < SELECT_NODE_MAX_RETRY; retry++) {
         const PeerId p = selectPeer();
 
         // If we cannot find a peer, it may be due to the fact that it is
         // unlikely due to high fragmentation, so compact and retry.
         if (p == NO_PEER) {
             compact();
             continue;
         }
 
         // See if that peer has an available node.
         auto &nview = nodes.get<next_request_time>();
         auto it = nview.lower_bound(boost::make_tuple(p, SteadyMilliseconds()));
         if (it != nview.end() && it->peerid == p &&
             it->nextRequestTime <= Now<SteadyMilliseconds>()) {
             return it->nodeid;
         }
     }
 
     // We failed to find a node to query, flag this so we can request more
     needMoreNodes = true;
 
     return NO_NODE;
 }
 
 std::unordered_set<ProofRef, SaltedProofHasher> PeerManager::updatedBlockTip() {
     std::vector<ProofId> invalidProofIds;
     std::vector<ProofRef> newImmatures;
 
     {
         LOCK(cs_main);
 
         for (const auto &p : peers) {
             ProofValidationState state;
             if (!p.proof->verify(stakeUtxoDustThreshold, chainman, state)) {
                 if (isImmatureState(state)) {
                     newImmatures.push_back(p.proof);
                 }
                 invalidProofIds.push_back(p.getProofId());
 
                 LogPrint(BCLog::AVALANCHE,
                          "Invalidating proof %s: verification failed (%s)\n",
                          p.proof->getId().GetHex(), state.ToString());
             }
         }
     }
 
     // Remove the invalid proofs before the immature rescan. This makes it
     // possible to pull back proofs with utxos that conflicted with these
     // invalid proofs.
     for (const ProofId &invalidProofId : invalidProofIds) {
         rejectProof(invalidProofId, RejectionMode::INVALIDATE);
     }
 
     auto registeredProofs = immatureProofPool.rescan(*this);
 
     for (auto &p : newImmatures) {
         immatureProofPool.addProofIfPreferred(p);
     }
 
     return registeredProofs;
 }
 
 ProofRef PeerManager::getProof(const ProofId &proofid) const {
     ProofRef proof;
 
     forPeer(proofid, [&](const Peer &p) {
         proof = p.proof;
         return true;
     });
 
     if (!proof) {
         proof = conflictingProofPool.getProof(proofid);
     }
 
     if (!proof) {
         proof = immatureProofPool.getProof(proofid);
     }
 
     return proof;
 }
 
 bool PeerManager::isBoundToPeer(const ProofId &proofid) const {
     auto &pview = peers.get<by_proofid>();
     return pview.find(proofid) != pview.end();
 }
 
 bool PeerManager::isImmature(const ProofId &proofid) const {
     return immatureProofPool.getProof(proofid) != nullptr;
 }
 
 bool PeerManager::isInConflictingPool(const ProofId &proofid) const {
     return conflictingProofPool.getProof(proofid) != nullptr;
 }
 
 bool PeerManager::isDangling(const ProofId &proofid) const {
     return danglingProofPool.getProof(proofid) != nullptr;
 }
 
 void PeerManager::setInvalid(const ProofId &proofid) {
     invalidProofs.insert(proofid);
 }
 
 bool PeerManager::isInvalid(const ProofId &proofid) const {
     return invalidProofs.contains(proofid);
 }
 
 void PeerManager::clearAllInvalid() {
     invalidProofs.reset();
 }
 
 bool PeerManager::saveRemoteProof(const ProofId &proofid, const NodeId nodeid,
                                   const bool present) {
     // Get how many proofs this node has announced
     auto &remoteProofsByLastUpdate = remoteProofs.get<by_lastUpdate>();
     auto [begin, end] = remoteProofsByLastUpdate.equal_range(nodeid);
 
     // Limit the number of proofs a single node can save:
     //  - At least MAX_REMOTE_PROOFS
     //  - Up to 2x as much as we have
     // The MAX_REMOTE_PROOFS minimum is there to ensure we don't overlimit at
     // startup when we don't have proofs yet.
     while (size_t(std::distance(begin, end)) >=
            std::max(MAX_REMOTE_PROOFS, 2 * peers.size())) {
         // Remove the proof with the oldest update time
         begin = remoteProofsByLastUpdate.erase(begin);
     }
 
     auto it = remoteProofs.find(boost::make_tuple(proofid, nodeid));
     if (it != remoteProofs.end()) {
         remoteProofs.erase(it);
     }
 
     return remoteProofs
         .emplace(RemoteProof{proofid, nodeid, GetTime<std::chrono::seconds>(),
                              present})
         .second;
 }
 
 std::vector<RemoteProof>
 PeerManager::getRemoteProofs(const NodeId nodeid) const {
     std::vector<RemoteProof> nodeRemoteProofs;
 
     auto &remoteProofsByLastUpdate = remoteProofs.get<by_lastUpdate>();
     auto [begin, end] = remoteProofsByLastUpdate.equal_range(nodeid);
 
     for (auto &it = begin; it != end; it++) {
         nodeRemoteProofs.emplace_back(*it);
     }
 
     return nodeRemoteProofs;
 }
 
 bool PeerManager::removePeer(const PeerId peerid) {
     auto it = peers.find(peerid);
     if (it == peers.end()) {
         return false;
     }
 
     // Remove all nodes from this peer.
     removeNodeFromPeer(it, it->node_count);
 
     auto &nview = nodes.get<next_request_time>();
 
     // Add the nodes to the pending set
     auto range = nview.equal_range(peerid);
     for (auto &nit = range.first; nit != range.second; ++nit) {
         pendingNodes.emplace(it->getProofId(), nit->nodeid);
     };
 
     // Remove nodes associated with this peer, unless their timeout is still
     // active. This ensure that we don't overquery them in case they are
     // subsequently added to another peer.
     nview.erase(
         nview.lower_bound(boost::make_tuple(peerid, SteadyMilliseconds())),
         nview.upper_bound(
             boost::make_tuple(peerid, Now<SteadyMilliseconds>())));
 
     // Release UTXOs attached to this proof.
     validProofPool.removeProof(it->getProofId());
 
     // If there were nodes attached, remove from the radix tree as well
     auto removed = shareableProofs.remove(Uint256RadixKey(it->getProofId()));
 
     m_unbroadcast_proofids.erase(it->getProofId());
 
     // Remove the peer from the PeerSet and remove its score from the registered
     // score total.
     assert(totalPeersScore >= it->getScore());
     totalPeersScore -= it->getScore();
     peers.erase(it);
     return true;
 }
 
 PeerId PeerManager::selectPeer() const {
     if (slots.empty() || slotCount == 0) {
         return NO_PEER;
     }
 
     const uint64_t max = slotCount;
     for (int retry = 0; retry < SELECT_PEER_MAX_RETRY; retry++) {
         size_t i = selectPeerImpl(slots, GetRand(max), max);
         if (i != NO_PEER) {
             return i;
         }
     }
 
     return NO_PEER;
 }
 
 uint64_t PeerManager::compact() {
     // There is nothing to compact.
     if (fragmentation == 0) {
         return 0;
     }
 
     std::vector<Slot> newslots;
     newslots.reserve(peers.size());
 
     uint64_t prevStop = 0;
     uint32_t i = 0;
     for (auto it = peers.begin(); it != peers.end(); it++) {
         if (it->node_count == 0) {
             continue;
         }
 
         newslots.emplace_back(prevStop, it->getScore(), it->peerid);
         prevStop = slots[i].getStop();
         if (!peers.modify(it, [&](Peer &p) { p.index = i++; })) {
             return 0;
         }
     }
 
     slots = std::move(newslots);
 
     const uint64_t saved = slotCount - prevStop;
     slotCount = prevStop;
     fragmentation = 0;
 
     return saved;
 }
 
 bool PeerManager::verify() const {
     uint64_t prevStop = 0;
     uint32_t scoreFromSlots = 0;
     for (size_t i = 0; i < slots.size(); i++) {
         const Slot &s = slots[i];
 
         // Slots must be in correct order.
         if (s.getStart() < prevStop) {
             return false;
         }
 
         prevStop = s.getStop();
 
         // If this is a dead slot, then nothing more needs to be checked.
         if (s.getPeerId() == NO_PEER) {
             continue;
         }
 
         // We have a live slot, verify index.
         auto it = peers.find(s.getPeerId());
         if (it == peers.end() || it->index != i) {
             return false;
         }
 
         // Accumulate score across slots
         scoreFromSlots += slots[i].getScore();
     }
 
     // Score across slots must be the same as our allocated score
     if (scoreFromSlots != connectedPeersScore) {
         return false;
     }
 
     uint32_t scoreFromAllPeers = 0;
     uint32_t scoreFromPeersWithNodes = 0;
 
     std::unordered_set<COutPoint, SaltedOutpointHasher> peersUtxos;
     for (const auto &p : peers) {
         // Accumulate the score across peers to compare with total known score
         scoreFromAllPeers += p.getScore();
 
         // A peer should have a proof attached
         if (!p.proof) {
             return false;
         }
 
         // Check proof pool consistency
         for (const auto &ss : p.proof->getStakes()) {
             const COutPoint &outpoint = ss.getStake().getUTXO();
             auto proof = validProofPool.getProof(outpoint);
 
             if (!proof) {
                 // Missing utxo
                 return false;
             }
             if (proof != p.proof) {
                 // Wrong proof
                 return false;
             }
 
             if (!peersUtxos.emplace(outpoint).second) {
                 // Duplicated utxo
                 return false;
             }
         }
 
         // Count node attached to this peer.
         const auto count_nodes = [&]() {
             size_t count = 0;
             auto &nview = nodes.get<next_request_time>();
             auto begin = nview.lower_bound(
                 boost::make_tuple(p.peerid, SteadyMilliseconds()));
             auto end = nview.upper_bound(
                 boost::make_tuple(p.peerid + 1, SteadyMilliseconds()));
 
             for (auto it = begin; it != end; ++it) {
                 count++;
             }
 
             return count;
         };
 
         if (p.node_count != count_nodes()) {
             return false;
         }
 
         // If there are no nodes attached to this peer, then we are done.
         if (p.node_count == 0) {
             continue;
         }
 
         scoreFromPeersWithNodes += p.getScore();
         // The index must point to a slot refering to this peer.
         if (p.index >= slots.size() || slots[p.index].getPeerId() != p.peerid) {
             return false;
         }
 
         // If the score do not match, same thing.
         if (slots[p.index].getScore() != p.getScore()) {
             return false;
         }
 
         // Check the proof is in the radix tree only if there are nodes attached
         if (((localProof && p.getProofId() == localProof->getId()) ||
              p.node_count > 0) &&
             shareableProofs.get(p.getProofId()) == nullptr) {
             return false;
         }
         if (p.node_count == 0 &&
             shareableProofs.get(p.getProofId()) != nullptr) {
             return false;
         }
     }
 
     // Check our accumulated scores against our registred and allocated scores
     if (scoreFromAllPeers != totalPeersScore) {
         return false;
     }
     if (scoreFromPeersWithNodes != connectedPeersScore) {
         return false;
     }
 
     // We checked the utxo consistency for all our peers utxos already, so if
     // the pool size differs from the expected one there are dangling utxos.
     if (validProofPool.size() != peersUtxos.size()) {
         return false;
     }
 
     // Check there is no dangling proof in the radix tree
     return shareableProofs.forEachLeaf([&](RCUPtr<const Proof> pLeaf) {
         return isBoundToPeer(pLeaf->getId());
     });
 }
 
 PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
                       const uint64_t max) {
     assert(slot <= max);
 
     size_t begin = 0, end = slots.size();
     uint64_t bottom = 0, top = max;
 
     // Try to find the slot using dichotomic search.
     while ((end - begin) > 8) {
         // The slot we picked in not allocated.
         if (slot < bottom || slot >= top) {
             return NO_PEER;
         }
 
         // Guesstimate the position of the slot.
         size_t i = begin + ((slot - bottom) * (end - begin) / (top - bottom));
         assert(begin <= i && i < end);
 
         // We have a match.
         if (slots[i].contains(slot)) {
             return slots[i].getPeerId();
         }
 
         // We undershooted.
         if (slots[i].precedes(slot)) {
             begin = i + 1;
             if (begin >= end) {
                 return NO_PEER;
             }
 
             bottom = slots[begin].getStart();
             continue;
         }
 
         // We overshooted.
         if (slots[i].follows(slot)) {
             end = i;
             top = slots[end].getStart();
             continue;
         }
 
         // We have an unalocated slot.
         return NO_PEER;
     }
 
     // Enough of that nonsense, let fallback to linear search.
     for (size_t i = begin; i < end; i++) {
         // We have a match.
         if (slots[i].contains(slot)) {
             return slots[i].getPeerId();
         }
     }
 
     // We failed to find a slot, retry.
     return NO_PEER;
 }
 
 void PeerManager::addUnbroadcastProof(const ProofId &proofid) {
     // The proof should be bound to a peer
     if (isBoundToPeer(proofid)) {
         m_unbroadcast_proofids.insert(proofid);
     }
 }
 
 void PeerManager::removeUnbroadcastProof(const ProofId &proofid) {
     m_unbroadcast_proofids.erase(proofid);
 }
 
 bool PeerManager::selectStakingRewardWinner(const CBlockIndex *pprev,
                                             std::vector<CScript> &winners) {
     if (!pprev) {
         return false;
     }
 
     // Don't select proofs that have not been known for long enough, i.e. at
     // least since twice the dangling proof cleanup timeout before the last
     // block time, so we're sure to not account for proofs more recent than the
     // previous block or lacking node connected.
     // The previous block time is capped to now for the unlikely event the
     // previous block time is in the future.
     const int64_t maxRegistrationTime =
         std::min(pprev->GetBlockTime(), GetTime()) -
         std::chrono::duration_cast<std::chrono::seconds>(2 *
                                                          Peer::DANGLING_TIMEOUT)
             .count();
 
+    const int64_t recentRegistrationTime =
+        std::min(pprev->GetBlockTime(), GetTime()) -
+        std::chrono::duration_cast<std::chrono::seconds>(4 *
+                                                         Peer::DANGLING_TIMEOUT)
+            .count();
+
     const BlockHash prevblockhash = pprev->GetBlockHash();
 
     winners.clear();
     while (winners.size() < peers.size()) {
         double bestRewardRank = std::numeric_limits<double>::max();
         ProofRef selectedProof = ProofRef();
+        int64_t selectedProofRegistrationTime{0};
         uint256 bestRewardHash;
 
         for (const Peer &peer : peers) {
             if (!peer.proof) {
                 // Should never happen, continue
                 continue;
             }
 
             if (!peer.hasFinalized ||
                 peer.registration_time.count() >= maxRegistrationTime) {
                 continue;
             }
 
             if (std::find(winners.begin(), winners.end(),
                           peer.proof->getPayoutScript()) != winners.end()) {
                 continue;
             }
 
             uint256 proofRewardHash;
             CHash256()
                 .Write(prevblockhash)
                 .Write(peer.getProofId())
                 .Finalize(proofRewardHash);
 
             if (proofRewardHash == uint256::ZERO) {
                 // This either the result of an incredibly unlikely lucky hash,
                 // or a the hash is getting abused. In this case, skip the
                 // proof.
                 LogPrintf(
                     "Staking reward hash has a suspicious value of zero for "
                     "proof %s and blockhash %s, skipping\n",
                     peer.getProofId().ToString(), prevblockhash.ToString());
                 continue;
             }
 
             // To make sure the selection is properly weighted according to the
             // proof score, we normalize the proofRewardHash to a number between
             // 0 and 1, then take the logarithm and divide by the weight. Since
             // it is scale-independent, we can simplify by removing constants
             // and use base 2 logarithm.
             // Inspired by: https://stackoverflow.com/a/30226926.
             double proofRewardRank =
                 (256.0 -
                  std::log2(UintToArith256(proofRewardHash).getdouble())) /
                 peer.getScore();
 
             // The best ranking is the lowest ranking value
             if (proofRewardRank < bestRewardRank) {
                 bestRewardRank = proofRewardRank;
                 selectedProof = peer.proof;
+                selectedProofRegistrationTime = peer.registration_time.count();
                 bestRewardHash = proofRewardHash;
             }
 
             // Select the lowest reward hash then proofid in the unlikely case
             // of a collision.
             if (proofRewardRank == bestRewardRank &&
                 (proofRewardHash < bestRewardHash ||
                  (proofRewardHash == bestRewardHash &&
                   peer.getProofId() < selectedProof->getId()))) {
                 selectedProof = peer.proof;
+                selectedProofRegistrationTime = peer.registration_time.count();
                 bestRewardHash = proofRewardHash;
             }
         }
 
         if (!selectedProof) {
             // No winner
             break;
         }
 
         winners.push_back(selectedProof->getPayoutScript());
 
-        if (!isFlaky(selectedProof->getId())) {
+        if (selectedProofRegistrationTime < recentRegistrationTime &&
+            !isFlaky(selectedProof->getId())) {
             break;
         }
     }
 
     return winners.size() > 0;
 }
 
 bool PeerManager::isFlaky(const ProofId &proofid) const {
     if (localProof && proofid == localProof->getId()) {
         return false;
     }
 
     // If we are missing connection to this proof, consider flaky
     if (forPeer(proofid,
                 [](const Peer &peer) { return peer.node_count == 0; })) {
         return true;
     }
 
     auto &remoteProofsByNodeId = remoteProofs.get<by_nodeid>();
     auto &nview = nodes.get<next_request_time>();
 
     std::unordered_map<PeerId, std::unordered_set<ProofId, SaltedProofIdHasher>>
         missing_per_peer;
 
     // Construct a set of missing proof ids per peer
     double total_score{0};
     for (const Peer &peer : peers) {
         const PeerId peerid = peer.peerid;
 
         total_score += peer.getScore();
 
         auto nodes_range = nview.equal_range(peerid);
         for (auto &nit = nodes_range.first; nit != nodes_range.second; ++nit) {
             auto proofs_range = remoteProofsByNodeId.equal_range(nit->nodeid);
             for (auto &proofit = proofs_range.first;
                  proofit != proofs_range.second; ++proofit) {
                 if (!proofit->present) {
                     missing_per_peer[peerid].insert(proofit->proofid);
                 }
             }
         };
     }
 
     double missing_score{0};
 
     // Now compute a score for the missing proof
     for (const auto &[peerid, missingProofs] : missing_per_peer) {
         if (missingProofs.size() > 3) {
             // Ignore peers with too many missing proofs
             continue;
         }
 
         auto pit = peers.find(peerid);
         if (pit == peers.end()) {
             // Peer not found
             continue;
         }
 
         if (missingProofs.count(proofid) > 0) {
             missing_score += pit->getScore();
         }
     }
 
     return (missing_score / total_score) > 0.3;
 }
 
 std::optional<bool>
 PeerManager::getRemotePresenceStatus(const ProofId &proofid) const {
     auto &remoteProofsView = remoteProofs.get<by_proofid>();
     auto [begin, end] = remoteProofsView.equal_range(proofid);
 
     if (begin == end) {
         // No remote registered anything yet, we are on our own
         return std::nullopt;
     }
 
     double total_score{0};
     double present_score{0};
     double missing_score{0};
 
     for (auto it = begin; it != end; it++) {
         auto nit = nodes.find(it->nodeid);
         if (nit == nodes.end()) {
             // No such node
             continue;
         }
 
         const PeerId peerid = nit->peerid;
 
         auto pit = peers.find(peerid);
         if (pit == peers.end()) {
             // Peer not found
             continue;
         }
 
         uint32_t node_count = pit->node_count;
         if (localProof && pit->getProofId() == localProof->getId()) {
             // If that's our local proof, account for ourself
             ++node_count;
         }
 
         if (node_count == 0) {
             // should never happen
             continue;
         }
 
         const double score = double(pit->getScore()) / node_count;
 
         total_score += score;
         if (it->present) {
             present_score += score;
         } else {
             missing_score += score;
         }
     }
 
     if (localProof) {
         auto &peersByProofid = peers.get<by_proofid>();
 
         // Do we have a node connected for that proof ?
         bool present = false;
         auto pit = peersByProofid.find(proofid);
         if (pit != peersByProofid.end()) {
             present = pit->node_count > 0;
         }
 
         pit = peersByProofid.find(localProof->getId());
         if (pit != peersByProofid.end()) {
             // Also divide by node_count, we can have several nodes even for our
             // local proof.
             const double score =
                 double(pit->getScore()) / (1 + pit->node_count);
 
             total_score += score;
             if (present) {
                 present_score += score;
             } else {
                 missing_score += score;
             }
         }
     }
 
     if (present_score / total_score > 0.55) {
         return std::make_optional(true);
     }
 
     if (missing_score / total_score > 0.55) {
         return std::make_optional(false);
     }
 
     return std::nullopt;
 }
 
 bool PeerManager::dumpPeersToFile(const fs::path &dumpPath) const {
     try {
         const fs::path dumpPathTmp = dumpPath + ".new";
         FILE *filestr = fsbridge::fopen(dumpPathTmp, "wb");
         if (!filestr) {
             return false;
         }
 
         CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
         file << PEERS_DUMP_VERSION;
         file << uint64_t(peers.size());
         for (const Peer &peer : peers) {
             file << peer.proof;
             file << peer.hasFinalized;
             file << int64_t(peer.registration_time.count());
             file << int64_t(peer.nextPossibleConflictTime.count());
         }
 
         if (!FileCommit(file.Get())) {
             throw std::runtime_error(strprintf("Failed to commit to file %s",
                                                PathToString(dumpPathTmp)));
         }
         file.fclose();
 
         if (!RenameOver(dumpPathTmp, dumpPath)) {
             throw std::runtime_error(strprintf("Rename failed from %s to %s",
                                                PathToString(dumpPathTmp),
                                                PathToString(dumpPath)));
         }
     } catch (const std::exception &e) {
         LogPrint(BCLog::AVALANCHE, "Failed to dump the avalanche peers: %s.\n",
                  e.what());
         return false;
     }
 
     LogPrint(BCLog::AVALANCHE, "Successfully dumped %d peers to %s.\n",
              peers.size(), PathToString(dumpPath));
 
     return true;
 }
 
 bool PeerManager::loadPeersFromFile(
     const fs::path &dumpPath,
     std::unordered_set<ProofRef, SaltedProofHasher> &registeredProofs) {
     registeredProofs.clear();
 
     FILE *filestr = fsbridge::fopen(dumpPath, "rb");
     CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
     if (file.IsNull()) {
         LogPrint(BCLog::AVALANCHE,
                  "Failed to open avalanche peers file from disk.\n");
         return false;
     }
 
     try {
         uint64_t version;
         file >> version;
 
         if (version != PEERS_DUMP_VERSION) {
             LogPrint(BCLog::AVALANCHE,
                      "Unsupported avalanche peers file version.\n");
             return false;
         }
 
         uint64_t numPeers;
         file >> numPeers;
 
         auto &peersByProofId = peers.get<by_proofid>();
 
         for (uint64_t i = 0; i < numPeers; i++) {
             ProofRef proof;
             bool hasFinalized;
             int64_t registrationTime;
             int64_t nextPossibleConflictTime;
 
             file >> proof;
             file >> hasFinalized;
             file >> registrationTime;
             file >> nextPossibleConflictTime;
 
             if (registerProof(proof)) {
                 auto it = peersByProofId.find(proof->getId());
                 if (it == peersByProofId.end()) {
                     // Should never happen
                     continue;
                 }
 
                 // We don't modify any key so we don't need to rehash.
                 // If the modify fails, it means we don't get the full benefit
                 // from the file but we still added our peer to the set. The
                 // non-overridden fields will be set the normal way.
                 peersByProofId.modify(it, [&](Peer &p) {
                     p.hasFinalized = hasFinalized;
                     p.registration_time =
                         std::chrono::seconds{registrationTime};
                     p.nextPossibleConflictTime =
                         std::chrono::seconds{nextPossibleConflictTime};
                 });
 
                 registeredProofs.insert(proof);
             }
         }
     } catch (const std::exception &e) {
         LogPrint(BCLog::AVALANCHE,
                  "Failed to read the avalanche peers file data on disk: %s.\n",
                  e.what());
         return false;
     }
 
     return true;
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
index f2cd50ae6..9790f763d 100644
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -1,3047 +1,3087 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/proofcomparator.h>
 #include <avalanche/statistics.h>
 #include <avalanche/test/util.h>
 #include <cashaddrenc.h>
 #include <config.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <script/standard.h>
 #include <uint256.h>
 #include <util/time.h>
 #include <util/translation.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <limits>
 #include <optional>
 #include <unordered_map>
 
 using namespace avalanche;
 
 namespace avalanche {
 namespace {
     struct TestPeerManager {
         static bool nodeBelongToPeer(const PeerManager &pm, NodeId nodeid,
                                      PeerId peerid) {
             return pm.forNode(nodeid, [&](const Node &node) {
                 return node.peerid == peerid;
             });
         }
 
         static bool isNodePending(const PeerManager &pm, NodeId nodeid) {
             auto &pendingNodesView = pm.pendingNodes.get<by_nodeid>();
             return pendingNodesView.find(nodeid) != pendingNodesView.end();
         }
 
         static PeerId getPeerIdForProofId(PeerManager &pm,
                                           const ProofId &proofid) {
             auto &pview = pm.peers.get<by_proofid>();
             auto it = pview.find(proofid);
             return it == pview.end() ? NO_PEER : it->peerid;
         }
 
         static PeerId registerAndGetPeerId(PeerManager &pm,
                                            const ProofRef &proof) {
             pm.registerProof(proof);
             return getPeerIdForProofId(pm, proof->getId());
         }
 
         static std::vector<uint32_t> getOrderedScores(const PeerManager &pm) {
             std::vector<uint32_t> scores;
 
             auto &peerView = pm.peers.get<by_score>();
             for (const Peer &peer : peerView) {
                 scores.push_back(peer.getScore());
             }
 
             return scores;
         }
 
         static void cleanupDanglingProofs(
             PeerManager &pm,
             std::unordered_set<ProofRef, SaltedProofHasher> &registeredProofs) {
             pm.cleanupDanglingProofs(registeredProofs);
         }
 
         static void cleanupDanglingProofs(PeerManager &pm) {
             std::unordered_set<ProofRef, SaltedProofHasher> dummy;
             pm.cleanupDanglingProofs(dummy);
         }
 
         static std::optional<RemoteProof> getRemoteProof(const PeerManager &pm,
                                                          const ProofId &proofid,
                                                          NodeId nodeid) {
             auto it = pm.remoteProofs.find(boost::make_tuple(proofid, nodeid));
             if (it == pm.remoteProofs.end()) {
                 return std::nullopt;
             }
             return std::make_optional(*it);
         }
 
         static size_t getPeerCount(const PeerManager &pm) {
             return pm.peers.size();
         }
 
         static std::optional<bool>
         getRemotePresenceStatus(const PeerManager &pm, const ProofId &proofid) {
             return pm.getRemotePresenceStatus(proofid);
         }
 
         static void clearPeers(PeerManager &pm) {
             std::vector<PeerId> peerIds;
             for (auto &peer : pm.peers) {
                 peerIds.push_back(peer.peerid);
             }
             for (const PeerId &peerid : peerIds) {
                 pm.removePeer(peerid);
             }
             BOOST_CHECK_EQUAL(pm.peers.size(), 0);
         }
 
         static void setLocalProof(PeerManager &pm, const ProofRef &proof) {
             pm.localProof = proof;
         }
 
         static bool isFlaky(const PeerManager &pm, const ProofId &proofid) {
             return pm.isFlaky(proofid);
         }
     };
 
     static void addCoin(Chainstate &chainstate, const COutPoint &outpoint,
                         const CKey &key,
                         const Amount amount = PROOF_DUST_THRESHOLD,
                         uint32_t height = 100, bool is_coinbase = false) {
         CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
         LOCK(cs_main);
         CCoinsViewCache &coins = chainstate.CoinsTip();
         coins.AddCoin(outpoint,
                       Coin(CTxOut(amount, script), height, is_coinbase), false);
     }
 
     static COutPoint createUtxo(Chainstate &chainstate, const CKey &key,
                                 const Amount amount = PROOF_DUST_THRESHOLD,
                                 uint32_t height = 100,
                                 bool is_coinbase = false) {
         COutPoint outpoint(TxId(GetRandHash()), 0);
         addCoin(chainstate, outpoint, key, amount, height, is_coinbase);
         return outpoint;
     }
 
     static ProofRef
     buildProof(const CKey &key,
                const std::vector<std::tuple<COutPoint, Amount>> &outpoints,
                const CKey &master = CKey::MakeCompressedKey(),
                int64_t sequence = 1, uint32_t height = 100,
                bool is_coinbase = false, int64_t expirationTime = 0,
                const CScript &payoutScript = UNSPENDABLE_ECREG_PAYOUT_SCRIPT) {
         ProofBuilder pb(sequence, expirationTime, master, payoutScript);
         for (const auto &[outpoint, amount] : outpoints) {
             BOOST_CHECK(pb.addUTXO(outpoint, amount, height, is_coinbase, key));
         }
         return pb.build();
     }
 
     template <typename... Args>
     static ProofRef
     buildProofWithOutpoints(const CKey &key,
                             const std::vector<COutPoint> &outpoints,
                             Amount amount, Args &&...args) {
         std::vector<std::tuple<COutPoint, Amount>> outpointsWithAmount;
         std::transform(
             outpoints.begin(), outpoints.end(),
             std::back_inserter(outpointsWithAmount),
             [amount](const auto &o) { return std::make_tuple(o, amount); });
         return buildProof(key, outpointsWithAmount,
                           std::forward<Args>(args)...);
     }
 
     static ProofRef
     buildProofWithSequence(const CKey &key,
                            const std::vector<COutPoint> &outpoints,
                            int64_t sequence) {
         return buildProofWithOutpoints(key, outpoints, PROOF_DUST_THRESHOLD,
                                        key, sequence);
     }
 } // namespace
 } // namespace avalanche
 
 namespace {
 struct PeerManagerFixture : public TestChain100Setup {
     PeerManagerFixture() {
         gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "1");
     }
     ~PeerManagerFixture() {
         gArgs.ClearForcedArg("-avaproofstakeutxoconfirmations");
     }
 };
 } // namespace
 
 namespace {
 struct NoCoolDownFixture : public PeerManagerFixture {
     NoCoolDownFixture() {
         gArgs.ForceSetArg("-avalancheconflictingproofcooldown", "0");
     }
     ~NoCoolDownFixture() {
         gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
     }
 };
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(peermanager_tests, PeerManagerFixture)
 
 BOOST_AUTO_TEST_CASE(select_peer_linear) {
     // No peers.
     BOOST_CHECK_EQUAL(selectPeerImpl({}, 0, 0), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl({}, 1, 3), NO_PEER);
 
     // One peer
     const std::vector<Slot> oneslot = {{100, 100, 23}};
 
     // Undershoot
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 0, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 42, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 99, 300), NO_PEER);
 
     // Nailed it
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 100, 300), 23);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 142, 300), 23);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 199, 300), 23);
 
     // Overshoot
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 200, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 242, 300), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(oneslot, 299, 300), NO_PEER);
 
     // Two peers
     const std::vector<Slot> twoslots = {{100, 100, 69}, {300, 100, 42}};
 
     // Undershoot
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 0, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 42, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 99, 500), NO_PEER);
 
     // First entry
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 100, 500), 69);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 142, 500), 69);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 199, 500), 69);
 
     // In between
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 200, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 242, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 299, 500), NO_PEER);
 
     // Second entry
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 300, 500), 42);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 342, 500), 42);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 399, 500), 42);
 
     // Overshoot
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 400, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 442, 500), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(twoslots, 499, 500), NO_PEER);
 }
 
 BOOST_AUTO_TEST_CASE(select_peer_dichotomic) {
     std::vector<Slot> slots;
 
     // 100 peers of size 1 with 1 empty element apart.
     uint64_t max = 1;
     for (int i = 0; i < 100; i++) {
         slots.emplace_back(max, 1, i);
         max += 2;
     }
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 4, max), NO_PEER);
 
     // Check that we get what we expect.
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i, max), NO_PEER);
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i + 1, max), i);
     }
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, max, max), NO_PEER);
 
     // Update the slots to be heavily skewed toward the last element.
     slots[99] = slots[99].withScore(101);
     max = slots[99].getStop();
     BOOST_CHECK_EQUAL(max, 300);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i, max), NO_PEER);
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 2 * i + 1, max), i);
     }
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 200, max), 99);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 256, max), 99);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 299, max), 99);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 300, max), NO_PEER);
 
     // Update the slots to be heavily skewed toward the first element.
     for (int i = 0; i < 100; i++) {
         slots[i] = slots[i].withStart(slots[i].getStart() + 100);
     }
 
     slots[0] = Slot(1, slots[0].getStop() - 1, slots[0].getPeerId());
     slots[99] = slots[99].withScore(1);
     max = slots[99].getStop();
     BOOST_CHECK_EQUAL(max, 300);
 
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 0, max), NO_PEER);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 1, max), 0);
     BOOST_CHECK_EQUAL(selectPeerImpl(slots, 42, max), 0);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 100 + 2 * i + 1, max), i);
         BOOST_CHECK_EQUAL(selectPeerImpl(slots, 100 + 2 * i + 2, max), NO_PEER);
     }
 }
 
 BOOST_AUTO_TEST_CASE(select_peer_random) {
     for (int c = 0; c < 1000; c++) {
         size_t size = InsecureRandBits(10) + 1;
         std::vector<Slot> slots;
         slots.reserve(size);
 
         uint64_t max = InsecureRandBits(3);
         auto next = [&]() {
             uint64_t r = max;
             max += InsecureRandBits(3);
             return r;
         };
 
         for (size_t i = 0; i < size; i++) {
             const uint64_t start = next();
             const uint32_t score = InsecureRandBits(3);
             max += score;
             slots.emplace_back(start, score, i);
         }
 
         for (int k = 0; k < 100; k++) {
             uint64_t s = max > 0 ? InsecureRandRange(max) : 0;
             auto i = selectPeerImpl(slots, s, max);
             // /!\ Because of the way we construct the vector, the peer id is
             // always the index. This might not be the case in practice.
             BOOST_CHECK(i == NO_PEER || slots[i].contains(s));
         }
     }
 }
 
 static void addNodeWithScore(Chainstate &active_chainstate,
                              avalanche::PeerManager &pm, NodeId node,
                              uint32_t score) {
     auto proof = buildRandomProof(active_chainstate, score);
     BOOST_CHECK(pm.registerProof(proof));
     BOOST_CHECK(pm.addNode(node, proof->getId()));
 };
 
 BOOST_AUTO_TEST_CASE(peer_probabilities) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     // No peers.
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     const NodeId node0 = 42, node1 = 69, node2 = 37;
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
     // One peer, we always return it.
     addNodeWithScore(active_chainstate, pm, node0, MIN_VALID_PROOF_SCORE);
     BOOST_CHECK_EQUAL(pm.selectNode(), node0);
 
     // Two peers, verify ratio.
     addNodeWithScore(active_chainstate, pm, node1, 2 * MIN_VALID_PROOF_SCORE);
 
     std::unordered_map<PeerId, int> results = {};
     for (int i = 0; i < 10000; i++) {
         size_t n = pm.selectNode();
         BOOST_CHECK(n == node0 || n == node1);
         results[n]++;
     }
 
     BOOST_CHECK(abs(2 * results[0] - results[1]) < 500);
 
     // Three peers, verify ratio.
     addNodeWithScore(active_chainstate, pm, node2, MIN_VALID_PROOF_SCORE);
 
     results.clear();
     for (int i = 0; i < 10000; i++) {
         size_t n = pm.selectNode();
         BOOST_CHECK(n == node0 || n == node1 || n == node2);
         results[n]++;
     }
 
     BOOST_CHECK(abs(results[0] - results[1] + results[2]) < 500);
 }
 
 BOOST_AUTO_TEST_CASE(remove_peer) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     // No peers.
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     BOOST_CHECK_EQUAL(pm.selectPeer(), NO_PEER);
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
     // Add 4 peers.
     std::array<PeerId, 8> peerids;
     for (int i = 0; i < 4; i++) {
         auto p = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         peerids[i] = TestPeerManager::registerAndGetPeerId(pm, p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 40000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[0] || p == peerids[1] || p == peerids[2] ||
                     p == peerids[3]);
     }
 
     // Remove one peer, it nevers show up now.
     BOOST_CHECK(pm.removePeer(peerids[2]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 40000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 10000);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 10000);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 30000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[0] || p == peerids[1] || p == peerids[3]);
     }
 
     // Add 4 more peers.
     for (int i = 0; i < 4; i++) {
         auto p = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         peerids[i + 4] = TestPeerManager::registerAndGetPeerId(pm, p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 70000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     BOOST_CHECK(pm.removePeer(peerids[0]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 70000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 10000);
 
     // Removing the last entry do not increase fragmentation.
     BOOST_CHECK(pm.removePeer(peerids[7]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 60000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 10000);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 10000);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 50000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[1] || p == peerids[3] || p == peerids[4] ||
                     p == peerids[5] || p == peerids[6]);
     }
 
     // Removing non existent peers fails.
     BOOST_CHECK(!pm.removePeer(peerids[0]));
     BOOST_CHECK(!pm.removePeer(peerids[2]));
     BOOST_CHECK(!pm.removePeer(peerids[7]));
     BOOST_CHECK(!pm.removePeer(NO_PEER));
 }
 
 BOOST_AUTO_TEST_CASE(compact_slots) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     // Add 4 peers.
     std::array<PeerId, 4> peerids;
     for (int i = 0; i < 4; i++) {
         auto p = buildRandomProof(chainman.ActiveChainstate(),
                                   MIN_VALID_PROOF_SCORE);
         peerids[i] = TestPeerManager::registerAndGetPeerId(pm, p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     // Remove all peers.
     for (auto p : peerids) {
         pm.removePeer(p);
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 30000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 30000);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(pm.selectPeer(), NO_PEER);
     }
 
     BOOST_CHECK_EQUAL(pm.compact(), 30000);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 0);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(node_crud) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     // Create one peer.
     auto proof =
         buildRandomProof(active_chainstate, 10000000 * MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof));
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     // Add 4 nodes.
     const ProofId &proofid = proof->getId();
     for (int i = 0; i < 4; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
     }
 
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         BOOST_CHECK(n >= 0 && n < 4);
         BOOST_CHECK(pm.updateNextRequestTime(n, Now<SteadyMilliseconds>()));
     }
 
     // Remove a node, check that it doesn't show up.
     BOOST_CHECK(pm.removeNode(2));
 
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         BOOST_CHECK(n == 0 || n == 1 || n == 3);
         BOOST_CHECK(pm.updateNextRequestTime(n, Now<SteadyMilliseconds>()));
     }
 
     // Push a node's timeout in the future, so that it doesn't show up.
     BOOST_CHECK(pm.updateNextRequestTime(1, Now<SteadyMilliseconds>() +
                                                 std::chrono::hours(24)));
 
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         BOOST_CHECK(n == 0 || n == 3);
         BOOST_CHECK(pm.updateNextRequestTime(n, Now<SteadyMilliseconds>()));
     }
 
     // Move a node from a peer to another. This peer has a very low score such
     // as chances of being picked are 1 in 10 million.
     addNodeWithScore(active_chainstate, pm, 3, MIN_VALID_PROOF_SCORE);
 
     int node3selected = 0;
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
         if (n == 3) {
             // Selecting this node should be exceedingly unlikely.
             BOOST_CHECK(node3selected++ < 1);
         } else {
             BOOST_CHECK_EQUAL(n, 0);
         }
         BOOST_CHECK(pm.updateNextRequestTime(n, Now<SteadyMilliseconds>()));
     }
 }
 
 BOOST_AUTO_TEST_CASE(node_binding) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     const ProofId &proofid = proof->getId();
 
     BOOST_CHECK_EQUAL(pm.getNodeCount(), 0);
     BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 0);
 
     // Add a bunch of nodes with no associated peer
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(!pm.addNode(i, proofid));
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 0);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), i + 1);
     }
 
     // Now create the peer and check all the nodes are bound
     const PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 10);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 0);
     }
     BOOST_CHECK(pm.verify());
 
     // Disconnect some nodes
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(pm.removeNode(i));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 10 - i - 1);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 0);
     }
 
     // Add nodes when the peer already exists
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 5 + i + 1);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 0);
     }
 
     auto alt_proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     const ProofId &alt_proofid = alt_proof->getId();
 
     // Update some nodes from a known proof to an unknown proof
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(!pm.addNode(i, alt_proofid));
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 10 - i - 1);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), i + 1);
     }
 
     auto alt2_proof =
         buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     const ProofId &alt2_proofid = alt2_proof->getId();
 
     // Update some nodes from an unknown proof to another unknown proof
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(!pm.addNode(i, alt2_proofid));
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 5);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 5);
     }
 
     // Update some nodes from an unknown proof to a known proof
     for (int i = 0; i < 5; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 5 + i + 1);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 5 - i - 1);
     }
 
     // Remove the peer, the nodes should be pending again
     BOOST_CHECK(pm.removePeer(peerid));
     BOOST_CHECK(!pm.exists(proof->getId()));
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 0);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 10);
     }
     BOOST_CHECK(pm.verify());
 
     // Remove the remaining pending nodes, check the count drops accordingly
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.removeNode(i));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
         BOOST_CHECK_EQUAL(pm.getNodeCount(), 0);
         BOOST_CHECK_EQUAL(pm.getPendingNodeCount(), 10 - i - 1);
     }
 }
 
 BOOST_AUTO_TEST_CASE(node_binding_reorg) {
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     ChainstateManager &chainman = *Assert(m_node.chainman);
 
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     auto proof = buildRandomProof(chainman.ActiveChainstate(),
                                   MIN_VALID_PROOF_SCORE, 99);
     const ProofId &proofid = proof->getId();
 
     PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     BOOST_CHECK(pm.verify());
 
     // Add nodes to our peer
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
     // Make the proof immature by reorging to a shorter chain
     {
         BlockValidationState state;
         chainman.ActiveChainstate().InvalidateBlock(
             state, WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip()));
         BOOST_CHECK_EQUAL(
             WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight()), 99);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(pm.isImmature(proofid));
     BOOST_CHECK(!pm.isBoundToPeer(proofid));
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 
     // Make the proof great again
     {
         // Advance the clock so the newly mined block won't collide with the
         // other deterministically-generated blocks
         SetMockTime(GetTime() + 20);
         mineBlocks(1);
         BlockValidationState state;
         BOOST_CHECK(chainman.ActiveChainstate().ActivateBestChain(state));
         LOCK(chainman.GetMutex());
         BOOST_CHECK_EQUAL(chainman.ActiveHeight(), 100);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isImmature(proofid));
     BOOST_CHECK(pm.isBoundToPeer(proofid));
     // The peerid has certainly been updated
     peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 }
 
 BOOST_AUTO_TEST_CASE(proof_conflict) {
     auto key = CKey::MakeCompressedKey();
 
     TxId txid1(GetRandHash());
     TxId txid2(GetRandHash());
     BOOST_CHECK(txid1 != txid2);
 
     const Amount v = PROOF_DUST_THRESHOLD;
     const int height = 100;
 
     ChainstateManager &chainman = *Assert(m_node.chainman);
     for (uint32_t i = 0; i < 10; i++) {
         addCoin(chainman.ActiveChainstate(), {txid1, i}, key);
         addCoin(chainman.ActiveChainstate(), {txid2, i}, key);
     }
 
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     CKey masterKey = CKey::MakeCompressedKey();
     const auto getPeerId = [&](const std::vector<COutPoint> &outpoints) {
         return TestPeerManager::registerAndGetPeerId(
             pm, buildProofWithOutpoints(key, outpoints, v, masterKey, 0, height,
                                         false, 0));
     };
 
     // Add one peer.
     const PeerId peer1 = getPeerId({COutPoint(txid1, 0)});
     BOOST_CHECK(peer1 != NO_PEER);
 
     // Same proof, same peer.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0)}), peer1);
 
     // Different txid, different proof.
     const PeerId peer2 = getPeerId({COutPoint(txid2, 0)});
     BOOST_CHECK(peer2 != NO_PEER && peer2 != peer1);
 
     // Different index, different proof.
     const PeerId peer3 = getPeerId({COutPoint(txid1, 1)});
     BOOST_CHECK(peer3 != NO_PEER && peer3 != peer1);
 
     // Empty proof, no peer.
     BOOST_CHECK_EQUAL(getPeerId({}), NO_PEER);
 
     // Multiple inputs.
     const PeerId peer4 = getPeerId({COutPoint(txid1, 2), COutPoint(txid2, 2)});
     BOOST_CHECK(peer4 != NO_PEER && peer4 != peer1);
 
     // Duplicated input.
     {
         ProofBuilder pb(0, 0, CKey::MakeCompressedKey(),
                         UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         COutPoint o(txid1, 3);
         BOOST_CHECK(pb.addUTXO(o, v, height, false, key));
         BOOST_CHECK(
             !pm.registerProof(TestProofBuilder::buildDuplicatedStakes(pb)));
     }
 
     // Multiple inputs, collision on first input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 4)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on second input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 4), COutPoint(txid2, 0)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on both inputs.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 2)}),
                       NO_PEER);
 }
 
 BOOST_AUTO_TEST_CASE(immature_proofs) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     auto key = CKey::MakeCompressedKey();
     int immatureHeight = 100;
 
     auto registerImmature = [&](const ProofRef &proof) {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proof, state));
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::IMMATURE);
     };
 
     auto checkImmature = [&](const ProofRef &proof, bool expectedImmature) {
         const ProofId &proofid = proof->getId();
         BOOST_CHECK(pm.exists(proofid));
 
         BOOST_CHECK_EQUAL(pm.isImmature(proofid), expectedImmature);
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(proofid), !expectedImmature);
 
         bool ret = false;
         pm.forEachPeer([&](const Peer &peer) {
             if (proof->getId() == peer.proof->getId()) {
                 ret = true;
             }
         });
         BOOST_CHECK_EQUAL(ret, !expectedImmature);
     };
 
     // Track immature proofs so we can test them later
     std::vector<ProofRef> immatureProofs;
 
     // Fill up the immature pool to test the size limit
     for (int64_t i = 1; i <= AVALANCHE_MAX_IMMATURE_PROOFS; i++) {
         COutPoint outpoint = COutPoint(TxId(GetRandHash()), 0);
         auto proof = buildProofWithOutpoints(
             key, {outpoint}, i * PROOF_DUST_THRESHOLD, key, 0, immatureHeight);
         addCoin(chainman.ActiveChainstate(), outpoint, key,
                 i * PROOF_DUST_THRESHOLD, immatureHeight);
         registerImmature(proof);
         checkImmature(proof, true);
         immatureProofs.push_back(proof);
     }
 
     // More immature proofs evict lower scoring proofs
     for (auto i = 0; i < 100; i++) {
         COutPoint outpoint = COutPoint(TxId(GetRandHash()), 0);
         auto proof =
             buildProofWithOutpoints(key, {outpoint}, 200 * PROOF_DUST_THRESHOLD,
                                     key, 0, immatureHeight);
         addCoin(chainman.ActiveChainstate(), outpoint, key,
                 200 * PROOF_DUST_THRESHOLD, immatureHeight);
         registerImmature(proof);
         checkImmature(proof, true);
         immatureProofs.push_back(proof);
         BOOST_CHECK(!pm.exists(immatureProofs.front()->getId()));
         immatureProofs.erase(immatureProofs.begin());
     }
 
     // Replacement when the pool is full still works
     {
         const COutPoint &outpoint =
             immatureProofs.front()->getStakes()[0].getStake().getUTXO();
         auto proof =
             buildProofWithOutpoints(key, {outpoint}, 101 * PROOF_DUST_THRESHOLD,
                                     key, 1, immatureHeight);
         registerImmature(proof);
         checkImmature(proof, true);
         immatureProofs.push_back(proof);
         BOOST_CHECK(!pm.exists(immatureProofs.front()->getId()));
         immatureProofs.erase(immatureProofs.begin());
     }
 
     // Mine a block to increase the chain height, turning all immature proofs to
     // mature
     mineBlocks(1);
     pm.updatedBlockTip();
     for (const auto &proof : immatureProofs) {
         checkImmature(proof, false);
     }
 }
 
 BOOST_AUTO_TEST_CASE(dangling_node) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
 
     const SteadyMilliseconds theFuture(Now<SteadyMilliseconds>() +
                                        std::chrono::hours(24));
 
     // Add nodes to this peer and update their request time far in the future
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proof->getId()));
         BOOST_CHECK(pm.updateNextRequestTime(i, theFuture));
     }
 
     // Remove the peer
     BOOST_CHECK(pm.removePeer(peerid));
 
     // Check the nodes are still there
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.forNode(i, [](const Node &n) { return true; }));
     }
 
     // Build a new one
     proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
 
     // Update the nodes with the new proof
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proof->getId()));
         BOOST_CHECK(pm.forNode(
             i, [&](const Node &n) { return n.nextRequestTime == theFuture; }));
     }
 
     // Remove the peer
     BOOST_CHECK(pm.removePeer(peerid));
 
     // Disconnect the nodes
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.removeNode(i));
     }
 }
 
 BOOST_AUTO_TEST_CASE(proof_accessors) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     constexpr int numProofs = 10;
 
     std::vector<ProofRef> proofs;
     proofs.reserve(numProofs);
     for (int i = 0; i < numProofs; i++) {
         proofs.push_back(buildRandomProof(chainman.ActiveChainstate(),
                                           MIN_VALID_PROOF_SCORE));
     }
 
     for (int i = 0; i < numProofs; i++) {
         BOOST_CHECK(pm.registerProof(proofs[i]));
 
         {
             ProofRegistrationState state;
             // Fail to add an existing proof
             BOOST_CHECK(!pm.registerProof(proofs[i], state));
             BOOST_CHECK(state.GetResult() ==
                         ProofRegistrationResult::ALREADY_REGISTERED);
         }
 
         for (int added = 0; added <= i; added++) {
             auto proof = pm.getProof(proofs[added]->getId());
             BOOST_CHECK(proof != nullptr);
 
             const ProofId &proofid = proof->getId();
             BOOST_CHECK_EQUAL(proofid, proofs[added]->getId());
         }
     }
 
     // No stake, copied from proof_tests.cpp
     const std::string badProofHex(
         "96527eae083f1f24625f049d9e54bb9a21023beefdde700a6bc02036335b4df141c8b"
         "c67bb05a971f5ac2745fd683797dde3002321023beefdde700a6bc02036335b4df141"
         "c8bc67bb05a971f5ac2745fd683797dde3ac135da984db510334abe41134e3d4ef09a"
         "d006b1152be8bc413182bf6f947eac1f8580fe265a382195aa2d73935cabf86d90a8f"
         "666d0a62385ae24732eca51575");
     bilingual_str error;
     auto badProof = RCUPtr<Proof>::make();
     BOOST_CHECK(Proof::FromHex(*badProof, badProofHex, error));
 
     ProofRegistrationState state;
     BOOST_CHECK(!pm.registerProof(badProof, state));
     BOOST_CHECK(state.GetResult() == ProofRegistrationResult::INVALID);
 }
 
 BOOST_FIXTURE_TEST_CASE(conflicting_proof_rescan, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     const COutPoint conflictingOutpoint = createUtxo(active_chainstate, key);
     const COutPoint outpointToSend = createUtxo(active_chainstate, key);
 
     ProofRef proofToInvalidate =
         buildProofWithSequence(key, {conflictingOutpoint, outpointToSend}, 20);
     BOOST_CHECK(pm.registerProof(proofToInvalidate));
 
     ProofRef conflictingProof =
         buildProofWithSequence(key, {conflictingOutpoint}, 10);
     ProofRegistrationState state;
     BOOST_CHECK(!pm.registerProof(conflictingProof, state));
     BOOST_CHECK(state.GetResult() == ProofRegistrationResult::CONFLICTING);
     BOOST_CHECK(pm.isInConflictingPool(conflictingProof->getId()));
 
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = active_chainstate.CoinsTip();
         // Make proofToInvalidate invalid
         coins.SpendCoin(outpointToSend);
     }
 
     pm.updatedBlockTip();
 
     BOOST_CHECK(!pm.exists(proofToInvalidate->getId()));
 
     BOOST_CHECK(!pm.isInConflictingPool(conflictingProof->getId()));
     BOOST_CHECK(pm.isBoundToPeer(conflictingProof->getId()));
 }
 
 BOOST_FIXTURE_TEST_CASE(conflicting_proof_selection, NoCoolDownFixture) {
     const CKey key = CKey::MakeCompressedKey();
 
     const Amount amount(PROOF_DUST_THRESHOLD);
     const uint32_t height = 100;
     const bool is_coinbase = false;
 
     ChainstateManager &chainman = *Assert(m_node.chainman);
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     // This will be the conflicting UTXO for all the following proofs
     auto conflictingOutpoint = createUtxo(active_chainstate, key, amount);
 
     auto proof_base = buildProofWithSequence(key, {conflictingOutpoint}, 10);
 
     ConflictingProofComparator comparator;
     auto checkPreferred = [&](const ProofRef &candidate,
                               const ProofRef &reference, bool expectAccepted) {
         BOOST_CHECK_EQUAL(comparator(candidate, reference), expectAccepted);
         BOOST_CHECK_EQUAL(comparator(reference, candidate), !expectAccepted);
 
         avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
         BOOST_CHECK(pm.registerProof(reference));
         BOOST_CHECK(pm.isBoundToPeer(reference->getId()));
 
         ProofRegistrationState state;
         BOOST_CHECK_EQUAL(pm.registerProof(candidate, state), expectAccepted);
         BOOST_CHECK_EQUAL(state.IsValid(), expectAccepted);
         BOOST_CHECK_EQUAL(state.GetResult() ==
                               ProofRegistrationResult::CONFLICTING,
                           !expectAccepted);
 
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(candidate->getId()), expectAccepted);
         BOOST_CHECK_EQUAL(pm.isInConflictingPool(candidate->getId()),
                           !expectAccepted);
 
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(reference->getId()),
                           !expectAccepted);
         BOOST_CHECK_EQUAL(pm.isInConflictingPool(reference->getId()),
                           expectAccepted);
     };
 
     // Same master key, lower sequence number
     checkPreferred(buildProofWithSequence(key, {conflictingOutpoint}, 9),
                    proof_base, false);
     // Same master key, higher sequence number
     checkPreferred(buildProofWithSequence(key, {conflictingOutpoint}, 11),
                    proof_base, true);
 
     auto buildProofFromAmounts = [&](const CKey &master,
                                      std::vector<Amount> &&amounts) {
         std::vector<std::tuple<COutPoint, Amount>> outpointsWithAmount{
             {conflictingOutpoint, amount}};
         std::transform(amounts.begin(), amounts.end(),
                        std::back_inserter(outpointsWithAmount),
                        [&key, &active_chainstate](const Amount amount) {
                            return std::make_tuple(
                                createUtxo(active_chainstate, key, amount),
                                amount);
                        });
         return buildProof(key, outpointsWithAmount, master, 0, height,
                           is_coinbase, 0);
     };
 
     auto proof_multiUtxo = buildProofFromAmounts(
         key, {2 * PROOF_DUST_THRESHOLD, 2 * PROOF_DUST_THRESHOLD});
 
     // Test for both the same master and a different one. The sequence number
     // is the same for all these tests.
     for (const CKey &k : {key, CKey::MakeCompressedKey()}) {
         // Low amount
         checkPreferred(buildProofFromAmounts(
                            k, {2 * PROOF_DUST_THRESHOLD, PROOF_DUST_THRESHOLD}),
                        proof_multiUtxo, false);
         // High amount
         checkPreferred(buildProofFromAmounts(k, {2 * PROOF_DUST_THRESHOLD,
                                                  3 * PROOF_DUST_THRESHOLD}),
                        proof_multiUtxo, true);
         // Same amount, low stake count
         checkPreferred(buildProofFromAmounts(k, {4 * PROOF_DUST_THRESHOLD}),
                        proof_multiUtxo, true);
         // Same amount, high stake count
         checkPreferred(buildProofFromAmounts(k, {2 * PROOF_DUST_THRESHOLD,
                                                  PROOF_DUST_THRESHOLD,
                                                  PROOF_DUST_THRESHOLD}),
                        proof_multiUtxo, false);
         // Same amount, same stake count, selection is done on proof id
         auto proofSimilar = buildProofFromAmounts(
             k, {2 * PROOF_DUST_THRESHOLD, 2 * PROOF_DUST_THRESHOLD});
         checkPreferred(proofSimilar, proof_multiUtxo,
                        proofSimilar->getId() < proof_multiUtxo->getId());
     }
 }
 
 BOOST_AUTO_TEST_CASE(conflicting_immature_proofs) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     const COutPoint conflictingOutpoint = createUtxo(active_chainstate, key);
     const COutPoint matureOutpoint =
         createUtxo(active_chainstate, key, PROOF_DUST_THRESHOLD, 99);
 
     auto immature10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto immature20 =
         buildProofWithSequence(key, {conflictingOutpoint, matureOutpoint}, 20);
 
     BOOST_CHECK(!pm.registerProof(immature10));
     BOOST_CHECK(pm.isImmature(immature10->getId()));
 
     BOOST_CHECK(!pm.registerProof(immature20));
     BOOST_CHECK(pm.isImmature(immature20->getId()));
     BOOST_CHECK(!pm.exists(immature10->getId()));
 
     // Build and register a valid proof that will conflict with the immature one
     auto proof30 = buildProofWithOutpoints(key, {matureOutpoint},
                                            PROOF_DUST_THRESHOLD, key, 30, 99);
     BOOST_CHECK(pm.registerProof(proof30));
     BOOST_CHECK(pm.isBoundToPeer(proof30->getId()));
 
     // Reorg to a shorter chain to make proof30 immature
     {
         BlockValidationState state;
         active_chainstate.InvalidateBlock(
             state, WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip()));
         BOOST_CHECK_EQUAL(
             WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight()), 99);
     }
 
     // Check that a rescan will also select the preferred immature proof, in
     // this case proof30 will replace immature20.
     pm.updatedBlockTip();
 
     BOOST_CHECK(!pm.isBoundToPeer(proof30->getId()));
     BOOST_CHECK(pm.isImmature(proof30->getId()));
     BOOST_CHECK(!pm.exists(immature20->getId()));
 }
 
 BOOST_FIXTURE_TEST_CASE(preferred_conflicting_proof, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq30));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq30->getId()));
 
     // proofSeq10 is a worst candidate than proofSeq30, so it goes to the
     // conflicting pool.
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isBoundToPeer(proofSeq10->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
 
     // proofSeq20 is a worst candidate than proofSeq30 but a better one than
     // proogSeq10, so it replaces it in the conflicting pool and proofSeq10 is
     // evicted.
     BOOST_CHECK(!pm.registerProof(proofSeq20));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isBoundToPeer(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
     BOOST_CHECK(!pm.exists(proofSeq10->getId()));
 }
 
 BOOST_FIXTURE_TEST_CASE(update_next_conflict_time, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     auto now = GetTime<std::chrono::seconds>();
     SetMockTime(now.count());
 
     // Updating the time of an unknown peer should fail
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(!pm.updateNextPossibleConflictTime(
             PeerId(GetRand<int>(1000)), now));
     }
 
     auto proof =
         buildRandomProof(chainman.ActiveChainstate(), MIN_VALID_PROOF_SCORE);
     PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
 
     auto checkNextPossibleConflictTime = [&](std::chrono::seconds expected) {
         BOOST_CHECK(pm.forPeer(proof->getId(), [&](const Peer &p) {
             return p.nextPossibleConflictTime == expected;
         }));
     };
 
     checkNextPossibleConflictTime(now);
 
     // Move the time in the past is not possible
     BOOST_CHECK(!pm.updateNextPossibleConflictTime(
         peerid, now - std::chrono::seconds{1}));
     checkNextPossibleConflictTime(now);
 
     BOOST_CHECK(pm.updateNextPossibleConflictTime(
         peerid, now + std::chrono::seconds{1}));
     checkNextPossibleConflictTime(now + std::chrono::seconds{1});
 }
 
 BOOST_FIXTURE_TEST_CASE(register_force_accept, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq30));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq30->getId()));
 
     // proofSeq20 is a worst candidate than proofSeq30, so it goes to the
     // conflicting pool.
     BOOST_CHECK(!pm.registerProof(proofSeq20));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
 
     // We can force the acceptance of proofSeq20
     using RegistrationMode = avalanche::PeerManager::RegistrationMode;
     BOOST_CHECK(pm.registerProof(proofSeq20, RegistrationMode::FORCE_ACCEPT));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
 
     // We can also force the acceptance of a proof which is not already in the
     // conflicting pool.
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(!pm.exists(proofSeq10->getId()));
 
     BOOST_CHECK(pm.registerProof(proofSeq10, RegistrationMode::FORCE_ACCEPT));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
     BOOST_CHECK(!pm.exists(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
 
     // Attempting to register again fails, and has no impact on the pools
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(!pm.registerProof(proofSeq10));
         BOOST_CHECK(
             !pm.registerProof(proofSeq10, RegistrationMode::FORCE_ACCEPT));
 
         BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
         BOOST_CHECK(!pm.exists(proofSeq20->getId()));
         BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
     }
 
     // Revert between proofSeq10 and proofSeq30 a few times
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(
             pm.registerProof(proofSeq30, RegistrationMode::FORCE_ACCEPT));
 
         BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
         BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
 
         BOOST_CHECK(
             pm.registerProof(proofSeq10, RegistrationMode::FORCE_ACCEPT));
 
         BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
         BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
     }
 }
 
 BOOST_FIXTURE_TEST_CASE(evicted_proof, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
 
     {
         ProofRegistrationState state;
         BOOST_CHECK(pm.registerProof(proofSeq30, state));
         BOOST_CHECK(state.IsValid());
     }
 
     {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proofSeq20, state));
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::CONFLICTING);
     }
 
     {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proofSeq10, state));
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::REJECTED);
     }
 }
 
 BOOST_AUTO_TEST_CASE(conflicting_proof_cooldown) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
     auto proofSeq40 = buildProofWithSequence(key, {conflictingOutpoint}, 40);
 
     int64_t conflictingProofCooldown = 100;
     gArgs.ForceSetArg("-avalancheconflictingproofcooldown",
                       strprintf("%d", conflictingProofCooldown));
 
     int64_t now = GetTime();
 
     auto increaseMockTime = [&](int64_t s) {
         now += s;
         SetMockTime(now);
     };
     increaseMockTime(0);
 
     BOOST_CHECK(pm.registerProof(proofSeq30));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
 
     auto checkRegistrationFailure = [&](const ProofRef &proof,
                                         ProofRegistrationResult reason) {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proof, state));
         BOOST_CHECK(state.GetResult() == reason);
     };
 
     // Registering a conflicting proof will fail due to the conflicting proof
     // cooldown
     checkRegistrationFailure(proofSeq20,
                              ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
     BOOST_CHECK(!pm.exists(proofSeq20->getId()));
 
     // The cooldown applies as well if the proof is the favorite
     checkRegistrationFailure(proofSeq40,
                              ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
     BOOST_CHECK(!pm.exists(proofSeq40->getId()));
 
     // Elapse the cooldown
     increaseMockTime(conflictingProofCooldown);
 
     // The proof will now be added to conflicting pool
     checkRegistrationFailure(proofSeq20, ProofRegistrationResult::CONFLICTING);
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
 
     // But no other
     checkRegistrationFailure(proofSeq40,
                              ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
     BOOST_CHECK(!pm.exists(proofSeq40->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
 
     // Elapse the cooldown
     increaseMockTime(conflictingProofCooldown);
 
     // The proof will now be accepted to replace proofSeq30, proofSeq30 will
     // move to the conflicting pool, and proofSeq20 will be evicted.
     BOOST_CHECK(pm.registerProof(proofSeq40));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq40->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
     BOOST_CHECK(!pm.exists(proofSeq20->getId()));
 
     gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
 }
 
 BOOST_FIXTURE_TEST_CASE(reject_proof, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     const COutPoint conflictingOutpoint =
         createUtxo(active_chainstate, key, PROOF_DUST_THRESHOLD, 99);
     const COutPoint immatureOutpoint = createUtxo(active_chainstate, key);
 
     // The good, the bad and the ugly
     auto proofSeq10 = buildProofWithOutpoints(
         key, {conflictingOutpoint}, PROOF_DUST_THRESHOLD, key, 10, 99);
     auto proofSeq20 = buildProofWithOutpoints(
         key, {conflictingOutpoint}, PROOF_DUST_THRESHOLD, key, 20, 99);
     auto immature30 = buildProofWithSequence(
         key, {conflictingOutpoint, immatureOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq20));
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(!pm.registerProof(immature30));
 
     BOOST_CHECK(pm.isBoundToPeer(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
     BOOST_CHECK(pm.isImmature(immature30->getId()));
 
     // Rejecting a proof that doesn't exist should fail
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(
             !pm.rejectProof(avalanche::ProofId(GetRandHash()),
                             avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(
             !pm.rejectProof(avalanche::ProofId(GetRandHash()),
                             avalanche::PeerManager::RejectionMode::INVALIDATE));
     }
 
     auto checkRejectDefault = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         const bool isImmature = pm.isImmature(proofid);
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(!pm.isBoundToPeer(proofid));
         BOOST_CHECK_EQUAL(pm.exists(proofid), !isImmature);
     };
 
     auto checkRejectInvalidate = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::INVALIDATE));
     };
 
     // Reject from the immature pool
     checkRejectDefault(immature30->getId());
     BOOST_CHECK(!pm.registerProof(immature30));
     BOOST_CHECK(pm.isImmature(immature30->getId()));
     checkRejectInvalidate(immature30->getId());
 
     // Reject from the conflicting pool
     checkRejectDefault(proofSeq10->getId());
     checkRejectInvalidate(proofSeq10->getId());
 
     // Add again a proof to the conflicting pool
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
 
     // Reject from the valid pool, default mode
     checkRejectDefault(proofSeq20->getId());
 
     // The conflicting proof should be promoted to a peer
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq10->getId()));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
 
     // Reject from the valid pool, invalidate mode
     checkRejectInvalidate(proofSeq10->getId());
 
     // The conflicting proof should also be promoted to a peer
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq20->getId()));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq20->getId()));
 }
 
 BOOST_AUTO_TEST_CASE(should_request_more_nodes) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     // Set mock time so that proof registration time is predictable and
     // testable.
     SetMockTime(GetTime());
 
     auto proof =
         buildRandomProof(chainman.ActiveChainstate(), MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof));
     // Not dangling yet, the proof will remain active for some time before it
     // turns dangling if no node is connecting in the meantime.
     BOOST_CHECK(!pm.isDangling(proof->getId()));
 
     // We have no nodes, so select node will fail and flag that we need more
     // nodes
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // The flag will not trigger again until we fail to select nodes again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Add a few nodes.
     const ProofId &proofid = proof->getId();
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
     }
 
     BOOST_CHECK(!pm.isDangling(proof->getId()));
 
     auto cooldownTimepoint = Now<SteadyMilliseconds>() + 10s;
 
     // All the nodes can be selected once
     for (size_t i = 0; i < 10; i++) {
         NodeId selectedId = pm.selectNode();
         BOOST_CHECK_NE(selectedId, NO_NODE);
         BOOST_CHECK(pm.updateNextRequestTime(selectedId, cooldownTimepoint));
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // All the nodes have been requested, next select will fail and the flag
     // should trigger
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // The flag will not trigger again until we fail to select nodes again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Make it possible to request a node again
     BOOST_CHECK(pm.updateNextRequestTime(0, Now<SteadyMilliseconds>()));
     BOOST_CHECK_NE(pm.selectNode(), NO_NODE);
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // Add another proof with no node attached
     auto proof2 =
         buildRandomProof(chainman.ActiveChainstate(), MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof2));
     BOOST_CHECK(!pm.isDangling(proof2->getId()));
     TestPeerManager::cleanupDanglingProofs(pm);
     BOOST_CHECK(!pm.isDangling(proof2->getId()));
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // After some time the proof will be considered dangling and more nodes will
     // be requested.
     SetMockTime(GetTime() + 15 * 60);
     TestPeerManager::cleanupDanglingProofs(pm);
     BOOST_CHECK(pm.isDangling(proof2->getId()));
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(pm.isDangling(proof2->getId()));
         // The flag will not trigger again until the condition is met again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Attempt to register the dangling proof again. This should fail but
     // trigger a request for more nodes.
     ProofRegistrationState state;
     BOOST_CHECK(!pm.registerProof(proof2, state));
     BOOST_CHECK(state.GetResult() == ProofRegistrationResult::DANGLING);
     BOOST_CHECK(pm.isDangling(proof2->getId()));
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(pm.isDangling(proof2->getId()));
         // The flag will not trigger again until the condition is met again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Attach a node to that proof
     BOOST_CHECK(!pm.addNode(11, proof2->getId()));
     BOOST_CHECK(pm.registerProof(proof2));
     SetMockTime(GetTime() + 15 * 60);
     TestPeerManager::cleanupDanglingProofs(pm);
     BOOST_CHECK(!pm.isDangling(proof2->getId()));
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // Disconnect the node, the proof is dangling again
     BOOST_CHECK(pm.removeNode(11));
     TestPeerManager::cleanupDanglingProofs(pm);
     BOOST_CHECK(pm.isDangling(proof2->getId()));
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     // Invalidating the proof, removes the proof from the dangling pool but not
     // a simple rejection.
     BOOST_CHECK(!pm.rejectProof(
         proof2->getId(), avalanche::PeerManager::RejectionMode::DEFAULT));
     BOOST_CHECK(pm.isDangling(proof2->getId()));
     BOOST_CHECK(pm.rejectProof(
         proof2->getId(), avalanche::PeerManager::RejectionMode::INVALIDATE));
     BOOST_CHECK(!pm.isDangling(proof2->getId()));
 }
 
 BOOST_AUTO_TEST_CASE(score_ordering) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     std::vector<uint32_t> expectedScores(10);
     // Expect the peers to be ordered by descending score
     std::generate(expectedScores.rbegin(), expectedScores.rend(),
                   [n = 1]() mutable { return n++ * MIN_VALID_PROOF_SCORE; });
 
     std::vector<ProofRef> proofs;
     proofs.reserve(expectedScores.size());
     for (uint32_t score : expectedScores) {
         proofs.push_back(buildRandomProof(chainman.ActiveChainstate(), score));
     }
 
     // Shuffle the proofs so they are registered in a random score order
     Shuffle(proofs.begin(), proofs.end(), FastRandomContext());
     for (auto &proof : proofs) {
         BOOST_CHECK(pm.registerProof(proof));
     }
 
     auto peersScores = TestPeerManager::getOrderedScores(pm);
     BOOST_CHECK_EQUAL_COLLECTIONS(peersScores.begin(), peersScores.end(),
                                   expectedScores.begin(), expectedScores.end());
 }
 
 BOOST_FIXTURE_TEST_CASE(known_score_tracking, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const Amount amount1(PROOF_DUST_THRESHOLD);
     const Amount amount2(2 * PROOF_DUST_THRESHOLD);
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     const COutPoint peer1ConflictingOutput =
         createUtxo(active_chainstate, key, amount1, 99);
     const COutPoint peer1SecondaryOutpoint =
         createUtxo(active_chainstate, key, amount2, 99);
 
     auto peer1Proof1 = buildProof(
         key,
         {{peer1ConflictingOutput, amount1}, {peer1SecondaryOutpoint, amount2}},
         key, 10, 99);
     auto peer1Proof2 =
         buildProof(key, {{peer1ConflictingOutput, amount1}}, key, 20, 99);
 
     // Create a proof with an immature UTXO, so the proof will be immature
     auto peer1Proof3 =
         buildProof(key,
                    {{peer1ConflictingOutput, amount1},
                     {createUtxo(active_chainstate, key, amount1), amount1}},
                    key, 30);
 
     const uint32_t peer1Score1 = Proof::amountToScore(amount1 + amount2);
     const uint32_t peer1Score2 = Proof::amountToScore(amount1);
 
     // Add first peer and check that we have its score tracked
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
     BOOST_CHECK(pm.registerProof(peer1Proof2));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Ensure failing to add conflicting proofs doesn't affect the score, the
     // first proof stays bound and counted
     BOOST_CHECK(!pm.registerProof(peer1Proof1));
     BOOST_CHECK(!pm.registerProof(peer1Proof3));
 
     BOOST_CHECK(pm.isBoundToPeer(peer1Proof2->getId()));
     BOOST_CHECK(pm.isInConflictingPool(peer1Proof1->getId()));
     BOOST_CHECK(pm.isImmature(peer1Proof3->getId()));
 
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     auto checkRejectDefault = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         const bool isImmature = pm.isImmature(proofid);
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(!pm.isBoundToPeer(proofid));
         BOOST_CHECK_EQUAL(pm.exists(proofid), !isImmature);
     };
 
     auto checkRejectInvalidate = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::INVALIDATE));
     };
 
     // Reject from the immature pool doesn't affect tracked score
     checkRejectDefault(peer1Proof3->getId());
     BOOST_CHECK(!pm.registerProof(peer1Proof3));
     BOOST_CHECK(pm.isImmature(peer1Proof3->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
     checkRejectInvalidate(peer1Proof3->getId());
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Reject from the conflicting pool
     checkRejectDefault(peer1Proof1->getId());
     checkRejectInvalidate(peer1Proof1->getId());
 
     // Add again a proof to the conflicting pool
     BOOST_CHECK(!pm.registerProof(peer1Proof1));
     BOOST_CHECK(pm.isInConflictingPool(peer1Proof1->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Reject from the valid pool, default mode
     // Now the score should change as the new peer is promoted
     checkRejectDefault(peer1Proof2->getId());
     BOOST_CHECK(!pm.isInConflictingPool(peer1Proof1->getId()));
     BOOST_CHECK(pm.isBoundToPeer(peer1Proof1->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score1);
 
     // Reject from the valid pool, invalidate mode
     // Now the score should change as the old peer is re-promoted
     checkRejectInvalidate(peer1Proof1->getId());
 
     // The conflicting proof should also be promoted to a peer
     BOOST_CHECK(!pm.isInConflictingPool(peer1Proof2->getId()));
     BOOST_CHECK(pm.isBoundToPeer(peer1Proof2->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Now add another peer and check that combined scores are correct
     uint32_t peer2Score = 1 * MIN_VALID_PROOF_SCORE;
     auto peer2Proof1 = buildRandomProof(active_chainstate, peer2Score, 99);
     PeerId peerid2 = TestPeerManager::registerAndGetPeerId(pm, peer2Proof1);
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2 + peer2Score);
 
     // Trying to remove non-existent peer doesn't affect score
     BOOST_CHECK(!pm.removePeer(1234));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2 + peer2Score);
 
     // Removing new peer removes its score
     BOOST_CHECK(pm.removePeer(peerid2));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
     PeerId peerid1 =
         TestPeerManager::getPeerIdForProofId(pm, peer1Proof2->getId());
     BOOST_CHECK(pm.removePeer(peerid1));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(connected_score_tracking) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const auto checkScores = [&pm](uint32_t known, uint32_t connected) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), known);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), connected);
     };
 
     // Start out with 0s
     checkScores(0, 0);
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     // Create one peer without a node. Its score should be registered but not
     // connected
     uint32_t score1 = 10000000 * MIN_VALID_PROOF_SCORE;
     auto proof1 = buildRandomProof(active_chainstate, score1);
     PeerId peerid1 = TestPeerManager::registerAndGetPeerId(pm, proof1);
     checkScores(score1, 0);
 
     // Add nodes. We now have a connected score, but it doesn't matter how many
     // nodes we add the score is the same
     const ProofId &proofid1 = proof1->getId();
     const uint8_t nodesToAdd = 10;
     for (int i = 0; i < nodesToAdd; i++) {
         BOOST_CHECK(pm.addNode(i, proofid1));
         checkScores(score1, score1);
     }
 
     // Remove all but 1 node and ensure the score doesn't change
     for (int i = 0; i < nodesToAdd - 1; i++) {
         BOOST_CHECK(pm.removeNode(i));
         checkScores(score1, score1);
     }
 
     // Removing the last node should remove the score from the connected count
     BOOST_CHECK(pm.removeNode(nodesToAdd - 1));
     checkScores(score1, 0);
 
     // Add 2 nodes to peer and create peer2. Without a node peer2 has no
     // connected score but after adding a node it does.
     BOOST_CHECK(pm.addNode(0, proofid1));
     BOOST_CHECK(pm.addNode(1, proofid1));
     checkScores(score1, score1);
 
     uint32_t score2 = 1 * MIN_VALID_PROOF_SCORE;
     auto proof2 = buildRandomProof(active_chainstate, score2);
     PeerId peerid2 = TestPeerManager::registerAndGetPeerId(pm, proof2);
     checkScores(score1 + score2, score1);
     BOOST_CHECK(pm.addNode(2, proof2->getId()));
     checkScores(score1 + score2, score1 + score2);
 
     // The first peer has two nodes left. Remove one and nothing happens, remove
     // the other and its score is no longer in the connected counter..
     BOOST_CHECK(pm.removeNode(0));
     checkScores(score1 + score2, score1 + score2);
     BOOST_CHECK(pm.removeNode(1));
     checkScores(score1 + score2, score2);
 
     // Removing a peer with no allocated score has no affect.
     BOOST_CHECK(pm.removePeer(peerid1));
     checkScores(score2, score2);
 
     // Remove the second peer's node removes its allocated score.
     BOOST_CHECK(pm.removeNode(2));
     checkScores(score2, 0);
 
     // Removing the second peer takes us back to 0.
     BOOST_CHECK(pm.removePeer(peerid2));
     checkScores(0, 0);
 
     // Add 2 peers with nodes and remove them without removing the nodes first.
     // Both score counters should be reduced by each peer's score when it's
     // removed.
     peerid1 = TestPeerManager::registerAndGetPeerId(pm, proof1);
     checkScores(score1, 0);
     peerid2 = TestPeerManager::registerAndGetPeerId(pm, proof2);
     checkScores(score1 + score2, 0);
     BOOST_CHECK(pm.addNode(0, proof1->getId()));
     checkScores(score1 + score2, score1);
     BOOST_CHECK(pm.addNode(1, proof2->getId()));
     checkScores(score1 + score2, score1 + score2);
 
     BOOST_CHECK(pm.removePeer(peerid2));
     checkScores(score1, score1);
 
     BOOST_CHECK(pm.removePeer(peerid1));
     checkScores(0, 0);
 }
 
 BOOST_FIXTURE_TEST_CASE(proof_radix_tree, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     struct ProofComparatorById {
         bool operator()(const ProofRef &lhs, const ProofRef &rhs) const {
             return lhs->getId() < rhs->getId();
         };
     };
     using ProofSetById = std::set<ProofRef, ProofComparatorById>;
     // Maintain a list of the expected proofs through this test
     ProofSetById expectedProofs;
 
     auto matchExpectedContent = [&](const auto &tree) {
         auto it = expectedProofs.begin();
         return tree.forEachLeaf([&](auto pLeaf) {
             return it != expectedProofs.end() &&
                    pLeaf->getId() == (*it++)->getId();
         });
     };
 
     CKey key = CKey::MakeCompressedKey();
     const int64_t sequence = 10;
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     // Add some initial proofs
     for (size_t i = 0; i < 10; i++) {
         auto outpoint = createUtxo(active_chainstate, key);
         auto proof = buildProofWithSequence(key, {{outpoint}}, sequence);
         BOOST_CHECK(pm.registerProof(proof));
         expectedProofs.insert(std::move(proof));
     }
 
     const auto &treeRef = pm.getShareableProofsSnapshot();
     BOOST_CHECK(matchExpectedContent(treeRef));
 
     // Create a copy
     auto tree = pm.getShareableProofsSnapshot();
 
     // Adding more proofs doesn't change the tree...
     ProofSetById addedProofs;
     std::vector<COutPoint> outpointsToSpend;
     for (size_t i = 0; i < 10; i++) {
         auto outpoint = createUtxo(active_chainstate, key);
         auto proof = buildProofWithSequence(key, {{outpoint}}, sequence);
         BOOST_CHECK(pm.registerProof(proof));
         addedProofs.insert(std::move(proof));
         outpointsToSpend.push_back(std::move(outpoint));
     }
 
     BOOST_CHECK(matchExpectedContent(tree));
 
     // ...until we get a new copy
     tree = pm.getShareableProofsSnapshot();
     expectedProofs.insert(addedProofs.begin(), addedProofs.end());
     BOOST_CHECK(matchExpectedContent(tree));
 
     // Spend some coins to make the associated proofs invalid
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = active_chainstate.CoinsTip();
         for (const auto &outpoint : outpointsToSpend) {
             coins.SpendCoin(outpoint);
         }
     }
 
     pm.updatedBlockTip();
 
     // This doesn't change the tree...
     BOOST_CHECK(matchExpectedContent(tree));
 
     // ...until we get a new copy
     tree = pm.getShareableProofsSnapshot();
     for (const auto &proof : addedProofs) {
         BOOST_CHECK_EQUAL(expectedProofs.erase(proof), 1);
     }
     BOOST_CHECK(matchExpectedContent(tree));
 
     // Add some more proof for which we will create conflicts
     std::vector<ProofRef> conflictingProofs;
     std::vector<COutPoint> conflictingOutpoints;
     for (size_t i = 0; i < 10; i++) {
         auto outpoint = createUtxo(active_chainstate, key);
         auto proof = buildProofWithSequence(key, {{outpoint}}, sequence);
         BOOST_CHECK(pm.registerProof(proof));
         conflictingProofs.push_back(std::move(proof));
         conflictingOutpoints.push_back(std::move(outpoint));
     }
 
     tree = pm.getShareableProofsSnapshot();
     expectedProofs.insert(conflictingProofs.begin(), conflictingProofs.end());
     BOOST_CHECK(matchExpectedContent(tree));
 
     // Build a bunch of conflicting proofs, half better, half worst
     for (size_t i = 0; i < 10; i += 2) {
         // The worst proof is not added to the expected set
         BOOST_CHECK(!pm.registerProof(buildProofWithSequence(
             key, {{conflictingOutpoints[i]}}, sequence - 1)));
 
         // But the better proof should replace its conflicting one
         auto replacementProof = buildProofWithSequence(
             key, {{conflictingOutpoints[i + 1]}}, sequence + 1);
         BOOST_CHECK(pm.registerProof(replacementProof));
         BOOST_CHECK_EQUAL(expectedProofs.erase(conflictingProofs[i + 1]), 1);
         BOOST_CHECK(expectedProofs.insert(replacementProof).second);
     }
 
     tree = pm.getShareableProofsSnapshot();
     BOOST_CHECK(matchExpectedContent(tree));
 
     // Check for consistency
     pm.verify();
 }
 
 BOOST_AUTO_TEST_CASE(received_avaproofs) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     auto addNode = [&](NodeId nodeid) {
         auto proof = buildRandomProof(chainman.ActiveChainstate(),
                                       MIN_VALID_PROOF_SCORE);
         BOOST_CHECK(pm.registerProof(proof));
         BOOST_CHECK(pm.addNode(nodeid, proof->getId()));
     };
 
     for (NodeId nodeid = 0; nodeid < 10; nodeid++) {
         // Node doesn't exist
         BOOST_CHECK(!pm.latchAvaproofsSent(nodeid));
 
         addNode(nodeid);
         BOOST_CHECK(pm.latchAvaproofsSent(nodeid));
 
         // The flag is already set
         BOOST_CHECK(!pm.latchAvaproofsSent(nodeid));
     }
 }
 
 BOOST_FIXTURE_TEST_CASE(cleanup_dangling_proof, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
 
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const auto now = GetTime<std::chrono::seconds>();
     auto mocktime = now;
 
     auto elapseTime = [&](std::chrono::seconds seconds) {
         mocktime += seconds;
         SetMockTime(mocktime.count());
     };
     elapseTime(0s);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const size_t numProofs = 10;
 
     std::vector<COutPoint> outpoints(numProofs);
     std::vector<ProofRef> proofs(numProofs);
     std::vector<ProofRef> conflictingProofs(numProofs);
     for (size_t i = 0; i < numProofs; i++) {
         outpoints[i] = createUtxo(chainman.ActiveChainstate(), key);
         proofs[i] = buildProofWithSequence(key, {outpoints[i]}, 2);
         conflictingProofs[i] = buildProofWithSequence(key, {outpoints[i]}, 1);
 
         BOOST_CHECK(pm.registerProof(proofs[i]));
         BOOST_CHECK(pm.isBoundToPeer(proofs[i]->getId()));
 
         BOOST_CHECK(!pm.registerProof(conflictingProofs[i]));
         BOOST_CHECK(pm.isInConflictingPool(conflictingProofs[i]->getId()));
 
         if (i % 2) {
             // Odd indexes get a node attached to them
             BOOST_CHECK(pm.addNode(i, proofs[i]->getId()));
         }
         BOOST_CHECK_EQUAL(pm.forPeer(proofs[i]->getId(),
                                      [&](const avalanche::Peer &peer) {
                                          return peer.node_count;
                                      }),
                           i % 2);
 
         elapseTime(1s);
     }
 
     // No proof expired yet
     TestPeerManager::cleanupDanglingProofs(pm);
     for (size_t i = 0; i < numProofs; i++) {
         BOOST_CHECK(pm.isBoundToPeer(proofs[i]->getId()));
         BOOST_CHECK(pm.isInConflictingPool(conflictingProofs[i]->getId()));
     }
 
     // Elapse the dangling timeout
     elapseTime(avalanche::Peer::DANGLING_TIMEOUT);
     TestPeerManager::cleanupDanglingProofs(pm);
     for (size_t i = 0; i < numProofs; i++) {
         const bool hasNodeAttached = i % 2;
 
         // Only the peers with no nodes attached are getting discarded
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(proofs[i]->getId()),
                           hasNodeAttached);
         BOOST_CHECK_EQUAL(!pm.exists(proofs[i]->getId()), !hasNodeAttached);
 
         // The proofs conflicting with the discarded ones are pulled back
         BOOST_CHECK_EQUAL(pm.isInConflictingPool(conflictingProofs[i]->getId()),
                           hasNodeAttached);
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(conflictingProofs[i]->getId()),
                           !hasNodeAttached);
     }
 
     // Attach a node to the first conflicting proof, which has been promoted
     BOOST_CHECK(pm.addNode(42, conflictingProofs[0]->getId()));
     BOOST_CHECK(pm.forPeer(
         conflictingProofs[0]->getId(),
         [&](const avalanche::Peer &peer) { return peer.node_count == 1; }));
 
     // Elapse the dangling timeout again
     elapseTime(avalanche::Peer::DANGLING_TIMEOUT);
     TestPeerManager::cleanupDanglingProofs(pm);
     for (size_t i = 0; i < numProofs; i++) {
         const bool hasNodeAttached = i % 2;
 
         // The initial peers with a node attached are still there
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(proofs[i]->getId()),
                           hasNodeAttached);
         BOOST_CHECK_EQUAL(!pm.exists(proofs[i]->getId()), !hasNodeAttached);
 
         // This time the previouly promoted conflicting proofs are evicted
         // because they have no node attached, except the index 0.
         BOOST_CHECK_EQUAL(pm.exists(conflictingProofs[i]->getId()),
                           hasNodeAttached || i == 0);
         BOOST_CHECK_EQUAL(pm.isInConflictingPool(conflictingProofs[i]->getId()),
                           hasNodeAttached);
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(conflictingProofs[i]->getId()),
                           i == 0);
     }
 
     // Disconnect all the nodes
     for (size_t i = 1; i < numProofs; i += 2) {
         BOOST_CHECK(pm.removeNode(i));
         BOOST_CHECK(
             pm.forPeer(proofs[i]->getId(), [&](const avalanche::Peer &peer) {
                 return peer.node_count == 0;
             }));
     }
     BOOST_CHECK(pm.removeNode(42));
     BOOST_CHECK(pm.forPeer(
         conflictingProofs[0]->getId(),
         [&](const avalanche::Peer &peer) { return peer.node_count == 0; }));
 
     TestPeerManager::cleanupDanglingProofs(pm);
     for (size_t i = 0; i < numProofs; i++) {
         const bool hadNodeAttached = i % 2;
 
         // All initially valid proofs have now been discarded
         BOOST_CHECK(!pm.exists(proofs[i]->getId()));
 
         // The remaining conflicting proofs are promoted
         BOOST_CHECK_EQUAL(!pm.exists(conflictingProofs[i]->getId()),
                           !hadNodeAttached);
         BOOST_CHECK(!pm.isInConflictingPool(conflictingProofs[i]->getId()));
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(conflictingProofs[i]->getId()),
                           hadNodeAttached);
     }
 
     // Elapse the timeout for the newly promoted conflicting proofs
     elapseTime(avalanche::Peer::DANGLING_TIMEOUT);
 
     // All other proofs have now been discarded
     TestPeerManager::cleanupDanglingProofs(pm);
 
     for (size_t i = 0; i < numProofs; i++) {
         // All proofs have finally been discarded
         BOOST_CHECK(!pm.exists(proofs[i]->getId()));
         BOOST_CHECK(!pm.exists(conflictingProofs[i]->getId()));
     }
 }
 
 BOOST_AUTO_TEST_CASE(register_proof_missing_utxo) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     CKey key = CKey::MakeCompressedKey();
     auto proof = buildProofWithOutpoints(key, {{TxId(GetRandHash()), 0}},
                                          PROOF_DUST_THRESHOLD);
 
     ProofRegistrationState state;
     BOOST_CHECK(!pm.registerProof(proof, state));
     BOOST_CHECK(state.GetResult() == ProofRegistrationResult::MISSING_UTXO);
 }
 
 BOOST_AUTO_TEST_CASE(proof_expiry) {
     gArgs.ForceSetArg("-avalancheconflictingproofcooldown", "0");
 
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const int64_t tipTime =
         WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip())
             ->GetBlockTime();
 
     CKey key = CKey::MakeCompressedKey();
 
     auto utxo = createUtxo(chainman.ActiveChainstate(), key);
     auto proofToExpire = buildProof(key, {{utxo, PROOF_DUST_THRESHOLD}}, key, 2,
                                     100, false, tipTime + 1);
     auto conflictingProof = buildProof(key, {{utxo, PROOF_DUST_THRESHOLD}}, key,
                                        1, 100, false, tipTime + 2);
 
     // Our proofToExpire is not expired yet, so it registers fine
     BOOST_CHECK(pm.registerProof(proofToExpire));
     BOOST_CHECK(pm.isBoundToPeer(proofToExpire->getId()));
 
     // The conflicting proof has a longer expiration time but a lower sequence
     // number, so it is moved to the conflicting pool.
     BOOST_CHECK(!pm.registerProof(conflictingProof));
     BOOST_CHECK(pm.isInConflictingPool(conflictingProof->getId()));
 
     // Mine blocks until the MTP of the tip moves to the proof expiration
     for (int64_t i = 0; i < 6; i++) {
         SetMockTime(proofToExpire->getExpirationTime() + i);
         CreateAndProcessBlock({}, CScript());
     }
     BOOST_CHECK_EQUAL(
         WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip())
             ->GetMedianTimePast(),
         proofToExpire->getExpirationTime());
 
     pm.updatedBlockTip();
 
     // The now expired proof is removed
     BOOST_CHECK(!pm.exists(proofToExpire->getId()));
 
     // The conflicting proof has been pulled back to the valid pool
     BOOST_CHECK(pm.isBoundToPeer(conflictingProof->getId()));
 
     gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
 }
 
 BOOST_AUTO_TEST_CASE(peer_availability_score) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     const std::vector<std::tuple<uint32_t, uint32_t, double>> testCases = {
         // {step, tau, decay_factor}
         {10, 100, 1. - std::exp(-1. * 10 / 100)},
         // Current defaults
         {AVALANCHE_STATISTICS_REFRESH_PERIOD.count(),
          AVALANCHE_STATISTICS_TIME_CONSTANT.count(),
          AVALANCHE_STATISTICS_DECAY_FACTOR},
     };
 
     for (const auto &[step, tau, decayFactor] : testCases) {
         // Add a peer
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK(pm.registerProof(proof));
         auto proofid = proof->getId();
 
         // Add some nodes for this peer
         const int numNodesPerPeer = 5;
         for (auto nodeid = 0; nodeid < numNodesPerPeer; nodeid++) {
             BOOST_CHECK(pm.addNode(nodeid, proofid));
         }
 
         auto getNodeAvailabilityScore = [&](double avgScore,
                                             NodeId nodeid) -> double {
             // Spread scores over a range of values such that their average is
             // the provided value.
             return (nodeid - numNodesPerPeer / 2) * 2 + avgScore;
         };
 
         auto getAvailabilityScore = [&]() {
             double score{0.0};
             pm.forPeer(proofid, [&](auto &peer) {
                 score = peer.availabilityScore;
                 return true;
             });
             return score;
         };
 
         double previousScore = getAvailabilityScore();
         BOOST_CHECK_SMALL(previousScore, 1e-6);
 
         // Check the statistics follow an exponential response for 1 to 10 tau
         for (size_t i = 1; i <= 10; i++) {
             for (uint32_t j = 0; j < tau; j += step) {
                 // Nodes respond to polls > 50% of the time (positive score)
                 pm.updateAvailabilityScores(decayFactor, [&](auto nodeid) {
                     return getNodeAvailabilityScore(1.0, nodeid);
                 });
 
                 // Expect a monotonic rise
                 double currentScore = getAvailabilityScore();
                 BOOST_CHECK_GE(currentScore, previousScore);
                 previousScore = currentScore;
             }
 
             // We expect (1 - e^-i) * numNodesPerPeer after i * tau. The
             // tolerance is expressed as a percentage, and we add a (large)
             // 0.1% margin to account for floating point errors.
             BOOST_CHECK_CLOSE(previousScore,
                               -1 * std::expm1(-1. * i) * numNodesPerPeer,
                               100.1 / tau);
         }
 
         // After 10 tau we should be very close to 100% (about 99.995%)
         BOOST_CHECK_CLOSE(previousScore, numNodesPerPeer, 0.01);
 
         // Make the proof invalid
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::INVALIDATE));
         BOOST_CHECK(!pm.isBoundToPeer(proofid));
         BOOST_CHECK(!pm.exists(proofid));
 
         // Re-register the proof
         BOOST_CHECK(pm.registerProof(proof));
         pm.forPeer(proofid, [&](auto &peer) {
             int nodeCount = 0;
             pm.forEachNode(peer, [&](const auto &node) { nodeCount++; });
             BOOST_CHECK_EQUAL(nodeCount, numNodesPerPeer);
             return true;
         });
 
         // Peer score should have reset even though nodes are still connected
         previousScore = getAvailabilityScore();
         BOOST_CHECK_SMALL(previousScore, 1e-6);
 
         // Bring the score back up to where we were
         for (size_t i = 1; i <= 10; i++) {
             for (uint32_t j = 0; j < tau; j += step) {
                 pm.updateAvailabilityScores(decayFactor, [&](auto nodeid) {
                     return getNodeAvailabilityScore(1.0, nodeid);
                 });
             }
         }
         previousScore = getAvailabilityScore();
         BOOST_CHECK_CLOSE(previousScore, numNodesPerPeer, 0.01);
 
         for (size_t i = 1; i <= 3; i++) {
             for (uint32_t j = 0; j < tau; j += step) {
                 // Nodes only respond to polls 50% of the time (0 score)
                 pm.updateAvailabilityScores(decayFactor, [&](auto nodeid) {
                     return getNodeAvailabilityScore(0.0, nodeid);
                 });
 
                 // Expect a monotonic fall
                 double currentScore = getAvailabilityScore();
                 BOOST_CHECK_LE(currentScore, previousScore);
                 previousScore = currentScore;
             }
 
             // There is a slight error in the expected value because we did not
             // start the decay at exactly 100%, but the 0.1% margin is at least
             // an order of magnitude larger than the expected error so it
             // doesn't matter.
             BOOST_CHECK_CLOSE(previousScore,
                               (1. + std::expm1(-1. * i)) * numNodesPerPeer,
                               100.1 / tau);
         }
 
         // After 3 more tau we should be under 5%
         BOOST_CHECK_LT(previousScore, .05 * numNodesPerPeer);
 
         for (size_t i = 1; i <= 100; i++) {
             // Nodes respond to polls < 50% of the time (negative score)
             pm.updateAvailabilityScores(decayFactor, [&](auto nodeid) {
                 return getNodeAvailabilityScore(-10.0, nodeid);
             });
 
             // It's still a monotonic fall, and the score should turn negative.
             double currentScore = getAvailabilityScore();
             BOOST_CHECK_LE(currentScore, previousScore);
             BOOST_CHECK_LE(currentScore, 0.);
             previousScore = currentScore;
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(select_staking_reward_winner) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     auto buildProofWithAmountAndPayout = [&](Amount amount,
                                              const CScript &payoutScript) {
         const CKey key = CKey::MakeCompressedKey();
         COutPoint utxo = createUtxo(active_chainstate, key, amount);
         return buildProof(key, {{std::move(utxo), amount}},
                           /*master=*/CKey::MakeCompressedKey(), /*sequence=*/1,
                           /*height=*/100, /*is_coinbase=*/false,
                           /*expirationTime=*/0, payoutScript);
     };
 
     std::vector<CScript> winners;
     // Null pprev
     BOOST_CHECK(!pm.selectStakingRewardWinner(nullptr, winners));
 
     CBlockIndex prevBlock;
 
     auto now = GetTime<std::chrono::seconds>();
     SetMockTime(now);
     prevBlock.nTime = now.count();
 
     BlockHash prevHash{uint256::ONE};
     prevBlock.phashBlock = &prevHash;
     // No peer
     BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
 
     // Let's build a list of payout addresses, and register a proofs for each
     // address
     size_t numProofs = 8;
     std::vector<ProofRef> proofs;
     proofs.reserve(numProofs);
     for (size_t i = 0; i < numProofs; i++) {
         const CKey key = CKey::MakeCompressedKey();
         CScript payoutScript = GetScriptForRawPubKey(key.GetPubKey());
 
         auto proof =
             buildProofWithAmountAndPayout(PROOF_DUST_THRESHOLD, payoutScript);
         PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
         BOOST_CHECK_NE(peerid, NO_PEER);
 
         // Finalize the proof
         BOOST_CHECK(pm.setFinalized(peerid));
 
         proofs.emplace_back(std::move(proof));
     }
 
     // Make sure the proofs have been registered before the prev block was found
-    // and before 2x the peer replacement cooldown.
-    now += 30min + 1s;
+    // and before 4x the peer replacement cooldown.
+    now += 4 * avalanche::Peer::DANGLING_TIMEOUT + 1s;
     SetMockTime(now);
     prevBlock.nTime = now.count();
 
     // At this stage we have a set of peers out of which none has any node
     // attached, so they're all considered flaky. Note that we have no remote
     // proofs status yet.
     BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
     BOOST_CHECK_LE(winners.size(), numProofs);
 
     // Let's add a node for each peer
     for (size_t i = 0; i < numProofs; i++) {
         BOOST_CHECK(TestPeerManager::isFlaky(pm, proofs[i]->getId()));
         BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
         BOOST_CHECK_LE(winners.size(), numProofs);
 
         BOOST_CHECK(pm.addNode(NodeId(i), proofs[i]->getId()));
 
         BOOST_CHECK(!TestPeerManager::isFlaky(pm, proofs[i]->getId()));
         BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
         BOOST_CHECK_LE(winners.size(), numProofs - i);
     }
 
     // Now we have a single winner
     BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
     BOOST_CHECK_LE(winners.size(), 1);
 
     // All proofs have the same amount, so the same probability to get picked.
     // Let's compute how many loop iterations we need to have a low false
     // negative rate when checking for this. Target false positive rate is
     // 10ppm (aka 1/100000).
     const size_t loop_iters =
         size_t(-1.0 * std::log(100000.0) /
                std::log((double(numProofs) - 1) / numProofs)) +
         1;
     BOOST_CHECK_GT(loop_iters, numProofs);
     std::unordered_map<std::string, size_t> winningCounts;
     for (size_t i = 0; i < loop_iters; i++) {
         BlockHash randomHash = BlockHash(GetRandHash());
         prevBlock.phashBlock = &randomHash;
         BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
         winningCounts[FormatScript(winners[0])]++;
     }
     BOOST_CHECK_EQUAL(winningCounts.size(), numProofs);
 
     prevBlock.phashBlock = &prevHash;
 
     // Ensure all nodes have all the proofs
     for (size_t i = 0; i < numProofs; i++) {
         for (size_t j = 0; j < numProofs; j++) {
             BOOST_CHECK(
                 pm.saveRemoteProof(proofs[j]->getId(), NodeId(i), true));
         }
     }
 
     // Make all the proofs flaky. This loop needs to be updated if the threshold
     // or the number of proofs change, so assert the test precondition.
     BOOST_CHECK_GT(3. / numProofs, 0.3);
     for (size_t i = 0; i < numProofs; i++) {
         const NodeId nodeid = NodeId(i);
 
         BOOST_CHECK(pm.saveRemoteProof(
             proofs[(i - 1 + numProofs) % numProofs]->getId(), nodeid, false));
         BOOST_CHECK(pm.saveRemoteProof(
             proofs[(i + numProofs) % numProofs]->getId(), nodeid, false));
         BOOST_CHECK(pm.saveRemoteProof(
             proofs[(i + 1 + numProofs) % numProofs]->getId(), nodeid, false));
     }
 
     // Now all the proofs are flaky
     BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
     for (const auto &proof : proofs) {
         BOOST_CHECK(TestPeerManager::isFlaky(pm, proof->getId()));
     }
     BOOST_CHECK_EQUAL(winners.size(), numProofs);
 
     // Revert flakyness for all proofs
     for (const auto &proof : proofs) {
         for (NodeId nodeid = 0; nodeid < NodeId(numProofs); nodeid++) {
             BOOST_CHECK(pm.saveRemoteProof(proof->getId(), nodeid, true));
         }
     }
 
     BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
     BOOST_CHECK_EQUAL(winners.size(), 1);
 
     // Increase the list from 1 to 4 winners by making them flaky
     for (size_t numWinner = 1; numWinner < 4; numWinner++) {
         // Who is the last possible winner ?
         CScript lastWinner = winners[numWinner - 1];
 
         // Make the last winner flaky, the other proofs untouched
         ProofId winnerProofId = ProofId(uint256::ZERO);
         for (const auto &proof : proofs) {
             if (proof->getPayoutScript() == lastWinner) {
                 winnerProofId = proof->getId();
                 break;
             }
         }
         BOOST_CHECK_NE(winnerProofId, ProofId(uint256::ZERO));
 
         for (NodeId nodeid = 0; nodeid < NodeId(numProofs); nodeid++) {
             BOOST_CHECK(pm.saveRemoteProof(winnerProofId, nodeid, false));
         }
         BOOST_CHECK(TestPeerManager::isFlaky(pm, winnerProofId));
 
         // There should be now exactly numWinner + 1 winners
         BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
         BOOST_CHECK_EQUAL(winners.size(), numWinner + 1);
     }
 
     // One more time and the nodes will be missing too many proofs, so they are
     // no longer considered for flakyness evaluation and we're back to a single
     // winner.
     CScript lastWinner = winners[3];
 
     ProofId winnerProofId = ProofId(uint256::ZERO);
     for (const auto &proof : proofs) {
         if (proof->getPayoutScript() == lastWinner) {
             winnerProofId = proof->getId();
             break;
         }
     }
     BOOST_CHECK_NE(winnerProofId, ProofId(uint256::ZERO));
 
     for (NodeId nodeid = 0; nodeid < NodeId(numProofs); nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(winnerProofId, nodeid, false));
     }
 
     // We're back to exactly 1 winner
     BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
     BOOST_CHECK_EQUAL(winners.size(), 1);
 
     // Remove all proofs
     for (auto &proof : proofs) {
         BOOST_CHECK(pm.rejectProof(
             proof->getId(), avalanche::PeerManager::RejectionMode::INVALIDATE));
     }
     // No more winner
     prevBlock.phashBlock = &prevHash;
     BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
 
     {
         // Add back a single proof
         const CKey key = CKey::MakeCompressedKey();
         CScript payoutScript = GetScriptForRawPubKey(key.GetPubKey());
 
         auto proof =
             buildProofWithAmountAndPayout(PROOF_DUST_THRESHOLD, payoutScript);
         PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
         BOOST_CHECK_NE(peerid, NO_PEER);
 
         // The single proof should always be selected, but:
         // 1. The proof is not finalized, and has been registered after the last
         // block was mined.
         BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
 
         // 2. The proof has has been registered after the last block was mined.
         BOOST_CHECK(pm.setFinalized(peerid));
         BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
 
         // 3. The proof has been registered 30min from the previous block time,
         // but the previous block time is in the future.
         now += 20min + 1s;
         SetMockTime(now);
         prevBlock.nTime = (now + 10min).count();
         BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
 
         // 4. The proof has been registered 30min from now, but only 20min from
         // the previous block time.
         now += 10min;
         SetMockTime(now);
         prevBlock.nTime = (now - 10min).count();
         BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
 
         // 5. Now the proof has it all
         prevBlock.nTime = now.count();
         BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
         // With a single proof, it's easy to determine the winner
         BOOST_CHECK_EQUAL(FormatScript(winners[0]), FormatScript(payoutScript));
+
+        // Remove the proof
+        BOOST_CHECK(pm.rejectProof(
+            proof->getId(), avalanche::PeerManager::RejectionMode::INVALIDATE));
+    }
+
+    {
+        for (size_t i = 0; i < 2; i++) {
+            // Add a couple proofs
+            const CKey key = CKey::MakeCompressedKey();
+            CScript payoutScript = GetScriptForRawPubKey(key.GetPubKey());
+
+            auto proof = buildProofWithAmountAndPayout(PROOF_DUST_THRESHOLD,
+                                                       payoutScript);
+            PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
+            BOOST_CHECK_NE(peerid, NO_PEER);
+
+            BOOST_CHECK(pm.addNode(NodeId(i), proof->getId()));
+
+            BOOST_CHECK(pm.setFinalized(peerid));
+        }
+
+        // The proofs has been registered > 30min from the previous block time,
+        // but less than 60min
+        now += 30min + 1s;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+
+        // Because they are both recently registered, both proofs are acceptable
+        BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
+        BOOST_CHECK_EQUAL(winners.size(), 2);
+
+        // The proofs has been registered > 60min from the previous block time
+        now += 30min;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+
+        // Now only one is acceptable
+        BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
+        BOOST_CHECK_EQUAL(winners.size(), 1);
     }
 }
 
 BOOST_AUTO_TEST_CASE(remote_proof) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     auto mockTime = GetTime<std::chrono::seconds>();
     SetMockTime(mockTime);
 
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), 0, true));
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ONE), 0, false));
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), 1, true));
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ONE), 1, false));
 
     auto checkRemoteProof =
         [&](const ProofId &proofid, const NodeId nodeid,
             const bool expectedPresent,
             const std::chrono::seconds &expectedlastUpdate) {
             auto remoteProof =
                 TestPeerManager::getRemoteProof(pm, proofid, nodeid);
             BOOST_CHECK(remoteProof.has_value());
             BOOST_CHECK_EQUAL(remoteProof->proofid, proofid);
             BOOST_CHECK_EQUAL(remoteProof->nodeid, nodeid);
             BOOST_CHECK_EQUAL(remoteProof->present, expectedPresent);
             BOOST_CHECK_EQUAL(remoteProof->lastUpdate.count(),
                               expectedlastUpdate.count());
         };
 
     checkRemoteProof(ProofId(uint256::ZERO), 0, true, mockTime);
     checkRemoteProof(ProofId(uint256::ONE), 0, false, mockTime);
     checkRemoteProof(ProofId(uint256::ZERO), 1, true, mockTime);
     checkRemoteProof(ProofId(uint256::ONE), 1, false, mockTime);
 
     mockTime += 1s;
     SetMockTime(mockTime);
 
     // Reverse the state
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), 0, false));
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ONE), 0, true));
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), 1, false));
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ONE), 1, true));
 
     checkRemoteProof(ProofId(uint256::ZERO), 0, false, mockTime);
     checkRemoteProof(ProofId(uint256::ONE), 0, true, mockTime);
     checkRemoteProof(ProofId(uint256::ZERO), 1, false, mockTime);
     checkRemoteProof(ProofId(uint256::ONE), 1, true, mockTime);
 
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     // Actually register the nodes
     auto proof0 = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof0));
     BOOST_CHECK(pm.addNode(0, proof0->getId()));
     auto proof1 = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof1));
     BOOST_CHECK(pm.addNode(1, proof1->getId()));
 
     // Removing the node removes all the associated remote proofs
     BOOST_CHECK(pm.removeNode(0));
     BOOST_CHECK(
         !TestPeerManager::getRemoteProof(pm, ProofId(uint256::ZERO), 0));
     BOOST_CHECK(!TestPeerManager::getRemoteProof(pm, ProofId(uint256::ONE), 0));
     // Other nodes are left untouched
     checkRemoteProof(ProofId(uint256::ZERO), 1, false, mockTime);
     checkRemoteProof(ProofId(uint256::ONE), 1, true, mockTime);
 
     BOOST_CHECK(pm.removeNode(1));
     BOOST_CHECK(
         !TestPeerManager::getRemoteProof(pm, ProofId(uint256::ZERO), 0));
     BOOST_CHECK(!TestPeerManager::getRemoteProof(pm, ProofId(uint256::ONE), 0));
     BOOST_CHECK(
         !TestPeerManager::getRemoteProof(pm, ProofId(uint256::ZERO), 1));
     BOOST_CHECK(!TestPeerManager::getRemoteProof(pm, ProofId(uint256::ONE), 1));
 
     for (size_t i = 0; i < avalanche::PeerManager::MAX_REMOTE_PROOFS; i++) {
         mockTime += 1s;
         SetMockTime(mockTime);
 
         const ProofId proofid{uint256(i)};
 
         BOOST_CHECK(pm.saveRemoteProof(proofid, 0, true));
         checkRemoteProof(proofid, 0, true, mockTime);
     }
 
     // The last updated proof is still there
     checkRemoteProof(ProofId(uint256::ZERO), 0, true,
                      mockTime -
                          (avalanche::PeerManager::MAX_REMOTE_PROOFS - 1) * 1s);
 
     // If we add one more it gets evicted
     mockTime += 1s;
     SetMockTime(mockTime);
 
     ProofId proofid{
         uint256(uint8_t(avalanche::PeerManager::MAX_REMOTE_PROOFS))};
 
     BOOST_CHECK(pm.saveRemoteProof(proofid, 0, true));
     checkRemoteProof(proofid, 0, true, mockTime);
     // Proof id 0 has been evicted
     BOOST_CHECK(
         !TestPeerManager::getRemoteProof(pm, ProofId(uint256::ZERO), 0));
 
     // Proof id 1 is still there
     BOOST_CHECK(TestPeerManager::getRemoteProof(pm, ProofId(uint256::ONE), 0));
 
     // Add MAX_REMOTE_PROOFS / 2 + 1 proofs to our node to bump the limit
     // Note that we already have proofs from the beginning of the test.
     std::vector<ProofRef> proofs;
     for (size_t i = 0; i < avalanche::PeerManager::MAX_REMOTE_PROOFS / 2 - 1;
          i++) {
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK(pm.registerProof(proof));
         proofs.push_back(proof);
     }
     BOOST_CHECK_EQUAL(TestPeerManager::getPeerCount(pm),
                       avalanche::PeerManager::MAX_REMOTE_PROOFS / 2 + 1);
 
     // We can now add one more without eviction
     mockTime += 1s;
     SetMockTime(mockTime);
 
     proofid = ProofId{
         uint256(uint8_t(avalanche::PeerManager::MAX_REMOTE_PROOFS + 1))};
 
     BOOST_CHECK(pm.saveRemoteProof(proofid, 0, true));
     checkRemoteProof(proofid, 0, true, mockTime);
     // Proof id 1 is still there
     BOOST_CHECK(TestPeerManager::getRemoteProof(pm, ProofId(uint256::ONE), 0));
 
     // Shrink our proofs to MAX_REMOTE_PROOFS / 2 - 1
     BOOST_CHECK(pm.rejectProof(
         proofs[0]->getId(), avalanche::PeerManager::RejectionMode::INVALIDATE));
     BOOST_CHECK(pm.rejectProof(
         proofs[1]->getId(), avalanche::PeerManager::RejectionMode::INVALIDATE));
 
     BOOST_CHECK_EQUAL(TestPeerManager::getPeerCount(pm),
                       avalanche::PeerManager::MAX_REMOTE_PROOFS / 2 - 1);
 
     // Upon update the first proof got evicted
     proofid = ProofId{
         uint256(uint8_t(avalanche::PeerManager::MAX_REMOTE_PROOFS + 2))};
     BOOST_CHECK(pm.saveRemoteProof(proofid, 0, true));
     // Proof id 1 is evicted
     BOOST_CHECK(!TestPeerManager::getRemoteProof(pm, ProofId(uint256::ONE), 0));
     // So is proof id 2
     BOOST_CHECK(!TestPeerManager::getRemoteProof(pm, ProofId(uint256(2)), 0));
     // But proof id 3 is still here
     BOOST_CHECK(TestPeerManager::getRemoteProof(pm, ProofId(uint256(3)), 0));
 }
 
 BOOST_AUTO_TEST_CASE(get_remote_status) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     auto mockTime = GetTime<std::chrono::seconds>();
     SetMockTime(mockTime);
 
     // No remote proof yet
     BOOST_CHECK(
         !TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
              .has_value());
 
     // 6/12 (50%) of the stakes
     for (NodeId nodeid = 0; nodeid < 12; nodeid++) {
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK(pm.registerProof(proof));
         BOOST_CHECK(pm.addNode(nodeid, proof->getId()));
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid,
                                        nodeid % 2 == 0));
     }
 
     BOOST_CHECK(
         !TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
              .has_value());
 
     // 7/12 (~58%) of the stakes
     for (NodeId nodeid = 0; nodeid < 5; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, false));
     }
     for (NodeId nodeid = 5; nodeid < 12; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, true));
     }
     BOOST_CHECK(
         TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
             .value());
 
     // Add our local proof so we have 7/13 (~54% < 55%)
     auto localProof =
         buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     TestPeerManager::setLocalProof(pm, localProof);
     BOOST_CHECK(pm.registerProof(localProof));
     BOOST_CHECK(
         !TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
              .has_value());
 
     // Remove the local proof to revert back to 7/12 (~58%)
     pm.rejectProof(localProof->getId());
     TestPeerManager::setLocalProof(pm, ProofRef());
     BOOST_CHECK(
         TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
             .value());
 
     // 5/12 (~42%) of the stakes
     for (NodeId nodeid = 0; nodeid < 5; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, true));
     }
     for (NodeId nodeid = 5; nodeid < 12; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, false));
     }
     BOOST_CHECK(
         !TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
              .value());
 
     // Most nodes agree but not enough of the stakes
     auto bigProof =
         buildRandomProof(active_chainstate, 100 * MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(bigProof));
     // Update the node's proof
     BOOST_CHECK(pm.addNode(0, bigProof->getId()));
 
     // 7/12 (~58%) of the remotes, but < 10% of the stakes => absent
     for (NodeId nodeid = 0; nodeid < 5; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, false));
     }
     for (NodeId nodeid = 5; nodeid < 12; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, true));
     }
     BOOST_CHECK(
         !TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
              .value());
 
     // 5/12 (42%) of the remotes, but > 90% of the stakes => present
     for (NodeId nodeid = 0; nodeid < 5; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, true));
     }
     for (NodeId nodeid = 5; nodeid < 12; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, false));
     }
     BOOST_CHECK(
         TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
             .value());
 
     TestPeerManager::clearPeers(pm);
 
     // Peer 1 has 1 node (id 0)
     auto proof1 = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof1));
     BOOST_CHECK(pm.addNode(0, proof1->getId()));
 
     // Peer 2 has 5 nodes (ids 1 to 5)
     auto proof2 = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof2));
     for (NodeId nodeid = 1; nodeid < 6; nodeid++) {
         BOOST_CHECK(pm.addNode(nodeid, proof2->getId()));
     }
 
     // Node 0 is missing proofid 0, nodes 1 to 5 have it
     BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), 0, false));
     for (NodeId nodeid = 1; nodeid < 6; nodeid++) {
         BOOST_CHECK(pm.saveRemoteProof(ProofId(uint256::ZERO), nodeid, true));
     }
 
     // At this stage we have 5/6 nodes with the proof, but since all the nodes
     // advertising the proof are from the same peer, we only 1/2 peers, i.e. 50%
     // of the stakes.
     BOOST_CHECK(
         !TestPeerManager::getRemotePresenceStatus(pm, ProofId(uint256::ZERO))
              .has_value());
 }
 
 BOOST_AUTO_TEST_CASE(dangling_with_remotes) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     auto mockTime = GetTime<std::chrono::seconds>();
     SetMockTime(mockTime);
 
     // Add a few proofs with no node attached
     std::vector<ProofRef> proofs;
     for (size_t i = 0; i < 10; i++) {
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK(pm.registerProof(proof));
         proofs.push_back(proof);
     }
 
     // The proofs are recent enough, the cleanup won't make them dangling
     TestPeerManager::cleanupDanglingProofs(pm);
     for (const auto &proof : proofs) {
         BOOST_CHECK(pm.isBoundToPeer(proof->getId()));
         BOOST_CHECK(!pm.isDangling(proof->getId()));
     }
 
     // Elapse enough time so we get the proofs dangling
     mockTime += avalanche::Peer::DANGLING_TIMEOUT + 1s;
     SetMockTime(mockTime);
 
     // The proofs are now dangling
     TestPeerManager::cleanupDanglingProofs(pm);
     for (const auto &proof : proofs) {
         BOOST_CHECK(!pm.isBoundToPeer(proof->getId()));
         BOOST_CHECK(pm.isDangling(proof->getId()));
     }
 
     // Add some remotes having this proof
     for (NodeId nodeid = 0; nodeid < 10; nodeid++) {
         auto localProof =
             buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK(pm.registerProof(localProof));
         BOOST_CHECK(pm.addNode(nodeid, localProof->getId()));
 
         for (const auto &proof : proofs) {
             BOOST_CHECK(pm.saveRemoteProof(proof->getId(), nodeid, true));
         }
     }
 
     // The proofs are all present according to the remote status
     for (const auto &proof : proofs) {
         BOOST_CHECK(TestPeerManager::getRemotePresenceStatus(pm, proof->getId())
                         .value());
     }
 
     // The proofs should be added back as a peer
     std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
     TestPeerManager::cleanupDanglingProofs(pm, registeredProofs);
     for (const auto &proof : proofs) {
         BOOST_CHECK(pm.isBoundToPeer(proof->getId()));
         BOOST_CHECK(!pm.isDangling(proof->getId()));
         BOOST_CHECK_EQUAL(registeredProofs.count(proof), 1);
     }
     BOOST_CHECK_EQUAL(proofs.size(), registeredProofs.size());
 
     // Remove the proofs from the remotes
     for (NodeId nodeid = 0; nodeid < 10; nodeid++) {
         for (const auto &proof : proofs) {
             BOOST_CHECK(pm.saveRemoteProof(proof->getId(), nodeid, false));
         }
     }
 
     // The proofs are now all absent according to the remotes
     for (const auto &proof : proofs) {
         BOOST_CHECK(
             !TestPeerManager::getRemotePresenceStatus(pm, proof->getId())
                  .value());
     }
 
     // The proofs are not dangling yet as they have been registered recently
     TestPeerManager::cleanupDanglingProofs(pm, registeredProofs);
     BOOST_CHECK(registeredProofs.empty());
     for (const auto &proof : proofs) {
         BOOST_CHECK(pm.isBoundToPeer(proof->getId()));
         BOOST_CHECK(!pm.isDangling(proof->getId()));
     }
 
     // Wait some time then run the cleanup again, the proofs will be dangling
     mockTime += avalanche::Peer::DANGLING_TIMEOUT + 1s;
     SetMockTime(mockTime);
 
     TestPeerManager::cleanupDanglingProofs(pm, registeredProofs);
     BOOST_CHECK(registeredProofs.empty());
     for (const auto &proof : proofs) {
         BOOST_CHECK(!pm.isBoundToPeer(proof->getId()));
         BOOST_CHECK(pm.isDangling(proof->getId()));
     }
 
     // Pull them back one more time
     for (NodeId nodeid = 0; nodeid < 10; nodeid++) {
         for (const auto &proof : proofs) {
             BOOST_CHECK(pm.saveRemoteProof(proof->getId(), nodeid, true));
         }
     }
 
     TestPeerManager::cleanupDanglingProofs(pm, registeredProofs);
     for (const auto &proof : proofs) {
         BOOST_CHECK(pm.isBoundToPeer(proof->getId()));
         BOOST_CHECK(!pm.isDangling(proof->getId()));
         BOOST_CHECK_EQUAL(registeredProofs.count(proof), 1);
     }
     BOOST_CHECK_EQUAL(proofs.size(), registeredProofs.size());
 }
 
 BOOST_AUTO_TEST_CASE(avapeers_dump) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     Chainstate &active_chainstate = chainman.ActiveChainstate();
 
     auto mockTime = GetTime<std::chrono::seconds>();
     SetMockTime(mockTime);
 
     std::vector<ProofRef> proofs;
     for (size_t i = 0; i < 10; i++) {
         SetMockTime(mockTime + std::chrono::seconds{i});
 
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         // Registration time is mockTime + i
         BOOST_CHECK(pm.registerProof(proof));
 
         auto peerid = TestPeerManager::getPeerIdForProofId(pm, proof->getId());
 
         // Next conflict time is mockTime + 100 + i
         BOOST_CHECK(pm.updateNextPossibleConflictTime(
             peerid, mockTime + std::chrono::seconds{100 + i}));
 
         // The 5 first proofs are finalized
         if (i < 5) {
             BOOST_CHECK(pm.setFinalized(peerid));
         }
 
         proofs.push_back(proof);
     }
 
     BOOST_CHECK_EQUAL(TestPeerManager::getPeerCount(pm), 10);
 
     const fs::path testDumpPath = "test_avapeers_dump.dat";
     BOOST_CHECK(pm.dumpPeersToFile(testDumpPath));
 
     TestPeerManager::clearPeers(pm);
 
     std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
     BOOST_CHECK(pm.loadPeersFromFile(testDumpPath, registeredProofs));
     BOOST_CHECK_EQUAL(registeredProofs.size(), 10);
 
     auto findProofIndex = [&proofs](const ProofId &proofid) {
         for (size_t i = 0; i < proofs.size(); i++) {
             if (proofs[i]->getId() == proofid) {
                 return i;
             }
         }
 
         // ProofId not found
         BOOST_CHECK(false);
         return size_t{0};
     };
 
     for (const auto &proof : registeredProofs) {
         const ProofId &proofid = proof->getId();
         size_t i = findProofIndex(proofid);
         BOOST_CHECK(pm.forPeer(proofid, [&](auto &peer) {
             BOOST_CHECK_EQUAL(peer.hasFinalized, i < 5);
             BOOST_CHECK_EQUAL(peer.registration_time.count(),
                               (mockTime + std::chrono::seconds{i}).count());
             BOOST_CHECK_EQUAL(
                 peer.nextPossibleConflictTime.count(),
                 (mockTime + std::chrono::seconds{100 + i}).count());
             return true;
         }));
     }
 
     // No peer: create an empty file but generate no error
     TestPeerManager::clearPeers(pm);
     BOOST_CHECK(pm.dumpPeersToFile("test_empty_avapeers.dat"));
     // We can also load an empty file
     BOOST_CHECK(
         pm.loadPeersFromFile("test_empty_avapeers.dat", registeredProofs));
     BOOST_CHECK(registeredProofs.empty());
     BOOST_CHECK_EQUAL(TestPeerManager::getPeerCount(pm), 0);
 
     // If the file exists, it is overrwritten
     BOOST_CHECK(pm.dumpPeersToFile("test_empty_avapeers.dat"));
 
     // It fails to load if the file does not exist and the registeredProofs is
     // cleared
     registeredProofs.insert(proofs[0]);
     BOOST_CHECK(!registeredProofs.empty());
     BOOST_CHECK(!pm.loadPeersFromFile("I_dont_exist.dat", registeredProofs));
     BOOST_CHECK(registeredProofs.empty());
 
     {
         // Change the version
         FILE *f = fsbridge::fopen("test_bad_version_avapeers.dat", "wb");
         BOOST_CHECK(f);
         CAutoFile file(f, SER_DISK, CLIENT_VERSION);
         file << static_cast<uint64_t>(-1); // Version
         file << uint64_t{0};               // Number of peers
         BOOST_CHECK(FileCommit(file.Get()));
         file.fclose();
 
         // Check loading fails and the registeredProofs is cleared
         registeredProofs.insert(proofs[0]);
         BOOST_CHECK(!registeredProofs.empty());
         BOOST_CHECK(!pm.loadPeersFromFile("test_bad_version_avapeers.dat",
                                           registeredProofs));
         BOOST_CHECK(registeredProofs.empty());
     }
 
     {
         // Wrong format, will cause a deserialization error
         FILE *f = fsbridge::fopen("test_ill_formed_avapeers.dat", "wb");
         BOOST_CHECK(f);
         const uint64_t now = GetTime();
         CAutoFile file(f, SER_DISK, CLIENT_VERSION);
         file << static_cast<uint64_t>(1); // Version
         file << uint64_t{2};              // Number of peers
         // Single peer content!
         file << proofs[0];
         file << true;
         file << now;
         file << now + 100;
 
         BOOST_CHECK(FileCommit(file.Get()));
         file.fclose();
 
         // Check loading fails and the registeredProofs is fed with our single
         // peer
         BOOST_CHECK(registeredProofs.empty());
         BOOST_CHECK(!pm.loadPeersFromFile("test_ill_formed_avapeers.dat",
                                           registeredProofs));
         BOOST_CHECK_EQUAL(registeredProofs.size(), 1);
         BOOST_CHECK_EQUAL((*registeredProofs.begin())->getId(),
                           proofs[0]->getId());
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()