Implement ConnOpenAck datagrain in the ICS Connection spec

Author: majecty

core/src/ibc/connection_03/manager.rs

@@ -118,6 +118,45 @@ impl<'a> Manager<'a> {
         Ok(())
     }
 
+    pub fn handle_open_ack(
+        &mut self,
+        identifier: Identifier,
+        proof_try: CommitmentProof,
+        proof_consensus: CommitmentProof,
+        proof_height: u64,
+        consensus_height: u64,
+    ) -> Result<(), String> {
+        let current_height = self.ctx.get_current_height();
+        if consensus_height > current_height {
+            return Err(format!(
+                "Consensus height {} is greater than current height {}",
+                consensus_height, current_height
+            ))
+        }
+        let mut connection = self
+            .query(&identifier)
+            .ok_or_else(|| format!("Cannot find connection with the identifier: {}", identifier))?;
+
+        if connection.state != ConnectionState::INIT && connection.state != ConnectionState::TRYOPEN {
+            return Err(format!("Invalid connection state expected INIT or TRYOPEN but found {:?}", connection.state))
+        }
+        let expected_connection = ConnectionEnd {
+            state: ConnectionState::TRYOPEN,
+            counterparty_connection_identifier: identifier.clone(),
+            counterparty_prefix: get_commiment_prefix(),
+            client_identifier: connection.counterparty_client_identifier.clone(),
+            counterparty_client_identifier: connection.client_identifier.clone(),
+        };
+        self.verify_connection_state(&connection, proof_height, proof_try, identifier.clone(), &expected_connection);
+
+        connection.state = ConnectionState::OPEN;
+        let kv_store = self.ctx.get_kv_store();
+        let path = connection_path(&identifier);
+        kv_store.set(&path, &connection.rlp_bytes());
+
+        Ok(())
+    }
+
     fn query(&mut self, identifier: &str) -> Option<ConnectionEnd> {
         let kv_store = self.ctx.get_kv_store();
 

core/src/ibc/transaction_handler/datagrams.rs

@@ -23,6 +23,7 @@ enum DatagramTag {
     UpdateClient = 2,
     ConnOpenInit = 3,
     ConnOpenTry = 4,
+    ConnOpenAck = 5,
 }
 
 impl Encodable for DatagramTag {
@@ -39,6 +40,7 @@ impl Decodable for DatagramTag {
             2 => Ok(DatagramTag::UpdateClient),
             3 => Ok(DatagramTag::ConnOpenInit),
             4 => Ok(DatagramTag::ConnOpenTry),
+            5 => Ok(DatagramTag::ConnOpenAck),
             _ => Err(DecoderError::Custom("Unexpected DatagramTag Value")),
         }
     }
@@ -74,6 +76,13 @@ pub enum Datagram {
         proof_height: u64,
         consensus_height: u64,
     },
+    ConnOpenAck {
+        identifier: String,
+        proof_try: String,
+        proof_consensus: String,
+        proof_height: u64,
+        consensus_height: u64,
+    },
 }
 
 impl Encodable for Datagram {
@@ -136,6 +145,21 @@ impl Encodable for Datagram {
                     .append(proof_height)
                     .append(consensus_height);
             }
+            Datagram::ConnOpenAck {
+                identifier,
+                proof_try,
+                proof_consensus,
+                proof_height,
+                consensus_height,
+            } => {
+                s.begin_list(6);
+                s.append(&DatagramTag::ConnOpenAck)
+                    .append(identifier)
+                    .append(proof_try)
+                    .append(proof_consensus)
+                    .append(proof_height)
+                    .append(consensus_height);
+            }
         };
     }
 }
@@ -208,6 +232,22 @@ impl Decodable for Datagram {
                     consensus_height: rlp.val_at(9)?,
                 })
             }
+            DatagramTag::ConnOpenAck => {
+                let item_count = rlp.item_count()?;
+                if item_count != 6 {
+                    return Err(DecoderError::RlpInvalidLength {
+                        expected: 6,
+                        got: item_count,
+                    })
+                }
+                Ok(Datagram::ConnOpenAck {
+                    identifier: rlp.val_at(1)?,
+                    proof_try: rlp.val_at(2)?,
+                    proof_consensus: rlp.val_at(3)?,
+                    proof_height: rlp.val_at(4)?,
+                    consensus_height: rlp.val_at(5)?,
+                })
+            }
         }
     }
 }

core/src/ibc/transaction_handler/mod.rs

@@ -96,6 +96,18 @@ pub fn execute(
                 )
                 .map_err(|err| RuntimeError::IBC(format!("ConnOpenTry: {}", err)).into())
         }
+        Datagram::ConnOpenAck {
+            identifier,
+            proof_try,
+            proof_consensus,
+            proof_height,
+            consensus_height,
+        } => {
+            let mut connection_manager = ibc_connection::Manager::new(&mut context);
+            connection_manager
+                .handle_open_ack(identifier, proof_try, proof_consensus, proof_height, consensus_height)
+                .map_err(|err| RuntimeError::IBC(format!("ConnOpenAck: {}", err)).into())
+        }
     }
 }