Handler for channel open init

.gitignore

@@ -15,4 +15,7 @@ Cargo.lock
 **/*.db/
 
 # Ignore Jetbrains
-.idea
+.idea
+
+# Ignore VisualStudio
+.vscode

modules/src/events.rs

@@ -99,9 +99,7 @@ impl IBCEvent {
             IBCEvent::AcknowledgePacketChannel(ev) => ev.height,
             IBCEvent::TimeoutPacketChannel(ev) => ev.height,
 
-            _ => {
-                unimplemented!()
-            }
+            _ => unimplemented!(),
         }
     }
     pub fn set_height(&mut self, height: ICSHeight) {
@@ -121,9 +119,7 @@ impl IBCEvent {
             IBCEvent::TimeoutPacketChannel(ev) => {
                 ev.height = Height::try_from(height.revision_height).unwrap()
             }
-            _ => {
-                unimplemented!()
-            }
+            _ => unimplemented!(),
         }
     }
 }

modules/src/ics03_connection/version.rs

@@ -16,6 +16,13 @@ pub struct Version {
     features: Vec<String>,
 }
 
+impl Version {
+    /// Checks whether or not the given feature is supported in this versin
+    pub fn is_supported_feature(&self, feature: String) -> bool {
+        self.features.contains(&feature)
+    }
+}
+
 impl Protobuf<RawVersion> for Version {}
 
 impl TryFrom<RawVersion> for Version {

modules/src/ics04_channel/channel.rs

@@ -44,7 +44,7 @@ impl TryFrom<RawChannel> for ChannelEnd {
 
     fn try_from(value: RawChannel) -> Result<Self, Self::Error> {
         // Parse the ordering type. Propagate the error, if any, to our caller.
-        let chan_state = State::from_i32(value.state)?;
+        let chan_state: State = State::from_i32(value.state)?;
 
         if chan_state == State::Uninitialized {
             return Ok(ChannelEnd::default());
@@ -82,7 +82,7 @@ impl From<ChannelEnd> for RawChannel {
         RawChannel {
             state: value.state.clone() as i32,
             ordering: value.ordering as i32,
-            counterparty: Some(value.counterparty().into()),
+            counterparty: Some(value.counterparty().clone().into()),
             connection_hops: value
                 .connection_hops
                 .iter()
@@ -124,12 +124,12 @@ impl ChannelEnd {
         &self.ordering
     }
 
-    pub fn counterparty(&self) -> Counterparty {
-        self.remote.clone()
+    pub fn counterparty(&self) -> &Counterparty {
+        &self.remote
     }
 
-    pub fn connection_hops(&self) -> Vec<ConnectionId> {
-        self.connection_hops.clone()
+    pub fn connection_hops(&self) -> &Vec<ConnectionId> {
+        &self.connection_hops
     }
 
     pub fn version(&self) -> String {
@@ -240,8 +240,8 @@ impl Order {
     pub fn as_string(&self) -> &'static str {
         match self {
             Self::None => "UNINITIALIZED",
-            Self::Unordered => "UNORDERED",
-            Self::Ordered => "ORDERED",
+            Self::Unordered => "ORDER_UNORDERED",
+            Self::Ordered => "ORDER_ORDERED",
         }
     }
 
@@ -322,6 +322,7 @@ pub fn validate_version(version: String) -> Result<String, Error> {
 
 #[cfg(test)]
 pub mod test_util {
+
     use ibc_proto::ibc::core::channel::v1::Channel as RawChannel;
     use ibc_proto::ibc::core::channel::v1::Counterparty as RawCounterparty;
 
@@ -337,10 +338,20 @@ pub mod test_util {
     pub fn get_dummy_raw_channel_end() -> RawChannel {
         RawChannel {
             state: 1,
-            ordering: 0,
+            ordering: 1,
             counterparty: Some(get_dummy_raw_counterparty()),
-            connection_hops: vec![],
-            version: "".to_string(), // The version is not validated.
+            connection_hops: vec!["defaultConnection-0".to_string()],
+            version: "ics20".to_string(), // The version is not validated.
+        }
+    }
+
+    pub fn get_dummy_raw_channel_end_with_missing_connection() -> RawChannel {
+        RawChannel {
+            state: 1,
+            ordering: 1,
+            counterparty: Some(get_dummy_raw_counterparty()),
+            connection_hops: vec!["noconnection".to_string()],
+            version: "ics20".to_string(), // The version is not validated.
         }
     }
 }

modules/src/ics04_channel/context.rs

@@ -0,0 +1,114 @@
+//! ICS4 (channel) context. The two traits `ChannelReader ` and `ChannelKeeper` define
+//! the interface that any host chain must implement to be able to process any `ChannelMsg`.
+//!
+use crate::ics02_client::client_def::{AnyClientState, AnyConsensusState};
+use crate::ics03_connection::connection::ConnectionEnd;
+use crate::ics04_channel::channel::{ChannelEnd, State};
+use crate::ics04_channel::error::Error;
+use crate::ics04_channel::handler::ChannelResult;
+use crate::ics05_port::capabilities::Capability;
+use crate::ics24_host::identifier::{ChannelId, ConnectionId, PortId};
+use crate::Height;
+
+/// A context supplying all the necessary read-only dependencies for processing any `ChannelMsg`.
+pub trait ChannelReader {
+    /// Returns the ChannelEnd for the given `port_id` and `chan_id`.
+    fn channel_end(&self, port_channel_id: &(PortId, ChannelId)) -> Option<ChannelEnd>;
+
+    /// Returns the ConnectionState for the given identifier `connection_id`.
+    fn connection_state(&self, connection_id: &ConnectionId) -> Option<ConnectionEnd>;
+
+    fn connection_channels(&self, cid: &ConnectionId) -> Option<Vec<(PortId, ChannelId)>>;
+
+    fn channel_client_state(&self, port_channel_id: &(PortId, ChannelId))
+        -> Option<AnyClientState>;
+
+    fn channel_consensus_state(
+        &self,
+        port_channel_id: &(PortId, ChannelId),
+        height: Height,
+    ) -> Option<AnyConsensusState>;
+
+    fn port_capability(&self, port_id: &PortId) -> Option<Capability>;
+
+    fn capability_authentification(&self, port_id: &PortId, cap: &Capability) -> bool;
+}
+
+/// A context supplying all the necessary write-only dependencies (i.e., storage writing facility)
+/// for processing any `ChannelMsg`.
+pub trait ChannelKeeper {
+    fn next_channel_id(&mut self) -> ChannelId;
+
+    fn store_channel_result(&mut self, result: ChannelResult) -> Result<(), Error> {
+        match result.channel_end.state() {
+            State::Init => {
+                let channel_id = self.next_channel_id();
+                self.store_channel(
+                    &(result.port_id.clone(), channel_id.clone()),
+                    &result.channel_end,
+                )?;
+
+                self.store_next_sequence_send(&(result.port_id.clone(), channel_id.clone()), 1)?;
+
+                self.store_next_sequence_recv(&(result.port_id.clone(), channel_id.clone()), 1)?;
+
+                self.store_next_sequence_ack(&(result.port_id.clone(), channel_id.clone()), 1)?;
+
+                self.store_connection_channels(
+                    &result.channel_end.connection_hops()[0].clone(),
+                    &(result.port_id.clone(), channel_id),
+                )?;
+            }
+            State::TryOpen => {
+                self.store_channel(
+                    &(result.port_id, result.channel_id.clone().unwrap()),
+                    &result.channel_end,
+                )?;
+                // TODO: If this is the first time the handler processed this channel, associate the
+                // channel end to its client identifier.
+                // self.store_channel_to_connection(
+                //     &(result.port_id,result.channel_id),
+                //     &result.... ,
+                // )?;
+            }
+            _ => {
+                self.store_channel(
+                    &(result.port_id, result.channel_id.clone().unwrap()),
+                    &result.channel_end,
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    fn store_connection_channels(
+        &mut self,
+        conn_id: &ConnectionId,
+        port_channel_id: &(PortId, ChannelId),
+    ) -> Result<(), Error>;
+
+    /// Stores the given channel_end at a path associated with the port_id and channel_id.
+    fn store_channel(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        channel_end: &ChannelEnd,
+    ) -> Result<(), Error>;
+
+    fn store_next_sequence_send(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        seq: u64,
+    ) -> Result<(), Error>;
+
+    fn store_next_sequence_recv(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        seq: u64,
+    ) -> Result<(), Error>;
+
+    fn store_next_sequence_ack(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        seq: u64,
+    ) -> Result<(), Error>;
+}

modules/src/ics04_channel/error.rs

@@ -3,6 +3,8 @@ use thiserror::Error;
 
 pub type Error = anomaly::Error<Kind>;
 
+use crate::ics24_host::identifier::ConnectionId;
+
 #[derive(Clone, Debug, Error)]
 pub enum Kind {
     #[error("channel state unknown")]
@@ -44,8 +46,26 @@ pub enum Kind {
     #[error("missing counterparty")]
     MissingCounterparty,
 
+    #[error("no commong version")]
+    NoCommonVersion,
+
     #[error("missing channel end")]
     MissingChannel,
+
+    #[error("given connection hop {0} does not exist")]
+    MissingConnection(ConnectionId),
+
+    #[error("the port has no capability associated")]
+    NoPortCapability,
+
+    #[error("the module associated with the port does not have the capability it needs")]
+    InvalidPortCapability,
+
+    #[error("single version must be negociated on connection before opening channel")]
+    InvalidVersionLengthConnection,
+
+    #[error("the channel ordering is not supported by connection ")]
+    ChannelFeatureNotSuportedByConnection,
 }
 
 impl Kind {

modules/src/ics04_channel/handler.rs

@@ -0,0 +1,65 @@
+//! This module implements the processing logic for ICS4 (channel) messages.
+
+use crate::handler::{Event, EventType, HandlerOutput};
+use crate::ics04_channel::channel::ChannelEnd;
+use crate::ics04_channel::context::ChannelReader;
+use crate::ics04_channel::error::Error;
+use crate::ics04_channel::msgs::ChannelMsg;
+use crate::ics05_port::capabilities::Capability;
+use crate::ics24_host::identifier::{ChannelId, PortId};
+
+pub mod chan_open_init;
+
+#[derive(Clone, Debug)]
+pub enum ChannelEvent {
+    ChanOpenInit(ChannelResult),
+    // ConnOpenTry(ConnectionResult),
+    // ConnOpenAck(ConnectionResult),
+    // ConnOpenConfirm(ConnectionResult),
+}
+
+#[derive(Clone, Debug)]
+pub struct ChannelResult {
+    pub port_id: PortId,
+    pub channel_id: Option<ChannelId>,
+    pub channel_cap: Capability,
+    pub channel_end: ChannelEnd,
+}
+
+impl From<ChannelEvent> for Event {
+    fn from(ev: ChannelEvent) -> Event {
+        match ev {
+            ChannelEvent::ChanOpenInit(_chan) => Event::new(
+                EventType::Custom("channel_open_init".to_string()),
+                vec![("channel_id".to_string(), "None".to_string())],
+            ),
+            // ChannelEvent::ChanOpenTry(conn) => Event::new(
+            //     EventType::Custom("channel_open_try".to_string()),
+            //     vec![("channel_id".to_string(), chan.channel_id.to_string())],
+            // ),
+            // ChannelEvent::ChanOpenAck(conn) => Event::new(
+            //     EventType::Custom("channel_open_ack".to_string()),
+            //     vec![("channel_id".to_string(), chan.channel_id.to_string())],
+            // ),
+            // ChannelEvent::ChanOpenConfirm(conn) => Event::new(
+            //     EventType::Custom("channel_open_confirm".to_string()),
+            //     vec![("channel_id".to_string(), conn.channel _id.to_string())],
+            // ),
+        }
+    }
+}
+
+/// General entry point for processing any type of message related to the ICS4 channel open
+/// handshake protocol.
+pub fn dispatch<Ctx>(ctx: &Ctx, msg: ChannelMsg) -> Result<HandlerOutput<ChannelResult>, Error>
+where
+    Ctx: ChannelReader,
+{
+    Ok(match msg {
+        ChannelMsg::ChannelOpenInit(msg) => chan_open_init::process(ctx, msg)?,
+        // ChannelMsg::ChannelOpenTry(msg) => chan_open_try::process(ctx, *msg)?,
+        // ChannelMsg::ChannelOpenAck(msg) => chan_open_ack::process(ctx, *msg)?,
+        // ChannelMsg::ChannelOpenConfirm(msg) => chan_open_confirm::process(ctx, msg)?,
+        _ => panic!(),
+    })
+}