client_contexts.rs

use std::fmt::Debug;

use basecoin_store::context::Store;
use basecoin_store::types::Height;
use ibc::clients::tendermint::client_state::ClientState as TmClientState;
use ibc::clients::tendermint::consensus_state::ConsensusState as TmConsensusState;
use ibc::clients::tendermint::context::{CommonContext, ValidationContext as TmValidationContext};
use ibc::core::client::context::{ClientExecutionContext, ClientValidationContext};
use ibc::core::client::types::error::ClientError;
use ibc::core::client::types::Height as IbcHeight;
use ibc::core::handler::types::error::ContextError;
use ibc::core::host::types::identifiers::ClientId;
use ibc::core::host::types::path::{ClientConsensusStatePath, ClientStatePath, Path};
use ibc::core::host::ValidationContext;
use ibc::primitives::Timestamp;

use super::impls::{AnyConsensusState, IbcContext};

impl<S> ClientValidationContext for IbcContext<S>
where
    S: Store + Debug,
{
    /// Returns the time and height when the client state for the given
    /// [`ClientId`] was updated with a header for the given [`IbcHeight`]
    fn update_meta(
        &self,
        client_id: &ClientId,
        height: &IbcHeight,
    ) -> Result<(Timestamp, IbcHeight), ContextError> {
        let processed_timestamp = self
            .client_processed_times
            .get(&(client_id.clone(), *height))
            .cloned()
            .ok_or(ClientError::UpdateMetaDataNotFound {
                client_id: client_id.clone(),
                height: *height,
            })?;
        let processed_height = self
            .client_processed_heights
            .get(&(client_id.clone(), *height))
            .cloned()
            .ok_or(ClientError::UpdateMetaDataNotFound {
                client_id: client_id.clone(),
                height: *height,
            })?;
        Ok((processed_timestamp, processed_height))
    }
}

impl<S> ClientExecutionContext for IbcContext<S>
where
    S: Store + Debug,
{
    type V = Self;

    type AnyClientState = TmClientState;

    type AnyConsensusState = AnyConsensusState;

    /// Called upon successful client creation and update
    fn store_client_state(
        &mut self,
        client_state_path: ClientStatePath,
        client_state: Self::AnyClientState,
    ) -> Result<(), ContextError> {
        self.client_state_store
            .set(client_state_path, client_state)
            .map(|_| ())
            .map_err(|_| ClientError::Other {
                description: "Client state store error".to_string(),
            })?;
        Ok(())
    }

    /// Called upon successful client creation and update
    fn store_consensus_state(
        &mut self,
        consensus_state_path: ClientConsensusStatePath,
        consensus_state: Self::AnyConsensusState,
    ) -> Result<(), ContextError> {
        let tm_consensus_state: TmConsensusState =
            consensus_state.try_into().map_err(|_| ClientError::Other {
                description: "Consensus state type mismatch".to_string(),
            })?;
        self.consensus_state_store
            .set(consensus_state_path, tm_consensus_state)
            .map_err(|_| ClientError::Other {
                description: "Consensus state store error".to_string(),
            })?;
        Ok(())
    }

    fn delete_consensus_state(
        &mut self,
        consensus_state_path: ClientConsensusStatePath,
    ) -> Result<(), ContextError> {
        self.consensus_state_store.delete(consensus_state_path);
        Ok(())
    }

    /// Called upon successful client update. Implementations are expected to
    /// use this to record the specified time and height at which this update
    /// (or header) was processed.
    fn store_update_meta(
        &mut self,
        client_id: ClientId,
        height: IbcHeight,
        host_timestamp: Timestamp,
        host_height: IbcHeight,
    ) -> Result<(), ContextError> {
        self.client_processed_times
            .insert((client_id.clone(), height), host_timestamp);
        self.client_processed_heights
            .insert((client_id, height), host_height);
        Ok(())
    }

    /// Delete the update time and height associated with the client at the
    /// specified height.
    fn delete_update_meta(
        &mut self,
        client_id: ClientId,
        height: IbcHeight,
    ) -> Result<(), ContextError> {
        self.client_processed_times
            .remove(&(client_id.clone(), height));
        self.client_processed_heights.remove(&(client_id, height));
        Ok(())
    }
}

