Implement consensus state pruning for Tendermint clients

.changelog/unreleased/improvements/600-tendermint-pruning.md

@@ -0,0 +1 @@
+- Implement consensus state pruning for Tendermint light clients ([#600](https://github.com/cosmos/ibc-rs/issues/600))

crates/ibc/src/clients/ics07_tendermint/client_state.rs

@@ -29,6 +29,7 @@ use crate::clients::ics07_tendermint::consensus_state::ConsensusState as TmConse
 use crate::clients::ics07_tendermint::error::Error;
 use crate::clients::ics07_tendermint::header::Header as TmHeader;
 use crate::clients::ics07_tendermint::misbehaviour::Misbehaviour as TmMisbehaviour;
+use crate::clients::ics07_tendermint::CommonContext;
 use crate::core::ics02_client::client_state::{
     ClientStateCommon, ClientStateExecution, ClientStateValidation, Status, UpdateKind,
 };
@@ -46,6 +47,7 @@ use crate::core::ics24_host::path::{
     ClientConsensusStatePath, ClientStatePath, Path, UpgradeClientPath,
 };
 use crate::core::timestamp::ZERO_DURATION;
+use crate::core::ExecutionContext;
 use crate::prelude::*;
 use crate::Height;
 
@@ -488,7 +490,7 @@ where
 
 impl<E> ClientStateExecution<E> for ClientState
 where
-    E: TmExecutionContext,
+    E: TmExecutionContext + ExecutionContext + TmValidationContext,
     <E as ClientExecutionContext>::AnyClientState: From<ClientState>,
     <E as ClientExecutionContext>::AnyConsensusState: From<TmConsensusState>,
 {
@@ -498,19 +500,18 @@ where
         client_id: &ClientId,
         consensus_state: Any,
     ) -> Result<(), ClientError> {
+        let host_timestamp = CommonContext::host_timestamp(ctx)?;
+        let host_height = CommonContext::host_height(ctx)?;
+
         let tm_consensus_state = TmConsensusState::try_from(consensus_state)?;
 
         ctx.store_client_state(ClientStatePath::new(client_id), self.clone().into())?;
         ctx.store_consensus_state(
             ClientConsensusStatePath::new(client_id, &self.latest_height),
             tm_consensus_state.into(),
         )?;
-        ctx.store_update_time(
-            client_id.clone(),
-            self.latest_height(),
-            ctx.host_timestamp()?,
-        )?;
-        ctx.store_update_height(client_id.clone(), self.latest_height(), ctx.host_height()?)?;
+        ctx.store_update_time(client_id.clone(), self.latest_height(), host_timestamp)?;
+        ctx.store_update_height(client_id.clone(), self.latest_height(), host_height)?;
 
         Ok(())
     }
@@ -524,10 +525,12 @@ where
         let header = TmHeader::try_from(header)?;
         let header_height = header.height();
 
+        self.prune_oldest_consensus_state(ctx, client_id)?;
+
         let maybe_existing_consensus_state = {
             let path_at_header_height = ClientConsensusStatePath::new(client_id, &header_height);
 
-            ctx.consensus_state(&path_at_header_height).ok()
+            CommonContext::consensus_state(ctx, &path_at_header_height).ok()
         };
 
         if maybe_existing_consensus_state.is_some() {
@@ -536,6 +539,9 @@ where
             //
             // Do nothing.
         } else {
+            let host_timestamp = CommonContext::host_timestamp(ctx)?;
+            let host_height = CommonContext::host_height(ctx)?;
+
             let new_consensus_state = TmConsensusState::from(header.clone());
             let new_client_state = self.clone().with_header(header)?;
 
@@ -544,8 +550,8 @@ where
                 new_consensus_state.into(),
             )?;
             ctx.store_client_state(ClientStatePath::new(client_id), new_client_state.into())?;
-            ctx.store_update_time(client_id.clone(), header_height, ctx.host_timestamp()?)?;
-            ctx.store_update_height(client_id.clone(), header_height, ctx.host_height()?)?;
+            ctx.store_update_time(client_id.clone(), header_height, host_timestamp)?;
+            ctx.store_update_height(client_id.clone(), header_height, host_height)?;
         }
 
         Ok(vec![header_height])
@@ -615,14 +621,16 @@ where
         );
 
         let latest_height = new_client_state.latest_height;
