diff --git a/src/avalanche/proofbuilder.h b/src/avalanche/proofbuilder.h
index 2f117cde5..a023dd862 100644
--- a/src/avalanche/proofbuilder.h
+++ b/src/avalanche/proofbuilder.h
@@ -1,61 +1,61 @@
 // 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_PROOFBUILDER_H
 #define BITCOIN_AVALANCHE_PROOFBUILDER_H
 
 #include <avalanche/proof.h>
 #include <key.h>
 
 #include <cstdio>
 
 namespace avalanche {
 
 struct TestProofBuilder;
 
 class ProofBuilder {
     uint64_t sequence;
     int64_t expirationTime;
     CKey masterKey;
     CScript payoutScriptPubKey;
 
     struct StakeSigner {
         Stake stake;
         CKey key;
 
         StakeSigner(Stake stake_, CKey key_)
             : stake(std::move(stake_)), key(std::move(key_)) {}
 
         SignedStake sign(const StakeCommitment &commitment);
     };
 
     struct StakeSignerComparator {
         bool operator()(const StakeSigner &lhs, const StakeSigner &rhs) const {
             return lhs.stake.getId() < rhs.stake.getId();
         }
     };
     std::set<StakeSigner, StakeSignerComparator> stakes;
 
 public:
     ProofBuilder(uint64_t sequence_, int64_t expirationTime_, CKey masterKey_,
-                 const CScript &payoutScriptPubKey_ = CScript())
+                 const CScript &payoutScriptPubKey_)
         : sequence(sequence_), expirationTime(expirationTime_),
           masterKey(std::move(masterKey_)),
           payoutScriptPubKey(payoutScriptPubKey_) {}
 
     [[nodiscard]] bool addUTXO(COutPoint utxo, Amount amount, uint32_t height,
                                bool is_coinbase, CKey key);
 
     ProofRef build();
 
 private:
     LimitedProofId getLimitedProofId() const;
     ProofId getProofId() const;
 
     friend struct TestProofBuilder;
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PROOFBUILDER_H
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
index 44bd4e539..208396bb8 100644
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -1,2102 +1,2104 @@
 // 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);
+        ProofBuilder pb(sequence, expirationTime, master,
+                        UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         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(), 40000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[0] || p == peerids[1] || p == peerids[2] ||
                     p == peerids[3]);
     }
 
     // Remove one peer, it nevers show up now.
     BOOST_CHECK(pm.removePeer(peerids[2]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 40000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 10000);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 10000);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 30000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[0] || p == peerids[1] || p == peerids[3]);
     }
 
     // Add 4 more peers.
     for (int i = 0; i < 4; i++) {
         auto p = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         peerids[i + 4] = TestPeerManager::registerAndGetPeerId(pm, p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 70000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     BOOST_CHECK(pm.removePeer(peerids[0]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 70000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 10000);
 
     // Removing the last entry do not increase fragmentation.
     BOOST_CHECK(pm.removePeer(peerids[7]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 60000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 10000);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 10000);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 50000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[1] || p == peerids[3] || p == peerids[4] ||
                     p == peerids[5] || p == peerids[6]);
     }
 
     // Removing non existent peers fails.
     BOOST_CHECK(!pm.removePeer(peerids[0]));
     BOOST_CHECK(!pm.removePeer(peerids[2]));
     BOOST_CHECK(!pm.removePeer(peerids[7]));
     BOOST_CHECK(!pm.removePeer(NO_PEER));
 }
 
 BOOST_AUTO_TEST_CASE(compact_slots) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     // Add 4 peers.
     std::array<PeerId, 4> peerids;
     for (int i = 0; i < 4; i++) {
         auto p = buildRandomProof(chainman.ActiveChainstate(),
                                   MIN_VALID_PROOF_SCORE);
         peerids[i] = TestPeerManager::registerAndGetPeerId(pm, p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     // Remove all peers.
     for (auto p : peerids) {
         pm.removePeer(p);
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 30000);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 30000);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(pm.selectPeer(), NO_PEER);
     }
 
     BOOST_CHECK_EQUAL(pm.compact(), 30000);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 0);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(node_crud) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     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));
     }
 
     // Make the proof immature by reorging to a shorter chain
     {
         BlockValidationState state;
         chainman.ActiveChainstate().InvalidateBlock(GetConfig(), state,
                                                     chainman.ActiveTip());
         BOOST_CHECK_EQUAL(chainman.ActiveHeight(), 99);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(pm.isImmature(proofid));
     BOOST_CHECK(!pm.isBoundToPeer(proofid));
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(!TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 
     // Make the proof great again
     {
         // Advance the clock so the newly mined block won't collide with the
         // other deterministically-generated blocks
         SetMockTime(GetTime() + 20);
         mineBlocks(1);
         BlockValidationState state;
         BOOST_CHECK(
             chainman.ActiveChainstate().ActivateBestChain(GetConfig(), state));
         BOOST_CHECK_EQUAL(chainman.ActiveHeight(), 100);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isImmature(proofid));
     BOOST_CHECK(pm.isBoundToPeer(proofid));
     // The peerid has certainly been updated
     peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
     BOOST_CHECK(pm.verify());
 }
 
 BOOST_AUTO_TEST_CASE(proof_conflict) {
     auto key = CKey::MakeCompressedKey();
 
     TxId txid1(GetRandHash());
     TxId txid2(GetRandHash());
     BOOST_CHECK(txid1 != txid2);
 
     const Amount v = PROOF_DUST_THRESHOLD;
     const int height = 100;
 
     ChainstateManager &chainman = *Assert(m_node.chainman);
     for (uint32_t i = 0; i < 10; i++) {
         addCoin(chainman.ActiveChainstate(), {txid1, i}, key);
         addCoin(chainman.ActiveChainstate(), {txid2, i}, key);
     }
 
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
     CKey masterKey = CKey::MakeCompressedKey();
     const auto getPeerId = [&](const std::vector<COutPoint> &outpoints) {
         return TestPeerManager::registerAndGetPeerId(
             pm, buildProofWithOutpoints(key, outpoints, v, masterKey, 0, height,
                                         false, 0));
     };
 
     // Add one peer.
     const PeerId peer1 = getPeerId({COutPoint(txid1, 0)});
     BOOST_CHECK(peer1 != NO_PEER);
 
     // Same proof, same peer.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0)}), peer1);
 
     // Different txid, different proof.
     const PeerId peer2 = getPeerId({COutPoint(txid2, 0)});
     BOOST_CHECK(peer2 != NO_PEER && peer2 != peer1);
 
     // Different index, different proof.
     const PeerId peer3 = getPeerId({COutPoint(txid1, 1)});
     BOOST_CHECK(peer3 != NO_PEER && peer3 != peer1);
 
     // Empty proof, no peer.
     BOOST_CHECK_EQUAL(getPeerId({}), NO_PEER);
 
     // Multiple inputs.
     const PeerId peer4 = getPeerId({COutPoint(txid1, 2), COutPoint(txid2, 2)});
     BOOST_CHECK(peer4 != NO_PEER && peer4 != peer1);
 
     // Duplicated input.
     {
-        ProofBuilder pb(0, 0, CKey::MakeCompressedKey());
+        ProofBuilder pb(0, 0, CKey::MakeCompressedKey(),
+                        UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         COutPoint o(txid1, 3);
         BOOST_CHECK(pb.addUTXO(o, v, height, false, key));
         BOOST_CHECK(
             !pm.registerProof(TestProofBuilder::buildDuplicatedStakes(pb)));
     }
 
     // Multiple inputs, collision on first input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 4)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on second input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 4), COutPoint(txid2, 0)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on both inputs.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 2)}),
                       NO_PEER);
 }
 
 BOOST_AUTO_TEST_CASE(immature_proofs) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     auto key = CKey::MakeCompressedKey();
     int immatureHeight = 100;
 
     auto registerImmature = [&](const ProofRef &proof) {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proof, state));
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::IMMATURE);
     };
 
     auto checkImmature = [&](const ProofRef &proof, bool expectedImmature) {
         const ProofId &proofid = proof->getId();
         BOOST_CHECK(pm.exists(proofid));
 
         BOOST_CHECK_EQUAL(pm.isImmature(proofid), expectedImmature);
         BOOST_CHECK_EQUAL(pm.isBoundToPeer(proofid), !expectedImmature);
 
         bool ret = false;
         pm.forEachPeer([&](const Peer &peer) {
             if (proof->getId() == peer.proof->getId()) {
                 ret = true;
             }
         });
         BOOST_CHECK_EQUAL(ret, !expectedImmature);
     };
 
     // Track immature proofs so we can test them later
     std::vector<ProofRef> immatureProofs;
 
     // Fill up the immature pool to test the size limit
     for (int64_t i = 1; i <= AVALANCHE_MAX_IMMATURE_PROOFS; i++) {
         COutPoint outpoint = COutPoint(TxId(GetRandHash()), 0);
         auto proof = buildProofWithOutpoints(
             key, {outpoint}, i * PROOF_DUST_THRESHOLD, key, 0, immatureHeight);
         addCoin(chainman.ActiveChainstate(), outpoint, key,
                 i * PROOF_DUST_THRESHOLD, immatureHeight);
         registerImmature(proof);
         checkImmature(proof, true);
         immatureProofs.push_back(proof);
     }
 
     // More immature proofs evict lower scoring proofs
     for (auto i = 0; i < 100; i++) {
         COutPoint outpoint = COutPoint(TxId(GetRandHash()), 0);
         auto proof =
             buildProofWithOutpoints(key, {outpoint}, 200 * PROOF_DUST_THRESHOLD,
                                     key, 0, immatureHeight);
         addCoin(chainman.ActiveChainstate(), outpoint, key,
                 200 * PROOF_DUST_THRESHOLD, immatureHeight);
         registerImmature(proof);
         checkImmature(proof, true);
         immatureProofs.push_back(proof);
         BOOST_CHECK(!pm.exists(immatureProofs.front()->getId()));
         immatureProofs.erase(immatureProofs.begin());
     }
 
     // Replacement when the pool is full still works
     {
         const COutPoint &outpoint =
             immatureProofs.front()->getStakes()[0].getStake().getUTXO();
         auto proof =
             buildProofWithOutpoints(key, {outpoint}, 101 * PROOF_DUST_THRESHOLD,
                                     key, 1, immatureHeight);
         registerImmature(proof);
         checkImmature(proof, true);
         immatureProofs.push_back(proof);
         BOOST_CHECK(!pm.exists(immatureProofs.front()->getId()));
         immatureProofs.erase(immatureProofs.begin());
     }
 
     // Mine a block to increase the chain height, turning all immature proofs to
     // mature
     mineBlocks(1);
     pm.updatedBlockTip();
     for (const auto &proof : immatureProofs) {
         checkImmature(proof, false);
     }
 }
 
 BOOST_AUTO_TEST_CASE(dangling_node) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     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_immature_proofs) {
     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 immature10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto immature20 =
         buildProofWithSequence(key, {conflictingOutpoint, matureOutpoint}, 20);
 
     BOOST_CHECK(!pm.registerProof(immature10));
     BOOST_CHECK(pm.isImmature(immature10->getId()));
 
     BOOST_CHECK(!pm.registerProof(immature20));
     BOOST_CHECK(pm.isImmature(immature20->getId()));
     BOOST_CHECK(!pm.exists(immature10->getId()));
 
     // Build and register a valid proof that will conflict with the immature one
     auto proof30 = buildProofWithOutpoints(key, {matureOutpoint},
                                            PROOF_DUST_THRESHOLD, key, 30, 99);
     BOOST_CHECK(pm.registerProof(proof30));
     BOOST_CHECK(pm.isBoundToPeer(proof30->getId()));
 
     // Reorg to a shorter chain to make proof30 immature
     {
         BlockValidationState state;
         active_chainstate.InvalidateBlock(GetConfig(), state,
                                           chainman.ActiveTip());
         BOOST_CHECK_EQUAL(chainman.ActiveHeight(), 99);
     }
 
     // Check that a rescan will also select the preferred immature proof, in
     // this case proof30 will replace immature20.
     pm.updatedBlockTip();
 
     BOOST_CHECK(!pm.isBoundToPeer(proof30->getId()));
     BOOST_CHECK(pm.isImmature(proof30->getId()));
     BOOST_CHECK(!pm.exists(immature20->getId()));
 }
 
 BOOST_FIXTURE_TEST_CASE(preferred_conflicting_proof, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq30));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq30->getId()));
 
     // proofSeq10 is a worst candidate than proofSeq30, so it goes to the
     // conflicting pool.
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isBoundToPeer(proofSeq10->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
 
     // proofSeq20 is a worst candidate than proofSeq30 but a better one than
     // proogSeq10, so it replaces it in the conflicting pool and proofSeq10 is
     // evicted.
     BOOST_CHECK(!pm.registerProof(proofSeq20));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isBoundToPeer(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
     BOOST_CHECK(!pm.exists(proofSeq10->getId()));
 }
 
 BOOST_FIXTURE_TEST_CASE(update_next_conflict_time, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     auto now = GetTime<std::chrono::seconds>();
     SetMockTime(now.count());
 
     // Updating the time of an unknown peer should fail
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(
             !pm.updateNextPossibleConflictTime(PeerId(GetRandInt(1000)), now));
     }
 
     auto proof =
         buildRandomProof(chainman.ActiveChainstate(), MIN_VALID_PROOF_SCORE);
     PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
 
     auto checkNextPossibleConflictTime = [&](std::chrono::seconds expected) {
         BOOST_CHECK(pm.forPeer(proof->getId(), [&](const Peer &p) {
             return p.nextPossibleConflictTime == expected;
         }));
     };
 
     checkNextPossibleConflictTime(now);
 
     // Move the time in the past is not possible
     BOOST_CHECK(!pm.updateNextPossibleConflictTime(
         peerid, now - std::chrono::seconds{1}));
     checkNextPossibleConflictTime(now);
 
     BOOST_CHECK(pm.updateNextPossibleConflictTime(
         peerid, now + std::chrono::seconds{1}));
     checkNextPossibleConflictTime(now + std::chrono::seconds{1});
 }
 
 BOOST_FIXTURE_TEST_CASE(register_force_accept, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq30));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq30->getId()));
 
     // proofSeq20 is a worst candidate than proofSeq30, so it goes to the
     // conflicting pool.
     BOOST_CHECK(!pm.registerProof(proofSeq20));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
 
     // We can force the acceptance of proofSeq20
     using RegistrationMode = avalanche::PeerManager::RegistrationMode;
     BOOST_CHECK(pm.registerProof(proofSeq20, RegistrationMode::FORCE_ACCEPT));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
 
     // We can also force the acceptance of a proof which is not already in the
     // conflicting pool.
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(!pm.exists(proofSeq10->getId()));
 
     BOOST_CHECK(pm.registerProof(proofSeq10, RegistrationMode::FORCE_ACCEPT));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
     BOOST_CHECK(!pm.exists(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
 
     // Attempting to register again fails, and has no impact on the pools
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(!pm.registerProof(proofSeq10));
         BOOST_CHECK(
             !pm.registerProof(proofSeq10, RegistrationMode::FORCE_ACCEPT));
 
         BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
         BOOST_CHECK(!pm.exists(proofSeq20->getId()));
         BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
     }
 
     // Revert between proofSeq10 and proofSeq30 a few times
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(
             pm.registerProof(proofSeq30, RegistrationMode::FORCE_ACCEPT));
 
         BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
         BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
 
         BOOST_CHECK(
             pm.registerProof(proofSeq10, RegistrationMode::FORCE_ACCEPT));
 
         BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
         BOOST_CHECK(pm.isInConflictingPool(proofSeq30->getId()));
     }
 }
 
 BOOST_FIXTURE_TEST_CASE(evicted_proof, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq10 = buildProofWithSequence(key, {conflictingOutpoint}, 10);
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
 
     {
         ProofRegistrationState state;
         BOOST_CHECK(pm.registerProof(proofSeq30, state));
         BOOST_CHECK(state.IsValid());
     }
 
     {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proofSeq20, state));
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::CONFLICTING);
     }
 
     {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proofSeq10, state));
         BOOST_CHECK(state.GetResult() == ProofRegistrationResult::REJECTED);
     }
 }
 
 BOOST_AUTO_TEST_CASE(conflicting_proof_cooldown) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const COutPoint conflictingOutpoint =
         createUtxo(chainman.ActiveChainstate(), key);
 
     auto proofSeq20 = buildProofWithSequence(key, {conflictingOutpoint}, 20);
     auto proofSeq30 = buildProofWithSequence(key, {conflictingOutpoint}, 30);
     auto proofSeq40 = buildProofWithSequence(key, {conflictingOutpoint}, 40);
 
     int64_t conflictingProofCooldown = 100;
     gArgs.ForceSetArg("-avalancheconflictingproofcooldown",
                       strprintf("%d", conflictingProofCooldown));
 
     int64_t now = GetTime();
 
     auto increaseMockTime = [&](int64_t s) {
         now += s;
         SetMockTime(now);
     };
     increaseMockTime(0);
 
     BOOST_CHECK(pm.registerProof(proofSeq30));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
 
     auto checkRegistrationFailure = [&](const ProofRef &proof,
                                         ProofRegistrationResult reason) {
         ProofRegistrationState state;
         BOOST_CHECK(!pm.registerProof(proof, state));
         BOOST_CHECK(state.GetResult() == reason);
     };
 
     // Registering a conflicting proof will fail due to the conflicting proof
     // cooldown
     checkRegistrationFailure(proofSeq20,
                              ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
     BOOST_CHECK(!pm.exists(proofSeq20->getId()));
 
     // The cooldown applies as well if the proof is the favorite
     checkRegistrationFailure(proofSeq40,
                              ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
     BOOST_CHECK(!pm.exists(proofSeq40->getId()));
 
     // Elapse the cooldown
     increaseMockTime(conflictingProofCooldown);
 
     // The proof will now be added to conflicting pool
     checkRegistrationFailure(proofSeq20, ProofRegistrationResult::CONFLICTING);
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
 
     // But no other
     checkRegistrationFailure(proofSeq40,
                              ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
     BOOST_CHECK(!pm.exists(proofSeq40->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
 
     // Elapse the cooldown
     increaseMockTime(conflictingProofCooldown);
 
     // The proof will now be 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 immature30 = buildProofWithSequence(
         key, {conflictingOutpoint, immatureOutpoint}, 30);
 
     BOOST_CHECK(pm.registerProof(proofSeq20));
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(!pm.registerProof(immature30));
 
     BOOST_CHECK(pm.isBoundToPeer(proofSeq20->getId()));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
     BOOST_CHECK(pm.isImmature(immature30->getId()));
 
     // Rejecting a proof that doesn't exist should fail
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(
             !pm.rejectProof(avalanche::ProofId(GetRandHash()),
                             avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(
             !pm.rejectProof(avalanche::ProofId(GetRandHash()),
                             avalanche::PeerManager::RejectionMode::INVALIDATE));
     }
 
     auto checkRejectDefault = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         const bool isImmature = pm.isImmature(proofid);
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(!pm.isBoundToPeer(proofid));
         BOOST_CHECK_EQUAL(pm.exists(proofid), !isImmature);
     };
 
     auto checkRejectInvalidate = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::INVALIDATE));
     };
 
     // Reject from the immature pool
     checkRejectDefault(immature30->getId());
     BOOST_CHECK(!pm.registerProof(immature30));
     BOOST_CHECK(pm.isImmature(immature30->getId()));
     checkRejectInvalidate(immature30->getId());
 
     // Reject from the conflicting pool
     checkRejectDefault(proofSeq10->getId());
     checkRejectInvalidate(proofSeq10->getId());
 
     // Add again a proof to the conflicting pool
     BOOST_CHECK(!pm.registerProof(proofSeq10));
     BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
 
     // Reject from the valid pool, default mode
     checkRejectDefault(proofSeq20->getId());
 
     // The conflicting proof should be promoted to a peer
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq10->getId()));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq10->getId()));
 
     // Reject from the valid pool, invalidate mode
     checkRejectInvalidate(proofSeq10->getId());
 
     // The conflicting proof should also be promoted to a peer
     BOOST_CHECK(!pm.isInConflictingPool(proofSeq20->getId()));
     BOOST_CHECK(pm.isBoundToPeer(proofSeq20->getId()));
 }
 
 BOOST_AUTO_TEST_CASE(should_request_more_nodes) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     // Set mock time so that proof registration time is predictable and
     // testable.
     SetMockTime(GetTime());
 
     auto proof =
         buildRandomProof(chainman.ActiveChainstate(), MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof));
 
     // We have no nodes, so select node will fail and flag that we need more
     // nodes
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // The flag will not trigger again until we fail to select nodes again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Add a few nodes.
     const ProofId &proofid = proof->getId();
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
     }
 
     auto cooldownTimepoint = std::chrono::steady_clock::now() + 10s;
 
     // All the nodes can be selected once
     for (size_t i = 0; i < 10; i++) {
         NodeId selectedId = pm.selectNode();
         BOOST_CHECK_NE(selectedId, NO_NODE);
         BOOST_CHECK(pm.updateNextRequestTime(selectedId, cooldownTimepoint));
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // All the nodes have been requested, next select will fail and the flag
     // should trigger
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // The flag will not trigger again until we fail to select nodes again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Make it possible to request a node again
     BOOST_CHECK(pm.updateNextRequestTime(0, std::chrono::steady_clock::now()));
     BOOST_CHECK_NE(pm.selectNode(), NO_NODE);
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // Add another proof with no node attached
     auto proof2 =
         buildRandomProof(chainman.ActiveChainstate(), MIN_VALID_PROOF_SCORE);
     BOOST_CHECK(pm.registerProof(proof2));
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // After some time the proof will be considered dangling and more nodes will
     // be requested.
     SetMockTime(GetTime() + 15 * 60);
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // The flag will not trigger again until the condition is met again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Attempt to register the dangling proof again. This should fail but
     // trigger a request for more nodes.
     ProofRegistrationState state;
     BOOST_CHECK(!pm.registerProof(proof2, state));
     BOOST_CHECK(state.GetResult() == ProofRegistrationResult::DANGLING);
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 
     for (size_t i = 0; i < 10; i++) {
         // The flag will not trigger again until the condition is met again
         BOOST_CHECK(!pm.shouldRequestMoreNodes());
     }
 
     // Attach a node to that proof
     BOOST_CHECK(!pm.addNode(11, proof2->getId()));
     BOOST_CHECK(pm.registerProof(proof2));
     SetMockTime(GetTime() + 15 * 60);
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(!pm.shouldRequestMoreNodes());
 
     // Disconnect the node, the proof is dangling again
     BOOST_CHECK(pm.removeNode(11));
     pm.cleanupDanglingProofs(ProofRef());
     BOOST_CHECK(pm.shouldRequestMoreNodes());
 }
 
 BOOST_AUTO_TEST_CASE(score_ordering) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     std::vector<uint32_t> expectedScores(10);
     // Expect the peers to be ordered by descending score
     std::generate(expectedScores.rbegin(), expectedScores.rend(),
                   [n = 1]() mutable { return n++ * MIN_VALID_PROOF_SCORE; });
 
     std::vector<ProofRef> proofs;
     proofs.reserve(expectedScores.size());
     for (uint32_t score : expectedScores) {
         proofs.push_back(buildRandomProof(chainman.ActiveChainstate(), score));
     }
 
     // Shuffle the proofs so they are registered in a random score order
     Shuffle(proofs.begin(), proofs.end(), FastRandomContext());
     for (auto &proof : proofs) {
         BOOST_CHECK(pm.registerProof(proof));
     }
 
     auto peersScores = TestPeerManager::getOrderedScores(pm);
     BOOST_CHECK_EQUAL_COLLECTIONS(peersScores.begin(), peersScores.end(),
                                   expectedScores.begin(), expectedScores.end());
 }
 
 BOOST_FIXTURE_TEST_CASE(known_score_tracking, NoCoolDownFixture) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "2");
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const CKey key = CKey::MakeCompressedKey();
 
     const Amount amount1(PROOF_DUST_THRESHOLD);
     const Amount amount2(2 * PROOF_DUST_THRESHOLD);
 
     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 immature
     auto peer1Proof3 =
         buildProof(key,
                    {{peer1ConflictingOutput, amount1},
                     {createUtxo(active_chainstate, key, amount1), amount1}},
                    key, 30);
 
     const uint32_t peer1Score1 = Proof::amountToScore(amount1 + amount2);
     const uint32_t peer1Score2 = Proof::amountToScore(amount1);
 
     // Add first peer and check that we have its score tracked
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
     BOOST_CHECK(pm.registerProof(peer1Proof2));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Ensure failing to add conflicting proofs doesn't affect the score, the
     // first proof stays bound and counted
     BOOST_CHECK(!pm.registerProof(peer1Proof1));
     BOOST_CHECK(!pm.registerProof(peer1Proof3));
 
     BOOST_CHECK(pm.isBoundToPeer(peer1Proof2->getId()));
     BOOST_CHECK(pm.isInConflictingPool(peer1Proof1->getId()));
     BOOST_CHECK(pm.isImmature(peer1Proof3->getId()));
 
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     auto checkRejectDefault = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         const bool isImmature = pm.isImmature(proofid);
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::DEFAULT));
         BOOST_CHECK(!pm.isBoundToPeer(proofid));
         BOOST_CHECK_EQUAL(pm.exists(proofid), !isImmature);
     };
 
     auto checkRejectInvalidate = [&](const ProofId &proofid) {
         BOOST_CHECK(pm.exists(proofid));
         BOOST_CHECK(pm.rejectProof(
             proofid, avalanche::PeerManager::RejectionMode::INVALIDATE));
     };
 
     // Reject from the immature pool doesn't affect tracked score
     checkRejectDefault(peer1Proof3->getId());
     BOOST_CHECK(!pm.registerProof(peer1Proof3));
     BOOST_CHECK(pm.isImmature(peer1Proof3->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
     checkRejectInvalidate(peer1Proof3->getId());
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Reject from the conflicting pool
     checkRejectDefault(peer1Proof1->getId());
     checkRejectInvalidate(peer1Proof1->getId());
 
     // Add again a proof to the conflicting pool
     BOOST_CHECK(!pm.registerProof(peer1Proof1));
     BOOST_CHECK(pm.isInConflictingPool(peer1Proof1->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Reject from the valid pool, default mode
     // Now the score should change as the new peer is promoted
     checkRejectDefault(peer1Proof2->getId());
     BOOST_CHECK(!pm.isInConflictingPool(peer1Proof1->getId()));
     BOOST_CHECK(pm.isBoundToPeer(peer1Proof1->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score1);
 
     // Reject from the valid pool, invalidate mode
     // Now the score should change as the old peer is re-promoted
     checkRejectInvalidate(peer1Proof1->getId());
 
     // The conflicting proof should also be promoted to a peer
     BOOST_CHECK(!pm.isInConflictingPool(peer1Proof2->getId()));
     BOOST_CHECK(pm.isBoundToPeer(peer1Proof2->getId()));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
 
     // Now add another peer and check that combined scores are correct
     uint32_t peer2Score = 1 * MIN_VALID_PROOF_SCORE;
     auto peer2Proof1 = buildRandomProof(active_chainstate, peer2Score, 99);
     PeerId peerid2 = TestPeerManager::registerAndGetPeerId(pm, peer2Proof1);
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2 + peer2Score);
 
     // Trying to remove non-existent peer doesn't affect score
     BOOST_CHECK(!pm.removePeer(1234));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2 + peer2Score);
 
     // Removing new peer removes its score
     BOOST_CHECK(pm.removePeer(peerid2));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), peer1Score2);
     PeerId peerid1 =
         TestPeerManager::getPeerIdForProofId(pm, peer1Proof2->getId());
     BOOST_CHECK(pm.removePeer(peerid1));
     BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(connected_score_tracking) {
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const auto checkScores = [&pm](uint32_t known, uint32_t connected) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), known);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), connected);
     };
 
     // Start out with 0s
     checkScores(0, 0);
 
     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_CASE(proof_expiry) {
     gArgs.ForceSetArg("-enableavalancheproofreplacement", "1");
     gArgs.ForceSetArg("-avalancheconflictingproofcooldown", "0");
 
     ChainstateManager &chainman = *Assert(m_node.chainman);
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, chainman);
 
     const int64_t tipMTP = chainman.ActiveTip()->GetMedianTimePast();
 
     CKey key = CKey::MakeCompressedKey();
 
     auto utxo = createUtxo(chainman.ActiveChainstate(), key);
     auto proofToExpire = buildProof(key, {{utxo, PROOF_DUST_THRESHOLD}}, key, 2,
                                     100, false, tipMTP + 1);
     auto conflictingProof = buildProof(key, {{utxo, PROOF_DUST_THRESHOLD}}, key,
                                        1, 100, false, tipMTP + 2);
 
     // Our proofToExpire is not expired yet, so it registers fine
     BOOST_CHECK(pm.registerProof(proofToExpire));
     BOOST_CHECK(pm.isBoundToPeer(proofToExpire->getId()));
 
     // The conflicting proof has a longer expiration time but a lower sequence
     // number, so it is moved to the conflicting pool.
     BOOST_CHECK(!pm.registerProof(conflictingProof));
     BOOST_CHECK(pm.isInConflictingPool(conflictingProof->getId()));
 
     // Mine blocks until the MTP of the tip moves to the proof expiration
     for (int64_t i = 0; i < 6; i++) {
         SetMockTime(proofToExpire->getExpirationTime() + i);
         CreateAndProcessBlock({}, CScript());
     }
     BOOST_CHECK_EQUAL(chainman.ActiveTip()->GetMedianTimePast(),
                       proofToExpire->getExpirationTime());
 
     pm.updatedBlockTip();
 
     // The now expired proof is removed
     BOOST_CHECK(!pm.exists(proofToExpire->getId()));
 
     // The conflicting proof has been pulled back to the valid pool
     BOOST_CHECK(pm.isBoundToPeer(conflictingProof->getId()));
 
     gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
     gArgs.ClearForcedArg("-enableavalancheproofreplacement");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/processor_tests.cpp b/src/avalanche/test/processor_tests.cpp
