Add get_current_height function to the IBC Context

The connection spec's OpenTry datagram handler needs to know the
host's current height.

Connection Spec:
https://github.com/cosmos/ics/tree/master/spec/ics-003-connection-semantics

Host Spec:
https://github.com/cosmos/ics/tree/master/spec/ics-024-host-requirements#consensus-state-introspection

Author: majecty

core/src/client/client.rs

@@ -867,7 +867,8 @@ impl IBCTransactionExecutor for Client {
         state: &mut TopLevelState,
         fee_payer: &Address,
         sender_pubkey: &Public,
+        current_block_number: BlockNumber,
     ) -> StateResult<()> {
-        ibc::execute_transaction(bytes, state, fee_payer, sender_pubkey)
+        ibc::execute_transaction(bytes, state, fee_payer, sender_pubkey, current_block_number)
     }
 }

core/src/ibc/context.rs

@@ -22,18 +22,21 @@ use rlp::RlpStream;
 
 pub trait Context {
     fn get_kv_store(&mut self) -> &mut dyn kv_store::KVStore;
+    fn get_current_height(&self) -> u64;
 }
 
 pub struct TopLevelContext<'a> {
     kv_store: TopLevelKVStore<'a>,
+    current_height: u64,
 }
 
 impl<'a> TopLevelContext<'a> {
-    pub fn new(state: &'a mut TopLevelState) -> Self {
+    pub fn new(state: &'a mut TopLevelState, current_height: u64) -> Self {
         TopLevelContext {
             kv_store: TopLevelKVStore {
                 state,
             },
+            current_height,
         }
     }
 }
@@ -42,6 +45,10 @@ impl<'a> Context for TopLevelContext<'a> {
     fn get_kv_store(&mut self) -> &mut dyn KVStore {
         &mut self.kv_store
     }
+
+    fn get_current_height(&self) -> u64 {
+        self.current_height
+    }
 }
 
 struct TopLevelKVStore<'a> {

core/src/ibc/transaction_handler/mod.rs

@@ -32,26 +32,27 @@ pub fn execute(
     state: &mut TopLevelState,
     fee_payer: &Address,
     _sender_public: &Public,
+    current_block_number: u64,
 ) -> StateResult<()> {
     let datagram = Datagram::decode(&Rlp::new(bytes)).expect("Verification passed");
     match datagram {
         Datagram::CreateClient {
             id,
             kind,
             consensus_state,
-        } => create_client(state, fee_payer, &id, kind, &consensus_state),
+        } => create_client(state, fee_payer, &id, kind, &consensus_state, current_block_number),
         Datagram::UpdateClient {
             id,
             header,
-        } => update_client(state, &id, &header),
+        } => update_client(state, &id, &header, current_block_number),
         Datagram::ConnOpenInit {
             identifier,
             desired_counterparty_connection_identifier,
             counterparty_prefix,
             client_identifier,
             counterparty_client_identifier,
         } => {
-            let mut context = ibc_context::TopLevelContext::new(state);
+            let mut context = ibc_context::TopLevelContext::new(state, current_block_number);
             let connection_manager = ibc_connection::Manager::new();
             connection_manager
                 .handle_open_init(
@@ -74,8 +75,9 @@ fn create_client(
     id: &str,
     kind: ibc_client::Kind,
     consensus_state: &[u8],
+    current_block_number: u64,
 ) -> StateResult<()> {
-    let mut context = ibc_context::TopLevelContext::new(state);
+    let mut context = ibc_context::TopLevelContext::new(state, current_block_number);
     let client_manager = ibc_client::Manager::new();
     if kind != ibc_client::KIND_FOUNDRY {
         return Err(RuntimeError::IBC(format!("CreateClient has invalid type {}", kind)).into())
@@ -94,8 +96,8 @@ fn create_client(
     Ok(())
 }
 
-fn update_client(state: &mut TopLevelState, id: &str, header: &[u8]) -> StateResult<()> {
-    let mut context = ibc_context::TopLevelContext::new(state);
+fn update_client(state: &mut TopLevelState, id: &str, header: &[u8], current_block_number: u64) -> StateResult<()> {
+    let mut context = ibc_context::TopLevelContext::new(state, current_block_number);
     let client_manager = ibc_client::Manager::new();
     let client_state = client_manager.query(&mut context, id).map_err(RuntimeError::IBC)?;
 

rpc/src/v1/impls/ibc.rs

@@ -56,7 +56,7 @@ where
             Some(block_number) => block_number,
         };
 
-        let mut context = ibc::context::TopLevelContext::new(&mut state);
+        let mut context = ibc::context::TopLevelContext::new(&mut state, block_number);
         let client_manager = ibc::client::Manager::new();
         let client_state =
             client_manager.query(&mut context, &client_id).map_err(|_| errors::ibc_client_not_exist())?;
@@ -96,7 +96,7 @@ where
             Some(block_number) => block_number,
         };
 
-        let mut context = ibc::context::TopLevelContext::new(&mut state);
+        let mut context = ibc::context::TopLevelContext::new(&mut state, block_number);
         let client_manager = ibc::client::Manager::new();
         let client_state =
             client_manager.query(&mut context, &client_id).map_err(|_| errors::ibc_client_not_exist())?;

state/src/ibc.rs

@@ -16,6 +16,7 @@
 
 use crate::{StateResult, TopLevelState};
 use ckey::{Address, Public};
+use ctypes::BlockNumber;
 
 pub trait IBCTransactionExecutor {
     fn execute(
@@ -24,6 +25,7 @@ pub trait IBCTransactionExecutor {
         _state: &mut TopLevelState,
         _fee_payer: &Address,
         _sender_pubkey: &Public,
+        _current_block_number: BlockNumber,
     ) -> StateResult<()> {
         Ok(())
     }

state/src/impls/top_level.rs

@@ -408,7 +408,14 @@ impl TopLevelState {
             Action::IBC {
                 bytes,
             } => {
-                IBCTransactionExecutor::execute(client, bytes, self, fee_payer, signer_public)?;
+                IBCTransactionExecutor::execute(
+                    client,
+                    bytes,
+                    self,
+                    fee_payer,
+                    signer_public,
+                    parent_block_number + 1,
+                )?;
                 return Ok(())
             }
         };