diff --git a/doc/release-notes.md b/doc/release-notes.md
index c225ae3cc..3feeff071 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,7 +1,12 @@
 # Bitcoin ABC 0.27.2 Release Notes
 
 Bitcoin ABC version 0.27.2 is now available from:
 
   <https://download.bitcoinabc.org/0.27.2/>
 
-This is a maintenance release with no user-visible change.
+This release includes the following features and fixes:
+  - `getavalanchepeerinfo` returns a new field `availability_score` that
+    indicates how responsive a peer's nodes are (collectively) to polls from
+    this node. Higher scores indicate a peer has at least one node that that
+    responds to polls often. Lower scores indicate a peer has nodes that do not
+    respond to polls reliably.
diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
index 3d8c40c3d..9547eb15f 100644
--- a/src/avalanche/peermanager.h
+++ b/src/avalanche/peermanager.h
@@ -1,470 +1,469 @@
 // 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.
 
 #ifndef BITCOIN_AVALANCHE_PEERMANAGER_H
 #define BITCOIN_AVALANCHE_PEERMANAGER_H
 
 #include <avalanche/node.h>
 #include <avalanche/proof.h>
 #include <avalanche/proofpool.h>
 #include <avalanche/proofradixtreeadapter.h>
 #include <bloom.h>
 #include <coins.h>
 #include <consensus/validation.h>
 #include <pubkey.h>
 #include <radix.h>
 #include <util/hasher.h>
 #include <util/time.h>
 
 #include <boost/multi_index/composite_key.hpp>
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/mem_fun.hpp>
 #include <boost/multi_index/member.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index_container.hpp>
 
 #include <atomic>
 #include <chrono>
 #include <cstdint>
 #include <memory>
 #include <vector>
 
 class ChainstateManager;
 class CScheduler;
 
 namespace avalanche {
 
 /**
  * Maximum number of immature proofs the peer manager will accept from the
  * network. Note that reorgs can cause the immature pool to temporarily exceed
  * this limit, but a change in chaintip cause previously reorged proofs to be
  * trimmed.
  */
 static constexpr uint32_t AVALANCHE_MAX_IMMATURE_PROOFS = 4000;
 
 class Delegation;
 
 namespace {
     struct TestPeerManager;
 }
 
 struct Slot {
 private:
     uint64_t start;
     uint32_t score;
     PeerId peerid;
 
 public:
     Slot(uint64_t startIn, uint32_t scoreIn, PeerId peeridIn)
         : start(startIn), score(scoreIn), peerid(peeridIn) {}
 
     Slot withStart(uint64_t startIn) const {
         return Slot(startIn, score, peerid);
     }
     Slot withScore(uint64_t scoreIn) const {
         return Slot(start, scoreIn, peerid);
     }
     Slot withPeerId(PeerId peeridIn) const {
         return Slot(start, score, peeridIn);
     }
 
     uint64_t getStart() const { return start; }
     uint64_t getStop() const { return start + score; }
     uint32_t getScore() const { return score; }
     PeerId getPeerId() const { return peerid; }
 
     bool contains(uint64_t slot) const {
         return getStart() <= slot && slot < getStop();
     }
     bool precedes(uint64_t slot) const { return slot >= getStop(); }
     bool follows(uint64_t slot) const { return getStart() > slot; }
 };
 
 struct Peer {
     PeerId peerid;
     uint32_t index = -1;
     uint32_t node_count = 0;
 
     ProofRef proof;
     bool hasFinalized = false;
 
     // The network stack uses timestamp in seconds, so we oblige.
     std::chrono::seconds registration_time;
     std::chrono::seconds nextPossibleConflictTime;
 
     double availabilityScore = 0.0;
 
     /**
      * Consider dropping the peer if no node is attached after this timeout
      * expired.
      */
     static constexpr auto DANGLING_TIMEOUT = 15min;
 
     Peer(PeerId peerid_, ProofRef proof_,
          std::chrono::seconds nextPossibleConflictTime_)
         : peerid(peerid_), proof(std::move(proof_)),
           registration_time(GetTime<std::chrono::seconds>()),
           nextPossibleConflictTime(std::move(nextPossibleConflictTime_)) {}
 
     const ProofId &getProofId() const { return proof->getId(); }
     uint32_t getScore() const { return proof->getScore(); }
 };
 
 struct proof_index {
     using result_type = ProofId;
     result_type operator()(const Peer &p) const { return p.proof->getId(); }
 };
 
 struct score_index {
     using result_type = uint32_t;
     result_type operator()(const Peer &p) const { return p.getScore(); }
 };
 
 struct next_request_time {};
 
 struct PendingNode {
     ProofId proofid;
     NodeId nodeid;
 
     PendingNode(ProofId proofid_, NodeId nodeid_)
         : proofid(proofid_), nodeid(nodeid_){};
 };
 
 struct by_proofid;
 struct by_nodeid;
 struct by_score;
 
 enum class ProofRegistrationResult {
     NONE = 0,
     ALREADY_REGISTERED,
     IMMATURE,
     INVALID,
     CONFLICTING,
     REJECTED,
     COOLDOWN_NOT_ELAPSED,
     DANGLING,
     MISSING_UTXO,
 };
 
 class ProofRegistrationState : public ValidationState<ProofRegistrationResult> {
 };
 
 namespace bmi = boost::multi_index;
 
 class PeerManager {
     std::vector<Slot> slots;
     uint64_t slotCount = 0;
     uint64_t fragmentation = 0;
 
     /**
      * Several nodes can make an avalanche peer. In this case, all nodes are
      * considered interchangeable parts of the same peer.
      */
     using PeerSet = boost::multi_index_container<
         Peer, bmi::indexed_by<
                   // index by peerid
                   bmi::hashed_unique<bmi::member<Peer, PeerId, &Peer::peerid>>,
                   // index by proof
                   bmi::hashed_unique<bmi::tag<by_proofid>, proof_index,
                                      SaltedProofIdHasher>,
                   // ordered by score, decreasing order
                   bmi::ordered_non_unique<bmi::tag<by_score>, score_index,
                                           std::greater<uint32_t>>>>;
 
     PeerId nextPeerId = 0;
     PeerSet peers;
 
     ProofPool validProofPool;
     ProofPool conflictingProofPool;
     ProofPool immatureProofPool;
 
     using ProofRadixTree = RadixTree<const Proof, ProofRadixTreeAdapter>;
     ProofRadixTree shareableProofs;
 
     using NodeSet = boost::multi_index_container<
         Node,
         bmi::indexed_by<
             // index by nodeid
             bmi::hashed_unique<bmi::member<Node, NodeId, &Node::nodeid>>,
             // sorted by peerid/nextRequestTime
             bmi::ordered_non_unique<
                 bmi::tag<next_request_time>,
                 bmi::composite_key<
                     Node, bmi::member<Node, PeerId, &Node::peerid>,
                     bmi::member<Node, TimePoint, &Node::nextRequestTime>>>>>;
 
     NodeSet nodes;
 
     /**
      * Flag indicating that we failed to select a node and need to expand our
      * node set.
      */
     std::atomic<bool> needMoreNodes{false};
 
     using PendingNodeSet = boost::multi_index_container<
         PendingNode,
         bmi::indexed_by<
             // index by proofid
             bmi::hashed_non_unique<
                 bmi::tag<by_proofid>,
                 bmi::member<PendingNode, ProofId, &PendingNode::proofid>,
                 SaltedProofIdHasher>,
             // index by nodeid
             bmi::hashed_unique<
                 bmi::tag<by_nodeid>,
                 bmi::member<PendingNode, NodeId, &PendingNode::nodeid>>>>;
     PendingNodeSet pendingNodes;
 
     static constexpr int SELECT_PEER_MAX_RETRY = 3;
     static constexpr int SELECT_NODE_MAX_RETRY = 3;
 
     /**
      * Track proof ids to broadcast
      */
     ProofIdSet m_unbroadcast_proofids;
 
     /**
      * Remember the last proofs that have been evicted because they had no node
      * attached.
      * A false positive would cause the proof to fail to register if there is
      * no previously known node that is claiming it, which is acceptable
      * intended the low expected false positive rate.
      */
     CRollingBloomFilter danglingProofIds{10000, 0.00001};
 
     /**
      * Quorum management.
      */
     uint32_t totalPeersScore = 0;
     uint32_t connectedPeersScore = 0;
 
     Amount stakeUtxoDustThreshold;
 
     ChainstateManager &chainman;
 
 public:
     PeerManager(const Amount &stakeUtxoDustThresholdIn,
                 ChainstateManager &chainmanIn)
         : stakeUtxoDustThreshold(stakeUtxoDustThresholdIn),
           chainman(chainmanIn){};
 
     /**
      * Node API.
      */
     bool addNode(NodeId nodeid, const ProofId &proofid);
     bool removeNode(NodeId nodeid);
     size_t getNodeCount() const { return nodes.size(); }
     size_t getPendingNodeCount() const { return pendingNodes.size(); }
 
     // Update when a node is to be polled next.
     bool updateNextRequestTime(NodeId nodeid, TimePoint timeout);
     /**
      * Flag that a node did send its compact proofs.
      * @return True if the flag changed state, i;e. if this is the first time
      * the message is accounted for this node.
      */
     bool latchAvaproofsSent(NodeId nodeid);
 
     // Randomly select a node to poll.
     NodeId selectNode();
 
     /**
      * Returns true if we encountered a lack of node since the last call.
      */
     bool shouldRequestMoreNodes() { return needMoreNodes.exchange(false); }
 
     template <typename Callable>
     bool forNode(NodeId nodeid, Callable &&func) const {
         auto it = nodes.find(nodeid);
         return it != nodes.end() && func(*it);
     }
 
     template <typename Callable>
     void forEachNode(const Peer &peer, Callable &&func) const {
         auto &nview = nodes.get<next_request_time>();
         auto range = nview.equal_range(peer.peerid);
         for (auto it = range.first; it != range.second; ++it) {
             func(*it);
         }
     }
 
     /**
      * Proof and Peer related API.
      */
 
     /**
      * Update the time before which a proof is not allowed to have conflicting
      * UTXO with this peer's proof.
      */
     bool updateNextPossibleConflictTime(PeerId peerid,
                                         const std::chrono::seconds &nextTime);
 
     /**
      * Latch on that this peer has a finalized proof.
      */
     bool setFinalized(PeerId peerid);
 
     /**
      * Registration mode
      *  - DEFAULT: Default policy, register only if the proof is unknown and has
      *    no conflict.
      *  - FORCE_ACCEPT: Turn a valid proof into a peer even if it has conflicts
      *    and is not the best candidate.
      */
     enum class RegistrationMode {
         DEFAULT,
         FORCE_ACCEPT,
     };
 
     bool registerProof(const ProofRef &proof,
                        ProofRegistrationState &registrationState,
                        RegistrationMode mode = RegistrationMode::DEFAULT);
     bool registerProof(const ProofRef &proof,
                        RegistrationMode mode = RegistrationMode::DEFAULT) {
         ProofRegistrationState dummy;
         return registerProof(proof, dummy, mode);
     }
 
     /**
      * Rejection mode
      *  - DEFAULT: Default policy, reject a proof and attempt to keep it in the
      *    conflicting pool if possible.
      *  - INVALIDATE: Reject a proof by removing it from any of the pool.
      *
      * In any case if a peer is rejected, it attempts to pull the conflicting
      * proofs back.
      */
     enum class RejectionMode {
         DEFAULT,
         INVALIDATE,
     };
 
     bool rejectProof(const ProofId &proofid,
                      RejectionMode mode = RejectionMode::DEFAULT);
 
     bool exists(const ProofId &proofid) const {
         return getProof(proofid) != nullptr;
     }
 
     void cleanupDanglingProofs(const ProofRef &localProof);
 
     template <typename Callable>
     bool forPeer(const ProofId &proofid, Callable &&func) const {
         auto &pview = peers.get<by_proofid>();
         auto it = pview.find(proofid);
         return it != pview.end() && func(*it);
     }
 
     template <typename Callable> void forEachPeer(Callable &&func) const {
         for (const auto &p : peers) {
             func(p);
         }
     }
 
     /**
      * Update the peer set when a new block is connected.
      */
     std::unordered_set<ProofRef, SaltedProofHasher> updatedBlockTip();
 
     /**
      * Proof broadcast API.
      */
     void addUnbroadcastProof(const ProofId &proofid);
     void removeUnbroadcastProof(const ProofId &proofid);
     auto getUnbroadcastProofs() const { return m_unbroadcast_proofids; }
 
     /*
      * Quorum management
      */
     uint32_t getTotalPeersScore() const { return totalPeersScore; }
     uint32_t getConnectedPeersScore() const { return connectedPeersScore; }
 
     template <typename Callable>
     void updateAvailabilityScores(const double decayFactor,
                                   Callable &&getNodeAvailabilityScore) {
         for (auto it = peers.begin(); it != peers.end(); it++) {
             peers.modify(it, [&](Peer &peer) {
                 // Calculate average of current node scores
                 double peerScore{0.0};
                 forEachNode(peer, [&](const avalanche::Node &node) {
                     peerScore += getNodeAvailabilityScore(node.nodeid);
                 });
-                peerScore /= peer.node_count;
 
                 // Calculate exponential moving average of averaged node scores
                 peer.availabilityScore =
                     decayFactor * peerScore +
                     (1. - decayFactor) * peer.availabilityScore;
             });
         }
     }
 
     /****************************************************
      * Functions which are public for testing purposes. *
      ****************************************************/
 
     /**
      * Remove an existing peer.
      */
     bool removePeer(const PeerId peerid);
 
     /**
      * Randomly select a peer to poll.
      */
     PeerId selectPeer() const;
 
     /**
      * Trigger maintenance of internal data structures.
      * Returns how much slot space was saved after compaction.
      */
     uint64_t compact();
 
     /**
      * Perform consistency check on internal data structures.
      */
     bool verify() const;
 
     // Accessors.
     uint64_t getSlotCount() const { return slotCount; }
     uint64_t getFragmentation() const { return fragmentation; }
 
     const ProofPool &getValidProofPool() const { return validProofPool; }
     const ProofPool &getConflictingProofPool() const {
         return conflictingProofPool;
     }
     const ProofPool &getImmatureProofPool() const { return immatureProofPool; }
 
     ProofRef getProof(const ProofId &proofid) const;
     bool isBoundToPeer(const ProofId &proofid) const;
     bool isImmature(const ProofId &proofid) const;
     bool isInConflictingPool(const ProofId &proofid) const;
 
     const ProofRadixTree &getShareableProofsSnapshot() const {
         return shareableProofs;
     }
 
     const Amount &getStakeUtxoDustThreshold() const {
         return stakeUtxoDustThreshold;
     }
 
 private:
     template <typename ProofContainer>
     void moveToConflictingPool(const ProofContainer &proofs);
 
     bool addOrUpdateNode(const PeerSet::iterator &it, NodeId nodeid);
     bool addNodeToPeer(const PeerSet::iterator &it);
     bool removeNodeFromPeer(const PeerSet::iterator &it, uint32_t count = 1);
 
     friend struct ::avalanche::TestPeerManager;
 };
 
 /**
  * Internal methods that are exposed for testing purposes.
  */
 PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
                       const uint64_t max);
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PEERMANAGER_H
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
index 1b55eabf0..0966c59e9 100644
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -1,2232 +1,2234 @@
 // 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 <config.h>
 #include <script/standard.h>
 #include <util/time.h>
 #include <util/translation.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 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,
                               const ProofRef &localProof = ProofRef()) {
             pm.cleanupDanglingProofs(localProof);
         }
     };
 
     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) {
         ProofBuilder pb(sequence, expirationTime, master,
                         UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         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, std::chrono::steady_clock::now()));
     }
 
     // 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, std::chrono::steady_clock::now()));
     }
 
     // Push a node's timeout in the future, so that it doesn't show up.
     BOOST_CHECK(pm.updateNextRequestTime(1, std::chrono::steady_clock::now() +
                                                 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, std::chrono::steady_clock::now()));
     }
 
     // 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, std::chrono::steady_clock::now()));
     }
 }
 
 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(GetConfig(), state,
                                                     chainman.ActiveTip());
         BOOST_CHECK_EQUAL(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(GetConfig(), state));
         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 TimePoint theFuture(std::chrono::steady_clock::now() +
                               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(GetConfig(), state,
                                           chainman.ActiveTip());
         BOOST_CHECK_EQUAL(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(GetRandInt(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));
 
     // 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));
     }
 
     auto cooldownTimepoint = std::chrono::steady_clock::now() + 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, std::chrono::steady_clock::now()));
     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));
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // After some time the proof will be considered dangling and more nodes will
     // be requested.
     SetMockTime(GetTime() + 15 * 60);
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // 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.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // 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);
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // Disconnect the node, the proof is dangling again
     BOOST_CHECK(pm.removeNode(11));
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 }
 
 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);
 
     // Use the first conflicting proof as our local proof
     TestPeerManager::cleanupDanglingProofs(pm, conflictingProofs[1]);
 
     for (size_t i = 0; i < numProofs; i++) {
         // All other proofs have now been discarded
         BOOST_CHECK(!pm.exists(proofs[i]->getId()));
         BOOST_CHECK_EQUAL(!pm.exists(conflictingProofs[i]->getId()), i != 1);
     }
 
     // Cleanup one more time with no local proof
     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 = 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(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) 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),
