Merge pull request #1149 from rphmeier/rpc-earliest-specific

Support "earliest" and specific block parameters in RPC where possible

ethcore/src/client/client.rs

@@ -346,6 +346,22 @@ impl<V> Client<V> where V: Verifier {
 		imported
 	}
 
+	/// Attempt to get a copy of a specific block's state.
+	///
+	/// This will not fail if given BlockID::Latest.
+	/// Otherwise, this can fail (but may not) if the DB prunes state.
+	pub fn state_at(&self, id: BlockID) -> Option<State> {
+		// fast path for latest state.
+		if let BlockID::Latest = id.clone() {
+			return Some(self.state())
+		}
+
+		self.block_header(id).map(|header| {
+			let db = self.state_db.lock().unwrap().boxed_clone();
+			State::from_existing(db, HeaderView::new(&header).state_root(), self.engine.account_start_nonce())
+		})
+	}
+
 	/// Get a copy of the best block's state.
 	pub fn state(&self) -> State {
 		State::from_existing(self.state_db.lock().unwrap().boxed_clone(), HeaderView::new(&self.best_block_header()).state_root(), self.engine.account_start_nonce())
@@ -541,10 +557,11 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 		Self::block_hash(&self.chain, id).and_then(|hash| self.chain.block_details(&hash)).map(|d| d.total_difficulty)
 	}
 
-	fn nonce(&self, address: &Address) -> U256 {
+	fn nonce(&self, address: &Address, id: BlockID) -> Option<U256> {
-		self.state().nonce(address)
+		self.state_at(id).map(|s| s.nonce(address))
 	}
 
+
 	fn block_hash(&self, id: BlockID) -> Option<H256> {
 		Self::block_hash(&self.chain, id)
 	}
@@ -553,12 +570,12 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 		self.state().code(address)
 	}
 
