diff --git a/src/avalanche/proofbuilder.cpp b/src/avalanche/proofbuilder.cpp
index 6e618e579..ceacc385f 100644
--- a/src/avalanche/proofbuilder.cpp
+++ b/src/avalanche/proofbuilder.cpp
@@ -1,67 +1,67 @@
 // 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/proofbuilder.h>
 
 #include <random.h>
 
 namespace avalanche {
 
 SignedStake ProofBuilder::StakeSigner::sign(const ProofId &proofid) {
     const uint256 h = stake.getHash(proofid);
 
     SchnorrSig sig;
     if (!key.SignSchnorr(h, sig)) {
         sig.fill(0);
     }
 
     return SignedStake(std::move(stake), std::move(sig));
 }
 
 bool ProofBuilder::addUTXO(COutPoint utxo, Amount amount, uint32_t height,
                            bool is_coinbase, CKey key) {
     if (!key.IsValid()) {
         return false;
     }
 
     return stakes
         .emplace(Stake(std::move(utxo), amount, height, is_coinbase,
                        key.GetPubKey()),
                  std::move(key))
         .second;
 }
 
 Proof ProofBuilder::build() {
     const ProofId proofid = getProofId();
 
     std::vector<SignedStake> signedStakes;
     signedStakes.reserve(stakes.size());
 
     while (!stakes.empty()) {
         auto handle = stakes.extract(stakes.begin());
         signedStakes.push_back(handle.value().sign(proofid));
     }
 
-    return Proof(sequence, expirationTime, std::move(master),
+    return Proof(sequence, expirationTime, masterKey.GetPubKey(),
                  std::move(signedStakes));
 }
 
 ProofId ProofBuilder::getProofId() const {
     CHashWriter ss(SER_GETHASH, 0);
     ss << sequence;
     ss << expirationTime;
 
     WriteCompactSize(ss, stakes.size());
     for (const auto &s : stakes) {
         ss << s.stake;
     }
 
     CHashWriter ss2(SER_GETHASH, 0);
     ss2 << ss.GetHash();
-    ss2 << master;
+    ss2 << masterKey.GetPubKey();
 
     return ProofId(ss2.GetHash());
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/proofbuilder.h b/src/avalanche/proofbuilder.h
index 720c683ef..2de323346 100644
--- a/src/avalanche/proofbuilder.h
+++ b/src/avalanche/proofbuilder.h
@@ -1,57 +1,57 @@
 // 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;
-    CPubKey master;
+    CKey masterKey;
 
     struct StakeSigner {
         Stake stake;
         CKey key;
 
         StakeSigner(Stake stake_, CKey key_)
             : stake(std::move(stake_)), key(std::move(key_)) {}
 
         SignedStake sign(const ProofId &proofid);
     };
 
     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_, CPubKey master_)
+    ProofBuilder(uint64_t sequence_, int64_t expirationTime_, CKey masterKey_)
         : sequence(sequence_), expirationTime(expirationTime_),
-          master(std::move(master_)) {}
+          masterKey(std::move(masterKey_)) {}
 
     [[nodiscard]] bool addUTXO(COutPoint utxo, Amount amount, uint32_t height,
                                bool is_coinbase, CKey key);
 
     Proof build();
 
 private:
     ProofId getProofId() const;
 
     friend struct TestProofBuilder;
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PROOFBUILDER_H
diff --git a/src/avalanche/test/delegation_tests.cpp b/src/avalanche/test/delegation_tests.cpp
index 54c497564..be613f542 100644
--- a/src/avalanche/test/delegation_tests.cpp
+++ b/src/avalanche/test/delegation_tests.cpp
@@ -1,198 +1,198 @@
 // 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/delegation.h>
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/test/util.h>
 #include <avalanche/validation.h>
 #include <streams.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <streams.h>
 #include <util/strencodings.h>
 
 using namespace avalanche;
 
 BOOST_FIXTURE_TEST_SUITE(delegation_tests, TestingSetup)
 
 static void CheckDelegation(const Delegation &dg, const Proof &p,
                             const CPubKey &expected_pubkey) {
     DelegationState state;
     CPubKey pubkey;
     BOOST_CHECK(dg.verify(state, pubkey));
     BOOST_CHECK(state.GetResult() == DelegationResult::NONE);
     BOOST_CHECK(pubkey == expected_pubkey);
 
     BOOST_CHECK(dg.getProofId() == p.getId());
 }
 
 BOOST_AUTO_TEST_CASE(verify_random) {
     auto key = CKey::MakeCompressedKey();
 
-    const Proof p = buildRandomProof(123456, key.GetPubKey());
+    const Proof p = buildRandomProof(123456, key);
     DelegationBuilder dgb(p);
 
     {
         Delegation dg = dgb.build();
         BOOST_CHECK_EQUAL(dg.getId(), p.getId());
         CheckDelegation(dg, p, p.getMaster());
     }
 
     auto l1key = CKey::MakeCompressedKey();
     BOOST_CHECK(!dgb.addLevel(l1key, key.GetPubKey()));
 
     dgb.addLevel(key, l1key.GetPubKey());
     CheckDelegation(dgb.build(), p, l1key.GetPubKey());
 
     auto l2key = CKey::MakeCompressedKey();
     BOOST_CHECK(!dgb.addLevel(key, l2key.GetPubKey()));
     BOOST_CHECK(!dgb.addLevel(l2key, l2key.GetPubKey()));
 
     dgb.addLevel(l1key, l2key.GetPubKey());
     CheckDelegation(dgb.build(), p, l2key.GetPubKey());
 }
 
 // Proof master priv:
 //     L4J6gEE4wL9ji2EQbzS5dPMTTsw8LRvcMst1Utij4e3X5ccUSdqW
 // Proof master pub:
 //     023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3
 // Stake priv:
 //     KydYrKDNsVnY5uhpLyC4UmazuJvUjNoKJhEEv9f1mdK1D5zcnMSM
 // Stake pub:
 //     02449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce680
 // Level 1 priv:
 //     KzzLLtiYiyFcTXPWUzywt2yEKk5FxkGbMfKhWgBd4oZdt8t8kk77
 // Level 1 pub:
 //     03e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645ef
 // Level 2 priv:
 //     KwM6hV6hxZt3Kt4NHMtWQGH5T2SwhpyswodUQC2zmSjg6KWFWkQU
 // Level 2 pub:
 //     03aac52f4cfca700e7e9824298e0184755112e32f359c832f5f6ad2ef62a2c024a
 
 static Proof getProof() {
     Proof p;
     CDataStream stream(
         ParseHex(
             "0000000000000000ffffffff0000000021023beefdde700a6bc02036335b4df141"
             "c8bc67bb05a971f5ac2745fd683797dde301bee72758084395310b5a7ccc98a836"
             "11dff786f0a469d1d66626ba286b0423870000000000108dbe1c000000a4090000"
             "2102449fb5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6"
             "8069c539018ac799848811fb44a4b987faa71a634970d35976c5e766fb98502432"
             "aaec53034bd7df23767e7e695203599cf4a6a71569bdf03e90f0f91c8760faae"),
         SER_NETWORK, 0);
     stream >> p;
     BOOST_CHECK_EQUAL(p.getId(),
                       ProofId::fromHex("afc74900c1f28b69e466461fb1e0663352da615"
                                        "3be0fcd59280e27f2446391d5"));
     BOOST_CHECK_EQUAL(
         p.getLimitedId(),
         LimitedProofId::fromHex("0d45ca55662c483107b45f5c5699e0d8c7778b2"
                                 "45c116cb988abba1afa6a1146"));
     return p;
 }
 
 struct TestVector {
     std::string name;
     std::string hex;
     std::string dgid;
     std::string pubkey;
     DelegationResult result;
 };
 
 BOOST_AUTO_TEST_CASE(deserialization) {
     Proof p = getProof();
 
     std::vector<TestVector> testcases{
         {"Empty delegation",
          "46116afa1abaab88b96c115c248b77c7d8e099565c5fb40731482c6655ca450d21"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3"
          "00",
          "afc74900c1f28b69e466461fb1e0663352da6153be0fcd59280e27f2446391d5",
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3",
          DelegationResult::NONE},
         {"One delegation",
          "46116afa1abaab88b96c115c248b77c7d8e099565c5fb40731482c6655ca450d21"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3"
          "012103e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645e"
          "f7d51"
          "2ddbea7c88dcf38412b58374856a466e165797a69321c0928a89c64521f7e2e767c93"
          "de645ef5125ec901dcd51347787ca29771e7786bbe402d2d5ead0dc",
          "ffcd49dc98ebdbc90e731a7b0c89939bfe082f15f3aa82aca657176b83669185",
          "03e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645ef",
          DelegationResult::NONE},
         {"Two delegation",
          "46116afa1abaab88b96c115c248b77c7d8e099565c5fb40731482c6655ca450d21"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3"
          "022103e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645e"
          "f7d512ddbea7c88dcf38412b58374856a466e165797a69321c0928a89c64521f7e2e7"
          "67c93de645ef5125ec901dcd51347787ca29771e7786bbe402d2d5ead0dc2103aac52"
          "f4cfca700e7e9824298e0184755112e32f359c832f5f6ad2ef62a2c024a5cddd0ffe8"
          "4e12e4bf49e4c0af7c8548e618a24e12495d659f5ba75e114e1526a618aa305b1e69b"
          "f6ae20b2557999f2e3fec25d5f2271f8b9de0d06ba7344550",
          "a3f98e6b5ec330219493d109e5c11ed8e302315df4604b5462e9fb80cb0fde89",
          "03aac52f4cfca700e7e9824298e0184755112e32f359c832f5f6ad2ef62a2c024a",
          DelegationResult::NONE},
         {"Invalid pubkey",
          "46116afa1abaab88b96c115c248b77c7d8e099565c5fb40731482c6655ca450d21"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3012"
          "103e49f9df53de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645ef7d"
          "512ddbea7c88dcf38412b58374856a466e165797a69321c0928a89c64521f7e2e767c"
          "93de645ef5125ec901dcd51347787ca29771e7786bbe402d2d5ead0dc",
          "af7e82716489c3cf3f361d449ed815112ff619f7fc34a4803bd958c68d1e2684",
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3",
          DelegationResult::INVALID_SIGNATURE},
         {"Invalid signature",
          "46116afa1abaab88b96c115c248b77c7d8e099565c5fb40731482c6655ca450d21"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3"
          "012103e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645e"
          "f7d512ddbea7c88dcf38412c58374856a466e165797a69321c0928a89c64521f7e2e7"
          "67c93de645ef5125ec901dcd51347787ca29771e7786bbe402d2d5ead0dc",
          "ffcd49dc98ebdbc90e731a7b0c89939bfe082f15f3aa82aca657176b83669185",
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3",
          DelegationResult::INVALID_SIGNATURE},
         {"Second invalid key",
          "46116afa1abaab88b96c115c248b77c7d8e099565c5fb40731482c6655ca450d21"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3"
          "022103e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645e"
          "f7d512ddbea7c88dcf38412b58374856a466e165797a69321c0928a89c64521f7e2e7"
          "67c93de645ef5125ec901dcd51347787ca29771e7786bbe402d2d5ead0dc2103aac52"
          "f4dfca700e7e9824298e0184755112e32f359c832f5f6ad2ef62a2c024a5cddd0ffe8"
          "4e12e4bf49e4c0af7c8548e618a24e12495d659f5ba75e114e1526a618aa305b1e69b"
          "f6ae20b2557999f2e3fec25d5f2271f8b9de0d06ba7344550",
          "b474512f71a3f5a6e94cc3b958fd658ece0d0632ace58c8c8f9f65c2b9ad5fad",
          "03e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645ef",
          DelegationResult::INVALID_SIGNATURE},
         {"Second invalid signature",
          "46116afa1abaab88b96c115c248b77c7d8e099565c5fb40731482c6655ca450d21"
          "023beefdde700a6bc02036335b4df141c8bc67bb05a971f5ac2745fd683797dde3"
          "022103e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645e"
          "f7d512ddbea7c88dcf38412b58374856a466e165797a69321c0928a89c64521f7e2e7"
          "67c93de645ef5125ec901dcd51347787ca29771e7786bbe402d2d5ead0dc2103aac52"
          "f4cfca700e7e9824298e0184755112e32f359c832f5f6ad2ef62a2c024a5cddd0ffe8"
          "4e12e4bf49e4c0af7c8548e618a24e12495d659f5ba75e114e1526a618aa305b1e69b"
          "f6ae20b2557999f2e3fec25d5f2271f8b9de0d06ba7344551",
          "a3f98e6b5ec330219493d109e5c11ed8e302315df4604b5462e9fb80cb0fde89",
          "03e49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0f9e645ef",
          DelegationResult::INVALID_SIGNATURE},
     };
 
     for (auto &c : testcases) {
         CDataStream stream(ParseHex(c.hex), SER_NETWORK, 0);
         Delegation dg;
         stream >> dg;
         BOOST_CHECK_EQUAL(dg.getId(), DelegationId::fromHex(c.dgid));
 
         DelegationState state;
         CPubKey pubkey;
         BOOST_CHECK_EQUAL(dg.verify(state, pubkey),
                           c.result == DelegationResult::NONE);
         BOOST_CHECK(state.GetResult() == c.result);
         BOOST_CHECK(pubkey == CPubKey(ParseHex(c.pubkey)));
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/orphanproofpool_tests.cpp b/src/avalanche/test/orphanproofpool_tests.cpp
index 47f639342..04db1577d 100644
--- a/src/avalanche/test/orphanproofpool_tests.cpp
+++ b/src/avalanche/test/orphanproofpool_tests.cpp
@@ -1,163 +1,163 @@
 // 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/orphanproofpool.h>
 #include <avalanche/proofbuilder.h>
 
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <array>
 #include <queue>
 
 using namespace avalanche;
 
 BOOST_FIXTURE_TEST_SUITE(orphanproofpool_tests, TestingSetup)
 
 /** Make a proof with stakes using random txids */
 static std::shared_ptr<Proof> makeProof(const size_t nStakes) {
     const Amount v = 5 * COIN;
     const int height = 1234;
-    ProofBuilder pb(0, 0, CPubKey());
+    ProofBuilder pb(0, 0, CKey::MakeCompressedKey());
     for (size_t i = 0; i < nStakes; i++) {
         TxId txid(GetRandHash());
         BOOST_CHECK(pb.addUTXO(COutPoint(txid, 0), v, height, false,
                                CKey::MakeCompressedKey()));
     }
     return std::make_shared<Proof>(pb.build());
 }
 
 BOOST_AUTO_TEST_CASE(pool_starts_empty) {
     OrphanProofPool pool{10};
     BOOST_CHECK_EQUAL(pool.getNProofs(), 0);
     BOOST_CHECK_EQUAL(pool.getNStakes(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(fail_to_add_same_proof_twice) {
     OrphanProofPool pool{10};
     auto p = makeProof(1);
     BOOST_CHECK(!pool.getProof(p->getId()));
 
     BOOST_CHECK(pool.addProof(p));
     BOOST_CHECK_EQUAL(pool.getNStakes(), 1);
     BOOST_CHECK_EQUAL(pool.getNProofs(), 1);
     BOOST_CHECK(pool.getProof(p->getId()));
 
     BOOST_CHECK(!pool.addProof(p));
     BOOST_CHECK_EQUAL(pool.getNStakes(), 1);
     BOOST_CHECK_EQUAL(pool.getNProofs(), 1);
     BOOST_CHECK(pool.getProof(p->getId()));
 }
 
 BOOST_AUTO_TEST_CASE(check_eviction_behavior) {
     {
         // Fill the pool
         OrphanProofPool pool{7};
         auto first = makeProof(4);
         pool.addProof(first);
         pool.addProof(makeProof(2));
         pool.addProof(makeProof(1));
         BOOST_CHECK_EQUAL(pool.getNStakes(), 7);
         BOOST_CHECK_EQUAL(pool.getNProofs(), 3);
         BOOST_CHECK(pool.getProof(first->getId()));
     }
 
     {
         OrphanProofPool pool{6};
         auto first = makeProof(4);
         pool.addProof(first);
         pool.addProof(makeProof(2));
         BOOST_CHECK_EQUAL(pool.getNStakes(), 6);
         BOOST_CHECK_EQUAL(pool.getNProofs(), 2);
 
         // The oldest proof has to be dropped
         pool.addProof(makeProof(1));
         BOOST_CHECK_EQUAL(pool.getNStakes(), 3);
         BOOST_CHECK_EQUAL(pool.getNProofs(), 2);
         BOOST_CHECK(!pool.getProof(first->getId()));
     }
 
     {
         OrphanProofPool pool{15};
         auto first = makeProof(1);
         pool.addProof(first);
         auto second = makeProof(2);
         pool.addProof(second);
         pool.addProof(makeProof(4));
         pool.addProof(makeProof(8));
         BOOST_CHECK_EQUAL(pool.getNStakes(), 15);
         BOOST_CHECK_EQUAL(pool.getNProofs(), 4);
 
         // Multiple proofs are dropped if needed
         pool.addProof(makeProof(2));
         BOOST_CHECK_EQUAL(pool.getNStakes(), 14);
         BOOST_CHECK_EQUAL(pool.getNProofs(), 3);
         BOOST_CHECK(!pool.getProof(first->getId()));
         BOOST_CHECK(!pool.getProof(second->getId()));
     }
 }
 
 BOOST_AUTO_TEST_CASE(remove_proofs) {
     OrphanProofPool pool{1337};
     std::array<ProofId, 10> aProofIds;
 
     // Add 10 proofs
     for (size_t i = 0; i < 10; i++) {
         auto p = makeProof(i + 1);
         aProofIds[i] = p->getId();
         BOOST_CHECK(pool.addProof(p));
     }
     BOOST_CHECK_EQUAL(pool.getNProofs(), 10);
     BOOST_CHECK_EQUAL(pool.getNStakes(), 55);
 
     // Remove a proof in the middle
     BOOST_CHECK(pool.removeProof(aProofIds[5]));
     BOOST_CHECK_EQUAL(pool.getNProofs(), 9);
     BOOST_CHECK_EQUAL(pool.getNStakes(), 49);
 
     // Remove a proof at the front
     BOOST_CHECK(pool.removeProof(aProofIds[0]));
     BOOST_CHECK_EQUAL(pool.getNProofs(), 8);
     BOOST_CHECK_EQUAL(pool.getNStakes(), 48);
 
     // Remove a proof at the back
     BOOST_CHECK(pool.removeProof(aProofIds[9]));
     BOOST_CHECK_EQUAL(pool.getNProofs(), 7);
     BOOST_CHECK_EQUAL(pool.getNStakes(), 38);
 
     // Fail to remove a proof that is longer in the pool
     BOOST_CHECK(!pool.removeProof(aProofIds[5]));
     BOOST_CHECK_EQUAL(pool.getNProofs(), 7);
     BOOST_CHECK_EQUAL(pool.getNStakes(), 38);
 
     // Fail to remove a proof that was never in the pool
     auto p = makeProof(11);
     BOOST_CHECK(!pool.getProof(p->getId()));
     BOOST_CHECK(!pool.removeProof(p->getId()));
     BOOST_CHECK_EQUAL(pool.getNProofs(), 7);
     BOOST_CHECK_EQUAL(pool.getNStakes(), 38);
 }
 
 BOOST_AUTO_TEST_CASE(add_proof_larger_than_pool) {
     OrphanProofPool pool{AVALANCHE_MAX_PROOF_STAKES - 1};
 
     // Add a couple of small proofs
     BOOST_CHECK(pool.addProof(makeProof(1)));
     BOOST_CHECK_EQUAL(pool.getNStakes(), 1);
     BOOST_CHECK_EQUAL(pool.getNProofs(), 1);
 
     BOOST_CHECK(pool.addProof(makeProof(2)));
     BOOST_CHECK_EQUAL(pool.getNStakes(), 3);
     BOOST_CHECK_EQUAL(pool.getNProofs(), 2);
 
     // Adding a proof larger than the pool causes the pool to be emptied
     BOOST_CHECK(pool.addProof(makeProof(AVALANCHE_MAX_PROOF_STAKES)));
     BOOST_CHECK_EQUAL(pool.getNStakes(), 0);
     BOOST_CHECK_EQUAL(pool.getNProofs(), 0);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
index 8b041ddd6..2f6d679f7 100644
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -1,797 +1,798 @@
 // 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/test/util.h>
 #include <script/standard.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();
         }
     };
 } // namespace
 } // namespace avalanche
 
 BOOST_FIXTURE_TEST_SUITE(peermanager_tests, TestingSetup)
 
 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 std::shared_ptr<Proof> getRandomProofPtr(uint32_t score) {
     return std::make_shared<Proof>(buildRandomProof(score));
 }
 
 static void addNodeWithScore(avalanche::PeerManager &pm, NodeId node,
                              uint32_t score) {
     auto proof = getRandomProofPtr(score);
     BOOST_CHECK_NE(pm.getPeerId(proof), NO_PEER);
     BOOST_CHECK(pm.addNode(node, proof->getId()));
 };
 
 BOOST_AUTO_TEST_CASE(peer_probabilities) {
     // No peers.
     avalanche::PeerManager pm;
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     const NodeId node0 = 42, node1 = 69, node2 = 37;
 
     // One peer, we always return it.
     addNodeWithScore(pm, node0, MIN_VALID_PROOF_SCORE);
     BOOST_CHECK_EQUAL(pm.selectNode(), node0);
 
     // Two peers, verify ratio.
     addNodeWithScore(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(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) {
     // No peers.
     avalanche::PeerManager pm;
     BOOST_CHECK_EQUAL(pm.selectPeer(), NO_PEER);
 
     // Add 4 peers.
     std::array<PeerId, 8> peerids;
     for (int i = 0; i < 4; i++) {
         auto p = getRandomProofPtr(100);
         peerids[i] = pm.getPeerId(p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 400);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     for (int i = 0; i < 100; i++) {
         PeerId p = pm.selectPeer();
         BOOST_CHECK(p == peerids[0] || p == peerids[1] || p == peerids[2] ||
                     p == peerids[3]);
     }
 
     // Remove one peer, it nevers show up now.
     BOOST_CHECK(pm.removePeer(peerids[2]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 400);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 100);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 300);
     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 = getRandomProofPtr(100);
         peerids[i + 4] = pm.getPeerId(p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 700);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 
     BOOST_CHECK(pm.removePeer(peerids[0]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 700);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
 
     // Removing the last entry do not increase fragmentation.
     BOOST_CHECK(pm.removePeer(peerids[7]));
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 600);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 100);
 
     // Make sure we compact to never get NO_PEER.
     BOOST_CHECK_EQUAL(pm.compact(), 100);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 500);
     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) {
     avalanche::PeerManager pm;
 
     // Add 4 peers.
     std::array<PeerId, 4> peerids;
     for (int i = 0; i < 4; i++) {
         auto p = getRandomProofPtr(100);
         peerids[i] = pm.getPeerId(p);
         BOOST_CHECK(pm.addNode(InsecureRand32(), p->getId()));
     }
 
     // Remove all peers.
     for (auto p : peerids) {
         pm.removePeer(p);
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 300);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 300);
 
     for (int i = 0; i < 100; i++) {
         BOOST_CHECK_EQUAL(pm.selectPeer(), NO_PEER);
     }
 
     BOOST_CHECK_EQUAL(pm.compact(), 300);
     BOOST_CHECK(pm.verify());
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 0);
     BOOST_CHECK_EQUAL(pm.getFragmentation(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(node_crud) {
     avalanche::PeerManager pm;
 
     // Create one peer.
     auto proof = getRandomProofPtr(10000000 * MIN_VALID_PROOF_SCORE);
     BOOST_CHECK_NE(pm.getPeerId(proof), NO_PEER);
     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(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) {
     avalanche::PeerManager pm;
 
     auto proof = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     const ProofId &proofid = proof->getId();
 
     // 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));
     }
 
     // Now create the peer and check all the nodes are bound
     const PeerId peerid = pm.getPeerId(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());
 
     // 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));
     }
 
     // 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));
     }
 
     auto alt_proof = getRandomProofPtr(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));
     }
 
     auto alt2_proof = getRandomProofPtr(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));
     }
 
     // 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));
     }
 
     // Remove the peer, the nodes should be pending again
     BOOST_CHECK(pm.removePeer(peerid));
     BOOST_CHECK(!pm.getProof(proof->getId()));
     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(node_binding_reorg) {
     avalanche::PeerManager pm;
 
-    ProofBuilder pb(0, 0, CPubKey());
+    ProofBuilder pb(0, 0, CKey::MakeCompressedKey());
     auto key = CKey::MakeCompressedKey();
     const CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
     COutPoint utxo(TxId(GetRandHash()), 0);
     Amount amount = 1 * COIN;
     const int height = 1234;
     BOOST_CHECK(pb.addUTXO(utxo, amount, height, false, key));
     auto proof = std::make_shared<Proof>(pb.build());
     const ProofId &proofid = proof->getId();
 
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(utxo, Coin(CTxOut(amount, script), height, false), false);
     }
 
     PeerId peerid = pm.getPeerId(proof);
     BOOST_CHECK_NE(peerid, NO_PEER);
     BOOST_CHECK(pm.verify());
 
     // Add nodes to our peer
     for (int i = 0; i < 10; i++) {
         BOOST_CHECK(pm.addNode(i, proofid));
         BOOST_CHECK(!TestPeerManager::isNodePending(pm, i));
         BOOST_CHECK(TestPeerManager::nodeBelongToPeer(pm, i, peerid));
     }
 
     // Orphan the proof
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.SpendCoin(utxo);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(pm.isOrphan(proofid));
     BOOST_CHECK(!pm.getProof(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
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(utxo, Coin(CTxOut(amount, script), height, false), false);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isOrphan(proofid));
     BOOST_CHECK(pm.getProof(proofid));
     // The peerid has certainly been updated
     peerid = pm.getPeerId(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();
     const CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
     TxId txid1(GetRandHash());
     TxId txid2(GetRandHash());
     BOOST_CHECK(txid1 != txid2);
 
     const Amount v = 5 * COIN;
     const int height = 1234;
 
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
 
         for (int i = 0; i < 10; i++) {
             coins.AddCoin(COutPoint(txid1, i),
                           Coin(CTxOut(v, script), height, false), false);
             coins.AddCoin(COutPoint(txid2, i),
                           Coin(CTxOut(v, script), height, false), false);
         }
     }
 
     avalanche::PeerManager pm;
+    CKey masterKey = CKey::MakeCompressedKey();
     const auto getPeerId = [&](const std::vector<COutPoint> &outpoints) {
-        ProofBuilder pb(0, 0, CPubKey());
+        ProofBuilder pb(0, 0, masterKey);
         for (const auto &o : outpoints) {
             BOOST_CHECK(pb.addUTXO(o, v, height, false, key));
         }
 
         return pm.getPeerId(std::make_shared<Proof>(pb.build()));
     };
 
     // 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, CPubKey());
+        ProofBuilder pb(0, 0, CKey::MakeCompressedKey());
         COutPoint o(txid1, 3);
         BOOST_CHECK(pb.addUTXO(o, v, height, false, key));
         PeerId peerid = pm.getPeerId(std::make_shared<Proof>(
             TestProofBuilder::buildDuplicatedStakes(pb)));
         BOOST_CHECK_EQUAL(peerid, NO_PEER);
     }
 
     // Multiple inputs, collision on first input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 4)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on second input.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 4), COutPoint(txid2, 0)}),
                       NO_PEER);
 
     // Mutliple inputs, collision on both inputs.
     BOOST_CHECK_EQUAL(getPeerId({COutPoint(txid1, 0), COutPoint(txid2, 2)}),
                       NO_PEER);
 }
 
 BOOST_AUTO_TEST_CASE(orphan_proofs) {
     avalanche::PeerManager pm;
 
     auto key = CKey::MakeCompressedKey();
     const CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
     COutPoint outpoint1 = COutPoint(TxId(GetRandHash()), 0);
     COutPoint outpoint2 = COutPoint(TxId(GetRandHash()), 0);
     COutPoint outpoint3 = COutPoint(TxId(GetRandHash()), 0);
 
     const Amount v = 5 * COIN;
     const int height = 1234;
     const int wrongHeight = 12345;
 
     const auto makeProof = [&](const COutPoint &outpoint, const int h) {
-        ProofBuilder pb(0, 0, CPubKey());
+        ProofBuilder pb(0, 0, CKey::MakeCompressedKey());
         BOOST_CHECK(pb.addUTXO(outpoint, v, h, false, key));
         return std::make_shared<Proof>(pb.build());
     };
 
     auto proof1 = makeProof(outpoint1, height);
     auto proof2 = makeProof(outpoint2, height);
     auto proof3 = makeProof(outpoint3, wrongHeight);
 
     const Coin coin = Coin(CTxOut(v, script), height, false);
 
     // Add outpoints 1 and 3, not 2
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(outpoint1, coin, false);
         coins.AddCoin(outpoint3, coin, false);
     }
 
     // Add the proofs
     BOOST_CHECK(pm.getPeerId(proof1) != NO_PEER);
     BOOST_CHECK(pm.getPeerId(proof2) == NO_PEER);
     BOOST_CHECK(pm.getPeerId(proof3) == NO_PEER);
 
     // Good
     BOOST_CHECK(!pm.isOrphan(proof1->getId()));
     // MISSING_UTXO
     BOOST_CHECK(pm.isOrphan(proof2->getId()));
     // HEIGHT_MISMATCH
     BOOST_CHECK(pm.isOrphan(proof3->getId()));
 
     const auto isGoodPeer = [&pm](const std::shared_ptr<Proof> &p) {
         bool ret = false;
         pm.forEachPeer([&](const Peer &peer) {
             if (p->getId() == peer.proof->getId()) {
                 ret = true;
             }
         });
         return ret;
     };
 
     BOOST_CHECK(isGoodPeer(proof1));
     BOOST_CHECK(!isGoodPeer(proof2));
     BOOST_CHECK(!isGoodPeer(proof3));
 
     // Add outpoint2, proof2 is no longer considered orphan
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(outpoint2, coin, false);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isOrphan(proof2->getId()));
     BOOST_CHECK(isGoodPeer(proof2));
 
     // The status of proof1 and proof3 are unchanged
     BOOST_CHECK(!pm.isOrphan(proof1->getId()));
     BOOST_CHECK(isGoodPeer(proof1));
     BOOST_CHECK(pm.isOrphan(proof3->getId()));
     BOOST_CHECK(!isGoodPeer(proof3));
 
     // Spend outpoint1, proof1 becomes orphan
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.SpendCoin(outpoint1);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(pm.isOrphan(proof1->getId()));
     BOOST_CHECK(!isGoodPeer(proof1));
 
     // The status of proof2 and proof3 are unchanged
     BOOST_CHECK(!pm.isOrphan(proof2->getId()));
     BOOST_CHECK(isGoodPeer(proof2));
     BOOST_CHECK(pm.isOrphan(proof3->getId()));
     BOOST_CHECK(!isGoodPeer(proof3));
 
     // A reorg could make a previous HEIGHT_MISMATCH become valid
     {
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.SpendCoin(outpoint3);
         coins.AddCoin(outpoint3, Coin(CTxOut(v, script), wrongHeight, false),
                       false);
     }
 
     pm.updatedBlockTip();
     BOOST_CHECK(!pm.isOrphan(proof3->getId()));
     BOOST_CHECK(isGoodPeer(proof3));
 
     // The status of proof 1 and proof2 are unchanged
     BOOST_CHECK(pm.isOrphan(proof1->getId()));
     BOOST_CHECK(!isGoodPeer(proof1));
     BOOST_CHECK(!pm.isOrphan(proof2->getId()));
     BOOST_CHECK(isGoodPeer(proof2));
 }
 
 BOOST_AUTO_TEST_CASE(dangling_node) {
     avalanche::PeerManager pm;
 
     auto proof = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     PeerId peerid = pm.getPeerId(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 = getRandomProofPtr(MIN_VALID_PROOF_SCORE);
     peerid = pm.getPeerId(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) {
     avalanche::PeerManager pm;
 
     constexpr int numProofs = 10;
 
     std::vector<std::shared_ptr<Proof>> proofs;
     proofs.reserve(numProofs);
     for (int i = 0; i < numProofs; i++) {
         proofs.push_back(getRandomProofPtr(MIN_VALID_PROOF_SCORE));
     }
 
     for (int i = 0; i < numProofs; i++) {
         BOOST_CHECK(pm.registerProof(proofs[i]));
         // Fail to add an existing proof
         BOOST_CHECK(!pm.registerProof(proofs[i]));
 
         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;
     Proof badProof;
     BOOST_CHECK(Proof::FromHex(badProof, badProofHex, error));
     BOOST_CHECK(
         !pm.registerProof(std::make_shared<Proof>(std::move(badProof))));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/processor_tests.cpp b/src/avalanche/test/processor_tests.cpp
index 240522d2c..49241f461 100644
--- a/src/avalanche/test/processor_tests.cpp
+++ b/src/avalanche/test/processor_tests.cpp
@@ -1,987 +1,987 @@
 // 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 <net_processing.h> // For ::PeerManager
 #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 <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 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 p.getSuitableNodeToQuery();
         }
 
         static uint64_t getRound(const Processor &p) { return p.round; }
     };
 } // 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 = std::make_unique<::PeerManager>(
             config.GetChainParams(), *m_connman, m_node.banman.get(),
             *m_node.scheduler, *m_node.chainman, *m_node.mempool);
         m_node.chain = interfaces::MakeChain(m_node, config.GetChainParams());
 
         // Get the processor ready.
         bilingual_str error;
         m_processor = Processor::MakeProcessor(*m_node.args, *m_node.chain,
                                                m_node.connman.get(), error);
         BOOST_CHECK(m_processor);
     }
 
     ~AvalancheTestingSetup() {
         m_connman->ClearNodes();
         SyncWithValidationInterfaceQueue();
     }
 
     CNode *ConnectNode(ServiceFlags nServices) {
         static NodeId id = 0;
 
         CAddress addr(ip(GetRandInt(0xffffffff)), NODE_NONE);
         auto node = new CNode(id++, ServiceFlags(NODE_NETWORK), 0,
                               INVALID_SOCKET, addr, 0, 0, 0, CAddress(), "",
                               ConnectionType::OUTBOUND_FULL_RELAY);
         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;
     }
 
     size_t next_coinbase = 0;
     std::shared_ptr<Proof> GetProof() {
         size_t current_coinbase = next_coinbase++;
         const CTransaction &coinbase = *m_coinbase_txns[current_coinbase];
-        ProofBuilder pb(0, 0, masterpriv.GetPubKey());
+        ProofBuilder pb(0, 0, masterpriv);
         BOOST_CHECK(pb.addUTXO(COutPoint(coinbase.GetId(), 0),
                                coinbase.vout[0].nValue, current_coinbase + 1,
                                true, coinbaseKey));
         return std::make_shared<Proof>(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> &updates) {
         int banscore;
         std::string error;
         return m_processor->registerVotes(nodeid, response, updates, banscore,
                                           error);
     }
 };
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(processor_tests, AvalancheTestingSetup)
 
 #define REGISTER_VOTE_AND_CHECK(vr, vote, state, finalized, confidence)        \
     vr.registerVote(NO_NODE, vote);                                            \
     BOOST_CHECK_EQUAL(vr.isAccepted(), state);                                 \
     BOOST_CHECK_EQUAL(vr.hasFinalized(), finalized);                           \
     BOOST_CHECK_EQUAL(vr.getConfidence(), confidence);
 
 BOOST_AUTO_TEST_CASE(vote_record) {
     VoteRecord vraccepted(true);
 
     // Check initial state.
     BOOST_CHECK_EQUAL(vraccepted.isAccepted(), true);
     BOOST_CHECK_EQUAL(vraccepted.hasFinalized(), false);
     BOOST_CHECK_EQUAL(vraccepted.getConfidence(), 0);
 
     VoteRecord vr(false);
 
     // Check initial state.
     BOOST_CHECK_EQUAL(vr.isAccepted(), false);
     BOOST_CHECK_EQUAL(vr.hasFinalized(), false);
     BOOST_CHECK_EQUAL(vr.getConfidence(), 0);
 
     // We need to register 6 positive votes before we start counting.
     for (int i = 0; i < 6; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, false, false, 0);
     }
 
     // Next vote will flip state, and confidence will increase as long as we
     // vote yes.
     REGISTER_VOTE_AND_CHECK(vr, 0, true, false, 0);
 
     // A single neutral vote do not change anything.
     REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 1);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, true, false, i);
     }
 
     // Two neutral votes will stall progress.
     REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 7);
     REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 7);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, true, false, 7);
     }
 
     // Now confidence will increase as long as we vote yes.
     for (int i = 8; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 0, true, false, i);
     }
 
     // The next vote will finalize the decision.
     REGISTER_VOTE_AND_CHECK(vr, 1, true, true, AVALANCHE_FINALIZATION_SCORE);
 
     // Now that we have two no votes, confidence stop increasing.
     for (int i = 0; i < 5; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, true, true,
                                 AVALANCHE_FINALIZATION_SCORE);
     }
 
     // Next vote will flip state, and confidence will increase as long as we
     // vote no.
     REGISTER_VOTE_AND_CHECK(vr, 1, false, false, 0);
 
     // A single neutral vote do not change anything.
     REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 1);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, false, false, i);
     }
 
     // Two neutral votes will stall progress.
     REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 7);
     REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 7);
     for (int i = 2; i < 8; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, false, false, 7);
     }
 
     // Now confidence will increase as long as we vote no.
     for (int i = 8; i < AVALANCHE_FINALIZATION_SCORE; i++) {
         REGISTER_VOTE_AND_CHECK(vr, 1, false, false, i);
     }
 
     // The next vote will finalize the decision.
     REGISTER_VOTE_AND_CHECK(vr, 0, false, true, AVALANCHE_FINALIZATION_SCORE);
 
     // Check that inflight accounting work as expected.
     VoteRecord vrinflight(false);
     for (int i = 0; i < 2 * AVALANCHE_MAX_INFLIGHT_POLL; i++) {
         bool shouldPoll = vrinflight.shouldPoll();
         BOOST_CHECK_EQUAL(shouldPoll, i < AVALANCHE_MAX_INFLIGHT_POLL);
         BOOST_CHECK_EQUAL(vrinflight.registerPoll(), shouldPoll);
     }
 
     // Clear various number of inflight requests and check everything behaves as
     // expected.
     for (int i = 1; i < AVALANCHE_MAX_INFLIGHT_POLL; i++) {
         vrinflight.clearInflightRequest(i);
         BOOST_CHECK(vrinflight.shouldPoll());
 
         for (int j = 1; j < i; j++) {
             BOOST_CHECK(vrinflight.registerPoll());
             BOOST_CHECK(vrinflight.shouldPoll());
         }
 
         BOOST_CHECK(vrinflight.registerPoll());
         BOOST_CHECK(!vrinflight.shouldPoll());
     }
 }
 
 BOOST_AUTO_TEST_CASE(block_update) {
     CBlockIndex index;
     CBlockIndex *pindex = &index;
 
     std::set<BlockUpdate::Status> status{
         BlockUpdate::Status::Invalid,
         BlockUpdate::Status::Rejected,
         BlockUpdate::Status::Accepted,
         BlockUpdate::Status::Finalized,
     };
 
     for (auto s : status) {
         BlockUpdate abu(pindex, s);
         BOOST_CHECK(abu.getBlockIndex() == pindex);
         BOOST_CHECK_EQUAL(abu.getStatus(), s);
     }
 }
 
 namespace {
 Response next(Response &r) {
     auto copy = r;
     r = {r.getRound() + 1, r.getCooldown(), r.GetVotes()};
     return copy;
 }
 } // namespace
 
 BOOST_AUTO_TEST_CASE(block_register) {
     std::vector<BlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHash = block.GetHash();
     const CBlockIndex *pindex;
     {
         LOCK(cs_main);
         pindex = 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));
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Newly added blocks' state reflect the blockchain.
     BOOST_CHECK(m_processor->isAccepted(pindex));
 
     int nextNodeIndex = 0;
     auto registerNewVote = [&](const Response &resp) {
         runEventLoop();
         auto nodeid = avanodes[nextNodeIndex++ % avanodes.size()]->GetId();
         BOOST_CHECK(registerVotes(nodeid, resp, updates));
     };
 
     // Let's vote for this block a few times.
     Response resp{0, 0, {Vote(0, blockHash)}};
     for (int i = 0; i < 6; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(pindex));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 0);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // A single neutral vote do not change anything.
     resp = {getRound(), 0, {Vote(-1, blockHash)}};
     registerNewVote(next(resp));
     BOOST_CHECK(m_processor->isAccepted(pindex));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 0);
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     resp = {getRound(), 0, {Vote(0, blockHash)}};
     for (int i = 1; i < 7; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(pindex));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), i);
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Two neutral votes will stall progress.
     resp = {getRound(), 0, {Vote(-1, blockHash)}};
     registerNewVote(next(resp));
     BOOST_CHECK(m_processor->isAccepted(pindex));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 6);
     BOOST_CHECK_EQUAL(updates.size(), 0);
     registerNewVote(next(resp));
     BOOST_CHECK(m_processor->isAccepted(pindex));
     BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 6);
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     resp = {getRound(), 0, {Vote(0, blockHash)}};
     for (int i = 2; i < 8; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(pindex));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 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(pindex));
         BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 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, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Now finalize the decision.
     registerNewVote(next(resp));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
     BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
     updates = {};
 
     // Once the decision is finalized, there is no poll for it.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 0);
 
     // Now let's undo this and finalize rejection.
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     resp = {getRound(), 0, {Vote(1, blockHash)}};
     for (int i = 0; i < 6; i++) {
         registerNewVote(next(resp));
         BOOST_CHECK(m_processor->isAccepted(pindex));
         BOOST_CHECK_EQUAL(updates.size(), 0);
     }
 
     // Now the state will flip.
     registerNewVote(next(resp));
     BOOST_CHECK(!m_processor->isAccepted(pindex));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
     BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Rejected);
     updates = {};
 
     // 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(pindex));
         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, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Now finalize the decision.
     registerNewVote(next(resp));
     BOOST_CHECK(!m_processor->isAccepted(pindex));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindex);
     BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Invalid);
     updates = {};
 
     // Once the decision is finalized, there is no poll for it.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 0);
 
     // Adding the block twice does nothing.
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
     BOOST_CHECK(!m_processor->addBlockToReconcile(pindex));
     BOOST_CHECK(m_processor->isAccepted(pindex));
 }
 
 BOOST_AUTO_TEST_CASE(multi_block_register) {
     CBlockIndex indexA, indexB;
 
     std::vector<BlockUpdate> updates;
 
     // Create several nodes that support avalanche.
     auto avanodes = ConnectNodes();
 
     // Make sure the block has a hash.
     CBlock blockA = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHashA = blockA.GetHash();
 
     CBlock blockB = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHashB = blockB.GetHash();
     const CBlockIndex *pindexA;
     const CBlockIndex *pindexB;
     {
         LOCK(cs_main);
         pindexA = LookupBlockIndex(blockHashA);
         pindexB = LookupBlockIndex(blockHashB);
     }
 
     // Querying for random block returns false.
     BOOST_CHECK(!m_processor->isAccepted(pindexA));
     BOOST_CHECK(!m_processor->isAccepted(pindexB));
 
     // Start voting on block A.
     BOOST_CHECK(m_processor->addBlockToReconcile(pindexA));
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHashA);
 
     uint64_t round = getRound();
     runEventLoop();
     BOOST_CHECK(registerVotes(avanodes[0]->GetId(),
                               {round, 0, {Vote(0, blockHashA)}}, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
 
     // Start voting on block B after one vote.
     Response resp{round + 1, 0, {Vote(0, blockHashB), Vote(0, blockHashA)}};
     BOOST_CHECK(m_processor->addBlockToReconcile(pindexB));
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 2);
 
     // Ensure B comes before A because it has accumulated more PoW.
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHashB);
     BOOST_CHECK_EQUAL(invs[1].type, MSG_BLOCK);
     BOOST_CHECK(invs[1].hash == blockHashA);
 
     // Let's vote for these blocks a few times.
     for (int i = 0; i < 4; i++) {
         NodeId nodeid = getSuitableNodeToQuery();
         runEventLoop();
         BOOST_CHECK(registerVotes(nodeid, next(resp), updates));
         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(registerVotes(nodeid, next(resp), updates));
         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 block A.
     BOOST_CHECK(registerVotes(firstNodeid, next(resp), updates));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindexA);
     BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
     updates = {};
 
     // We do not vote on A anymore.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHashB);
 
     // Next vote will finalize block B.
     BOOST_CHECK(registerVotes(secondNodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 1);
     BOOST_CHECK(updates[0].getBlockIndex() == pindexB);
     BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
     updates = {};
 
     // There is nothing left to vote on.
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(poll_and_response) {
     std::vector<BlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHash = block.GetHash();
     const CBlockIndex *pindex;
     {
         LOCK(cs_main);
         pindex = LookupBlockIndex(blockHash);
     }
 
     // There is no node to query.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);
 
     // Create a node that supports avalanche and one that doesn't.
     ConnectNode(NODE_NONE);
     auto avanode = ConnectNode(NODE_AVALANCHE);
     NodeId avanodeid = avanode->GetId();
     BOOST_CHECK(addNode(avanodeid));
 
     // It returns the avalanche peer.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // Register a block and check it is added to the list of elements to poll.
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
     auto invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 
     // Trigger a poll on avanode.
     uint64_t round = getRound();
     runEventLoop();
 
     // There is no more suitable peer available, so return nothing.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);
 
     // Respond to the request.
     Response resp = {round, 0, {Vote(0, blockHash)}};
     BOOST_CHECK(registerVotes(avanodeid, resp, updates));
     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) {
         int banscore;
         std::string error;
         BOOST_CHECK(!m_processor->registerVotes(nodeid, response, updates,
                                                 banscore, 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, blockHash), Vote(0, blockHash)}};
     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);
 
     // 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, blockHash)}};
     checkRegisterVotesError(avanodeid + 1234, resp, "unexpected-ava-response");
 
     // Proper response gets processed and avanode is available again.
     resp = {queryRound, 0, {Vote(0, blockHash)}};
     BOOST_CHECK(registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // Out of order response are rejected.
     CBlock block2 = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHash2 = block2.GetHash();
     CBlockIndex *pindex2;
     {
         LOCK(cs_main);
         pindex2 = LookupBlockIndex(blockHash2);
     }
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex2));
 
     resp = {getRound(), 0, {Vote(0, blockHash), Vote(0, blockHash2)}};
     runEventLoop();
     checkRegisterVotesError(avanodeid, resp, "invalid-ava-response-content");
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // But they are accepted in order.
     resp = {getRound(), 0, {Vote(0, blockHash2), Vote(0, blockHash)}};
     runEventLoop();
     BOOST_CHECK(registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 
     // When a block is marked invalid, stop polling.
     pindex2->nStatus = pindex2->nStatus.withFailed();
     resp = {getRound(), 0, {Vote(0, blockHash)}};
     runEventLoop();
     BOOST_CHECK(registerVotes(avanodeid, resp, updates));
     BOOST_CHECK_EQUAL(updates.size(), 0);
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
 }
 
 BOOST_AUTO_TEST_CASE(poll_inflight_timeout, *boost::unit_test::timeout(60)) {
     std::vector<BlockUpdate> updates;
 
     CBlock block = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHash = block.GetHash();
     const CBlockIndex *pindex;
     {
         LOCK(cs_main);
         pindex = LookupBlockIndex(blockHash);
     }
 
     // Add the block
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
 
     // Create a node that supports avalanche.
     auto avanode = ConnectNode(NODE_AVALANCHE);
     NodeId avanodeid = avanode->GetId();
     BOOST_CHECK(addNode(avanodeid));
 
     // Expire requests after some time.
     auto queryTimeDuration = std::chrono::milliseconds(10);
     m_processor->setQueryTimeoutDuration(queryTimeDuration);
     for (int i = 0; i < 10; i++) {
         Response resp = {getRound(), 0, {Vote(0, blockHash)}};
 
         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 = registerVotes(avanodeid, next(resp), updates);
         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);
 
         // Now try again but wait for expiration.
         runEventLoop();
         std::this_thread::sleep_for(queryTimeDuration);
         runEventLoop();
         BOOST_CHECK(!registerVotes(avanodeid, next(resp), updates));
     }
 }
 
 BOOST_AUTO_TEST_CASE(poll_inflight_count) {
     // 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 a block to poll
     CBlock block = CreateAndProcessBlock({}, CScript());
     const BlockHash blockHash = block.GetHash();
     const CBlockIndex *pindex;
     {
         LOCK(cs_main);
         pindex = LookupBlockIndex(blockHash);
     }
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
 
     // 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, MSG_BLOCK);
         BOOST_CHECK(invs[0].hash == blockHash);
         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);
 
     std::vector<BlockUpdate> updates;
 
     // Send one response, now we can poll again.
     auto it = node_round_map.begin();
     Response resp = {it->second, 0, {Vote(0, blockHash)}};
     BOOST_CHECK(registerVotes(it->first, resp, updates));
     node_round_map.erase(it);
 
     invs = getInvsForNextPoll();
     BOOST_CHECK_EQUAL(invs.size(), 1);
     BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
     BOOST_CHECK(invs[0].hash == blockHash);
 }
 
 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 = 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, round] : node_round_map) {
         uint64_t r = round;
 
         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 = 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 node that supports avalanche.
     auto avanode = ConnectNode(NODE_AVALANCHE);
     NodeId nodeid = avanode->GetId();
     BOOST_CHECK(addNode(nodeid));
 
     // There is no query in flight at the moment.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), nodeid);
 
     // Add a new block. Check it is added to the polls.
     uint64_t queryRound = getRound();
     BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
 
     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 10ms.
         UninterruptibleSleep(std::chrono::milliseconds(1));
         if (getRound() != queryRound) {
             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;
     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_SUITE_END()
diff --git a/src/avalanche/test/proof_tests.cpp b/src/avalanche/test/proof_tests.cpp
index 77e46ac3f..7f3eee331 100644
--- a/src/avalanche/test/proof_tests.cpp
+++ b/src/avalanche/test/proof_tests.cpp
@@ -1,495 +1,494 @@
 // 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 <streams.h>
 #include <util/strencodings.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 using namespace avalanche;
 
 BOOST_FIXTURE_TEST_SUITE(proof_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(proof_random) {
     for (int i = 0; i < 1000; i++) {
         const uint32_t score = InsecureRand32();
         const Proof p = buildRandomProof(score);
         BOOST_CHECK_EQUAL(p.getScore(), score);
 
         ProofValidationResult expected_state =
             hasDustStake(p) ? ProofValidationResult::DUST_THRESOLD
                             : ProofValidationResult::NONE;
 
         ProofValidationState state;
         BOOST_CHECK_EQUAL(p.verify(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, master);
+    ProofBuilder pb(sequence, expiration, key);
 
     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));
     }
 
     Proof p = pb.build();
 
     ProofValidationState state;
     BOOST_CHECK(p.verify(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) {
     std::vector<TestVector> testcases{
         {"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_SIGNATURE},
         {"2 utxo staked",
          "872379ab64f55b4166ca0e79639999ec4104a66861de557a54eefc0375264cc17c3a3"
          "50ccabca6fd9c91883e899ab55bb140517aa56c5b4041908e7027a786b99f66488a04"
          "135ce5fe189a99a7bc541ddfe602fabf3ad5b875840e7813a66d5ea8a1288a49b6222"
          "b59fcbe6249f94e5927f9f4b884b0b040a534b3ba040000d045d5d021036830e697b0"
          "ee89866da798a8945bd85b352545ec1bcace7e04909ea54c134f16d5fe4e972b7acd2"
          "9ebfc2b7b11c26974b84e5f21a45bbe8372472f59e5dfdea7e9e5857c6aebe5dbc5e6"
          "46dfbf4e7cee380afaddb15d06153bf1755b9ef00a616d4c8c3c3a662b5eddc192656"
          "4a488e3e68e334291078001480f7fa5144ef3a606a41e85c0218dd377090000e41099"
          "912102ebfcea8e1864c1273c41e0d7c1e9097be5c491bbbf5fe31161d8e5589b9d6b5"
          "b12f3b963c7fc7614d56d83af907e5cb18ac2f4c3e70a8c4253995f6bc002ec5e3504"
          "91c965cba4dbc11c210979217f1ac3ece7a748f5b2fcf5cced40a5d4c40e",
          ProofId::fromHex("ba5aba9be72c9c2c52f857b81245e1ec85c879bbc8e111008673"
                           "d78c26610b05"),
          15610172, ProofValidationResult::INVALID_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_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_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",
          "c964aa6fde575e4ce8404581c7be874e21038439233261789dd340bdc1450172d9c67"
          "1b72ee8c0b2736ed2a3a250760897fd03e4ed76e1f19b2c2a0fcc069b4ace4a078cb5"
          "cc31e9e19b266d0af41ea8bb0c30c8b47c95a856d9aa000000007dfdd89a21030f588"
          "3ac0b61082277ad94d9f5f979baffc49d516167aeda0eb7de30db319a411f97bc976e"
          "0490468f2f6d552c8cf87e8def1492b8ac81df0b4448a3c212e9000f9e753b97c93e0"
          "2fbe8976c95488b54a24f7df00d3cfed308701e6d690c394cac098c86414715db364a"
          "4e32216084c561acdd79e0860b1fdf7497b159cb13230451200296c902ee000000009"
          "f2bc7392102a397e8e1f737cae7d8c41ec68445261e9201ed36bc694d753095f716b3"
          "97319d5c5ef9a7712ec77b6826b29bf53691bbcb6873a326f313efb8cdb8911715bc6"
          "7d61a3b804f9ac9162374c6df42dc918b0ba3f05d0578cd9f96d5078c903b89f30b1e"
          "5f35704cb63360aa3d5f444ee35eea4c154c1af6d4e7595b409ada4b42377764698a9"
          "15c2ac4000000000f28db3221039f1ae9bbeeafa63abdc362f0a2c00e6c0582615b79"
          "61745180c47a0b7800abc1e97c016b9e99625394b738643e8ef0d3d4936165caff79c"
          "1070d36ca432ba04dbbb54474a42f9e72587d05ba6353ce1be41a0e80e2d2257bc444"
          "99fa26f5c1d7",
          ProofId::fromHex("317289c8d2f4fb7b4fea5195e4dbc9804018c6aab71606b50e27"
                           "ddd8e2d985db"),
          10150, ProofValidationResult::NONE},
         {"Changing sequence affect ProofId",
          "d87587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("333c462a0161e9146da55d77733a2d4ccd022217a70beb004742"
                           "5069f1d32ed5"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing expiration affect ProofId",
          "d97587e6c882615797011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("6b7d6b32a88e68e830454bb0189ac14dc938917bdc64f22ef11d"
                           "d41535ede85a"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the master key affect ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469aa5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("d4e2673f9df2e5c506892f3794b986910c77aa9b0c292cdcfea8"
                           "3dd804008b00"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the TxId affect the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90179a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("fefa0e3d8f76358431caba523ac71faaf57921bb6f1049f74a3e"
                           "8bebd512c20b"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the outpoint index change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91df00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("a9f6b78b97a01d21d47b834bb8bf5d9397f50bfac115ec3da05b"
                           "695189aef040"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the amount changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21814712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("89796be200e6eeeefdb894e47f16653afc572310d5f94c859cac"
                           "628ffc0d9781"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the height changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010028e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("77db71b3099331de1e09262d03ee4a5f2d2c21f5abc48f68e28d"
                           "456cecc822ce"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the pubkey changes the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102459fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e2",
          ProofId::fromHex("3663e72aae7fe4dacde5aa6d5e6f2a3041171d9e7756a47662e1"
                           "e0a11e82621c"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"Changing the signature does NOT change the ProofId",
          "d97587e6c882615796011ec8f9a7b1c6410469ab5a892ffa4bb104a3d5760dd893a55"
          "02512eea4ba32a6d6672767be4959c0f70489b803a47a3abf83f30e8d9da978de4027"
          "c70ce7e0d3b0ad62eb08edd8f90169a79ff23e1d58c64afad42ad81cffe53967e16be"
          "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a32102449fb5237e"
          "fe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce6800a7b4811c6412ad"
          "f94b0d6bb5227aeec27f49b2948b6e3da564d12d96ff00779f113d52c82093e101323"
          "4440ad829030c685ca03d4fd9ce95b298e79c5eee6e3",
          ProofId::fromHex("cbd77dad2ebc525c591ab44a0f6a25803c1d934c3e5caa61f9f4"
                           "c63c9f29a4e6"),
          444638638, ProofValidationResult::INVALID_SIGNATURE},
         {"1 utxo staked but zero coins",
          "a6d6852ffa70b172d37a0ad2c01c2acd21023beefdde700a6bc02036335b4df141c8b"
          "c67bb05a971f5ac2745fd683797dde30145a4d07798547464daa53acefb7c97c0c415"
          "ed8e81e549ff56a0ef6f847fcc9ca855b3620000000000000000e707d7272102449fb"
          "5237efe8f647d32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68065cd42e0e6"
          "9d511ad24ecb3c3af07176bcf890caa7cfc64039dc65e51014dd99d11bd00ffbfbcc1"
          "9619ca502bfd4dd6dbc0967692ff6d2211b0bd9b9f05e1298",
          ProofId::fromHex("38f7c9696f9c2c07db3f23024d550a6b0b7f851013074280dbe3"
                           "49f42a2a5a00"),
          0, ProofValidationResult::DUST_THRESOLD},
     };
 
     for (auto &c : testcases) {
         CDataStream stream(ParseHex(c.hex), SER_NETWORK, 0);
         Proof p;
         stream >> p;
         BOOST_CHECK_EQUAL(p.getId(), c.proofid);
         BOOST_CHECK_EQUAL(p.getScore(), c.score);
 
         ProofValidationState state;
         BOOST_CHECK_EQUAL(p.verify(state),
                           c.result == ProofValidationResult::NONE);
         BOOST_CHECK(state.GetResult() == c.result);
         BOOST_TEST_MESSAGE(c.proofid);
     }
 }
 
 BOOST_AUTO_TEST_CASE(verify) {
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
 
     auto key = CKey::MakeCompressedKey();
     const CPubKey pubkey = key.GetPubKey();
 
     const Amount value = 12345 * COIN;
     const uint32_t height = 10;
 
     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) {
         // Generate a proof that match the UTXO.
-        ProofBuilder pb(0, 0, pubkey);
+        ProofBuilder pb(0, 0, key);
         BOOST_CHECK(pb.addUTXO(o, v, h, is_coinbase, k));
         Proof p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(p.verify(state));
         BOOST_CHECK(p.verify(state, coins) ==
                     (result == ProofValidationResult::NONE));
         BOOST_CHECK(state.GetResult() == result);
     };
 
     // Valid proof
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
              key);
 
     // 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
     {
-        Proof p = ProofBuilder(0, 0, pubkey).build();
+        Proof p = ProofBuilder(0, 0, key).build();
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::NO_STAKE);
     }
 
     // Dust thresold
     {
-        ProofBuilder pb(0, 0, pubkey);
+        ProofBuilder pb(0, 0, key);
         BOOST_CHECK(
             pb.addUTXO(pkh_outpoint, Amount::zero(), height, false, key));
         Proof p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::DUST_THRESOLD);
     }
 
     {
-        ProofBuilder pb(0, 0, pubkey);
+        ProofBuilder pb(0, 0, key);
         BOOST_CHECK(pb.addUTXO(pkh_outpoint, PROOF_DUST_THRESHOLD - 1 * SATOSHI,
                                height, false, key));
         Proof p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::DUST_THRESOLD);
     }
 
     // Duplicated input
     {
-        ProofBuilder pb(0, 0, pubkey);
+        ProofBuilder pb(0, 0, key);
         BOOST_CHECK(pb.addUTXO(pkh_outpoint, value, height, false, key));
         Proof p = TestProofBuilder::buildDuplicatedStakes(pb);
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         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, pubkey);
+        ProofBuilder pb(0, 0, key);
         BOOST_CHECK(pb.addUTXO(pkh_outpoint, value, height, false, key));
         BOOST_CHECK(pb.addUTXO(other_pkh_outpoint, value, height, false, key));
         Proof p = TestProofBuilder::buildWithReversedOrderStakes(pb);
 
         ProofValidationState state;
         BOOST_CHECK(!p.verify(state, coins));
         BOOST_CHECK(state.GetResult() ==
                     ProofValidationResult::WRONG_STAKE_ORDERING);
     }
 }
 
 BOOST_AUTO_TEST_CASE(deterministic_proofid) {
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
 
     auto key = CKey::MakeCompressedKey();
-    const CPubKey pubkey = key.GetPubKey();
 
     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, pubkey);
+        ProofBuilder pb(0, 0, key);
         for (const COutPoint &outpoint : outpoints) {
             BOOST_CHECK(pb.addUTXO(outpoint, value, height, false, key));
         }
         Proof p = pb.build();
 
         return p.getId();
     };
 
     const ProofId proofid = computeProofId();
     Shuffle(outpoints.begin(), outpoints.end(), FastRandomContext());
     BOOST_CHECK_EQUAL(proofid, computeProofId());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/avalanche/test/util.cpp b/src/avalanche/test/util.cpp
index 50e766bb6..bd8407025 100644
--- a/src/avalanche/test/util.cpp
+++ b/src/avalanche/test/util.cpp
@@ -1,119 +1,119 @@
 // 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 {
 
-Proof buildRandomProof(uint32_t score, const CPubKey &master) {
+Proof buildRandomProof(uint32_t score, const CKey &masterKey) {
     auto key = CKey::MakeCompressedKey();
 
     const COutPoint o(TxId(GetRandHash()), 0);
     const Amount v = (int64_t(score) * COIN) / 100;
     const int height = 1234;
     const bool is_coinbase = false;
 
     {
         CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
 
         LOCK(cs_main);
         CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         coins.AddCoin(o, Coin(CTxOut(v, script), height, is_coinbase), false);
     }
 
-    ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), master);
+    ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), masterKey);
     BOOST_CHECK(pb.addUTXO(o, v, height, is_coinbase, std::move(key)));
     return pb.build();
 }
 
 bool hasDustStake(const Proof &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.master;
+    ss2 << pb.masterKey.GetPubKey();
 
     return ProofId(ss2.GetHash());
 }
 
 Proof TestProofBuilder::buildWithReversedOrderStakes(ProofBuilder &pb) {
     const ProofId proofid = TestProofBuilder::getReverseOrderProofId(pb);
 
     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(proofid));
     }
 
