WIP Connection queries for Relayer

modules/Cargo.toml

@@ -26,7 +26,12 @@ serde_derive = "1.0.104"
 serde = "1.0.104"
 serde_json = "1"
 tracing = "0.1.13"
+prost = "0.6.1"
+bytes = "0.5.5"
 
 [dev-dependencies]
 tokio = { version = "0.2", features = ["macros"] }
 subtle-encoding = { version = "0.5" }
+
+[build-dependencies]
+prost-build = { version = "0.6.1" }

modules/build.rs

@@ -0,0 +1,5 @@
+extern crate prost_build;
+
+fn main() {
+    prost_build::compile_protos(&["src/proto/connection.proto"], &["src/proto"]).unwrap();
+}

modules/src/ics03_connection/connection.rs

@@ -1,9 +1,13 @@
 use super::exported::*;
 use crate::ics03_connection::error::{Error, Kind};
+use crate::ics03_connection::proto_connection;
 use crate::ics23_commitment::CommitmentPrefix;
 use crate::ics24_host::identifier::{ClientId, ConnectionId};
 use serde_derive::{Deserialize, Serialize};
 
+use anomaly::fail;
+use std::str::FromStr;
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ConnectionEnd {
     state: State,
@@ -25,6 +29,34 @@ impl ConnectionEnd {
             versions: validate_versions(versions).map_err(|e| Kind::InvalidVersion.context(e))?,
         })
     }
+
+    pub fn set_state(&mut self, new_state: State) {
+        self.state = new_state;
+    }
+
+    pub fn from_proto_connection(pc: proto_connection::ConnectionEnd) -> Result<Self, Error> {
+        // The Counterparty field is an Option, may be missing.
+        match pc.counterparty {
+            Some(cp) => {
+                let mut conn = ConnectionEnd::new(
+                    ClientId::from_str(&pc.client_id).unwrap(),
+                    Counterparty::from_proto_counterparty(cp).unwrap(),
+                    pc.versions,
+                )
+                .unwrap();
+
+                // Set the state.
+                conn.set_state(State::from_i32(pc.state));
+                Ok(conn)
+            }
+
+            // If no counterparty was set, signal the error.
+            None => fail!(
+                Kind::MissingCounterparty,
+                "no counterparty in the given connection"
+            ),
+        }
+    }
 }
 
 impl Connection for ConnectionEnd {
@@ -76,6 +108,20 @@ impl Counterparty {
             prefix,
         })
     }
