Move IBC transactions to toplevel

Author: majecty

core/src/client/client.rs

@@ -26,6 +26,7 @@ use crate::client::{ConsensusClient, SnapshotClient, TermInfo};
 use crate::consensus::{CodeChainEngine, EngineError};
 use crate::encoded;
 use crate::error::{BlockImportError, Error, ImportError, SchemeError};
+use crate::ibc;
 use crate::miner::{Miner, MinerService};
 use crate::scheme::Scheme;
 use crate::service::ClientIoMessage;
@@ -862,11 +863,11 @@ impl SnapshotClient for Client {
 impl IBCTransactionExecutor for Client {
     fn execute(
         &self,
-        _bytes: &[u8],
-        _state: &mut TopLevelState,
-        _fee_payer: &Address,
-        _sender_pubkey: &Public,
+        bytes: &[u8],
+        state: &mut TopLevelState,
+        fee_payer: &Address,
+        sender_pubkey: &Public,
     ) -> StateResult<()> {
-        unimplemented!()
+        ibc::execute_transaction(bytes, state, fee_payer, sender_pubkey)
     }
 }

core/src/ibc/mod.rs

@@ -23,7 +23,9 @@ pub mod context;
 #[allow(unused_variables)]
 pub mod custom_action_handler;
 mod kv_store;
+mod transaction_handler;
 
 pub use self::client_02 as client;
 pub use self::context::Context;
 pub use self::kv_store::KVStore;
+pub use transaction_handler::execute as execute_transaction;

core/src/ibc/transaction_handler/actions.rs

@@ -0,0 +1,89 @@
+// Copyright 2019-2020 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream};
+
+const ACTION_CREATE_CLIENT: u8 = 1;
+const ACTION_UPDATE_CLIENT: u8 = 2;
+
+#[derive(Debug, PartialEq)]
+pub enum Action {
+    CreateClient {
+        id: String,
+        kind: u8,
+        consensus_state: Vec<u8>,
+    },
+    UpdateClient {
+        id: String,
+        header: Vec<u8>,
+    },
+}
+
+impl Encodable for Action {
+    fn rlp_append(&self, s: &mut RlpStream) {
+        match self {
+            Action::CreateClient {
+                id,
+                kind,
+                consensus_state,
+            } => {
+                s.begin_list(4).append(&ACTION_CREATE_CLIENT).append(id).append(kind).append(consensus_state);
+            }
+            Action::UpdateClient {
+                id,
+                header,
+            } => {
+                s.begin_list(3).append(&ACTION_UPDATE_CLIENT).append(id).append(header);
+            }
+        };
+    }
+}
+
+impl Decodable for Action {
+    fn decode(rlp: &Rlp) -> Result<Self, DecoderError> {
+        let tag = rlp.val_at(0)?;
+        match tag {
+            ACTION_CREATE_CLIENT => {
+                let item_count = rlp.item_count()?;
+                if item_count != 4 {
+                    return Err(DecoderError::RlpInvalidLength {
+                        expected: 4,
+                        got: item_count,
+                    })
+                }
+                Ok(Action::CreateClient {
+                    id: rlp.val_at(1)?,
+                    kind: rlp.val_at(2)?,
+                    consensus_state: rlp.val_at(3)?,
+                })
+            }
+            ACTION_UPDATE_CLIENT => {
+                let item_count = rlp.item_count()?;
+                if item_count != 3 {
+                    return Err(DecoderError::RlpInvalidLength {
+                        expected: 3,
+                        got: item_count,
+                    })
+                }
+                Ok(Action::UpdateClient {
+                    id: rlp.val_at(1)?,
+                    header: rlp.val_at(2)?,
+                })
+            }
+            _ => Err(DecoderError::Custom("Unexpected IBC Action Type")),
+        }
+    }
+}

core/src/ibc/transaction_handler/mod.rs

@@ -0,0 +1,84 @@
+// Copyright 2020 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+mod actions;
+
+use self::actions::Action;
+use crate::ibc;
+use ckey::{Address, Public};
+use cstate::{StateResult, TopLevelState};
+use ctypes::errors::RuntimeError;
+use ibc::client_02 as ibc_client;
+use ibc::client_02::foundry as ibc_foundry;
+use ibc::context as ibc_context;
+use rlp::{Decodable, Rlp};
+
+pub fn execute(
+    bytes: &[u8],
+    state: &mut TopLevelState,
+    fee_payer: &Address,
+    _sender_public: &Public,
+) -> StateResult<()> {
+    let action = Action::decode(&Rlp::new(bytes)).expect("Verification passed");
+    match action {
+        Action::CreateClient {
+            id,
+            kind,
+            consensus_state,
+        } => create_client(state, fee_payer, &id, kind, &consensus_state),
+        Action::UpdateClient {
+            id,
+            header,
+        } => update_client(state, &id, &header),
+    }
+}
+
+
+fn create_client(
+    state: &mut TopLevelState,
+    _fee_payer: &Address,
+    id: &str,
+    kind: ibc_client::Kind,
+    consensus_state: &[u8],
+) -> StateResult<()> {
+    let mut context = ibc_context::TopLevelContext::new(state);
+    let client_manager = ibc_client::Manager::new();
+    if kind != ibc_client::KIND_FOUNDRY {
+        return Err(RuntimeError::IBC(format!("CreateClient has invalid type {}", kind)).into())
+    }
+    let rlp = rlp::Rlp::new(consensus_state);
+    let foundry_consensus_state: ibc_foundry::ConsensusState = match rlp.as_val() {
+        Ok(cs) => cs,
+        Err(err) => {
+            return Err(RuntimeError::IBC(format!("CreateClient failed to decode consensus state {}", err)).into())
+        }
+    };
+
+    client_manager
+        .create(&mut context, id, &foundry_consensus_state)
+        .map_err(|err| RuntimeError::IBC(format!("CreateClient: {:?}", err)))?;
+    Ok(())
+}
+
+fn update_client(state: &mut TopLevelState, id: &str, header: &[u8]) -> StateResult<()> {
+    let mut context = ibc_context::TopLevelContext::new(state);
+    let client_manager = ibc_client::Manager::new();
+    let client_state = client_manager.query(&mut context, id).map_err(RuntimeError::IBC)?;
+
+    client_state.update(&mut context, header).map_err(RuntimeError::IBC)?;
+
+    Ok(())
+}