diff --git a/src/avalanche/proof.h b/src/avalanche/proof.h
index 16f1d55d6..a71d809d8 100644
--- a/src/avalanche/proof.h
+++ b/src/avalanche/proof.h
@@ -1,211 +1,211 @@
 // 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_PROOF_H
 #define BITCOIN_AVALANCHE_PROOF_H
 
 #include <amount.h>
 #include <avalanche/proofid.h>
 #include <key.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <rcu.h>
 #include <serialize.h>
 #include <validation.h> // For ChainstateManager and cs_main
 
 #include <array>
 #include <cstdint>
 #include <optional>
 #include <vector>
 
 class ArgsManager;
 struct bilingual_str;
 
 /**
  * How many UTXOs can be used for a single proof.
  */
 static constexpr int AVALANCHE_MAX_PROOF_STAKES = 1000;
 
 /**
  * Whether the legacy proof format should be used by default.
  */
 static constexpr bool AVALANCHE_DEFAULT_LEGACY_PROOF = true;
 
 /**
  * Minimum number of confirmations before a stake utxo is mature enough to be
  * included into a proof.
  */
 static constexpr int AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS = 2016;
 
 namespace avalanche {
 
 /** Minimum amount per utxo */
-static constexpr Amount PROOF_DUST_THRESHOLD = 1 * COIN;
+static constexpr Amount PROOF_DUST_THRESHOLD = 100 * COIN;
 
 class ProofValidationState;
 
 using StakeId = uint256;
 
 struct StakeCommitment : public uint256 {
     explicit StakeCommitment() : uint256() {}
     explicit StakeCommitment(const uint256 &b) : uint256(b) {}
     StakeCommitment(const ProofId &proofid, int64_t expirationTime,
                     const CPubKey &master);
 };
 
 class Stake {
     COutPoint utxo;
 
     Amount amount;
     uint32_t height;
     CPubKey pubkey;
 
     StakeId stakeid;
     void computeStakeId();
 
 public:
     explicit Stake() = default;
     Stake(COutPoint utxo_, Amount amount_, uint32_t height_, bool is_coinbase,
           CPubKey pubkey_)
         : utxo(utxo_), amount(amount_), height(height_ << 1 | is_coinbase),
           pubkey(std::move(pubkey_)) {
         computeStakeId();
     }
 
     SERIALIZE_METHODS(Stake, obj) {
         READWRITE(obj.utxo, obj.amount, obj.height, obj.pubkey);
         SER_READ(obj, obj.computeStakeId());
     }
 
     const COutPoint &getUTXO() const { return utxo; }
     Amount getAmount() const { return amount; }
     uint32_t getHeight() const { return height >> 1; }
     bool isCoinbase() const { return height & 1; }
     const CPubKey &getPubkey() const { return pubkey; }
 
     uint256 getHash(const StakeCommitment &commitment) const;
 
     const StakeId &getId() const { return stakeid; }
 };
 
 class SignedStake {
     Stake stake;
     SchnorrSig sig;
 
 public:
     explicit SignedStake() = default;
     SignedStake(Stake stake_, SchnorrSig sig_)
         : stake(std::move(stake_)), sig(std::move(sig_)) {}
 
     SERIALIZE_METHODS(SignedStake, obj) { READWRITE(obj.stake, obj.sig); }
 
     const Stake &getStake() const { return stake; }
     const SchnorrSig &getSignature() const { return sig; }
 
     bool verify(const StakeCommitment &commitment) const;
 };
 
 class Proof {
     uint64_t sequence;
     int64_t expirationTime;
     CPubKey master;
     std::vector<SignedStake> stakes;
     CScript payoutScriptPubKey;
     SchnorrSig signature;
 
     LimitedProofId limitedProofId;
     ProofId proofid;
     void computeProofId();
 
     uint32_t score;
     void computeScore();
 
     IMPLEMENT_RCU_REFCOUNT(uint64_t);
 
 public:
     Proof()
         : sequence(0), expirationTime(0), master(), stakes(),
           payoutScriptPubKey(CScript()), limitedProofId(), proofid() {}
 
     Proof(uint64_t sequence_, int64_t expirationTime_, CPubKey master_,
           std::vector<SignedStake> stakes_, const CScript &payoutScriptPubKey_,
           SchnorrSig signature_)
         : sequence(sequence_), expirationTime(expirationTime_),
           master(std::move(master_)), stakes(std::move(stakes_)),
           payoutScriptPubKey(payoutScriptPubKey_),
           signature(std::move(signature_)) {
         computeProofId();
         computeScore();
     }
     Proof(Proof &&other)
         : sequence(other.sequence), expirationTime(other.expirationTime),
           master(std::move(other.master)), stakes(std::move(other.stakes)),
           payoutScriptPubKey(std::move(other.payoutScriptPubKey)),
           signature(std::move(other.signature)),
           limitedProofId(std::move(other.limitedProofId)),
           proofid(std::move(other.proofid)), score(other.score) {}
 
     /**
      * Deserialization constructor.
      */
     template <typename Stream> Proof(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 
     SERIALIZE_METHODS(Proof, obj) {
         READWRITE(obj.sequence, obj.expirationTime, obj.master, obj.stakes);
         if (!useLegacy()) {
             READWRITE(obj.payoutScriptPubKey, obj.signature);
         }
         SER_READ(obj, obj.computeProofId());
         SER_READ(obj, obj.computeScore());
     }
 
     static bool useLegacy();
     static bool useLegacy(const ArgsManager &argsman);
 
     static bool FromHex(Proof &proof, const std::string &hexProof,
                         bilingual_str &errorOut);
     std::string ToHex() const;
 
     static uint32_t amountToScore(Amount amount);
 
     uint64_t getSequence() const { return sequence; }
     int64_t getExpirationTime() const { return expirationTime; }
     const CPubKey &getMaster() const { return master; }
     const std::vector<SignedStake> &getStakes() const { return stakes; }
     const CScript &getPayoutScript() const { return payoutScriptPubKey; }
     std::optional<const SchnorrSig> getSignature() const {
         return useLegacy() ? std::nullopt : std::make_optional(signature);
     }
 
     const ProofId &getId() const { return proofid; }
     const LimitedProofId &getLimitedId() const { return limitedProofId; }
     const StakeCommitment getStakeCommitment() const {
         return StakeCommitment(proofid, expirationTime, master);
     };
     uint32_t getScore() const { return score; }
     Amount getStakedAmount() const;
 
     bool verify(const Amount &stakeUtxoDustThreshold,
                 ProofValidationState &state) const;
     bool verify(const Amount &stakeUtxoDustThreshold,
                 const ChainstateManager &chainman,
                 ProofValidationState &state) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 };
 
 using ProofRef = RCUPtr<const Proof>;
 
 class SaltedProofHasher : private SaltedUint256Hasher {
 public:
     SaltedProofHasher() : SaltedUint256Hasher() {}
     size_t operator()(const ProofRef &proof) const {
         return hash(proof->getId());
     }
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PROOF_H
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
index b1533f6dc..33f546e65 100644
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -1,2056 +1,2056 @@
 // 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/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(CChainState &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(CChainState &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);
         for (const auto &outpoint : outpoints) {
             BOOST_CHECK(pb.addUTXO(std::get<0>(outpoint), std::get<1>(outpoint),
                                    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(CChainState &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;
 
     CChainState &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);
 
     CChainState &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(), 400);
+    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(), 400);
-    BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
+    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(), 100);
+    BOOST_CHECK_EQUAL(pm.compact(), 10000);
     BOOST_CHECK(pm.verify());
-    BOOST_CHECK_EQUAL(pm.getSlotCount(), 300);
+    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(), 700);
+    BOOST_CHECK_EQUAL(pm.getSlotCount(), 70000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     BOOST_CHECK(pm.removePeer(peerids[0]));
-    BOOST_CHECK_EQUAL(pm.getSlotCount(), 700);
-    BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
+    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(), 600);
-    BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
+    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(), 100);
+    BOOST_CHECK_EQUAL(pm.compact(), 10000);
     BOOST_CHECK(pm.verify());
-    BOOST_CHECK_EQUAL(pm.getSlotCount(), 500);
+    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(), 300);
-    BOOST_CHECK_EQUAL(pm.getFragmentation(), 300);
+    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(), 300);
+    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);
 
     CChainState &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);
 
     CChainState &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));
     }
 
     // Orphan the proof by reorging to a shorter chain that makes the proof
     // immature
     {
         BlockValidationState state;
         chainman.ActiveChainstate().InvalidateBlock(GetConfig(), state,
                                                     chainman.ActiveTip());
         BOOST_CHECK_EQUAL(chainman.ActiveHeight(), 99);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(pm.isOrphan(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.isOrphan(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());
         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(orphan_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 registerOrphan = [&](const ProofRef &proof) {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proof, state));
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::ORPHAN);
     };
 
     auto checkOrphan = [&](const ProofRef &proof, bool expectedOrphan) {
         const ProofId &proofid = proof->getId();
         BOOST_CHECK(pm.exists(proofid));
 
         BOOST_CHECK_EQUAL(pm.isOrphan(proofid), expectedOrphan);
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(proofid), !expectedOrphan);
 
         bool ret = false;
         pm.forEachPeer([&](const Peer &peer) {
             if (proof->getId() == peer.proof->getId()) {
                 ret = true;
             }
         });
         BOOST_CHECK_EQUAL(ret, !expectedOrphan);
     };
 
     // Track orphans so we can test them later
     std::vector<ProofRef> orphans;
 
     // Fill up orphan pool to test the size limit
     for (int64_t i = 1; i <= AVALANCHE_MAX_ORPHAN_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);
         registerOrphan(proof);
         checkOrphan(proof, true);
         orphans.push_back(proof);
     }
 
     // More orphans 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);
         registerOrphan(proof);
         checkOrphan(proof, true);
         orphans.push_back(proof);
         BOOST_CHECK(!pm.exists(orphans.front()->getId()));
         orphans.erase(orphans.begin());
     }
 
     // Replacement when the pool is full still works
     {
         const COutPoint &outpoint =
             orphans.front()->getStakes()[0].getStake().getUTXO();
         auto proof =
             buildProofWithOutpoints(key, {outpoint}, 101 * PROOF_DUST_THRESHOLD,
                                     key, 1, immatureHeight);
         registerOrphan(proof);
         checkOrphan(proof, true);
         orphans.push_back(proof);
         BOOST_CHECK(!pm.exists(orphans.front()->getId()));
         orphans.erase(orphans.begin());
     }
 
     // Mine a block to increase the chain height, making all orphans mature
     mineBlocks(1);
     pm.updatedBlockTip();
     for (const auto &proof : orphans) {
         checkOrphan(proof, false);
     }
 }
 
 BOOST_AUTO_TEST_CASE(dangling_node) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     CChainState &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(
         "96527eae083f1f24625f049d9e54bb9a2102a93d98bf42ab90cfc0bf9e7c634ed76a7"
         "3e95b02cacfd357b64e4fb6c92e92dd00");
     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();
 
     CChainState &active_chainstate = chainman.ActiveChainstate();
 
     const COutPoint conflictingOutpoint = createUtxo(active_chainstate, key);
     const COutPoint outpointToSend = createUtxo(active_chainstate, key);
 
     const Amount amount = PROOF_DUST_THRESHOLD;
 
     ProofRef proofToInvalidate = buildProofWithOutpoints(
         key, {conflictingOutpoint, outpointToSend}, amount);
     BOOST_CHECK(pm.registerProof(proofToInvalidate));
 
     ProofRef conflictingProof = buildProofWithOutpoints(
         key, {conflictingOutpoint, createUtxo(active_chainstate, key)}, amount);
     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);
     CChainState &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);
 
     gArgs.ForceSetArg("-enableavalancheproofreplacement", "1");
 
     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());
     }
 
     gArgs.ClearForcedArg("-enableavalancheproofreplacement");
 }
 
 BOOST_AUTO_TEST_CASE(conflicting_orphans) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     CChainState &active_chainstate = chainman.ActiveChainstate();
 
     const COutPoint conflictingOutpoint = createUtxo(active_chainstate, key);
     const COutPoint matureOutpoint =
         createUtxo(active_chainstate, key, PROOF_DUST_THRESHOLD, 99);
 
     auto orphan10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto orphan20 =
         buildProofWithSequence(key, {conflictingOutpoint, matureOutpoint}, 20);
 
     BOOST_CHECK(!pm.registerProof(orphan10));
     BOOST_CHECK(pm.isOrphan(orphan10->getId()));
 
     BOOST_CHECK(!pm.registerProof(orphan20));
     BOOST_CHECK(pm.isOrphan(orphan20->getId()));
     BOOST_CHECK(!pm.exists(orphan10->getId()));
 
     // Build and register a valid proof that will conflict with the orphan
     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 orphan proof30
     {
         BlockValidationState state;
         active_chainstate.InvalidateBlock(GetConfig(), state,
                                           chainman.ActiveTip());
         BOOST_CHECK_EQUAL(chainman.ActiveHeight(), 99);
     }
 
     // Check that a rescan will also select the preferred orphan, in this case
     // proof30 will replace orphan20.
     pm.updatedBlockTip();
 
     BOOST_CHECK(!pm.isBoundToPeer(proof30->getId()));
     BOOST_CHECK(pm.isOrphan(proof30->getId()));
     BOOST_CHECK(!pm.exists(orphan20->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 added to conflicting pool
     checkRegistrationFailure(proofSeq40, ProofRegistrationResult::CONFLICTING);
     BOOST_CHECK(pm.isInConflictingPool(proofSeq40->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();
 
     CChainState &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 orphan30 = buildProofWithSequence(
         key, {conflictingOutpoint, immatureOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq20));
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(!pm.registerProof(orphan30));
 
     BOOST_CHECK(pm.isBoundToPeer(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
     BOOST_CHECK(pm.isOrphan(orphan30->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 isOrphan = pm.isOrphan(proofid);
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(!pm.isBoundToPeer(proofid));
         BOOST_CHECK_EQUAL(pm.exists(proofid), !isOrphan);
     };
 
     auto checkRejectInvalidate = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::INVALIDATE));
     };
 
     // Reject from the orphan pool
     checkRejectDefault(orphan30->getId());
     BOOST_CHECK(!pm.registerProof(orphan30));
     BOOST_CHECK(pm.isOrphan(orphan30->getId()));
     checkRejectInvalidate(orphan30->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);
 
     CChainState &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 orphaned
     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.isOrphan(peer1Proof3->getId()));
 
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     auto checkRejectDefault = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         const bool isOrphan = pm.isOrphan(proofid);
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(!pm.isBoundToPeer(proofid));
         BOOST_CHECK_EQUAL(pm.exists(proofid), !isOrphan);
     };
 
     auto checkRejectInvalidate = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::INVALIDATE));
     };
 
     // Reject from the orphan pool doesn't affect tracked score
     checkRejectDefault(peer1Proof3->getId());
     BOOST_CHECK(!pm.registerProof(peer1Proof3));
     BOOST_CHECK(pm.isOrphan(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);
 
     CChainState &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);
 
     gArgs.ForceSetArg("-enableavalancheproofreplacement", "1");
 
     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;
 
     CChainState &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();
 
     gArgs.ClearForcedArg("-enableavalancheproofreplacement");
 }
 
 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);
     gArgs.ForceSetArg("-enableavalancheproofreplacement", "1");
 
     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()));
     }
 
     gArgs.ClearForcedArg("-enableavalancheproofreplacement");
 }
 
 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_SUITE_END()