-    return Proof(pb.sequence, pb.expirationTime, std::move(pb.master),
+    return Proof(pb.sequence, pb.expirationTime, pb.masterKey.GetPubKey(),
                  std::move(signedStakes));
 }
 
 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.master;
+    ss2 << pb.masterKey.GetPubKey();
 
     return ProofId(ss2.GetHash());
 }
 
 Proof TestProofBuilder::buildDuplicatedStakes(ProofBuilder &pb) {
     const ProofId proofid = TestProofBuilder::getDuplicatedStakeProofId(pb);
 
     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(proofid);
         signedStakes.push_back(signedStake);
         signedStakes.push_back(signedStake);
     }
 
-    return Proof(pb.sequence, pb.expirationTime, std::move(pb.master),
+    return Proof(pb.sequence, pb.expirationTime, pb.masterKey.GetPubKey(),
                  std::move(signedStakes));
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/test/util.h b/src/avalanche/test/util.h
index a04d1f33d..b19b1409b 100644
--- a/src/avalanche/test/util.h
+++ b/src/avalanche/test/util.h
@@ -1,31 +1,32 @@
 // 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 <pubkey.h>
+#include <key.h>
 
 #include <cstdio>
 
 namespace avalanche {
 
 constexpr uint32_t MIN_VALID_PROOF_SCORE = 100 * PROOF_DUST_THRESHOLD / COIN;
 
-Proof buildRandomProof(uint32_t score, const CPubKey &master = CPubKey());
+Proof buildRandomProof(uint32_t score,
+                       const CKey &masterKey = CKey::MakeCompressedKey());
 
 bool hasDustStake(const Proof &proof);
 
 struct TestProofBuilder {
     static ProofId getReverseOrderProofId(ProofBuilder &pb);
     static Proof buildWithReversedOrderStakes(ProofBuilder &pb);
     static ProofId getDuplicatedStakeProofId(ProofBuilder &pb);
     static Proof buildDuplicatedStakes(ProofBuilder &pb);
 };
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_TEST_UTIL_H
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
index 10c2a10e6..27f048659 100644
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -1,672 +1,677 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/avalanche.h>
 #include <avalanche/delegation.h>
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/processor.h>
 #include <avalanche/proof.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/validation.h>
 #include <config.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <net_processing.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <util/strencodings.h>
 
 #include <univalue.h>
 
 static UniValue getavalanchekey(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "getavalanchekey",
         "Returns the key used to sign avalanche messages.\n",
         {},
         RPCResult{RPCResult::Type::STR_HEX, "", ""},
         RPCExamples{HelpExampleRpc("getavalanchekey", "")},
     }
         .Check(request);
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     return HexStr(g_avalanche->getSessionPubKey());
 }
 
 static CPubKey ParsePubKey(const UniValue &param) {
     const std::string keyHex = param.get_str();
     if ((keyHex.length() != 2 * CPubKey::COMPRESSED_SIZE &&
          keyHex.length() != 2 * CPubKey::SIZE) ||
         !IsHex(keyHex)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("Invalid public key: %s\n", keyHex));
     }
 
     return HexToPubKey(keyHex);
 }
 
 static bool registerProofIfNeeded(std::shared_ptr<avalanche::Proof> proof) {
     return g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
         return pm.getProof(proof->getId()) ||
                pm.registerProof(std::move(proof));
     });
 }
 
 static void verifyDelegationOrThrow(avalanche::Delegation &dg,
                                     const std::string &dgHex, CPubKey &auth) {
     bilingual_str error;
     if (!avalanche::Delegation::FromHex(dg, dgHex, error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
     }
 
     avalanche::DelegationState state;
     if (!dg.verify(state, auth)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "The delegation is invalid: " + state.ToString());
     }
 }
 
 static void verifyProofOrThrow(const NodeContext &node, avalanche::Proof &proof,
                                const std::string &proofHex) {
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, proofHex, error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
     }
 
     avalanche::ProofValidationState state;
     {
         LOCK(cs_main);
         if (!proof.verify(state,
                           node.chainman->ActiveChainstate().CoinsTip())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The proof is invalid: " + state.ToString());
         }
     }
 }
 
 static UniValue addavalanchenode(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "addavalanchenode",
         "Add a node in the set of peers to poll for avalanche.\n",
         {
             {"nodeid", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Node to be added to avalanche."},
             {"publickey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The public key of the node."},
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Proof that the node is not a sybil."},
             {"delegation", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
              "The proof delegation the the node public key"},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the addition succeeded or not."},
         RPCExamples{
             HelpExampleRpc("addavalanchenode", "5, \"<pubkey>\", \"<proof>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {UniValue::VNUM, UniValue::VSTR, UniValue::VSTR});
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     const NodeId nodeid = request.params[0].get_int64();
     CPubKey key = ParsePubKey(request.params[1]);
 
     auto proof = std::make_shared<avalanche::Proof>();
     NodeContext &node = EnsureNodeContext(request.context);
     verifyProofOrThrow(node, *proof, request.params[2].get_str());
 
     const avalanche::ProofId &proofid = proof->getId();
     if (key != proof->getMaster()) {
         if (request.params.size() < 4 || request.params[3].isNull()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "The public key does not match the proof");
         }
 
         avalanche::Delegation dg;
         CPubKey auth;
         verifyDelegationOrThrow(dg, request.params[3].get_str(), auth);
 
         if (dg.getProofId() != proofid) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The delegation does not match the proof");
         }
 
         if (key != auth) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "The public key does not match the delegation");
         }
     }
 
     if (!registerProofIfNeeded(proof)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "The proof has conflicting utxos");
     }
 
     if (!node.connman->ForNode(nodeid, [&](CNode *pnode) {
             // FIXME This is not thread safe, and might cause issues if the
             // unlikely event the peer sends an avahello message at the same
             // time.
             if (!pnode->m_avalanche_state) {
                 pnode->m_avalanche_state =
                     std::make_unique<CNode::AvalancheState>();
             }
             pnode->m_avalanche_state->pubkey = std::move(key);
             return true;
         })) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strprintf("The node does not exist: %d", nodeid));
         ;
     }
 
     return g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
         if (!pm.addNode(nodeid, proofid)) {
             return false;
         }
 
         pm.addUnbroadcastProof(proofid);
         return true;
     });
 }
 
 static UniValue buildavalancheproof(const Config &config,
                                     const JSONRPCRequest &request) {
     RPCHelpMan{
         "buildavalancheproof",
         "Build a proof for avalanche's sybil resistance.\n",
         {
             {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The proof's sequence"},
             {"expiration", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "A timestamp indicating when the proof expire"},
-            {"master", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
-             "The master public key"},
+            {"master", RPCArg::Type::STR, RPCArg::Optional::NO,
+             "The master private key in base58-encoding"},
             {
                 "stakes",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The stakes to be signed and associated private keys",
                 {
                     {
                         "stake",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::NO,
                         "A stake to be attached to this proof",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount in this UTXO"},
                             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The height at which this UTXO was mined"},
                             {"iscoinbase", RPCArg::Type::BOOL,
                              /* default */ "false",
                              "Indicate wether the UTXO is a coinbase"},
                             {"privatekey", RPCArg::Type::STR,
                              RPCArg::Optional::NO,
                              "private key in base58-encoding"},
                         },
                     },
                 },
             },
         },
         RPCResult{RPCResult::Type::STR_HEX, "proof",
                   "A string that is a serialized, hex-encoded proof data."},
         RPCExamples{HelpExampleRpc("buildavalancheproof",
                                    "0 1234567800 \"<master>\" []")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VNUM,
                                   UniValue::VSTR, UniValue::VARR});
 
     const uint64_t sequence = request.params[0].get_int64();
     const int64_t expiration = request.params[1].get_int64();
-    avalanche::ProofBuilder pb(sequence, expiration,
-                               ParsePubKey(request.params[2]));
+
+    CKey masterKey = DecodeSecret(request.params[2].get_str());
+    if (!masterKey.IsValid()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid master key");
+    }
+
+    avalanche::ProofBuilder pb(sequence, expiration, masterKey);
 
     const UniValue &stakes = request.params[3].get_array();
     for (size_t i = 0; i < stakes.size(); i++) {
         const UniValue &stake = stakes[i];
         RPCTypeCheckObj(stake,
                         {
                             {"txid", UniValue::VSTR},
                             {"vout", UniValue::VNUM},
                             // "amount" is also required but check is done below
                             // due to UniValue::VNUM erroneously not accepting
                             // quoted numerics (which are valid JSON)
                             {"height", UniValue::VNUM},
                             {"privatekey", UniValue::VSTR},
                         });
 
         int nOut = find_value(stake, "vout").get_int();
         if (nOut < 0) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "vout must be positive");
         }
 
         const int height = find_value(stake, "height").get_int();
         if (height < 1) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "height must be positive");
         }
 
         const TxId txid(ParseHashO(stake, "txid"));
         const COutPoint utxo(txid, nOut);
 
         if (!stake.exists("amount")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing amount");
         }
 
         const Amount amount = AmountFromValue(find_value(stake, "amount"));
 
         const UniValue &iscbparam = find_value(stake, "iscoinbase");
         const bool iscoinbase =
             iscbparam.isNull() ? false : iscbparam.get_bool();
         CKey key = DecodeSecret(find_value(stake, "privatekey").get_str());
 
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid private key");
         }
 
         if (!pb.addUTXO(utxo, amount, uint32_t(height), iscoinbase,
                         std::move(key))) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Duplicated stake");
         }
     }
 
     const avalanche::Proof proof = pb.build();
 
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << proof;
     return HexStr(ss);
 }
 
 static UniValue decodeavalancheproof(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "decodeavalancheproof",
         "Convert a serialized, hex-encoded proof, into JSON object. "
         "The validity of the proof is not verified.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The proof hex string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "sequence",
                  "The proof's sequential number"},
                 {RPCResult::Type::NUM, "expiration",
                  "A timestamp indicating when the proof expires"},
                 {RPCResult::Type::STR_HEX, "master", "The master public key"},
                 {RPCResult::Type::STR_HEX, "limitedid",
                  "A hash of the proof data excluding the master key."},
                 {RPCResult::Type::STR_HEX, "proofid",
                  "A hash of the limitedid and master key."},
                 {RPCResult::Type::ARR,
                  "stakes",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The transaction id"},
                           {RPCResult::Type::NUM, "vout", "The output number"},
                           {RPCResult::Type::STR_AMOUNT, "amount",
                            "The amount in this UTXO"},
                           {RPCResult::Type::NUM, "height",
                            "The height at which this UTXO was mined"},
                           {RPCResult::Type::BOOL, "iscoinbase",
                            "Indicate whether the UTXO is a coinbase"},
                           {RPCResult::Type::STR_HEX, "pubkey",
                            "This UTXO's public key"},
                           {RPCResult::Type::STR, "signature",
                            "Signature of the proofid with this UTXO's private "
                            "key (base64 encoded)"},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("decodeavalancheproof", "\"<hex proof>\"") +
                     HelpExampleRpc("decodeavalancheproof", "\"<hex proof>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     avalanche::Proof proof;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
     }
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("sequence", proof.getSequence());
     result.pushKV("expiration", proof.getExpirationTime());
     result.pushKV("master", HexStr(proof.getMaster()));
     result.pushKV("limitedid", proof.getLimitedId().ToString());
     result.pushKV("proofid", proof.getId().ToString());
 
     UniValue stakes(UniValue::VARR);
     for (const avalanche::SignedStake &s : proof.getStakes()) {
         const COutPoint &utxo = s.getStake().getUTXO();
         UniValue stake(UniValue::VOBJ);
         stake.pushKV("txid", utxo.GetTxId().ToString());
         stake.pushKV("vout", uint64_t(utxo.GetN()));
         stake.pushKV("amount", s.getStake().getAmount());
         stake.pushKV("height", uint64_t(s.getStake().getHeight()));
         stake.pushKV("iscoinbase", s.getStake().isCoinbase());
         stake.pushKV("pubkey", HexStr(s.getStake().getPubkey()));
         stake.pushKV("signature", EncodeBase64(s.getSignature()));
         stakes.push_back(stake);
     }
     result.pushKV("stakes", stakes);
 
     return result;
 }
 
 static UniValue delegateavalancheproof(const Config &config,
                                        const JSONRPCRequest &request) {
     RPCHelpMan{
         "delegateavalancheproof",
         "Delegate the avalanche proof to another public key.\n",
         {
             {"limitedproofid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The limited id of the proof to be delegated."},
             {"privatekey", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The private key in base58-encoding. Must match the proof master "
              "public key or the upper level parent delegation public key if "
              " supplied."},
             {"publickey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The public key to delegate the proof to."},
             {"delegation", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
              "A string that is the serialized, hex-encoded delegation for the "
              "proof and which is a parent for the delegation to build."},
         },
         RPCResult{RPCResult::Type::STR_HEX, "delegation",
                   "A string that is a serialized, hex-encoded delegation."},
         RPCExamples{
             HelpExampleRpc("delegateavalancheproof",
                            "\"<limitedproofid>\" \"<privkey>\" \"<pubkey>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {UniValue::VSTR, UniValue::VSTR, UniValue::VSTR});
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     avalanche::LimitedProofId limitedProofId{
         ParseHashV(request.params[0], "limitedproofid")};
 
     const CKey privkey = DecodeSecret(request.params[1].get_str());
     if (!privkey.IsValid()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "The private key is invalid");
     }
 
     const CPubKey pubkey = ParsePubKey(request.params[2]);
 
     std::unique_ptr<avalanche::DelegationBuilder> dgb;
     if (request.params.size() >= 4 && !request.params[3].isNull()) {
         avalanche::Delegation dg;
         CPubKey auth;
         verifyDelegationOrThrow(dg, request.params[3].get_str(), auth);
 
         if (dg.getProofId() !=
             limitedProofId.computeProofId(dg.getProofMaster())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The delegation does not match the proof");
         }
 
         if (privkey.GetPubKey() != auth) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "The private key does not match the delegation");
         }
 
         dgb = std::make_unique<avalanche::DelegationBuilder>(dg);
     } else {
         dgb = std::make_unique<avalanche::DelegationBuilder>(
             limitedProofId, privkey.GetPubKey());
     }
 
     if (!dgb->addLevel(privkey, pubkey)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Unable to build the delegation");
     }
 
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << dgb->build();
     return HexStr(ss);
 }
 
 static UniValue getavalanchepeerinfo(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "getavalanchepeerinfo",
         "Returns data about each connected avalanche peer as a json array of "
         "objects.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {{
                     {RPCResult::Type::NUM, "peerid", "The peer id"},
                     {RPCResult::Type::STR_HEX, "proof",
                      "The avalanche proof used by this peer"},
                     {RPCResult::Type::NUM, "nodecount",
                      "The number of nodes for this peer"},
                     {RPCResult::Type::ARR,
                      "nodes",
                      "",
                      {
                          {RPCResult::Type::NUM, "nodeid",
                           "Node id, as returned by getpeerinfo"},
                      }},
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("getavalanchepeerinfo", "") +
                     HelpExampleRpc("getavalanchepeerinfo", "")},
     }
         .Check(request);
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     UniValue ret(UniValue::VARR);
 
     g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
         pm.forEachPeer([&](const avalanche::Peer &peer) {
             UniValue obj(UniValue::VOBJ);
 
             CDataStream serproof(SER_NETWORK, PROTOCOL_VERSION);
             serproof << *peer.proof;
 
             obj.pushKV("peerid", uint64_t(peer.peerid));
             obj.pushKV("proof", HexStr(serproof));
 
             UniValue nodes(UniValue::VARR);
             pm.forEachNode(peer, [&](const avalanche::Node &n) {
                 nodes.push_back(n.nodeid);
             });
 
             obj.pushKV("nodecount", uint64_t(peer.node_count));
             obj.pushKV("nodes", nodes);
 
             ret.push_back(obj);
         });
     });
 
     return ret;
 }
 
 static UniValue getrawavalancheproof(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "getrawavalancheproof",
         "Lookup for a known avalanche proof by id.\n",
         {
             {"proofid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex encoded avalanche proof identifier."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {{
                 {RPCResult::Type::STR_HEX, "proof",
                  "The hex encoded proof matching the identifier."},
                 {RPCResult::Type::BOOL, "orphan",
                  "Whether the proof is an orphan."},
             }},
         },
         RPCExamples{HelpExampleRpc("getrawavalancheproof", "<proofid>")},
     }
         .Check(request);
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     const avalanche::ProofId proofid =
         avalanche::ProofId::fromHex(request.params[0].get_str());
 
     bool isOrphan = false;
     auto proof = g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
         auto proof = pm.getProof(proofid);
         if (!proof) {
             proof = pm.getOrphan(proofid);
             isOrphan = true;
         }
         return proof;
     });
 
     if (!proof) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Proof not found");
     }
 
     UniValue ret(UniValue::VOBJ);
 
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << *proof;
     ret.pushKV("proof", HexStr(ss));
     ret.pushKV("orphan", isOrphan);
 
     return ret;
 }
 
 static UniValue sendavalancheproof(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "sendavalancheproof",
         "Broadcast an avalanche proof.\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The avalanche proof to broadcast."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the proof was sent successfully or not."},
         RPCExamples{HelpExampleRpc("sendavalancheproof", "<proof>")},
     }
         .Check(request);
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     auto proof = std::make_shared<avalanche::Proof>();
     NodeContext &node = EnsureNodeContext(request.context);
 
     // Verify the proof. Note that this is redundant with the verification done
     // when adding the proof to the pool, but we get a chance to give a better
     // error message.
     verifyProofOrThrow(node, *proof, request.params[0].get_str());
 
     // Add the proof to the pool if we don't have it already. Since the proof
     // verification has already been done, a failure likely indicates that there
     // already is a proof with conflicting utxos.
     const avalanche::ProofId &proofid = proof->getId();
     if (!registerProofIfNeeded(proof)) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "The proof has conflicting utxo with an existing proof");
     }
 
     g_avalanche->withPeerManager(
         [&](avalanche::PeerManager &pm) { pm.addUnbroadcastProof(proofid); });
 
     RelayProof(proofid, *node.connman);
 
     return true;
 }
 
 static UniValue verifyavalancheproof(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "verifyavalancheproof",
         "Verify an avalanche proof is valid and return the error otherwise.\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Proof to verify."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the proof is valid or not."},
         RPCExamples{HelpExampleRpc("verifyavalancheproof", "\"<proof>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     avalanche::Proof proof;
     verifyProofOrThrow(EnsureNodeContext(request.context), proof,
                        request.params[0].get_str());
 
     return true;
 }
 
 void RegisterAvalancheRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                      actor (function)        argNames
         //  ------------------- ------------------------  ----------------------  ----------
         { "avalanche",          "getavalanchekey",        getavalanchekey,        {}},
         { "avalanche",          "addavalanchenode",       addavalanchenode,       {"nodeid"}},
         { "avalanche",          "buildavalancheproof",    buildavalancheproof,    {"sequence", "expiration", "master", "stakes"}},
         { "avalanche",          "decodeavalancheproof",   decodeavalancheproof,   {"proof"}},
         { "avalanche",          "delegateavalancheproof", delegateavalancheproof, {"proof", "privatekey", "publickey", "delegation"}},
         { "avalanche",          "getavalanchepeerinfo",   getavalanchepeerinfo,   {}},
         { "avalanche",          "getrawavalancheproof",   getrawavalancheproof,   {"proofid"}},
         { "avalanche",          "sendavalancheproof",     sendavalancheproof,     {"proof"}},
         { "avalanche",          "verifyavalancheproof",   verifyavalancheproof,   {"proof"}},
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/test/functional/abc_p2p_avalanche_peer_discovery.py b/test/functional/abc_p2p_avalanche_peer_discovery.py
index 52a2650a5..83fe0489e 100755
--- a/test/functional/abc_p2p_avalanche_peer_discovery.py
+++ b/test/functional/abc_p2p_avalanche_peer_discovery.py
@@ -1,267 +1,265 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020-2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the peer discovery behavior of avalanche nodes.
 
 This includes tests for the service flag, avahello handshake and
 proof exchange.
 """
 
 import time
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
 from test_framework.avatools import (
     get_ava_p2p_interface,
     create_coinbase_stakes,
     get_proof_ids,
 )
 from test_framework.key import (
     ECKey,
     ECPubKey,
 )
 from test_framework.p2p import p2p_lock
 from test_framework.messages import (
     AvalancheProof,
     CInv,
     FromHex,
     MSG_AVA_PROOF,
     msg_getdata,
     NODE_AVALANCHE,
     NODE_NETWORK,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     wait_until,
 )
 from test_framework.wallet_util import bytes_to_wif
 
 UNCONDITIONAL_RELAY_DELAY = 2 * 60
 
 
 class AvalancheTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1',
                             '-enableavalanchepeerdiscovery=1']]
         self.supports_cli = False
 
     def run_test(self):
         node = self.nodes[0]
 
         # duplicate the deterministic sig test from src/test/key_tests.cpp
         privkey = ECKey()
         privkey.set(bytes.fromhex(
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
-        pubkey = privkey.get_pubkey()
+        wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         self.log.info(
             "Check the node is signalling the avalanche service bit only if there is a proof.")
         assert_equal(
             int(node.getnetworkinfo()['localservices'], 16) & NODE_AVALANCHE,
             0)
 
         # Create stakes by mining blocks
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(2, addrkey0.address)
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         proof_sequence = 11
         proof_expiration = 12
         proof = node.buildavalancheproof(
-            proof_sequence, proof_expiration, pubkey.get_bytes().hex(),
-            stakes)
+            proof_sequence, proof_expiration, wif_privkey, stakes)
 
         # Restart the node
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
 
         assert_equal(
             int(node.getnetworkinfo()['localservices'], 16) & NODE_AVALANCHE,
             NODE_AVALANCHE)
 
         def check_avahello(args):
             # Restart the node with the given args
             self.restart_node(0, self.extra_args[0] + args)
 
             peer = get_ava_p2p_interface(node)
 
             avahello = peer.wait_for_avahello().hello
 
             avakey = ECPubKey()
             avakey.set(bytes.fromhex(node.getavalanchekey()))
             assert avakey.verify_schnorr(
                 avahello.sig, avahello.get_sighash(peer))
 
         self.log.info(
             "Test the avahello signature with a generated delegation")
         check_avahello([
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN"
         ])
 
         master_key = ECKey()
         master_key.generate()
         limited_id = FromHex(AvalancheProof(), proof).limited_proofid
         delegation = node.delegateavalancheproof(
             f"{limited_id:0{64}x}",
             bytes_to_wif(privkey.get_bytes()),
             master_key.get_pubkey().get_bytes().hex(),
         )
 
         self.log.info("Test the avahello signature with a supplied delegation")
         check_avahello([
             "-avaproof={}".format(proof),
             "-avadelegation={}".format(delegation),
             "-avamasterkey={}".format(bytes_to_wif(master_key.get_bytes())),
         ])
 
         stakes = create_coinbase_stakes(node, [blockhashes[1]], addrkey0.key)
         interface_proof_hex = node.buildavalancheproof(
-            proof_sequence, proof_expiration, pubkey.get_bytes().hex(),
-            stakes)
+            proof_sequence, proof_expiration, wif_privkey, stakes)
         limited_id = FromHex(
             AvalancheProof(),
             interface_proof_hex).limited_proofid
 
         # delegate
         delegated_key = ECKey()
         delegated_key.generate()
         interface_delegation_hex = node.delegateavalancheproof(
             f"{limited_id:0{64}x}",
             bytes_to_wif(privkey.get_bytes()),
             delegated_key.get_pubkey().get_bytes().hex(),
             None)
 
         self.log.info("Test that wrong avahello signature causes a ban")
         bad_interface = get_ava_p2p_interface(node)
         wrong_key = ECKey()
         wrong_key.generate()
         with node.assert_debug_log(
                 ["Misbehaving",
                  "peer=1 (0 -> 100) BAN THRESHOLD EXCEEDED: invalid-avahello-signature"]):
             bad_interface.send_avahello(interface_delegation_hex, wrong_key)
             bad_interface.wait_for_disconnect()
 
         self.log.info(
             'Check that receiving a valid avahello triggers a proof getdata request')
         good_interface = get_ava_p2p_interface(node)
         proofid = good_interface.send_avahello(
             interface_delegation_hex, delegated_key)
 
         def getdata_found(peer, proofid):
             with p2p_lock:
                 return good_interface.last_message.get(
                     "getdata") and good_interface.last_message["getdata"].inv[-1].hash == proofid
         wait_until(lambda: getdata_found(good_interface, proofid))
 
         self.log.info('Check that we can download the proof from our peer')
 
         node_proofid = FromHex(AvalancheProof(), proof).proofid
 
         def wait_for_proof_validation():
             # Connect some blocks to trigger the proof verification
             node.generate(1)
             wait_until(lambda: node_proofid in get_proof_ids(node))
 
         wait_for_proof_validation()
 
         getdata = msg_getdata([CInv(MSG_AVA_PROOF, node_proofid)])
 
         self.log.info(
             "Proof has been inv'ed recently, check it can be requested")
         good_interface.send_message(getdata)
 
         def proof_received(peer):
             with p2p_lock:
                 return peer.last_message.get(
                     "avaproof") and peer.last_message["avaproof"].proof.proofid == node_proofid
         wait_until(lambda: proof_received(good_interface))
 
         # Restart the node
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
         wait_for_proof_validation()
 
         self.log.info(
             "The proof has not been announced, it cannot be requested")
         peer = get_ava_p2p_interface(node, services=NODE_NETWORK)
         peer.send_message(getdata)
 
         # Give enough time for the node to answer. Since we cannot check for a
         # non-event this is the best we can do
         time.sleep(2)
         assert not proof_received(peer)
 
         self.log.info("The proof is known for long enough to be requested")
         current_time = int(time.time())
         node.setmocktime(current_time + UNCONDITIONAL_RELAY_DELAY)
 
         peer.send_message(getdata)
         wait_until(lambda: proof_received(peer))
 
         # Restart the node
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
         wait_for_proof_validation()
         # The only peer is the node itself
         assert_equal(len(node.getavalanchepeerinfo()), 1)
         assert_equal(node.getavalanchepeerinfo()[0]["proof"], proof)
 
         peer = get_ava_p2p_interface(node)
         peer_proofid = peer.send_avahello(
             interface_delegation_hex, delegated_key)
 
         wait_until(lambda: getdata_found(peer, peer_proofid))
         assert peer_proofid not in get_proof_ids(node)
 
         self.log.info(
             "Check that the peer gets added as an avalanche node as soon as the node knows about the proof")
         node.sendavalancheproof(interface_proof_hex)
 
         def has_node_count(count):
             peerinfo = node.getavalanchepeerinfo()
             return (len(peerinfo) == 2 and
                     peerinfo[-1]["proof"] == interface_proof_hex and
                     peerinfo[-1]["nodecount"] == count)
 
         wait_until(lambda: has_node_count(1))
 
         self.log.info(
             "Check that the peer gets added immediately if the proof is already known")
 
         # Connect another peer using the same proof
         peer_proof_known = get_ava_p2p_interface(node)
         peer_proof_known.send_avahello(interface_delegation_hex, delegated_key)
 
         wait_until(lambda: has_node_count(2))
 
         self.log.info("Invalidate the proof and check the nodes are removed")
         tip = node.getbestblockhash()
         # Invalidate the block with the proof utxo
         node.invalidateblock(blockhashes[1])
         # Change the address to make sure we don't generate a block identical
         # to the one we just invalidated. Can be generate(1) after D9694 or
         # D9697 is landed.
         forked_tip = node.generatetoaddress(1, ADDRESS_ECREG_UNSPENDABLE)[0]
         wait_until(lambda: node.getbestblockhash() == forked_tip)
 
         wait_until(lambda: len(node.getavalanchepeerinfo()) == 1)
         assert peer_proofid not in get_proof_ids(node)
 
         self.log.info("Reorg back and check the nodes are added back")
         node.invalidateblock(forked_tip)
         node.reconsiderblock(tip)
         wait_until(lambda: has_node_count(2), timeout=2)
 
 
 if __name__ == '__main__':
     AvalancheTest().main()
diff --git a/test/functional/abc_p2p_avalanche_voting.py b/test/functional/abc_p2p_avalanche_voting.py
index ec86d7eaf..0edf7af27 100755
--- a/test/functional/abc_p2p_avalanche_voting.py
+++ b/test/functional/abc_p2p_avalanche_voting.py
@@ -1,242 +1,243 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020-2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the resolution of forks via avalanche."""
 import random
 
 from test_framework.avatools import (
     get_ava_p2p_interface,
     create_coinbase_stakes,
 )
 from test_framework.key import (
     ECKey,
     ECPubKey,
 )
 from test_framework.messages import AvalancheVote
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     wait_until,
 )
+from test_framework.wallet_util import bytes_to_wif
 
 BLOCK_ACCEPTED = 0
 BLOCK_INVALID = 1
 BLOCK_PARKED = 2
 BLOCK_FORK = 3
 BLOCK_UNKNOWN = -1
 BLOCK_MISSING = -2
 BLOCK_PENDING = -3
 
 QUORUM_NODE_COUNT = 16
 
 
 class AvalancheTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [
             ['-enableavalanche=1', '-avacooldown=0'],
             ['-enableavalanche=1', '-avacooldown=0', '-noparkdeepreorg', '-maxreorgdepth=-1']]
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def run_test(self):
         node = self.nodes[0]
 
         # Build a fake quorum of nodes.
         def get_quorum():
             return [get_ava_p2p_interface(node)
                     for _ in range(0, QUORUM_NODE_COUNT)]
 
         # Pick on node from the quorum for polling.
         quorum = get_quorum()
         poll_node = quorum[0]
 
         # Generate many block and poll for them.
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(100, addrkey0.address)
         # Use the first coinbase to create a stake
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         fork_node = self.nodes[1]
         # Make sure the fork node has synced the blocks
         self.sync_blocks([node, fork_node])
 
         # Get the key so we can verify signatures.
         avakey = ECPubKey()
         avakey.set(bytes.fromhex(node.getavalanchekey()))
 
         self.log.info("Poll for the chain tip...")
         best_block_hash = int(node.getbestblockhash(), 16)
         poll_node.send_poll([best_block_hash])
 
         def assert_response(expected):
             response = poll_node.wait_for_avaresponse()
             r = response.response
             assert_equal(r.cooldown, 0)
 
             # Verify signature.
             assert avakey.verify_schnorr(response.sig, r.get_hash())
 
             votes = r.votes
             assert_equal(len(votes), len(expected))
             for i in range(0, len(votes)):
                 assert_equal(repr(votes[i]), repr(expected[i]))
 
         assert_response([AvalancheVote(BLOCK_ACCEPTED, best_block_hash)])
 
         self.log.info("Poll for a selection of blocks...")
         various_block_hashes = [
             int(node.getblockhash(0), 16),
             int(node.getblockhash(1), 16),
             int(node.getblockhash(10), 16),
             int(node.getblockhash(25), 16),
             int(node.getblockhash(42), 16),
             int(node.getblockhash(96), 16),
             int(node.getblockhash(99), 16),
             int(node.getblockhash(100), 16),
         ]
 
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(BLOCK_ACCEPTED, h)
                          for h in various_block_hashes])
 
         self.log.info(
             "Poll for a selection of blocks, but some are now invalid...")
         invalidated_block = node.getblockhash(76)
         node.invalidateblock(invalidated_block)
         # We need to send the coin to a new address in order to make sure we do
         # not regenerate the same block.
         node.generatetoaddress(
             26, 'ecregtest:pqv2r67sgz3qumufap3h2uuj0zfmnzuv8v38gtrh5v')
         node.reconsiderblock(invalidated_block)
 
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(BLOCK_ACCEPTED, h) for h in various_block_hashes[:5]] +
                         [AvalancheVote(BLOCK_FORK, h) for h in various_block_hashes[-3:]])
 
         self.log.info("Poll for unknown blocks...")
         various_block_hashes = [
             int(node.getblockhash(0), 16),
             int(node.getblockhash(25), 16),
             int(node.getblockhash(42), 16),
             various_block_hashes[5],
             various_block_hashes[6],
             various_block_hashes[7],
             random.randrange(1 << 255, (1 << 256) - 1),
             random.randrange(1 << 255, (1 << 256) - 1),
             random.randrange(1 << 255, (1 << 256) - 1),
         ]
         poll_node.send_poll(various_block_hashes)
         assert_response([AvalancheVote(BLOCK_ACCEPTED, h) for h in various_block_hashes[:3]] +
                         [AvalancheVote(BLOCK_FORK, h) for h in various_block_hashes[3:6]] +
                         [AvalancheVote(BLOCK_UNKNOWN, h) for h in various_block_hashes[-3:]])
 
         self.log.info("Trigger polling from the node...")
         # duplicate the deterministic sig test from src/test/key_tests.cpp
         privkey = ECKey()
         privkey.set(bytes.fromhex(
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
-        pubkey = privkey.get_pubkey()
 
         proof_sequence = 11
         proof_expiration = 12
         proof = node.buildavalancheproof(
-            proof_sequence, proof_expiration, pubkey.get_bytes().hex(),
+            proof_sequence, proof_expiration, bytes_to_wif(
+                privkey.get_bytes()),
             stakes)
 
         # Activate the quorum.
         for n in quorum:
             success = node.addavalanchenode(
-                n.nodeid, pubkey.get_bytes().hex(), proof)
+                n.nodeid, privkey.get_pubkey().get_bytes().hex(), proof)
             assert success is True
 
         def can_find_block_in_poll(hash, resp=BLOCK_ACCEPTED):
             found_hash = False
             for n in quorum:
                 poll = n.get_avapoll_if_available()
 
                 # That node has not received a poll
                 if poll is None:
                     continue
 
                 # We got a poll, check for the hash and repond
                 votes = []
                 for inv in poll.invs:
                     # Vote yes to everything
                     r = BLOCK_ACCEPTED
 
                     # Look for what we expect
                     if inv.hash == hash:
                         r = resp
                         found_hash = True
 
                     votes.append(AvalancheVote(r, inv.hash))
 
                 n.send_avaresponse(poll.round, votes, privkey)
 
             return found_hash
 
         # Now that we have a peer, we should start polling for the tip.
         hash_tip = int(node.getbestblockhash(), 16)
         wait_until(lambda: can_find_block_in_poll(hash_tip), timeout=5)
 
         # Make sure the fork node has synced the blocks
         self.sync_blocks([node, fork_node])
 
         # Create a fork 2 blocks deep. This should trigger polling.
         fork_node.invalidateblock(fork_node.getblockhash(100))
         fork_address = fork_node.get_deterministic_priv_key().address
         fork_node.generatetoaddress(2, fork_address)
 
         # Because the new tip is a deep reorg, the node will not accept it
         # right away, but poll for it.
         def parked_block(blockhash):
             for tip in node.getchaintips():
                 if tip["hash"] == blockhash:
                     assert tip["status"] != "active"
                     return tip["status"] == "parked"
             return False
 
         fork_tip = fork_node.getbestblockhash()
         wait_until(lambda: parked_block(fork_tip))
 
         self.log.info("Answer all polls to finalize...")
 
         hash_to_find = int(fork_tip, 16)
 
         def has_accepted_new_tip():
             can_find_block_in_poll(hash_to_find)
             return node.getbestblockhash() == fork_tip
 
         # Because everybody answers yes, the node will accept that block.
         wait_until(has_accepted_new_tip, timeout=15)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         self.log.info("Answer all polls to park...")
         node.generate(1)
 
         tip_to_park = node.getbestblockhash()
         hash_to_find = int(tip_to_park, 16)
         assert(tip_to_park != fork_tip)
 
         def has_parked_new_tip():
             can_find_block_in_poll(hash_to_find, BLOCK_PARKED)
             return node.getbestblockhash() == fork_tip
 
         # Because everybody answers no, the node will park that block.
         wait_until(has_parked_new_tip, timeout=15)
         assert_equal(node.getbestblockhash(), fork_tip)
 
         self.log.info(
             "Check the node is discouraging unexpected avaresponses.")
         with node.assert_debug_log(
                 ['Misbehaving', 'peer=1 (0 -> 2): unexpected-ava-response']):
             # unknown voting round
             poll_node.send_avaresponse(
                 round=2**32 - 1, votes=[], privkey=privkey)
 
 
 if __name__ == '__main__':
     AvalancheTest().main()
diff --git a/test/functional/abc_rpc_addavalanchenode.py b/test/functional/abc_rpc_addavalanchenode.py
index 8f0188bbc..6e1956c31 100644
--- a/test/functional/abc_rpc_addavalanchenode.py
+++ b/test/functional/abc_rpc_addavalanchenode.py
@@ -1,188 +1,190 @@
 #!/usr/bin/env python3
 # Copyright (c) 2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the addavalanchenode RPC"""
 
 from test_framework.avatools import create_coinbase_stakes
 from test_framework.key import ECKey
 from test_framework.messages import (
     AvalancheDelegation,
     AvalancheDelegationLevel,
     AvalancheProof,
     FromHex,
     hash256,
     ser_string,
 )
 from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_raises_rpc_error,
 )
