From 069c655bfeb7b7cb503e9125b416a33ea167deaa Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 25 May 2025 02:10:59 +0000
Subject: [PATCH] 2025-05-25 automated rustfmt nightly

---
 bitcoin/src/psbt/mod.rs                       | 24 +++++++++----------
 .../bitcoin/p2p_address_roundtrip.rs          | 15 +++---------
 units/src/amount/error.rs                     |  1 -
 units/src/locktime/absolute.rs                |  2 --
 4 files changed, 14 insertions(+), 28 deletions(-)

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index a70b88d9a..142e93a2b 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/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!(
diff --git a/fuzz/fuzz_targets/bitcoin/p2p_address_roundtrip.rs b/fuzz/fuzz_targets/bitcoin/p2p_address_roundtrip.rs
index f5dd65a64..669c5ea92 100644
--- a/fuzz/fuzz_targets/bitcoin/p2p_address_roundtrip.rs
+++ b/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()) {
diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index fbb1cfdfd..e0946d15c 100644
--- a/units/src/amount/error.rs
+++ b/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,
         }
diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
index ee50262ef..46e8a7403 100644
--- a/units/src/locktime/absolute.rs
+++ b/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 =>