Very basic EVM binary. (#1574)

* EVM binary - initial version

* Adding missing documentation

* Fixing warnings

* Basic evmbin options

* EVMbin crate.

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)
+}