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]
@@ -110,3 +112,5 @@ test-heavy = []
 benches = []
 # Compile test helpers
 test-helpers = ["tempdir"]
+# Slow method to-pod-full for evmbin or test only.
+to-pod-full = []

ethcore/src/client/evm_test_client.rs

@@ -66,6 +66,11 @@ use ethjson::spec::ForkSpec;
 pub struct EvmTestClient<'a> {
 	state: state::State<state_db::StateDB>,
 	spec: &'a spec::Spec,
+	dump_state: fn(&state::State<state_db::StateDB>) -> Option<pod_state::PodState>,
+}
+
+fn no_dump_state(_: &state::State<state_db::StateDB>) -> Option<pod_state::PodState> {
+	None
 }
 
 impl<'a> fmt::Debug for EvmTestClient<'a> {
@@ -92,32 +97,51 @@ impl<'a> EvmTestClient<'a> {
 		}
 	}
 
+	/// Change default function for dump state (default does not dump)
+	pub fn set_dump_state_fn(&mut self, dump_state: fn(&state::State<state_db::StateDB>) -> Option<pod_state::PodState>) {
+		self.dump_state = dump_state;
+	}
+
 	/// Creates new EVM test client with in-memory DB initialized with genesis of given Spec.
-	pub fn new(spec: &'a spec::Spec) -> Result<Self, EvmTestError> {
-		let factories = Self::factories();
+	/// You can specify a specific trie kind.
+	pub fn new_with_trie(spec: &'a spec::Spec, trie_spec: trie::TrieSpec) -> Result<Self, EvmTestError> {
+		let factories = Self::factories(trie_spec);
 		let state =	Self::state_from_spec(spec, &factories)?;
 
 		Ok(EvmTestClient {
 			state,
 			spec,
+			dump_state: no_dump_state,
 		})
 	}
 
+	/// Creates new EVM test client with in-memory DB initialized with genesis of given Spec.
+	pub fn new(spec: &'a spec::Spec) -> Result<Self, EvmTestError> {
+		Self::new_with_trie(spec, trie::TrieSpec::Secure)
+	}
+
 	/// Creates new EVM test client with in-memory DB initialized with given PodState.
-	pub fn from_pod_state(spec: &'a spec::Spec, pod_state: pod_state::PodState) -> Result<Self, EvmTestError> {
-		let factories = Self::factories();
+	/// You can specify a specific trie kind.
+	pub fn from_pod_state_with_trie(spec: &'a spec::Spec, pod_state: pod_state::PodState, trie_spec: trie::TrieSpec) -> Result<Self, EvmTestError> {
+		let factories = Self::factories(trie_spec);
 		let state =	Self::state_from_pod(spec, &factories, pod_state)?;
 
 		Ok(EvmTestClient {
 			state,
 			spec,
+			dump_state: no_dump_state,
 		})
 	}
 
-	fn factories() -> Factories {
+	/// Creates new EVM test client with in-memory DB initialized with given PodState.
+	pub fn from_pod_state(spec: &'a spec::Spec, pod_state: pod_state::PodState) -> Result<Self, EvmTestError> {
+		Self::from_pod_state_with_trie(spec, pod_state, trie::TrieSpec::Secure)
+	}
+
+	fn factories(trie_spec: trie::TrieSpec) -> Factories {
 		Factories {
 			vm: factory::VmFactory::new(VMType::Interpreter, 5 * 1024),
-			trie: trie::TrieFactory::new(trie::TrieSpec::Secure),
+			trie: trie::TrieFactory::new(trie_spec),
 			accountdb: Default::default(),
 		}
 	}
@@ -223,6 +247,7 @@ impl<'a> EvmTestClient<'a> {
 			return TransactResult::Err {
 				state_root: *self.state.root(),
 				error: error.into(),
+				end_state: (self.dump_state)(&self.state),
 			};
 		}
 
@@ -247,12 +272,17 @@ impl<'a> EvmTestClient<'a> {
 			&None,
 			false
 		).ok();
+
 		self.state.commit().ok();
 
+		let state_root = *self.state.root();
+
+		let end_state = (self.dump_state)(&self.state);
+
 		match result {
 			Ok(result) => {
 				TransactResult::Ok {
-					state_root: *self.state.root(),
+					state_root,
 					gas_left: initial_gas - result.receipt.gas_used,
 					outcome: result.receipt.outcome,
 					output: result.output,
@@ -263,12 +293,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(),
+				state_root,
 				error,
+				end_state,
 			},
 		}
 	}
@@ -295,12 +327,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;
@@ -185,3 +188,4 @@ pub use types::*;
 pub use executive::contract_address;
 pub use evm::CreateContractAddress;
 pub use blockchain::{BlockChainDB, BlockChainDBHandler};
+pub use trie::TrieSpec;

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/state/mod.rs

@@ -940,7 +940,7 @@ impl<B: Backend> State<B> {
 	}
 
 	/// Populate a PodAccount map from this state.
-	pub fn to_pod(&self) -> PodState {
+	fn to_pod_cache(&self) -> PodState {
 		assert!(self.checkpoints.borrow().is_empty());
 		// TODO: handle database rather than just the cache.
 		// will need fat db.
@@ -952,8 +952,78 @@ impl<B: Backend> State<B> {
 		}))
 	}
 
+	#[cfg(feature="to-pod-full")]
+	/// Populate a PodAccount map from this state.
+	/// Warning this is not for real time use.
+	/// Use of this method requires FatDB mode to be able 
+	/// to iterate on accounts.
+	pub fn to_pod_full(&self) -> PodState {
+
+		assert!(self.checkpoints.borrow().is_empty());
+		assert!(self.factories.trie.is_fat());
+
+		let mut result = BTreeMap::new();
+
+		let trie = match self.factories.trie.readonly(self.db.as_hashdb(), &self.root) {
+			Ok(trie) => trie,
+			_ => {
+				trace!(target: "state", "to_pod_full: Couldn't open the DB");
+				return PodState::from(result);
+			}
+		};
+
+		let iter = match trie.iter() {
+			Ok(iter) => iter,
+			_ => return PodState::from(result),
+		};
+
+		// put trie in cache 
+		for item in iter {
+			if let Ok((addr, _dbval)) = item {
+				let address = Address::from_slice(&addr);
+				let _ = self.require(&address, true);
+			}
+		}
+
+		// Resolve missing part
+		for (add, opt) in self.cache.borrow_mut().iter_mut() {
+			if let Some(ref mut acc) = opt.account {
+				let pod_account = self.account_to_pod_account(acc, add);
+				result.insert(add.clone(), pod_account);
+			}
+		}
+
+		PodState::from(result)
+	}
+
+	fn account_to_pod_account(&self, account: &mut Account, address: &Address) -> PodAccount {
+		let mut pod_storage = BTreeMap::new();
+		let addr_hash = account.address_hash(address);
+		let accountdb = self.factories.accountdb.readonly(self.db.as_hashdb(), addr_hash);
+
+		if account.code_size().is_none() {
+			let _ = account.cache_code(accountdb.as_hashdb());
+		}
+
+		account.storage_root()
+			.map(|root| self.factories.trie.readonly(accountdb.as_hashdb(), &root)
+				.map(|trie|	trie.iter()
+					.map(|iter| iter.for_each(|o_kv|{
+						if let Ok((key, val)) = o_kv {
+							pod_storage.insert(H256::from(&key[..]), H256::from(&val[..]));
+						}
+					}
+					))));
+
+		let mut pod_account = PodAccount::from_account(&account);
+		// cached one first
+		pod_storage.append(&mut pod_account.storage);
+		pod_account.storage = pod_storage;
+		pod_account
+	}
+
 	/// Populate a PodAccount map from this state, with another state as the account and storage query.
-	pub fn to_pod_diff<X: Backend>(&mut self, query: &State<X>) -> TrieResult<PodState> {
+	fn to_pod_diff<X: Backend>(&mut self, query: &State<X>) -> TrieResult<PodState> {
 		assert!(self.checkpoints.borrow().is_empty());
 
 		// Merge PodAccount::to_pod for cache of self and `query`.
@@ -1008,7 +1078,7 @@ impl<B: Backend> State<B> {
 	/// Returns a `StateDiff` describing the difference from `orig` to `self`.
 	/// Consumes self.
 	pub fn diff_from<X: Backend>(&self, mut orig: State<X>) -> TrieResult<StateDiff> {
-		let pod_state_post = self.to_pod();
+		let pod_state_post = self.to_pod_cache();
 		let pod_state_pre = orig.to_pod_diff(self)?;
 		Ok(pod_state::diff_pod(&pod_state_pre, &pod_state_post))
 	}

ethcore/src/trace/mod.rs

@@ -96,6 +96,7 @@ pub trait VMTracer: Send {
 
 	/// Consumes self and returns the VM trace.
 	fn drain(self) -> Option<Self::Output>;
+
 }
 
 /// `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/Cargo.toml

@@ -11,7 +11,7 @@ path = "./src/main.rs"
 [dependencies]
 docopt = "0.8"
 env_logger = "0.5"
-ethcore = { path = "../ethcore", features = ["test-helpers", "json-tests"] }
+ethcore = { path = "../ethcore", features = ["test-helpers", "json-tests", "to-pod-full"] }
 ethjson = { path = "../json" }
 parity-bytes = "0.1"
 ethcore-transaction = { path = "../ethcore/transaction" }

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());