feat(network): complete request-response codec implementation (Phase 2 Task 2.2)

Phase 2 Task 2.2: Complete request-response codec implementation

Implements full request-response protocol support with SSZ serialization:

1. **BlockCodec Implementation**:
   - Implemented libp2p RequestResponseCodec trait for BlockCodec
   - SSZ-based read/write for requests and responses
   - Length-prefixed framing (4-byte big-endian length prefix)
   - Size validation (1MB request limit, 10MB response limit)
   - Protocol type: &'static str ("/alys/block/1.0.0") for libp2p 0.25.3 compatibility

2. **AlysNetworkBehaviour Updates**:
   - Added request_response: Behaviour<BlockCodec> field
   - Initialized request-response behavior with BlockCodec
   - Protocol support: Full duplex (/alys/block/1.0.0)
   - Updated event enum with new request-response events:
     * BlockRequestReceived (replaces old RequestReceived)
     * BlockResponseReceived
     * RequestSent
     * ResponseSent
     * RequestFailed
   - Implemented From<Event<BlockRequest, BlockResponse>> for event conversion

3. **SwarmCommand Handler Implementation**:
   - SendRequest: Calls swarm.behaviour_mut().request_response.send_request()
   - SendResponse: Calls swarm.behaviour_mut().request_response.send_response()
   - Both handlers properly integrated in swarm polling task select! loop

4. **Event Handling in handle_network_event**:
   - BlockRequestReceived: Sends error response (Phase 3 will integrate with ChainActor)
   - BlockResponseReceived: Handles Blocks/ChainStatus/Error variants
   - RequestSent: Logs and records metrics
   - ResponseSent: Logs and records metrics
   - RequestFailed: Penalizes peer reputation

5. **swarm_factory.rs Updates**:
   - Added request_response behavior initialization
   - Consistent codec configuration across behaviour.rs and swarm_factory.rs

6. **libp2p 0.25.3 Compatibility Fixes**:
   - Protocol type: &'static str instead of StreamProtocol
   - RequestId instead of InboundRequestId/OutboundRequestId
   - SSZ DecodeError formatting with {:?} instead of {}

7. **Test Fixture Updates**:
   - Removed obsolete RequestReceived event from test fixtures
   - Added PeerIdentified event for test coverage

Files modified:
- app/src/actors_v2/network/protocols/request_response.rs (codec implementation)
- app/src/actors_v2/network/behaviour.rs (event types, From implementations)
- app/src/actors_v2/network/network_actor.rs (handler updates)
- app/src/actors_v2/network/swarm_factory.rs (behavior initialization)
- app/src/actors_v2/testing/network/fixtures.rs (test data fixes)

**Verification**:
- Phase 1 integration test passes ✅
- Code compiles with 0 errors (warnings only)
- Request-response protocol fully functional in swarm
- Ready for Phase 3 integration with ChainActor/SyncActor

Author: michaelgpt

app/src/actors_v2/network/behaviour.rs

@@ -1,12 +1,13 @@
 //! NetworkActor V2 libp2p Behaviour (Real Implementation)
 //!
 //! Complete network behaviour with libp2p NetworkBehaviour derive macro.
-//! Includes: Gossipsub, Identify, and mDNS protocols.
+//! Includes: Gossipsub, Identify, mDNS, and Request-Response protocols.
 
 use anyhow::{Result, Context as AnyhowContext};
 use libp2p::swarm::NetworkBehaviour;
 use libp2p::PeerId;
 use super::NetworkConfig;
+use super::protocols::{BlockProtocol, BlockCodec, BlockRequest, BlockResponse};
 
 /// Complete V2 network behaviour with real libp2p protocols
 #[derive(NetworkBehaviour)]
@@ -15,6 +16,7 @@ pub struct AlysNetworkBehaviour {
     pub gossipsub: libp2p::gossipsub::Behaviour,
     pub identify: libp2p::identify::Behaviour,
     pub mdns: libp2p::mdns::tokio::Behaviour,
+    pub request_response: libp2p::request_response::Behaviour<BlockCodec>,
 }
 
 /// Network behaviour events
@@ -27,17 +29,32 @@ pub enum AlysNetworkBehaviourEvent {
         source_peer: String,
         message_id: String,
     },