+
+    pub fn from_proto_counterparty(pc: proto_connection::Counterparty) -> Result<Self, Error> {
+        match pc.prefix {
+            Some(prefix) => Counterparty::new(
+                pc.client_id,
+                pc.connection_id,
+                CommitmentPrefix::new(prefix.key_prefix),
+            ),
+            None => fail!(
+                Kind::MissingCounterpartyPrefix,
+                "no prefix in the given counterparty"
+            ),
+        }
+    }
 }
 
 impl ConnectionCounterparty for Counterparty {

modules/src/ics03_connection/error.rs

@@ -21,6 +21,12 @@ pub enum Kind {
 
     #[error("invalid proof")]
     InvalidProof,
+
+    #[error("missing counterparty")]
+    MissingCounterparty,
+
+    #[error("missing counterparty prefix")]
+    MissingCounterpartyPrefix,
 }
 
 impl Kind {

modules/src/ics03_connection/exported.rs

@@ -42,6 +42,15 @@ impl State {
             Self::Open => "OPEN",
         }
     }
+
+    pub fn from_i32(nr: i32) -> Self {
+        match nr {
+            1 => Self::Init,
+            2 => Self::TryOpen,
+            3 => Self::Open,
+            _ => Self::Uninitialized,
+        }
+    }
 }
 
 impl std::str::FromStr for State {

modules/src/ics03_connection/mod.rs

@@ -6,3 +6,11 @@ pub mod events;
 pub mod exported;
 pub mod msgs;
 pub mod query;
+
+// Use the generated proto file for the connection according to prost_build instructions
+pub mod proto_connection {
+
+    #![allow(unused_qualifications)]
+
+    include!(concat!(env!("OUT_DIR"), "/connection.rs"));
+}

modules/src/ics03_connection/msgs.rs

@@ -308,7 +308,7 @@ mod tests {
             client_id: "srcclient".to_string(),
             counterparty_connection_id: "destconnection".to_string(),
             counterparty_client_id: "destclient".to_string(),
-            counterparty_commitment_prefix: CommitmentPrefix {},
+            counterparty_commitment_prefix: CommitmentPrefix::new(vec![]),
         };
 
         let tests: Vec<Test> = vec![
@@ -398,7 +398,7 @@ mod tests {
             client_id: "srcclient".to_string(),
             counterparty_connection_id: "destconnection".to_string(),
             counterparty_client_id: "destclient".to_string(),
-            counterparty_commitment_prefix: CommitmentPrefix {},
+            counterparty_commitment_prefix: CommitmentPrefix::new(vec![]),
             counterparty_versions: vec!["1.0.0".to_string()],
             proof_init: get_dummy_proof(),
             proof_consensus: get_dummy_proof(),

modules/src/ics03_connection/query.rs

@@ -11,6 +11,12 @@ use crate::path::{ConnectionPath, Path};
 use crate::query::{IbcQuery, IbcResponse};
 use crate::Height;
 
+// Protobuf
+use crate::ics03_connection::error::Error;
+use crate::ics03_connection::proto_connection;
+use bytes::Bytes;
+use prost::Message;
+
 pub struct QueryConnection {
     pub chain_height: Height,
     pub connection_id: ConnectionId,
@@ -79,11 +85,11 @@ impl IbcResponse<QueryConnection> for ConnectionResponse {
         query: QueryConnection,
         response: AbciQuery,
     ) -> Result<Self, error::Error> {
-        let connection = amino_unmarshal_binary_length_prefixed(&response.value)?;
+        let decoded_conn = proto_unmarshal(response.value).unwrap();
 
         Ok(ConnectionResponse::new(
             query.connection_id,
-            connection,
+            decoded_conn,
             response.proof,
             response.height.into(),
         ))
@@ -105,6 +111,8 @@ impl IdentifiedConnectionEnd {
     }
 }
 
-fn amino_unmarshal_binary_length_prefixed<T>(_bytes: &[u8]) -> Result<T, error::Error> {
-    todo!()
+fn proto_unmarshal(bytes: Vec<u8>) -> Result<ConnectionEnd, Error> {
+    let buf = Bytes::from(bytes);
+    let decoded = proto_connection::ConnectionEnd::decode(buf).unwrap();
+    ConnectionEnd::from_proto_connection(decoded)
 }

modules/src/ics23_commitment/mod.rs

@@ -14,7 +14,7 @@ impl CommitmentPath {
     where
         P: Path,
     {
-        todo!()
+        CommitmentPath {}
     }
 }
 
@@ -32,6 +32,10 @@ impl CommitmentProof {
 */
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct CommitmentPrefix;
+pub struct CommitmentPrefix(Vec<u8>);
 
-// TODO: impl CommitPrefix
+impl CommitmentPrefix {
+    pub fn new(content: Vec<u8>) -> Self {
+        Self { 0: content }
+    }
+}

modules/src/proto/connection.proto

@@ -0,0 +1,54 @@
+syntax = "proto3";
+
+package connection;
+
+// ICS03 - Connection Data Structures as defined in
+// https://github.com/cosmos/ics/tree/master/spec/ics-003-connection-semantics#data-structures
+
+// ConnectionEnd defines a stateful object on a chain connected to another separate
+// one.
+// NOTE: there must only be 2 defined ConnectionEnds to establish a connection
+// between two chains.
+message ConnectionEnd {
+  // connection identifier.
+  string id = 1;
+  // client associated with this connection.
+  string client_id = 2;
+  // opaque string which can be utilised to determine encodings or protocols for
+  // channels or packets utilising this connection
+  repeated string versions = 3;
+  // current state of the connection end.
+  State state = 4;
+  // counterparty chain associated with this connection.
+  Counterparty counterparty = 5;
+}
+
+// State defines if a connection is in one of the following states:
+// INIT, TRYOPEN, OPEN or UNINITIALIZED.
+enum State {
+  // Default State
+  STATE_UNINITIALIZED_UNSPECIFIED = 0;
+  // A connection end has just started the opening handshake.
+  STATE_INIT = 1;
+  // A connection end has acknowledged the handshake step on the counterparty chain.
+  STATE_TRYOPEN = 2;
+  // A connection end has completed the handshake.
+  STATE_OPEN = 3;
+}
+
+// Counterparty defines the counterparty chain associated with a connection end.
+message Counterparty {
+  // identifies the client on the counterparty chain associated with a given connection.
+  string client_id = 1;
+  // identifies the connection end on the counterparty chain associated with a given connection.
+  string connection_id = 2;
+  // commitment merkle prefix of the counterparty chain
+  MerklePrefix prefix = 3;
+}
+
+
+// MerklePrefix is merkle path prefixed to the key.
+// The constructed key from the Path and the key will be append(Path.KeyPath, append(Path.KeyPrefix, key...))
+message MerklePrefix {
+  bytes key_prefix = 1;
+}