Implement ICS connection's open_try datagram

I omit vector commitment and light client part. I will fill the part
after we merge them in the PoC branch.

Author: majecty

core/src/ibc/connection_03/manager.rs

@@ -15,7 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use super::path as connection_path;
-use super::types::{CommitmentPrefix, Identifier};
+use super::types::{CommitmentPrefix, CommitmentProof, Identifier};
 use crate::ibc;
 use crate::ibc::connection_03::client_connections_path;
 use crate::ibc::connection_03::types::{ConnectionEnd, ConnectionIdentifiersInClient, ConnectionState};
@@ -24,6 +24,11 @@ use rlp::{Encodable, Rlp};
 #[derive(Default)]
 pub struct Manager {}
 
+// FIXME: this will be changed after implementing Vector commitment
+fn get_commiment_prefix() -> String {
+    "".to_owned()
+}
+
 impl Manager {
     pub fn new() -> Self {
         Manager {}
@@ -55,6 +60,106 @@ impl Manager {
         Ok(())
     }
 
+    // We all following ICS spec.
+    #[allow(clippy::too_many_arguments)]
+    pub fn handle_open_try(
+        &self,
+        ctx: &mut dyn ibc::Context,
+        desired_identifier: Identifier,
+        counterparty_connection_identifier: Identifier,
+        counterparty_prefix: CommitmentPrefix,
+        counterparty_client_identifier: Identifier,
+        client_identifier: Identifier,
+        counterparty_versions: Vec<String>,
+        proof_init: CommitmentProof,
+        proof_consensus: CommitmentProof,
+        proof_height: u64,
+        consensus_height: u64,
+    ) -> Result<(), String> {
+        let current_height = ctx.get_current_height();
+        if consensus_height > current_height {
+            return Err(format!(
+                "Consensus height {} is greater than current height {}",
+                consensus_height, current_height
+            ))
+        }
+        let expected = ConnectionEnd {
+            state: ConnectionState::INIT,
+            counterparty_connection_identifier: desired_identifier.clone(),
+            counterparty_prefix: get_commiment_prefix(),
+            client_identifier: counterparty_client_identifier.clone(),
+            counterparty_client_identifier: client_identifier.clone(),
+        };
+
+        let connection = ConnectionEnd {
+            state: ConnectionState::TRYOPEN,
+            counterparty_connection_identifier: counterparty_client_identifier.clone(),
+            counterparty_prefix: counterparty_prefix.clone(),
+            client_identifier: client_identifier.clone(),
+            counterparty_client_identifier: counterparty_client_identifier.clone(),
+        };
+
+        self.verify_connection_state(ctx, &connection, proof_height, proof_init, desired_identifier.clone(), &expected);
+
+        if let Some(previous_connection_end) = self.query(ctx, &desired_identifier) {
+            let expected_init = ConnectionEnd {
+                state: ConnectionState::INIT,
+                counterparty_connection_identifier,
+                counterparty_prefix,
+                client_identifier,
+                counterparty_client_identifier,
+            };
+            if previous_connection_end != expected_init {
+                return Err(format!(
+                    "Invalid previous connection status: previous: {:?}, expected: {:?}",
+                    previous_connection_end, expected_init
+                ))
+            }
+        }
+
+        let kv_store = ctx.get_kv_store();
+        kv_store.set(&connection_path(&desired_identifier), &connection.rlp_bytes());
+        Ok(())
+    }
+
+    fn query(&self, ctx: &mut dyn ibc::Context, identifier: &str) -> Option<ConnectionEnd> {
+        let kv_store = ctx.get_kv_store();
+
+        let path = connection_path(&identifier);
+        if kv_store.has(&path) {
+            let raw = kv_store.get(&path);
+            let connection_end = rlp::decode(&raw).expect("Only the connection code can save the code");
+            return Some(connection_end)
+        }
+
+        None
+    }
+
+    fn verify_connection_state(
+        &self,
+        ctx: &mut dyn ibc::Context,
+        connection: &ConnectionEnd,
+        proof_height: u64,
+        proof: CommitmentProof,
+        connection_identifier: Identifier,
+        connection_end: &ConnectionEnd,
+    ) -> bool {
+        // check values in the connection_end
+        let path = format!("connections/{}", connection_identifier);
+        self.client_verify_membership(proof_height, proof, path, &rlp::encode(connection_end))
+    }
+
+    fn client_verify_membership(
+        &self,
+        _height: u64,
+        _commitment_proof: CommitmentProof,
+        _path: String,
+        _value: &[u8],
+    ) -> bool {
+        // FIXME
+        true
+    }
+
     fn add_connection_to_client(
         &self,
         ctx: &mut dyn ibc::Context,

core/src/ibc/connection_03/types.rs

@@ -45,6 +45,8 @@ impl rlp::Decodable for ConnectionState {
 
 // FIXME: current commitment_23::Prefix is too generic.
 pub type CommitmentPrefix = String;
+// FIXME: This type will be replaced after commitment code changed.
+pub type CommitmentProof = String;
 pub type Identifier = String;
 
 #[derive(RlpEncodable, RlpDecodable, PartialEq, Debug)]