Decouple virtual machines (#6184)

* work in progress for splitting vms

* evm working

* Evm -> Vm

* wasm converted

* ethcore working

* test fixes

ethcore/vm/src/action_params.rs

@@ -0,0 +1,121 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Evm input params.
+use util::{Address, Bytes, U256};
+use util::hash::{H256};
+use util::sha3::{Hashable, SHA3_EMPTY};
+use ethjson;
+
+use call_type::CallType;
+
+use std::sync::Arc;
+
+/// Transaction value
+#[derive(Clone, Debug)]
+pub enum ActionValue {
+	/// Value that should be transfered
+	Transfer(U256),
+	/// Apparent value for transaction (not transfered)
+	Apparent(U256)
+}
+
+impl ActionValue {
+	/// Returns action value as U256.
+	pub fn value(&self) -> U256 {
+		match *self {
+			ActionValue::Transfer(x) | ActionValue::Apparent(x) => x
+		}
+	}
+
+	/// Returns the transfer action value of the U256-convertable raw value
+	pub fn transfer<T: Into<U256>>(transfer_value: T) -> ActionValue {
+		ActionValue::Transfer(transfer_value.into())
+	}
+
+	/// Returns the apparent action value of the U256-convertable raw value
+	pub fn apparent<T: Into<U256>>(apparent_value: T) -> ActionValue {
+		ActionValue::Apparent(apparent_value.into())
+	}
+}
+
+// TODO: should be a trait, possible to avoid cloning everything from a Transaction(/View).
+/// Action (call/create) input params. Everything else should be specified in Externalities.
+#[derive(Clone, Debug)]
+pub struct ActionParams {
+	/// Address of currently executed code.
+	pub code_address: Address,
+	/// Hash of currently executed code.
+	pub code_hash: Option<H256>,
+	/// Receive address. Usually equal to code_address,
+	/// except when called using CALLCODE.
+	pub address: Address,
+	/// Sender of current part of the transaction.
+	pub sender: Address,
+	/// Transaction initiator.
+	pub origin: Address,
+	/// Gas paid up front for transaction execution
+	pub gas: U256,
+	/// Gas price.
+	pub gas_price: U256,
+	/// Transaction value.
+	pub value: ActionValue,
+	/// Code being executed.
+	pub code: Option<Arc<Bytes>>,
+	/// Input data.
+	pub data: Option<Bytes>,
+	/// Type of call
+	pub call_type: CallType,
+
+}
+
+impl Default for ActionParams {
+	/// Returns default ActionParams initialized with zeros
+	fn default() -> ActionParams {
+		ActionParams {
+			code_address: Address::new(),
+			code_hash: Some(SHA3_EMPTY),
+			address: Address::new(),
+			sender: Address::new(),
+			origin: Address::new(),
+			gas: U256::zero(),
+			gas_price: U256::zero(),
+			value: ActionValue::Transfer(U256::zero()),
+			code: None,
+			data: None,
+			call_type: CallType::None,
+		}
+	}
+}
+
+impl From<ethjson::vm::Transaction> for ActionParams {
+	fn from(t: ethjson::vm::Transaction) -> Self {
+		let address: Address = t.address.into();
+		ActionParams {
+			code_address: Address::new(),
+			code_hash: Some((&*t.code).sha3()),
+			address: address,
+			sender: t.sender.into(),
+			origin: t.origin.into(),
+			code: Some(Arc::new(t.code.into())),
+			data: Some(t.data.into()),
+			gas: t.gas.into(),
+			gas_price: t.gas_price.into(),
+			value: ActionValue::Transfer(t.value.into()),
+			call_type: match address.is_zero() { true => CallType::None, false => CallType::Call },	// TODO @debris is this correct?
+		}
+	}
+}

ethcore/vm/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/vm/src/env_info.rs

@@ -0,0 +1,107 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Environment information for transaction execution.
+
+use std::cmp;
+use std::sync::Arc;
+use util::{U256, Address, H256, Hashable};
+use types::BlockNumber;
+use ethjson;
+
+/// Simple vector of hashes, should be at most 256 items large, can be smaller if being used
+/// for a block whose number is less than 257.
+pub type LastHashes = Vec<H256>;
+
+/// Information concerning the execution environment for a message-call/contract-creation.
+#[derive(Debug, Clone)]
+pub struct EnvInfo {
+	/// The block number.
+	pub number: BlockNumber,
+	/// The block author.
+	pub author: Address,
+	/// The block timestamp.
+	pub timestamp: u64,
+	/// The block difficulty.
+	pub difficulty: U256,
+	/// The block gas limit.
+	pub gas_limit: U256,
+	/// The last 256 block hashes.
+	pub last_hashes: Arc<LastHashes>,
+	/// The gas used.
+	pub gas_used: U256,
+}
+
+impl Default for EnvInfo {
+	fn default() -> Self {
+		EnvInfo {
+			number: 0,
+			author: Address::default(),
+			timestamp: 0,
+			difficulty: 0.into(),
+			gas_limit: 0.into(),
+			last_hashes: Arc::new(vec![]),
+			gas_used: 0.into(),
+		}
+	}
+}
+
+impl From<ethjson::vm::Env> for EnvInfo {
+	fn from(e: ethjson::vm::Env) -> Self {
+		let number = e.number.into();
+		EnvInfo {
+			number: number,
+			author: e.author.into(),
+			difficulty: e.difficulty.into(),
+			gas_limit: e.gas_limit.into(),
+			timestamp: e.timestamp.into(),
+			last_hashes: Arc::new((1..cmp::min(number + 1, 257)).map(|i| format!("{}", number - i).as_bytes().sha3()).collect()),
+			gas_used: U256::default(),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use super::*;
+	use util::{U256, Address};
+	use ethjson;
+
+	#[test]
+	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)),
+			difficulty: ethjson::uint::Uint(U256::from(50_000)),
+			gas_limit: ethjson::uint::Uint(U256::from(40_000)),
+			timestamp: ethjson::uint::Uint(U256::from(1_100))
+		});
+
+		assert_eq!(env_info.number, 1112339);
+		assert_eq!(env_info.author, Address::from_str("000000f00000000f000000000000f00000000f00").unwrap());
+		assert_eq!(env_info.gas_limit, 40000.into());
+		assert_eq!(env_info.difficulty, 50000.into());
+		assert_eq!(env_info.gas_used, 0.into());
+	}
+
+	#[test]
+	fn it_can_be_created_as_default() {
+		let default_env_info = EnvInfo::default();
+
+		assert_eq!(default_env_info.difficulty, 0.into());
+	}
+}