+from test_framework.wallet_util import bytes_to_wif
 
 
 def add_interface_node(test_node) -> int:
     """Create a peer, connect it to test_node, return the nodeid of the peer as
     registered by test_node.
     """
     n = P2PInterface()
     test_node.add_p2p_connection(n)
     n.wait_for_verack()
     return test_node.getpeerinfo()[-1]['id']
 
 
 class AddAvalancheNodeTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1', '-avacooldown=0']]
 
     def run_test(self):
         node = self.nodes[0]
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(2, addrkey0.address)
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         privkey = ECKey()
         privkey.generate()
+        wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         proof_master = privkey.get_pubkey().get_bytes().hex()
         proof_sequence = 42
         proof_expiration = 2000000000
         proof = node.buildavalancheproof(
-            proof_sequence, proof_expiration, proof_master, stakes)
+            proof_sequence, proof_expiration, wif_privkey, stakes)
 
         nodeid = add_interface_node(node)
 
         def check_addavalanchenode_error(
                 error_code, error_message, nodeid=nodeid, proof=proof, pubkey=proof_master, delegation=None):
             assert_raises_rpc_error(
                 error_code,
                 error_message,
                 node.addavalanchenode,
                 nodeid,
                 pubkey,
                 proof,
                 delegation,
             )
 
         self.log.info("Invalid proof")
         check_addavalanchenode_error(-22,
                                      "Proof must be an hexadecimal string",
                                      proof="not a proof")
         check_addavalanchenode_error(-22,
                                      "Proof has invalid format",
                                      proof="f000")
         no_stake = node.buildavalancheproof(
-            proof_sequence, proof_expiration, proof_master, [])
+            proof_sequence, proof_expiration, wif_privkey, [])
         check_addavalanchenode_error(-8,
                                      "The proof is invalid: no-stake",
                                      proof=no_stake)
 
         self.log.info("Node doesn't exist")
         check_addavalanchenode_error(-8,
                                      f"The node does not exist: {nodeid + 1}",
                                      nodeid=nodeid + 1)
 
         self.log.info("Invalid delegation")
         dg_privkey = ECKey()
         dg_privkey.generate()
         dg_pubkey = dg_privkey.get_pubkey().get_bytes()
         check_addavalanchenode_error(-22,
                                      "Delegation must be an hexadecimal string",
                                      pubkey=dg_pubkey.hex(),
                                      delegation="not a delegation")
         check_addavalanchenode_error(-22,
                                      "Delegation has invalid format",
                                      pubkey=dg_pubkey.hex(),
                                      delegation="f000")
 
         self.log.info("Delegation mismatch with the proof")
         delegation_wrong_proofid = AvalancheDelegation()
         check_addavalanchenode_error(-8,
                                      "The delegation does not match the proof",
                                      pubkey=dg_pubkey.hex(),
                                      delegation=delegation_wrong_proofid.serialize().hex())
 
         proofobj = FromHex(AvalancheProof(), proof)
         delegation = AvalancheDelegation(
             limited_proofid=proofobj.limited_proofid,
             proof_master=proofobj.master,
         )
 
         self.log.info("Delegation with bad signature")
         bad_level = AvalancheDelegationLevel(
             pubkey=dg_pubkey,
         )
         delegation.levels.append(bad_level)
         check_addavalanchenode_error(-8,
                                      "The delegation is invalid",
                                      pubkey=dg_pubkey.hex(),
                                      delegation=delegation.serialize().hex())
 
         delegation.levels = []
         level = AvalancheDelegationLevel(
             pubkey=dg_pubkey,
             sig=privkey.sign_schnorr(
                 hash256(
                     delegation.getid() +
                     ser_string(dg_pubkey)
                 )
             )
         )
         delegation.levels.append(level)
 
         self.log.info("Key mismatch with the proof")
         check_addavalanchenode_error(
             -5,
             "The public key does not match the proof",
             pubkey=dg_pubkey.hex(),
         )
 
         self.log.info("Key mismatch with the delegation")
         random_privkey = ECKey()
         random_privkey.generate()
         random_pubkey = random_privkey.get_pubkey()
         check_addavalanchenode_error(
             -5,
             "The public key does not match the delegation",
             pubkey=random_pubkey.get_bytes().hex(),
             delegation=delegation.serialize().hex(),
         )
 
         self.log.info("Happy path")
         assert node.addavalanchenode(nodeid, proof_master, proof)
         # Adding several times is OK
         assert node.addavalanchenode(nodeid, proof_master, proof)
 
         # Use an hardcoded proof. This will help detecting proof format changes.
         # Generated using:
         # stakes = create_coinbase_stakes(node, [blockhashes[1]], addrkey0.key)
         # hardcoded_proof = node.buildavalancheproof(
         #    proof_sequence, proof_expiration, random_pubkey, stakes)
         hardcoded_pubkey = "037d20fcfe118296bb53f0a8f87c864e7b9831c4fcd7c6a0bb9a58e0e0f53d5cbc"
         hardcoded_proof = (
             "2a00000000000000009435770000000021037d20fcfe118296bb53f0a8f87c864e"
             "7b9831c4fcd7c6a0bb9a58e0e0f53d5cbc01683ef49024cf25bb55775b327f5e68"
             "c79da3a7824dc03df5623c96f4a60158f90000000000f902950000000095010000"
             "210227d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d"
             "3f612834ef0e2545d6359e9f34967c2bb69cb88fe246fed716d998f3f62eba1ef6"
             "6a547606a7ac14c1b5697f4acc20853b3f99954f4f7b6e9bf8a085616d3adfc7"
         )
         assert node.addavalanchenode(nodeid, hardcoded_pubkey, hardcoded_proof)
 
         self.log.info("Add a node with a valid delegation")
         assert node.addavalanchenode(
             nodeid,
             dg_pubkey.hex(),
             proof,
             delegation.serialize().hex(),
         )
 
         self.log.info("Several nodes can share a proof")
         nodeid2 = add_interface_node(node)
         assert node.addavalanchenode(nodeid2, proof_master, proof)
 
 
 if __name__ == '__main__':
     AddAvalancheNodeTest().main()
