diff --git a/.gitignore b/.gitignore
index 34cfc5a..6d8dcc2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -78,4 +78,7 @@ tests/fixtures/**/*.json
 ci-build*
 
 # Internal docs
-internal-docs*
\ No newline at end of file
+internal-docs*
+
+# External clients
+external-clients*
\ No newline at end of file
diff --git a/include/lantern/networking/reqresp_service.h b/include/lantern/networking/reqresp_service.h
index dd60f89..7cdbaa4 100644
--- a/include/lantern/networking/reqresp_service.h
+++ b/include/lantern/networking/reqresp_service.h
@@ -11,13 +11,9 @@
 #include "libp2p/stream.h"
 #include "peer_id/peer_id.h"
 
-#define LANTERN_REQRESP_STATUS_PROTOCOL_SNAPPY "/leanconsensus/req/status/1/ssz_snappy"
-#define LANTERN_REQRESP_STATUS_PROTOCOL_LEGACY "/leanconsensus/req/status/1/"
-#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_SNAPPY "/leanconsensus/req/lean_blocks_by_root/1/ssz_snappy"
-#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_LEGACY "/leanconsensus/req/blocks_by_root/1/ssz_snappy"
-#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_BARE "/leanconsensus/req/blocks_by_root/1/"
-#define LANTERN_REQRESP_STATUS_PROTOCOL LANTERN_REQRESP_STATUS_PROTOCOL_SNAPPY
-#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_SNAPPY
+/* Canonical protocol IDs from LeanSpec (tools/leanSpec/src/lean_spec/subspecs/networking/reqresp/message.py) */
+#define LANTERN_REQRESP_STATUS_PROTOCOL "/leanconsensus/req/status/1/"
+#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL "/leanconsensus/req/blocks_by_root/1/"
 #define LANTERN_REQRESP_STATUS_PREVIEW_BYTES 256u
 #define LANTERN_REQRESP_MAX_CHUNK_BYTES (1u << 22)
 #define LANTERN_REQRESP_MAX_CONTEXT_BYTES (1u << 20)
@@ -56,10 +52,7 @@ enum lantern_reqresp_protocol_kind {
 };
 
 #define LANTERN_STATUS_PROTOCOL_ID LANTERN_REQRESP_STATUS_PROTOCOL
-#define LANTERN_STATUS_PROTOCOL_ID_LEGACY LANTERN_REQRESP_STATUS_PROTOCOL_LEGACY
 #define LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL
-#define LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_LEGACY LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_LEGACY
-#define LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_BARE LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_BARE
 #define LANTERN_STATUS_PREVIEW_BYTES LANTERN_REQRESP_STATUS_PREVIEW_BYTES
 
 struct libp2p_host;
@@ -94,14 +87,10 @@ struct lantern_reqresp_service {
     struct libp2p_host *host;
     struct lantern_reqresp_service_callbacks callbacks;
     struct libp2p_protocol_server *status_server;
-    struct libp2p_protocol_server *status_server_legacy;
     struct libp2p_protocol_server *blocks_server;
-    struct libp2p_protocol_server *blocks_server_legacy;
-    struct libp2p_protocol_server *blocks_server_bare;
     struct libp2p_subscription *event_subscription;
     int lock_initialized;
     pthread_mutex_t lock;
-    struct lantern_string_list legacy_peers;
 };
 
 #ifdef __cplusplus
@@ -114,13 +103,6 @@ int lantern_reqresp_service_request_status(
     struct lantern_reqresp_service *service,
     const peer_id_t *peer_id,
     const char *peer_id_text);
-void lantern_reqresp_service_hint_peer_legacy(
-    struct lantern_reqresp_service *service,
-    const char *peer_id_text,
-    bool legacy);
-int lantern_reqresp_service_peer_prefers_legacy(
-    const struct lantern_reqresp_service *service,
-    const char *peer_id_text);
 int lantern_reqresp_service_start(
     struct lantern_reqresp_service *service,
     const struct lantern_reqresp_service_config *config);
