Implement ConnOpenConfirm datagram

Author: majecty

core/src/ibc/connection_03/manager.rs

@@ -166,6 +166,39 @@ impl<'a> Manager<'a> {
         Ok(())
     }
 
+    pub fn handle_open_confirm(
+        &mut self,
+        identifier: Identifier,
+        proof_ack: Vec<u8>,
+        proof_height: u64,
+    ) -> Result<(), String> {
+        let mut connection = self
+            .query(&identifier)
+            .ok_or_else(|| format!("Cannot find connection with the identifier: {}", identifier))?;
+        if connection.state != ConnectionState::TRYOPEN {
+            return Err(format!("Invalid connection state expected TRYOPEN but found {:?}", connection.state))
+        }
+
+        let expected = ConnectionEnd {
+            state: ConnectionState::OPEN,
+            counterparty_connection_identifier: identifier.clone(),
+            counterparty_prefix: get_commiment_prefix(),
+            client_identifier: connection.counterparty_client_identifier.clone(),
+            counterparty_client_identifier: connection.client_identifier.clone(),
+        };
+
+        if !self.verify_connection_state(&connection, proof_height, proof_ack, identifier.clone(), &expected) {
+            return Err(format!("Counterparty chain's connection state verification fail. expected: {:?}", expected))
+        }
+
+        connection.state = ConnectionState::OPEN;
+        let kv_store = self.ctx.get_kv_store_mut();
+        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

@@ -24,6 +24,7 @@ enum DatagramTag {
     ConnOpenInit = 3,
     ConnOpenTry = 4,
     ConnOpenAck = 5,
+    ConnOpenConfirm = 6,
 }
 
 impl Encodable for DatagramTag {
@@ -41,6 +42,7 @@ impl Decodable for DatagramTag {
             3 => Ok(DatagramTag::ConnOpenInit),
             4 => Ok(DatagramTag::ConnOpenTry),
             5 => Ok(DatagramTag::ConnOpenAck),
+            6 => Ok(DatagramTag::ConnOpenConfirm),
             _ => Err(DecoderError::Custom("Unexpected DatagramTag Value")),
         }
     }
@@ -83,6 +85,11 @@ pub enum Datagram {
         proof_height: u64,
         consensus_height: u64,
     },
+    ConnOpenConfirm {
+        identifier: String,
+        proof_ack: Vec<u8>,
+        proof_height: u64,
+    },
 }
 
 impl Encodable for Datagram {
@@ -160,6 +167,14 @@ impl Encodable for Datagram {
                     .append(proof_height)
                     .append(consensus_height);
             }
+            Datagram::ConnOpenConfirm {
+                identifier,
+                proof_ack,
+                proof_height,
+            } => {
+                s.begin_list(4);
+                s.append(&DatagramTag::ConnOpenConfirm).append(identifier).append(proof_ack).append(proof_height);
+            }
         };
     }
 }
@@ -248,6 +263,20 @@ impl Decodable for Datagram {
                     consensus_height: rlp.val_at(5)?,
                 })
             }
+            DatagramTag::ConnOpenConfirm => {
+                let item_count = rlp.item_count()?;
+                if item_count != 4 {
+                    return Err(DecoderError::RlpInvalidLength {
+                        expected: 4,
+                        got: item_count,
+                    })
+                }
+                Ok(Datagram::ConnOpenConfirm {
+                    identifier: rlp.val_at(1)?,
+                    proof_ack: rlp.val_at(2)?,
+                    proof_height: rlp.val_at(3)?,
+                })
+            }
         }
     }
 }
@@ -296,4 +325,14 @@ mod tests {
         };
         rlp_encode_and_decode_test!(conn_open_ack);
     }
+
+    #[test]
+    fn conn_open_confirm() {
+        let conn_open_confirm = Datagram::ConnOpenConfirm {
+            identifier: "identifier".to_owned(),
+            proof_ack: b"proof_ack".to_vec(),
+            proof_height: 1,
+        };
+        rlp_encode_and_decode_test!(conn_open_confirm);
+    }
 }

core/src/ibc/transaction_handler/mod.rs

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