diff --git a/test/functional/abc_rpc_avalancheproof.py b/test/functional/abc_rpc_avalancheproof.py
index 97dd851a5..3c422f222 100644
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -1,480 +1,481 @@
 #!/usr/bin/env python3
 # Copyright (c) 2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test building avalanche proofs and using them to add avalanche peers."""
 import base64
 from decimal import Decimal
 
 from test_framework.address import ADDRESS_ECREG_UNSPENDABLE
 from test_framework.avatools import (
     create_coinbase_stakes,
     create_stakes,
     get_proof_ids,
     wait_for_proof,
 )
 from test_framework.key import ECKey
 from test_framework.messages import (
     AvalancheDelegation,
     AvalancheDelegationLevel,
     AvalancheProof,
     FromHex,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 from test_framework.util import (
     append_config,
     assert_equal,
     connect_nodes,
     wait_until,
     assert_raises_rpc_error,
 )
 from test_framework.wallet_util import bytes_to_wif
 
 AVALANCHE_MAX_PROOF_STAKES = 1000
 
 PROOF_DUST_THRESHOLD = 1000000.0
 """Minimum amount per UTXO in a proof (in coins, not in satoshis)"""
 
 
 def add_interface_node(test_node) -> str:
     """Create a mininode, connect it to test_node, return the nodeid
     of the mininode as registered by test_node.
     """
     n = P2PInterface()
     test_node.add_p2p_connection(n)
     n.wait_for_verack()
     return test_node.getpeerinfo()[-1]['id']
 
 
 class AvalancheProofTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [['-enableavalanche=1', '-avacooldown=0'],
                            ['-enableavalanche=1', '-avacooldown=0']]
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def run_test(self):
         # Turn off node 1 while node 0 mines blocks to generate stakes,
         # so that we can later try starting node 1 with an orphan proof.
         self.stop_node(1)
 
         node = self.nodes[0]
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(100, addrkey0.address)
 
         self.log.info(
             "Make build a valid proof and restart the node to use it")
         privkey = ECKey()
         privkey.set(bytes.fromhex(
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747"), True)
+        wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         def get_hex_pubkey(privkey):
             return privkey.get_pubkey().get_bytes().hex()
 
         proof_master = get_hex_pubkey(privkey)
         proof_sequence = 11
         proof_expiration = 12
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
         proof = node.buildavalancheproof(
-            proof_sequence, proof_expiration, proof_master, stakes)
+            proof_sequence, proof_expiration, wif_privkey, stakes)
 
         self.log.info("Test decodeavalancheproof RPC")
         proofobj = FromHex(AvalancheProof(), proof)
         decodedproof = node.decodeavalancheproof(proof)
         limited_id_hex = f"{proofobj.limited_proofid:0{64}x}"
         assert_equal(decodedproof["sequence"], proof_sequence)
         assert_equal(decodedproof["expiration"], proof_expiration)
         assert_equal(decodedproof["master"], proof_master)
         assert_equal(decodedproof["proofid"], f"{proofobj.proofid:0{64}x}")
         assert_equal(decodedproof["limitedid"], limited_id_hex)
         assert_equal(decodedproof["stakes"][0]["txid"], stakes[0]["txid"])
         assert_equal(decodedproof["stakes"][0]["vout"], stakes[0]["vout"])
         assert_equal(decodedproof["stakes"][0]["height"], stakes[0]["height"])
         assert_equal(
             decodedproof["stakes"][0]["iscoinbase"],
             stakes[0]["iscoinbase"])
         assert_equal(
             decodedproof["stakes"][0]["signature"],
             base64.b64encode(proofobj.stakes[0].sig).decode("ascii"))
 
         # Invalid hex (odd number of hex digits)
         assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
                                 node.decodeavalancheproof, proof[:-1])
         # Valid hex but invalid proof
         assert_raises_rpc_error(-22, "Proof has invalid format",
                                 node.decodeavalancheproof, proof[:-2])
 
         # Restart the node with this proof
         self.restart_node(0, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
 
         self.log.info("The proof is registered at first chaintip update")
         assert_equal(len(node.getavalanchepeerinfo()), 0)
         node.generate(1)
         wait_until(lambda: len(node.getavalanchepeerinfo()) == 1, timeout=5)
 
         # This case will occur for users building proofs with a third party
         # tool and then starting a new node that is not yet aware of the
         # transactions used for stakes.
         self.log.info("Start a node with an orphan proof")
 
         self.start_node(1, self.extra_args[0] + [
             "-avaproof={}".format(proof),
             "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
         ])
         # Mine a block to trigger an attempt at registering the proof
         self.nodes[1].generate(1)
         wait_for_proof(self.nodes[1], f"{proofobj.proofid:0{64}x}",
                        expect_orphan=True)
 
         self.log.info("Connect to an up-to-date node to unorphan the proof")
         connect_nodes(self.nodes[1], node)
         self.sync_all()
         wait_for_proof(self.nodes[1], f"{proofobj.proofid:0{64}x}",
                        expect_orphan=False)
 
         self.log.info("Generate delegations for the proof")
 
         # Stack up a few delegation levels
         def gen_privkey():
             pk = ECKey()
             pk.generate()
             return pk
 
         delegator_privkey = privkey
         delegation = None
         for _ in range(10):
             delegated_privkey = gen_privkey()
             delegation = node.delegateavalancheproof(
                 limited_id_hex,
                 bytes_to_wif(delegator_privkey.get_bytes()),
                 get_hex_pubkey(delegated_privkey),
                 delegation,
             )
             delegator_privkey = delegated_privkey
 
         random_privkey = gen_privkey()
         random_pubkey = get_hex_pubkey(random_privkey)
 
         # Invalid proof
         no_stake = node.buildavalancheproof(proof_sequence, proof_expiration,
-                                            proof_master, [])
+                                            wif_privkey, [])
 
         # Invalid privkey
         assert_raises_rpc_error(-5, "The private key is invalid",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(bytes(32)),
                                 random_pubkey,
                                 )
 
         # Invalid delegation
         bad_dg = AvalancheDelegation()
         assert_raises_rpc_error(-8, "The delegation does not match the proof",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 bad_dg.serialize().hex(),
                                 )
 
         # Still invalid, but with a matching proofid
         bad_dg.limited_proofid = proofobj.limited_proofid
         bad_dg.proof_master = proofobj.master
         bad_dg.levels = [AvalancheDelegationLevel()]
         assert_raises_rpc_error(-8, "The delegation is invalid",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 bad_dg.serialize().hex(),
                                 )
 
         # Wrong privkey, match the proof but does not match the delegation
         assert_raises_rpc_error(-5, "The private key does not match the delegation",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 delegation,
                                 )
 
         # Delegation not hex
         assert_raises_rpc_error(-22, "Delegation must be an hexadecimal string.",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 "f00",
                                 )
         # Delegation is hex but ill-formed
         assert_raises_rpc_error(-22, "Delegation has invalid format",
                                 node.delegateavalancheproof,
                                 limited_id_hex,
                                 bytes_to_wif(privkey.get_bytes()),
                                 random_pubkey,
                                 "dead",
                                 )
 
         # Test invalid proofs
         dust = node.buildavalancheproof(
-            proof_sequence, proof_expiration, proof_master,
+            proof_sequence, proof_expiration, wif_privkey,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key, amount="0"))
 
         dust_amount = Decimal(f"{PROOF_DUST_THRESHOLD * 0.9999:.4f}")
         dust2 = node.buildavalancheproof(
-            proof_sequence, proof_expiration, proof_master,
+            proof_sequence, proof_expiration, wif_privkey,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key,
                                    amount=str(dust_amount)))
 
         missing_stake = node.buildavalancheproof(
-            proof_sequence, proof_expiration, proof_master, [{
+            proof_sequence, proof_expiration, wif_privkey, [{
                 'txid': '0' * 64,
                 'vout': 0,
                 'amount': 10000000,
                 'height': 42,
                 'iscoinbase': False,
                 'privatekey': addrkey0.key,
             }]
         )
 
         duplicate_stake = ("0b000000000000000c0000000000000021030b4c866585dd868"
                            "a9d62348a9cd008d6a312937048fff31670e7e920cfc7a74402"
                            "05c5f72f5d6da3085583e75ee79340eb4eff208c89988e7ed0e"
                            "fb30b87298fa30000000000f2052a0100000003000000210227"
                            "d85ba011276cf25b51df6a188b75e604b38770a462b2d0e9fb2"
                            "fc839ef5d3f86076def2e8bc3c40671c1a0eb505da5857a950a"
                            "0cf4625a80018cdd75ac62e61273ff8142f747de67e73f6368c"
                            "8648942b0ef6c065d72a81ad7438a23c11cca05c5f72f5d6da3"
                            "085583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30"
                            "000000000f2052a0100000003000000210227d85ba011276cf2"
                            "5b51df6a188b75e604b38770a462b2d0e9fb2fc839ef5d3f860"
                            "76def2e8bc3c40671c1a0eb505da5857a950a0cf4625a80018c"
                            "dd75ac62e61273ff8142f747de67e73f6368c8648942b0ef6c0"
                            "65d72a81ad7438a23c11cca")
 
         bad_sig = ("0b000000000000000c0000000000000021030b4c866585dd868a9d62348"
                    "a9cd008d6a312937048fff31670e7e920cfc7a7440105c5f72f5d6da3085"
                    "583e75ee79340eb4eff208c89988e7ed0efb30b87298fa30000000000f20"
                    "52a0100000003000000210227d85ba011276cf25b51df6a188b75e604b3"
                    "8770a462b2d0e9fb2fc839ef5d3faf07f001dd38e9b4a43d07d5d449cc0"
                    "f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
                    "1321b91a79b82d1c2cfd47793261e4ba003cf5")
 
         wrong_order = ("c964aa6fde575e4ce8404581c7be874e21023beefdde700a6bc0203"
                        "6335b4df141c8bc67bb05a971f5ac2745fd683797dde30305d427b7"
                        "06705a5d4b6a368a231d6db62abacf8c29bc32b61e7f65a0a6976aa"
                        "8b86b687bc0260e821e4f0200b9d3bf6d2102449fb5237efe8f647d"
                        "32e8b64f06c22d1d40368eaca2a71ffc6a13ecc8bce68052365271b"
                        "6c71189f5cd7e3b694b77b579080f0b35bae567b96590ab6aa3019b"
                        "018ff9f061f52f1426bdb195d4b6d4dff5114cee90e33dabf0c588e"
                        "badf7774418f54247f6390791706af36fac782302479898b5273f9e"
                        "51a92cb1fb5af43deeb6c8c269403d30ffcb380300134398c42103e"
                        "49f9df52de2dea81cf7838b82521b69f2ea360f1c4eed9e6c89b7d0"
                        "f9e645efa08e97ea0c60e1f0a064fbf08989c084707082727e85dcb"
                        "9f79bb503f76ee6c8dad42a07ef15c89b3750a5631d604b21fafff0"
                        "f4de354ade95c2f28160ae549af0d4ce48c4ca9d0714b1fa5192027"
                        "0f8575e0af610f07b4e602a018ecdbb649b64fff614c0026e9fc8e0"
                        "030092533d422103aac52f4cfca700e7e9824298e0184755112e32f"
                        "359c832f5f6ad2ef62a2c024af812d6d7f2ecc6223a774e19bce1fb"
                        "20d94d6b01ea693638f55c74fdaa5358fa9239d03e4caf3d817e8f7"
                        "48ccad55a27b9d365db06ad5a0b779ac385f3dc8710")
 
         self.log.info(
             "Check the verifyavalancheproof and sendavalancheproof RPCs")
 
         if self.is_wallet_compiled():
             self.log.info(
                 "Check a proof with the maximum number of UTXO is valid")
             new_blocks = node.generate(AVALANCHE_MAX_PROOF_STAKES // 10 + 1)
             # confirm the coinbase UTXOs
             node.generate(101)
             too_many_stakes = create_stakes(
                 node, new_blocks, AVALANCHE_MAX_PROOF_STAKES + 1)
             maximum_stakes = too_many_stakes[:-1]
 
             good_proof = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
-                proof_master, maximum_stakes)
+                wif_privkey, maximum_stakes)
 
             too_many_utxos = node.buildavalancheproof(
                 proof_sequence, proof_expiration,
-                proof_master, too_many_stakes)
+                wif_privkey, too_many_stakes)
 
             assert node.verifyavalancheproof(good_proof)
 
         for rpc in [node.verifyavalancheproof, node.sendavalancheproof]:
             assert_raises_rpc_error(-22, "Proof must be an hexadecimal string",
                                     rpc, "f00")
             assert_raises_rpc_error(-22, "Proof has invalid format",
                                     rpc, "f00d")
 
             def check_rpc_failure(proof, message):
                 assert_raises_rpc_error(-8, "The proof is invalid: " + message,
                                         rpc, proof)
 
             check_rpc_failure(no_stake, "no-stake")
             check_rpc_failure(dust, "amount-below-dust-threshold")
             check_rpc_failure(duplicate_stake, "duplicated-stake")
             check_rpc_failure(missing_stake, "utxo-missing-or-spent")
             check_rpc_failure(bad_sig, "invalid-signature")
             check_rpc_failure(wrong_order, "wrong-stake-ordering")
             if self.is_wallet_compiled():
                 check_rpc_failure(too_many_utxos, "too-many-utxos")
 
         conflicting_utxo = node.buildavalancheproof(
-            proof_sequence + 1, proof_expiration, proof_master, stakes)
+            proof_sequence + 1, proof_expiration, wif_privkey, stakes)
         assert_raises_rpc_error(-8, "The proof has conflicting utxo with an existing proof",
                                     node.sendavalancheproof, conflicting_utxo)
 
         # Good proof
         assert node.verifyavalancheproof(proof)
 
         peer = node.add_p2p_connection(P2PInterface())
 
         proofid = FromHex(AvalancheProof(), proof).proofid
         node.sendavalancheproof(proof)
         assert proofid in get_proof_ids(node)
 
         def inv_found():
             with p2p_lock:
                 return peer.last_message.get(
                     "inv") and peer.last_message["inv"].inv[-1].hash == proofid
         wait_until(inv_found)
 
         self.log.info("Check the getrawproof RPC")
 
         raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
         assert_equal(raw_proof['proof'], proof)
         assert_equal(raw_proof['orphan'], False)
 
         assert_raises_rpc_error(-8, "Proof not found",
                                 node.getrawavalancheproof, '0' * 64)
 
         # Orphan the proof by sending the stake
         raw_tx = node.createrawtransaction(
             [{"txid": stakes[-1]["txid"], "vout": 0}],
             {ADDRESS_ECREG_UNSPENDABLE: stakes[-1]
                 ["amount"] - Decimal('10000')}
         )
         signed_tx = node.signrawtransactionwithkey(raw_tx, [addrkey0.key])
         node.sendrawtransaction(signed_tx["hex"])
         node.generate(1)
         wait_until(lambda: proofid not in get_proof_ids(node))
 
         raw_proof = node.getrawavalancheproof("{:064x}".format(proofid))
         assert_equal(raw_proof['proof'], proof)
         assert_equal(raw_proof['orphan'], True)
 
         self.log.info("Bad proof should be rejected at startup")
 
         self.stop_node(0)
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avasessionkey=0",
             ],
             expected_msg="Error: The avalanche session key is invalid.",
         )
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
             ],
             expected_msg="Error: The avalanche master key is missing for the avalanche proof.",
         )
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
                 "-avamasterkey=0",
             ],
             expected_msg="Error: The avalanche master key is invalid.",
         )
 
         def check_proof_init_error(proof, message):
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avaproof={}".format(proof),
                     "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
                 ],
                 expected_msg="Error: " + message,
             )
 
         check_proof_init_error(no_stake,
                                "The avalanche proof has no stake.")
         check_proof_init_error(dust,
                                "The avalanche proof stake is too low.")
         check_proof_init_error(dust2,
                                "The avalanche proof stake is too low.")
         check_proof_init_error(duplicate_stake,
                                "The avalanche proof has duplicated stake.")
         check_proof_init_error(bad_sig,
                                "The avalanche proof has invalid stake signatures.")
         if self.is_wallet_compiled():
             # The too many utxos case creates a proof which is that large that it
             # cannot fit on the command line
             append_config(node.datadir, ["avaproof={}".format(too_many_utxos)])
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avamasterkey=cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN",
                 ],
                 expected_msg="Error: The avalanche proof has too many utxos.",
                 match=ErrorMatch.PARTIAL_REGEX,
             )
 
         # Master private key mismatch
         random_privkey = ECKey()
         random_privkey.generate()
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(random_privkey.get_bytes())),
             ],
             expected_msg="Error: The master key does not match the proof public key.",
         )
 
         self.log.info("Bad delegation should be rejected at startup")
 
         def check_delegation_init_error(delegation, message):
             node.assert_start_raises_init_error(
                 self.extra_args[0] + [
                     "-avadelegation={}".format(delegation),
                     "-avaproof={}".format(proof),
                     "-avamasterkey={}".format(
                         bytes_to_wif(delegated_privkey.get_bytes())),
                 ],
                 expected_msg="Error: " + message,
             )
 
         check_delegation_init_error(
             AvalancheDelegation().serialize().hex(),
             "The delegation does not match the proof.")
 
         bad_level_sig = FromHex(AvalancheDelegation(), delegation)
         # Tweak some key to cause the signature to mismatch
         bad_level_sig.levels[-2].pubkey = bytes.fromhex(proof_master)
         check_delegation_init_error(bad_level_sig.serialize().hex(),
                                     "The avalanche delegation has invalid signatures.")
 
         node.assert_start_raises_init_error(
             self.extra_args[0] + [
                 "-avadelegation={}".format(delegation),
                 "-avaproof={}".format(proof),
                 "-avamasterkey={}".format(
                     bytes_to_wif(random_privkey.get_bytes())),
             ],
             expected_msg="Error: The master key does not match the delegation public key.",
         )
 
 
 if __name__ == '__main__':
     AvalancheProofTest().main()
