connetion features

modules/src/ics03_connection/version.rs

@@ -56,6 +56,15 @@ impl Default for Version {
     }
 }
 
+pub fn verify_supported_feature(version: Version, feature: String) -> bool{
+    for f in version.features.iter() {
+       if f.eq(&feature) {
+           return true;
+        }
+     }
+    false
+}
+
 /// Returns the lists of supported versions
 pub fn get_compatible_versions() -> Vec<Version> {
     vec![Version::default()]

modules/src/ics04_channel/channel.rs

@@ -41,7 +41,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());
@@ -237,8 +237,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",
         }
     }
 
@@ -335,7 +335,7 @@ 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!["defaultConnection-0".to_string()],
             version: "ics20".to_string(), // The version is not validated.
@@ -345,7 +345,7 @@ pub mod test_util {
     pub fn get_dummy_raw_channel_end_with_missing_connection() -> RawChannel {
         RawChannel {
             state: 1,
-            ordering: 0,
+            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/error.rs

@@ -60,6 +60,11 @@ pub enum Kind {
 
     #[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/chan_open_init.rs

@@ -1,12 +1,14 @@
 //! Protocol logic specific to ICS4 messages of type `MsgChannelOpenInit`.
 
 use crate::handler::{HandlerOutput, HandlerResult};
+//use crate::ics03_connection::connection::C;
 use crate::ics04_channel::channel::{ChannelEnd, State};
 use crate::ics04_channel::context::ChannelReader;
 use crate::ics04_channel::error::{Error, Kind};
 use crate::ics04_channel::handler::ChannelEvent::ChanOpenInit;
 use crate::ics04_channel::handler::ChannelResult;
 use crate::ics04_channel::msgs::chan_open_init::MsgChannelOpenInit;
+use crate::ics03_connection::version::verify_supported_feature;
 
 pub(crate) fn process(
     ctx: &dyn ChannelReader,
@@ -37,13 +39,22 @@ pub(crate) fn process(
     let connection_end = ctx
         .connection_state(&msg.channel().connection_hops()[0]);
 
-    if connection_end.is_none()
-    {
-       return Err(Kind::MissingConnection(msg.channel().connection_hops()[0].clone()).into());
-    }
-    else{
-        //TODO: Understand conenction version. 
+    match connection_end{
+        None=>     {
+            return Err(Kind::MissingConnection(msg.channel().connection_hops()[0].clone()).into());
+         }
+         Some(conn) =>
+        {
+        let get_versions = conn.versions();
+        if get_versions.len() != 1 {
+            return Err(Kind::InvalidVersionLengthConnection.into());
+        }
+        if !verify_supported_feature(get_versions[0].clone(),msg.channel().ordering().as_string().to_string())
+            {
+                return Err(Kind::ChannelFeatureNotSuportedByConnection.into());
+            }
     }
+}
 
     // TODO: Check that `version` is non empty but not necessary coherent
     if msg.channel().version().is_empty() {
@@ -120,6 +131,7 @@ mod tests {
             get_compatible_versions(),
             msg_conn_init.delay_period,
         );
+
 
         let ccid = <ConnectionId as FromStr>::from_str("defaultConnection-0");
         let cid = match ccid {

modules/src/ics04_channel/msgs/chan_open_init.rs

@@ -96,6 +96,8 @@ pub mod test_util {
     use crate::ics04_channel::channel::test_util::get_dummy_raw_channel_end;
     use crate::ics04_channel::channel::test_util::get_dummy_raw_channel_end_with_missing_connection;
     use crate::test_utils::get_dummy_bech32_account;
+    //use crate::ics04_channel::channel::State;
+
 
     /// Returns a dummy `RawMsgChannelOpenInit`, for testing only!
     pub fn get_dummy_raw_msg_chan_open_init() -> RawMsgChannelOpenInit {
@@ -176,6 +178,7 @@ mod tests {
     fn to_and_from() {
         let raw = get_dummy_raw_msg_chan_open_init();
         let msg = MsgChannelOpenInit::try_from(raw.clone()).unwrap();
+        assert!(msg.channel().state_matches(&crate::ics04_channel::channel::State::Init));
         let raw_back = RawMsgChannelOpenInit::from(msg.clone());
         let msg_back = MsgChannelOpenInit::try_from(raw_back.clone()).unwrap();
         assert_eq!(raw, raw_back);

modules/src/ics04_channel/version.rs

@@ -94,6 +94,7 @@ pub fn pick_version(
     Ok(intersection[0].to_string())
 }
 
+
 pub fn validate_versions(versions: Vec<String>) -> Result<Vec<String>, Error> {
     if versions.is_empty() {
         return Err(Kind::InvalidVersion