fix: change BlocksByRoot container de/serialization (#63)

The request type was changed in
leanEthereum/leanSpec@054b2e9.
This PR updates it to the latest format, while keeping backwards
compatibility with the other one. This is because Zeam uses the new
format, while the rest of clients use the old one. Once everyone moves
to the new format we can remove this patch.

Author: MegaRedHand

Makefile

@@ -6,7 +6,7 @@ help: ## 📚 Show help for each of the Makefile recipes
 lint: ## 🔍 Run clippy on all workspace crates
 	cargo clippy --workspace --all-targets -- -D warnings
 
-test: ## 🧪 Run all tests, then forkchoice tests with skip-signature-verification
+test: leanSpec/fixtures ## 🧪 Run all tests, then forkchoice tests with skip-signature-verification
 	# Tests need to be run on release to avoid stack overflows during signature verification/aggregation
 	cargo test --workspace --release
 	cargo test -p ethlambda-blockchain --features skip-signature-verification --test forkchoice_spectests

crates/net/p2p/src/req_resp/codec.rs

@@ -41,9 +41,10 @@ impl libp2p::request_response::Codec for Codec {
                 Ok(Request::Status(status))
             }
             BLOCKS_BY_ROOT_PROTOCOL_V1 => {
-                let request = BlocksByRootRequest::from_ssz_bytes(&payload).map_err(|err| {
-                    io::Error::new(io::ErrorKind::InvalidData, format!("{err:?}"))
-                })?;
+                let request =
+                    BlocksByRootRequest::from_ssz_bytes_compat(&payload).map_err(|err| {
+                        io::Error::new(io::ErrorKind::InvalidData, format!("{err:?}"))
+                    })?;
                 Ok(Request::BlocksByRoot(request))
             }
             _ => Err(io::Error::new(

crates/net/p2p/src/req_resp/handlers.rs

@@ -13,7 +13,7 @@ use super::{
 };
 use crate::{
     BACKOFF_MULTIPLIER, INITIAL_BACKOFF_MS, MAX_FETCH_RETRIES, P2PServer, PendingRequest,
-    RetryMessage,
+    RetryMessage, req_resp::RequestedBlockRoots,
 };
 
 pub async fn handle_req_resp_message(
@@ -105,7 +105,7 @@ async fn handle_blocks_by_root_request(
     channel: request_response::ResponseChannel<Response>,
     peer: PeerId,
 ) {
-    let num_roots = request.len();
+    let num_roots = request.roots.len();
     info!(%peer, num_roots, "Received BlocksByRoot request");
 
     // TODO: Support multiple blocks per request (currently only handles first root)
@@ -198,11 +198,12 @@ pub async fn fetch_block_from_peer(
     };
 
     // Create BlocksByRoot request with single root
-    let mut request = BlocksByRootRequest::empty();
-    if let Err(err) = request.push(root) {
+    let mut roots = RequestedBlockRoots::empty();
+    if let Err(err) = roots.push(root) {
         error!(%root, ?err, "Failed to create BlocksByRoot request");
         return false;
     }
+    let request = BlocksByRootRequest { roots };
 
     info!(%peer, %root, "Sending BlocksByRoot request for missing block");
     let request_id = server

crates/net/p2p/src/req_resp/messages.rs

@@ -1,4 +1,5 @@
 use ethlambda_types::{block::SignedBlockWithAttestation, primitives::H256, state::Checkpoint};
+use ssz::Decode as SszDecode;
 use ssz_derive::{Decode, Encode};
 use ssz_types::typenum;
 
@@ -102,7 +103,7 @@ pub struct Status {
 type MaxRequestBlocks = typenum::U1024;
 type MaxErrorMessageLength = typenum::U256;
 
-pub type BlocksByRootRequest = ssz_types::VariableList<H256, MaxRequestBlocks>;
+pub type RequestedBlockRoots = ssz_types::VariableList<H256, MaxRequestBlocks>;
 
 /// Error message type for non-success responses.
 /// SSZ-encoded as List[byte, 256] per spec.
@@ -121,3 +122,60 @@ pub fn error_message(msg: impl AsRef<str>) -> ErrorMessage {
     let vec = truncated.to_vec();
     ErrorMessage::new(vec).expect("error message fits in 256 bytes")
 }
+
+#[derive(Debug, Clone, Encode, Decode)]
+pub struct BlocksByRootRequest {
+    pub roots: RequestedBlockRoots,
+}
+
+impl BlocksByRootRequest {
+    /// Decode from SSZ bytes with backward compatibility.
+    ///
+    /// Tries to decode as new format (container with `roots` field) first.
+    /// Falls back to old format (transparent - direct list of roots) if that fails.
+    pub fn from_ssz_bytes_compat(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
+        // Try new format (container) first
+        SszDecode::from_ssz_bytes(bytes).or_else(|_| {
+            // Fall back to old format (transparent/direct list)
+            SszDecode::from_ssz_bytes(bytes).map(|roots| Self { roots })
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ssz::Encode as SszEncode;
+
+    #[test]
+    fn test_blocks_by_root_backward_compatibility() {
+        // Create some test roots
+        let root1 = H256::from_slice(&[1u8; 32]);
+        let root2 = H256::from_slice(&[2u8; 32]);
+        let roots_list =
+            RequestedBlockRoots::new(vec![root1, root2]).expect("Failed to create roots list");
+
+        // Encode as old format (direct list, similar to transparent)
+        let old_format_bytes = roots_list.as_ssz_bytes();
+
+        // Encode as new format (container)
+        let new_request = BlocksByRootRequest {
+            roots: roots_list.clone(),
+        };
+        let new_format_bytes = new_request.as_ssz_bytes();
+
+        // Both formats should decode successfully
+        let decoded_from_old = BlocksByRootRequest::from_ssz_bytes_compat(&old_format_bytes)
+            .expect("Failed to decode old format");
+        let decoded_from_new = BlocksByRootRequest::from_ssz_bytes_compat(&new_format_bytes)
+            .expect("Failed to decode new format");
+
+        // Both should have the same roots
+        assert_eq!(decoded_from_old.roots.len(), 2);
+        assert_eq!(decoded_from_new.roots.len(), 2);
+        assert_eq!(decoded_from_old.roots[0], root1);
+        assert_eq!(decoded_from_old.roots[1], root2);
+        assert_eq!(decoded_from_new.roots[0], root1);
+        assert_eq!(decoded_from_new.roots[1], root2);
+    }
+}

crates/net/p2p/src/req_resp/mod.rs

@@ -7,6 +7,6 @@ pub use codec::Codec;
 pub use encoding::MAX_COMPRESSED_PAYLOAD_SIZE;
 pub use handlers::{build_status, fetch_block_from_peer, handle_req_resp_message};
 pub use messages::{
-    BLOCKS_BY_ROOT_PROTOCOL_V1, BlocksByRootRequest, Request, Response, ResponseCode,
+    BLOCKS_BY_ROOT_PROTOCOL_V1, BlocksByRootRequest, Request, RequestedBlockRoots, Response, ResponseCode,
     ResponsePayload, STATUS_PROTOCOL_V1, Status, error_message,
 };