+        let host_timestamp = CommonContext::host_timestamp(ctx)?;
+        let host_height = CommonContext::host_height(ctx)?;
 
         ctx.store_client_state(ClientStatePath::new(client_id), new_client_state.into())?;
         ctx.store_consensus_state(
             ClientConsensusStatePath::new(client_id, &latest_height),
             new_consensus_state.into(),
         )?;
-        ctx.store_update_time(client_id.clone(), latest_height, ctx.host_timestamp()?)?;
-        ctx.store_update_height(client_id.clone(), latest_height, ctx.host_height()?)?;
+        ctx.store_update_time(client_id.clone(), latest_height, host_timestamp)?;
+        ctx.store_update_height(client_id.clone(), latest_height, host_height)?;
 
         Ok(latest_height)
     }

crates/ibc/src/clients/ics07_tendermint/client_state/update_client.rs

@@ -5,8 +5,10 @@ use super::{check_header_trusted_next_validator_set, ClientState};
 use crate::clients::ics07_tendermint::consensus_state::ConsensusState as TmConsensusState;
 use crate::clients::ics07_tendermint::error::{Error, IntoResult};
 use crate::clients::ics07_tendermint::header::Header as TmHeader;
-use crate::clients::ics07_tendermint::ValidationContext as TmValidationContext;
+use crate::clients::ics07_tendermint::{CommonContext, ValidationContext as TmValidationContext};
+use crate::core::ics02_client::consensus_state::ConsensusState;
 use crate::core::ics02_client::error::ClientError;
+use crate::core::ics02_client::ClientExecutionContext;
 use crate::core::ics24_host::identifier::ClientId;
 use crate::core::ics24_host::path::ClientConsensusStatePath;
 use crate::prelude::*;
@@ -163,4 +165,47 @@ impl ClientState {
             }
         }
     }
+
+    pub fn prune_oldest_consensus_state<E>(
+        &self,
+        ctx: &mut E,
+        client_id: &ClientId,
+    ) -> Result<(), ClientError>
+    where
+        E: ClientExecutionContext + TmValidationContext,
+    {
+        let mut heights = ctx.consensus_state_heights(client_id)?;
+
+        heights.sort();
+
+        for height in heights {
+            let client_consensus_state_path = ClientConsensusStatePath::new(client_id, &height);
+            let consensus_state =
+                CommonContext::consensus_state(ctx, &client_consensus_state_path)?;
+            let tm_consensus_state: TmConsensusState =
+                consensus_state
+                    .try_into()
+                    .map_err(|err| ClientError::Other {
+                        description: err.to_string(),
+                    })?;
+
+            let host_timestamp = ctx.host_timestamp()?;
+            let tm_consensus_state_timestamp = (tm_consensus_state.timestamp() + self.trusting_period)
+                .map_err(|_| ClientError::Other {
+                    description: String::from("Timestamp overflow error occurred while attempting to parse TmConsensusState")
+                })?;
+
+            if tm_consensus_state_timestamp > host_timestamp {
+                break;
+            } else {
+                let client_id = client_id.clone();
+
+                ctx.delete_consensus_state(client_consensus_state_path)?;
+                ctx.delete_update_time(client_id.clone(), height)?;
+                ctx.delete_update_height(client_id, height)?;
+            }
+        }
+
+        Ok(())
+    }
 }

crates/ibc/src/clients/ics07_tendermint/context.rs

@@ -6,6 +6,7 @@ use crate::core::ics24_host::identifier::ClientId;
 use crate::core::ics24_host::path::ClientConsensusStatePath;
 use crate::core::timestamp::Timestamp;
 use crate::core::ContextError;
+use crate::prelude::*;
 use crate::Height;
 
 /// Client's context required during both validation and execution
@@ -27,6 +28,9 @@ pub trait CommonContext {
         &self,
         client_cons_state_path: &ClientConsensusStatePath,
     ) -> Result<Self::AnyConsensusState, ContextError>;
