diff --git a/README.md b/README.md index e07e9395..8d6d4af6 100644 --- a/README.md +++ b/README.md @@ -20,8 +20,6 @@ It assumes that the node has password authentication setup, the RPC interface is is set up to accept RPC connections. ```rust -extern crate bitcoincore_rpc; - use bitcoincore_rpc::{Auth, Client, RpcApi}; fn main() { diff --git a/client/src/client.rs b/client/src/client.rs index faea7490..e39cf6ff 100644 --- a/client/src/client.rs +++ b/client/src/client.rs @@ -17,11 +17,8 @@ use std::{fmt, result}; use crate::{bitcoin, deserialize_hex}; use bitcoin::hex::DisplayHex; -use jsonrpc; -use serde; -use serde_json; -use crate::bitcoin::address::{NetworkUnchecked, NetworkChecked}; +use crate::bitcoin::address::{NetworkChecked, NetworkUnchecked}; use crate::bitcoin::hashes::hex::FromHex; use crate::bitcoin::secp256k1::ecdsa::Signature; use crate::bitcoin::{ @@ -54,11 +51,11 @@ impl From for JsonOutPoint { } } -impl Into for JsonOutPoint { - fn into(self) -> OutPoint { +impl From for OutPoint { + fn from(val: JsonOutPoint) -> Self { OutPoint { - txid: self.txid, - vout: self.vout, + txid: val.txid, + vout: val.vout, } } } @@ -112,9 +109,9 @@ fn empty_obj() -> serde_json::Value { /// /// Elements of `args` without corresponding `defaults` value, won't /// be substituted, because they are required. -fn handle_defaults<'a, 'b>( +fn handle_defaults<'a>( args: &'a mut [serde_json::Value], - defaults: &'b [serde_json::Value], + defaults: &[serde_json::Value], ) -> &'a [serde_json::Value] { assert!(args.len() >= defaults.len()); @@ -230,7 +227,7 @@ pub trait RpcApi: Sized { &self, id: &>::Id, ) -> Result { - T::query(&self, &id) + T::query(self, id) } fn get_network_info(&self) -> Result { @@ -377,9 +374,9 @@ pub trait RpcApi: Sized { self.call( "getblocktemplate", &[into_json(Argument { - mode: mode, - rules: rules, - capabilities: capabilities, + mode, + rules, + capabilities, })?], ) } @@ -418,7 +415,7 @@ pub trait RpcApi: Sized { type_: json::SoftforkType::Buried, bip9: None, height: None, - active: active, + active, }, ); } @@ -531,7 +528,7 @@ pub trait RpcApi: Sized { } fn get_balances(&self) -> Result { - Ok(self.call("getbalances", &[])?) + self.call("getbalances", &[]) } fn get_received_by_address(&self, address: &Address, minconf: Option) -> Result { @@ -702,18 +699,14 @@ pub trait RpcApi: Sized { /// To unlock, use [unlock_unspent]. fn lock_unspent(&self, outputs: &[OutPoint]) -> Result { - let outputs: Vec<_> = outputs - .into_iter() - .map(|o| serde_json::to_value(JsonOutPoint::from(*o)).unwrap()) - .collect(); + let outputs: Vec<_> = + outputs.iter().map(|o| serde_json::to_value(JsonOutPoint::from(*o)).unwrap()).collect(); self.call("lockunspent", &[false.into(), outputs.into()]) } fn unlock_unspent(&self, outputs: &[OutPoint]) -> Result { - let outputs: Vec<_> = outputs - .into_iter() - .map(|o| serde_json::to_value(JsonOutPoint::from(*o)).unwrap()) - .collect(); + let outputs: Vec<_> = + outputs.iter().map(|o| serde_json::to_value(JsonOutPoint::from(*o)).unwrap()).collect(); self.call("lockunspent", &[true.into(), outputs.into()]) } @@ -891,7 +884,10 @@ pub trait RpcApi: Sized { } /// Generate new address for receiving change - fn get_raw_change_address(&self, address_type: Option) -> Result> { + fn get_raw_change_address( + &self, + address_type: Option, + ) -> Result> { self.call("getrawchangeaddress", &[opt_into_json(address_type)?]) } @@ -987,22 +983,22 @@ pub trait RpcApi: Sized { /// Attempts to add a node to the addnode list. /// Nodes added using addnode (or -connect) are protected from DoS disconnection and are not required to be full nodes/support SegWit as other outbound peers are (though such peers will not be synced from). fn add_node(&self, addr: &str) -> Result<()> { - self.call("addnode", &[into_json(&addr)?, into_json("add")?]) + self.call("addnode", &[into_json(addr)?, into_json("add")?]) } /// Attempts to remove a node from the addnode list. fn remove_node(&self, addr: &str) -> Result<()> { - self.call("addnode", &[into_json(&addr)?, into_json("remove")?]) + self.call("addnode", &[into_json(addr)?, into_json("remove")?]) } /// Attempts to connect to a node without permanently adding it to the addnode list. fn onetry_node(&self, addr: &str) -> Result<()> { - self.call("addnode", &[into_json(&addr)?, into_json("onetry")?]) + self.call("addnode", &[into_json(addr)?, into_json("onetry")?]) } /// Immediately disconnects from the specified peer node. fn disconnect_node(&self, addr: &str) -> Result<()> { - self.call("disconnectnode", &[into_json(&addr)?]) + self.call("disconnectnode", &[into_json(addr)?]) } fn disconnect_node_by_id(&self, node_id: u32) -> Result<()> { @@ -1012,7 +1008,7 @@ pub trait RpcApi: Sized { /// Returns information about the given added node, or all added nodes (note that onetry addnodes are not listed here) fn get_added_node_info(&self, node: Option<&str>) -> Result> { if let Some(addr) = node { - self.call("getaddednodeinfo", &[into_json(&addr)?]) + self.call("getaddednodeinfo", &[into_json(addr)?]) } else { self.call("getaddednodeinfo", &[]) } @@ -1024,7 +1020,7 @@ pub trait RpcApi: Sized { count: Option, ) -> Result> { let cnt = count.unwrap_or(1); - self.call("getnodeaddresses", &[into_json(&cnt)?]) + self.call("getnodeaddresses", &[into_json(cnt)?]) } /// List all banned IPs/Subnets. @@ -1041,18 +1037,18 @@ pub trait RpcApi: Sized { fn add_ban(&self, subnet: &str, bantime: u64, absolute: bool) -> Result<()> { self.call( "setban", - &[into_json(&subnet)?, into_json("add")?, into_json(&bantime)?, into_json(&absolute)?], + &[into_json(subnet)?, into_json("add")?, into_json(bantime)?, into_json(absolute)?], ) } /// Attempts to remove an IP/Subnet from the banned list. fn remove_ban(&self, subnet: &str) -> Result<()> { - self.call("setban", &[into_json(&subnet)?, into_json("remove")?]) + self.call("setban", &[into_json(subnet)?, into_json("remove")?]) } /// Disable/enable all p2p network activity. fn set_network_active(&self, state: bool) -> Result { - self.call("setnetworkactive", &[into_json(&state)?]) + self.call("setnetworkactive", &[into_json(state)?]) } /// Returns data about each connected network node as an array of @@ -1182,7 +1178,11 @@ pub trait RpcApi: Sized { self.call("finalizepsbt", handle_defaults(&mut args, &[true.into()])) } - fn derive_addresses(&self, descriptor: &str, range: Option<[u32; 2]>) -> Result>> { + fn derive_addresses( + &self, + descriptor: &str, + range: Option<[u32; 2]>, + ) -> Result>> { let mut args = [into_json(descriptor)?, opt_into_json(range)?]; self.call("deriveaddresses", handle_defaults(&mut args, &[null()])) } @@ -1248,10 +1248,10 @@ pub trait RpcApi: Sized { /// Submit a block as a hex string fn submit_block_hex(&self, block_hex: &str) -> Result<()> { - match self.call("submitblock", &[into_json(&block_hex)?]) { + match self.call("submitblock", &[into_json(block_hex)?]) { Ok(serde_json::Value::Null) => Ok(()), Ok(res) => Err(Error::ReturnedError(res.to_string())), - Err(err) => Err(err.into()), + Err(err) => Err(err), } } @@ -1313,9 +1313,9 @@ impl RpcApi for Client { let json_string = serde_json::to_string(a)?; serde_json::value::RawValue::from_string(json_string) // we can't use to_raw_value here due to compat with Rust 1.29 }) - .map(|a| a.map_err(|e| Error::Json(e))) + .map(|a| a.map_err(Error::Json)) .collect::>>()?; - let req = self.client.build_request(&cmd, &raw_args); + let req = self.client.build_request(cmd, &raw_args); if log_enabled!(Debug) { debug!(target: "bitcoincore_rpc", "JSON-RPC request: {} {}", cmd, serde_json::Value::from(args)); } @@ -1357,12 +1357,11 @@ fn log_response(cmd: &str, resp: &Result) { mod tests { use super::*; use crate::bitcoin; - use serde_json; #[test] fn test_raw_tx() { use crate::bitcoin::consensus::encode; - let client = Client::new("http://localhost/".into(), Auth::None).unwrap(); + let client = Client::new("http://localhost/", Auth::None).unwrap(); let tx: bitcoin::Transaction = encode::deserialize(&Vec::::from_hex("0200000001586bd02815cf5faabfec986a4e50d25dbee089bd2758621e61c5fab06c334af0000000006b483045022100e85425f6d7c589972ee061413bcf08dc8c8e589ce37b217535a42af924f0e4d602205c9ba9cb14ef15513c9d946fa1c4b797883e748e8c32171bdf6166583946e35c012103dae30a4d7870cd87b45dd53e6012f71318fdd059c1c2623b8cc73f8af287bb2dfeffffff021dc4260c010000001976a914f602e88b2b5901d8aab15ebe4a97cf92ec6e03b388ac00e1f505000000001976a914687ffeffe8cf4e4c038da46a9b1d37db385a472d88acfd211500").unwrap()).unwrap(); assert!(client.send_raw_transaction(&tx).is_err()); diff --git a/client/src/error.rs b/client/src/error.rs index 3a6b6961..dc900a90 100644 --- a/client/src/error.rs +++ b/client/src/error.rs @@ -13,8 +13,6 @@ use std::{error, fmt, io}; use crate::bitcoin; use crate::bitcoin::hashes::hex; use crate::bitcoin::secp256k1; -use jsonrpc; -use serde_json; /// The error type for errors produced in this library. #[derive(Debug)] diff --git a/client/src/lib.rs b/client/src/lib.rs index c3c7b420..82f91b92 100644 --- a/client/src/lib.rs +++ b/client/src/lib.rs @@ -39,7 +39,7 @@ pub use crate::error::Error; pub use crate::queryable::*; fn deserialize_hex(hex: &str) -> Result { - let mut reader = HexToBytesIter::new(&hex)?; + let mut reader = HexToBytesIter::new(hex)?; let object = Decodable::consensus_decode(&mut reader)?; if reader.read_u8().is_ok() { Err(Error::BitcoinSerialization(bitcoin::consensus::encode::Error::ParseFailed( diff --git a/client/src/queryable.rs b/client/src/queryable.rs index 696a37d2..880dbb5b 100644 --- a/client/src/queryable.rs +++ b/client/src/queryable.rs @@ -9,7 +9,6 @@ // use crate::bitcoin; -use serde_json; use crate::client::Result; use crate::client::RpcApi; diff --git a/integration_test/src/main.rs b/integration_test/src/main.rs index 7c439619..00fe79b7 100644 --- a/integration_test/src/main.rs +++ b/integration_test/src/main.rs @@ -26,7 +26,7 @@ use crate::json::BlockStatsFields as BsFields; use bitcoin::consensus::encode::{deserialize, serialize_hex}; use bitcoin::hashes::hex::FromHex; use bitcoin::hashes::Hash; -use bitcoin::{secp256k1, ScriptBuf, sighash}; +use bitcoin::{secp256k1, sighash, ScriptBuf}; use bitcoin::{ transaction, Address, Amount, Network, OutPoint, PrivateKey, Sequence, SignedAmount, Transaction, TxIn, TxOut, Txid, Witness, @@ -109,21 +109,21 @@ fn sbtc>(btc: F) -> SignedAmount { } fn get_testdir() -> String { - return std::env::var("TESTDIR").expect("TESTDIR must be set"); + std::env::var("TESTDIR").expect("TESTDIR must be set") } fn get_rpc_url() -> String { - return std::env::var("RPC_URL").expect("RPC_URL must be set"); + std::env::var("RPC_URL").expect("RPC_URL must be set") } fn get_auth() -> bitcoincore_rpc::Auth { if let Ok(cookie) = std::env::var("RPC_COOKIE") { - return Auth::CookieFile(cookie.into()); + Auth::CookieFile(cookie.into()) } else if let Ok(user) = std::env::var("RPC_USER") { return Auth::UserPass(user, std::env::var("RPC_PASS").unwrap_or_default()); } else { panic!("Either RPC_COOKIE or RPC_USER + RPC_PASS must be set."); - }; + } } fn new_wallet_client(wallet_name: &str) -> Client { @@ -249,7 +249,8 @@ fn test_get_new_address(cl: &Client) { let addr = cl.get_new_address(None, Some(json::AddressType::Bech32)).unwrap().assume_checked(); assert_eq!(addr.address_type(), Some(bitcoin::AddressType::P2wpkh)); - let addr = cl.get_new_address(None, Some(json::AddressType::P2shSegwit)).unwrap().assume_checked(); + let addr = + cl.get_new_address(None, Some(json::AddressType::P2shSegwit)).unwrap().assume_checked(); assert_eq!(addr.address_type(), Some(bitcoin::AddressType::P2sh)); } @@ -260,7 +261,8 @@ fn test_get_raw_change_address(cl: &Client) { let addr = cl.get_raw_change_address(Some(json::AddressType::Bech32)).unwrap().assume_checked(); assert_eq!(addr.address_type(), Some(bitcoin::AddressType::P2wpkh)); - let addr = cl.get_raw_change_address(Some(json::AddressType::P2shSegwit)).unwrap().assume_checked(); + let addr = + cl.get_raw_change_address(Some(json::AddressType::P2shSegwit)).unwrap().assume_checked(); assert_eq!(addr.address_type(), Some(bitcoin::AddressType::P2sh)); } @@ -290,7 +292,9 @@ fn test_generate(cl: &Client) { fn test_get_balance_generate_to_address(cl: &Client) { let initial = cl.get_balance(None, None).unwrap(); - let blocks = cl.generate_to_address(500, &cl.get_new_address(None, None).unwrap().assume_checked()).unwrap(); + let blocks = cl + .generate_to_address(500, &cl.get_new_address(None, None).unwrap().assume_checked()) + .unwrap(); assert_eq!(blocks.len(), 500); assert_ne!(cl.get_balance(None, None).unwrap(), initial); } @@ -299,7 +303,9 @@ fn test_get_balances_generate_to_address(cl: &Client) { if version() >= 190000 { let initial = cl.get_balances().unwrap(); - let blocks = cl.generate_to_address(500, &cl.get_new_address(None, None).unwrap().assume_checked()).unwrap(); + let blocks = cl + .generate_to_address(500, &cl.get_new_address(None, None).unwrap().assume_checked()) + .unwrap(); assert_eq!(blocks.len(), 500); assert_ne!(cl.get_balances().unwrap(), initial); } @@ -375,7 +381,8 @@ fn test_get_address_info(cl: &Client) { let info = cl.get_address_info(&addr).unwrap(); assert!(!info.witness_program.unwrap().is_empty()); - let addr = cl.get_new_address(None, Some(json::AddressType::P2shSegwit)).unwrap().assume_checked(); + let addr = + cl.get_new_address(None, Some(json::AddressType::P2shSegwit)).unwrap().assume_checked(); let info = cl.get_address_info(&addr).unwrap(); assert!(!info.hex.unwrap().is_empty()); } @@ -431,7 +438,9 @@ fn test_get_received_by_address(cl: &Client) { let _ = cl.send_to_address(&addr, btc(1), None, None, None, None, None, None).unwrap(); assert_eq!(cl.get_received_by_address(&addr, Some(0)).unwrap(), btc(1)); assert_eq!(cl.get_received_by_address(&addr, Some(1)).unwrap(), btc(0)); - let _ = cl.generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()).unwrap(); + let _ = cl + .generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()) + .unwrap(); assert_eq!(cl.get_received_by_address(&addr, Some(6)).unwrap(), btc(1)); assert_eq!(cl.get_received_by_address(&addr, None).unwrap(), btc(1)); } @@ -439,19 +448,23 @@ fn test_get_received_by_address(cl: &Client) { fn test_list_unspent(cl: &Client) { let addr = cl.get_new_address(None, None).unwrap(); let addr_checked = addr.clone().assume_checked(); - let txid = cl.send_to_address(&addr.clone().assume_checked(), btc(1), None, None, None, None, None, None).unwrap(); - let unspent = cl.list_unspent(Some(0), None, Some(&[ &addr_checked]), None, None).unwrap(); + let txid = cl + .send_to_address(&addr.clone().assume_checked(), btc(1), None, None, None, None, None, None) + .unwrap(); + let unspent = cl.list_unspent(Some(0), None, Some(&[&addr_checked]), None, None).unwrap(); assert_eq!(unspent[0].txid, txid); assert_eq!(unspent[0].address.as_ref(), Some(&addr)); assert_eq!(unspent[0].amount, btc(1)); - let txid = cl.send_to_address(&addr_checked, btc(7), None, None, None, None, None, None).unwrap(); + let txid = + cl.send_to_address(&addr_checked, btc(7), None, None, None, None, None, None).unwrap(); let options = json::ListUnspentQueryOptions { minimum_amount: Some(btc(7)), maximum_amount: Some(btc(7)), ..Default::default() }; - let unspent = cl.list_unspent(Some(0), None, Some(&[&addr_checked]), None, Some(options)).unwrap(); + let unspent = + cl.list_unspent(Some(0), None, Some(&[&addr_checked]), None, Some(options)).unwrap(); assert_eq!(unspent.len(), 1); assert_eq!(unspent[0].txid, txid); assert_eq!(unspent[0].address.as_ref(), Some(&addr)); @@ -477,7 +490,9 @@ fn test_get_raw_transaction(cl: &Client) { let info = cl.get_raw_transaction_info(&txid, None).unwrap(); assert_eq!(info.txid, txid); - let blocks = cl.generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()).unwrap(); + let blocks = cl + .generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()) + .unwrap(); let _ = cl.get_raw_transaction_info(&txid, Some(&blocks[0])).unwrap(); } @@ -533,7 +548,9 @@ fn test_get_tx_out_proof(cl: &Client) { cl.send_to_address(&RANDOM_ADDRESS, btc(1), None, None, None, None, None, None).unwrap(); let txid2 = cl.send_to_address(&RANDOM_ADDRESS, btc(1), None, None, None, None, None, None).unwrap(); - let blocks = cl.generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()).unwrap(); + let blocks = cl + .generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()) + .unwrap(); let proof = cl.get_tx_out_proof(&[txid1, txid2], Some(&blocks[0])).unwrap(); assert!(!proof.is_empty()); } @@ -560,7 +577,9 @@ fn test_lock_unspent_unlock_unspent(cl: &Client) { } fn test_get_block_filter(cl: &Client) { - let blocks = cl.generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()).unwrap(); + let blocks = cl + .generate_to_address(7, &cl.get_new_address(None, None).unwrap().assume_checked()) + .unwrap(); if version() >= 190000 { let _ = cl.get_block_filter(&blocks[0]).unwrap(); } else { @@ -581,7 +600,7 @@ fn test_sign_raw_transaction_with_send_raw_transaction(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let tx = Transaction { version: transaction::Version::ONE, @@ -617,7 +636,7 @@ fn test_sign_raw_transaction_with_send_raw_transaction(cl: &Client) { lock_time: LockTime::ZERO, input: vec![TxIn { previous_output: OutPoint { - txid: txid, + txid, vout: 0, }, script_sig: ScriptBuf::new(), @@ -631,7 +650,12 @@ fn test_sign_raw_transaction_with_send_raw_transaction(cl: &Client) { }; let res = cl - .sign_raw_transaction_with_key(&tx, &[sk], None, Some(sighash::EcdsaSighashType::All.into())) + .sign_raw_transaction_with_key( + &tx, + &[sk], + None, + Some(sighash::EcdsaSighashType::All.into()), + ) .unwrap(); assert!(res.complete); let _ = cl.send_raw_transaction(&res.transaction().unwrap()).unwrap(); @@ -654,7 +678,7 @@ fn test_create_raw_transaction(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, @@ -677,7 +701,7 @@ fn test_decode_raw_transaction(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, @@ -746,7 +770,7 @@ fn test_test_mempool_accept(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, @@ -774,7 +798,7 @@ fn test_wallet_create_funded_psbt(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, @@ -832,7 +856,7 @@ fn test_wallet_process_psbt(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, vout: unspent.vout, @@ -888,7 +912,7 @@ fn test_combine_psbt(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, vout: unspent.vout, @@ -910,7 +934,7 @@ fn test_combine_raw_transaction(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, vout: unspent.vout, @@ -931,7 +955,7 @@ fn test_create_psbt(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, @@ -950,7 +974,7 @@ fn test_finalize_psbt(cl: &Client) { ..Default::default() }; let unspent = cl.list_unspent(Some(6), None, None, None, Some(options)).unwrap(); - let unspent = unspent.into_iter().nth(0).unwrap(); + let unspent = unspent.into_iter().next().unwrap(); let input = json::CreateRawTransactionInput { txid: unspent.txid, vout: unspent.vout, @@ -1047,7 +1071,7 @@ fn test_estimate_smart_fee(cl: &Client) { } fn test_ping(cl: &Client) { - let _ = cl.ping().unwrap(); + cl.ping().unwrap(); } fn test_get_peer_info(cl: &Client) { @@ -1160,7 +1184,7 @@ fn test_create_wallet(cl: &Client) { // Main wallet created for tests assert!(loaded_wallet_list.iter().any(|w| w == "testwallet")); - loaded_wallet_list.retain(|w| w != "testwallet" && w != ""); + loaded_wallet_list.retain(|w| w != "testwallet" && !w.is_empty()); // Created wallets assert!(loaded_wallet_list.iter().zip(wallet_names).all(|(a, b)| a == b)); @@ -1280,9 +1304,7 @@ fn test_getblocktemplate(cl: &Client) { fn test_unloadwallet(cl: &Client) { cl.create_wallet("testunloadwallet", None, None, None, None).unwrap(); - let res = new_wallet_client("testunloadwallet") - .unload_wallet(None) - .unwrap(); + let res = new_wallet_client("testunloadwallet").unload_wallet(None).unwrap(); if version() >= 210000 { assert!(res.is_some()); @@ -1321,7 +1343,13 @@ fn test_wait_for_new_block(cl: &Client) { let hash = cl.get_block_hash(height).unwrap(); assert!(cl.wait_for_new_block(std::u64::MAX).is_err()); // JSON integer out of range - assert_eq!(cl.wait_for_new_block(100).unwrap(), json::BlockRef{hash, height}); + assert_eq!( + cl.wait_for_new_block(100).unwrap(), + json::BlockRef { + hash, + height + } + ); } fn test_wait_for_block(cl: &Client) { @@ -1329,15 +1357,26 @@ fn test_wait_for_block(cl: &Client) { let hash = cl.get_block_hash(height).unwrap(); assert!(cl.wait_for_block(&hash, std::u64::MAX).is_err()); // JSON integer out of range - assert_eq!(cl.wait_for_block(&hash, 0).unwrap(), json::BlockRef{hash, height}); + assert_eq!( + cl.wait_for_block(&hash, 0).unwrap(), + json::BlockRef { + hash, + height + } + ); } fn test_get_descriptor_info(cl: &Client) { - let res = cl.get_descriptor_info(r"pkh(cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR)").unwrap(); - assert_eq!(res.descriptor, r"pkh(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)#62k9sn4x"); - assert_eq!(res.is_range, false); - assert_eq!(res.is_solvable, true); - assert_eq!(res.has_private_keys, true); + let res = cl + .get_descriptor_info(r"pkh(cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR)") + .unwrap(); + assert_eq!( + res.descriptor, + r"pkh(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)#62k9sn4x" + ); + assert!(!res.is_range); + assert!(res.is_solvable); + assert!(res.has_private_keys); // Checksum introduced in: https://github.com/bitcoin/bitcoin/commit/26d3fad1093dfc697048313be7a96c9adf723654 if version() >= 190000 { @@ -1352,19 +1391,28 @@ fn test_get_descriptor_info(cl: &Client) { fn test_add_multisig_address(cl: &Client) { let addr1 = cl.get_new_address(None, Some(json::AddressType::Bech32)).unwrap().assume_checked(); let addr2 = cl.get_new_address(None, Some(json::AddressType::Bech32)).unwrap().assume_checked(); - let addresses = [ - json::PubKeyOrAddress::Address(&addr1), - json::PubKeyOrAddress::Address(&addr2), - ]; + let addresses = + [json::PubKeyOrAddress::Address(&addr1), json::PubKeyOrAddress::Address(&addr2)]; assert!(cl.add_multisig_address(addresses.len(), &addresses, None, None).is_ok()); assert!(cl.add_multisig_address(addresses.len() - 1, &addresses, None, None).is_ok()); assert!(cl.add_multisig_address(addresses.len() + 1, &addresses, None, None).is_err()); assert!(cl.add_multisig_address(0, &addresses, None, None).is_err()); assert!(cl.add_multisig_address(addresses.len(), &addresses, Some("test_label"), None).is_ok()); - assert!(cl.add_multisig_address(addresses.len(), &addresses, None, Some(json::AddressType::Legacy)).is_ok()); - assert!(cl.add_multisig_address(addresses.len(), &addresses, None, Some(json::AddressType::P2shSegwit)).is_ok()); - assert!(cl.add_multisig_address(addresses.len(), &addresses, None, Some(json::AddressType::Bech32)).is_ok()); + assert!(cl + .add_multisig_address(addresses.len(), &addresses, None, Some(json::AddressType::Legacy)) + .is_ok()); + assert!(cl + .add_multisig_address( + addresses.len(), + &addresses, + None, + Some(json::AddressType::P2shSegwit) + ) + .is_ok()); + assert!(cl + .add_multisig_address(addresses.len(), &addresses, None, Some(json::AddressType::Bech32)) + .is_ok()); } #[rustfmt::skip] diff --git a/json/src/lib.rs b/json/src/lib.rs index 3574ef1b..50cd1f75 100644 --- a/json/src/lib.rs +++ b/json/src/lib.rs @@ -24,13 +24,15 @@ extern crate serde_json; use std::collections::HashMap; - use bitcoin::address::NetworkUnchecked; use bitcoin::block::Version; use bitcoin::consensus::encode; use bitcoin::hashes::hex::FromHex; use bitcoin::hashes::sha256; -use bitcoin::{Address, Amount, PrivateKey, PublicKey, SignedAmount, Transaction, ScriptBuf, Script, bip158, bip32, Network}; +use bitcoin::{ + bip158, bip32, Address, Amount, Network, PrivateKey, PublicKey, Script, ScriptBuf, + SignedAmount, Transaction, +}; use serde::de::Error as SerdeError; use serde::{Deserialize, Serialize}; use std::fmt; @@ -51,7 +53,7 @@ pub mod serde_hex { pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { let hex_str: String = ::serde::Deserialize::deserialize(d)?; - Ok(FromHex::from_hex(&hex_str).map_err(D::Error::custom)?) + FromHex::from_hex(&hex_str).map_err(D::Error::custom) } pub mod opt { @@ -643,7 +645,7 @@ impl GetRawTransactionResult { } pub fn transaction(&self) -> Result { - Ok(encode::deserialize(&self.hex)?) + encode::deserialize(&self.hex) } } @@ -712,7 +714,7 @@ pub struct GetTransactionResult { impl GetTransactionResult { pub fn transaction(&self) -> Result { - Ok(encode::deserialize(&self.hex)?) + encode::deserialize(&self.hex) } } @@ -825,7 +827,7 @@ pub struct SignRawTransactionResult { impl SignRawTransactionResult { pub fn transaction(&self) -> Result { - Ok(encode::deserialize(&self.hex)?) + encode::deserialize(&self.hex) } } @@ -1150,7 +1152,7 @@ impl<'a> serde::Serialize for ImportMultiRequestScriptPubkey<'a> { S: serde::Serializer, { match *self { - ImportMultiRequestScriptPubkey::Address(ref addr) => { + ImportMultiRequestScriptPubkey::Address(addr) => { #[derive(Serialize)] struct Tmp<'a> { pub address: &'a Address, @@ -1877,10 +1879,7 @@ pub struct FundRawTransactionOptions { pub include_watching: Option, #[serde(skip_serializing_if = "Option::is_none")] pub lock_unspents: Option, - #[serde( - with = "bitcoin::amount::serde::as_btc::opt", - skip_serializing_if = "Option::is_none" - )] + #[serde(with = "bitcoin::amount::serde::as_btc::opt", skip_serializing_if = "Option::is_none")] pub fee_rate: Option, #[serde(skip_serializing_if = "Option::is_none")] pub subtract_fee_from_outputs: Option>, @@ -2172,7 +2171,7 @@ where /// deserialize_bip70_network deserializes a Bitcoin Core network according to BIP70 /// The accepted input variants are: {"main", "test", "signet", "regtest"} -fn deserialize_bip70_network<'de, D>(deserializer: D) -> Result +fn deserialize_bip70_network<'de, D>(deserializer: D) -> Result where D: serde::Deserializer<'de>, { @@ -2181,8 +2180,12 @@ where type Value = Network; fn visit_str(self, s: &str) -> Result { - Network::from_core_arg(s) - .map_err(|_| E::invalid_value(serde::de::Unexpected::Str(s), &"bitcoin network encoded as a string")) + Network::from_core_arg(s).map_err(|_| { + E::invalid_value( + serde::de::Unexpected::Str(s), + &"bitcoin network encoded as a string", + ) + }) } fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {