Fix clippy lint issues

common-api/src/crypto/mod.rs

     fn split_encoded() {
         let bs58_str = bs58::encode(vec![0, 0, 0]).into_string();
         assert!(matches!(
-                split_encoded_str(&format!("ed25519:{}", bs58_str)),
+                split_encoded_str(&format!("ed25519:{bs58_str}")),
                 Ok((key_type, s)) if key_type == ED25519 && s == bs58_str));
         assert!(matches!(
-                split_encoded_str(&format!("x25519:{}", bs58_str)),
+                split_encoded_str(&format!("x25519:{bs58_str}")),
                 Ok((key_type, s)) if key_type == X25519 && s == bs58_str));
         assert!(matches!(
             split_encoded_str(&bs58_str),

near-primitives-light/src/errors.rs

 impl Display for TxExecutionError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
         match self {
-            TxExecutionError::ActionError(e) => write!(f, "{}", e),
-            TxExecutionError::InvalidTxError(e) => write!(f, "{}", e),
+            TxExecutionError::ActionError(e) => write!(f, "{e}"),
+            TxExecutionError::InvalidTxError(e) => write!(f, "{e}"),
         }
     }
 }
 
 impl std::fmt::Display for RuntimeError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        f.write_str(&format!("{:?}", self))
+        f.write_str(&format!("{self:?}"))
     }
 }
 
 
 impl std::fmt::Display for StorageError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        f.write_str(&format!("{:?}", self))
