transaction proof test

ethcore/src/client/client.rs

@@ -308,13 +308,13 @@ impl Client {
 	}
 
 	/// The env info as of the best block.
-	fn latest_env_info(&self) -> EnvInfo {
+	pub fn latest_env_info(&self) -> EnvInfo {
 		self.env_info(BlockId::Latest).expect("Best block header always stored; qed")
 	}
 
 	/// The env info as of a given block.
 	/// returns `None` if the block unknown.
-	fn env_info(&self, id: BlockId) -> Option<EnvInfo> {
+	pub fn env_info(&self, id: BlockId) -> Option<EnvInfo> {
 		self.block_header(id).map(|header| {
 			EnvInfo {
 				number: header.number(),

ethcore/src/state/backend.rs

@@ -66,21 +66,48 @@ pub trait Backend: Send {
 	fn is_known_null(&self, address: &Address) -> bool;
 }
 
-/// A raw backend which simply wraps a hashdb and does no caching.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct NoCache<T>(T);
+/// A raw backend used to check proofs of execution.
+///
+/// This doesn't delete anything since execution proofs won't have mangled keys
+/// and we want to avoid collisions.
+// TODO: when account lookup moved into backends, this won't rely as tenuously on intended
+// usage.
+#[derive(Clone, PartialEq)]
+pub struct ProofCheck(MemoryDB);
 
-impl<T> NoCache<T> {
-	/// Create a new `NoCache` backend.
-	pub fn new(inner: T) -> Self { NoCache(inner) }
-
-	/// Consume the backend, yielding the inner database.
-	pub fn into_inner(self) -> T { self.0 }
+impl ProofCheck {
+	/// Create a new `ProofCheck` backend from the given state items.
+	pub fn new(proof: &[DBValue]) -> Self {
+		let mut db = MemoryDB::new();
+		for item in proof { db.insert(item); }
+		ProofCheck(db)
+	}
 }
 
-impl<T: AsHashDB + Send> Backend for NoCache<T> {
-	fn as_hashdb(&self) -> &HashDB { self.0.as_hashdb() }
-	fn as_hashdb_mut(&mut self) -> &mut HashDB { self.0.as_hashdb_mut() }
+impl HashDB for ProofCheck {
+	fn keys(&self) -> HashMap<H256, i32> { self.0.keys() }
+	fn get(&self, key: &H256) -> Option<DBValue> {
+		self.0.get(key)
+	}
+
+	fn contains(&self, key: &H256) -> bool {
+		self.0.contains(key)
+	}
+
+	fn insert(&mut self, value: &[u8]) -> H256 {
+		self.0.insert(value)
+	}
+
+	fn emplace(&mut self, key: H256, value: DBValue) {
+		self.0.emplace(key, value)
+	}
+
+	fn remove(&mut self, _key: &H256) { }
+}
+
+impl Backend for ProofCheck {
+	fn as_hashdb(&self) -> &HashDB { self }
+	fn as_hashdb_mut(&mut self) -> &mut HashDB { self }
 	fn add_to_account_cache(&mut self, _addr: Address, _data: Option<Account>, _modified: bool) {}
 	fn cache_code(&self, _hash: H256, _code: Arc<Vec<u8>>) {}
 	fn get_cached_account(&self, _addr: &Address) -> Option<Option<Account>> { None }
@@ -95,7 +122,8 @@ impl<T: AsHashDB + Send> Backend for NoCache<T> {
 }
 
 /// Proving state backend.
-/// See module docs for more details.
+/// This keeps track of all state values loaded during usage of this backend.
+/// The proof-of-execution can be extracted with `extract_proof`.
 ///
 /// This doesn't cache anything or rely on the canonical state caches.
 pub struct Proving<H: AsHashDB> {

ethcore/src/tests/client.rs

@@ -16,7 +16,8 @@
 
 use io::IoChannel;
 use client::{BlockChainClient, MiningBlockChainClient, Client, ClientConfig, BlockId};
-use state::CleanupMode;
+use state::{self, State, CleanupMode};
+use executive::Executive;
 use ethereum;
 use block::IsBlock;
 use tests::helpers::*;
@@ -342,3 +343,43 @@ fn does_not_propagate_delayed_transactions() {
 	assert_eq!(2, client.ready_transactions().len());
 	assert_eq!(2, client.miner().pending_transactions().len());
 }
+
+#[test]
+fn transaction_proof() {
+	use ::client::ProvingBlockChainClient;
+
+	let client_result = generate_dummy_client(0);
+	let client = client_result.reference();
+	let address = Address::random();
+	let test_spec = Spec::new_test();
+	for _ in 0..20 {
+		let mut b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]);
+		b.block_mut().fields_mut().state.add_balance(&address, &5.into(), CleanupMode::NoEmpty).unwrap();
+		b.block_mut().fields_mut().state.commit().unwrap();
+		let b = b.close_and_lock().seal(&*test_spec.engine, vec![]).unwrap();
+		client.import_sealed_block(b).unwrap(); // account change is in the journal overlay
+	}
+
+	let transaction = Transaction {
+		nonce: 0.into(),
+		gas_price: 0.into(),
+		gas: 21000.into(),
+		action: Action::Call(Address::default()),
+		value: 5.into(),
+		data: Vec::new(),
+	}.fake_sign(address);
+
+	let proof = client.prove_transaction(transaction.clone(), BlockId::Latest).unwrap();
+	let backend = state::backend::ProofCheck::new(&proof);
+
+	let mut factories = ::factory::Factories::default();
+	factories.accountdb = ::account_db::Factory::Plain; // raw state values, no mangled keys.
+	let root = client.best_block_header().state_root();
+
+	let mut state = State::from_existing(backend, root, 0.into(), factories.clone()).unwrap();
+	Executive::new(&mut state, &client.latest_env_info(), &*test_spec.engine, &factories.vm)
+		.transact(&transaction, Default::default()).unwrap();
+
+	assert_eq!(state.balance(&Address::default()).unwrap(), 5.into());
+	assert_eq!(state.balance(&address).unwrap(), 95.into());
+}