chan open init

modules/src/ics04_channel/context.rs

@@ -56,33 +56,28 @@ pub trait ChannelKeeper {
     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(), result.channel_id.clone()),
+                    &(result.port_id.clone(), channel_id.clone()),
                     &result.channel_end,
                 )?;
 
-                self.store_nextsequence_send(
-                    &(result.port_id.clone(), result.channel_id.clone()),
-                    1,
-                )?;
+                self.store_nextsequence_send(&(result.port_id.clone(), channel_id.clone()), 1)?;
 
-                self.store_nextsequence_recv(
-                    &(result.port_id.clone(), result.channel_id.clone()),
-                    1,
-                )?;
+                self.store_nextsequence_recv(&(result.port_id.clone(), channel_id.clone()), 1)?;
 
-                self.store_nextsequence_ack(
-                    &(result.port_id.clone(), result.channel_id.clone()),
-                    1,
-                )?;
+                self.store_nextsequence_ack(&(result.port_id.clone(), channel_id.clone()), 1)?;
 
                 self.store_connection_channels(
                     &result.channel_end.connection_hops()[0].clone(),
-                    &(result.port_id.clone(), result.channel_id.clone()),
+                    &(result.port_id.clone(), channel_id.clone()),
                 )?;
             }
             State::TryOpen => {
-                self.store_channel(&(result.port_id, result.channel_id), &result.channel_end)?;
+                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(
@@ -91,12 +86,17 @@ pub trait ChannelKeeper {
                 // )?;
             }
             _ => {
-                self.store_channel(&(result.port_id, result.channel_id), &result.channel_end)?;
+                self.store_channel(
+                    &(result.port_id, result.channel_id.clone().unwrap()),
+                    &result.channel_end,
+                )?;
             }
         }
         Ok(())
     }
 