diff --git a/test/functional/abc_rpc_buildavalancheproof.py b/test/functional/abc_rpc_buildavalancheproof.py
index c4f2f873b..ff8ab4f4d 100644
--- a/test/functional/abc_rpc_buildavalancheproof.py
+++ b/test/functional/abc_rpc_buildavalancheproof.py
@@ -1,96 +1,101 @@
 #!/usr/bin/env python3
 # Copyright (c) 2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the buildavalancheproof RPC"""
 
 from test_framework.avatools import create_coinbase_stakes
 from test_framework.key import ECKey
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_raises_rpc_error,
 )
+from test_framework.wallet_util import bytes_to_wif
 
 
 class BuildAvalancheProofTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1', '-avacooldown=0']]
 
     def run_test(self):
         node = self.nodes[0]
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(2, addrkey0.address)
         stakes = create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key)
 
         privkey = ECKey()
         privkey.generate()
-
-        proof_master = privkey.get_pubkey().get_bytes().hex()
+        wif_privkey = bytes_to_wif(privkey.get_bytes())
 
         def check_buildavalancheproof_error(
-                error_code, error_message, stakes):
+                error_code, error_message, stakes, master_key=wif_privkey):
             assert_raises_rpc_error(
                 error_code,
                 error_message,
                 node.buildavalancheproof,
                 # Sequence
                 0,
                 # Expiration
                 0,
-                # Master
-                proof_master,
+                master_key,
                 stakes,
             )
 
         good_stake = stakes[0]
 
         self.log.info("Error cases")
 
