Initial vector tests passing

Author: njgheorghita

ethportal-peertest/src/main.rs

@@ -88,14 +88,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         // Test history and state network Ping request on target node
         info!("Pinging {} on history network", target_node);
-        let ping_result = history_overlay.send_ping(target_node.clone(), None).await;
+        let ping_result = history_overlay.send_ping(target_node.clone()).await;
         match ping_result {
             Ok(val) => info!("Successful ping to History network: {:?}", val),
             Err(msg) => panic!("Invalid ping to History network: {:?}", msg),
         }
 
         info!("Pinging {} on state network", target_node);
-        let ping_result = state_overlay.send_ping(target_node.clone(), None).await;
+        let ping_result = state_overlay.send_ping(target_node.clone()).await;
         match ping_result {
             Ok(val) => info!("Successful ping to State network: {:?}", val),
             Err(msg) => panic!("Invalid ping to State network: {:?}", msg),

trin-core/src/portalnet/overlay.rs

@@ -156,18 +156,14 @@ impl OverlayProtocol {
     }
 
     /// Sends a `Ping` request to `enr`.
-    pub async fn send_ping(
-        &self,
-        enr: Enr,
-        payload: Option<Vec<u8>>,
-    ) -> Result<Pong, OverlayRequestError> {
+    pub async fn send_ping(&self, enr: Enr) -> Result<Pong, OverlayRequestError> {
         // Construct the request.
         let enr_seq = self.discovery.read_with_warn().await.local_enr().seq();
         let data_radius = self.data_radius().await;
-        let payload = CustomPayload::new(data_radius, payload);
+        let custom_payload = CustomPayload::new(u64::to_be_bytes(data_radius.as_u64()).to_vec());
         let request = Ping {
             enr_seq,
-            payload: Some(payload),
+            custom_payload,
         };
 
         let node_id = enr.node_id();

trin-core/src/portalnet/overlay_service.rs

@@ -6,8 +6,8 @@ use crate::{
     portalnet::{
         discovery::Discovery,
         types::{
-            CustomPayload, FindContent, FindNodes, FoundContent, Message, Nodes, Ping, Pong,
-            ProtocolId, Request, Response, SszEnr,
+            ByteList, CustomPayload, FindContent, FindNodes, FoundContent, Message, Nodes, Ping,
+            Pong, ProtocolId, Request, Response, SszEnr,
         },
         Enr, U256,
     },
@@ -18,6 +18,8 @@ use discv5::{enr::NodeId, kbucket::KBucketsTable};
 use futures::channel::oneshot;
 use log::{debug, info};
 use rocksdb::DB;
+use ssz::Encode;
+use ssz_types::VariableList;
 use thiserror::Error;
 use tokio::sync::{
     mpsc::{self, UnboundedReceiver, UnboundedSender},
@@ -257,8 +259,11 @@ impl OverlayService {
         );
         let enr_seq = self.local_enr().await.seq();
         let data_radius = self.data_radius().await;
-        let payload = Some(CustomPayload::new(data_radius, None));
-        Pong { enr_seq, payload }
+        let custom_payload = CustomPayload::new(data_radius.as_ssz_bytes());
+        Pong {
+            enr_seq,
+            custom_payload,
+        }
     }
 
     /// Builds a `Nodes` response for a `FindNodes` request.
@@ -276,16 +281,13 @@ impl OverlayService {
         request: FindContent,
     ) -> Result<FoundContent, OverlayRequestError> {
         match self.db.get(&request.content_key) {
-            Ok(Some(value)) => Ok(FoundContent {
-                enrs: vec![],
-                payload: value,
-            }),
+            Ok(Some(value)) => {
+                let content = Some(ByteList::from(VariableList::from(value)));
+                Ok(FoundContent::new(None, None, content))
+            }
             Ok(None) => {
-                let enrs = self.find_nodes_close_to_content(request.content_key).await;
-                Ok(FoundContent {
-                    enrs,
-                    payload: vec![],
-                })
+                let enrs = Some(self.find_nodes_close_to_content(request.content_key).await);
+                Ok(FoundContent::new(None, enrs, None))
             }
             Err(error) => panic!("Unable to respond to FindContent: {}", error),
         }
@@ -328,15 +330,15 @@ impl OverlayService {
     }
 
     /// Returns a vector of the ENRs of the closest nodes by the given log2 distances.
-    async fn nodes_by_distance(&self, mut log2_distances: Vec<u64>) -> Vec<Enr> {
+    async fn nodes_by_distance(&self, mut log2_distances: Vec<u64>) -> Vec<SszEnr> {
         let mut nodes_to_send = Vec::new();
         log2_distances.sort_unstable();
         log2_distances.dedup();
 
         let mut log2_distances = log2_distances.as_slice();
         if let Some(0) = log2_distances.first() {
             // If the distance is 0 send our local ENR.
-            nodes_to_send.push(self.local_enr().await);
+            nodes_to_send.push(SszEnr::new(self.local_enr().await));
             log2_distances = &log2_distances[1..];
         }
 
@@ -347,7 +349,7 @@ impl OverlayService {
                 .into_iter()
                 .map(|entry| entry.node.value.clone())
             {
-                nodes_to_send.push(node.enr());
+                nodes_to_send.push(SszEnr::new(node.enr()));
             }
         }
         nodes_to_send