diff --git a/src/avalanche/test/processor_tests.cpp b/src/avalanche/test/processor_tests.cpp
index 520384297..6d2d8afac 100644
--- a/src/avalanche/test/processor_tests.cpp
+++ b/src/avalanche/test/processor_tests.cpp
@@ -1,1773 +1,1773 @@
 // Copyright (c) 2018-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/processor.h>
 
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/voterecord.h>
 #include <chain.h>
 #include <config.h>
 #include <key_io.h>
 #include <net_processing.h> // For ::PeerManager
 #include <reverse_iterator.h>
 #include <scheduler.h>
 #include <util/time.h>
 #include <util/translation.h> // For bilingual_str
 // D6970 moved LookupBlockIndex from chain.h to validation.h TODO: remove this
 // when LookupBlockIndex is refactored out of validation
 #include <validation.h>
 
 #include <avalanche/test/util.h>
 #include <test/util/setup_common.h>
 
 #include <boost/mpl/list.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <functional>
 #include <type_traits>
 #include <vector>
 
 using namespace avalanche;
 
 namespace avalanche {
 namespace {
     struct AvalancheTest {
         static void runEventLoop(avalanche::Processor &p) { p.runEventLoop(); }
 
         static std::vector<CInv> getInvsForNextPoll(Processor &p) {
             return p.getInvsForNextPoll(false);
         }
 
         static NodeId getSuitableNodeToQuery(Processor &p) {
             return WITH_LOCK(p.cs_peerManager,
                              return p.peerManager->selectNode());
         }
 
         static uint64_t getRound(const Processor &p) { return p.round; }
 
         static uint32_t getMinQuorumScore(const Processor &p) {
             return p.minQuorumScore;
         }
 
         static double getMinQuorumConnectedScoreRatio(const Processor &p) {
             return p.minQuorumConnectedScoreRatio;
         }
 
         static void clearavaproofsNodeCounter(Processor &p) {
             p.avaproofsNodeCounter = 0;
         }
     };
 } // namespace
 } // namespace avalanche
 
 namespace {
 struct CConnmanTest : public CConnman {
     using CConnman::CConnman;
     void AddNode(CNode &node) {
         LOCK(cs_vNodes);
         vNodes.push_back(&node);
     }
     void ClearNodes() {
         LOCK(cs_vNodes);
         for (CNode *node : vNodes) {
             delete node;
         }
         vNodes.clear();
     }
 };
 
 CService ip(uint32_t i) {
     struct in_addr s;
     s.s_addr = i;
     return CService(CNetAddr(s), Params().GetDefaultPort());
 }
 
 struct AvalancheTestingSetup : public TestChain100Setup {
     const ::Config &config;
     CConnmanTest *m_connman;
 
     std::unique_ptr<Processor> m_processor;
 
     // The master private key we delegate to.
     CKey masterpriv;
 
     AvalancheTestingSetup()
         : TestChain100Setup(), config(GetConfig()),
           masterpriv(CKey::MakeCompressedKey()) {
         // Deterministic randomness for tests.
         auto connman = std::make_unique<CConnmanTest>(config, 0x1337, 0x1337);
         m_connman = connman.get();
         m_node.connman = std::move(connman);
         m_node.peerman = ::PeerManager::make(
             config.GetChainParams(), *m_connman, m_node.banman.get(),
             *m_node.scheduler, *m_node.chainman, *m_node.mempool, false);
         m_node.chain = interfaces::MakeChain(m_node, config.GetChainParams());
 
         // Get the processor ready.
         bilingual_str error;
         m_processor = Processor::MakeProcessor(
             *m_node.args, *m_node.chain, m_node.connman.get(),
             *Assert(m_node.chainman), *m_node.scheduler, error);
         BOOST_CHECK(m_processor);
 
         gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "1");
         gArgs.ForceSetArg("-enableavalancheproofreplacement", "1");
     }
 
     ~AvalancheTestingSetup() {
         m_connman->ClearNodes();
         SyncWithValidationInterfaceQueue();
 
         gArgs.ClearForcedArg("-avaproofstakeutxoconfirmations");
         gArgs.ClearForcedArg("-enableavalancheproofreplacement");
     }
 
     CNode *ConnectNode(ServiceFlags nServices) {
         static NodeId id = 0;
 
         CAddress addr(ip(GetRandInt(0xffffffff)), NODE_NONE);
         auto node =
             new CNode(id++, ServiceFlags(NODE_NETWORK), INVALID_SOCKET, addr,
                       /* nKeyedNetGroupIn */ 0,
                       /* nLocalHostNonceIn */ 0,
                       /* nLocalExtraEntropyIn */ 0, CAddress(),
                       /* pszDest */ "", ConnectionType::OUTBOUND_FULL_RELAY,
                       /* inbound_onion */ false);
         node->SetCommonVersion(PROTOCOL_VERSION);
         node->nServices = nServices;
         m_node.peerman->InitializeNode(config, node);
         node->nVersion = 1;
         node->fSuccessfullyConnected = true;
         node->m_avalanche_state = std::make_unique<CNode::AvalancheState>();
 
         m_connman->AddNode(*node);
         return node;
     }
 
     ProofRef GetProof() {
         const CKey key = CKey::MakeCompressedKey();
         const COutPoint outpoint{TxId(GetRandHash()), 0};
         CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
         const Amount amount = PROOF_DUST_THRESHOLD;
         const uint32_t height = 100;
 
         LOCK(cs_main);
         CCoinsViewCache &coins =
             Assert(m_node.chainman)->ActiveChainstate().CoinsTip();
         coins.AddCoin(outpoint, Coin(CTxOut(amount, script), height, false),
                       false);
 
         ProofBuilder pb(0, 0, masterpriv);
         BOOST_CHECK(pb.addUTXO(outpoint, amount, height, false, key));
         return pb.build();
     }
 
     bool addNode(NodeId nodeid, const ProofId &proofid) {
         return m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
             return pm.addNode(nodeid, proofid);
         });
     }
 
     bool addNode(NodeId nodeid) {
         auto proof = GetProof();
         return m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
             return pm.registerProof(proof) &&
                    pm.addNode(nodeid, proof->getId());
         });
     }
 
     std::array<CNode *, 8> ConnectNodes() {
         auto proof = GetProof();
         BOOST_CHECK(
             m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
                 return pm.registerProof(proof);
             }));
         const ProofId &proofid = proof->getId();
 
         std::array<CNode *, 8> nodes;
         for (CNode *&n : nodes) {
             n = ConnectNode(NODE_AVALANCHE);
             BOOST_CHECK(addNode(n->GetId(), proofid));
         }
 
         return nodes;
     }
 
     void runEventLoop() { AvalancheTest::runEventLoop(*m_processor); }
 
     NodeId getSuitableNodeToQuery() {
         return AvalancheTest::getSuitableNodeToQuery(*m_processor);
     }
 
     std::vector<CInv> getInvsForNextPoll() {
         return AvalancheTest::getInvsForNextPoll(*m_processor);
     }
 
     uint64_t getRound() const { return AvalancheTest::getRound(*m_processor); }
 
     bool registerVotes(NodeId nodeid, const avalanche::Response &response,
                        std::vector<avalanche::BlockUpdate> &blockUpdates) {
         int banscore;
         std::string error;
         std::vector<avalanche::ProofUpdate> proofUpdates;
         return m_processor->registerVotes(nodeid, response, blockUpdates,
                                           proofUpdates, banscore, error);
     }
 };
 
 struct BlockProvider {
     AvalancheTestingSetup *fixture;
 
     std::vector<BlockUpdate> updates;
     uint32_t invType;
 
     BlockProvider(AvalancheTestingSetup *_fixture)
         : fixture(_fixture), invType(MSG_BLOCK) {}
 
     CBlockIndex *buildVoteItem() const {
         CBlock block = fixture->CreateAndProcessBlock({}, CScript());
         const BlockHash blockHash = block.GetHash();
 
         LOCK(cs_main);
         return Assert(fixture->m_node.chainman)
             ->m_blockman.LookupBlockIndex(blockHash);
     }
 
     uint256 getVoteItemId(const CBlockIndex *pindex) const {
         return pindex->GetBlockHash();
     }
 
     bool registerVotes(NodeId nodeid, const avalanche::Response &response,
                        std::string &error) {
         int banscore;
         std::vector<avalanche::ProofUpdate> proofUpdates;
         return fixture->m_processor->registerVotes(
             nodeid, response, updates, proofUpdates, banscore, error);
     }
     bool registerVotes(NodeId nodeid, const avalanche::Response &response) {
         std::string error;
         return registerVotes(nodeid, response, error);
     }
 
     bool addToReconcile(const CBlockIndex *pindex) {
         return fixture->m_processor->addBlockToReconcile(pindex);
     }
 
     std::vector<Vote> buildVotesForItems(uint32_t error,
                                          std::vector<CBlockIndex *> &&items) {
         size_t numItems = items.size();
 
         std::vector<Vote> votes;
         votes.reserve(numItems);
 
         // Votes are sorted by most work first
         std::sort(items.begin(), items.end(), CBlockIndexWorkComparator());
         for (auto &item : reverse_iterate(items)) {
             votes.emplace_back(error, item->GetBlockHash());
         }
 
         return votes;
     }
 
     void invalidateItem(CBlockIndex *pindex) {
         pindex->nStatus = pindex->nStatus.withFailed();
     }
 };
 
 struct ProofProvider {
     AvalancheTestingSetup *fixture;
 
     std::vector<ProofUpdate> updates;
     uint32_t invType;
 
     ProofProvider(AvalancheTestingSetup *_fixture)
         : fixture(_fixture), invType(MSG_AVA_PROOF) {}
 
     ProofRef buildVoteItem() const {
         const ProofRef proof = fixture->GetProof();
         fixture->m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
             BOOST_CHECK(pm.registerProof(proof));
         });
         return proof;
     }
 
     uint256 getVoteItemId(const ProofRef &proof) const {
         return proof->getId();
     }
 
     bool registerVotes(NodeId nodeid, const avalanche::Response &response,
                        std::string &error) {
         int banscore;
         std::vector<avalanche::BlockUpdate> blockUpdates;
         return fixture->m_processor->registerVotes(
             nodeid, response, blockUpdates, updates, banscore, error);
     }
     bool registerVotes(NodeId nodeid, const avalanche::Response &response) {
         std::string error;
         return registerVotes(nodeid, response, error);
     }
 
     bool addToReconcile(const ProofRef &proof) {
         return fixture->m_processor->addProofToReconcile(proof);
     }
 
     std::vector<Vote> buildVotesForItems(uint32_t error,
                                          std::vector<ProofRef> &&items) {
         size_t numItems = items.size();
 
         std::vector<Vote> votes;
         votes.reserve(numItems);
 
         // Votes are sorted by high score first
         std::sort(items.begin(), items.end(), ProofComparatorByScore());
         for (auto &item : items) {
             votes.emplace_back(error, item->getId());
         }
 
         return votes;
     }
 
     void invalidateItem(const ProofRef &proof) {
         fixture->m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
             pm.rejectProof(proof->getId(),
                            avalanche::PeerManager::RejectionMode::INVALIDATE);
         });
     }
 };
 
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(processor_tests, AvalancheTestingSetup)
 
 // FIXME A std::tuple can be used instead of boost::mpl::list after boost 1.67
 using VoteItemProviders = boost::mpl::list<BlockProvider, ProofProvider>;
 
 BOOST_AUTO_TEST_CASE(block_update) {
     CBlockIndex index;
     CBlockIndex *pindex = &index;
 
     std::set<VoteStatus> status{
         VoteStatus::Invalid,   VoteStatus::Rejected, VoteStatus::Accepted,
         VoteStatus::Finalized, VoteStatus::Stale,
     };
 
     for (auto s : status) {
         BlockUpdate abu(pindex, s);
         // The use of BOOST_CHECK instead of BOOST_CHECK_EQUAL prevents from
         // having to define operator<<() for each argument type.
         BOOST_CHECK(abu.getVoteItem() == pindex);
         BOOST_CHECK(abu.getStatus() == s);
     }
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(item_reconcile_twice, P, VoteItemProviders) {
     P provider(this);
 
     auto item = provider.buildVoteItem();
 
     // Adding the item twice does nothing.
     BOOST_CHECK(provider.addToReconcile(item));
     BOOST_CHECK(!provider.addToReconcile(item));
     BOOST_CHECK(m_processor->isAccepted(item));
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(item_null, P, VoteItemProviders) {
     P provider(this);
 
     // Check that null case is handled on the public interface
     BOOST_CHECK(!m_processor->isAccepted(nullptr));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(nullptr), -1);
 
     auto item = decltype(provider.buildVoteItem())();
     BOOST_CHECK(item == nullptr);
     BOOST_CHECK(!provider.addToReconcile(item));
 
     // Check that adding item to vote on doesn't change the outcome. A
     // comparator is used under the hood, and this is skipped if there are no
     // vote records.
     item = provider.buildVoteItem();
     BOOST_CHECK(provider.addToReconcile(item));
 
     BOOST_CHECK(!m_processor->isAccepted(nullptr));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(nullptr), -1);
 }
 
 namespace {
 Response next(Response &r) {
     auto copy = r;
     r = {r.getRound() + 1, r.getCooldown(), r.GetVotes()};
     return copy;
 }
 } // namespace
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(vote_item_register, P, VoteItemProviders) {
     P provider(this);
     auto &updates = provider.updates;
     const uint32_t invType = provider.invType;
 
     auto item = provider.buildVoteItem();
     auto itemid = provider.getVoteItemId(item);
 
     // Create nodes that supports avalanche.
     auto avanodes = ConnectNodes();
 
     // Querying for random item returns false.
     BOOST_CHECK(!m_processor->isAccepted(item));
 
     // Add a new item. Check it is added to the polls.
     BOOST_CHECK(provider.addToReconcile(item));
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemid);
 
     BOOST_CHECK(m_processor->isAccepted(item));
 
     int nextNodeIndex = 0;
     auto registerNewVote = [&](const Response &resp) {
         runEventLoop();
         auto nodeid = avanodes[nextNodeIndex++ % avanodes.size()]->GetId();
         BOOST_CHECK(provider.registerVotes(nodeid, resp));
     };
 
     // Let's vote for this item a few times.
     Response resp{0, 0, {Vote(0, itemid)}};
     for (int i = 0; i < 6; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(item));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(item), 0);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // A single neutral vote do not change anything.
     resp = {getRound(), 0, {Vote(-1, itemid)}};
     registerNewVote(next(resp));
     BOOST_CHECK(m_processor->isAccepted(item));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(item), 0);
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     resp = {getRound(), 0, {Vote(0, itemid)}};
     for (int i = 1; i < 7; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(item));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(item), i);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Two neutral votes will stall progress.
     resp = {getRound(), 0, {Vote(-1, itemid)}};
     registerNewVote(next(resp));
     BOOST_CHECK(m_processor->isAccepted(item));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(item), 6);
     BOOST_CHECK_EQUAL(updates.size(), 0);
     registerNewVote(next(resp));
     BOOST_CHECK(m_processor->isAccepted(item));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(item), 6);
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     resp = {getRound(), 0, {Vote(0, itemid)}};
     for (int i = 2; i < 8; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(item));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(item), 6);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // We vote for it numerous times to finalize it.
     for (int i = 7; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(item));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(item), i);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // As long as it is not finalized, we poll.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemid);
 
     // Now finalize the decision.
     registerNewVote(next(resp));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getVoteItem() == item);
     BOOST_CHECK(updates[0].getStatus() == VoteStatus::Finalized);
     updates.clear();
 
     // Once the decision is finalized, there is no poll for it.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 0);
 
     // Get a new item to vote on
     item = provider.buildVoteItem();
     itemid = provider.getVoteItemId(item);
     BOOST_CHECK(provider.addToReconcile(item));
 
     // Now let's finalize rejection.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemid);
 
     resp = {getRound(), 0, {Vote(1, itemid)}};
     for (int i = 0; i < 6; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(item));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Now the state will flip.
     registerNewVote(next(resp));
     BOOST_CHECK(!m_processor->isAccepted(item));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getVoteItem() == item);
     BOOST_CHECK(updates[0].getStatus() == VoteStatus::Rejected);
     updates.clear();
 
     // Now it is rejected, but we can vote for it numerous times.
     for (int i = 1; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(!m_processor->isAccepted(item));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // As long as it is not finalized, we poll.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemid);
 
     // Now finalize the decision.
     registerNewVote(next(resp));
     BOOST_CHECK(!m_processor->isAccepted(item));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getVoteItem() == item);
     BOOST_CHECK(updates[0].getStatus() == VoteStatus::Invalid);
     updates.clear();
 
     // Once the decision is finalized, there is no poll for it.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 0);
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(multi_item_register, P, VoteItemProviders) {
     P provider(this);
     auto &updates = provider.updates;
     const uint32_t invType = provider.invType;
 
     auto itemA = provider.buildVoteItem();
     auto itemidA = provider.getVoteItemId(itemA);
 
     auto itemB = provider.buildVoteItem();
     auto itemidB = provider.getVoteItemId(itemB);
 
     // Create several nodes that support avalanche.
     auto avanodes = ConnectNodes();
 
     // Querying for random item returns false.
     BOOST_CHECK(!m_processor->isAccepted(itemA));
     BOOST_CHECK(!m_processor->isAccepted(itemB));
 
     // Start voting on item A.
     BOOST_CHECK(provider.addToReconcile(itemA));
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemidA);
 
     uint64_t round = getRound();
     runEventLoop();
     BOOST_CHECK(provider.registerVotes(avanodes[0]->GetId(),
                                        {round, 0, {Vote(0, itemidA)}}));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Start voting on item B after one vote.
     std::vector<Vote> votes = provider.buildVotesForItems(0, {itemA, itemB});
     Response resp{round + 1, 0, votes};
     BOOST_CHECK(provider.addToReconcile(itemB));
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 2);
 
     // Ensure the inv ordering is as expected
     for (size_t i = 0; i < invs.size(); i++) {
         BOOST_CHECK_EQUAL(invs[i].type, invType);
         BOOST_CHECK(invs[i].hash == votes[i].GetHash());
     }
 
     // Let's vote for these items a few times.
     for (int i = 0; i < 4; i++) {
         NodeId nodeid = getSuitableNodeToQuery();
         runEventLoop();
         BOOST_CHECK(provider.registerVotes(nodeid, next(resp)));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Now it is accepted, but we can vote for it numerous times.
     for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         NodeId nodeid = getSuitableNodeToQuery();
         runEventLoop();
         BOOST_CHECK(provider.registerVotes(nodeid, next(resp)));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Running two iterration of the event loop so that vote gets triggered on A
     // and B.
     NodeId firstNodeid = getSuitableNodeToQuery();
     runEventLoop();
     NodeId secondNodeid = getSuitableNodeToQuery();
     runEventLoop();
 
     BOOST_CHECK(firstNodeid != secondNodeid);
 
     // Next vote will finalize item A.
     BOOST_CHECK(provider.registerVotes(firstNodeid, next(resp)));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getVoteItem() == itemA);
     BOOST_CHECK(updates[0].getStatus() == VoteStatus::Finalized);
     updates = {};
 
     // We do not vote on A anymore.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemidB);
 
     // Next vote will finalize item B.
     BOOST_CHECK(provider.registerVotes(secondNodeid, resp));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getVoteItem() == itemB);
     BOOST_CHECK(updates[0].getStatus() == VoteStatus::Finalized);
     updates = {};
 
     // There is nothing left to vote on.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 0);
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(poll_and_response, P, VoteItemProviders) {
     P provider(this);
     auto &updates = provider.updates;
     const uint32_t invType = provider.invType;
 
     auto item = provider.buildVoteItem();
     auto itemid = provider.getVoteItemId(item);
 
     // There is no node to query.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);
 
     // Add enough nodes to have a valid quorum, and the same amount with no
     // avalanche support
     std::set<NodeId> avanodeIds;
     auto avanodes = ConnectNodes();
     for (auto avanode : avanodes) {
         ConnectNode(NODE_NONE);
         avanodeIds.insert(avanode->GetId());
     }
 
     auto getSelectedAvanodeId = [&]() {
         NodeId avanodeid = getSuitableNodeToQuery();
         BOOST_CHECK(avanodeIds.find(avanodeid) != avanodeIds.end());
         return avanodeid;
     };
 
     // It returns one of the avalanche peer.
     NodeId avanodeid = getSelectedAvanodeId();
 
     // Register an item and check it is added to the list of elements to poll.
     BOOST_CHECK(provider.addToReconcile(item));
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemid);
 
     std::set<NodeId> unselectedNodeids = avanodeIds;
     unselectedNodeids.erase(avanodeid);
     const size_t remainingNodeIds = unselectedNodeids.size();
 
     uint64_t round = getRound();
     for (size_t i = 0; i < remainingNodeIds; i++) {
         // Trigger a poll on avanode.
         runEventLoop();
 
         // Another node is selected
         NodeId nodeid = getSuitableNodeToQuery();
         BOOST_CHECK(unselectedNodeids.find(nodeid) != avanodeIds.end());
         unselectedNodeids.erase(nodeid);
     }
 
     // There is no more suitable peer available, so return nothing.
     BOOST_CHECK(unselectedNodeids.empty());
     runEventLoop();
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);
 
     // Respond to the request.
     Response resp = {round, 0, {Vote(0, itemid)}};
     BOOST_CHECK(provider.registerVotes(avanodeid, resp));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Now that avanode fullfilled his request, it is added back to the list of
     // queriable nodes.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     auto checkRegisterVotesError = [&](NodeId nodeid,
                                        const avalanche::Response &response,
                                        const std::string &expectedError) {
         std::string error;
         BOOST_CHECK(!provider.registerVotes(nodeid, response, error));
         BOOST_CHECK_EQUAL(error, expectedError);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     };
 
     // Sending a response when not polled fails.
     checkRegisterVotesError(avanodeid, next(resp), "unexpected-ava-response");
 
     // Trigger a poll on avanode.
     round = getRound();
     runEventLoop();
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);
 
     // Sending responses that do not match the request also fails.
     // 1. Too many results.
     resp = {round, 0, {Vote(0, itemid), Vote(0, itemid)}};
     runEventLoop();
     checkRegisterVotesError(avanodeid, resp, "invalid-ava-response-size");
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // 2. Not enough results.
     resp = {getRound(), 0, {}};
     runEventLoop();
     checkRegisterVotesError(avanodeid, resp, "invalid-ava-response-size");
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // 3. Do not match the poll.
     resp = {getRound(), 0, {Vote()}};
     runEventLoop();
     checkRegisterVotesError(avanodeid, resp, "invalid-ava-response-content");
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // At this stage we have reached the max inflight requests for our inv, so
     // it won't be requested anymore until the requests are fullfilled. Let's
     // vote on another item with no inflight request so the remaining tests
     // makes sense.
     invs = getInvsForNextPoll();
     BOOST_CHECK(invs.empty());
 
     item = provider.buildVoteItem();
     itemid = provider.getVoteItemId(item);
     BOOST_CHECK(provider.addToReconcile(item));
 
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
 
     // 4. Invalid round count. Request is not discarded.
     uint64_t queryRound = getRound();
     runEventLoop();
 
     resp = {queryRound + 1, 0, {Vote()}};
     checkRegisterVotesError(avanodeid, resp, "unexpected-ava-response");
 
     resp = {queryRound - 1, 0, {Vote()}};
     checkRegisterVotesError(avanodeid, resp, "unexpected-ava-response");
 
     // 5. Making request for invalid nodes do not work. Request is not
     // discarded.
     resp = {queryRound, 0, {Vote(0, itemid)}};
     checkRegisterVotesError(avanodeid + 1234, resp, "unexpected-ava-response");
 
     // Proper response gets processed and avanode is available again.
     resp = {queryRound, 0, {Vote(0, itemid)}};
     BOOST_CHECK(provider.registerVotes(avanodeid, resp));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // Out of order response are rejected.
     const auto item2 = provider.buildVoteItem();
     BOOST_CHECK(provider.addToReconcile(item2));
 
     std::vector<Vote> votes = provider.buildVotesForItems(0, {item, item2});
     resp = {getRound(), 0, {votes[1], votes[0]}};
     runEventLoop();
     checkRegisterVotesError(avanodeid, resp, "invalid-ava-response-content");
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // But they are accepted in order.
     resp = {getRound(), 0, votes};
     runEventLoop();
     BOOST_CHECK(provider.registerVotes(avanodeid, resp));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(dont_poll_invalid_item, P, VoteItemProviders) {
     P provider(this);
     auto &updates = provider.updates;
     const uint32_t invType = provider.invType;
 
     auto itemA = provider.buildVoteItem();
     auto itemB = provider.buildVoteItem();
 
     auto avanodes = ConnectNodes();
 
     // Build votes to get proper ordering
     std::vector<Vote> votes = provider.buildVotesForItems(0, {itemA, itemB});
 
     // Register the items and check they are added to the list of elements to
     // poll.
     BOOST_CHECK(provider.addToReconcile(itemA));
     BOOST_CHECK(provider.addToReconcile(itemB));
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 2);
     for (size_t i = 0; i < invs.size(); i++) {
         BOOST_CHECK_EQUAL(invs[i].type, invType);
         BOOST_CHECK(invs[i].hash == votes[i].GetHash());
     }
 
     // When an item is marked invalid, stop polling.
     provider.invalidateItem(itemB);
 
     Response goodResp{getRound(), 0, {Vote(0, provider.getVoteItemId(itemA))}};
     runEventLoop();
     BOOST_CHECK(provider.registerVotes(avanodes[0]->GetId(), goodResp));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Votes including itemB are rejected
     Response badResp{getRound(), 0, votes};
     runEventLoop();
     std::string error;
     BOOST_CHECK(!provider.registerVotes(avanodes[1]->GetId(), badResp, error));
     BOOST_CHECK_EQUAL(error, "invalid-ava-response-size");
 }
 
 BOOST_TEST_DECORATOR(*boost::unit_test::timeout(60))
 BOOST_AUTO_TEST_CASE_TEMPLATE(poll_inflight_timeout, P, VoteItemProviders) {
     P provider(this);
     ArgsManager argsman;
     ChainstateManager &chainman = *Assert(m_node.chainman);
 
     auto queryTimeDuration = std::chrono::milliseconds(10);
     argsman.ForceSetArg("-avatimeout", ToString(queryTimeDuration.count()));
 
     bilingual_str error;
     m_processor =
         Processor::MakeProcessor(argsman, *m_node.chain, m_node.connman.get(),
                                  chainman, *m_node.scheduler, error);
 
     const auto item = provider.buildVoteItem();
     const auto itemid = provider.getVoteItemId(item);
 
     // Add the item
     BOOST_CHECK(provider.addToReconcile(item));
 
     // Create a quorum of nodes that support avalanche.
     ConnectNodes();
     NodeId avanodeid = NO_NODE;
 
     // Expire requests after some time.
     for (int i = 0; i < 10; i++) {
         Response resp = {getRound(), 0, {Vote(0, itemid)}};
         avanodeid = getSuitableNodeToQuery();
 
         auto start = std::chrono::steady_clock::now();
         runEventLoop();
         // We cannot guarantee that we'll wait for just 1ms, so we have to bail
         // if we aren't within the proper time range.
         std::this_thread::sleep_for(std::chrono::milliseconds(1));
         runEventLoop();
 
         bool ret = provider.registerVotes(avanodeid, next(resp));
         if (std::chrono::steady_clock::now() > start + queryTimeDuration) {
             // We waited for too long, bail. Because we can't know for sure when
             // previous steps ran, ret is not deterministic and we do not check
             // it.
             i--;
             continue;
         }
 
         // We are within time bounds, so the vote should have worked.
         BOOST_CHECK(ret);
 
         avanodeid = getSuitableNodeToQuery();
 
         // Now try again but wait for expiration.
         runEventLoop();
         std::this_thread::sleep_for(queryTimeDuration);
         runEventLoop();
         BOOST_CHECK(!provider.registerVotes(avanodeid, next(resp)));
     }
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(poll_inflight_count, P, VoteItemProviders) {
     P provider(this);
     const uint32_t invType = provider.invType;
 
     // Create enough nodes so that we run into the inflight request limit.
     auto proof = GetProof();
     BOOST_CHECK(m_processor->withPeerManager(
         [&](avalanche::PeerManager &pm) { return pm.registerProof(proof); }));
 
     std::array<CNode *, AVALANCHE_MAX_INFLIGHT_POLL + 1> nodes;
     for (auto &n : nodes) {
         n = ConnectNode(NODE_AVALANCHE);
         BOOST_CHECK(addNode(n->GetId(), proof->getId()));
     }
 
     // Add an item to poll
     const auto item = provider.buildVoteItem();
     const auto itemid = provider.getVoteItemId(item);
     BOOST_CHECK(provider.addToReconcile(item));
 
     // Ensure there are enough requests in flight.
     std::map<NodeId, uint64_t> node_round_map;
     for (int i = 0; i < AVALANCHE_MAX_INFLIGHT_POLL; i++) {
         NodeId nodeid = getSuitableNodeToQuery();
         BOOST_CHECK(node_round_map.find(nodeid) == node_round_map.end());
         node_round_map.insert(std::pair<NodeId, uint64_t>(nodeid, getRound()));
         auto invs = getInvsForNextPoll();
         BOOST_CHECK_EQUAL(invs.size(), 1);
         BOOST_CHECK_EQUAL(invs[0].type, invType);
         BOOST_CHECK(invs[0].hash == itemid);
         runEventLoop();
     }
 
     // Now that we have enough in flight requests, we shouldn't poll.
     auto suitablenodeid = getSuitableNodeToQuery();
     BOOST_CHECK(suitablenodeid != NO_NODE);
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 0);
     runEventLoop();
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), suitablenodeid);
 
     // Send one response, now we can poll again.
     auto it = node_round_map.begin();
     Response resp = {it->second, 0, {Vote(0, itemid)}};
     BOOST_CHECK(provider.registerVotes(it->first, resp));
     node_round_map.erase(it);
 
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, invType);
     BOOST_CHECK(invs[0].hash == itemid);
 }
 
 BOOST_AUTO_TEST_CASE(quorum_diversity) {
     std::vector<BlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHash = block.GetHash();
     const CBlockIndex *pindex;
     {
         LOCK(cs_main);
         pindex =
             Assert(m_node.chainman)->m_blockman.LookupBlockIndex(blockHash);
     }
 
     // Create nodes that supports avalanche.
     auto avanodes = ConnectNodes();
 
     // Querying for random block returns false.
     BOOST_CHECK(!m_processor->isAccepted(pindex));
 
     // Add a new block. Check it is added to the polls.
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
 
     // Do one valid round of voting.
     uint64_t round = getRound();
     Response resp{round, 0, {Vote(0, blockHash)}};
 
     // Check that all nodes can vote.
     for (size_t i = 0; i < avanodes.size(); i++) {
         runEventLoop();
         BOOST_CHECK(registerVotes(avanodes[i]->GetId(), next(resp), updates));
     }
 
     // Generate a query for every single node.
     const NodeId firstNodeId = getSuitableNodeToQuery();
     std::map<NodeId, uint64_t> node_round_map;
     round = getRound();
     for (size_t i = 0; i < avanodes.size(); i++) {
         NodeId nodeid = getSuitableNodeToQuery();
         BOOST_CHECK(node_round_map.find(nodeid) == node_round_map.end());
         node_round_map[nodeid] = getRound();
         runEventLoop();
     }
 
     // Now only the first node can vote. All others would be duplicate in the
     // quorum.
     auto confidence = m_processor->getConfidence(pindex);
     BOOST_REQUIRE(confidence > 0);
 
     for (auto &[nodeid, r] : node_round_map) {
         if (nodeid == firstNodeId) {
             // Node 0 is the only one which can vote at this stage.
             round = r;
             continue;
         }
 
         BOOST_CHECK(
             registerVotes(nodeid, {r, 0, {Vote(0, blockHash)}}, updates));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), confidence);
     }
 
     BOOST_CHECK(
         registerVotes(firstNodeId, {round, 0, {Vote(0, blockHash)}}, updates));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), confidence + 1);
 }
 
 BOOST_AUTO_TEST_CASE(event_loop) {
     CScheduler s;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHash = block.GetHash();
     const CBlockIndex *pindex;
     {
         LOCK(cs_main);
         pindex =
             Assert(m_node.chainman)->m_blockman.LookupBlockIndex(blockHash);
     }
 
     // Starting the event loop.
     BOOST_CHECK(m_processor->startEventLoop(s));
 
     // There is one task planned in the next hour (our event loop).
     std::chrono::system_clock::time_point start, stop;
     BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 1);
 
     // Starting twice doesn't start it twice.
     BOOST_CHECK(!m_processor->startEventLoop(s));
 
     // Start the scheduler thread.
     std::thread schedulerThread(std::bind(&CScheduler::serviceQueue, &s));
 
     // Create a quorum of nodes that support avalanche.
     auto avanodes = ConnectNodes();
 
     // There is no query in flight at the moment.
     NodeId nodeid = getSuitableNodeToQuery();
     BOOST_CHECK_NE(nodeid, NO_NODE);
 
     // Add a new block. Check it is added to the polls.
     uint64_t queryRound = getRound();
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
 
     // Wait until all nodes got a poll
     for (int i = 0; i < 60 * 1000; i++) {
         // Technically, this is a race condition, but this should do just fine
         // as we wait up to 1 minute for an event that should take 80ms.
         UninterruptibleSleep(std::chrono::milliseconds(1));
         if (getRound() == queryRound + avanodes.size()) {
             break;
         }
     }
 
     // Check that we effectively got a request and not timed out.
     BOOST_CHECK(getRound() > queryRound);
 
     // Respond and check the cooldown time is respected.
     uint64_t responseRound = getRound();
     auto queryTime =
         std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
 
     std::vector<BlockUpdate> updates;
     // Only the first node answers, so it's the only one that gets polled again
     registerVotes(nodeid, {queryRound, 100, {Vote(0, blockHash)}}, updates);
 
     for (int i = 0; i < 10000; i++) {
         // We make sure that we do not get a request before queryTime.
         UninterruptibleSleep(std::chrono::milliseconds(1));
         if (getRound() != responseRound) {
             BOOST_CHECK(std::chrono::steady_clock::now() > queryTime);
             break;
         }
     }
 
     // But we eventually get one.
     BOOST_CHECK(getRound() > responseRound);
 
     // Stop event loop.
     BOOST_CHECK(m_processor->stopEventLoop());
 
     // We don't have any task scheduled anymore.
     BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 0);
 
     // Can't stop the event loop twice.
     BOOST_CHECK(!m_processor->stopEventLoop());
 
     // Wait for the scheduler to stop.
     s.StopWhenDrained();
     schedulerThread.join();
 }
 
 BOOST_AUTO_TEST_CASE(destructor) {
     CScheduler s;
     std::chrono::system_clock::time_point start, stop;
 
     std::thread schedulerThread;
     BOOST_CHECK(m_processor->startEventLoop(s));
     BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 1);
 
     // Start the service thread after the queue size check to prevent a race
     // condition where the thread may be processing the event loop task during
     // the check.
     schedulerThread = std::thread(std::bind(&CScheduler::serviceQueue, &s));
 
     // Destroy the processor.
     m_processor.reset();
 
     // Now that avalanche is destroyed, there is no more scheduled tasks.
     BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 0);
 
     // Wait for the scheduler to stop.
     s.StopWhenDrained();
     schedulerThread.join();
 }
 
 BOOST_AUTO_TEST_CASE(add_proof_to_reconcile) {
     uint32_t score = MIN_VALID_PROOF_SCORE;
     CChainState &active_chainstate =
         Assert(m_node.chainman)->ActiveChainstate();
 
     auto addProofToReconcile = [&](uint32_t proofScore) {
         auto proof = buildRandomProof(active_chainstate, proofScore);
         m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
             BOOST_CHECK(pm.registerProof(proof));
         });
         BOOST_CHECK(m_processor->addProofToReconcile(proof));
         return proof;
     };
 
     for (size_t i = 0; i < AVALANCHE_MAX_ELEMENT_POLL; i++) {
         auto proof = addProofToReconcile(++score);
 
         auto invs = AvalancheTest::getInvsForNextPoll(*m_processor);
         BOOST_CHECK_EQUAL(invs.size(), i + 1);
         BOOST_CHECK(invs.front().IsMsgProof());
         BOOST_CHECK_EQUAL(invs.front().hash, proof->getId());
     }
 
     // From here a new proof is only polled if its score is in the top
     // AVALANCHE_MAX_ELEMENT_POLL
     ProofId lastProofId;
     for (size_t i = 0; i < 10; i++) {
         auto proof = addProofToReconcile(++score);
 
         auto invs = AvalancheTest::getInvsForNextPoll(*m_processor);
         BOOST_CHECK_EQUAL(invs.size(), AVALANCHE_MAX_ELEMENT_POLL);
         BOOST_CHECK(invs.front().IsMsgProof());
         BOOST_CHECK_EQUAL(invs.front().hash, proof->getId());
 
         lastProofId = proof->getId();
     }
 
     for (size_t i = 0; i < 10; i++) {
         auto proof = addProofToReconcile(--score);
 
         auto invs = AvalancheTest::getInvsForNextPoll(*m_processor);
         BOOST_CHECK_EQUAL(invs.size(), AVALANCHE_MAX_ELEMENT_POLL);
         BOOST_CHECK(invs.front().IsMsgProof());
         BOOST_CHECK_EQUAL(invs.front().hash, lastProofId);
     }
 
     {
         // The score is not high enough to get polled
         auto proof = addProofToReconcile(--score);
         auto invs = AvalancheTest::getInvsForNextPoll(*m_processor);
         for (auto &inv : invs) {
             BOOST_CHECK_NE(inv.hash, proof->getId());
         }
     }
 
     {
         // If proof replacement is not enabled there is no point polling for the
         // proof.
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
             BOOST_CHECK(pm.registerProof(proof));
         });
 
         gArgs.ForceSetArg("-enableavalancheproofreplacement", "0");
         BOOST_CHECK(!m_processor->addProofToReconcile(proof));
 
         gArgs.ForceSetArg("-enableavalancheproofreplacement", "1");
         BOOST_CHECK(m_processor->addProofToReconcile(proof));
 
         gArgs.ClearForcedArg("-enableavalancheproofreplacement");
     }
 }
 
 BOOST_AUTO_TEST_CASE(proof_record) {
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     gArgs.ForceSetArg("-avalancheconflictingproofcooldown", "0");
 
     BOOST_CHECK(!m_processor->isAccepted(nullptr));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(nullptr), -1);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint{TxId(GetRandHash()), 0};
     const COutPoint immatureOutpoint{TxId(GetRandHash()), 0};
     {
         CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
         LOCK(cs_main);
         CCoinsViewCache &coins =
             Assert(m_node.chainman)->ActiveChainstate().CoinsTip();
         coins.AddCoin(conflictingOutpoint,
                       Coin(CTxOut(PROOF_DUST_THRESHOLD, script), 10, false),
                       false);
         coins.AddCoin(immatureOutpoint,
                       Coin(CTxOut(PROOF_DUST_THRESHOLD, script), 100, false),
                       false);
     }
 
     auto buildProof = [&](const COutPoint &outpoint, uint64_t sequence,
                           uint32_t height = 10) {
         ProofBuilder pb(sequence, 0, key);
         BOOST_CHECK(
             pb.addUTXO(outpoint, PROOF_DUST_THRESHOLD, height, false, key));
         return pb.build();
     };
 
     auto conflictingProof = buildProof(conflictingOutpoint, 1);
     auto validProof = buildProof(conflictingOutpoint, 2);
     auto orphanProof = buildProof(immatureOutpoint, 3, 100);
 
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(!m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(orphanProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), -1);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), -1);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(orphanProof), -1);
 
     // Reconciling proofs that don't exist will fail
     BOOST_CHECK(!m_processor->addProofToReconcile(conflictingProof));
     BOOST_CHECK(!m_processor->addProofToReconcile(validProof));
     BOOST_CHECK(!m_processor->addProofToReconcile(orphanProof));
 
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK(pm.registerProof(conflictingProof));
         BOOST_CHECK(pm.registerProof(validProof));
         BOOST_CHECK(!pm.registerProof(orphanProof));
 
         BOOST_CHECK(pm.isBoundToPeer(validProof->getId()));
         BOOST_CHECK(pm.isInConflictingPool(conflictingProof->getId()));
         BOOST_CHECK(pm.isOrphan(orphanProof->getId()));
     });
 
     BOOST_CHECK(m_processor->addProofToReconcile(conflictingProof));
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(!m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(orphanProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), -1);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(orphanProof), -1);
 
     BOOST_CHECK(m_processor->addProofToReconcile(validProof));
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(orphanProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(orphanProof), -1);
 
     BOOST_CHECK(!m_processor->addProofToReconcile(orphanProof));
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(orphanProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(orphanProof), -1);
 
     gArgs.ClearForcedArg("-avaproofstakeutxoconfirmations");
     gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
 }
 
 BOOST_AUTO_TEST_CASE(quorum_detection) {
     // Set min quorum parameters for our test
-    int minStake = 4'000'000;
+    int minStake = 400'000'000;
     gArgs.ForceSetArg("-avaminquorumstake", ToString(minStake));
     gArgs.ForceSetArg("-avaminquorumconnectedstakeratio", "0.5");
 
     // Create a new processor with our given quorum parameters
     const auto currency = Currency::get();
     uint32_t minScore = Proof::amountToScore(minStake * currency.baseunit);
 
     CChainState &active_chainstate =
         Assert(m_node.chainman)->ActiveChainstate();
 
     const CKey key = CKey::MakeCompressedKey();
     auto localProof =
         buildRandomProof(active_chainstate, minScore / 4, 100, key);
     gArgs.ForceSetArg("-avamasterkey", EncodeSecret(key));
     gArgs.ForceSetArg("-avaproof", localProof->ToHex());
 
     bilingual_str error;
     ChainstateManager &chainman = *Assert(m_node.chainman);
     std::unique_ptr<Processor> processor = Processor::MakeProcessor(
         *m_node.args, *m_node.chain, m_node.connman.get(), chainman,
         *m_node.scheduler, error);
 
     BOOST_CHECK(processor != nullptr);
     BOOST_CHECK(processor->getLocalProof() != nullptr);
     BOOST_CHECK_EQUAL(processor->getLocalProof()->getId(), localProof->getId());
     BOOST_CHECK_EQUAL(AvalancheTest::getMinQuorumScore(*processor), minScore);
     BOOST_CHECK_EQUAL(
         AvalancheTest::getMinQuorumConnectedScoreRatio(*processor), 0.5);
 
     // The local proof has not been validated yet
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     BOOST_CHECK(!processor->isQuorumEstablished());
 
     // Register the local proof. This is normally done when the chain tip is
     // updated. The local proof should be accounted for in the min quorum
     // computation but the peer manager doesn't know about that.
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK(pm.registerProof(processor->getLocalProof()));
         BOOST_CHECK(pm.isBoundToPeer(processor->getLocalProof()->getId()));
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     BOOST_CHECK(!processor->isQuorumEstablished());
 
     // Add enough nodes to get a conclusive vote
     for (NodeId id = 0; id < 8; id++) {
         processor->withPeerManager([&](avalanche::PeerManager &pm) {
             pm.addNode(id, processor->getLocalProof()->getId());
             BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore / 4);
             BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
         });
     }
 
     // Add part of the required stake and make sure we still report no quorum
     auto proof1 = buildRandomProof(active_chainstate, minScore / 2);
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK(pm.registerProof(proof1));
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 3 * minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(!processor->isQuorumEstablished());
 
     // Add the rest of the stake, but we are still lacking connected stake
     auto proof2 = buildRandomProof(active_chainstate, minScore / 4);
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK(pm.registerProof(proof2));
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(!processor->isQuorumEstablished());
 
     // Adding a node should cause the quorum to be detected and locked-in
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         pm.addNode(8, proof2->getId());
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore);
         // The peer manager knows that proof2 has a node attached ...
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 2);
     });
     // ... but the processor also account for the local proof, so we reached 50%
     BOOST_CHECK(processor->isQuorumEstablished());
 
     // Go back to not having enough connected score, but we've already latched
     // the quorum as established
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         pm.removeNode(8);
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(processor->isQuorumEstablished());
 
     // Removing one more node drops our count below the minimum and the quorum
     // is no longer ready
     processor->withPeerManager(
         [&](avalanche::PeerManager &pm) { pm.removeNode(7); });
     BOOST_CHECK(!processor->isQuorumEstablished());
 
     // It resumes when we have enough nodes again
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         pm.addNode(7, processor->getLocalProof()->getId());
     });
     BOOST_CHECK(processor->isQuorumEstablished());
 
     // Remove peers one at a time until the quorum is no longer established
     auto spendProofUtxo = [&processor, &chainman](ProofRef proof) {
         {
             LOCK(cs_main);
             CCoinsViewCache &coins = chainman.ActiveChainstate().CoinsTip();
             coins.SpendCoin(proof->getStakes()[0].getStake().getUTXO());
         }
         processor->withPeerManager([&proof](avalanche::PeerManager &pm) {
             pm.updatedBlockTip();
             BOOST_CHECK(!pm.isBoundToPeer(proof->getId()));
         });
     };
 
     spendProofUtxo(proof2);
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 3 * minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(processor->isQuorumEstablished());
 
     spendProofUtxo(proof1);
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(processor->isQuorumEstablished());
 
     spendProofUtxo(processor->getLocalProof());
     processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     // There is no node left
     BOOST_CHECK(!processor->isQuorumEstablished());
 
     gArgs.ClearForcedArg("-avamasterkey");
     gArgs.ClearForcedArg("-avaproof");
     gArgs.ClearForcedArg("-avaminquorumstake");
     gArgs.ClearForcedArg("-avaminquorumconnectedstakeratio");
 }
 
 BOOST_AUTO_TEST_CASE(quorum_detection_parameter_validation) {
     // Create vector of tuples of:
     // <min stake, min ratio, min avaproofs messages, success bool>
     std::vector<std::tuple<std::string, std::string, std::string, bool>> tests =
         {
             // All parameters are invalid
             {"", "", "", false},
             {"-1", "-1", "-1", false},
 
             // Min stake is out of range
             {"-1", "0", "0", false},
             {"-0.01", "0", "0", false},
             {"21000000000000.01", "0", "0", false},
 
             // Min connected ratio is out of range
             {"0", "-1", "0", false},
             {"0", "1.1", "0", false},
 
             // Min avaproofs messages ratio is out of range
             {"0", "0", "-1", false},
 
             // All parameters are valid
             {"0", "0", "0", true},
             {"0.00", "0", "0", true},
             {"0.01", "0", "0", true},
             {"1", "0.1", "0", true},
             {"10", "0.5", "0", true},
             {"10", "1", "0", true},
             {"21000000000000.00", "0", "0", true},
             {"0", "0", "1", true},
             {"0", "0", "100", true},
         };
 
     // For each case set the parameters and check that making the processor
     // succeeds or fails as expected
     for (auto it = tests.begin(); it != tests.end(); ++it) {
         gArgs.ForceSetArg("-avaminquorumstake", std::get<0>(*it));
         gArgs.ForceSetArg("-avaminquorumconnectedstakeratio", std::get<1>(*it));
         gArgs.ForceSetArg("-avaminavaproofsnodecount", std::get<2>(*it));
 
         bilingual_str error;
         std::unique_ptr<Processor> processor = Processor::MakeProcessor(
             *m_node.args, *m_node.chain, m_node.connman.get(),
             *Assert(m_node.chainman), *m_node.scheduler, error);
 
         if (std::get<3>(*it)) {
             BOOST_CHECK(processor != nullptr);
             BOOST_CHECK(error.empty());
             BOOST_CHECK_EQUAL(error.original, "");
         } else {
             BOOST_CHECK(processor == nullptr);
             BOOST_CHECK(!error.empty());
             BOOST_CHECK(error.original != "");
         }
     }
 
     gArgs.ClearForcedArg("-avaminquorumstake");
     gArgs.ClearForcedArg("-avaminquorumconnectedstakeratio");
     gArgs.ClearForcedArg("-avaminavaproofsnodecount");
 }
 
 BOOST_AUTO_TEST_CASE(min_avaproofs_messages) {
     ArgsManager argsman;
     argsman.ForceSetArg("-avaminquorumstake", "0");
     argsman.ForceSetArg("-avaminquorumconnectedstakeratio", "0");
 
     ChainstateManager &chainman = *Assert(m_node.chainman);
 
     auto checkMinAvaproofsMessages = [&](int64_t minAvaproofsMessages) {
         argsman.ForceSetArg("-avaminavaproofsnodecount",
                             ToString(minAvaproofsMessages));
 
         bilingual_str error;
         auto processor = Processor::MakeProcessor(
             argsman, *m_node.chain, m_node.connman.get(), chainman,
             *m_node.scheduler, error);
 
         auto addNode = [&](NodeId nodeid) {
             auto proof = buildRandomProof(chainman.ActiveChainstate(),
                                           MIN_VALID_PROOF_SCORE);
             processor->withPeerManager([&](avalanche::PeerManager &pm) {
                 BOOST_CHECK(pm.registerProof(proof));
                 BOOST_CHECK(pm.addNode(nodeid, proof->getId()));
             });
         };
 
         // Add enough node to have a conclusive vote, but don't account any
         // avaproofs.
         // NOTE: we can't use the test facilites like ConnectNodes() because we
         // are not testing on m_processor.
         for (NodeId id = 100; id < 108; id++) {
             addNode(id);
         }
 
         BOOST_CHECK_EQUAL(processor->isQuorumEstablished(),
                           minAvaproofsMessages <= 0);
 
         for (int64_t i = 0; i < minAvaproofsMessages - 1; i++) {
             addNode(i);
 
             processor->avaproofsSent(i);
             BOOST_CHECK_EQUAL(processor->getAvaproofsNodeCounter(), i + 1);
 
             // Receiving again on the same node does not increase the counter
             processor->avaproofsSent(i);
             BOOST_CHECK_EQUAL(processor->getAvaproofsNodeCounter(), i + 1);
 
             BOOST_CHECK(!processor->isQuorumEstablished());
         }
 
         addNode(minAvaproofsMessages);
         processor->avaproofsSent(minAvaproofsMessages);
         BOOST_CHECK(processor->isQuorumEstablished());
 
         // Check the latch
         AvalancheTest::clearavaproofsNodeCounter(*processor);
         BOOST_CHECK(processor->isQuorumEstablished());
     };
 
     checkMinAvaproofsMessages(0);
     checkMinAvaproofsMessages(1);
     checkMinAvaproofsMessages(10);
     checkMinAvaproofsMessages(100);
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(voting_parameters, P, VoteItemProviders) {
     // Check that setting voting parameters has the expected effect
     gArgs.ForceSetArg("-avastalevotethreshold",
                       ToString(AVALANCHE_VOTE_STALE_MIN_THRESHOLD));
     gArgs.ForceSetArg("-avastalevotefactor", "2");
 
     std::vector<std::tuple<int, int>> testCases = {
         // {number of yes votes, number of neutral votes}
         {0, AVALANCHE_VOTE_STALE_MIN_THRESHOLD},
         {AVALANCHE_FINALIZATION_SCORE + 4, AVALANCHE_FINALIZATION_SCORE - 6},
     };
 
     bilingual_str error;
     m_processor = Processor::MakeProcessor(
         *m_node.args, *m_node.chain, m_node.connman.get(),
         *Assert(m_node.chainman), *m_node.scheduler, error);
 
     BOOST_CHECK(m_processor != nullptr);
     BOOST_CHECK(error.empty());
 
     P provider(this);
     auto &updates = provider.updates;
     const uint32_t invType = provider.invType;
 
     const auto item = provider.buildVoteItem();
     const auto itemid = provider.getVoteItemId(item);
 
     // Create nodes that supports avalanche.
     auto avanodes = ConnectNodes();
     int nextNodeIndex = 0;
 
     for (auto &testCase : testCases) {
         // Add a new item. Check it is added to the polls.
         BOOST_CHECK(provider.addToReconcile(item));
         auto invs = getInvsForNextPoll();
         BOOST_CHECK_EQUAL(invs.size(), 1);
         BOOST_CHECK_EQUAL(invs[0].type, invType);
         BOOST_CHECK(invs[0].hash == itemid);
 
         BOOST_CHECK(m_processor->isAccepted(item));
 
         auto registerNewVote = [&](const Response &resp) {
             runEventLoop();
             auto nodeid = avanodes[nextNodeIndex++ % avanodes.size()]->GetId();
             BOOST_CHECK(provider.registerVotes(nodeid, resp));
         };
 
         // Add some confidence
         for (int i = 0; i < std::get<0>(testCase); i++) {
             Response resp = {getRound(), 0, {Vote(0, itemid)}};
             registerNewVote(next(resp));
             BOOST_CHECK(m_processor->isAccepted(item));
             BOOST_CHECK_EQUAL(m_processor->getConfidence(item),
                               i >= 6 ? i - 5 : 0);
             BOOST_CHECK_EQUAL(updates.size(), 0);
         }
 
         // Vote until just before item goes stale
         for (int i = 0; i < std::get<1>(testCase); i++) {
             Response resp = {getRound(), 0, {Vote(-1, itemid)}};
             registerNewVote(next(resp));
             BOOST_CHECK_EQUAL(updates.size(), 0);
         }
 
         // As long as it is not stale, we poll.
         invs = getInvsForNextPoll();
         BOOST_CHECK_EQUAL(invs.size(), 1);
         BOOST_CHECK_EQUAL(invs[0].type, invType);
         BOOST_CHECK(invs[0].hash == itemid);
 
         // Now stale
         Response resp = {getRound(), 0, {Vote(-1, itemid)}};
         registerNewVote(next(resp));
         BOOST_CHECK_EQUAL(updates.size(), 1);
         BOOST_CHECK(updates[0].getVoteItem() == item);
         BOOST_CHECK(updates[0].getStatus() == VoteStatus::Stale);
         updates.clear();
 
         // Once stale, there is no poll for it.
         invs = getInvsForNextPoll();
         BOOST_CHECK_EQUAL(invs.size(), 0);
     }
 
     gArgs.ClearForcedArg("-avastalevotethreshold");
     gArgs.ClearForcedArg("-avastalevotefactor");
 }
 
 BOOST_AUTO_TEST_CASE(block_vote_finalization_tip) {
     BlockProvider provider(this);
 
     std::vector<CBlockIndex *> blockIndexes;
     for (size_t i = 0; i < AVALANCHE_MAX_ELEMENT_POLL; i++) {
         CBlockIndex *pindex = provider.buildVoteItem();
         BOOST_CHECK(provider.addToReconcile(pindex));
         blockIndexes.push_back(pindex);
     }
 
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), AVALANCHE_MAX_ELEMENT_POLL);
     for (size_t i = 0; i < AVALANCHE_MAX_ELEMENT_POLL; i++) {
         BOOST_CHECK_EQUAL(
             invs[i].hash,
             blockIndexes[AVALANCHE_MAX_ELEMENT_POLL - i - 1]->GetBlockHash());
     }
 
     // Build a vote vector with the 11th block only being accepted and others
     // unknown.
     const BlockHash eleventhBlockHash =
         blockIndexes[AVALANCHE_MAX_ELEMENT_POLL - 10 - 1]->GetBlockHash();
     std::vector<Vote> votes;
     votes.reserve(AVALANCHE_MAX_ELEMENT_POLL);
     for (size_t i = AVALANCHE_MAX_ELEMENT_POLL; i > 0; i--) {
         BlockHash blockhash = blockIndexes[i - 1]->GetBlockHash();
         votes.emplace_back(blockhash == eleventhBlockHash ? 0 : -1, blockhash);
     }
 
     auto avanodes = ConnectNodes();
     int nextNodeIndex = 0;
 
     auto registerNewVote = [&]() {
         Response resp = {getRound(), 0, votes};
         runEventLoop();
         auto nodeid = avanodes[nextNodeIndex++ % avanodes.size()]->GetId();
         BOOST_CHECK(provider.registerVotes(nodeid, resp));
     };
 
     // Vote for the blocks until the one being accepted finalizes
     bool eleventhBlockFinalized = false;
     for (size_t i = 0; i < 10000 && !eleventhBlockFinalized; i++) {
         registerNewVote();
 
         for (auto &update : provider.updates) {
             if (update.getStatus() == VoteStatus::Finalized &&
                 update.getVoteItem()->GetBlockHash() == eleventhBlockHash) {
                 eleventhBlockFinalized = true;
             }
         }
     }
     BOOST_CHECK(eleventhBlockFinalized);
 
     // From now only the 10 blocks with more work are polled for
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 10);
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK_EQUAL(
             invs[i].hash,
             blockIndexes[AVALANCHE_MAX_ELEMENT_POLL - i - 1]->GetBlockHash());
     }
 
     // Adding ancestor blocks to reconcile will fail
     for (size_t i = 0; i < AVALANCHE_MAX_ELEMENT_POLL - 10 - 1; i++) {
         BOOST_CHECK(!provider.addToReconcile(blockIndexes[i]));
     }
 
     // Create a couple concurrent chain tips
     CBlockIndex *tip = provider.buildVoteItem();
 
     const auto &config = GetConfig();
     auto &activeChainstate = m_node.chainman->ActiveChainstate();
     BlockValidationState state;
     activeChainstate.InvalidateBlock(config, state, tip);
 
     // Use another script to make sure we don't generate the same block again
     CBlock altblock = CreateAndProcessBlock({}, CScript() << OP_TRUE);
     auto alttip = WITH_LOCK(
         cs_main, return Assert(m_node.chainman)
                      ->m_blockman.LookupBlockIndex(altblock.GetHash()));
     BOOST_CHECK(alttip);
     BOOST_CHECK(alttip->pprev == tip->pprev);
     BOOST_CHECK(alttip->GetBlockHash() != tip->GetBlockHash());
 
     // Reconsider the previous tip valid, so we have concurrent tip candidates
     {
         LOCK(cs_main);
         activeChainstate.ResetBlockFailureFlags(tip);
     }
     activeChainstate.ActivateBestChain(config, state);
 
     BOOST_CHECK(provider.addToReconcile(tip));
     BOOST_CHECK(provider.addToReconcile(alttip));
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 12);
 
     // Vote for the tip until it finalizes
     BlockHash tiphash = tip->GetBlockHash();
     votes.clear();
     votes.reserve(12);
     for (auto &inv : invs) {
         votes.emplace_back(inv.hash == tiphash ? 0 : -1, inv.hash);
     }
 
     bool tipFinalized = false;
     for (size_t i = 0; i < 10000 && !tipFinalized; i++) {
         registerNewVote();
 
         for (auto &update : provider.updates) {
             if (update.getStatus() == VoteStatus::Finalized &&
                 update.getVoteItem()->GetBlockHash() == tiphash) {
                 tipFinalized = true;
             }
         }
     }
     BOOST_CHECK(tipFinalized);
 
     // Now the tip and all its ancestors will be removed from polls. Only the
     // alttip remains because it is on a forked chain so we want to keep polling
     // for that one until it's invalidated or stalled.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].hash, alttip->GetBlockHash());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/abc_feature_proof_cleanup.py b/test/functional/abc_feature_proof_cleanup.py