+        f.write_str(&format!("{self:?}"))
     }
 }
 
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
         match self {
             ReceiptValidationError::InvalidPredecessorId { account_id } => {
-                write!(f, "The predecessor_id `{}` of a Receipt is not valid.", account_id)
+                write!(f, "The predecessor_id `{account_id}` of a Receipt is not valid.")
             }
             ReceiptValidationError::InvalidReceiverId { account_id } => {
-                write!(f, "The receiver_id `{}` of a Receipt is not valid.", account_id)
+                write!(f, "The receiver_id `{account_id}` of a Receipt is not valid.")
             }
             ReceiptValidationError::InvalidSignerId { account_id } => {
-                write!(f, "The signer_id `{}` of an ActionReceipt is not valid.", account_id)
+                write!(f, "The signer_id `{account_id}` of an ActionReceipt is not valid.")
             }
             ReceiptValidationError::InvalidDataReceiverId { account_id } => write!(
                 f,
-                "The receiver_id `{}` of a DataReceiver within an ActionReceipt is not valid.",
-                account_id
+                "The receiver_id `{account_id}` of a DataReceiver within an ActionReceipt is not valid."
             ),
             ReceiptValidationError::ReturnedValueLengthExceeded { length, limit } => write!(
                 f,
-                "The length of the returned data {} exceeded the limit {} in a DataReceipt",
-                length, limit
+                "The length of the returned data {length} exceeded the limit {limit} in a DataReceipt"
             ),
             ReceiptValidationError::NumberInputDataDependenciesExceeded { number_of_input_data_dependencies, limit } => write!(
                 f,
-                "The number of input data dependencies {} exceeded the limit {} in an ActionReceipt",
-                number_of_input_data_dependencies, limit
+                "The number of input data dependencies {number_of_input_data_dependencies} exceeded the limit {limit} in an ActionReceipt"
             ),
-            ReceiptValidationError::ActionsValidation(e) => write!(f, "{}", e),
+            ReceiptValidationError::ActionsValidation(e) => write!(f, "{e}"),
         }
     }
 }
                 write!(f, "The delete action must be the last action in transaction")
             }
             ActionsValidationError::TotalPrepaidGasExceeded { total_prepaid_gas, limit } => {
-                write!(f, "The total prepaid gas {} exceeds the limit {}", total_prepaid_gas, limit)
+                write!(f, "The total prepaid gas {total_prepaid_gas} exceeds the limit {limit}")
             }
             ActionsValidationError::TotalNumberOfActionsExceeded {total_number_of_actions, limit } => {
                 write!(
                     f,
-                    "The total number of actions {} exceeds the limit {}",
-                    total_number_of_actions, limit
+                    "The total number of actions {total_number_of_actions} exceeds the limit {limit}"
                 )
             }
             ActionsValidationError::AddKeyMethodNamesNumberOfBytesExceeded { total_number_of_bytes, limit } => write!(
                 f,
-                "The total number of bytes in allowed method names {} exceeds the maximum allowed number {} in a AddKey action",
-                total_number_of_bytes, limit
+                "The total number of bytes in allowed method names {total_number_of_bytes} exceeds the maximum allowed number {limit} in a AddKey action"
             ),
             ActionsValidationError::AddKeyMethodNameLengthExceeded { length, limit } => write!(
                 f,
-                "The length of some method name {} exceeds the maximum allowed length {} in a AddKey action",
-                length, limit
+                "The length of some method name {length} exceeds the maximum allowed length {limit} in a AddKey action"
             ),
             ActionsValidationError::IntegerOverflow => write!(
                 f,
             ),
             ActionsValidationError::InvalidAccountId { account_id } => write!(
                 f,
-                "Invalid account ID `{}`",
-                account_id
+                "Invalid account ID `{account_id}`"
             ),
             ActionsValidationError::ContractSizeExceeded { size, limit } => write!(
                 f,
-                "The length of the contract size {} exceeds the maximum allowed size {} in a DeployContract action",
-                size, limit
+                "The length of the contract size {size} exceeds the maximum allowed size {limit} in a DeployContract action"
             ),
             ActionsValidationError::FunctionCallMethodNameLengthExceeded { length, limit } => write!(
                 f,
-                "The length of the method name {} exceeds the maximum allowed length {} in a FunctionCall action",
-                length, limit
+                "The length of the method name {length} exceeds the maximum allowed length {limit} in a FunctionCall action"
             ),
             ActionsValidationError::FunctionCallArgumentsLengthExceeded { length, limit } => write!(
                 f,
-                "The length of the arguments {} exceeds the maximum allowed length {} in a FunctionCall action",
-                length, limit
+                "The length of the arguments {length} exceeds the maximum allowed length {limit} in a FunctionCall action"
             ),
             ActionsValidationError::UnsuitableStakingKey { public_key } => write!(
                 f,
-                "The staking key must be ristretto compatible ED25519 key. {} is provided instead.",
-                public_key,
+                "The staking key must be ristretto compatible ED25519 key. {public_key} is provided instead."
             ),
             ActionsValidationError::FunctionCallZeroAttachedGas => write!(
                 f,
             InvalidTxError::InvalidSignerId { signer_id } => {
                 write!(
                     f,
-                    "Invalid signer account ID {:?} according to requirements",
-                    signer_id
+                    "Invalid signer account ID {signer_id:?} according to requirements"
                 )
             }
             InvalidTxError::SignerDoesNotExist { signer_id } => {
-                write!(f, "Signer {:?} does not exist", signer_id)
+                write!(f, "Signer {signer_id:?} does not exist")
             }
             InvalidTxError::InvalidAccessKeyError(access_key_error) => {
                 Display::fmt(&access_key_error, f)
             }
             InvalidTxError::InvalidNonce { tx_nonce, ak_nonce } => write!(
                 f,
-                "Transaction nonce {} must be larger than nonce of the used access key {}",
-                tx_nonce, ak_nonce
+                "Transaction nonce {tx_nonce} must be larger than nonce of the used access key {ak_nonce}"
             ),
             InvalidTxError::InvalidReceiverId { receiver_id } => {
                 write!(
                     f,
-                    "Invalid receiver account ID {:?} according to requirements",
-                    receiver_id
+                    "Invalid receiver account ID {receiver_id:?} according to requirements"
                 )
             }
             InvalidTxError::InvalidSignature => {
                 cost,
             } => write!(
                 f,
-                "Sender {:?} does not have enough balance {} for operation costing {}",
-                signer_id, balance, cost
+                "Sender {signer_id:?} does not have enough balance {balance} for operation costing {cost}"
             ),
             InvalidTxError::LackBalanceForState { signer_id, amount } => {
-                write!(f, "Failed to execute, because the account {:?} wouldn't have enough balance to cover storage, required to have {} yoctoNEAR more", signer_id, amount)
+                write!(f, "Failed to execute, because the account {signer_id:?} wouldn't have enough balance to cover storage, required to have {amount} yoctoNEAR more")
             }
             InvalidTxError::CostOverflow => {
                 write!(f, "Transaction gas or balance cost is too high")
                 write!(f, "Transaction has expired")
             }
             InvalidTxError::ActionsValidation(error) => {
-                write!(f, "Transaction actions validation error: {}", error)
+                write!(f, "Transaction actions validation error: {error}")
             }
             InvalidTxError::NonceTooLarge {
                 tx_nonce,
             } => {
                 write!(
                     f,
-                    "Transaction nonce {} must be smaller than the access key nonce upper bound {}",
-                    tx_nonce, upper_bound
+                    "Transaction nonce {tx_nonce} must be smaller than the access key nonce upper bound {upper_bound}"
                 )
             }
             InvalidTxError::TransactionSizeExceeded { size, limit } => {
                 write!(
                     f,
-                    "Size of serialized transaction {} exceeded the limit {}",
-                    size, limit
+                    "Size of serialized transaction {size} exceeded the limit {limit}"
                 )
             }
         }
                 public_key,
             } => write!(
                 f,
-                "Signer {:?} doesn't have access key with the given public_key {}",
-                account_id, public_key
+                "Signer {account_id:?} doesn't have access key with the given public_key {public_key}"
             ),
             InvalidAccessKeyError::ReceiverMismatch {
                 tx_receiver,
                 ak_receiver,
             } => write!(
                 f,
-                "Transaction receiver_id {:?} doesn't match the access key receiver_id {:?}",
-                tx_receiver, ak_receiver
+                "Transaction receiver_id {tx_receiver:?} doesn't match the access key receiver_id {ak_receiver:?}",
             ),
             InvalidAccessKeyError::MethodNameMismatch { method_name } => write!(
                 f,
-                "Transaction method name {:?} isn't allowed by the access key",
-                method_name
+                "Transaction method name {method_name:?} isn't allowed by the access key"
             ),
             InvalidAccessKeyError::RequiresFullAccess => {
                 write!(f, "Invalid access key type. Full-access keys are required for transactions that have multiple or non-function-call actions")
                 cost,
             } => write!(
                 f,
-                "Access Key {:?}:{} does not have enough balance {} for transaction costing {}",
-                account_id, public_key, allowance, cost
+                "Access Key {account_id:?}:{public_key} does not have enough balance {allowance} for transaction costing {cost}"
             ),
             InvalidAccessKeyError::DepositWithFunctionCall => {
                 write!(f, "Having a deposit with a function call action is not allowed with a function call access key.")
 
 impl std::fmt::Display for IntegerOverflowError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        f.write_str(&format!("{:?}", self))
+        f.write_str(&format!("{self:?}"))
     }
 }
 
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
         match self {
             ActionErrorKind::AccountAlreadyExists { account_id } => {
-                write!(f, "Can't create a new account {:?}, because it already exists", account_id)
+                write!(f, "Can't create a new account {account_id:?}, because it already exists")
             }
             ActionErrorKind::AccountDoesNotExist { account_id } => write!(
                 f,
-                "Can't complete the action because account {:?} doesn't exist",
-                account_id
+                "Can't complete the action because account {account_id:?} doesn't exist"
             ),
             ActionErrorKind::ActorNoPermission { actor_id, account_id } => write!(
                 f,
-                "Actor {:?} doesn't have permission to account {:?} to complete the action",
-                actor_id, account_id
+                "Actor {actor_id:?} doesn't have permission to account {account_id:?} to complete the action"
             ),
             ActionErrorKind::LackBalanceForState { account_id, amount } => write!(
                 f,
-                "The account {} wouldn't have enough balance to cover storage, required to have {} yoctoNEAR more",
-                account_id, amount
+                "The account {account_id} wouldn't have enough balance to cover storage, required to have {amount} yoctoNEAR more"
             ),
             ActionErrorKind::TriesToUnstake { account_id } => {
-                write!(f, "Account {:?} is not yet staked, but tries to unstake", account_id)
+                write!(f, "Account {account_id:?} is not yet staked, but tries to unstake")
             }
             ActionErrorKind::TriesToStake { account_id, stake, locked, balance } => write!(
                 f,
-                "Account {:?} tries to stake {}, but has staked {} and only has {}",
-                account_id, stake, locked, balance
+                "Account {account_id:?} tries to stake {stake}, but has staked {locked} and only has {balance}"
             ),
             ActionErrorKind::CreateAccountOnlyByRegistrar { account_id, registrar_account_id, predecessor_id } => write!(
                 f,
-                "A top-level account ID {:?} can't be created by {:?}, short top-level account IDs can only be created by {:?}",
-                account_id, predecessor_id, registrar_account_id,
+                "A top-level account ID {account_id:?} can't be created by {predecessor_id:?}, short top-level account IDs can only be created by {registrar_account_id:?}"
             ),
             ActionErrorKind::CreateAccountNotAllowed { account_id, predecessor_id } => write!(
                 f,
-                "A sub-account ID {:?} can't be created by account {:?}",
-                account_id, predecessor_id,
+                "A sub-account ID {account_id:?} can't be created by account {predecessor_id:?}"
             ),
             ActionErrorKind::DeleteKeyDoesNotExist { account_id, .. } => write!(
                 f,
-                "Account {:?} tries to remove an access key that doesn't exist",
-                account_id
+                "Account {account_id:?} tries to remove an access key that doesn't exist"
             ),
             ActionErrorKind::AddKeyAlreadyExists { public_key, .. } => write!(
                 f,
-                "The public key {:?} is already used for an existing access key",
-                public_key
+                "The public key {public_key:?} is already used for an existing access key"
             ),
             ActionErrorKind::DeleteAccountStaking { account_id } => {
-                write!(f, "Account {:?} is staking and can not be deleted", account_id)
+                write!(f, "Account {account_id:?} is staking and can not be deleted")
             }
-            ActionErrorKind::FunctionCallError(s) => write!(f, "{:?}", s),
+            ActionErrorKind::FunctionCallError(s) => write!(f, "{s:?}"),
             ActionErrorKind::NewReceiptValidationError(e) => {
-                write!(f, "An new action receipt created during a FunctionCall is not valid: {}", e)
+                write!(f, "An new action receipt created during a FunctionCall is not valid: {e}")
             }
-            ActionErrorKind::InsufficientStake { account_id, stake, minimum_stake } => write!(f, "Account {} tries to stake {} but minimum required stake is {}", account_id, stake, minimum_stake),
-            ActionErrorKind::OnlyImplicitAccountCreationAllowed { account_id } => write!(f, "CreateAccount action is called on hex-characters account of length 64 {}", account_id),
-            ActionErrorKind::DeleteAccountWithLargeState { account_id } => write!(f, "The state of account {} is too large and therefore cannot be deleted", account_id),
+            ActionErrorKind::InsufficientStake { account_id, stake, minimum_stake } => write!(f, "Account {account_id} tries to stake {stake} but minimum required stake is {minimum_stake}"),
+            ActionErrorKind::OnlyImplicitAccountCreationAllowed { account_id } => write!(f, "CreateAccount action is called on hex-characters account of length 64 {account_id}"),
+            ActionErrorKind::DeleteAccountWithLargeState { account_id } => write!(f, "The state of account {account_id} is too large and therefore cannot be deleted"),
         }
     }
 }
                 num_seats,
             } => write!(
                 f,
-                "Total stake {} must be higher than the number of seats {}",
-                stake_sum, num_seats
+                "Total stake {stake_sum} must be higher than the number of seats {num_seats}"
             ),