+    fn next_channel_id(&mut self) -> ChannelId;
+
     fn store_connection_channels(
         &mut self,
         conn_id: &ConnectionId,

modules/src/ics04_channel/handler.rs

@@ -20,16 +20,16 @@ pub enum ChannelEvent {
 #[derive(Clone, Debug)]
 pub struct ChannelResult {
     pub port_id: PortId,
-    pub channel_id: ChannelId,
+    pub channel_id: Option<ChannelId>,
     pub channel_end: ChannelEnd,
 }
 
 impl From<ChannelEvent> for Event {
     fn from(ev: ChannelEvent) -> Event {
         match ev {
-            ChannelEvent::ChanOpenInit(chan) => Event::new(
+            ChannelEvent::ChanOpenInit(_chan) => Event::new(
                 EventType::Custom("channel_open_init".to_string()),
-                vec![("channel_id".to_string(), chan.channel_id.to_string())],
+                vec![("channel_id".to_string(), "None".to_string())],
             ),
             // ChannelEvent::ChanOpenTry(conn) => Event::new(
             //     EventType::Custom("channel_open_try".to_string()),

modules/src/ics04_channel/handler/chan_open_init.rs

@@ -5,7 +5,6 @@ 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::ics05_port::context::PortReader;
 use crate::ics04_channel::handler::ChannelResult;
 use crate::ics04_channel::msgs::chan_open_init::MsgChannelOpenInit;
 
@@ -15,12 +14,6 @@ pub(crate) fn process(
 ) -> HandlerResult<ChannelResult, Error> {
     let mut output = HandlerOutput::builder();
 
-    let pc_id = (msg.port_id().clone(), msg.channel_id().clone());
-
-    if ctx.channel_end(&pc_id).is_some() {
-        return Err(Kind::ChannelExistsAlready(msg.channel_id().clone()).into());
-    }
-
     let cap = ctx.port_capability(&msg.port_id().clone());
     match cap {
         Some(key) => {
@@ -60,7 +53,7 @@ pub(crate) fn process(
 
     let result = ChannelResult {
         port_id: msg.port_id().clone(),
-        channel_id: msg.channel_id().clone(),
+        channel_id: None,
         channel_end: new_channel_end,
     };
 
@@ -72,23 +65,25 @@ pub(crate) fn process(
 #[cfg(test)]
 mod tests {
     use std::convert::TryFrom;
+    use std::str::FromStr;
 
     use crate::handler::EventType;
 
     use crate::ics03_connection::msgs::conn_open_init::test_util::get_dummy_msg_conn_open_init;
 
     use crate::ics03_connection::connection::State as ConnectionState;
     use crate::ics03_connection::msgs::conn_open_init::MsgConnectionOpenInit;
-    use crate::ics04_channel::channel::{ChannelEnd, State};
+    use crate::ics04_channel::channel::State;
 
     use crate::ics03_connection::connection::ConnectionEnd;
-
+    use crate::ics03_connection::version::get_compatible_versions;
     use crate::ics04_channel::handler::{dispatch, ChannelResult};
     use crate::ics04_channel::msgs::chan_open_init::test_util::get_dummy_raw_msg_chan_open_init;
 
-    use crate::ics03_connection::version::default_version_string;
     use crate::ics04_channel::msgs::chan_open_init::MsgChannelOpenInit;
     use crate::ics04_channel::msgs::ChannelMsg;
+
+    use crate::ics24_host::identifier::ConnectionId;
     use crate::mock::context::MockContext;
 
     #[test]
@@ -105,37 +100,25 @@ mod tests {
 
         let context = MockContext::default();
 
-        let init_chan_end = &ChannelEnd::new(
-            State::Init,
-            *msg_chan_init.channel().ordering(),
-            msg_chan_init.channel().counterparty().clone(),
-            msg_chan_init.channel().connection_hops().clone(),
-            "ics20".to_string(),
-        );
-
         let msg_conn_init =
             MsgConnectionOpenInit::try_from(get_dummy_msg_conn_open_init()).unwrap();
 
         let init_conn_end = ConnectionEnd::new(
             ConnectionState::Init,
             msg_conn_init.client_id().clone(),
             msg_conn_init.counterparty().clone(),
-            vec![default_version_string()],
-        )
-        .unwrap();
+            get_compatible_versions(),
+            msg_conn_init.delay_period,
+        );
+
+        // let cid = ConnectionId::default();
+        let ccid = <ConnectionId as FromStr>::from_str("srcconnection");
+        let cid = match ccid {
+            Ok(v) => v,
+            Err(_e) => ConnectionId::default(),
+        };
 
         let tests: Vec<Test> = vec![
-            Test {
-                name: "Processing fails because the channel exists in the store already"
-                    .to_string(),
-                ctx: context.clone().with_channel(
-                    msg_chan_init.port_id().clone(),
-                    msg_chan_init.channel_id().clone(),
-                    init_chan_end.clone(),
-                ),
-                msg: ChannelMsg::ChannelOpenInit(msg_chan_init.clone()),
-                want_pass: false,
-            },
             Test {
                 name: "Processing fails because no connection exists in the context".to_string(),
                 ctx: context.clone(),
@@ -145,13 +128,9 @@ mod tests {
             Test {
                 name: "Processing fails because port does not have a capability associated"
                     .to_string(),
-                ctx: context.clone().with_connection(
-                    MsgConnectionOpenInit::try_from(get_dummy_msg_conn_open_init())
-                        .unwrap()
-                        .connection_id()
-                        .clone(),
-                    init_conn_end.clone(),
-                ),
+                ctx: context
+                    .clone()
+                    .with_connection(cid.clone(), init_conn_end.clone()),
                 msg: ChannelMsg::ChannelOpenInit(msg_chan_init.clone()),
                 want_pass: false,
             },
@@ -163,10 +142,7 @@ mod tests {
                             .unwrap()
                             .port_id()
                             .clone(),
-                        MsgConnectionOpenInit::try_from(get_dummy_msg_conn_open_init())
-                            .unwrap()
-                            .connection_id()
-                            .clone(),
+                        cid.clone(),
                         init_conn_end.clone(),
                     )
                     .clone(),
@@ -194,7 +170,7 @@ mod tests {
 
                     // The object in the output is a ConnectionEnd, should have init state.
                     let res: ChannelResult = proto_output.result;
-                    assert_eq!(res.channel_id, msg_chan_init.channel_id().clone());
+                    //assert_eq!(res.channel_id, msg_chan_init.channel_id().clone());
                     assert_eq!(res.channel_end.state().clone(), State::Init);
 
                     for e in proto_output.events.iter() {

modules/src/ics04_channel/msgs/chan_open_init.rs

@@ -23,17 +23,12 @@ pub struct MsgChannelOpenInit {
 }
 
 impl MsgChannelOpenInit {
-    /// Getter: borrow the `connection_id` from this message.
-    pub fn channel_id(&self) -> &ChannelId {
-        &self.channel_id
-    }
-
-    /// Getter: borrow the `client_id` from this message.
+    /// Getter: borrow the `port_id` from this message.
     pub fn port_id(&self) -> &PortId {
         &self.port_id
     }
 
-    /// Getter: borrow the `counterparty` from this message.
+    /// Getter: borrow the `channelEnd` from this message.
     pub fn channel(&self) -> &ChannelEnd {
         &self.channel
     }
@@ -114,7 +109,6 @@ pub mod test_util {
     pub fn get_dummy_raw_msg_chan_open_init_aux_test_missing_connection() -> RawMsgChannelOpenInit {
         RawMsgChannelOpenInit {
             port_id: "port".to_string(),
-            channel_id: "testchannel".to_string(),
             channel: Some(get_dummy_raw_channel_end_aux_test_missing_connection()),
             signer: get_dummy_bech32_account(),
         }

modules/src/ics04_channel/version.rs

@@ -7,7 +7,7 @@ use crate::ics04_channel::error::{Error, Kind};
 use std::str::FromStr;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-struct Version {
+pub struct Version {
     /// unique version identifier
     identifier: String,
     /// list of features compatible with the specified identifier

modules/src/mock/context.rs

@@ -83,9 +83,11 @@ pub struct MockContext {
     next_sequence_ack: HashMap<(PortId, ChannelId), u64>,
 
     port_capabilities: HashMap<PortId, Capability>,
-  
+
     /// Counter for connection identifiers (see `next_connection_id`).
     connection_ids_counter: u32,
+
+    channel_ids_counter: u32,
 }
 
 /// Returns a MockContext with bare minimum initialization: no clients, no connections and no channels are
@@ -155,7 +157,7 @@ impl MockContext {
             next_sequence_ack: Default::default(),
             port_capabilities: Default::default(),
             connection_ids_counter: 0,
-
+            channel_ids_counter: 0,
         }
     }
 
@@ -245,27 +247,6 @@ impl MockContext {
         }
     }
 
-    // pub fn with_capability(self, port_id: PortId) -> Self {
-    //     let mut port_capabilities = self.port_capabilities.clone();
-    //     port_capabilities.insert(port_id, Capability::new());
-    //     Self {
-    //         port_capabilities,
-    //         ..self
-    //     }
-    // }
-
-    /// Associates a channel to this context.
-    pub fn with_channel(
-        self,
-        port_id: PortId,
-        channel_id: ChannelId,
-        channel_end: ChannelEnd,
-    ) -> Self {
-        let mut channels = self.channels.clone();
-        channels.insert((port_id, channel_id), channel_end);
-        Self { channels, ..self }
-    }
-
     /// Accessor for a block of the local (host) chain from this context.
     /// Returns `None` if the block at the requested height does not exist.
     fn host_block(&self, target_height: Height) -> Option<&HostBlock> {
@@ -419,6 +400,14 @@ impl ChannelReader for MockContext {
 }
 
 impl ChannelKeeper for MockContext {
+    fn next_channel_id(&mut self) -> ChannelId {
+        let prefix = ChannelId::default().to_string();
+        let suffix = self.channel_ids_counter;
+        self.channel_ids_counter += 1;
+
+        ChannelId::from_str(format!("{}-{}", prefix, suffix).as_str()).unwrap()
+    }
+
     fn store_channel(
         &mut self,
         port_channel_id: &(PortId, ChannelId),