Backporting to beta

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 description = "Parity Ethereum client"
 name = "parity"
-version = "1.5.0"
+version = "1.5.1"
 license = "GPL-3.0"
 authors = ["Parity Technologies <[email protected]>"]
 build = "build.rs"

ethcore/src/client/test_client.rs

@@ -300,22 +300,29 @@ impl TestBlockChainClient {
 		}
 	}
 
-	/// Inserts a transaction to miners transactions queue.
-	pub fn insert_transaction_to_queue(&self) {
+	/// Inserts a transaction with given gas price to miners transactions queue.
+	pub fn insert_transaction_with_gas_price_to_queue(&self, gas_price: U256) -> H256 {
 		let keypair = Random.generate().unwrap();
 		let tx = Transaction {
 			action: Action::Create,
 			value: U256::from(100),
 			data: "3331600055".from_hex().unwrap(),
 			gas: U256::from(100_000),
-			gas_price: U256::from(20_000_000_000u64),
+			gas_price: gas_price,
 			nonce: U256::zero()
 		};
 		let signed_tx = tx.sign(keypair.secret(), None);
 		self.set_balance(signed_tx.sender().unwrap(), 10_000_000_000_000_000_000u64.into());
-		let res = self.miner.import_external_transactions(self, vec![signed_tx]);
+		let hash = signed_tx.hash();
+		let res = self.miner.import_external_transactions(self, vec![signed_tx.into()]);
 		let res = res.into_iter().next().unwrap().expect("Successful import");
 		assert_eq!(res, TransactionImportResult::Current);
+		hash
+	}
+
+	/// Inserts a transaction to miners transactions queue.
+	pub fn insert_transaction_to_queue(&self) -> H256 {
+		self.insert_transaction_with_gas_price_to_queue(U256::from(20_000_000_000u64))
 	}
 
 	/// Set reported history size.

ethcore/src/evm/interpreter/mod.rs

@@ -37,7 +37,6 @@ use bit_set::BitSet;
 
 use util::*;
 
-type CodePosition = usize;
 type ProgramCounter = usize;
 
 const ONE: U256 = U256([1, 0, 0, 0]);

ethcore/src/miner/banning_queue.rs

@@ -22,7 +22,7 @@ use std::ops::{Deref, DerefMut};
 use std::cell::Cell;
 use transaction::{SignedTransaction, Action};
 use transient_hashmap::TransientHashMap;
-use miner::{TransactionQueue, TransactionImportResult, TransactionOrigin, AccountDetails};
+use miner::{TransactionQueue, TransactionQueueDetailsProvider, TransactionImportResult, TransactionOrigin};
 use miner::transaction_queue::QueuingInstant;
 use error::{Error, TransactionError};
 use util::{Uint, U256, H256, Address, Hashable};
@@ -76,16 +76,12 @@ impl BanningTransactionQueue {
 
 	/// Add to the queue taking bans into consideration.
 	/// May reject transaction because of the banlist.
-	pub fn add_with_banlist<F, G>(
+	pub fn add_with_banlist(
 		&mut self,
 		transaction: SignedTransaction,
 		time: QueuingInstant,
-		account_details: &F,
-		gas_estimator: &G,
-	) -> Result<TransactionImportResult, Error> where
-		F: Fn(&Address) -> AccountDetails,
-		G: Fn(&SignedTransaction) -> U256,
-	{
+		details_provider: &TransactionQueueDetailsProvider,
+	) -> Result<TransactionImportResult, Error> {
 		if let Threshold::BanAfter(threshold) = self.ban_threshold {
 			// NOTE In all checks use direct query to avoid increasing ban timeout.
 
@@ -117,7 +113,7 @@ impl BanningTransactionQueue {
 				}
 			}
 		}
-		self.queue.add(transaction, TransactionOrigin::External, time, None, account_details, gas_estimator)
+		self.queue.add(transaction, TransactionOrigin::External, time, None, details_provider)
 	}
 
 	/// Ban transaction with given hash.
@@ -220,22 +216,16 @@ mod tests {
 	use transaction::{Transaction, SignedTransaction, Action};
 	use error::{Error, TransactionError};
 	use client::TransactionImportResult;
-	use miner::{TransactionQueue, TransactionOrigin, AccountDetails};
+	use miner::{TransactionQueue, TransactionOrigin};
 	use util::{Uint, U256, Address, FromHex, Hashable};
+	use miner::transaction_queue::test::DummyTransactionDetailsProvider;
 
 	fn queue() -> BanningTransactionQueue {
 		BanningTransactionQueue::new(TransactionQueue::default(), Threshold::BanAfter(1), Duration::from_secs(180))
 	}
 
-	fn default_account_details(_address: &Address) -> AccountDetails {
-		AccountDetails {
-			nonce: U256::zero(),
-			balance: !U256::zero(),
-		}
-	}
-
-	fn gas_required(_tx: &SignedTransaction) -> U256 {
-		0.into()
+	fn default_tx_provider() -> DummyTransactionDetailsProvider {
+		DummyTransactionDetailsProvider::default().with_account_nonce(U256::zero())
 	}
 
 	fn transaction(action: Action) -> SignedTransaction {
@@ -265,7 +255,7 @@ mod tests {
 		let mut txq = queue();
 
 		// when
-		txq.queue().add(tx, TransactionOrigin::External, 0, None, &default_account_details, &gas_required).unwrap();
+		txq.queue().add(tx, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
 
 		// then
 		// should also deref to queue
@@ -281,12 +271,12 @@ mod tests {
 		let banlist1 = txq.ban_sender(tx.sender().unwrap());
 		assert!(!banlist1, "Threshold not reached yet.");
 		// Insert once
-		let import1 = txq.add_with_banlist(tx.clone(), 0, &default_account_details, &gas_required).unwrap();
+		let import1 = txq.add_with_banlist(tx.clone(), 0, &default_tx_provider()).unwrap();
 		assert_eq!(import1, TransactionImportResult::Current);
 
 		// when
 		let banlist2 = txq.ban_sender(tx.sender().unwrap());
-		let import2 = txq.add_with_banlist(tx.clone(), 0, &default_account_details, &gas_required);
+		let import2 = txq.add_with_banlist(tx.clone(), 0, &default_tx_provider());
 
 		// then
 		assert!(banlist2, "Threshold should be reached - banned.");
@@ -305,12 +295,12 @@ mod tests {
 		let banlist1 = txq.ban_recipient(recipient);
 		assert!(!banlist1, "Threshold not reached yet.");
 		// Insert once
-		let import1 = txq.add_with_banlist(tx.clone(), 0, &default_account_details, &gas_required).unwrap();
+		let import1 = txq.add_with_banlist(tx.clone(), 0, &default_tx_provider()).unwrap();
 		assert_eq!(import1, TransactionImportResult::Current);
 
 		// when
 		let banlist2 = txq.ban_recipient(recipient);
-		let import2 = txq.add_with_banlist(tx.clone(), 0, &default_account_details, &gas_required);
+		let import2 = txq.add_with_banlist(tx.clone(), 0, &default_tx_provider());
 
 		// then
 		assert!(banlist2, "Threshold should be reached - banned.");
@@ -327,12 +317,12 @@ mod tests {
 		let banlist1 = txq.ban_codehash(codehash);
 		assert!(!banlist1, "Threshold not reached yet.");
 		// Insert once
-		let import1 = txq.add_with_banlist(tx.clone(), 0, &default_account_details, &gas_required).unwrap();
+		let import1 = txq.add_with_banlist(tx.clone(), 0, &default_tx_provider()).unwrap();
 		assert_eq!(import1, TransactionImportResult::Current);
 
 		// when
 		let banlist2 = txq.ban_codehash(codehash);
-		let import2 = txq.add_with_banlist(tx.clone(), 0, &default_account_details, &gas_required);
+		let import2 = txq.add_with_banlist(tx.clone(), 0, &default_tx_provider());
 
 		// then
 		assert!(banlist2, "Threshold should be reached - banned.");

ethcore/src/miner/local_transactions.rs

@@ -70,36 +70,43 @@ impl LocalTransactionsList {
 	}
 
 	pub fn mark_pending(&mut self, hash: H256) {
+		debug!(target: "own_tx", "Imported to Current (hash {:?})", hash);
 		self.clear_old();
 		self.transactions.insert(hash, Status::Pending);
 	}
 
 	pub fn mark_future(&mut self, hash: H256) {
+		debug!(target: "own_tx", "Imported to Future (hash {:?})", hash);
 		self.transactions.insert(hash, Status::Future);
 		self.clear_old();
 	}
 
 	pub fn mark_rejected(&mut self, tx: SignedTransaction, err: TransactionError) {
+		debug!(target: "own_tx", "Transaction rejected (hash {:?}): {:?}", tx.hash(), err);
 		self.transactions.insert(tx.hash(), Status::Rejected(tx, err));
 		self.clear_old();
 	}
 
 	pub fn mark_replaced(&mut self, tx: SignedTransaction, gas_price: U256, hash: H256) {
+		debug!(target: "own_tx", "Transaction replaced (hash {:?}) by {:?} (new gas price: {:?})", tx.hash(), hash, gas_price);
 		self.transactions.insert(tx.hash(), Status::Replaced(tx, gas_price, hash));
 		self.clear_old();
 	}
 
 	pub fn mark_invalid(&mut self, tx: SignedTransaction) {
+		warn!(target: "own_tx", "Transaction marked invalid (hash {:?})", tx.hash());
 		self.transactions.insert(tx.hash(), Status::Invalid(tx));
 		self.clear_old();
 	}
 
 	pub fn mark_dropped(&mut self, tx: SignedTransaction) {
+		warn!(target: "own_tx", "Transaction dropped (hash {:?})", tx.hash());
 		self.transactions.insert(tx.hash(), Status::Dropped(tx));
 		self.clear_old();
 	}
 
 	pub fn mark_mined(&mut self, tx: SignedTransaction) {
+		info!(target: "own_tx", "Transaction mined (hash {:?})", tx.hash());
 		self.transactions.insert(tx.hash(), Status::Mined(tx));
 		self.clear_old();
 	}