diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
--- a/src/avalanche/peermanager.h
+++ b/src/avalanche/peermanager.h
@@ -24,6 +24,8 @@
 
 namespace avalanche {
 
+class Delegation;
+
 struct Slot {
 private:
     uint64_t start;
@@ -143,7 +145,8 @@
     /**
      * Node API.
      */
-    bool addNode(NodeId nodeid, const Proof &proof, const CPubKey &pubkey);
+    bool addNode(NodeId nodeid, const Proof &proof,
+                 const Delegation &delegation);
     bool removeNode(NodeId nodeid);
 
     NodeId selectNode();
diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -4,7 +4,7 @@
 
 #include <avalanche/peermanager.h>
 
-#include <avalanche/proofid.h>
+#include <avalanche/delegation.h>
 #include <avalanche/validation.h>
 #include <random.h>
 #include <validation.h> // For ChainstateActive()
@@ -109,21 +109,27 @@
 }
 
 bool PeerManager::addNode(NodeId nodeid, const Proof &proof,
-                          const CPubKey &pubkey) {
+                          const Delegation &delegation) {
     const PeerId peerid = getPeer(proof);
     if (peerid == NO_PEER) {
         return false;
     }
 
+    DelegationState state;
+    CPubKey pubkey;
+    if (!delegation.verify(state, proof, pubkey)) {
+        return false;
+    }
+
     auto nit = nodes.find(nodeid);
     if (nit == nodes.end()) {
-        return nodes.emplace(nodeid, peerid, pubkey).second;
+        return nodes.emplace(nodeid, peerid, std::move(pubkey)).second;
     }
 
     // We actually have this node already, we need to update it.
     return nodes.modify(nit, [&](Node &n) {
         n.peerid = peerid;
-        n.pubkey = pubkey;
+        n.pubkey = std::move(pubkey);
     });
 }
 
diff --git a/src/avalanche/processor.h b/src/avalanche/processor.h
--- a/src/avalanche/processor.h
+++ b/src/avalanche/processor.h
@@ -61,6 +61,7 @@
 
 namespace avalanche {
 
+class Delegation;
 class PeerManager;
 class Proof;
 
@@ -265,7 +266,8 @@
     bool registerVotes(NodeId nodeid, const Response &response,
                        std::vector<BlockUpdate> &updates);
 
-    bool addNode(NodeId nodeid, const Proof &proof, const CPubKey &pubkey);
+    bool addNode(NodeId nodeid, const Proof &proof,
+                 const Delegation &delegation);
     bool forNode(NodeId nodeid, std::function<bool(const Node &n)> func) const;
 
     CPubKey getSessionPubKey() const { return sessionKey.GetPubKey(); }
diff --git a/src/avalanche/processor.cpp b/src/avalanche/processor.cpp
--- a/src/avalanche/processor.cpp
+++ b/src/avalanche/processor.cpp
@@ -353,9 +353,9 @@
 }
 
 bool Processor::addNode(NodeId nodeid, const Proof &proof,
-                        const CPubKey &pubkey) {
+                        const Delegation &delegation) {
     LOCK(cs_peerManager);
-    return peerManager->addNode(nodeid, proof, pubkey);
+    return peerManager->addNode(nodeid, proof, delegation);
 }
 
 bool Processor::forNode(NodeId nodeid,
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -2,11 +2,12 @@
 // 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 <avalanche/test/util.h>
 
 #include <test/util/setup_common.h>
 
@@ -162,11 +163,14 @@
 
     // One peer, we always return it.
     Proof proof0 = buildRandomProof(100);
-    pm.addNode(node0, buildRandomProof(100), CPubKey());
+    Delegation dg0 = DelegationBuilder(proof0).build();
+    pm.addNode(node0, proof0, dg0);
     BOOST_CHECK_EQUAL(pm.selectNode(), node0);
 
     // Two peers, verify ratio.
-    pm.addNode(node1, buildRandomProof(200), CPubKey());
+    Proof proof1 = buildRandomProof(200);
+    Delegation dg1 = DelegationBuilder(proof1).build();
+    pm.addNode(node1, proof1, dg1);
 
     std::unordered_map<PeerId, int> results = {};
     for (int i = 0; i < 10000; i++) {
@@ -178,7 +182,9 @@
     BOOST_CHECK(abs(2 * results[0] - results[1]) < 500);
 
     // Three peers, verify ratio.
-    pm.addNode(node2, buildRandomProof(100), CPubKey());
+    Proof proof2 = buildRandomProof(100);
+    Delegation dg2 = DelegationBuilder(proof2).build();
+    pm.addNode(node2, proof2, dg2);
 
     results.clear();
     for (int i = 0; i < 10000; i++) {
@@ -294,11 +300,12 @@
 
     // Create one peer.
     Proof proof = buildRandomProof(100000000);
+    Delegation dg = DelegationBuilder(proof).build();
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     // Add 4 nodes.
     for (int i = 0; i < 4; i++) {
-        BOOST_CHECK(pm.addNode(i, proof, CPubKey()));
+        BOOST_CHECK(pm.addNode(i, proof, dg));
     }
 
     for (int i = 0; i < 100; i++) {
@@ -332,7 +339,8 @@
     // Move a node from a peer to another. This peer has a very low score such
     // as chances of being picked are 1 in a billion.
     Proof altproof = buildRandomProof(1);
-    BOOST_CHECK(pm.addNode(3, altproof, CPubKey()));
+    Delegation altdg = DelegationBuilder(altproof).build();
+    BOOST_CHECK(pm.addNode(3, altproof, altdg));
 
     int node3selected = 0;
     for (int i = 0; i < 100; i++) {
diff --git a/src/avalanche/test/processor_tests.cpp b/src/avalanche/test/processor_tests.cpp
--- a/src/avalanche/test/processor_tests.cpp
+++ b/src/avalanche/test/processor_tests.cpp
@@ -4,6 +4,7 @@
 
 #include <avalanche/processor.h>
 
+#include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/proofbuilder.h>
 #include <chain.h>
@@ -122,14 +123,21 @@
         return pb.build();
     }
 
+    bool addNode(NodeId nodeid) {
+        Proof proof = GetProof();
+        return m_processor->addNode(nodeid, proof,
+                                    DelegationBuilder(proof).build());
+    }
+
     std::array<CNode *, 8> ConnectNodes() {
         PeerManager &pm = getPeerManager();
         Proof proof = GetProof();
+        Delegation dg = DelegationBuilder(proof).build();
 
         std::array<CNode *, 8> nodes;
         for (CNode *&n : nodes) {
             n = ConnectNode(NODE_AVALANCHE);
-            BOOST_CHECK(pm.addNode(n->GetId(), proof, masterpriv.GetPubKey()));
+            BOOST_CHECK(pm.addNode(n->GetId(), proof, dg));
         }
 
         return nodes;
@@ -561,7 +569,7 @@
     ConnectNode(NODE_NONE);
     auto avanode = ConnectNode(NODE_AVALANCHE);
     NodeId avanodeid = avanode->GetId();
-    BOOST_CHECK(m_processor->addNode(avanodeid, GetProof(), CPubKey()));
+    BOOST_CHECK(addNode(avanodeid));
 
     // It returns the avalanche peer.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
@@ -693,7 +701,7 @@
     // Create a node that supports avalanche.
     auto avanode = ConnectNode(NODE_AVALANCHE);
     NodeId avanodeid = avanode->GetId();
-    BOOST_CHECK(m_processor->addNode(avanodeid, GetProof(), CPubKey()));
+    BOOST_CHECK(addNode(avanodeid));
 
     // Expire requests after some time.
     auto queryTimeDuration = std::chrono::milliseconds(10);
@@ -733,11 +741,12 @@
     // Create enough nodes so that we run into the inflight request limit.
     PeerManager &pm = getPeerManager();
     Proof proof = GetProof();
+    Delegation dg = DelegationBuilder(proof).build();
 
     std::array<CNode *, AVALANCHE_MAX_INFLIGHT_POLL + 1> nodes;
     for (auto &n : nodes) {
         n = ConnectNode(NODE_AVALANCHE);
-        BOOST_CHECK(pm.addNode(n->GetId(), proof, CPubKey()));
+        BOOST_CHECK(pm.addNode(n->GetId(), proof, dg));
     }
 
     // Add a block to poll
@@ -879,7 +888,7 @@
     // Create a node that supports avalanche.
     auto avanode = ConnectNode(NODE_AVALANCHE);
     NodeId nodeid = avanode->GetId();
-    BOOST_CHECK(m_processor->addNode(nodeid, GetProof(), CPubKey()));
+    BOOST_CHECK(addNode(nodeid));
 
     // There is no query in flight at the moment.
     BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), nodeid);
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -2,6 +2,7 @@
 // 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/processor.h>
 #include <avalanche/proof.h>
 #include <avalanche/proofbuilder.h>
@@ -78,7 +79,13 @@
     avalanche::Proof proof;
     ss >> proof;
 
-    return g_avalanche->addNode(nodeid, proof, key);
+    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,