From e27fd74db573f5e91d28fdb9013a4900b56c5cc2 Mon Sep 17 00:00:00 2001 From: uink45 <79078981+uink45@users.noreply.github.com> Date: Fri, 30 Jan 2026 13:51:02 +1000 Subject: [PATCH] fix: align forkchoice restore with anchor vote and quiet libp2p debug stderr --- external/c-libp2p | 2 +- include/lantern/networking/reqresp_service.h | 6 +- src/core/client_network_internal.h | 1 - src/core/client_reqresp_blocks.c | 122 ++----------------- src/core/client_sync.c | 37 ++++-- src/networking/reqresp_service.c | 28 ----- 6 files changed, 40 insertions(+), 156 deletions(-) diff --git a/external/c-libp2p b/external/c-libp2p index 240f71d..9ea4737 160000 --- a/external/c-libp2p +++ b/external/c-libp2p @@ -1 +1 @@ -Subproject commit 240f71d30d71917a568284bfdb92adba9cff4ca5 +Subproject commit 9ea47375bcc9a56f859789ace60d77c162decdde diff --git a/include/lantern/networking/reqresp_service.h b/include/lantern/networking/reqresp_service.h index f27ced1..c9f303b 100644 --- a/include/lantern/networking/reqresp_service.h +++ b/include/lantern/networking/reqresp_service.h @@ -12,10 +12,8 @@ #define LANTERN_REQRESP_STATUS_PROTOCOL_SNAPPY "/leanconsensus/req/status/1/ssz_snappy" #define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_SNAPPY "/leanconsensus/req/blocks_by_root/1/ssz_snappy" -#define LANTERN_REQRESP_LEAN_BLOCKS_BY_ROOT_PROTOCOL_SNAPPY "/leanconsensus/req/lean_blocks_by_root/1/ssz_snappy" #define LANTERN_REQRESP_STATUS_PROTOCOL LANTERN_REQRESP_STATUS_PROTOCOL_SNAPPY -#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL LANTERN_REQRESP_LEAN_BLOCKS_BY_ROOT_PROTOCOL_SNAPPY -#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_FALLBACK LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_SNAPPY +#define LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_SNAPPY #define LANTERN_REQRESP_STATUS_PREVIEW_BYTES 256u #define LANTERN_REQRESP_MAX_CHUNK_BYTES (10u * 1024u * 1024u) #define LANTERN_REQRESP_MAX_CONTEXT_BYTES (1u << 20) @@ -57,7 +55,6 @@ enum lantern_reqresp_protocol_kind { #define LANTERN_STATUS_PROTOCOL_ID LANTERN_REQRESP_STATUS_PROTOCOL #define LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL -#define LANTERN_BLOCKS_BY_ROOT_PROTOCOL_FALLBACK_ID LANTERN_REQRESP_BLOCKS_BY_ROOT_PROTOCOL_FALLBACK #define LANTERN_STATUS_PREVIEW_BYTES LANTERN_REQRESP_STATUS_PREVIEW_BYTES struct libp2p_host; @@ -93,7 +90,6 @@ struct lantern_reqresp_service { struct lantern_reqresp_service_callbacks callbacks; struct libp2p_protocol_server *status_server; struct libp2p_protocol_server *blocks_server; - struct libp2p_protocol_server *blocks_server_legacy; struct libp2p_subscription *event_subscription; int lock_initialized; pthread_mutex_t lock; diff --git a/src/core/client_network_internal.h b/src/core/client_network_internal.h index 7b0fd2f..805f37e 100644 --- a/src/core/client_network_internal.h +++ b/src/core/client_network_internal.h @@ -108,7 +108,6 @@ struct block_request_ctx uint32_t *depths; /**< Backfill depth per root */ size_t root_count; /**< Number of roots requested */ const char *protocol_id; /**< Protocol ID string */ - bool tried_fallback; /**< True if fallback protocol already attempted */ }; diff --git a/src/core/client_reqresp_blocks.c b/src/core/client_reqresp_blocks.c index f4fcdf8..aaf4f99 100644 --- a/src/core/client_reqresp_blocks.c +++ b/src/core/client_reqresp_blocks.c @@ -86,18 +86,6 @@ static void block_request_ctx_free(struct block_request_ctx *ctx) free(ctx); } -static void write_u32_le(uint8_t *out, uint32_t value) -{ - if (!out) - { - return; - } - out[0] = (uint8_t)(value & 0xffu); - out[1] = (uint8_t)((value >> 8) & 0xffu); - out[2] = (uint8_t)((value >> 16) & 0xffu); - out[3] = (uint8_t)((value >> 24) & 0xffu); -} - /* ============================================================================ * Block Chunk Processing * ============================================================================ */ @@ -349,15 +337,7 @@ static void *block_request_worker(void *arg) } size_t roots_bytes = request.roots.length * LANTERN_ROOT_SIZE; - bool use_container = false; - if (ctx->protocol_id - && LANTERN_BLOCKS_BY_ROOT_PROTOCOL_FALLBACK_ID - && strcmp(ctx->protocol_id, LANTERN_BLOCKS_BY_ROOT_PROTOCOL_FALLBACK_ID) != 0) - { - use_container = true; - } - - size_t raw_size = roots_bytes + (use_container ? 4u : 0u); + size_t raw_size = roots_bytes; raw_request = (uint8_t *)malloc(raw_size > 0 ? raw_size : 1u); if (!raw_request) { @@ -369,44 +349,14 @@ static void *block_request_worker(void *arg) } size_t raw_written = 0; - if (use_container) - { - if (raw_size < 4u) - { - lantern_log_error( - "reqresp", - &meta, - "failed to size blocks_by_root request"); - goto cleanup; - } - write_u32_le(raw_request, 4u); - size_t roots_written = 0; - if (lantern_network_blocks_by_root_request_encode( - &request, - raw_request + 4u, - raw_size - 4u, - &roots_written) - != 0) - { - lantern_log_error( - "reqresp", - &meta, - "failed to encode blocks_by_root request"); - goto cleanup; - } - raw_written = 4u + roots_written; - } - else + if (lantern_network_blocks_by_root_request_encode(&request, raw_request, raw_size, &raw_written) != 0 + || raw_written == 0) { - if (lantern_network_blocks_by_root_request_encode(&request, raw_request, raw_size, &raw_written) != 0 - || raw_written == 0) - { - lantern_log_error( - "reqresp", - &meta, - "failed to encode blocks_by_root request"); - goto cleanup; - } + lantern_log_error( + "reqresp", + &meta, + "failed to encode blocks_by_root request"); + goto cleanup; } size_t max_payload = 0; @@ -652,56 +602,6 @@ static void *block_request_worker(void *arg) * Stream Open Callback * ============================================================================ */ -static bool block_request_try_fallback( - struct block_request_ctx *ctx, - int err, - const struct lantern_log_metadata *meta) -{ - if (!ctx || ctx->tried_fallback) - { - return false; - } - if (err != LIBP2P_ERR_UNSUPPORTED && err != LIBP2P_ERR_PROTO_NEGOTIATION_FAILED) - { - return false; - } - if (!ctx->client || !ctx->client->network.host) - { - return false; - } - const char *fallback = LANTERN_BLOCKS_BY_ROOT_PROTOCOL_FALLBACK_ID; - if (!fallback || !ctx->protocol_id || strcmp(fallback, ctx->protocol_id) == 0) - { - return false; - } - - ctx->tried_fallback = true; - ctx->protocol_id = fallback; - lantern_log_warn( - "reqresp", - meta, - "retrying blocks_by_root with fallback protocol=%s err=%d", - ctx->protocol_id, - err); - - int rc = libp2p_host_open_stream_async( - ctx->client->network.host, - &ctx->peer_id, - ctx->protocol_id, - block_request_on_open, - ctx); - if (rc == 0) - { - return true; - } - lantern_log_warn( - "reqresp", - meta, - "fallback blocks_by_root open failed rc=%d", - rc); - return false; -} - /** * Callback when a block request stream opens. * @@ -738,7 +638,6 @@ static void block_request_on_open(libp2p_stream_t *stream, void *user_data, int "block request stream opened protocol=%s err=%d", ctx->protocol_id ? ctx->protocol_id : "(unknown)", err); - if (err != 0 || !stream) { lantern_log_warn( @@ -752,10 +651,6 @@ static void block_request_on_open(libp2p_stream_t *stream, void *user_data, int libp2p_stream_free(stream); stream = NULL; } - if (block_request_try_fallback(ctx, err, &meta)) - { - return; - } if (ctx->client) { lantern_client_on_blocks_request_complete_batch( @@ -892,7 +787,6 @@ static int schedule_blocks_request_batch( ctx->client = client; ctx->root_count = root_count; ctx->protocol_id = LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID; - ctx->tried_fallback = false; strncpy(ctx->peer_text, peer_id_text, sizeof(ctx->peer_text) - 1); ctx->peer_text[sizeof(ctx->peer_text) - 1] = '\0'; diff --git a/src/core/client_sync.c b/src/core/client_sync.c index 2f98244..af777b8 100644 --- a/src/core/client_sync.c +++ b/src/core/client_sync.c @@ -317,14 +317,30 @@ void persist_anchor_block( block->state_root = anchor_block->state_root; LanternRoot computed_root; + const LanternRoot *root_for_vote = anchor_root; const LanternRoot *root_to_log = anchor_root; - if (!root_to_log) + if (!root_for_vote) { if (lantern_hash_tree_root_block(block, &computed_root) == 0) { - root_to_log = &computed_root; + root_for_vote = &computed_root; + root_to_log = root_for_vote; } } + + if (root_for_vote) + { + LanternVote *vote = &stored_anchor.message.proposer_attestation; + LanternCheckpoint anchor_checkpoint = { + .root = *root_for_vote, + .slot = block->slot, + }; + vote->validator_id = block->proposer_index; + vote->slot = block->slot; + vote->head = anchor_checkpoint; + vote->target = anchor_checkpoint; + vote->source = anchor_checkpoint; + } char root_hex[ROOT_HEX_BUFFER_LEN]; root_hex[0] = '\0'; if (root_to_log) @@ -674,14 +690,21 @@ int restore_persisted_blocks(struct lantern_client *client) for (size_t i = 0; i < list.length; ++i) { const struct lantern_persisted_block *entry = &list.items[i]; + const LanternBlock *block = &entry->block.message.block; + const LanternVote *vote = &entry->block.message.proposer_attestation; LanternSignedVote persisted_proposer; - memset(&persisted_proposer, 0, sizeof(persisted_proposer)); - persisted_proposer.data = entry->block.message.proposer_attestation; - persisted_proposer.signature = entry->block.signatures.proposer_signature; + const LanternSignedVote *proposer_ptr = NULL; + if (vote->slot == block->slot && vote->validator_id == block->proposer_index) + { + memset(&persisted_proposer, 0, sizeof(persisted_proposer)); + persisted_proposer.data = *vote; + persisted_proposer.signature = entry->block.signatures.proposer_signature; + proposer_ptr = &persisted_proposer; + } if (lantern_fork_choice_add_block( &client->fork_choice, - &entry->block.message.block, - &persisted_proposer, + block, + proposer_ptr, &client->state.latest_justified, &client->state.latest_finalized, &entry->root) diff --git a/src/networking/reqresp_service.c b/src/networking/reqresp_service.c index 2095914..854df5e 100644 --- a/src/networking/reqresp_service.c +++ b/src/networking/reqresp_service.c @@ -108,7 +108,6 @@ static void lantern_reqresp_service_clear(struct lantern_reqresp_service *servic service->callbacks.collect_blocks = NULL; service->status_server = NULL; service->blocks_server = NULL; - service->blocks_server_legacy = NULL; service->event_subscription = NULL; } @@ -136,9 +135,6 @@ void lantern_reqresp_service_reset(struct lantern_reqresp_service *service) { 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); - } lantern_reqresp_service_clear(service); } @@ -2630,10 +2626,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_FALLBACK_ID); -} - int lantern_reqresp_service_start( struct lantern_reqresp_service *service, const struct lantern_reqresp_service_config *config) { @@ -2658,7 +2650,6 @@ int lantern_reqresp_service_start( status_def.user_data = service; const char *blocks_protocol_primary = LANTERN_BLOCKS_BY_ROOT_PROTOCOL_ID; - const char *blocks_protocol_fallback = LANTERN_BLOCKS_BY_ROOT_PROTOCOL_FALLBACK_ID; libp2p_protocol_def_t blocks_def; memset(&blocks_def, 0, sizeof(blocks_def)); @@ -2676,25 +2667,6 @@ int lantern_reqresp_service_start( return -1; } - if (blocks_protocol_fallback - && blocks_protocol_primary - && strcmp(blocks_protocol_fallback, blocks_protocol_primary) != 0) { - libp2p_protocol_def_t blocks_legacy_def; - memset(&blocks_legacy_def, 0, sizeof(blocks_legacy_def)); - blocks_legacy_def.protocol_id = blocks_protocol_fallback; - blocks_legacy_def.read_mode = LIBP2P_READ_PULL; - blocks_legacy_def.on_open = blocks_on_open_legacy; - blocks_legacy_def.user_data = service; - if (libp2p_host_listen_protocol( - service->host, - &blocks_legacy_def, - &service->blocks_server_legacy) - != 0) { - lantern_reqresp_service_reset(service); - return -1; - } - } - lantern_log_info( "network", &(const struct lantern_log_metadata){0},