Change the shuffling to take into account the weight. (linera-io#4505)

## Motivation

Not all validators are equal. Taking into account their weight during
the shuffling makes the validators with more weight more responsible for
accessing the

Fixes linera-io#2616 

## Proposal

We simply count the weights when doing the random shuffling.

## Test Plan

The CI.

## Release Plan

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

## Links

None.

Author: MathieuDutSik

linera-core/src/client/mod.rs

@@ -56,7 +56,11 @@ use linera_execution::{
 };
 use linera_storage::{Clock as _, ResultReadCertificates, Storage as _};
 use linera_views::ViewError;
-use rand::prelude::SliceRandom as _;
+use rand::{
+    distributions::{Distribution, WeightedIndex},
+    rngs::StdRng,
+    SeedableRng,
+};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tokio::sync::{mpsc, OwnedRwLockReadGuard};
@@ -263,18 +267,45 @@ impl<Env: Environment> Client<Env> {
         }
     }
 
+    fn weighted_select(
+        remaining_validators: &mut Vec<RemoteNode<Env::ValidatorNode>>,
+        remaining_weights: &mut Vec<u64>,
+        rng: &mut StdRng,
+    ) -> Option<RemoteNode<Env::ValidatorNode>> {
+        if remaining_weights.is_empty() {
+            return None;
+        }
+        let dist = WeightedIndex::new(remaining_weights.clone()).unwrap();
+        let idx = dist.sample(rng);
+        remaining_weights.remove(idx);
+        Some(remaining_validators.remove(idx))
+    }
+
     /// Downloads and processes all certificates up to (excluding) the specified height.
     #[instrument(level = "trace", skip(self))]
     async fn download_certificates(
         &self,
         chain_id: ChainId,
         target_next_block_height: BlockHeight,
     ) -> Result<Box<ChainInfo>, ChainClientError> {
-        let mut validators = self.validator_nodes().await?;
-        // Sequentially try each validator in random order.
-        validators.shuffle(&mut rand::thread_rng());
-        let mut info = self.fetch_chain_info(chain_id, &validators).await?;
-        for remote_node in validators {
+        let (_, committee) = self.admin_committee().await?;
+        let mut remaining_validators = self.make_nodes(&committee)?;
+        let mut info = self
+            .fetch_chain_info(chain_id, &remaining_validators)
+            .await?;
+        // Determining the weights of the validators
+        let mut remaining_weights = remaining_validators
+            .iter()
+            .map(|validator| {
+                let validator_state = committee.validators.get(&validator.public_key).unwrap();
+                validator_state.votes
+            })
+            .collect::<Vec<_>>();
+        let mut rng: StdRng = StdRng::from_entropy();
+
+        while let Some(remote_node) =
+            Self::weighted_select(&mut remaining_validators, &mut remaining_weights, &mut rng)
+        {
             if target_next_block_height <= info.next_block_height {
                 return Ok(info);
             }