Implement channel query and ChanOpenInit message (#65)

* Add channel module and query

* Add MsgChanOpenInit message

* Added more tests and error handling

Use of 'map_err' to convert errors when parsing

Return Resuls for constructor functions for channel and endpoint, and
perform validation

* Fixed connection hops validation

Fixed some clippy errors

Allow too_many_arguments for message parameters

* review comments

Author: ancazamfir

modules/src/ics02_client/msgs.rs

@@ -1,7 +1,7 @@
 use super::client_type::ClientType;
 use super::header::Header;
 use super::state::ConsensusState;
-use crate::ics24_host::client::ClientId;
+use crate::ics24_host::identifier::ClientId;
 
 // FIXME: Remove Header associated type and use Box<dyn tendermint::lite::Header> instead of
 // Self::Header?

modules/src/ics02_client/query.rs

@@ -7,7 +7,7 @@ use crate::ics23_commitment::{CommitmentPath, CommitmentProof};
 
 use crate::error;
 use crate::ics02_client::state::{ClientState, ConsensusState};
-use crate::ics24_host::client::ClientId;
+use crate::ics24_host::identifier::ClientId;
 use crate::path::{ClientStatePath, ConsensusStatePath, Path};
 use crate::query::{IbcQuery, IbcResponse};
 use crate::Height;

modules/src/ics02_client/state.rs

@@ -1,7 +1,7 @@
 use super::client_type::ClientType;
 
 use crate::ics23_commitment::CommitmentRoot;
-use crate::ics24_host::client::ClientId;
+use crate::ics24_host::identifier::ClientId;
 use crate::Height;
 
 pub trait ConsensusState {

modules/src/ics04_channel/channel.rs

@@ -0,0 +1,107 @@
+use super::exported::*;
+use crate::ics04_channel::error;
+use crate::ics04_channel::error::Kind;
+use crate::ics24_host::identifier::{ChannelId, ConnectionId, PortId};
+use serde_derive::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Channel {
+    state: State,
+    ordering: Order,
+    remote: Endpoint,
+    connection_hops: Vec<ConnectionId>,
+    version: String,
+}
+
+impl Channel {
+    pub fn new(
+        ordering: Order,
+        remote: Endpoint,
+        connection_hops: Vec<ConnectionId>,
+        version: String,
+    ) -> Self {
+        Self {
+            state: State::Uninitialized,
+            ordering,
+            remote,
+            connection_hops,
+            version,
+        }
+    }
+}
+
+impl ChannelI for Channel {
+    type ValidationError = crate::ics04_channel::error::Error;
+
+    fn state(&self) -> State {
+        self.state.clone()
+    }
+
+    fn ordering(&self) -> Order {
+        self.ordering.clone()
+    }
+
+    fn counterparty(&self) -> Box<dyn CounterpartyI<ValidationError = Self::ValidationError>> {
+        Box::new(self.remote.clone())
+    }
+
+    fn connection_hops(&self) -> Vec<ConnectionId> {
+        self.connection_hops.clone()
+    }
+
+    fn version(&self) -> String {
+        self.version.parse().unwrap()
+    }
+
+    fn validate_basic(&self) -> Result<(), Self::ValidationError> {
+        if self.connection_hops.len() != 1 {
+            return Err(error::Kind::InvalidConnectionHopsLength
+                .context("validate channel")
+                .into());
+        }
+        if self.version().trim() == "" {
+            return Err(error::Kind::InvalidVersion
+                .context("empty version string")
+                .into());
+        }
+        self.counterparty().validate_basic()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Endpoint {
+    port_id: PortId,
+    channel_id: ChannelId,
+}
+
+impl Endpoint {
+    pub fn new(
+        port_id: String,
+        channel_id: String,
+    ) -> Result<Self, crate::ics04_channel::error::Error> {
+        Ok(Self {
+            port_id: port_id
+                .parse()
+                .map_err(|e| Kind::IdentifierError.context(e))?,
+            channel_id: channel_id
+                .parse()
+                .map_err(|e| Kind::IdentifierError.context(e))?,
+        })
+    }
+}
+
+impl CounterpartyI for Endpoint {
+    type ValidationError = crate::ics04_channel::error::Error;
+
+    fn port_id(&self) -> String {
+        String::from(self.port_id.as_str())
+    }
+
+    fn channel_id(&self) -> String {
+        String::from(self.channel_id.as_str())
+    }
+
+    fn validate_basic(&self) -> Result<(), Self::ValidationError> {
+        Ok(())
+    }
+}

modules/src/ics04_channel/error.rs

@@ -0,0 +1,28 @@
+use anomaly::{BoxError, Context};
+use thiserror::Error;
+
+pub type Error = anomaly::Error<Kind>;
+
+#[derive(Clone, Debug, Error)]
+pub enum Kind {
+    #[error("channel state unknown")]
+    UnknownState,
+
+    #[error("identifier error")]
+    IdentifierError,
+
+    #[error("channel order type unknown")]
+    UnknownOrderType,
+
+    #[error("invalid connection hops length")]
+    InvalidConnectionHopsLength,
+
+    #[error("invalid version")]
+    InvalidVersion,
+}
+
+impl Kind {
+    pub fn context(self, source: impl Into<BoxError>) -> Context<Self> {
+        Context::new(self, Some(source.into()))
+    }
+}

modules/src/ics04_channel/exported.rs

@@ -0,0 +1,194 @@
+use super::error;
+use crate::ics24_host::identifier::ConnectionId;
+use anomaly::fail;
+use serde_derive::{Deserialize, Serialize};
+
+pub trait ChannelI {
+    type ValidationError: std::error::Error;
+    fn state(&self) -> State;
+    fn ordering(&self) -> Order;
+    fn counterparty(&self) -> Box<dyn CounterpartyI<ValidationError = super::error::Error>>;
+    fn connection_hops(&self) -> Vec<ConnectionId>;
+    fn version(&self) -> String;
+    fn validate_basic(&self) -> Result<(), Self::ValidationError>;
+}
+
+pub trait CounterpartyI {
+    type ValidationError: std::error::Error;
+    fn port_id(&self) -> String;
+    fn channel_id(&self) -> String;
+    fn validate_basic(&self) -> Result<(), Self::ValidationError>;
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum State {
+    Uninitialized = 0,
+    Init,
+    TryOpen,
+    Open,
+    Closed,
+}
+
+impl State {
+    /// Yields the state as a string
+    pub fn as_string(&self) -> &'static str {
+        match self {
+            Self::Uninitialized => "UNINITIALIZED",
+            Self::Init => "INIT",
+            Self::TryOpen => "TRYOPEN",
+            Self::Open => "OPEN",
+            Self::Closed => "CLOSED",
+        }
+    }
+}
+
+impl std::str::FromStr for State {
+    type Err = error::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "UNINITIALIZED" => Ok(Self::Uninitialized),
+            "INIT" => Ok(Self::Init),
+            "TRYOPEN" => Ok(Self::TryOpen),
+            "OPEN" => Ok(Self::Open),
+            "CLOSED" => Ok(Self::Closed),
+            _ => fail!(error::Kind::UnknownState, s),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum Order {
+    None = 0,
+    Unordered,
+    Ordered,
+}
+
+impl Order {
+    /// Yields the Order as a string
+    pub fn as_string(&self) -> &'static str {
+        match self {
+            Self::None => "UNINITIALIZED",
+            Self::Unordered => "UNORDERED",
+            Self::Ordered => "ORDERED",
+        }
+    }
+}
+
+impl std::str::FromStr for Order {
+    type Err = error::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "UNINITIALIZED" => Ok(Self::None),
+            "UNORDERED" => Ok(Self::Unordered),
+            "ORDERED" => Ok(Self::Ordered),
+            _ => fail!(error::Kind::UnknownOrderType, s),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    #[test]
+    fn parse_channel_ordering_type() {
+        use super::Order;
+
+        struct Test {
+            ordering: &'static str,
+            want_res: Order,
+            want_err: bool,
+        }
+        let tests: Vec<Test> = vec![
+            Test {
+                ordering: "UNINITIALIZED",
+                want_res: Order::None,
+                want_err: false,
+            },
+            Test {
+                ordering: "UNORDERED",
+                want_res: Order::Unordered,
+                want_err: false,
+            },
+            Test {
+                ordering: "ORDERED",
+                want_res: Order::Ordered,
+                want_err: false,
+            },
+            Test {
+                ordering: "UNKNOWN_ORDER",
+                want_res: Order::None,
+                want_err: true,
+            },
+        ]
+        .into_iter()
+        .collect();
+
+        for test in tests {
+            match Order::from_str(test.ordering) {
+                Ok(res) => {
+                    assert!(!test.want_err);
+                    assert_eq!(test.want_res, res);
+                }
+                Err(_) => assert!(test.want_err, "parse failed"),
+            }
+        }
+    }
+
+    #[test]
+    fn parse_channel_state() {
+        use super::State;
+
+        struct Test {
+            state: &'static str,
+            want_res: State,
+            want_err: bool,
+        }
+        let tests: Vec<Test> = vec![
+            Test {
+                state: "UNINITIALIZED",
+                want_res: State::Uninitialized,
+                want_err: false,
+            },
+            Test {
+                state: "INIT",
+                want_res: State::Init,
+                want_err: false,
+            },
+            Test {
+                state: "TRYOPEN",
+                want_res: State::TryOpen,
+                want_err: false,
+            },
+            Test {
+                state: "OPEN",
+                want_res: State::Open,
+                want_err: false,
+            },
+            Test {
+                state: "CLOSED",
+                want_res: State::Closed,
+                want_err: false,
+            },
+            Test {
+                state: "INVALID_STATE",
+                want_res: State::Open,
+                want_err: true,
+            },
+        ]
+        .into_iter()
+        .collect();
+
+        for test in tests {
+            match State::from_str(test.state) {
+                Ok(res) => {
+                    assert!(!test.want_err);
+                    assert_eq!(test.want_res, res);
+                }
+                Err(_) => assert!(test.want_err, "parse failed"),
+            }
+        }
+    }
+}

modules/src/ics04_channel/mod.rs

@@ -0,0 +1,7 @@
+//! ICS 04: IBC Channel implementation
+
+pub mod channel;
+pub mod error;
+pub mod exported;
+pub mod msgs;
+pub mod query;