Simplify chain manager logic. (#3178)

## Motivation

We are using the chain manager's `locked` field for two purposes:
* In validators, this is meant to track _this validator's_ locked block,
i.e. the latest proposal it signed to confirm.
* In the client, it tracks the highest validated block (or fast
proposal) we have seen, i.e. the highest block that _might_ be locked
for any honest validator, so that the client knows which block it should
re-propose in the next round.

This is confusing, and makes it more difficult to tackle issues like
#2971.

## Proposal

Use the `locked` field for the first purpose, both in clients and
validators: to track the highest block that _might_ be locked for any of
the validators.

In a validator's chain manager, the block that is locked for _that
validator_ is the one it has last voted to confirm, i.e. the
`confirmed_vote` field.

## Test Plan

The tests already cover lots of scenarios involving locked blocks, and
should catch any regressions. They have been updated where appropriate.

## Release Plan

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

## Links

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

Author: afck

linera-chain/src/block.rs

@@ -23,6 +23,7 @@ use crate::{
         BlockExecutionOutcome, EventRecord, ExecutedBlock, IncomingBundle, Medium, MessageBundle,
         OutgoingMessage, ProposedBlock,
     },
+    types::CertificateValue,
     ChainError,
 };
 
@@ -154,6 +155,28 @@ impl ConfirmedBlock {
             })
         }
     }
+
+    /// Returns whether this block matches the proposal.
+    pub fn matches_proposed_block(&self, block: &ProposedBlock) -> bool {
+        let ProposedBlock {
+            chain_id,
+            epoch,
+            incoming_bundles,
+            operations,
+            height,
+            timestamp,
+            authenticated_signer,
+            previous_block_hash,
+        } = block;
+        *chain_id == self.chain_id()
+            && *epoch == self.epoch()
+            && *incoming_bundles == self.block().body.incoming_bundles
+            && *operations == self.block().body.operations
+            && *height == self.block().header.height
+            && *timestamp == self.block().header.timestamp
+            && *authenticated_signer == self.block().header.authenticated_signer
+            && *previous_block_hash == self.block().header.previous_block_hash
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize, Serialize)]

linera-chain/src/lib.rs

@@ -127,8 +127,10 @@ pub enum ChainError {
     InsufficientRoundStrict(Round),
     #[error("Round number should be {0:?}")]
     WrongRound(Round),
-    #[error("A different block for height {0:?} was already locked at round number {1:?}")]
-    HasLockedBlock(BlockHeight, Round),
+    #[error("Already voted to confirm a different block for height {0:?} at round number {1:?}")]
+    HasIncompatibleConfirmedVote(BlockHeight, Round),
+    #[error("Proposal for height {0:?} is not newer than locking block in round {1:?}")]
+    MustBeNewerThanLockingBlock(BlockHeight, Round),
     #[error("Cannot confirm a block before its predecessors: {current_block_height:?}")]
     MissingEarlierBlocks { current_block_height: BlockHeight },
     #[error("Signatures in a certificate must be from different validators")]

linera-chain/src/manager.rs

@@ -141,7 +141,7 @@ where
         callback: oneshot::Sender<Result<(ChainInfoResponse, NetworkActions), WorkerError>>,
     },
 
-    /// Get a blob if it belongs to the current locked block or pending proposal.
+    /// Get a blob if it belongs to the current locking block or pending proposal.
     DownloadPendingBlob {
         blob_id: BlobId,
         #[debug(skip)]

linera-core/src/chain_worker/actor.rs

@@ -295,7 +295,7 @@ where
         Ok((response, actions))
     }
 