index c4dd8c2c7..c94a34223 100644
--- a/src/avalanche/test/processor_tests.cpp
+++ b/src/avalanche/test/processor_tests.cpp
@@ -1,1810 +1,1810 @@
 // 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.
         gArgs.ForceSetArg("-avaminquorumstake", "0");
         gArgs.ForceSetArg("-avaminquorumconnectedstakeratio", "0");
         gArgs.ForceSetArg("avaminavaproofsnodecount", "0");
         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");
         gArgs.ClearForcedArg("-avaminquorumstake");
         gArgs.ClearForcedArg("-avaminquorumconnectedstakeratio");
         gArgs.ClearForcedArg("-avaminavaproofsnodecount");
     }
 
     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);
+        ProofBuilder pb(0, 0, masterpriv, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         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()));
     argsman.ForceSetArg("-avaminquorumstake", "0");
     argsman.ForceSetArg("-avaminquorumconnectedstakeratio", "0");
     argsman.ForceSetArg("avaminavaproofsnodecount", "0");
 
     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);
+        ProofBuilder pb(sequence, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         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 immatureProof = buildProof(immatureOutpoint, 3, 100);
 
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(!m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(immatureProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), -1);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), -1);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(immatureProof), -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(immatureProof));
 
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK(pm.registerProof(conflictingProof));
         BOOST_CHECK(pm.registerProof(validProof));
         BOOST_CHECK(!pm.registerProof(immatureProof));
 
         BOOST_CHECK(pm.isBoundToPeer(validProof->getId()));
         BOOST_CHECK(pm.isInConflictingPool(conflictingProof->getId()));
         BOOST_CHECK(pm.isImmature(immatureProof->getId()));
     });
 
     BOOST_CHECK(m_processor->addProofToReconcile(conflictingProof));
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(!m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(immatureProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), -1);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(immatureProof), -1);
 
     BOOST_CHECK(m_processor->addProofToReconcile(validProof));
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(immatureProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(immatureProof), -1);
 
     BOOST_CHECK(!m_processor->addProofToReconcile(immatureProof));
     BOOST_CHECK(!m_processor->isAccepted(conflictingProof));
     BOOST_CHECK(m_processor->isAccepted(validProof));
     BOOST_CHECK(!m_processor->isAccepted(immatureProof));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(conflictingProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(validProof), 0);
     BOOST_CHECK_EQUAL(m_processor->getConfidence(immatureProof), -1);
 
     gArgs.ClearForcedArg("-avaproofstakeutxoconfirmations");
     gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
 }
 
 BOOST_AUTO_TEST_CASE(quorum_detection) {
     // Set min quorum parameters for our test
     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);
     m_processor = Processor::MakeProcessor(*m_node.args, *m_node.chain,
                                            m_node.connman.get(), chainman,
                                            *m_node.scheduler, error);
 
     BOOST_CHECK(m_processor != nullptr);
     BOOST_CHECK(m_processor->getLocalProof() != nullptr);
     BOOST_CHECK_EQUAL(m_processor->getLocalProof()->getId(),
                       localProof->getId());
     BOOST_CHECK_EQUAL(AvalancheTest::getMinQuorumScore(*m_processor), minScore);
     BOOST_CHECK_EQUAL(
         AvalancheTest::getMinQuorumConnectedScoreRatio(*m_processor), 0.5);
 
     // The local proof has not been validated yet
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     BOOST_CHECK(!m_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.
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK(pm.registerProof(m_processor->getLocalProof()));
         BOOST_CHECK(pm.isBoundToPeer(m_processor->getLocalProof()->getId()));
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     BOOST_CHECK(!m_processor->isQuorumEstablished());
 
     // Add enough nodes to get a conclusive vote
     for (NodeId id = 0; id < 8; id++) {
         m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
             pm.addNode(id, m_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);
     m_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(!m_processor->isQuorumEstablished());
 
     // Add the rest of the stake, but we are still lacking connected stake
     const int64_t tipMTP = chainman.ActiveTip()->GetMedianTimePast();
     const COutPoint utxo{TxId(GetRandHash()), 0};
     const Amount amount = (int64_t(minScore / 4) * COIN) / 100;
     const int height = 100;
     const bool isCoinbase = false;
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = active_chainstate.CoinsTip();
         coins.AddCoin(utxo,
                       Coin(CTxOut(amount, GetScriptForDestination(
                                               PKHash(key.GetPubKey()))),
                            height, isCoinbase),
                       false);
     }
-    ProofBuilder pb(1, tipMTP + 1, key);
+    ProofBuilder pb(1, tipMTP + 1, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
     BOOST_CHECK(pb.addUTXO(utxo, amount, height, isCoinbase, key));
     auto proof2 = pb.build();
 
     m_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(!m_processor->isQuorumEstablished());
 
     // Adding a node should cause the quorum to be detected and locked-in
     m_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(m_processor->isQuorumEstablished());
 
     // Go back to not having enough connected score, but we've already latched
     // the quorum as established
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         pm.removeNode(8);
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(m_processor->isQuorumEstablished());
 
     // Removing one more node drops our count below the minimum and the quorum
     // is no longer ready
     m_processor->withPeerManager(
         [&](avalanche::PeerManager &pm) { pm.removeNode(7); });
     BOOST_CHECK(!m_processor->isQuorumEstablished());
 
     // It resumes when we have enough nodes again
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         pm.addNode(7, m_processor->getLocalProof()->getId());
     });
     BOOST_CHECK(m_processor->isQuorumEstablished());
 
     // Remove peers one at a time until the quorum is no longer established
     auto spendProofUtxo = [&](ProofRef proof) {
         {
             LOCK(cs_main);
             CCoinsViewCache &coins = chainman.ActiveChainstate().CoinsTip();
             coins.SpendCoin(proof->getStakes()[0].getStake().getUTXO());
         }
         m_processor->withPeerManager([&proof](avalanche::PeerManager &pm) {
             pm.updatedBlockTip();
             BOOST_CHECK(!pm.isBoundToPeer(proof->getId()));
         });
     };
 
     // Expire proof2, the quorum is still latched
     for (int64_t i = 0; i < 6; i++) {
         SetMockTime(proof2->getExpirationTime() + i);
         CreateAndProcessBlock({}, CScript());
     }
     BOOST_CHECK_EQUAL(chainman.ActiveTip()->GetMedianTimePast(),
                       proof2->getExpirationTime());
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         pm.updatedBlockTip();
         BOOST_CHECK(!pm.exists(proof2->getId()));
     });
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 3 * minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(m_processor->isQuorumEstablished());
 
     spendProofUtxo(proof1);
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), minScore / 4);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), minScore / 4);
     });
     BOOST_CHECK(m_processor->isQuorumEstablished());
 
     spendProofUtxo(m_processor->getLocalProof());
     m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
         BOOST_CHECK_EQUAL(pm.getTotalPeersScore(), 0);
         BOOST_CHECK_EQUAL(pm.getConnectedPeersScore(), 0);
     });
     // There is no node left
     BOOST_CHECK(!m_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/src/avalanche/test/proof_tests.cpp b/src/avalanche/test/proof_tests.cpp
index 30be7e1f3..91f7fa9f6 100644
--- a/src/avalanche/test/proof_tests.cpp
+++ b/src/avalanche/test/proof_tests.cpp
@@ -1,1165 +1,1167 @@
 // 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/proof.h>
 
 #include <avalanche/proofbuilder.h>
 #include <avalanche/test/util.h>
 #include <avalanche/validation.h>
 #include <coins.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
 #include <util/translation.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 using namespace avalanche;
 
 BOOST_FIXTURE_TEST_SUITE(proof_tests, TestChain100Setup)
 
 BOOST_AUTO_TEST_CASE(proof_random) {
     CChainState &active_chainstate =
         Assert(m_node.chainman)->ActiveChainstate();
 
     for (int i = 0; i < 1000; i++) {
         const uint32_t score = InsecureRand32();
         auto p = buildRandomProof(active_chainstate, score);
         BOOST_CHECK_EQUAL(p->getScore(), score);
 
         ProofValidationResult expected_state =
             hasDustStake(p) ? ProofValidationResult::DUST_THRESHOLD
                             : ProofValidationResult::NONE;
 
         ProofValidationState state;
         BOOST_CHECK_EQUAL(p->verify(PROOF_DUST_THRESHOLD, state),
                           state.GetResult() == ProofValidationResult::NONE);
         BOOST_CHECK(state.GetResult() == expected_state);
     }
 }
 
 BOOST_AUTO_TEST_CASE(proofbuilder) {
     // Master key.
     auto key = CKey::MakeCompressedKey();
     const CPubKey master = key.GetPubKey();
 
     const uint64_t sequence = InsecureRandBits(64);
     const int64_t expiration = InsecureRandBits(64);
 
-    ProofBuilder pb(sequence, expiration, key);
+    ProofBuilder pb(sequence, expiration, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
 
     for (int i = 0; i < 3; i++) {
         key.MakeNewKey(true);
         BOOST_CHECK(pb.addUTXO(COutPoint(TxId(GetRandHash()), InsecureRand32()),
                                int64_t(InsecureRand32()) * COIN / 100,
                                InsecureRand32(), InsecureRandBool(), key));
     }
 
     ProofRef p = pb.build();
 
     ProofValidationState state;
     BOOST_CHECK(p->verify(PROOF_DUST_THRESHOLD, state));
 
     BOOST_CHECK_EQUAL(p->getSequence(), sequence);
     BOOST_CHECK_EQUAL(p->getExpirationTime(), expiration);
     BOOST_CHECK(p->getMaster() == master);
 
     BOOST_CHECK(state.GetResult() == ProofValidationResult::NONE);
 }
 
 struct TestVector {
     std::string name;
     std::string hex;
     ProofId proofid;
     uint32_t score;
     ProofValidationResult result;
 };
 
 BOOST_AUTO_TEST_CASE(deserialization) {
     // All stakes signed using the key:
     // KydYrKDNsVnY5uhpLyC4UmazuJvUjNoKJhEEv9f1mdK1D5zcnMSM
     std::vector<TestVector> legacyFormatTestCases{
         {"No utxo staked",
          "96527eae083f1f24625f049d9e54bb9a2102a93d98bf42ab90cfc0bf9e7c634ed76a7"
          "3e95b02cacfd357b64e4fb6c92e92dd00",
          ProofId::fromHex("19f6631738a5a0196bf6152dcdb40de4675954567b444631cdec"
                           "52d4c39b5316"),
          0, ProofValidationResult::NO_STAKE},
         {"1 utxo staked",
          "a6d66db9fe9378fdd37a0ad2c01c2acd2103648144bb6a0c1d09b0f04d0df6d55f914"
          "fd81efc65f23a718b68b7c9e42bd5430145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b36200fe38dce5060000e707d7274104fb662"
          "6e21dbd1cc9feeecdefc9213fdce2b51ac4bb44e1f8dc6f14c2052f5dd7bfaeb2267a"
          "97ca2bec6e0dd4acf50a66204bde1ebb5d6c551684cff2f939920f7fbb2efd860d6d5"
          "926bf425eb47b78bf6979cdcd67eb705e2c9a4d45a0930ba25463178a3fb99cb28c8b"
          "77d8fcf68c54ebfadf08b9a446c251a0088301c50d53",
          ProofId::fromHex("82754c0d4170521b19360c6862483ad435b7b95f078aedf781d6"
                           "9a6c5b89a916"),
          7584312, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"2 utxo staked",
          "872379ab64f55b4166ca0e79639999ec4104a66861de557a54eefc0375264cc17c3a3"
          "50ccabca6fd9c91883e899ab55bb140517aa56c5b4041908e7027a786b99f66488a04"
          "135ce5fe189a99a7bc541ddfe602fabf3ad5b875840e7813a66d5ea8a1288a49b6222"
          "b59fcbe6249f94e5927f9f4b884b0b040a534b3ba040000d045d5d021036830e697b0"
          "ee89866da798a8945bd85b352545ec1bcace7e04909ea54c134f16d5fe4e972b7acd2"
          "9ebfc2b7b11c26974b84e5f21a45bbe8372472f59e5dfdea7e9e5857c6aebe5dbc5e6"
          "46dfbf4e7cee380afaddb15d06153bf1755b9ef00a616d4c8c3c3a662b5eddc192656"
          "4a488e3e68e334291078001480f7fa5144ef3a606a41e85c0218dd377090000e41099"
          "912102ebfcea8e1864c1273c41e0d7c1e9097be5c491bbbf5fe31161d8e5589b9d6b5"
          "b12f3b963c7fc7614d56d83af907e5cb18ac2f4c3e70a8c4253995f6bc002ec5e3504"
          "91c965cba4dbc11c210979217f1ac3ece7a748f5b2fcf5cced40a5d4c40e",
          ProofId::fromHex("ba5aba9be72c9c2c52f857b81245e1ec85c879bbc8e111008673"
                           "d78c26610b05"),
          15610172, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"3 utxo staked",
          "525e2aa04af0e2457c66ac9e7f66257f210252db8e3ceea6fca44a7696e82f7b77e5a"
          "4025e60ac60271b174e91ffbb6ce01f039ce8d3b77938e49ce3bc9824e90b72c65542"
          "2fb502f137e03a4499e5223d10096fe541eb80316ce3c80800000285f59341044fd7e"
          "95de7c7bb30e7f60434a3e1a414a9e5d9c383c7b27396b1b84355a32e2996ecb98dc2"
          "0143089932fa1b905a60fc3cfefeea193c91d1405f7c03de494fa4de065c067d64606"
          "0e9270281c316d5c4c01d7e43d009151a72bf647794ce1727cbefaeb19719f916cd4d"
          "d176c376a4da72431b61736d4a3e01c25ba057eac0af8f2988b78d1b75e02281fac56"
          "2357a06353bf7f214c883e65add05b3a616300cb99cc963c0f4ded8c00e0000b03aab"
          "f82103172b4f1890594508ab1e0cc5e9728b8a249660da4df724762a8fd888e8ece1b"
          "d6fe923ed17ad0fd77a90d31e3877de1a8cdb4e95bcf2cdd6fb9768f86789f253b432"
          "f3b5058b2d1892e90882529055fdedf8ae5d3280b2404a65321cf7f7229202db300ff"
          "2897e33259a81dfc4bf296c3a156dc8dbfa074c602dd2250cc531b346fc28bb80ddf2"
          "9ddc020000a713a5bb21035615635d449988a4eea03fd317e44481bde2e34a2489f3f"
          "b24f0b0ea1cbfc4030bec095a8d3e9c2a233778535dc1fcc07755149b23ea8c17931a"
          "37e9377eaa2f45bafb8d0bb9ba1700aab88fd6a53ea3e83d95ad2d84e7abe828f5570"
          "91b185e",
          ProofId::fromHex("9ea64e9760f2c7832f1c9840923947915361acb22dcc0bae4404"
                           "94be0d51842d"),
          29026903, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"4 utxo staked",
          "eef33172651f752ac255c85a4e1374992102c12b37ff6139157865fc4c3a9d7ad999b"
          "686ade45d453545d04e76f6e14793b404295de5ebf9fbbbb65fc1d9a71587c5284cff"
          "b2e834addefe090b8200435668c8f02c0b0100689a117e0e000007d801582102a682d"
          "9d12d53b0eb37a3af2838510f079041905a75f82b6a3fb5558728d781fbf868d1d968"
          "27b273f5a79f84ebe23add967a98f472fb80323439d0a65d546fc3745806f6d7f3381"
          "24a7a2573864e97a26246644a7d7b05d97943dfcdb4b694df631e6dc5f87e28c1fe3e"
          "5ba021f38c471638769041db81ffcf8c9887d078419f97fe2a2c408fee822c0600001"
          "689b9cd2102e38d0adddcd7c88e3c87b8babcae10647e2862fb719839fc8890e42aeb"
          "929b85e1a3f14e2cdc65e2b1396f2dae41b047958cdc7e4d2f6fa051065829e26797c"
          "5b882e45bb9fea32c0b0e0ad90f8ac1e5d8d0b16a9b74d77614b7fd99e56b6091aca3"
          "67f8f7a68d1b654e51dd00733bd191dc9bea2ba750e063b05d962aaf9c4d2088ce4f0"
          "03e73e253040000a5eebe222103a20dd85b66b44b22fdd17a93762194c9bedb442c7f"
          "fd7f08a9f82c42a8c1d9a0443f700cb8a40c8cf7f840b5137b6d019efed961771d095"
          "88b0eb3c5e1672bb95b06ca7e2068e564001aa75b8c37bb6601117c286b6b0c9728d1"
          "e928ab02e3b67e9422b484ef2624ce5de974b5bd616874ec39d03d32ed0bf114759b7"
          "0bf5dcef51534b100515301140f0000950121754104d66dba1569164a134111961133"
          "4bad5e2d398823f1454ceecb9c4266fd3ba4b969ac4d4f6c4b3975d19c2f7dcbbca09"
          "6af5395780a2d3c42505146c095bc861fab15238fb8aa1fb82c7ad28b0ee5d1335348"
          "76dc7887490c7c6e61103b2cd221f1991826a73fecf08e0b5a0a7d357a5431eee032d"
          "14a348c80ca1833d68b3d7b",
          ProofId::fromHex("ae60f62b336c6a948f95af123bc25574b0c5f423d1cab8f795d3"
                           "bf8f895457f3"),
          44059793, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Properly signed 1 UTXO proof",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("cbd77dad2ebc525c591ab44a0f6a25803c1d934c3e5caa61f9f4"
                           "c63c9f29a4e6"),
          444638638, ProofValidationResult::NONE},
         {"Duplicated UTXO",
          "60f8332a3ff3430a4f3c9010160cc63e21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde302d1e26c2287948bc6ab2b55945c591b8ba3ff"
          "a237f5d9164d30a4f10145a61f788e639b1480731e2aead30500bf8462872102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680f43f437a2d"
          "8910aa81ff6c5619dd7b27a1e4b794841e3ab60a3878cf00cff8c0135dc85e451e179"
          "34b252b51b44db5a8761d215565cc9533cdecfda0870ef079d1e26c2287948bc6ab2b"
          "55945c591b8ba3ffa237f5d9164d30a4f10145a61f788e639b1480731e2aead30500b"
          "f8462872102449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8"
          "bce680f43f437a2d8910aa81ff6c5619dd7b27a1e4b794841e3ab60a3878cf00cff8c"
          "0135dc85e451e17934b252b51b44db5a8761d215565cc9533cdecfda0870ef079",
          ProofId::fromHex("a7cd6e76b5766cf4fc2251da4a01668682a1786d4b76539e04d7"
                           "f79cebeb5983"),
          3280755132, ProofValidationResult::DUPLICATE_STAKE},
         {"Properly signed 3 UTXO proof",
          "c964aa6fde575e4ce8404581c7be874e21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde3030b1e5f35704cb63360aa3d5f444ee35eea4c"
          "154c1af6d4e7595b409ada4b42377764698aaa9da7a9070000000f28db322102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68079273097c8"
          "20f1bc7ef5597b97827546da4b6a67cfa9bfbaa6bd87194590dd251b4775a11950e00"
          "eee019f207ccd722b90d6acfdd898c076357f93b8686f9c2cac098c86414715db364a"
          "4e32216084c561acdd79e0860b1fdf7497b159cb132304512002dcdf1b4c090000009"
          "f2bc7392102449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8"
          "bce68082dec8e6d9ce9a73a6e37ace78a16a085f53a5672127ca7cfea48bba727d3b6"
          "86d272c829fb1883ebbeb5497e7c18c9581e2dad2efa972ee14158cdbd835c347e4ed"
          "76e1f19b2c2a0fcc069b4ace4a078cb5cc31e9e19b266d0af41ea8bb0c30c8b47c959"
          "0627dac060000007dfdd89a2102449fb5237efe8f647d32e8b64f06c22d1d40368eac"
          "a2a71ffc6a13ecc8bce680acbb88dbdfffd2f3fb870b325e45cc8745455da5932d75e"
          "8adf9b2cf2fc0e83ed2db04c4ed49ef66af22cb4e56a2eecaa8828b11b5f580815a33"
          "6f1010c18521",
          ProofId::fromHex("848c146066af1c5187a3c5e73ceaaf7f2f1c39972410cbd1b0f2"
                           "fb1793382e74"),
          101506, ProofValidationResult::NONE},
         {"Changing sequence affect ProofId",
          "d87587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("333c462a0161e9146da55d77733a2d4ccd022217a70beb004742"
                           "5069f1d32ed5"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing expiration affect ProofId",
          "d97587e6c882615797011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("6b7d6b32a88e68e830454bb0189ac14dc938917bdc64f22ef11d"
                           "d41535ede85a"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the master key affect ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469aa5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("d4e2673f9df2e5c506892f3794b986910c77aa9b0c292cdcfea8"
                           "3dd804008b00"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the TxId affect the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90179a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("fefa0e3d8f76358431caba523ac71faaf57921bb6f1049f74a3e"
                           "8bebd512c20b"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the outpoint index change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91df00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("a9f6b78b97a01d21d47b834bb8bf5d9397f50bfac115ec3da05b"
                           "695189aef040"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the amount changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21814712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("89796be200e6eeeefdb894e47f16653afc572310d5f94c859cac"
                           "628ffc0d9781"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the height changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010028e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("77db71b3099331de1e09262d03ee4a5f2d2c21f5abc48f68e28d"
                           "456cecc822ce"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the pubkey changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102459fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("3663e72aae7fe4dacde5aa6d5e6f2a3041171d9e7756a47662e1"
                           "e0a11e82621c"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the signature does NOT change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e3",
          ProofId::fromHex("cbd77dad2ebc525c591ab44a0f6a25803c1d934c3e5caa61f9f4"
                           "c63c9f29a4e6"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"1 utxo staked but zero coins",
          "a6d6852ffa70b172d37a0ad2c01c2acd21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b3620000000000000000e707d7272102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68065cd42e0e6"
          "9d511ad24ecb3c3af07176bcf890caa7cfc64039dc65e51014dd99d11bd00ffbfbcc1"
          "9619ca502bfd4dd6dbc0967692ff6d2211b0bd9b9f05e1298",
          ProofId::fromHex("38f7c9696f9c2c07db3f23024d550a6b0b7f851013074280dbe3"
                           "49f42a2a5a00"),
          0, ProofValidationResult::DUST_THRESHOLD},
     };
 
     // Proof master key:
     // privkey L4J6gEE4wL9ji2EQbzS5dPMTTsw8LRvcMst1Utij4e3X5ccUSdqW
     std::vector<TestVector> regularFormatTestCases{
         // Duplicated from the legacy tests, using P2PK payout to
         // 023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3
         {"No utxo staked",
          "96527eae083f1f24625f049d9e54bb9a21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde3002321023beefdde700a6bc02036335b4df141"
          "c8bc67bb05a971f5ac2745fd683797dde3ac135da984db510334abe41134e3d4ef09a"
          "d006b1152be8bc413182bf6f947eac1f8580fe265a382195aa2d73935cabf86d90a8f"
          "666d0a62385ae24732eca51575",
          ProofId::fromHex("979dbc3b1351ee12f91f537e04e61fdf93a73d5ebfc317bccd12"
                           "643b8be87b02"),
          0, ProofValidationResult::NO_STAKE},
         {"1 utxo staked",
          "a6d66db9fe9378fdd37a0ad2c01c2acd21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b36200fe38dce5060000e707d7274104fb662"
          "6e21dbd1cc9feeecdefc9213fdce2b51ac4bb44e1f8dc6f14c2052f5dd7bfaeb2267a"
          "97ca2bec6e0dd4acf50a66204bde1ebb5d6c551684cff2f939920f7fbb2efd860d6d5"
          "926bf425eb47b78bf6979cdcd67eb705e2c9a4d45a0930ba25463178a3fb99cb28c8b"
          "77d8fcf68c54ebfadf08b9a446c251a0088301c50d532321023beefdde700a6bc0203"
          "6335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac845148594a3067f06bc2cf"
          "495a1191c00e012dd3d0e4b0c393b3e46c2adcebc3df50f1a203f02e445a0101f4675"
          "26becb0aa4c64400a10bbde83b3f0290bdeaa",
          ProofId::fromHex("e01bac293ed39e8d5e06214e7fe0bceb9646ef253ce501dcd7a4"
                           "75f802ab07f1"),
          7584312, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"2 utxo staked",
          "872379ab64f55b4166ca0e79639999ec21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde302fabf3ad5b875840e7813a66d5ea8a1288a49"
          "b6222b59fcbe6249f94e5927f9f4b884b0b040a534b3ba040000d045d5d021036830e"
          "697b0ee89866da798a8945bd85b352545ec1bcace7e04909ea54c134f16d5fe4e972b"
          "7acd29ebfc2b7b11c26974b84e5f21a45bbe8372472f59e5dfdea7e9e5857c6aebe5d"
          "bc5e646dfbf4e7cee380afaddb15d06153bf1755b9ef00a616d4c8c3c3a662b5eddc1"
          "926564a488e3e68e334291078001480f7fa5144ef3a606a41e85c0218dd377090000e"
          "41099912102ebfcea8e1864c1273c41e0d7c1e9097be5c491bbbf5fe31161d8e5589b"
          "9d6b5b12f3b963c7fc7614d56d83af907e5cb18ac2f4c3e70a8c4253995f6bc002ec5"
          "e350491c965cba4dbc11c210979217f1ac3ece7a748f5b2fcf5cced40a5d4c40e2321"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ace"
          "a8c988e488eaeef3dc441eb8ede93d2e249ecac3a4277d0347bb1abfdb79b7ebc507e"
          "5447309db034983b38bd663242834b89026424472e192220863274b266",
          ProofId::fromHex("ebf52f8d3c845761e55ef145a37537162e5fbbcc87c58a5b0040"
                           "d0a9c89003c4"),
          15610172, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"3 utxo staked",
          "525e2aa04af0e2457c66ac9e7f66257f21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde3039ce8d3b77938e49ce3bc9824e90b72c65542"
          "2fb502f137e03a4499e5223d10096fe541eb80316ce3c80800000285f59341044fd7e"
          "95de7c7bb30e7f60434a3e1a414a9e5d9c383c7b27396b1b84355a32e2996ecb98dc2"
          "0143089932fa1b905a60fc3cfefeea193c91d1405f7c03de494fa4de065c067d64606"
          "0e9270281c316d5c4c01d7e43d009151a72bf647794ce1727cbefaeb19719f916cd4d"
          "d176c376a4da72431b61736d4a3e01c25ba057eac0af8f2988b78d1b75e02281fac56"
          "2357a06353bf7f214c883e65add05b3a616300cb99cc963c0f4ded8c00e0000b03aab"
          "f82103172b4f1890594508ab1e0cc5e9728b8a249660da4df724762a8fd888e8ece1b"
          "d6fe923ed17ad0fd77a90d31e3877de1a8cdb4e95bcf2cdd6fb9768f86789f253b432"
          "f3b5058b2d1892e90882529055fdedf8ae5d3280b2404a65321cf7f7229202db300ff"
          "2897e33259a81dfc4bf296c3a156dc8dbfa074c602dd2250cc531b346fc28bb80ddf2"
          "9ddc020000a713a5bb21035615635d449988a4eea03fd317e44481bde2e34a2489f3f"
          "b24f0b0ea1cbfc4030bec095a8d3e9c2a233778535dc1fcc07755149b23ea8c17931a"
          "37e9377eaa2f45bafb8d0bb9ba1700aab88fd6a53ea3e83d95ad2d84e7abe828f5570"
          "91b185e2321023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd68"
          "3797dde3acf3c32376092a751c432eb727544e6e5caab7e9be1c947ece79995ddc883"
          "e6e1d48c6865554267cd8f388af277e4fa7a4ad6801f17db36074985ac477e250702"
          "b",
          ProofId::fromHex("8542635d83f8020bc781d9e8a3de53c23f5e3f77c21588719b58"
                           "b6618ee1782b"),
          29026903, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"4 utxo staked",
          "eef33172651f752ac255c85a4e13749921023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde304295de5ebf9fbbbb65fc1d9a71587c5284cff"
          "b2e834addefe090b8200435668c8f02c0b0100689a117e0e000007d801582102a682d"
          "9d12d53b0eb37a3af2838510f079041905a75f82b6a3fb5558728d781fbf868d1d968"
          "27b273f5a79f84ebe23add967a98f472fb80323439d0a65d546fc3745806f6d7f3381"
          "24a7a2573864e97a26246644a7d7b05d97943dfcdb4b694df631e6dc5f87e28c1fe3e"
          "5ba021f38c471638769041db81ffcf8c9887d078419f97fe2a2c408fee822c0600001"
          "689b9cd2102e38d0adddcd7c88e3c87b8babcae10647e2862fb719839fc8890e42aeb"
          "929b85e1a3f14e2cdc65e2b1396f2dae41b047958cdc7e4d2f6fa051065829e26797c"
          "5b882e45bb9fea32c0b0e0ad90f8ac1e5d8d0b16a9b74d77614b7fd99e56b6091aca3"
          "67f8f7a68d1b654e51dd00733bd191dc9bea2ba750e063b05d962aaf9c4d2088ce4f0"
          "03e73e253040000a5eebe222103a20dd85b66b44b22fdd17a93762194c9bedb442c7f"
          "fd7f08a9f82c42a8c1d9a0443f700cb8a40c8cf7f840b5137b6d019efed961771d095"
          "88b0eb3c5e1672bb95b06ca7e2068e564001aa75b8c37bb6601117c286b6b0c9728d1"
          "e928ab02e3b67e9422b484ef2624ce5de974b5bd616874ec39d03d32ed0bf114759b7"
          "0bf5dcef51534b100515301140f0000950121754104d66dba1569164a134111961133"
          "4bad5e2d398823f1454ceecb9c4266fd3ba4b969ac4d4f6c4b3975d19c2f7dcbbca09"
          "6af5395780a2d3c42505146c095bc861fab15238fb8aa1fb82c7ad28b0ee5d1335348"
          "76dc7887490c7c6e61103b2cd221f1991826a73fecf08e0b5a0a7d357a5431eee032d"
          "14a348c80ca1833d68b3d7b2321023beefdde700a6bc02036335b4df141c8bc67bb05"
          "a971f5ac2745fd683797dde3ac157f7621dd2ce427c07dc0da1fc46412edd5c78b10c"
          "e70e7e6010c65d22de2f434e4f08c158af3c9f5a2411677bd69adbaec068cbb04e79f"
          "90dbdcb6be2b437f",
          ProofId::fromHex("6ba2a3ff986d5bc4457da693096bab408cfd8cf4e988e5ac013f"
                           "e48a4e2961c9"),
          44059793, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Properly signed 1 UTXO proof",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9ac05a9ea3a5333926249331f"
          "34a41a3519bab179ce9228dc940019ee80f754da0499379229f9b49f1bccc6566a734"
          "7227299f775939444505952f920ccea8b9f18",
          ProofId::fromHex("cdcdd71605139f49d4884b0c3d9a6be309f07b008a760bb3b25f"
                           "cfcb7a3ffc46"),
          444638638, ProofValidationResult::NONE},
         {"Duplicated UTXO",
          "c964aa6fde575e4ce8404581c7be874e21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde302d1e26c2287948bc6ab2b55945c591b8ba3ff"
          "a237f5d9164d30a4f10145a61f788e639b1480731e2aead30500bf8462872102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6806b8111af77"
          "e1076caba7cb76de29abae963b7f6a1879318e8e37ff488d5843b783215fe9561431a"
          "c55ecef78ce214869aac0c271d35bee7fdb0858a7ddffe3b0d1e26c2287948bc6ab2b"
          "55945c591b8ba3ffa237f5d9164d30a4f10145a61f788e639b1480731e2aead30500b"
          "f8462872102449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8"
          "bce6802f5c4b2a2ab7fb315d3b9e0318e4e90faa997f28ea6fb31c3487332718079c1"
          "0131da1acd028a093be651330679bb02bd471053e18a590e373a08c2e60ca15f92321"
          "038439233261789dd340bdc1450172d9c671b72ee8c0b2736ed2a3a250760897fdac3"
          "dfb66133d94674a3a6565d8f84e1a31e2f79a4bb399c04adc802abcf8b395f62315d3"
          "ad8450ba57e11dfb61b1f5a7325094d5ffda1f5830e0990dcc2ebb9be8",
          ProofId::fromHex("5d4919b43a1afb6acdeddaf1678397eaa10562125db6b911ec4e"
                           "35fd8598ad73"),
          3280755132, ProofValidationResult::DUPLICATE_STAKE},
         {"Properly signed 3 UTXO proof",
          "c964aa6fde575e4ce8404581c7be874e21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde3030b1e5f35704cb63360aa3d5f444ee35eea4c"
          "154c1af6d4e7595b409ada4b42377764698aaa9da7a9070000000f28db322102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680bff436d745"
          "ad2517f048748d49425db654ad2db24a89cbf91221f3d2e8833cbc63395b0b6f25e54"
          "3bc4c081e57dd7c29e271d0245230077eddfa991e418a9cceac098c86414715db364a"
          "4e32216084c561acdd79e0860b1fdf7497b159cb132304512002dcdf1b4c090000009"
          "f2bc7392102449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8"
          "bce680cbfabd2e54169fa88efc205505dca2bd65baf893eb38dfa2bc5a691569ed660"
          "6873d8abc9b68951f8a76db379fb1244d0a1e005d310774f3dbd7863c5f6b060ce4ed"
          "76e1f19b2c2a0fcc069b4ace4a078cb5cc31e9e19b266d0af41ea8bb0c30c8b47c959"
          "0627dac060000007dfdd89a2102449fb5237efe8f647d32e8b64f06c22d1d40368eac"
          "a2a71ffc6a13ecc8bce6800d930fdf810c20955b67deb1b7db92a1e4f835da7b48495"
          "4ab1c0b982b3821d627a99fc244c9f9556a3b2b2db0098b5c4ef4578de2df3df6b744"
          "249d456987881976a914f8172c51efbf34413a308a030fd4b164c5bfcd8f88ac87b98"
          "97ce7b037539f910559fc8ddf69edd509484119f39a344cad40b4b7655438dabf7142"
          "7a37b92e0e6e29226b6474022ea16be6108ab0f9075f0cd391e746",
          ProofId::fromHex("526e0e5aef9d857d8c4c15208cc30b5a00818627eebe06098055"
                           "a88d57d461b0"),
          101506, ProofValidationResult::NONE},
         {"Changing sequence affect ProofId but not the stake signature",
          "d87587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9ac80bdeb2ada22b35856fa25"
          "d2fe7a145b4ce09c6332b72925dbf2b09140d6163863437a8076f7836fcbb7154b831"
          "65a65910d1b2a8c3655d111f008a57315f5a0",
          ProofId::fromHex("8b0640e7bf81f487d90d6b5c3ead4bc41eae418da4e6874618b2"
                           "89124e52ba1e"),
          444638638, ProofValidationResult::NONE},
         {"Changing expiration affect ProofId",
          "d97587e6c882615797011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9ac5995555107107e656abd8e"
          "2852f311ff0f5c4f606695b63ec44e04303e3378a2e21e16bf05727240ebee1334d2f"
          "858c6c2e3bdd8d289400b99d7f70b35f9d2fa",
          ProofId::fromHex("26ce40e7b5dfc8d3d48d743ed23fa6ff32ca269a59c4fb101b3b"
                           "48e5d8450465"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the TxId affect the ProofId",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30179a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9acaefee33b8b7a0ce4d5d1ab"
          "92ea8d08dd2538102a4dde790f6317558ceb68e5d2267aac97a0f313dccec827d0401"
          "a3095b4e862068077ce942380b474c30b64e0",
          ProofId::fromHex("4b57e163adc5174820ce21eb0e0e9d6565bc00d51bf9f86c58c5"
                           "6947428c2d84"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the outpoint index change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91df00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9acecc6e78166848efad9772b"
          "a11ed0a8b1e9e844cbc2727c69c5e1898430548c9062a52ca9dc1dbe614213d9f7d54"
          "65dc297d0dc1880adb7daf088f6927a4d6a51",
          ProofId::fromHex("b569969b77b683904a89c3364c667ac434602936548c80352a85"
                           "ffed4c934cbc"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the amount changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21814712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9acefbdde03c4cc7065075d06"
          "6c693086c0df0b6b349ec9300ff1333cca65d076364560fb2cbb1365240cdd6c9c323"
          "d73fc17576da71a5c336a170f76a1b52ffc89",
          ProofId::fromHex("6989ce300064196c177eae6fd73cf3f89719ddedf068e757eb39"
                           "eb2030baa846"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the height changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010028e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9ac4fc8c51b5a993c0a8f3a53"
          "c88fb49f228305da66d20b8c73e7e9de55300ac1de52c898fa73e8c5f54a727edc4a6"
          "76a66dc8bb89bd6c54d41053edceaead6d7b1",
          ProofId::fromHex("81d217bbfa019439ab6dfbe02b8b703b93eb26e6047a7ee3cc4a"
                           "ba1366286d8d"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the pubkey changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102459fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fc43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9ac893ad17cf6a17016f35337"
          "f6a10f85357689be2760734137c51225cbe0eca4fa00b671f50deacfb86afd61d9cdf"
          "ae24aa1e9ced62954c4f8eb8114bb4fb852fe",
          ProofId::fromHex("e33e02f3d608b4a6447c3b3ee283763718716fff02f3a79e3251"
                           "417bd03b9834"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Changing the signature does NOT change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68099f1e258ab"
          "54f960102c8b480e1dd5795422791bb8a7a19e5542fe8b6a76df7fa09a3fd4be62db7"
          "50131f1fbea6f7bb978288f7fe941c39ef625aa80576e19fd43410469ab5a892ffa4b"
          "b104a3d5760dd893a5502512eea4ba32a6d6672767be4959c0f70489b803a47a3abf8"
          "3f30e8d9da978de4027c70ce7e0d3b0ad62eb08edd8f9ac3359ba425e0084157ca510"
          "e30865693578e3f5eb426d97597ccbd7766db411abaf653aea59c34861cbafeaee076"
          "8ae58fa2b68a7bfdcdbdc041c50ea59cf1b22",
          ProofId::fromHex("cdcdd71605139f49d4884b0c3d9a6be309f07b008a760bb3b25f"
                           "cfcb7a3ffc46"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"1 utxo staked but zero coins",
          "a6d6852ffa70b172d37a0ad2c01c2acd21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b3620000000000000000e707d7272102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680061c669954"
          "f964a68b43b1b354b65b651f349a3ff310a1dcb862aa285f26fc7f6fd0b9cb766f1e1"
          "f90fc63ce03c956b3dac9a4ac2fff963f643ae1326b08d33c2321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac6ad76de70caa0fb07"
          "12a44e24f791244f733017920ef42c876220a9c50f0239d97414829fe9103741aba28"
          "7579d8ea26ca28162e3091d53cc51fd58be9b18d22",
          ProofId::fromHex("c95e3c6417a799dd3085af689ea12fb3d2e1130870fef9f0bdc6"
                           "d10a27df746a"),
          0, ProofValidationResult::DUST_THRESHOLD},
 
         // Exclusive tests (not duplicated from legacy)
         {"Properly signed 1 UTXO proof, P2PK payout script",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6804534ca1f5e"
          "22670be3df5cbd5957d8dd83d05c8f17eae391f0e7ffdce4fb3defadb7c079473ebec"
          "cf88c1f8ce87c61e451447b89c445967335ffd1aadef429982321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("455f34eb8a00b0799630071c0728481bdb1653035b1484ac33e9"
                           "74aa4ae7db6d"),
          444638638, ProofValidationResult::NONE},
         {"Properly signed 1 UTXO proof, P2PKH payout script",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6804848a02e2b"
          "1c8aa1d21c31b056ab6a63f08e07bb0b56258d1c58b87f3ff472b7b5b9a5907142a04"
          "041e95e6874ae0874d0f7bbe266f7c4606af315711d0f49341976a914f8172c51efbf"
          "34413a308a030fd4b164c5bfcd8f88ac2d805b078f5efe022304f8c6ccd0ef5255d80"
          "6a473fc85a5ad1caf1aa94a4e49ef7625b9dc85d263b2829d5822af62226bc50a4a83"
          "76a3a6e1cd0a37ea2fbbf9",
          ProofId::fromHex("8a2fcc5700a89f37a3726cdf3202353bf61f280815a9df744e3c"
                           "9de6215a745a"),
          444638638, ProofValidationResult::NONE},
         {"Properly signed 1 UTXO proof, P2SH payout script",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680575db01b67"
          "5b042bf1ab89aa6ad3842804bb57bf87ebf2bfbcb169debdbf9c51e5d2638eb981bfd"
          "0e7465a5f3edd152d52b2f6d0108fcd277168be362e849e1f17a914da1745e9b549bd"
          "0bfa1a569971c77eba30cd5a4b87fea0a245528a4aadfc1dd5731c0cfe738e276c938"
          "15c69789fe97b15a5fb5b4f75b598ed94096205561e8d16203b8ef21763891d8e79a5"
          "9862bccbbd5bdf3a58",
          ProofId::fromHex("c61ee0416eb9549ea0e09dfd2c6062a11aa5d3ab0adcdf59abcc"
                           "02dd0de401fc"),
          444638638, ProofValidationResult::NONE},
         {"Properly signed 1 UTXO proof, 1-of-1 multisig payout script",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680ea4c55850f"
          "587c7839fe254880547049a8be7c27cf511e440fa46237db32dced28e0c10edcf5ddb"
          "31e2f61e5c749e7324e7edf9aa09547810d64a12fb960a206255121023beefdde700a"
          "6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde351ae29eaecb058c9b"
          "b74eef68dbeaa5da8b96aacc00bc89c911095ad016cfbdc53b1eeb10a9f29d6c48a5f"
          "b3a1e6e30d332a05bdc67062f94acffbe6d6c909bb5643",
          ProofId::fromHex("29deedc94713bbc4d4f88fe96fae6801b91c5ae50601f158fa76"
                           "a036e18ea468"),
          444638638, ProofValidationResult::NONE},
         {"Properly signed 1 UTXO proof, 2-of-3 multisig payout script",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680edf24d6c6e"
          "1ed44a0e0d651d5d2611f80e5c921778c3cbc2923fade878d7d9c69e5f4f7ff0c8dd9"
          "985ff427011c5cf0cac854c607e1d788d140f8b6d6010aad8695221023beefdde700a"
          "6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde321023beefdde700a6"
          "bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde353ae34814734c1bd2c4"
          "76fdae6fb1145530c3244878f3c2e0c2e5c05da14f17456aedee6beb80f68f42248fd"
          "89042346be54beaef7da8e549d7d5ff07f9a2cc63c83",
          ProofId::fromHex("c24dc13d98d0e0a80c19346b9590368557a66f0f65c0088c179d"
                           "89eca25107c8"),
          444638638, ProofValidationResult::NONE},
         {"Properly signed 1 UTXO proof, OP_RETURN payout script",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680b746fe5c9d"
          "10002880169f03c69456f57d60589cd451c2fa078fc0241a022f2c6f1736b4bb49ea0"
          "d7b878e581de9625f301c68defeda9d506f9b128dbccb08481b6a19492077616e7420"
          "746f206275726e206d792072657761726473f42ae2e5fa253a700e5dcb3970a894db4"
          "48b61960b45c84723bf769d4dab0370994d0163e235b688da2fabc8e5b57e24805dce"
          "3baa62e064c32266a723c6adb6",
          ProofId::fromHex("bfc250ca1986177acc779f26eaff80aa8916d23cb3e7e0ce6d35"
                           "89c4f5ea364c"),
          444638638, ProofValidationResult::NONE},
         {"Invalid payout script (OP_FALSE)",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68082a5aec394"
          "b2a25fedc70a81f93bb08b46a51bd1259f3f10fa421a4989039d74d30cf449de3b8b4"
          "6551b8ec927a83d16caaf8fc32636110407cfc9effbaf8c210100b71f0e77b4ad5d73"
          "d5a872ab43699309b5c194f72be5ee0812236c1a46a5b2c22ddd71d909cf52143f487"
          "54a61dfe0c6566342fa50b7d62c40fb44d1ff5abed3",
          ProofId::fromHex("046e75fa2d7f0868dcfa683bbdf657fc6a49b8f8b0d5c2dfdf90"
                           "736ded26b076"),
          444638638, ProofValidationResult::INVALID_PAYOUT_SCRIPT},
         {"Invalid payout script (1-of-5 multisig)",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6804d972714d8"
          "bcdeb680cd736ee6252c92453d7de362b97007c77abe1d76c80c41b502aa331a94d50"
          "fb2d709b66a679e2b4b2385dd2f4fad13c85015fc4c6ae7e4ad5121023beefdde700a"
          "6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde321023beefdde700a6"
          "bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde321023beefdde700a6bc"
          "02036335b4df141c8bc67bb05a971f5ac2745fd683797dde321023beefdde700a6bc0"
          "2036335b4df141c8bc67bb05a971f5ac2745fd683797dde355ae005dfe80b01bc99f9"
          "3ae1d1c2d7176f7ea54a7f7c76b6eabb1aec5d31de170b0690282f624d01070fb2700"
          "18694aea6a73ac5b7a96e30ed69df9b7684298b986",
          ProofId::fromHex("e66b0ab11de5e2f358d2e1f65b1ebe608e4a1f10a9f5d42f1173"
                           "b262e1a218a6"),
          444638638, ProofValidationResult::INVALID_PAYOUT_SCRIPT},
         {"Changing the payout address changes the proof signature (P2PK) but "
          "not the stake signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6804534ca1f5e"
          "22670be3df5cbd5957d8dd83d05c8f17eae391f0e7ffdce4fb3defadb7c079473ebec"
          "cf88c1f8ce87c61e451447b89c445967335ffd1aadef429982321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde4ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("ce2812a1decdef0267e0266c68ab53c5ecad292f7b7d0fbd3db9"
                           "285a08ccd2a1"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         // The following tests are based on the valid 1 UTXO proof (P2PK script)
         {"Changing the sequence changes the proof signature",
          "da7587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6808ef3a5bb64"
          "dc73a757aba041f348e7bc93c9c96f53a3d48a9a9df6f505f37283834788bad9370e9"
          "e6e702f8ba5323d38cb3b720adfefee6af4187ee6d9bed2482321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("37a08e004f35d6410b24a5724b8351b41d4e3ac04f285cd76d73"
                           "a023b2ae5519"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the expiration time changes the proof signature",
          "d97587e6c882615797011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680e475b4323a"
          "a8775b6b0ab82985f515bd95fb1cc18389d40c7a59a49df1ffa788ae68cfcc21e60c0"
          "e39806e935ce19b71f1182f4ca83f51d654a95b2e9b021ea12321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("1312eff53594f63e61f044c36b2cf2d3e7e44c706f17bfabcf49"
                           "954741380bbc"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the master pubkey does NOT change the proof signature (but "
          "signature verification obviously fails)",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde40169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680306b113bd2"
          "fc0e5c4f0cc46aed8a6c8efb0b5bcdc214ad78a29e00b1174c67d1c4576f4d815ba74"
          "ef6bdd0d8243402f6c4c8dcf71a4eb24d97f6d6b1d4a65b912321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("de837b44ae2df5408f89dc42039ae53a61ea508a15e214e69a50"
                           "d940b72e7713"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the TxId changes the proof signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde3016aa79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680e0d7f1933e"
          "b1e4f9011b9cf363f198f764ff5d65f471f4e4568beeed834d15f6917378fc9f84a3a"
          "5c3e445329dbfed556d82ba43e74619e32baad4b3437e2f482321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("2c90b8359740d675952b570cca76ffb7c1a225984b8c7f47bc27"
                           "607c58a613b5"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the outpoint index changes the proof signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91df00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6803671ac4cd4"
          "928d9db4be75e0213709e903855369c90f2bd8459ad24ad936a09c550b87d2ab7c7c0"
          "f1e7b18c484c65aa175e3fc10088b198334d9b2846d7c19272321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("289c082f835c2edd24b95e1aee7dbb353dff30cdcaab02d5dc2a"
                           "c44c57181468"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the amount changes the proof signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21814712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680c4a8d2cbb3"
          "ef086b41da91cbf99404c4970fee9cd8dff8c82d4169751e1049fb2506a194e14ef96"
          "4f308f1afdbb3853df59f58fa88cedcf71722f8130f89e6ef2321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("8d97d3ed1884462122976da4706778593fc4b5eaafb859bec0b4"
                           "5f590219f5ba"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the height changes the proof signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf2180471280659401003ae168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6804fb8adfb4e"
          "08ad2e6284042968f65dfe365b975492fdac597c75ae91edcb3b0d7ad9352d0cff1b2"
          "7577eb5fc4646f0106d57d214f71ce21272eb31af09482f2b2321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("690cb3d74b5add1cfb7d4cf186426d41117586c57d59da330cc9"
                           "50e2d18d613c"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the coinbase flag changes the proof signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010039e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6807b0eeab05c"
          "31d69c288fab140311274530dea518a7b62846c33e6a087b489210fed85b8a18017d4"
          "30751e81e276aecdb565a3cd5c58b5a0f81cbf5af33196dfd2321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("f713dec5d2f798360748914face171d5a45706b9c5f0bc4d561f"
                           "6e80e098beef"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the stake pubkey changes the proof signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6814534ca1f5e"
          "22670be3df5cbd5957d8dd83d05c8f17eae391f0e7ffdce4fb3defadb7c079473ebec"
          "cf88c1f8ce87c61e451447b89c445967335ffd1aadef429982321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("df84548b3a085e29d58ba5e83ad2fd1c9ecbe8595d4240f3f588"
                           "e52af84cc65b"),
          444638638, ProofValidationResult::INVALID_PROOF_SIGNATURE},
         {"Changing the stake signature does NOT change the proof signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30169a79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6804534ca1f5e"
          "22670be3df5cbd5957d8dd83d05c8f17eae391f0e7ffdce4fb3defadb7c079473ebec"
          "cf88c1f8ce87c61e451447b89c445967335ffd1aadef429992321023beefdde700a6b"
          "c02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac7b0b7865200f63052"
          "ff980b93f965f398dda04917d411dd46e3c009a5fef35661fac28779b6a22760c0000"
          "4f5ddf7d9865c7fead7e4a840b947939590261640f",
          ProofId::fromHex("455f34eb8a00b0799630071c0728481bdb1653035b1484ac33e9"
                           "74aa4ae7db6d"),
          444638638, ProofValidationResult::INVALID_STAKE_SIGNATURE},
         {"Adding a stake changes the proof signature but does not involve "
          "changing the previous stake signature",
          "d97587e6c882615796011ec8f9a7b1c621023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde3026aa79ff23e1d58c64afad42ad81cffe53967"
          "e16beb692fc5776bb442c79c5d91df00cf2180471280659401003be168a32102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680f2adfb4bcb"
          "14bf1f6aa38a44994419bd34e9da07d972d3f092cd3ef037fe7bcd92e3d7073faa7e6"
          "e0697b9fab8670417959ab0b0958fdc576a11dffe599e851269a79ff23e1d58c64afa"
          "d42ad81cffe53967e16beb692fc5776bb442c79c5d91de00cf2180471280659401003"
          "8e168a32102449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8"
          "bce6804534ca1f5e22670be3df5cbd5957d8dd83d05c8f17eae391f0e7ffdce4fb3de"
          "fadb7c079473ebeccf88c1f8ce87c61e451447b89c445967335ffd1aadef429982321"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3ac9"
          "32ce54c4d405de52399cf48b4b10038d1bbbd65206f0934b2bdfc7b6a4a2e1cff1803"
          "a69bd03dd3897d4cfde46c2ee2cf17895880770c8b49089a26b6b5ff1e",
          ProofId::fromHex("96bd9fee759d81f9bc30e26015d979df3f6046c7a8764582d1a2"
                           "c5c3d61c2f44"),
          2 * 444638638, ProofValidationResult::NONE},
     };
 
     auto checkCases = [&](const std::vector<TestVector> &testcases) {
         for (auto &c : testcases) {
             Proof p;
             bilingual_str error;
             BOOST_CHECK(Proof::FromHex(p, c.hex, error));
             BOOST_CHECK_EQUAL(p.getId(), c.proofid);
             BOOST_CHECK_EQUAL(p.getScore(), c.score);
 
             ProofValidationState state;
             BOOST_CHECK_EQUAL(p.verify(PROOF_DUST_THRESHOLD, state),
                               c.result == ProofValidationResult::NONE);
             BOOST_CHECK(state.GetResult() == c.result);
             BOOST_TEST_MESSAGE(c.proofid);
         }
     };
 
     gArgs.ForceSetArg("-legacyavaproof", "1");
     BOOST_CHECK(Proof::useLegacy(gArgs));
     checkCases(legacyFormatTestCases);
 
     gArgs.ForceSetArg("-legacyavaproof", "0");
     BOOST_CHECK(!Proof::useLegacy(gArgs));
     checkCases(regularFormatTestCases);
 
     gArgs.ClearForcedArg("-legacyavaproof");
 }
 
 BOOST_AUTO_TEST_CASE(verify) {
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "1");
 
     auto key = CKey::MakeCompressedKey();
     const CPubKey pubkey = key.GetPubKey();
 
     const Amount value = 2 * PROOF_DUST_THRESHOLD;
     const uint32_t height = 10;
 
     ChainstateManager &chainman = *Assert(m_node.chainman);
     LOCK(cs_main);
     CCoinsViewCache &coins = chainman.ActiveChainstate().CoinsTip();
 
     COutPoint pkh_outpoint(TxId(InsecureRand256()), InsecureRand32());
     CTxOut pkh_output(value, GetScriptForRawPubKey(pubkey));
     coins.AddCoin(pkh_outpoint, Coin(pkh_output, height, false), false);
 
     COutPoint nonstd_outpoint(TxId(InsecureRand256()), InsecureRand32());
     CTxOut nonstd_output(value, CScript() << OP_TRUE);
     coins.AddCoin(nonstd_outpoint, Coin(nonstd_output, height, false), false);
 
     COutPoint p2sh_outpoint(TxId(InsecureRand256()), InsecureRand32());
     CTxOut p2sh_output(value,
                        GetScriptForDestination(ScriptHash(InsecureRand160())));
     coins.AddCoin(p2sh_outpoint, Coin(p2sh_output, height, false), false);
 
     const auto runCheck = [&](const ProofValidationResult result,
                               const COutPoint &o, const Amount v,
                               const uint32_t h, const bool is_coinbase,
                               const CKey &k, int64_t expirationTime = 0) {
         // Generate a proof that match the UTXO.
-        ProofBuilder pb(0, expirationTime, key);
+        ProofBuilder pb(0, expirationTime, key,
+                        UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         BOOST_CHECK(pb.addUTXO(o, v, h, is_coinbase, k));
         ProofRef p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(p->verify(PROOF_DUST_THRESHOLD, state));
         LOCK(cs_main);
         BOOST_CHECK(p->verify(PROOF_DUST_THRESHOLD, chainman, state) ==
                     (result == ProofValidationResult::NONE));
         BOOST_CHECK(state.GetResult() == result);
     };
 
     const int64_t currentTipMTP = chainman.ActiveTip()->GetMedianTimePast();
 
     // Valid proof
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key);
 
     // Expiration checks
 
     // Negative or zero expiration times means no expiration
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key, -1);
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key, 0);
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key, std::numeric_limits<int64_t>::min());
 
     // The future
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key, std::numeric_limits<int64_t>::max());
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key, currentTipMTP + 1);
 
     // Expired proofs
     runCheck(ProofValidationResult::EXPIRED, pkh_outpoint, value, height, false,
              key, 1);
     runCheck(ProofValidationResult::EXPIRED, pkh_outpoint, value, height, false,
              key, currentTipMTP - 1);
     runCheck(ProofValidationResult::EXPIRED, pkh_outpoint, value, height, false,
              key, currentTipMTP);
 
     // Coinbase mismatch
     runCheck(ProofValidationResult::COINBASE_MISMATCH, pkh_outpoint, value,
              height, true, key);
 
     // Height mismatch
     runCheck(ProofValidationResult::HEIGHT_MISMATCH, pkh_outpoint, value,
              height + 1, false, key);
 
     // Amount mismatch
     runCheck(ProofValidationResult::AMOUNT_MISMATCH, pkh_outpoint,
              value + 1 * SATOSHI, height, false, key);
 
     // Invalid outpoints
     runCheck(ProofValidationResult::MISSING_UTXO,
              COutPoint(pkh_outpoint.GetTxId(), pkh_outpoint.GetN() + 1), value,
              height, false, key);
     runCheck(ProofValidationResult::MISSING_UTXO,
              COutPoint(TxId(InsecureRand256()), pkh_outpoint.GetN()), value,
              height, false, key);
 
     // Non standard script
     runCheck(ProofValidationResult::NON_STANDARD_DESTINATION, nonstd_outpoint,
              value, height, false, key);
 
     // Non PKHhash destination
     runCheck(ProofValidationResult::DESTINATION_NOT_SUPPORTED, p2sh_outpoint,
              value, height, false, key);
 
     // Mismatching key
     {
         runCheck(ProofValidationResult::DESTINATION_MISMATCH, pkh_outpoint,
                  value, height, false, CKey::MakeCompressedKey());
     }
 
     // No stake
     {
-        ProofRef p = ProofBuilder(0, 0, key).build();
+        ProofRef p =
+            ProofBuilder(0, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT).build();
 
         ProofValidationState state;
         BOOST_CHECK(!p->verify(PROOF_DUST_THRESHOLD, chainman, state));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::NO_STAKE);
     }
 
     // Dust thresold
     {
         // tuple<utxo value, dust threshold, result>
         std::vector<std::tuple<Amount, Amount, ProofValidationResult>>
             testCases = {
                 // Defaults
                 {Amount::zero(), PROOF_DUST_THRESHOLD,
                  ProofValidationResult::DUST_THRESHOLD},
                 {PROOF_DUST_THRESHOLD - 1 * SATOSHI, PROOF_DUST_THRESHOLD,
                  ProofValidationResult::DUST_THRESHOLD},
                 {value, PROOF_DUST_THRESHOLD, ProofValidationResult::NONE},
                 // Modified threshold
                 {Amount::zero(), value, ProofValidationResult::DUST_THRESHOLD},
                 {value - 1 * SATOSHI, value,
                  ProofValidationResult::DUST_THRESHOLD},
                 {value, value, ProofValidationResult::NONE},
             };
 
         for (auto it = testCases.begin(); it != testCases.end(); ++it) {
-            ProofBuilder pb(0, 0, key);
+            ProofBuilder pb(0, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
             BOOST_CHECK(
                 pb.addUTXO(pkh_outpoint, std::get<0>(*it), height, false, key));
             ProofRef p = pb.build();
 
             ProofValidationState state;
             BOOST_CHECK(p->verify(std::get<1>(*it), chainman, state) ==
                         (std::get<2>(*it) == ProofValidationResult::NONE));
             BOOST_CHECK(state.GetResult() == std::get<2>(*it));
         }
     }
 
     // Duplicated input
     {
-        ProofBuilder pb(0, 0, key);
+        ProofBuilder pb(0, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         BOOST_CHECK(pb.addUTXO(pkh_outpoint, value, height, false, key));
         ProofRef p = TestProofBuilder::buildDuplicatedStakes(pb);
 
         ProofValidationState state;
         BOOST_CHECK(!p->verify(PROOF_DUST_THRESHOLD, chainman, state));
         BOOST_CHECK(state.GetResult() ==
                     ProofValidationResult::DUPLICATE_STAKE);
     }
 
     // Wrong stake ordering
     {
         COutPoint other_pkh_outpoint(TxId(InsecureRand256()), InsecureRand32());
         CTxOut other_pkh_output(value, GetScriptForRawPubKey(pubkey));
         coins.AddCoin(other_pkh_outpoint, Coin(other_pkh_output, height, false),
                       false);
 
-        ProofBuilder pb(0, 0, key);
+        ProofBuilder pb(0, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         BOOST_CHECK(pb.addUTXO(pkh_outpoint, value, height, false, key));
         BOOST_CHECK(pb.addUTXO(other_pkh_outpoint, value, height, false, key));
         ProofRef p = TestProofBuilder::buildWithReversedOrderStakes(pb);
 
         ProofValidationState state;
         BOOST_CHECK(!p->verify(PROOF_DUST_THRESHOLD, chainman, state));
         BOOST_CHECK(state.GetResult() ==
                     ProofValidationResult::WRONG_STAKE_ORDERING);
     }
 
     // Immature stake
     {
         uint32_t chaintipHeight = chainman.ActiveHeight();
 
         // A proof where the UTXO is both missing and immature gives
         // MISSING_UTXO
         {
             gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "11");
             for (auto h = chaintipHeight; h > chaintipHeight - 10; h--) {
                 COutPoint outpoint(TxId(InsecureRand256()), InsecureRand32());
                 CTxOut output(value, GetScriptForRawPubKey(pubkey));
                 runCheck(ProofValidationResult::MISSING_UTXO, outpoint, value,
                          h, false, key);
 
                 // Add the coin to the UTXO set to verify it's immature
                 coins.AddCoin(outpoint, Coin(output, h, false), false);
                 runCheck(ProofValidationResult::IMMATURE_UTXO, outpoint, value,
                          h, false, key);
             }
         }
 
         // tuple<stake utxo confs, avaproofstakeutxoconfirmations, result>
         std::vector<std::tuple<uint32_t, std::string, ProofValidationResult>>
             testCases = {
                 // Require less or equal the number of confirmations the stake
                 // has
                 {chaintipHeight, "1", ProofValidationResult::NONE},
                 {50, "1", ProofValidationResult::NONE},
                 {50, "50", ProofValidationResult::NONE},
                 {50, "51", ProofValidationResult::NONE},
                 // Require more than the number of confirmations the stake has
                 {chaintipHeight, "2", ProofValidationResult::IMMATURE_UTXO},
                 {50, "52", ProofValidationResult::IMMATURE_UTXO},
                 {50, "100", ProofValidationResult::IMMATURE_UTXO},
             };
 
         for (auto it = testCases.begin(); it != testCases.end(); ++it) {
             const uint32_t stakeConfs = std::get<0>(*it);
             COutPoint outpoint(TxId(InsecureRand256()), InsecureRand32());
             CTxOut output(value, GetScriptForRawPubKey(pubkey));
             coins.AddCoin(outpoint, Coin(output, stakeConfs, false), false);
 
             gArgs.ForceSetArg("-avaproofstakeutxoconfirmations",
                               std::get<1>(*it));
             runCheck(std::get<2>(*it), outpoint, value, stakeConfs, false, key);
         }
         gArgs.ClearForcedArg("-avaproofstakeutxoconfirmations");
     }
 }
 
 BOOST_AUTO_TEST_CASE(deterministic_proofid) {
     auto key = CKey::MakeCompressedKey();
 
     const Amount value = 12345 * COIN;
     const uint32_t height = 10;
 
     std::vector<COutPoint> outpoints(10);
     for (size_t i = 0; i < 10; i++) {
         outpoints[i] = COutPoint(TxId(InsecureRand256()), InsecureRand32());
     }
 
     auto computeProofId = [&]() {
-        ProofBuilder pb(0, 0, key);
+        ProofBuilder pb(0, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         for (const COutPoint &outpoint : outpoints) {
             BOOST_CHECK(pb.addUTXO(outpoint, value, height, false, key));
         }
         ProofRef p = pb.build();
 
         return p->getId();
     };
 
     const ProofId proofid = computeProofId();
     Shuffle(outpoints.begin(), outpoints.end(), FastRandomContext());
     BOOST_CHECK_EQUAL(proofid, computeProofId());
 }
 
 BOOST_AUTO_TEST_CASE(get_staked_amount) {
     auto key = CKey::MakeCompressedKey();
-    ProofBuilder pb(10, 11, key);
+    ProofBuilder pb(10, 11, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
 
     {
         ProofRef p = pb.build();
         BOOST_CHECK_EQUAL(p->getStakedAmount(), Amount::zero());
     }
 
     for (int i = 1; i <= 10; i++) {
         BOOST_CHECK(pb.addUTXO(COutPoint(TxId(GetRandHash()), 0), i * COIN, 42,
                                false, key));
     }
 
     {
         ProofRef p = pb.build();
         BOOST_CHECK_EQUAL(p->getStakedAmount(), 55 * COIN);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/proofpool_tests.cpp b/src/avalanche/test/proofpool_tests.cpp
index a8f4988f9..04cfd51a2 100644
--- a/src/avalanche/test/proofpool_tests.cpp
+++ b/src/avalanche/test/proofpool_tests.cpp
@@ -1,374 +1,374 @@
 // 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.
 
 #include <avalanche/proofpool.h>
 
 #include <avalanche/peermanager.h>
 #include <avalanche/proofcomparator.h>
 #include <key.h>
 #include <primitives/transaction.h>
 #include <primitives/txid.h>
 #include <random.h>
 
 #include <avalanche/test/util.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 using namespace avalanche;
 
 BOOST_FIXTURE_TEST_SUITE(proofpool_tests, TestChain100Setup)
 
 BOOST_AUTO_TEST_CASE(add_remove_proof_no_conflict) {
     ProofPool testPool;
 
     CChainState &active_chainstate =
         Assert(m_node.chainman)->ActiveChainstate();
 
     std::vector<ProofRef> proofs;
     for (size_t i = 0; i < 10; i++) {
         // Add a bunch of random proofs
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof),
                           ProofPool::AddProofStatus::SUCCEED);
         BOOST_CHECK_EQUAL(testPool.countProofs(), i + 1);
 
         // Trying to add them again will return a duplicated status
         for (size_t j = 0; j < 10; j++) {
             BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof),
                               ProofPool::AddProofStatus::DUPLICATED);
             BOOST_CHECK_EQUAL(testPool.countProofs(), i + 1);
         }
         proofs.push_back(std::move(proof));
     }
 
     const CKey key = CKey::MakeCompressedKey();
     const COutPoint conflictingOutpoint{TxId(GetRandHash()), 0};
 
     auto buildProofWithSequence = [&](uint64_t sequence) {
-        ProofBuilder pb(sequence, 0, key);
+        ProofBuilder pb(sequence, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         BOOST_CHECK(
             pb.addUTXO(conflictingOutpoint, 10 * COIN, 123456, false, key));
         return pb.build();
     };
 
     auto proof_seq10 = buildProofWithSequence(10);
     BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof_seq10),
                       ProofPool::AddProofStatus::SUCCEED);
     BOOST_CHECK_EQUAL(testPool.countProofs(), 11);
     proofs.push_back(std::move(proof_seq10));
 
     auto proof_seq20 = buildProofWithSequence(20);
     BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof_seq20),
                       ProofPool::AddProofStatus::REJECTED);
     BOOST_CHECK_EQUAL(testPool.countProofs(), 11);
 
     // Removing proofs which are not in the pool will fail
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(!testPool.removeProof(ProofId(GetRandHash())));
     }
     BOOST_CHECK_EQUAL(testPool.countProofs(), 11);
 
     for (auto proof : proofs) {
         BOOST_CHECK(testPool.removeProof(proof->getId()));
     }
     BOOST_CHECK_EQUAL(testPool.size(), 0);
     BOOST_CHECK_EQUAL(testPool.countProofs(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(rescan) {
     gArgs.ForceSetArg("-avaproofstakeutxoconfirmations", "1");
     ProofPool testPool;
     avalanche::PeerManager pm(PROOF_DUST_THRESHOLD, *Assert(m_node.chainman));
 
     testPool.rescan(pm);
     BOOST_CHECK_EQUAL(testPool.size(), 0);
     BOOST_CHECK_EQUAL(testPool.countProofs(), 0);
 
     // No peer should be created
     bool hasPeer = false;
     pm.forEachPeer([&](const Peer &p) { hasPeer = true; });
     BOOST_CHECK(!hasPeer);
 
     CChainState &active_chainstate =
         Assert(m_node.chainman)->ActiveChainstate();
 
     std::set<ProofRef, ProofRefComparatorByAddress> poolProofs;
     for (size_t i = 0; i < 10; i++) {
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof),
                           ProofPool::AddProofStatus::SUCCEED);
         poolProofs.insert(std::move(proof));
         BOOST_CHECK_EQUAL(testPool.countProofs(), i + 1);
     }
 
     testPool.rescan(pm);
 
     // All the proofs should be registered as peer
     std::set<ProofRef, ProofRefComparatorByAddress> pmProofs;
     pm.forEachPeer([&](const Peer &p) { pmProofs.insert(p.proof); });
     BOOST_CHECK_EQUAL_COLLECTIONS(poolProofs.begin(), poolProofs.end(),
                                   pmProofs.begin(), pmProofs.end());
     BOOST_CHECK_EQUAL(testPool.size(), 0);
     BOOST_CHECK_EQUAL(testPool.countProofs(), 0);
 
     gArgs.ClearForcedArg("-avaproofstakeutxoconfirmations");
 }
 
 BOOST_AUTO_TEST_CASE(proof_override) {
     ProofPool testPool;
 
     const CKey key = CKey::MakeCompressedKey();
 
     auto buildProofWithSequenceAndOutpoints =
         [&](uint64_t sequence, const std::vector<COutPoint> &outpoints) {
-            ProofBuilder pb(sequence, 0, key);
+            ProofBuilder pb(sequence, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
             for (const COutPoint &outpoint : outpoints) {
                 BOOST_CHECK(
                     pb.addUTXO(outpoint, 10 * COIN, 123456, false, key));
             }
             return pb.build();
         };
 
     const COutPoint outpoint1{TxId(GetRandHash()), 0};
     const COutPoint outpoint2{TxId(GetRandHash()), 0};
     const COutPoint outpoint3{TxId(GetRandHash()), 0};
 
     // Build and register 3 proofs with a single utxo
     auto proof_seq10 = buildProofWithSequenceAndOutpoints(10, {outpoint1});
     auto proof_seq20 = buildProofWithSequenceAndOutpoints(20, {outpoint2});
     auto proof_seq30 = buildProofWithSequenceAndOutpoints(30, {outpoint3});
 
     BOOST_CHECK_EQUAL(testPool.addProofIfPreferred(proof_seq10),
                       ProofPool::AddProofStatus::SUCCEED);
     BOOST_CHECK(testPool.getProof(proof_seq10->getId()));
     BOOST_CHECK_EQUAL(testPool.countProofs(), 1);
 
     BOOST_CHECK_EQUAL(testPool.addProofIfPreferred(proof_seq20),
                       ProofPool::AddProofStatus::SUCCEED);
     BOOST_CHECK(testPool.getProof(proof_seq20->getId()));
     BOOST_CHECK_EQUAL(testPool.countProofs(), 2);
 
     BOOST_CHECK_EQUAL(testPool.addProofIfPreferred(proof_seq30),
                       ProofPool::AddProofStatus::SUCCEED);
     BOOST_CHECK(testPool.getProof(proof_seq30->getId()));
     BOOST_CHECK_EQUAL(testPool.countProofs(), 3);
 
     // Build a proof that conflicts with the above 3, but has a higher sequence
     auto proof_seq123 = buildProofWithSequenceAndOutpoints(
         123, {outpoint1, outpoint2, outpoint3});
     ProofPool::ConflictingProofSet expectedConflictingProofs = {
         proof_seq10, proof_seq20, proof_seq30};
 
     // The no conflict call should reject our candidate and not alter the 3
     // conflicting proofs
     ProofPool::ConflictingProofSet conflictingProofs;
     BOOST_CHECK_EQUAL(
         testPool.addProofIfNoConflict(proof_seq123, conflictingProofs),
         ProofPool::AddProofStatus::REJECTED);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         conflictingProofs.begin(), conflictingProofs.end(),
         expectedConflictingProofs.begin(), expectedConflictingProofs.end());
     BOOST_CHECK_EQUAL(testPool.countProofs(), 3);
     BOOST_CHECK(!testPool.getProof(proof_seq123->getId()));
     BOOST_CHECK(testPool.getProof(proof_seq10->getId()));
     BOOST_CHECK(testPool.getProof(proof_seq20->getId()));
     BOOST_CHECK(testPool.getProof(proof_seq30->getId()));
 
     // The conflict handling call will override the 3 conflicting proofs
     conflictingProofs.clear();
     BOOST_CHECK_EQUAL(
         testPool.addProofIfPreferred(proof_seq123, conflictingProofs),
         ProofPool::AddProofStatus::SUCCEED);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         conflictingProofs.begin(), conflictingProofs.end(),
         expectedConflictingProofs.begin(), expectedConflictingProofs.end());
     BOOST_CHECK_EQUAL(testPool.countProofs(), 1);
     BOOST_CHECK(testPool.getProof(proof_seq123->getId()));
     BOOST_CHECK(!testPool.getProof(proof_seq10->getId()));
     BOOST_CHECK(!testPool.getProof(proof_seq20->getId()));
     BOOST_CHECK(!testPool.getProof(proof_seq30->getId()));
 }
 
 BOOST_AUTO_TEST_CASE(conflicting_proofs_set) {
     ProofPool testPool;
 
     const CKey key = CKey::MakeCompressedKey();
     const COutPoint conflictingOutpoint{TxId(GetRandHash()), 0};
 
     auto buildProofWithSequence = [&](uint64_t sequence) {
-        ProofBuilder pb(sequence, 0, key);
+        ProofBuilder pb(sequence, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         BOOST_CHECK(
             pb.addUTXO(conflictingOutpoint, 10 * COIN, 123456, false, key));
         return pb.build();
     };
 
     auto proofSeq10 = buildProofWithSequence(10);
     auto proofSeq20 = buildProofWithSequence(20);
     auto proofSeq30 = buildProofWithSequence(30);
 
     BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proofSeq20),
                       ProofPool::AddProofStatus::SUCCEED);
 
     CChainState &active_chainstate =
         Assert(m_node.chainman)->ActiveChainstate();
 
     auto getRandomConflictingProofSet = [&active_chainstate]() {
         return ProofPool::ConflictingProofSet{
             buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE),
             buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE),
             buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE),
         };
     };
 
     auto checkConflictingProofs =
         [&](const ProofPool::ConflictingProofSet &conflictingProofs,
             const ProofPool::ConflictingProofSet &expectedConflictingProofs) {
             BOOST_CHECK_EQUAL_COLLECTIONS(conflictingProofs.begin(),
                                           conflictingProofs.end(),
                                           expectedConflictingProofs.begin(),
                                           expectedConflictingProofs.end());
         };
 
     {
         // Without override, duplicated proof
         auto conflictingProofs = getRandomConflictingProofSet();
         BOOST_CHECK_EQUAL(
             testPool.addProofIfNoConflict(proofSeq20, conflictingProofs),
             ProofPool::AddProofStatus::DUPLICATED);
         checkConflictingProofs(conflictingProofs, {});
     }
 
     {
         // With override, duplicated proof
         auto conflictingProofs = getRandomConflictingProofSet();
         BOOST_CHECK_EQUAL(
             testPool.addProofIfPreferred(proofSeq20, conflictingProofs),
             ProofPool::AddProofStatus::DUPLICATED);
         checkConflictingProofs(conflictingProofs, {});
     }
 
     {
         // Without override, worst proof
         auto conflictingProofs = getRandomConflictingProofSet();
         BOOST_CHECK_EQUAL(
             testPool.addProofIfNoConflict(proofSeq10, conflictingProofs),
             ProofPool::AddProofStatus::REJECTED);
         checkConflictingProofs(conflictingProofs, {proofSeq20});
     }
 
     {
         // Without override, better proof
         auto conflictingProofs = getRandomConflictingProofSet();
         BOOST_CHECK_EQUAL(
             testPool.addProofIfNoConflict(proofSeq30, conflictingProofs),
             ProofPool::AddProofStatus::REJECTED);
         checkConflictingProofs(conflictingProofs, {proofSeq20});
     }
 
     {
         // With override, worst proof
         auto conflictingProofs = getRandomConflictingProofSet();
         BOOST_CHECK_EQUAL(
             testPool.addProofIfPreferred(proofSeq10, conflictingProofs),
             ProofPool::AddProofStatus::REJECTED);
         checkConflictingProofs(conflictingProofs, {proofSeq20});
     }
 
     {
         // With override, better proof
         auto conflictingProofs = getRandomConflictingProofSet();
         BOOST_CHECK_EQUAL(
             testPool.addProofIfPreferred(proofSeq30, conflictingProofs),
             ProofPool::AddProofStatus::SUCCEED);
         checkConflictingProofs(conflictingProofs, {proofSeq20});
     }
 }
 
 BOOST_AUTO_TEST_CASE(get_proof) {
     ProofPool testPool;
 
     for (size_t i = 0; i < 10; i++) {
         BOOST_CHECK(!testPool.getProof(ProofId(GetRandHash())));
     }
 
     CChainState &active_chainstate =
         Assert(m_node.chainman)->ActiveChainstate();
 
     for (size_t i = 0; i < 10; i++) {
         auto proof = buildRandomProof(active_chainstate, MIN_VALID_PROOF_SCORE);
         BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof),
                           ProofPool::AddProofStatus::SUCCEED);
 
         auto retrievedProof = testPool.getProof(proof->getId());
         BOOST_CHECK_NE(retrievedProof, nullptr);
         BOOST_CHECK_EQUAL(retrievedProof->getId(), proof->getId());
     }
 }
 
 BOOST_AUTO_TEST_CASE(get_lowest_score_proof) {
     ProofPool testPool;
     BOOST_CHECK_EQUAL(testPool.getLowestScoreProof(), nullptr);
 
     const CKey key = CKey::MakeCompressedKey();
     auto buildProofWithRandomOutpoints = [&](uint32_t score) {
         int numOutpoints = InsecureRand32() % 10 + 1;
-        ProofBuilder pb(0, 0, key);
+        ProofBuilder pb(0, 0, key, UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
         for (int i = 0; i < numOutpoints; i++) {
             Amount amount = 1 * COIN;
             if (i == numOutpoints - 1) {
                 // Last UTXO is the remainder
                 amount =
                     (int64_t(score) * COIN) / 100 - (numOutpoints - 1) * COIN;
             }
             const COutPoint outpoint{TxId(GetRandHash()), 0};
             BOOST_CHECK(pb.addUTXO(outpoint, amount, 123456, false, key));
         }
         return pb.build();
     };
 
     // Add some proofs with different scores and check the lowest scoring proof
     for (int i = 9; i >= 0; i--) {
         auto proof = buildProofWithRandomOutpoints(MIN_VALID_PROOF_SCORE + i);
         BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof),
                           ProofPool::AddProofStatus::SUCCEED);
         auto checkLowestScoreProof = testPool.getLowestScoreProof();
         BOOST_CHECK_EQUAL(checkLowestScoreProof->getScore(),
                           MIN_VALID_PROOF_SCORE + i);
         BOOST_CHECK_EQUAL(checkLowestScoreProof->getId(), proof->getId());
     }
     BOOST_CHECK_EQUAL(testPool.countProofs(), 10);
 
     auto lowestScoreProof = testPool.getLowestScoreProof();
 
     // Adding more proofs doesn't change the lowest scoring proof
     for (size_t i = 1; i < 10; i++) {
         auto proof = buildProofWithRandomOutpoints(MIN_VALID_PROOF_SCORE + i);
         BOOST_CHECK_EQUAL(testPool.addProofIfNoConflict(proof),
                           ProofPool::AddProofStatus::SUCCEED);
         auto checkLowestScoreProof = testPool.getLowestScoreProof();
         BOOST_CHECK_EQUAL(checkLowestScoreProof->getScore(),
                           MIN_VALID_PROOF_SCORE);
         BOOST_CHECK_EQUAL(checkLowestScoreProof->getId(),
                           lowestScoreProof->getId());
     }
     BOOST_CHECK_EQUAL(testPool.countProofs(), 19);
 
     // Remove proofs by lowest score, checking the lowest score as we go
     for (int scoreCount = 1; scoreCount < 10; scoreCount++) {
         for (size_t i = 0; i < 2; i++) {
             BOOST_CHECK(
                 testPool.removeProof(testPool.getLowestScoreProof()->getId()));
             BOOST_CHECK_EQUAL(testPool.getLowestScoreProof()->getScore(),
                               MIN_VALID_PROOF_SCORE + scoreCount);
         }
     }
 
     // Remove the last proof
     BOOST_CHECK(testPool.removeProof(testPool.getLowestScoreProof()->getId()));
     BOOST_CHECK_EQUAL(testPool.getLowestScoreProof(), nullptr);
     BOOST_CHECK_EQUAL(testPool.countProofs(), 0);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/util.cpp b/src/avalanche/test/util.cpp
