diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
index 39be43ab9..b1d84f280 100644
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -1,459 +1,459 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <avalanche/peermanager.h>
 
 #include <avalanche/delegation.h>
 #include <avalanche/validation.h>
 #include <random.h>
 #include <validation.h> // For ChainstateActive()
 
 #include <cassert>
 
 namespace avalanche {
 
 bool PeerManager::addNode(NodeId nodeid, const Proof &proof,
                           const Delegation &delegation) {
     auto it = fetchOrCreatePeer(proof);
     if (it == peers.end()) {
         return false;
     }
 
     const PeerId peerid = it->peerid;
 
     DelegationState state;
     CPubKey pubkey;
     if (!delegation.verify(state, pubkey)) {
         return false;
     }
 
     auto nit = nodes.find(nodeid);
     if (nit == nodes.end()) {
         if (!nodes.emplace(nodeid, peerid, std::move(pubkey)).second) {
             return false;
         }
     } else {
         const PeerId oldpeerid = nit->peerid;
         if (!nodes.modify(nit, [&](Node &n) {
                 n.peerid = peerid;
                 n.pubkey = std::move(pubkey);
             })) {
             return false;
         }
 
         // We actually have this node already, we need to update it.
         bool success = removeNodeFromPeer(peers.find(oldpeerid));
         assert(success);
 
         // Make sure it is not invalidated.
         it = peers.find(peerid);
     }
 
     bool success = addNodeToPeer(it);
     assert(success);
 
     return true;
 }
 
 bool PeerManager::addNodeToPeer(const PeerSet::iterator &it) {
     assert(it != peers.end());
     return peers.modify(it, [&](Peer &p) {
         if (p.node_count++ > 0) {
             // We are done.
             return;
         }
 
         // We ned to allocate this peer.
         p.index = uint32_t(slots.size());
         const uint32_t score = p.getScore();
         const uint64_t start = slotCount;
         slots.emplace_back(start, score, it->peerid);
         slotCount = start + score;
     });
 }
 
 bool PeerManager::removeNode(NodeId nodeid) {
     auto it = nodes.find(nodeid);
     if (it == nodes.end()) {
         return false;
     }
 
     const PeerId peerid = it->peerid;
     nodes.erase(it);
 
     // Keep the track of the reference count.
     bool success = removeNodeFromPeer(peers.find(peerid));
     assert(success);
 
     return true;
 }
 
 bool PeerManager::removeNodeFromPeer(const PeerSet::iterator &it,
                                      uint32_t count) {
     assert(it != peers.end());
     assert(count <= it->node_count);
     if (count == 0) {
         // This is a NOOP.
         return false;
     }
 
     const uint32_t new_count = it->node_count - count;
     if (!peers.modify(it, [&](Peer &p) { p.node_count = new_count; })) {
         return false;
     }
 
     if (new_count > 0) {
         // We are done.
         return true;
     }
 
     // There are no more node left, we need to cleanup.
     const size_t i = it->index;
     assert(i < slots.size());
     if (i + 1 == slots.size()) {
         slots.pop_back();
         slotCount = slots.empty() ? 0 : slots.back().getStop();
     } else {
         fragmentation += slots[i].getScore();
         slots[i] = slots[i].withPeerId(NO_PEER);
     }
 
     return true;
 }
 
 bool PeerManager::forNode(NodeId nodeid,
                           std::function<bool(const Node &n)> func) const {
     auto it = nodes.find(nodeid);
     return it != nodes.end() && func(*it);
 }
 
 bool PeerManager::updateNextRequestTime(NodeId nodeid, TimePoint timeout) {
     auto it = nodes.find(nodeid);
     if (it == nodes.end()) {
         return false;
     }
 
     return nodes.modify(it, [&](Node &n) { n.nextRequestTime = timeout; });
 }
 
 NodeId PeerManager::selectNode() {
     for (int retry = 0; retry < SELECT_NODE_MAX_RETRY; retry++) {
         const PeerId p = selectPeer();
 
         // If we cannot find a peer, it may be due to the fact that it is
         // unlikely due to high fragmentation, so compact and retry.
         if (p == NO_PEER) {
             compact();
             continue;
         }
 
         // See if that peer has an available node.
         auto &nview = nodes.get<next_request_time>();
         auto it = nview.lower_bound(boost::make_tuple(p, TimePoint()));
         if (it != nview.end() && it->peerid == p &&
             it->nextRequestTime <= std::chrono::steady_clock::now()) {
             return it->nodeid;
         }
     }
 
     return NO_NODE;
 }
 
 void PeerManager::updatedBlockTip() {
     std::vector<PeerId> invalidPeers;
 
     {
         LOCK(cs_main);
 
         const CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
         for (const auto &p : peers) {
             ProofValidationState state;
-            if (!p.proof.verify(state, coins)) {
+            if (!p.proof->verify(state, coins)) {
                 invalidPeers.push_back(p.peerid);
             }
         }
     }
 
     for (const auto &pid : invalidPeers) {
         removePeer(pid);
     }
 }
 
 PeerId PeerManager::getPeerId(const Proof &proof) {
     auto it = fetchOrCreatePeer(proof);
     return it == peers.end() ? NO_PEER : it->peerid;
 }
 
 PeerManager::PeerSet::iterator
 PeerManager::fetchOrCreatePeer(const Proof &proof) {
     {
         // Check if we already know of that peer.
         auto &pview = peers.get<proof_index>();
         auto it = pview.find(proof.getId());
         if (it != pview.end()) {
             return peers.project<0>(it);
         }
     }
 
     {
         // Reject invalid proof.
         LOCK(cs_main);
         const CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
 
         ProofValidationState state;
         if (!proof.verify(state, coins)) {
             return peers.end();
         }
     }
 
     // New peer means new peerid!
     const PeerId peerid = nextPeerId++;
 
     // Attach UTXOs to this proof.
     std::unordered_set<PeerId> conflicting_peerids;
     for (const auto &s : proof.getStakes()) {
         auto p = utxos.emplace(s.getStake().getUTXO(), peerid);
         if (!p.second) {
             // We have a collision with an existing proof.
             conflicting_peerids.insert(p.first->second);
         }
     }
 
     // For now, if there is a conflict, just ceanup the mess.
     if (conflicting_peerids.size() > 0) {
         for (const auto &s : proof.getStakes()) {
             auto it = utxos.find(s.getStake().getUTXO());
             assert(it != utxos.end());
 
             // We need to delete that one.
             if (it->second == peerid) {
                 utxos.erase(it);
             }
         }
 
         return peers.end();
     }
 
     // We have no peer for this proof, time to create it.
     auto inserted = peers.emplace(peerid, proof);
     assert(inserted.second);
 
     return inserted.first;
 }
 
 bool PeerManager::removePeer(const PeerId peerid) {
     auto it = peers.find(peerid);
     if (it == peers.end()) {
         return false;
     }
 
     // Remove all nodes from this peer.
     removeNodeFromPeer(it, it->node_count);
 
     // Remove nodes associated with this peer, unless their timeout is still
     // active. This ensure that we don't overquery them in case they are
     // subsequently added to another peer.
     auto &nview = nodes.get<next_request_time>();
     nview.erase(nview.lower_bound(boost::make_tuple(peerid, TimePoint())),
                 nview.upper_bound(boost::make_tuple(
                     peerid, std::chrono::steady_clock::now())));
 
     // Release UTXOs attached to this proof.
-    for (const auto &s : it->proof.getStakes()) {
+    for (const auto &s : it->proof->getStakes()) {
         bool deleted = utxos.erase(s.getStake().getUTXO()) > 0;
         assert(deleted);
     }
 
     peers.erase(it);
     return true;
 }
 
 PeerId PeerManager::selectPeer() const {
     if (slots.empty() || slotCount == 0) {
         return NO_PEER;
     }
 
     const uint64_t max = slotCount;
     for (int retry = 0; retry < SELECT_PEER_MAX_RETRY; retry++) {
         size_t i = selectPeerImpl(slots, GetRand(max), max);
         if (i != NO_PEER) {
             return i;
         }
     }
 
     return NO_PEER;
 }
 
 uint64_t PeerManager::compact() {
     // There is nothing to compact.
     if (fragmentation == 0) {
         return 0;
     }
 
     std::vector<Slot> newslots;
     newslots.reserve(peers.size());
 
     uint64_t prevStop = 0;
     uint32_t i = 0;
     for (auto it = peers.begin(); it != peers.end(); it++) {
         if (it->node_count == 0) {
             continue;
         }
 
         newslots.emplace_back(prevStop, it->getScore(), it->peerid);
         prevStop = slots[i].getStop();
         if (!peers.modify(it, [&](Peer &p) { p.index = i++; })) {
             return 0;
         }
     }
 
     slots = std::move(newslots);
 
     const uint64_t saved = slotCount - prevStop;
     slotCount = prevStop;
     fragmentation = 0;
 
     return saved;
 }
 
 bool PeerManager::verify() const {
     uint64_t prevStop = 0;
     for (size_t i = 0; i < slots.size(); i++) {
         const Slot &s = slots[i];
 
         // Slots must be in correct order.
         if (s.getStart() < prevStop) {
             return false;
         }
 
         prevStop = s.getStop();
 
         // If this is a dead slot, then nothing more needs to be checked.
         if (s.getPeerId() == NO_PEER) {
             continue;
         }
 
         // We have a live slot, verify index.
         auto it = peers.find(s.getPeerId());
         if (it == peers.end() || it->index != i) {
             return false;
         }
     }
 
     for (const auto &p : peers) {
         // Count node attached to this peer.
         const auto count_nodes = [&]() {
             size_t count = 0;
             auto &nview = nodes.get<next_request_time>();
             auto begin =
                 nview.lower_bound(boost::make_tuple(p.peerid, TimePoint()));
             auto end =
                 nview.upper_bound(boost::make_tuple(p.peerid + 1, TimePoint()));
 
             for (auto it = begin; it != end; ++it) {
                 count++;
             }
 
             return count;
         };
 
         if (p.node_count != count_nodes()) {
             return false;
         }
 
         // If there are no nodes attached to this peer, then we are done.
         if (p.node_count == 0) {
             continue;
         }
 
         // The index must point to a slot refering to this peer.
         if (p.index >= slots.size() || slots[p.index].getPeerId() != p.peerid) {
             return false;
         }
 
         // If the score do not match, same thing.
         if (slots[p.index].getScore() != p.getScore()) {
             return false;
         }
     }
 
     return true;
 }
 
 PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
                       const uint64_t max) {
     assert(slot <= max);
 
     size_t begin = 0, end = slots.size();
     uint64_t bottom = 0, top = max;
 
     // Try to find the slot using dichotomic search.
     while ((end - begin) > 8) {
         // The slot we picked in not allocated.
         if (slot < bottom || slot >= top) {
             return NO_PEER;
         }
 
         // Guesstimate the position of the slot.
         size_t i = begin + ((slot - bottom) * (end - begin) / (top - bottom));
         assert(begin <= i && i < end);
 
         // We have a match.
         if (slots[i].contains(slot)) {
             return slots[i].getPeerId();
         }
 
         // We undershooted.
         if (slots[i].precedes(slot)) {
             begin = i + 1;
             if (begin >= end) {
                 return NO_PEER;
             }
 
             bottom = slots[begin].getStart();
             continue;
         }
 
         // We overshooted.
         if (slots[i].follows(slot)) {
             end = i;
             top = slots[end].getStart();
             continue;
         }
 
         // We have an unalocated slot.
         return NO_PEER;
     }
 
     // Enough of that nonsense, let fallback to linear search.
     for (size_t i = begin; i < end; i++) {
         // We have a match.
         if (slots[i].contains(slot)) {
             return slots[i].getPeerId();
         }
     }
 
     // We failed to find a slot, retry.
     return NO_PEER;
 }
 
 std::vector<Peer> PeerManager::getPeers() const {
     std::vector<Peer> vpeers;
     for (auto &it : peers.get<0>()) {
         vpeers.emplace_back(it);
     }
     return vpeers;
 }
 
 std::vector<NodeId> PeerManager::getNodeIdsForPeer(PeerId peerId) const {
     std::vector<NodeId> nodeids;
     auto &nview = nodes.get<next_request_time>();
     auto nodeRange = nview.equal_range(peerId);
     for (auto it = nodeRange.first; it != nodeRange.second; ++it) {
         nodeids.emplace_back(it->nodeid);
     }
     return nodeids;
 }
 
 } // namespace avalanche
diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
index b947be1df..3571b4f9b 100644
--- a/src/avalanche/peermanager.h
+++ b/src/avalanche/peermanager.h
@@ -1,198 +1,199 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_AVALANCHE_PEERMANAGER_H
 #define BITCOIN_AVALANCHE_PEERMANAGER_H
 
 #include <avalanche/node.h>
 #include <avalanche/proof.h>
 #include <coins.h>
 #include <net.h>
 #include <pubkey.h>
 #include <salteduint256hasher.h>
 
 #include <boost/multi_index/composite_key.hpp>
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/member.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index_container.hpp>
 
 #include <chrono>
 #include <cstdint>
+#include <memory>
 #include <vector>
 
 namespace avalanche {
 
 class Delegation;
 
 struct Slot {
 private:
     uint64_t start;
     uint32_t score;
     PeerId peerid;
 
 public:
     Slot(uint64_t startIn, uint32_t scoreIn, PeerId peeridIn)
         : start(startIn), score(scoreIn), peerid(peeridIn) {}
 
     Slot withStart(uint64_t startIn) const {
         return Slot(startIn, score, peerid);
     }
     Slot withScore(uint64_t scoreIn) const {
         return Slot(start, scoreIn, peerid);
     }
     Slot withPeerId(PeerId peeridIn) const {
         return Slot(start, score, peeridIn);
     }
 
     uint64_t getStart() const { return start; }
     uint64_t getStop() const { return start + score; }
     uint32_t getScore() const { return score; }
     PeerId getPeerId() const { return peerid; }
 
     bool contains(uint64_t slot) const {
         return getStart() <= slot && slot < getStop();
     }
     bool precedes(uint64_t slot) const { return slot >= getStop(); }
     bool follows(uint64_t slot) const { return getStart() > slot; }
 };
 
 struct Peer {
     PeerId peerid;
     uint32_t index = -1;
     uint32_t node_count = 0;
 
-    Proof proof;
+    std::shared_ptr<Proof> proof;
 
     Peer(PeerId peerid_, Proof proof_)
-        : peerid(peerid_), proof(std::move(proof_)) {}
+        : peerid(peerid_), proof(std::make_shared<Proof>(std::move(proof_))) {}
 
-    const ProofId &getProofId() const { return proof.getId(); }
-    uint32_t getScore() const { return proof.getScore(); }
+    const ProofId &getProofId() const { return proof->getId(); }
+    uint32_t getScore() const { return proof->getScore(); }
 };
 
 struct proof_index {
     using result_type = ProofId;
-    result_type operator()(const Peer &p) const { return p.proof.getId(); }
+    result_type operator()(const Peer &p) const { return p.proof->getId(); }
 };
 
 struct next_request_time {};
 
 class PeerManager {
     std::vector<Slot> slots;
     uint64_t slotCount = 0;
     uint64_t fragmentation = 0;
 
     /**
      * Several nodes can make an avalanche peer. In this case, all nodes are
      * considered interchangeable parts of the same peer.
      */
     using PeerSet = boost::multi_index_container<
         Peer, boost::multi_index::indexed_by<
                   // index by peerid
                   boost::multi_index::hashed_unique<
                       boost::multi_index::member<Peer, PeerId, &Peer::peerid>>,
                   // index by proof
                   boost::multi_index::hashed_unique<
                       boost::multi_index::tag<proof_index>, proof_index,
                       SaltedProofIdHasher>>>;
 
     PeerId nextPeerId = 0;
     PeerSet peers;
 
     std::unordered_map<COutPoint, PeerId, SaltedOutpointHasher> utxos;
 
     using NodeSet = boost::multi_index_container<
         Node,
         boost::multi_index::indexed_by<
             // index by nodeid
             boost::multi_index::hashed_unique<
                 boost::multi_index::member<Node, NodeId, &Node::nodeid>>,
             // sorted by peerid/nextRequestTime
             boost::multi_index::ordered_non_unique<
                 boost::multi_index::tag<next_request_time>,
                 boost::multi_index::composite_key<
                     Node,
                     boost::multi_index::member<Node, PeerId, &Node::peerid>,
                     boost::multi_index::member<Node, TimePoint,
                                                &Node::nextRequestTime>>>>>;
 
     NodeSet nodes;
 
     static constexpr int SELECT_PEER_MAX_RETRY = 3;
     static constexpr int SELECT_NODE_MAX_RETRY = 3;
 
 public:
     /**
      * Node API.
      */
     bool addNode(NodeId nodeid, const Proof &proof,
                  const Delegation &delegation);
     bool removeNode(NodeId nodeid);
 
     bool forNode(NodeId nodeid, std::function<bool(const Node &n)> func) const;
     bool updateNextRequestTime(NodeId nodeid, TimePoint timeout);
 
     /**
      * Randomly select a node to poll.
      */
     NodeId selectNode();
 
     /**
      * Update the peer set when a new block is connected.
      */
     void updatedBlockTip();
 
     /****************************************************
      * Functions which are public for testing purposes. *
      ****************************************************/
     /**
      * Provide the PeerId associated with the given proof. If the peer does not
      * exist, then it is created.
      */
     PeerId getPeerId(const Proof &proof);
 
     /**
      * Remove an existing peer.
      */
     bool removePeer(const PeerId peerid);
 
     /**
      * Randomly select a peer to poll.
      */
     PeerId selectPeer() const;
 
     /**
      * Trigger maintenance of internal data structures.
      * Returns how much slot space was saved after compaction.
      */
     uint64_t compact();
 
     /**
      * Perform consistency check on internal data structures.
      */
     bool verify() const;
 
     // Accessors.
     uint64_t getSlotCount() const { return slotCount; }
     uint64_t getFragmentation() const { return fragmentation; }
 
     std::vector<Peer> getPeers() const;
     std::vector<NodeId> getNodeIdsForPeer(PeerId peerId) const;
 
 private:
     PeerSet::iterator fetchOrCreatePeer(const Proof &proof);
     bool addNodeToPeer(const PeerSet::iterator &it);
     bool removeNodeFromPeer(const PeerSet::iterator &it, uint32_t count = 1);
 };
 
 /**
  * This is an internal method that is exposed for testing purposes.
  */
 PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
                       const uint64_t max);
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PEERMANAGER_H
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
index 951563349..6f4031083 100644
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -1,509 +1,509 @@
 // 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/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 <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 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."},
         },
         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();
     const CPubKey key = ParsePubKey(request.params[1]);
 
     avalanche::Proof proof;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[2].get_str(), error)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, error.original);
     }
 
     if (key != proof.getMaster()) {
         // TODO: we want to provide a proper delegation.
         return false;
     }
 
     return g_avalanche->addNode(nodeid, proof,
                                 avalanche::DelegationBuilder(proof).build());
 }
 
 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"},
             {
                 "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]));
 
     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 (!pb.addUTXO(utxo, amount, uint32_t(height), iscoinbase,
                         std::move(key))) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid private key");
         }
     }
 
     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",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "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",
                                    "\"<proof>\" \"<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::Proof proof;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, error.original);
     }
 
     avalanche::ProofValidationState proofState;
     if (!proof.verify(proofState)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "The proof is invalid");
     }
 
     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]);
 
     avalanche::DelegationBuilder dgb(proof);
     CPubKey auth;
     if (request.params.size() >= 4 && !request.params[3].isNull()) {
         avalanche::Delegation dg;
         CDataStream ss(ParseHexV(request.params[3], "delegation"), SER_NETWORK,
                        PROTOCOL_VERSION);
         ss >> dg;
 
         if (dg.getProofId() != proof.getId()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "The supplied delegation does not match the proof");
         }
 
         avalanche::DelegationState dgState;
         if (!dg.verify(dgState, auth)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The supplied delegation is not valid");
         }
 
         if (!dgb.importDelegation(dg)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Failed to import the delegation");
         }
 
     } else {
         auth = proof.getMaster();
     }
 
     if (privkey.GetPubKey() != auth) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "The private key does not match the proof or the delegation");
     }
 
     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::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);
 
     for (const auto &peer : g_avalanche->getPeers()) {
         UniValue obj(UniValue::VOBJ);
 
         CDataStream serproof(SER_NETWORK, PROTOCOL_VERSION);
-        serproof << peer.proof;
+        serproof << *peer.proof;
 
         obj.pushKV("peerid", uint64_t(peer.peerid));
         obj.pushKV("proof", HexStr(serproof));
 
         UniValue nodes(UniValue::VARR);
         for (const auto &id : g_avalanche->getNodeIdsForPeer(peer.peerid)) {
             nodes.push_back(id);
         }
         obj.pushKV("nodes", nodes);
         obj.pushKV("nodecount", uint64_t(peer.node_count));
 
         ret.push_back(obj);
     }
 
     return ret;
 }
 
 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;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, error.original);
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
 
     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());
         }
     }
 
     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",          "verifyavalancheproof",   verifyavalancheproof,   {"proof"}},
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }