merge with master

ethcore/src/evm/evm.rs

@@ -95,11 +95,17 @@ impl<'a> Finalize for Result<GasLeft<'a>> {
 	}
 }
 
+/// Cost calculation type. For low-gas usage we calculate costs using usize instead of U256
 pub trait CostType: ops::Mul<Output=Self> + ops::Div<Output=Self> + ops::Add<Output=Self> + ops::Sub<Output=Self> + ops::Shr<usize, Output=Self> + ops::Shl<usize, Output=Self> + cmp::Ord + Sized + From<usize> + Copy {
+	/// Converts this cost into `U256`
 	fn as_u256(&self) -> U256;
+	/// Tries to fit `U256` into this `Cost` type
 	fn from_u256(val: U256) -> Result<Self>;
+	/// Convert to usize (may panic)
 	fn as_usize(&self) -> usize;
+	/// Add with overflow
 	fn overflow_add(self, other: Self) -> (Self, bool);
+	/// Multiple with overflow
 	fn overflow_mul(self, other: Self) -> (Self, bool);
 }
 

ethcore/src/evm/interpreter/mod.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-///! Rust VM implementation
+//! Rust VM implementation
 
 #[cfg(not(feature = "evm-debug"))]
 macro_rules! evm_debug {
@@ -182,6 +182,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 				instruction: instruction
 			});
 		}