impl<S> CommonContext for IbcContext<S>
where
    S: Store + Debug,
{
    type ConversionError = &'static str;
    type AnyConsensusState = AnyConsensusState;

    fn host_timestamp(&self) -> Result<Timestamp, ContextError> {
        ValidationContext::host_timestamp(self)
    }

    fn host_height(&self) -> Result<IbcHeight, ContextError> {
        ValidationContext::host_height(self)
    }

    fn consensus_state(
        &self,
        client_cons_state_path: &ClientConsensusStatePath,
    ) -> Result<Self::AnyConsensusState, ContextError> {
        ValidationContext::consensus_state(self, client_cons_state_path)
    }

    fn consensus_state_heights(
        &self,
        client_id: &ClientId,
    ) -> Result<Vec<IbcHeight>, ContextError> {
        let path = format!("clients/{}/consensusStates", client_id)
            .try_into()
            .map_err(|_| ClientError::Other {
                description: "Invalid consensus state path".into(),
            })?;

        self.consensus_state_store
            .get_keys(&path)
            .into_iter()
            .flat_map(|path| {
                if let Ok(Path::ClientConsensusState(consensus_path)) = path.try_into() {
                    Some(consensus_path)
                } else {
                    None
                }
            })
            .map(|consensus_path| {
                let height = IbcHeight::new(
                    consensus_path.revision_number,
                    consensus_path.revision_height,
                )?;
                Ok(height)
            })
            .collect()
    }
}

impl<S> TmValidationContext for IbcContext<S>
where
    S: Store + Debug,
{
    fn next_consensus_state(
        &self,
        client_id: &ClientId,
        height: &IbcHeight,
    ) -> Result<Option<Self::AnyConsensusState>, ContextError> {
        let path = format!("clients/{client_id}/consensusStates")
            .try_into()
            .unwrap(); // safety - path must be valid since ClientId and height are valid Identifiers

        let keys = self.store.get_keys(&path);
        let found_path = keys.into_iter().find_map(|path| {
            if let Ok(Path::ClientConsensusState(path)) = path.try_into() {
                if height > &IbcHeight::new(path.revision_number, path.revision_height).unwrap() {
                    return Some(path);
                }
            }
            None
        });

        if let Some(path) = found_path {
            let consensus_state = self
                .consensus_state_store
                .get(Height::Pending, &path)
                .ok_or(ClientError::ConsensusStateNotFound {
                    client_id: client_id.clone(),
                    height: *height,
                })?;

            Ok(Some(consensus_state.into()))
        } else {
            Ok(None)
        }
    }

    fn prev_consensus_state(
        &self,
        client_id: &ClientId,
        height: &IbcHeight,
    ) -> Result<Option<Self::AnyConsensusState>, ContextError> {
        let path = format!("clients/{client_id}/consensusStates")
            .try_into()
            .unwrap(); // safety - path must be valid since ClientId and height are valid Identifiers

        let keys = self.store.get_keys(&path);
        let pos = keys.iter().position(|path| {
            if let Ok(Path::ClientConsensusState(path)) = path.clone().try_into() {
                height >= &IbcHeight::new(path.revision_number, path.revision_height).unwrap()
            } else {
                false
            }
        });

        if let Some(pos) = pos {
            if pos > 0 {
                let prev_path = match keys[pos - 1].clone().try_into() {
                    Ok(Path::ClientConsensusState(p)) => p,
                    _ => unreachable!(), // safety - path retrieved from store
                };
                let consensus_state = self
                    .consensus_state_store
                    .get(Height::Pending, &prev_path)
                    .ok_or(ClientError::ConsensusStateNotFound {
                        client_id: client_id.clone(),
                        height: *height,
                    })?;
                return Ok(Some(consensus_state.into()));
            }
        }
        Ok(None)
    }
}