Add a optional json dump state to evm-bin

ethcore/Cargo.toml

@@ -67,6 +67,8 @@ unexpected = { path = "../util/unexpected" }
 journaldb = { path = "../util/journaldb" }
 keccak-hasher = { path = "../util/keccak-hasher" }
 kvdb-rocksdb = "0.1.3"
+serde = "1.0"
+serde_derive = "1.0"
 tempdir = {version="0.3", optional = true}
 
 [target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "windows", target_os = "android"))'.dependencies]

ethcore/src/client/evm_test_client.rs

@@ -223,9 +223,15 @@ impl<'a> EvmTestClient<'a> {
 			return TransactResult::Err {
 				state_root: *self.state.root(),
 				error: error.into(),
+				end_state: if vm_tracer.dump_end_state() {
+					Some(self.state.to_pod())
+				} else {
+					None
+				},
 			};
 		}
 
+		let do_dump_state = vm_tracer.dump_end_state();
 		// Apply transaction
 		let result = self.state.apply_with_tracing(&env_info, self.spec.engine.machine(), &transaction, tracer, vm_tracer);
 		let scheme = self.spec.engine.machine().create_address_scheme(env_info.number);
@@ -249,6 +255,12 @@ impl<'a> EvmTestClient<'a> {
 		).ok();
 		self.state.commit().ok();
 
+		let end_state = if do_dump_state {
+			Some(self.state.to_pod())
+		} else {
+			None
+		};
+
 		match result {
 			Ok(result) => {
 				TransactResult::Ok {
@@ -263,12 +275,14 @@ impl<'a> EvmTestClient<'a> {
 						Some(executive::contract_address(scheme, &transaction.sender(), &transaction.nonce, &transaction.data).0)
 					} else {
 						None
-					}
+					},
+					end_state,
 				}
 			},
 			Err(error) => TransactResult::Err {
 				state_root: *self.state.root(),
 				error,
+				end_state,
 			},
 		}
 	}
@@ -295,12 +309,16 @@ pub enum TransactResult<T, V> {
 		logs: Vec<log_entry::LogEntry>,
 		/// outcome
 		outcome: receipt::TransactionOutcome,
+		/// end state if needed
+		end_state: Option<pod_state::PodState>,
 	},
 	/// Transaction failed to run
 	Err {
 		/// State root
 		state_root: H256,
 		/// Execution error
 		error: ::error::Error,
+		/// end state if needed
+		end_state: Option<pod_state::PodState>,
 	},
 }

ethcore/src/json_tests/state.rs

@@ -95,7 +95,7 @@ pub fn json_chain_test<H: FnMut(&str, HookType)>(json_data: &[u8], start_stop_ho
 							flushln!("{} fail", info);
 							failed.push(name.clone());
 						},