+
 		if info.tier == instructions::GasPriceTier::Invalid {
 			return Err(evm::Error::BadInstruction {
 				instruction: instruction

ethcore/src/lib.rs

@@ -119,18 +119,18 @@ pub mod engine;
 pub mod migrations;
 pub mod miner;
 pub mod snapshot;
+pub mod action_params;
+#[macro_use] pub mod evm;
 
 mod blooms;
 mod db;
 mod common;
 mod basic_types;
-#[macro_use] mod evm;
 mod env_info;
 mod pod_account;
 mod state;
 mod account;
 mod account_db;
-mod action_params;
 mod null_engine;
 mod builtin;
 mod substate;

evmbin/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "evm"
+description = "Parity's EVM implementation"
+version = "0.1.0"
+authors = ["Ethcore <admin@ethcore.io>"]
+
+[dependencies]
+rustc-serialize = "0.3"
+docopt = { version = "0.6" }
+ethcore = { path = "../ethcore" }
+ethcore-util = { path = "../util" }

evmbin/src/ext.rs

@@ -0,0 +1,107 @@
+// Copyright 2015, 2016 Ethcore (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/>.
+
+//! Externalities implementation.
+
+use std::collections::HashMap;
+use util::{U256, H256, Address, Bytes, FixedHash};
+use ethcore::client::EnvInfo;
+use ethcore::evm::{self, Ext, ContractCreateResult, MessageCallResult, Schedule};
+
+pub struct FakeExt {
+	schedule: Schedule,
+	store: HashMap<H256, H256>,
+}
+
+impl Default for FakeExt {
+	fn default() -> Self {
+		FakeExt {
+			schedule: Schedule::new_homestead(),
+			store: HashMap::new(),
+		}
+	}
+}
+
+impl Ext for FakeExt {
+	fn storage_at(&self, key: &H256) -> H256 {
+		self.store.get(key).unwrap_or(&H256::new()).clone()
+	}
+
+	fn set_storage(&mut self, key: H256, value: H256) {
+		self.store.insert(key, value);
+	}
+
+	fn exists(&self, _address: &Address) -> bool {
+		unimplemented!();
+	}
+
+	fn balance(&self, _address: &Address) -> U256 {
+		unimplemented!();
+	}
+
+	fn blockhash(&self, _number: &U256) -> H256 {
+		unimplemented!();
+	}
+
+	fn create(&mut self, _gas: &U256, _value: &U256, _code: &[u8]) -> ContractCreateResult {
+		unimplemented!();
+	}
+
+	fn call(&mut self,
+			_gas: &U256,
+			_sender_address: &Address,
+			_receive_address: &Address,
+			_value: Option<U256>,
+			_data: &[u8],
+			_code_address: &Address,
+			_output: &mut [u8]) -> MessageCallResult {
+		unimplemented!();
+	}
+
+	fn extcode(&self, _address: &Address) -> Bytes {
+		unimplemented!();
+	}
+
+	fn log(&mut self, _topics: Vec<H256>, _data: &[u8]) {
+		unimplemented!();
+	}
+
+	fn ret(self, gas: &U256, _data: &[u8]) -> evm::Result<U256> {
+		Ok(*gas)
+	}
+
+	fn suicide(&mut self, _refund_address: &Address) {
+		unimplemented!();
+	}
+
+	fn schedule(&self) -> &Schedule {
+		&self.schedule
+	}
+
+	fn env_info(&self) -> &EnvInfo {
+		unimplemented!()
+	}
+
+	fn depth(&self) -> usize {
+		unimplemented!();
+		// self.depth
+	}
+
+	fn inc_sstore_clears(&mut self) {
+		unimplemented!();
+		// self.sstore_clears += 1;
+	}
+}

evmbin/src/main.rs

@@ -0,0 +1,108 @@
+// Copyright 2015, 2016 Ethcore (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/>.
+
+//! Parity EVM interpreter binary.
+
+#![warn(missing_docs)]
+extern crate ethcore;
+extern crate rustc_serialize;
+extern crate docopt;
+#[macro_use]
+extern crate ethcore_util as util;
+
+mod ext;
+
+use std::time::Instant;
+use std::str::FromStr;
+use docopt::Docopt;
+use util::{U256, FromHex, Uint, Bytes};
+use ethcore::evm::{Factory, VMType, Finalize};
+use ethcore::action_params::ActionParams;
+
+const USAGE: &'static str = r#"
+EVM implementation for Parity.
+  Copyright 2016 Ethcore (UK) Limited
+
+Usage:
+    evmbin stats [options]
+    evmbin [-h | --help]
+
+Transaction options:
+    --code CODE        Contract code.
+    --input DATA       Input data.
+    --gas GAS          Supplied gas.
+
+General options:
+    -h, --help         Display this message and exit.
+"#;
+
+
+fn main() {
+	let args: Args = Docopt::new(USAGE).and_then(|d| d.decode()).unwrap_or_else(|e| e.exit());
+
+	let mut params = ActionParams::default();
+	params.gas = args.gas();
+	params.code = Some(args.code());
+	params.data = args.data();
+
+	let factory = Factory::new(VMType::Interpreter);
+	let mut vm = factory.create(params.gas);
+	let mut ext = ext::FakeExt::default();
+
+	let start = Instant::now();
+	let gas_left = vm.exec(params, &mut ext).finalize(ext).expect("OK");
+	let duration = start.elapsed();
+
+	println!("Gas used: {:?}", args.gas() - gas_left);
+	println!("Output: {:?}", "");
+	println!("Time: {}.{:.9}s", duration.as_secs(), duration.subsec_nanos());
+}
+
+#[derive(Debug, RustcDecodable)]
+struct Args {
+	cmd_stats: bool,
+	flag_code: Option<String>,
+	flag_gas: Option<String>,
+	flag_input: Option<String>,
+}
+
+impl Args {
+	pub fn gas(&self) -> U256 {
+		self.flag_gas
+			.clone()
+			.and_then(|g| U256::from_str(&g).ok())
+			.unwrap_or_else(|| !U256::zero())
+	}
+
+	pub fn code(&self) -> Bytes {
+		self.flag_code
+			.clone()
+			.and_then(|c| c.from_hex().ok())
+			.unwrap_or_else(|| die("Code is required."))
+	}
+
+	pub fn data(&self) -> Option<Bytes> {
+		self.flag_input
+			.clone()
+			.and_then(|d| d.from_hex().ok())
+	}
+}
+
+
+fn die(msg: &'static str) -> ! {
+	println!("{}", msg);
+	::std::process::exit(-1)
+}