diff --git a/src/core/client_network.c b/src/core/client_network.c
index 2552bfa..76f72e9 100644
--- a/src/core/client_network.c
+++ b/src/core/client_network.c
@@ -359,38 +359,16 @@ void request_status_now(struct lantern_client *client, const peer_id_t *peer, co
 
 
 /**
- * Seed reqresp service with peer legacy mode hints from genesis config.
+ * Seed reqresp service with peer mode hints from genesis config.
  *
  * @param client  Client instance
  *
+ * @note Currently a no-op as only canonical protocol is supported.
  * @note Thread safety: This function is thread-safe
  */
 void lantern_client_seed_reqresp_peer_modes(struct lantern_client *client)
 {
-    if (!client)
-    {
-        return;
-    }
-#if defined(LANTERN_REQRESP_STATUS_PROTOCOL_LEGACY) \
-    || defined(LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_LEGACY)
-    const struct lantern_validator_config *config = &client->genesis.validator_config;
-    if (!config || !config->entries)
-    {
-        return;
-    }
-    for (size_t i = 0; i < config->count; ++i)
-    {
-        const struct lantern_validator_config_entry *entry = &config->entries[i];
-        if (!entry->peer_id_text || !entry->peer_id_text[0])
-        {
-            continue;
-        }
-        int legacy = (entry->client_kind == LANTERN_VALIDATOR_CLIENT_QLEAN);
-        lantern_reqresp_service_hint_peer_legacy(&client->reqresp, entry->peer_id_text, legacy);
-    }
-#else
     (void)client;
-#endif
 }
 
 
diff --git a/src/core/client_network_internal.h b/src/core/client_network_internal.h
index 0052fc0..d69eff4 100644
--- a/src/core/client_network_internal.h
+++ b/src/core/client_network_internal.h
@@ -97,13 +97,12 @@ struct lantern_peer_status_entry
 };
 
 /**
- * Blocks-by-root protocol variants for fallback handling.
+ * Blocks-by-root protocol variant.
+ * Only the canonical protocol is supported per LeanSpec.
  */
 enum lantern_blocks_req_variant
 {
     LANTERN_BLOCKS_REQ_VARIANT_PRIMARY = 0,
-    LANTERN_BLOCKS_REQ_VARIANT_LEGACY_SNAPPY = 1,
-    LANTERN_BLOCKS_REQ_VARIANT_BARE = 2,
 };
 
 
diff --git a/src/core/client_reqresp_blocks.c b/src/core/client_reqresp_blocks.c
index 81b96e0..4844c9a 100644
--- a/src/core/client_reqresp_blocks.c
+++ b/src/core/client_reqresp_blocks.c
@@ -95,46 +95,31 @@ static bool blocks_next_variant(
     enum lantern_blocks_req_variant current,
     enum lantern_blocks_req_variant *out_next)
 {
-    if (!out_next)
-    {
-        return false;
-    }
-    switch (current)
-    {
-    case LANTERN_BLOCKS_REQ_VARIANT_PRIMARY:
-        *out_next = LANTERN_BLOCKS_REQ_VARIANT_LEGACY_SNAPPY;
-        return true;
-    case LANTERN_BLOCKS_REQ_VARIANT_LEGACY_SNAPPY:
-        *out_next = LANTERN_BLOCKS_REQ_VARIANT_BARE;
-        return true;
-    default:
-        break;
-    }
+    (void)current;
+    (void)out_next;
+    /* No fallback variants - only canonical protocol supported */
     return false;
 }
 
 static const char *blocks_protocol_id_for_variant(enum lantern_blocks_req_variant variant)
 {
-    switch (variant)
-    {
-    case LANTERN_BLOCKS_REQ_VARIANT_LEGACY_SNAPPY:
-        return LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_LEGACY;
-    case LANTERN_BLOCKS_REQ_VARIANT_BARE:
-        return LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_BARE;
-    case LANTERN_BLOCKS_REQ_VARIANT_PRIMARY:
-    default:
-        return LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID;
-    }
+    (void)variant;
+    /* Only canonical protocol ID supported */
+    return LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID;
 }
 
 static bool blocks_variant_uses_raw_snappy(enum lantern_blocks_req_variant variant)
 {
-    return variant != LANTERN_BLOCKS_REQ_VARIANT_PRIMARY;
+    (void)variant;
+    /* Always use framed snappy (canonical format) */
+    return false;
 }
 
 static bool blocks_variant_is_legacy(enum lantern_blocks_req_variant variant)
 {
-    return variant != LANTERN_BLOCKS_REQ_VARIANT_PRIMARY;
+    (void)variant;
+    /* No legacy variants */
+    return false;
 }
 
 