index bc860a611..b9af97fda 100644
--- a/test/functional/abc_feature_proof_cleanup.py
+++ b/test/functional/abc_feature_proof_cleanup.py
@@ -1,151 +1,152 @@
 #!/usr/bin/env python3
 # Copyright (c) 2022 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 dangling proofs cleanup
 """
 
 import time
 
 from test_framework.avatools import (
     gen_proof,
     get_ava_p2p_interface,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.key import ECKey
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 from test_framework.wallet_util import bytes_to_wif
 
 # Interval between 2 proof cleanups
 AVALANCHE_CLEANUP_INTERVAL = 5 * 60
 # Dangling proof timeout
 AVALANCHE_DANGLING_PROOF_TIMEOUT = 15 * 60
 
 
 class ProofsCleanupTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [[
             '-enableavalanche=1',
+            '-avaproofstakeutxodustthreshold=1000000',
             '-avaproofstakeutxoconfirmations=1',
             '-enableavalanchepeerdiscovery=1',
             # Get rid of the getdata delay penalty for inbounds
             '-whitelist=noban@127.0.0.1',
         ]] * self.num_nodes
 
     def run_test(self):
         node = self.nodes[0]
 
         master_key, local_proof = gen_proof(node)
 
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(local_proof.serialize().hex()),
             "-avamasterkey={}".format(bytes_to_wif(master_key.get_bytes())),
         ])
 
         node.generate(1)
         wait_for_proof(node, f"{local_proof.proofid:0{64}x}")
 
         mocktime = int(time.time())
         node.setmocktime(mocktime)
 
         proofs = [local_proof]
         keys = [master_key]
         peers = []
         # The first 5 peers have a node attached
         for _ in range(5):
             key, proof = gen_proof(node)
 
             peer = get_ava_p2p_interface(node)
             node.addavalanchenode(
                 peer.nodeid,
                 key.get_pubkey().get_bytes().hex(),
                 proof.serialize().hex())
 
             proofs.append(proof)
             keys.append(key)
             peers.append(peer)
 
         # The last 5 peers have no node attached
         for _ in range(5):
             _, proof = gen_proof(node)
             node.sendavalancheproof(proof.serialize().hex())
             proofs.append(proof)
 
         peer_info = node.getavalanchepeerinfo()
         assert_equal(len(peer_info), 11)
         assert_equal(set(get_proof_ids(node)),
                      set([proof.proofid for proof in proofs]))
 
         self.log.info("No proof is cleaned before the timeout expires")
 
         mocktime += AVALANCHE_DANGLING_PROOF_TIMEOUT - 1
         node.setmocktime(mocktime)
         # Run the cleanup, the proofs are still there
         node.mockscheduler(AVALANCHE_CLEANUP_INTERVAL)
         assert_equal(len(peer_info), 11)
 
         self.log.info("Check the proofs with attached nodes are not cleaned")
 
         # Expire the dangling proof timeout
         mocktime += 1
         node.setmocktime(mocktime)
 
         # Run the cleanup, the proofs with no node are cleaned excepted our
         # local proof
         node.mockscheduler(AVALANCHE_CLEANUP_INTERVAL)
         self.wait_until(lambda: set(get_proof_ids(node)) == set(
             [proof.proofid for proof in proofs[:6]]), timeout=5)
 
         self.log.info(
             "Check the proofs are cleaned on next cleanup after the nodes disconnected")
 
         for peer in peers:
             peer.peer_disconnect()
             peer.wait_for_disconnect()
 
         node.mockscheduler(AVALANCHE_CLEANUP_INTERVAL)
         self.wait_until(lambda: get_proof_ids(node) == [local_proof.proofid])
 
         self.log.info("Check the cleaned up proofs are no longer accepted...")
 
         sender = get_ava_p2p_interface(node)
         for proof in proofs[1:]:
             with node.assert_debug_log(["dangling-proof"]):
                 sender.send_avaproof(proof)
 
         assert_equal(get_proof_ids(node), [local_proof.proofid])
 
         self.log.info("...until there is a node to attach")
 
         node.disconnect_p2ps()
         assert_equal(len(node.p2ps), 0)
 
         avanode = get_ava_p2p_interface(node)
 
         avanode_key = keys[1]
         avanode_proof = proofs[1]
 
         delegated_key = ECKey()
         delegated_key.generate()
 
         delegation = node.delegateavalancheproof(
             f"{avanode_proof.limited_proofid:064x}",
             bytes_to_wif(avanode_key.get_bytes()),
             delegated_key.get_pubkey().get_bytes().hex(),
         )
 
         avanode.send_avahello(delegation, delegated_key)
         avanode.sync_with_ping()
         avanode.wait_until(lambda: avanode.last_message.get(
             "getdata") and avanode.last_message["getdata"].inv[-1].hash == avanode_proof.proofid)
 
         avanode.send_avaproof(avanode_proof)
         self.wait_until(lambda: avanode_proof.proofid in get_proof_ids(node))
 
 
 if __name__ == '__main__':
     ProofsCleanupTest().main()
diff --git a/test/functional/abc_p2p_avalanche_peer_discovery.py b/test/functional/abc_p2p_avalanche_peer_discovery.py
index 4fba78a09..337eaf650 100755
--- a/test/functional/abc_p2p_avalanche_peer_discovery.py
+++ b/test/functional/abc_p2p_avalanche_peer_discovery.py
@@ -1,320 +1,321 @@
 #!/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 peer discovery behavior of avalanche nodes.
 
 This includes tests for the service flag, avahello handshake and
 proof exchange.
 """
 
 import time
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
 from test_framework.avatools import (
     AvaP2PInterface,
     avalanche_proof_from_hex,
     create_coinbase_stakes,
     gen_proof,
     get_ava_p2p_interface,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.key import ECKey, ECPubKey
 from test_framework.messages import (
     MSG_AVA_PROOF,
     MSG_TYPE_MASK,
     NODE_AVALANCHE,
     NODE_NETWORK,
     CInv,
     msg_getdata,
 )
 from test_framework.p2p import p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 from test_framework.wallet_util import bytes_to_wif
 
 UNCONDITIONAL_RELAY_DELAY = 2 * 60
 
 
 class GetProofDataCountingInterface(AvaP2PInterface):
     def __init__(self):
         self.get_proof_data_count = 0
         super().__init__()
 
     def on_getdata(self, message):
         if message.inv.type & MSG_TYPE_MASK == MSG_AVA_PROOF:
             self.get_proof_data_count += 1
 
 
 class AvalancheTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1',
+                            '-avaproofstakeutxodustthreshold=1000000',
                             '-avaproofstakeutxoconfirmations=3',
                             '-enableavalanchepeerdiscovery=1']]
         self.supports_cli = False
 
     def run_test(self):
         node = self.nodes[0]
 
         # duplicate the deterministic sig test from src/test/key_tests.cpp
         privkey = ECKey()
         privkey.set(bytes.fromhex(
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
         wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         self.log.info(
             "Check the node is signalling the avalanche service bit only if there is a proof.")
         assert_equal(
             int(node.getnetworkinfo()['localservices'], 16) & NODE_AVALANCHE,
             0)
 
         # Create stakes by mining blocks
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(4, addrkey0.address)
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         proof_sequence = 11
         proof_expiration = 12
         proof = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey, stakes)
 
         self.log.info("Test the avahello signature with no proof")
 
         peer = get_ava_p2p_interface(node)
         avahello = peer.wait_for_avahello().hello
         assert_equal(avahello.delegation.limited_proofid, 0)
 
         self.log.info(
             "A delegation with all zero limited id indicates that the peer has no proof")
 
         no_proof_peer = GetProofDataCountingInterface()
         node.add_p2p_connection(no_proof_peer, wait_for_verack=True)
 
         no_proof_peer.sync_send_with_ping()
 
         # No proof is requested
         with p2p_lock:
             assert_equal(no_proof_peer.get_proof_data_count, 0)
 
         # Restart the node
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
 
         assert_equal(
             int(node.getnetworkinfo()['localservices'], 16) & NODE_AVALANCHE,
             NODE_AVALANCHE)
 
         def check_avahello(args):
             # Restart the node with the given args
             self.restart_node(0, self.extra_args[0] + args)
 
             peer = get_ava_p2p_interface(node)
 
             avahello = peer.wait_for_avahello().hello
 
             avakey = ECPubKey()
             avakey.set(bytes.fromhex(node.getavalanchekey()))
             assert avakey.verify_schnorr(
                 avahello.sig, avahello.get_sighash(peer))
 
         self.log.info(
             "Test the avahello signature with a generated delegation")
         check_avahello([
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN"
         ])
 
         master_key = ECKey()
         master_key.generate()
 
         limited_id = avalanche_proof_from_hex(proof).limited_proofid
         delegation = node.delegateavalancheproof(
             f"{limited_id:0{64}x}",
             bytes_to_wif(privkey.get_bytes()),
             master_key.get_pubkey().get_bytes().hex(),
         )
 
         self.log.info("Test the avahello signature with a supplied delegation")
         check_avahello([
             "-avaproof={}".format(proof),
             "-avadelegation={}".format(delegation),
             "-avamasterkey={}".format(bytes_to_wif(master_key.get_bytes())),
         ])
 
         stakes = create_coinbase_stakes(node, [blockhashes[1]], addrkey0.key)
         interface_proof_hex = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey, stakes)
         limited_id = avalanche_proof_from_hex(
             interface_proof_hex).limited_proofid
 
         # delegate
         delegated_key = ECKey()
         delegated_key.generate()
         interface_delegation_hex = node.delegateavalancheproof(
             f"{limited_id:0{64}x}",
             bytes_to_wif(privkey.get_bytes()),
             delegated_key.get_pubkey().get_bytes().hex(),
             None)
 
         self.log.info("Test that wrong avahello signature causes a ban")
         bad_interface = get_ava_p2p_interface(node)
         wrong_key = ECKey()
         wrong_key.generate()
         with node.assert_debug_log(
                 ["Misbehaving",
                  "peer=1 (0 -> 100) BAN THRESHOLD EXCEEDED: invalid-avahello-signature"]):
             bad_interface.send_avahello(interface_delegation_hex, wrong_key)
             bad_interface.wait_for_disconnect()
 
         self.log.info(
             'Check that receiving a valid avahello triggers a proof getdata request')
         good_interface = get_ava_p2p_interface(node)
         proofid = good_interface.send_avahello(
             interface_delegation_hex, delegated_key)
 
         def getdata_found(peer, proofid):
             with p2p_lock:
                 return good_interface.last_message.get(
                     "getdata") and good_interface.last_message["getdata"].inv[-1].hash == proofid
         self.wait_until(lambda: getdata_found(good_interface, proofid))
 
         self.log.info('Check that we can download the proof from our peer')
 
         node_proofid = avalanche_proof_from_hex(proof).proofid
 
         getdata = msg_getdata([CInv(MSG_AVA_PROOF, node_proofid)])
 
         self.log.info(
             "Proof has been inv'ed recently, check it can be requested")
         good_interface.send_message(getdata)
 
         # This is our local proof so if it was announced it can be requested
         # without waiting for validation.
         assert_equal(len(node.getavalanchepeerinfo()), 0)
 
         def proof_received(peer, proofid):
             with p2p_lock:
                 return peer.last_message.get(
                     "avaproof") and peer.last_message["avaproof"].proof.proofid == proofid
         self.wait_until(lambda: proof_received(good_interface, node_proofid))
 
         # Restart the node
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
 
         def wait_for_proof_validation():
             # Connect some blocks to trigger the proof verification
             node.generate(1)
             self.wait_until(lambda: node_proofid in get_proof_ids(node))
 
         wait_for_proof_validation()
 
         self.log.info(
             "The proof has not been announced, it cannot be requested")
         peer = get_ava_p2p_interface(node, services=NODE_NETWORK)
 
         # Build a new proof and only announce this one
         _, new_proof_obj = gen_proof(node)
         new_proof = new_proof_obj.serialize().hex()
         new_proofid = new_proof_obj.proofid
 
         # Make the proof mature
         node.generate(2)
 
         node.sendavalancheproof(new_proof)
         wait_for_proof(node, f"{new_proofid:0{64}x}")
 
         # Request both our local proof and the new proof
         getdata = msg_getdata(
             [CInv(MSG_AVA_PROOF, node_proofid), CInv(MSG_AVA_PROOF, new_proofid)])
         peer.send_message(getdata)
 
         self.wait_until(lambda: proof_received(peer, new_proofid))
         assert not proof_received(peer, node_proofid)
 
         self.log.info("The proof is known for long enough to be requested")
         current_time = int(time.time())
         node.setmocktime(current_time + UNCONDITIONAL_RELAY_DELAY)
 
         getdata = msg_getdata([CInv(MSG_AVA_PROOF, node_proofid)])
         peer.send_message(getdata)
         self.wait_until(lambda: proof_received(peer, node_proofid))
 
         # Restart the node
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
         wait_for_proof_validation()
         # The only peer is the node itself
         assert_equal(len(node.getavalanchepeerinfo()), 1)
         assert_equal(node.getavalanchepeerinfo()[0]["proof"], proof)
 
         peer = get_ava_p2p_interface(node)
         peer_proofid = peer.send_avahello(
             interface_delegation_hex, delegated_key)
 
         self.wait_until(lambda: getdata_found(peer, peer_proofid))
         assert peer_proofid not in get_proof_ids(node)
 
         self.log.info(
             "Check that the peer gets added as an avalanche node as soon as the node knows about the proof")
         node.sendavalancheproof(interface_proof_hex)
 
         def has_node_count(count):
             peerinfo = node.getavalanchepeerinfo()
             return (len(peerinfo) == 2 and
                     peerinfo[-1]["proof"] == interface_proof_hex and
                     peerinfo[-1]["nodecount"] == count)
 
         self.wait_until(lambda: has_node_count(1))
 
         self.log.info(
             "Check that the peer gets added immediately if the proof is already known")
 
         # Connect another peer using the same proof
         peer_proof_known = get_ava_p2p_interface(node)
         peer_proof_known.send_avahello(interface_delegation_hex, delegated_key)
 
         self.wait_until(lambda: has_node_count(2))
 
         self.log.info("Check that repeated avahello messages are ignored")
         for i in range(3):
             with node.assert_debug_log(['Ignoring avahello from peer']):
                 peer_proof_known.send_avahello(
                     interface_delegation_hex, delegated_key)
 
         self.log.info("Invalidate the proof and check the nodes are removed")
         tip = node.getbestblockhash()
         # Invalidate the block after the proof utxo to make the proof immature
         node.invalidateblock(blockhashes[2])
         # Change the address to make sure we don't generate a block identical
         # to the one we just invalidated. Can be generate(1) after D9694 or
         # D9697 is landed.
         forked_tip = node.generatetoaddress(1, ADDRESS_ECREG_UNSPENDABLE)[0]
         self.wait_until(lambda: node.getbestblockhash() == forked_tip)
 
         self.wait_until(lambda: len(node.getavalanchepeerinfo()) == 1)
         assert peer_proofid not in get_proof_ids(node)
 
         self.log.info("Reorg back and check the nodes are added back")
         node.invalidateblock(forked_tip)
         node.reconsiderblock(tip)
         self.wait_until(lambda: has_node_count(2), timeout=2)
 
         self.log.info(
             "Check the node sends an avahello message to all peers even if the avalanche service bit is not advertised")
         for _ in range(3):
             nonavapeer = get_ava_p2p_interface(node, services=NODE_NETWORK)
             nonavapeer.wait_for_avahello()
 
 
 if __name__ == '__main__':
     AvalancheTest().main()
