diff --git a/parity/rpc_apis.rs b/parity/rpc_apis.rs index 9287f6272..288f85ab4 100644 --- a/parity/rpc_apis.rs +++ b/parity/rpc_apis.rs @@ -283,7 +283,7 @@ impl FullDependencies { handler.extend_with(DebugClient::new(self.client.clone()).to_delegate()); } Api::Web3 => { - handler.extend_with(Web3Client::new().to_delegate()); + handler.extend_with(Web3Client::default().to_delegate()); } Api::Net => { handler.extend_with(NetClient::new(&self.sync).to_delegate()); @@ -529,7 +529,7 @@ impl LightDependencies { warn!(target: "rpc", "Debug API is not available in light client mode.") } Api::Web3 => { - handler.extend_with(Web3Client::new().to_delegate()); + handler.extend_with(Web3Client::default().to_delegate()); } Api::Net => { handler.extend_with(light::NetClient::new(self.sync.clone()).to_delegate()); diff --git a/rpc/src/authcodes.rs b/rpc/src/authcodes.rs index 976ce1a3f..b348dfd72 100644 --- a/rpc/src/authcodes.rs +++ b/rpc/src/authcodes.rs @@ -51,7 +51,7 @@ const TIME_THRESHOLD: u64 = 7; /// minimal length of hash const TOKEN_LENGTH: usize = 16; /// Separator between fields in serialized tokens file. -const SEPARATOR: &'static str = ";"; +const SEPARATOR: &str = ";"; /// Number of seconds to keep unused tokens. const UNUSED_TOKEN_TIMEOUT: u64 = 3600 * 24; // a day @@ -115,7 +115,7 @@ impl AuthCodes { }) .collect(); Ok(AuthCodes { - codes: codes, + codes, now: time_provider, }) } @@ -128,7 +128,7 @@ impl AuthCodes { pub fn to_file(&self, file: &Path) -> io::Result<()> { let mut file = fs::File::create(file)?; let content = self.codes.iter().map(|code| { - let mut data = vec![code.code.clone(), encode_time(code.created_at.clone())]; + let mut data = vec![code.code.clone(), encode_time(code.created_at)]; if let Some(used_at) = code.last_used_at { data.push(encode_time(used_at)); } @@ -141,11 +141,11 @@ impl AuthCodes { pub fn new(codes: Vec, now: T) -> Self { AuthCodes { codes: codes.into_iter().map(|code| Code { - code: code, + code, created_at: time::Duration::from_secs(now.now()), last_used_at: None, }).collect(), - now: now, + now, } } @@ -183,7 +183,7 @@ impl AuthCodes { .join("-"); trace!(target: "signer", "New authentication token generated."); self.codes.push(Code { - code: code, + code, created_at: time::Duration::from_secs(self.now.now()), last_used_at: None, }); diff --git a/rpc/src/http_common.rs b/rpc/src/http_common.rs index 517bbbf76..99bd392f3 100644 --- a/rpc/src/http_common.rs +++ b/rpc/src/http_common.rs @@ -44,7 +44,7 @@ impl http::MetaExtractor for MetaExtractor where { fn read_metadata(&self, req: &hyper::Request) -> M { let as_string = |header: Option<&hyper::header::HeaderValue>| { - header.and_then(|val| val.to_str().ok().map(|s| s.to_owned())) + header.and_then(|val| val.to_str().ok().map(ToOwned::to_owned)) }; let origin = as_string(req.headers().get("origin")); diff --git a/rpc/src/lib.rs b/rpc/src/lib.rs index cafd7a8e4..a537cb294 100644 --- a/rpc/src/lib.rs +++ b/rpc/src/lib.rs @@ -17,6 +17,25 @@ //! Parity RPC. #![warn(missing_docs, unused_extern_crates)] +#![cfg_attr(feature = "cargo-clippy", warn(clippy::all, clippy::pedantic))] +#![cfg_attr( + feature = "cargo-clippy", + allow( + // things are often more readable this way + clippy::cast_lossless, + clippy::module_name_repetitions, + clippy::single_match_else, + clippy::type_complexity, + clippy::use_self, + // not practical + clippy::match_bool, + clippy::needless_pass_by_value, + clippy::similar_names, + // don't require markdown syntax for docs + clippy::doc_markdown, + ), + warn(clippy::indexing_slicing) +)] #[macro_use] extern crate futures; @@ -145,8 +164,8 @@ pub fn start_http( Ok(http::ServerBuilder::with_meta_extractor(handler, extractor) .keep_alive(keep_alive) .threads(threads) - .cors(cors_domains.into()) - .allowed_hosts(allowed_hosts.into()) + .cors(cors_domains) + .allowed_hosts(allowed_hosts) .health_api(("/api/health", "parity_nodeStatus")) .cors_allow_headers(AccessControlAllowHeaders::Any) .max_request_body_size(max_payload * 1024 * 1024) @@ -176,8 +195,8 @@ pub fn start_http_with_middleware( Ok(http::ServerBuilder::with_meta_extractor(handler, extractor) .keep_alive(keep_alive) .threads(threads) - .cors(cors_domains.into()) - .allowed_hosts(allowed_hosts.into()) + .cors(cors_domains) + .allowed_hosts(allowed_hosts) .cors_allow_headers(AccessControlAllowHeaders::Any) .max_request_body_size(max_payload * 1024 * 1024) .request_middleware(middleware) diff --git a/rpc/src/tests/helpers.rs b/rpc/src/tests/helpers.rs index fe04906d4..301d77e91 100644 --- a/rpc/src/tests/helpers.rs +++ b/rpc/src/tests/helpers.rs @@ -39,7 +39,7 @@ impl Server { Server { server: f(remote), - event_loop: event_loop, + event_loop, } } } @@ -60,8 +60,8 @@ pub struct GuardedAuthCodes { pub path: PathBuf, } -impl GuardedAuthCodes { - pub fn new() -> Self { +impl Default for GuardedAuthCodes { + fn default() -> Self { let tempdir = TempDir::new("").unwrap(); let path = tempdir.path().join("file"); diff --git a/rpc/src/tests/http_client.rs b/rpc/src/tests/http_client.rs index 7720f4254..0588c791e 100644 --- a/rpc/src/tests/http_client.rs +++ b/rpc/src/tests/http_client.rs @@ -30,7 +30,7 @@ pub struct Response { impl Response { pub fn assert_header(&self, header: &str, value: &str) { let header = format!("{}: {}", header, value); - assert!(self.headers.iter().find(|h| *h == &header).is_some(), "Couldn't find header {} in {:?}", header, &self.headers) + assert!(self.headers.iter().any(|h| h == &header), "Couldn't find header {} in {:?}", header, &self.headers) } pub fn assert_status(&self, status: &str) { @@ -98,35 +98,35 @@ pub fn request(address: &SocketAddr, request: &str) -> Response { let mut lines = response.lines(); let status = lines.next().expect("Expected a response").to_owned(); let headers_raw = read_block(&mut lines, false); - let headers = headers_raw.split('\n').map(|v| v.to_owned()).collect(); + let headers = headers_raw.split('\n').map(ToOwned::to_owned).collect(); let body = read_block(&mut lines, true); Response { - status: status, - headers: headers, - headers_raw: headers_raw, - body: body, + status, + headers, + headers_raw, + body, } } /// Check if all required security headers are present pub fn assert_security_headers_present(headers: &[String], port: Option) { - if let None = port { + if port.is_none() { assert!( - headers.iter().find(|header| header.as_str() == "X-Frame-Options: SAMEORIGIN").is_some(), + headers.iter().any(|header| header.as_str() == "X-Frame-Options: SAMEORIGIN") "X-Frame-Options: SAMEORIGIN missing: {:?}", headers ); } assert!( - headers.iter().find(|header| header.as_str() == "X-XSS-Protection: 1; mode=block").is_some(), + headers.iter().any(|header| header.as_str() == "X-XSS-Protection: 1; mode=block") "X-XSS-Protection missing: {:?}", headers ); assert!( - headers.iter().find(|header| header.as_str() == "X-Content-Type-Options: nosniff").is_some(), + headers.iter().any(|header| header.as_str() == "X-Content-Type-Options: nosniff") "X-Content-Type-Options missing: {:?}", headers ); assert!( - headers.iter().find(|header| header.starts_with("Content-Security-Policy: ")).is_some(), + headers.iter().any(|header| header.starts_with("Content-Security-Policy: ")) "Content-Security-Policy missing: {:?}", headers ) } diff --git a/rpc/src/tests/ws.rs b/rpc/src/tests/ws.rs index 7bb0b0089..3b6078882 100644 --- a/rpc/src/tests/ws.rs +++ b/rpc/src/tests/ws.rs @@ -29,7 +29,7 @@ use tests::http_client; pub fn serve() -> (Server, usize, GuardedAuthCodes) { let address = "127.0.0.1:0".parse().unwrap(); let io = MetaIoHandler::default(); - let authcodes = GuardedAuthCodes::new(); + let authcodes = GuardedAuthCodes::default(); let stats = Arc::new(informant::RpcStats::default()); let res = Server::new(|_| ::start_ws( diff --git a/rpc/src/v1/extractors.rs b/rpc/src/v1/extractors.rs index 2620125e0..d3384c2c1 100644 --- a/rpc/src/v1/extractors.rs +++ b/rpc/src/v1/extractors.rs @@ -41,8 +41,8 @@ impl HttpMetaExtractor for RpcExtractor { Metadata { origin: Origin::Rpc( format!("{} / {}", - origin.unwrap_or("unknown origin".to_string()), - user_agent.unwrap_or("unknown agent".to_string())) + origin.unwrap_or_else(|| "unknown origin".to_string()), + user_agent.unwrap_or_else(|| "unknown agent".to_string())) ), session: None, } @@ -67,7 +67,7 @@ impl WsExtractor { /// Creates new `WsExtractor` with given authcodes path. pub fn new(path: Option<&Path>) -> Self { WsExtractor { - authcodes_path: path.map(|p| p.to_owned()), + authcodes_path: path.map(ToOwned::to_owned), } } } @@ -80,7 +80,7 @@ impl ws::MetaExtractor for WsExtractor { Some(ref path) => { let authorization = req.protocols.get(0).and_then(|p| auth_token_hash(&path, p, true)); match authorization { - Some(id) => Origin::Signer { session: id.into() }, + Some(id) => Origin::Signer { session: id }, None => Origin::Ws { session: id.into() }, } }, @@ -186,7 +186,7 @@ impl WsStats { /// Creates new WS usage tracker. pub fn new(stats: Arc) -> Self { WsStats { - stats: stats, + stats, } } } @@ -210,7 +210,7 @@ impl> WsDispatcher { /// Create new `WsDispatcher` with given full handler. pub fn new(full_handler: core::MetaIoHandler) -> Self { WsDispatcher { - full_handler: full_handler, + full_handler, } } } @@ -229,7 +229,7 @@ impl> core::Middleware for WsDispatcher< X: core::futures::Future, Error=()> + Send + 'static, { let use_full = match &meta.origin { - &Origin::Signer { .. } => true, + Origin::Signer { .. } => true, _ => false, }; diff --git a/rpc/src/v1/helpers/deprecated.rs b/rpc/src/v1/helpers/deprecated.rs index eb754c01a..49e9d8b07 100644 --- a/rpc/src/v1/helpers/deprecated.rs +++ b/rpc/src/v1/helpers/deprecated.rs @@ -66,7 +66,7 @@ impl Instant> DeprecationNotice { pub fn print<'a, T: Into>>(&self, method: MethodName, details: T) { let now = (self.now)(); match self.next_warning_at.read().get(method) { - Some(next) if next > &now => return, + Some(next) if *next > now => return, _ => {}, } diff --git a/rpc/src/v1/helpers/dispatch/light.rs b/rpc/src/v1/helpers/dispatch/light.rs index 2913e52c8..59c3af523 100644 --- a/rpc/src/v1/helpers/dispatch/light.rs +++ b/rpc/src/v1/helpers/dispatch/light.rs @@ -147,19 +147,19 @@ where const DEFAULT_GAS_PRICE: U256 = U256([0, 0, 0, 21_000_000]); let gas_limit = self.client.best_block_header().gas_limit(); - let request_gas_price = request.gas_price.clone(); + let request_gas_price = request.gas_price; let from = request.from.unwrap_or(default_sender); let with_gas_price = move |gas_price| { let request = request; FilledTransactionRequest { - from: from.clone(), + from, used_default_from: request.from.is_none(), to: request.to, nonce: request.nonce, - gas_price: gas_price, + gas_price, gas: request.gas.unwrap_or_else(|| gas_limit / 3), - value: request.value.unwrap_or_else(|| 0.into()), + value: request.value.unwrap_or_default(), data: request.data.unwrap_or_else(Vec::new), condition: request.condition, } diff --git a/rpc/src/v1/helpers/dispatch/mod.rs b/rpc/src/v1/helpers/dispatch/mod.rs index 887720972..3f247f0c6 100644 --- a/rpc/src/v1/helpers/dispatch/mod.rs +++ b/rpc/src/v1/helpers/dispatch/mod.rs @@ -294,7 +294,7 @@ pub fn execute( Box::new( dispatcher.sign(request, &signer, pass, post_sign).map(|(hash, token)| { - WithToken::from((ConfirmationResponse::SendTransaction(hash.into()), token)) + WithToken::from((ConfirmationResponse::SendTransaction(hash), token)) }) ) }, @@ -368,13 +368,13 @@ pub fn from_rpc(payload: RpcConfirmationPayload, default_account: Address, di .map(ConfirmationPayload::SignTransaction)) }, RpcConfirmationPayload::Decrypt(RpcDecryptRequest { address, msg }) => { - Box::new(future::ok(ConfirmationPayload::Decrypt(address.into(), msg.into()))) + Box::new(future::ok(ConfirmationPayload::Decrypt(address, msg.into()))) }, RpcConfirmationPayload::EthSignMessage(RpcEthSignRequest { address, data }) => { - Box::new(future::ok(ConfirmationPayload::EthSignMessage(address.into(), data.into()))) + Box::new(future::ok(ConfirmationPayload::EthSignMessage(address, data.into()))) }, RpcConfirmationPayload::EIP191SignMessage(RpcSignRequest { address, data }) => { - Box::new(future::ok(ConfirmationPayload::SignMessage(address.into(), data.into()))) + Box::new(future::ok(ConfirmationPayload::SignMessage(address, data))) }, } } diff --git a/rpc/src/v1/helpers/external_signer/mod.rs b/rpc/src/v1/helpers/external_signer/mod.rs index 49bbaafe5..0797929cb 100644 --- a/rpc/src/v1/helpers/external_signer/mod.rs +++ b/rpc/src/v1/helpers/external_signer/mod.rs @@ -40,7 +40,7 @@ impl SignerService { SignerService { queue: Arc::new(ConfirmationsQueue::default()), generate_new_token: Box::new(new_token), - is_enabled: is_enabled, + is_enabled, } } diff --git a/rpc/src/v1/helpers/external_signer/oneshot.rs b/rpc/src/v1/helpers/external_signer/oneshot.rs index 623691d39..eac3dca7f 100644 --- a/rpc/src/v1/helpers/external_signer/oneshot.rs +++ b/rpc/src/v1/helpers/external_signer/oneshot.rs @@ -28,7 +28,7 @@ pub struct Sender { impl Sender { pub fn send(self, data: Res) { let res = self.sender.send(data); - if let Err(_) = res { + if res.is_err() { debug!(target: "rpc", "Responding to a no longer active request."); } } diff --git a/rpc/src/v1/helpers/external_signer/signing_queue.rs b/rpc/src/v1/helpers/external_signer/signing_queue.rs index 9bbc778ec..00a459a86 100644 --- a/rpc/src/v1/helpers/external_signer/signing_queue.rs +++ b/rpc/src/v1/helpers/external_signer/signing_queue.rs @@ -121,7 +121,7 @@ impl ConfirmationsQueue { )); // notify confirmation receiver about resolution - let result = result.ok_or(errors::request_rejected()); + let result = result.ok_or_else(errors::request_rejected); sender.sender.send(result); Some(sender.request) @@ -150,7 +150,7 @@ impl SigningQueue for ConfirmationsQueue { // Increment id let id = { let mut last_id = self.id.lock(); - *last_id = *last_id + U256::from(1); + *last_id += U256::from(1); *last_id }; // Add request to queue diff --git a/rpc/src/v1/helpers/fake_sign.rs b/rpc/src/v1/helpers/fake_sign.rs index 76d37aab2..9f9b7c8ed 100644 --- a/rpc/src/v1/helpers/fake_sign.rs +++ b/rpc/src/v1/helpers/fake_sign.rs @@ -24,16 +24,16 @@ pub fn sign_call(request: CallRequest) -> Result { let max_gas = U256::from(50_000_000); let gas = match request.gas { Some(gas) => gas, - None => max_gas * 10u32, + None => max_gas * 10_u32, }; - let from = request.from.unwrap_or(0.into()); + let from = request.from.unwrap_or_default(); Ok(Transaction { - nonce: request.nonce.unwrap_or_else(|| 0.into()), + nonce: request.nonce.unwrap_or_default(), action: request.to.map_or(Action::Create, Action::Call), gas, - gas_price: request.gas_price.unwrap_or_else(|| 0.into()), - value: request.value.unwrap_or(0.into()), + gas_price: request.gas_price.unwrap_or_default(), + value: request.value.unwrap_or_default(), data: request.data.unwrap_or_default(), }.fake_sign(from)) } diff --git a/rpc/src/v1/helpers/ipfs.rs b/rpc/src/v1/helpers/ipfs.rs index 928362cf8..93110dbf3 100644 --- a/rpc/src/v1/helpers/ipfs.rs +++ b/rpc/src/v1/helpers/ipfs.rs @@ -28,5 +28,5 @@ pub fn cid(content: Bytes) -> Result { let hash = digest::sha256(&content.0); let mh = multihash::encode(multihash::Hash::SHA2256, &*hash).map_err(errors::encoding)?; let cid = Cid::new(Codec::DagProtobuf, Version::V0, &mh); - Ok(cid.to_string().into()) + Ok(cid.to_string()) } diff --git a/rpc/src/v1/helpers/light_fetch.rs b/rpc/src/v1/helpers/light_fetch.rs index 3ac17c2fd..3d19e3fa8 100644 --- a/rpc/src/v1/helpers/light_fetch.rs +++ b/rpc/src/v1/helpers/light_fetch.rs @@ -121,7 +121,7 @@ pub fn extract_transaction_at_index(block: encoded::Block, index: usize) -> Opti cached_sender, } }) - .map(|tx| Transaction::from_localized(tx)) + .map(Transaction::from_localized) } // extract the header indicated by the given `HeaderRef` from the given responses. @@ -159,7 +159,7 @@ where let idx = reqs.len(); let hash_ref = Field::back_ref(idx, 0); reqs.push(req.into()); - reqs.push(request::HeaderByHash(hash_ref.clone()).into()); + reqs.push(request::HeaderByHash(hash_ref).into()); Ok(HeaderRef::Unresolved(idx + 1, hash_ref)) } @@ -197,7 +197,7 @@ where Err(e) => return Either::A(future::err(e)), }; - reqs.push(request::Account { header: header_ref.clone(), address: address }.into()); + reqs.push(request::Account { header: header_ref.clone(), address }.into()); let account_idx = reqs.len() - 1; reqs.push(request::Code { header: header_ref, code_hash: Field::back_ref(account_idx, 0) }.into()); @@ -216,7 +216,7 @@ where Err(e) => return Either::A(future::err(e)), }; - reqs.push(request::Account { header: header_ref, address: address }.into()); + reqs.push(request::Account { header: header_ref, address }.into()); Either::B(self.send_requests(reqs, |mut res|match res.pop() { Some(OnDemandResponse::Account(acc)) => acc, @@ -246,7 +246,7 @@ where } }; - let from = req.from.unwrap_or_else(|| Address::zero()); + let from = req.from.unwrap_or_default(); let nonce_fut = match req.nonce { Some(nonce) => Either::A(future::ok(Some(nonce))), None => Either::B(self.account(from, id).map(|acc| acc.map(|a| a.nonce))), @@ -370,10 +370,10 @@ where for (transaction_log_index, log) in receipt.logs.into_iter().enumerate() { if filter.matches(&log) { matches.insert((num, block_index), Log { - address: log.address.into(), + address: log.address, topics: log.topics.into_iter().map(Into::into).collect(), data: log.data.into(), - block_hash: Some(hash.into()), + block_hash: Some(hash), block_number: Some(num.into()), // No way to easily retrieve transaction hash, so let's just skip it. transaction_hash: None, @@ -410,8 +410,8 @@ where let mut blocks = BTreeMap::new(); for log in result.iter() { let block_hash = log.block_hash.as_ref().expect("Previously initialized with value; qed"); - blocks.entry(block_hash.clone()).or_insert_with(|| { - fetcher_block.block(BlockId::Hash(block_hash.clone().into())) + blocks.entry(*block_hash).or_insert_with(|| { + fetcher_block.block(BlockId::Hash(*block_hash)) }); } // future get blocks (unordered it) @@ -419,12 +419,12 @@ where let transactions_per_block: BTreeMap<_, _> = blocks.iter() .map(|block| (block.hash(), block.transactions())).collect(); for log in result.iter_mut() { - let log_index: U256 = log.transaction_index.expect("Previously initialized with value; qed").into(); - let block_hash = log.block_hash.clone().expect("Previously initialized with value; qed").into(); + let log_index = log.transaction_index.expect("Previously initialized with value; qed"); + let block_hash = log.block_hash.expect("Previously initialized with value; qed"); let tx_hash = transactions_per_block.get(&block_hash) // transaction index is from an enumerate call in log common so not need to check value .and_then(|txs| txs.get(log_index.as_usize())) - .map(|tr| tr.hash().into()); + .map(types::transaction::UnverifiedTransaction::hash); log.transaction_hash = tx_hash; } result @@ -442,7 +442,7 @@ where Box::new(future::loop_fn(params, move |(sync, on_demand)| { let maybe_future = sync.with_context(|ctx| { - let req = request::TransactionIndex(tx_hash.clone().into()); + let req = request::TransactionIndex(tx_hash.into()); on_demand.request(ctx, req) }); @@ -468,7 +468,7 @@ where let index = index.index as usize; let transaction = extract_transaction_at_index(blk, index); - if transaction.as_ref().map_or(true, |tx| tx.hash != tx_hash.into()) { + if transaction.as_ref().map_or(true, |tx| tx.hash != tx_hash) { // index is actively wrong: indicated block has // fewer transactions than necessary or the transaction // at that index had a different hash. @@ -522,7 +522,7 @@ where ) -> impl Future, Error = Error> { let fetch_hashes = [from_block, to_block].iter() .filter_map(|block_id| match block_id { - BlockId::Hash(hash) => Some(hash.clone()), + BlockId::Hash(hash) => Some(*hash), _ => None, }) .collect::>(); @@ -533,14 +533,14 @@ where self.headers_by_hash(&fetch_hashes[..]).and_then(move |mut header_map| { let (from_block_num, to_block_num) = { let block_number = |id| match id { - &BlockId::Earliest => 0, - &BlockId::Latest => best_number, - &BlockId::Hash(ref h) => - header_map.get(h).map(|hdr| hdr.number()) + BlockId::Earliest => 0, + BlockId::Latest => best_number, + BlockId::Hash(ref h) => + header_map.get(h).map(types::encoded::Header::number) .expect("from_block and to_block headers are fetched by hash; this closure is only called on from_block and to_block; qed"), - &BlockId::Number(x) => x, + BlockId::Number(x) => x, }; - (block_number(&from_block), block_number(&to_block)) + (block_number(from_block), block_number(to_block)) }; if to_block_num < from_block_num { @@ -557,7 +557,7 @@ where let headers_fut = fetcher.headers_range(from_block_num, to_block_num, to_header_hint); Either::B(headers_fut.map(move |headers| { // Validate from_block if it's a hash - let last_hash = headers.last().map(|hdr| hdr.hash()); + let last_hash = headers.last().map(types::encoded::Header::hash); match (last_hash, from_block) { (Some(h1), BlockId::Hash(h2)) if h1 != h2 => Vec::new(), _ => headers, @@ -578,15 +578,13 @@ where } self.send_requests(reqs, move |res| { - let headers = refs.drain() - .map(|(hash, header_ref)| { + refs.into_iter().map(|(hash, header_ref)| { let hdr = extract_header(&res, header_ref) .expect("these responses correspond to requests that header_ref belongs to; \ qed"); (hash, hdr) - }) - .collect(); - headers + }) + .collect() }) } @@ -678,7 +676,7 @@ where { fn clone(&self) -> Self { Self { - from: self.from.clone(), + from: self.from, tx: self.tx.clone(), hdr: self.hdr.clone(), env_info: self.env_info.clone(), @@ -719,7 +717,7 @@ where required, got); if required <= params.hdr.gas_limit() { params.tx.gas = required; - return Ok(future::Loop::Continue(params)) + Ok(future::Loop::Continue(params)) } else { warn!(target: "light_fetch", "Required gas is bigger than block header's gas dropping the request"); diff --git a/rpc/src/v1/helpers/signature.rs b/rpc/src/v1/helpers/signature.rs index 32827ea1e..b191a3737 100644 --- a/rpc/src/v1/helpers/signature.rs +++ b/rpc/src/v1/helpers/signature.rs @@ -45,7 +45,7 @@ pub fn verify_signature( let v = if v >= 35 { (v - 1) % 2 } else { v }; - let signature = Signature::from_rsv(&r.into(), &s.into(), v as u8); + let signature = Signature::from_rsv(&r, &s, v as u8); let public_key = recover(&signature, &hash).map_err(errors::encryption)?; let address = public_to_address(&public_key); Ok(RecoveredAccount { address, public_key, is_valid_for_current_chain }) diff --git a/rpc/src/v1/helpers/subscription_manager.rs b/rpc/src/v1/helpers/subscription_manager.rs index 4f50cad42..d83beb397 100644 --- a/rpc/src/v1/helpers/subscription_manager.rs +++ b/rpc/src/v1/helpers/subscription_manager.rs @@ -52,7 +52,7 @@ impl> GenericPollManager { pub fn new(rpc: MetaIoHandler) -> Self { GenericPollManager { subscribers: Default::default(), - rpc: rpc, + rpc, } } diff --git a/rpc/src/v1/helpers/work.rs b/rpc/src/v1/helpers/work.rs index 661b4cab8..b52cb70c5 100644 --- a/rpc/src/v1/helpers/work.rs +++ b/rpc/src/v1/helpers/work.rs @@ -29,15 +29,10 @@ pub fn submit_work_detail(client: &Arc, // TODO [ToDr] Should disallow submissions in case of PoA? trace!(target: "miner", "submit_work_detail: Decoded: nonce={}, pow_hash={}, mix_hash={}", nonce, pow_hash, mix_hash); let seal = vec![rlp::encode(&mix_hash), rlp::encode(&nonce)]; - let import = miner.submit_seal(pow_hash, seal) - .and_then(|block| client.import_sealed_block(block)); - match import { - Ok(hash) => { - Ok(hash.into()) - }, - Err(err) => { - warn!(target: "miner", "Cannot submit work - {:?}.", err); - Err(errors::cannot_submit_work(err)) - }, - } + miner.submit_seal(pow_hash, seal) + .and_then(|block| client.import_sealed_block(block)) + .map_err(|e| { + warn!(target: "miner", "Cannot submit work - {:?}.", e); + errors::cannot_submit_work(e) + }) } diff --git a/rpc/src/v1/impls/debug.rs b/rpc/src/v1/impls/debug.rs index abec9b1f8..e46dd628d 100644 --- a/rpc/src/v1/impls/debug.rs +++ b/rpc/src/v1/impls/debug.rs @@ -19,6 +19,7 @@ use std::sync::Arc; use ethcore::client::BlockChainClient; +use types::header::Header; use types::transaction::LocalizedTransaction; use jsonrpc_core::Result; @@ -50,7 +51,7 @@ impl Debug for DebugClient { let hash = block.header.hash(); RichBlock { inner: Block { - hash: Some(hash.into()), + hash: Some(hash), size: Some(block.bytes.len().into()), parent_hash: cast(block.header.parent_hash()), uncles_hash: cast(block.header.uncles_hash()), @@ -65,14 +66,14 @@ impl Debug for DebugClient { timestamp: block.header.timestamp().into(), difficulty: cast(block.header.difficulty()), total_difficulty: None, - seal_fields: block.header.seal().into_iter().cloned().map(Into::into).collect(), - uncles: block.uncles.into_iter().map(|u| u.hash().into()).collect(), + seal_fields: block.header.seal().iter().cloned().map(Into::into).collect(), + uncles: block.uncles.iter().map(Header::hash).collect(), transactions: BlockTransactions::Full(block.transactions .into_iter() .enumerate() .map(|(transaction_index, signed)| Transaction::from_localized(LocalizedTransaction { - block_number: number.into(), - block_hash: hash.into(), + block_number: number, + block_hash: hash, transaction_index, signed, cached_sender: None, diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index 31b8be10c..1b5fdf447 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -197,7 +197,7 @@ impl EthClient EthClient None, - false => Some(view.hash().into()), + false => Some(view.hash()), }, size: Some(block.rlp().as_raw().len().into()), - parent_hash: view.parent_hash().into(), - uncles_hash: view.uncles_hash().into(), - author: view.author().into(), - miner: view.author().into(), - state_root: view.state_root().into(), - transactions_root: view.transactions_root().into(), - receipts_root: view.receipts_root().into(), + parent_hash: view.parent_hash(), + uncles_hash: view.uncles_hash(), + author: view.author(), + miner: view.author(), + state_root: view.state_root(), + transactions_root: view.transactions_root(), + receipts_root: view.receipts_root(), number: match is_pending { true => None, false => Some(view.number().into()), }, - gas_used: view.gas_used().into(), - gas_limit: view.gas_limit().into(), + gas_used: view.gas_used(), + gas_limit: view.gas_limit(), logs_bloom: match is_pending { true => None, - false => Some(view.log_bloom().into()), + false => Some(view.log_bloom()), }, timestamp: view.timestamp().into(), - difficulty: view.difficulty().into(), - total_difficulty: Some(total_difficulty.into()), + difficulty: view.difficulty(), + total_difficulty: Some(total_difficulty), seal_fields: view.seal().into_iter().map(Into::into).collect(), - uncles: block.uncle_hashes().into_iter().map(Into::into).collect(), + uncles: block.uncle_hashes(), transactions: match include_txs { - true => BlockTransactions::Full(block.view().localized_transactions().into_iter().map(|t| Transaction::from_localized(t)).collect()), - false => BlockTransactions::Hashes(block.transaction_hashes().into_iter().map(Into::into).collect()), + true => BlockTransactions::Full(block.view().localized_transactions().into_iter().map(Transaction::from_localized).collect()), + false => BlockTransactions::Hashes(block.transaction_hashes()), }, extra_data: Bytes::new(view.extra_data()), }, @@ -334,7 +334,7 @@ impl EthClient EthClient { return Ok(None); } }; - let parent_difficulty = match client.block_total_difficulty(BlockId::Hash(uncle.parent_hash().clone())) { + let parent_difficulty = match client.block_total_difficulty(BlockId::Hash(*uncle.parent_hash())) { Some(difficulty) => difficulty, None => { return Ok(None); } }; @@ -398,29 +398,28 @@ impl EthClient(miner: &M, best_block: EthBlockNumber, filter: &EthcoreFi .filter(|pair| filter.matches(&pair.1)) .map(|pair| { let mut log = Log::from(pair.1); - log.transaction_hash = Some(pair.0.into()); + log.transaction_hash = Some(pair.0); log }) .collect() @@ -518,8 +517,8 @@ impl Eth for EthClient< let info = SyncInfo { starting_block: status.start_block_number.into(), - current_block: current_block.into(), - highest_block: highest_block.into(), + current_block, + highest_block, warp_chunks_amount: warp_chunks_amount.map(|x| U256::from(x as u64)).map(Into::into), warp_chunks_processed: warp_chunks_processed.map(|x| U256::from(x as u64)).map(Into::into), }; @@ -535,10 +534,9 @@ impl Eth for EthClient< (self.accounts)() .first() .cloned() - .map(From::from) .ok_or_else(|| errors::account("No accounts were found", "")) } else { - Ok(H160::from(miner)) + Ok(miner) } } @@ -551,18 +549,18 @@ impl Eth for EthClient< } fn hashrate(&self) -> Result { - Ok(U256::from(self.external_miner.hashrate())) + Ok(self.external_miner.hashrate()) } fn gas_price(&self) -> Result { - Ok(U256::from(default_gas_price(&*self.client, &*self.miner, self.options.gas_price_percentile))) + Ok(default_gas_price(&*self.client, &*self.miner, self.options.gas_price_percentile)) } fn accounts(&self) -> Result> { self.deprecation_notice.print("eth_accounts", deprecated::msgs::ACCOUNTS); let accounts = (self.accounts)(); - Ok(accounts.into_iter().map(Into::into).collect()) + Ok(accounts) } fn block_number(&self) -> Result { @@ -574,7 +572,7 @@ impl Eth for EthClient< try_bf!(check_known(&*self.client, num.clone())); let res = match self.client.balance(&address, self.get_state(num)) { - Some(balance) => Ok(balance.into()), + Some(balance) => Ok(balance), None => Err(errors::state_pruned()), }; @@ -600,16 +598,16 @@ impl Eth for EthClient< try_bf!(check_known(&*self.client, num.clone())); let res = match self.client.prove_account(key1, id) { Some((proof, account)) => Ok(EthAccount { - address: address, - balance: account.balance.into(), - nonce: account.nonce.into(), - code_hash: account.code_hash.into(), - storage_hash: account.storage_root.into(), + address, + balance: account.balance, + nonce: account.nonce, + code_hash: account.code_hash, + storage_hash: account.storage_root, account_proof: proof.into_iter().map(Bytes::new).collect(), storage_proof: values.into_iter().filter_map(|storage_index| { - let key2: H256 = storage_index.into(); + let key2: H256 = storage_index; self.client.prove_storage(key1, keccak(key2), id) - .map(|(storage_proof,storage_value)| StorageProof { + .map(|(storage_proof, storage_value)| StorageProof { key: key2.into(), value: storage_value.into(), proof: storage_proof.into_iter().map(Bytes::new).collect() @@ -624,12 +622,11 @@ impl Eth for EthClient< } fn storage_at(&self, address: H160, position: U256, num: Option) -> BoxFuture { - let address: Address = address.into(); let num = num.unwrap_or_default(); try_bf!(check_known(&*self.client, num.clone())); let res = match self.client.storage_at(&address, &H256::from(position), self.get_state(num)) { - Some(s) => Ok(s.into()), + Some(s) => Ok(s), None => Err(errors::state_pruned()), }; @@ -637,11 +634,9 @@ impl Eth for EthClient< } fn transaction_count(&self, address: H160, num: Option) -> BoxFuture { - let address: Address = address.into(); - let res = match num.unwrap_or_default() { BlockNumber::Pending if self.options.pending_nonce_from_queue => { - Ok(self.miner.next_nonce(&*self.client, &address).into()) + Ok(self.miner.next_nonce(&*self.client, &address)) } BlockNumber::Pending => { let info = self.client.chain_info(); @@ -654,14 +649,14 @@ impl Eth for EthClient< }); match nonce { - Some(nonce) => Ok(nonce.into()), + Some(nonce) => Ok(nonce), None => Err(errors::database("latest nonce missing")) } }, number => { try_bf!(check_known(&*self.client, number.clone())); match self.client.nonce(&address, block_number_to_id(number)) { - Some(nonce) => Ok(nonce.into()), + Some(nonce) => Ok(nonce), None => Err(errors::state_pruned()), } } @@ -671,7 +666,7 @@ impl Eth for EthClient< } fn block_transaction_count_by_hash(&self, hash: H256) -> BoxFuture> { - let trx_count = self.client.block(BlockId::Hash(hash.into())) + let trx_count = self.client.block(BlockId::Hash(hash)) .map(|block| block.transactions_count().into()); let result = Ok(trx_count) .and_then(errors::check_block_gap(&*self.client, self.options.allow_missing_blocks)); @@ -696,7 +691,7 @@ impl Eth for EthClient< } fn block_uncles_count_by_hash(&self, hash: H256) -> BoxFuture> { - let uncle_count = self.client.block(BlockId::Hash(hash.into())) + let uncle_count = self.client.block(BlockId::Hash(hash)) .map(|block| block.uncles_count().into()); let result = Ok(uncle_count) .and_then(errors::check_block_gap(&*self.client, self.options.allow_missing_blocks)); @@ -734,7 +729,7 @@ impl Eth for EthClient< } fn block_by_hash(&self, hash: H256, include_txs: bool) -> BoxFuture> { - let result = self.rich_block(BlockId::Hash(hash.into()).into(), include_txs) + let result = self.rich_block(BlockId::Hash(hash).into(), include_txs) .and_then(errors::check_block_gap(&*self.client, self.options.allow_missing_blocks)); Box::new(future::done(result)) } @@ -756,7 +751,7 @@ impl Eth for EthClient< } fn transaction_by_block_hash_and_index(&self, hash: H256, index: Index) -> BoxFuture> { - let id = PendingTransactionId::Location(PendingOrBlock::Block(BlockId::Hash(hash.into())), index.value()); + let id = PendingTransactionId::Location(PendingOrBlock::Block(BlockId::Hash(hash)), index.value()); let result = self.transaction(id).and_then( errors::check_block_gap(&*self.client, self.options.allow_missing_blocks)); Box::new(future::done(result)) @@ -792,7 +787,7 @@ impl Eth for EthClient< fn uncle_by_block_hash_and_index(&self, hash: H256, index: Index) -> BoxFuture> { let result = self.uncle(PendingUncleId { - id: PendingOrBlock::Block(BlockId::Hash(hash.into())), + id: PendingOrBlock::Block(BlockId::Hash(hash)), position: index.value() }).and_then(errors::check_block_gap(&*self.client, self.options.allow_missing_blocks)); Box::new(future::done(result)) @@ -822,7 +817,7 @@ impl Eth for EthClient< } fn logs(&self, filter: Filter) -> BoxFuture> { - base_logs(&*self.client, &*self.miner, filter.into()) + base_logs(&*self.client, &*self.miner, filter) } fn work(&self, no_new_work_timeout: Option) -> Result { @@ -865,16 +860,16 @@ impl Eth for EthClient< Err(errors::no_new_work()) } else if self.options.send_block_number_in_get_work { Ok(Work { - pow_hash: pow_hash.into(), + pow_hash, seed_hash: seed_hash.into(), - target: target.into(), + target, number: Some(number), }) } else { Ok(Work { - pow_hash: pow_hash.into(), + pow_hash, seed_hash: seed_hash.into(), - target: target.into(), + target, number: None }) } @@ -888,7 +883,7 @@ impl Eth for EthClient< } fn submit_hashrate(&self, rate: U256, id: H256) -> Result { - self.external_miner.submit_hashrate(rate.into(), id.into()); + self.external_miner.submit_hashrate(rate, id); Ok(true) } @@ -919,8 +914,8 @@ impl Eth for EthClient< let (mut state, header) = if num == BlockNumber::Pending { let info = self.client.chain_info(); - let state = try_bf!(self.miner.pending_state(info.best_block_number).ok_or(errors::state_pruned())); - let header = try_bf!(self.miner.pending_block_header(info.best_block_number).ok_or(errors::state_pruned())); + let state = try_bf!(self.miner.pending_state(info.best_block_number).ok_or_else(errors::state_pruned)); + let header = try_bf!(self.miner.pending_block_header(info.best_block_number).ok_or_else(errors::state_pruned)); (state, header) } else { @@ -931,8 +926,8 @@ impl Eth for EthClient< BlockNumber::Pending => unreachable!(), // Already covered }; - let state = try_bf!(self.client.state_at(id).ok_or(errors::state_pruned())); - let header = try_bf!(self.client.block_header(id).ok_or(errors::state_pruned()).and_then(|h| h.decode().map_err(errors::decode))); + let state = try_bf!(self.client.state_at(id).ok_or_else(errors::state_pruned)); + let header = try_bf!(self.client.block_header(id).ok_or_else(errors::state_pruned).and_then(|h| h.decode().map_err(errors::decode))); (state, header) }; @@ -958,8 +953,10 @@ impl Eth for EthClient< let (state, header) = if num == BlockNumber::Pending { let info = self.client.chain_info(); - let state = try_bf!(self.miner.pending_state(info.best_block_number).ok_or(errors::state_pruned())); - let header = try_bf!(self.miner.pending_block_header(info.best_block_number).ok_or(errors::state_pruned())); + let state = try_bf!(self.miner.pending_state(info.best_block_number) + .ok_or_else(errors::state_pruned)); + let header = try_bf!(self.miner.pending_block_header(info.best_block_number) + .ok_or_else(errors::state_pruned)); (state, header) } else { @@ -970,14 +967,15 @@ impl Eth for EthClient< BlockNumber::Pending => unreachable!(), // Already covered }; - let state = try_bf!(self.client.state_at(id).ok_or(errors::state_pruned())); - let header = try_bf!(self.client.block_header(id).ok_or(errors::state_pruned()).and_then(|h| h.decode().map_err(errors::decode))); - + let state = try_bf!(self.client.state_at(id) + .ok_or_else(errors::state_pruned)); + let header = try_bf!(self.client.block_header(id) + .ok_or_else(errors::state_pruned) + .and_then(|h| h.decode().map_err(errors::decode))); (state, header) }; Box::new(future::done(self.client.estimate_gas(&signed, &state, &header) - .map(Into::into) .map_err(errors::call) )) } diff --git a/rpc/src/v1/impls/eth_filter.rs b/rpc/src/v1/impls/eth_filter.rs index f8d4d2902..c51c85fb6 100644 --- a/rpc/src/v1/impls/eth_filter.rs +++ b/rpc/src/v1/impls/eth_filter.rs @@ -68,8 +68,8 @@ impl EthFilterClient { /// Creates new Eth filter client. pub fn new(client: Arc, miner: Arc, poll_lifetime: u32) -> Self { EthFilterClient { - client: client, - miner: miner, + client, + miner, polls: Mutex::new(PollManager::new(poll_lifetime)), } } @@ -188,17 +188,14 @@ impl EthFilter for T { let mut hashes = Vec::new(); for n in (*last_block_number + 1)..=current_number { let block_number = BlockId::Number(n); - match self.block_hash(block_number) { - Some(hash) => { - *last_block_number = n; - hashes.push(H256::from(hash)); - // Only keep the most recent history - if recent_reported_hashes.len() >= PollFilter::MAX_BLOCK_HISTORY_SIZE { - recent_reported_hashes.pop_back(); - } - recent_reported_hashes.push_front((n, hash)); - }, - None => (), + if let Some(hash) = self.block_hash(block_number) { + *last_block_number = n; + hashes.push(hash); + // Only keep the most recent history + if recent_reported_hashes.len() >= PollFilter::MAX_BLOCK_HISTORY_SIZE { + recent_reported_hashes.pop_back(); + } + recent_reported_hashes.push_front((n, hash)); } } diff --git a/rpc/src/v1/impls/eth_pubsub.rs b/rpc/src/v1/impls/eth_pubsub.rs index b4baf5aa4..91f32827b 100644 --- a/rpc/src/v1/impls/eth_pubsub.rs +++ b/rpc/src/v1/impls/eth_pubsub.rs @@ -134,10 +134,10 @@ impl ChainNotificationHandler { fn notify_heads(&self, headers: &[(encoded::Header, BTreeMap)]) { for subscriber in self.heads_subscribers.read().values() { for &(ref header, ref extra_info) in headers { - Self::notify(&self.executor, subscriber, pubsub::Result::Header(RichHeader { + Self::notify(&self.executor, subscriber, pubsub::Result::Header(Box::new(RichHeader { inner: header.into(), extra_info: extra_info.clone(), - })); + }))); } } } @@ -154,7 +154,7 @@ impl ChainNotificationHandler { .map(|&(hash, ref ex)| { let mut filter = filter.clone(); filter.from_block = BlockId::Hash(hash); - filter.to_block = filter.from_block.clone(); + filter.to_block = filter.from_block; logs(filter, ex).into_future() }) .collect::>() @@ -167,7 +167,7 @@ impl ChainNotificationHandler { let logs = logs.into_iter().flat_map(|log| log).collect(); for log in limit_logs(logs, limit) { - Self::notify(&executor, &subscriber, pubsub::Result::Log(log)) + Self::notify(&executor, &subscriber, pubsub::Result::Log(Box::new(log))) } }) .map_err(|e| warn!("Unable to fetch latest logs: {:?}", e)) @@ -179,7 +179,7 @@ impl ChainNotificationHandler { pub fn notify_new_transactions(&self, hashes: &[H256]) { for subscriber in self.transactions_subscribers.read().values() { for hash in hashes { - Self::notify(&self.executor, subscriber, pubsub::Result::TransactionHash((*hash).into())); + Self::notify(&self.executor, subscriber, pubsub::Result::TransactionHash(*hash)); } } } @@ -223,13 +223,13 @@ impl LightChainNotify for ChainNotificationHandler { impl ChainNotify for ChainNotificationHandler { fn new_blocks(&self, new_blocks: NewBlocks) { if self.heads_subscribers.read().is_empty() && self.logs_subscribers.read().is_empty() { return } - const EXTRA_INFO_PROOF: &'static str = "Object exists in in blockchain (fetched earlier), extra_info is always available if object exists; qed"; + const EXTRA_INFO_PROOF: &str = "Object exists in in blockchain (fetched earlier), extra_info is always available if object exists; qed"; let headers = new_blocks.route.route() .iter() .filter_map(|&(hash, ref typ)| { match typ { - &ChainRouteType::Retracted => None, - &ChainRouteType::Enacted => self.client.block_header(BlockId::Hash(hash)) + ChainRouteType::Retracted => None, + ChainRouteType::Enacted => self.client.block_header(BlockId::Hash(hash)) } }) .map(|header| { @@ -244,9 +244,9 @@ impl ChainNotify for ChainNotificationHandler { // We notify logs enacting and retracting as the order in route. self.notify_logs(new_blocks.route.route(), |filter, ex| { match ex { - &ChainRouteType::Enacted => + ChainRouteType::Enacted => Ok(self.client.logs(filter).unwrap_or_default().into_iter().map(Into::into).collect()), - &ChainRouteType::Retracted => + ChainRouteType::Retracted => Ok(self.client.logs(filter).unwrap_or_default().into_iter().map(Into::into).map(|mut log: Log| { log.log_type = "removed".into(); log.removed = true; @@ -267,7 +267,7 @@ impl EthPubSub for EthPubSubClient { kind: pubsub::Kind, params: Option, ) { - let error = match (kind, params.into()) { + let error = match (kind, params) { (pubsub::Kind::NewHeads, None) => { self.heads_subscribers.write().push(subscriber); return; diff --git a/rpc/src/v1/impls/light/eth.rs b/rpc/src/v1/impls/light/eth.rs index 909d4c244..fa972c5d6 100644 --- a/rpc/src/v1/impls/light/eth.rs +++ b/rpc/src/v1/impls/light/eth.rs @@ -142,23 +142,23 @@ where let extra_info = engine.extra_info(&header); RichBlock { inner: Block { - hash: Some(header.hash().into()), + hash: Some(header.hash()), size: Some(block.rlp().as_raw().len().into()), - parent_hash: header.parent_hash().clone().into(), - uncles_hash: header.uncles_hash().clone().into(), - author: header.author().clone().into(), - miner: header.author().clone().into(), - state_root: header.state_root().clone().into(), - transactions_root: header.transactions_root().clone().into(), - receipts_root: header.receipts_root().clone().into(), + parent_hash: *header.parent_hash(), + uncles_hash: *header.uncles_hash(), + author: *header.author(), + miner: *header.author(), + state_root: *header.state_root(), + transactions_root: *header.transactions_root(), + receipts_root: *header.receipts_root(), number: Some(header.number().into()), - gas_used: header.gas_used().clone().into(), - gas_limit: header.gas_limit().clone().into(), - logs_bloom: Some(header.log_bloom().clone().into()), + gas_used: *header.gas_used(), + gas_limit: *header.gas_limit(), + logs_bloom: Some(*header.log_bloom()), timestamp: header.timestamp().into(), - difficulty: header.difficulty().clone().into(), + difficulty: *header.difficulty(), total_difficulty: score.map(Into::into), - seal_fields: header.seal().into_iter().cloned().map(Into::into).collect(), + seal_fields: header.seal().iter().cloned().map(Into::into).collect(), uncles: block.uncle_hashes().into_iter().map(Into::into).collect(), transactions: match include_txs { true => BlockTransactions::Full(block.view().localized_transactions().into_iter().map(Transaction::from_localized).collect()), @@ -166,7 +166,7 @@ where }, extra_data: Bytes::new(header.extra_data().clone()), }, - extra_info: extra_info + extra_info, } }; @@ -237,9 +237,9 @@ where .unwrap_or_else(|| current_block); Ok(RpcSyncStatus::Info(RpcSyncInfo { - starting_block: U256::from(self.sync.start_block()).into(), - current_block: current_block.into(), - highest_block: highest_block.into(), + starting_block: U256::from(self.sync.start_block()), + current_block, + highest_block, warp_chunks_amount: None, warp_chunks_processed: None, })) @@ -289,8 +289,8 @@ where } fn balance(&self, address: H160, num: Option) -> BoxFuture { - Box::new(self.fetcher().account(address.into(), num.unwrap_or_default().to_block_id()) - .map(|acc| acc.map_or(0.into(), |a| a.balance).into())) + Box::new(self.fetcher().account(address, num.unwrap_or_default().to_block_id()) + .map(|acc| acc.map_or(0.into(), |a| a.balance))) } fn storage_at(&self, _address: H160, _key: U256, _num: Option) -> BoxFuture { @@ -298,7 +298,7 @@ where } fn block_by_hash(&self, hash: H256, include_txs: bool) -> BoxFuture> { - Box::new(self.rich_block(BlockId::Hash(hash.into()), include_txs).map(Some)) + Box::new(self.rich_block(BlockId::Hash(hash), include_txs).map(Some)) } fn block_by_number(&self, num: BlockNumber, include_txs: bool) -> BoxFuture> { @@ -306,20 +306,20 @@ where } fn transaction_count(&self, address: H160, num: Option) -> BoxFuture { - Box::new(self.fetcher().account(address.into(), num.unwrap_or_default().to_block_id()) - .map(|acc| acc.map_or(0.into(), |a| a.nonce).into())) + Box::new(self.fetcher().account(address, num.unwrap_or_default().to_block_id()) + .map(|acc| acc.map_or(0.into(), |a| a.nonce))) } fn block_transaction_count_by_hash(&self, hash: H256) -> BoxFuture> { let (sync, on_demand) = (self.sync.clone(), self.on_demand.clone()); - Box::new(self.fetcher().header(BlockId::Hash(hash.into())).and_then(move |hdr| { + Box::new(self.fetcher().header(BlockId::Hash(hash)).and_then(move |hdr| { if hdr.transactions_root() == KECCAK_NULL_RLP { - Either::A(future::ok(Some(U256::from(0).into()))) + Either::A(future::ok(Some(U256::from(0)))) } else { sync.with_context(|ctx| on_demand.request(ctx, request::Body(hdr.into()))) .map(|x| x.expect(NO_INVALID_BACK_REFS)) - .map(|x| x.map(|b| Some(U256::from(b.transactions_count()).into()))) + .map(|x| x.map(|b| Some(U256::from(b.transactions_count())))) .map(|x| Either::B(x.map_err(errors::on_demand_error))) .unwrap_or_else(|| Either::A(future::err(errors::network_disabled()))) } @@ -331,11 +331,11 @@ where Box::new(self.fetcher().header(num.to_block_id()).and_then(move |hdr| { if hdr.transactions_root() == KECCAK_NULL_RLP { - Either::A(future::ok(Some(U256::from(0).into()))) + Either::A(future::ok(Some(U256::from(0)))) } else { sync.with_context(|ctx| on_demand.request(ctx, request::Body(hdr.into()))) .map(|x| x.expect(NO_INVALID_BACK_REFS)) - .map(|x| x.map(|b| Some(U256::from(b.transactions_count()).into()))) + .map(|x| x.map(|b| Some(U256::from(b.transactions_count())))) .map(|x| Either::B(x.map_err(errors::on_demand_error))) .unwrap_or_else(|| Either::A(future::err(errors::network_disabled()))) } @@ -345,13 +345,13 @@ where fn block_uncles_count_by_hash(&self, hash: H256) -> BoxFuture> { let (sync, on_demand) = (self.sync.clone(), self.on_demand.clone()); - Box::new(self.fetcher().header(BlockId::Hash(hash.into())).and_then(move |hdr| { + Box::new(self.fetcher().header(BlockId::Hash(hash)).and_then(move |hdr| { if hdr.uncles_hash() == KECCAK_EMPTY_LIST_RLP { - Either::A(future::ok(Some(U256::from(0).into()))) + Either::A(future::ok(Some(U256::from(0)))) } else { sync.with_context(|ctx| on_demand.request(ctx, request::Body(hdr.into()))) .map(|x| x.expect(NO_INVALID_BACK_REFS)) - .map(|x| x.map(|b| Some(U256::from(b.uncles_count()).into()))) + .map(|x| x.map(|b| Some(U256::from(b.uncles_count())))) .map(|x| Either::B(x.map_err(errors::on_demand_error))) .unwrap_or_else(|| Either::A(future::err(errors::network_disabled()))) } @@ -363,11 +363,11 @@ where Box::new(self.fetcher().header(num.to_block_id()).and_then(move |hdr| { if hdr.uncles_hash() == KECCAK_EMPTY_LIST_RLP { - Either::B(future::ok(Some(U256::from(0).into()))) + Either::B(future::ok(Some(U256::from(0)))) } else { sync.with_context(|ctx| on_demand.request(ctx, request::Body(hdr.into()))) .map(|x| x.expect(NO_INVALID_BACK_REFS)) - .map(|x| x.map(|b| Some(U256::from(b.uncles_count()).into()))) + .map(|x| x.map(|b| Some(U256::from(b.uncles_count())))) .map(|x| Either::A(x.map_err(errors::on_demand_error))) .unwrap_or_else(|| Either::B(future::err(errors::network_disabled()))) } @@ -375,7 +375,7 @@ where } fn code_at(&self, address: H160, num: Option) -> BoxFuture { - Box::new(self.fetcher().code(address.into(), num.unwrap_or_default().to_block_id()).map(Into::into)) + Box::new(self.fetcher().code(address, num.unwrap_or_default().to_block_id()).map(Into::into)) } fn send_raw_transaction(&self, raw: Bytes) -> Result { @@ -414,15 +414,13 @@ where // TODO: binary chop for more accurate estimates. Box::new(self.fetcher().proved_read_only_execution(req, num).and_then(|res| { match res { - Ok(exec) => Ok((exec.refunded + exec.gas_used).into()), + Ok(exec) => Ok(exec.refunded + exec.gas_used), Err(e) => Err(errors::execution(e)), } })) } fn transaction_by_hash(&self, hash: H256) -> BoxFuture> { - let hash = hash.into(); - { let tx_queue = self.transaction_queue.read(); if let Some(tx) = tx_queue.get(&hash) { @@ -436,7 +434,7 @@ where } fn transaction_by_block_hash_and_index(&self, hash: H256, idx: Index) -> BoxFuture> { - Box::new(self.fetcher().block(BlockId::Hash(hash.into())).map(move |block| { + Box::new(self.fetcher().block(BlockId::Hash(hash)).map(move |block| { light_fetch::extract_transaction_at_index(block, idx.value()) })) } @@ -449,14 +447,14 @@ where fn transaction_receipt(&self, hash: H256) -> BoxFuture> { let fetcher = self.fetcher(); - Box::new(fetcher.transaction_by_hash(hash.into()).and_then(move |tx| { + Box::new(fetcher.transaction_by_hash(hash).and_then(move |tx| { // the block hash included in the transaction object here has // already been checked for canonicality and whether it contains // the transaction. match tx { - Some((tx, index)) => match tx.block_hash.clone() { + Some((tx, index)) => match tx.block_hash { Some(block_hash) => { - let extract_receipt = fetcher.receipts(BlockId::Hash(block_hash.clone().into())) + let extract_receipt = fetcher.receipts(BlockId::Hash(block_hash)) .and_then(move |mut receipts| future::ok(receipts.swap_remove(index))) .map(Receipt::from) .map(move |mut receipt| { @@ -479,7 +477,7 @@ where fn uncle_by_block_hash_and_index(&self, hash: H256, idx: Index) -> BoxFuture> { let client = self.client.clone(); - Box::new(self.fetcher().block(BlockId::Hash(hash.into())).map(move |block| { + Box::new(self.fetcher().block(BlockId::Hash(hash)).map(move |block| { extract_uncle_at_index(block, idx, client) })) } @@ -576,27 +574,27 @@ fn extract_uncle_at_index(block: encoded::Block, index: Ind let extra_info = client.engine().extra_info(&uncle); Some(RichBlock { inner: Block { - hash: Some(uncle.hash().into()), + hash: Some(uncle.hash()), size: None, - parent_hash: uncle.parent_hash().clone().into(), - uncles_hash: uncle.uncles_hash().clone().into(), - author: uncle.author().clone().into(), - miner: uncle.author().clone().into(), - state_root: uncle.state_root().clone().into(), - transactions_root: uncle.transactions_root().clone().into(), + parent_hash: *uncle.parent_hash(), + uncles_hash: *uncle.uncles_hash(), + author: *uncle.author(), + miner: *uncle.author(), + state_root: *uncle.state_root(), + transactions_root: *uncle.transactions_root(), number: Some(uncle.number().into()), - gas_used: uncle.gas_used().clone().into(), - gas_limit: uncle.gas_limit().clone().into(), - logs_bloom: Some(uncle.log_bloom().clone().into()), + gas_used: *uncle.gas_used(), + gas_limit: *uncle.gas_limit(), + logs_bloom: Some(*uncle.log_bloom()), timestamp: uncle.timestamp().into(), - difficulty: uncle.difficulty().clone().into(), + difficulty: *uncle.difficulty(), total_difficulty: None, - receipts_root: uncle.receipts_root().clone().into(), + receipts_root: *uncle.receipts_root(), extra_data: uncle.extra_data().clone().into(), - seal_fields: uncle.seal().into_iter().cloned().map(Into::into).collect(), + seal_fields: uncle.seal().iter().cloned().map(Into::into).collect(), uncles: vec![], transactions: BlockTransactions::Hashes(vec![]), }, - extra_info: extra_info, + extra_info, }) } diff --git a/rpc/src/v1/impls/light/net.rs b/rpc/src/v1/impls/light/net.rs index 3f73e010b..a9ab012e5 100644 --- a/rpc/src/v1/impls/light/net.rs +++ b/rpc/src/v1/impls/light/net.rs @@ -29,7 +29,7 @@ impl NetClient where S: LightSyncProvider { /// Creates new NetClient. pub fn new(sync: Arc) -> Self { NetClient { - sync: sync, + sync, } } } diff --git a/rpc/src/v1/impls/light/parity.rs b/rpc/src/v1/impls/light/parity.rs index 24dba420e..b6e378f68 100644 --- a/rpc/src/v1/impls/light/parity.rs +++ b/rpc/src/v1/impls/light/parity.rs @@ -140,7 +140,7 @@ where active: peer_numbers.active, connected: peer_numbers.connected, max: peer_numbers.max as u32, - peers: peers, + peers, }) } @@ -157,7 +157,7 @@ where if reg == Default::default() { Ok(None) } else { - Ok(Some(reg.into())) + Ok(Some(reg)) } } @@ -191,7 +191,7 @@ where } fn phrase_to_address(&self, phrase: String) -> Result { - Ok(Brain::new(phrase).generate().unwrap().address().into()) + Ok(Brain::new(phrase).generate().expect("Brain::generate always returns Ok; qed").address()) } fn list_accounts(&self, _: u64, _: Option, _: Option) -> Result>> { @@ -203,7 +203,7 @@ where } fn encrypt_message(&self, key: H512, phrase: Bytes) -> Result { - ecies::encrypt(&key.into(), &DEFAULT_MAC, &phrase.0) + ecies::encrypt(&key, &DEFAULT_MAC, &phrase.0) .map_err(errors::encryption) .map(Into::into) } @@ -215,7 +215,7 @@ where txq.ready_transactions(chain_info.best_block_number, chain_info.best_block_timestamp) .into_iter() .take(limit.unwrap_or_else(usize::max_value)) - .map(|tx| Transaction::from_pending(tx)) + .map(Transaction::from_pending) .collect::>() ) } @@ -223,7 +223,7 @@ where fn all_transactions(&self) -> Result> { Ok( light_all_transactions(&self.light_dispatch) - .map(|tx| Transaction::from_pending(tx)) + .map(Transaction::from_pending) .collect() ) } @@ -231,7 +231,7 @@ where fn all_transaction_hashes(&self) -> Result> { Ok( light_all_transactions(&self.light_dispatch) - .map(|tx| tx.transaction.hash().into()) + .map(|tx| tx.transaction.hash()) .collect() ) } @@ -242,7 +242,7 @@ where Ok( txq.future_transactions(chain_info.best_block_number, chain_info.best_block_timestamp) .into_iter() - .map(|tx| Transaction::from_pending(tx)) + .map(Transaction::from_pending) .collect::>() ) } @@ -250,7 +250,7 @@ where fn pending_transactions_stats(&self) -> Result> { let stats = self.light_dispatch.sync.transactions_stats(); Ok(stats.into_iter() - .map(|(hash, stats)| (hash.into(), stats.into())) + .map(|(hash, stats)| (hash, stats.into())) .collect() ) } @@ -262,11 +262,11 @@ where let txq = self.light_dispatch.transaction_queue.read(); for pending in txq.ready_transactions(best_num, best_tm) { - map.insert(pending.hash().into(), LocalTransactionStatus::Pending); + map.insert(pending.hash(), LocalTransactionStatus::Pending); } for future in txq.future_transactions(best_num, best_tm) { - map.insert(future.hash().into(), LocalTransactionStatus::Future); + map.insert(future.hash(), LocalTransactionStatus::Future); } // TODO: other types? @@ -276,11 +276,11 @@ where fn ws_url(&self) -> Result { helpers::to_url(&self.ws_address) - .ok_or_else(|| errors::ws_disabled()) + .ok_or_else(errors::ws_disabled) } fn next_nonce(&self, address: H160) -> BoxFuture { - Box::new(self.light_dispatch.next_nonce(address.into()).map(Into::into)) + Box::new(self.light_dispatch.next_nonce(address)) } fn mode(&self) -> Result { @@ -314,7 +314,7 @@ where .and_then(|first| chain_info.first_block_number.map(|last| (first, U256::from(last)))); Ok(ChainStatus { - block_gap: gap.map(|(x, y)| (x.into(), y.into())), + block_gap: gap, }) } @@ -336,25 +336,25 @@ where let extra_info = engine.extra_info(&header); Ok(RichHeader { inner: Header { - hash: Some(header.hash().into()), + hash: Some(header.hash()), size: Some(encoded.rlp().as_raw().len().into()), - parent_hash: header.parent_hash().clone().into(), - uncles_hash: header.uncles_hash().clone().into(), - author: header.author().clone().into(), - miner: header.author().clone().into(), - state_root: header.state_root().clone().into(), - transactions_root: header.transactions_root().clone().into(), - receipts_root: header.receipts_root().clone().into(), + parent_hash: *header.parent_hash(), + uncles_hash: *header.uncles_hash(), + author: *header.author(), + miner: *header.author(), + state_root: *header.state_root(), + transactions_root: *header.transactions_root(), + receipts_root: *header.receipts_root(), number: Some(header.number().into()), - gas_used: header.gas_used().clone().into(), - gas_limit: header.gas_limit().clone().into(), - logs_bloom: header.log_bloom().clone().into(), + gas_used: *header.gas_used(), + gas_limit: *header.gas_limit(), + logs_bloom: *header.log_bloom(), timestamp: header.timestamp().into(), - difficulty: header.difficulty().clone().into(), + difficulty: *header.difficulty(), seal_fields: header.seal().iter().cloned().map(Into::into).collect(), extra_data: Bytes::new(header.extra_data().clone()), }, - extra_info: extra_info, + extra_info, }) }; let id = number.unwrap_or_default().to_block_id(); diff --git a/rpc/src/v1/impls/light/parity_set.rs b/rpc/src/v1/impls/light/parity_set.rs index f129f86b3..68fc212b2 100644 --- a/rpc/src/v1/impls/light/parity_set.rs +++ b/rpc/src/v1/impls/light/parity_set.rs @@ -43,9 +43,9 @@ impl ParitySetClient { /// Creates new `ParitySetClient` with given `Fetch`. pub fn new(client: Arc, net: Arc, fetch: F) -> Self { ParitySetClient { - client: client, - net: net, - fetch: fetch, + client, + net, + fetch, } } } diff --git a/rpc/src/v1/impls/parity.rs b/rpc/src/v1/impls/parity.rs index d985f33f6..27a703795 100644 --- a/rpc/src/v1/impls/parity.rs +++ b/rpc/src/v1/impls/parity.rs @@ -109,7 +109,7 @@ impl Parity for ParityClient where } fn min_gas_price(&self) -> Result { - Ok(self.miner.queue_status().options.minimal_gas_price.into()) + Ok(self.miner.queue_status().options.minimal_gas_price) } fn extra_data(&self) -> Result { @@ -117,11 +117,11 @@ impl Parity for ParityClient where } fn gas_floor_target(&self) -> Result { - Ok(U256::from(self.miner.authoring_params().gas_range_target.0)) + Ok(self.miner.authoring_params().gas_range_target.0) } fn gas_ceil_target(&self) -> Result { - Ok(U256::from(self.miner.authoring_params().gas_range_target.1)) + Ok(self.miner.authoring_params().gas_range_target.1) } fn dev_logs(&self) -> Result> { @@ -152,7 +152,7 @@ impl Parity for ParityClient where active: sync_status.num_active_peers, connected: sync_status.num_peers, max: sync_status.current_max_peers(*num_peers_range.start(), *num_peers_range.end()), - peers: peers + peers, }) } @@ -170,7 +170,6 @@ impl Parity for ParityClient where .additional_params() .get("registrar") .and_then(|s| Address::from_str(s).ok()) - .map(|s| H160::from(s)) ) } @@ -207,7 +206,7 @@ impl Parity for ParityClient where } fn phrase_to_address(&self, phrase: String) -> Result { - Ok(Brain::new(phrase).generate().unwrap().address().into()) + Ok(Brain::new(phrase).generate().expect("Brain::generate always returns Ok; qed").address()) } fn list_accounts(&self, count: u64, after: Option, block_number: Option) -> Result>> { @@ -236,12 +235,12 @@ impl Parity for ParityClient where }; Ok(self.client - .list_storage(number, &address.into(), after.map(Into::into).as_ref(), count) + .list_storage(number, &address, after.map(Into::into).as_ref(), count) .map(|a| a.into_iter().map(Into::into).collect())) } fn encrypt_message(&self, key: H512, phrase: Bytes) -> Result { - ecies::encrypt(&key.into(), &DEFAULT_MAC, &phrase.0) + ecies::encrypt(&key, &DEFAULT_MAC, &phrase.0) .map_err(errors::encryption) .map(Into::into) } @@ -271,13 +270,7 @@ impl Parity for ParityClient where } fn all_transaction_hashes(&self) -> Result> { - let all_transaction_hashes = self.miner.queued_transaction_hashes(); - - Ok(all_transaction_hashes - .into_iter() - .map(|hash| hash.into()) - .collect() - ) + Ok(self.miner.queued_transaction_hashes()) } fn future_transactions(&self) -> Result> { @@ -287,7 +280,7 @@ impl Parity for ParityClient where fn pending_transactions_stats(&self) -> Result> { let stats = self.sync.transactions_stats(); Ok(stats.into_iter() - .map(|(hash, stats)| (hash.into(), stats.into())) + .map(|(hash, stats)| (hash, stats.into())) .collect() ) } @@ -296,7 +289,7 @@ impl Parity for ParityClient where let transactions = self.miner.local_transactions(); Ok(transactions .into_iter() - .map(|(hash, status)| (hash.into(), LocalTransactionStatus::from(status))) + .map(|(hash, status)| (hash, LocalTransactionStatus::from(status))) .collect() ) } @@ -307,9 +300,7 @@ impl Parity for ParityClient where } fn next_nonce(&self, address: H160) -> BoxFuture { - let address: Address = address.into(); - - Box::new(future::ok(self.miner.next_nonce(&*self.client, &address).into())) + Box::new(future::ok(self.miner.next_nonce(&*self.client, &address))) } fn mode(&self) -> Result { @@ -339,7 +330,7 @@ impl Parity for ParityClient where .and_then(|first| chain_info.first_block_number.map(|last| (first, U256::from(last)))); Ok(ChainStatus { - block_gap: gap.map(|(x, y)| (x.into(), y.into())), + block_gap: gap, }) } @@ -370,7 +361,7 @@ impl Parity for ParityClient where BlockNumber::Pending => unreachable!(), // Already covered }; - let header = try_bf!(self.client.block_header(id.clone()).ok_or_else(errors::unknown_block)); + let header = try_bf!(self.client.block_header(id).ok_or_else(errors::unknown_block)); let info = self.client.block_extra_info(id).expect(EXTRA_INFO_PROOF); (header, Some(info)) @@ -467,7 +458,7 @@ impl Parity for ParityClient where fn logs_no_tx_hash(&self, filter: Filter) -> BoxFuture> { use v1::impls::eth::base_logs; // only specific impl for lightclient - base_logs(&*self.client, &*self.miner, filter.into()) + base_logs(&*self.client, &*self.miner, filter) } fn verify_signature(&self, is_prefixed: bool, message: Bytes, r: H256, s: H256, v: U64) -> Result { diff --git a/rpc/src/v1/impls/parity_set.rs b/rpc/src/v1/impls/parity_set.rs index 16ef8d543..b7cef6c6b 100644 --- a/rpc/src/v1/impls/parity_set.rs +++ b/rpc/src/v1/impls/parity_set.rs @@ -119,7 +119,7 @@ impl ParitySet for ParitySetClient where { fn set_min_gas_price(&self, gas_price: U256) -> Result { - match self.miner.set_minimal_gas_price(gas_price.into()) { + match self.miner.set_minimal_gas_price(gas_price) { Ok(success) => Ok(success), Err(e) => Err(errors::unsupported(e, None)), } @@ -136,15 +136,15 @@ impl ParitySet for ParitySetClient where } fn set_gas_floor_target(&self, target: U256) -> Result { - let mut range = self.miner.authoring_params().gas_range_target.clone(); - range.0 = target.into(); + let mut range = self.miner.authoring_params().gas_range_target; + range.0 = target; self.miner.set_gas_range_target(range); Ok(true) } fn set_gas_ceil_target(&self, target: U256) -> Result { - let mut range = self.miner.authoring_params().gas_range_target.clone(); - range.1 = target.into(); + let mut range = self.miner.authoring_params().gas_range_target; + range.1 = target; self.miner.set_gas_range_target(range); Ok(true) } @@ -155,7 +155,7 @@ impl ParitySet for ParitySetClient where } fn set_author(&self, address: H160) -> Result { - self.miner.set_author(miner::Author::External(address.into())); + self.miner.set_author(miner::Author::External(address)); Ok(true) } @@ -236,8 +236,6 @@ impl ParitySet for ParitySetClient where } fn remove_transaction(&self, hash: H256) -> Result> { - let hash = hash.into(); - Ok(self.miner.remove_transaction(&hash) .map(|t| Transaction::from_pending(t.pending().clone())) ) diff --git a/rpc/src/v1/impls/private.rs b/rpc/src/v1/impls/private.rs index f1cf99124..c3be3f915 100644 --- a/rpc/src/v1/impls/private.rs +++ b/rpc/src/v1/impls/private.rs @@ -60,7 +60,7 @@ impl Private for PrivateClient { .map_err(errors::rlp) .and_then(|tx| SignedTransaction::new(tx).map_err(errors::transaction))?; let client = self.unwrap_manager()?; - let receipt = client.create_private_transaction(signed_transaction).map_err(|e| errors::private_message(e))?; + let receipt = client.create_private_transaction(signed_transaction).map_err(errors::private_message)?; Ok(receipt.into()) } @@ -76,16 +76,17 @@ impl Private for PrivateClient { num => block_number_to_id(num) }; - let (transaction, contract_address) = client.public_creation_transaction(id, &signed_transaction, addresses.as_slice(), gas_price.into()) - .map_err(|e| errors::private_message(e))?; + let (transaction, contract_address) = client + .public_creation_transaction(id, &signed_transaction, addresses.as_slice(), gas_price) + .map_err(errors::private_message)?; let tx_hash = transaction.hash(None); let request = TransactionRequest { - from: Some(signed_transaction.sender().into()), + from: Some(signed_transaction.sender()), to: None, - nonce: Some(transaction.nonce.into()), - gas_price: Some(transaction.gas_price.into()), - gas: Some(transaction.gas.into()), - value: Some(transaction.value.into()), + nonce: Some(transaction.nonce), + gas_price: Some(transaction.gas_price), + gas: Some(transaction.gas), + value: Some(transaction.value), data: Some(transaction.data.into()), condition: None, }; @@ -93,8 +94,8 @@ impl Private for PrivateClient { Ok(PrivateTransactionReceiptAndTransaction { transaction: request, receipt: PrivateTransactionReceipt { - transaction_hash: tx_hash.into(), - contract_address: contract_address.into(), + transaction_hash: tx_hash, + contract_address, status_code: 0, } }) @@ -109,13 +110,13 @@ impl Private for PrivateClient { let request = CallRequest::into(request); let signed = fake_sign::sign_call(request)?; let client = self.unwrap_manager()?; - let executed_result = client.private_call(id, &signed).map_err(|e| errors::private_message(e))?; + let executed_result = client.private_call(id, &signed).map_err(errors::private_message)?; Ok(executed_result.output.into()) } fn private_contract_key(&self, contract_address: H160) -> Result { let client = self.unwrap_manager()?; - let key = client.contract_key_id(&contract_address.into()).map_err(|e| errors::private_message(e))?; - Ok(key.into()) + let key = client.contract_key_id(&contract_address).map_err(errors::private_message)?; + Ok(key) } } diff --git a/rpc/src/v1/impls/pubsub.rs b/rpc/src/v1/impls/pubsub.rs index 9650fd2d0..1575aacdd 100644 --- a/rpc/src/v1/impls/pubsub.rs +++ b/rpc/src/v1/impls/pubsub.rs @@ -81,7 +81,7 @@ impl> PubSub for PubSubClient { type Metadata = Metadata; fn parity_subscribe(&self, mut meta: Metadata, subscriber: Subscriber, method: String, params: Option) { - let params = params.unwrap_or(core::Params::Array(vec![])); + let params = params.unwrap_or_else(|| core::Params::Array(vec![])); // Make sure to get rid of PubSub session otherwise it will never be dropped. meta.session = None; diff --git a/rpc/src/v1/impls/rpc.rs b/rpc/src/v1/impls/rpc.rs index f218c5ade..0c2afd57c 100644 --- a/rpc/src/v1/impls/rpc.rs +++ b/rpc/src/v1/impls/rpc.rs @@ -32,8 +32,8 @@ impl RpcClient { let valid_apis = vec!["web3", "eth", "net", "personal", "rpc"]; RpcClient { - modules: modules, - valid_apis: valid_apis.into_iter().map(|x| x.to_owned()).collect(), + modules, + valid_apis: valid_apis.into_iter().map(ToOwned::to_owned).collect(), } } } diff --git a/rpc/src/v1/impls/signer.rs b/rpc/src/v1/impls/signer.rs index c4f4d3576..4edac1144 100644 --- a/rpc/src/v1/impls/signer.rs +++ b/rpc/src/v1/impls/signer.rs @@ -85,7 +85,6 @@ impl SignerClient { T: IntoFuture, Error=Error>, T::Future: Send + 'static { - let id = id.into(); let dispatcher = self.dispatcher.clone(); let signer = self.signer.clone(); @@ -94,15 +93,15 @@ impl SignerClient { // Modify payload if let ConfirmationPayload::SendTransaction(ref mut request) = payload { if let Some(sender) = modification.sender { - request.from = sender.into(); + request.from = sender; // Altering sender should always reset the nonce. request.nonce = None; } if let Some(gas_price) = modification.gas_price { - request.gas_price = gas_price.into(); + request.gas_price = gas_price; } if let Some(gas) = modification.gas { - request.gas = gas.into(); + request.gas = gas; } if let Some(ref condition) = modification.condition { request.condition = condition.clone().map(Into::into); @@ -177,7 +176,7 @@ impl Signer for SignerClient { Box::new(self.confirm_internal(id, modification, move |dis, accounts, payload| { dispatch::execute(dis, accounts, payload, dispatch::SignWith::Password(pass.into())) - }).map(|v| v.into_value())) + }).map(dispatch::WithToken::into_value)) } fn confirm_request_with_token(&self, id: U256, modification: TransactionModification, token: String) @@ -191,7 +190,7 @@ impl Signer for SignerClient { WithToken::No(_) => Err(errors::internal("Unexpected response without token.", "")), WithToken::Yes(response, token) => Ok(ConfirmationResponseWithToken { result: response, - token: token, + token, }), })) } @@ -199,8 +198,6 @@ impl Signer for SignerClient { fn confirm_request_raw(&self, id: U256, bytes: Bytes) -> Result { self.deprecation_notice.print("signer_confirmRequestRaw", deprecated::msgs::ACCOUNTS); - let id = id.into(); - self.signer.take(&id).map(|sender| { let payload = sender.request.payload.clone(); let result = match payload { @@ -251,7 +248,7 @@ impl Signer for SignerClient { fn reject_request(&self, id: U256) -> Result { self.deprecation_notice.print("signer_rejectRequest", deprecated::msgs::ACCOUNTS); - let res = self.signer.take(&id.into()).map(|sender| self.signer.request_rejected(sender)); + let res = self.signer.take(&id).map(|sender| self.signer.request_rejected(sender)); Ok(res.is_some()) } @@ -259,7 +256,7 @@ impl Signer for SignerClient { self.deprecation_notice.print("signer_generateAuthorizationToken", deprecated::msgs::ACCOUNTS); self.signer.generate_token() - .map_err(|e| errors::token(e)) + .map_err(errors::token) } fn subscribe_pending(&self, _meta: Self::Metadata, sub: Subscriber>) { diff --git a/rpc/src/v1/impls/signing.rs b/rpc/src/v1/impls/signing.rs index 12f890956..38ca6d59c 100644 --- a/rpc/src/v1/impls/signing.rs +++ b/rpc/src/v1/impls/signing.rs @@ -75,7 +75,7 @@ fn schedule(executor: Executor, future: RpcConfirmationReceiver) { { let mut confirmations = confirmations.lock(); - confirmations.insert(id.clone(), None); + confirmations.insert(id, None); } let future = future.then(move |result| { @@ -122,7 +122,7 @@ impl SigningQueueClient { let sender = payload.sender(); if accounts.is_unlocked(&sender) { Either::A(dispatch::execute(dispatcher, &accounts, payload, dispatch::SignWith::Nothing) - .map(|v| v.into_value()) + .map(dispatch::WithToken::into_value) .map(DispatchResult::Value)) } else { Either::B(future::done( @@ -149,13 +149,13 @@ impl ParitySigning for SigningQueueClient { let confirmations = self.confirmations.clone(); Box::new(self.dispatch( - RpcConfirmationPayload::EthSignMessage((address.clone(), data).into()), + RpcConfirmationPayload::EthSignMessage((address, data).into()), meta.origin ).map(move |result| match result { DispatchResult::Value(v) => RpcEither::Or(v), DispatchResult::Future(id, future) => { schedule(executor, confirmations, id, future); - RpcEither::Either(id.into()) + RpcEither::Either(id) }, })) } @@ -170,14 +170,13 @@ impl ParitySigning for SigningQueueClient { DispatchResult::Value(v) => RpcEither::Or(v), DispatchResult::Future(id, future) => { schedule(executor, confirmations, id, future); - RpcEither::Either(id.into()) + RpcEither::Either(id) }, })) } fn check_request(&self, id: U256) -> Result> { self.deprecation_notice.print("parity_checkRequest", deprecated::msgs::ACCOUNTS); - let id: U256 = id.into(); match self.confirmations.lock().get(&id) { None => Err(errors::request_not_found()), // Request info has been dropped, or even never been there Some(&None) => Ok(None), // No confirmation yet, request is known, confirmation is pending @@ -188,7 +187,7 @@ impl ParitySigning for SigningQueueClient { fn decrypt_message(&self, meta: Metadata, address: H160, data: RpcBytes) -> BoxFuture { self.deprecation_notice.print("parity_decryptMessage", deprecated::msgs::ACCOUNTS); let res = self.dispatch( - RpcConfirmationPayload::Decrypt((address.clone(), data).into()), + RpcConfirmationPayload::Decrypt((address, data).into()), meta.origin, ); @@ -208,7 +207,7 @@ impl EthSigning for SigningQueueClient { fn sign(&self, meta: Metadata, address: H160, data: RpcBytes) -> BoxFuture { self.deprecation_notice.print("eth_sign", deprecated::msgs::ACCOUNTS); let res = self.dispatch( - RpcConfirmationPayload::EthSignMessage((address.clone(), data).into()), + RpcConfirmationPayload::EthSignMessage((address, data).into()), meta.origin, ); diff --git a/rpc/src/v1/impls/signing_unsafe.rs b/rpc/src/v1/impls/signing_unsafe.rs index 72a3a6fbf..f08a9ffbe 100644 --- a/rpc/src/v1/impls/signing_unsafe.rs +++ b/rpc/src/v1/impls/signing_unsafe.rs @@ -60,7 +60,7 @@ impl SigningUnsafeClient { .and_then(move |payload| { dispatch::execute(dis, &accounts, payload, dispatch::SignWith::Nothing) }) - .map(|v| v.into_value())) + .map(dispatch::WithToken::into_value)) } } @@ -70,7 +70,7 @@ impl EthSigning for SigningUnsafeClient fn sign(&self, _: Metadata, address: H160, data: RpcBytes) -> BoxFuture { self.deprecation_notice.print("eth_sign", deprecated::msgs::ACCOUNTS); - Box::new(self.handle(RpcConfirmationPayload::EthSignMessage((address.clone(), data).into()), address.into()) + Box::new(self.handle(RpcConfirmationPayload::EthSignMessage((address, data).into()), address) .then(|res| match res { Ok(RpcConfirmationResponse::Signature(signature)) => Ok(signature), Err(e) => Err(e), @@ -111,7 +111,7 @@ impl ParitySigning for SigningUnsafeClient { fn decrypt_message(&self, _: Metadata, address: H160, data: RpcBytes) -> BoxFuture { self.deprecation_notice.print("parity_decryptMessage", deprecated::msgs::ACCOUNTS); - Box::new(self.handle(RpcConfirmationPayload::Decrypt((address.clone(), data).into()), address.into()) + Box::new(self.handle(RpcConfirmationPayload::Decrypt((address, data).into()), address) .then(|res| match res { Ok(RpcConfirmationResponse::Decrypt(data)) => Ok(data), Err(e) => Err(e), diff --git a/rpc/src/v1/impls/traces.rs b/rpc/src/v1/impls/traces.rs index d7428aad2..a6301eda5 100644 --- a/rpc/src/v1/impls/traces.rs +++ b/rpc/src/v1/impls/traces.rs @@ -74,13 +74,13 @@ impl Traces for TracesClient where } fn transaction_traces(&self, transaction_hash: H256) -> Result>> { - Ok(self.client.transaction_traces(TransactionId::Hash(transaction_hash.into())) + Ok(self.client.transaction_traces(TransactionId::Hash(transaction_hash)) .map(|traces| traces.into_iter().map(LocalizedTrace::from).collect())) } fn trace(&self, transaction_hash: H256, address: Vec) -> Result> { let id = TraceId { - transaction: TransactionId::Hash(transaction_hash.into()), + transaction: TransactionId::Hash(transaction_hash), address: address.into_iter().map(|i| i.value()).collect() }; @@ -102,8 +102,8 @@ impl Traces for TracesClient where BlockNumber::Pending => return Err(errors::invalid_params("`BlockNumber::Pending` is not supported", ())), }; - let mut state = self.client.state_at(id).ok_or(errors::state_pruned())?; - let header = self.client.block_header(id).ok_or(errors::state_pruned())?; + let mut state = self.client.state_at(id).ok_or_else(errors::state_pruned)?; + let header = self.client.block_header(id).ok_or_else(errors::state_pruned)?; self.client.call(&signed, to_call_analytics(flags), &mut state, &header.decode().map_err(errors::decode)?) .map(TraceResults::from) @@ -129,8 +129,8 @@ impl Traces for TracesClient where BlockNumber::Pending => return Err(errors::invalid_params("`BlockNumber::Pending` is not supported", ())), }; - let mut state = self.client.state_at(id).ok_or(errors::state_pruned())?; - let header = self.client.block_header(id).ok_or(errors::state_pruned())?; + let mut state = self.client.state_at(id).ok_or_else(errors::state_pruned)?; + let header = self.client.block_header(id).ok_or_else(errors::state_pruned)?; self.client.call_many(&requests, &mut state, &header.decode().map_err(errors::decode)?) .map(|results| results.into_iter().map(TraceResults::from).collect()) @@ -151,8 +151,8 @@ impl Traces for TracesClient where BlockNumber::Pending => return Err(errors::invalid_params("`BlockNumber::Pending` is not supported", ())), }; - let mut state = self.client.state_at(id).ok_or(errors::state_pruned())?; - let header = self.client.block_header(id).ok_or(errors::state_pruned())?; + let mut state = self.client.state_at(id).ok_or_else(errors::state_pruned)?; + let header = self.client.block_header(id).ok_or_else(errors::state_pruned)?; self.client.call(&signed, to_call_analytics(flags), &mut state, &header.decode().map_err(errors::decode)?) .map(TraceResults::from) @@ -160,7 +160,7 @@ impl Traces for TracesClient where } fn replay_transaction(&self, transaction_hash: H256, flags: TraceOptions) -> Result { - self.client.replay(TransactionId::Hash(transaction_hash.into()), to_call_analytics(flags)) + self.client.replay(TransactionId::Hash(transaction_hash), to_call_analytics(flags)) .map(TraceResults::from) .map_err(errors::call) } @@ -175,7 +175,7 @@ impl Traces for TracesClient where }; self.client.replay_block_transactions(id, to_call_analytics(flags)) - .map(|results| results.into_iter().map(TraceResultsWithTransactionHash::from).collect()) + .map(|results| results.map(TraceResultsWithTransactionHash::from).collect()) .map_err(errors::call) } } diff --git a/rpc/src/v1/impls/web3.rs b/rpc/src/v1/impls/web3.rs index e7bf9dd49..5ffda51b6 100644 --- a/rpc/src/v1/impls/web3.rs +++ b/rpc/src/v1/impls/web3.rs @@ -23,19 +23,15 @@ use v1::traits::Web3; use v1::types::Bytes; /// Web3 rpc implementation. +#[derive(Default)] pub struct Web3Client; -impl Web3Client { - /// Creates new Web3Client. - pub fn new() -> Self { Web3Client } -} - impl Web3 for Web3Client { fn client_version(&self) -> Result { Ok(version().to_owned().replacen("/", "//", 1)) } fn sha3(&self, data: Bytes) -> Result { - Ok(keccak(&data.0).into()) + Ok(keccak(&data.0)) } } diff --git a/rpc/src/v1/informant.rs b/rpc/src/v1/informant.rs index 9455fa9eb..945378390 100644 --- a/rpc/src/v1/informant.rs +++ b/rpc/src/v1/informant.rs @@ -135,7 +135,7 @@ impl StatsCalculator { #[derive(Default, Debug)] pub struct RpcStats { requests: RwLock, - roundtrips: RwLock>, + roundtrips: RwLock>, active_sessions: AtomicUsize, } @@ -157,7 +157,7 @@ impl RpcStats { } /// Add roundtrip time (microseconds) - pub fn add_roundtrip(&self, microseconds: u32) { + pub fn add_roundtrip(&self, microseconds: u128) { self.roundtrips.write().add(microseconds) } @@ -172,7 +172,7 @@ impl RpcStats { } /// Returns approximated roundtrip in microseconds - pub fn approximated_roundtrip(&self) -> u32 { + pub fn approximated_roundtrip(&self) -> u128 { self.roundtrips.read().approximated_median() } } @@ -197,10 +197,6 @@ impl Middleware { notifier, } } - - fn as_micro(dur: time::Duration) -> u32 { - (dur.as_secs() * 1_000_000) as u32 + dur.subsec_nanos() / 1_000 - } } impl core::Middleware for Middleware { @@ -223,7 +219,7 @@ impl core::Middleware for Middleware< let stats = self.stats.clone(); let future = process(request, meta).map(move |res| { - let time = Self::as_micro(start.elapsed()); + let time = start.elapsed().as_micros(); if time > 10_000 { debug!(target: "rpc", "[{:?}] Took {}ms", id, time / 1_000); } diff --git a/rpc/src/v1/tests/mocked/web3.rs b/rpc/src/v1/tests/mocked/web3.rs index 79bcfe01d..5590d5d28 100644 --- a/rpc/src/v1/tests/mocked/web3.rs +++ b/rpc/src/v1/tests/mocked/web3.rs @@ -20,7 +20,7 @@ use v1::{Web3, Web3Client}; #[test] fn rpc_web3_version() { - let web3 = Web3Client::new().to_delegate(); + let web3 = Web3Client::default().to_delegate(); let mut io = IoHandler::new(); io.extend_with(web3); @@ -34,7 +34,7 @@ fn rpc_web3_version() { #[test] fn rpc_web3_sha3() { - let web3 = Web3Client::new().to_delegate(); + let web3 = Web3Client::default().to_delegate(); let mut io = IoHandler::new(); io.extend_with(web3); @@ -46,7 +46,7 @@ fn rpc_web3_sha3() { #[test] fn rpc_web3_sha3_wiki() { - let web3 = Web3Client::new().to_delegate(); + let web3 = Web3Client::default().to_delegate(); let mut io = IoHandler::new(); io.extend_with(web3); diff --git a/rpc/src/v1/types/block.rs b/rpc/src/v1/types/block.rs index 6e23647a0..61f4402af 100644 --- a/rpc/src/v1/types/block.rs +++ b/rpc/src/v1/types/block.rs @@ -139,21 +139,21 @@ impl From for Header { impl<'a> From<&'a EthHeader> for Header { fn from(h: &'a EthHeader) -> Self { Header { - hash: Some(h.hash().into()), + hash: Some(h.hash()), size: Some(h.rlp().as_raw().len().into()), - parent_hash: h.parent_hash().into(), - uncles_hash: h.uncles_hash().into(), - author: h.author().into(), - miner: h.author().into(), - state_root: h.state_root().into(), - transactions_root: h.transactions_root().into(), - receipts_root: h.receipts_root().into(), + parent_hash: h.parent_hash(), + uncles_hash: h.uncles_hash(), + author: h.author(), + miner: h.author(), + state_root: h.state_root(), + transactions_root: h.transactions_root(), + receipts_root: h.receipts_root(), number: Some(h.number().into()), - gas_used: h.gas_used().into(), - gas_limit: h.gas_limit().into(), - logs_bloom: h.log_bloom().into(), + gas_used: h.gas_used(), + gas_limit: h.gas_limit(), + logs_bloom: h.log_bloom(), timestamp: h.timestamp().into(), - difficulty: h.difficulty().into(), + difficulty: h.difficulty(), extra_data: h.extra_data().into(), seal_fields: h.view().decode_seal() .expect("Client/Miner returns only valid headers. We only serialize headers from Client/Miner; qed") diff --git a/rpc/src/v1/types/block_number.rs b/rpc/src/v1/types/block_number.rs index 64b100d5a..7e19f2d3d 100644 --- a/rpc/src/v1/types/block_number.rs +++ b/rpc/src/v1/types/block_number.rs @@ -107,7 +107,7 @@ impl<'a> Visitor<'a> for BlockNumberVisitor { _ if value.starts_with("0x") => u64::from_str_radix(&value[2..], 16).map(BlockNumber::Num).map_err(|e| { Error::custom(format!("Invalid block number: {}", e)) }), - _ => Err(Error::custom(format!("Invalid block number: missing 0x prefix"))), + _ => Err(Error::custom("Invalid block number: missing 0x prefix".to_string())), } } diff --git a/rpc/src/v1/types/confirmations.rs b/rpc/src/v1/types/confirmations.rs index 1534fbcea..dedd0ba25 100644 --- a/rpc/src/v1/types/confirmations.rs +++ b/rpc/src/v1/types/confirmations.rs @@ -41,7 +41,7 @@ pub struct ConfirmationRequest { impl From for ConfirmationRequest { fn from(c: helpers::ConfirmationRequest) -> Self { ConfirmationRequest { - id: c.id.into(), + id: c.id, payload: c.payload.into(), origin: c.origin, } @@ -214,15 +214,15 @@ impl From for ConfirmationPayload { helpers::ConfirmationPayload::SendTransaction(t) => ConfirmationPayload::SendTransaction(t.into()), helpers::ConfirmationPayload::SignTransaction(t) => ConfirmationPayload::SignTransaction(t.into()), helpers::ConfirmationPayload::EthSignMessage(address, data) => ConfirmationPayload::EthSignMessage(EthSignRequest { - address: address.into(), + address, data: data.into(), }), helpers::ConfirmationPayload::SignMessage(address, data) => ConfirmationPayload::EIP191SignMessage(EIP191SignRequest { - address: address.into(), - data: data.into(), + address, + data, }), helpers::ConfirmationPayload::Decrypt(address, msg) => ConfirmationPayload::Decrypt(DecryptRequest { - address: address.into(), + address, msg: msg.into(), }), } diff --git a/rpc/src/v1/types/consensus_status.rs b/rpc/src/v1/types/consensus_status.rs index a5a5c9de8..da2aa26a1 100644 --- a/rpc/src/v1/types/consensus_status.rs +++ b/rpc/src/v1/types/consensus_status.rs @@ -109,7 +109,7 @@ impl Into for updater::VersionInfo { VersionInfo { track: self.track.into(), version: self.version.into(), - hash: self.hash.into(), + hash: self.hash, } } } diff --git a/rpc/src/v1/types/filter.rs b/rpc/src/v1/types/filter.rs index c6708da57..ec9f54179 100644 --- a/rpc/src/v1/types/filter.rs +++ b/rpc/src/v1/types/filter.rs @@ -88,10 +88,7 @@ impl Filter { }; let (from_block, to_block) = match self.block_hash { - Some(hash) => { - let hash = hash.into(); - (BlockId::Hash(hash), BlockId::Hash(hash)) - }, + Some(hash) => (BlockId::Hash(hash), BlockId::Hash(hash)), None => (self.from_block.map_or_else(|| BlockId::Latest, &num_to_id), self.to_block.map_or_else(|| BlockId::Latest, &num_to_id)), @@ -101,14 +98,14 @@ impl Filter { from_block, to_block, address: self.address.and_then(|address| match address { VariadicValue::Null => None, - VariadicValue::Single(a) => Some(vec![a.into()]), - VariadicValue::Multiple(a) => Some(a.into_iter().map(Into::into).collect()) + VariadicValue::Single(a) => Some(vec![a]), + VariadicValue::Multiple(a) => Some(a) }), topics: { let mut iter = self.topics.map_or_else(Vec::new, |topics| topics.into_iter().take(4).map(|topic| match topic { VariadicValue::Null => None, - VariadicValue::Single(t) => Some(vec![t.into()]), - VariadicValue::Multiple(t) => Some(t.into_iter().map(Into::into).collect()) + VariadicValue::Single(t) => Some(vec![t]), + VariadicValue::Multiple(t) => Some(t) }).collect()).into_iter(); vec![ diff --git a/rpc/src/v1/types/log.rs b/rpc/src/v1/types/log.rs index 3dcc8fb29..57b2cdd5d 100644 --- a/rpc/src/v1/types/log.rs +++ b/rpc/src/v1/types/log.rs @@ -51,12 +51,12 @@ pub struct Log { impl From for Log { fn from(e: LocalizedLogEntry) -> Log { Log { - address: e.entry.address.into(), + address: e.entry.address, topics: e.entry.topics.into_iter().map(Into::into).collect(), data: e.entry.data.into(), - block_hash: Some(e.block_hash.into()), + block_hash: Some(e.block_hash), block_number: Some(e.block_number.into()), - transaction_hash: Some(e.transaction_hash.into()), + transaction_hash: Some(e.transaction_hash), transaction_index: Some(e.transaction_index.into()), log_index: Some(e.log_index.into()), transaction_log_index: Some(e.transaction_log_index.into()), @@ -69,7 +69,7 @@ impl From for Log { impl From for Log { fn from(e: LogEntry) -> Log { Log { - address: e.address.into(), + address: e.address, topics: e.topics.into_iter().map(Into::into).collect(), data: e.data.into(), block_hash: None, diff --git a/rpc/src/v1/types/private_receipt.rs b/rpc/src/v1/types/private_receipt.rs index fd0eae067..68e9e716f 100644 --- a/rpc/src/v1/types/private_receipt.rs +++ b/rpc/src/v1/types/private_receipt.rs @@ -34,9 +34,9 @@ pub struct PrivateTransactionReceipt { impl From for PrivateTransactionReceipt { fn from(r: EthPrivateReceipt) -> Self { PrivateTransactionReceipt { - transaction_hash: r.hash.into(), - contract_address: r.contract_address.into(), - status_code: r.status_code.into(), + transaction_hash: r.hash, + contract_address: r.contract_address, + status_code: r.status_code, } } } diff --git a/rpc/src/v1/types/pubsub.rs b/rpc/src/v1/types/pubsub.rs index c526a2b37..1586b115c 100644 --- a/rpc/src/v1/types/pubsub.rs +++ b/rpc/src/v1/types/pubsub.rs @@ -26,9 +26,9 @@ use v1::types::{RichHeader, Filter, Log}; #[derive(Debug, Clone, PartialEq, Eq)] pub enum Result { /// New block header. - Header(RichHeader), + Header(Box), /// Log - Log(Log), + Log(Box), /// Transaction hash TransactionHash(H256), } @@ -144,7 +144,7 @@ mod tests { #[test] fn should_serialize_header() { - let header = Result::Header(RichHeader { + let header = Result::Header(Box::new(RichHeader { extra_info: Default::default(), inner: Header { hash: Some(Default::default()), @@ -165,7 +165,7 @@ mod tests { seal_fields: vec![Default::default(), Default::default()], size: Some(69.into()), }, - }); + })); let expected = r#"{"author":"0x0000000000000000000000000000000000000000","difficulty":"0x0","extraData":"0x","gasLimit":"0x0","gasUsed":"0x0","hash":"0x0000000000000000000000000000000000000000000000000000000000000000","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","miner":"0x0000000000000000000000000000000000000000","number":"0x0","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000","receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","sealFields":["0x","0x"],"sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000","size":"0x45","stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","timestamp":"0x0","transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000"}"#; assert_eq!(serde_json::to_string(&header).unwrap(), expected); } diff --git a/rpc/src/v1/types/receipt.rs b/rpc/src/v1/types/receipt.rs index f440c8f48..f492ca98c 100644 --- a/rpc/src/v1/types/receipt.rs +++ b/rpc/src/v1/types/receipt.rs @@ -56,7 +56,7 @@ impl Receipt { fn outcome_to_state_root(outcome: TransactionOutcome) -> Option { match outcome { TransactionOutcome::Unknown | TransactionOutcome::StatusCode(_) => None, - TransactionOutcome::StateRoot(root) => Some(root.into()), + TransactionOutcome::StateRoot(root) => Some(root), } } @@ -72,18 +72,18 @@ impl From for Receipt { fn from(r: LocalizedReceipt) -> Self { Receipt { to: r.to.map(Into::into), - from: Some(r.from.into()), - transaction_hash: Some(r.transaction_hash.into()), + from: Some(r.from), + transaction_hash: Some(r.transaction_hash), transaction_index: Some(r.transaction_index.into()), - block_hash: Some(r.block_hash.into()), + block_hash: Some(r.block_hash), block_number: Some(r.block_number.into()), - cumulative_gas_used: r.cumulative_gas_used.into(), - gas_used: Some(r.gas_used.into()), + cumulative_gas_used: r.cumulative_gas_used, + gas_used: Some(r.gas_used), contract_address: r.contract_address.map(Into::into), logs: r.logs.into_iter().map(Into::into).collect(), status_code: Self::outcome_to_status_code(&r.outcome), state_root: Self::outcome_to_state_root(r.outcome), - logs_bloom: r.log_bloom.into(), + logs_bloom: r.log_bloom, } } } @@ -93,17 +93,17 @@ impl From for Receipt { Receipt { from: None, to: None, - transaction_hash: Some(r.transaction_hash.into()), + transaction_hash: Some(r.transaction_hash), transaction_index: Some(r.transaction_index.into()), block_hash: None, block_number: None, - cumulative_gas_used: r.cumulative_gas_used.into(), - gas_used: Some(r.gas_used.into()), + cumulative_gas_used: r.cumulative_gas_used, + gas_used: Some(r.gas_used), contract_address: r.contract_address.map(Into::into), logs: r.logs.into_iter().map(Into::into).collect(), status_code: Self::outcome_to_status_code(&r.outcome), state_root: Self::outcome_to_state_root(r.outcome), - logs_bloom: r.log_bloom.into(), + logs_bloom: r.log_bloom, } } } @@ -117,13 +117,13 @@ impl From for Receipt { transaction_index: None, block_hash: None, block_number: None, - cumulative_gas_used: r.gas_used.into(), + cumulative_gas_used: r.gas_used, gas_used: None, contract_address: None, logs: r.logs.into_iter().map(Into::into).collect(), status_code: Self::outcome_to_status_code(&r.outcome), state_root: Self::outcome_to_state_root(r.outcome), - logs_bloom: r.log_bloom.into(), + logs_bloom: r.log_bloom, } } } diff --git a/rpc/src/v1/types/sync.rs b/rpc/src/v1/types/sync.rs index 10094742c..901611fea 100644 --- a/rpc/src/v1/types/sync.rs +++ b/rpc/src/v1/types/sync.rs @@ -120,7 +120,7 @@ impl From for PipProtocolInfo { fn from(info: sync::PipProtocolInfo) -> Self { PipProtocolInfo { version: info.version, - difficulty: info.difficulty.into(), + difficulty: info.difficulty, head: format!("{:x}", info.head), } } @@ -179,7 +179,7 @@ impl From for TransactionStats { first_seen: s.first_seen, propagated_to: s.propagated_to .into_iter() - .map(|(id, count)| (id.into(), count)) + .map(|(id, count)| (id, count)) .collect(), } } diff --git a/rpc/src/v1/types/trace.rs b/rpc/src/v1/types/trace.rs index 715ffe62c..58a5ee596 100644 --- a/rpc/src/v1/types/trace.rs +++ b/rpc/src/v1/types/trace.rs @@ -58,8 +58,8 @@ pub struct StorageDiff { impl From for StorageDiff { fn from(c: et::StorageDiff) -> Self { StorageDiff { - key: c.location.into(), - val: c.value.into(), + key: c.location, + val: c.value, } } } @@ -190,7 +190,7 @@ impl From for AccountDiff { balance: c.balance.into(), nonce: c.nonce.into(), code: c.code.into(), - storage: c.storage.into_iter().map(|(k, v)| (k.into(), v.into())).collect(), + storage: c.storage.into_iter().map(|(k, v)| (k, v.into())).collect(), } } } @@ -208,7 +208,7 @@ impl Serialize for StateDiff { impl From for StateDiff { fn from(c: state_diff::StateDiff) -> Self { - StateDiff(c.raw.into_iter().map(|(k, v)| (k.into(), v.into())).collect()) + StateDiff(c.raw.into_iter().map(|(k, v)| (k, v.into())).collect()) } } @@ -228,9 +228,9 @@ pub struct Create { impl From for Create { fn from(c: trace::Create) -> Self { Create { - from: c.from.into(), - value: c.value.into(), - gas: c.gas.into(), + from: c.from, + value: c.value, + gas: c.gas, init: Bytes::new(c.init), } } @@ -285,10 +285,10 @@ pub struct Call { impl From for Call { fn from(c: trace::Call) -> Self { Call { - from: c.from.into(), - to: c.to.into(), - value: c.value.into(), - gas: c.gas.into(), + from: c.from, + to: c.to, + value: c.value, + gas: c.gas, input: c.input.into(), call_type: c.call_type.into(), } @@ -335,8 +335,8 @@ pub struct Reward { impl From for Reward { fn from(r: trace::Reward) -> Self { Reward { - author: r.author.into(), - value: r.value.into(), + author: r.author, + value: r.value, reward_type: r.reward_type.into(), } } @@ -357,9 +357,9 @@ pub struct Suicide { impl From for Suicide { fn from(s: trace::Suicide) -> Self { Suicide { - address: s.address.into(), - refund_address: s.refund_address.into(), - balance: s.balance.into(), + address: s.address, + refund_address: s.refund_address, + balance: s.balance, } } } @@ -401,7 +401,7 @@ pub struct CallResult { impl From for CallResult { fn from(c: trace::CallResult) -> Self { CallResult { - gas_used: c.gas_used.into(), + gas_used: c.gas_used, output: c.output.into(), } } @@ -422,9 +422,9 @@ pub struct CreateResult { impl From for CreateResult { fn from(c: trace::CreateResult) -> Self { CreateResult { - gas_used: c.gas_used.into(), + gas_used: c.gas_used, code: c.code.into(), - address: c.address.into(), + address: c.address, } } } @@ -526,11 +526,11 @@ impl From for LocalizedTrace { action: t.action.into(), result: t.result.into(), trace_address: t.trace_address.into_iter().map(Into::into).collect(), - subtraces: t.subtraces.into(), + subtraces: t.subtraces, transaction_position: t.transaction_number.map(Into::into), transaction_hash: t.transaction_hash.map(Into::into), - block_number: t.block_number.into(), - block_hash: t.block_hash.into(), + block_number: t.block_number, + block_hash: t.block_hash, } } } @@ -591,7 +591,7 @@ impl From for Trace { fn from(t: FlatTrace) -> Self { Trace { trace_address: t.trace_address.into_iter().map(Into::into).collect(), - subtraces: t.subtraces.into(), + subtraces: t.subtraces, action: t.action.into(), result: t.result.into(), } @@ -646,7 +646,7 @@ impl From<(H256, Executed)> for TraceResultsWithTransactionHash { trace: t.1.trace.into_iter().map(Into::into).collect(), vm_trace: t.1.vm_trace.map(Into::into), state_diff: t.1.state_diff.map(Into::into), - transaction_hash: t.0.into(), + transaction_hash: t.0, } } } diff --git a/rpc/src/v1/types/transaction.rs b/rpc/src/v1/types/transaction.rs index 72b591a89..931e03866 100644 --- a/rpc/src/v1/types/transaction.rs +++ b/rpc/src/v1/types/transaction.rs @@ -177,22 +177,22 @@ impl Transaction { let signature = t.signature(); let scheme = CreateContractAddress::FromSenderAndNonce; Transaction { - hash: t.hash().into(), - nonce: t.nonce.into(), - block_hash: Some(t.block_hash.clone().into()), + hash: t.hash(), + nonce: t.nonce, + block_hash: Some(t.block_hash), block_number: Some(t.block_number.into()), transaction_index: Some(t.transaction_index.into()), - from: t.sender().into(), + from: t.sender(), to: match t.action { Action::Create => None, - Action::Call(ref address) => Some(address.clone().into()) + Action::Call(ref address) => Some(*address) }, - value: t.value.into(), - gas_price: t.gas_price.into(), - gas: t.gas.into(), + value: t.value, + gas_price: t.gas_price, + gas: t.gas, input: Bytes::new(t.data.clone()), creates: match t.action { - Action::Create => Some(contract_address(scheme, &t.sender(), &t.nonce, &t.data).0.into()), + Action::Create => Some(contract_address(scheme, &t.sender(), &t.nonce, &t.data).0), Action::Call(_) => None, }, raw: ::rlp::encode(&t.signed).into(), @@ -211,22 +211,22 @@ impl Transaction { let signature = t.signature(); let scheme = CreateContractAddress::FromSenderAndNonce; Transaction { - hash: t.hash().into(), - nonce: t.nonce.into(), + hash: t.hash(), + nonce: t.nonce, block_hash: None, block_number: None, transaction_index: None, - from: t.sender().into(), + from: t.sender(), to: match t.action { Action::Create => None, - Action::Call(ref address) => Some(address.clone().into()) + Action::Call(ref address) => Some(*address) }, - value: t.value.into(), - gas_price: t.gas_price.into(), - gas: t.gas.into(), + value: t.value, + gas_price: t.gas_price, + gas: t.gas, input: Bytes::new(t.data.clone()), creates: match t.action { - Action::Create => Some(contract_address(scheme, &t.sender(), &t.nonce, &t.data).0.into()), + Action::Create => Some(contract_address(scheme, &t.sender(), &t.nonce, &t.data).0), Action::Call(_) => None, }, raw: ::rlp::encode(&t).into(), @@ -243,7 +243,7 @@ impl Transaction { /// Convert `PendingTransaction` into RPC Transaction. pub fn from_pending(t: PendingTransaction) -> Transaction { let mut r = Transaction::from_signed(t.transaction); - r.condition = t.condition.map(|b| b.into()); + r.condition = r.condition.map(Into::into); r } } @@ -265,8 +265,8 @@ impl LocalTransactionStatus { Canceled(tx) => LocalTransactionStatus::Canceled(convert(tx)), Replaced { old, new } => LocalTransactionStatus::Replaced( convert(old), - new.signed().gas_price.into(), - new.signed().hash().into(), + new.signed().gas_price, + new.signed().hash(), ), } } diff --git a/rpc/src/v1/types/transaction_request.rs b/rpc/src/v1/types/transaction_request.rs index a4698cafa..944ee1114 100644 --- a/rpc/src/v1/types/transaction_request.rs +++ b/rpc/src/v1/types/transaction_request.rs @@ -63,7 +63,7 @@ pub fn format_ether(i: U256) -> String { impl fmt::Display for TransactionRequest { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let eth = self.value.unwrap_or(U256::from(0)); + let eth = self.value.unwrap_or_default(); match self.to { Some(ref to) => write!( f, @@ -106,14 +106,14 @@ impl From for TransactionRequest { impl From for TransactionRequest { fn from(r: helpers::FilledTransactionRequest) -> Self { TransactionRequest { - from: Some(r.from.into()), - to: r.to.map(Into::into), - gas_price: Some(r.gas_price.into()), - gas: Some(r.gas.into()), - value: Some(r.value.into()), + from: Some(r.from), + to: r.to, + gas_price: Some(r.gas_price), + gas: Some(r.gas), + value: Some(r.value), data: Some(r.data.into()), - nonce: r.nonce.map(Into::into), - condition: r.condition.map(Into::into), + nonce: r.nonce, + condition: r.condition, } } }