Manually fix uninlined_format_args lint error

The `uninlined_format_args` lint was added in the latest Rust 1.88
nightly.
This commit includes the manual changes required to address it.
Specifically, the ones that `cargo clippy --fix` could not automatically
resolve.

[Clippy lint
reference](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)

Author: arminsabouri

payjoin-cli/src/app/config.rs

@@ -146,8 +146,7 @@ impl Config {
                         Ok(v1) => config.version = Some(VersionConfig::V1(v1)),
                         Err(e) =>
                             return Err(ConfigError::Message(format!(
-                                "Valid V1 configuration is required for BIP78 mode: {}",
-                                e
+                                "Valid V1 configuration is required for BIP78 mode: {e}"
                             ))),
                     }
                 }

payjoin-cli/src/app/v1.rs

@@ -91,8 +91,8 @@ impl AppTrait for App {
         );
         let psbt = ctx.process_response(&mut response.bytes().await?.to_vec().as_slice()).map_err(
             |e| {
-                log::debug!("Error processing response: {:?}", e);
-                anyhow!("Failed to process response {}", e)
+                log::debug!("Error processing response: {e:?}");
+                anyhow!("Failed to process response {e}")
             },
         )?;
 
@@ -165,7 +165,7 @@ impl App {
                 let stream = match tls_acceptor.accept(stream).await {
                     Ok(tls_stream) => tls_stream,
                     Err(e) => {
-                        log::error!("TLS accept error: {}", e);
+                        log::error!("TLS accept error: {e}");
                         return;
                     }
                 };
@@ -211,19 +211,19 @@ impl App {
         self,
         req: Request<Incoming>,
     ) -> Result<Response<BoxBody<Bytes, hyper::Error>>> {
-        log::debug!("Received request: {:?}", req);
+        log::debug!("Received request: {req:?}");
         let mut response = match (req.method(), req.uri().path()) {
             (&Method::GET, "/bip21") => {
                 let query_string = req.uri().query().unwrap_or("");
-                log::debug!("{:?}, {:?}", req.method(), query_string);
+                log::debug!("{:?}, {query_string:?}", req.method());
                 let query_params: HashMap<_, _> =
                     url::form_urlencoded::parse(query_string.as_bytes()).into_owned().collect();
                 let amount = query_params.get("amount").map(|amt| {
                     Amount::from_btc(amt.parse().expect("Failed to parse amount")).unwrap()
                 });
                 self.handle_get_bip21(amount)
                     .map_err(|e| {
-                        log::error!("Error handling request: {}", e);
+                        log::error!("Error handling request: {e}");
                         Response::builder().status(500).body(full(e.to_string())).unwrap()
                     })
                     .unwrap_or_else(|err_resp| err_resp)
@@ -233,11 +233,11 @@ impl App {
                 .await
                 .map_err(|e| match e {
                     V1(e) => {
-                        log::error!("Error handling request: {}", e);
+                        log::error!("Error handling request: {e}");
                         Response::builder().status(400).body(full(e.to_string())).unwrap()
                     }
                     e => {
-                        log::error!("Error handling request: {}", e);
+                        log::error!("Error handling request: {e}");
                         Response::builder().status(500).body(full(e.to_string())).unwrap()
                     }
                 })

payjoin-cli/tests/e2e.rs

@@ -48,7 +48,7 @@ mod e2e {
             let receiver_rpchost = format!("http://{}/wallet/receiver", bitcoind.params.rpc_socket);
             let sender_rpchost = format!("http://{}/wallet/sender", bitcoind.params.rpc_socket);
             let cookie_file = &bitcoind.params.cookie_file;
-            let pj_endpoint = format!("https://localhost:{}", port);
+            let pj_endpoint = format!("https://localhost:{port}");
             let payjoin_cli = env!("CARGO_BIN_EXE_payjoin-cli");
 
             let mut cli_receiver = Command::new(payjoin_cli)
@@ -82,7 +82,7 @@ mod e2e {
             {
                 // Write to stdout regardless
                 stdout
-                    .write_all(format!("{}\n", line).as_bytes())
+                    .write_all(format!("{line}\n").as_bytes())
                     .await
                     .expect("Failed to write to stdout");
 
@@ -121,7 +121,7 @@ mod e2e {
                     lines.next_line().await.expect("Failed to read line from stdout")
                 {
                     stdout
-                        .write_all(format!("{}\n", line).as_bytes())
+                        .write_all(format!("{line}\n").as_bytes())
                         .await
                         .expect("Failed to write to stdout");
                     if line.contains("Payjoin sent") {
@@ -173,8 +173,8 @@ mod e2e {
             CleanupGuard { paths: vec![receiver_db_path.clone(), sender_db_path.clone()] };
 
         let result = tokio::select! {
-            res = services.take_ohttp_relay_handle() => Err(format!("Ohttp relay is long running: {:?}", res).into()),
-            res = services.take_directory_handle() => Err(format!("Directory server is long running: {:?}", res).into()),
+            res = services.take_ohttp_relay_handle() => Err(format!("Ohttp relay is long running: {res:?}").into()),
+            res = services.take_directory_handle() => Err(format!("Directory server is long running: {res:?}").into()),
             res = send_receive_cli_async(&services, receiver_db_path.clone(), sender_db_path.clone()) => res,
         };
 
@@ -357,7 +357,7 @@ mod e2e {
             {
                 // Write all output to tests stdout
                 stdout
-                    .write_all(format!("{}\n", line).as_bytes())
+                    .write_all(format!("{line}\n").as_bytes())
                     .await
                     .expect("Failed to write to stdout");
 
@@ -375,7 +375,7 @@ mod e2e {
 
     fn cleanup_temp_file(path: &std::path::Path) {
         if let Err(e) = std::fs::remove_dir_all(path) {
-            eprintln!("Failed to remove {:?}: {}", path, e);
+            eprintln!("Failed to remove {path:?}: {e}");
         }
     }
 }

payjoin/src/receive/multiparty/error.rs

@@ -29,15 +29,15 @@ impl fmt::Display for MultipartyError {
         match &self.0 {
             InternalMultipartyError::NotEnoughProposals => write!(f, "Not enough proposals"),
             InternalMultipartyError::ProposalVersionNotSupported(v) =>
-                write!(f, "Proposal version not supported: {}", v),
+                write!(f, "Proposal version not supported: {v}"),
             InternalMultipartyError::OptimisticMergeNotSupported =>
                 write!(f, "Optimistic merge not supported"),
             InternalMultipartyError::BitcoinExtractTxError(e) =>
-                write!(f, "Bitcoin extract tx error: {:?}", e),
+                write!(f, "Bitcoin extract tx error: {e:?}"),
             InternalMultipartyError::InputMissingWitnessOrScriptSig =>
                 write!(f, "Input in Finalized Proposal is missing witness or script_sig"),
             InternalMultipartyError::FailedToCombinePsbts(e) =>
-                write!(f, "Failed to combine psbts: {:?}", e),
+                write!(f, "Failed to combine psbts: {e:?}"),
         }
     }
 }

payjoin/src/receive/v1/exclusive/error.rs

@@ -56,13 +56,13 @@ impl From<RequestError> for JsonReply {
 impl fmt::Display for RequestError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self.0 {
-            InternalRequestError::Io(e) => write!(f, "{}", e),
-            InternalRequestError::MissingHeader(header) => write!(f, "Missing header: {}", header),
+            InternalRequestError::Io(e) => write!(f, "{e}"),
+            InternalRequestError::MissingHeader(header) => write!(f, "Missing header: {header}"),
             InternalRequestError::InvalidContentType(content_type) =>
-                write!(f, "Invalid content type: {}", content_type),
-            InternalRequestError::InvalidContentLength(e) => write!(f, "{}", e),
+                write!(f, "Invalid content type: {content_type}"),
+            InternalRequestError::InvalidContentLength(e) => write!(f, "{e}"),
             InternalRequestError::ContentLengthTooLarge(length) =>
-                write!(f, "Content length too large: {}.", length),
+                write!(f, "Content length too large: {length}."),
         }
     }
 }

payjoin/tests/integration.rs

@@ -85,7 +85,7 @@ mod integration {
                 .check_pj_supported()
                 .map_err(|e| e.to_string())?;
             let psbt = build_original_psbt(&sender, &uri)?;
-            debug!("Original psbt: {:#?}", psbt);
+            debug!("Original psbt: {psbt:#?}");
             let (req, ctx) = SenderBuilder::new(psbt, uri)
                 .build_with_additional_fee(Amount::from_sat(10000), None, FeeRate::ZERO, false)?
                 .extract_v1();
@@ -150,7 +150,7 @@ mod integration {
                 .check_pj_supported()
                 .map_err(|e| e.to_string())?;
             let psbt = build_original_psbt(&sender, &uri)?;
-            debug!("Original psbt: {:#?}", psbt);
+            debug!("Original psbt: {psbt:#?}");
             let (req, _ctx) = SenderBuilder::new(psbt, uri)
                 .build_with_additional_fee(Amount::from_sat(10000), None, FeeRate::ZERO, false)?
                 .extract_v1();
@@ -656,14 +656,14 @@ mod integration {
                         .map(input_pair_from_list_unspent);
                     let selected_input =
                         payjoin.try_preserving_privacy(candidate_inputs).map_err(|e| {
-                            format!("Failed to make privacy preserving selection: {:?}", e)
+                            format!("Failed to make privacy preserving selection: {e:?}")
                         })?;
                     vec![selected_input]
                 }
             };
             let payjoin = payjoin
                 .contribute_inputs(inputs)
-                .map_err(|e| format!("Failed to contribute inputs: {:?}", e))?
+                .map_err(|e| format!("Failed to contribute inputs: {e:?}"))?
                 .commit_inputs();
 
             // Sign and finalize the proposal PSBT
@@ -1038,7 +1038,7 @@ mod integration {
                 .check_pj_supported()
                 .map_err(|e| e.to_string())?;
             let psbt = build_original_psbt(&sender, &uri)?;
-            log::debug!("Original psbt: {:#?}", psbt);
+            log::debug!("Original psbt: {psbt:#?}");
             let max_additional_fee = Amount::from_sat(1000);
             let (req, ctx) = SenderBuilder::new(psbt.clone(), uri)
                 .build_with_additional_fee(max_additional_fee, None, FeeRate::ZERO, false)?
@@ -1116,7 +1116,7 @@ mod integration {
                 .check_pj_supported()
                 .map_err(|e| e.to_string())?;
             let psbt = build_original_psbt(&sender, &uri)?;
-            log::debug!("Original psbt: {:#?}", psbt);
+            log::debug!("Original psbt: {psbt:#?}");
             let (req, ctx) = SenderBuilder::new(psbt.clone(), uri)
                 .build_with_additional_fee(Amount::from_sat(10000), None, FeeRate::ZERO, false)?
                 .extract_v1();
@@ -1226,7 +1226,7 @@ mod integration {
         let proposal =
             handle_proposal(proposal, receiver, custom_outputs, drain_script, custom_inputs)?;
         let psbt = proposal.psbt();
-        tracing::debug!("Receiver's Payjoin proposal PSBT: {:#?}", &psbt);
+        tracing::debug!("Receiver's Payjoin proposal PSBT: {psbt:#?}");
         Ok(psbt.to_string())
     }
 
@@ -1284,13 +1284,13 @@ mod integration {
                     .map(input_pair_from_list_unspent);
                 let selected_input = payjoin
                     .try_preserving_privacy(candidate_inputs)
-                    .map_err(|e| format!("Failed to make privacy preserving selection: {:?}", e))?;
+                    .map_err(|e| format!("Failed to make privacy preserving selection: {e:?}"))?;
                 vec![selected_input]
             }
         };
         let payjoin = payjoin
             .contribute_inputs(inputs)
-            .map_err(|e| format!("Failed to contribute inputs: {:?}", e))?
+            .map_err(|e| format!("Failed to contribute inputs: {e:?}"))?
             .commit_inputs();
 
         let payjoin_proposal = payjoin.finalize_proposal(
@@ -1320,7 +1320,7 @@ mod integration {
         let payjoin_psbt =
             sender.finalize_psbt(&payjoin_psbt, Some(false))?.psbt.expect("should contain a PSBT");
         let payjoin_psbt = Psbt::from_str(&payjoin_psbt)?;
-        tracing::debug!("Sender's Payjoin PSBT: {:#?}", payjoin_psbt);
+        tracing::debug!("Sender's Payjoin PSBT: {payjoin_psbt:#?}");
 
         Ok(payjoin_psbt.extract_tx()?)
     }