2025-05-25 automated rustfmt nightly

Author: Fmt Bot

bitcoin/src/psbt/mod.rs

@@ -856,11 +856,11 @@ impl GetKey for $map<PublicKey, PrivateKey> {
             KeyRequest::XOnlyPubkey(xonly) => {
                 let pubkey_even = xonly.public_key(secp256k1::Parity::Even);
                 let key = self.get(&pubkey_even).cloned();
-               
+              
                 if key.is_some() {
                     return Ok(key);
                 }
-               
+              
                 let pubkey_odd = xonly.public_key(secp256k1::Parity::Odd);
                 if let Some(priv_key) = self.get(&pubkey_odd).copied() {
                     let negated_priv_key  = priv_key.negate();
@@ -893,18 +893,18 @@ impl GetKey for $map<XOnlyPublicKey, PrivateKey> {
             KeyRequest::XOnlyPubkey(xonly) => Ok(self.get(xonly).cloned()),
             KeyRequest::Pubkey(pk) => {
                 let (xonly, parity) = pk.inner.x_only_public_key();
-               
+              
                 if let Some(mut priv_key) = self.get(&XOnlyPublicKey::from(xonly)).cloned() {
                     let computed_pk = priv_key.public_key(&secp);
                     let (_, computed_parity) = computed_pk.inner.x_only_public_key();
-                   
+                  
                     if computed_parity != parity {
                         priv_key = priv_key.negate();
                     }
-                   
+                  
                     return Ok(Some(priv_key));
                 }
-               
+              
                 Ok(None)
             },
             KeyRequest::Bip32(_) => Err(GetKeyError::NotSupported),
@@ -1412,17 +1412,15 @@ mod tests {
             Err(ABSURD_FEE_RATE)
         );
         assert_eq!(
-            psbt.clone()
-                .extract_tx_with_fee_rate_limit(JUST_BELOW_ABSURD_FEE_RATE)
-                .map_err(|e| match e {
+            psbt.clone().extract_tx_with_fee_rate_limit(JUST_BELOW_ABSURD_FEE_RATE).map_err(|e| {
+                match e {
                     ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
                     _ => panic!(""),
-                }),
+                }
+            }),
             Err(ABSURD_FEE_RATE)
         );
-        assert!(psbt
-            .extract_tx_with_fee_rate_limit(ABSURD_FEE_RATE)
-            .is_ok());
+        assert!(psbt.extract_tx_with_fee_rate_limit(ABSURD_FEE_RATE).is_ok());
 
         // Testing that extract_tx will error at 25k sat/vbyte (6250000 sat/kwu)
         assert_eq!(

fuzz/fuzz_targets/bitcoin/p2p_address_roundtrip.rs

@@ -19,26 +19,17 @@ fn do_test(data: &[u8]) {
 
     if let Ok(ip_addr) = IpAddr::try_from(addr_v2.clone()) {
         let round_trip: AddrV2 = AddrV2::from(ip_addr);
-        assert_eq!(
-            addr_v2, round_trip,
-            "AddrV2 -> IpAddr -> AddrV2 should round-trip correctly"
-        );
+        assert_eq!(addr_v2, round_trip, "AddrV2 -> IpAddr -> AddrV2 should round-trip correctly");
     }
 
     if let Ok(ip_addr) = Ipv4Addr::try_from(addr_v2.clone()) {
         let round_trip: AddrV2 = AddrV2::from(ip_addr);
-        assert_eq!(
-            addr_v2, round_trip,
-            "AddrV2 -> Ipv4Addr -> AddrV2 should round-trip correctly"
-        );
+        assert_eq!(addr_v2, round_trip, "AddrV2 -> Ipv4Addr -> AddrV2 should round-trip correctly");
     }
 
     if let Ok(ip_addr) = Ipv6Addr::try_from(addr_v2.clone()) {
         let round_trip: AddrV2 = AddrV2::from(ip_addr);
-        assert_eq!(
-            addr_v2, round_trip,
-            "AddrV2 -> Ipv6Addr -> AddrV2 should round-trip correctly"
-        );
+        assert_eq!(addr_v2, round_trip, "AddrV2 -> Ipv6Addr -> AddrV2 should round-trip correctly");
     }
 
     if let Ok(socket_addr) = SocketAddr::try_from(addr_v2.clone()) {

units/src/amount/error.rs

@@ -347,7 +347,6 @@ impl fmt::Display for ParseDenominationError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseDenominationError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-
         match *self {
             Self::Unknown(_) | Self::PossiblyConfusing(_) => None,
         }

units/src/locktime/absolute.rs

@@ -377,7 +377,6 @@ impl ParseError {
     ) -> fmt::Result {
         use core::num::IntErrorKind;
 
-
         match self {
             Self::ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
                 if *source.kind() == IntErrorKind::PosOverflow =>
@@ -425,7 +424,6 @@ impl ParseError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         use core::num::IntErrorKind;
 
-
         match self {
             Self::ParseInt(ParseIntError { source, .. })
                 if *source.kind() == IntErrorKind::PosOverflow =>