Decouple virtual machines (#6184)

* work in progress for splitting vms

* evm working

* Evm -> Vm

* wasm converted

* ethcore working

* test fixes

ethcore/src/externalities.rs

@@ -16,13 +16,14 @@
 
 //! Transaction Execution environment.
 use util::*;
-use evm::action_params::{ActionParams, ActionValue};
 use state::{Backend as StateBackend, State, Substate, CleanupMode};
 use engines::Engine;
-use evm::env_info::EnvInfo;
 use executive::*;
-use evm::{self, Schedule, Ext, ContractCreateResult, MessageCallResult, CreateContractAddress, ReturnData};
-use evm::CallType;
+use vm::{
+	self, ActionParams, ActionValue, EnvInfo, CallType, Schedule,
+	Ext, ContractCreateResult, MessageCallResult, CreateContractAddress,
+	ReturnData
+};
 use transaction::UNSIGNED_SENDER;
 use trace::{Tracer, VMTracer};
 
@@ -109,31 +110,31 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Externalities<'a, T, V, B, E>
 impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 	where T: Tracer, V: VMTracer, B: StateBackend, E: Engine + ?Sized
 {
-	fn storage_at(&self, key: &H256) -> evm::Result<H256> {
+	fn storage_at(&self, key: &H256) -> vm::Result<H256> {
 		self.state.storage_at(&self.origin_info.address, key).map_err(Into::into)
 	}
 
-	fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()> {
+	fn set_storage(&mut self, key: H256, value: H256) -> vm::Result<()> {
 		if self.static_flag {
-			Err(evm::Error::MutableCallInStaticContext)
+			Err(vm::Error::MutableCallInStaticContext)
 		} else {
 			self.state.set_storage(&self.origin_info.address, key, value).map_err(Into::into)
 		}
 	}
 
-	fn exists(&self, address: &Address) -> evm::Result<bool> {
+	fn exists(&self, address: &Address) -> vm::Result<bool> {
 		self.state.exists(address).map_err(Into::into)
 	}
 
-	fn exists_and_not_null(&self, address: &Address) -> evm::Result<bool> {
+	fn exists_and_not_null(&self, address: &Address) -> vm::Result<bool> {
 		self.state.exists_and_not_null(address).map_err(Into::into)
 	}
 
-	fn origin_balance(&self) -> evm::Result<U256> {
+	fn origin_balance(&self) -> vm::Result<U256> {
 		self.balance(&self.origin_info.address).map_err(Into::into)
 	}
 
-	fn balance(&self, address: &Address) -> evm::Result<U256> {
+	fn balance(&self, address: &Address) -> vm::Result<U256> {
 		self.state.balance(address).map_err(Into::into)
 	}
 
@@ -274,16 +275,16 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 		}
 	}
 
-	fn extcode(&self, address: &Address) -> evm::Result<Arc<Bytes>> {
+	fn extcode(&self, address: &Address) -> vm::Result<Arc<Bytes>> {
 		Ok(self.state.code(address)?.unwrap_or_else(|| Arc::new(vec![])))
 	}
 
-	fn extcodesize(&self, address: &Address) -> evm::Result<usize> {
+	fn extcodesize(&self, address: &Address) -> vm::Result<usize> {
 		Ok(self.state.code_size(address)?.unwrap_or(0))
 	}
 
 	#[cfg_attr(feature="dev", allow(match_ref_pats))]
-	fn ret(mut self, gas: &U256, data: &ReturnData) -> evm::Result<U256>
+	fn ret(mut self, gas: &U256, data: &ReturnData) -> vm::Result<U256>
 		where Self: Sized {
 		let handle_copy = |to: &mut Option<&mut Bytes>| {
 			to.as_mut().map(|b| **b = data.to_vec());
@@ -307,7 +308,7 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 				let return_cost = U256::from(data.len()) * U256::from(self.schedule.create_data_gas);
 				if return_cost > *gas || data.len() > self.schedule.create_data_limit {
 					return match self.schedule.exceptional_failed_code_deposit {
-						true => Err(evm::Error::OutOfGas),
+						true => Err(vm::Error::OutOfGas),
 						false => Ok(*gas)
 					}
 				}
@@ -320,11 +321,11 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 		}
 	}
 
-	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> evm::Result<()> {
+	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> vm::Result<()> {
 		use log_entry::LogEntry;
 
 		if self.static_flag {
-			return Err(evm::Error::MutableCallInStaticContext);
+			return Err(vm::Error::MutableCallInStaticContext);
 		}
 
 		let address = self.origin_info.address.clone();
@@ -337,9 +338,9 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 		Ok(())
 	}
 
-	fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> {
+	fn suicide(&mut self, refund_address: &Address) -> vm::Result<()> {
 		if self.static_flag {
-			return Err(evm::Error::MutableCallInStaticContext);
+			return Err(vm::Error::MutableCallInStaticContext);
 		}
 
 		let address = self.origin_info.address.clone();
@@ -396,13 +397,11 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 mod tests {
 	use util::*;
 	use engines::Engine;
-	use evm::env_info::EnvInfo;
-	use evm::Ext;
+	use evm::{EnvInfo, Ext, CallType};
 	use state::{State, Substate};
 	use tests::helpers::*;
 	use super::*;
 	use trace::{NoopTracer, NoopVMTracer};
-	use evm::CallType;
 
 	fn get_test_origin() -> OriginInfo {
 		OriginInfo {