ICS3 connection handshake protocol (message processing logic)

modules/src/address.rs

@@ -0,0 +1 @@
+pub struct AccAddress(Vec<u8>;

modules/src/context.rs

@@ -0,0 +1,30 @@
+use crate::ics02_client::client_def::AnyConsensusState;
+use crate::mock_client::header::MockHeader;
+use crate::mock_client::state::MockConsensusState;
+use serde_derive::{Deserialize, Serialize};
+use tendermint::block::Height;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SelfHeader {
+    Mock(MockHeader),
+    //Tendermint(tendermint::header::Header),
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct HistoricalInfo {
+    pub header: SelfHeader,
+}
+
+impl From<MockHeader> for AnyConsensusState {
+    fn from(h: MockHeader) -> Self {
+        AnyConsensusState::Mock(MockConsensusState(h))
+    }
+}
+
+pub trait ChainReader {
+    fn self_historical_info(&self, height: Height) -> Option<&HistoricalInfo>;
+}
+
+pub trait ChainKeeper {
+    fn store_historical_info(&mut self, height: Height, info: HistoricalInfo);
+}

modules/src/context_mock.rs

@@ -0,0 +1,142 @@
+use crate::context::{ChainKeeper, ChainReader, HistoricalInfo, SelfHeader};
+use crate::mock_client::header::MockHeader;
+use serde_derive::{Deserialize, Serialize};
+use std::error::Error;
+use tendermint::block::Height;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct MockChainContext {
+    pub max_size: usize,
+    pub latest: Height,
+    pub history: Vec<HistoricalInfo>,
+}
+
+impl MockChainContext {
+    pub fn new(max_size: usize, n: Height) -> Self {
+        Self {
+            max_size,
+            latest: n,
+            history: (0..n.value())
+                .map(|i| HistoricalInfo {
+                    header: SelfHeader::Mock(MockHeader(Height(i).increment())),
+                })
+                .collect(),
+        }
+    }
+
+    pub fn max_size(&self) -> usize {
+        self.max_size
+    }
+
+    /// Used for testing
+    pub fn populate(&mut self, hs: Vec<u64>) {
+        for h in hs {
+            self.store_historical_info(
+                Height(h),
+                HistoricalInfo {
+                    header: SelfHeader::Mock(MockHeader(Height(h))),
+                },
+            );
+        }
+    }
+
+    /// Used for testing
+    pub fn validate(&self) -> Result<(), Box<dyn Error>> {
+        // check that the number of entries is not higher than max_size
+        if self.history.len() > self.max_size {
+            return Err("too many entries".to_string().into());
+        }
+
+        // check latest is properly updated with highest header height
+        let SelfHeader::Mock(lh) = self.history[self.history.len() - 1].header;
+        if lh.height() != self.latest {
+            return Err("latest height is not updated".to_string().into());
+        }
+
+        // check that all headers are in sequential order
+        for i in 1..self.history.len() {
+            let SelfHeader::Mock(ph) = self.history[i - 1].header;
+            let SelfHeader::Mock(h) = self.history[i].header;
+            if ph.height().increment() != h.height() {
+                return Err("headers in history not sequential".to_string().into());
+            }
+        }
+        Ok(())
+    }
+}
+
+impl ChainReader for MockChainContext {
+    fn self_historical_info(&self, height: Height) -> Option<&HistoricalInfo> {
+        let l = height.value() as usize;
+        let h = self.latest.value() as usize;
+
+        if l <= h - self.max_size {
+            // header with height not in the history
+            None
+        } else {
+            Some(&self.history[h - l])
+        }
+    }
+}
+
+impl ChainKeeper for MockChainContext {
+    fn store_historical_info(&mut self, height: Height, info: HistoricalInfo) {
+        if height != self.latest.increment() {
+            return;
+        }
+        let mut history = self.history.clone();
+        if history.len() >= self.max_size {
+            history.rotate_left(1);
+            history[self.max_size - 1] = info;
+        } else {
+            history.push(info);
+        }
+        //history.insert(height, info);
+        self.history = history;
+        self.latest = height;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::context_mock::MockChainContext;
+    use tendermint::block::Height;
+
+    #[test]
+    fn test_store_historical_info() {
+        pub struct Test {
+            name: String,
+            ctx: MockChainContext,
+            args: Vec<u64>,
+        }
+
+        impl Test {
+            pub fn apply(&mut self, hs: Vec<u64>) {
+                self.ctx.populate(hs);
+            }
+        }
+
+        let tests: Vec<Test> = vec![
+            Test {
+                name: "Add no prune".to_string(),
+                ctx: MockChainContext::new(3, Height(0)),
+                args: [1].to_vec(),
+            },
+            Test {
+                name: "Add with prune".to_string(),
+                ctx: MockChainContext::new(3, Height(2)),
+                args: [3, 4].to_vec(),
+            },
+            Test {
+                name: "Attempt to add non sequential headers".to_string(),
+                ctx: MockChainContext::new(3, Height(2)),
+                args: [3, 5, 7].to_vec(),
+            },
+        ];
+
+        for mut test in tests {
+            test.apply(test.args.clone());
+            assert!(test.ctx.validate().is_ok());
+        }
+    }
+}

modules/src/events.rs

@@ -11,6 +11,7 @@ use tendermint::block;
 
 use tendermint_rpc::event_listener::{ResultEvent, TMEventData};
 
+/// Events created by the IBC component of a chain, destined for a relayer.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum IBCEvent {
     NewBlock(NewBlock),

modules/src/handler.rs

@@ -20,8 +20,8 @@ pub enum EventType {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Event {
-    tpe: EventType,
-    attributes: Vec<Attribute>,
+    pub tpe: EventType,
+    pub attributes: Vec<Attribute>,
 }
 
 impl Event {

modules/src/ics02_client/client_def.rs

@@ -3,12 +3,16 @@ use serde_derive::{Deserialize, Serialize};
 use crate::ics02_client::client_type::ClientType;
 use crate::ics02_client::header::Header;
 use crate::ics02_client::state::{ClientState, ConsensusState};
-use crate::ics23_commitment::CommitmentRoot;
+use crate::ics23_commitment::commitment::{CommitmentPrefix, CommitmentProof, CommitmentRoot};
 use crate::Height;
 
-use crate::ics02_client::mocks;
+use crate::ics03_connection::connection::ConnectionEnd;
 use crate::ics07_tendermint as tendermint;
 use crate::ics07_tendermint::client_def::TendermintClient;
+use crate::ics24_host::identifier::{ClientId, ConnectionId};
+use crate::mock_client::client_def::MockClient;
+use crate::mock_client::header::MockHeader;
+use crate::mock_client::state::{MockClientState, MockConsensusState};
 
 pub trait ClientDef: Clone {
     type Header: Header;
@@ -19,7 +23,7 @@ pub trait ClientDef: Clone {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] // TODO: Add Eq
 #[allow(clippy::large_enum_variant)]
 pub enum AnyHeader {
-    Mock(mocks::MockHeader),
+    Mock(MockHeader),
     Tendermint(tendermint::header::Header),
 }
 
@@ -41,10 +45,35 @@ impl Header for AnyHeader {
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum AnyClientState {
-    Mock(mocks::MockClientState),
+    Mock(MockClientState),
     Tendermint(crate::ics07_tendermint::client_state::ClientState),
 }
 
+impl AnyClientState {
+    pub fn check_header_and_update_state(
+        &self,
+        header: AnyHeader,
+    ) -> Result<(AnyClientState, AnyConsensusState), Box<dyn std::error::Error>> {
+        match self {
+            AnyClientState::Tendermint(tm_state) => {
+                let (new_state, new_consensus) = tm_state.check_header_and_update_state(header)?;
+                Ok((
+                    AnyClientState::Tendermint(new_state),
+                    AnyConsensusState::Tendermint(new_consensus),
+                ))
+            }
+            AnyClientState::Mock(mock_state) => {
+                let (new_state, new_consensus) =
+                    mock_state.check_header_and_update_state(header)?;
+                Ok((
+                    AnyClientState::Mock(new_state),
+                    AnyConsensusState::Mock(new_consensus),
+                ))
+            }
+        }
+    }
+}
+
 impl ClientState for AnyClientState {
     fn chain_id(&self) -> String {
         todo!()
@@ -54,28 +83,89 @@ impl ClientState for AnyClientState {
         todo!()
     }
 
-    fn get_latest_height(&self) -> Height {
+    fn latest_height(&self) -> Height {
         match self {
-            AnyClientState::Tendermint(tm_state) => tm_state.get_latest_height(),
-            AnyClientState::Mock(mock_state) => mock_state.get_latest_height(),
+            AnyClientState::Tendermint(tm_state) => tm_state.latest_height(),
+            AnyClientState::Mock(mock_state) => mock_state.latest_height(),
         }
     }
 
     fn is_frozen(&self) -> bool {
-        todo!()
+        match self {
+            AnyClientState::Tendermint(tm_state) => tm_state.is_frozen(),
+            AnyClientState::Mock(mock_state) => mock_state.is_frozen(),
+        }
     }
 
+    // fn check_header_and_update_state(
+    //     &self,
+    //     header: &dyn Header,
+    // ) -> Result<(Box<dyn ClientState>, Box<dyn ConsensusState>), Box<dyn std::error::Error>> {
+    //     match self {
+    //         AnyClientState::Tendermint(tm_state) => tm_state.check_header_and_update_state(header),
+    //         AnyClientState::Mock(mock_state) => mock_state.check_header_and_update_state(header),
+    //     }
+    // }
+
     fn verify_client_consensus_state(
         &self,
-        _root: &CommitmentRoot,
+        height: Height,
+        prefix: &CommitmentPrefix,
+        proof: &CommitmentProof,
+        client_id: &ClientId,
+        consensus_height: Height,
+        expected_consensus_state: &dyn ConsensusState,
     ) -> Result<(), Box<dyn std::error::Error>> {
-        todo!()
+        match self {
+            AnyClientState::Tendermint(tm_state) => tm_state.verify_client_consensus_state(
+                height,
+                prefix,
+                proof,
+                client_id,
+                consensus_height,
+                expected_consensus_state,
+            ),
+            AnyClientState::Mock(mock_state) => mock_state.verify_client_consensus_state(
+                height,
+                prefix,
+                proof,
+                client_id,
+                consensus_height,
+                expected_consensus_state,
+            ),
+        }
+    }
+
+    fn verify_connection_state(
+        &self,
+        height: Height,
+        prefix: &CommitmentPrefix,
+        proof: &CommitmentProof,
+        connection_id: &ConnectionId,
+        expected_connection_end: &ConnectionEnd,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        match self {
+            AnyClientState::Tendermint(tm_state) => tm_state.verify_connection_state(
+                height,
+                prefix,
+                proof,
+                connection_id,
+                expected_connection_end,
+            ),
+            AnyClientState::Mock(mock_state) => mock_state.verify_connection_state(
+                height,
+                prefix,
+                proof,
+                connection_id,
+                expected_connection_end,
+            ),
+        }
     }
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum AnyConsensusState {
-    Mock(mocks::MockConsensusState),
+    Mock(MockConsensusState),
     Tendermint(crate::ics07_tendermint::consensus_state::ConsensusState),
 }
 
@@ -99,7 +189,7 @@ impl ConsensusState for AnyConsensusState {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum AnyClient {
-    Mock(mocks::MockClient),
+    Mock(MockClient),
     Tendermint(TendermintClient),
 }
 

modules/src/ics02_client/client_type.rs

@@ -6,13 +6,15 @@ use serde_derive::{Deserialize, Serialize};
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 pub enum ClientType {
     Tendermint = 1,
+    Mock,
 }
 
 impl ClientType {
     /// Yields the identifier of this client type as a string
     pub fn as_string(&self) -> &'static str {
         match self {
             Self::Tendermint => "tendermint",
+            Self::Mock => "mock",
         }
     }
 }