Misbehavior monitoring and handling

modules/src/events.rs

@@ -13,6 +13,7 @@ use crate::Height;
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum IbcEventType {
     CreateClient,
+    UpdateClient,
     SendPacket,
     WriteAck,
 }
@@ -21,6 +22,7 @@ impl IbcEventType {
     pub fn as_str(&self) -> &'static str {
         match *self {
             IbcEventType::CreateClient => "create_client",
+            IbcEventType::UpdateClient => "update_client",
             IbcEventType::SendPacket => "send_packet",
             IbcEventType::WriteAck => "write_acknowledgement",
         }
@@ -34,7 +36,7 @@ pub enum IbcEvent {
 
     CreateClient(ClientEvents::CreateClient),
     UpdateClient(ClientEvents::UpdateClient),
-    ClientMisbehavior(ClientEvents::ClientMisbehavior),
+    ClientMisbehaviour(ClientEvents::ClientMisbehaviour),
 
     OpenInitConnection(ConnectionEvents::OpenInit),
     OpenTryConnection(ConnectionEvents::OpenTry),
@@ -57,6 +59,7 @@ pub enum IbcEvent {
 
     Empty(String),      // Special event, signifying empty response
     ChainError(String), // Special event, signifying an error on CheckTx or DeliverTx
+    UpdateClient2(ClientEvents::UpdateClient2), // Special event, signifying an error on CheckTx or DeliverTx
 }
 
 // This is tendermint specific
@@ -86,7 +89,7 @@ impl IbcEvent {
             IbcEvent::NewBlock(bl) => bl.height(),
             IbcEvent::CreateClient(ev) => ev.height(),
             IbcEvent::UpdateClient(ev) => ev.height(),
-            IbcEvent::ClientMisbehavior(ev) => ev.height(),
+            IbcEvent::ClientMisbehaviour(ev) => ev.height(),
             IbcEvent::OpenInitConnection(ev) => ev.height(),
             IbcEvent::OpenTryConnection(ev) => ev.height(),
             IbcEvent::OpenAckConnection(ev) => ev.height(),
@@ -111,7 +114,7 @@ impl IbcEvent {
             IbcEvent::NewBlock(ev) => ev.set_height(height),
             IbcEvent::CreateClient(ev) => ev.set_height(height),
             IbcEvent::UpdateClient(ev) => ev.set_height(height),
-            IbcEvent::ClientMisbehavior(ev) => ev.set_height(height),
+            IbcEvent::ClientMisbehaviour(ev) => ev.set_height(height),
             IbcEvent::OpenInitConnection(ev) => ev.set_height(height),
             IbcEvent::OpenTryConnection(ev) => ev.set_height(height),
             IbcEvent::OpenAckConnection(ev) => ev.set_height(height),

modules/src/ics02_client/client_consensus.rs

@@ -0,0 +1,150 @@
+use std::convert::{TryFrom, TryInto};
+
+use prost_types::Any;
+use serde_derive::Serialize;
+use tendermint_proto::Protobuf;
+
+use ibc_proto::ibc::core::client::v1::ConsensusStateWithHeight;
+
+use crate::ics02_client::client_type::ClientType;
+use crate::ics02_client::error::{Error, Kind};
+use crate::ics02_client::height::Height;
+use crate::ics07_tendermint::consensus_state::ConsensusState as TmConsensusState;
+use crate::ics23_commitment::commitment::CommitmentRoot;
+#[cfg(any(test, feature = "mocks"))]
+use crate::mock::client_state::MockConsensusState;
+
+#[cfg(any(test, feature = "mocks"))]
+pub const MOCK_CONSENSUS_STATE_TYPE_URL: &str = "/ibc.mock.ConsensusState";
+
+pub const TENDERMINT_CONSENSUS_STATE_TYPE_URL: &str =
+    "/ibc.lightclients.tendermint.v1.ConsensusState";
+
+#[dyn_clonable::clonable]
+pub trait ConsensusState: Clone + std::fmt::Debug + Send + Sync {
+    /// Type of client associated with this consensus state (eg. Tendermint)
+    fn client_type(&self) -> ClientType;
+
+    /// Commitment root of the consensus state, which is used for key-value pair verification.
+    fn root(&self) -> &CommitmentRoot;
+
+    /// Performs basic validation of the consensus state
+    fn validate_basic(&self) -> Result<(), Box<dyn std::error::Error>>;
+
+    /// Wrap into an `AnyConsensusState`
+    fn wrap_any(self) -> AnyConsensusState;
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(tag = "type")]
+pub enum AnyConsensusState {
+    Tendermint(TmConsensusState),
+
+    #[cfg(any(test, feature = "mocks"))]
+    Mock(MockConsensusState),
+}
+
+impl AnyConsensusState {
+    pub fn client_type(&self) -> ClientType {
+        match self {
+            AnyConsensusState::Tendermint(_cs) => ClientType::Tendermint,
+
+            #[cfg(any(test, feature = "mocks"))]
+            AnyConsensusState::Mock(_cs) => ClientType::Mock,
+        }
+    }
+}
+
+impl Protobuf<Any> for AnyConsensusState {}
+
+impl TryFrom<Any> for AnyConsensusState {
+    type Error = Error;
+
+    fn try_from(value: Any) -> Result<Self, Self::Error> {
+        match value.type_url.as_str() {
+            "" => Err(Kind::EmptyConsensusState.into()),
+
+            TENDERMINT_CONSENSUS_STATE_TYPE_URL => Ok(AnyConsensusState::Tendermint(
+                TmConsensusState::decode_vec(&value.value)
+                    .map_err(|e| Kind::InvalidRawConsensusState.context(e))?,
+            )),
+
+            #[cfg(any(test, feature = "mocks"))]
+            MOCK_CONSENSUS_STATE_TYPE_URL => Ok(AnyConsensusState::Mock(
+                MockConsensusState::decode_vec(&value.value)
+                    .map_err(|e| Kind::InvalidRawConsensusState.context(e))?,
+            )),
+
+            _ => Err(Kind::UnknownConsensusStateType(value.type_url).into()),
+        }
+    }
+}
+
+impl From<AnyConsensusState> for Any {
+    fn from(value: AnyConsensusState) -> Self {
+        match value {
+            AnyConsensusState::Tendermint(value) => Any {
+                type_url: TENDERMINT_CONSENSUS_STATE_TYPE_URL.to_string(),
+                value: value.encode_vec().unwrap(),
+            },
+            #[cfg(any(test, feature = "mocks"))]
+            AnyConsensusState::Mock(value) => Any {
+                type_url: MOCK_CONSENSUS_STATE_TYPE_URL.to_string(),
+                value: value.encode_vec().unwrap(),
+            },
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+pub struct AnyConsensusStateWithHeight {
+    height: Height,
+    consensus_state: AnyConsensusState,
+}
+
+impl Protobuf<ConsensusStateWithHeight> for AnyConsensusStateWithHeight {}
+
+impl TryFrom<ConsensusStateWithHeight> for AnyConsensusStateWithHeight {
+    type Error = Error;
+
+    fn try_from(value: ConsensusStateWithHeight) -> Result<Self, Self::Error> {
+        let state = value
+            .consensus_state
+            .map(AnyConsensusState::try_from)
+            .transpose()
+            .map_err(|e| Kind::InvalidRawConsensusState.context(e))?
+            .ok_or(Kind::EmptyConsensusState)?;
+
+        Ok(AnyConsensusStateWithHeight {
+            height: value.height.ok_or(Kind::InvalidHeightResult)?.try_into()?,
+            consensus_state: state,
+        })
+    }
+}
+
+impl From<AnyConsensusStateWithHeight> for ConsensusStateWithHeight {
+    fn from(value: AnyConsensusStateWithHeight) -> Self {
+        ConsensusStateWithHeight {
+            height: Some(value.height.into()),
+            consensus_state: Some(value.consensus_state.into()),
+        }
+    }
+}
+
+impl ConsensusState for AnyConsensusState {
+    fn client_type(&self) -> ClientType {
+        self.client_type()
+    }
+
+    fn root(&self) -> &CommitmentRoot {
+        todo!()
+    }
+
+    fn validate_basic(&self) -> Result<(), Box<dyn std::error::Error>> {
+        todo!()
+    }
+
+    fn wrap_any(self) -> AnyConsensusState {
+        self
+    }
+}