ethcore/vm/src/error.rs

@@ -0,0 +1,100 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! VM errors module
+
+use util::trie;
+use std::fmt;
+
+/// VM errors.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Error {
+	/// `OutOfGas` is returned when transaction execution runs out of gas.
+	/// The state should be reverted to the state from before the
+	/// transaction execution. But it does not mean that transaction
+	/// was invalid. Balance still should be transfered and nonce
+	/// should be increased.
+	OutOfGas,
+	/// `BadJumpDestination` is returned when execution tried to move
+	/// to position that wasn't marked with JUMPDEST instruction
+	BadJumpDestination {
+		/// Position the code tried to jump to.
+		destination: usize
+	},
+	/// `BadInstructions` is returned when given instruction is not supported
+	BadInstruction {
+		/// Unrecognized opcode
+		instruction: u8,
+	},
+	/// `StackUnderflow` when there is not enough stack elements to execute instruction
+	StackUnderflow {
+		/// Invoked instruction
+		instruction: &'static str,
+		/// How many stack elements was requested by instruction
+		wanted: usize,
+		/// How many elements were on stack
+		on_stack: usize
+	},
+	/// When execution would exceed defined Stack Limit
+	OutOfStack {
+		/// Invoked instruction
+		instruction: &'static str,
+		/// How many stack elements instruction wanted to push
+		wanted: usize,
+		/// What was the stack limit
+		limit: usize
+	},
+	/// Built-in contract failed on given input
+	BuiltIn(&'static str),
+	/// When execution tries to modify the state in static context
+	MutableCallInStaticContext,
+	/// Likely to cause consensus issues.
+	Internal(String),
+	/// Wasm runtime error
+	Wasm(String),
+}
+
+
+impl From<Box<trie::TrieError>> for Error {
+	fn from(err: Box<trie::TrieError>) -> Self {
+		Error::Internal(format!("Internal error: {}", err))
+	}
+}
+
+// impl From<wasm::RuntimeError> for Error {
+// 	fn from(err: wasm::RuntimeError) -> Self {
+// 		Error::Wasm(format!("Runtime error: {:?}", err))
+// 	}
+// }
+
+impl fmt::Display for Error {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		use self::Error::*;
+		match *self {
+			OutOfGas => write!(f, "Out of gas"),
+			BadJumpDestination { destination } => write!(f, "Bad jump destination {:x}", destination),
+			BadInstruction { instruction } => write!(f, "Bad instruction {:x}",  instruction),
+			StackUnderflow { instruction, wanted, on_stack } => write!(f, "Stack underflow {} {}/{}", instruction, wanted, on_stack),
+			OutOfStack { instruction, wanted, limit } => write!(f, "Out of stack {} {}/{}", instruction, wanted, limit),
+			BuiltIn(name) => write!(f, "Built-in failed: {}", name),
+			Internal(ref msg) => write!(f, "Internal error: {}", msg),
+			MutableCallInStaticContext => write!(f, "Mutable call in static context"),
+			Wasm(ref msg) => write!(f, "Internal error: {}", msg),
+		}
+	}
+}
+
+pub type Result<T> = ::std::result::Result<T, Error>;