index cffb69899..91f8eeb7c 100644
--- a/src/avalanche/test/util.cpp
+++ b/src/avalanche/test/util.cpp
@@ -1,123 +1,124 @@
 // 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 <amount.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/test/util.h>
 #include <key.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/standard.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <limits>
 
 namespace avalanche {
 
 ProofRef buildRandomProof(CChainState &active_chainstate, uint32_t score,
                           int height, const CKey &masterKey) {
     auto key = CKey::MakeCompressedKey();
 
     const COutPoint o(TxId(GetRandHash()), 0);
     const Amount v = (int64_t(score) * COIN) / 100;
     const bool is_coinbase = false;
 
     {
         CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
         LOCK(cs_main);
         CCoinsViewCache &coins = active_chainstate.CoinsTip();
         coins.AddCoin(o, Coin(CTxOut(v, script), height, is_coinbase), false);
     }
 
-    ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), masterKey);
+    ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), masterKey,
+                    UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
     BOOST_CHECK(pb.addUTXO(o, v, height, is_coinbase, std::move(key)));
     return pb.build();
 }
 
 bool hasDustStake(const ProofRef &proof) {
     for (const SignedStake &s : proof->getStakes()) {
         if (s.getStake().getAmount() < PROOF_DUST_THRESHOLD) {
             return true;
         }
     }
     return false;
 }
 
 ProofId TestProofBuilder::getReverseOrderProofId(ProofBuilder &pb) {
     CHashWriter ss(SER_GETHASH, 0);
     ss << pb.sequence;
     ss << pb.expirationTime;
 
     WriteCompactSize(ss, pb.stakes.size());
     for (auto it = pb.stakes.rbegin(); it != pb.stakes.rend(); it++) {
         ss << it->stake;
     }
 
     CHashWriter ss2(SER_GETHASH, 0);
     ss2 << ss.GetHash();
     ss2 << pb.masterKey.GetPubKey();
 
     return ProofId(ss2.GetHash());
 }
 
 ProofRef TestProofBuilder::buildWithReversedOrderStakes(ProofBuilder &pb) {
     const ProofId proofid = TestProofBuilder::getReverseOrderProofId(pb);
     const StakeCommitment commitment(proofid);
 
     std::vector<SignedStake> signedStakes;
     signedStakes.reserve(pb.stakes.size());
 
     while (!pb.stakes.empty()) {
         // We need a forward iterator, so pb.stakes.rbegin() is not an
         // option.
         auto handle = pb.stakes.extract(std::prev(pb.stakes.end()));
         signedStakes.push_back(handle.value().sign(commitment));
     }
 
     return ProofRef::make(pb.sequence, pb.expirationTime,
                           pb.masterKey.GetPubKey(), std::move(signedStakes),
                           pb.payoutScriptPubKey, SchnorrSig());
 }
 
 ProofId TestProofBuilder::getDuplicatedStakeProofId(ProofBuilder &pb) {
     CHashWriter ss(SER_GETHASH, 0);
     ss << pb.sequence;
     ss << pb.expirationTime;
 
     WriteCompactSize(ss, 2 * pb.stakes.size());
     for (auto &s : pb.stakes) {
         ss << s.stake;
         ss << s.stake;
     }
 
     CHashWriter ss2(SER_GETHASH, 0);
     ss2 << ss.GetHash();
     ss2 << pb.masterKey.GetPubKey();
 
     return ProofId(ss2.GetHash());
 }
 
 ProofRef TestProofBuilder::buildDuplicatedStakes(ProofBuilder &pb) {
     const ProofId proofid = TestProofBuilder::getDuplicatedStakeProofId(pb);
     const StakeCommitment commitment(proofid);
 
     std::vector<SignedStake> signedStakes;
     signedStakes.reserve(2 * pb.stakes.size());
 
     while (!pb.stakes.empty()) {
         auto handle = pb.stakes.extract(pb.stakes.begin());
         SignedStake signedStake = handle.value().sign(commitment);
         signedStakes.push_back(signedStake);
         signedStakes.push_back(signedStake);
     }
 
     return ProofRef::make(pb.sequence, pb.expirationTime,
                           pb.masterKey.GetPubKey(), std::move(signedStakes),
                           pb.payoutScriptPubKey, SchnorrSig());
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/test/util.h b/src/avalanche/test/util.h
index 1f0639b42..bd7573d4e 100644
--- a/src/avalanche/test/util.h
+++ b/src/avalanche/test/util.h
@@ -1,33 +1,38 @@
 // 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_TEST_UTIL_H
 #define BITCOIN_AVALANCHE_TEST_UTIL_H
 
 #include <avalanche/proof.h>
 #include <avalanche/proofbuilder.h>
 #include <key.h>
+#include <script/script.h>
 
-#include <cstdio>
+#include <vector>
 
 namespace avalanche {
 
 constexpr uint32_t MIN_VALID_PROOF_SCORE = 100 * PROOF_DUST_THRESHOLD / COIN;
 
+const CScript UNSPENDABLE_ECREG_PAYOUT_SCRIPT =
+    CScript() << OP_DUP << OP_HASH160 << std::vector<uint8_t>(20, 0)
+              << OP_EQUALVERIFY << OP_CHECKSIG;
+
 ProofRef buildRandomProof(CChainState &active_chainstate, uint32_t score,
                           int height = 100,
                           const CKey &masterKey = CKey::MakeCompressedKey());
 
 bool hasDustStake(const ProofRef &proof);
 
 struct TestProofBuilder {
     static ProofId getReverseOrderProofId(ProofBuilder &pb);
     static ProofRef buildWithReversedOrderStakes(ProofBuilder &pb);
     static ProofId getDuplicatedStakeProofId(ProofBuilder &pb);
     static ProofRef buildDuplicatedStakes(ProofBuilder &pb);
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_TEST_UTIL_H
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index 46ebc91c8..a1a9ead0b 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -1,589 +1,591 @@
 // Copyright (c) 2012-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <serialize.h>
 
 #include <avalanche/proof.h>
 #include <avalanche/proofbuilder.h>
+#include <avalanche/test/util.h>
 #include <hash.h>
 #include <streams.h>
 #include <util/strencodings.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <cstdint>
 #include <limits>
 
 BOOST_FIXTURE_TEST_SUITE(serialize_tests, BasicTestingSetup)
 
 class CSerializeMethodsTestSingle {
 protected:
     int intval;
     bool boolval;
     std::string stringval;
     char charstrval[16];
     CTransactionRef txval;
     avalanche::ProofRef proofval;
 
 public:
     CSerializeMethodsTestSingle() = default;
     CSerializeMethodsTestSingle(int intvalin, bool boolvalin,
                                 std::string stringvalin,
                                 const char *charstrvalin,
                                 const CTransactionRef &txvalin,
                                 const avalanche::ProofRef &proofvalin)
         : intval(intvalin), boolval(boolvalin),
           stringval(std::move(stringvalin)), txval(txvalin),
           proofval(proofvalin) {
         memcpy(charstrval, charstrvalin, sizeof(charstrval));
     }
 
     SERIALIZE_METHODS(CSerializeMethodsTestSingle, obj) {
         READWRITE(obj.intval);
         READWRITE(obj.boolval);
         READWRITE(obj.stringval);
         READWRITE(obj.charstrval);
         READWRITE(obj.txval);
         READWRITE(obj.proofval);
     }
 
     bool operator==(const CSerializeMethodsTestSingle &rhs) {
         return intval == rhs.intval && boolval == rhs.boolval &&
                stringval == rhs.stringval &&
                strcmp(charstrval, rhs.charstrval) == 0 &&
                *txval == *rhs.txval &&
                proofval->getId() == rhs.proofval->getId();
     }
 };
 
 class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle {
 public:
     using CSerializeMethodsTestSingle::CSerializeMethodsTestSingle;
 
     SERIALIZE_METHODS(CSerializeMethodsTestMany, obj) {
         READWRITE(obj.intval, obj.boolval, obj.stringval, obj.charstrval,
                   obj.txval, obj.proofval);
     }
 };
 
 BOOST_AUTO_TEST_CASE(sizes) {
     BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(char(0)));
     BOOST_CHECK_EQUAL(sizeof(int8_t), GetSerializeSize(int8_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(uint8_t(0)));
     BOOST_CHECK_EQUAL(sizeof(int16_t), GetSerializeSize(int16_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint16_t), GetSerializeSize(uint16_t(0)));
     BOOST_CHECK_EQUAL(sizeof(int32_t), GetSerializeSize(int32_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint32_t), GetSerializeSize(uint32_t(0)));
     BOOST_CHECK_EQUAL(sizeof(int64_t), GetSerializeSize(int64_t(0)));
     BOOST_CHECK_EQUAL(sizeof(uint64_t), GetSerializeSize(uint64_t(0)));
     BOOST_CHECK_EQUAL(sizeof(float), GetSerializeSize(float(0)));
     BOOST_CHECK_EQUAL(sizeof(double), GetSerializeSize(double(0)));
     // Bool is serialized as char
     BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(bool(0)));
 
     // Sanity-check GetSerializeSize and c++ type matching
     BOOST_CHECK_EQUAL(GetSerializeSize(char(0)), 1U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int8_t(0)), 1U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint8_t(0)), 1U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int16_t(0)), 2U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint16_t(0)), 2U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int32_t(0)), 4U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint32_t(0)), 4U);
     BOOST_CHECK_EQUAL(GetSerializeSize(int64_t(0)), 8U);
     BOOST_CHECK_EQUAL(GetSerializeSize(uint64_t(0)), 8U);
     BOOST_CHECK_EQUAL(GetSerializeSize(float(0)), 4U);
     BOOST_CHECK_EQUAL(GetSerializeSize(double(0)), 8U);
     BOOST_CHECK_EQUAL(GetSerializeSize(bool(0)), 1U);
 }
 
 BOOST_AUTO_TEST_CASE(floats_conversion) {
     // Choose values that map unambiguously to binary floating point to avoid
     // rounding issues at the compiler side.
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x00000000), 0.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f000000), 0.5F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f800000), 1.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40000000), 2.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40800000), 4.0F);
     BOOST_CHECK_EQUAL(ser_uint32_to_float(0x44444444), 785.066650390625F);
 
     BOOST_CHECK_EQUAL(ser_float_to_uint32(0.0F), 0x00000000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(0.5F), 0x3f000000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(1.0F), 0x3f800000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(2.0F), 0x40000000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(4.0F), 0x40800000U);
     BOOST_CHECK_EQUAL(ser_float_to_uint32(785.066650390625F), 0x44444444U);
 }
 
 BOOST_AUTO_TEST_CASE(doubles_conversion) {
     // Choose values that map unambiguously to binary floating point to avoid
     // rounding issues at the compiler side.
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x0000000000000000ULL), 0.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3fe0000000000000ULL), 0.5);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3ff0000000000000ULL), 1.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4000000000000000ULL), 2.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4010000000000000ULL), 4.0);
     BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4088888880000000ULL),
                       785.066650390625);
 
     BOOST_CHECK_EQUAL(ser_double_to_uint64(0.0), 0x0000000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(0.5), 0x3fe0000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(1.0), 0x3ff0000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(2.0), 0x4000000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(4.0), 0x4010000000000000ULL);
     BOOST_CHECK_EQUAL(ser_double_to_uint64(785.066650390625),
                       0x4088888880000000ULL);
 }
 /*
 Python code to generate the below hashes:
 
     def reversed_hex(x):
         return b''.join(reversed(x)).hex().encode()
     def dsha256(x):
         return hashlib.sha256(hashlib.sha256(x).digest()).digest()
 
     reversed_hex(dsha256(b''.join(struct.pack('<f', x) for x in range(0,1000))))
 == '8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c'
     reversed_hex(dsha256(b''.join(struct.pack('<d', x) for x in range(0,1000))))
 == '43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96'
 */
 BOOST_AUTO_TEST_CASE(floats) {
     CDataStream ss(SER_DISK, 0);
     // encode
     for (int i = 0; i < 1000; i++) {
         ss << float(i);
     }
     BOOST_CHECK(Hash(ss) ==
                 uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85"
                          "099d7f3fe0c"));
 
     // decode
     for (int i = 0; i < 1000; i++) {
         float j;
         ss >> j;
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 }
 
 BOOST_AUTO_TEST_CASE(doubles) {
     CDataStream ss(SER_DISK, 0);
     // encode
     for (int i = 0; i < 1000; i++) {
         ss << double(i);
     }
     BOOST_CHECK(Hash(ss) ==
                 uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0"
                          "d7878b23f96"));
 
     // decode
     for (int i = 0; i < 1000; i++) {
         double j;
         ss >> j;
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 }
 
 BOOST_AUTO_TEST_CASE(varints) {
     // encode
 
     CDataStream ss(SER_DISK, 0);
     CDataStream::size_type size = 0;
     for (int i = 0; i < 100000; i++) {
         ss << VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED);
         size +=
             ::GetSerializeSize(VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED));
         BOOST_CHECK(size == ss.size());
     }
 
     for (uint64_t i = 0; i < 100000000000ULL; i += 999999937) {
         ss << VARINT(i);
         size += ::GetSerializeSize(VARINT(i));
         BOOST_CHECK(size == ss.size());
     }
 
     // decode
     for (int i = 0; i < 100000; i++) {
         int j = -1;
         ss >> VARINT_MODE(j, VarIntMode::NONNEGATIVE_SIGNED);
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 
     for (uint64_t i = 0; i < 100000000000ULL; i += 999999937) {
         uint64_t j = std::numeric_limits<uint64_t>::max();
         ss >> VARINT(j);
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 }
 
 BOOST_AUTO_TEST_CASE(varints_bitpatterns) {
     CDataStream ss(SER_DISK, 0);
     ss << VARINT_MODE(0, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "00");
     ss.clear();
     ss << VARINT_MODE(0x7f, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "7f");
     ss.clear();
     ss << VARINT_MODE((int8_t)0x7f, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "7f");
     ss.clear();
     ss << VARINT_MODE(0x80, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "8000");
     ss.clear();
     ss << VARINT((uint8_t)0x80);
     BOOST_CHECK_EQUAL(HexStr(ss), "8000");
     ss.clear();
     ss << VARINT_MODE(0x1234, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "a334");
     ss.clear();
     ss << VARINT_MODE((int16_t)0x1234, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "a334");
     ss.clear();
     ss << VARINT_MODE(0xffff, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f");
     ss.clear();
     ss << VARINT((uint16_t)0xffff);
     BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f");
     ss.clear();
     ss << VARINT_MODE(0x123456, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "c7e756");
     ss.clear();
     ss << VARINT_MODE((int32_t)0x123456, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "c7e756");
     ss.clear();
     ss << VARINT(0x80123456U);
     BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756");
     ss.clear();
     ss << VARINT((uint32_t)0x80123456U);
     BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756");
     ss.clear();
     ss << VARINT(0xffffffff);
     BOOST_CHECK_EQUAL(HexStr(ss), "8efefefe7f");
     ss.clear();
     ss << VARINT_MODE(0x7fffffffffffffffLL, VarIntMode::NONNEGATIVE_SIGNED);
     BOOST_CHECK_EQUAL(HexStr(ss), "fefefefefefefefe7f");
     ss.clear();
     ss << VARINT(0xffffffffffffffffULL);
     BOOST_CHECK_EQUAL(HexStr(ss), "80fefefefefefefefe7f");
     ss.clear();
 }
 
 static bool isTooLargeException(const std::ios_base::failure &ex) {
     std::ios_base::failure expectedException(
         "ReadCompactSize(): size too large");
 
     // The string returned by what() can be different for different platforms.
     // Instead of directly comparing the ex.what() with an expected string,
     // create an instance of exception to see if ex.what() matches  the expected
     // explanatory string returned by the exception instance.
     return strcmp(expectedException.what(), ex.what()) == 0;
 }
 
 BOOST_AUTO_TEST_CASE(compactsize) {
     CDataStream ss(SER_DISK, 0);
     std::vector<char>::size_type i, j;
 
     for (i = 1; i <= MAX_SIZE; i *= 2) {
         WriteCompactSize(ss, i - 1);
         WriteCompactSize(ss, i);
     }
     for (i = 1; i <= MAX_SIZE; i *= 2) {
         j = ReadCompactSize(ss);
         BOOST_CHECK_MESSAGE((i - 1) == j,
                             "decoded:" << j << " expected:" << (i - 1));
         j = ReadCompactSize(ss);
         BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
     }
 
     WriteCompactSize(ss, MAX_SIZE);
     BOOST_CHECK_EQUAL(ReadCompactSize(ss), MAX_SIZE);
 
     WriteCompactSize(ss, MAX_SIZE + 1);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isTooLargeException);
 
     WriteCompactSize(ss, std::numeric_limits<int64_t>::max());
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isTooLargeException);
 
     WriteCompactSize(ss, std::numeric_limits<uint64_t>::max());
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isTooLargeException);
 }
 
 static bool isCanonicalException(const std::ios_base::failure &ex) {
     std::ios_base::failure expectedException("non-canonical ReadCompactSize()");
 
     // The string returned by what() can be different for different platforms.
     // Instead of directly comparing the ex.what() with an expected string,
     // create an instance of exception to see if ex.what() matches  the expected
     // explanatory string returned by the exception instance.
     return strcmp(expectedException.what(), ex.what()) == 0;
 }
 
 BOOST_AUTO_TEST_CASE(vector_bool) {
     std::vector<uint8_t> vec1{1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1,
                               1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1};
     std::vector<bool> vec2{1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1,
                            1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1};
 
     BOOST_CHECK(vec1 == std::vector<uint8_t>(vec2.begin(), vec2.end()));
     BOOST_CHECK(SerializeHash(vec1) == SerializeHash(vec2));
 }
 
 BOOST_AUTO_TEST_CASE(noncanonical) {
     // Write some non-canonical CompactSize encodings, and make sure an
     // exception is thrown when read back.
     CDataStream ss(SER_DISK, 0);
     std::vector<char>::size_type n;
 
     // zero encoded with three bytes:
     ss.write("\xfd\x00\x00", 3);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0xfc encoded with three bytes:
     ss.write("\xfd\xfc\x00", 3);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0xfd encoded with three bytes is OK:
     ss.write("\xfd\xfd\x00", 3);
     n = ReadCompactSize(ss);
     BOOST_CHECK(n == 0xfd);
 
     // zero encoded with five bytes:
     ss.write("\xfe\x00\x00\x00\x00", 5);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0xffff encoded with five bytes:
     ss.write("\xfe\xff\xff\x00\x00", 5);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // zero encoded with nine bytes:
     ss.write("\xff\x00\x00\x00\x00\x00\x00\x00\x00", 9);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 
     // 0x01ffffff encoded with nine bytes:
     ss.write("\xff\xff\xff\xff\x01\x00\x00\x00\x00", 9);
     BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure,
                           isCanonicalException);
 }
 
 BOOST_AUTO_TEST_CASE(insert_delete) {
     // Test inserting/deleting bytes.
     CDataStream ss(SER_DISK, 0);
     BOOST_CHECK_EQUAL(ss.size(), 0U);
 
     ss.write("\x00\x01\x02\xff", 4);
     BOOST_CHECK_EQUAL(ss.size(), 4U);
 
     char c = (char)11;
 
     // Inserting at beginning/end/middle:
     ss.insert(ss.begin(), c);
     BOOST_CHECK_EQUAL(ss.size(), 5U);
     BOOST_CHECK_EQUAL(ss[0], c);
     BOOST_CHECK_EQUAL(ss[1], 0);
 
     ss.insert(ss.end(), c);
     BOOST_CHECK_EQUAL(ss.size(), 6U);
     BOOST_CHECK_EQUAL(ss[4], (char)0xff);
     BOOST_CHECK_EQUAL(ss[5], c);
 
     ss.insert(ss.begin() + 2, c);
     BOOST_CHECK_EQUAL(ss.size(), 7U);
     BOOST_CHECK_EQUAL(ss[2], c);
 
     // Delete at beginning/end/middle
     ss.erase(ss.begin());
     BOOST_CHECK_EQUAL(ss.size(), 6U);
     BOOST_CHECK_EQUAL(ss[0], 0);
 
     ss.erase(ss.begin() + ss.size() - 1);
     BOOST_CHECK_EQUAL(ss.size(), 5U);
     BOOST_CHECK_EQUAL(ss[4], (char)0xff);
 
     ss.erase(ss.begin() + 1);
     BOOST_CHECK_EQUAL(ss.size(), 4U);
     BOOST_CHECK_EQUAL(ss[0], 0);
     BOOST_CHECK_EQUAL(ss[1], 1);
     BOOST_CHECK_EQUAL(ss[2], 2);
     BOOST_CHECK_EQUAL(ss[3], (char)0xff);
 
     // Make sure GetAndClear does the right thing:
     CSerializeData d;
     ss.GetAndClear(d);
     BOOST_CHECK_EQUAL(ss.size(), 0U);
 }
 
 BOOST_AUTO_TEST_CASE(class_methods) {
     int intval(100);
     bool boolval(true);
     std::string stringval("testing");
     const char charstrval[16] = "testing charstr";
     CMutableTransaction txval;
     CTransactionRef tx_ref{MakeTransactionRef(txval)};
-    avalanche::ProofBuilder pb(0, 0, CKey::MakeCompressedKey());
+    avalanche::ProofBuilder pb(0, 0, CKey::MakeCompressedKey(),
+                               avalanche::UNSPENDABLE_ECREG_PAYOUT_SCRIPT);
     avalanche::ProofRef proofval = pb.build();
     CSerializeMethodsTestSingle methodtest1(intval, boolval, stringval,
                                             charstrval, tx_ref, proofval);
     CSerializeMethodsTestMany methodtest2(intval, boolval, stringval,
                                           charstrval, tx_ref, proofval);
     CSerializeMethodsTestSingle methodtest3;
     CSerializeMethodsTestMany methodtest4;
     CDataStream ss(SER_DISK, PROTOCOL_VERSION);
     BOOST_CHECK(methodtest1 == methodtest2);
     ss << methodtest1;
     ss >> methodtest4;
     ss << methodtest2;
     ss >> methodtest3;
     BOOST_CHECK(methodtest1 == methodtest2);
     BOOST_CHECK(methodtest2 == methodtest3);
     BOOST_CHECK(methodtest3 == methodtest4);
 
     CDataStream ss2(SER_DISK, PROTOCOL_VERSION, intval, boolval, stringval,
                     charstrval, txval, proofval);
     ss2 >> methodtest3;
     BOOST_CHECK(methodtest3 == methodtest4);
 }
 
 namespace {
 struct DifferentialIndexedItem {
     uint32_t index;
     std::string text;
 
     template <typename Stream> void SerData(Stream &s) { s << text; }
     template <typename Stream> void UnserData(Stream &s) { s >> text; }
 
     bool operator==(const DifferentialIndexedItem &other) const {
         return index == other.index && text == other.text;
     }
     bool operator!=(const DifferentialIndexedItem &other) const {
         return !(*this == other);
     }
 
     // Make boost happy
     friend std::ostream &operator<<(std::ostream &os,
                                     const DifferentialIndexedItem &item) {
         os << "index: " << item.index << ", text: " << item.text;
         return os;
     }
 
     DifferentialIndexedItem() {}
     DifferentialIndexedItem(uint32_t indexIn)
         : index(indexIn), text(ToString(index)) {}
 };
 
 template <typename Formatter, typename T>
 static void checkDifferentialEncodingRoundtrip() {
     Formatter formatter;
 
     const std::vector<T> indicesIn{0, 1, 2, 5, 10, 20, 50, 100};
     std::vector<T> indicesOut;
 
     CDataStream ss(SER_DISK, PROTOCOL_VERSION);
     formatter.Ser(ss, indicesIn);
     formatter.Unser(ss, indicesOut);
     BOOST_CHECK_EQUAL_COLLECTIONS(indicesIn.begin(), indicesIn.end(),
                                   indicesOut.begin(), indicesOut.end());
 }
 
 template <typename Formatter, typename T>
 static void checkDifferentialEncodingOverflow() {
     Formatter formatter;
 
     {
         const std::vector<T> indicesIn{1, 0};
 
         CDataStream ss(SER_DISK, PROTOCOL_VERSION);
         BOOST_CHECK_EXCEPTION(formatter.Ser(ss, indicesIn),
                               std::ios_base::failure,
                               HasReason("differential value overflow"));
     }
 }
 } // namespace
 
 BOOST_AUTO_TEST_CASE(difference_formatter) {
     {
         // Roundtrip with internals check
         VectorFormatter<DifferenceFormatter> formatter;
 
         std::vector<uint32_t> indicesIn{0, 1, 2, 5, 10, 20, 50, 100};
         std::vector<uint32_t> indicesOut;
 
         CDataStream ss(SER_DISK, PROTOCOL_VERSION);
         formatter.Ser(ss, indicesIn);
 
         // Check the stream is differentially encoded. Don't care about the
         // prefixes and vector length here (assumed to be < 253).
         const std::string streamStr = ss.str();
         const std::string differences =
             HexStr(streamStr.substr(streamStr.size() - indicesIn.size()));
         BOOST_CHECK_EQUAL(differences, "0000000204091d31");
 
         formatter.Unser(ss, indicesOut);
         BOOST_CHECK_EQUAL_COLLECTIONS(indicesIn.begin(), indicesIn.end(),
                                       indicesOut.begin(), indicesOut.end());
     }
 
     checkDifferentialEncodingRoundtrip<VectorFormatter<DifferenceFormatter>,
                                        uint32_t>();
     checkDifferentialEncodingRoundtrip<
         VectorFormatter<DifferentialIndexedItemFormatter>,
         DifferentialIndexedItem>();
 
     {
         // Checking 32 bits overflow requires to manually create the serialized
         // stream, so only do it with uint32_t
         std::vector<uint32_t> indicesOut;
 
         // Compute the number of MAX_SIZE increment we need to cause an overflow
         const uint64_t overflow =
             uint64_t(std::numeric_limits<uint32_t>::max()) + 1;
         // Due to differential encoding, a value of MAX_SIZE bumps the index by
         // MAX_SIZE + 1
         BOOST_CHECK_GE(overflow, MAX_SIZE + 1);
         const uint64_t overflowIter = overflow / (MAX_SIZE + 1);
 
         // Make sure the iteration fits in an uint32_t and is <= MAX_SIZE
         BOOST_CHECK_LE(overflowIter, std::numeric_limits<uint32_t>::max());
         BOOST_CHECK_LE(overflowIter, MAX_SIZE);
         uint32_t remainder =
             uint32_t(overflow - ((MAX_SIZE + 1) * overflowIter));
 
         auto buildStream = [&](uint32_t lastItemDifference) {
             CDataStream ss(SER_DISK, PROTOCOL_VERSION);
             WriteCompactSize(ss, overflowIter + 1);
             for (uint32_t i = 0; i < overflowIter; i++) {
                 WriteCompactSize(ss, MAX_SIZE);
             }
             // This will cause an overflow if lastItemDifference >= remainder
             WriteCompactSize(ss, lastItemDifference);
 
             return ss;
         };
 
         VectorFormatter<DifferenceFormatter> formatter;
 
         auto noThrowStream = buildStream(remainder - 1);
         BOOST_CHECK_NO_THROW(formatter.Unser(noThrowStream, indicesOut));
 
         auto overflowStream = buildStream(remainder);
         BOOST_CHECK_EXCEPTION(formatter.Unser(overflowStream, indicesOut),
                               std::ios_base::failure,
                               HasReason("differential value overflow"));
     }
 
     checkDifferentialEncodingOverflow<VectorFormatter<DifferenceFormatter>,
                                       uint32_t>();
     checkDifferentialEncodingOverflow<
         VectorFormatter<DifferentialIndexedItemFormatter>,
         DifferentialIndexedItem>();
 }
 
 BOOST_AUTO_TEST_SUITE_END()