Implementing ICS connection's open_try datagram

Author: majecty

core/src/ibc/client_02/types.rs

@@ -43,4 +43,5 @@ pub trait State {
     fn set_root(&self, ctx: &mut dyn ibc::Context, block_height: u64, root: &dyn commitment::Root);
     fn exists(&self, ctx: &mut dyn ibc::Context) -> bool;
     fn update(&self, ctx: &mut dyn ibc::Context, header: &[u8]) -> Result<(), String>;
+    fn verify_membership()
 }

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:
+fn get_commiment_prefix() -> String {
+    "".to_owned()
+}
+
 impl Manager {
     pub fn new() -> Self {
         Manager {}
@@ -55,6 +60,71 @@ impl Manager {
         Ok(())
     }
 
+    // We can't know the exact format of counterparty parameters
+    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> {
+        if consensus_height > ctx.get_current_height() {
+            return Err(format!(
+                "Consensus height {} is greater than current height {}",
+                consensus_height,
+                ctx.get_current_height()
+            ))
+        }
+        let expected = ConnectionEnd     {
+            state: ConnectionState::INIT,
+            counterparty_connection_identifier: desired_identifier,
+            counterparty_prefix: get_commiment_prefix(),
+            client_identifier,
+            counterparty_client_identifier,
+        };
+
+        //        let connection =
+
+        //        consensus_height <
+        Ok(())
+    }
+
+    fn verify_connection_state(
+        &self,
+        ctx: &mut dyn ibc::Context,
+        connection: ConnectionEnd,
+        proof_height: u64,
+        proof: CommitmentProof,
+        connection_identifier: Identifier,
+        connection_end: ConnectionEnd,
+    ) -> Result<(), String> {
+        //        let client_manager = ibc::client_02::Manager::new();
+        // should we use connection.client_identifier?
+        //        let client = client_manager.query(ctx, &connection.client_identifier)?;
+        //        client.verify
+        let path = format!("connections/{}", connection_identifier);
+
+        let
+        self.client_verify_membership(proof_height, proof, path, connection_end.);
+    }
+
+    fn client_verify_membership(
+        &self,
+        _height: u64,
+        _commitment_proof: CommitmentProof,
+        _path: String,
+        _value: String,
+    ) {
+        true
+    }
+
     fn add_connection_to_client(
         &self,
         ctx: &mut dyn ibc::Context,

core/src/ibc/connection_03/types.rs

@@ -45,8 +45,11 @@ 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)]
 pub struct ConnectionEnd {
     pub state: ConnectionState,