ethcore/vm/src/ext.rs

@@ -0,0 +1,142 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Interface for Evm externalities.
+
+use util::*;
+use call_type::CallType;
+use env_info::EnvInfo;
+use schedule::Schedule;
+use return_data::ReturnData;
+use error::Result;
+
+/// Result of externalities create function.
+pub enum ContractCreateResult {
+	/// Returned when creation was successfull.
+	/// Contains an address of newly created contract and gas left.
+	Created(Address, U256),
+	/// Returned when contract creation failed.
+	/// VM doesn't have to know the reason.
+	Failed
+}
+
+/// Result of externalities call function.
+pub enum MessageCallResult {
+	/// Returned when message call was successfull.
+	/// Contains gas left and output data.
+	Success(U256, ReturnData),
+	/// Returned when message call failed.
+	/// VM doesn't have to know the reason.
+	Failed
+}
+
+/// Specifies how an address is calculated for a new contract.
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum CreateContractAddress {
+	/// Address is calculated from nonce and sender. Pre EIP-86 (Metropolis)
+	FromSenderAndNonce,
+	/// Address is calculated from code hash. Default since EIP-86
+	FromCodeHash,
+	/// Address is calculated from code hash and sender. Used by CREATE_P2SH instruction.
+	FromSenderAndCodeHash,
+}
+
+/// Externalities interface for EVMs
+pub trait Ext {
+	/// Returns a value for given key.
+	fn storage_at(&self, key: &H256) -> Result<H256>;
+
+	/// Stores a value for given key.
+	fn set_storage(&mut self, key: H256, value: H256) -> Result<()>;
+
+	/// Determine whether an account exists.
+	fn exists(&self, address: &Address) -> Result<bool>;
+
+	/// Determine whether an account exists and is not null (zero balance/nonce, no code).
+	fn exists_and_not_null(&self, address: &Address) -> Result<bool>;
+
+	/// Balance of the origin account.
+	fn origin_balance(&self) -> Result<U256>;
+
+	/// Returns address balance.
+	fn balance(&self, address: &Address) -> Result<U256>;
+
+	/// Returns the hash of one of the 256 most recent complete blocks.
+	fn blockhash(&mut self, number: &U256) -> H256;
+
+	/// Creates new contract.
+	///
+	/// Returns gas_left and contract address if contract creation was succesfull.
+	fn create(&mut self, gas: &U256, value: &U256, code: &[u8], address: CreateContractAddress) -> ContractCreateResult;
+
+	/// Message call.
+	///
+	/// Returns Err, if we run out of gas.
+	/// Otherwise returns call_result which contains gas left
+	/// and true if subcall was successfull.
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
+	fn call(&mut self,
+		gas: &U256,
+		sender_address: &Address,
+		receive_address: &Address,
+		value: Option<U256>,
+		data: &[u8],
+		code_address: &Address,
+		output: &mut [u8],
+		call_type: CallType
+	) -> MessageCallResult;
+
+	/// Returns code at given address
+	fn extcode(&self, address: &Address) -> Result<Arc<Bytes>>;
+
+	/// Returns code size at given address
+	fn extcodesize(&self, address: &Address) -> Result<usize>;
+
+	/// Creates log entry with given topics and data
+	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> Result<()>;
+
+	/// Should be called when transaction calls `RETURN` opcode.
+	/// Returns gas_left if cost of returning the data is not too high.
+	fn ret(self, gas: &U256, data: &ReturnData) -> Result<U256>;
+
+	/// Should be called when contract commits suicide.
+	/// Address to which funds should be refunded.
+	fn suicide(&mut self, refund_address: &Address) -> Result<()> ;
+
+	/// Returns schedule.
+	fn schedule(&self) -> &Schedule;
+
+	/// Returns environment info.
+	fn env_info(&self) -> &EnvInfo;
+
+	/// Returns current depth of execution.
+	///
+	/// If contract A calls contract B, and contract B calls C,
+	/// then A depth is 0, B is 1, C is 2 and so on.
+	fn depth(&self) -> usize;
+
+	/// Increments sstore refunds count by 1.
+	fn inc_sstore_clears(&mut self);
+
+	/// Decide if any more operations should be traced. Passthrough for the VM trace.
+	fn trace_next_instruction(&mut self, _pc: usize, _instruction: u8) -> bool { false }
+
+	/// Prepare to trace an operation. Passthrough for the VM trace.
+	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: U256) {}
+
+	/// Trace the finalised execution of a single instruction.
+	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem_diff: Option<(usize, &[u8])>, _store_diff: Option<(U256, U256)>) {}
+}