-    /// Request received from peer
-    RequestReceived {
-        request: crate::actors_v2::network::messages::NetworkRequest,
-        source_peer: String,
-        request_id: String,
+    /// Block request received from peer
+    BlockRequestReceived {
+        peer_id: String,
+        request_id: libp2p::request_response::RequestId,
+        request: BlockRequest,
+        channel: libp2p::request_response::ResponseChannel<BlockResponse>,
+    },
+    /// Block response received from peer
+    BlockResponseReceived {
+        peer_id: String,
+        request_id: libp2p::request_response::RequestId,
+        response: BlockResponse,
     },
-    /// Response received from peer
-    ResponseReceived {
-        response: Vec<u8>,
+    /// Request sent successfully
+    RequestSent {
         peer_id: String,
-        request_id: String,
+        request_id: libp2p::request_response::RequestId,
+    },
+    /// Response sent successfully
+    ResponseSent {
+        peer_id: String,
+    },
+    /// Request failed
+    RequestFailed {
+        peer_id: String,
+        error: String,
     },
     /// Peer connected
     PeerConnected {
@@ -118,10 +135,22 @@ impl AlysNetworkBehaviour {
         )
         .context("Failed to create mDNS behaviour")?;
 
+        // Configure Request-Response with BlockCodec
+        let request_response = {
+            let protocols = std::iter::once(("/alys/block/1.0.0", libp2p::request_response::ProtocolSupport::Full));
+            let cfg = libp2p::request_response::Config::default();
+            libp2p::request_response::Behaviour::with_codec(
+                BlockCodec::new(),
+                protocols,
+                cfg,
+            )
+        };
+
         Ok(Self {
             gossipsub,
             identify,
             mdns,
+            request_response,
         })
     }
 
@@ -243,3 +272,49 @@ impl From<libp2p::mdns::Event> for AlysNetworkBehaviourEvent {
         }
     }
 }
+
+impl From<libp2p::request_response::Event<BlockRequest, BlockResponse>> for AlysNetworkBehaviourEvent {
+    fn from(event: libp2p::request_response::Event<BlockRequest, BlockResponse>) -> Self {
+        use libp2p::request_response::Event;
+
+        match event {
+            Event::Message { peer, message } => {
+                use libp2p::request_response::Message;
+                match message {
+                    Message::Request { request_id, request, channel } => {
+                        AlysNetworkBehaviourEvent::BlockRequestReceived {
+                            peer_id: peer.to_string(),
+                            request_id,
+                            request,
+                            channel,
+                        }
+                    }
+                    Message::Response { request_id, response } => {
+                        AlysNetworkBehaviourEvent::BlockResponseReceived {
+                            peer_id: peer.to_string(),
+                            request_id,
+                            response,
+                        }
+                    }
+                }
+            }
+            Event::OutboundFailure { peer, request_id, error } => {
+                AlysNetworkBehaviourEvent::RequestFailed {
+                    peer_id: peer.to_string(),
+                    error: format!("{:?}", error),
+                }
+            }
+            Event::InboundFailure { peer, request_id, error } => {
+                AlysNetworkBehaviourEvent::RequestFailed {
+                    peer_id: peer.to_string(),
+                    error: format!("{:?}", error),
+                }
+            }
+            Event::ResponseSent { peer, request_id } => {
+                AlysNetworkBehaviourEvent::ResponseSent {
+                    peer_id: peer.to_string(),
+                }
+            }
+        }
+    }
+}

app/src/actors_v2/network/network_actor.rs

@@ -332,21 +332,102 @@ impl NetworkActor {
                 }
             }
 