-	fn balance(&self, address: &Address) -> U256 {
+	fn balance(&self, address: &Address, id: BlockID) -> Option<U256> {
-		self.state().balance(address)
+		self.state_at(id).map(|s| s.balance(address))
 	}
 
-	fn storage_at(&self, address: &Address, position: &H256) -> H256 {
+	fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option<H256> {
-		self.state().storage_at(address, position)
+		self.state_at(id).map(|s| s.storage_at(address, position))
 	}
 
 	fn transaction(&self, id: TransactionID) -> Option<LocalizedTransaction> {

ethcore/src/client/mod.rs

@@ -65,8 +65,16 @@ pub trait BlockChainClient : Sync + Send {
 	/// Get block total difficulty.
 	fn block_total_difficulty(&self, id: BlockID) -> Option<U256>;
 
-	/// Get address nonce.
+	/// Attempt to get address nonce at given block.
-	fn nonce(&self, address: &Address) -> U256;
+	/// May not fail on BlockID::Latest.
+	fn nonce(&self, address: &Address, id: BlockID) -> Option<U256>;
+
+	/// Get address nonce at the latest block's state.
+	fn latest_nonce(&self, address: &Address) -> U256 {
+		self.nonce(address, BlockID::Latest)
+			.expect("nonce will return Some when given BlockID::Latest. nonce was given BlockID::Latest. \
+			Therefore nonce has returned Some; qed")
+	}
 
 	/// Get block hash.
 	fn block_hash(&self, id: BlockID) -> Option<H256>;
@@ -74,11 +82,31 @@ pub trait BlockChainClient : Sync + Send {
 	/// Get address code.
 	fn code(&self, address: &Address) -> Option<Bytes>;
 
-	/// Get address balance.
+	/// Get address balance at the given block's state.
-	fn balance(&self, address: &Address) -> U256;
+	///
+	/// May not return None if given BlockID::Latest.
+	/// Returns None if and only if the block's root hash has been pruned from the DB.
+	fn balance(&self, address: &Address, id: BlockID) -> Option<U256>;
 
-	/// Get value of the storage at given position.
+	/// Get address balance at the latest block's state.
-	fn storage_at(&self, address: &Address, position: &H256) -> H256;
+	fn latest_balance(&self, address: &Address) -> U256 {
+		self.balance(address, BlockID::Latest)
+			.expect("balance will return Some if given BlockID::Latest. balance was given BlockID::Latest \
+			Therefore balance has returned Some; qed")
+	}
+
+	/// Get value of the storage at given position at the given block's state.
+	///
+	/// May not return None if given BlockID::Latest.
+	/// Returns None if and only if the block's root hash has been pruned from the DB.
+	fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option<H256>;
+
+	/// Get value of the storage at given position at the latest block's state.
+	fn latest_storage_at(&self, address: &Address, position: &H256) -> H256 {
+		self.storage_at(address, position, BlockID::Latest)
+			.expect("storage_at will return Some if given BlockID::Latest. storage_at was given BlockID::Latest. \
+			Therefore storage_at has returned Some; qed")
+	}
 
 	/// Get transaction with given hash.
 	fn transaction(&self, id: TransactionID) -> Option<LocalizedTransaction>;

ethcore/src/client/test_client.rs

@@ -245,20 +245,31 @@ impl BlockChainClient for TestBlockChainClient {
 		Self::block_hash(self, id)
 	}
 
-	fn nonce(&self, address: &Address) -> U256 {
+	fn nonce(&self, address: &Address, id: BlockID) -> Option<U256> {
-		self.nonces.read().unwrap().get(address).cloned().unwrap_or_else(U256::zero)
+		match id {
+			BlockID::Latest => Some(self.nonces.read().unwrap().get(address).cloned().unwrap_or_else(U256::zero)),
+			_ => None,
+		}
 	}
 
 	fn code(&self, address: &Address) -> Option<Bytes> {
 		self.code.read().unwrap().get(address).cloned()
 	}
 
-	fn balance(&self, address: &Address) -> U256 {
+	fn balance(&self, address: &Address, id: BlockID) -> Option<U256> {
-		self.balances.read().unwrap().get(address).cloned().unwrap_or_else(U256::zero)
+		if let BlockID::Latest = id {
+			Some(self.balances.read().unwrap().get(address).cloned().unwrap_or_else(U256::zero))
+		} else {
+			None
+		}
 	}
 
-	fn storage_at(&self, address: &Address, position: &H256) -> H256 {
+	fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option<H256> {
-		self.storage.read().unwrap().get(&(address.clone(), position.clone())).cloned().unwrap_or_else(H256::new)
+		if let BlockID::Latest = id {
+			Some(self.storage.read().unwrap().get(&(address.clone(), position.clone())).cloned().unwrap_or_else(H256::new))
+		} else {
+			None
+		}
 	}
 
 	fn transaction(&self, _id: TransactionID) -> Option<LocalizedTransaction> {

miner/src/lib.rs

@@ -63,8 +63,8 @@ pub use external::{ExternalMiner, ExternalMinerService};
 use std::collections::BTreeMap;
 use util::{H256, U256, Address, Bytes};
 use ethcore::client::{BlockChainClient, Executed};
-use ethcore::block::{ClosedBlock};
+use ethcore::block::ClosedBlock;
-use ethcore::receipt::{Receipt};
+use ethcore::receipt::Receipt;
 use ethcore::error::{Error, ExecutionError};
 use ethcore::transaction::SignedTransaction;
 
@@ -154,7 +154,7 @@ pub trait MinerService : Send + Sync {
 	/// Suggested gas limit.
 	fn sensible_gas_limit(&self) -> U256 { x!(21000) }
 
-	/// Account balance
+	/// Latest account balance in pending state.
 	fn balance(&self, chain: &BlockChainClient, address: &Address) -> U256;
 
 	/// Call into contract code using pending state.

miner/src/miner.rs

@@ -167,8 +167,8 @@ impl Miner {
 		};
 		let mut queue = self.transaction_queue.lock().unwrap();
 		let fetch_account = |a: &Address| AccountDetails {
-			nonce: chain.nonce(a),
+			nonce: chain.latest_nonce(a),
-			balance: chain.balance(a),
+			balance: chain.latest_balance(a),
 		};
 		for hash in invalid_transactions.into_iter() {
 			queue.remove_invalid(&hash, &fetch_account);
@@ -290,17 +290,23 @@ impl MinerService for Miner {
 
 	fn balance(&self, chain: &BlockChainClient, address: &Address) -> U256 {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		sealing_work.peek_last_ref().map_or_else(|| chain.balance(address), |b| b.block().fields().state.balance(address))
+		sealing_work.peek_last_ref().map_or_else(
+			|| chain.latest_balance(address),
+			|b| b.block().fields().state.balance(address)
+		)
 	}
 
 	fn storage_at(&self, chain: &BlockChainClient, address: &Address, position: &H256) -> H256 {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		sealing_work.peek_last_ref().map_or_else(|| chain.storage_at(address, position), |b| b.block().fields().state.storage_at(address, position))
+		sealing_work.peek_last_ref().map_or_else(
+			|| chain.latest_storage_at(address, position),
+			|b| b.block().fields().state.storage_at(address, position)
+		)
 	}
 
 	fn nonce(&self, chain: &BlockChainClient, address: &Address) -> U256 {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		sealing_work.peek_last_ref().map_or_else(|| chain.nonce(address), |b| b.block().fields().state.nonce(address))
+		sealing_work.peek_last_ref().map_or_else(|| chain.latest_nonce(address), |b| b.block().fields().state.nonce(address))
 	}
 
 	fn code(&self, chain: &BlockChainClient, address: &Address) -> Option<Bytes> {
@@ -545,8 +551,8 @@ impl MinerService for Miner {
 					let _sender = tx.sender();
 				}
 				let _ = self.import_transactions(txs, |a| AccountDetails {
-					nonce: chain.nonce(a),
+					nonce: chain.latest_nonce(a),
-					balance: chain.balance(a),
+					balance: chain.latest_balance(a),
 				});
 			});
 		}
@@ -566,7 +572,7 @@ impl MinerService for Miner {
 						})
 						.collect::<HashSet<Address>>();
 				for sender in to_remove.into_iter() {
-					transaction_queue.remove_all(sender, chain.nonce(&sender));
+					transaction_queue.remove_all(sender, chain.latest_nonce(&sender));
 				}
 			});
 		}

rpc/src/v1/impls/eth.rs

@@ -26,7 +26,7 @@ use ethminer::{MinerService, AccountDetails, ExternalMinerService};
 use jsonrpc_core::*;
 use util::numbers::*;
 use util::sha3::*;
-use util::bytes::{ToPretty};
+use util::bytes::ToPretty;
 use util::rlp::{encode, decode, UntrustedRlp, View};
 use ethcore::client::{BlockChainClient, BlockID, TransactionID, UncleID};
 use ethcore::block::IsBlock;
@@ -164,7 +164,7 @@ impl<C, S, A, M, EM> EthClient<C, S, A, M, EM> where
 					.or_else(|| miner
 							 .last_nonce(&request.from)
 							 .map(|nonce| nonce + U256::one()))
-					.unwrap_or_else(|| client.nonce(&request.from)),
+					.unwrap_or_else(|| client.latest_nonce(&request.from)),
 					action: request.to.map_or(Action::Create, Action::Call),
 					gas: request.gas.unwrap_or_else(|| miner.sensible_gas_limit()),
 					gas_price: request.gas_price.unwrap_or_else(|| miner.sensible_gas_price()),
@@ -181,7 +181,7 @@ impl<C, S, A, M, EM> EthClient<C, S, A, M, EM> where
 		let miner = take_weak!(self.miner);
 		let from = request.from.unwrap_or(Address::zero());
 		Ok(EthTransaction {
-			nonce: request.nonce.unwrap_or_else(|| client.nonce(&from)),
+			nonce: request.nonce.unwrap_or_else(|| client.latest_nonce(&from)),
 			action: request.to.map_or(Action::Create, Action::Call),
 			gas: request.gas.unwrap_or(U256::from(50_000_000)),
 			gas_price: request.gas_price.unwrap_or_else(|| miner.sensible_gas_price()),
@@ -199,8 +199,8 @@ impl<C, S, A, M, EM> EthClient<C, S, A, M, EM> where
 
 			miner.import_own_transaction(client.deref(), signed_transaction, |a: &Address| {
 				AccountDetails {
-					nonce: client.nonce(&a),
+					nonce: client.latest_nonce(&a),
-					balance: client.balance(&a),
+					balance: client.latest_balance(&a),
 				}
 			})
 		};
@@ -257,6 +257,17 @@ fn pending_logs<M>(miner: &M, filter: &EthcoreFilter) -> Vec<Log> where M: Miner
 	result
 }
 
+// must be in range [-32099, -32000]
+const UNSUPPORTED_REQUEST_CODE: i64 = -32000;
+
+fn make_unsupported_err() -> Error {
+	Error {
+		code: ErrorCode::ServerError(UNSUPPORTED_REQUEST_CODE),
+		message: "Unsupported request.".into(),
+		data: None
+	}
+}
+
 impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 	C: BlockChainClient + 'static,
 	S: SyncProvider + 'static,
@@ -341,18 +352,19 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 	fn balance(&self, params: Params) -> Result<Value, Error> {
 		from_params_default_second(params)
 			.and_then(|(address, block_number,)| match block_number {
-				BlockNumber::Latest => to_value(&take_weak!(self.client).balance(&address)),
 				BlockNumber::Pending => to_value(&take_weak!(self.miner).balance(take_weak!(self.client).deref(), &address)),
-				_ => Err(Error::invalid_params()),
+				id => to_value(&try!(take_weak!(self.client).balance(&address, id.into()).ok_or_else(make_unsupported_err))),
 			})
 	}
 
 	fn storage_at(&self, params: Params) -> Result<Value, Error> {
 		from_params_default_third::<Address, U256>(params)
 			.and_then(|(address, position, block_number,)| match block_number {
-				BlockNumber::Pending => to_value(&U256::from(take_weak!(self.miner).storage_at(take_weak!(self.client).deref(), &address, &H256::from(position)))),
+				BlockNumber::Pending => to_value(&U256::from(take_weak!(self.miner).storage_at(&*take_weak!(self.client), &address, &H256::from(position)))),
-				BlockNumber::Latest => to_value(&U256::from(take_weak!(self.client).storage_at(&address, &H256::from(position)))),
+				id => match take_weak!(self.client).storage_at(&address, &H256::from(position), id.into()) {
-				_ => Err(Error::invalid_params()),
+					Some(s) => to_value(&U256::from(s)),
+					None => Err(make_unsupported_err()), // None is only returned on unsupported requests.
+				}
 			})
 	}
 
@@ -360,8 +372,7 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 		from_params_default_second(params)
 			.and_then(|(address, block_number,)| match block_number {
 				BlockNumber::Pending => to_value(&take_weak!(self.miner).nonce(take_weak!(self.client).deref(), &address)),
-				BlockNumber::Latest => to_value(&take_weak!(self.client).nonce(&address)),
+				id => to_value(&take_weak!(self.client).nonce(&address, id.into())),
-				_ => Err(Error::invalid_params()),
 			})
 	}
 

sync/src/chain.rs

@@ -900,8 +900,8 @@ impl ChainSync {
 		}
 		let chain = io.chain();
 		let fetch_account = |a: &Address| AccountDetails {
-			nonce: chain.nonce(a),
+			nonce: chain.latest_nonce(a),
-			balance: chain.balance(a),
+			balance: chain.latest_balance(a),
 		};
 		let _ = self.miner.import_transactions(transactions, fetch_account);
 		Ok(())