+            // 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, 1., 0.01);
+        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, 1., 0.01);
+        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),
+            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);
+        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_SUITE_END()
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
index 54cc871e5..0f056532c 100644
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -1,1357 +1,1360 @@
 // 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/avalanche.h>
 #include <avalanche/delegation.h>
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/processor.h>
 #include <avalanche/proof.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/validation.h>
 #include <config.h>
 #include <core_io.h>
 #include <index/txindex.h>
 #include <key_io.h>
 #include <net_processing.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <util/strencodings.h>
 #include <util/translation.h>
 
 #include <univalue.h>
 
 using node::GetTransaction;
 using node::NodeContext;
 
 static RPCHelpMan getavalanchekey() {
     return RPCHelpMan{
         "getavalanchekey",
         "Returns the key used to sign avalanche messages.\n",
         {},
         RPCResult{RPCResult::Type::STR_HEX, "", ""},
         RPCExamples{HelpExampleRpc("getavalanchekey", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             return HexStr(g_avalanche->getSessionPubKey());
         },
     };
 }
 
 static CPubKey ParsePubKey(const UniValue &param) {
     const std::string keyHex = param.get_str();
     if ((keyHex.length() != 2 * CPubKey::COMPRESSED_SIZE &&
          keyHex.length() != 2 * CPubKey::SIZE) ||
         !IsHex(keyHex)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("Invalid public key: %s\n", keyHex));
     }
 
     return HexToPubKey(keyHex);
 }
 
 static bool registerProofIfNeeded(avalanche::ProofRef proof,
                                   avalanche::ProofRegistrationState &state) {
     auto localProof = g_avalanche->getLocalProof();
     if (localProof && localProof->getId() == proof->getId()) {
         return true;
     }
 
     return g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
         return pm.getProof(proof->getId()) ||
                pm.registerProof(std::move(proof), state);
     });
 }
 
 static bool registerProofIfNeeded(avalanche::ProofRef proof) {
     avalanche::ProofRegistrationState state;
     return registerProofIfNeeded(std::move(proof), state);
 }
 
 static void verifyDelegationOrThrow(avalanche::Delegation &dg,
                                     const std::string &dgHex, CPubKey &auth) {
     bilingual_str error;
     if (!avalanche::Delegation::FromHex(dg, dgHex, error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
     }
 
     avalanche::DelegationState state;
     if (!dg.verify(state, auth)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "The delegation is invalid: " + state.ToString());
     }
 }
 
 static void verifyProofOrThrow(const NodeContext &node, avalanche::Proof &proof,
                                const std::string &proofHex) {
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, proofHex, error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
     }
 
     Amount stakeUtxoDustThreshold = avalanche::PROOF_DUST_THRESHOLD;
     if (g_avalanche) {
         // If Avalanche is enabled, use the configured dust threshold
         g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
             stakeUtxoDustThreshold = pm.getStakeUtxoDustThreshold();
         });
     }
 
     avalanche::ProofValidationState state;
     {
         LOCK(cs_main);
         if (!proof.verify(stakeUtxoDustThreshold, *Assert(node.chainman),
                           state)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The proof is invalid: " + state.ToString());
         }
     }
 }
 
 static RPCHelpMan addavalanchenode() {
     return RPCHelpMan{
         "addavalanchenode",
         "Add a node in the set of peers to poll for avalanche.\n",
         {
             {"nodeid", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Node to be added to avalanche."},
             {"publickey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The public key of the node."},
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Proof that the node is not a sybil."},
             {"delegation", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
              "The proof delegation the the node public key"},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the addition succeeded or not."},
         RPCExamples{
             HelpExampleRpc("addavalanchenode", "5, \"<pubkey>\", \"<proof>\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params,
                          {UniValue::VNUM, UniValue::VSTR, UniValue::VSTR});
 
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             const NodeId nodeid = request.params[0].get_int64();
             CPubKey key = ParsePubKey(request.params[1]);
 
             auto proof = RCUPtr<avalanche::Proof>::make();
             NodeContext &node = EnsureAnyNodeContext(request.context);
             verifyProofOrThrow(node, *proof, request.params[2].get_str());
 
             const avalanche::ProofId &proofid = proof->getId();
             if (key != proof->getMaster()) {
                 if (request.params.size() < 4 || request.params[3].isNull()) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "The public key does not match the proof");
                 }
 
                 avalanche::Delegation dg;
                 CPubKey auth;
                 verifyDelegationOrThrow(dg, request.params[3].get_str(), auth);
 
                 if (dg.getProofId() != proofid) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "The delegation does not match the proof");
                 }
 
                 if (key != auth) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "The public key does not match the delegation");
                 }
             }
 
             if (!registerProofIfNeeded(proof)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "The proof has conflicting utxos");
             }
 
             if (!node.connman->ForNode(nodeid, [&](CNode *pnode) {
                     LOCK(pnode->cs_avalanche_pubkey);
                     bool expected = false;
                     if (pnode->m_avalanche_enabled.compare_exchange_strong(
                             expected, true)) {
                         pnode->m_avalanche_pubkey = std::move(key);
                     }
                     return true;
                 })) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("The node does not exist: %d", nodeid));
             }
 
             return g_avalanche->withPeerManager(
                 [&](avalanche::PeerManager &pm) {
                     if (!pm.addNode(nodeid, proofid)) {
                         return false;
                     }
 
                     pm.addUnbroadcastProof(proofid);
                     return true;
                 });
         },
     };
 }
 
 static RPCHelpMan buildavalancheproof() {
     return RPCHelpMan{
         "buildavalancheproof",
         "Build a proof for avalanche's sybil resistance.\n",
         {
             {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The proof's sequence"},
             {"expiration", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "A timestamp indicating when the proof expire"},
             {"master", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The master private key in base58-encoding"},
             {
                 "stakes",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The stakes to be signed and associated private keys",
                 {
                     {
                         "stake",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::NO,
                         "A stake to be attached to this proof",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount in this UTXO"},
                             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The height at which this UTXO was mined"},
                             {"iscoinbase", RPCArg::Type::BOOL,
                              /* default */ "false",
                              "Indicate wether the UTXO is a coinbase"},
                             {"privatekey", RPCArg::Type::STR,
                              RPCArg::Optional::NO,
                              "private key in base58-encoding"},
                         },
                     },
                 },
             },
             {"payoutAddress", RPCArg::Type::STR, RPCArg::Optional::NO,
              "A payout address"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "proof",
                   "A string that is a serialized, hex-encoded proof data."},
         RPCExamples{HelpExampleRpc("buildavalancheproof",
                                    "0 1234567800 \"<master>\" []")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VNUM,
                                           UniValue::VSTR, UniValue::VARR});
 
             const uint64_t sequence = request.params[0].get_int64();
             const int64_t expiration = request.params[1].get_int64();
 
             CKey masterKey = DecodeSecret(request.params[2].get_str());
             if (!masterKey.IsValid()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid master key");
             }
 
             CTxDestination payoutAddress = DecodeDestination(
                 request.params[4].get_str(), config.GetChainParams());
 
             if (!IsValidDestination(payoutAddress)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid payout address");
             }
 
             avalanche::ProofBuilder pb(sequence, expiration, masterKey,
                                        GetScriptForDestination(payoutAddress));
 
             const UniValue &stakes = request.params[3].get_array();
             for (size_t i = 0; i < stakes.size(); i++) {
                 const UniValue &stake = stakes[i];
                 RPCTypeCheckObj(
                     stake,
                     {
                         {"txid", UniValue::VSTR},
                         {"vout", UniValue::VNUM},
                         // "amount" is also required but check is done below
                         // due to UniValue::VNUM erroneously not accepting
                         // quoted numerics (which are valid JSON)
                         {"height", UniValue::VNUM},
                         {"privatekey", UniValue::VSTR},
                     });
 
                 int nOut = find_value(stake, "vout").get_int();
                 if (nOut < 0) {
                     throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                        "vout cannot be negative");
                 }
 
                 const int height = find_value(stake, "height").get_int();
                 if (height < 1) {
                     throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                        "height must be positive");
                 }
 
                 const TxId txid(ParseHashO(stake, "txid"));
                 const COutPoint utxo(txid, nOut);
 
                 if (!stake.exists("amount")) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing amount");
                 }
 
                 const Amount amount =
                     AmountFromValue(find_value(stake, "amount"));
 
                 const UniValue &iscbparam = find_value(stake, "iscoinbase");
                 const bool iscoinbase =
                     iscbparam.isNull() ? false : iscbparam.get_bool();
                 CKey key =
                     DecodeSecret(find_value(stake, "privatekey").get_str());
 
                 if (!key.IsValid()) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Invalid private key");
                 }
 
                 if (!pb.addUTXO(utxo, amount, uint32_t(height), iscoinbase,
                                 std::move(key))) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Duplicated stake");
                 }
             }
 
             const avalanche::ProofRef proof = pb.build();
 
             return proof->ToHex();
         },
     };
 }
 
 static RPCHelpMan decodeavalancheproof() {
     return RPCHelpMan{
         "decodeavalancheproof",
         "Convert a serialized, hex-encoded proof, into JSON object. "
         "The validity of the proof is not verified.\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The proof hex string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "sequence",
                  "The proof's sequential number"},
                 {RPCResult::Type::NUM, "expiration",
                  "A timestamp indicating when the proof expires"},
                 {RPCResult::Type::STR_HEX, "master", "The master public key"},
                 {RPCResult::Type::STR, "signature",
                  "The proof signature (base64 encoded)"},
                 {RPCResult::Type::OBJ,
                  "payoutscript",
                  "The proof payout script",
                  {
                      {RPCResult::Type::STR, "asm", "Decoded payout script"},
                      {RPCResult::Type::STR_HEX, "hex",
                       "Raw payout script in hex format"},
                      {RPCResult::Type::STR, "type",
                       "The output type (e.g. " + GetAllOutputTypes() + ")"},
                      {RPCResult::Type::NUM, "reqSigs",
                       "The required signatures"},
                      {RPCResult::Type::ARR,
                       "addresses",
                       "",
                       {
                           {RPCResult::Type::STR, "address", "eCash address"},
                       }},
                  }},
                 {RPCResult::Type::STR_HEX, "limitedid",
                  "A hash of the proof data excluding the master key."},
                 {RPCResult::Type::STR_HEX, "proofid",
                  "A hash of the limitedid and master key."},
                 {RPCResult::Type::STR_AMOUNT, "staked_amount",
                  "The total staked amount of this proof in " +
                      Currency::get().ticker + "."},
                 {RPCResult::Type::NUM, "score", "The score of this proof."},
                 {RPCResult::Type::ARR,
                  "stakes",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The transaction id"},
                           {RPCResult::Type::NUM, "vout", "The output number"},
                           {RPCResult::Type::STR_AMOUNT, "amount",
                            "The amount in this UTXO"},
                           {RPCResult::Type::NUM, "height",
                            "The height at which this UTXO was mined"},
                           {RPCResult::Type::BOOL, "iscoinbase",
                            "Indicate whether the UTXO is a coinbase"},
                           {RPCResult::Type::STR_HEX, "pubkey",
                            "This UTXO's public key"},
                           {RPCResult::Type::STR, "signature",
                            "Signature of the proofid with this UTXO's private "
                            "key (base64 encoded)"},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("decodeavalancheproof", "\"<hex proof>\"") +
                     HelpExampleRpc("decodeavalancheproof", "\"<hex proof>\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR});
 
             avalanche::Proof proof;
             bilingual_str error;
             if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(),
                                            error)) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
             }
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("sequence", proof.getSequence());
             result.pushKV("expiration", proof.getExpirationTime());
             result.pushKV("master", HexStr(proof.getMaster()));
             result.pushKV("signature", EncodeBase64(proof.getSignature()));
 
             const auto payoutScript = proof.getPayoutScript();
             UniValue payoutScriptObj(UniValue::VOBJ);
             ScriptPubKeyToUniv(payoutScript, payoutScriptObj,
                                /* fIncludeHex */ true);
             result.pushKV("payoutscript", payoutScriptObj);
 
             result.pushKV("limitedid", proof.getLimitedId().ToString());
             result.pushKV("proofid", proof.getId().ToString());
 
             result.pushKV("staked_amount", proof.getStakedAmount());
             result.pushKV("score", uint64_t(proof.getScore()));
 
             UniValue stakes(UniValue::VARR);
             for (const avalanche::SignedStake &s : proof.getStakes()) {
                 const COutPoint &utxo = s.getStake().getUTXO();
                 UniValue stake(UniValue::VOBJ);
                 stake.pushKV("txid", utxo.GetTxId().ToString());
                 stake.pushKV("vout", uint64_t(utxo.GetN()));
                 stake.pushKV("amount", s.getStake().getAmount());
                 stake.pushKV("height", uint64_t(s.getStake().getHeight()));
                 stake.pushKV("iscoinbase", s.getStake().isCoinbase());
                 stake.pushKV("pubkey", HexStr(s.getStake().getPubkey()));
                 // Only PKHash destination is supported, so this is safe
                 stake.pushKV("address",
                              EncodeDestination(PKHash(s.getStake().getPubkey()),
                                                config));
                 stake.pushKV("signature", EncodeBase64(s.getSignature()));
                 stakes.push_back(stake);
             }
             result.pushKV("stakes", stakes);
 
             return result;
         },
     };
 }
 
 static RPCHelpMan delegateavalancheproof() {
     return RPCHelpMan{
         "delegateavalancheproof",
         "Delegate the avalanche proof to another public key.\n",
         {
             {"limitedproofid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The limited id of the proof to be delegated."},
             {"privatekey", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The private key in base58-encoding. Must match the proof master "
              "public key or the upper level parent delegation public key if "
              " supplied."},
             {"publickey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The public key to delegate the proof to."},
             {"delegation", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
              "A string that is the serialized, hex-encoded delegation for the "
              "proof and which is a parent for the delegation to build."},
         },
         RPCResult{RPCResult::Type::STR_HEX, "delegation",
                   "A string that is a serialized, hex-encoded delegation."},
         RPCExamples{
             HelpExampleRpc("delegateavalancheproof",
                            "\"<limitedproofid>\" \"<privkey>\" \"<pubkey>\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params,
                          {UniValue::VSTR, UniValue::VSTR, UniValue::VSTR});
 
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             avalanche::LimitedProofId limitedProofId{
                 ParseHashV(request.params[0], "limitedproofid")};
 
             const CKey privkey = DecodeSecret(request.params[1].get_str());
             if (!privkey.IsValid()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "The private key is invalid");
             }
 
             const CPubKey pubkey = ParsePubKey(request.params[2]);
 
             std::unique_ptr<avalanche::DelegationBuilder> dgb;
             if (request.params.size() >= 4 && !request.params[3].isNull()) {
                 avalanche::Delegation dg;
                 CPubKey auth;
                 verifyDelegationOrThrow(dg, request.params[3].get_str(), auth);
 
                 if (dg.getProofId() !=
                     limitedProofId.computeProofId(dg.getProofMaster())) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "The delegation does not match the proof");
                 }
 
                 if (privkey.GetPubKey() != auth) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "The private key does not match the delegation");
                 }
 
                 dgb = std::make_unique<avalanche::DelegationBuilder>(dg);
             } else {
                 dgb = std::make_unique<avalanche::DelegationBuilder>(
                     limitedProofId, privkey.GetPubKey());
             }
 
             if (!dgb->addLevel(privkey, pubkey)) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Unable to build the delegation");
             }
 
             CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
             ss << dgb->build();
             return HexStr(ss);
         },
     };
 }
 
 static RPCHelpMan decodeavalanchedelegation() {
     return RPCHelpMan{
         "decodeavalanchedelegation",
         "Convert a serialized, hex-encoded avalanche proof delegation, into "
         "JSON object. \n"
         "The validity of the delegation is not verified.\n",
         {
             {"delegation", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The delegation hex string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "pubkey",
                  "The public key the proof is delegated to."},
                 {RPCResult::Type::STR_HEX, "proofmaster",
                  "The delegated proof master public key."},
                 {RPCResult::Type::STR_HEX, "delegationid",
                  "The identifier of this delegation."},
                 {RPCResult::Type::STR_HEX, "limitedid",
                  "A delegated proof data hash excluding the master key."},
                 {RPCResult::Type::STR_HEX, "proofid",
                  "A hash of the delegated proof limitedid and master key."},
                 {RPCResult::Type::NUM, "depth",
                  "The number of delegation levels."},
                 {RPCResult::Type::ARR,
                  "levels",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::NUM, "index",
                            "The index of this delegation level."},
                           {RPCResult::Type::STR_HEX, "pubkey",
                            "This delegated public key for this level"},
                           {RPCResult::Type::STR, "signature",
                            "Signature of this delegation level (base64 "
                            "encoded)"},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("decodeavalanchedelegation",
                                    "\"<hex delegation>\"") +
                     HelpExampleRpc("decodeavalanchedelegation",
                                    "\"<hex delegation>\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR});
 
             avalanche::Delegation delegation;
             bilingual_str error;
             if (!avalanche::Delegation::FromHex(
                     delegation, request.params[0].get_str(), error)) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
             }
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("pubkey", HexStr(delegation.getDelegatedPubkey()));
             result.pushKV("proofmaster", HexStr(delegation.getProofMaster()));
             result.pushKV("delegationid", delegation.getId().ToString());
             result.pushKV("limitedid",
                           delegation.getLimitedProofId().ToString());
             result.pushKV("proofid", delegation.getProofId().ToString());
 
             auto levels = delegation.getLevels();
             result.pushKV("depth", uint64_t(levels.size()));
 
             UniValue levelsArray(UniValue::VARR);
             for (auto &level : levels) {
                 UniValue obj(UniValue::VOBJ);
                 obj.pushKV("pubkey", HexStr(level.pubkey));
                 obj.pushKV("signature", EncodeBase64(level.sig));
                 levelsArray.push_back(std::move(obj));
             }
             result.pushKV("levels", levelsArray);
 
             return result;
         },
     };
 }
 
 static RPCHelpMan getavalancheinfo() {
     return RPCHelpMan{
         "getavalancheinfo",
         "Returns an object containing various state info regarding avalanche "
         "networking.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::BOOL, "ready_to_poll",
                  "Whether the node is ready to start polling and voting."},
                 {RPCResult::Type::OBJ,
                  "local",
                  "Only available if -avaproof has been supplied to the node",
                  {
                      {RPCResult::Type::BOOL, "verified",
                       "Whether the node local proof has been locally verified "
                       "or not."},
                      {RPCResult::Type::STR, "verification_status",
                       "The proof verification status. Only available if the "
                       "\"verified\" flag is false."},
                      {RPCResult::Type::BOOL, "sharing",
                       "Whether the node local proof is being advertised on the "
                       "network or not."},
                      {RPCResult::Type::STR_HEX, "proofid",
                       "The node local proof id."},
                      {RPCResult::Type::STR_HEX, "limited_proofid",
                       "The node local limited proof id."},
                      {RPCResult::Type::STR_HEX, "master",
                       "The node local proof master public key."},
                      {RPCResult::Type::STR, "payout_address",
                       "The node local proof payout address. This might be "
                       "omitted if the payout script is not one of P2PK, P2PKH "
                       "or P2SH, in which case decodeavalancheproof can be used "
                       "to get more details."},
                      {RPCResult::Type::STR_AMOUNT, "stake_amount",
                       "The node local proof staked amount."},
                  }},
                 {RPCResult::Type::OBJ,
                  "network",
                  "",
                  {
                      {RPCResult::Type::NUM, "proof_count",
                       "The number of valid avalanche proofs we know exist "
                       "(including this node's local proof if applicable)."},
                      {RPCResult::Type::NUM, "connected_proof_count",
                       "The number of avalanche proofs with at least one node "
                       "we are connected to (including this node's local proof "
                       "if applicable)."},
                      {RPCResult::Type::NUM, "dangling_proof_count",
                       "The number of avalanche proofs with no node attached."},
                      {RPCResult::Type::NUM, "finalized_proof_count",
                       "The number of known avalanche proofs that have been "
                       "finalized by avalanche."},
                      {RPCResult::Type::NUM, "conflicting_proof_count",
                       "The number of known avalanche proofs that conflict with "
                       "valid proofs."},
                      {RPCResult::Type::NUM, "immature_proof_count",
                       "The number of known avalanche proofs that have immature "
                       "utxos."},
                      {RPCResult::Type::STR_AMOUNT, "total_stake_amount",
                       "The total staked amount over all the valid proofs in " +
                           Currency::get().ticker +
                           " (including this node's local proof if "
                           "applicable)."},
                      {RPCResult::Type::STR_AMOUNT, "connected_stake_amount",
                       "The total staked amount over all the connected proofs "
                       "in " +
                           Currency::get().ticker +
                           " (including this node's local proof if "
                           "applicable)."},
                      {RPCResult::Type::STR_AMOUNT, "dangling_stake_amount",
                       "The total staked amount over all the dangling proofs "
                       "in " +
                           Currency::get().ticker +
                           " (including this node's local proof if "
                           "applicable)."},
                      {RPCResult::Type::STR_AMOUNT, "immature_stake_amount",
                       "The total staked amount over all the immature proofs "
                       "in " +
                           Currency::get().ticker +
                           " (including this node's local proof if "
                           "applicable)."},
                      {RPCResult::Type::NUM, "node_count",
                       "The number of avalanche nodes we are connected to "
                       "(including this node if a local proof is set)."},
                      {RPCResult::Type::NUM, "connected_node_count",
                       "The number of avalanche nodes associated with an "
                       "avalanche proof (including this node if a local proof "
                       "is set)."},
                      {RPCResult::Type::NUM, "pending_node_count",
                       "The number of avalanche nodes pending for a proof."},
                  }},
             },
         },
         RPCExamples{HelpExampleCli("getavalancheinfo", "") +
                     HelpExampleRpc("getavalancheinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("ready_to_poll", g_avalanche->isQuorumEstablished());
 
             auto localProof = g_avalanche->getLocalProof();
             if (localProof != nullptr) {
                 UniValue local(UniValue::VOBJ);
                 const bool verified = g_avalanche->withPeerManager(
                     [&](const avalanche::PeerManager &pm) {
                         const avalanche::ProofId &proofid = localProof->getId();
                         return pm.isBoundToPeer(proofid);
                     });
                 local.pushKV("verified", verified);
                 if (!verified) {
                     avalanche::ProofRegistrationState state =
                         g_avalanche->getLocalProofRegistrationState();
                     // If the local proof is not registered but the state is
                     // valid, no registration attempt occurred yet.
                     local.pushKV("verification_status",
                                  state.IsValid() ? "pending"
                                                  : state.GetRejectReason());
                 }
                 local.pushKV("sharing", g_avalanche->canShareLocalProof());
                 local.pushKV("proofid", localProof->getId().ToString());
                 local.pushKV("limited_proofid",
                              localProof->getLimitedId().ToString());
                 local.pushKV("master", HexStr(localProof->getMaster()));
                 CTxDestination destination;
                 if (ExtractDestination(localProof->getPayoutScript(),
                                        destination)) {
                     local.pushKV("payout_address",
                                  EncodeDestination(destination, config));
                 }
                 local.pushKV("stake_amount", localProof->getStakedAmount());
                 ret.pushKV("local", local);
             }
 
             g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
                 UniValue network(UniValue::VOBJ);
 
                 uint64_t proofCount{0};
                 uint64_t connectedProofCount{0};
                 uint64_t finalizedProofCount{0};
                 uint64_t connectedNodeCount{0};
                 Amount totalStakes = Amount::zero();
                 Amount connectedStakes = Amount::zero();
 
                 pm.forEachPeer([&](const avalanche::Peer &peer) {
                     CHECK_NONFATAL(peer.proof != nullptr);
 
                     const bool isLocalProof = peer.proof == localProof;
 
                     ++proofCount;
                     const Amount proofStake = peer.proof->getStakedAmount();
 
                     totalStakes += proofStake;
 
                     if (peer.hasFinalized) {
                         ++finalizedProofCount;
                     }
 
                     if (peer.node_count > 0 || isLocalProof) {
                         ++connectedProofCount;
                         connectedStakes += proofStake;
                     }
 
                     connectedNodeCount += peer.node_count + isLocalProof;
                 });
 
                 Amount immatureStakes = Amount::zero();
                 pm.getImmatureProofPool().forEachProof(
                     [&](const avalanche::ProofRef &proof) {
                         immatureStakes += proof->getStakedAmount();
                     });
 
                 network.pushKV("proof_count", proofCount);
                 network.pushKV("connected_proof_count", connectedProofCount);
                 network.pushKV("dangling_proof_count",
                                proofCount - connectedProofCount);
 
                 network.pushKV("finalized_proof_count", finalizedProofCount);
                 network.pushKV(
                     "conflicting_proof_count",
                     uint64_t(pm.getConflictingProofPool().countProofs()));
                 network.pushKV(
                     "immature_proof_count",
                     uint64_t(pm.getImmatureProofPool().countProofs()));
 
                 network.pushKV("total_stake_amount", totalStakes);
                 network.pushKV("connected_stake_amount", connectedStakes);
                 network.pushKV("dangling_stake_amount",
                                totalStakes - connectedStakes);
                 network.pushKV("immature_stake_amount", immatureStakes);
 
                 const uint64_t pendingNodes = pm.getPendingNodeCount();
                 network.pushKV("node_count", connectedNodeCount + pendingNodes);
                 network.pushKV("connected_node_count", connectedNodeCount);
                 network.pushKV("pending_node_count", pendingNodes);
 
                 ret.pushKV("network", network);
             });
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan getavalanchepeerinfo() {
     return RPCHelpMan{
         "getavalanchepeerinfo",
         "Returns data about an avalanche peer as a json array of objects. If "
         "no proofid is provided, returns data about all the peers.\n",
         {
             {"proofid", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
              "The hex encoded avalanche proof identifier."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {{
                     {RPCResult::Type::NUM, "avalanche_peerid",
                      "The avalanche internal peer identifier"},
+                    {RPCResult::Type::NUM, "availability_score",
+                     "The agreggated availability score of this peer's nodes"},
                     {RPCResult::Type::STR_HEX, "proofid",
                      "The avalanche proof id used by this peer"},
                     {RPCResult::Type::STR_HEX, "proof",
                      "The avalanche proof used by this peer"},
                     {RPCResult::Type::NUM, "nodecount",
                      "The number of nodes for this peer"},
                     {RPCResult::Type::ARR,
                      "node_list",
                      "",
                      {
                          {RPCResult::Type::NUM, "nodeid",
                           "Node id, as returned by getpeerinfo"},
                      }},
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("getavalanchepeerinfo", "") +
                     HelpExampleCli("getavalanchepeerinfo", "\"proofid\"") +
                     HelpExampleRpc("getavalanchepeerinfo", "") +
                     HelpExampleRpc("getavalanchepeerinfo", "\"proofid\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR});
 
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             auto peerToUniv = [](const avalanche::PeerManager &pm,
                                  const avalanche::Peer &peer) {
                 UniValue obj(UniValue::VOBJ);
 
                 obj.pushKV("avalanche_peerid", uint64_t(peer.peerid));
+                obj.pushKV("availability_score", peer.availabilityScore);
                 obj.pushKV("proofid", peer.getProofId().ToString());
                 obj.pushKV("proof", peer.proof->ToHex());
 
                 UniValue nodes(UniValue::VARR);
                 pm.forEachNode(peer, [&](const avalanche::Node &n) {
                     nodes.push_back(n.nodeid);
                 });
 
                 obj.pushKV("nodecount", uint64_t(peer.node_count));
                 obj.pushKV("node_list", nodes);
 
                 return obj;
             };
 
             UniValue ret(UniValue::VARR);
 
             g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
                 // If a proofid is provided, only return the associated peer
                 if (!request.params[0].isNull()) {
                     const avalanche::ProofId proofid =
                         avalanche::ProofId::fromHex(
                             request.params[0].get_str());
                     if (!pm.isBoundToPeer(proofid)) {
                         throw JSONRPCError(RPC_INVALID_PARAMETER,
                                            "Proofid not found");
                     }
 
                     pm.forPeer(proofid, [&](const avalanche::Peer &peer) {
                         return ret.push_back(peerToUniv(pm, peer));
                     });
 
                     return;
                 }
 
                 // If no proofid is provided, return all the peers
                 pm.forEachPeer([&](const avalanche::Peer &peer) {
                     ret.push_back(peerToUniv(pm, peer));
                 });
             });
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan getavalancheproofs() {
     return RPCHelpMan{
         "getavalancheproofs",
         "Returns an object containing all tracked proofids.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "valid",
                  "",
                  {
                      {RPCResult::Type::STR_HEX, "proofid",
                       "Avalanche proof id"},
                  }},
                 {RPCResult::Type::ARR,
                  "conflicting",
                  "",
                  {
                      {RPCResult::Type::STR_HEX, "proofid",
                       "Avalanche proof id"},
                  }},
                 {RPCResult::Type::ARR,
                  "immature",
                  "",
                  {
                      {RPCResult::Type::STR_HEX, "proofid",
                       "Avalanche proof id"},
                  }},
             },
         },
         RPCExamples{HelpExampleCli("getavalancheproofs", "") +
                     HelpExampleRpc("getavalancheproofs", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             UniValue ret(UniValue::VOBJ);
             g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
                 auto appendProofIds = [&ret](const avalanche::ProofPool &pool,
                                              const std::string &key) {
                     UniValue arrOut(UniValue::VARR);
                     for (const avalanche::ProofId &proofid :
                          pool.getProofIds()) {
                         arrOut.push_back(proofid.ToString());
                     }
                     ret.pushKV(key, arrOut);
                 };
 
                 appendProofIds(pm.getValidProofPool(), "valid");
                 appendProofIds(pm.getConflictingProofPool(), "conflicting");
                 appendProofIds(pm.getImmatureProofPool(), "immature");
             });
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan getrawavalancheproof() {
     return RPCHelpMan{
         "getrawavalancheproof",
         "Lookup for a known avalanche proof by id.\n",
         {
             {"proofid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex encoded avalanche proof identifier."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {{
                 {RPCResult::Type::STR_HEX, "proof",
                  "The hex encoded proof matching the identifier."},
                 {RPCResult::Type::BOOL, "immature",
                  "Whether the proof has immature utxos."},
                 {RPCResult::Type::BOOL, "boundToPeer",
                  "Whether the proof is bound to an avalanche peer."},
                 {RPCResult::Type::BOOL, "conflicting",
                  "Whether the proof has a conflicting UTXO with an avalanche "
                  "peer."},
                 {RPCResult::Type::BOOL, "finalized",
                  "Whether the proof is finalized by vote."},
             }},
         },
         RPCExamples{HelpExampleRpc("getrawavalancheproof", "<proofid>")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             const avalanche::ProofId proofid =
                 avalanche::ProofId::fromHex(request.params[0].get_str());
 
             bool isImmature = false;
             bool isBoundToPeer = false;
             bool conflicting = false;
             bool finalized = false;
             auto proof = g_avalanche->withPeerManager(
                 [&](const avalanche::PeerManager &pm) {
                     isImmature = pm.isImmature(proofid);
                     isBoundToPeer = pm.isBoundToPeer(proofid);
                     conflicting = pm.isInConflictingPool(proofid);
                     finalized =
                         pm.forPeer(proofid, [&](const avalanche::Peer &p) {
                             return p.hasFinalized;
                         });
                     return pm.getProof(proofid);
                 });
 
             if (!proof) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Proof not found");
             }
 
             UniValue ret(UniValue::VOBJ);
 
             CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
             ss << *proof;
             ret.pushKV("proof", HexStr(ss));
             ret.pushKV("immature", isImmature);
             ret.pushKV("boundToPeer", isBoundToPeer);
             ret.pushKV("conflicting", conflicting);
             ret.pushKV("finalized", finalized);
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan isfinalblock() {
     return RPCHelpMan{
         "isfinalblock",
         "Check if a block has been finalized by avalanche votes.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hash of the block."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the block has been finalized by avalanche votes."},
         RPCExamples{HelpExampleRpc("isfinalblock", "<block hash>") +
                     HelpExampleCli("isfinalblock", "<block hash>")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             // Deprecated since 0.26.2
             if (!IsDeprecatedRPCEnabled(gArgs, "isfinalblock_noerror") &&
                 !g_avalanche->isQuorumEstablished()) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Avalanche is not ready to poll yet.");
             }
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const BlockHash blockhash(
                 ParseHashV(request.params[0], "blockhash"));
             const CBlockIndex *pindex;
 
             {
                 LOCK(cs_main);
                 pindex = chainman.m_blockman.LookupBlockIndex(blockhash);
 
                 if (!pindex) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Block not found");
                 }
             }
 
             return chainman.ActiveChainstate().IsBlockAvalancheFinalized(
                 pindex);
         },
     };
 }
 
 static RPCHelpMan isfinaltransaction() {
     return RPCHelpMan{
         "isfinaltransaction",
         "Check if a transaction has been finalized by avalanche votes.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The id of the transaction."},
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
              "The block in which to look for the transaction"},
         },
         RPCResult{
             RPCResult::Type::BOOL, "success",
             "Whether the transaction has been finalized by avalanche votes."},
         RPCExamples{HelpExampleRpc("isfinaltransaction", "<txid> <blockhash>") +
                     HelpExampleCli("isfinaltransaction", "<txid> <blockhash>")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             const NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             const TxId txid = TxId(ParseHashV(request.params[0], "txid"));
             CBlockIndex *pindex = nullptr;
 
             if (!request.params[1].isNull()) {
                 const BlockHash blockhash(
                     ParseHashV(request.params[1], "blockhash"));
 
                 LOCK(cs_main);
                 pindex = chainman.m_blockman.LookupBlockIndex(blockhash);
                 if (!pindex) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Block not found");
                 }
             }
 
             bool f_txindex_ready = false;
             if (g_txindex && !pindex) {
                 f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
             }
 
             BlockHash hash_block;
             const CTransactionRef tx = GetTransaction(
                 pindex, node.mempool.get(), txid,
                 config.GetChainParams().GetConsensus(), hash_block);
 
             // Deprecated since 0.26.2
             if (!IsDeprecatedRPCEnabled(gArgs, "isfinaltransaction_noerror")) {
                 if (!g_avalanche->isQuorumEstablished()) {
                     throw JSONRPCError(RPC_MISC_ERROR,
                                        "Avalanche is not ready to poll yet.");
                 }
 
                 if (!tx) {
                     std::string errmsg;
                     if (pindex) {
                         if (WITH_LOCK(::cs_main,
                                       return !pindex->nStatus.hasData())) {
                             throw JSONRPCError(
                                 RPC_MISC_ERROR,
                                 "Block data not downloaded yet.");
                         }
                         errmsg =
                             "No such transaction found in the provided block.";
                     } else if (!g_txindex) {
                         errmsg =
                             "No such transaction. Use -txindex or provide a "
                             "block "
                             "hash to enable blockchain transaction queries.";
                     } else if (!f_txindex_ready) {
                         errmsg =
                             "No such transaction. Blockchain transactions are "
                             "still in the process of being indexed.";
                     } else {
                         errmsg = "No such mempool or blockchain transaction.";
                     }
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, errmsg);
                 }
             }
 
             if (!pindex) {
                 LOCK(cs_main);
                 pindex = chainman.m_blockman.LookupBlockIndex(hash_block);
             }
 
             // The first 2 checks are redundant as we expect to throw a JSON RPC
             // error for these cases, but they are almost free so they are kept
             // as a safety net.
             return tx != nullptr && !node.mempool->exists(txid) &&
                    chainman.ActiveChainstate().IsBlockAvalancheFinalized(
                        pindex);
         },
     };
 }
 
 static RPCHelpMan sendavalancheproof() {
     return RPCHelpMan{
         "sendavalancheproof",
         "Broadcast an avalanche proof.\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The avalanche proof to broadcast."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the proof was sent successfully or not."},
         RPCExamples{HelpExampleRpc("sendavalancheproof", "<proof>")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!g_avalanche) {
                 throw JSONRPCError(RPC_INTERNAL_ERROR,
                                    "Avalanche is not initialized");
             }
 
             auto proof = RCUPtr<avalanche::Proof>::make();
             NodeContext &node = EnsureAnyNodeContext(request.context);
 
             // Verify the proof. Note that this is redundant with the
             // verification done when adding the proof to the pool, but we get a
             // chance to give a better error message.
             verifyProofOrThrow(node, *proof, request.params[0].get_str());
 
             // Add the proof to the pool if we don't have it already. Since the
             // proof verification has already been done, a failure likely
             // indicates that there already is a proof with conflicting utxos.
             const avalanche::ProofId &proofid = proof->getId();
             avalanche::ProofRegistrationState state;
             if (!registerProofIfNeeded(proof, state)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    strprintf("%s (%s)\n",
                                              state.GetRejectReason(),
                                              state.GetDebugMessage()));
             }
 
             g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
                 pm.addUnbroadcastProof(proofid);
             });
 
             if (node.peerman) {
                 node.peerman->RelayProof(proofid);
             }
 
             return true;
         },
     };
 }
 
 static RPCHelpMan verifyavalancheproof() {
     return RPCHelpMan{
         "verifyavalancheproof",
         "Verify an avalanche proof is valid and return the error otherwise.\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Proof to verify."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the proof is valid or not."},
         RPCExamples{HelpExampleRpc("verifyavalancheproof", "\"<proof>\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR});
 
             avalanche::Proof proof;
             verifyProofOrThrow(EnsureAnyNodeContext(request.context), proof,
                                request.params[0].get_str());
 
             return true;
         },
     };
 }
 
 static RPCHelpMan verifyavalanchedelegation() {
     return RPCHelpMan{
         "verifyavalanchedelegation",
         "Verify an avalanche delegation is valid and return the error "
         "otherwise.\n",
         {
             {"delegation", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The avalanche proof delegation to verify."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the delegation is valid or not."},
         RPCExamples{HelpExampleRpc("verifyavalanchedelegation", "\"<proof>\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR});
 
             avalanche::Delegation delegation;
             CPubKey dummy;
             verifyDelegationOrThrow(delegation, request.params[0].get_str(),
                                     dummy);
 
             return true;
         },
     };
 }
 
 void RegisterAvalancheRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category           actor (function)
         //  -----------------  --------------------
         { "avalanche",         getavalanchekey,           },
         { "avalanche",         addavalanchenode,          },
         { "avalanche",         buildavalancheproof,       },
         { "avalanche",         decodeavalancheproof,      },
         { "avalanche",         delegateavalancheproof,    },
         { "avalanche",         decodeavalanchedelegation, },
         { "avalanche",         getavalancheinfo,          },
         { "avalanche",         getavalanchepeerinfo,      },
         { "avalanche",         getavalancheproofs,        },
         { "avalanche",         getrawavalancheproof,      },
         { "avalanche",         isfinalblock,              },
         { "avalanche",         isfinaltransaction,        },
         { "avalanche",         sendavalancheproof,        },
         { "avalanche",         verifyavalancheproof,      },
         { "avalanche",         verifyavalanchedelegation, },
     };
     // clang-format on
 
     for (const auto &c : commands) {
         t.appendCommand(c.name, &c);
     }
 }
diff --git a/test/functional/abc_rpc_getavalanchepeerinfo.py b/test/functional/abc_rpc_getavalanchepeerinfo.py
index 2ba904639..7371c975b 100755
--- a/test/functional/abc_rpc_getavalanchepeerinfo.py
+++ b/test/functional/abc_rpc_getavalanchepeerinfo.py
@@ -1,95 +1,240 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020-2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the getavalanchepeerinfo RPC."""
 from random import choice
 
 from test_framework.avatools import (
+    AvaP2PInterface,
     avalanche_proof_from_hex,
     create_coinbase_stakes,
+    gen_proof,
     get_ava_p2p_interface_no_handshake,
 )
 from test_framework.key import ECKey
+from test_framework.messages import (
+    NODE_AVALANCHE,
+    NODE_NETWORK,
+    AvalancheVote,
+    AvalancheVoteError,
+)
+from test_framework.p2p import p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, uint256_hex
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_raises_rpc_error,
+    uint256_hex,
+)
 from test_framework.wallet_util import bytes_to_wif
 
+# The interval between avalanche statistics computation
+AVALANCHE_STATISTICS_INTERVAL = 10 * 60
+
+
+class MutedAvaP2PInterface(AvaP2PInterface):
+    def __init__(self, test_framework=None, node=None):
+        super().__init__(test_framework, node)
+        self.is_responding = False
+        self.privkey = None
+        self.addr = None
+        self.poll_received = 0
+
+    def on_avapoll(self, message):
+        self.poll_received += 1
+
+
+class AllYesAvaP2PInterface(MutedAvaP2PInterface):
+    def __init__(self, test_framework=None, node=None):
+        super().__init__(test_framework, node)
+        self.is_responding = True
+
+    def on_avapoll(self, message):
+        self.send_avaresponse(
+            message.poll.round, [
+                AvalancheVote(
+                    AvalancheVoteError.ACCEPTED, inv.hash) for inv in message.poll.invs],
+            self.master_privkey if self.delegation is None else self.delegated_privkey)
+        super().on_avapoll(message)
+
 
 class GetAvalanchePeerInfoTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [['-avaproofstakeutxodustthreshold=1000000',
                             '-avaproofstakeutxoconfirmations=1',
                             '-avacooldown=0']]
 
-    def run_test(self):
+    def test_proofs_and_nodecounts(self):
         node = self.nodes[0]
         peercount = 5
         nodecount = 10
 
         self.log.info(
             f"Generating {peercount} peers with {nodecount} nodes each")
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = self.generatetoaddress(
             node, peercount, addrkey0.address, sync_fun=self.no_op)
         # Use the first coinbase to create a stake
         stakes = create_coinbase_stakes(node, blockhashes, addrkey0.key)
 
         def getProof(stake):
             privkey = ECKey()
             privkey.generate()
             pubkey = privkey.get_pubkey()
 
             proof_sequence = 11
             proof_expiration = 0
             proof = node.buildavalancheproof(
                 proof_sequence, proof_expiration, bytes_to_wif(
                     privkey.get_bytes()),
                 [stake])
             return (pubkey.get_bytes().hex(), proof)
 
         # Create peercount * nodecount node array
         nodes = [[get_ava_p2p_interface_no_handshake(node) for _ in range(
             nodecount)] for _ in range(peercount)]
 
         # Add peercount peers and bind all the nodes to each
         proofs = []
         for i in range(peercount):
             pubkey_hex, proof = getProof(stakes[i])
             proofs.append(proof)
             [node.addavalanchenode(n.nodeid, pubkey_hex, proof)
              for n in nodes[i]]
 
         self.log.info("Testing getavalanchepeerinfo...")
         avapeerinfo = node.getavalanchepeerinfo()
 
         assert_equal(len(avapeerinfo), peercount)
         for i, peer in enumerate(avapeerinfo):
             proofid_hex = uint256_hex(
                 avalanche_proof_from_hex(
                     proofs[i]).proofid)
             assert_equal(peer["avalanche_peerid"], i)
+            assert_equal(peer["availability_score"], 0.0)
             assert_equal(peer["proofid"], proofid_hex)
             assert_equal(peer["proof"], proofs[i])
             assert_equal(peer["nodecount"], nodecount)
             assert_equal(set(peer["node_list"]), set(
                 [n.nodeid for n in nodes[i]]))
 
         self.log.info("Testing with a specified proofid")
 
         assert_raises_rpc_error(-8, "Proofid not found",
                                 node.getavalanchepeerinfo, proofid="0" * 64)
 
         target_proof = choice(proofs)
         target_proofid = avalanche_proof_from_hex(target_proof).proofid
         avapeerinfo = node.getavalanchepeerinfo(
             proofid=uint256_hex(target_proofid))
         assert_equal(len(avapeerinfo), 1)
         assert_equal(avapeerinfo[0]["proof"], target_proof)
 
+    def test_peer_availability_scores(self):
+        self.restart_node(0, extra_args=self.extra_args[0] + [
+            '-avaminquorumstake=0',
+            '-avaminavaproofsnodecount=0',
+        ])
+        node = self.nodes[0]
+
+        # Setup node interfaces, some responsive and some not
+        avanodes = [
+            # First peer has all responsive nodes
+            AllYesAvaP2PInterface(),
+            AllYesAvaP2PInterface(),
+            AllYesAvaP2PInterface(),
+            # Next peer has only one responsive node
+            MutedAvaP2PInterface(),
+            MutedAvaP2PInterface(),
+            AllYesAvaP2PInterface(),
+            # Last peer has no responsive nodes
+            MutedAvaP2PInterface(),
+            MutedAvaP2PInterface(),
+            MutedAvaP2PInterface(),
+        ]
+
+        # Create some proofs and associate the nodes with them
+        avaproofids = []
+        p2p_idx = 0
+        num_proof = 3
+        num_avanode = 3
+        for p in range(num_proof):
+            master_privkey, proof = gen_proof(self, node)
+            avaproofids.append(uint256_hex(proof.proofid))
+            for n in range(num_avanode):
+                avanode = avanodes[p * num_proof + n]
+                avanode.master_privkey = master_privkey
+                avanode.proof = proof
+                node.add_outbound_p2p_connection(
+                    avanode,
+                    p2p_idx=p2p_idx,
+                    connection_type="avalanche",
+                    services=NODE_NETWORK | NODE_AVALANCHE)
+                p2p_idx += 1
+
+        assert_equal(len(avanodes), num_proof * num_avanode)
+
+        def all_nodes_connected():
+            avapeers = node.getavalanchepeerinfo()
+            if len(avapeers) != num_proof:
+                return False
+
+            for avapeer in avapeers:
+                if avapeer['nodecount'] != num_avanode:
+                    return False
+
+            return True
+
+        self.wait_until(all_nodes_connected)
+
+        # Force the availability score to diverge between the responding and the
+        # muted nodes.
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        def poll_all_for_block():
+            with p2p_lock:
+                return all([avanode.poll_received > (
+                    10 if avanode.is_responding else 0) for avanode in avanodes])
+        self.wait_until(poll_all_for_block)
+
+        # Move the scheduler forward so that so that our peers get availability
+        # scores computed.
+        node.mockscheduler(AVALANCHE_STATISTICS_INTERVAL)
+
+        def check_availability_scores():
+            peerinfos = node.getavalanchepeerinfo()
+
+            # Get availability scores for each peer
+            scores = {}
+            for peerinfo in peerinfos:
+                p = avaproofids.index(peerinfo['proofid'])
+                scores[p] = peerinfo['availability_score']
+
+                # Wait until scores have been computed
+                if scores[p] == 0.0:
+                    return False
+
+            # Even though the first peer has more responsive nodes than the second
+            # peer, they will both have "good" scores because overall both peers are
+            # responsive to polls. But the first peer's score won't necessarily be
+            # higher than the second.
+            assert_greater_than(scores[0], 5)
+            assert_greater_than(scores[1], 5)
+
+            # Last peer should have negative score since it is unresponsive
+            assert_greater_than(0.0, scores[2])
+            return True
+
+        self.wait_until(check_availability_scores)
+
+    def run_test(self):
+        self.test_proofs_and_nodecounts()
+        self.test_peer_availability_scores()
+
 
 if __name__ == '__main__':
     GetAvalanchePeerInfoTest().main()