-            AlysNetworkBehaviourEvent::RequestReceived { request, source_peer, request_id } => {
-                tracing::debug!("Received request {} from peer {}: {:?}",
-                    request_id, source_peer, request);
+            AlysNetworkBehaviourEvent::BlockRequestReceived { peer_id, request_id, request, channel } => {
+                tracing::debug!(
+                    peer_id = %peer_id,
+                    request_id = ?request_id,
+                    request = ?request,
+                    "Received block request from peer"
+                );
+
+                self.metrics.record_message_received(0); // Size would be calculated
+
+                // Handle the block request - forward to ChainActor/SyncActor for data retrieval
+                // For now, send an error response (Phase 3 will integrate with ChainActor)
+                if let Some(cmd_tx) = self.swarm_cmd_tx.as_ref() {
+                    let error_response = BlockResponse::Error(
+                        crate::actors_v2::network::protocols::request_response::ErrorResponse {
+                            message: b"Block requests not yet implemented".to_vec(),
+                        }
+                    );
+
+                    let cmd = SwarmCommand::SendResponse {
+                        channel,
+                        response: error_response,
+                    };
+
+                    if let Err(e) = cmd_tx.try_send(cmd) {
+                        tracing::error!(error = ?e, "Failed to send response command");
+                    }
+                } else {
+                    tracing::warn!("Cannot send response: command channel not available");
+                }
+            }
+
+            AlysNetworkBehaviourEvent::BlockResponseReceived { peer_id, request_id, response } => {
+                tracing::info!(
+                    peer_id = %peer_id,
+                    request_id = ?request_id,
+                    response = ?response,
+                    "Received block response from peer"
+                );
 
                 self.metrics.record_message_received(0); // Size would be calculated
 
-                // Handle the request
-                self.handle_peer_request(request, source_peer, request_id)?;
+                // Forward to SyncActor or handle internally based on response type
+                match response {
+                    BlockResponse::Blocks(blocks_response) => {
+                        tracing::info!(
+                            block_count = blocks_response.blocks.len(),
+                            "Received blocks from peer"
+                        );
+                        // TODO: Forward to SyncActor in Phase 3
+                    }
+                    BlockResponse::ChainStatus(status) => {
+                        tracing::info!(
+                            height = status.height,
+                            head_hash = ?status.head_hash,
+                            "Received chain status from peer"
+                        );
+                        // TODO: Forward to SyncActor in Phase 3
+                    }
+                    BlockResponse::Error(error) => {
+                        let error_msg = String::from_utf8_lossy(&error.message);
+                        tracing::warn!(
+                            peer_id = %peer_id,
+                            error = %error_msg,
+                            "Peer returned error response"
+                        );
+                        self.peer_manager.update_peer_reputation(&peer_id, -1.0);
+                    }
+                }
+            }
+
+            AlysNetworkBehaviourEvent::RequestSent { peer_id, request_id } => {
+                tracing::debug!(
+                    peer_id = %peer_id,
+                    request_id = ?request_id,
+                    "Request sent successfully"
+                );
+                self.metrics.record_message_sent(0); // Size would be calculated
             }
 
-            AlysNetworkBehaviourEvent::ResponseReceived { response, peer_id, request_id } => {
-                tracing::debug!("Received response {} from peer {} ({} bytes)",
-                    request_id, peer_id, response.len());
+            AlysNetworkBehaviourEvent::ResponseSent { peer_id } => {
+                tracing::debug!(
+                    peer_id = %peer_id,
+                    "Response sent successfully"
+                );
+                self.metrics.record_message_sent(0); // Size would be calculated
+            }
 
-                self.metrics.record_message_received(response.len());
+            AlysNetworkBehaviourEvent::RequestFailed { peer_id, error } => {
+                tracing::warn!(
+                    peer_id = %peer_id,
+                    error = %error,
+                    "Request-response operation failed"
+                );
+                self.peer_manager.update_peer_reputation(&peer_id, -2.0);
+                self.metrics.record_block_response_error();
             }
 
             AlysNetworkBehaviourEvent::PeerConnected { peer_id, address } => {
@@ -700,15 +781,30 @@ impl Handler<NetworkMessage> for NetworkActor {
                                         let _ = response_tx.send(result);
                                     }
 
-                                    Some(SwarmCommand::SendRequest { peer_id: _, request: _, response_tx }) => {
-                                        // TODO: Phase 2 Task 2.2 - Implement when request_response behavior is added
-                                        tracing::warn!("SendRequest not yet implemented - Phase 2 Task 2.2");
-                                        let _ = response_tx.send(Err("Request-response protocol not yet implemented".to_string()));
+                                    Some(SwarmCommand::SendRequest { peer_id, request, response_tx }) => {
+                                        // Phase 2 Task 2.2: Send request-response request via request_response behavior
+                                        let request_id = swarm.behaviour_mut().request_response
+                                            .send_request(&peer_id, request);
+
+                                        tracing::debug!(
+                                            peer_id = %peer_id,
+                                            request_id = ?request_id,
+                                            "Sent request-response request"
+                                        );
+
+                                        let _ = response_tx.send(Ok(request_id));
                                     }
 
-                                    Some(SwarmCommand::SendResponse { channel: _, response: _ }) => {
-                                        // TODO: Phase 2 Task 2.2 - Implement when request_response behavior is added
-                                        tracing::warn!("SendResponse not yet implemented - Phase 2 Task 2.2");
+                                    Some(SwarmCommand::SendResponse { channel, response }) => {
+                                        // Phase 2 Task 2.2: Send request-response response via request_response behavior
+                                        match swarm.behaviour_mut().request_response.send_response(channel, response) {
+                                            Ok(_) => {
+                                                tracing::debug!("Sent request-response response");
+                                            }
+                                            Err(e) => {
+                                                tracing::error!(error = ?e, "Failed to send request-response response");
+                                            }
+                                        }
                                     }
 
                                     None => {