+
+    /// Returns all the heights at which a consensus state is stored
+    fn consensus_state_heights(&self, client_id: &ClientId) -> Result<Vec<Height>, ContextError>;
 }
 
 /// Client's context required during validation

crates/ibc/src/core/ics02_client/context.rs

@@ -53,6 +53,30 @@ pub trait ClientExecutionContext: Sized {
         consensus_state: Self::AnyConsensusState,
     ) -> Result<(), ContextError>;
 
+    /// Delete the consensus state from the store located at the given `ClientConsensusStatePath`
+    fn delete_consensus_state(
+        &mut self,
+        consensus_state_path: ClientConsensusStatePath,
+    ) -> Result<(), ContextError>;
+
+    /// Delete the update time associated with the client at the specified height. This update
+    /// time should be associated with a consensus state through the specified height.
+    ///
+    /// Note that this timestamp is determined by the host.
+    fn delete_update_time(
+        &mut self,
+        client_id: ClientId,
+        height: Height,
+    ) -> Result<(), ContextError>;
+
+    /// Delete the update height associated with the client at the specified height. This update
+    /// time should be associated with a consensus state through the specified height.
+    fn delete_update_height(
+        &mut self,
+        client_id: ClientId,
+        height: Height,
+    ) -> Result<(), ContextError>;
+
     /// Called upon successful client update.
     /// Implementations are expected to use this to record the specified time as the time at which
     /// this update (or header) was processed.

crates/ibc/src/mock/context/clients.rs

@@ -52,6 +52,21 @@ impl TmCommonContext for MockContext {
     ) -> Result<Self::AnyConsensusState, ContextError> {
         ValidationContext::consensus_state(self, client_cons_state_path)
     }
+
+    fn consensus_state_heights(&self, client_id: &ClientId) -> Result<Vec<Height>, ContextError> {
+        let ibc_store = self.ibc_store.lock();
+        let client_record =
+            ibc_store
+                .clients
+                .get(client_id)
+                .ok_or_else(|| ClientError::ClientStateNotFound {
+                    client_id: client_id.clone(),
+                })?;
+
+        let heights = client_record.consensus_states.keys().cloned().collect();
+
+        Ok(heights)
+    }
 }
 
 impl TmValidationContext for MockContext {
@@ -214,6 +229,56 @@ impl ClientExecutionContext for MockContext {
         Ok(())
     }
 
+    fn delete_consensus_state(
+        &mut self,
+        consensus_state_path: ClientConsensusStatePath,
+    ) -> Result<(), ContextError> {
+        let mut ibc_store = self.ibc_store.lock();
+
+        let client_record = ibc_store
+            .clients
+            .entry(consensus_state_path.client_id)
+            .or_insert(MockClientRecord {
+                consensus_states: Default::default(),
+                client_state: Default::default(),
+            });
+
+        let height = Height::new(consensus_state_path.epoch, consensus_state_path.height)
+            .expect("Never fails");
+
+        client_record.consensus_states.remove(&height);
+
+        Ok(())
+    }
+
+    fn delete_update_height(
+        &mut self,
+        client_id: ClientId,
+        height: Height,
+    ) -> Result<(), ContextError> {
+        let _ = self
+            .ibc_store
+            .lock()
+            .client_processed_heights
+            .remove(&(client_id, height));
+
+        Ok(())
+    }
+
+    fn delete_update_time(
+        &mut self,
+        client_id: ClientId,
+        height: Height,
+    ) -> Result<(), ContextError> {
+        let _ = self
+            .ibc_store
+            .lock()
+            .client_processed_times
+            .remove(&(client_id, height));
+
+        Ok(())
+    }
+
     fn store_update_time(
         &mut self,
         client_id: ClientId,
@@ -225,6 +290,7 @@ impl ClientExecutionContext for MockContext {
             .lock()
             .client_processed_times
             .insert((client_id, height), timestamp);
+
         Ok(())
     }
 
@@ -239,6 +305,7 @@ impl ClientExecutionContext for MockContext {
             .lock()
             .client_processed_heights
             .insert((client_id, height), host_height);
+
         Ok(())
     }
 }