fix: add more test vectors

crates/ethportal-api/src/types/ping_extensions/extensions/type_0.rs

@@ -39,6 +39,18 @@ impl ClientInfoRadiusCapabilities {
         }
     }
 
+    pub fn new_with_client_info(
+        client_info: Option<ClientInfo>,
+        radius: Distance,
+        capabilities: Vec<u16>,
+    ) -> Self {
+        Self {
+            client_info,
+            data_radius: radius,
+            capabilities: VariableList::from(capabilities),
+        }
+    }
+
     pub fn capabilities(&self) -> Result<Vec<Extensions>, ExtensionError> {
         self.capabilities
             .iter()
@@ -175,7 +187,13 @@ mod tests {
     use rstest::rstest;
 
     use super::*;
-    use crate::types::ping_extensions::decode::DecodedExtension;
+    use crate::{
+        types::{
+            ping_extensions::decode::DecodedExtension,
+            portal_wire::{Message, Ping, Pong},
+        },
+        utils::bytes::{hex_decode, hex_encode},
+    };
 
     #[test]
     fn test_client_info_radius_capabilities() {
@@ -236,4 +254,102 @@ mod tests {
     fn test_client_info_from_str_invalid(#[case] string: &str) {
         ClientInfo::from_str(string).unwrap();
     }
+
+    #[test]
+    fn message_encoding_ping_capabilities_with_client_info() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let client_info =
+            ClientInfo::from_str("trin/v0.1.1-b61fdc5c/linux-x86_64/rustc1.81.0").unwrap();
+        let capabilities = vec![0, 1, 65535];
+        let capabilities_payload = ClientInfoRadiusCapabilities::new_with_client_info(
+            Some(client_info),
+            data_radius,
+            capabilities,
+        );
+        let custom_payload = CustomPayload::from(capabilities_payload);
+        let ping = Ping {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let ping = Message::Ping(ping);
+
+        let encoded: Vec<u8> = ping.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0001000000000000000c00000000000600000028000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff56000000017472696e2f76302e312e312d62363166646335632f6c696e75782d7838365f36342f7275737463312e38312e3000000100ffff";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, ping);
+    }
+
+    #[test]
+    fn message_encoding_ping_capabilities_without_client_info() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let capabilities = vec![0, 1, 65535];
+        let capabilities_payload =
+            ClientInfoRadiusCapabilities::new_with_client_info(None, data_radius, capabilities);
+        let custom_payload = CustomPayload::from(capabilities_payload);
+        let ping = Ping {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let ping = Message::Ping(ping);
+
+        let encoded: Vec<u8> = ping.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0001000000000000000c00000000000600000028000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff290000000000000100ffff";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, ping);
+    }
+
+    #[test]
+    fn message_encoding_pong_capabilities_with_client_info() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let client_info =
+            ClientInfo::from_str("trin/v0.1.1-b61fdc5c/linux-x86_64/rustc1.81.0").unwrap();
+        let capabilities = vec![0, 1, 65535];
+        let capabilities_payload = ClientInfoRadiusCapabilities::new_with_client_info(
+            Some(client_info),
+            data_radius,
+            capabilities,
+        );
+        let custom_payload = CustomPayload::from(capabilities_payload);
+        let pong = Pong {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let pong = Message::Pong(pong);
+
+        let encoded: Vec<u8> = pong.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0101000000000000000c00000000000600000028000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff56000000017472696e2f76302e312e312d62363166646335632f6c696e75782d7838365f36342f7275737463312e38312e3000000100ffff";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, pong);
+    }
+
+    #[test]
+    fn message_encoding_pong_capabilities_without_client_info() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let capabilities = vec![0, 1, 65535];
+        let capabilities_payload =
+            ClientInfoRadiusCapabilities::new_with_client_info(None, data_radius, capabilities);
+        let custom_payload = CustomPayload::from(capabilities_payload);
+        let pong = Pong {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let pong = Message::Pong(pong);
+
+        let encoded: Vec<u8> = pong.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0101000000000000000c00000000000600000028000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff290000000000000100ffff";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, pong);
+    }
 }

crates/ethportal-api/src/types/ping_extensions/extensions/type_1.rs

@@ -35,7 +35,14 @@ mod tests {
     use ssz::Decode;
 
     use super::*;
-    use crate::types::{distance::Distance, ping_extensions::decode::DecodedExtension};
+    use crate::{
+        types::{
+            distance::Distance,
+            ping_extensions::decode::DecodedExtension,
+            portal_wire::{Message, Ping, Pong},
+        },
+        utils::bytes::{hex_decode, hex_encode},
+    };
 
     #[test]
     fn test_basic_radius() {
@@ -61,4 +68,44 @@ mod tests {
         assert_eq!(bytes.len(), 32);
         assert_eq!(basic_radius, decoded);
     }
+
+    #[test]
+    fn message_encoding_ping_basic_radius() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let basic_radius = BasicRadius::new(data_radius);
+        let custom_payload = CustomPayload::from(basic_radius);
+        let ping = Ping {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let ping = Message::Ping(ping);
+
+        let encoded: Vec<u8> = ping.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0001000000000000000c000000010006000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, ping);
+    }
+
+    #[test]
+    fn message_encoding_pong_basic_radius() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let basic_radius = BasicRadius::new(data_radius);
+        let custom_payload = CustomPayload::from(basic_radius);
+        let pong = Pong {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let pong = Message::Pong(pong);
+
+        let encoded: Vec<u8> = pong.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0101000000000000000c000000010006000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, pong);
+    }
 }

crates/ethportal-api/src/types/ping_extensions/extensions/type_2.rs

@@ -39,7 +39,14 @@ mod tests {
     use ssz::Decode;
 
     use super::*;
-    use crate::types::{distance::Distance, ping_extensions::decode::DecodedExtension};
+    use crate::{
+        types::{
+            distance::Distance,
+            ping_extensions::decode::DecodedExtension,
+            portal_wire::{Message, Ping, Pong},
+        },
+        utils::bytes::{hex_decode, hex_encode},
+    };
 
     #[test]
     fn test_history_radius() {
@@ -65,4 +72,46 @@ mod tests {
         assert_eq!(bytes.len(), 34);
         assert_eq!(history_radius, decoded);
     }
+
+    #[test]
+    fn message_encoding_ping_history_radius() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let ephemeral_header_count = 4242;
+        let history_radius = HistoryRadius::new(data_radius, ephemeral_header_count);
+        let custom_payload = CustomPayload::from(history_radius);
+        let ping = Ping {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let ping = Message::Ping(ping);
+
+        let encoded: Vec<u8> = ping.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0001000000000000000c000000020006000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9210";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, ping);
+    }
+
+    #[test]
+    fn message_encoding_pong_history_radius() {
+        let data_radius = Distance::from(U256::MAX - U256::from(1));
+        let ephemeral_header_count = 4242;
+        let history_radius = HistoryRadius::new(data_radius, ephemeral_header_count);
+        let custom_payload = CustomPayload::from(history_radius);
+        let pong = Pong {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let pong = Message::Pong(pong);
+
+        let encoded: Vec<u8> = pong.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded = "0x0101000000000000000c000000020006000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9210";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, pong);
+    }
 }

crates/ethportal-api/src/types/ping_extensions/extensions/type_65535.rs

@@ -1,3 +1,4 @@
+use anyhow::anyhow;
 use ssz::Encode;
 use ssz_derive::{Decode, Encode};
 use ssz_types::{typenum::U300, VariableList};
@@ -21,6 +22,15 @@ impl PingError {
             message: VariableList::empty(),
         }
     }
+
+    pub fn new_with_message(error_code: ErrorCodes, message: Vec<u8>) -> anyhow::Result<Self> {
+        Ok(Self {
+            error_code: error_code.into(),
+            message: VariableList::new(message).map_err(|err| {
+                anyhow!("PingError can only handle messages up to 300 bytes, received {err:?}")
+            })?,
+        })
+    }
 }
 
 impl From<PingError> for CustomPayload {
@@ -58,7 +68,13 @@ mod tests {
     use ssz::Decode;
 
     use super::*;
-    use crate::types::ping_extensions::decode::DecodedExtension;
+    use crate::{
+        types::{
+            ping_extensions::decode::DecodedExtension,
+            portal_wire::{Message, Pong},
+        },
+        utils::bytes::{hex_decode, hex_encode},
+    };
 
     #[test]
     fn test_ping_error() {
@@ -84,4 +100,27 @@ mod tests {
         assert_eq!(bytes.len(), 6);
         assert_eq!(ping_error, decoded);
     }
+
+    #[test]
+    fn message_encoding_pong_basic_radius() {
+        let error_code = ErrorCodes::FailedToDecodePayload;
+        let message = "hello world";
+        let basic_radius =
+            PingError::new_with_message(error_code, message.as_bytes().to_vec()).unwrap();
+        let custom_payload = CustomPayload::from(basic_radius);
+        let pong = Pong {
+            enr_seq: 1,
+            custom_payload,
+        };
+        let pong = Message::Pong(pong);
+
+        let encoded: Vec<u8> = pong.clone().into();
+        let encoded = hex_encode(encoded);
+        let expected_encoded =
+            "0x0101000000000000000c000000ffff0600000002000600000068656c6c6f20776f726c64";
+        assert_eq!(encoded, expected_encoded);
+
+        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
+        assert_eq!(decoded, pong);
+    }
 }

crates/ethportal-api/src/types/portal_wire.rs

@@ -606,46 +606,6 @@ mod test {
         assert_eq!(hex, expected_hex);
     }
 
-    // Wire message test vectors available in Ethereum Portal Network specs repo:
-    // github.com/ethereum/portal-network-specs
-    #[test]
-    fn message_encoding_ping() {
-        let data_radius: U256 = U256::MAX - U256::from(1u8);
-        let custom_payload = CustomPayload::from(data_radius.as_ssz_bytes());
-        let ping = Ping {
-            enr_seq: 1,
-            custom_payload,
-        };
-        let ping = Message::Ping(ping);
-
-        let encoded: Vec<u8> = ping.clone().into();
-        let encoded = hex_encode(encoded);
-        let expected_encoded = "0x0001000000000000000c000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
-        assert_eq!(encoded, expected_encoded);
-
-        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
-        assert_eq!(decoded, ping);
-    }
-
-    #[test]
-    fn message_encoding_pong() {
-        let data_radius: U256 = U256::MAX / U256::from(2u8);
-        let custom_payload = CustomPayload::from(data_radius.as_ssz_bytes());
-        let pong = Pong {
-            enr_seq: 1,
-            custom_payload,
-        };
-        let pong = Message::Pong(pong);
-
-        let encoded: Vec<u8> = pong.clone().into();
-        let encoded = hex_encode(encoded);
-        let expected_encoded = "0x0101000000000000000c000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f";
-        assert_eq!(encoded, expected_encoded);
-
-        let decoded = Message::try_from(hex_decode(&encoded).unwrap()).unwrap();
-        assert_eq!(decoded, pong);
-    }
-
     #[test]
     fn message_encoding_find_nodes() {
         let distances = vec![256, 255];