ethcore/vm/src/lib.rs

@@ -0,0 +1,46 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Virtual machines support library
+
+extern crate ethcore_util as util;
+extern crate common_types as types;
+extern crate ethjson;
+extern crate rlp;
+
+mod action_params;
+mod call_type;
+mod env_info;
+mod schedule;
+mod ext;
+mod return_data;
+mod error;
+
+pub use action_params::{ActionParams, ActionValue};
+pub use call_type::CallType;
+pub use env_info::{EnvInfo, LastHashes};
+pub use schedule::{Schedule, CleanDustMode};
+pub use ext::{Ext, MessageCallResult, ContractCreateResult, CreateContractAddress};
+pub use return_data::{ReturnData, GasLeft};
+pub use error::{Error, Result};
+
+/// Virtual Machine interface
+pub trait Vm {
+	/// This function should be used to execute transaction.
+	/// It returns either an error, a known amount of gas left, or parameters to be used
+	/// to compute the final gas left.
+	fn exec(&mut self, params: ActionParams, ext: &mut Ext) -> Result<GasLeft>;
+}

ethcore/vm/src/return_data.rs

@@ -0,0 +1,68 @@
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Return data structures
+
+use util::U256;
+
+/// Return data buffer. Holds memory from a previous call and a slice into that memory.
+#[derive(Debug)]
+pub struct ReturnData {
+	mem: Vec<u8>,
+	offset: usize,
+	size: usize,
+}
+
+impl ::std::ops::Deref for ReturnData {
+	type Target = [u8];
+	fn deref(&self) -> &[u8] {
+		&self.mem[self.offset..self.offset + self.size]
+	}
+}
+
+impl ReturnData {
+	/// Create empty `ReturnData`.
+	pub fn empty() -> Self {
+		ReturnData {
+			mem: Vec::new(),
+			offset: 0,
+			size: 0,
+		}
+	}
+	/// Create `ReturnData` from give buffer and slice.
+	pub fn new(mem: Vec<u8>, offset: usize, size: usize) -> Self {
+		ReturnData {
+			mem: mem,
+			offset: offset,
+			size: size,
+		}
+	}
+}
+
+/// Gas Left: either it is a known value, or it needs to be computed by processing
+/// a return instruction.
+#[derive(Debug)]
+pub enum GasLeft {
+	/// Known gas left
+	Known(U256),
+	/// Return or Revert instruction must be processed.
+	NeedsReturn {
+		/// Amount of gas left.
+		gas_left: U256,
+		/// Return data buffer.
+		data: ReturnData,
+		/// Apply or revert state changes on revert.
+		apply_state: bool
+	},
+}