diff --git a/test/functional/abc_p2p_avalanche_proof_voting.py b/test/functional/abc_p2p_avalanche_proof_voting.py
index d00f627aa..53be1fd84 100755
--- a/test/functional/abc_p2p_avalanche_proof_voting.py
+++ b/test/functional/abc_p2p_avalanche_proof_voting.py
@@ -1,503 +1,506 @@
 #!/usr/bin/env python3
 # Copyright (c) 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 resolution of conflicting proofs via avalanche."""
 import time
 
 from test_framework.avatools import (
     avalanche_proof_from_hex,
     create_coinbase_stakes,
     gen_proof,
     get_ava_p2p_interface,
     get_proof_ids,
 )
 from test_framework.key import ECPubKey
 from test_framework.messages import (
     MSG_AVA_PROOF,
     AvalancheProofVoteResponse,
     AvalancheVote,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error, try_rpc
 from test_framework.wallet_util import bytes_to_wif
 
 QUORUM_NODE_COUNT = 16
 
 
 class AvalancheProofVotingTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.conflicting_proof_cooldown = 100
         self.peer_replacement_cooldown = 2000
         self.extra_args = [
             ['-enableavalanche=1',
+             '-avaproofstakeutxodustthreshold=1000000',
              '-enableavalancheproofreplacement=1',
              '-avaproofstakeutxoconfirmations=2',
                 f'-avalancheconflictingproofcooldown={self.conflicting_proof_cooldown}', f'-avalanchepeerreplacementcooldown={self.peer_replacement_cooldown}', '-avacooldown=0', '-avastalevotethreshold=140', '-avastalevotefactor=1'],
         ]
         self.supports_cli = False
 
     # Build a fake quorum of nodes.
     def get_quorum(self, node):
         quorum = [get_ava_p2p_interface(node)
                   for _ in range(0, QUORUM_NODE_COUNT)]
 
         for n in quorum:
             success = node.addavalanchenode(
                 n.nodeid,
                 self.privkey.get_pubkey().get_bytes().hex(),
                 self.quorum_proof.serialize().hex(),
             )
             assert success is True
 
         return quorum
 
     def can_find_proof_in_poll(self, hash, response):
         found_hash = False
         for n in self.quorum:
             poll = n.get_avapoll_if_available()
 
             # That node has not received a poll
             if poll is None:
                 continue
 
             # We got a poll, check for the hash and repond
             votes = []
             for inv in poll.invs:
                 # Vote yes to everything
                 r = AvalancheProofVoteResponse.ACTIVE
 
                 # Look for what we expect
                 if inv.hash == hash:
                     r = response
                     found_hash = True
 
                 votes.append(AvalancheVote(r, inv.hash))
 
             n.send_avaresponse(poll.round, votes, self.privkey)
 
         return found_hash
 
     @staticmethod
     def send_proof(from_peer, proof_hex):
         proof = avalanche_proof_from_hex(proof_hex)
         from_peer.send_avaproof(proof)
         return proof.proofid
 
     def send_and_check_for_polling(self, peer,
                                    proof_hex, response=AvalancheProofVoteResponse.ACTIVE):
         proofid = self.send_proof(peer, proof_hex)
         self.wait_until(lambda: self.can_find_proof_in_poll(proofid, response))
 
     def build_conflicting_proof(self, node, sequence):
         return node.buildavalancheproof(
             sequence, 0, self.privkey_wif, self.conflicting_stakes)
 
     def run_test(self):
         node = self.nodes[0]
 
         self.privkey, self.quorum_proof = gen_proof(node)
         self.privkey_wif = bytes_to_wif(self.privkey.get_bytes())
 
         # Make the quorum proof mature before preparing the quorum
         node.generate(1)
 
         self.quorum = self.get_quorum(node)
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhash = node.generatetoaddress(10, addrkey0.address)
         self.conflicting_stakes = create_coinbase_stakes(
             node, blockhash[5:9], addrkey0.key)
         self.immature_stakes = create_coinbase_stakes(
             node, blockhash[9:], addrkey0.key)
 
         self.poll_tests(node)
         self.update_tests(node)
         self.vote_tests(node)
         self.stale_proof_tests(node)
         self.unorphan_poll_tests(node)
 
     def poll_tests(self, node):
         proof_seq10 = self.build_conflicting_proof(node, 10)
         proof_seq20 = self.build_conflicting_proof(node, 20)
         proof_seq30 = self.build_conflicting_proof(node, 30)
         proof_seq40 = self.build_conflicting_proof(node, 40)
 
         orphan = node.buildavalancheproof(
             100, 0, self.privkey_wif, self.immature_stakes)
 
         no_stake = node.buildavalancheproof(
             200, 2000000000, self.privkey_wif, []
         )
 
         # Get the key so we can verify signatures.
         avakey = ECPubKey()
         avakey.set(bytes.fromhex(node.getavalanchekey()))
 
         self.log.info("Trigger polling from the node...")
 
         peer = get_ava_p2p_interface(node)
 
         mock_time = int(time.time())
         node.setmocktime(mock_time)
 
         self.log.info("Check we poll for valid proof")
         self.send_and_check_for_polling(peer, proof_seq30)
 
         self.log.info(
             "Check we don't poll for subsequent proofs if the cooldown is not elapsed, proof not the favorite")
         with node.assert_debug_log(["Not polling the avalanche proof (cooldown-not-elapsed)"]):
             peer.send_avaproof(avalanche_proof_from_hex(proof_seq20))
 
         self.log.info(
             "Check we don't poll for subsequent proofs if the cooldown is not elapsed, proof is the favorite")
         with node.assert_debug_log(["Not polling the avalanche proof (cooldown-not-elapsed)"]):
             peer.send_avaproof(avalanche_proof_from_hex(proof_seq40))
 
         self.log.info(
             "Check we poll for conflicting proof if the proof is not the favorite")
         mock_time += self.conflicting_proof_cooldown
         node.setmocktime(mock_time)
         self.send_and_check_for_polling(
             peer, proof_seq20, response=AvalancheProofVoteResponse.REJECTED)
 
         self.log.info(
             "Check we poll for conflicting proof if the proof is the favorite")
         mock_time += self.conflicting_proof_cooldown
         node.setmocktime(mock_time)
         self.send_and_check_for_polling(peer, proof_seq40)
 
         mock_time += self.conflicting_proof_cooldown
         node.setmocktime(mock_time)
 
         self.log.info("Check we don't poll for orphans")
         with node.assert_debug_log(["Not polling the avalanche proof (orphan-proof)"]):
             peer.send_avaproof(avalanche_proof_from_hex(orphan))
 
         self.log.info("Check we don't poll for proofs that get rejected")
         with node.assert_debug_log(["Not polling the avalanche proof (rejected-proof)"]):
             peer.send_avaproof(avalanche_proof_from_hex(proof_seq10))
 
         self.log.info("Check we don't poll for invalid proofs and get banned")
         with node.assert_debug_log(["Misbehaving", "invalid-proof"]):
             peer.send_avaproof(avalanche_proof_from_hex(no_stake))
         peer.wait_for_disconnect()
 
         self.log.info("We don't poll for proofs if replacement is disabled")
 
         self.restart_node(
             0,
             extra_args=self.extra_args[0] +
             ['-enableavalancheproofreplacement=0'])
         peer = get_ava_p2p_interface(node)
         with node.assert_debug_log(["Not polling the avalanche proof (not-worth-polling)"]):
             peer.send_avaproof(avalanche_proof_from_hex(proof_seq10))
 
     def update_tests(self, node):
         # Restart the node to get rid of in-flight requests
         self.restart_node(0)
 
         mock_time = int(time.time())
         node.setmocktime(mock_time)
 
         self.quorum = self.get_quorum(node)
         peer = get_ava_p2p_interface(node)
 
         proof_seq30 = self.build_conflicting_proof(node, 30)
         proof_seq40 = self.build_conflicting_proof(node, 40)
         proof_seq50 = self.build_conflicting_proof(node, 50)
         proofid_seq30 = avalanche_proof_from_hex(proof_seq30).proofid
         proofid_seq40 = avalanche_proof_from_hex(proof_seq40).proofid
         proofid_seq50 = avalanche_proof_from_hex(proof_seq50).proofid
 
         node.sendavalancheproof(proof_seq40)
         self.wait_until(lambda: proofid_seq40 in get_proof_ids(node))
 
         assert proofid_seq40 in get_proof_ids(node)
         assert proofid_seq30 not in get_proof_ids(node)
 
         self.log.info("Test proof acceptance")
 
         def accept_proof(proofid):
             self.wait_until(lambda: self.can_find_proof_in_poll(
                 proofid, response=AvalancheProofVoteResponse.ACTIVE), timeout=5)
             return proofid in get_proof_ids(node)
 
         mock_time += self.conflicting_proof_cooldown
         node.setmocktime(mock_time)
 
         self.send_and_check_for_polling(peer, proof_seq30)
 
         # Let the quorum vote for it
         self.wait_until(lambda: accept_proof(proofid_seq30))
         assert proofid_seq40 not in get_proof_ids(node)
 
         self.log.info("Test the peer replacement rate limit")
 
         def vote_until_finalized(proofid):
             self.can_find_proof_in_poll(
                 proofid, response=AvalancheProofVoteResponse.ACTIVE)
             return node.getrawavalancheproof(
                 f"{proofid:0{64}x}").get("finalized", False)
 
         # Wait until proof_seq30 is finalized
         self.wait_until(lambda: vote_until_finalized(proofid_seq30))
 
         # Not enough
         assert self.conflicting_proof_cooldown < self.peer_replacement_cooldown
         mock_time += self.conflicting_proof_cooldown
         node.setmocktime(mock_time)
 
         peer = get_ava_p2p_interface(node)
 
         with node.assert_debug_log(["Not polling the avalanche proof (cooldown-not-elapsed)"]):
             self.send_proof(peer, proof_seq50)
 
         mock_time += self.peer_replacement_cooldown
         node.setmocktime(mock_time)
 
         self.log.info("Test proof rejection")
 
         self.send_proof(peer, proof_seq50)
         self.wait_until(lambda: proofid_seq50 in get_proof_ids(node))
         assert proofid_seq40 not in get_proof_ids(node)
 
         def reject_proof(proofid):
             self.wait_until(
                 lambda: self.can_find_proof_in_poll(
                     proofid, response=AvalancheProofVoteResponse.REJECTED))
             return proofid not in get_proof_ids(node)
 
         with node.assert_debug_log(
             [f"Avalanche rejected proof {proofid_seq50:0{64}x}"],
             ["Failed to reject proof"]
         ):
             self.wait_until(lambda: reject_proof(proofid_seq50))
 
         assert proofid_seq50 not in get_proof_ids(node)
         assert proofid_seq40 in get_proof_ids(node)
 
         self.log.info("Test proof invalidation")
 
         def invalidate_proof(proofid):
             self.wait_until(
                 lambda: self.can_find_proof_in_poll(
                     proofid, response=AvalancheProofVoteResponse.REJECTED))
             return try_rpc(-8, "Proof not found",
                            node.getrawavalancheproof, f"{proofid:0{64}x}")
 
         with node.assert_debug_log(
             [f"Avalanche invalidated proof {proofid_seq50:0{64}x}"],
             ["Failed to reject proof"]
         ):
             self.wait_until(lambda: invalidate_proof(proofid_seq50))
 
         self.log.info("The node will now ignore the invalid proof")
 
         for i in range(5):
             with node.assert_debug_log(["received: avaproof"]):
                 self.send_proof(peer, proof_seq50)
             assert_raises_rpc_error(-8,
                                     "Proof not found",
                                     node.getrawavalancheproof,
                                     f"{proofid_seq50:0{64}x}")
 
     def vote_tests(self, node):
         self.restart_node(0, extra_args=['-enableavalanche=1',
+                                         '-avaproofstakeutxodustthreshold=1000000',
                                          '-avaproofstakeutxoconfirmations=2',
                                          '-avacooldown=0',
                                          '-avalancheconflictingproofcooldown=0',
                                          '-whitelist=noban@127.0.0.1', ])
 
         self.get_quorum(node)
 
         ava_node = get_ava_p2p_interface(node)
 
         # Generate coinbases to use for stakes
         stakes_key = node.get_deterministic_priv_key()
         blocks = node.generatetoaddress(4, stakes_key.address)
 
         # Get the ava key so we can verify signatures.
         ava_key = ECPubKey()
         ava_key.set(bytes.fromhex(node.getavalanchekey()))
 
         def create_proof(stakes):
             proof = node.buildavalancheproof(11, 12, self.privkey_wif, stakes)
             proof_id = avalanche_proof_from_hex(proof).proofid
             return proof, proof_id
 
         # proof_0 is valid right now
         stakes_0 = create_coinbase_stakes(node, [blocks[0]], stakes_key.key)
         proof_0, proof_0_id = create_proof(stakes_0)
 
         # proof_1 is valid right now, and from different stakes
         stakes_1 = create_coinbase_stakes(node, [blocks[1]], stakes_key.key)
         proof_1, proof_1_id = create_proof(stakes_1)
 
         # proof_2 is an orphan because the stake UTXO is immature
         stakes_2 = create_coinbase_stakes(node, [blocks[3]], stakes_key.key)
         proof_2, proof_2_id = create_proof(stakes_2)
 
         # proof_3 conflicts with proof_0 and proof_1
         stakes_3 = create_coinbase_stakes(
             node, [blocks[0], blocks[1]], stakes_key.key)
         proof_3, proof_3_id = create_proof(stakes_3)
 
         # proof_4 is invalid and should be rejected
         stakes_4 = create_coinbase_stakes(node, [blocks[2]], stakes_key.key)
         stakes_4[0]['amount'] -= 100000
         proof_4, proof_4_id = create_proof(stakes_4)
 
         # Create a helper to issue a poll and validate the responses
         def poll_assert_response(expected):
             # Issue a poll for each proof
             self.log.info("Trigger polling from the node...")
             ava_node.send_poll(
                 [proof_0_id, proof_1_id, proof_2_id, proof_3_id, proof_4_id],
                 MSG_AVA_PROOF)
             response = ava_node.wait_for_avaresponse()
             r = response.response
 
             # Verify signature
             assert ava_key.verify_schnorr(response.sig, r.get_hash())
 
             # Verify votes
             votes = r.votes
             assert_equal(len(votes), len(expected))
             for i in range(0, len(votes)):
                 assert_equal(repr(votes[i]), repr(expected[i]))
 
         # Check that all proofs start unknown
         poll_assert_response([
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_0_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_1_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_2_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_3_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_4_id)])
 
         # Send the first proof. Nodes should now respond that it's accepted
         node.sendavalancheproof(proof_0)
         poll_assert_response([
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_0_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_1_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_2_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_3_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_4_id)])
 
         # Send and check the 2nd proof. Nodes should now respond that it's
         # accepted
         node.sendavalancheproof(proof_1)
         poll_assert_response([
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_0_id),
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_1_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_2_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_3_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_4_id)])
 
         # The next proof should be rejected/put in the orphan pool
         ava_node.send_proof(avalanche_proof_from_hex(proof_2))
         poll_assert_response([
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_0_id),
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_1_id),
             AvalancheVote(AvalancheProofVoteResponse.ORPHAN, proof_2_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_3_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_4_id)])
 
         # The next proof should be rejected and marked as a conflicting proof
         assert_raises_rpc_error(-8,
                                 "The proof has conflicting utxo with an existing proof",
                                 node.sendavalancheproof, proof_3)
         poll_assert_response([
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_0_id),
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_1_id),
             AvalancheVote(AvalancheProofVoteResponse.ORPHAN, proof_2_id),
             AvalancheVote(AvalancheProofVoteResponse.CONFLICT, proof_3_id),
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proof_4_id)])
 
         # The final proof should be permanently rejected for being completely
         # invalid
         ava_node.send_proof(avalanche_proof_from_hex(proof_4))
         poll_assert_response([
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_0_id),
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proof_1_id),
             AvalancheVote(AvalancheProofVoteResponse.ORPHAN, proof_2_id),
             AvalancheVote(AvalancheProofVoteResponse.CONFLICT, proof_3_id),
             AvalancheVote(AvalancheProofVoteResponse.REJECTED, proof_4_id)])
 
     def stale_proof_tests(self, node):
         # Restart the node to get rid of in-flight requests
         self.restart_node(0)
 
         mock_time = int(time.time())
         node.setmocktime(mock_time)
 
         self.quorum = self.get_quorum(node)
         peer = get_ava_p2p_interface(node)
 
         proof_seq1 = self.build_conflicting_proof(node, 1)
         proof_seq2 = self.build_conflicting_proof(node, 2)
         proofid_seq1 = avalanche_proof_from_hex(proof_seq1).proofid
         proofid_seq2 = avalanche_proof_from_hex(proof_seq2).proofid
 
         node.sendavalancheproof(proof_seq2)
         self.wait_until(lambda: proofid_seq2 in get_proof_ids(node))
 
         assert proofid_seq2 in get_proof_ids(node)
         assert proofid_seq1 not in get_proof_ids(node)
 
         mock_time += self.conflicting_proof_cooldown
         node.setmocktime(mock_time)
 
         self.send_and_check_for_polling(
             peer, proof_seq1, response=AvalancheProofVoteResponse.UNKNOWN)
 
         def vote_until_dropped(proofid):
             self.can_find_proof_in_poll(
                 proofid, response=AvalancheProofVoteResponse.UNKNOWN)
             return try_rpc(-8, "Proof not found",
                            node.getrawavalancheproof, f"{proofid:0{64}x}")
 
         with node.assert_debug_log([f"Avalanche stalled proof {proofid_seq1:0{64}x}"]):
             self.wait_until(lambda: vote_until_dropped(proofid_seq1))
 
         # Verify that proof_seq2 was not replaced
         assert proofid_seq2 in get_proof_ids(node)
         assert proofid_seq1 not in get_proof_ids(node)
 
         # When polled, peer responds with expected votes for both proofs
         peer.send_poll([proofid_seq1, proofid_seq2], MSG_AVA_PROOF)
         response = peer.wait_for_avaresponse()
         assert repr(response.response.votes) == repr([
             AvalancheVote(AvalancheProofVoteResponse.UNKNOWN, proofid_seq1),
             AvalancheVote(AvalancheProofVoteResponse.ACTIVE, proofid_seq2)])
 
     def unorphan_poll_tests(self, node):
         # Restart the node with appropriate flags for this test
         self.restart_node(0, extra_args=[
             '-enableavalanche=1',
+            '-avaproofstakeutxodustthreshold=1000000',
             '-enableavalancheproofreplacement=1',
             '-avaproofstakeutxoconfirmations=2',
             '-avalancheconflictingproofcooldown=0',
             '-avacooldown=0',
         ])
 
         self.quorum = self.get_quorum(node)
         peer = get_ava_p2p_interface(node)
 
         _, immature_proof = gen_proof(node)
 
         self.log.info("Orphan proofs are not polled")
 
         with node.assert_debug_log(["Not polling the avalanche proof (orphan-proof)"]):
             peer.send_avaproof(immature_proof)
 
         self.log.info("Unorphaned proofs are polled")
 
         node.generate(1)
         self.send_and_check_for_polling(peer, immature_proof.serialize().hex())
 
 
 if __name__ == '__main__':
     AvalancheProofVotingTest().main()
diff --git a/test/functional/abc_p2p_avalanche_quorum.py b/test/functional/abc_p2p_avalanche_quorum.py
index ee77d133c..63350d18b 100755
--- a/test/functional/abc_p2p_avalanche_quorum.py
+++ b/test/functional/abc_p2p_avalanche_quorum.py
@@ -1,253 +1,254 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020-2022 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 quorum detection of avalanche."""
 
 from test_framework.avatools import (
     AvaP2PInterface,
     build_msg_avaproofs,
     gen_proof,
     get_ava_p2p_interface,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.key import ECPubKey
 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
 
 
 class AvalancheQuorumTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
         self.min_avaproofs_node_count = 8
         self.extra_args = [[
             '-enableavalanche=1',
+            '-avaproofstakeutxodustthreshold=1000000',
             '-enableavalanchepeerdiscovery=1',
             '-avaproofstakeutxoconfirmations=1',
             '-avacooldown=0',
             '-avatimeout=0',
             '-avaminquorumstake=150000000',
             '-avaminquorumconnectedstakeratio=0.8',
             '-minimumchainwork=0',
         ]] * self.num_nodes
         self.extra_args[0] = self.extra_args[0] + \
             ['-avaminavaproofsnodecount=0']
         self.extra_args[1] = self.extra_args[1] + \
             [f'-avaminavaproofsnodecount={self.min_avaproofs_node_count}']
         self.extra_args[2] = self.extra_args[2] + \
             [f'-avaminavaproofsnodecount={self.min_avaproofs_node_count}']
 
     def run_test(self):
         # Initially all nodes start with 8 nodes attached to a single proof
         privkey, proof = gen_proof(self.nodes[0])
         for node in self.nodes:
             quorum = [get_ava_p2p_interface(node)
                       for _ in range(0, 8)]
 
             for n in quorum:
                 success = node.addavalanchenode(
                     n.nodeid,
                     privkey.get_pubkey().get_bytes().hex(),
                     proof.serialize().hex(),
                 )
                 assert success is True
 
         # Prepare peers proofs
         peers = []
         for i in range(0, self.min_avaproofs_node_count + 1):
             key, proof = gen_proof(self.nodes[0])
             peers.append({'key': key, 'proof': proof})
 
         # Let the nodes known about all the blocks then disconnect them so we're
         # sure they won't exchange proofs when we start connecting peers.
         self.sync_all()
         self.disconnect_nodes(0, 1)
 
         # Restart node 2 to apply the minimum chainwork and make sure it's still
         # in IBD state.
         chainwork = int(self.nodes[2].getblockchaininfo()['chainwork'], 16)
         self.restart_node(
             2,
             extra_args=self.extra_args[2] +
             [f'-minimumchainwork={chainwork + 2:#x}'])
         assert self.nodes[2].getblockchaininfo()['initialblockdownload']
 
         # Build polling nodes
         pollers = [get_ava_p2p_interface(node) for node in self.nodes]
 
         def poll_and_assert_response(node, expected):
             pubkey = ECPubKey()
             pubkey.set(bytes.fromhex(node.getavalanchekey()))
 
             poller = pollers[node.index]
 
             # Send poll for best block
             block = int(node.getbestblockhash(), 16)
             poller.send_poll([block])
 
             # Get response and check that the vote is what we expect
             response = poller.wait_for_avaresponse()
             r = response.response
             assert pubkey.verify_schnorr(response.sig, r.get_hash())
             assert_equal(len(r.votes), 1)
 
             actual = repr(r.votes[0])
             expected = repr(AvalancheVote(expected, block))
             assert_equal(actual, expected)
 
         p2p_idx = 0
 
         def get_ava_outbound(node, peer, empty_avaproof):
             nonlocal p2p_idx
 
             avapeer = AvaP2PInterface()
             avapeer.proof = peer['proof']
             avapeer.master_privkey = peer['key']
             node.add_outbound_p2p_connection(
                 avapeer,
                 p2p_idx=p2p_idx,
                 connection_type="avalanche",
                 services=NODE_NETWORK | NODE_AVALANCHE,
             )
             p2p_idx += 1
             avapeer.nodeid = node.getpeerinfo()[-1]['id']
 
             peer['node'] = avapeer
 
             # There is no compact proof request if the node is in IBD state
             if not node.getblockchaininfo()['initialblockdownload']:
                 avapeer.wait_until(
                     lambda: avapeer.last_message.get("getavaproofs"))
 
                 if empty_avaproof:
                     avapeer.send_message(build_msg_avaproofs([]))
                     avapeer.sync_send_with_ping()
                     with p2p_lock:
                         assert_equal(
                             avapeer.message_count.get(
                                 "avaproofsreq", 0), 0)
                 else:
                     avapeer.send_and_ping(build_msg_avaproofs([peer['proof']]))
                     avapeer.wait_until(
                         lambda: avapeer.last_message.get("avaproofsreq"))
 
             return avapeer
 
         def add_avapeer_and_check_status(
                 peer, expected_status, empty_avaproof=False):
             for i, node in enumerate(self.nodes):
                 get_ava_outbound(node, peer, empty_avaproof)
                 poll_and_assert_response(node, expected_status[i])
 
         # Start polling. The response should be UNKNOWN because there's not
         # enough stake
         [poll_and_assert_response(node, AvalancheVoteError.UNKNOWN)
          for node in self.nodes]
 
         # Create one peer with half the remaining missing stake and add one
         # node
         add_avapeer_and_check_status(
             peers[0], [
                 AvalancheVoteError.UNKNOWN,
                 AvalancheVoteError.UNKNOWN,
                 AvalancheVoteError.UNKNOWN,
             ])
 
         # Create a second peer with the other half and add one node.
         # This is enough for node0 but not node1
         add_avapeer_and_check_status(
             peers[1], [
                 AvalancheVoteError.ACCEPTED,
                 AvalancheVoteError.UNKNOWN,
                 AvalancheVoteError.UNKNOWN,
             ])
 
         # Add more peers for triggering the avaproofs messaging
         for i in range(2, self.min_avaproofs_node_count - 1):
             add_avapeer_and_check_status(
                 peers[i], [
                     AvalancheVoteError.ACCEPTED,
                     AvalancheVoteError.UNKNOWN,
                     AvalancheVoteError.UNKNOWN,
                 ])
 
         add_avapeer_and_check_status(
             peers[self.min_avaproofs_node_count - 1], [
                 AvalancheVoteError.ACCEPTED,
                 AvalancheVoteError.ACCEPTED,
                 AvalancheVoteError.UNKNOWN,
             ])
 
         # The proofs are not requested during IBD, so node 2 has no proof yet.
         assert_equal(len(get_proof_ids(self.nodes[2])), 0)
         # And all the nodes are pending
         assert_equal(
             self.nodes[2].getavalancheinfo()['network']['pending_node_count'],
             self.min_avaproofs_node_count)
 
         self.nodes[2].generate(1)
         assert not self.nodes[2].getblockchaininfo()['initialblockdownload']
 
         # Connect the pending nodes so the next compact proofs requests can get
         # accounted for
         for i in range(self.min_avaproofs_node_count):
             node.sendavalancheproof(peers[i]['proof'].serialize().hex())
         assert_equal(self.nodes[2].getavalancheinfo()[
                      'network']['pending_node_count'], 0)
 
         # The avaproofs message are not accounted during IBD, so this is not
         # enough.
         poll_and_assert_response(self.nodes[2], AvalancheVoteError.UNKNOWN)
 
         # Connect more peers to reach the message threshold while node 2 is out
         # of IBD.
         for i in range(self.min_avaproofs_node_count - 1):
             add_avapeer_and_check_status(
                 peers[i], [
                     AvalancheVoteError.ACCEPTED,
                     AvalancheVoteError.ACCEPTED,
                     AvalancheVoteError.UNKNOWN,
                 ])
 
         # The messages is not accounted when there is no shortid
         add_avapeer_and_check_status(
             peers[self.min_avaproofs_node_count - 1], [
                 AvalancheVoteError.ACCEPTED,
                 AvalancheVoteError.ACCEPTED,
                 AvalancheVoteError.UNKNOWN,
             ], empty_avaproof=True)
 
         # The messages are accounted and the node quorum finally valid
         add_avapeer_and_check_status(
             peers[self.min_avaproofs_node_count], [
                 AvalancheVoteError.ACCEPTED,
                 AvalancheVoteError.ACCEPTED,
                 AvalancheVoteError.ACCEPTED,
             ])
 
         # Unless there is not enough nodes to poll
         for node in self.nodes:
             avapeers = [p2p for p2p in node.p2ps if p2p not in pollers]
             for peer in avapeers[7:]:
                 peer.peer_disconnect()
                 peer.wait_for_disconnect()
             poll_and_assert_response(node, AvalancheVoteError.UNKNOWN)
 
             # Add a node back and check it resumes the quorum status
             avapeer = AvaP2PInterface(node)
             node.add_p2p_connection(avapeer)
             wait_for_proof(node, f"{avapeer.proof.proofid:0{64}x}")
             poll_and_assert_response(node, AvalancheVoteError.ACCEPTED)
 
 
 if __name__ == '__main__':
     AvalancheQuorumTest().main()
diff --git a/test/functional/abc_p2p_avalanche_voting.py b/test/functional/abc_p2p_avalanche_voting.py
index 188c1753c..376c136c9 100755
--- a/test/functional/abc_p2p_avalanche_voting.py
+++ b/test/functional/abc_p2p_avalanche_voting.py
@@ -1,236 +1,237 @@
 #!/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 resolution of forks via avalanche."""
 import random
 
 from test_framework.avatools import (
     create_coinbase_stakes,
     get_ava_p2p_interface,
 )
 from test_framework.key import ECKey, ECPubKey
 from test_framework.messages import AvalancheVote, AvalancheVoteError
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 from test_framework.wallet_util import bytes_to_wif
 
 QUORUM_NODE_COUNT = 16
 
 
 class AvalancheTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [
             ['-enableavalanche=1',
+             '-avaproofstakeutxodustthreshold=1000000',
              '-avaproofstakeutxoconfirmations=1',
              '-avacooldown=0'],
             ['-enableavalanche=1',
              '-avaproofstakeutxoconfirmations=1',
              '-avacooldown=0', '-noparkdeepreorg', '-maxreorgdepth=-1']]
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def run_test(self):
         node = self.nodes[0]
 
         # Build a fake quorum of nodes.
         def get_quorum():
             return [get_ava_p2p_interface(node)
                     for _ in range(0, QUORUM_NODE_COUNT)]
 
         # Pick on node from the quorum for polling.
         quorum = get_quorum()
         poll_node = quorum[0]
 
         # Generate many block and poll for them.
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(100, addrkey0.address)
         # Use the first coinbase to create a stake
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         # duplicate the deterministic sig test from src/test/key_tests.cpp
         privkey = ECKey()
         privkey.set(bytes.fromhex(
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
 
         proof_sequence = 11
         proof_expiration = 12
         proof = node.buildavalancheproof(
             proof_sequence, proof_expiration, bytes_to_wif(
                 privkey.get_bytes()),
             stakes)
 
         # Activate the quorum.
         for n in quorum:
             success = node.addavalanchenode(
                 n.nodeid, privkey.get_pubkey().get_bytes().hex(), proof)
             assert success is True
 
         fork_node = self.nodes[1]
         # Make sure the fork node has synced the blocks
         self.sync_blocks([node, fork_node])
 
         # Get the key so we can verify signatures.
         avakey = ECPubKey()
         avakey.set(bytes.fromhex(node.getavalanchekey()))
 
         self.log.info("Poll for the chain tip...")
         best_block_hash = int(node.getbestblockhash(), 16)
         poll_node.send_poll([best_block_hash])
 
         def assert_response(expected):
             response = poll_node.wait_for_avaresponse()
             r = response.response
             assert_equal(r.cooldown, 0)
 
             # Verify signature.
             assert avakey.verify_schnorr(response.sig, r.get_hash())
 
             votes = r.votes
             assert_equal(len(votes), len(expected))
             for i in range(0, len(votes)):
                 assert_equal(repr(votes[i]), repr(expected[i]))
 
         assert_response(
             [AvalancheVote(AvalancheVoteError.ACCEPTED, best_block_hash)])
 
         self.log.info("Poll for a selection of blocks...")
         various_block_hashes = [
             int(node.getblockhash(0), 16),
             int(node.getblockhash(1), 16),
             int(node.getblockhash(10), 16),
             int(node.getblockhash(25), 16),
             int(node.getblockhash(42), 16),
             int(node.getblockhash(96), 16),
             int(node.getblockhash(99), 16),
             int(node.getblockhash(100), 16),
         ]
 
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(AvalancheVoteError.ACCEPTED, h)
                          for h in various_block_hashes])
 
         self.log.info(
             "Poll for a selection of blocks, but some are now invalid...")
         invalidated_block = node.getblockhash(76)
         node.invalidateblock(invalidated_block)
         # We need to send the coin to a new address in order to make sure we do
         # not regenerate the same block.
         node.generatetoaddress(
             26, 'ecregtest:pqv2r67sgz3qumufap3h2uuj0zfmnzuv8v38gtrh5v')
         node.reconsiderblock(invalidated_block)
 
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(AvalancheVoteError.ACCEPTED, h) for h in various_block_hashes[:5]] +
                         [AvalancheVote(AvalancheVoteError.FORK, h) for h in various_block_hashes[-3:]])
 
         self.log.info("Poll for unknown blocks...")
         various_block_hashes = [
             int(node.getblockhash(0), 16),
             int(node.getblockhash(25), 16),
             int(node.getblockhash(42), 16),
             various_block_hashes[5],
             various_block_hashes[6],
             various_block_hashes[7],
             random.randrange(1 << 255, (1 << 256) - 1),
             random.randrange(1 << 255, (1 << 256) - 1),
             random.randrange(1 << 255, (1 << 256) - 1),
         ]
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(AvalancheVoteError.ACCEPTED, h) for h in various_block_hashes[:3]] +
                         [AvalancheVote(AvalancheVoteError.FORK, h) for h in various_block_hashes[3:6]] +
                         [AvalancheVote(AvalancheVoteError.UNKNOWN, h) for h in various_block_hashes[-3:]])
 
         self.log.info("Trigger polling from the node...")
 
         def can_find_block_in_poll(hash, resp=AvalancheVoteError.ACCEPTED):
             found_hash = False
             for n in quorum:
                 poll = n.get_avapoll_if_available()
 
                 # That node has not received a poll
                 if poll is None:
                     continue
 
                 # We got a poll, check for the hash and repond
                 votes = []
                 for inv in poll.invs:
                     # Vote yes to everything
                     r = AvalancheVoteError.ACCEPTED
 
                     # Look for what we expect
                     if inv.hash == hash:
                         r = resp
                         found_hash = True
 
                     votes.append(AvalancheVote(r, inv.hash))
 
                 n.send_avaresponse(poll.round, votes, privkey)
 
             return found_hash
 
         # Now that we have a peer, we should start polling for the tip.
         hash_tip = int(node.getbestblockhash(), 16)
         self.wait_until(lambda: can_find_block_in_poll(hash_tip), timeout=5)
 
         # Make sure the fork node has synced the blocks
         self.sync_blocks([node, fork_node])
 
         # Create a fork 2 blocks deep. This should trigger polling.
         fork_node.invalidateblock(fork_node.getblockhash(100))
         fork_address = fork_node.get_deterministic_priv_key().address
         fork_node.generatetoaddress(2, fork_address)
 
         # Because the new tip is a deep reorg, the node will not accept it
         # right away, but poll for it.
         def parked_block(blockhash):
             for tip in node.getchaintips():
                 if tip["hash"] == blockhash:
                     assert tip["status"] != "active"
                     return tip["status"] == "parked"
             return False
 
         fork_tip = fork_node.getbestblockhash()
         self.wait_until(lambda: parked_block(fork_tip))
 
         self.log.info("Answer all polls to finalize...")
 
         hash_to_find = int(fork_tip, 16)
 
         def has_accepted_new_tip():
             can_find_block_in_poll(hash_to_find)
             return node.getbestblockhash() == fork_tip
 
         # Because everybody answers yes, the node will accept that block.
         self.wait_until(has_accepted_new_tip, timeout=15)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         self.log.info("Answer all polls to park...")
         node.generate(1)
 
         tip_to_park = node.getbestblockhash()
         hash_to_find = int(tip_to_park, 16)
         assert(tip_to_park != fork_tip)
 
         def has_parked_new_tip():
             can_find_block_in_poll(hash_to_find, AvalancheVoteError.PARKED)
             return node.getbestblockhash() == fork_tip
 
         # Because everybody answers no, the node will park that block.
         with node.assert_debug_log([f"Avalanche invalidated block {hash_to_find:0{64}x}"]):
             self.wait_until(has_parked_new_tip, timeout=15)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         self.log.info(
             "Check the node is discouraging unexpected avaresponses.")
         with node.assert_debug_log(
                 ['Misbehaving', 'peer=1 (0 -> 2): unexpected-ava-response']):
             # unknown voting round
             poll_node.send_avaresponse(
                 round=2**32 - 1, votes=[], privkey=privkey)
 
 
 if __name__ == '__main__':
     AvalancheTest().main()
