Remove hash, time and height from ChainClientState. (#4024)

## Motivation

The next block height, most recent block hash, and most recent block
timestamp are currently read from the wallet and put into
`ChainClientState`, which is then updated frequently (but not always:
#2652) based on the
local node's chain state.

So the fields in the `ChainClientState` are meant to first equal the
values from the wallet, and then the values from the chain state view.

## Proposal

Keep only the values from the wallet in `ChainClient` and never update
them. Whenever the _current_ values are needed, read them from the chain
state directly.

## Test Plan

CI

## Release Plan

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

## Links

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

Author: afck

linera-client/src/client_context.rs

@@ -100,7 +100,6 @@ where
         self.make_chain_client_internal(
             chain_id,
             chain.block_hash,
-            chain.timestamp,
             chain.next_block_height,
             chain.pending_proposal,
             chain.owner,
@@ -272,15 +271,13 @@ impl<Env: Environment, W: Persist<Target = Wallet>> ClientContext<Env, W> {
         &self,
         chain_id: ChainId,
         block_hash: Option<CryptoHash>,
-        timestamp: Timestamp,
         next_block_height: BlockHeight,
         pending_proposal: Option<PendingProposal>,
         preferred_owner: Option<AccountOwner>,
     ) -> ChainClient<Env> {
         let mut chain_client = self.client.create_chain_client(
             chain_id,
             block_hash,
-            timestamp,
             next_block_height,
             pending_proposal,
             preferred_owner,
@@ -316,7 +313,12 @@ impl<Env: Environment, W: Persist<Target = Wallet>> ClientContext<Env, W> {
         &mut self,
         client: &ChainClient<Env_>,
     ) -> Result<(), Error> {
-        self.wallet.as_mut().update_from_state(client);
+        let info = client.chain_info().await?;
+        let client_owner = client.preferred_owner();
+        let pending_proposal = client.pending_proposal().clone();
+        self.wallet
+            .as_mut()
+            .update_from_info(pending_proposal, client_owner, &info);
         self.save_wallet().await
     }
 
@@ -777,7 +779,12 @@ where
 
             info!("Updating wallet from chain clients...");
             for chain_client in chain_clients.values() {
-                self.wallet.as_mut().update_from_state(chain_client);
+                let info = chain_client.chain_info().await?;
+                let client_owner = chain_client.preferred_owner();
+                let pending_proposal = chain_client.pending_proposal().clone();
+                self.wallet
+                    .as_mut()
+                    .update_from_info(pending_proposal, client_owner, &info);
             }
             self.save_wallet().await?;
         }
@@ -903,7 +910,6 @@ where
                 let mut chain_client = self.make_chain_client_internal(
                     chain_id,
                     None,
-                    certificate.block().header.timestamp,
                     BlockHeight::ZERO,
                     None,
                     Some(pub_key.into()),

linera-client/src/unit_tests/chain_listener.rs

@@ -57,7 +57,6 @@ impl chain_listener::ClientContext for ClientContext {
         self.client.create_chain_client(
             chain_id,
             chain.block_hash,
-            chain.timestamp,
             chain.next_block_height,
             chain.pending_proposal.clone(),
             chain.owner,
@@ -88,7 +87,11 @@ impl chain_listener::ClientContext for ClientContext {
         &mut self,
         client: &ChainClient<environment::Test>,
     ) -> Result<(), Error> {
-        self.wallet.update_from_state(client);
+        let info = client.chain_info().await?;
+        let client_owner = client.preferred_owner();
+        let pending_proposal = client.pending_proposal().clone();
+        self.wallet
+            .update_from_info(pending_proposal, client_owner, &info);
         Ok(())
     }
 }

linera-client/src/wallet.rs

@@ -9,10 +9,7 @@ use linera_base::{
     ensure,
     identifiers::{AccountOwner, ChainId},
 };
-use linera_core::{
-    client::{ChainClient, PendingProposal},
-    Environment,
-};
+use linera_core::{client::PendingProposal, data_types::ChainInfo};
 use serde::{Deserialize, Serialize};
 
 use crate::{config::GenesisConfig, error, Error};
@@ -132,16 +129,19 @@ impl Wallet {
         Ok(())
     }
 
-    pub fn update_from_state<Env: Environment>(&mut self, chain_client: &ChainClient<Env>) {
-        let client_owner = chain_client.preferred_owner();
-        let state = chain_client.state();
+    pub fn update_from_info(
+        &mut self,
+        pending_proposal: Option<PendingProposal>,
+        owner: Option<AccountOwner>,
+        info: &ChainInfo,
+    ) {
         self.insert(UserChain {
-            chain_id: chain_client.chain_id(),
-            owner: client_owner,
-            block_hash: state.block_hash(),
-            next_block_height: state.next_block_height(),
-            timestamp: state.timestamp(),
-            pending_proposal: state.pending_proposal().clone(),
+            chain_id: info.chain_id,
+            owner,
+            block_hash: info.block_hash,
+            next_block_height: info.next_block_height,
+            timestamp: info.timestamp,
+            pending_proposal,
         });
     }
 

linera-core/src/client/chain_client_state.rs

@@ -4,29 +4,16 @@
 
 use std::{collections::BTreeSet, sync::Arc};
 
-use linera_base::{
-    crypto::CryptoHash,
-    data_types::{Blob, BlockHeight, Timestamp},
-    ensure,
-    identifiers::AccountOwner,
-    ownership::ChainOwnership,
-};
+use linera_base::data_types::Blob;
 use linera_chain::data_types::ProposedBlock;
 use tokio::sync::Mutex;
 
-use super::{ChainClientError, PendingProposal};
+use super::PendingProposal;
 use crate::data_types::ChainInfo;
 
 /// The state of our interaction with a particular chain: how far we have synchronized it and
 /// whether we are currently attempting to propose a new block.
 pub struct ChainClientState {
-    /// Latest block hash, if any.
-    block_hash: Option<CryptoHash>,
-    /// The earliest possible timestamp for the next block.
-    timestamp: Timestamp,
-    /// Sequence number that we plan to use for the next block.
-    /// We track this value outside local storage mainly for security reasons.
-    next_block_height: BlockHeight,
     /// The block we are currently trying to propose for the next height, if any.
     ///
     /// This is always at the same height as `next_block_height`.
@@ -38,71 +25,44 @@ pub struct ChainClientState {
 }
 
 impl ChainClientState {
-    pub fn new(
-        block_hash: Option<CryptoHash>,
-        timestamp: Timestamp,
-        next_block_height: BlockHeight,
-        pending_proposal: Option<PendingProposal>,
-    ) -> ChainClientState {
+    pub fn new(pending_proposal: Option<PendingProposal>) -> ChainClientState {
         ChainClientState {
-            block_hash,
-            timestamp,
-            next_block_height,
             pending_proposal,
             client_mutex: Arc::default(),
         }
     }
 
-    pub fn block_hash(&self) -> Option<CryptoHash> {
-        self.block_hash
-    }
-
-    pub fn timestamp(&self) -> Timestamp {
-        self.timestamp
-    }
-
-    pub fn next_block_height(&self) -> BlockHeight {
-        self.next_block_height
-    }
-
     pub fn pending_proposal(&self) -> &Option<PendingProposal> {
         &self.pending_proposal
     }
 
     pub(super) fn set_pending_proposal(&mut self, block: ProposedBlock, blobs: Vec<Blob>) {
-        if block.height == self.next_block_height {
-            let blobs = Vec::from_iter(blobs);
-            assert_eq!(
-                block.published_blob_ids(),
-                BTreeSet::from_iter(blobs.iter().map(Blob::id))
-            );
-            self.pending_proposal = Some(PendingProposal { block, blobs });
-        } else {
+        if self
+            .pending_proposal
+            .as_ref()
+            .is_some_and(|pending| pending.block.height >= block.height)
+        {
             tracing::error!(
-                "Not setting pending block at height {}, because next_block_height is {}.",
-                block.height,
-                self.next_block_height
+                "Not setting pending block at {}, because we already have a pending proposal.",
+                block.height
             );
+            return;
         }
-    }
-
-    /// Returns whether the given ownership includes anyone whose secret key we don't have.
-    pub fn has_other_owners(
-        &self,
-        ownership: &ChainOwnership,
-        preferred_owner: &Option<AccountOwner>,
-    ) -> bool {
-        ownership
-            .all_owners()
-            .any(|owner| Some(owner) != preferred_owner.as_ref())
+        let blobs = Vec::from_iter(blobs);
+        assert_eq!(
+            block.published_blob_ids(),
+            BTreeSet::from_iter(blobs.iter().map(Blob::id))
+        );
+        self.pending_proposal = Some(PendingProposal { block, blobs });
     }
 
     pub(super) fn update_from_info(&mut self, info: &ChainInfo) {
-        if info.next_block_height > self.next_block_height {
-            self.next_block_height = info.next_block_height;
+        if self
+            .pending_proposal
+            .as_ref()
+            .is_some_and(|pending| pending.block.height < info.next_block_height)
+        {
             self.clear_pending_proposal();
-            self.block_hash = info.block_hash;
-            self.timestamp = info.timestamp;
         }
     }
 
@@ -113,17 +73,4 @@ impl ChainClientState {
     pub(super) fn client_mutex(&self) -> Arc<Mutex<()>> {
         self.client_mutex.clone()
     }
-
-    /// Returns an error if the chain info does not match the block hash and height.
-    pub(super) fn check_info_is_up_to_date(
-        &self,
-        info: &ChainInfo,
-    ) -> Result<(), ChainClientError> {
-        ensure!(
-            self.block_hash() == info.block_hash
-                && self.next_block_height() == info.next_block_height,
-            ChainClientError::BlockProposalError("The chain is not synchronized.")
-        );
-        Ok(())
-    }
 }