Port latest changes from #4643 to main (#4669)

## Motivation

We did some development on #4643 that is not yet reflected on `main`

## Proposal

Port the missing changes

## Test Plan

CI

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

- [reviewer
checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)

---------

Co-authored-by: Mathieu Baudet <[email protected]>

Author: bart-linera

linera-core/src/chain_worker/config.rs

@@ -7,8 +7,10 @@ use std::sync::Arc;
 
 use linera_base::{crypto::ValidatorSecretKey, time::Duration};
 
+use crate::CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES;
+
 /// Configuration parameters for the [`ChainWorkerState`][`super::state::ChainWorkerState`].
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct ChainWorkerConfig {
     /// The signature key pair of the validator. The key may be missing for replicas
     /// without voting rights (possibly with a partial view of chains).
@@ -24,6 +26,8 @@ pub struct ChainWorkerConfig {
     pub grace_period: Duration,
     /// Idle chain workers free their memory after that duration without requests.
     pub ttl: Duration,
+    /// The size to truncate receive log entries in chain info responses.
+    pub chain_info_max_received_log_entries: usize,
 }
 
 impl ChainWorkerConfig {
@@ -45,3 +49,17 @@ impl ChainWorkerConfig {
         self.key_pair.as_ref().map(Arc::as_ref)
     }
 }
+
+impl Default for ChainWorkerConfig {
+    fn default() -> Self {
+        Self {
+            key_pair: None,
+            allow_inactive_chains: false,
+            allow_messages_from_deprecated_epochs: false,
+            long_lived_services: false,
+            grace_period: Default::default(),
+            ttl: Default::default(),
+            chain_info_max_received_log_entries: CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES,
+        }
+    }
+}

linera-core/src/chain_worker/mod.rs

@@ -14,8 +14,5 @@ pub(crate) use self::state::CrossChainUpdateHelper;
 pub(crate) use self::{
     actor::{ChainWorkerActor, ChainWorkerRequest},
     config::ChainWorkerConfig,
-    state::{
-        BlockOutcome, CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_DEFAULT,
-        CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_VAR,
-    },
+    state::BlockOutcome,
 };

linera-core/src/chain_worker/state.rs

@@ -48,12 +48,6 @@ use crate::{
     worker::{NetworkActions, Notification, Reason, WorkerError},
 };
 
-/// The maximum number of entries in a `received_log` included in a `ChainInfo` response.
-// TODO(#4638): Revisit the number.
-pub const CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_DEFAULT: usize = 1000;
-pub const CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_VAR: &str =
-    "LINERA_CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES";
-
 /// The state of the chain worker.
 pub(crate) struct ChainWorkerState<StorageClient>
 where
@@ -1417,11 +1411,10 @@ where
         info.requested_sent_certificate_hashes = hashes;
         if let Some(start) = query.request_received_log_excluding_first_n {
             let start = usize::try_from(start).map_err(|_| ArithmeticError::Overflow)?;
-            let max_entries = std::env::var(CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_VAR)
-                .ok()
-                .and_then(|var| var.parse().ok())
-                .unwrap_or(CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_DEFAULT);
-            let end = (start.saturating_add(max_entries)).min(chain.received_log.count());
+            let max_received_log_entries = self.config.chain_info_max_received_log_entries;
+            let end = start
+                .saturating_add(max_received_log_entries)
+                .min(chain.received_log.count());
             info.requested_received_log = chain.received_log.read(start..end).await?;
         }
         if query.request_manager_values {

linera-core/src/client/mod.rs

@@ -65,9 +65,6 @@ use tokio_stream::wrappers::UnboundedReceiverStream;
 use tracing::{debug, error, info, instrument, trace, warn, Instrument as _};
 
 use crate::{
-    chain_worker::{
-        CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_DEFAULT, CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_VAR,
-    },
     data_types::{ChainInfo, ChainInfoQuery, ChainInfoResponse, ClientOutcome, RoundTimeout},
     environment::Environment,
     local_node::{LocalChainInfoExt as _, LocalNodeClient, LocalNodeError},
@@ -79,6 +76,7 @@ use crate::{
     remote_node::RemoteNode,
     updater::{communicate_with_quorum, CommunicateAction, CommunicationError, ValidatorUpdater},
     worker::{Notification, ProcessableCertificate, Reason, WorkerError, WorkerState},
+    CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES,
 };
 
 mod chain_client_state;
@@ -841,17 +839,13 @@ impl<Env: Environment> Client<Env> {
         // Retrieve the list of newly received certificates from this validator.
         let mut remote_log = Vec::new();
         let mut offset = tracker;
-        let max_entries = std::env::var(CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_VAR)
-            .ok()
-            .and_then(|var| var.parse().ok())
-            .unwrap_or(CHAIN_INFO_RECEIVED_LOG_MAX_ENTRIES_DEFAULT);
         loop {
             let query = ChainInfoQuery::new(chain_id).with_received_log_excluding_first_n(offset);
             let info = remote_node.handle_chain_info_query(query).await?;
             let received_entries = info.requested_received_log.len();
             offset += received_entries as u64;
             remote_log.extend(info.requested_received_log);
-            if received_entries < max_entries {
+            if received_entries < CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES {
                 break;
             }
         }

linera-core/src/lib.rs

@@ -29,3 +29,7 @@ pub use crate::join_set_ext::{JoinSetExt, TaskHandle};
 
 pub mod environment;
 pub use environment::Environment;
+
+/// The maximum number of entries in a `received_log` included in a `ChainInfo` response.
+// TODO(#4638): Revisit the number.
+pub const CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES: usize = 20_000;

linera-core/src/worker.rs

@@ -43,6 +43,7 @@ use crate::{
     join_set_ext::{JoinSet, JoinSetExt},
     notifier::Notifier,
     value_cache::ValueCache,
+    CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES,
 };
 
 #[cfg(test)]
@@ -417,6 +418,26 @@ where
         self
     }
 
+    /// Returns an instance with the specified maximum size for received_log entries.
+    ///
+    /// Sizes below `CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES` should be avoided.
+    #[instrument(level = "trace", skip(self))]
+    pub fn with_chain_info_max_received_log_entries(
+        mut self,
+        chain_info_max_received_log_entries: usize,
+    ) -> Self {
+        if chain_info_max_received_log_entries < CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES {
+            warn!(
+                "The value set for the maximum size of received_log entries \
+                   may not be compatible with the latest clients: {} instead of {}",
+                chain_info_max_received_log_entries, CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES
+            );
+        }
+        self.chain_worker_config.chain_info_max_received_log_entries =
+            chain_info_max_received_log_entries;
+        self
+    }
+
     #[instrument(level = "trace", skip(self))]
     pub fn nickname(&self) -> &str {
         &self.nickname

linera-service/src/server.rs

@@ -37,7 +37,7 @@ use linera_base::{
     listen_for_shutdown_signals,
 };
 use linera_client::config::{CommitteeConfig, ValidatorConfig, ValidatorServerConfig};
-use linera_core::{worker::WorkerState, JoinSetExt as _};
+use linera_core::{worker::WorkerState, JoinSetExt as _, CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES};
 use linera_execution::{WasmRuntime, WithWasmDefault};
 #[cfg(with_metrics)]
 use linera_metrics::monitoring_server;
@@ -70,6 +70,7 @@ struct ServerContext {
     chain_worker_ttl: Duration,
     block_cache_size: usize,
     execution_state_cache_size: usize,
+    chain_info_max_received_log_entries: usize,
 }
 
 impl ServerContext {
@@ -98,7 +99,8 @@ impl ServerContext {
         .with_allow_inactive_chains(false)
         .with_allow_messages_from_deprecated_epochs(false)
         .with_grace_period(self.grace_period)
-        .with_chain_worker_ttl(self.chain_worker_ttl);
+        .with_chain_worker_ttl(self.chain_worker_ttl)
+        .with_chain_info_max_received_log_entries(self.chain_info_max_received_log_entries);
         (state, shard_id, shard.clone())
     }
 
@@ -396,6 +398,15 @@ enum ServerCommand {
             value_parser = util::parse_millis
         )]
         chain_worker_ttl: Duration,
+
+        /// Maximum size for received_log entries in chain info responses. This should
+        /// generally only be increased from the default value.
+        #[arg(
+            long,
+            default_value_t = CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES,
+            env = "LINERA_SERVER_CHAIN_INFO_MAX_RECEIVED_LOG_ENTRIES",
+        )]
+        chain_info_max_received_log_entries: usize,
     },
 
     /// Act as a trusted third-party and generate all server configurations
@@ -508,6 +519,7 @@ async fn run(options: ServerOptions) {
             grace_period,
             wasm_runtime,
             chain_worker_ttl,
+            chain_info_max_received_log_entries,
         } => {
             linera_version::VERSION_INFO.log();
 
@@ -523,6 +535,7 @@ async fn run(options: ServerOptions) {
                 chain_worker_ttl,
                 block_cache_size: options.block_cache_size,
                 execution_state_cache_size: options.execution_state_cache_size,
+                chain_info_max_received_log_entries,
             };
             let wasm_runtime = wasm_runtime.with_wasm_default();
             let store_config = storage_config