+        check_buildavalancheproof_error(-8,
+                                        "Invalid master key",
+                                        [good_stake],
+                                        master_key=bytes_to_wif(b'f00')
+                                        )
+
         negative_vout = good_stake.copy()
         negative_vout['vout'] = -1
         check_buildavalancheproof_error(-22,
                                         "vout must be positive",
                                         [negative_vout],
                                         )
 
         zero_height = good_stake.copy()
         zero_height['height'] = 0
         check_buildavalancheproof_error(-22,
                                         "height must be positive",
                                         [zero_height],
                                         )
         negative_height = good_stake.copy()
         negative_height['height'] = -1
         check_buildavalancheproof_error(-22,
                                         "height must be positive",
                                         [negative_height],
                                         )
 
         missing_amount = good_stake.copy()
         del missing_amount['amount']
         check_buildavalancheproof_error(-8,
                                         "Missing amount",
                                         [missing_amount],
                                         )
 
         invalid_privkey = good_stake.copy()
         invalid_privkey['privatekey'] = 'foobar'
         check_buildavalancheproof_error(-8,
                                         "Invalid private key",
                                         [invalid_privkey],
                                         )
 
         duplicate_stake = [good_stake] * 2
         check_buildavalancheproof_error(-8,
                                         "Duplicated stake",
                                         duplicate_stake,
                                         )
 
         self.log.info("Happy path")
