Merge branch 'master' into Cezara

modules/src/ics03_connection/version.rs

@@ -58,12 +58,12 @@ impl Default for Version {
     }
 }
 
-pub fn verify_supported_feature(version: Version, feature: String) -> bool{
+pub fn verify_supported_feature(version: Version, feature: String) -> bool {
     for f in version.features.iter() {
-       if f.eq(&feature) {
-           return true;
+        if f.eq(&feature) {
+            return true;
         }
-     }
+    }
     false
 }
 

modules/src/ics04_channel/channel.rs

@@ -1,16 +1,3 @@
-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;
-use ibc_proto::ibc::core::channel::v1::Counterparty as RawCounterparty;
-
-use tendermint_proto::Protobuf;
-
-use crate::events::IBCEventType;
-use crate::ics02_client::height::Height;
-use crate::ics04_channel::packet::Sequence;
-use anomaly::fail;
 use std::convert::{TryFrom, TryInto};
 use std::str::FromStr;
 

modules/src/ics04_channel/context.rs

@@ -37,9 +37,8 @@ pub trait ChannelReader {
 /// 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 => {
@@ -81,7 +80,7 @@ pub trait ChannelKeeper {
         }
         Ok(())
     }
-    
+
     fn store_connection_channels(
         &mut self,
         conn_id: &ConnectionId,

modules/src/ics04_channel/error.rs

@@ -64,7 +64,7 @@ pub enum Kind {
     #[error("single version must be negociated on connection before opening channel")]
     InvalidVersionLengthConnection,
     #[error("the channel ordering is not supported by connection ")]
-    ChannelFeatureNotSuportedByConnection
+    ChannelFeatureNotSuportedByConnection,
 }
 
 impl Kind {

modules/src/ics04_channel/handler/chan_open_init.rs

@@ -2,13 +2,13 @@
 
 use crate::handler::{HandlerOutput, HandlerResult};
 //use crate::ics03_connection::connection::C;
+use crate::ics03_connection::version::verify_supported_feature;
 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,
@@ -35,26 +35,26 @@ pub(crate) fn process(
     }
 
     // An IBC connection running on the local (host) chain should exist.
-
-    let connection_end = ctx
-        .connection_state(&msg.channel().connection_hops()[0]);
 
-    match connection_end{
-        None=>     {
+    let connection_end = ctx.connection_state(&msg.channel().connection_hops()[0]);
+
+    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())
-            {
+        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() {
@@ -131,7 +131,6 @@ mod tests {
             get_compatible_versions(),
             msg_conn_init.delay_period,
         );
-
 
         let ccid = <ConnectionId as FromStr>::from_str("defaultConnection-0");
         let cid = match ccid {
@@ -157,13 +156,14 @@ mod tests {
             },
             Test {
                 name: "Good parameters".to_string(),
-                ctx: context.with_connection(cid,
-                    init_conn_end).with_port_capability(
-                    MsgChannelOpenInit::try_from(get_dummy_raw_msg_chan_open_init())
-                        .unwrap()
-                        .port_id()
-                        .clone(),
-                ),
+                ctx: context
+                    .with_connection(cid, init_conn_end)
+                    .with_port_capability(
+                        MsgChannelOpenInit::try_from(get_dummy_raw_msg_chan_open_init())
+                            .unwrap()
+                            .port_id()
+                            .clone(),
+                    ),
                 msg: ChannelMsg::ChannelOpenInit(msg_chan_init),
                 want_pass: true,
             },
@@ -188,7 +188,7 @@ mod tests {
 
                     // The object in the output is a ChannelEnd, should have init state.
                     let res: ChannelResult = proto_output.result;
-                    assert_eq!(res.channel_end.state().clone(), State::Init); 
+                    assert_eq!(res.channel_end.state().clone(), State::Init);
                     let msg_init = test.msg.clone();
 
                     if let ChannelMsg::ChannelOpenInit(msg_init) = msg_init {

modules/src/ics04_channel/msgs/chan_open_init.rs

@@ -94,7 +94,6 @@ pub mod test_util {
     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 {
         RawMsgChannelOpenInit {

modules/src/ics04_channel/version.rs

@@ -94,7 +94,6 @@ 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

modules/src/mock/context.rs

@@ -230,10 +230,7 @@ impl MockContext {
             ..self
         }
     }
-    pub fn with_port_capability(
-        self,
-        port_id: PortId,
-    ) -> Self {
+    pub fn with_port_capability(self, port_id: PortId) -> Self {
         let mut port_capabilities = self.port_capabilities.clone();
         port_capabilities.insert(port_id, Capability::new());
         Self {
@@ -378,13 +375,11 @@ impl ChannelReader for MockContext {
 
                 let conn = self.connection_state(&cid);
                 match conn {
-                    Some(v) => {
-                        ConnectionReader::client_consensus_state(
-                            self,
-                            &v.client_id().clone(),
-                            height,
-                        )
-                    }
+                    Some(v) => ConnectionReader::client_consensus_state(
+                        self,
+                        &v.client_id().clone(),
+                        height,
+                    ),
                     None => panic!(),
                 }
             }