Use the latest committee instead of the "local" one. (#3735)

## Motivation

When downloading blobs or certificates from validators, it is better to
contact the latest validators. The "local" ones may already be offline,
or the client may fail to even obtain them, if the to-be-synchronized
chain does not exist in the database yet.

## Proposal

Use the latest committee, so synchronizing works even if the chain does
not exist in storage yet.

## Test Plan

#3732 works for me now.

## Release Plan

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

## Links

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

Author: afck

linera-core/src/client/mod.rs

@@ -940,6 +940,15 @@ where
             .ok_or(LocalNodeError::InactiveChain(self.chain_id))
     }
 
+    /// Obtains the committee for the latest epoch.
+    #[instrument(level = "trace")]
+    pub async fn latest_committee(&self) -> Result<Committee, LocalNodeError> {
+        let (mut committees, epoch) = self.known_committees().await?;
+        committees
+            .remove(&epoch)
+            .ok_or(LocalNodeError::InactiveChain(self.chain_id))
+    }
+
     /// Obtains all the committees trusted by either the local chain or its admin chain. Also
     /// return the latest trusted epoch.
     #[instrument(level = "trace")]
@@ -963,19 +972,11 @@ where
             .collect())
     }
 
-    /// Obtains the validators trusted by the local chain.
+    /// Obtains the validators for the latest epoch.
     #[instrument(level = "trace")]
     async fn validator_nodes(&self) -> Result<Vec<RemoteNode<P::Node>>, ChainClientError> {
-        match self.local_committee().await {
-            Ok(committee) => Ok(self.make_nodes(&committee)?),
-            Err(LocalNodeError::InactiveChain(_)) => Ok(Vec::new()),
-            Err(LocalNodeError::WorkerError(WorkerError::ChainError(error)))
-                if matches!(*error, ChainError::InactiveChain(_)) =>
-            {
-                Ok(Vec::new())
-            }
-            Err(e) => Err(e.into()),
-        }
+        let committee = self.latest_committee().await?;
+        Ok(self.make_nodes(&committee)?)
     }
 
     /// Obtains the current epoch of the local chain.

linera-core/src/remote_node.rs

@@ -174,20 +174,24 @@ impl<N: ValidatorNode> RemoteNode<N> {
             limit: Some(limit),
         };
         let query = ChainInfoQuery::new(chain_id).with_sent_certificate_hashes_in_range(range);
-        if let Ok(info) = self.handle_chain_info_query(query).await {
-            let certificates = self
-                .node
-                .download_certificates(info.requested_sent_certificate_hashes)
-                .await?
-                .into_iter()
-                .map(|c| {
-                    ConfirmedBlockCertificate::try_from(c)
-                        .map_err(|_| NodeError::InvalidChainInfoResponse)
-                })
-                .collect::<Result<_, _>>()?;
-            Ok(Some(certificates))
-        } else {
-            Ok(None)
+        match self.handle_chain_info_query(query).await {
+            Ok(info) => {
+                let certificates = self
+                    .node
+                    .download_certificates(info.requested_sent_certificate_hashes)
+                    .await?
+                    .into_iter()
+                    .map(|c| {
+                        ConfirmedBlockCertificate::try_from(c)
+                            .map_err(|_| NodeError::InvalidChainInfoResponse)
+                    })
+                    .collect::<Result<_, _>>()?;
+                Ok(Some(certificates))
+            }
+            Err(error) => {
+                tracing::warn!("Failed to query certificates: {error}");
+                Ok(None)
+            }
         }
     }