Use ChainClientOptions in more places. (#4051)

## Motivation

Clippy rightly thinks that `Client::new` has `too_many_arguments`.

## Proposal

Use `ChainClientOptions` instead of passing in individual parameters.

## 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)

Author: afck

linera-client/src/client_context.rs

@@ -15,10 +15,10 @@ use linera_base::{
 };
 use linera_chain::types::ConfirmedBlockCertificate;
 use linera_core::{
-    client::{ChainClient, Client, MessagePolicy},
+    client::{ChainClient, Client},
     data_types::{ChainInfoQuery, ClientOutcome},
     join_set_ext::JoinSet,
-    node::{CrossChainMessageDelivery, ValidatorNode},
+    node::ValidatorNode,
     Environment, JoinSetExt as _,
 };
 use linera_persistent::{Persist, PersistExt as _};
@@ -119,7 +119,6 @@ where
             retry_delay: options.retry_delay,
             max_retries: options.max_retries,
         });
-        let delivery = CrossChainMessageDelivery::new(options.wait_for_outgoing_messages);
         let chain_ids = wallet.chain_ids();
         let name = match chain_ids.len() {
             0 => "Client node".to_string(),
@@ -132,19 +131,12 @@ where
                 storage,
                 signer,
             },
-            options.max_pending_message_bundles,
             wallet.genesis_admin_chain(),
-            MessagePolicy::new(
-                options.blanket_message_policy,
-                options.restrict_chain_ids_to,
-            ),
-            delivery,
             options.long_lived_services,
             chain_ids,
             name,
             options.max_loaded_chains,
-            options.grace_period,
-            options.blob_download_timeout,
+            options.to_chain_client_options(),
         );
 
         ClientContext {
@@ -160,7 +152,7 @@ where
 
     #[cfg(with_testing)]
     pub fn new_test_client_context(storage: S, wallet: W, signer: Si) -> Self {
-        use linera_core::DEFAULT_GRACE_PERIOD;
+        use linera_core::{client::ChainClientOptions, node::CrossChainMessageDelivery};
 
         let send_recv_timeout = Duration::from_millis(4000);
         let retry_delay = Duration::from_millis(1000);
@@ -172,7 +164,6 @@ where
             retry_delay,
             max_retries,
         };
-        let delivery = CrossChainMessageDelivery::new(true);
         let chain_ids = wallet.chain_ids();
         let name = match chain_ids.len() {
             0 => "Client node".to_string(),
@@ -185,16 +176,15 @@ where
                 network: NodeProvider::new(node_options),
                 signer,
             },
-            10,
             wallet.genesis_admin_chain(),
-            MessagePolicy::new_accept_all(),
-            delivery,
             false,
             chain_ids,
             name,
             NonZeroUsize::new(20).expect("Chain worker limit should not be zero"),
-            DEFAULT_GRACE_PERIOD,
-            Duration::from_secs(1),
+            ChainClientOptions {
+                cross_chain_message_delivery: CrossChainMessageDelivery::Blocking,
+                ..ChainClientOptions::test_default()
+            },
         );
 
         ClientContext {

linera-client/src/client_options.rs

@@ -9,7 +9,11 @@ use linera_base::{
     ownership::{ChainOwnership, TimeoutConfig},
     time::Duration,
 };
-use linera_core::{client::BlanketMessagePolicy, DEFAULT_GRACE_PERIOD};
+use linera_core::{
+    client::{BlanketMessagePolicy, ChainClientOptions, MessagePolicy},
+    node::CrossChainMessageDelivery,
+    DEFAULT_GRACE_PERIOD,
+};
 use linera_execution::ResourceControlPolicy;
 
 use crate::util;
@@ -112,6 +116,25 @@ pub struct ClientContextOptions {
     pub blob_download_timeout: Duration,
 }
 
+impl ClientContextOptions {
+    /// Creates [`ChainClientOptions`] with the corresponding values.
+    pub fn to_chain_client_options(&self) -> ChainClientOptions {
+        let message_policy = MessagePolicy::new(
+            self.blanket_message_policy,
+            self.restrict_chain_ids_to.clone(),
+        );
+        let cross_chain_message_delivery =
+            CrossChainMessageDelivery::new(self.wait_for_outgoing_messages);
+        ChainClientOptions {
+            max_pending_message_bundles: self.max_pending_message_bundles,
+            message_policy,
+            cross_chain_message_delivery,
+            grace_period: self.grace_period,
+            blob_download_timeout: self.blob_download_timeout,
+        }
+    }
+}
+
 #[derive(Debug, Clone, clap::Args)]
 pub struct ChainOwnershipConfig {
     /// The new super owners.

linera-client/src/unit_tests/chain_listener.rs

@@ -13,11 +13,9 @@ use linera_base::{
     ownership::{ChainOwnership, TimeoutConfig},
 };
 use linera_core::{
-    client::{ChainClient, Client, MessagePolicy},
+    client::{ChainClient, ChainClientOptions, Client},
     environment,
-    node::CrossChainMessageDelivery,
     test_utils::{MemoryStorageBuilder, StorageBuilder as _, TestBuilder},
-    DEFAULT_GRACE_PERIOD,
 };
 use linera_execution::system::Recipient;
 use linera_storage::Storage;
@@ -102,7 +100,6 @@ async fn test_chain_listener() -> anyhow::Result<()> {
     let genesis_config = make_genesis_config(&builder);
     let admin_id = genesis_config.admin_id();
     let storage = builder.make_storage().await?;
-    let delivery = CrossChainMessageDelivery::NonBlocking;
 
     let mut context = ClientContext {
         wallet: Wallet::new(genesis_config),
@@ -112,16 +109,12 @@ async fn test_chain_listener() -> anyhow::Result<()> {
                 network: builder.make_node_provider(),
                 signer,
             },
-            10,
             admin_id,
-            MessagePolicy::new_accept_all(),
-            delivery,
             false,
             [chain_id0],
             format!("Client node for {:.8}", chain_id0),
             NonZeroUsize::new(20).expect("Chain worker LRU cache size must be non-zero"),
-            DEFAULT_GRACE_PERIOD,
-            Duration::from_secs(1),
+            ChainClientOptions::test_default(),
         )),
     };
     context
@@ -191,7 +184,6 @@ async fn test_chain_listener_admin_chain() -> anyhow::Result<()> {
     let genesis_config = make_genesis_config(&builder);
     let admin_id = genesis_config.admin_id();
     let storage = builder.make_storage().await?;
-    let delivery = CrossChainMessageDelivery::NonBlocking;
 
     let context = ClientContext {
         wallet: Wallet::new(genesis_config),
@@ -201,16 +193,12 @@ async fn test_chain_listener_admin_chain() -> anyhow::Result<()> {
                 network: builder.make_node_provider(),
                 signer,
             },
-            10,
             admin_id,
-            MessagePolicy::new_accept_all(),
-            delivery,
             false,
             [],
             "Client node with no chains".to_string(),
             NonZeroUsize::new(20).expect("Chain worker LRU cache size must be non-zero"),
-            DEFAULT_GRACE_PERIOD,
-            Duration::from_secs(1),
+            ChainClientOptions::test_default(),
         )),
     };
     let context = Arc::new(Mutex::new(context));