ethcore/vm/src/schedule.rs

@@ -0,0 +1,269 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Cost schedule and other parameterisations for the EVM.
+
+/// Definition of the cost schedule and other parameterisations for the EVM.
+pub struct Schedule {
+	/// Does it support exceptional failed code deposit
+	pub exceptional_failed_code_deposit: bool,
+	/// Does it have a delegate cal
+	pub have_delegate_call: bool,
+	/// Does it have a CREATE_P2SH instruction
+	pub have_create2: bool,
+	/// Does it have a REVERT instruction
+	pub have_revert: bool,
+	/// VM stack limit
+	pub stack_limit: usize,
+	/// Max number of nested calls/creates
+	pub max_depth: usize,
+	/// Gas prices for instructions in all tiers
+	pub tier_step_gas: [usize; 8],
+	/// Gas price for `EXP` opcode
+	pub exp_gas: usize,
+	/// Additional gas for `EXP` opcode for each byte of exponent
+	pub exp_byte_gas: usize,
+	/// Gas price for `SHA3` opcode
+	pub sha3_gas: usize,
+	/// Additional gas for `SHA3` opcode for each word of hashed memory
+	pub sha3_word_gas: usize,
+	/// Gas price for loading from storage
+	pub sload_gas: usize,
+	/// Gas price for setting new value to storage (`storage==0`, `new!=0`)
+	pub sstore_set_gas: usize,
+	/// Gas price for altering value in storage
+	pub sstore_reset_gas: usize,
+	/// Gas refund for `SSTORE` clearing (when `storage!=0`, `new==0`)
+	pub sstore_refund_gas: usize,
+	/// Gas price for `JUMPDEST` opcode
+	pub jumpdest_gas: usize,
+	/// Gas price for `LOG*`
+	pub log_gas: usize,
+	/// Additional gas for data in `LOG*`
+	pub log_data_gas: usize,
+	/// Additional gas for each topic in `LOG*`
+	pub log_topic_gas: usize,
+	/// Gas price for `CREATE` opcode
+	pub create_gas: usize,
+	/// Gas price for `*CALL*` opcodes
+	pub call_gas: usize,
+	/// Stipend for transfer for `CALL|CALLCODE` opcode when `value>0`
+	pub call_stipend: usize,
+	/// Additional gas required for value transfer (`CALL|CALLCODE`)
+	pub call_value_transfer_gas: usize,
+	/// Additional gas for creating new account (`CALL|CALLCODE`)
+	pub call_new_account_gas: usize,
+	/// Refund for SUICIDE
+	pub suicide_refund_gas: usize,
+	/// Gas for used memory
+	pub memory_gas: usize,
+	/// Coefficient used to convert memory size to gas price for memory
+	pub quad_coeff_div: usize,
+	/// Cost for contract length when executing `CREATE`
+	pub create_data_gas: usize,
+	/// Maximum code size when creating a contract.
+	pub create_data_limit: usize,
+	/// Transaction cost
+	pub tx_gas: usize,
+	/// `CREATE` transaction cost
+	pub tx_create_gas: usize,
+	/// Additional cost for empty data transaction
+	pub tx_data_zero_gas: usize,
+	/// Aditional cost for non-empty data transaction
+	pub tx_data_non_zero_gas: usize,
+	/// Gas price for copying memory
+	pub copy_gas: usize,
+	/// Price of EXTCODESIZE
+	pub extcodesize_gas: usize,
+	/// Base price of EXTCODECOPY
+	pub extcodecopy_base_gas: usize,
+	/// Price of BALANCE
+	pub balance_gas: usize,
+	/// Price of SUICIDE
+	pub suicide_gas: usize,
+	/// Amount of additional gas to pay when SUICIDE credits a non-existant account
+	pub suicide_to_new_account_cost: usize,
+	/// If Some(x): let limit = GAS * (x - 1) / x; let CALL's gas = min(requested, limit). let CREATE's gas = limit.
+	/// If None: let CALL's gas = (requested > GAS ? [OOG] : GAS). let CREATE's gas = GAS
+	pub sub_gas_cap_divisor: Option<usize>,
+	/// Don't ever make empty accounts; contracts start with nonce=1. Also, don't charge 25k when sending/suicide zero-value.
+	pub no_empty: bool,
+	/// Kill empty accounts if touched.
+	pub kill_empty: bool,
+	/// Blockhash instruction gas cost.
+	pub blockhash_gas: usize,
+	/// Static Call opcode enabled.
+	pub have_static_call: bool,
+	/// RETURNDATA and RETURNDATASIZE opcodes enabled.
+	pub have_return_data: bool,
+	/// Kill basic accounts below this balance if touched.
+	pub kill_dust: CleanDustMode,
+}
+
+/// Dust accounts cleanup mode.
+#[derive(PartialEq, Eq)]
+pub enum CleanDustMode {
+	/// Dust cleanup is disabled.
+	Off,
+	/// Basic dust accounts will be removed.
+	BasicOnly,
+	/// Basic and contract dust accounts will be removed.
+	WithCodeAndStorage,
+}
+
+impl Schedule {
+	/// Schedule for the Frontier-era of the Ethereum main net.
+	pub fn new_frontier() -> Schedule {
+		Self::new(false, false, 21000)
+	}
+
+	/// Schedule for the Homestead-era of the Ethereum main net.
+	pub fn new_homestead() -> Schedule {
+		Self::new(true, true, 53000)
+	}
+
+	/// Schedule for the post-EIP-150-era of the Ethereum main net.
+	pub fn new_post_eip150(max_code_size: usize, fix_exp: bool, no_empty: bool, kill_empty: bool) -> Schedule {
+		Schedule {
+			exceptional_failed_code_deposit: true,
+			have_delegate_call: true,
+			have_create2: false,
+			have_revert: false,
+			have_return_data: false,
+			stack_limit: 1024,
+			max_depth: 1024,
+			tier_step_gas: [0, 2, 3, 5, 8, 10, 20, 0],
+			exp_gas: 10,
+			exp_byte_gas: if fix_exp {50} else {10},
+			sha3_gas: 30,
+			sha3_word_gas: 6,
+			sload_gas: 200,
+			sstore_set_gas: 20000,
+			sstore_reset_gas: 5000,
+			sstore_refund_gas: 15000,
+			jumpdest_gas: 1,
+			log_gas: 375,
+			log_data_gas: 8,
+			log_topic_gas: 375,
+			create_gas: 32000,
+			call_gas: 700,
+			call_stipend: 2300,
+			call_value_transfer_gas: 9000,
+			call_new_account_gas: 25000,
+			suicide_refund_gas: 24000,
+			memory_gas: 3,
+			quad_coeff_div: 512,
+			create_data_gas: 200,
+			create_data_limit: max_code_size,
+			tx_gas: 21000,
+			tx_create_gas: 53000,
+			tx_data_zero_gas: 4,
+			tx_data_non_zero_gas: 68,
+			copy_gas: 3,
+			extcodesize_gas: 700,
+			extcodecopy_base_gas: 700,
+			balance_gas: 400,
+			suicide_gas: 5000,
+			suicide_to_new_account_cost: 25000,
+			sub_gas_cap_divisor: Some(64),
+			no_empty: no_empty,
+			kill_empty: kill_empty,
+			blockhash_gas: 20,
+			have_static_call: false,
+			kill_dust: CleanDustMode::Off,
+		}
+	}
+
+	/// Schedule for the Metropolis of the Ethereum main net.
+	pub fn new_metropolis() -> Schedule {
+		let mut schedule = Self::new_post_eip150(24576, true, true, true);
+		schedule.have_create2 = true;
+		schedule.have_revert = true;
+		schedule.have_static_call = true;
+		schedule.have_return_data = true;
+		schedule.blockhash_gas = 350;
+		schedule
+	}
+
+	fn new(efcd: bool, hdc: bool, tcg: usize) -> Schedule {
+		Schedule {
+			exceptional_failed_code_deposit: efcd,
+			have_delegate_call: hdc,
+			have_create2: false,
+			have_revert: false,
+			have_return_data: false,
+			stack_limit: 1024,
+			max_depth: 1024,
+			tier_step_gas: [0, 2, 3, 5, 8, 10, 20, 0],
+			exp_gas: 10,
+			exp_byte_gas: 10,
+			sha3_gas: 30,
+			sha3_word_gas: 6,
+			sload_gas: 50,
+			sstore_set_gas: 20000,
+			sstore_reset_gas: 5000,
+			sstore_refund_gas: 15000,
+			jumpdest_gas: 1,
+			log_gas: 375,
+			log_data_gas: 8,
+			log_topic_gas: 375,
+			create_gas: 32000,
+			call_gas: 40,
+			call_stipend: 2300,
+			call_value_transfer_gas: 9000,
+			call_new_account_gas: 25000,
+			suicide_refund_gas: 24000,
+			memory_gas: 3,
+			quad_coeff_div: 512,
+			create_data_gas: 200,
+			create_data_limit: usize::max_value(),
+			tx_gas: 21000,
+			tx_create_gas: tcg,
+			tx_data_zero_gas: 4,
+			tx_data_non_zero_gas: 68,
+			copy_gas: 3,
+			extcodesize_gas: 20,
+			extcodecopy_base_gas: 20,
+			balance_gas: 20,
+			suicide_gas: 0,
+			suicide_to_new_account_cost: 0,
+			sub_gas_cap_divisor: None,
+			no_empty: false,
+			kill_empty: false,
+			blockhash_gas: 20,
+			have_static_call: false,
+			kill_dust: CleanDustMode::Off,
+		}
+	}
+}
+
+impl Default for Schedule {
+	fn default() -> Self {
+		Schedule::new_frontier()
+	}
+}
+
+#[test]
+#[cfg(test)]
+fn schedule_evm_assumptions() {
+	let s1 = Schedule::new_frontier();
+	let s2 = Schedule::new_homestead();
+
+	// To optimize division we assume 2**9 for quad_coeff_div
+	assert_eq!(s1.quad_coeff_div, 512);
+	assert_eq!(s2.quad_coeff_div, 512);
+}
+