Turn block heights list into ranges to load more at once from storage. (#4881)

Backport of #4880.

## Motivation

When handling a chain info query asking for sender certificate hashes,
we currently load those hashes from the chain state view one by one:
`chain.block_hashes(height..=height).await?`. In most cases, the block
heights are actually contiguous.

## Proposal

Turn the list into an equivalent list of ranges, and load each range at
once.

## Test Plan

CI should catch any regressions. We should find a way to try out if this
improves performance, or even addresses the problems on the testnet.

## Release Plan

- These changes should
    - be released in a new SDK,
    - be released in a validator hotfix.

## Links

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

Author: afck

linera-core/src/chain_worker/state.rs

@@ -7,6 +7,7 @@ use std::{
     borrow::Cow,
     collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     iter,
+    ops::RangeInclusive,
     sync::{self, Arc},
 };
 
@@ -1517,8 +1518,9 @@ where
             info.requested_pending_message_bundles = bundles;
         }
         let mut hashes = Vec::new();
-        for height in query.request_sent_certificate_hashes_by_heights {
-            hashes.extend(chain.block_hashes(height..=height).await?);
+        let height_ranges = into_ranges(query.request_sent_certificate_hashes_by_heights);
+        for height_range in height_ranges {
+            hashes.extend(chain.block_hashes(height_range).await?);
         }
         info.requested_sent_certificate_hashes = hashes;
         if let Some(start) = query.request_received_log_excluding_first_n {
@@ -1596,6 +1598,21 @@ where
     }
 }
 
+/// Returns an iterator of inclusive ranges that exactly cover the list of block heights.
+fn into_ranges(
+    values: impl IntoIterator<Item = BlockHeight>,
+) -> impl Iterator<Item = RangeInclusive<BlockHeight>> {
+    let mut values_iter = values.into_iter().peekable();
+    iter::from_fn(move || {
+        let start = values_iter.next()?;
+        let mut end = start;
+        while values_iter.peek() == end.try_add_one().ok().as_ref() {
+            end = values_iter.next()?;
+        }
+        Some(start..=end)
+    })
+}
+
 /// Returns the keys whose value is `None`.
 fn missing_blob_ids(maybe_blobs: &BTreeMap<BlobId, Option<Blob>>) -> Vec<BlobId> {
     maybe_blobs
@@ -1708,3 +1725,21 @@ impl<'a> CrossChainUpdateHelper<'a> {
         Ok(bundles)
     }
 }
+
+#[test]
+fn test_into_ranges() {
+    assert_eq!(
+        into_ranges(vec![
+            BlockHeight(2),
+            BlockHeight(3),
+            BlockHeight(4),
+            BlockHeight(6)
+        ],)
+        .collect::<Vec<_>>(),
+        vec![
+            BlockHeight(2)..=BlockHeight(4),
+            BlockHeight(6)..=BlockHeight(6)
+        ]
+    );
+    assert_eq!(into_ranges(vec![]).collect::<Vec<_>>(), vec![]);
+}