Handler for channel open init

modules/src/ics03_connection/connection.rs

@@ -8,6 +8,7 @@ use tendermint_proto::Protobuf;
 
 use crate::ics03_connection::error::{Error, Kind};
 use crate::ics03_connection::version::validate_versions;
+use crate::ics03_connection::version::default_version_string;
 use crate::ics23_commitment::commitment::CommitmentPrefix;
 use crate::ics24_host::error::ValidationError;
 use crate::ics24_host::identifier::{ClientId, ConnectionId};
@@ -51,6 +52,7 @@ impl From<ConnectionEnd> for RawConnectionEnd {
     }
 }
 
+
 impl ConnectionEnd {
     pub fn new(
         state: State,
@@ -66,6 +68,21 @@ impl ConnectionEnd {
         })
     }
 
+    pub fn test_channel_new(
+        client_id: ClientId,
+        counterparty: Counterparty,
+    ) -> Result<Self, Error> {
+
+        ConnectionEnd::new(
+            State::Init,
+            client_id,
+            counterparty,
+            vec![default_version_string()],
+        )
+    }
+
+
+
     /// Getter for the state of this connection end.
     pub fn state(&self) -> &State {
         &self.state

modules/src/ics04_channel/channel.rs

@@ -1,4 +1,5 @@
 use crate::ics04_channel::error::{self, Error, Kind};
+
 use crate::ics24_host::identifier::{ChannelId, ConnectionId, PortId};
 
 use ibc_proto::ibc::core::channel::v1::Channel as RawChannel;
@@ -279,8 +280,12 @@ 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;
+    // use crate::ics03_connection::msgs::conn_open_init::MsgConnectionOpenInit;
+    // use
+    //crate::ics03_connection::msgs::conn_open_init::test_util::get_dummy_msg_conn_open_init;
 
     /// Returns a dummy `RawCounterparty`, for testing only!
     pub fn get_dummy_raw_counterparty() -> RawCounterparty {
@@ -296,11 +301,22 @@ pub mod test_util {
             state: 1,
             ordering: 0,
             counterparty: Some(get_dummy_raw_counterparty()),
-            connection_hops: vec![],
-            version: "".to_string(), // The version is not validated.
+            connection_hops: vec!["srcconnection".to_string()],
+            version: "ics20".to_string(), // The version is not validated.
+        }
+    }
+
+    pub fn get_dummy_raw_channel_end_aux_test_missing_connection() -> RawChannel {
+        RawChannel {
+            state: 1,
+            ordering: 0,
+            counterparty: Some(get_dummy_raw_counterparty()),
+            connection_hops: vec!["noconnection".to_string()],
+            version: "ics20".to_string(), // The version is not validated.
         }
     }
 }
+//MsgConnectionOpenInit::try_from(get_dummy_msg_conn_open_init()).unwrap().connection_id()
 
 #[cfg(test)]
 mod tests {

modules/src/ics04_channel/context.rs

@@ -0,0 +1,104 @@
+//! ICS4 (channel) context. The two traits `ConnectionReader` and `ConnectionKeeper` define
+//! the interface that any host chain must implement to be able to process any `ChannelMsg`.
+//! TODO make "ADR 004: IBC protocol implementation" for more details.
+//!
+//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::ics04_channel::version::{get_compatible_versions, pick_version};
+//use crate::ics23_commitment::commitment::CommitmentPrefix;
+use crate::ics24_host::identifier::{ChannelId, ConnectionId, PortId};
+//use crate::Height;
+
+/// A context supplying all the necessary read-only dependencies for processing any `ConnectionMsg`.
+pub trait ChannelReader {
+    /// Returns the ChannelEnd for the given identifier `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>;
+
+    /// Function required by ICS 04. Returns the list of all possible versions that the channels handshake protocol supports.
+    fn get_compatible_versions(&self) -> Vec<String> {
+        get_compatible_versions()
+    }
+
+    /// Function required by ICS 04. Returns one version out of the supplied list of versions, which the channel handshake protocol prefers.
+    fn pick_version(
+        &self,
+        supported_versions: Vec<String>,
+        counterparty_candidate_versions: Vec<String>,
+    ) -> Result<String, Error> {
+        pick_version(supported_versions, counterparty_candidate_versions)
+    }
+}
+
+/// A context supplying all the necessary write-only dependencies (i.e., storage writing facility)
+/// for processing any `ConnectionMsg`.
+pub trait ChannelKeeper {
+    fn store_channel_result(&mut self, result: ChannelResult) -> Result<(), Error> {
+        match result.channel_end.state() {
+            State::Init => {
+                self.store_channel(
+                    &(result.port_id.clone(), result.channel_id.clone()),
+                    &result.channel_end,
+                )?;
+
+                self.store_nextsequence_send(
+                    &(result.port_id.clone(), result.channel_id.clone()),
+                    1,
+                )?;
+
+                self.store_nextsequence_recv(
+                    &(result.port_id.clone(), result.channel_id.clone()),
+                    1,
+                )?;
+
+                self.store_nextsequence_ack(
+                    &(result.port_id.clone(), result.channel_id.clone()),
+                    1,
+                )?;
+            }
+            State::TryOpen => {
+                self.store_channel(&(result.port_id, result.channel_id), &result.channel_end)?;
+                // TODOIf 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), &result.channel_end)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Stores the given connection_end at a path associated with the connection_id.
+    fn store_channel(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        channel_end: &ChannelEnd,
+    ) -> Result<(), Error>;
+
+    fn store_nextsequence_send(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        seq: u64,
+    ) -> Result<(), Error>;
+
+    fn store_nextsequence_recv(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        seq: u64,
+    ) -> Result<(), Error>;
+
+    fn store_nextsequence_ack(
+        &mut self,
+        port_channel_id: &(PortId, ChannelId),
+        seq: u64,
+    ) -> Result<(), Error>;
+}

modules/src/ics04_channel/error.rs

@@ -3,8 +3,13 @@ use thiserror::Error;
 
 pub type Error = anomaly::Error<Kind>;
 
+use crate::ics24_host::identifier::{ConnectionId,ChannelId};
+
 #[derive(Clone, Debug, Error)]
 pub enum Kind {
+    #[error("not implemented yet")]
+    Niy,
+
     #[error("channel state unknown")]
     UnknownState,
 
@@ -44,8 +49,17 @@ pub enum Kind {
     #[error("missing counterparty")]
     MissingCounterparty,
 
+    #[error("no commong version")]
+    NoCommonVersion,
+
     #[error("missing channel end")]
     MissingChannel,
+
+    #[error("channel exists (was initialized) already: {0}")]
+    ChannelExistsAlready(ChannelId),
+
+    #[error("given connection {0} for channel innexitant ")]
+    MissingConnection(ConnectionId),
 }
 
 impl Kind {

modules/src/ics04_channel/handler.rs

@@ -0,0 +1,63 @@
+//! 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::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: ChannelId,
+    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(), chan.channel_id.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!(),
+    })
+}