linera-core/src/client/mod.rs

@@ -149,17 +149,8 @@ pub struct Client<Env: Environment> {
     /// Local node to manage the execution state and the local storage of the chains that we are
     /// tracking.
     local_node: LocalNodeClient<Env::Storage>,
-    /// Maximum number of pending message bundles processed at a time in a block.
-    max_pending_message_bundles: usize,
-    /// The policy for automatically handling incoming messages.
-    message_policy: MessagePolicy,
     /// The admin chain ID.
     admin_id: ChainId,
-    /// Whether to block on cross-chain message delivery.
-    cross_chain_message_delivery: CrossChainMessageDelivery,
-    /// An additional delay, after reaching a quorum, to wait for additional validator signatures,
-    /// as a fraction of time taken to reach quorum.
-    grace_period: f64,
     /// Chains that should be tracked by the client.
     // TODO(#2412): Merge with set of chains the client is receiving notifications from validators
     tracked_chains: Arc<RwLock<HashSet<ChainId>>>,
@@ -169,26 +160,21 @@ pub struct Client<Env: Environment> {
     chains: DashMap<ChainId, ChainClientState>,
     /// The maximum active chain workers.
     max_loaded_chains: NonZeroUsize,
-    /// The delay when downloading a blob, after which we try a second validator.
-    blob_download_timeout: Duration,
+    /// Configuration options.
+    options: ChainClientOptions,
 }
 
 impl<Env: Environment> Client<Env> {
     /// Creates a new `Client` with a new cache and notifiers.
-    #[expect(clippy::too_many_arguments)]
     #[instrument(level = "trace", skip_all)]
     pub fn new(
         environment: Env,
-        max_pending_message_bundles: usize,
         admin_id: ChainId,
-        message_policy: MessagePolicy,
-        cross_chain_message_delivery: CrossChainMessageDelivery,
         long_lived_services: bool,
         tracked_chains: impl IntoIterator<Item = ChainId>,
         name: impl Into<String>,
         max_loaded_chains: NonZeroUsize,
-        grace_period: f64,
-        blob_download_timeout: Duration,
+        options: ChainClientOptions,
     ) -> Self {
         let tracked_chains = Arc::new(RwLock::new(tracked_chains.into_iter().collect()));
         let state = WorkerState::new_for_client(
@@ -206,15 +192,11 @@ impl<Env: Environment> Client<Env> {
             environment,
             local_node,
             chains: DashMap::new(),
-            max_pending_message_bundles,
             admin_id,
-            message_policy,
-            cross_chain_message_delivery,
-            grace_period,
             tracked_chains,
             notifier: Arc::new(ChannelNotifier::default()),
             max_loaded_chains,
-            blob_download_timeout,
+            options,
         }
     }
 
@@ -267,13 +249,7 @@ impl<Env: Environment> Client<Env> {
         ChainClient {
             client: self.clone(),
             chain_id,
-            options: ChainClientOptions {
-                max_pending_message_bundles: self.max_pending_message_bundles,
-                message_policy: self.message_policy.clone(),
-                cross_chain_message_delivery: self.cross_chain_message_delivery,
-                grace_period: self.grace_period,
-                blob_download_timeout: self.blob_download_timeout,
-            },
+            options: self.options.clone(),
             preferred_owner,
             initial_block_hash: block_hash,
             initial_next_block_height: next_block_height,
@@ -292,10 +268,13 @@ impl<Env: Environment> Client<Env> {
                 // If the chain is missing then the error is a WorkerError
                 // and so a BlobsNotFound
                 // TODO(#2351): make sure the blobs are legitimate!
-                let blobs =
-                    RemoteNode::download_blobs(&blob_ids, validators, self.blob_download_timeout)
-                        .await
-                        .ok_or(LocalNodeError::BlobsNotFound(blob_ids))?;
+                let blobs = RemoteNode::download_blobs(
+                    &blob_ids,
+                    validators,
+                    self.options.blob_download_timeout,
+                )
+                .await
+                .ok_or(LocalNodeError::BlobsNotFound(blob_ids))?;
                 self.local_node.storage_client().write_blobs(&blobs).await?;
                 self.local_node.chain_info(chain_id).await
             }
@@ -484,9 +463,10 @@ impl<Env: Environment> Client<Env> {
         // Recover history from the current validators, according to the admin chain.
         // TODO(#2351): make sure that the blob is legitimately created!
         let nodes = self.validator_nodes().await?;
-        let blob = RemoteNode::download_blob(&nodes, chain_desc_id, self.blob_download_timeout)
-            .await
-            .ok_or(LocalNodeError::BlobsNotFound(vec![chain_desc_id]))?;
+        let blob =
+            RemoteNode::download_blob(&nodes, chain_desc_id, self.options.blob_download_timeout)
+                .await
+                .ok_or(LocalNodeError::BlobsNotFound(vec![chain_desc_id]))?;
         self.local_node.storage_client().write_blob(&blob).await?;
         Ok(blob)
     }
@@ -521,7 +501,7 @@ impl<Env: Environment> Client<Env> {
         let hashed_value = ConfirmedBlock::new(certificate.inner().block().clone());
         let finalize_action = CommunicateAction::FinalizeBlock {
             certificate: Box::new(certificate),
-            delivery: self.cross_chain_message_delivery,
+            delivery: self.options.cross_chain_message_delivery,
         };
         let certificate = self
             .communicate_chain_action(committee, finalize_action, hashed_value)
@@ -587,7 +567,7 @@ impl<Env: Environment> Client<Env> {
                         .await
                 })
             },
-            self.grace_period,
+            self.options.grace_period,
         )
         .await?;
         Ok(())
@@ -622,7 +602,7 @@ impl<Env: Environment> Client<Env> {
                 let action = action.clone();
                 Box::pin(async move { updater.send_chain_update(action).await })
             },
-            self.grace_period,
+            self.options.grace_period,
         )
         .await?;
         ensure!(
@@ -715,10 +695,13 @@ impl<Env: Environment> Client<Env> {
         if let Err(err) = self.process_certificate(certificate.clone()).await {
             match &err {
                 LocalNodeError::BlobsNotFound(blob_ids) => {
-                    let blobs =
-                        RemoteNode::download_blobs(blob_ids, &nodes, self.blob_download_timeout)
-                            .await
-                            .ok_or(err)?;
+                    let blobs = RemoteNode::download_blobs(
+                        blob_ids,
+                        &nodes,
+                        self.options.blob_download_timeout,
+                    )
+                    .await
+                    .ok_or(err)?;
                     self.local_node.store_blobs(&blobs).await?;
                     self.process_certificate(certificate).await?;
                 }
@@ -933,7 +916,7 @@ impl<Env: Environment> Client<Env> {
                 self.try_synchronize_chain_state_from(&remote_node, chain_id)
                     .await
             },
-            self.grace_period,
+            self.options.grace_period,
         )
         .await?;
 
@@ -1294,7 +1277,6 @@ impl MessagePolicy {
     }
 }
 
-#[non_exhaustive]
 #[derive(Debug, Clone)]
 pub struct ChainClientOptions {
     /// Maximum number of pending message bundles processed at a time in a block.
@@ -1310,6 +1292,21 @@ pub struct ChainClientOptions {
     pub blob_download_timeout: Duration,
 }
 
+#[cfg(with_testing)]
+impl ChainClientOptions {
+    pub fn test_default() -> Self {
+        use crate::DEFAULT_GRACE_PERIOD;
+
+        ChainClientOptions {
+            max_pending_message_bundles: 10,
+            message_policy: MessagePolicy::new_accept_all(),
+            cross_chain_message_delivery: CrossChainMessageDelivery::NonBlocking,
+            grace_period: DEFAULT_GRACE_PERIOD,
+            blob_download_timeout: Duration::from_secs(1),
+        }
+    }
+}
+
 /// Client to operate a chain by interacting with validators and the given local storage
 /// implementation.
 /// * The chain being operated is called the "local chain" or just the "chain".