-        assert node.buildavalancheproof(0, 0, proof_master, [good_stake])
+        assert node.buildavalancheproof(0, 0, wif_privkey, [good_stake])
 
 
 if __name__ == '__main__':
     BuildAvalancheProofTest().main()
diff --git a/test/functional/abc_rpc_getavalanchepeerinfo.py b/test/functional/abc_rpc_getavalanchepeerinfo.py
index 59e51de8f..2fd386ac7 100755
--- a/test/functional/abc_rpc_getavalanchepeerinfo.py
+++ b/test/functional/abc_rpc_getavalanchepeerinfo.py
@@ -1,70 +1,72 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020-2021 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the getavalanchepeerinfo RPC."""
 from test_framework.avatools import (
     get_ava_p2p_interface,
     create_coinbase_stakes,
 )
 from test_framework.key import ECKey
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
+from test_framework.wallet_util import bytes_to_wif
 
 
 class GetAvalanchePeerInfoTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [['-enableavalanche=1', '-avacooldown=0']]
 
     def run_test(self):
         node = self.nodes[0]
         peercount = 5
         nodecount = 10
 
         self.log.info(
             f"Generating {peercount} peers with {nodecount} nodes each")
 
         addrkey0 = node.get_deterministic_priv_key()
         blockhashes = node.generatetoaddress(peercount, addrkey0.address)
         # Use the first coinbase to create a stake
         stakes = create_coinbase_stakes(node, blockhashes, addrkey0.key)
 
         def getProof(stake):
             privkey = ECKey()
             privkey.generate()
             pubkey = privkey.get_pubkey()
 
             proof_sequence = 11
             proof_expiration = 12
             proof = node.buildavalancheproof(
-                proof_sequence, proof_expiration, pubkey.get_bytes().hex(),
+                proof_sequence, proof_expiration, bytes_to_wif(
+                    privkey.get_bytes()),
                 [stake])
             return (pubkey.get_bytes().hex(), proof)
 
         # Create peercount * nodecount node array
         nodes = [[get_ava_p2p_interface(node) for n in range(
             nodecount)] for p in range(peercount)]
 
         # Add peercount peers and bind all the nodes to each
         proofs = []
         for i in range(peercount):
             pubkey_hex, proof = getProof(stakes[i])
             proofs.append(proof)
             [node.addavalanchenode(n.nodeid, pubkey_hex, proof)
              for n in nodes[i]]
 
         self.log.info("Testing getavalanchepeerinfo...")
         avapeerinfo = node.getavalanchepeerinfo()
 
         assert_equal(len(avapeerinfo), peercount)
         for i, peer in enumerate(avapeerinfo):
             assert_equal(peer["peerid"], i)
             assert_equal(peer["proof"], proofs[i])
             assert_equal(peer["nodecount"], nodecount)
             assert_equal(set(peer["nodes"]), set([n.nodeid for n in nodes[i]]))
 
 
 if __name__ == '__main__':
     GetAvalanchePeerInfoTest().main()
diff --git a/test/functional/p2p_eviction.py b/test/functional/p2p_eviction.py
index 50880f464..7ad131d6a 100755
--- a/test/functional/p2p_eviction.py
+++ b/test/functional/p2p_eviction.py
@@ -1,210 +1,211 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 """ Test node eviction logic
 
 When the number of peers has reached the limit of maximum connections,
 the next connecting inbound peer will trigger the eviction mechanism.
 We cannot currently test the parts of the eviction logic that are based on
 address/netgroup since in the current framework, all peers are connecting from
 the same local address. See Issue #14210 for more info.
 Therefore, this test is limited to the remaining protection criteria.
 """
 
 import time
 
 from test_framework.avatools import AvaP2PInterface, create_coinbase_stakes
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.key import ECKey
 from test_framework.messages import (
     AvalancheProof,
     CTransaction,
     FromHex,
     msg_avaproof,
     msg_pong,
     msg_tx,
 )
 from test_framework.p2p import P2PDataStore, P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, wait_until
 from test_framework.wallet_util import bytes_to_wif
 
 
 class SlowP2PDataStore(P2PDataStore):
     def on_ping(self, message):
         time.sleep(0.1)
         self.send_message(msg_pong(message.nonce))
 
 
 class SlowP2PInterface(P2PInterface):
     def on_ping(self, message):
         time.sleep(0.1)
         self.send_message(msg_pong(message.nonce))
 
 
 class SlowAvaP2PInterface(AvaP2PInterface):
     def on_ping(self, message):
         time.sleep(0.1)
         self.send_message(msg_pong(message.nonce))
 
 
 class P2PEvict(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         # The choice of maxconnections=164 results in a maximum of 153 inbound
         # connections (164 - 10 outbound - 1 feeler). 152 inbound peers are
         # protected from eviction:
         # 4 by netgroup, 4 that sent us blocks, 4 that sent us proofs, 4 that
         # sent us transactions, 8 via lowest ping time, 128 with the best
         # avalanche availability score
         self.extra_args = [['-maxconnections=164', "-enableavalanche=1"]]
 
     def run_test(self):
         # peers that we expect to be protected from eviction
         protected_peers = set()
         current_peer = -1
         node = self.nodes[0]
         blocks = node.generatetoaddress(
             101, node.get_deterministic_priv_key().address)
 
         self.log.info(
             "Create 4 peers and protect them from eviction by sending us a block")
         for _ in range(4):
             block_peer = node.add_p2p_connection(SlowP2PDataStore())
             current_peer += 1
             block_peer.sync_with_ping()
             best_block = node.getbestblockhash()
             tip = int(best_block, 16)
             best_block_time = node.getblock(best_block)['time']
             block = create_block(
                 tip,
                 create_coinbase(
                     node.getblockcount() + 1),
                 best_block_time + 1)
             block.solve()
             block_peer.send_blocks_and_test([block], node, success=True)
             protected_peers.add(current_peer)
 
         self.log.info(
             "Create 4 peers and protect them from eviction by sending us a proof")
         privkey = ECKey()
         privkey.generate()
+        wif_privkey = bytes_to_wif(privkey.get_bytes())
         pubkey = privkey.get_pubkey()
 
         stakes = create_coinbase_stakes(
             node, blocks, node.get_deterministic_priv_key().key)
 
         for i in range(4):
             proof_peer = node.add_p2p_connection(SlowP2PDataStore())
             current_peer += 1
             proof_peer.sync_with_ping()
 
             proof = node.buildavalancheproof(
-                42, 2000000000, pubkey.get_bytes().hex(), [stakes[i]])
+                42, 2000000000, wif_privkey, [stakes[i]])
 
             avaproof_msg = msg_avaproof()
             avaproof_msg.proof = FromHex(AvalancheProof(), proof)
             proof_peer.send_message(avaproof_msg)
             protected_peers.add(current_peer)
 
         self.log.info(
             "Create 5 slow-pinging peers, making them eviction candidates")
         for _ in range(5):
             node.add_p2p_connection(SlowP2PInterface())
             current_peer += 1
 
         self.log.info(
             "Create 4 peers and protect them from eviction by sending us a tx")
         for i in range(4):
             txpeer = node.add_p2p_connection(SlowP2PInterface())
             current_peer += 1
             txpeer.sync_with_ping()
 
             prevtx = node.getblock(node.getblockhash(i + 1), 2)['tx'][0]
             rawtx = node.createrawtransaction(
                 inputs=[{'txid': prevtx['txid'], 'vout': 0}],
                 outputs=[
                     {node.get_deterministic_priv_key().address: 50000000 - 1250.00}],
             )
             sigtx = node.signrawtransactionwithkey(
                 hexstring=rawtx,
                 privkeys=[node.get_deterministic_priv_key().key],
                 prevtxs=[{
                     'txid': prevtx['txid'],
                     'vout': 0,
                     'amount': prevtx['vout'][0]['value'],
                     'scriptPubKey': prevtx['vout'][0]['scriptPubKey']['hex'],
                 }],
             )['hex']
             txpeer.send_message(msg_tx(FromHex(CTransaction(), sigtx)))
             protected_peers.add(current_peer)
 
         self.log.info(
             "Create 8 peers and protect them from eviction by having faster pings")
         for _ in range(8):
             fastpeer = node.add_p2p_connection(P2PInterface())
             current_peer += 1
             wait_until(lambda: "ping" in fastpeer.last_message, timeout=10)
 
         self.log.info(
             "Create 128 peers and protect them from eviction by sending an avahello message")
 
         proof = node.buildavalancheproof(
-            42, 2000000000, pubkey.get_bytes().hex(), [stakes[0]])
+            42, 2000000000, wif_privkey, [stakes[0]])
         proof_obj = FromHex(AvalancheProof(), proof)
         delegation = node.delegateavalancheproof(
             f"{proof_obj.limited_proofid:064x}",
             bytes_to_wif(privkey.get_bytes()),
             pubkey.get_bytes().hex(),
         )
 
         for _ in range(128):
             avapeer = node.add_p2p_connection(SlowAvaP2PInterface())
             current_peer += 1
             avapeer.sync_with_ping()
             avapeer.send_avahello(delegation, privkey)
 
         # Make sure by asking the node what the actual min pings are
         peerinfo = node.getpeerinfo()
         pings = {}
         for i in range(len(peerinfo)):
             pings[i] = peerinfo[i]['minping'] if 'minping' in peerinfo[i] else 1000000
         sorted_pings = sorted(pings.items(), key=lambda x: x[1])
 
         # Usually the 8 fast peers are protected. In rare case of unreliable pings,
         # one of the slower peers might have a faster min ping though.
         for i in range(8):
             protected_peers.add(sorted_pings[i][0])
 
         self.log.info("Create peer that triggers the eviction mechanism")
         node.add_p2p_connection(SlowP2PInterface())
 
         # One of the non-protected peers must be evicted. We can't be sure which one because
         # 4 peers are protected via netgroup, which is identical for all peers,
         # and the eviction mechanism doesn't preserve the order of identical
         # elements.
         evicted_peers = []
         for i in range(len(node.p2ps)):
             if not node.p2ps[i].is_connected:
                 evicted_peers.append(i)
 
         self.log.info("Test that one peer was evicted")
         self.log.debug(
             "{} evicted peer: {}".format(
                 len(evicted_peers),
                 set(evicted_peers)))
         assert_equal(len(evicted_peers), 1)
 
         self.log.info("Test that no peer expected to be protected was evicted")
         self.log.debug(
             "{} protected peers: {}".format(
                 len(protected_peers),
                 protected_peers))
         assert evicted_peers[0] not in protected_peers
 
 
 if __name__ == '__main__':
     P2PEvict().main()
diff --git a/test/functional/rpc_net.py b/test/functional/rpc_net.py
index 0a1725b32..66cc012fb 100755
--- a/test/functional/rpc_net.py
+++ b/test/functional/rpc_net.py
@@ -1,266 +1,267 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test RPC calls related to net.
 
 Tests correspond to code in rpc/net.cpp.
 """
 
 from decimal import Decimal
 from itertools import product
 import time
 
 from test_framework.avatools import create_coinbase_stakes
 from test_framework.key import ECKey
 from test_framework.p2p import P2PInterface
 import test_framework.messages
 from test_framework.messages import NODE_NETWORK
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_approx,
     assert_equal,
     assert_greater_than_or_equal,
     assert_greater_than,
     assert_raises_rpc_error,
     connect_nodes,
     p2p_port,
     wait_until,
 )
