Implement portal_*Offer json-rpc endpoint

Author: ogenev

newsfragments/275.added.md

@@ -0,0 +1 @@
+Add `portal_*Offer` JSON-RPC andpoint

trin-core/src/jsonrpc/endpoints.rs

@@ -14,6 +14,7 @@ pub enum StateEndpoint {
     FindContent,
     FindNodes,
     LocalContent,
+    Offer,
     Ping,
 }
 
@@ -24,6 +25,7 @@ pub enum HistoryEndpoint {
     FindContent,
     FindNodes,
     LocalContent,
+    Offer,
     Ping,
     RecursiveFindContent,
 }
@@ -77,6 +79,7 @@ impl FromStr for TrinEndpoint {
             "portal_historyLocalContent" => {
                 Ok(TrinEndpoint::HistoryEndpoint(HistoryEndpoint::LocalContent))
             }
+            "portal_historyOffer" => Ok(TrinEndpoint::HistoryEndpoint(HistoryEndpoint::Offer)),
             "portal_historyPing" => Ok(TrinEndpoint::HistoryEndpoint(HistoryEndpoint::Ping)),
             "portal_historyRadius" => {
                 Ok(TrinEndpoint::HistoryEndpoint(HistoryEndpoint::DataRadius))
@@ -88,6 +91,7 @@ impl FromStr for TrinEndpoint {
             "portal_stateLocalContent" => {
                 Ok(TrinEndpoint::StateEndpoint(StateEndpoint::LocalContent))
             }
+            "portal_stateOffer" => Ok(TrinEndpoint::StateEndpoint(StateEndpoint::Offer)),
             "portal_statePing" => Ok(TrinEndpoint::StateEndpoint(StateEndpoint::Ping)),
             "portal_stateRadius" => Ok(TrinEndpoint::StateEndpoint(StateEndpoint::DataRadius)),
             _ => Err(()),

trin-core/src/jsonrpc/types.rs

@@ -196,6 +196,65 @@ impl TryFrom<[&Value; 2]> for FindContentParams {
     }
 }
 
+pub struct OfferParams {
+    pub enr: SszEnr,
+    pub content_keys: Vec<ByteList>,
+}
+
+impl TryFrom<Params> for OfferParams {
+    type Error = ValidationError;
+
+    fn try_from(params: Params) -> Result<Self, Self::Error> {
+        match params {
+            Params::Array(val) => match val.len() {
+                2 => Self::try_from([&val[0], &val[1]]),
+                _ => Err(ValidationError::new("Expected 2 params")),
+            },
+            _ => Err(ValidationError::new("Expected array of params")),
+        }
+    }
+}
+
+impl TryFrom<[&Value; 2]> for OfferParams {
+    type Error = ValidationError;
+
+    fn try_from(params: [&Value; 2]) -> Result<Self, Self::Error> {
+        let enr: SszEnr = params[0].try_into()?;
+
+        let content_keys = params[1].as_array();
+
+        match content_keys {
+            Some(content_keys) => {
+                let content_keys: Result<Vec<String>, _> = content_keys
+                    .iter()
+                    .cloned()
+                    .map(serde_json::from_value)
+                    .collect();
+
+                if let Ok(content_keys) = content_keys {
+                    let content_keys: Result<Vec<Vec<u8>>, _> =
+                        content_keys.iter().map(hex::decode).collect();
+
+                    if let Ok(content_keys) = content_keys {
+                        Ok(Self {
+                            enr,
+                            content_keys: content_keys
+                                .into_iter()
+                                .map(VariableList::from)
+                                .collect(),
+                        })
+                    } else {
+                        Err(ValidationError::new("Unable to hex decode content keys"))
+                    }
+                } else {
+                    Err(ValidationError::new("Unable to decode content keys"))
+                }
+            }
+            None => Err(ValidationError::new("Required a list of content keys")),
+        }
+    }
+}
+
 pub struct RecursiveFindContentParams {
     pub content_key: ByteList,
 }

trin-core/src/portalnet/types/messages.rs

@@ -491,6 +491,12 @@ pub struct Accept {
     pub content_keys: BitList<typenum::U8>,
 }
 
+impl Into<Value> for Accept {
+    fn into(self) -> Value {
+        serde_json::json!({ "connection_id": format!("{:?}", self.connection_id.to_be()) , "content_keys": self.content_keys})
+    }
+}
+
 #[derive(Debug, PartialEq, Clone)]
 pub struct SszEnr(Enr);
 

trin-history/src/jsonrpc.rs

@@ -5,6 +5,7 @@ use serde_json::{json, Value};
 use tokio::sync::mpsc;
 
 use crate::network::HistoryNetwork;
+use trin_core::jsonrpc::types::OfferParams;
 use trin_core::jsonrpc::{
     endpoints::HistoryEndpoint,
     types::{
@@ -170,6 +171,26 @@ impl HistoryRequestHandler {
                     };
                     let _ = request.resp.send(response);
                 }
+                HistoryEndpoint::Offer => {
+                    let response = match OfferParams::try_from(request.params) {
+                        Ok(val) => {
+                            let content_keys =
+                                val.content_keys.iter().map(|key| key.to_vec()).collect();
+
+                            match self
+                                .network
+                                .overlay
+                                .send_offer(content_keys, val.enr.into())
+                                .await
+                            {
+                                Ok(accept) => Ok(accept.into()),
+                                Err(msg) => Err(format!("Offer request timeout: {:?}", msg)),
+                            }
+                        }
+                        Err(msg) => Err(format!("Invalid Offer params: {:?}", msg)),
+                    };
+                    let _ = request.resp.send(response);
+                }
                 HistoryEndpoint::Ping => {
                     let response = match PingParams::try_from(request.params) {
                         Ok(val) => match self.network.overlay.send_ping(val.enr.into()).await {

trin-state/src/jsonrpc.rs

@@ -4,6 +4,7 @@ use serde_json::Value;
 use tokio::sync::mpsc;
 
 use crate::network::StateNetwork;
+use trin_core::jsonrpc::types::OfferParams;
 use trin_core::jsonrpc::{
     endpoints::StateEndpoint,
     types::{
@@ -81,6 +82,26 @@ impl StateRequestHandler {
                     };
                     let _ = request.resp.send(response);
                 }
+                StateEndpoint::Offer => {
+                    let response = match OfferParams::try_from(request.params) {
+                        Ok(val) => {
+                            let content_keys =
+                                val.content_keys.iter().map(|key| key.to_vec()).collect();
+
+                            match self
+                                .network
+                                .overlay
+                                .send_offer(content_keys, val.enr.into())
+                                .await
+                            {
+                                Ok(accept) => Ok(accept.into()),
+                                Err(msg) => Err(format!("Offer request timeout: {:?}", msg)),
+                            }
+                        }
+                        Err(msg) => Err(format!("Invalid Offer params: {:?}", msg)),
+                    };
+                    let _ = request.resp.send(response);
+                }
                 StateEndpoint::Ping => {
                     let response = match PingParams::try_from(request.params) {
                         Ok(val) => match self.network.overlay.send_ping(val.enr.into()).await {