@@ -358,7 +343,7 @@ static void *block_request_worker(void *arg)
     request.roots.items[0] = ctx->root;
 
     bool use_raw_snappy = blocks_variant_uses_raw_snappy(ctx->variant);
-    size_t raw_size = sizeof(uint32_t) + (request.roots.length * LANTERN_ROOT_SIZE);
+    size_t raw_size = request.roots.length * LANTERN_ROOT_SIZE;
     raw_request = (uint8_t *)malloc(raw_size > 0 ? raw_size : 1u);
     if (!raw_request)
     {
@@ -786,10 +771,6 @@ static void *block_request_worker(void *arg)
     {
         free(initial_chunk);
     }
-    if (request_success && ctx->variant != LANTERN_BLOCKS_REQ_VARIANT_PRIMARY && ctx->client && ctx->peer_text[0])
-    {
-        lantern_reqresp_service_hint_peer_legacy(&ctx->client->reqresp, ctx->peer_text, true);
-    }
     free(response);
     free(payload);
     free(raw_request);
@@ -1087,7 +1068,7 @@ static int schedule_blocks_request_variant(
  * @param client        Client instance
  * @param peer_id_text  Peer ID string
  * @param root          Block root to request
- * @param use_legacy    True to use legacy protocol
+ * @param use_legacy    Unused (only canonical protocol supported)
  * @return 0 on success
  * @return LANTERN_CLIENT_ERR_INVALID_PARAM if any parameter is NULL, the peer ID is invalid, or the root is zero
  * @return LANTERN_CLIENT_ERR_ALLOC if allocation fails
@@ -1101,7 +1082,6 @@ int lantern_client_schedule_blocks_request(
     const LanternRoot *root,
     bool use_legacy)
 {
-    enum lantern_blocks_req_variant variant =
-        use_legacy ? LANTERN_BLOCKS_REQ_VARIANT_LEGACY_SNAPPY : LANTERN_BLOCKS_REQ_VARIANT_PRIMARY;
-    return schedule_blocks_request_variant(client, peer_id_text, root, variant);
+    (void)use_legacy; /* Only canonical protocol supported */
+    return schedule_blocks_request_variant(client, peer_id_text, root, LANTERN_BLOCKS_REQ_VARIANT_PRIMARY);
 }
diff --git a/src/core/client_reqresp_stream.c b/src/core/client_reqresp_stream.c
index b22d891..48a7cca 100644
--- a/src/core/client_reqresp_stream.c
+++ b/src/core/client_reqresp_stream.c
@@ -181,23 +181,16 @@ static void init_peer_log_metadata(
 
 /**
  * @brief Records peer legacy framing preference.
+ * @note Currently a no-op as only canonical protocol is supported.
  */
 static void hint_peer_legacy_framing(
     struct lantern_reqresp_service *service,
     const char *peer_text,
     bool is_legacy)
 {
-    if (!service || !peer_text || peer_text[0] == '\0')
-    {
-        return;
-    }
-
-#if defined(LANTERN_REQRESP_STATUS_PROTOCOL_LEGACY) \
-    || defined(LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_LEGACY)
-    lantern_reqresp_service_hint_peer_legacy(service, peer_text, is_legacy ? 1 : 0);
-#else
+    (void)service;
+    (void)peer_text;
     (void)is_legacy;
-#endif
 }
 
 
diff --git a/src/networking/messages.c b/src/networking/messages.c
index b8f86eb..ec2783b 100644
--- a/src/networking/messages.c
+++ b/src/networking/messages.c
@@ -388,25 +388,17 @@ int lantern_network_blocks_by_root_request_encode(
     if (req->roots.length > LANTERN_MAX_REQUEST_BLOCKS) {
         return -1;
     }
-    /* SSZ container: one variable field (roots list) -> 4‑byte offset + payload */
-    const uint32_t offset = (uint32_t)sizeof(uint32_t);
     size_t roots_bytes = req->roots.length * LANTERN_ROOT_SIZE;
-    size_t total_bytes = sizeof(uint32_t) + roots_bytes;
-    if (out_len < total_bytes) {
+    if (out_len < roots_bytes) {
         return -1;
     }
-    /* fixed part */
-    if (write_u32_le(offset, out, out_len) != 0) {
-        return -1;
-    }
-    /* variable part */
     if (roots_bytes > 0) {
         if (!req->roots.items) {
             return -1;
         }
-        memcpy(out + sizeof(uint32_t), req->roots.items, roots_bytes);
+        memcpy(out, req->roots.items, roots_bytes);
     }
-    *written = total_bytes;
+    *written = roots_bytes;
     return 0;
 }
 
@@ -414,39 +406,17 @@ int lantern_network_blocks_by_root_request_decode(
     LanternBlocksByRootRequest *req,
     const uint8_t *data,
     size_t data_len) {
-    if (!req || (!data && data_len > 0)) {
+    if (!req) {
         return -1;
     }
-
-    /* New-format decode: expect 4‑byte offset to variable section */
-    if (data_len >= sizeof(uint32_t)) {
-        uint32_t offset = 0;
-        if (read_u32_le(data, data_len, &offset) != 0) {
-            return -1;
-        }
-        if (offset >= sizeof(uint32_t) && offset <= data_len && (offset % sizeof(uint32_t)) == 0) {
-            size_t roots_bytes = data_len - offset;
-            if (roots_bytes % LANTERN_ROOT_SIZE != 0) {
-                return -1;
-            }
-            size_t count = roots_bytes / LANTERN_ROOT_SIZE;
-            if (count > LANTERN_MAX_REQUEST_BLOCKS) {
-                return -1;
-            }
-            if (lantern_root_list_resize(&req->roots, (uint32_t)count) != 0) {
-                return -1;
-            }
-            if (count > 0) {
-                if (!req->roots.items) {
-                    return -1;
-                }
-                memcpy(req->roots.items, data + offset, roots_bytes);
-            }
-            return 0;
-        }
+    if (data_len == 0) {
+        return lantern_root_list_resize(&req->roots, 0) == 0 ? 0 : -1;
+    }
+    if (!data) {
+        return -1;
     }
 
-    /* Legacy fallback (no offset) */
+    /* Canonical SSZ list encoding: raw concatenated roots. */
     if (data_len % LANTERN_ROOT_SIZE != 0) {
         return -1;
     }
@@ -479,7 +449,7 @@ int lantern_network_blocks_by_root_request_encode_snappy(
     if (!req || !out || !written) {
         return -1;
     }
-    size_t raw_size = sizeof(uint32_t) + (req->roots.length * LANTERN_ROOT_SIZE);
+    size_t raw_size = req->roots.length * LANTERN_ROOT_SIZE;
     uint8_t *raw = alloc_scratch(raw_size);
     if (!raw) {
         return -1;
diff --git a/src/networking/reqresp_service.c b/src/networking/reqresp_service.c
index b029a48..f0d07e1 100644
--- a/src/networking/reqresp_service.c
+++ b/src/networking/reqresp_service.c
@@ -147,13 +147,8 @@ static void lantern_reqresp_service_clear(struct lantern_reqresp_service *servic
     service->callbacks.status_failure = NULL;
     service->callbacks.collect_blocks = NULL;
     service->status_server = NULL;
-    service->status_server_legacy = NULL;
     service->blocks_server = NULL;
-    service->blocks_server_legacy = NULL;
-    service->blocks_server_bare = NULL;
     service->event_subscription = NULL;
-    lantern_string_list_reset(&service->legacy_peers);
-    lantern_string_list_init(&service->legacy_peers);
 }
 
 void lantern_reqresp_service_init(struct lantern_reqresp_service *service) {
@@ -162,7 +157,6 @@ void lantern_reqresp_service_init(struct lantern_reqresp_service *service) {
     }
     memset(service, 0, sizeof(*service));
     service->lock_initialized = 0;
-    lantern_string_list_init(&service->legacy_peers);
 }
 
 static void destroy_lock(struct lantern_reqresp_service *service) {
@@ -186,19 +180,10 @@ void lantern_reqresp_service_reset(struct lantern_reqresp_service *service) {
     if (service->status_server && host) {
         (void)libp2p_host_unlisten(host, service->status_server);
     }
-    if (service->status_server_legacy && host) {
-        (void)libp2p_host_unlisten(host, service->status_server_legacy);
-    }
 
     if (service->blocks_server && host) {
         (void)libp2p_host_unlisten(host, service->blocks_server);
     }
-    if (service->blocks_server_legacy && host) {
-        (void)libp2p_host_unlisten(host, service->blocks_server_legacy);
-    }
-    if (service->blocks_server_bare && host) {
-        (void)libp2p_host_unlisten(host, service->blocks_server_bare);
-    }
 
     destroy_lock(service);
     lantern_reqresp_service_clear(service);
@@ -215,77 +200,6 @@ static void ensure_lock(struct lantern_reqresp_service *service) {
     }
 }
 
-void lantern_reqresp_service_hint_peer_legacy(
-    struct lantern_reqresp_service *service,
-    const char *peer_id_text,
-    bool legacy) {
-    if (!service || !peer_id_text || peer_id_text[0] == '\0') {
-        return;
-    }
-    ensure_lock(service);
-    if (!service->lock_initialized) {
-        return;
-    }
-
-    if (pthread_mutex_lock(&service->lock) != 0) {
-        return;
-    }
-
-    bool found = false;
-    for (size_t i = 0; i < service->legacy_peers.len; ++i) {
-        if (service->legacy_peers.items[i]
-            && strcmp(service->legacy_peers.items[i], peer_id_text) == 0) {
-            found = true;
-            break;
-        }
-    }
-
-    if (legacy) {
-        if (!found) {
-            (void)lantern_string_list_append(&service->legacy_peers, peer_id_text);
-        }
-    } else if (found) {
-        for (size_t i = 0; i < service->legacy_peers.len; ++i) {
-            if (service->legacy_peers.items[i]
-                && strcmp(service->legacy_peers.items[i], peer_id_text) == 0) {
-                free(service->legacy_peers.items[i]);
-                for (size_t j = i; j + 1 < service->legacy_peers.len; ++j) {
-                    service->legacy_peers.items[j] = service->legacy_peers.items[j + 1];
-                }
-                service->legacy_peers.len--;
-                service->legacy_peers.items[service->legacy_peers.len] = NULL;
-                break;
-            }
-        }
-    }
-
-    pthread_mutex_unlock(&service->lock);
-}
-
-int lantern_reqresp_service_peer_prefers_legacy(
-    const struct lantern_reqresp_service *service,
-    const char *peer_id_text) {
-    if (!service || !peer_id_text || peer_id_text[0] == '\0') {
-        return 0;
-    }
-    if (!service->lock_initialized) {
-        return 0;
-    }
-    if (pthread_mutex_lock((pthread_mutex_t *)&service->lock) != 0) {
-        return 0;
-    }
-    int result = 0;
-    for (size_t i = 0; i < service->legacy_peers.len; ++i) {
-        if (service->legacy_peers.items[i]
-            && strcmp(service->legacy_peers.items[i], peer_id_text) == 0) {
-            result = 1;
-            break;
-        }
-    }
-    pthread_mutex_unlock((pthread_mutex_t *)&service->lock);
-    return result;
-}
-
 static void describe_peer(const peer_id_t *peer, char *buffer, size_t length) {
     if (!buffer || length == 0) {
         return;
@@ -987,9 +901,6 @@ static void *status_worker(void *arg) {
         request_kind == STATUS_PAYLOAD_RAW_SSZ ? "raw_ssz"
             : (request_kind == STATUS_PAYLOAD_RAW_SNAPPY ? "raw_snappy" : "framed"),
         include_response_code ? "true" : "false");
-    if (request_kind != STATUS_PAYLOAD_FRAMED_SNAPPY && peer_text[0] != '\0') {
-        lantern_reqresp_service_hint_peer_legacy(service, peer_text, true);
-    }
 
     char head_hex[(LANTERN_ROOT_SIZE * 2u) + 3u];
     if (lantern_bytes_to_hex(remote_status.head.root.bytes, LANTERN_ROOT_SIZE, head_hex, sizeof(head_hex), 1) != 0) {
@@ -1395,26 +1306,12 @@ static void *status_request_worker(void *arg) {
         remote_status.finalized.slot);
 
     handle_remote_status(service, &remote_status, ctx->peer_text);
-    if (legacy_framing && peer_text[0] != '\0') {
-        lantern_reqresp_service_hint_peer_legacy(service, peer_text, true);
-    }
     failure_code = LIBP2P_ERR_OK;
 
 finish:
-    bool scheduled_retry = false;
-    if (failure_code != LIBP2P_ERR_OK && !legacy_framing && ctx->peer_text[0] != '\0') {
-        if (status_request_launch(service, &ctx->peer_id, ctx->peer_text, true, false) == 0) {
-            lantern_log_info(
-                "reqresp",
-                &meta,
-                "status[%" PRIu64 "] retrying with legacy framing",
-                trace_id);
-            scheduled_retry = true;
-        }
-    }
     close_stream(stream);
     status_request_ctx_free(ctx);
-    if (failure_code != LIBP2P_ERR_OK && !scheduled_retry) {
+    if (failure_code != LIBP2P_ERR_OK) {
         status_request_notify_failure(service, peer_text[0] ? peer_text : NULL, failure_code);
     }
     return NULL;
@@ -1444,36 +1341,6 @@ static void status_request_on_open(libp2p_stream_t *stream, void *user_data, int
     }
 
     if (err != 0 || !stream) {
-#if defined(LANTERN_STATUS_PROTOCOL_ID_LEGACY)
-        if (ctx
-            && ctx->service
-            && ctx->service->host
-            && ctx->protocol_id
-            && strcmp(ctx->protocol_id, LANTERN_STATUS_PROTOCOL_ID) == 0
-            && (err == LIBP2P_ERR_PROTO_NEGOTIATION_FAILED || err == LIBP2P_ERR_UNSUPPORTED)) {
-            ctx->protocol_id = LANTERN_STATUS_PROTOCOL_ID_LEGACY;
-            lantern_log_debug(
-                "reqresp",
-                &meta,
-                "status[%" PRIu64 "] retrying with legacy protocol=%s",
-                trace_id,
-                ctx->protocol_id);
-            int retry_rc = libp2p_host_open_stream_async(
-                ctx->service->host,
-                &ctx->peer_id,
-                ctx->protocol_id,
-                status_request_on_open,
-                ctx);
-            if (retained) {
-                close_stream(stream);
-                retained = false;
-            }
-            if (retry_rc == 0) {
-                return;
-            }
-            err = retry_rc;
-        }
-#endif
         lantern_log_warn(
             "reqresp",
             &meta,
@@ -1630,11 +1497,7 @@ int lantern_reqresp_service_request_status(
     struct lantern_reqresp_service *service,
     const peer_id_t *peer_id,
     const char *peer_id_text) {
-    bool prefer_legacy = false;
-    if (service && peer_id_text && peer_id_text[0] != '\0') {
-        prefer_legacy = lantern_reqresp_service_peer_prefers_legacy(service, peer_id_text) != 0;
-    }
-    return status_request_launch(service, peer_id, peer_id_text, prefer_legacy, true);
+    return status_request_launch(service, peer_id, peer_id_text, false, true);
 }
 
 static void *blocks_worker(void *arg) {
@@ -1700,9 +1563,6 @@ static void *blocks_worker(void *arg) {
         "blocks_by_root request framing=%s include_response_code=%s",
         request_framed ? "framed" : "raw",
         include_response_code ? "true" : "false");
-    if (!request_framed && peer_text[0] != '\0') {
-        lantern_reqresp_service_hint_peer_legacy(service, peer_text, true);
-    }
 
     LanternBlocksByRootRequest decoded_request;
     lantern_blocks_by_root_request_init(&decoded_request);
@@ -1957,10 +1817,6 @@ static void status_on_open_primary(libp2p_stream_t *stream, void *user_data) {
     status_on_open_impl(stream, user_data, LANTERN_STATUS_PROTOCOL_ID);
 }
 
-static void status_on_open_legacy(libp2p_stream_t *stream, void *user_data) {
-    status_on_open_impl(stream, user_data, LANTERN_STATUS_PROTOCOL_ID_LEGACY);
-}
-
 static void blocks_on_open_impl(libp2p_stream_t *stream, void *user_data, const char *protocol_id) {
     struct lantern_reqresp_service *service = (struct lantern_reqresp_service *)user_data;
     if (!service) {
@@ -1992,14 +1848,6 @@ static void blocks_on_open_primary(libp2p_stream_t *stream, void *user_data) {
     blocks_on_open_impl(stream, user_data, LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID);
 }
 
-static void blocks_on_open_legacy(libp2p_stream_t *stream, void *user_data) {
-    blocks_on_open_impl(stream, user_data, LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_LEGACY);
-}
-
-static void blocks_on_open_bare(libp2p_stream_t *stream, void *user_data) {
-    blocks_on_open_impl(stream, user_data, LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_BARE);
-}
-
 int lantern_reqresp_service_start(
     struct lantern_reqresp_service *service,
     const struct lantern_reqresp_service_config *config) {
@@ -2035,37 +1883,10 @@ int lantern_reqresp_service_start(
         lantern_reqresp_service_reset(service);
         return -1;
     }
-#if defined(LANTERN_STATUS_PROTOCOL_ID_LEGACY)
-    libp2p_protocol_def_t status_def_legacy = status_def;
-    status_def_legacy.protocol_id = LANTERN_STATUS_PROTOCOL_ID_LEGACY;
-    status_def_legacy.on_open = status_on_open_legacy;
-    if (libp2p_host_listen_protocol(service->host, &status_def_legacy, &service->status_server_legacy) != 0) {
-        lantern_reqresp_service_reset(service);
-        return -1;
-    }
-#endif
     if (libp2p_host_listen_protocol(service->host, &blocks_def, &service->blocks_server) != 0) {
         lantern_reqresp_service_reset(service);
         return -1;
     }
-#if defined(LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_LEGACY)
-    libp2p_protocol_def_t blocks_def_legacy = blocks_def;
-    blocks_def_legacy.protocol_id = LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_LEGACY;
-    blocks_def_legacy.on_open = blocks_on_open_legacy;
-    if (libp2p_host_listen_protocol(service->host, &blocks_def_legacy, &service->blocks_server_legacy) != 0) {
-        lantern_reqresp_service_reset(service);
-        return -1;
-    }
-#endif
-#if defined(LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_BARE)
-    libp2p_protocol_def_t blocks_def_bare = blocks_def;
-    blocks_def_bare.protocol_id = LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID_BARE;
-    blocks_def_bare.on_open = blocks_on_open_bare;
-    if (libp2p_host_listen_protocol(service->host, &blocks_def_bare, &service->blocks_server_bare) != 0) {
-        lantern_reqresp_service_reset(service);
-        return -1;
-    }
-#endif
 
     lantern_log_info(
         "network",
diff --git a/tests/unit/test_networking_messages.c b/tests/unit/test_networking_messages.c
index a9bc934..5f365cf 100644
--- a/tests/unit/test_networking_messages.c
+++ b/tests/unit/test_networking_messages.c
@@ -762,20 +762,8 @@ static void test_blocks_by_root_request_fixture(void) {
     check_zero(
         lantern_network_blocks_by_root_request_encode(&decoded, encoded, sizeof(encoded), &written),
         "request fixture encode");
-    /* NOTE: leanSpec encodes SSZ lists as raw concatenated elements (96 bytes for 3 roots),
-     * while Lantern's encoder adds a 4-byte offset prefix (100 bytes total).
-     * Both are valid SSZ encodings. We validate round-trip correctness instead of
-     * byte-for-byte equality with the fixture. */
-    LanternBlocksByRootRequest redecoded;
-    lantern_blocks_by_root_request_init(&redecoded);
-    check_zero(
-        lantern_network_blocks_by_root_request_decode(&redecoded, encoded, written),
-        "request round-trip decode");
-    CHECK(redecoded.roots.length == decoded.roots.length);
-    expect_root_seed(&redecoded.roots.items[0], 0x21);
-    expect_root_seed(&redecoded.roots.items[1], 0x52);
-    expect_root_seed(&redecoded.roots.items[2], 0x83);
-    lantern_blocks_by_root_request_reset(&redecoded);
+    CHECK(written == fixture_len);
+    CHECK(memcmp(encoded, fixture, fixture_len) == 0);
 
     size_t max_compressed = 0;
     CHECK(lantern_snappy_max_compressed_size(fixture_len, &max_compressed) == LANTERN_SNAPPY_OK);
@@ -1147,7 +1135,7 @@ static void test_blocks_by_root_request(void) {
     uint8_t encoded[128];
     size_t written = 0;
     check_zero(lantern_network_blocks_by_root_request_encode(&req, encoded, sizeof(encoded), &written), "request encode");
-    size_t expected_written = sizeof(uint32_t) + (req.roots.length * LANTERN_ROOT_SIZE);
+    size_t expected_written = req.roots.length * LANTERN_ROOT_SIZE;
     CHECK(written == expected_written);
 
     LanternBlocksByRootRequest decoded;
diff --git a/tools/debug/regenerate_networking_fixtures.c b/tools/debug/regenerate_networking_fixtures.c
index 276cb4d..871be99 100644
--- a/tools/debug/regenerate_networking_fixtures.c
+++ b/tools/debug/regenerate_networking_fixtures.c
@@ -229,7 +229,7 @@ static int generate_blocks_by_root_request_fixture(const char *output_dir) {
     fill_root(&req.roots.items[1], 0x52);
     fill_root(&req.roots.items[2], 0x83);
 
-    /* 3 roots * 32 bytes = 96 bytes, but we need extra for encoding */
+    /* 3 roots * 32 bytes = 96 bytes (raw SSZ list encoding) */
     size_t ssz_size = 1024;
     uint8_t *ssz = malloc(ssz_size);
     size_t written = 0;
diff --git a/tools/leanSpec b/tools/leanSpec
index 836b17f..772d4b1 160000
--- a/tools/leanSpec
+++ b/tools/leanSpec
@@ -1 +1 @@
-Subproject commit 836b17f34ec4b96e9dd35baef59bf8af1ba432d4
+Subproject commit 772d4b1d0547fbb7504b533d58cafb231b29287f