Add JSON-RPC endpoints for blocks (lambdaclass#301)

## Motivation

Closes lambdaclass#75. There's currently no way to inspect individual blocks over
HTTP — useful for debugging, integration tests, and comparing state
across clients.

## Description

Adds two debug endpoints:

- `GET /lean/v0/blocks/{block_id}` — returns the block as JSON
- `GET /lean/v0/blocks/{block_id}/header` — returns the block header as
JSON

`block_id` is either a `0x`-prefixed 32-byte hex root or a decimal slot.
Slot lookups use the head state's `historical_block_hashes`, so only
canonical blocks are reachable by slot — side-fork blocks must be
addressed by their root. Invalid ids return 400; unknown/empty slots or
missing roots return 404.

Supporting changes:
- `Serialize` on `Block`, `BlockBody`, `AggregatedAttestation`, and
`AttestationData`. Custom serializers for the two `SszList`/`SszBitlist`
  fields (attestations as a JSON array, aggregation_bits as a `0x`-hex
  string matching the beacon API convention).
- New `Store::get_block`, which returns header+body without signatures
  and works for the genesis block (unlike `get_signed_block`, which
  requires a signature entry).

## How to Test

```bash
curl -s http://127.0.0.1:5052/lean/v0/blocks/0x<root> | jq .
curl -s http://127.0.0.1:5052/lean/v0/blocks/42 | jq .
curl -s http://127.0.0.1:5052/lean/v0/blocks/42/header | jq .
```

Unit tests in `crates/net/rpc/src/lib.rs` cover happy paths (by root, by
slot, header variant) and error paths (400 invalid id, 404 missing root,
404 future slot, 404 empty slot).

## Closes

Closes lambdaclass#75

Author: pablodeymo

CLAUDE.md

@@ -294,6 +294,8 @@ The RPC crate runs **two independent Axum servers** on separate ports, allowing
 - `GET /lean/v0/checkpoints/justified` — justified checkpoint (JSON)
 - `GET /lean/v0/fork_choice` — fork choice tree (JSON)
 - `GET /lean/v0/fork_choice/ui` — interactive D3.js visualization
+- `GET /lean/v0/blocks/{block_id}` — block as JSON; `block_id` is a `0x`-prefixed 32-byte hex root or a decimal slot
+- `GET /lean/v0/blocks/{block_id}/header` — block header as JSON
 - Requires `Store` access
 
 ### Metrics Server (`:5054`)

Cargo.lock

@@ -1,5 +1,7 @@
+use libssz::SszEncode as _;
 use libssz_derive::{HashTreeRoot, SszDecode, SszEncode};
 use libssz_types::{SszBitlist, SszVector};
+use serde::{Serialize, Serializer};
 
 use crate::{
     block::AggregatedSignatureProof,
@@ -19,7 +21,7 @@ pub struct Attestation {
 }
 
 /// Attestation content describing the validator's observed chain view.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, SszEncode, SszDecode, HashTreeRoot)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, SszEncode, SszDecode, HashTreeRoot)]
 pub struct AttestationData {
     /// The slot for which the attestation is made.
     pub slot: u64,
@@ -57,9 +59,10 @@ pub struct SignedAttestation {
 pub type XmssSignature = SszVector<u8, SIGNATURE_SIZE>;
 
 /// Aggregated attestation consisting of participation bits and message.
-#[derive(Debug, Clone, SszEncode, SszDecode, HashTreeRoot)]
+#[derive(Debug, Clone, Serialize, SszEncode, SszDecode, HashTreeRoot)]
 pub struct AggregatedAttestation {
     /// Bitfield indicating which validators participated in the aggregation.
+    #[serde(serialize_with = "serialize_aggregation_bits")]
     pub aggregation_bits: AggregationBits,
 
     /// Combined attestation data similar to the beacon chain format.
@@ -75,6 +78,16 @@ pub struct AggregatedAttestation {
 /// in some collective action (attestation, signature aggregation, etc.).
 pub type AggregationBits = SszBitlist<4096>;
 
+/// Serialize an `AggregationBits` bitlist as a `0x`-prefixed hex string of its
+/// SSZ encoding (matching the beacon API convention).
+fn serialize_aggregation_bits<S>(bits: &AggregationBits, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let encoded = format!("0x{}", hex::encode(bits.to_ssz()));
+    serializer.serialize_str(&encoded)
+}
+
 /// Returns the indices of set bits in an `AggregationBits` bitfield as validator IDs.
 pub fn validator_indices(bits: &AggregationBits) -> impl Iterator<Item = u64> + '_ {
     (0..bits.len()).filter_map(move |i| {

crates/common/types/src/attestation.rs

@@ -1,4 +1,4 @@
-use serde::Serialize;
+use serde::{Serialize, Serializer, ser::SerializeSeq};
 
 use libssz_derive::{HashTreeRoot, SszDecode, SszEncode};
 use libssz_types::SszList;
@@ -142,7 +142,7 @@ pub struct BlockHeader {
 }
 
 /// A complete block including header and body.
-#[derive(Debug, Clone, SszEncode, SszDecode, HashTreeRoot)]
+#[derive(Debug, Clone, Serialize, SszEncode, SszDecode, HashTreeRoot)]
 pub struct Block {
     /// The slot in which the block was proposed.
     pub slot: u64,
@@ -192,14 +192,29 @@ impl Block {
 ///
 /// Currently, the main operation is voting. Validators submit attestations which are
 /// packaged into blocks.
-#[derive(Debug, Default, Clone, SszEncode, SszDecode, HashTreeRoot)]
+#[derive(Debug, Default, Clone, Serialize, SszEncode, SszDecode, HashTreeRoot)]
 pub struct BlockBody {
     /// Plain validator attestations carried in the block body.
     ///
     /// Individual signatures live in the aggregated block signature list, so
     /// these entries contain only attestation data without per-attestation signatures.
+    #[serde(serialize_with = "serialize_attestations")]
     pub attestations: AggregatedAttestations,
 }
 
 /// List of aggregated attestations included in a block.
 pub type AggregatedAttestations = SszList<AggregatedAttestation, 4096>;
+
+fn serialize_attestations<S>(
+    attestations: &AggregatedAttestations,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut seq = serializer.serialize_seq(Some(attestations.len()))?;
+    for attestation in attestations.iter() {
+        seq.serialize_element(attestation)?;
+    }
+    seq.end()
+}

crates/common/types/src/block.rs

@@ -23,6 +23,7 @@ ethlambda-types.workspace = true
 libssz.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+hex.workspace = true
 tracing.workspace = true
 jemalloc_pprof.workspace = true
 

crates/net/rpc/Cargo.toml

@@ -0,0 +1,100 @@
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+};
+use ethlambda_storage::Store;
+use ethlambda_types::primitives::H256;
+use serde_json::json;
+
+use crate::json_response;
+
+/// `GET /lean/v0/blocks/:block_id` — returns the block as JSON.
+///
+/// `block_id` can be a `0x`-prefixed 32-byte hex root or a decimal slot.
+pub async fn get_block(
+    Path(block_id): Path<String>,
+    State(store): State<Store>,
+) -> impl IntoResponse {
+    let root = match resolve_block_id(&store, &block_id) {
+        Ok(root) => root,
+        Err(err) => return err.into_response(),
+    };
+
+    match store.get_block(&root) {
+        Some(block) => json_response(block),
+        None => BlockIdError::NotFound.into_response(),
+    }
+}
+
+/// `GET /lean/v0/blocks/:block_id/header` — returns the block header as JSON.
+pub async fn get_block_header(
+    Path(block_id): Path<String>,
+    State(store): State<Store>,
+) -> impl IntoResponse {
+    let root = match resolve_block_id(&store, &block_id) {
+        Ok(root) => root,
+        Err(err) => return err.into_response(),
+    };
+
+    match store.get_block_header(&root) {
+        Some(header) => json_response(header),
+        None => BlockIdError::NotFound.into_response(),
+    }
+}
+
+/// Resolve a `block_id` (hex root or decimal slot) into a block root.
+///
+/// Slot lookups use the head state's `historical_block_hashes`, so only
+/// canonical blocks are reachable by slot — blocks on side forks must be
+/// addressed by their root.
+fn resolve_block_id(store: &Store, block_id: &str) -> Result<H256, BlockIdError> {
+    if let Some(hex_body) = block_id.strip_prefix("0x") {
+        parse_root(hex_body)
+    } else if block_id.chars().all(|c| c.is_ascii_digit()) {
+        let slot: u64 = block_id.parse().map_err(|_| BlockIdError::Invalid)?;
+        resolve_slot(store, slot)
+    } else {
+        Err(BlockIdError::Invalid)
+    }
+}
+
+fn parse_root(hex_body: &str) -> Result<H256, BlockIdError> {
+    let bytes = hex::decode(hex_body).map_err(|_| BlockIdError::Invalid)?;
+    if bytes.len() != 32 {
+        return Err(BlockIdError::Invalid);
+    }
+    let mut arr = [0u8; 32];
+    arr.copy_from_slice(&bytes);
+    Ok(H256(arr))
+}
+
+fn resolve_slot(store: &Store, slot: u64) -> Result<H256, BlockIdError> {
+    let head_state = store.head_state();
+    let root = head_state
+        .historical_block_hashes
+        .get(slot as usize)
+        .ok_or(BlockIdError::NotFound)?;
+    if root.is_zero() {
+        return Err(BlockIdError::NotFound);
+    }
+    Ok(*root)
+}
+
+#[derive(Debug)]
+enum BlockIdError {
+    Invalid,
+    NotFound,
+}
+
+impl IntoResponse for BlockIdError {
+    fn into_response(self) -> axum::response::Response {
+        let (status, message) = match self {
+            BlockIdError::Invalid => (StatusCode::BAD_REQUEST, "invalid block_id"),
+            BlockIdError::NotFound => (StatusCode::NOT_FOUND, "block not found"),
+        };
+        let mut response = json_response(json!({ "error": message }));
+        *response.status_mut() = status;
+        response
+    }
+}