diff --git a/test/functional/abc_p2p_compactproofs.py b/test/functional/abc_p2p_compactproofs.py
index 8661a873e..5e4945531 100644
--- a/test/functional/abc_p2p_compactproofs.py
+++ b/test/functional/abc_p2p_compactproofs.py
@@ -1,681 +1,682 @@
 #!/usr/bin/env python3
 # Copyright (c) 2022 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
 Test proof inventory relaying
 """
 
 import random
 import time
 
 from test_framework.avatools import (
     AvaP2PInterface,
     NoHandshakeAvaP2PInterface,
     build_msg_avaproofs,
     gen_proof,
     get_ava_p2p_interface,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.messages import (
     NODE_AVALANCHE,
     NODE_NETWORK,
     AvalanchePrefilledProof,
     calculate_shortid,
     msg_avaproofsreq,
     msg_getavaproofs,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import MAX_NODES, assert_equal, p2p_port
 
 # Timeout after which the proofs can be cleaned up
 AVALANCHE_AVAPROOFS_TIMEOUT = 2 * 60
 # Max interval between 2 periodic networking processing
 AVALANCHE_MAX_PERIODIC_NETWORKING_INTERVAL = 5 * 60
 
 
 class ProofStoreP2PInterface(AvaP2PInterface):
     def __init__(self):
         self.proofs = []
         super().__init__()
 
     def on_avaproof(self, message):
         self.proofs.append(message.proof)
 
     def get_proofs(self):
         with p2p_lock:
             return self.proofs
 
 
 class CompactProofsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [[
             '-enableavalanche=1',
+            '-avaproofstakeutxodustthreshold=1000000',
             '-avaproofstakeutxoconfirmations=1',
             '-avacooldown=0',
             '-enableavalanchepeerdiscovery=1',
         ]] * self.num_nodes
 
     def setup_network(self):
         # Don't connect the nodes
         self.setup_nodes()
 
     @staticmethod
     def received_avaproofs(peer):
         with p2p_lock:
             return peer.last_message.get("avaproofs")
 
     def test_send_outbound_getavaproofs(self):
         self.log.info(
             "Check we send a getavaproofs message to our avalanche outbound peers")
         node = self.nodes[0]
 
         p2p_idx = 0
         non_avapeers = []
         for _ in range(4):
             peer = P2PInterface()
             node.add_outbound_p2p_connection(
                 peer,
                 p2p_idx=p2p_idx,
                 connection_type="outbound-full-relay",
                 services=NODE_NETWORK,
             )
             non_avapeers.append(peer)
             p2p_idx += 1
 
         inbound_avapeers = [
             node.add_p2p_connection(
                 NoHandshakeAvaP2PInterface()) for _ in range(4)]
 
         outbound_avapeers = []
         # With a proof and the service bit set
         for _ in range(4):
             peer = AvaP2PInterface(node)
             node.add_outbound_p2p_connection(
                 peer,
                 p2p_idx=p2p_idx,
                 connection_type="avalanche",
                 services=NODE_NETWORK | NODE_AVALANCHE,
             )
             outbound_avapeers.append(peer)
             p2p_idx += 1
 
         # Without a proof and no service bit set
         for _ in range(4):
             peer = AvaP2PInterface()
             node.add_outbound_p2p_connection(
                 peer,
                 p2p_idx=p2p_idx,
                 connection_type="outbound-full-relay",
                 services=NODE_NETWORK,
             )
             outbound_avapeers.append(peer)
             p2p_idx += 1
 
         def all_peers_received_getavaproofs():
             with p2p_lock:
                 return all([p.last_message.get("getavaproofs")
                            for p in outbound_avapeers])
         self.wait_until(all_peers_received_getavaproofs)
 
         with p2p_lock:
             assert all([p.message_count.get(
                 "getavaproofs", 0) >= 1 for p in outbound_avapeers])
             assert all([p.message_count.get(
                 "getavaproofs", 0) == 0 for p in non_avapeers])
             assert all([p.message_count.get(
                 "getavaproofs", 0) == 0 for p in inbound_avapeers])
 
         self.log.info(
             "Check we send periodic getavaproofs message to some of our peers")
 
         def count_outbounds_getavaproofs():
             with p2p_lock:
                 return sum([p.message_count.get("getavaproofs", 0)
                             for p in outbound_avapeers])
 
         outbounds_getavaproofs = count_outbounds_getavaproofs()
         node.mockscheduler(AVALANCHE_MAX_PERIODIC_NETWORKING_INTERVAL)
         self.wait_until(lambda: count_outbounds_getavaproofs()
                         == outbounds_getavaproofs + 3)
         outbounds_getavaproofs += 3
 
         with p2p_lock:
             assert all([p.message_count.get(
                 "getavaproofs", 0) == 0 for p in non_avapeers])
             assert all([p.message_count.get(
                 "getavaproofs", 0) == 0 for p in inbound_avapeers])
 
         self.log.info(
             "After the first avaproofs has been received, all the peers are requested periodically")
 
         responding_outbound_avapeer = AvaP2PInterface(node)
         node.add_outbound_p2p_connection(
             responding_outbound_avapeer,
             p2p_idx=p2p_idx,
             connection_type="avalanche",
             services=NODE_NETWORK | NODE_AVALANCHE,
         )
         p2p_idx += 1
         responding_outbound_avapeer_id = node.getpeerinfo()[-1]['id']
         outbound_avapeers.append(responding_outbound_avapeer)
 
         self.wait_until(all_peers_received_getavaproofs)
 
         # Register as an avalanche node for the avaproofs message to be counted
         key, proof = gen_proof(node)
         assert node.addavalanchenode(
             responding_outbound_avapeer_id,
             key.get_pubkey().get_bytes().hex(),
             proof.serialize().hex())
 
         # Send the avaproofs message
         avaproofs = build_msg_avaproofs([proof])
         responding_outbound_avapeer.send_and_ping(avaproofs)
 
         # Now the node will request from all its peers at each time period
         outbounds_getavaproofs = count_outbounds_getavaproofs()
         num_outbound_avapeers = len(outbound_avapeers)
         node.mockscheduler(AVALANCHE_MAX_PERIODIC_NETWORKING_INTERVAL)
         self.wait_until(lambda: count_outbounds_getavaproofs()
                         == outbounds_getavaproofs + num_outbound_avapeers)
         outbounds_getavaproofs += num_outbound_avapeers
 
         for p in outbound_avapeers:
             with node.assert_debug_log(["received: avaproofs"], ["Ignoring unsollicited avaproofs"]):
                 p.send_message(build_msg_avaproofs([]))
 
         with p2p_lock:
             assert all([p.message_count.get(
                 "getavaproofs", 0) == 0 for p in non_avapeers])
             assert all([p.message_count.get(
                 "getavaproofs", 0) == 0 for p in inbound_avapeers])
 
     def test_send_manual_getavaproofs(self):
         self.log.info(
             "Check we send a getavaproofs message to our manually connected peers that support avalanche")
         node = self.nodes[0]
 
         # Get rid of previously connected nodes
         node.disconnect_p2ps()
 
         def added_node_connected(ip_port):
             added_node_info = node.getaddednodeinfo(ip_port)
             return len(
                 added_node_info) == 1 and added_node_info[0]['connected']
 
         def connect_callback(address, port):
             self.log.debug("Connecting to {}:{}".format(address, port))
 
         p = AvaP2PInterface(node)
         p2p_idx = 1
         p.peer_accept_connection(
             connect_cb=connect_callback,
             connect_id=p2p_idx,
             net=node.chain,
             timeout_factor=node.timeout_factor,
             services=NODE_NETWORK | NODE_AVALANCHE,
         )()
         ip_port = f"127.0.01:{p2p_port(MAX_NODES - p2p_idx)}"
 
         node.addnode(node=ip_port, command="add")
         self.wait_until(lambda: added_node_connected(ip_port))
 
         assert_equal(node.getpeerinfo()[-1]['addr'], ip_port)
         assert_equal(node.getpeerinfo()[-1]['connection_type'], 'manual')
 
         p.wait_until(lambda: p.last_message.get("getavaproofs"))
 
     def test_respond_getavaproofs(self):
         self.log.info("Check the node responds to getavaproofs messages")
 
         node = self.nodes[0]
 
         def send_getavaproof_check_shortid_len(peer, expected_len):
             peer.send_message(msg_getavaproofs())
             self.wait_until(lambda: self.received_avaproofs(peer))
 
             avaproofs = self.received_avaproofs(peer)
             assert_equal(len(avaproofs.shortids), expected_len)
 
         # Initially the node has 0 peer
         self.restart_node(0)
         assert_equal(len(get_proof_ids(node)), 0)
 
         peer = node.add_p2p_connection(NoHandshakeAvaP2PInterface())
         send_getavaproof_check_shortid_len(peer, 0)
 
         # Add some proofs
         sending_peer = node.add_p2p_connection(NoHandshakeAvaP2PInterface())
         for _ in range(50):
             _, proof = gen_proof(node)
             sending_peer.send_avaproof(proof)
             wait_for_proof(node, f"{proof.proofid:0{64}x}")
 
         proofids = get_proof_ids(node)
         assert_equal(len(proofids), 50)
 
         receiving_peer = node.add_p2p_connection(NoHandshakeAvaP2PInterface())
         send_getavaproof_check_shortid_len(receiving_peer, len(proofids))
 
         avaproofs = self.received_avaproofs(receiving_peer)
         expected_shortids = [
             calculate_shortid(
                 avaproofs.key0,
                 avaproofs.key1,
                 proofid) for proofid in sorted(proofids)]
         assert_equal(expected_shortids, avaproofs.shortids)
 
         # Don't expect any prefilled proof for now
         assert_equal(len(avaproofs.prefilled_proofs), 0)
 
     def test_request_missing_proofs(self):
         self.log.info(
             "Check the node requests the missing proofs after receiving an avaproofs message")
 
         node = self.nodes[0]
 
         self.restart_node(0)
 
         key0 = random.randint(0, 2**64 - 1)
         key1 = random.randint(0, 2**64 - 1)
         proofs = [gen_proof(node)[1] for _ in range(10)]
 
         # Build a map from proofid to shortid. Use sorted proofids so we don't
         # have the same indices than the `proofs` list.
         proofids = [p.proofid for p in proofs]
         shortid_map = {}
         for proofid in sorted(proofids):
             shortid_map[proofid] = calculate_shortid(key0, key1, proofid)
 
         self.log.info("The node ignores unsollicited avaproofs")
 
         spam_peer = get_ava_p2p_interface(node)
 
         msg = build_msg_avaproofs(
             proofs, prefilled_proofs=[], key_pair=[
                 key0, key1])
 
         with node.assert_debug_log(["Ignoring unsollicited avaproofs"]):
             spam_peer.send_message(msg)
 
         def received_avaproofsreq(peer):
             with p2p_lock:
                 return peer.last_message.get("avaproofsreq")
 
         p2p_idx = 0
 
         def add_avalanche_p2p_outbound():
             nonlocal p2p_idx
 
             peer = AvaP2PInterface(node)
             node.add_outbound_p2p_connection(
                 peer,
                 p2p_idx=p2p_idx,
                 connection_type="avalanche",
                 services=NODE_NETWORK | NODE_AVALANCHE,
             )
             p2p_idx += 1
 
             peer.wait_until(lambda: peer.last_message.get("getavaproofs"))
 
             return peer
 
         def expect_indices(shortids, expected_indices, prefilled_proofs=None):
             nonlocal p2p_idx
 
             msg = build_msg_avaproofs(
                 [], prefilled_proofs=prefilled_proofs, key_pair=[
                     key0, key1])
             msg.shortids = shortids
 
             peer = add_avalanche_p2p_outbound()
             peer.send_message(msg)
             self.wait_until(lambda: received_avaproofsreq(peer))
 
             avaproofsreq = received_avaproofsreq(peer)
             assert_equal(avaproofsreq.indices, expected_indices)
 
         self.log.info("Check no proof is requested if there is no shortid")
 
         msg = build_msg_avaproofs([])
         sender = add_avalanche_p2p_outbound()
         with node.assert_debug_log(["Got an avaproofs message with no shortid"]):
             sender.send_message(msg)
         # Make sure we don't get an avaproofsreq message
         sender.sync_send_with_ping()
         with p2p_lock:
             assert_equal(sender.message_count.get("avaproofsreq", 0), 0)
 
         self.log.info(
             "Check the node requests all the proofs if it known none")
 
         expect_indices(
             list(shortid_map.values()),
             [i for i in range(len(shortid_map))]
         )
 
         self.log.info(
             "Check the node requests only the missing proofs")
 
         known_proofids = []
         for proof in proofs[:5]:
             node.sendavalancheproof(proof.serialize().hex())
             known_proofids.append(proof.proofid)
 
         expected_indices = [i for i, proofid in enumerate(
             shortid_map) if proofid not in known_proofids]
         expect_indices(list(shortid_map.values()), expected_indices)
 
         self.log.info(
             "Check the node don't request prefilled proofs")
 
         # Get the indices for a couple of proofs
         indice_proof5 = list(shortid_map.keys()).index(proofids[5])
         indice_proof6 = list(shortid_map.keys()).index(proofids[6])
         prefilled_proofs = [
             AvalanchePrefilledProof(indice_proof5, proofs[5]),
             AvalanchePrefilledProof(indice_proof6, proofs[6]),
         ]
         prefilled_proofs = sorted(
             prefilled_proofs,
             key=lambda prefilled_proof: prefilled_proof.index)
         remaining_shortids = [shortid for proofid, shortid in shortid_map.items(
         ) if proofid not in proofids[5:7]]
         known_proofids.extend(proofids[5:7])
         expected_indices = [i for i, proofid in enumerate(
             shortid_map) if proofid not in known_proofids]
         expect_indices(
             remaining_shortids,
             expected_indices,
             prefilled_proofs=prefilled_proofs)
 
         self.log.info(
             "Check the node requests no proof if it knows all of them")
 
         for proof in proofs[5:]:
             node.sendavalancheproof(proof.serialize().hex())
             known_proofids.append(proof.proofid)
 
         expect_indices(list(shortid_map.values()), [])
 
         self.log.info("Check out of bounds index")
 
         bad_peer = add_avalanche_p2p_outbound()
 
         msg = build_msg_avaproofs([], prefilled_proofs=[
             AvalanchePrefilledProof(
                 len(shortid_map) + 1,
                 gen_proof(node)[1])], key_pair=[key0, key1])
         msg.shortids = list(shortid_map.values())
 
         with node.assert_debug_log(["Misbehaving", "avaproofs-bad-indexes"]):
             bad_peer.send_message(msg)
         bad_peer.wait_for_disconnect()
 
         self.log.info("An invalid prefilled proof will trigger a ban")
 
         _, no_stake = gen_proof(node)
         no_stake.stakes = []
 
         bad_peer = add_avalanche_p2p_outbound()
 
         msg = build_msg_avaproofs([], prefilled_proofs=[
             AvalanchePrefilledProof(len(shortid_map), no_stake),
         ], key_pair=[key0, key1])
         msg.shortids = list(shortid_map.values())
 
         with node.assert_debug_log(["Misbehaving", "invalid-proof"]):
             bad_peer.send_message(msg)
         bad_peer.wait_for_disconnect()
 
     def test_send_missing_proofs(self):
         self.log.info("Check the node respond to missing proofs requests")
 
         node = self.nodes[0]
 
         self.restart_node(0)
 
         numof_proof = 10
         proofs = [gen_proof(node)[1] for _ in range(numof_proof)]
 
         for proof in proofs:
             node.sendavalancheproof(proof.serialize().hex())
         proofids = get_proof_ids(node)
         assert all(proof.proofid in proofids for proof in proofs)
 
         self.log.info("Unsollicited requests are ignored")
 
         peer = node.add_p2p_connection(ProofStoreP2PInterface())
         peer.send_and_ping(msg_avaproofsreq())
         assert_equal(len(peer.get_proofs()), 0)
 
         def request_proofs(peer):
             peer.send_message(msg_getavaproofs())
             self.wait_until(lambda: self.received_avaproofs(peer))
 
             avaproofs = self.received_avaproofs(peer)
             assert_equal(len(avaproofs.shortids), numof_proof)
 
             return avaproofs
 
         _ = request_proofs(peer)
 
         self.log.info("Sending an empty request has no effect")
 
         peer.send_and_ping(msg_avaproofsreq())
         assert_equal(len(peer.get_proofs()), 0)
 
         self.log.info("Check the requested proofs are sent by the node")
 
         def check_received_proofs(indices):
             requester = node.add_p2p_connection(ProofStoreP2PInterface())
             avaproofs = request_proofs(requester)
 
             req = msg_avaproofsreq()
             req.indices = indices
             requester.send_message(req)
 
             # Check we got the expected number of proofs
             self.wait_until(
                 lambda: len(
                     requester.get_proofs()) == len(indices))
 
             # Check we got the expected proofs
             received_shortids = [
                 calculate_shortid(
                     avaproofs.key0,
                     avaproofs.key1,
                     proof.proofid) for proof in requester.get_proofs()]
             assert_equal(set(received_shortids),
                          set([avaproofs.shortids[i] for i in indices]))
 
         # Only the first proof
         check_received_proofs([0])
         # Only the last proof
         check_received_proofs([numof_proof - 1])
         # Half first
         check_received_proofs(range(0, numof_proof // 2))
         # Half last
         check_received_proofs(range(numof_proof // 2, numof_proof))
         # Even
         check_received_proofs([i for i in range(numof_proof) if i % 2 == 0])
         # Odds
         check_received_proofs([i for i in range(numof_proof) if i % 2 == 1])
         # All
         check_received_proofs(range(numof_proof))
 
         self.log.info(
             "Check the node will not send the proofs if not requested before the timeout elapsed")
 
         # Disconnect the peers
         for peer in node.p2ps:
             peer.peer_disconnect()
             peer.wait_for_disconnect()
 
         mocktime = int(time.time())
         node.setmocktime(mocktime)
 
         slow_peer = ProofStoreP2PInterface()
         node.add_outbound_p2p_connection(
             slow_peer,
             p2p_idx=0,
             connection_type="avalanche",
             services=NODE_NETWORK | NODE_AVALANCHE,
         )
         slow_peer.wait_until(
             lambda: slow_peer.last_message.get("getavaproofs"))
 
         slow_peer.nodeid = node.getpeerinfo()[-1]['id']
         _ = request_proofs(slow_peer)
 
         # Elapse the timeout
         mocktime += AVALANCHE_AVAPROOFS_TIMEOUT + 1
         node.setmocktime(mocktime)
 
         node.mockscheduler(AVALANCHE_MAX_PERIODIC_NETWORKING_INTERVAL)
 
         # Periodic compact proofs requests are sent in the same loop than the
         # cleanup, so when such a request is made we are sure the cleanup did
         # happen.
         slow_peer.wait_until(
             lambda: slow_peer.message_count.get("getavaproofs") > 1)
 
         req = msg_avaproofsreq()
         req.indices = range(numof_proof)
         slow_peer.send_and_ping(req)
 
         # Check we get no proof
         assert_equal(len(slow_peer.get_proofs()), 0)
 
     def test_compact_proofs_download_on_connect(self):
         self.log.info(
             "Check the node get compact proofs upon avalanche outbound discovery")
 
         requestee = self.nodes[0]
         requester = self.nodes[1]
 
         self.restart_node(0)
 
         numof_proof = 10
         proofs = [gen_proof(requestee)[1] for _ in range(numof_proof)]
 
         for proof in proofs:
             requestee.sendavalancheproof(proof.serialize().hex())
         proofids = get_proof_ids(requestee)
         assert all(proof.proofid in proofids for proof in proofs)
 
         # Start the requester and check it gets all the proofs
         self.start_node(1)
         self.connect_nodes(0, 1)
         self.wait_until(
             lambda: all(
                 proof.proofid in proofids for proof in get_proof_ids(requester)))
 
     def test_no_compactproofs_during_ibs(self):
         self.log.info(
             "Check the node don't request compact proofs during IBD")
 
         node = self.nodes[0]
 
         chainwork = int(node.getblockchaininfo()['chainwork'], 16)
         self.restart_node(
             0,
             extra_args=self.extra_args[0] +
             [f'-minimumchainwork={chainwork + 2:#x}'])
 
         assert node.getblockchaininfo()['initialblockdownload']
 
         peer = P2PInterface()
         node.add_outbound_p2p_connection(
             peer,
             p2p_idx=0,
             connection_type="avalanche",
             services=NODE_NETWORK | NODE_AVALANCHE,
         )
 
         # Force the node to process the sending loop
         peer.sync_send_with_ping()
         with p2p_lock:
             assert_equal(peer.message_count.get("getavaproofs", 0), 0)
 
         # Make sure there is no message sent as part as the periodic network
         # messaging either
         node.mockscheduler(AVALANCHE_MAX_PERIODIC_NETWORKING_INTERVAL)
         peer.sync_send_with_ping()
         with p2p_lock:
             assert_equal(peer.message_count.get("getavaproofs", 0), 0)
 
     def test_send_inbound_getavaproofs_until_quorum_is_established(self):
         self.log.info(
             "Check we also request the inbounds until the quorum is established")
 
         node = self.nodes[0]
 
         self.restart_node(
             0,
             extra_args=self.extra_args[0] +
             ['-avaminquorumstake=1000000'])
 
         assert_equal(node.getavalancheinfo()['ready_to_poll'], False)
 
         outbound = AvaP2PInterface()
         node.add_outbound_p2p_connection(outbound, p2p_idx=0)
 
         inbound = AvaP2PInterface()
         node.add_p2p_connection(inbound)
         inbound.nodeid = node.getpeerinfo()[-1]['id']
 
         def count_getavaproofs(peers):
             with p2p_lock:
                 return sum([peer.message_count.get("getavaproofs", 0)
                            for peer in peers])
 
         # Upon connection only the outbound gets a compact proofs message
         assert_equal(count_getavaproofs([inbound]), 0)
         self.wait_until(lambda: count_getavaproofs([outbound]) == 1)
 
         # Periodic send will include the inbound as well
         current_total = count_getavaproofs([inbound, outbound])
         while count_getavaproofs([inbound]) == 0:
             node.mockscheduler(AVALANCHE_MAX_PERIODIC_NETWORKING_INTERVAL)
             self.wait_until(lambda: count_getavaproofs(
                 [inbound, outbound]) > current_total)
             current_total = count_getavaproofs([inbound, outbound])
 
         # Connect the minimum amount of stake and nodes
         for _ in range(8):
             node.add_p2p_connection(AvaP2PInterface(node))
         self.wait_until(lambda: node.getavalancheinfo()
                         ['ready_to_poll'] is True)
 
         # From now only the outbound is requested
         count_inbound = count_getavaproofs([inbound])
         for _ in range(20):
             node.mockscheduler(AVALANCHE_MAX_PERIODIC_NETWORKING_INTERVAL)
             self.wait_until(lambda: count_getavaproofs(
                 [inbound, outbound]) > current_total)
             current_total = count_getavaproofs([inbound, outbound])
 
         assert_equal(count_getavaproofs([inbound]), count_inbound)
 
     def run_test(self):
         # Most if the tests only need a single node, let the other ones start
         # the node when required
         self.stop_node(1)
 
         self.test_send_outbound_getavaproofs()
         self.test_send_manual_getavaproofs()
         self.test_respond_getavaproofs()
         self.test_request_missing_proofs()
         self.test_send_missing_proofs()
         self.test_compact_proofs_download_on_connect()
         self.test_no_compactproofs_during_ibs()
         self.test_send_inbound_getavaproofs_until_quorum_is_established()
 
 
 if __name__ == '__main__':
     CompactProofsTest().main()
diff --git a/test/functional/abc_p2p_getavaaddr.py b/test/functional/abc_p2p_getavaaddr.py
index a76effab8..1c572c134 100755
--- a/test/functional/abc_p2p_getavaaddr.py
+++ b/test/functional/abc_p2p_getavaaddr.py
@@ -1,472 +1,473 @@
 #!/usr/bin/env python3
 # Copyright (c) 2022 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test getavaaddr p2p message"""
 import time
 from decimal import Decimal
 
 from test_framework.avatools import AvaP2PInterface, gen_proof
 from test_framework.messages import (
     NODE_AVALANCHE,
     NODE_NETWORK,
     AvalancheVote,
     AvalancheVoteError,
     msg_getavaaddr,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import MAX_NODES, assert_equal, p2p_port
 
 # getavaaddr time interval in seconds, as defined in net_processing.cpp
 # A node will ignore repeated getavaaddr during this interval
 GETAVAADDR_INTERVAL = 2 * 60
 
 # Address are sent every 30s on average, with a Poisson filter. Use a large
 # enough delay so it's very unlikely we don't get the message within this time.
 MAX_ADDR_SEND_DELAY = 5 * 60
 
 # The interval between avalanche statistics computation
 AVALANCHE_STATISTICS_INTERVAL = 10 * 60
 
 # The getavaaddr messages are sent every 2 to 5 minutes
 MAX_GETAVAADDR_DELAY = 5 * 60
 
 
 class AddrReceiver(P2PInterface):
     def __init__(self):
         super().__init__()
         self.received_addrs = None
 
     def get_received_addrs(self):
         with p2p_lock:
             return self.received_addrs
 
     def on_addr(self, message):
         self.received_addrs = []
         for addr in message.addrs:
             self.received_addrs.append(f"{addr.ip}:{addr.port}")
 
     def addr_received(self):
         return self.received_addrs is not None
 
 
 class MutedAvaP2PInterface(AvaP2PInterface):
     def __init__(self, node=None):
         super().__init__(node)
         self.is_responding = False
         self.privkey = None
         self.addr = None
         self.poll_received = 0
 
     def set_addr(self, addr):
         self.addr = addr
 
     def on_avapoll(self, message):
         self.poll_received += 1
 
 
 class AllYesAvaP2PInterface(MutedAvaP2PInterface):
     def __init__(self, node=None):
         super().__init__(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 AvaAddrTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = False
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1',
+                            '-avaproofstakeutxodustthreshold=1000000',
                             '-enableavalanchepeerdiscovery=1',
                             '-enableavalancheproofreplacement=1',
                             '-avaproofstakeutxoconfirmations=1',
                             '-avacooldown=0', '-whitelist=noban@127.0.0.1']]
 
     def check_all_peers_received_getavaaddr_once(self, avapeers):
         def received_all_getavaaddr(avapeers):
             with p2p_lock:
                 return all([p.last_message.get("getavaaddr")
                            for p in avapeers])
         self.wait_until(lambda: received_all_getavaaddr(avapeers))
 
         with p2p_lock:
             assert all([p.message_count.get(
                 "getavaaddr", 0) == 1 for p in avapeers])
 
     def getavaaddr_interval_test(self):
         node = self.nodes[0]
 
         # Init mock time
         mock_time = int(time.time())
         node.setmocktime(mock_time)
 
         # Add some avalanche peers to the node
         for _ in range(10):
             node.add_p2p_connection(AllYesAvaP2PInterface(node))
 
         # Build some statistics to ensure some addresses will be returned
         def all_peers_received_poll():
             with p2p_lock:
                 return all([avanode.poll_received >
                            0 for avanode in node.p2ps])
         self.wait_until(all_peers_received_poll)
         node.mockscheduler(AVALANCHE_STATISTICS_INTERVAL)
 
         requester = node.add_p2p_connection(AddrReceiver())
         requester.send_message(msg_getavaaddr())
         # Remember the time we sent the getavaaddr message
         getavaddr_time = mock_time
 
         # Spamming more get getavaaddr has no effect
         for _ in range(10):
             with node.assert_debug_log(["Ignoring repeated getavaaddr from peer"]):
                 requester.send_message(msg_getavaaddr())
 
         # Move the time so we get an addr response
         mock_time += MAX_ADDR_SEND_DELAY
         node.setmocktime(mock_time)
         requester.wait_until(requester.addr_received)
 
         # Elapse the getavaaddr interval and check our message is now accepted
         # again
         mock_time = getavaddr_time + GETAVAADDR_INTERVAL
         node.setmocktime(mock_time)
 
         requester.send_message(msg_getavaaddr())
 
         # We can get an addr message again
         mock_time += MAX_ADDR_SEND_DELAY
         node.setmocktime(mock_time)
         requester.wait_until(requester.addr_received)
 
     def address_test(self, maxaddrtosend, num_proof, num_avanode):
         self.restart_node(
             0,
             extra_args=self.extra_args[0] +
             [f'-maxaddrtosend={maxaddrtosend}'])
         node = self.nodes[0]
 
         # Init mock time
         mock_time = int(time.time())
         node.setmocktime(mock_time)
 
         # Create a bunch of proofs and associate each a bunch of nodes.
         avanodes = []
         for _ in range(num_proof):
             master_privkey, proof = gen_proof(node)
             for n in range(num_avanode):
                 avanode = AllYesAvaP2PInterface() if n % 2 else MutedAvaP2PInterface()
                 avanode.master_privkey = master_privkey
                 avanode.proof = proof
                 node.add_p2p_connection(avanode)
 
                 peerinfo = node.getpeerinfo()[-1]
                 avanode.set_addr(peerinfo["addr"])
 
                 avanodes.append(avanode)
 
         responding_addresses = [
             avanode.addr for avanode in avanodes if avanode.is_responding]
         assert_equal(len(responding_addresses), num_proof * num_avanode // 2)
 
         # Check we have what we expect
         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.
         node.generate(1)
 
         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 time 10 minutes forward so that so that our peers
         # get an availability score computed.
         node.mockscheduler(AVALANCHE_STATISTICS_INTERVAL)
 
         requester = node.add_p2p_connection(AddrReceiver())
         requester.send_and_ping(msg_getavaaddr())
 
         # Sanity check that the availability score is set up as expected
         peerinfo = node.getpeerinfo()
         muted_addresses = [
             avanode.addr for avanode in avanodes if not avanode.is_responding]
         assert all([p['availability_score'] <
                    0 for p in peerinfo if p["addr"] in muted_addresses])
         assert all([p['availability_score'] >
                    0 for p in peerinfo if p["addr"] in responding_addresses])
         # Requester has no availability_score because it's not an avalanche
         # peer
         assert 'availability_score' not in peerinfo[-1].keys()
 
         mock_time += MAX_ADDR_SEND_DELAY
         node.setmocktime(mock_time)
 
         requester.wait_until(requester.addr_received)
         addresses = requester.get_received_addrs()
         assert_equal(len(addresses),
                      min(maxaddrtosend, len(responding_addresses)))
 
         # Check all the addresses belong to responding peer
         assert all([address in responding_addresses for address in addresses])
 
     def getavaaddr_outbound_test(self):
         self.log.info(
             "Check we send a getavaaddr message to our avalanche outbound peers")
         node = self.nodes[0]
 
         # Get rid of previously connected nodes
         node.disconnect_p2ps()
 
         avapeers = []
         for i in range(16):
             avapeer = AvaP2PInterface()
             node.add_outbound_p2p_connection(
                 avapeer,
                 p2p_idx=i,
             )
             avapeers.append(avapeer)
 
         self.check_all_peers_received_getavaaddr_once(avapeers)
 
         # Generate some block to poll for
         node.generate(1)
 
         # Because none of the avalanche peers is responding, our node should
         # fail out of option shortly and send a getavaaddr message to its
         # outbound avalanche peers.
         node.mockscheduler(MAX_GETAVAADDR_DELAY)
 
         def all_peers_received_getavaaddr():
             with p2p_lock:
                 return all([p.message_count.get(
                     "getavaaddr", 0) > 1 for p in avapeers])
         self.wait_until(all_peers_received_getavaaddr)
 
     def getavaaddr_manual_test(self):
         self.log.info(
             "Check we send a getavaaddr message to our manually connected peers that support avalanche")
         node = self.nodes[0]
 
         # Get rid of previously connected nodes
         node.disconnect_p2ps()
 
         def added_node_connected(ip_port):
             added_node_info = node.getaddednodeinfo(ip_port)
             return len(
                 added_node_info) == 1 and added_node_info[0]['connected']
 
         def connect_callback(address, port):
             self.log.debug("Connecting to {}:{}".format(address, port))
 
         p = AvaP2PInterface()
         p2p_idx = 1
         p.peer_accept_connection(
             connect_cb=connect_callback,
             connect_id=p2p_idx,
             net=node.chain,
             timeout_factor=node.timeout_factor,
         )()
         ip_port = f"127.0.01:{p2p_port(MAX_NODES - p2p_idx)}"
 
         node.addnode(node=ip_port, command="add")
         self.wait_until(lambda: added_node_connected(ip_port))
 
         assert_equal(node.getpeerinfo()[-1]['addr'], ip_port)
         assert_equal(node.getpeerinfo()[-1]['connection_type'], 'manual')
 
         p.wait_until(lambda: p.last_message.get("getavaaddr"))
 
         # Generate some block to poll for
         node.generate(1)
 
         # Because our avalanche peer is not responding, our node should fail
         # out of option shortly and send another getavaaddr message.
         node.mockscheduler(MAX_GETAVAADDR_DELAY)
         p.wait_until(lambda: p.message_count.get("getavaaddr", 0) > 1)
 
     def getavaaddr_noquorum(self):
         self.log.info(
             "Check we send a getavaaddr message while our quorum is not established")
         node = self.nodes[0]
 
         self.restart_node(0, extra_args=self.extra_args[0] + [
             '-avaminquorumstake=500000000',
             '-avaminquorumconnectedstakeratio=0.8',
         ])
 
         avapeers = []
         for i in range(16):
             avapeer = AllYesAvaP2PInterface(node)
             node.add_outbound_p2p_connection(
                 avapeer,
                 p2p_idx=i,
                 connection_type="avalanche",
                 services=NODE_NETWORK | NODE_AVALANCHE,
             )
             avapeers.append(avapeer)
 
             peerinfo = node.getpeerinfo()[-1]
             avapeer.set_addr(peerinfo["addr"])
 
         self.check_all_peers_received_getavaaddr_once(avapeers)
 
         def total_getavaaddr_msg():
             with p2p_lock:
                 return sum([p.message_count.get("getavaaddr", 0)
                             for p in avapeers])
 
         # Because we have not enough stake to start polling, we keep requesting
         # more addresses from all our peers
         total_getavaaddr = total_getavaaddr_msg()
         node.mockscheduler(MAX_GETAVAADDR_DELAY)
         self.wait_until(lambda: total_getavaaddr_msg() ==
                         total_getavaaddr + len(avapeers))
 
         # Move the schedulter time forward to make sure we get statistics
         # computed. But since we did not start polling yet it should remain all
         # zero.
         node.mockscheduler(AVALANCHE_STATISTICS_INTERVAL)
 
         def wait_for_availability_score():
             peerinfo = node.getpeerinfo()
             return all([p.get('availability_score', None) == Decimal(0)
                        for p in peerinfo])
         self.wait_until(wait_for_availability_score)
 
         requester = node.add_p2p_connection(AddrReceiver())
         requester.send_and_ping(msg_getavaaddr())
 
         node.setmocktime(int(time.time() + MAX_ADDR_SEND_DELAY))
 
         # Check all the peers addresses are returned.
         requester.wait_until(requester.addr_received)
         addresses = requester.get_received_addrs()
         assert_equal(len(addresses), len(avapeers))
         expected_addresses = [avapeer.addr for avapeer in avapeers]
         assert all([address in expected_addresses for address in addresses])
 
         # Add more nodes so we reach the mininum quorum stake amount.
         for _ in range(4):
             avapeer = AllYesAvaP2PInterface(node)
             node.add_p2p_connection(avapeer)
         self.wait_until(lambda: node.getavalancheinfo()
                         ['ready_to_poll'] is True)
 
         def is_vote_finalized(proof):
             return node.getrawavalancheproof(
                 f"{proof.proofid:0{64}x}").get("finalized", False)
 
         # Wait until all proofs are finalized
         self.wait_until(lambda: all([is_vote_finalized(p.proof)
                         for p in node.p2ps if isinstance(p, AvaP2PInterface)]))
 
         # Go through several rounds of getavaaddr requests. We don't know for
         # sure how many will be sent as it depends on whether the peers
         # responded fast enough during the polling phase, but at some point a
         # single outbound peer will be requested and no more.
         def sent_single_getavaaddr():
             total_getavaaddr = total_getavaaddr_msg()
             node.mockscheduler(MAX_GETAVAADDR_DELAY)
             self.wait_until(lambda: total_getavaaddr_msg()
                             >= total_getavaaddr + 1)
             for p in avapeers:
                 p.sync_send_with_ping()
             return total_getavaaddr_msg() == total_getavaaddr + 1
 
         self.wait_until(sent_single_getavaaddr)
 
     def test_send_inbound_getavaaddr_until_quorum_is_established(self):
         self.log.info(
             "Check we also request the inbounds until the quorum is established")
 
         node = self.nodes[0]
 
         self.restart_node(
             0,
             extra_args=self.extra_args[0] +
             ['-avaminquorumstake=1000000'])
 
         assert_equal(node.getavalancheinfo()['ready_to_poll'], False)
 
         outbound = MutedAvaP2PInterface()
         node.add_outbound_p2p_connection(outbound, p2p_idx=0)
 
         inbound = MutedAvaP2PInterface()
         node.add_p2p_connection(inbound)
         inbound.nodeid = node.getpeerinfo()[-1]['id']
 
         def count_getavaaddr(peers):
             with p2p_lock:
                 return sum([peer.message_count.get("getavaaddr", 0)
                            for peer in peers])
 
         # Upon connection only the outbound gets a getavaaddr message
         assert_equal(count_getavaaddr([inbound]), 0)
         self.wait_until(lambda: count_getavaaddr([outbound]) == 1)
 
         # Periodic send will include the inbound as well
         current_total = count_getavaaddr([inbound, outbound])
         while count_getavaaddr([inbound]) == 0:
             node.mockscheduler(MAX_GETAVAADDR_DELAY)
             self.wait_until(lambda: count_getavaaddr(
                 [inbound, outbound]) > current_total)
             current_total = count_getavaaddr([inbound, outbound])
 
         # Connect the minimum amount of stake and nodes
         for _ in range(8):
             node.add_p2p_connection(AvaP2PInterface(node))
         self.wait_until(lambda: node.getavalancheinfo()
                         ['ready_to_poll'] is True)
 
         # From now only the outbound is requested
         count_inbound = count_getavaaddr([inbound])
         for _ in range(10):
             # Trigger a poll
             node.generate(1)
             inbound.sync_send_with_ping()
 
             node.mockscheduler(MAX_GETAVAADDR_DELAY)
             self.wait_until(lambda: count_getavaaddr(
                 [inbound, outbound]) > current_total)
             current_total = count_getavaaddr([inbound, outbound])
 
         assert_equal(count_getavaaddr([inbound]), count_inbound)
 
     def run_test(self):
         self.getavaaddr_interval_test()
 
         # Limited by maxaddrtosend
         self.address_test(maxaddrtosend=3, num_proof=2, num_avanode=8)
         # Limited by the number of good nodes
         self.address_test(maxaddrtosend=100, num_proof=2, num_avanode=8)
 
         self.getavaaddr_outbound_test()
         self.getavaaddr_manual_test()
         self.getavaaddr_noquorum()
         self.test_send_inbound_getavaaddr_until_quorum_is_established()
 
 
 if __name__ == '__main__':
     AvaAddrTest().main()
diff --git a/test/functional/abc_p2p_proof_inventory.py b/test/functional/abc_p2p_proof_inventory.py
index 9b4532bf6..ea9c85052 100644
--- a/test/functional/abc_p2p_proof_inventory.py
+++ b/test/functional/abc_p2p_proof_inventory.py
@@ -1,350 +1,352 @@
 #!/usr/bin/env python3
 # Copyright (c) 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 proof inventory relaying
 """
 
 import time
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
 from test_framework.avatools import (
     AvaP2PInterface,
     avalanche_proof_from_hex,
     gen_proof,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.messages import (
     MSG_AVA_PROOF,
     MSG_TYPE_MASK,
     CInv,
     msg_avaproof,
     msg_getdata,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
 )
 from test_framework.wallet_util import bytes_to_wif
 
 # Broadcast reattempt occurs every 10 to 15 minutes
 MAX_INITIAL_BROADCAST_DELAY = 15 * 60
 # Delay to allow the node to respond to getdata requests
 UNCONDITIONAL_RELAY_DELAY = 2 * 60
 
 
 class ProofInvStoreP2PInterface(P2PInterface):
     def __init__(self):
         super().__init__()
         self.proof_invs_counter = 0
 
     def on_inv(self, message):
         for i in message.inv:
             if i.type & MSG_TYPE_MASK == MSG_AVA_PROOF:
                 self.proof_invs_counter += 1
 
 
 class ProofInventoryTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 5
         self.extra_args = [[
             '-enableavalanche=1',
+            '-avaproofstakeutxodustthreshold=1000000',
             '-avaproofstakeutxoconfirmations=2',
             '-avacooldown=0',
             '-whitelist=noban@127.0.0.1',
         ]] * self.num_nodes
 
     def generate_proof(self, node, mature=True):
         privkey, proof = gen_proof(node)
 
         if mature:
             node.generate(1)
 
         return privkey, proof
 
     def test_send_proof_inv(self):
         self.log.info("Test sending a proof to our peers")
 
         node = self.nodes[0]
 
         for i in range(10):
             node.add_p2p_connection(ProofInvStoreP2PInterface())
 
         _, proof = self.generate_proof(node)
         assert node.sendavalancheproof(proof.serialize().hex())
 
         def proof_inv_found(peer):
             with p2p_lock:
                 return peer.last_message.get(
                     "inv") and peer.last_message["inv"].inv[-1].hash == proof.proofid
 
         self.wait_until(lambda: all(proof_inv_found(i) for i in node.p2ps))
 
         self.log.info("Test that we don't send the same inv several times")
 
         extra_peer = ProofInvStoreP2PInterface()
         node.add_p2p_connection(extra_peer)
 
         # Send the same proof one more time
         node.sendavalancheproof(proof.serialize().hex())
 
         # Our new extra peer should receive it but not the others
         self.wait_until(lambda: proof_inv_found(extra_peer))
         assert all(p.proof_invs_counter == 1 for p in node.p2ps)
 
         # Send the proof again and force the send loop to be processed
         for peer in node.p2ps:
             node.sendavalancheproof(proof.serialize().hex())
             peer.sync_with_ping()
 
         assert all(p.proof_invs_counter == 1 for p in node.p2ps)
 
     def test_receive_proof(self):
         self.log.info("Test a peer is created on proof reception")
 
         node = self.nodes[0]
         _, proof = self.generate_proof(node)
 
         peer = node.add_p2p_connection(P2PInterface())
 
         msg = msg_avaproof()
         msg.proof = proof
         peer.send_message(msg)
 
         self.wait_until(lambda: proof.proofid in get_proof_ids(node))
 
         self.log.info(
             "Test receiving a proof with an immature utxo is orphaned")
 
         _, orphan = self.generate_proof(node, mature=False)
         orphan_proofid = "{:064x}".format(orphan.proofid)
 
         msg = msg_avaproof()
         msg.proof = orphan
         peer.send_message(msg)
 
         wait_for_proof(node, orphan_proofid, expect_status="orphan")
 
     def test_ban_invalid_proof(self):
         node = self.nodes[0]
         _, bad_proof = self.generate_proof(node)
         bad_proof.stakes = []
 
         privkey = node.get_deterministic_priv_key().key
         missing_stake = node.buildavalancheproof(
             1, 0, privkey, [{
                 'txid': '0' * 64,
                 'vout': 0,
                 'amount': 10000000,
                 'height': 42,
                 'iscoinbase': False,
                 'privatekey': privkey,
             }]
         )
 
-        self.restart_node(0, ['-enableavalanche=1'])
+        self.restart_node(
+            0, ['-enableavalanche=1', '-avaproofstakeutxodustthreshold=1000000'])
 
         peer = node.add_p2p_connection(P2PInterface())
         msg = msg_avaproof()
 
         # Sending a proof with a missing utxo doesn't trigger a ban
         msg.proof = avalanche_proof_from_hex(missing_stake)
         with node.assert_debug_log(["received: avaproof"], ["Misbehaving"]):
             peer.send_message(msg)
             peer.sync_with_ping()
 
         msg.proof = bad_proof
         with node.assert_debug_log([
             'Misbehaving',
             'invalid-proof',
         ]):
             peer.send_message(msg)
             peer.wait_for_disconnect()
 
     def test_proof_relay(self):
         # This test makes no sense with less than 2 nodes !
         assert_greater_than(self.num_nodes, 2)
 
         proofs_keys = [self.generate_proof(self.nodes[0]) for _ in self.nodes]
         proofids = set([proof_key[1].proofid for proof_key in proofs_keys])
         self.sync_all()
 
         def restart_nodes_with_proof(nodes, extra_args=None):
             for node in nodes:
                 privkey, proof = proofs_keys[node.index]
                 self.restart_node(node.index, self.extra_args[node.index] + [
                     "-avaproof={}".format(proof.serialize().hex()),
                     "-avamasterkey={}".format(bytes_to_wif(privkey.get_bytes()))
                 ] + (extra_args or []))
 
         restart_nodes_with_proof(self.nodes[:-1])
 
         chainwork = int(self.nodes[-1].getblockchaininfo()['chainwork'], 16)
         restart_nodes_with_proof(
             self.nodes[-1:], extra_args=[f'-minimumchainwork={chainwork + 100:#x}'])
 
         [[self.connect_nodes(node.index, j)
           for j in range(node.index)] for node in self.nodes]
 
         # Connect a block to make the proofs added to our pool
         self.nodes[0].generate(1)
         self.sync_all()
 
         self.log.info("Nodes should eventually get the proof from their peer")
         self.sync_proofs(self.nodes[:-1])
         for node in self.nodes[:-1]:
             assert_equal(set(get_proof_ids(node)), proofids)
 
         assert self.nodes[-1].getblockchaininfo()['initialblockdownload']
         self.log.info("Except the node that has not completed IBD")
         assert_equal(len(get_proof_ids(self.nodes[-1])), 1)
 
         # The same if we send a proof directly with no download request
         peer = AvaP2PInterface()
         self.nodes[-1].add_p2p_connection(peer)
 
         _, proof = self.generate_proof(self.nodes[0])
         peer.send_avaproof(proof)
         peer.sync_send_with_ping()
         with p2p_lock:
             assert_equal(peer.message_count.get('getdata', 0), 0)
 
         # Leave the nodes in good shape for the next tests
         restart_nodes_with_proof(self.nodes)
         [[self.connect_nodes(node.index, j)
           for j in range(node.index)] for node in self.nodes]
 
     def test_manually_sent_proof(self):
         node0 = self.nodes[0]
 
         _, proof = self.generate_proof(node0)
 
         self.log.info(
             "Send a proof via RPC and check all the nodes download it")
         node0.sendavalancheproof(proof.serialize().hex())
         self.sync_proofs()
 
     def test_unbroadcast(self):
         self.log.info("Test broadcasting proofs")
 
         node = self.nodes[0]
 
         # Disconnect the other nodes/peers, or they will request the proof and
         # invalidate the test
         [n.stop_node() for n in self.nodes[1:]]
         node.disconnect_p2ps()
 
         def add_peers(count):
             peers = []
             for i in range(count):
                 peer = node.add_p2p_connection(ProofInvStoreP2PInterface())
                 peer.wait_for_verack()
                 peers.append(peer)
             return peers
 
         _, proof = self.generate_proof(node)
         proofid_hex = "{:064x}".format(proof.proofid)
 
         # Broadcast the proof
         peers = add_peers(3)
         assert node.sendavalancheproof(proof.serialize().hex())
         wait_for_proof(node, proofid_hex)
 
         def proof_inv_received(peers):
             with p2p_lock:
                 return all(p.last_message.get(
                     "inv") and p.last_message["inv"].inv[-1].hash == proof.proofid for p in peers)
 
         self.wait_until(lambda: proof_inv_received(peers))
 
         # If no peer request the proof for download, the node should reattempt
         # broadcasting to all new peers after 10 to 15 minutes.
         peers = add_peers(3)
         node.mockscheduler(MAX_INITIAL_BROADCAST_DELAY + 1)
         peers[-1].sync_with_ping()
         self.wait_until(lambda: proof_inv_received(peers))
 
         # If at least one peer requests the proof, there is no more attempt to
         # broadcast it
         node.setmocktime(int(time.time()) + UNCONDITIONAL_RELAY_DELAY)
         msg = msg_getdata([CInv(t=MSG_AVA_PROOF, h=proof.proofid)])
         peers[-1].send_message(msg)
 
         # Give enough time for the node to broadcast the proof again
         peers = add_peers(3)
         node.mockscheduler(MAX_INITIAL_BROADCAST_DELAY + 1)
         peers[-1].sync_with_ping()
 
         assert not proof_inv_received(peers)
 
         self.log.info(
             "Proofs that become invalid should no longer be broadcasted")
 
         # Restart and add connect a new set of peers
         self.restart_node(0)
 
         # Broadcast the proof
         peers = add_peers(3)
         assert node.sendavalancheproof(proof.serialize().hex())
         self.wait_until(lambda: proof_inv_received(peers))
 
         # Sanity check our node knows the proof, and it is valid
         wait_for_proof(node, proofid_hex)
 
         # Mature the utxo then spend it
         node.generate(100)
         utxo = proof.stakes[0].stake.utxo
         raw_tx = node.createrawtransaction(
             inputs=[{
                 # coinbase
                 "txid": "{:064x}".format(utxo.hash),
                 "vout": utxo.n
             }],
             outputs={ADDRESS_ECREG_UNSPENDABLE: 25_000_000 - 250.00},
         )
         signed_tx = node.signrawtransactionwithkey(
             hexstring=raw_tx,
             privkeys=[node.get_deterministic_priv_key().key],
         )
         node.sendrawtransaction(signed_tx['hex'])
 
         # Mine the tx in a block
         node.generate(1)
 
         # Wait for the proof to be invalidated
         def check_proof_not_found(proofid):
             try:
                 assert_raises_rpc_error(-8,
                                         "Proof not found",
                                         node.getrawavalancheproof,
                                         proofid)
                 return True
             except BaseException:
                 return False
         self.wait_until(lambda: check_proof_not_found(proofid_hex))
 
         # It should no longer be broadcasted
         peers = add_peers(3)
         node.mockscheduler(MAX_INITIAL_BROADCAST_DELAY + 1)
         peers[-1].sync_with_ping()
 
         assert not proof_inv_received(peers)
 
     def run_test(self):
         self.test_send_proof_inv()
         self.test_receive_proof()
         self.test_proof_relay()
         self.test_manually_sent_proof()
 
         # Run these tests last because they need to disconnect the nodes
         self.test_unbroadcast()
         self.test_ban_invalid_proof()
 
 
 if __name__ == '__main__':
     ProofInventoryTest().main()
diff --git a/test/functional/abc_rpc_addavalanchenode.py b/test/functional/abc_rpc_addavalanchenode.py
index 4aff85e92..ed2132bb7 100644
--- a/test/functional/abc_rpc_addavalanchenode.py
+++ b/test/functional/abc_rpc_addavalanchenode.py
@@ -1,175 +1,176 @@
 #!/usr/bin/env python3
 # Copyright (c) 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 addavalanchenode RPC"""
 
 from test_framework.avatools import (
     avalanche_proof_from_hex,
     create_coinbase_stakes,
 )
 from test_framework.key import ECKey
 from test_framework.messages import (
     AvalancheDelegation,
     AvalancheDelegationLevel,
     hash256,
     ser_string,
 )
 from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_raises_rpc_error
 from test_framework.wallet_util import bytes_to_wif
 
 
 def add_interface_node(test_node) -> int:
     """Create a peer, connect it to test_node, return the nodeid of the peer as
     registered by test_node.
     """
     n = P2PInterface()
     test_node.add_p2p_connection(n)
     n.wait_for_verack()
     return test_node.getpeerinfo()[-1]['id']
 
 
 class AddAvalancheNodeTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1',
-                            "-avaproofstakeutxoconfirmations=1",
+                            '-avaproofstakeutxodustthreshold=1000000',
+                            '-avaproofstakeutxoconfirmations=1',
                             '-avacooldown=0']]
 
     def run_test(self):
         node = self.nodes[0]
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(2, addrkey0.address)
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         privkey = ECKey()
         privkey.generate()
         wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         proof_master = privkey.get_pubkey().get_bytes().hex()
         proof_sequence = 42
         proof_expiration = 2000000000
         proof = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey, stakes)
 
         nodeid = add_interface_node(node)
 
         def check_addavalanchenode_error(
                 error_code, error_message, nodeid=nodeid, proof=proof, pubkey=proof_master, delegation=None):
             assert_raises_rpc_error(
                 error_code,
                 error_message,
                 node.addavalanchenode,
                 nodeid,
                 pubkey,
                 proof,
                 delegation,
             )
 
         self.log.info("Invalid proof")
         check_addavalanchenode_error(-22,
                                      "Proof must be an hexadecimal string",
                                      proof="not a proof")
         check_addavalanchenode_error(-22,
                                      "Proof has invalid format",
                                      proof="f000")
         no_stake = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey, [])
         check_addavalanchenode_error(-8,
                                      "The proof is invalid: no-stake",
                                      proof=no_stake)
 
         self.log.info("Node doesn't exist")
         check_addavalanchenode_error(-8,
                                      f"The node does not exist: {nodeid + 1}",
                                      nodeid=nodeid + 1)
 
         self.log.info("Invalid delegation")
         dg_privkey = ECKey()
         dg_privkey.generate()
         dg_pubkey = dg_privkey.get_pubkey().get_bytes()
         check_addavalanchenode_error(-22,
                                      "Delegation must be an hexadecimal string",
                                      pubkey=dg_pubkey.hex(),
                                      delegation="not a delegation")
         check_addavalanchenode_error(-22,
                                      "Delegation has invalid format",
                                      pubkey=dg_pubkey.hex(),
                                      delegation="f000")
 
         self.log.info("Delegation mismatch with the proof")
         delegation_wrong_proofid = AvalancheDelegation()
         check_addavalanchenode_error(-8,
                                      "The delegation does not match the proof",
                                      pubkey=dg_pubkey.hex(),
                                      delegation=delegation_wrong_proofid.serialize().hex())
 
         proofobj = avalanche_proof_from_hex(proof)
         delegation = AvalancheDelegation(
             limited_proofid=proofobj.limited_proofid,
             proof_master=proofobj.master,
         )
 
         self.log.info("Delegation with bad signature")
         bad_level = AvalancheDelegationLevel(
             pubkey=dg_pubkey,
         )
         delegation.levels.append(bad_level)
         check_addavalanchenode_error(-8,
                                      "The delegation is invalid",
                                      pubkey=dg_pubkey.hex(),
                                      delegation=delegation.serialize().hex())
 
         delegation.levels = []
         level = AvalancheDelegationLevel(
             pubkey=dg_pubkey,
             sig=privkey.sign_schnorr(
                 hash256(
                     delegation.getid() +
                     ser_string(dg_pubkey)
                 )
             )
         )
         delegation.levels.append(level)
 
         self.log.info("Key mismatch with the proof")
         check_addavalanchenode_error(
             -5,
             "The public key does not match the proof",
             pubkey=dg_pubkey.hex(),
         )
 
         self.log.info("Key mismatch with the delegation")
         random_privkey = ECKey()
         random_privkey.generate()
         random_pubkey = random_privkey.get_pubkey()
         check_addavalanchenode_error(
             -5,
             "The public key does not match the delegation",
             pubkey=random_pubkey.get_bytes().hex(),
             delegation=delegation.serialize().hex(),
         )
 
         self.log.info("Happy path")
         assert node.addavalanchenode(nodeid, proof_master, proof)
         # Adding several times is OK
         assert node.addavalanchenode(nodeid, proof_master, proof)
 
         self.log.info("Add a node with a valid delegation")
         assert node.addavalanchenode(
             nodeid,
             dg_pubkey.hex(),
             proof,
             delegation.serialize().hex(),
         )
 
         self.log.info("Several nodes can share a proof")
         nodeid2 = add_interface_node(node)
         assert node.addavalanchenode(nodeid2, proof_master, proof)
 
 
 if __name__ == '__main__':
     AddAvalancheNodeTest().main()