-						Ok(TransactResult::Err { state_root, ref error }) if state_root != post_root => {
+						Ok(TransactResult::Err { state_root, ref error, .. }) if state_root != post_root => {
 							println!("{} !!! State mismatch (got: {}, expect: {}", info, state_root, post_root);
 							println!("{} !!! Execution error: {:?}", info, error);
 							flushln!("{} fail", info);

ethcore/src/lib.rs

@@ -110,6 +110,7 @@ extern crate vm;
 extern crate wasm;
 extern crate memory_cache;
 extern crate journaldb;
+extern crate serde;
 #[cfg(any(test, feature = "json-tests", feature = "test-helpers"))]
 extern crate tempdir;
 
@@ -135,6 +136,8 @@ extern crate macros;
 extern crate rlp_derive;
 #[macro_use]
 extern crate trace_time;
+#[macro_use]
+extern crate serde_derive;
 
 #[cfg_attr(test, macro_use)]
 extern crate evm;

ethcore/src/pod_account.rs

@@ -31,21 +31,29 @@ use state::Account;
 use ethjson;
 use types::account_diff::*;
 use rlp::{self, RlpStream};
+use serde::Serializer;
+use rustc_hex::ToHex;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 /// An account, expressed as Plain-Old-Data (hence the name).
 /// Does not have a DB overlay cache, code hash or anything like that.
 pub struct PodAccount {
 	/// The balance of the account.
 	pub balance: U256,
 	/// The nonce of the account.
 	pub nonce: U256,
+	#[serde(serialize_with="opt_bytes_to_hex")]
 	/// The code of the account or `None` in the special case that it is unknown.
 	pub code: Option<Bytes>,
 	/// The storage of the account.
 	pub storage: BTreeMap<H256, H256>,
 }
 
+fn opt_bytes_to_hex<S>(opt_bytes: &Option<Bytes>, serializer: S) -> Result<S::Ok, S::Error>
+	where S: Serializer {
+	serializer.collect_str(&format_args!("0x{}",opt_bytes.as_ref().map(|b|b.to_hex()).unwrap_or("".to_string())))
+}
+
 impl PodAccount {
 	/// Convert Account to a PodAccount.
 	/// NOTE: This will silently fail unless the account is fully cached.

ethcore/src/pod_state.rs

@@ -26,7 +26,7 @@ use types::state_diff::StateDiff;
 use ethjson;
 
 /// State of all accounts in the system expressed in Plain Old Data.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize)]
 pub struct PodState (BTreeMap<Address, PodAccount>);
 
 impl PodState {

ethcore/src/state/account.rs

@@ -620,7 +620,7 @@ mod tests {
 		assert!(raw.len() > compact_vec.len());
 		let again_raw = decompress(&compact_vec, snapshot_swapper());
 		assert_eq!(raw, again_raw.into_vec());
-    }
+	}
 
 	#[test]
 	fn storage_at() {

ethcore/src/trace/mod.rs

@@ -96,6 +96,10 @@ pub trait VMTracer: Send {
 
 	/// Consumes self and returns the VM trace.
 	fn drain(self) -> Option<Self::Output>;
+
+	/// Indicate if state dump is needed.
+	fn dump_end_state(&self) -> bool { false }
+
 }
 
 /// `DbExtras` provides an interface to query extra data which is not stored in tracesdb,

ethcore/wasm/run/src/runner.rs

@@ -66,7 +66,7 @@ impl Fail {
 }
 
 impl fmt::Display for Fail {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		use self::Fail::*;
 		match *self {
 			Return { ref expected, ref actual } =>

evmbin/src/display/json.rs

@@ -58,6 +58,8 @@ impl Informant {
 }
 
 impl vm::Informant for Informant {
+	type Sink = ();
+
 	fn before_test(&mut self, name: &str, action: &str) {
 		println!("{}", json!({"action": action, "test": name}));
 	}
@@ -66,7 +68,9 @@ impl vm::Informant for Informant {
 		self.gas_used = gas;
 	}
 
-	fn finish(result: vm::RunResult<Self::Output>) {
+	fn clone_sink(&self) -> Self::Sink { () }
+
+	fn finish(result: vm::RunResult<Self::Output>, _sink: &mut Self::Sink) {
 		match result {
 			Ok(success) => {
 				for trace in success.traces.unwrap_or_else(Vec::new) {

evmbin/src/display/simple.rs

@@ -27,11 +27,16 @@ use info as vm;
 pub struct Informant;
 
 impl vm::Informant for Informant {
+
+	type Sink = ();
+
 	fn before_test(&mut self, name: &str, action: &str) {
 		println!("Test: {} ({})", name, action);
 	}
 
-	fn finish(result: vm::RunResult<Self::Output>) {
+	fn clone_sink(&self) -> Self::Sink { () }
+
+	fn finish(result: vm::RunResult<Self::Output>, _sink: &mut Self::Sink) {
 		match result {
 			Ok(success) => {
 				println!("Output: 0x{}", success.output.to_hex());

evmbin/src/display/std_json.rs

@@ -21,7 +21,7 @@ use std::io;
 
 use ethereum_types::{H256, U256};
 use bytes::ToPretty;
-use ethcore::trace;
+use ethcore::{trace, pod_state};
 
 use display;
 use info as vm;
@@ -52,10 +52,11 @@ impl Writer for io::Stderr {
 }
 
 /// JSON formatting informant.
-pub struct Informant<Trace = io::Stderr, Out = io::Stdout> {
+pub struct Informant<Trace, Out> {
 	code: Vec<u8>,
 	instruction: u8,
 	depth: usize,
+	dump_state: bool,
 	stack: Vec<U256>,
 	storage: HashMap<H256, H256>,
 	subinfos: Vec<Informant<Trace, Out>>,
@@ -64,18 +65,41 @@ pub struct Informant<Trace = io::Stderr, Out = io::Stdout> {
 	out_sink: Out,
 }
 
-impl Default for Informant {
+impl<Trace, Out> Informant<Trace, Out> {
+	/// Activate or deactivate final dump state
+	pub fn dump_state(&mut self, do_dump : bool) {
+		self.dump_state = do_dump;
+	}
+}
+
+impl Default for Informant<io::Stderr, io::Stdout> {
 	fn default() -> Self {
 		Self::new(io::stderr(), io::stdout())
 	}
 }
 
+impl Informant<io::Stdout, io::Stdout> {
+	/// std json informant using out only.
+	pub fn out_only() -> Self {
+		Self::new(io::stdout(), io::stdout())
+	}
+}
+
+impl Informant<io::Stderr, io::Stderr> {
+	/// std json informant using err only.
+	pub fn err_only() -> Self {
+		Self::new(io::stderr(), io::stderr())
+	}
+}
+
 impl<Trace: Writer, Out: Writer> Informant<Trace, Out> {
+
 	pub fn new(trace_sink: Trace, out_sink: Out) -> Self {
 		Informant {
 			code: Default::default(),
 			instruction: Default::default(),
 			depth: Default::default(),
+			dump_state: false,
 			stack: Default::default(),
 			storage: Default::default(),
 			subinfos: Default::default(),
@@ -91,9 +115,24 @@ impl<Trace: Writer, Out: Writer> Informant<Trace, Out> {
 			Self::with_informant_in_depth(informant.subinfos.last_mut().expect("prepare/done_trace are not balanced"), depth - 1, f);
 		}
 	}
+
+	fn dump_state_into(trace_sink: &mut Trace, root: H256, end_state: &Option<pod_state::PodState>) {
+		if let Some(ref end_state) =	end_state {
+			let dump_data = json!({
+				"root": root,
+				"accounts": end_state,
+			});
+			writeln!(trace_sink, "{}", dump_data).expect("The sink must be writeable.");
+		}
+	}
+
+
 }
 
 impl<Trace: Writer, Out: Writer> vm::Informant for Informant<Trace, Out> {
+
+	type Sink = (Trace, Out);
+
 	fn before_test(&mut self, name: &str, action: &str) {
 		let out_data = json!({
 			"action": action,
@@ -105,23 +144,26 @@ impl<Trace: Writer, Out: Writer> vm::Informant for Informant<Trace, Out> {
 
 	fn set_gas(&mut self, _gas: U256) {}
 
-	fn finish(result: vm::RunResult<<Self as trace::VMTracer>::Output>) {
-		let mut trace_sink = Trace::default();
-		let mut out_sink = Out::default();
+	fn clone_sink(&self) -> Self::Sink {
+		(self.trace_sink.clone(), self.out_sink.clone())
+	}
+	fn finish(result: vm::RunResult<<Self as trace::VMTracer>::Output>, (ref mut trace_sink, ref mut out_sink): &mut Self::Sink) {
 
 		match result {
 			Ok(success) => {
 				let trace_data = json!({"stateRoot": success.state_root});
-				writeln!(&mut trace_sink, "{}", trace_data)
+				writeln!(trace_sink, "{}", trace_data)
 					.expect("The sink must be writeable.");
 
+				Self::dump_state_into(trace_sink, success.state_root, &success.end_state);
+
 				let out_data = json!({
 					"output": format!("0x{}", success.output.to_hex()),
 					"gasUsed": format!("{:#x}", success.gas_used),
 					"time": display::as_micros(&success.time),
 				});
 
-				writeln!(&mut out_sink, "{}", out_data).expect("The sink must be writeable.");
+				writeln!(out_sink, "{}", out_data).expect("The sink must be writeable.");
 			},
 			Err(failure) => {
 				let out_data = json!({
@@ -130,7 +172,9 @@ impl<Trace: Writer, Out: Writer> vm::Informant for Informant<Trace, Out> {
 					"time": display::as_micros(&failure.time),
 				});
 
-				writeln!(&mut out_sink, "{}", out_data).expect("The sink must be writeable.");
+				Self::dump_state_into(trace_sink, failure.state_root, &failure.end_state);
+
+				writeln!(out_sink, "{}", out_data).expect("The sink must be writeable.");
 			},
 		}
 	}
@@ -200,6 +244,11 @@ impl<Trace: Writer, Out: Writer> trace::VMTracer for Informant<Trace, Out> {
 	}
 
 	fn drain(self) -> Option<Self::Output> { None }
+
+	fn dump_end_state(&self) -> bool {
+		self.dump_state
+	}
+
 }
 
 #[cfg(test)]