-            EpochError::MissingBlock(hash) => write!(f, "Missing block {}", hash),
-            EpochError::IOErr(err) => write!(f, "IO: {}", err),
-            EpochError::ShardingError(err) => write!(f, "Sharding Error: {}", err),
+            EpochError::MissingBlock(hash) => write!(f, "Missing block {hash}"),
+            EpochError::IOErr(err) => write!(f, "IO: {err}"),
+            EpochError::ShardingError(err) => write!(f, "Sharding Error: {err}"),
             EpochError::NotEnoughValidators {
                 num_shards,
                 num_validators,
             } => {
-                write!(f, "There were not enough validator proposals to fill all shards. num_proposals: {}, num_shards: {}", num_validators, num_shards)
+                write!(f, "There were not enough validator proposals to fill all shards. num_proposals: {num_validators}, num_shards: {num_shards}")
             }
         }
     }
                 stake_sum,
                 num_seats,
             } => {
-                write!(f, "ThresholdError({}, {})", stake_sum, num_seats)
+                write!(f, "ThresholdError({stake_sum}, {num_seats})")
             }
-            EpochError::MissingBlock(hash) => write!(f, "MissingBlock({})", hash),
-            EpochError::IOErr(err) => write!(f, "IOErr({})", err),
-            EpochError::ShardingError(err) => write!(f, "ShardingError({})", err),
+            EpochError::MissingBlock(hash) => write!(f, "MissingBlock({hash})"),
+            EpochError::IOErr(err) => write!(f, "IOErr({err})"),
+            EpochError::ShardingError(err) => write!(f, "ShardingError({err})"),
             EpochError::NotEnoughValidators {
                 num_shards,
                 num_validators,
             } => {
-                write!(f, "NotEnoughValidators({}, {})", num_validators, num_shards)
+                write!(f, "NotEnoughValidators({num_validators}, {num_shards})")
             }
         }
     }