diff --git a/test/functional/abc_rpc_avalancheproof.py b/test/functional/abc_rpc_avalancheproof.py
index c1c2791e6..e3cc536d7 100644
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -1,659 +1,663 @@
 #!/usr/bin/env python3
 # Copyright (c) 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 building avalanche proofs and using them to add avalanche peers."""
 import base64
 from decimal import Decimal
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE, base58_to_byte
 from test_framework.avatools import (
     avalanche_proof_from_hex,
     create_coinbase_stakes,
     create_stakes,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.cashaddr import PUBKEY_TYPE, encode_full
 from test_framework.key import ECKey
 from test_framework.messages import (
     AvalancheDelegation,
     AvalancheDelegationLevel,
     AvalancheProof,
     FromHex,
     LegacyAvalancheProof,
     msg_avaproof,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 from test_framework.util import (
     append_config,
     assert_equal,
     assert_raises_rpc_error,
 )
 from test_framework.wallet_util import bytes_to_wif
 
 AVALANCHE_MAX_PROOF_STAKES = 1000
 
 PROOF_DUST_THRESHOLD = 1000000.0
 """Minimum amount per UTXO in a proof (in coins, not in satoshis)"""
 
 # From delegation.h
 MAX_DELEGATION_LEVELS = 20
 
 
 def add_interface_node(test_node) -> str:
     """Create a mininode, connect it to test_node, return the nodeid
     of the mininode as registered by test_node.
     """
     n = P2PInterface()
     test_node.add_p2p_connection(n)
     n.wait_for_verack()
     return test_node.getpeerinfo()[-1]['id']
 
 
 class LegacyAvalancheProofTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
-        self.extra_args = [
-            ['-enableavalanche=1', '-avaproofstakeutxoconfirmations=1', '-avacooldown=0', '-legacyavaproof=1']] * self.num_nodes
+        self.extra_args = [['-enableavalanche=1',
+                            '-avaproofstakeutxodustthreshold={}'.format(
+                                PROOF_DUST_THRESHOLD),
+                            '-avaproofstakeutxoconfirmations=1',
+                            '-avacooldown=0',
+                            '-legacyavaproof=1']] * self.num_nodes
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def run_test(self):
         # Turn off node 1 while node 0 mines blocks to generate stakes,
         # so that we can later try starting node 1 with an orphan proof.
         self.stop_node(1)
 
         node = self.nodes[0]
 
         # FIXME Remove after the hardcoded addresses have been converted in the
         # LUT from test_node.py
         def legacy_to_ecash_p2pkh(legacy):
             payload, _ = base58_to_byte(legacy)
             return encode_full('ecregtest', PUBKEY_TYPE, payload)
 
         addrkey0 = node.get_deterministic_priv_key()
         node_ecash_addr = legacy_to_ecash_p2pkh(addrkey0.address)
 
         blockhashes = node.generatetoaddress(100, node_ecash_addr)
 
         self.log.info(
             "Make build a valid proof and restart the node to use it")
         privkey = ECKey()
         privkey.set(bytes.fromhex(
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
         wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         def get_hex_pubkey(privkey):
             return privkey.get_pubkey().get_bytes().hex()
 
         proof_master = get_hex_pubkey(privkey)
         proof_sequence = 11
         proof_expiration = 12
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
         proof = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey, stakes)
 
         self.log.info("Test decodeavalancheproof RPC")
         proofobj = FromHex(LegacyAvalancheProof(), proof)
         decodedproof = node.decodeavalancheproof(proof)
         limited_id_hex = f"{proofobj.limited_proofid:0{64}x}"
         proofid_hex = f"{proofobj.proofid:0{64}x}"
         assert_equal(decodedproof["sequence"], proof_sequence)
         assert_equal(decodedproof["expiration"], proof_expiration)
         assert_equal(decodedproof["master"], proof_master)
         assert_equal(decodedproof["payoutscript"]["hex"], "")
         assert "signature" not in decodedproof.keys()
         assert_equal(decodedproof["proofid"], proofid_hex)
         assert_equal(decodedproof["limitedid"], limited_id_hex)
         assert_equal(decodedproof["staked_amount"], Decimal('50000000.00'))
         assert_equal(decodedproof["score"], 5000)
         assert_equal(decodedproof["stakes"][0]["txid"], stakes[0]["txid"])
         assert_equal(decodedproof["stakes"][0]["vout"], stakes[0]["vout"])
         assert_equal(decodedproof["stakes"][0]["height"], stakes[0]["height"])
         assert_equal(
             decodedproof["stakes"][0]["iscoinbase"],
             stakes[0]["iscoinbase"])
         assert_equal(
             decodedproof["stakes"][0]["address"],
             node_ecash_addr)
         assert_equal(
             decodedproof["stakes"][0]["signature"],
             base64.b64encode(proofobj.stakes[0].sig).decode("ascii"))
 
         # Invalid hex (odd number of hex digits)
         assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
                                 node.decodeavalancheproof, proof[:-1])
         # Valid hex but invalid proof
         assert_raises_rpc_error(-22, "Proof has invalid format",
                                 node.decodeavalancheproof, proof[:-2])
 
         self.log.info(
             "Testing decodeavalancheproof with legacyavaproof disabled")
         self.restart_node(0, self.extra_args[0] + ["-legacyavaproof=0"])
 
         regular_proof = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey, stakes, ADDRESS_ECREG_UNSPENDABLE)
         decoded_regular_proof = node.decodeavalancheproof(regular_proof)
 
         assert_equal(
             decoded_regular_proof["sequence"],
             decodedproof["sequence"])
         assert_equal(
             decoded_regular_proof["expiration"],
             decodedproof["expiration"])
         assert_equal(decoded_regular_proof["master"], decodedproof["master"])
         assert_equal(decoded_regular_proof["payoutscript"], {
             "asm": "OP_DUP OP_HASH160 0000000000000000000000000000000000000000 OP_EQUALVERIFY OP_CHECKSIG",
             "hex": "76a914000000000000000000000000000000000000000088ac",
             "reqSigs": 1,
             "type": "pubkeyhash",
             "addresses": [ADDRESS_ECREG_UNSPENDABLE],
         })
 
         regular_proof_obj = FromHex(AvalancheProof(), regular_proof)
         assert_equal(
             decoded_regular_proof["signature"],
             base64.b64encode(regular_proof_obj.signature).decode("ascii"))
         assert_equal(
             decoded_regular_proof["proofid"],
             f"{regular_proof_obj.proofid:0{64}x}")
         assert_equal(
             decoded_regular_proof["limitedid"],
             f"{regular_proof_obj.limited_proofid:0{64}x}")
         assert_equal(
             decoded_regular_proof["staked_amount"],
             decodedproof["staked_amount"])
         assert_equal(
             decoded_regular_proof["score"],
             decodedproof["score"])
         assert_equal(
             decoded_regular_proof["stakes"][0]["txid"],
             decodedproof["stakes"][0]["txid"])
         assert_equal(
             decoded_regular_proof["stakes"][0]["vout"],
             decodedproof["stakes"][0]["vout"])
         assert_equal(
             decoded_regular_proof["stakes"][0]["height"],
             decodedproof["stakes"][0]["height"])
         assert_equal(
             decoded_regular_proof["stakes"][0]["iscoinbase"],
             decodedproof["stakes"][0]["iscoinbase"])
         assert_equal(
             decoded_regular_proof["stakes"][0]["address"],
             decodedproof["stakes"][0]["address"])
         assert_equal(
             decoded_regular_proof["stakes"][0]["signature"],
             base64.b64encode(regular_proof_obj.stakes[0].sig).decode("ascii"))
 
         # Restart the node with this proof
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
 
         self.log.info("The proof is registered at first chaintip update")
         assert_equal(len(node.getavalanchepeerinfo()), 0)
         node.generate(1)
         self.wait_until(lambda: len(node.getavalanchepeerinfo()) == 1,
                         timeout=5)
 
         # This case will occur for users building proofs with a third party
         # tool and then starting a new node that is not yet aware of the
         # transactions used for stakes.
         self.log.info("Start a node with an orphan proof")
 
         stake_age = node.getblockcount() + 2
         self.restart_node(1, self.extra_args[0] + [
             "-avaproofstakeutxoconfirmations={}".format(stake_age),
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
         # Mine a block to trigger an attempt at registering the proof
         self.connect_nodes(1, node.index)
         self.sync_all()
         self.nodes[1].generate(1)
         wait_for_proof(self.nodes[1], proofid_hex, expect_status="orphan")
 
         # Mine another block to make the orphan mature
         self.nodes[1].generate(1)
         wait_for_proof(self.nodes[0], proofid_hex)
 
         self.log.info(
             "Generate delegations for the proof, verify and decode them")
 
         # Stack up a few delegation levels
         def gen_privkey():
             pk = ECKey()
             pk.generate()
             return pk
 
         delegator_privkey = privkey
         delegation = None
         for i in range(MAX_DELEGATION_LEVELS):
             delegated_privkey = gen_privkey()
             delegated_pubkey = get_hex_pubkey(delegated_privkey)
             delegation = node.delegateavalancheproof(
                 limited_id_hex,
                 bytes_to_wif(delegator_privkey.get_bytes()),
                 delegated_pubkey,
                 delegation,
             )
 
             assert node.verifyavalanchedelegation(delegation)
 
             dg_info = node.decodeavalanchedelegation(delegation)
             assert_equal(dg_info['pubkey'], delegated_pubkey)
             assert_equal(dg_info['proofmaster'], proof_master)
             assert 'delegationid' in dg_info.keys()
             assert_equal(dg_info['limitedid'], limited_id_hex)
             assert_equal(dg_info['proofid'], proofid_hex)
             assert_equal(dg_info['depth'], i + 1)
             assert_equal(len(dg_info['levels']), dg_info['depth'])
             assert_equal(dg_info['levels'][-1]['pubkey'], delegated_pubkey)
             assert 'signature' in dg_info['levels'][-1]
 
             delegator_privkey = delegated_privkey
 
         self.log.info("Check the delegation levels are limited")
         too_many_levels_privkey = gen_privkey()
         too_many_levels_delegation = node.delegateavalancheproof(
             limited_id_hex,
             bytes_to_wif(delegator_privkey.get_bytes()),
             get_hex_pubkey(too_many_levels_privkey),
             delegation,
         )
 
         assert_raises_rpc_error(-8,
                                 "too-many-levels",
                                 node.verifyavalanchedelegation,
                                 too_many_levels_delegation)
 
         random_privkey = gen_privkey()
         random_pubkey = get_hex_pubkey(random_privkey)
 
         # Invalid proof
         no_stake = node.buildavalancheproof(proof_sequence, proof_expiration,
                                             wif_privkey, [])
 
         # Invalid privkey
         assert_raises_rpc_error(-5, "The private key is invalid",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(bytes(32)),
                                 random_pubkey,
                                 )
 
         # Invalid delegation
         bad_dg = AvalancheDelegation()
         assert_raises_rpc_error(-8, "The delegation does not match the proof",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 bad_dg.serialize().hex(),
                                 )
 
         # Still invalid, but with a matching proofid
         bad_dg.limited_proofid = proofobj.limited_proofid
         bad_dg.proof_master = proofobj.master
         bad_dg.levels = [AvalancheDelegationLevel()]
         assert_raises_rpc_error(-8, "The delegation is invalid",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 bad_dg.serialize().hex(),
                                 )
 
         # Wrong privkey, match the proof but does not match the delegation
         assert_raises_rpc_error(-5, "The private key does not match the delegation",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 delegation,
                                 )
 
         # Delegation not hex
         assert_raises_rpc_error(-22, "Delegation must be an hexadecimal string.",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 "f00",
                                 )
         # Delegation is hex but ill-formed
         assert_raises_rpc_error(-22, "Delegation has invalid format",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 "dead",
                                 )
 
         # Test invalid proofs
         dust = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key, amount="0"))
 
         dust2 = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key,
                                    amount=f"{PROOF_DUST_THRESHOLD * 0.9999:.2f}"))
 
         missing_stake = node.buildavalancheproof(
             proof_sequence, proof_expiration, wif_privkey, [{
                 'txid': '0' * 64,
                 'vout': 0,
                 'amount': 10000000,
                 'height': 42,
                 'iscoinbase': False,
                 'privatekey': addrkey0.key,
             }]
         )
 
         duplicate_stake = ("0b000000000000000c0000000000000021030b4c866585dd868"
                            "a9d62348a9cd008d6a312937048fff31670e7e920cfc7a74402"
                            "05c5f72f5d6da3085583e75ee79340eb4eff208c89988e7ed0e"
                            "fb30b87298fa30000000000f2052a0100000003000000210227"
                            "d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2"
                            "fc839ef5d3f86076def2e8bc3c40671c1a0eb505da5857a950a"
                            "0cf4625a80018cdd75ac62e61273ff8142f747de67e73f6368c"
                            "8648942b0ef6c065d72a81ad7438a23c11cca05c5f72f5d6da3"
                            "085583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30"
                            "000000000f2052a0100000003000000210227d85ba011276cf2"
                            "5b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3f860"
                            "76def2e8bc3c40671c1a0eb505da5857a950a0cf4625a80018c"
                            "dd75ac62e61273ff8142f747de67e73f6368c8648942b0ef6c0"
                            "65d72a81ad7438a23c11cca")
 
         bad_sig = ("0b000000000000000c0000000000000021030b4c866585dd868a9d62348"
                    "a9cd008d6a312937048fff31670e7e920cfc7a7440105c5f72f5d6da3085"
                    "583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30000000000f20"
                    "52a0100000003000000210227d85ba011276cf25b51df6a188b75e604b3"
                    "8770a462b2d0e9fb2fc839ef5d3faf07f001dd38e9b4a43d07d5d449cc0"
                    "f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
                    "1321b91a79b82d1c2cfd47793261e4ba003cf5")
 
         wrong_order = ("c964aa6fde575e4ce8404581c7be874e21023beefdde700a6bc0203"
                        "6335b4df141c8bc67bb05a971f5ac2745fd683797dde30305d427b7"
                        "06705a5d4b6a368a231d6db62abacf8c29bc32b61e7f65a0a6976aa"
                        "8b86b687bc0260e821e4f0200b9d3bf6d2102449fb5237efe8f647d"
                        "32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68052365271b"
                        "6c71189f5cd7e3b694b77b579080f0b35bae567b96590ab6aa3019b"
                        "018ff9f061f52f1426bdb195d4b6d4dff5114cee90e33dabf0c588e"
                        "badf7774418f54247f6390791706af36fac782302479898b5273f9e"
                        "51a92cb1fb5af43deeb6c8c269403d30ffcb380300134398c42103e"
                        "49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0"
                        "f9e645efa08e97ea0c60e1f0a064fbf08989c084707082727e85dcb"
                        "9f79bb503f76ee6c8dad42a07ef15c89b3750a5631d604b21fafff0"
                        "f4de354ade95c2f28160ae549af0d4ce48c4ca9d0714b1fa5192027"
                        "0f8575e0af610f07b4e602a018ecdbb649b64fff614c0026e9fc8e0"
                        "030092533d422103aac52f4cfca700e7e9824298e0184755112e32f"
                        "359c832f5f6ad2ef62a2c024af812d6d7f2ecc6223a774e19bce1fb"
                        "20d94d6b01ea693638f55c74fdaa5358fa9239d03e4caf3d817e8f7"
                        "48ccad55a27b9d365db06ad5a0b779ac385f3dc8710")
 
         self.log.info(
             "Check the verifyavalancheproof and sendavalancheproof RPCs")
 
         if self.is_wallet_compiled():
             self.log.info(
                 "Check a proof with the maximum number of UTXO is valid")
             new_blocks = node.generate(AVALANCHE_MAX_PROOF_STAKES // 10 + 1)
             # confirm the coinbase UTXOs
             node.generate(101)
             too_many_stakes = create_stakes(
                 node, new_blocks, AVALANCHE_MAX_PROOF_STAKES + 1)
             # Make the newly split UTXOs mature
             node.generate(stake_age)
 
             maximum_stakes = too_many_stakes[:-1]
             good_proof = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
                 wif_privkey, maximum_stakes)
 
             too_many_utxos = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
                 wif_privkey, too_many_stakes)
 
             assert node.verifyavalancheproof(good_proof)
 
         for rpc in [node.verifyavalancheproof, node.sendavalancheproof]:
             assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
                                     rpc, "f00")
             assert_raises_rpc_error(-22, "Proof has invalid format",
                                     rpc, "f00d")
 
             def check_rpc_failure(proof, message):
                 assert_raises_rpc_error(-8, "The proof is invalid: " + message,
                                         rpc, proof)
 
             check_rpc_failure(no_stake, "no-stake")
             check_rpc_failure(dust, "amount-below-dust-threshold")
             check_rpc_failure(duplicate_stake, "duplicated-stake")
             check_rpc_failure(missing_stake, "utxo-missing-or-spent")
             check_rpc_failure(bad_sig, "invalid-stake-signature")
             check_rpc_failure(wrong_order, "wrong-stake-ordering")
             if self.is_wallet_compiled():
                 check_rpc_failure(too_many_utxos, "too-many-utxos")
 
         conflicting_utxo = node.buildavalancheproof(
             proof_sequence + 1, proof_expiration, wif_privkey, stakes)
         assert_raises_rpc_error(-8, "The proof has conflicting utxo with an existing proof",
                                     node.sendavalancheproof, conflicting_utxo)
 
         # Clear the proof pool
         stake_age = node.getblockcount()
         self.restart_node(0, self.extra_args[0] + [
             "-avaproofstakeutxoconfirmations={}".format(stake_age),
             '-enableavalancheproofreplacement=1',
             '-avalancheconflictingproofcooldown=0'
         ])
 
         # Good proof
         assert node.verifyavalancheproof(proof)
 
         peer = node.add_p2p_connection(P2PInterface())
 
         proofid = FromHex(LegacyAvalancheProof(), proof).proofid
         node.sendavalancheproof(proof)
         assert proofid in get_proof_ids(node)
 
         def inv_found():
             with p2p_lock:
                 return peer.last_message.get(
                     "inv") and peer.last_message["inv"].inv[-1].hash == proofid
         self.wait_until(inv_found)
 
         self.log.info("Check the getrawproof RPC")
 
         raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
         assert_equal(raw_proof['proof'], proof)
         assert_equal(raw_proof['orphan'], False)
         assert_equal(raw_proof['boundToPeer'], True)
         assert_equal(raw_proof['conflicting'], False)
         assert_equal(raw_proof['finalized'], False)
 
         assert_raises_rpc_error(-8, "Proof not found",
                                 node.getrawavalancheproof, '0' * 64)
 
         conflicting_proof = node.buildavalancheproof(
             proof_sequence - 1, proof_expiration, wif_privkey, stakes)
         conflicting_proofobj = avalanche_proof_from_hex(conflicting_proof)
         conflicting_proofid_hex = f"{conflicting_proofobj.proofid:0{64}x}"
 
         msg = msg_avaproof()
         msg.proof = conflicting_proofobj
         peer.send_message(msg)
         wait_for_proof(
             node,
             conflicting_proofid_hex,
             expect_status="conflicting")
 
         raw_proof = node.getrawavalancheproof(conflicting_proofid_hex)
         assert_equal(raw_proof['proof'], conflicting_proof)
         assert_equal(raw_proof['orphan'], False)
         assert_equal(raw_proof['boundToPeer'], False)
         assert_equal(raw_proof['conflicting'], True)
         assert_equal(raw_proof['finalized'], False)
 
         # To orphan the proof, we make it immature by switching to a shorter
         # chain
         node.invalidateblock(node.getbestblockhash())
         # Although the chaintip has changed, updatedBlockTip does not get
         # called unless new chainwork needs evaluating, so invalidate another
         # block and then mine a new one.
         node.invalidateblock(node.getbestblockhash())
         node.setmocktime(
             node.getblock(
                 node.getbestblockhash())['mediantime'] +
             100)
         node.generate(1)
 
         # Wait until UpdatedBlockTip has been called so we know the proof
         # validity has updated
         node.syncwithvalidationinterfacequeue()
 
         raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
         assert_equal(raw_proof['proof'], proof)
         assert_equal(raw_proof['orphan'], True)
         assert_equal(raw_proof['boundToPeer'], False)
         assert_equal(raw_proof['conflicting'], False)
         assert_equal(raw_proof['finalized'], False)
 
         self.log.info("Bad proof should be rejected at startup")
 
         self.stop_node(0)
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avasessionkey=0",
             ],
             expected_msg="Error: The avalanche session key is invalid.",
         )
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
             ],
             expected_msg="Error: The avalanche master key is missing for the avalanche proof.",
         )
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
                 "-avamasterkey=0",
             ],
             expected_msg="Error: The avalanche master key is invalid.",
         )
 
         def check_proof_init_error(proof, message):
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avaproof={}".format(proof),
                     "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
                 ],
                 expected_msg="Error: " + message,
             )
 
         check_proof_init_error(no_stake,
                                "The avalanche proof has no stake.")
         check_proof_init_error(dust,
                                "The avalanche proof stake is too low.")
         check_proof_init_error(dust2,
                                "The avalanche proof stake is too low.")
         check_proof_init_error(duplicate_stake,
                                "The avalanche proof has duplicated stake.")
         check_proof_init_error(bad_sig,
                                "The avalanche proof has invalid stake signatures.")
         if self.is_wallet_compiled():
             # The too many utxos case creates a proof which is that large that it
             # cannot fit on the command line
             append_config(node.datadir, ["avaproof={}".format(too_many_utxos)])
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
                 ],
                 expected_msg="Error: The avalanche proof has too many utxos.",
                 match=ErrorMatch.PARTIAL_REGEX,
             )
 
         # Master private key mismatch
         random_privkey = ECKey()
         random_privkey.generate()
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(random_privkey.get_bytes())),
             ],
             expected_msg="Error: The master key does not match the proof public key.",
         )
 
         self.log.info("Bad delegation should be rejected at startup")
 
         def check_delegation_init_error(delegation, message):
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avadelegation={}".format(delegation),
                     "-avaproof={}".format(proof),
                     "-avamasterkey={}".format(
                         bytes_to_wif(delegated_privkey.get_bytes())),
                     # Prevent the node from adding a delegation level
                     "-avasessionkey={}".format(
                         bytes_to_wif(delegated_privkey.get_bytes())),
                 ],
                 expected_msg="Error: " + message,
             )
 
         check_delegation_init_error(
             AvalancheDelegation().serialize().hex(),
             "The delegation does not match the proof.")
 
         bad_level_sig = FromHex(AvalancheDelegation(), delegation)
         # Tweak some key to cause the signature to mismatch
         bad_level_sig.levels[-2].pubkey = bytes.fromhex(proof_master)
         check_delegation_init_error(bad_level_sig.serialize().hex(),
                                     "The avalanche delegation has invalid signatures.")
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avadelegation={}".format(delegation),
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(random_privkey.get_bytes())),
             ],
             expected_msg="Error: The master key does not match the delegation public key.",
         )
 
         # The node stacks another delegation level at startup
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avadelegation={}".format(delegation),
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(delegated_privkey.get_bytes())),
             ],
             expected_msg="Error: The avalanche delegation has too many delegation levels.",
         )
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avadelegation={}".format(too_many_levels_delegation),
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(too_many_levels_privkey.get_bytes())),
                 "-avasessionkey={}".format(
                     bytes_to_wif(too_many_levels_privkey.get_bytes())),
             ],
             expected_msg="Error: The avalanche delegation has too many delegation levels.",
         )
 
 
 if __name__ == '__main__':
     LegacyAvalancheProofTest().main()
