Ethcore crate split part 1 (#6041)

* split out types into separate crate

* split out evm into its own crate

ethcore/Cargo.toml

@@ -16,6 +16,7 @@ bloomchain = "0.1"
 bn = { git = "https://github.com/paritytech/bn" }
 byteorder = "1.0"
 clippy = { version = "0.0.103", optional = true}
+common-types = { path = "types" }
 crossbeam = "0.2.9"
 env_logger = "0.4"
 ethabi = "2.0"
@@ -31,7 +32,7 @@ ethcore-util = { path = "../util" }
 ethjson = { path = "../json" }
 ethkey = { path = "../ethkey" }
 ethstore = { path = "../ethstore" }
-evmjit = { path = "../evmjit", optional = true }
+evm = { path = "evm" }
 futures = "0.1"
 hardware-wallet = { path = "../hw" }
 hyper = { git = "https://github.com/paritytech/hyper", default-features = false }
@@ -52,14 +53,12 @@ semver = "0.6"
 stats = { path = "../util/stats" }
 time = "0.1"
 transient-hashmap = "0.4"
-parity-wasm = "0.12"
-wasm-utils = { git = "https://github.com/paritytech/wasm-utils" }
 
 [dev-dependencies]
 native-contracts = { path = "native_contracts", features = ["test_contracts"] }
 
 [features]
-jit = ["evmjit"]
+jit = ["evm/jit"]
 evm-debug = ["slow-blocks"]
 evm-debug-tests = ["evm-debug"]
 slow-blocks = [] # Use SLOW_TX_DURATION="50" (compile time!) to track transactions over 50ms

ethcore/build.rs

@@ -17,7 +17,6 @@
 extern crate ethcore_ipc_codegen;
 
 fn main() {
-	ethcore_ipc_codegen::derive_binary("src/types/mod.rs.in").unwrap();
 	ethcore_ipc_codegen::derive_ipc_cond("src/client/traits.rs", cfg!(feature="ipc")).unwrap();
 	ethcore_ipc_codegen::derive_ipc_cond("src/snapshot/snapshot_service_trait.rs", cfg!(feature="ipc")).unwrap();
 	ethcore_ipc_codegen::derive_ipc_cond("src/client/chain_notify.rs", cfg!(feature="ipc")).unwrap();

ethcore/evm/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "evm"
+version = "0.1.0"
+authors = ["Parity Technologies <[email protected]>"]
+
+[dependencies]
+bit-set = "0.4"
+byteorder = "1.0"
+common-types = { path = "../types" }
+ethcore-util = { path = "../../util" }
+evmjit = { path = "../../evmjit", optional = true }
+ethjson = { path = "../../json" }
+lazy_static = "0.2"
+log = "0.3"
+rlp = { path = "../../util/rlp" }
+parity-wasm = "0.12"
+wasm-utils = { git = "https://github.com/paritytech/wasm-utils" }
+
+[dev-dependencies]
+rustc-hex = "1.0"
+
+[features]
+jit = ["evmjit"]

ethcore/src/action_params.rs → ethcore/evm/src/action_params.rs

@@ -19,7 +19,8 @@ use util::{Address, Bytes, U256};
 use util::hash::{H256};
 use util::sha3::{Hashable, SHA3_EMPTY};
 use ethjson;
-use types::executed::CallType;
+
+use {CallType};
 
 use std::sync::Arc;
 

ethcore/src/evm/benches/mod.rs → ethcore/evm/src/benches/mod.rs

@@ -25,7 +25,7 @@ extern crate test;
 use self::test::{Bencher, black_box};
 
 use util::*;
-use action_params::ActionParams;
+use evm::action_params::ActionParams;
 use evm::{self, Factory, VMType};
 use evm::tests::FakeExt;
 

ethcore/evm/src/call_type.rs

@@ -0,0 +1,70 @@
+//! EVM call types.
+
+use rlp::{Encodable, Decodable, DecoderError, RlpStream, UntrustedRlp};
+
+/// The type of the call-like instruction.
+#[derive(Debug, PartialEq, Clone)]
+pub enum CallType {
+	/// Not a CALL.
+	None,
+	/// CALL.
+	Call,
+	/// CALLCODE.
+	CallCode,
+	/// DELEGATECALL.
+	DelegateCall,
+	/// STATICCALL
+	StaticCall,
+}
+
+impl Encodable for CallType {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		let v = match *self {
+			CallType::None => 0u32,
+			CallType::Call => 1,
+			CallType::CallCode => 2,
+			CallType::DelegateCall => 3,
+			CallType::StaticCall => 4,
+		};
+		Encodable::rlp_append(&v, s);
+	}
+}
+
+impl Decodable for CallType {
+	fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
+		rlp.as_val().and_then(|v| Ok(match v {
+			0u32 => CallType::None,
+			1 => CallType::Call,
+			2 => CallType::CallCode,
+			3 => CallType::DelegateCall,
+			4 => CallType::StaticCall,
+			_ => return Err(DecoderError::Custom("Invalid value of CallType item")),
+		}))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use rlp::*;
+	use super::CallType;
+
+	#[test]
+	fn encode_call_type() {
+		let ct = CallType::Call;
+
+		let mut s = RlpStream::new_list(2);
+		s.append(&ct);
+		assert!(!s.is_finished(), "List shouldn't finished yet");
+		s.append(&ct);
+		assert!(s.is_finished(), "List should be finished now");
+		s.out();
+	}
+
+	#[test]
+	fn should_encode_and_decode_call_type() {
+		let original = CallType::Call;
+		let encoded = encode(&original);
+		let decoded = decode(&encoded);
+		assert_eq!(original, decoded);
+	}
+}

ethcore/src/env_info.rs → ethcore/evm/src/env_info.rs

@@ -19,7 +19,7 @@
 use std::cmp;
 use std::sync::Arc;
 use util::{U256, Address, H256, Hashable};
-use header::BlockNumber;
+use types::BlockNumber;
 use ethjson;
 
 /// Simple vector of hashes, should be at most 256 items large, can be smaller if being used
@@ -82,7 +82,7 @@ mod tests {
 	use ethjson;
 
 	#[test]
-	fn it_serializes_form_json() {
+	fn it_serializes_from_json() {
 		let env_info = EnvInfo::from(ethjson::vm::Env {
 			author: ethjson::hash::Address(Address::from_str("000000f00000000f000000000000f00000000f00").unwrap()),
 			number: ethjson::uint::Uint(U256::from(1_112_339)),

ethcore/src/evm/evm.rs → ethcore/evm/src/evm.rs

@@ -19,8 +19,8 @@
 use std::{ops, cmp, fmt};
 use util::{U128, U256, U512, trie};
 use action_params::ActionParams;
-use evm::Ext;
-use builtin;
+use {Ext};
+
 use super::wasm;
 
 /// Evm errors.
@@ -77,12 +77,6 @@ impl From<Box<trie::TrieError>> for Error {
 	}
 }
 
-impl From<builtin::Error> for Error {
-	fn from(err: builtin::Error) -> Self {
-		Error::BuiltIn(err.0)
-	}
-}
-
 impl From<wasm::RuntimeError> for Error {
 	fn from(err: wasm::RuntimeError) -> Self {
 		Error::Wasm(format!("Runtime error: {:?}", err))
@@ -109,7 +103,6 @@ impl fmt::Display for Error {
 /// A specialized version of Result over EVM errors.
 pub type Result<T> = ::std::result::Result<T, Error>;
 
-
 /// Return data buffer. Holds memory from a previous call and a slice into that memory.
 #[derive(Debug)]
 pub struct ReturnData {

ethcore/src/evm/ext.rs → ethcore/evm/src/ext.rs

@@ -17,9 +17,10 @@
 //! Interface for Evm externalities.
 
 use util::*;
-use evm::{self, Schedule, ReturnData};
-use env_info::*;
-use types::executed::CallType;
+use call_type::CallType;
+use env_info::EnvInfo;
+use schedule::Schedule;
+use evm::{self, ReturnData};
 
 /// Result of externalities create function.
 pub enum ContractCreateResult {