From 0d09a473a70ef690744949c73d861c3c6b84dc86 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Thu, 9 Feb 2017 20:38:43 +0100 Subject: [PATCH] remove let inner pattern with take_weakf and try_bf --- rpc/src/v1/helpers/dispatch.rs | 79 +++++++++----------- rpc/src/v1/impls/eth.rs | 133 +++++++++++++-------------------- rpc/src/v1/mod.rs | 11 +++ 3 files changed, 101 insertions(+), 122 deletions(-) diff --git a/rpc/src/v1/helpers/dispatch.rs b/rpc/src/v1/helpers/dispatch.rs index 47f5b4b9c..0fbe318d4 100644 --- a/rpc/src/v1/helpers/dispatch.rs +++ b/rpc/src/v1/helpers/dispatch.rs @@ -92,57 +92,50 @@ impl Dispatcher for FullDispatcher BoxFuture { - let inner = move || { - let (client, miner) = (take_weak!(self.client), take_weak!(self.miner)); - let request = request; - Ok(FilledTransactionRequest { - from: request.from.unwrap_or(default_sender), - used_default_from: request.from.is_none(), - to: request.to, - nonce: request.nonce, - gas_price: request.gas_price.unwrap_or_else(|| default_gas_price(&*client, &*miner)), - gas: request.gas.unwrap_or_else(|| miner.sensible_gas_limit()), - value: request.value.unwrap_or_else(|| 0.into()), - data: request.data.unwrap_or_else(Vec::new), - condition: request.condition, - }) - }; - future::done(inner()).boxed() + let (client, miner) = (take_weakf!(self.client), take_weakf!(self.miner)); + let request = request; + future::ok(FilledTransactionRequest { + from: request.from.unwrap_or(default_sender), + used_default_from: request.from.is_none(), + to: request.to, + nonce: request.nonce, + gas_price: request.gas_price.unwrap_or_else(|| default_gas_price(&*client, &*miner)), + gas: request.gas.unwrap_or_else(|| miner.sensible_gas_limit()), + value: request.value.unwrap_or_else(|| 0.into()), + data: request.data.unwrap_or_else(Vec::new), + condition: request.condition, + }).boxed() } fn sign(&self, accounts: &AccountProvider, filled: FilledTransactionRequest, password: SignWith) -> BoxFuture, Error> { - let inner = move || { - let (client, miner) = (take_weak!(self.client), take_weak!(self.miner)); - let network_id = client.signing_network_id(); - let address = filled.from; - let signed_transaction = { - let t = Transaction { - nonce: filled.nonce - .or_else(|| miner - .last_nonce(&filled.from) - .map(|nonce| nonce + U256::one())) - .unwrap_or_else(|| client.latest_nonce(&filled.from)), + let (client, miner) = (take_weakf!(self.client), take_weakf!(self.miner)); + let network_id = client.signing_network_id(); + let address = filled.from; + future::ok({ + let t = Transaction { + nonce: filled.nonce + .or_else(|| miner + .last_nonce(&filled.from) + .map(|nonce| nonce + U256::one())) + .unwrap_or_else(|| client.latest_nonce(&filled.from)), - action: filled.to.map_or(Action::Create, Action::Call), - gas: filled.gas, - gas_price: filled.gas_price, - value: filled.value, - data: filled.data, - }; - - let hash = t.hash(network_id); - let signature = signature(accounts, address, hash, password)?; - signature.map(|sig| { - SignedTransaction::new(t.with_signature(sig, network_id)) - .expect("Transaction was signed by AccountsProvider; it never produces invalid signatures; qed") - }) + action: filled.to.map_or(Action::Create, Action::Call), + gas: filled.gas, + gas_price: filled.gas_price, + value: filled.value, + data: filled.data, }; - Ok(signed_transaction) - }; - future::done(inner()).boxed() + let hash = t.hash(network_id); + let signature = try_bf!(signature(accounts, address, hash, password)); + + signature.map(|sig| { + SignedTransaction::new(t.with_signature(sig, network_id)) + .expect("Transaction was signed by AccountsProvider; it never produces invalid signatures; qed") + }) + }).boxed() } fn dispatch_transaction(&self, signed_transaction: PendingTransaction) -> Result { diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index 3747c6192..7a954ccaf 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -359,133 +359,108 @@ impl Eth for EthClient where fn balance(&self, address: RpcH160, num: Trailing) -> BoxFuture { let address = address.into(); - let inner = || { - match num.0.clone() { - BlockNumber::Pending => Ok(take_weak!(self.miner).balance(&*take_weak!(self.client), &address).into()), - id => { - let client = take_weak!(self.client); + let res = match num.0.clone() { + BlockNumber::Pending => Ok(take_weakf!(self.miner).balance(&*take_weakf!(self.client), &address).into()), + id => { + let client = take_weakf!(self.client); - check_known(&*client, id.clone())?; - match client.balance(&address, id.into()) { - Some(balance) => Ok(balance.into()), - None => Err(errors::state_pruned()), - } + try_bf!(check_known(&*client, id.clone())); + match client.balance(&address, id.into()) { + Some(balance) => Ok(balance.into()), + None => Err(errors::state_pruned()), } } }; - future::done(inner()).boxed() + future::done(res).boxed() } fn storage_at(&self, address: RpcH160, pos: RpcU256, num: Trailing) -> BoxFuture { let address: Address = RpcH160::into(address); let position: U256 = RpcU256::into(pos); - let inner = || { - match num.0.clone() { - BlockNumber::Pending => Ok(take_weak!(self.miner).storage_at(&*take_weak!(self.client), &address, &H256::from(position)).into()), - id => { - let client = take_weak!(self.client); + let res = match num.0.clone() { + BlockNumber::Pending => Ok(take_weakf!(self.miner).storage_at(&*take_weakf!(self.client), &address, &H256::from(position)).into()), + id => { + let client = take_weakf!(self.client); - check_known(&*client, id.clone())?; - match client.storage_at(&address, &H256::from(position), id.into()) { - Some(s) => Ok(s.into()), - None => Err(errors::state_pruned()), - } + try_bf!(check_known(&*client, id.clone())); + match client.storage_at(&address, &H256::from(position), id.into()) { + Some(s) => Ok(s.into()), + None => Err(errors::state_pruned()), } } }; - future::done(inner()).boxed() + future::done(res).boxed() } fn transaction_count(&self, address: RpcH160, num: Trailing) -> BoxFuture { let address: Address = RpcH160::into(address); - let inner = move || { - match num.0.clone() { - BlockNumber::Pending => Ok(take_weak!(self.miner).nonce(&*take_weak!(self.client), &address).into()), - id => { - let client = take_weak!(self.client); + let res = match num.0.clone() { + BlockNumber::Pending => Ok(take_weakf!(self.miner).nonce(&*take_weakf!(self.client), &address).into()), + id => { + let client = take_weakf!(self.client); - check_known(&*client, id.clone())?; - match client.nonce(&address, id.into()) { - Some(nonce) => Ok(nonce.into()), - None => Err(errors::state_pruned()), - } + try_bf!(check_known(&*client, id.clone())); + match client.nonce(&address, id.into()) { + Some(nonce) => Ok(nonce.into()), + None => Err(errors::state_pruned()), } } }; - future::done(inner()).boxed() + future::done(res).boxed() } fn block_transaction_count_by_hash(&self, hash: RpcH256) -> BoxFuture, Error> { - let inner = || { - Ok(take_weak!(self.client).block(BlockId::Hash(hash.into())) - .map(|block| block.transactions_count().into())) - }; - - future::done(inner()).boxed() + future::ok(take_weakf!(self.client).block(BlockId::Hash(hash.into())) + .map(|block| block.transactions_count().into())).boxed() } fn block_transaction_count_by_number(&self, num: BlockNumber) -> BoxFuture, Error> { - let inner = || { - match num { - BlockNumber::Pending => Ok(Some( - take_weak!(self.miner).status().transactions_in_pending_block.into() - )), - _ => Ok( - take_weak!(self.client).block(num.into()) - .map(|block| block.transactions_count().into()) - ) - } - }; - - future::done(inner()).boxed() + future::ok(match num { + BlockNumber::Pending => Some( + take_weakf!(self.miner).status().transactions_in_pending_block.into() + ), + _ => + take_weakf!(self.client).block(num.into()) + .map(|block| block.transactions_count().into()) + }).boxed() } fn block_uncles_count_by_hash(&self, hash: RpcH256) -> BoxFuture, Error> { - let inner = || { - Ok(take_weak!(self.client).block(BlockId::Hash(hash.into())) + future::ok(take_weakf!(self.client).block(BlockId::Hash(hash.into())) .map(|block| block.uncles_count().into())) - }; - - future::done(inner()).boxed() + .boxed() } fn block_uncles_count_by_number(&self, num: BlockNumber) -> BoxFuture, Error> { - let inner = || { - match num { - BlockNumber::Pending => Ok(Some(0.into())), - _ => Ok( - take_weak!(self.client).block(num.into()) - .map(|block| block.uncles_count().into()) - ), - } - }; - - future::done(inner()).boxed() + future::ok(match num { + BlockNumber::Pending => Some(0.into()), + _ => take_weakf!(self.client).block(num.into()) + .map(|block| block.uncles_count().into() + ), + }).boxed() } fn code_at(&self, address: RpcH160, num: Trailing) -> BoxFuture { let address: Address = RpcH160::into(address); - let inner = || { - match num.0.clone() { - BlockNumber::Pending => Ok(take_weak!(self.miner).code(&*take_weak!(self.client), &address).map_or_else(Bytes::default, Bytes::new)), - id => { - let client = take_weak!(self.client); + let res = match num.0.clone() { + BlockNumber::Pending => Ok(take_weakf!(self.miner).code(&*take_weakf!(self.client), &address).map_or_else(Bytes::default, Bytes::new)), + id => { + let client = take_weakf!(self.client); - check_known(&*client, id.clone())?; - match client.code(&address, id.into()) { - Some(code) => Ok(code.map_or_else(Bytes::default, Bytes::new)), - None => Err(errors::state_pruned()), - } + try_bf!(check_known(&*client, id.clone())); + match client.code(&address, id.into()) { + Some(code) => Ok(code.map_or_else(Bytes::default, Bytes::new)), + None => Err(errors::state_pruned()), } } }; - future::done(inner()).boxed() + future::done(res).boxed() } fn block_by_hash(&self, hash: RpcH256, include_txs: bool) -> BoxFuture, Error> { diff --git a/rpc/src/v1/mod.rs b/rpc/src/v1/mod.rs index b54f444c1..c69acbea3 100644 --- a/rpc/src/v1/mod.rs +++ b/rpc/src/v1/mod.rs @@ -38,6 +38,17 @@ macro_rules! take_weakf { } } +// short for "try_boxfuture" +// unwrap a result, returning a BoxFuture<_, Err> on failure. +macro_rules! try_bf { + ($res: expr) => { + match $res { + Ok(val) => val, + Err(e) => return ::futures::future::err(e.into()).boxed(), + } + } +} + #[macro_use] mod helpers; mod impls;