nightly clippy 0.1.68 (d0dc9ef 2022-12-18)

ci/env

@@ -1,3 +1,3 @@
 #!/bin/sh
 
-export RUSTC_VERSION=nightly-2022-09-01
+export RUSTC_VERSION=nightly-2022-12-18

node/rpc/src/task.rs

@@ -57,7 +57,7 @@ where
 			JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
 				ErrorCode::InvalidParams.code(),
 				"Not a valid hex-string or SS58 address.",
-				Some(format!("{:?}", e)),
+				Some(format!("{e:?}")),
 			)))
 		})?;
 

node/src/benchmarking.rs

@@ -175,6 +175,6 @@ pub fn inherent_benchmark_data() -> Result<InherentData> {
 
 	timestamp
 		.provide_inherent_data(&mut inherent_data)
-		.map_err(|e| format!("creating inherent data: {:?}", e))?;
+		.map_err(|e| format!("creating inherent data: {e:?}"))?;
 	Ok(inherent_data)
 }

node/src/chain_spec.rs

@@ -17,7 +17,7 @@ pub type ChainSpec = sc_service::GenericChainSpec<GenesisConfig>;
 
 /// Generate a crypto pair from seed.
 pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
-	TPublic::Pair::from_string(&format!("//{}", seed), None)
+	TPublic::Pair::from_string(&format!("//{seed}"), None)
 		.expect("static values are valid; qed")
 		.public()
 }

node/src/cli.rs