diff --git a/test/functional/abc_rpc_getavalancheinfo.py b/test/functional/abc_rpc_getavalancheinfo.py
index 8bb4a832c..50018ade9 100755
--- a/test/functional/abc_rpc_getavalancheinfo.py
+++ b/test/functional/abc_rpc_getavalancheinfo.py
@@ -1,378 +1,379 @@
 #!/usr/bin/env python3
 # Copyright (c) 2022 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 getavalancheinfo RPC."""
 import time
 from decimal import Decimal
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
 from test_framework.avatools import (
     AvaP2PInterface,
     avalanche_proof_from_hex,
     create_coinbase_stakes,
     gen_proof,
     get_ava_p2p_interface,
     wait_for_proof,
 )
 from test_framework.key import ECKey
 from test_framework.messages import (
     AvalancheProofVoteResponse,
     AvalancheVote,
     LegacyAvalancheProof,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, try_rpc
 from test_framework.wallet_util import bytes_to_wif
 
 
 class GetAvalancheInfoTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.conflicting_proof_cooldown = 100
         self.extra_args = [[
             '-enableavalanche=1',
             '-enableavalancheproofreplacement=1',
             f'-avalancheconflictingproofcooldown={self.conflicting_proof_cooldown}',
             '-avaproofstakeutxoconfirmations=2',
             '-avacooldown=0',
             '-enableavalanchepeerdiscovery=1',
             '-avaminquorumstake=250000000',
             '-avaminquorumconnectedstakeratio=0.9',
+            '-avaproofstakeutxodustthreshold=1000000',
         ]]
 
     def run_test(self):
         node = self.nodes[0]
 
         privkey, proof = gen_proof(node)
         is_legacy = isinstance(proof, LegacyAvalancheProof)
 
         # Make the proof mature
         node.generate(1)
 
         def handle_legacy_format(expected):
             # Add the payout address to the expected output if the legacy format
             # is diabled
             if not is_legacy and "local" in expected.keys():
                 expected["local"]["payout_address"] = ADDRESS_ECREG_UNSPENDABLE
 
             return expected
 
         def assert_avalancheinfo(expected):
             assert_equal(
                 node.getavalancheinfo(),
                 handle_legacy_format(expected)
             )
 
         coinbase_amount = Decimal('25000000.00')
 
         self.log.info("The test node has no proof")
 
         assert_avalancheinfo({
             "ready_to_poll": False,
             "network": {
                 "proof_count": 0,
                 "connected_proof_count": 0,
                 "dangling_proof_count": 0,
                 "finalized_proof_count": 0,
                 "conflicting_proof_count": 0,
                 "immature_proof_count": 0,
                 "total_stake_amount": Decimal('0.00'),
                 "connected_stake_amount": Decimal('0.00'),
                 "dangling_stake_amount": Decimal('0.00'),
                 "node_count": 0,
                 "connected_node_count": 0,
                 "pending_node_count": 0,
             }
         })
 
         self.log.info("The test node has a proof")
 
         self.restart_node(0, self.extra_args[0] + [
             '-enableavalanche=1',
             '-avaproof={}'.format(proof.serialize().hex()),
             '-avamasterkey={}'.format(bytes_to_wif(privkey.get_bytes()))
         ])
         assert_avalancheinfo({
             "ready_to_poll": False,
             "local": {
                 "verified": False,
                 "proofid": f"{proof.proofid:0{64}x}",
                 "limited_proofid": f"{proof.limited_proofid:0{64}x}",
                 "master": privkey.get_pubkey().get_bytes().hex(),
                 "stake_amount": coinbase_amount,
             },
             "network": {
                 "proof_count": 0,
                 "connected_proof_count": 0,
                 "dangling_proof_count": 0,
                 "finalized_proof_count": 0,
                 "conflicting_proof_count": 0,
                 "immature_proof_count": 0,
                 "total_stake_amount": Decimal('0.00'),
                 "connected_stake_amount": Decimal('0.00'),
                 "dangling_stake_amount": Decimal('0.00'),
                 "node_count": 0,
                 "connected_node_count": 0,
                 "pending_node_count": 0,
             }
         })
 
         # Mine a block to trigger proof validation
         node.generate(1)
         self.wait_until(
             lambda: node.getavalancheinfo() == handle_legacy_format({
                 "ready_to_poll": False,
                 "local": {
                     "verified": True,
                     "proofid": f"{proof.proofid:0{64}x}",
                     "limited_proofid": f"{proof.limited_proofid:0{64}x}",
                     "master": privkey.get_pubkey().get_bytes().hex(),
                     "stake_amount": coinbase_amount,
                 },
                 "network": {
                     "proof_count": 1,
                     "connected_proof_count": 1,
                     "dangling_proof_count": 0,
                     "finalized_proof_count": 0,
                     "conflicting_proof_count": 0,
                     "immature_proof_count": 0,
                     "total_stake_amount": coinbase_amount,
                     "connected_stake_amount": coinbase_amount,
                     "dangling_stake_amount": Decimal('0.00'),
                     "node_count": 1,
                     "connected_node_count": 1,
                     "pending_node_count": 0,
                 }
             })
         )
 
         self.log.info("Connect a bunch of peers and nodes")
 
         mock_time = int(time.time())
         node.setmocktime(mock_time)
 
         privkeys = []
         proofs = []
         conflicting_proofs = []
         quorum = []
         N = 13
         for _ in range(N):
             _privkey, _proof = gen_proof(node)
             proofs.append(_proof)
             privkeys.append(_privkey)
 
             # For each proof, also make a conflicting one
             stakes = create_coinbase_stakes(
                 node, [node.getbestblockhash()], node.get_deterministic_priv_key().key)
             conflicting_proof_hex = node.buildavalancheproof(
                 10, 9999, bytes_to_wif(_privkey.get_bytes()), stakes)
             conflicting_proof = avalanche_proof_from_hex(conflicting_proof_hex)
             conflicting_proofs.append(conflicting_proof)
 
             # Make the proof and its conflicting proof mature
             node.generate(1)
 
             n = AvaP2PInterface()
             n.proof = _proof
             n.master_privkey = _privkey
             node.add_p2p_connection(n)
             quorum.append(n)
 
             n.send_avaproof(_proof)
             wait_for_proof(node, f"{_proof.proofid:0{64}x}")
 
             mock_time += self.conflicting_proof_cooldown
             node.setmocktime(mock_time)
             n.send_avaproof(conflicting_proof)
 
         # Generate an orphan (immature) proof
         _, orphan_proof = gen_proof(node)
         n.send_avaproof(orphan_proof)
 
         self.wait_until(
             lambda: node.getavalancheinfo() == handle_legacy_format({
                 "ready_to_poll": True,
                 "local": {
                     "verified": True,
                     "proofid": f"{proof.proofid:0{64}x}",
                     "limited_proofid": f"{proof.limited_proofid:0{64}x}",
                     "master": privkey.get_pubkey().get_bytes().hex(),
                     "stake_amount": coinbase_amount,
                 },
                 "network": {
                     "proof_count": N + 1,
                     "connected_proof_count": N + 1,
                     "dangling_proof_count": 0,
                     "finalized_proof_count": 0,
                     "conflicting_proof_count": N,
                     "immature_proof_count": 1,
                     "total_stake_amount": coinbase_amount * (N + 1),
                     "connected_stake_amount": coinbase_amount * (N + 1),
                     "dangling_stake_amount": Decimal('0.00'),
                     "node_count": N + 1,
                     "connected_node_count": N + 1,
                     "pending_node_count": 0,
                 }
             })
         )
 
         self.log.info("Disconnect some nodes")
 
         D = 3
         for _ in range(D):
             n = node.p2ps.pop()
             n.peer_disconnect()
             n.wait_for_disconnect()
 
         self.wait_until(
             lambda: node.getavalancheinfo() == handle_legacy_format({
                 "ready_to_poll": True,
                 "local": {
                     "verified": True,
                     "proofid": f"{proof.proofid:0{64}x}",
                     "limited_proofid": f"{proof.limited_proofid:0{64}x}",
                     "master": privkey.get_pubkey().get_bytes().hex(),
                     "stake_amount": coinbase_amount,
                 },
                 "network": {
                     "proof_count": N + 1,
                     "connected_proof_count": N - D + 1,
                     "dangling_proof_count": D,
                     "finalized_proof_count": 0,
                     "conflicting_proof_count": N,
                     "immature_proof_count": 1,
                     "total_stake_amount": coinbase_amount * (N + 1),
                     "connected_stake_amount": coinbase_amount * (N + 1 - D),
                     "dangling_stake_amount": coinbase_amount * D,
                     "node_count": N + 1 - D,
                     "connected_node_count": N + 1 - D,
                     "pending_node_count": 0,
                 }
             })
         )
 
         self.log.info("Add some pending nodes")
 
         P = 3
         for _ in range(P):
             dg_priv = ECKey()
             dg_priv.generate()
             dg_pub = dg_priv.get_pubkey().get_bytes().hex()
 
             _privkey, _proof = gen_proof(node)
 
             # Make the proof mature
             node.generate(1)
 
             delegation = node.delegateavalancheproof(
                 f"{_proof.limited_proofid:0{64}x}",
                 bytes_to_wif(_privkey.get_bytes()),
                 dg_pub,
                 None
             )
 
             n = get_ava_p2p_interface(node)
             n.send_avahello(delegation, dg_priv)
             # Make sure we completed at least one time the ProcessMessage or we
             # might miss the last pending node for the following assert
             n.sync_with_ping()
 
         assert_avalancheinfo({
             "ready_to_poll": True,
             "local": {
                 "verified": True,
                 "proofid": f"{proof.proofid:0{64}x}",
                 "limited_proofid": f"{proof.limited_proofid:0{64}x}",
                 "master": privkey.get_pubkey().get_bytes().hex(),
                 "stake_amount": coinbase_amount,
             },
             "network": {
                 # Orphan became mature
                 "proof_count": N + 2,
                 "connected_proof_count": N + 1 - D,
                 "dangling_proof_count": D + 1,
                 "finalized_proof_count": 0,
                 "conflicting_proof_count": N,
                 "immature_proof_count": 0,
                 "total_stake_amount": coinbase_amount * (N + 2),
                 "connected_stake_amount": coinbase_amount * (N + 1 - D),
                 "dangling_stake_amount": coinbase_amount * (D + 1),
                 "node_count": N + 1 - D + P,
                 "connected_node_count": N + 1 - D,
                 "pending_node_count": P,
             }
         })
 
         self.log.info("Finalize the proofs for some peers")
 
         def vote_for_all_proofs():
             for i, n in enumerate(quorum):
                 if not n.is_connected:
                     continue
 
                 poll = n.get_avapoll_if_available()
 
                 # That node has not received a poll
                 if poll is None:
                     continue
 
                 # Respond yes to all polls except the conflicting proofs
                 votes = []
                 for inv in poll.invs:
                     response = AvalancheProofVoteResponse.ACTIVE
                     if inv.hash in [p.proofid for p in conflicting_proofs]:
                         response = AvalancheProofVoteResponse.REJECTED
 
                     votes.append(AvalancheVote(response, inv.hash))
 
                 n.send_avaresponse(poll.round, votes, privkeys[i])
 
             # Check if all proofs are finalized or invalidated
             return all(
                 [node.getrawavalancheproof(f"{p.proofid:0{64}x}").get("finalized", False) for p in proofs] +
                 [try_rpc(-8, "Proof not found", node.getrawavalancheproof,
                          f"{c.proofid:0{64}x}") for c in conflicting_proofs]
             )
 
         # Vote until proofs have finalized
         expected_logs = []
         for p in proofs:
             expected_logs.append(
                 f"Avalanche finalized proof {p.proofid:0{64}x}")
         with node.assert_debug_log(expected_logs):
             self.wait_until(lambda: vote_for_all_proofs())
 
         self.log.info(
             "Disconnect all the nodes, so we are the only node left on the network")
 
         node.disconnect_p2ps()
 
         assert_avalancheinfo({
             "ready_to_poll": False,
             "local": {
                 "verified": True,
                 "proofid": f"{proof.proofid:0{64}x}",
                 "limited_proofid": f"{proof.limited_proofid:0{64}x}",
                 "master": privkey.get_pubkey().get_bytes().hex(),
                 "stake_amount": coinbase_amount,
             },
             "network": {
                 "proof_count": N + 2,
                 "connected_proof_count": 1,
                 "dangling_proof_count": N + 1,
                 "finalized_proof_count": N + 1,
                 "conflicting_proof_count": 0,
                 "immature_proof_count": 0,
                 "total_stake_amount": coinbase_amount * (N + 2),
                 "connected_stake_amount": coinbase_amount,
                 "dangling_stake_amount": coinbase_amount * (N + 1),
                 "node_count": 1,
                 "connected_node_count": 1,
                 "pending_node_count": 0,
             }
         })
 
 
 if __name__ == '__main__':
     GetAvalancheInfoTest().main()
diff --git a/test/functional/abc_rpc_getavalanchepeerinfo.py b/test/functional/abc_rpc_getavalanchepeerinfo.py
index 6e769eef5..3c47cc769 100755
--- a/test/functional/abc_rpc_getavalanchepeerinfo.py
+++ b/test/functional/abc_rpc_getavalanchepeerinfo.py
@@ -1,92 +1,93 @@
 #!/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 (
     avalanche_proof_from_hex,
     create_coinbase_stakes,
     get_ava_p2p_interface,
 )
 from test_framework.key import ECKey
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 from test_framework.wallet_util import bytes_to_wif
 
 
 class GetAvalanchePeerInfoTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1',
+                            '-avaproofstakeutxodustthreshold=1000000',
                             '-avaproofstakeutxoconfirmations=1',
                             '-avacooldown=0']]
 
     def run_test(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 = node.generatetoaddress(peercount, addrkey0.address)
         # 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 = 12
             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(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 = f"{avalanche_proof_from_hex(proofs[i]).proofid:0{64}x}"
             assert_equal(peer["avalanche_peerid"], i)
             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=f"{target_proofid:0{64}x}")
         assert_equal(len(avapeerinfo), 1)
         assert_equal(avapeerinfo[0]["proof"], target_proof)
 
 
 if __name__ == '__main__':
     GetAvalanchePeerInfoTest().main()
diff --git a/test/functional/p2p_eviction.py b/test/functional/p2p_eviction.py
index def745fe1..f3721bb06 100755
--- a/test/functional/p2p_eviction.py
+++ b/test/functional/p2p_eviction.py
@@ -1,207 +1,208 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 """ Test node eviction logic
 
 When the number of peers has reached the limit of maximum connections,
 the next connecting inbound peer will trigger the eviction mechanism.
 We cannot currently test the parts of the eviction logic that are based on
 address/netgroup since in the current framework, all peers are connecting from
 the same local address. See Issue #14210 for more info.
 Therefore, this test is limited to the remaining protection criteria.
 """
 
 import time
 
 from test_framework.avatools import (
     AvaP2PInterface,
     avalanche_proof_from_hex,
     create_coinbase_stakes,
 )
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.key import ECKey
 from test_framework.messages import (
     CTransaction,
     FromHex,
     msg_avaproof,
     msg_pong,
     msg_tx,
 )
 from test_framework.p2p import P2PDataStore, P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 from test_framework.wallet_util import bytes_to_wif
 
 
 class SlowP2PDataStore(P2PDataStore):
     def on_ping(self, message):
         time.sleep(0.1)
         self.send_message(msg_pong(message.nonce))
 
 
 class SlowP2PInterface(P2PInterface):
     def on_ping(self, message):
         time.sleep(0.1)
         self.send_message(msg_pong(message.nonce))
 
 
 class SlowAvaP2PInterface(AvaP2PInterface):
     def on_ping(self, message):
         time.sleep(0.1)
         self.send_message(msg_pong(message.nonce))
 
 
 class P2PEvict(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         # The choice of maxconnections=188 results in a maximum of 153 inbound
         # connections (188 - 34 outbound - 1 feeler). The 34 outbounds count is
         # from 16 full-relay + 16 avalanche + 2 block-only-relay.
         # 152 inbound peers are protected from eviction:
         # 4 by netgroup, 4 that sent us blocks, 4 that sent us proofs, 4 that
         # sent us transactions, 8 via lowest ping time, 128 with the best
         # avalanche availability score
         self.extra_args = [["-maxconnections=188",
                             "-enableavalanche=1",
+                            "-avaproofstakeutxodustthreshold=1000000",
                             "-avaproofstakeutxoconfirmations=1",
                             "-maxavalancheoutbound=16"]]
 
     def run_test(self):
         # peers that we expect to be protected from eviction
         protected_peers = set()
         current_peer = -1
         node = self.nodes[0]
         blocks = node.generatetoaddress(
             101, node.get_deterministic_priv_key().address)
 
         self.log.info(
             "Create 4 peers and protect them from eviction by sending us a block")
         for _ in range(4):
             block_peer = node.add_p2p_connection(SlowP2PDataStore())
             current_peer += 1
             block_peer.sync_with_ping()
             best_block = node.getbestblockhash()
             tip = int(best_block, 16)
             best_block_time = node.getblock(best_block)['time']
             block = create_block(
                 tip,
                 create_coinbase(
                     node.getblockcount() + 1),
                 best_block_time + 1)
             block.solve()
             block_peer.send_blocks_and_test([block], node, success=True)
             protected_peers.add(current_peer)
 
         self.log.info(
             "Create 4 peers and protect them from eviction by sending us a proof")
         privkey = ECKey()
         privkey.generate()
         wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         stakes = create_coinbase_stakes(
             node, blocks, node.get_deterministic_priv_key().key)
 
         for i in range(4):
             proof_peer = node.add_p2p_connection(SlowP2PDataStore())
             current_peer += 1
             proof_peer.sync_with_ping()
 
             proof = node.buildavalancheproof(
                 42, 2000000000, wif_privkey, [stakes[i]])
 
             avaproof_msg = msg_avaproof()
             avaproof_msg.proof = avalanche_proof_from_hex(proof)
             proof_peer.send_message(avaproof_msg)
             protected_peers.add(current_peer)
 
         self.log.info(
             "Create 5 slow-pinging peers, making them eviction candidates")
         for _ in range(5):
             node.add_p2p_connection(SlowP2PInterface())
             current_peer += 1
 
         self.log.info(
             "Create 4 peers and protect them from eviction by sending us a tx")
         for i in range(4):
             txpeer = node.add_p2p_connection(SlowP2PInterface())
             current_peer += 1
             txpeer.sync_with_ping()
 
             prevtx = node.getblock(node.getblockhash(i + 1), 2)['tx'][0]
             rawtx = node.createrawtransaction(
                 inputs=[{'txid': prevtx['txid'], 'vout': 0}],
                 outputs=[
                     {node.get_deterministic_priv_key().address: 50000000 - 1250.00}],
             )
             sigtx = node.signrawtransactionwithkey(
                 hexstring=rawtx,
                 privkeys=[node.get_deterministic_priv_key().key],
                 prevtxs=[{
                     'txid': prevtx['txid'],
                     'vout': 0,
                     'amount': prevtx['vout'][0]['value'],
                     'scriptPubKey': prevtx['vout'][0]['scriptPubKey']['hex'],
                 }],
             )['hex']
             txpeer.send_message(msg_tx(FromHex(CTransaction(), sigtx)))
             protected_peers.add(current_peer)
 
         self.log.info(
             "Create 8 peers and protect them from eviction by having faster pings")
         for _ in range(8):
             fastpeer = node.add_p2p_connection(P2PInterface())
             current_peer += 1
             self.wait_until(lambda: "ping" in fastpeer.last_message,
                             timeout=10)
 
         self.log.info(
             "Create 128 peers and protect them from eviction by sending an avahello message")
 
         for _ in range(128):
             node.add_p2p_connection(SlowAvaP2PInterface())
             current_peer += 1
 
         # Make sure by asking the node what the actual min pings are
         peerinfo = node.getpeerinfo()
         pings = {}
         for i in range(len(peerinfo)):
             pings[i] = peerinfo[i]['minping'] if 'minping' in peerinfo[i] else 1000000
         sorted_pings = sorted(pings.items(), key=lambda x: x[1])
 
         # Usually the 8 fast peers are protected. In rare case of unreliable pings,
         # one of the slower peers might have a faster min ping though.
         for i in range(8):
             protected_peers.add(sorted_pings[i][0])
 
         self.log.info("Create peer that triggers the eviction mechanism")
         node.add_p2p_connection(SlowP2PInterface())
 
         # One of the non-protected peers must be evicted. We can't be sure which one because
         # 4 peers are protected via netgroup, which is identical for all peers,
         # and the eviction mechanism doesn't preserve the order of identical
         # elements.
         evicted_peers = []
         for i in range(len(node.p2ps)):
             if not node.p2ps[i].is_connected:
                 evicted_peers.append(i)
 
         self.log.info("Test that one peer was evicted")
         self.log.debug(
             "{} evicted peer: {}".format(
                 len(evicted_peers),
                 set(evicted_peers)))
         assert_equal(len(evicted_peers), 1)
 
         self.log.info("Test that no peer expected to be protected was evicted")
         self.log.debug(
             "{} protected peers: {}".format(
                 len(protected_peers),
                 protected_peers))
         assert evicted_peers[0] not in protected_peers
 
 
 if __name__ == '__main__':
     P2PEvict().main()
diff --git a/test/functional/p2p_inv_download.py b/test/functional/p2p_inv_download.py
index a39abef46..94a637f0d 100755
--- a/test/functional/p2p_inv_download.py
+++ b/test/functional/p2p_inv_download.py
@@ -1,479 +1,480 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
 Test inventory download behavior
 """
 
 import functools
 import time
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
 from test_framework.avatools import (
     avalanche_proof_from_hex,
     gen_proof,
     wait_for_proof,
 )
 from test_framework.key import ECKey
 from test_framework.messages import (
     MSG_AVA_PROOF,
     MSG_TX,
     MSG_TYPE_MASK,
     CInv,
     CTransaction,
     FromHex,
     msg_avaproof,
     msg_inv,
     msg_notfound,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 from test_framework.wallet_util import bytes_to_wif
 
 
 class TestP2PConn(P2PInterface):
     def __init__(self, inv_type):
         super().__init__()
         self.inv_type = inv_type
         self.getdata_count = 0
 
     def on_getdata(self, message):
         for i in message.inv:
             if i.type & MSG_TYPE_MASK == self.inv_type:
                 self.getdata_count += 1
 
 
 class NetConstants:
     """Constants from net_processing"""
 
     def __init__(self,
                  getdata_interval,
                  inbound_peer_delay,
                  overloaded_peer_delay,
                  max_getdata_in_flight,
                  max_peer_announcements,
                  bypass_request_limits_permission_flags,
                  ):
         self.getdata_interval = getdata_interval
         self.inbound_peer_delay = inbound_peer_delay
         self.overloaded_peer_delay = overloaded_peer_delay
         self.max_getdata_in_flight = max_getdata_in_flight
         self.max_peer_announcements = max_peer_announcements
         self.max_getdata_inbound_wait = self.getdata_interval + self.inbound_peer_delay
         self.bypass_request_limits_permission_flags = bypass_request_limits_permission_flags
 
 
 class TestContext:
     def __init__(self, inv_type, inv_name, constants):
         self.inv_type = inv_type
         self.inv_name = inv_name
         self.constants = constants
 
     def p2p_conn(self):
         return TestP2PConn(self.inv_type)
 
 
 PROOF_TEST_CONTEXT = TestContext(
     MSG_AVA_PROOF,
     "avalanche proof",
     NetConstants(
         getdata_interval=60,  # seconds
         inbound_peer_delay=2,  # seconds
         overloaded_peer_delay=2,  # seconds
         max_getdata_in_flight=100,
         max_peer_announcements=5000,
         bypass_request_limits_permission_flags="bypass_proof_request_limits",
     ),
 )
 
 TX_TEST_CONTEXT = TestContext(
     MSG_TX,
     "transaction",
     NetConstants(
         getdata_interval=60,  # seconds
         inbound_peer_delay=2,  # seconds
         overloaded_peer_delay=2,  # seconds
         max_getdata_in_flight=100,
         max_peer_announcements=5000,
         bypass_request_limits_permission_flags="relay",
     ),
 )
 
 # Python test constants
 NUM_INBOUND = 10
 
 # Common network parameters
 UNCONDITIONAL_RELAY_DELAY = 2 * 60
 
 
 def skip(context):
     def decorator(test):
         @functools.wraps(test)
         def wrapper(*args, **kwargs):
             # Assume the signature is test(self, context) unless context is
             # passed by name
             call_context = kwargs.get("context", args[1])
             if call_context == context:
                 return lambda *args, **kwargs: None
             return test(*args, **kwargs)
         return wrapper
     return decorator
 
 
 class InventoryDownloadTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [['-enableavalanche=1',
+                            '-avaproofstakeutxodustthreshold=1000000',
                             '-avaproofstakeutxoconfirmations=1',
                             '-avacooldown=0']] * self.num_nodes
 
     def test_data_requests(self, context):
         self.log.info(
             "Test that we request data from all our peers, eventually")
 
         invid = 0xdeadbeef
 
         self.log.info("Announce the invid from each incoming peer to node 0")
         msg = msg_inv([CInv(t=context.inv_type, h=invid)])
         for p in self.nodes[0].p2ps:
             p.send_and_ping(msg)
 
         outstanding_peer_index = [i for i in range(len(self.nodes[0].p2ps))]
 
         def getdata_found(peer_index):
             p = self.nodes[0].p2ps[peer_index]
             with p2p_lock:
                 return p.last_message.get(
                     "getdata") and p.last_message["getdata"].inv[-1].hash == invid
 
         node_0_mocktime = int(time.time())
         while outstanding_peer_index:
             node_0_mocktime += context.constants.max_getdata_inbound_wait
             self.nodes[0].setmocktime(node_0_mocktime)
             self.wait_until(lambda: any(getdata_found(i)
                                         for i in outstanding_peer_index))
             for i in outstanding_peer_index:
                 if getdata_found(i):
                     outstanding_peer_index.remove(i)
 
         self.nodes[0].setmocktime(0)
         self.log.info("All outstanding peers received a getdata")
 
     @skip(PROOF_TEST_CONTEXT)
     def test_inv_tx(self, context):
         self.log.info("Generate a transaction on node 0")
         tx = self.nodes[0].createrawtransaction(
             inputs=[{
                 # coinbase
                 "txid": self.nodes[0].getblock(self.nodes[0].getblockhash(1))['tx'][0],
                 "vout": 0
             }],
             outputs={ADDRESS_ECREG_UNSPENDABLE: 50000000 - 250.00},
         )
         tx = self.nodes[0].signrawtransactionwithkey(
             hexstring=tx,
             privkeys=[self.nodes[0].get_deterministic_priv_key().key],
         )['hex']
         ctx = FromHex(CTransaction(), tx)
         txid = int(ctx.rehash(), 16)
 
         self.log.info(
             "Announce the transaction to all nodes from all {} incoming peers, but never send it".format(NUM_INBOUND))
         msg = msg_inv([CInv(t=context.inv_type, h=txid)])
         for p in self.peers:
             p.send_and_ping(msg)
 
         self.log.info("Put the tx in node 0's mempool")
         self.nodes[0].sendrawtransaction(tx)
 
         # node1 is an inbound peer for node0, so the tx relay is delayed by a
         # duration calculated using a poisson's law with a 5s average time.
         # In order to make sure the inv is sent we move the time 2 minutes
         # forward, which has the added side effect that the tx can be
         # unconditionally requested.
         with self.nodes[1].assert_debug_log([f"got inv: tx {txid:064x}  new peer=0"]):
             self.nodes[0].setmocktime(
                 int(time.time()) + UNCONDITIONAL_RELAY_DELAY)
 
         # Since node 1 is connected outbound to an honest peer (node 0), it
         # should get the tx within a timeout.
         # The timeout is the sum of
         # * the worst case until the tx is first requested from an inbound
         #   peer, plus
         # * the first time it is re-requested from the outbound peer, plus
         # * 2 seconds to avoid races
         assert self.nodes[1].getpeerinfo()[0]['inbound'] is False
         max_delay = context.constants.inbound_peer_delay + \
             context.constants.getdata_interval
         margin = 2
         self.log.info(
             "Tx should be received at node 1 after {} seconds".format(max_delay + margin))
         self.nodes[1].setmocktime(int(time.time()) + max_delay)
         self.sync_mempools(timeout=margin)
 
     def test_in_flight_max(self, context):
         max_getdata_in_flight = context.constants.max_getdata_in_flight
         max_inbound_delay = context.constants.inbound_peer_delay + \
             context.constants.overloaded_peer_delay
 
         self.log.info("Test that we don't load peers with more than {} getdata requests immediately".format(
             max_getdata_in_flight))
         invids = [i for i in range(max_getdata_in_flight + 2)]
 
         p = self.nodes[0].p2ps[0]
 
         with p2p_lock:
             p.getdata_count = 0
 
         mock_time = int(time.time() + 1)
         self.nodes[0].setmocktime(mock_time)
         for i in range(max_getdata_in_flight):
             p.send_message(msg_inv([CInv(t=context.inv_type, h=invids[i])]))
         p.sync_with_ping()
         mock_time += context.constants.inbound_peer_delay
         self.nodes[0].setmocktime(mock_time)
         p.wait_until(lambda: p.getdata_count >= max_getdata_in_flight)
         for i in range(max_getdata_in_flight, len(invids)):
             p.send_message(msg_inv([CInv(t=context.inv_type, h=invids[i])]))
         p.sync_with_ping()
         self.log.info(
             "No more than {} requests should be seen within {} seconds after announcement".format(
                 max_getdata_in_flight,
                 max_inbound_delay - 1))
         self.nodes[0].setmocktime(
             mock_time +
             max_inbound_delay - 1)
         p.sync_with_ping()
         with p2p_lock:
             assert_equal(p.getdata_count, max_getdata_in_flight)
         self.log.info(
             "If we wait {} seconds after announcement, we should eventually get more requests".format(
                 max_inbound_delay))
         self.nodes[0].setmocktime(
             mock_time +
             max_inbound_delay)
         p.wait_until(lambda: p.getdata_count == len(invids))
 
     def test_expiry_fallback(self, context):
         self.log.info(
             'Check that expiry will select another peer for download')
         peer1 = self.nodes[0].add_p2p_connection(context.p2p_conn())
         peer2 = self.nodes[0].add_p2p_connection(context.p2p_conn())
         for p in [peer1, peer2]:
             p.send_message(msg_inv([CInv(t=context.inv_type, h=0xffaa)]))
         # One of the peers is asked for the data
         peer2.wait_until(
             lambda: sum(
                 p.getdata_count for p in [
                     peer1, peer2]) == 1)
         with p2p_lock:
             peer_expiry, peer_fallback = (
                 peer1, peer2) if peer1.getdata_count == 1 else (
                 peer2, peer1)
             assert_equal(peer_fallback.getdata_count, 0)
         # Wait for request to peer_expiry to expire
         self.nodes[0].setmocktime(
             int(time.time()) + context.constants.getdata_interval + 1)
         peer_fallback.wait_until(
             lambda: peer_fallback.getdata_count >= 1)
         with p2p_lock:
             assert_equal(peer_fallback.getdata_count, 1)
         # reset mocktime
         self.restart_node(0)
 
     def test_disconnect_fallback(self, context):
         self.log.info(
             'Check that disconnect will select another peer for download')
         peer1 = self.nodes[0].add_p2p_connection(context.p2p_conn())
         peer2 = self.nodes[0].add_p2p_connection(context.p2p_conn())
         for p in [peer1, peer2]:
             p.send_message(msg_inv([CInv(t=context.inv_type, h=0xffbb)]))
         # One of the peers is asked for the data
         peer2.wait_until(
             lambda: sum(
                 p.getdata_count for p in [
                     peer1, peer2]) == 1)
         with p2p_lock:
             peer_disconnect, peer_fallback = (
                 peer1, peer2) if peer1.getdata_count == 1 else (
                 peer2, peer1)
             assert_equal(peer_fallback.getdata_count, 0)
         peer_disconnect.peer_disconnect()
         peer_disconnect.wait_for_disconnect()
         peer_fallback.wait_until(
             lambda: peer_fallback.getdata_count >= 1)
         with p2p_lock:
             assert_equal(peer_fallback.getdata_count, 1)
 
     def test_notfound_fallback(self, context):
         self.log.info(
             'Check that notfounds will select another peer for download immediately')
         peer1 = self.nodes[0].add_p2p_connection(context.p2p_conn())
         peer2 = self.nodes[0].add_p2p_connection(context.p2p_conn())
         for p in [peer1, peer2]:
             p.send_message(msg_inv([CInv(t=context.inv_type, h=0xffdd)]))
         # One of the peers is asked for the data
         peer2.wait_until(
             lambda: sum(
                 p.getdata_count for p in [
                     peer1, peer2]) == 1)
         with p2p_lock:
             peer_notfound, peer_fallback = (
                 peer1, peer2) if peer1.getdata_count == 1 else (
                 peer2, peer1)
             assert_equal(peer_fallback.getdata_count, 0)
         # Send notfound, so that fallback peer is selected
         peer_notfound.send_and_ping(msg_notfound(
             vec=[CInv(context.inv_type, 0xffdd)]))
         peer_fallback.wait_until(
             lambda: peer_fallback.getdata_count >= 1)
         with p2p_lock:
             assert_equal(peer_fallback.getdata_count, 1)
 
     def test_preferred_inv(self, context):
         self.log.info(
             'Check that invs from preferred peers are downloaded immediately')
         self.restart_node(
             0,
             extra_args=self.extra_args[0] +
             ['-whitelist=noban@127.0.0.1'])
         peer = self.nodes[0].add_p2p_connection(context.p2p_conn())
         peer.send_message(msg_inv([CInv(t=context.inv_type, h=0xff00ff00)]))
         peer.wait_until(lambda: peer.getdata_count >= 1)
         with p2p_lock:
             assert_equal(peer.getdata_count, 1)
 
     def test_large_inv_batch(self, context):
         max_peer_announcements = context.constants.max_peer_announcements
         net_permissions = context.constants.bypass_request_limits_permission_flags
         self.log.info(
             'Test how large inv batches are handled with {} permission'.format(net_permissions))
         self.restart_node(
             0,
             extra_args=self.extra_args[0] +
             ['-whitelist={}@127.0.0.1'.format(net_permissions)])
         peer = self.nodes[0].add_p2p_connection(context.p2p_conn())
         peer.send_message(msg_inv([CInv(t=context.inv_type, h=invid)
                                    for invid in range(max_peer_announcements + 1)]))
         peer.wait_until(lambda: peer.getdata_count ==
                         max_peer_announcements + 1)
 
         self.log.info(
             'Test how large inv batches are handled without {} permission'.format(net_permissions))
         self.restart_node(0)
         peer = self.nodes[0].add_p2p_connection(context.p2p_conn())
         peer.send_message(msg_inv([CInv(t=context.inv_type, h=invid)
                                    for invid in range(max_peer_announcements + 1)]))
         peer.wait_until(lambda: peer.getdata_count ==
                         max_peer_announcements)
         peer.sync_with_ping()
         with p2p_lock:
             assert_equal(peer.getdata_count, max_peer_announcements)
 
     def test_spurious_notfound(self, context):
         self.log.info('Check that spurious notfound is ignored')
         self.nodes[0].p2ps[0].send_message(
             msg_notfound(vec=[CInv(context.inv_type, 1)]))
 
     @skip(TX_TEST_CONTEXT)
     def test_orphan_download(self, context):
         node = self.nodes[0]
 
         # Build a proof with immature utxos so it will be orphaned
         privkey, orphan = gen_proof(node)
         proofid_hex = "{:064x}".format(orphan.proofid)
 
         self.restart_node(0, extra_args=self.extra_args[0] + [
             "-avaproofstakeutxoconfirmations=3",
             "-avaproof={}".format(orphan.serialize().hex()),
             "-avamasterkey={}".format(bytes_to_wif(privkey.get_bytes())),
         ])
         node.generate(1)
         wait_for_proof(node, proofid_hex, expect_status="orphan")
 
         peer = node.add_p2p_connection(context.p2p_conn())
         peer.send_message(
             msg_inv([CInv(t=context.inv_type, h=orphan.proofid)]))
 
         # Give enough time for the node to eventually request the proof.
         node.setmocktime(int(time.time()) +
                          context.constants.getdata_interval + 1)
         peer.sync_with_ping()
 
         assert_equal(peer.getdata_count, 0)
 
     @skip(TX_TEST_CONTEXT)
     def test_request_invalid_once(self, context):
         node = self.nodes[0]
         privkey = ECKey()
         privkey.generate()
 
         # Build an invalid proof (no stake)
         no_stake_hex = node.buildavalancheproof(
             42, 2000000000, bytes_to_wif(privkey.get_bytes()), []
         )
         no_stake = avalanche_proof_from_hex(no_stake_hex)
         assert_raises_rpc_error(-8,
                                 "The proof is invalid: no-stake",
                                 node.verifyavalancheproof,
                                 no_stake_hex)
 
         # Send the proof
         msg = msg_avaproof()
         msg.proof = no_stake
         node.p2ps[0].send_message(msg)
 
         # Check we get banned
         node.p2ps[0].wait_for_disconnect()
 
         # Now that the node knows the proof is invalid, it should not be
         # requested anymore
         node.p2ps[1].send_message(
             msg_inv([CInv(t=context.inv_type, h=no_stake.proofid)]))
 
         # Give enough time for the node to eventually request the proof
         node.setmocktime(int(time.time()) +
                          context.constants.getdata_interval + 1)
         node.p2ps[1].sync_with_ping()
 
         assert all(p.getdata_count == 0 for p in node.p2ps[1:])
 
     def run_test(self):
         for context in [TX_TEST_CONTEXT, PROOF_TEST_CONTEXT]:
             self.log.info(
                 "Starting tests using " +
                 context.inv_name +
                 " inventory type")
 
             # Run tests without mocktime that only need one peer-connection first,
             # to avoid restarting the nodes
             self.test_expiry_fallback(context)
             self.test_disconnect_fallback(context)
             self.test_notfound_fallback(context)
             self.test_preferred_inv(context)
             self.test_large_inv_batch(context)
             self.test_spurious_notfound(context)
 
             # Run each test against new bitcoind instances, as setting mocktimes has long-term effects on when
             # the next trickle relay event happens.
             for test in [self.test_in_flight_max, self.test_inv_tx,
                          self.test_data_requests, self.test_orphan_download, self.test_request_invalid_once]:
                 self.stop_nodes()
                 self.start_nodes()
                 self.connect_nodes(1, 0)
                 # Setup the p2p connections
                 self.peers = []
                 for node in self.nodes:
                     for _ in range(NUM_INBOUND):
                         self.peers.append(
                             node.add_p2p_connection(
                                 context.p2p_conn()))
                 self.log.info(
                     "Nodes are setup with {} incoming connections each".format(NUM_INBOUND))
                 test(context)
 
 
 if __name__ == '__main__':
     InventoryDownloadTest().main()
diff --git a/test/functional/rpc_net.py b/test/functional/rpc_net.py
index cece84054..3df287fb4 100755
--- a/test/functional/rpc_net.py
+++ b/test/functional/rpc_net.py
@@ -1,301 +1,307 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test RPC calls related to net.
 
 Tests correspond to code in rpc/net.cpp.
 """
 
 import time
 from decimal import Decimal
 from itertools import product
 
 import test_framework.messages
 from test_framework.avatools import create_coinbase_stakes
 from test_framework.key import ECKey
 from test_framework.messages import NODE_NETWORK
 from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_approx,
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
     p2p_port,
 )
 from test_framework.wallet_util import bytes_to_wif
 
 
 def assert_net_servicesnames(servicesflag, servicenames):
     """Utility that checks if all flags are correctly decoded in
     `getpeerinfo` and `getnetworkinfo`.
 
     :param servicesflag: The services as an integer.
     :param servicenames: The list of decoded services names, as strings.
     """
     servicesflag_generated = 0
     for servicename in servicenames:
         servicesflag_generated |= getattr(
             test_framework.messages, 'NODE_' + servicename)
     assert servicesflag_generated == servicesflag
 
 
 class NetTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
-        self.extra_args = [["-enableavalanche=1", "-avaproofstakeutxoconfirmations=1", "-minrelaytxfee=10"],
-                           ["-enableavalanche=1", "-avaproofstakeutxoconfirmations=1", "-minrelaytxfee=5"]]
+        self.extra_args = [["-enableavalanche=1",
+                            "-avaproofstakeutxodustthreshold=1000000",
+                            "-avaproofstakeutxoconfirmations=1",
+                            "-minrelaytxfee=10"],
+                           ["-enableavalanche=1",
+                            "-avaproofstakeutxodustthreshold=1000000",
+                            "-avaproofstakeutxoconfirmations=1",
+                            "-minrelaytxfee=5"]]
         self.supports_cli = False
 
     def run_test(self):
         # Get out of IBD for the minfeefilter and getpeerinfo tests.
         self.nodes[0].generate(101)
         # Connect nodes both ways.
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 0)
         self.sync_all()
 
         self.test_connection_count()
         self.test_getpeerinfo()
         self.test_getnettotals()
         self.test_getnetworkinfo()
         self.test_getaddednodeinfo()
         self.test_service_flags()
         self.test_getnodeaddresses()
 
     def test_connection_count(self):
         self.log.info("Test getconnectioncount")
         # After using `connect_nodes` to connect nodes 0 and 1 to each other.
         assert_equal(self.nodes[0].getconnectioncount(), 2)
 
     def test_getnettotals(self):
         self.log.info("Test getnettotals")
         # Test getnettotals and getpeerinfo by doing a ping. The bytes
         # sent/received should increase by at least the size of one ping (32
         # bytes) and one pong (32 bytes).
         net_totals_before = self.nodes[0].getnettotals()
         peer_info_before = self.nodes[0].getpeerinfo()
         self.nodes[0].ping()
         self.wait_until(
             lambda:
                 self.nodes[0].getnettotals()['totalbytessent']
                 >= net_totals_before['totalbytessent'] + 32 * 2,
             timeout=10)
         self.wait_until(
             lambda:
                 self.nodes[0].getnettotals()['totalbytesrecv']
                 >= net_totals_before['totalbytesrecv'] + 32 * 2,
             timeout=10)
 
         for peer_before in peer_info_before:
             def peer_after():
                 return next(
                     p for p in self.nodes[0].getpeerinfo()
                     if p['id'] == peer_before['id']
                 )
             self.wait_until(
                 lambda:
                     peer_after()['bytesrecv_per_msg'].get('pong', 0)
                     >= peer_before['bytesrecv_per_msg'].get('pong', 0) + 32,
                 timeout=10
             )
             self.wait_until(
                 lambda:
                     peer_after()['bytessent_per_msg'].get('ping', 0)
                     >= peer_before['bytessent_per_msg'].get('ping', 0) + 32,
                 timeout=10)
 
     def test_getnetworkinfo(self):
         self.log.info("Test getnetworkinfo")
         info = self.nodes[0].getnetworkinfo()
         assert_equal(info['networkactive'], True)
         assert_equal(info['connections'], 2)
         assert_equal(info['connections_in'], 1)
         assert_equal(info['connections_out'], 1)
 
         with self.nodes[0].assert_debug_log(expected_msgs=['SetNetworkActive: false\n']):
             self.nodes[0].setnetworkactive(state=False)
         assert_equal(self.nodes[0].getnetworkinfo()['networkactive'], False)
         # Wait a bit for all sockets to close
         self.wait_until(lambda: self.nodes[0].getnetworkinfo()[
             'connections'] == 0, timeout=3)
 
         with self.nodes[0].assert_debug_log(expected_msgs=['SetNetworkActive: true\n']):
             self.nodes[0].setnetworkactive(state=True)
         # Connect nodes both ways.
         self.connect_nodes(0, 1)
         self.connect_nodes(1, 0)
 
         info = self.nodes[0].getnetworkinfo()
         assert_equal(info['networkactive'], True)
         assert_equal(info['connections'], 2)
         assert_equal(info['connections_in'], 1)
         assert_equal(info['connections_out'], 1)
 
         # check the `servicesnames` field
         network_info = [node.getnetworkinfo() for node in self.nodes]
         for info in network_info:
             assert_net_servicesnames(int(info["localservices"], 0x10),
                                      info["localservicesnames"])
 
         # Check dynamically generated networks list in getnetworkinfo help
         # output.
         assert (
             "(ipv4, ipv6, onion, i2p)" in self.nodes[0].help("getnetworkinfo")
         )
 
     def test_getaddednodeinfo(self):
         self.log.info("Test getaddednodeinfo")
         assert_equal(self.nodes[0].getaddednodeinfo(), [])
         # add a node (node2) to node0
         ip_port = "127.0.0.1:{}".format(p2p_port(2))
         self.nodes[0].addnode(node=ip_port, command='add')
         # check that the node has indeed been added
         added_nodes = self.nodes[0].getaddednodeinfo(ip_port)
         assert_equal(len(added_nodes), 1)
         assert_equal(added_nodes[0]['addednode'], ip_port)
         # check that node cannot be added again
         assert_raises_rpc_error(-23,
                                 "Node already added",
                                 self.nodes[0].addnode,
                                 node=ip_port,
                                 command='add')
         # check that node can be removed
         self.nodes[0].addnode(node=ip_port, command='remove')
         assert_equal(self.nodes[0].getaddednodeinfo(), [])
         # check that trying to remove the node again returns an error
         assert_raises_rpc_error(-24,
                                 "Node could not be removed",
                                 self.nodes[0].addnode,
                                 node=ip_port,
                                 command='remove')
         # check that a non-existent node returns an error
         assert_raises_rpc_error(-24, "Node has not been added",
                                 self.nodes[0].getaddednodeinfo, '1.1.1.1')
 
     def test_getpeerinfo(self):
         self.log.info("Test getpeerinfo")
         # Create a few getpeerinfo last_block/last_transaction/last_proof
         # values.
         if self.is_wallet_compiled():
             self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1000000)
         tip = self.nodes[1].generate(1)[0]
         self.sync_all()
 
         stake = create_coinbase_stakes(
             self.nodes[1], [tip], self.nodes[1].get_deterministic_priv_key().key)
         privkey = ECKey()
         privkey.generate()
         proof = self.nodes[1].buildavalancheproof(
             42, 2000000000, bytes_to_wif(privkey.get_bytes()), stake)
         self.nodes[1].sendavalancheproof(proof)
         self.sync_proofs()
 
         time_now = int(time.time())
         peer_info = [x.getpeerinfo() for x in self.nodes]
         # Verify last_block, last_transaction and last_proof keys/values.
         for node, peer, field in product(range(self.num_nodes), range(2), [
                                          'last_block', 'last_transaction', 'last_proof']):
             assert field in peer_info[node][peer].keys()
             if peer_info[node][peer][field] != 0:
                 assert_approx(peer_info[node][peer][field], time_now, vspan=60)
         # check both sides of bidirectional connection between nodes
         # the address bound to on one side will be the source address for the
         # other node
         assert_equal(peer_info[0][0]['addrbind'], peer_info[1][0]['addr'])
         assert_equal(peer_info[1][0]['addrbind'], peer_info[0][0]['addr'])
         assert_equal(peer_info[0][0]['minfeefilter'], Decimal("5.00"))
         assert_equal(peer_info[1][0]['minfeefilter'], Decimal("10.00"))
         # check the `servicesnames` field
         for info in peer_info:
             assert_net_servicesnames(int(info[0]["services"], 0x10),
                                      info[0]["servicesnames"])
 
         assert_equal(peer_info[0][0]['connection_type'], 'inbound')
         assert_equal(peer_info[0][1]['connection_type'], 'manual')
 
         assert_equal(peer_info[1][0]['connection_type'], 'manual')
         assert_equal(peer_info[1][1]['connection_type'], 'inbound')
 
         # Check dynamically generated networks list in getpeerinfo help output.
         assert (
             "(ipv4, ipv6, onion, i2p, not_publicly_routable)" in
             self.nodes[0].help("getpeerinfo")
         )
 
         # Node state fields
         for node, peer, field in product(range(self.num_nodes), range(2),
                                          ['startingheight', 'synced_headers', 'synced_blocks', 'inflight']):
             assert field in peer_info[node][peer].keys()
 
     def test_service_flags(self):
         self.log.info("Test service flags")
         self.nodes[0].add_p2p_connection(
             P2PInterface(), services=(
                 1 << 5) | (
                 1 << 63))
         assert_equal(['UNKNOWN[2^5]', 'UNKNOWN[2^63]'],
                      self.nodes[0].getpeerinfo()[-1]['servicesnames'])
         self.nodes[0].disconnect_p2ps()
 
     def test_getnodeaddresses(self):
         self.log.info("Test getnodeaddresses")
         self.nodes[0].add_p2p_connection(P2PInterface())
 
         # Add an IPv6 address to the address manager.
         ipv6_addr = "1233:3432:2434:2343:3234:2345:6546:4534"
         self.nodes[0].addpeeraddress(address=ipv6_addr, port=8333)
 
         # Add 10,000 IPv4 addresses to the address manager. Due to the way bucket
         # and bucket positions are calculated, some of these addresses will
         # collide.
         imported_addrs = []
         for i in range(10000):
             first_octet = i >> 8
             second_octet = i % 256
             a = f"{first_octet}.{second_octet}.1.1"
             imported_addrs.append(a)
             self.nodes[0].addpeeraddress(a, 8333)
 
         # Fetch the addresses via the RPC and test the results.
         # default count is 1
         assert_equal(len(self.nodes[0].getnodeaddresses()), 1)
         assert_equal(len(self.nodes[0].getnodeaddresses(count=2)), 2)
         assert_equal(
             len(self.nodes[0].getnodeaddresses(network="ipv4", count=8)), 8)
 
         # Maximum possible addresses in AddrMan is 10000. The actual number will
         # usually be less due to bucket and bucket position collisions.
         node_addresses = self.nodes[0].getnodeaddresses(0, "ipv4")
         assert_greater_than(len(node_addresses), 5000)
         assert_greater_than(10000, len(node_addresses))
         for a in node_addresses:
             assert_greater_than(a["time"], 1527811200)  # 1st June 2018
             assert_equal(a["services"], NODE_NETWORK)
             assert a["address"] in imported_addrs
             assert_equal(a["port"], 8333)
             assert_equal(a["network"], "ipv4")
 
         # Test the IPv6 address.
         res = self.nodes[0].getnodeaddresses(0, "ipv6")
         assert_equal(len(res), 1)
         assert_equal(res[0]["address"], ipv6_addr)
         assert_equal(res[0]["network"], "ipv6")
         assert_equal(res[0]["port"], 8333)
         assert_equal(res[0]["services"], NODE_NETWORK)
 
         # Test for the absence of onion and I2P addresses.
         for network in ["onion", "i2p"]:
             assert_equal(self.nodes[0].getnodeaddresses(0, network), [])
 
         # Test invalid arguments.
         assert_raises_rpc_error(-8, "Address count out of range",
                                 self.nodes[0].getnodeaddresses, -1)
         assert_raises_rpc_error(-8, "Network not recognized: Foo",
                                 self.nodes[0].getnodeaddresses, 1, "Foo")
 
 
 if __name__ == '__main__':
     NetTest().main()