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]
@@ -101,7 +103,7 @@ evm-debug-tests = ["evm-debug", "evm/evm-debug-tests"]
 # EVM debug traces are printed.
 slow-blocks = []
 # Run JSON consensus tests.
-json-tests = ["ethcore-transaction/json-tests", "test-helpers", "tempdir"]
+json-tests = ["ethcore-transaction/json-tests", "test-helpers", "tempdir", "to-pod-full"]
 # Skip JSON consensus tests with pending issues.
 ci-skip-issue = []
 # Run memory/cpu heavy tests.
@@ -110,3 +112,5 @@ test-heavy = []
 benches = []
 # Compile test helpers
 test-helpers = ["tempdir"]
+# Enables slow 'to-pod-full' method for use in tests and evmbin.
+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();
+	/// Takes a `TrieSpec` to set the type of trie.
+	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 given PodState.
-	pub fn from_pod_state(spec: &'a spec::Spec, pod_state: pod_state::PodState) -> Result<Self, EvmTestError> {
-		let factories = Self::factories();
+	/// Creates new EVM test client with an in-memory DB initialized with genesis of given chain 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 an in-memory DB initialized with given PodState.
+	/// Takes a `TrieSpec` to set the type of trie.
+	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 an 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,30 @@ 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,8 +26,8 @@ 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)]
-pub struct PodState (BTreeMap<Address, PodAccount>);
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize)]
+pub struct PodState(BTreeMap<Address, PodAccount>);
 
 impl PodState {
 	/// Contruct a new object from the `m`.

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