+from test_framework.wallet_util import bytes_to_wif
 
 
 def assert_net_servicesnames(servicesflag, servicenames):
     """Utility that checks if all flags are correctly decoded in
     `getpeerinfo` and `getnetworkinfo`.
 
     :param servicesflag: The services as an integer.
     :param servicenames: The list of decoded services names, as strings.
     """
     servicesflag_generated = 0
     for servicename in servicenames:
         servicesflag_generated |= getattr(
             test_framework.messages, 'NODE_' + servicename)
     assert servicesflag_generated == servicesflag
 
 
 class NetTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [["-enableavalanche=1", "-minrelaytxfee=10"],
                            ["-enableavalanche=1", "-minrelaytxfee=5"]]
         self.supports_cli = False
 
     def run_test(self):
         # Get out of IBD for the minfeefilter and getpeerinfo tests.
         self.nodes[0].generate(101)
         # Connect nodes both ways.
         connect_nodes(self.nodes[0], self.nodes[1])
         connect_nodes(self.nodes[1], self.nodes[0])
         self.sync_all()
 
         self.test_connection_count()
         self.test_getpeerinfo()
         self.test_getnettotals()
         self.test_getnetworkinfo()
         self.test_getaddednodeinfo()
         self.test_service_flags()
         self.test_getnodeaddresses()
 
     def test_connection_count(self):
         self.log.info("Test getconnectioncount")
         # After using `connect_nodes` to connect nodes 0 and 1 to each other.
         assert_equal(self.nodes[0].getconnectioncount(), 2)
 
     def test_getnettotals(self):
         self.log.info("Test getnettotals")
         # getnettotals totalbytesrecv and totalbytessent should be
         # consistent with getpeerinfo. Since the RPC calls are not atomic,
         # and messages might have been recvd or sent between RPC calls, call
         # getnettotals before and after and verify that the returned values
         # from getpeerinfo are bounded by those values.
         net_totals_before = self.nodes[0].getnettotals()
         peer_info = self.nodes[0].getpeerinfo()
         net_totals_after = self.nodes[0].getnettotals()
         assert_equal(len(peer_info), 2)
         peers_recv = sum([peer['bytesrecv'] for peer in peer_info])
         peers_sent = sum([peer['bytessent'] for peer in peer_info])
 
         assert_greater_than_or_equal(
             peers_recv, net_totals_before['totalbytesrecv'])
         assert_greater_than_or_equal(
             net_totals_after['totalbytesrecv'], peers_recv)
         assert_greater_than_or_equal(
             peers_sent, net_totals_before['totalbytessent'])
         assert_greater_than_or_equal(
             net_totals_after['totalbytessent'], peers_sent)
 
         # test getnettotals and getpeerinfo by doing a ping
         # the bytes sent/received should change
         # note ping and pong are 32 bytes each
         self.nodes[0].ping()
         wait_until(lambda: (self.nodes[0].getnettotals()[
                    'totalbytessent'] >= net_totals_after['totalbytessent'] + 32 * 2), timeout=1)
         wait_until(lambda: (self.nodes[0].getnettotals()[
                    'totalbytesrecv'] >= net_totals_after['totalbytesrecv'] + 32 * 2), timeout=1)
 
         peer_info_after_ping = self.nodes[0].getpeerinfo()
         for before, after in zip(peer_info, peer_info_after_ping):
             assert_greater_than_or_equal(
                 after['bytesrecv_per_msg'].get(
                     'pong', 0), before['bytesrecv_per_msg'].get(
                     'pong', 0) + 32)
             assert_greater_than_or_equal(
                 after['bytessent_per_msg'].get(
                     'ping', 0), before['bytessent_per_msg'].get(
                     'ping', 0) + 32)
 
     def test_getnetworkinfo(self):
         self.log.info("Test getnetworkinfo")
         assert_equal(self.nodes[0].getnetworkinfo()['networkactive'], True)
         assert_equal(self.nodes[0].getnetworkinfo()['connections'], 2)
 
         with self.nodes[0].assert_debug_log(expected_msgs=['SetNetworkActive: false\n']):
             self.nodes[0].setnetworkactive(state=False)
         assert_equal(self.nodes[0].getnetworkinfo()['networkactive'], False)
         # Wait a bit for all sockets to close
         wait_until(lambda: self.nodes[0].getnetworkinfo()[
                    'connections'] == 0, timeout=3)
 
         with self.nodes[0].assert_debug_log(expected_msgs=['SetNetworkActive: true\n']):
             self.nodes[0].setnetworkactive(state=True)
         # Connect nodes both ways.
         connect_nodes(self.nodes[0], self.nodes[1])
         connect_nodes(self.nodes[1], self.nodes[0])
 
         assert_equal(self.nodes[0].getnetworkinfo()['networkactive'], True)
         assert_equal(self.nodes[0].getnetworkinfo()['connections'], 2)
 
         # check the `servicesnames` field
         network_info = [node.getnetworkinfo() for node in self.nodes]
         for info in network_info:
             assert_net_servicesnames(int(info["localservices"], 0x10),
                                      info["localservicesnames"])
 
     def test_getaddednodeinfo(self):
         self.log.info("Test getaddednodeinfo")
         assert_equal(self.nodes[0].getaddednodeinfo(), [])
         # add a node (node2) to node0
         ip_port = "127.0.0.1:{}".format(p2p_port(2))
         self.nodes[0].addnode(node=ip_port, command='add')
         # check that the node has indeed been added
         added_nodes = self.nodes[0].getaddednodeinfo(ip_port)
         assert_equal(len(added_nodes), 1)
         assert_equal(added_nodes[0]['addednode'], ip_port)
         # check that node cannot be added again
         assert_raises_rpc_error(-23,
                                 "Node already added",
                                 self.nodes[0].addnode,
                                 node=ip_port,
                                 command='add')
         # check that node can be removed
         self.nodes[0].addnode(node=ip_port, command='remove')
         assert_equal(self.nodes[0].getaddednodeinfo(), [])
         # check that trying to remove the node again returns an error
         assert_raises_rpc_error(-24,
                                 "Node could not be removed",
                                 self.nodes[0].addnode,
                                 node=ip_port,
                                 command='remove')
         # check that a non-existent node returns an error
         assert_raises_rpc_error(-24, "Node has not been added",
                                 self.nodes[0].getaddednodeinfo, '1.1.1.1')
 
     def test_getpeerinfo(self):
         self.log.info("Test getpeerinfo")
         # Create a few getpeerinfo last_block/last_transaction/last_proof
         # values.
         if self.is_wallet_compiled():
             self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1000000)
         tip = self.nodes[1].generate(1)[0]
         self.sync_all()
 
         stake = create_coinbase_stakes(
             self.nodes[1], [tip], self.nodes[1].get_deterministic_priv_key().key)
         privkey = ECKey()
         privkey.generate()
         proof = self.nodes[1].buildavalancheproof(
-            42, 2000000000, privkey.get_pubkey().get_bytes().hex(), stake)
+            42, 2000000000, bytes_to_wif(privkey.get_bytes()), stake)
         self.nodes[1].sendavalancheproof(proof)
         self.sync_proofs()
 
         time_now = int(time.time())
         peer_info = [x.getpeerinfo() for x in self.nodes]
         # Verify last_block, last_transaction and last_proof keys/values.
         for node, peer, field in product(range(self.num_nodes), range(2), [
                                          'last_block', 'last_transaction', 'last_proof']):
             assert field in peer_info[node][peer].keys()
             if peer_info[node][peer][field] != 0:
                 assert_approx(peer_info[node][peer][field], time_now, vspan=60)
         # check both sides of bidirectional connection between nodes
         # the address bound to on one side will be the source address for the
         # other node
         assert_equal(peer_info[0][0]['addrbind'], peer_info[1][0]['addr'])
         assert_equal(peer_info[1][0]['addrbind'], peer_info[0][0]['addr'])
         assert_equal(peer_info[0][0]['minfeefilter'], Decimal("5.00"))
         assert_equal(peer_info[1][0]['minfeefilter'], Decimal("10.00"))
         # check the `servicesnames` field
         for info in peer_info:
             assert_net_servicesnames(int(info[0]["services"], 0x10),
                                      info[0]["servicesnames"])
 
     def test_service_flags(self):
         self.log.info("Test service flags")
         self.nodes[0].add_p2p_connection(
             P2PInterface(), services=(
                 1 << 5) | (
                 1 << 63))
         assert_equal(['UNKNOWN[2^5]', 'UNKNOWN[2^63]'],
                      self.nodes[0].getpeerinfo()[-1]['servicesnames'])
         self.nodes[0].disconnect_p2ps()
 
     def test_getnodeaddresses(self):
         self.log.info("Test getnodeaddresses")
         self.nodes[0].add_p2p_connection(P2PInterface())
 
         # Add some addresses to the Address Manager over RPC. Due to the way
         # bucket and bucket position are calculated, some of these addresses
         # will collide.
         imported_addrs = []
         for i in range(10000):
             first_octet = i >> 8
             second_octet = i % 256
             a = "{}.{}.1.1".format(first_octet, second_octet)
             imported_addrs.append(a)
             self.nodes[0].addpeeraddress(a, 8333)
 
         # Obtain addresses via rpc call and check they were ones sent in before.
         #
         # Maximum possible addresses in addrman is 10000, although actual
         # number will usually be less due to bucket and bucket position
         # collisions.
         node_addresses = self.nodes[0].getnodeaddresses(0)
         assert_greater_than(len(node_addresses), 5000)
         assert_greater_than(10000, len(node_addresses))
         for a in node_addresses:
             assert_greater_than(a["time"], 1527811200)  # 1st June 2018
             assert_equal(a["services"], NODE_NETWORK)
             assert a["address"] in imported_addrs
             assert_equal(a["port"], 8333)
 
         node_addresses = self.nodes[0].getnodeaddresses(1)
         assert_equal(len(node_addresses), 1)
 
         assert_raises_rpc_error(-8, "Address count out of range",
                                 self.nodes[0].getnodeaddresses, -1)
 
         # addrman's size cannot be known reliably after insertion, as hash collisions may occur
         # so only test that requesting a large number of addresses returns less
         # than that
         LARGE_REQUEST_COUNT = 10000
         node_addresses = self.nodes[0].getnodeaddresses(LARGE_REQUEST_COUNT)
         assert_greater_than(LARGE_REQUEST_COUNT, len(node_addresses))
 
 
 if __name__ == '__main__':
     NetTest().main()