-    /// Returns the requested blob, if it belongs to the current locked block or pending proposal.
+    /// Returns the requested blob, if it belongs to the current locking block or pending proposal.
     pub(super) async fn download_pending_blob(&self, blob_id: BlobId) -> Result<Blob, WorkerError> {
         let maybe_blob = self.chain.manager.pending_blob(&blob_id).await?;
         maybe_blob.ok_or_else(|| WorkerError::BlobsNotFound(vec![blob_id]))

linera-core/src/chain_worker/state/mod.rs

@@ -44,7 +44,7 @@ use linera_chain::{
         BlockProposal, ChainAndHeight, ExecutedBlock, IncomingBundle, LiteVote, MessageAction,
         ProposedBlock,
     },
-    manager::LockedBlock,
+    manager::LockingBlock,
     types::{
         CertificateKind, CertificateValue, ConfirmedBlock, ConfirmedBlockCertificate,
         GenericCertificate, LiteCertificate, Timeout, TimeoutCertificate, ValidatedBlock,
@@ -1747,65 +1747,58 @@ where
         {
             return Ok(());
         };
+        let mut proposals = Vec::new();
         if let Some(proposal) = info.manager.requested_proposed {
+            proposals.push(*proposal);
+        }
+        if let Some(locking) = info.manager.requested_locking {
+            match *locking {
+                LockingBlock::Fast(proposal) => {
+                    proposals.push(proposal);
+                }
+                LockingBlock::Regular(cert) => {
+                    let hash = cert.hash();
+                    if let Err(err) = self.try_process_locking_block_from(remote_node, cert).await {
+                        warn!(
+                            "Skipping certificate {hash} from validator {}: {err}",
+                            remote_node.name
+                        );
+                    }
+                }
+            }
+        }
+        for proposal in proposals {
             let owner = proposal.owner;
-            while let Err(original_err) = self
+            if let Err(mut err) = self
                 .client
                 .local_node
-                .handle_block_proposal(*proposal.clone())
+                .handle_block_proposal(proposal.clone())
                 .await
             {
-                if let LocalNodeError::BlobsNotFound(blob_ids) = &original_err {
+                if let LocalNodeError::BlobsNotFound(blob_ids) = &err {
                     self.update_local_node_with_blobs_from(blob_ids.clone(), remote_node)
                         .await?;
-                    continue; // We found the missing blobs: retry.
-                }
-
-                warn!(
-                    "Skipping proposal from {} and validator {}: {}",
-                    owner, remote_node.name, original_err
-                );
-                break;
-            }
-        }
-        if let Some(locked) = info.manager.requested_locked {
-            match *locked {
-                LockedBlock::Fast(proposal) => {
-                    let owner = proposal.owner;
-                    while let Err(original_err) = self
+                    // We found the missing blobs: retry.
+                    if let Err(new_err) = self
                         .client
                         .local_node
                         .handle_block_proposal(proposal.clone())
                         .await
                     {
-                        if let LocalNodeError::BlobsNotFound(blob_ids) = &original_err {
-                            self.update_local_node_with_blobs_from(blob_ids.clone(), remote_node)
-                                .await?;
-                            continue; // We found the missing blobs: retry.
-                        }
-
-                        warn!(
-                            "Skipping proposal from {} and validator {}: {}",
-                            owner, remote_node.name, original_err
-                        );
-                        break;
-                    }
-                }
-                LockedBlock::Regular(cert) => {
-                    let hash = cert.hash();
-                    if let Err(err) = self.try_process_locked_block_from(remote_node, cert).await {
-                        warn!(
-                            "Skipping certificate {hash} from validator {}: {err}",
-                            remote_node.name
-                        );
+                        err = new_err;
+                    } else {
+                        continue;
                     }
                 }
+
+                let name = &remote_node.name;
+                warn!("Skipping proposal from {owner} and validator {name}: {err}",);
             }
         }
         Ok(())
     }
 
-    async fn try_process_locked_block_from(
+    async fn try_process_locking_block_from(
         &self,
         remote_node: &RemoteNode<P::Node>,
         certificate: GenericCertificate<ValidatedBlock>,
@@ -1984,7 +1977,7 @@ where
 
             let maybe_blob = {
                 let chain_state_view = self.chain_state_view().await?;
-                chain_state_view.manager.locked_blobs.get(&blob_id).await?
+                chain_state_view.manager.locking_blobs.get(&blob_id).await?
             };
 
             if let Some(blob) = maybe_blob {
@@ -2426,17 +2419,18 @@ where
         let info = self.request_leader_timeout_if_needed().await?;
 
         // If there is a validated block in the current round, finalize it.
-        if info.manager.has_locked_block_in_current_round() && !info.manager.current_round.is_fast()
+        if info.manager.has_locking_block_in_current_round()
+            && !info.manager.current_round.is_fast()
         {
-            return self.finalize_locked_block(info).await;
+            return self.finalize_locking_block(info).await;
         }
 
         // Otherwise we have to re-propose the highest validated block, if there is one.
         let pending: Option<ProposedBlock> = self.state().pending_proposal().clone();
-        let executed_block = if let Some(locked) = &info.manager.requested_locked {
-            match &**locked {
-                LockedBlock::Regular(certificate) => certificate.block().clone().into(),
-                LockedBlock::Fast(proposal) => {
+        let executed_block = if let Some(locking) = &info.manager.requested_locking {
+            match &**locking {
+                LockingBlock::Regular(certificate) => certificate.block().clone().into(),
+                LockingBlock::Fast(proposal) => {
                     let block = proposal.content.block.clone();
                     self.stage_block_execution(block).await?.0
                 }
@@ -2463,12 +2457,12 @@ where
             .already_handled_proposal(round, &executed_block.block);
         let key_pair = self.key_pair().await?;
         // Create the final block proposal.
-        let proposal = if let Some(locked) = info.manager.requested_locked {
-            Box::new(match *locked {
-                LockedBlock::Regular(cert) => {
+        let proposal = if let Some(locking) = info.manager.requested_locking {
+            Box::new(match *locking {
+                LockingBlock::Regular(cert) => {
                     BlockProposal::new_retry(round, cert, &key_pair, blobs)
                 }
-                LockedBlock::Fast(proposal) => {
+                LockingBlock::Fast(proposal) => {
                     BlockProposal::new_initial(round, proposal.content.block, &key_pair, blobs)
                 }
             })
@@ -2517,19 +2511,19 @@ where
         Ok(info)
     }
 
-    /// Finalizes the locked block.
+    /// Finalizes the locking block.
     ///
-    /// Panics if there is no locked block; fails if the locked block is not in the current round.
-    async fn finalize_locked_block(
+    /// Panics if there is no locking block; fails if the locking block is not in the current round.
+    async fn finalize_locking_block(
         &self,
         info: Box<ChainInfo>,
     ) -> Result<ClientOutcome<Option<ConfirmedBlockCertificate>>, ChainClientError> {
-        let locked = info
+        let locking = info
             .manager
-            .requested_locked
-            .expect("Should have a locked block");
-        let LockedBlock::Regular(certificate) = *locked else {
-            panic!("Should have a locked validated block");
+            .requested_locking
+            .expect("Should have a locking block");
+        let LockingBlock::Regular(certificate) = *locking else {
+            panic!("Should have a locking validated block");
         };
         let committee = self.local_committee().await?;
         match self.finalize_block(&committee, certificate.clone()).await {

linera-core/src/client/mod.rs

@@ -187,17 +187,17 @@ where
         Ok(storage.read_blobs(blob_ids).await?.into_iter().collect())
     }
 
-    /// Looks for the specified blobs in the local chain manager's locked blobs.
+    /// Looks for the specified blobs in the local chain manager's locking blobs.
     /// Returns `Ok(None)` if any of the blobs is not found.
-    pub async fn get_locked_blobs(
+    pub async fn get_locking_blobs(
         &self,
         blob_ids: &[BlobId],
         chain_id: ChainId,
     ) -> Result<Option<Vec<Blob>>, LocalNodeError> {
         let chain = self.chain_state_view(chain_id).await?;
         let mut blobs = Vec::new();
         for blob_id in blob_ids {
-            match chain.manager.locked_blobs.get(blob_id).await? {
+            match chain.manager.locking_blobs.get(blob_id).await? {
                 None => return Ok(None),
                 Some(blob) => blobs.push(blob),
             }

linera-core/src/local_node.rs

@@ -108,7 +108,7 @@ pub trait ValidatorNode {
     /// Downloads a blob. Returns an error if the validator does not have the blob.
     async fn download_blob(&self, blob_id: BlobId) -> Result<BlobContent, NodeError>;
 
-    /// Downloads a blob that belongs to a pending proposal or the locked block on a chain.
+    /// Downloads a blob that belongs to a pending proposal or the locking block on a chain.
     async fn download_pending_blob(
         &self,
         chain_id: ChainId,

linera-core/src/node.rs

@@ -153,10 +153,10 @@ impl<N: ValidatorNode> RemoteNode<N> {
     ) -> Result<Box<ChainInfo>, NodeError> {
         let manager = &response.info.manager;
         let proposed = manager.requested_proposed.as_ref();
-        let locked = manager.requested_locked.as_ref();
+        let locking = manager.requested_locking.as_ref();
         ensure!(
             proposed.map_or(true, |proposal| proposal.content.block.chain_id == chain_id)
-                && locked.map_or(true, |cert| cert.chain_id() == chain_id)
+                && locking.map_or(true, |cert| cert.chain_id() == chain_id)
                 && response.check(&self.name).is_ok(),
             NodeError::InvalidChainInfoResponse
         );