near-primitives-light/src/transaction.rs

     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             ExecutionStatus::Unknown => f.write_str("Unknown"),
-            ExecutionStatus::Failure(e) => f.write_fmt(format_args!("Failure({})", e)),
+            ExecutionStatus::Failure(e) => f.write_fmt(format_args!("Failure({e})")),
             ExecutionStatus::SuccessValue(v) => {
                 f.write_fmt(format_args!("SuccessValue({})", to_base58(v)))
             }
             ExecutionStatus::SuccessReceiptId(receipt_id) => {
-                f.write_fmt(format_args!("SuccessReceiptId({})", receipt_id))
+                f.write_fmt(format_args!("SuccessReceiptId({receipt_id})"))
             }
         }
     }

near-primitives-light/src/views.rs

         match self {
             FinalExecutionStatus::NotStarted => f.write_str("NotStarted"),
             FinalExecutionStatus::Started => f.write_str("Started"),
-            FinalExecutionStatus::Failure(e) => f.write_fmt(format_args!("Failure({:?})", e)),
+            FinalExecutionStatus::Failure(e) => f.write_fmt(format_args!("Failure({e:?})")),
             FinalExecutionStatus::SuccessValue(v) => {
-                f.write_fmt(format_args!("SuccessValue({:?})", v))
+                f.write_fmt(format_args!("SuccessValue({v:?})"))
             }
         }
     }
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             ExecutionStatusView::Unknown => f.write_str("Unknown"),
-            ExecutionStatusView::Failure(e) => f.write_fmt(format_args!("Failure({:?})", e)),
+            ExecutionStatusView::Failure(e) => f.write_fmt(format_args!("Failure({e:?})")),
             ExecutionStatusView::SuccessValue(v) => {
-                f.write_fmt(format_args!("SuccessValue({:?})", v))
+                f.write_fmt(format_args!("SuccessValue({v:?})"))
             }
             ExecutionStatusView::SuccessReceiptId(receipt_id) => {
-                f.write_fmt(format_args!("SuccessReceiptId({})", receipt_id))
+                f.write_fmt(format_args!("SuccessReceiptId({receipt_id})"))
             }
         }
     }
                         cost: match cost {
                             Cost::ActionCost {
                                 action_cost_kind: action_cost,
-                            } => format!("{:?}", action_cost).to_ascii_uppercase(),
+                            } => format!("{action_cost:?}").to_ascii_uppercase(),
                             Cost::ExtCost {
                                 ext_cost_kind: ext_cost,
-                            } => format!("{:?}", ext_cost).to_ascii_uppercase(),
+                            } => format!("{ext_cost:?}").to_ascii_uppercase(),
                             Cost::WasmInstruction => "WASM_INSTRUCTION".to_string(),
                         },
                         gas_used: profile_data[cost],

near-rpc/src/client.rs

         serde_json::from_slice::<T>(&self.data).map_err(Error::DeserializeTransactionOutput)
     }
 
+    #[allow(clippy::misnamed_getters)]
     /// Returns a transaction id
     pub fn id(&self) -> CryptoHash {
         self.transaction.block_hash

near-rpc/src/rpc/mod.rs

 impl Display for Cause {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(info) = &self.info {
-            return write!(f, "{}", info);
+            return write!(f, "{info}");
         }
 
         Ok(())

near-rpc/tests/rpc.rs

 async fn clone_and_compile_wasm() -> Vec<u8> {
     let tmp_path = temp_dir().into_path();
     let repo_path = format!("{}/near-smartcontracts", tmp_path.to_string_lossy());
-    let target_path = format!("{}/test-contract", repo_path);
+    let target_path = format!("{repo_path}/test-contract");
     let repo_url = "git@github.com:Relayz-io/near-smartcontracts.git";
 
     // Prepare callbacks.