@@ -12,7 +12,7 @@ fn parse_rpc_pair(input: &str) -> Result<(String, String), String> {
 			Ok(s.trim_matches('\'').into())
 		} else if s.starts_with('\"') && s.ends_with('\"') {
 			Ok(s.trim_matches('\"').into())
-		} else if !s.starts_with(&['\'', '\"']) {
+		} else if !s.starts_with(['\'', '\"']) {
 			Ok(s.into())
 		} else {
 			Err(String::from("invalid quotes in rpc mapping"))

node/src/service.rs

@@ -167,8 +167,8 @@ pub fn decode_mining_key(
 	if let Some(key) = mining_key {
 		// raw public key
 		if let Some(key_without_prefix) = key.strip_prefix("0x") {
-			let key_bytes = hex::decode(&key_without_prefix)
-				.map_err(|e| format!("Invalid mining key, expected hex: {}", e))?;
+			let key_bytes = hex::decode(key_without_prefix)
+				.map_err(|e| format!("Invalid mining key, expected hex: {e}"))?;
 			Ok(creditcoin_node_runtime::Signer::from(
 				sp_core::ecdsa::Public::from_full(&key_bytes)
 					.map_err(|_| String::from("Invalid mining key, expected 33 bytes"))?,
@@ -181,7 +181,7 @@ pub fn decode_mining_key(
 				Err(err) => match creditcoin_node_runtime::AccountId::from_ss58check(key) {
 					Ok(account_id) => Ok(account_id),
 					Err(e) => {
-						let msg = format!("Invalid mining key, failed to interpret it as an ECDSA public key (error: {}) and as an account ID (error: {})", err, e);
+						let msg = format!("Invalid mining key, failed to interpret it as an ECDSA public key (error: {err}) and as an account ID (error: {e})");
 						log::error!("{}", msg);
 						Err(msg)
 					},
@@ -215,8 +215,7 @@ pub fn new_full(config: Configuration, cli: Cli) -> Result<TaskManager, ServiceE
 			Ok(k) => keystore_container.set_remote_keystore(k),
 			Err(e) => {
 				return Err(ServiceError::Other(format!(
-					"Error hooking up remote keystore for {}: {}",
-					url, e
+					"Error hooking up remote keystore for {url}: {e}"
 				)))
 			},
 		};
@@ -370,7 +369,7 @@ pub fn new_full(config: Configuration, cli: Cli) -> Result<TaskManager, ServiceE
 									Ok(None) => {
 										count += 1;
 									},
-									Err(e) => eprintln!("Mining error: {}", e),
+									Err(e) => eprintln!("Mining error: {e}"),
 								}
 								if count >= 1_000_000 {
 									mining_metrics.add(count);

pallets/creditcoin/src/benchmarking.rs

@@ -86,12 +86,12 @@ benchmarks! {
 
 		for i in 0..c {
 			let collector: T::AccountId = lender_account::<T>(true);
-			let evm_address = format!("{:03x}",i).as_bytes() .into_bounded();
+			let evm_address = format!("{i:03x}").as_bytes() .into_bounded();
 			let address_id = AddressId::new::<T>(&CHAIN, &evm_address);
 			let entry = Address { blockchain: CHAIN, value: evm_address.clone(), owner: collector.clone() };
 			<Addresses<T>>::insert(address_id, entry);
 
-			let tx_id = format!("{:03x}",i) .as_bytes() .into_bounded();
+			let tx_id = format!("{i:03x}") .as_bytes() .into_bounded();
 			let collected_coins_id = CollectedCoinsId::new::<T>(&CHAIN, &tx_id);
 
 			let pending = types::UnverifiedCollectedCoins { to: evm_address.clone(), tx_id: tx_id.clone() , contract: Default::default()};
@@ -300,7 +300,7 @@ benchmarks! {
 		<Timestamp<T>>::set_timestamp(1u32.into());
 		let collector: T::AccountId = lender_account::<T>(true);
 		let collector_addr_id = register_eth_addr::<T>(&collector, "collector");
-		let address = Creditcoin::<T>::addresses(&collector_addr_id).unwrap();
+		let address = Creditcoin::<T>::addresses(collector_addr_id).unwrap();
 		let tx_id = "40be73b6ea10ef3da3ab33a2d5184c8126c5b64b21ae1e083ee005f18e3f5fab"
 			.as_bytes()
 			.into_bounded();
@@ -427,13 +427,13 @@ fn generate_transfer<T: Config>(
 ) -> (TransferId<T::Hash>, Transfer<T::AccountId, T::BlockNumber, T::Hash, T::Moment>) {
 	let (raw_tx, gain, who) = if swap_sender {
 		(
-			format!("0xcb13b65dd4d9d7f3cb8fcddeb442dfdf767403f8a9e5fe8587859225f8a620{:02x}", seed),
+			format!("0xcb13b65dd4d9d7f3cb8fcddeb442dfdf767403f8a9e5fe8587859225f8a620{seed:02x}"),
 			1u64,
 			borrower_account::<T>(true),
 		)
 	} else {
 		(
-			format!("0xcb13b65dd4d9d7f3cb8fcddeb442dfdf767403f8a9e5fe8587859225f8a621{:02x}", seed),
+			format!("0xcb13b65dd4d9d7f3cb8fcddeb442dfdf767403f8a9e5fe8587859225f8a621{seed:02x}"),
 			0u64,
 			lender_account::<T>(true),
 		)
@@ -649,7 +649,7 @@ fn generate_offer<T: Config>(
 
 fn register_eth_addr<T: Config>(who: &T::AccountId, seed: &str) -> AddressId<<T>::Hash> {
 	let ktypeid = KeyTypeId(*b"dumy");
-	let pkey = ecdsa_generate(ktypeid, Some(format!("//{}", seed).as_bytes().to_vec()));
+	let pkey = ecdsa_generate(ktypeid, Some(format!("//{seed}").as_bytes().to_vec()));
 	let address = EVMAddress::from_public(&pkey);
 	let address_id = crate::AddressId::new::<T>(&Blockchain::ETHEREUM, &address);
 
@@ -670,9 +670,9 @@ fn generate_ask<T: Config>(
 	call: bool,
 	seed: u8,
 ) -> Result<(AddressId<<T>::Hash>, AskOrderId<T::BlockNumber, T::Hash>, Vec<u8>), crate::Error<T>> {
-	let secretkey = &format!("lender{:02x}", seed)[..];
+	let secretkey = &format!("lender{seed:02x}")[..];
 	let address_id = register_eth_addr::<T>(who, secretkey);
-	let guid = format!("ask_guid{:02x}", seed);
+	let guid = format!("ask_guid{seed:02x}");
 	let guid = guid.as_bytes();
 
 	let ask_order_id = AskOrderId::new::<T>(*expiration_block, guid);
@@ -698,9 +698,9 @@ fn generate_bid<T: Config>(
 	call: bool,
 	seed: u8,
 ) -> Result<(AddressId<<T>::Hash>, BidOrderId<T::BlockNumber, T::Hash>, Vec<u8>), crate::Error<T>> {
-	let secretkey = &format!("borrower{:02x}", seed)[..];
+	let secretkey = &format!("borrower{seed:02x}")[..];
 	let address_id = register_eth_addr::<T>(who, secretkey);
-	let guid = format!("bid_guid{:02x}", seed);
+	let guid = format!("bid_guid{seed:02x}");
 	let guid = guid.as_bytes();
 
 	let bid_order_id = BidOrderId::new::<T>(*expiration_block, guid);
@@ -721,12 +721,12 @@ fn generate_bid<T: Config>(
 }
 
 fn fake_address_id<T: Config>(seed: u32) -> AddressId<T::Hash> {
-	let address = format!("somefakeaddress{}", seed);
+	let address = format!("somefakeaddress{seed}");
 	crate::AddressId::new::<T>(&Blockchain::ETHEREUM, address.as_bytes())
 }
 
 fn insert_fake_address<T: Config>(owner: T::AccountId, seed: u32) -> AddressId<T::Hash> {
-	let addr = format!("somefakeaddress{}", seed);
+	let addr = format!("somefakeaddress{seed}");
 	let id = crate::AddressId::new::<T>(&Blockchain::ETHEREUM, addr.as_bytes());
 
 	let address = crate::Address {
@@ -744,7 +744,7 @@ fn fake_ask_id<T: Config>(
 	seed: u32,
 	expiration_block: BlockNumberFor<T>,
 ) -> AskOrderId<T::BlockNumber, T::Hash> {
-	let guid = format!("somefakeaskguid{}", seed);
+	let guid = format!("somefakeaskguid{seed}");
 	crate::AskOrderId::new::<T>(expiration_block, guid.as_bytes())
 }
 
@@ -772,7 +772,7 @@ fn fake_bid_id<T: Config>(
 	seed: u32,
 	expiration_block: BlockNumberFor<T>,
 ) -> BidOrderId<T::BlockNumber, T::Hash> {
-	let guid = format!("somefakebidguid{}", seed);
+	let guid = format!("somefakebidguid{seed}");
 	crate::BidOrderId::new::<T>(expiration_block, guid.as_bytes())
 }
 
@@ -832,7 +832,7 @@ fn fake_deal_id<T: Config>(
 }
 
 fn fake_transfer_id<T: Config>(seed: u32) -> TransferId<T::Hash> {
-	let tx_id = format!("somefaketransfertxid{}", seed);
+	let tx_id = format!("somefaketransfertxid{seed}");
 	crate::TransferId::new::<T>(&Blockchain::ETHEREUM, tx_id.as_bytes())
 }
 
@@ -872,8 +872,8 @@ fn insert_fake_unverified_transfer<T: Config>(
 	deadline: BlockNumberFor<T>,
 	seed: u32,
 ) {
-	let from_external = format!("somefakefromext{}", seed).as_bytes().into_bounded();
-	let to_external = format!("somefaketoext{}", seed).as_bytes().into_bounded();
+	let from_external = format!("somefakefromext{seed}").as_bytes().into_bounded();
+	let to_external = format!("somefaketoext{seed}").as_bytes().into_bounded();
 	let transfer_id = fake_transfer_id::<T>(seed);
 	let transfer = crate::UnverifiedTransfer {
 		deadline,
@@ -896,7 +896,7 @@ fn insert_fake_unverified_transfer<T: Config>(
 					&fake_bid_id::<T>(seed, deadline),
 				),
 			),
-			tx_id: format!("{:03x}", seed).as_bytes().into_bounded(),
+			tx_id: format!("{seed:03x}").as_bytes().into_bounded(),
 			timestamp: None,
 		},
 		currency_to_check: crate::CurrencyOrLegacyTransferKind::TransferKind(

pallets/creditcoin/src/helpers.rs

@@ -54,7 +54,7 @@ impl<T: Config> Pallet<T> {
 		<pallet_timestamp::Pallet<T>>::get()
 	}
 	pub fn get_address(address_id: &AddressId<T::Hash>) -> Result<Address<T::AccountId>, Error<T>> {
-		Self::addresses(&address_id).ok_or(Error::<T>::NonExistentAddress)
+		Self::addresses(address_id).ok_or(Error::<T>::NonExistentAddress)
 	}
 
 	pub fn authority_id() -> Option<T::AccountId> {

pallets/creditcoin/src/helpers/register_transfer.rs

@@ -33,7 +33,7 @@ impl<T: Config> Pallet<T> {
 		let transfer_id = TransferId::new::<T>(&from.blockchain, &blockchain_tx_id);
 		ensure!(!Transfers::<T>::contains_key(&transfer_id), Error::<T>::TransferAlreadyRegistered);
 
-		let currency = Currencies::<T>::get(&currency).ok_or(Error::<T>::CurrencyNotRegistered)?;
+		let currency = Currencies::<T>::get(currency).ok_or(Error::<T>::CurrencyNotRegistered)?;
 
 		ensure!(currency.supports(&transfer_kind), Error::<T>::UnsupportedTransferKind);
 
@@ -64,7 +64,7 @@ impl<T: Config> Pallet<T> {
 		};
 		let task_id = TaskId::from(transfer_id.clone());
 		let pending = Task::from(pending);
-		PendingTasks::<T>::insert(&deadline, &task_id, &pending);
+		PendingTasks::<T>::insert(deadline, task_id, &pending);
 
 		Ok((transfer_id, transfer))
 	}
@@ -97,7 +97,7 @@ impl<T: Config> Pallet<T> {
 
 		DealOrders::<T>::mutate(
 			deal_order_id.expiration(),
-			&deal_order_id.hash(),
+			deal_order_id.hash(),
 			|deal_order| -> Result<(), crate::Error<T>> {
 				let mut deal_order = deal_order.as_mut().ok_or(Error::<T>::NonExistentDealOrder)?;
 				let currency = match &from.blockchain {
@@ -155,7 +155,7 @@ impl<T: Config> Pallet<T> {
 		};
 		let task_id = TaskId::from(transfer_id.clone());
 		let pending = Task::from(pending);
-		PendingTasks::<T>::insert(&deadline, &task_id, &pending);
+		PendingTasks::<T>::insert(deadline, task_id, &pending);
 
 		Ok((transfer_id, transfer))
 	}

pallets/creditcoin/src/lib.rs

@@ -1213,12 +1213,12 @@ pub mod pallet {
 			let deadline = Self::block_number().saturating_add(T::UnverifiedTaskTimeout::get());
 
 			ensure!(
-				!PendingTasks::<T>::contains_key(deadline, &TaskId::from(collect_coins_id.clone())),
+				!PendingTasks::<T>::contains_key(deadline, TaskId::from(collect_coins_id.clone())),
 				Error::<T>::CollectCoinsAlreadyRegistered
 			);
 
 			let address_id = AddressId::new::<T>(contract_chain, &evm_address);
-			let address = Self::addresses(&address_id).ok_or(Error::<T>::NonExistentAddress)?;
+			let address = Self::addresses(address_id).ok_or(Error::<T>::NonExistentAddress)?;
 			ensure!(address.owner == who, Error::<T>::NotAddressOwner);
 
 			let pending = types::UnverifiedCollectedCoins { to: evm_address, tx_id, contract };
@@ -1354,8 +1354,8 @@ pub mod pallet {
 			let who = ensure_signed(origin)?;
 
 			DealOrders::<T>::try_mutate(
-				&deal_order_id.expiration(),
-				&deal_order_id.hash(),
+				deal_order_id.expiration(),
+				deal_order_id.hash(),
 				|value| -> DispatchResult {
 					let deal_order =
 						value.as_mut().ok_or(crate::Error::<T>::NonExistentDealOrder)?;
@@ -1444,7 +1444,7 @@ pub mod pallet {
 				},
 			};
 
-			PendingTasks::<T>::remove(&deadline, &task_id);
+			PendingTasks::<T>::remove(deadline, task_id);
 
 			Self::deposit_event(event);
 
@@ -1468,20 +1468,20 @@ pub mod pallet {
 			let event = match &task_id {
 				TaskId::VerifyTransfer(transfer_id) => {
 					ensure!(
-						!Transfers::<T>::contains_key(&transfer_id),
+						!Transfers::<T>::contains_key(transfer_id),
 						Error::<T>::TransferAlreadyRegistered
 					);
 					Event::<T>::TransferFailedVerification(transfer_id.clone(), cause)
 				},
 				TaskId::CollectCoins(collected_coins_id) => {
 					ensure!(
-						!CollectedCoins::<T>::contains_key(&collected_coins_id),
+						!CollectedCoins::<T>::contains_key(collected_coins_id),
 						Error::<T>::CollectCoinsAlreadyRegistered
 					);
 					Event::<T>::CollectCoinsFailedVerification(collected_coins_id.clone(), cause)
 				},
 			};
-			PendingTasks::<T>::remove(&deadline, &task_id);
+			PendingTasks::<T>::remove(deadline, &task_id);
 			Self::deposit_event(event);
 
 			Ok(PostDispatchInfo { actual_weight: None, pays_fee: Pays::No })

pallets/creditcoin/src/mock.rs

@@ -422,7 +422,7 @@ fn get_mock_contract_input<T>(index: usize, convert: impl FnOnce(ethabi::Token)
 		.as_str()
 		.unwrap()
 		.to_string();
-	let input_bytes = hex::decode(&input.trim_start_matches("0x")).unwrap();
+	let input_bytes = hex::decode(input.trim_start_matches("0x")).unwrap();
 	let inputs = abi.decode_input(&input_bytes[4..]).unwrap();
 	convert(inputs[index].clone()).unwrap()
 }

pallets/creditcoin/src/ocw/rpc.rs

@@ -127,7 +127,7 @@ impl<'a> Visitor<'a> for BytesVisitor {
 	{
 		if value.len() >= 2 && &value[0..2] == "0x" {
 			let bytes = hex::decode(&value[2..])
-				.map_err(|e| Error::custom(alloc::format!("Invalid hex: {}", e)))?;
+				.map_err(|e| Error::custom(alloc::format!("Invalid hex: {e}")))?;
 			Ok(Bytes(bytes))
 		} else {
 			Err(Error::invalid_value(Unexpected::Str(value), &"0x prefix"))
@@ -322,7 +322,7 @@ fn to_json_hex(bytes: &[u8]) -> String {
 }
 
 fn format_as_hex<T: sp_std::fmt::LowerHex>(value: T) -> String {
-	alloc::format!("0x{:x}", value)
+	alloc::format!("0x{value:x}")
 }
 
 pub fn eth_get_transaction(

pallets/creditcoin/src/ocw/tasks/collect_coins.rs

@@ -98,7 +98,7 @@ pub fn validate_collect_coins(
 		if selector != transfer_fn.short_signature() {
 			log::error!(
 				"function selector mismatch, expected: {}, got: {}",
-				hex::encode(&transfer_fn.short_signature()),
+				hex::encode(transfer_fn.short_signature()),
 				hex::encode(selector)
 			);
 			return Err(VerificationFailureCause::AbiMismatch.into());
@@ -244,7 +244,7 @@ pub(crate) mod tests {
 	fn prepare_rpc_mocks() -> MockedRpcRequests {
 		let dummy_url = "dummy";
 		let contract_chain = Creditcoin::<Test>::collect_coins_contract();
-		set_rpc_uri(&contract_chain.chain, &dummy_url);
+		set_rpc_uri(&contract_chain.chain, dummy_url);
 
 		MockedRpcRequests::new(dummy_url, &TX_HASH, &BLOCK_NUMBER_STR, &RESPONSES)
 	}

pallets/creditcoin/src/ocw/tests.rs

@@ -331,7 +331,7 @@ fn blockchain_rpc_url_missing() {
 #[test]
 fn blockchain_rpc_url_non_utf8() {
 	ExtBuilder::default().build_offchain_and_execute(|| {
-		set_rpc_uri(&Blockchain::ETHEREUM, &[0x80]);
+		set_rpc_uri(&Blockchain::ETHEREUM, [0x80]);
 
 		assert_matches!(Blockchain::ETHEREUM.rpc_url().unwrap_err(), RpcUrlError::InvalidUrl(_));
 	});
@@ -891,7 +891,7 @@ fn ocw_retries() {
 		let tx_block_num_value =
 			u64::from_str_radix(tx_block_num.trim_start_matches("0x"), 16).unwrap();
 
-		set_rpc_uri(&Blockchain::RINKEBY, &dummy_url);
+		set_rpc_uri(&Blockchain::RINKEBY, dummy_url);
 
 		let loan_amount = get_mock_amount();
 		let terms = LoanTerms { amount: loan_amount, ..Default::default() };
@@ -976,7 +976,7 @@ fn duplicate_retry_fail_and_succeed() {
 		MockedRpcRequests::new(dummy_url, &tx_hash, &tx_block_num, &ETHLESS_RESPONSES)
 			.mock_all(&mut state.write());
 
-		set_rpc_uri(&Blockchain::RINKEBY, &dummy_url);
+		set_rpc_uri(&Blockchain::RINKEBY, dummy_url);
 
 		let loan_amount = get_mock_amount();
 		let currency = crate::tests::ethless_currency(contract.clone());