From 86eab79d9de8946d67922a0bea2360384e54e413 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Thu, 26 May 2016 11:46:45 +0200 Subject: [PATCH] consolidate [balance/storage]_at and _at_id functionality --- ethcore/src/client/client.rs | 29 ++++++++++------------------ ethcore/src/client/mod.rs | 32 +++++++------------------------ ethcore/src/client/test_client.rs | 16 ++++++++++++---- miner/src/miner.rs | 14 ++++++++++---- rpc/src/v1/impls/eth.rs | 13 +++++++------ sync/src/chain.rs | 2 +- 6 files changed, 47 insertions(+), 59 deletions(-) diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index c28493d7a..1b31a7b3b 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -349,7 +349,12 @@ impl Client where V: Verifier { /// Attempt to get a copy of a specific block's state. /// /// This can fail (but may not) if the DB prunes state. - pub fn state_at_id(&self, id: BlockID) -> Option { + pub fn state_at(&self, id: BlockID) -> Option { + // 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()) @@ -563,26 +568,12 @@ impl BlockChainClient for Client where V: Verifier { self.state().code(address) } - fn balance(&self, address: &Address) -> U256 { - self.state().balance(address) + fn balance(&self, address: &Address, id: BlockID) -> Option { + self.state_at(id).map(|s| s.balance(address)) } - fn balance_at_id(&self, address: &Address, id: BlockID) -> Option { - match id { - BlockID::Latest => Some(self.balance(address)), - id => self.state_at_id(id).map(|s| s.balance(address)), - } - } - - fn storage_at(&self, address: &Address, position: &H256) -> H256 { - self.state().storage_at(address, position) - } - - fn storage_at_id(&self, address: &Address, position: &H256, id: BlockID) -> Option { - match id { - BlockID::Latest => Some(self.storage_at(address, position)), - id => self.state_at_id(id).map(|s| s.storage_at(address, position)), - } + fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option { + self.state_at(id).map(|s| s.storage_at(address, position)) } fn transaction(&self, id: TransactionID) -> Option { diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs index 75517190f..988dac023 100644 --- a/ethcore/src/client/mod.rs +++ b/ethcore/src/client/mod.rs @@ -74,33 +74,15 @@ pub trait BlockChainClient : Sync + Send { /// Get address code. fn code(&self, address: &Address) -> Option; - /// Get address balance at latest state. - fn balance(&self, address: &Address) -> U256; - - /// Account balance at a specific block ID. + /// Get address balance at the given block's state. /// - /// Must not fail if `id` is `BlockID::Latest`. - /// Will fail if the block is not valid or the block's root hash has been - /// pruned from the DB. - fn balance_at_id(&self, address: &Address, id: BlockID) -> Option { - if let BlockID::Latest = id { - Some(self.balance(address)) - } else { - None - } - } + /// 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; - /// Get value of the storage at given position from the latest state. - fn storage_at(&self, address: &Address, position: &H256) -> H256; - - /// Get value of the storage at given position form the latest state. - fn storage_at_id(&self, address: &Address, position: &H256, id: BlockID) -> Option { - if let BlockID::Latest = id { - Some(self.storage_at(address, position)) - } else { - None - } - } + /// Get value of the storage at given position at the given block. + /// + /// 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; /// Get transaction with given hash. fn transaction(&self, id: TransactionID) -> Option; diff --git a/ethcore/src/client/test_client.rs b/ethcore/src/client/test_client.rs index a60218a31..3e7608395 100644 --- a/ethcore/src/client/test_client.rs +++ b/ethcore/src/client/test_client.rs @@ -253,12 +253,20 @@ impl BlockChainClient for TestBlockChainClient { self.code.read().unwrap().get(address).cloned() } - fn balance(&self, address: &Address) -> U256 { - self.balances.read().unwrap().get(address).cloned().unwrap_or_else(U256::zero) + fn balance(&self, address: &Address, id: BlockID) -> Option { + 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 { - self.storage.read().unwrap().get(&(address.clone(), position.clone())).cloned().unwrap_or_else(H256::new) + fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option { + 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 { diff --git a/miner/src/miner.rs b/miner/src/miner.rs index f159cac1c..efb2f2c77 100644 --- a/miner/src/miner.rs +++ b/miner/src/miner.rs @@ -168,7 +168,7 @@ impl Miner { let mut queue = self.transaction_queue.lock().unwrap(); let fetch_account = |a: &Address| AccountDetails { nonce: chain.nonce(a), - balance: chain.balance(a), + balance: chain.balance(a, BlockID::Latest).unwrap(), }; for hash in invalid_transactions.into_iter() { queue.remove_invalid(&hash, &fetch_account); @@ -290,12 +290,18 @@ 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.balance(address, BlockID::Latest).unwrap(), + |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.storage_at(address, position, BlockID::Latest).unwrap(), + |b| b.block().fields().state.storage_at(address, position) + ) } fn nonce(&self, chain: &BlockChainClient, address: &Address) -> U256 { @@ -546,7 +552,7 @@ impl MinerService for Miner { } let _ = self.import_transactions(txs, |a| AccountDetails { nonce: chain.nonce(a), - balance: chain.balance(a), + balance: chain.balance(a, BlockID::Latest).unwrap(), }); }); } diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index 2751444e2..2aa5ff3f2 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -28,7 +28,7 @@ use util::numbers::*; use util::sha3::*; use util::bytes::ToPretty; use util::rlp::{encode, decode, UntrustedRlp, View}; -use ethcore::client::{self, BlockChainClient, BlockID, TransactionID, UncleID}; +use ethcore::client::{BlockChainClient, BlockID, TransactionID, UncleID}; use ethcore::block::IsBlock; use ethcore::views::*; use ethcore::ethereum::Ethash; @@ -200,7 +200,7 @@ impl EthClient where miner.import_own_transaction(client.deref(), signed_transaction, |a: &Address| { AccountDetails { nonce: client.nonce(&a), - balance: client.balance(&a), + balance: client.balance(&a, BlockID::Latest).unwrap(), } }) }; @@ -352,9 +352,8 @@ impl Eth for EthClient where fn balance(&self, params: Params) -> Result { 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)), - id => to_value(&try!(take_weak!(self.client).balance_at_id(&address, id.into()).ok_or_else(make_unsupported_err))), + id => to_value(&try!(take_weak!(self.client).balance(&address, id.into()).ok_or_else(make_unsupported_err))), }) } @@ -362,8 +361,10 @@ impl Eth for EthClient where from_params_default_third::(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), &address, &H256::from(position)))), - BlockNumber::Latest => to_value(&U256::from(take_weak!(self.client).storage_at(&address, &H256::from(position)))), - id => to_value(&try!(take_weak!(self.client).storage_at_id(&address, &H256::from(position), id.into()).ok_or_else(make_unsupported_err))), + id => match take_weak!(self.client).storage_at(&address, &H256::from(position), id.into()) { + Some(s) => to_value(&U256::from(s)), + None => Err(make_unsupported_err()), // None is only returned on unsupported requests. + } }) } diff --git a/sync/src/chain.rs b/sync/src/chain.rs index 2a59d36df..5f9cf6371 100644 --- a/sync/src/chain.rs +++ b/sync/src/chain.rs @@ -901,7 +901,7 @@ impl ChainSync { let chain = io.chain(); let fetch_account = |a: &Address| AccountDetails { nonce: chain.nonce(a), - balance: chain.balance(a), + balance: chain.balance(a, BlockID::Latest).unwrap(), }; let _ = self.miner.import_transactions(transactions, fetch_account); Ok(())