Bugs fixed for last_hashes.

src/block.rs

@@ -255,6 +255,11 @@ impl IsBlock for SealedBlock {
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
 pub fn enact<'x, 'y>(block_bytes: &[u8], engine: &'x Engine, db: OverlayDB, parent: &Header, last_hashes: &'y LastHashes) -> Result<ClosedBlock<'x, 'y>, Error> {
+	{
+		let header = BlockView::new(block_bytes).header_view();
+		let s = State::from_existing(db.clone(), parent.state_root().clone(), engine.account_start_nonce());
+//		flush(format!("enact(): root={}, author={}, author_balance={}\n", s.root(), header.author(), s.balance(&header.author())));
+	}
 	let block = BlockView::new(block_bytes);
 	let header = block.header_view();
 	let mut b = OpenBlock::new(engine, db, parent, last_hashes, header.author(), header.extra_data());

src/client.rs

@@ -142,14 +142,13 @@ impl Client {
 			},
 		};
 		// build last hashes
-		let mut last = self.chain.read().unwrap().best_block_hash();
 		let mut last_hashes = LastHashes::new();
 		last_hashes.resize(256, H256::new());
+		last_hashes[0] = header.parent_hash.clone();
 		for i in 0..255 {
-			match self.chain.read().unwrap().block_details(&last) {
+			match self.chain.read().unwrap().block_details(&last_hashes[i]) {
 				Some(details) => {
 					last_hashes[i + 1] = details.parent.clone();
-					last = details.parent.clone();
 				},
 				None => break,
 			}

src/executive.rs

@@ -196,6 +196,8 @@ impl<'a> Executive<'a> {
 			// part of substate that may be reverted
 			let mut unconfirmed_substate = Substate::new();
 
+			info!("exec: call; env_info={:?}", self.info);
+
 			let res = {
 				let mut ext = self.to_externalities(params, &mut unconfirmed_substate, OutputPolicy::Return(output));
 				let evm = Factory::create();
@@ -257,12 +259,12 @@ impl<'a> Executive<'a> {
 		let refund_value = gas_left * t.gas_price;
 		let fees_value = gas_used * t.gas_price;
 
-		flush(format!("exec::finalize: t.gas={}, sstore_refunds={}, suicide_refunds={}, refunds_bound={}, gas_left_prerefund={}, refunded={}, gas_left={}, gas_used={}, refund_value={}, fees_value={}\n",
-			t.gas, sstore_refunds, suicide_refunds, refunds_bound, gas_left_prerefund, refunded, gas_left, gas_used, refund_value, fees_value));
+//		flush(format!("exec::finalize: t.gas={}, sstore_refunds={}, suicide_refunds={}, refunds_bound={}, gas_left_prerefund={}, refunded={}, gas_left={}, gas_used={}, refund_value={}, fees_value={}\n",
+//			t.gas, sstore_refunds, suicide_refunds, refunds_bound, gas_left_prerefund, refunded, gas_left, gas_used, refund_value, fees_value));
 
-		flush(format!("exec::finalize: Refunding sender={}\n", t.sender().unwrap()));
+//		flush(format!("exec::finalize: Refunding refund_value={}, sender={}\n", refund_value, t.sender().unwrap()));
 		self.state.add_balance(&t.sender().unwrap(), &refund_value);
-		flush(format!("exec::finalize: Compensating author: fees_value: {}, author: {}", fees_value, &self.info.author));
+//		flush(format!("exec::finalize: Compensating author: fees_value={}, author={}\n", fees_value, &self.info.author));
 		self.state.add_balance(&self.info.author, &fees_value);
 
 		// perform suicides

src/externalities.rs

@@ -84,9 +84,14 @@ impl<'a> Ext for Externalities<'a> {
 		match *number < U256::from(self.info.number) && number.low_u64() >= cmp::max(256, self.info.number) - 256 {
 			true => {
 				let index = self.info.number - number.low_u64() - 1;
-				self.info.last_hashes[index as usize].clone()
+				let r = self.info.last_hashes[index as usize].clone();
+//				flush(format!("ext: blockhash({}) -> {} self.info.number={}\n", number, r, self.info.number));
+				r
+			},
+			false => {
+//				flush(format!("ext: blockhash({}) -> null self.info.number={}\n", number, self.info.number));
+				H256::from(&U256::zero())
 			},
-			false => H256::from(&U256::zero()),
 		}
 	}
 
@@ -142,6 +147,8 @@ impl<'a> Ext for Externalities<'a> {
 			call_gas = call_gas + U256::from(self.schedule.call_stipend);
 		}
 
+//		flush(format!("Externalities::call(gas={}, call_gas={}, recv={}, value={}, data={}, code={})\n", gas, call_gas, receive_address, value, data.pretty(), code_address));
+
 		if gas_cost > *gas {
 			return Err(evm::Error::OutOfGas);
 		}
@@ -165,8 +172,13 @@ impl<'a> Ext for Externalities<'a> {
 			data: Some(data.to_vec()),
 		};
 
-		let mut ex = Executive::from_parent(self.state, self.info, self.engine, self.depth);
-		match ex.call(&params, self.substate, BytesRef::Fixed(output)) {
+
+//		flush(format!("Externalities::call: BEFORE: bal({})={}, bal({})={}\n", params.sender, self.state.balance(&params.sender), params.address, self.state.balance(&params.address)));
+//		flush(format!("Externalities::call: CALLING: params={:?}\n", params));
+		let r = Executive::from_parent(self.state, self.info, self.engine, self.depth).call(&params, self.substate, BytesRef::Fixed(output));
+//		flush(format!("Externalities::call: AFTER: bal({})={}, bal({})={}\n", params.sender, self.state.balance(&params.sender), params.address, self.state.balance(&params.address)));
+
+		match r {
 			Ok(gas_left) => Ok((gas + gas_left, true)),
 			_ => Ok((gas, false))
 		}

src/state.rs

@@ -107,14 +107,16 @@ impl State {
 
 	/// Add `incr` to the balance of account `a`.
 	pub fn add_balance(&mut self, a: &Address, incr: &U256) {
-		flush(format!("state: add_balance({}, {})\n", a, incr));
-		self.require(a, false).add_balance(incr)
+//		let old = self.balance(a);
+		self.require(a, false).add_balance(incr);
+//		flush(format!("state: add_balance({}, {}): {} -> {}\n", a, incr, old, self.balance(a)));
 	}
 
 	/// Subtract `decr` from the balance of account `a`.
 	pub fn sub_balance(&mut self, a: &Address, decr: &U256) {
-		flush(format!("state: sub_balance({}, {})\n", a, decr));
-		self.require(a, false).sub_balance(decr)
+//		let old = self.balance(a);
+		self.require(a, false).sub_balance(decr);
+//		flush(format!("state: sub_balance({}, {}): {} -> {}\n", a, decr, old, self.balance(a)));
 	}
 
 	/// Subtracts `by` from the balance of `from` and adds it to that of `to`.
@@ -148,7 +150,7 @@ impl State {
 		let e = try!(Executive::new(self, env_info, engine).transact(t));
 		//println!("Executed: {:?}", e);
 
-		flush(format!("Applied transaction. Diff:\n{}\n", StateDiff::diff_pod(&old, &self.to_pod())));
+//		flush(format!("Applied transaction. Diff:\n{}\n", StateDiff::diff_pod(&old, &self.to_pod())));
 		self.commit();
 		let receipt = Receipt::new(self.root().clone(), e.cumulative_gas_used, e.logs);
 		debug!("Transaction receipt: {:?}", receipt);
@@ -227,8 +229,16 @@ impl State {
 	/// Pull account `a` in our cache from the trie DB and return it.
 	/// `require_code` requires that the code be cached, too.
 	fn get(&self, a: &Address, require_code: bool) -> Ref<Option<Account>> {
-		self.cache.borrow_mut().entry(a.clone()).or_insert_with(||
-			SecTrieDB::new(&self.db, &self.root).get(&a).map(|rlp| Account::from_rlp(rlp)));
+		self.cache.borrow_mut().entry(a.clone()).or_insert_with(|| {
+			/*{
+				let orlp = SecTrieDB::new(&self.db, &self.root).get(&a).map(|rlp| rlp.to_vec());
+				if let Some(rlp) = orlp {
+					let acc = Account::from_rlp(&rlp);
+					flush(format!("State::get({}) -> {} (bal={})\n", a, rlp.pretty(), acc.balance()));
+				}
+			}*/
+			SecTrieDB::new(&self.db, &self.root).get(&a).map(|rlp| Account::from_rlp(rlp))
+		});
 		if require_code {
 			if let Some(ref mut account) = self.cache.borrow_mut().get_mut(a).unwrap().as_mut() {
 				account.cache_code(&self.db);