2026-01-25 automated rustfmt nightly

diff --git a/bitcoin/src/network/mod.rs b/bitcoin/src/network/mod.rs
index 165ecb78..f4f390cd 100644
--- a/bitcoin/src/network/mod.rs
+++ b/bitcoin/src/network/mod.rs
@@ -15,10 +15,10 @@ use crate::constants::ChainHash;
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use self::params::Params;
-#[doc(inline)]
-pub use network::{Network, NetworkKind, TestnetVersion};
 #[doc(no_inline)]
 pub use network::ParseNetworkError;
+#[doc(inline)]
+pub use network::{Network, NetworkKind, TestnetVersion};
 
 /// Extension functionality for the [`Network`] type.
 // `define_extension_trait` chokes on the rustdoc example code.
@@ -57,9 +57,7 @@ pub trait NetworkExt: sealed::Sealed {
 impl NetworkExt for Network {
     fn chain_hash(self) -> ChainHash { ChainHash::using_genesis_block_const(self) }
 
-    fn from_chain_hash(chain_hash: ChainHash) -> Option<Self> {
-        Self::try_from(chain_hash).ok()
-    }
+    fn from_chain_hash(chain_hash: ChainHash) -> Option<Self> { Self::try_from(chain_hash).ok() }
 
     /// Returns the associated network parameters.
     fn params(self) -> &'static Params {
diff --git a/bitcoin/src/network/params.rs b/bitcoin/src/network/params.rs
index a754ac04..0c6f5fe9 100644
--- a/bitcoin/src/network/params.rs
+++ b/bitcoin/src/network/params.rs
@@ -60,7 +60,7 @@
 //! # }
 //! ```
 
-use super::{Network, TestnetVersion, NetworkExt as _};
+use super::{Network, NetworkExt as _, TestnetVersion};
 #[cfg(doc)]
 use crate::pow::CompactTarget;
 use crate::pow::Target;
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index c8ef40d3..cbcf7ba2 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -1573,7 +1573,7 @@ mod tests {
         assert_eq!(got, want)
     }
 
-   #[test]
+    #[test]
     fn u256_overflowing_mul() {
         let a = U256(u128::MAX, 0);
         let b = U256(1 << 65 | 1, 0);
@@ -1613,7 +1613,7 @@ mod tests {
 
         // mul_u64 overflows twice but no other overflows. Kills |= -> ^= mutant.
         let a = U256::ONE << 255;
-        let b = U256(1<<1 | 1<<65, 0);
+        let b = U256(1 << 1 | 1 << 65, 0);
         let (res, overflow) = a.overflowing_mul(b);
         assert_eq!(res, U256::ZERO);
         assert!(overflow);
diff --git a/consensus_encoding/src/encode/encoders.rs b/consensus_encoding/src/encode/encoders.rs
index 4ab239b0..52a5ff8b 100644
--- a/consensus_encoding/src/encode/encoders.rs
+++ b/consensus_encoding/src/encode/encoders.rs
@@ -40,9 +40,7 @@ impl Encoder for BytesEncoder<'_> {
 
 impl<'sl> ExactSizeEncoder for BytesEncoder<'sl> {
     #[inline]
-    fn len(&self) -> usize {
-        self.sl.map_or(0, <[u8]>::len)
-    }
+    fn len(&self) -> usize { self.sl.map_or(0, <[u8]>::len) }
 }
 
 /// An encoder for a single array.
diff --git a/consensus_encoding/src/encode/mod.rs b/consensus_encoding/src/encode/mod.rs
index d6ec9f24..99e23038 100644
--- a/consensus_encoding/src/encode/mod.rs
+++ b/consensus_encoding/src/encode/mod.rs
@@ -115,12 +115,11 @@ impl<'s, T: Encodable + 's> Iterator for EncodableByteIter<'s, T> {
 impl<'s, T> ExactSizeIterator for EncodableByteIter<'s, T>
 where
     T: Encodable + 's,
-    T::Encoder<'s>: ExactSizeEncoder
+    T::Encoder<'s>: ExactSizeEncoder,
 {
     fn len(&self) -> usize { self.enc.len() - self.position }
 }
 
-
 /// An encoder with a known size.
 pub trait ExactSizeEncoder: Encoder {
     /// The number of bytes remaining that the encoder will yield.
diff --git a/p2p/src/lib.rs b/p2p/src/lib.rs
index e6fb5210..edc3519c 100644
--- a/p2p/src/lib.rs
+++ b/p2p/src/lib.rs
@@ -37,10 +37,10 @@ use core::{fmt, ops};
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use bitcoin::consensus::encode::{self, Decodable, Encodable};
-use network::{Network, TestnetVersion};
 use hex::FromHex;
 use internals::{impl_to_hex_from_lower_hex, write_err};
 use io::{BufRead, Write};
+use network::{Network, TestnetVersion};
 
 #[rustfmt::skip]
 #[doc(inline)]
@@ -119,9 +119,7 @@ encoding::encoder_newtype! {
 impl encoding::Encodable for ProtocolVersion {
     type Encoder<'e> = ProtocolVersionEncoder;
     fn encoder(&self) -> Self::Encoder<'_> {
-        ProtocolVersionEncoder(encoding::ArrayEncoder::without_length_prefix(
-            self.0.to_le_bytes(),
-        ))
+        ProtocolVersionEncoder(encoding::ArrayEncoder::without_length_prefix(self.0.to_le_bytes()))
     }
 }
 
@@ -344,9 +342,7 @@ encoding::encoder_newtype! {
 impl encoding::Encodable for ServiceFlags {
     type Encoder<'e> = ServiceFlagsEncoder;
     fn encoder(&self) -> Self::Encoder<'_> {
-        ServiceFlagsEncoder(encoding::ArrayEncoder::without_length_prefix(
-            self.0.to_le_bytes(),
-        ))
+        ServiceFlagsEncoder(encoding::ArrayEncoder::without_length_prefix(self.0.to_le_bytes()))
     }
 }
 
diff --git a/p2p/src/message.rs b/p2p/src/message.rs
index a67f3435..99619c00 100644
--- a/p2p/src/message.rs
+++ b/p2p/src/message.rs
@@ -26,7 +26,8 @@ use units::FeeRate;
 use crate::address::{AddrV2Message, Address};
 use crate::consensus::{impl_consensus_encoding, impl_vec_wrapper};
 use crate::{
-    bip152, message_blockdata, message_bloom, message_compact_blocks, message_filter, message_network, Magic
+    bip152, message_blockdata, message_bloom, message_compact_blocks, message_filter,
+    message_network, Magic,
 };
 
 /// The maximum number of [`super::message_blockdata::Inventory`] items in an `inv` message.
@@ -255,11 +256,11 @@ pub struct V1MessageHeader {
 }
 
 type V1MessageHeaderInnerDecoder = encoding::Decoder4<
-            encoding::ArrayDecoder<4>,
-            CommandStringDecoder,
-            encoding::ArrayDecoder<4>,
-            encoding::ArrayDecoder<4>,
-        >;
+    encoding::ArrayDecoder<4>,
+    CommandStringDecoder,
+    encoding::ArrayDecoder<4>,
+    encoding::ArrayDecoder<4>,
+>;
 
 /// The Decoder for `V1MessageHeader`
 pub struct V1MessageHeaderDecoder(V1MessageHeaderInnerDecoder);
@@ -275,15 +276,14 @@ impl encoding::Decoder for V1MessageHeaderDecoder {
 
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
-        let (magic, command, length, checksum) = self.0.end().map_err(V1MessageHeaderDecoderError)?;
-        Ok(
-            V1MessageHeader {
-                magic: Magic(magic),
-                command,
-                length: u32::from_le_bytes(length),
-                checksum
-            }
-        )
+        let (magic, command, length, checksum) =
+            self.0.end().map_err(V1MessageHeaderDecoderError)?;
+        Ok(V1MessageHeader {
+            magic: Magic(magic),
+            command,
+            length: u32::from_le_bytes(length),
+            checksum,
+        })
     }
 
     #[inline]
@@ -293,11 +293,11 @@ impl encoding::Decoder for V1MessageHeaderDecoder {
 impl encoding::Decodable for V1MessageHeader {
     type Decoder = V1MessageHeaderDecoder;
     fn decoder() -> Self::Decoder {
-        V1MessageHeaderDecoder (encoding::Decoder4::new(
+        V1MessageHeaderDecoder(encoding::Decoder4::new(
             encoding::ArrayDecoder::<4>::new(),
             CommandString::decoder(),
             encoding::ArrayDecoder::<4>::new(),
-            encoding::ArrayDecoder::<4>::new()
+            encoding::ArrayDecoder::<4>::new(),
         ))
     }
 }
diff --git a/p2p/src/message_blockdata.rs b/p2p/src/message_blockdata.rs
index 113dba15..9ec72f70 100644
--- a/p2p/src/message_blockdata.rs
+++ b/p2p/src/message_blockdata.rs
@@ -125,8 +125,8 @@ impl encoding::Encodable for Inventory {
         };
         InventoryEncoder(Encoder2::new(
             ArrayEncoder::without_length_prefix(prefix.to_le_bytes()),
-            ArrayEncoder::without_length_prefix(bytes))
-        )
+            ArrayEncoder::without_length_prefix(bytes),
+        ))
     }
 }
 
@@ -179,7 +179,6 @@ impl From<Infallible> for InventoryDecoderError {
     fn from(never: Infallible) -> Self { match never {} }
 }
 
-
 impl fmt::Display for InventoryDecoderError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write_err!(f, "inventory error"; self.0)
diff --git a/p2p/src/message_bloom.rs b/p2p/src/message_bloom.rs
index 9b18f692..f157a76d 100644
--- a/p2p/src/message_bloom.rs
+++ b/p2p/src/message_bloom.rs
@@ -81,12 +81,10 @@ impl encoding::Encodable for FilterAdd {
     type Encoder<'e> = FilterAddEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        FilterAddEncoder(
-            Encoder2::new(
-                CompactSizeEncoder::new(self.data.len()),
-                BytesEncoder::without_length_prefix(&self.data)
-            )
-        )
+        FilterAddEncoder(Encoder2::new(
+            CompactSizeEncoder::new(self.data.len()),
+            BytesEncoder::without_length_prefix(&self.data),
+        ))
     }
 }
 
@@ -117,9 +115,7 @@ impl encoding::Decoder for FilterAddDecoder {
 impl encoding::Decodable for FilterAdd {
     type Decoder = FilterAddDecoder;
 
-    fn decoder() -> Self::Decoder {
-        FilterAddDecoder(FilterAddInnerDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { FilterAddDecoder(FilterAddInnerDecoder::new()) }
 }
 
 /// An error decoding a [`FilterAdd`] message.
diff --git a/p2p/src/message_filter.rs b/p2p/src/message_filter.rs
index 5c83d37b..4c9f8928 100644
--- a/p2p/src/message_filter.rs
+++ b/p2p/src/message_filter.rs
@@ -10,11 +10,16 @@ use core::fmt;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
-use encoding::{ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder2, Decoder3, Decoder4, Encoder2, Encoder3, Encoder4, SliceEncoder, VecDecoder};
+use encoding::{
+    ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder2,
+    Decoder3, Decoder4, Encoder2, Encoder3, Encoder4, SliceEncoder, VecDecoder,
+};
 use hashes::{sha256d, HashEngine};
 use internals::write_err;
-use primitives::{block::{BlockHashDecoder, BlockHashEncoder}, BlockHash};
-use units::{block::{BlockHeightDecoder, BlockHeightEncoder}, BlockHeight};
+use primitives::block::{BlockHashDecoder, BlockHashEncoder};
+use primitives::BlockHash;
+use units::block::{BlockHeightDecoder, BlockHeightEncoder};
+use units::BlockHeight;
 
 use crate::consensus::impl_consensus_encoding;
 
@@ -110,9 +115,7 @@ impl encoding::Decoder for FilterHashDecoder {
 impl encoding::Decodable for FilterHash {
     type Decoder = FilterHashDecoder;
 
-    fn decoder() -> Self::Decoder {
-        FilterHashDecoder(ArrayDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { FilterHashDecoder(ArrayDecoder::new()) }
 }
 
 /// Errors occuring when decoding a [`FilterHash`] message.
@@ -159,9 +162,7 @@ impl encoding::Decoder for FilterHeaderDecoder {
 impl encoding::Decodable for FilterHeader {
     type Decoder = FilterHeaderDecoder;
 
-    fn decoder() -> Self::Decoder {
-        FilterHeaderDecoder(ArrayDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { FilterHeaderDecoder(ArrayDecoder::new()) }
 }
 
 /// Errors occuring when decoding a [`FilterHash`] message.
@@ -217,13 +218,11 @@ impl encoding::Encodable for GetCFilters {
     type Encoder<'e> = GetCFiltersEncoder;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        GetCFiltersEncoder(
-            Encoder3::new(
-                ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
-                self.start_height.encoder(),
-                self.stop_hash.encoder()
-            )
-        )
+        GetCFiltersEncoder(Encoder3::new(
+            ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
+            self.start_height.encoder(),
+            self.stop_hash.encoder(),
+        ))
     }
 }
 
@@ -244,11 +243,7 @@ impl encoding::Decoder for GetCFiltersDecoder {
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
         let (ty, start_height, stop_hash) = self.0.end().map_err(GetCFiltersDecoderError)?;
-        Ok(GetCFilters {
-            filter_type: u8::from_le_bytes(ty),
-            start_height,
-            stop_hash
-        })
+        Ok(GetCFilters { filter_type: u8::from_le_bytes(ty), start_height, stop_hash })
     }
 
     #[inline]
@@ -259,13 +254,11 @@ impl encoding::Decodable for GetCFilters {
     type Decoder = GetCFiltersDecoder;
 
     fn decoder() -> Self::Decoder {
-        GetCFiltersDecoder(
-            Decoder3::new(
-                ArrayDecoder::new(),
-                BlockHeightDecoder::new(),
-                BlockHashDecoder::new()
-            )
-        )
+        GetCFiltersDecoder(Decoder3::new(
+            ArrayDecoder::new(),
+            BlockHeightDecoder::new(),
+            BlockHashDecoder::new(),
+        ))
     }
 }
 
@@ -313,21 +306,20 @@ encoding::encoder_newtype! {
 }
 
 impl encoding::Encodable for CFilter {
-    type Encoder<'e> = CFilterEncoder<'e>
+    type Encoder<'e>
+        = CFilterEncoder<'e>
     where
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        CFilterEncoder(
-            Encoder3::new(
-                ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
-                self.block_hash.encoder(),
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.filter.len()),
-                    BytesEncoder::without_length_prefix(&self.filter)
-                )
-            )
-        )
+        CFilterEncoder(Encoder3::new(
+            ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
+            self.block_hash.encoder(),
+            Encoder2::new(
+                CompactSizeEncoder::new(self.filter.len()),
+                BytesEncoder::without_length_prefix(&self.filter),
+            ),
+        ))
     }
 }
 
@@ -348,11 +340,7 @@ impl encoding::Decoder for CFilterDecoder {
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
         let (ty, block_hash, filter) = self.0.end().map_err(CFilterDecoderError)?;
-        Ok(CFilter {
-            filter_type: u8::from_le_bytes(ty),
-            block_hash,
-            filter,
-        })
+        Ok(CFilter { filter_type: u8::from_le_bytes(ty), block_hash, filter })
     }
 
     #[inline]
@@ -363,9 +351,11 @@ impl encoding::Decodable for CFilter {
     type Decoder = CFilterDecoder;
 
     fn decoder() -> Self::Decoder {
-        CFilterDecoder(
-            Decoder3::new(ArrayDecoder::new(), BlockHashDecoder::new(), ByteVecDecoder::new())
-        )
+        CFilterDecoder(Decoder3::new(
+            ArrayDecoder::new(),
+            BlockHashDecoder::new(),
+            ByteVecDecoder::new(),
+        ))
     }
 }
 
@@ -410,13 +400,11 @@ impl encoding::Encodable for GetCFHeaders {
     type Encoder<'e> = GetCFHeadersEncoder;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        GetCFHeadersEncoder(
-            Encoder3::new(
-                ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
-                self.start_height.encoder(),
-                self.stop_hash.encoder()
-            )
-        )
+        GetCFHeadersEncoder(Encoder3::new(
+            ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
+            self.start_height.encoder(),
+            self.stop_hash.encoder(),
+        ))
     }
 }
 
@@ -437,11 +425,7 @@ impl encoding::Decoder for GetCFHeadersDecoder {
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
         let (ty, start_height, stop_hash) = self.0.end().map_err(GetCFHeadersDecoderError)?;
-        Ok(GetCFHeaders {
-            filter_type: u8::from_le_bytes(ty),
-            start_height,
-            stop_hash
-        })
+        Ok(GetCFHeaders { filter_type: u8::from_le_bytes(ty), start_height, stop_hash })
     }
 
     #[inline]
@@ -452,13 +436,11 @@ impl encoding::Decodable for GetCFHeaders {
     type Decoder = GetCFHeadersDecoder;
 
     fn decoder() -> Self::Decoder {
-        GetCFHeadersDecoder(
-            Decoder3::new(
-                ArrayDecoder::new(),
-                BlockHeightDecoder::new(),
-                BlockHashDecoder::new()
-            )
-        )
+        GetCFHeadersDecoder(Decoder3::new(
+            ArrayDecoder::new(),
+            BlockHeightDecoder::new(),
+            BlockHashDecoder::new(),
+        ))
     }
 }
 
@@ -512,21 +494,20 @@ impl encoding::Encodable for CFHeaders {
     type Encoder<'e> = CFHeadersEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        CFHeadersEncoder(
-            Encoder4::new(
-                ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
-                self.stop_hash.encoder(),
-                self.previous_filter_header.encoder(),
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.filter_hashes.len()),
-                    SliceEncoder::without_length_prefix(&self.filter_hashes),
-                )
-            )
-        )
+        CFHeadersEncoder(Encoder4::new(
+            ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
+            self.stop_hash.encoder(),
+            self.previous_filter_header.encoder(),
+            Encoder2::new(
+                CompactSizeEncoder::new(self.filter_hashes.len()),
+                SliceEncoder::without_length_prefix(&self.filter_hashes),
+            ),
+        ))
     }
 }
 
-type CFHeadersInnerDecoder = Decoder4<ArrayDecoder<1>, BlockHashDecoder, FilterHeaderDecoder, VecDecoder<FilterHash>>;
+type CFHeadersInnerDecoder =
+    Decoder4<ArrayDecoder<1>, BlockHashDecoder, FilterHeaderDecoder, VecDecoder<FilterHash>>;
 
 /// Decoder type for a [`CFHeaders`] message.
 pub struct CFHeadersDecoder(CFHeadersInnerDecoder);
@@ -542,12 +523,13 @@ impl encoding::Decoder for CFHeadersDecoder {
 
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
-        let (ty, stop_hash, previous_filter_header, filter_hashes) = self.0.end().map_err(CFHeadersDecoderError)?;
+        let (ty, stop_hash, previous_filter_header, filter_hashes) =
+            self.0.end().map_err(CFHeadersDecoderError)?;
         Ok(CFHeaders {
             filter_type: u8::from_le_bytes(ty),
             stop_hash,
             previous_filter_header,
-            filter_hashes
+            filter_hashes,
         })
     }
 
@@ -559,14 +541,12 @@ impl encoding::Decodable for CFHeaders {
     type Decoder = CFHeadersDecoder;
 
     fn decoder() -> Self::Decoder {
-        CFHeadersDecoder(
-            Decoder4::new(
-                ArrayDecoder::new(),
-                BlockHashDecoder::new(),
-                FilterHeader::decoder(),
-                VecDecoder::new()
-            )
-        )
+        CFHeadersDecoder(Decoder4::new(
+            ArrayDecoder::new(),
+            BlockHashDecoder::new(),
+            FilterHeader::decoder(),
+            VecDecoder::new(),
+        ))
     }
 }
 
@@ -608,12 +588,10 @@ impl encoding::Encodable for GetCFCheckpt {
     type Encoder<'e> = GetCFCheckptEncoder;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        GetCFCheckptEncoder(
-            Encoder2::new(
-                ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
-                self.stop_hash.encoder()
-            )
-        )
+        GetCFCheckptEncoder(Encoder2::new(
+            ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
+            self.stop_hash.encoder(),
+        ))
     }
 }
 
@@ -634,10 +612,7 @@ impl encoding::Decoder for GetCFCheckptDecoder {
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
         let (ty, stop_hash) = self.0.end().map_err(GetCFCheckptDecoderError)?;
-        Ok(GetCFCheckpt {
-            filter_type: u8::from_le_bytes(ty),
-            stop_hash
-        })
+        Ok(GetCFCheckpt { filter_type: u8::from_le_bytes(ty), stop_hash })
     }
 
     #[inline]
@@ -648,9 +623,7 @@ impl encoding::Decodable for GetCFCheckpt {
     type Decoder = GetCFCheckptDecoder;
 
     fn decoder() -> Self::Decoder {
-        GetCFCheckptDecoder(
-            Decoder2::new(ArrayDecoder::new(), BlockHashDecoder::new())
-        )
+        GetCFCheckptDecoder(Decoder2::new(ArrayDecoder::new(), BlockHashDecoder::new()))
     }
 }
 
@@ -698,21 +671,20 @@ encoding::encoder_newtype! {
 }
 
 impl encoding::Encodable for CFCheckpt {
-    type Encoder<'e> = CFCheckptEncoder<'e>
+    type Encoder<'e>
+        = CFCheckptEncoder<'e>
     where
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        CFCheckptEncoder(
-            Encoder3::new(
-                ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
-                self.stop_hash.encoder(),
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.filter_headers.len()),
-                    SliceEncoder::without_length_prefix(&self.filter_headers)
-                )
-            )
-        )
+        CFCheckptEncoder(Encoder3::new(
+            ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
+            self.stop_hash.encoder(),
+            Encoder2::new(
+                CompactSizeEncoder::new(self.filter_headers.len()),
+                SliceEncoder::without_length_prefix(&self.filter_headers),
+            ),
+        ))
     }
 }
 
@@ -733,11 +705,7 @@ impl encoding::Decoder for CFCheckptDecoder {
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
         let (ty, stop_hash, filter_headers) = self.0.end().map_err(CFCheckptDecoderError)?;
-        Ok(CFCheckpt {
-            filter_type: u8::from_le_bytes(ty),
-            stop_hash,
-            filter_headers,
-        })
+        Ok(CFCheckpt { filter_type: u8::from_le_bytes(ty), stop_hash, filter_headers })
     }
 
     #[inline]
@@ -748,9 +716,11 @@ impl encoding::Decodable for CFCheckpt {
     type Decoder = CFCheckptDecoder;
 
     fn decoder() -> Self::Decoder {
-        CFCheckptDecoder(
-            Decoder3::new(ArrayDecoder::new(), BlockHashDecoder::new(), VecDecoder::new())
-        )
+        CFCheckptDecoder(Decoder3::new(
+            ArrayDecoder::new(),
+            BlockHashDecoder::new(),
+            VecDecoder::new(),
+        ))
     }
 }
 
diff --git a/p2p/src/message_network.rs b/p2p/src/message_network.rs
index e938fda0..0afbb208 100644
--- a/p2p/src/message_network.rs
+++ b/p2p/src/message_network.rs
@@ -116,12 +116,10 @@ impl encoding::Encodable for UserAgent {
     type Encoder<'e> = UserAgentEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        UserAgentEncoder(
-            Encoder2::new(
-                CompactSizeEncoder::new(self.user_agent.len()),
-                BytesEncoder::without_length_prefix(self.user_agent.as_bytes())
-            )
-        )
+        UserAgentEncoder(Encoder2::new(
+            CompactSizeEncoder::new(self.user_agent.len()),
+            BytesEncoder::without_length_prefix(self.user_agent.as_bytes()),
+        ))
     }
 }
 
@@ -142,7 +140,8 @@ impl encoding::Decoder for UserAgentDecoder {
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
         let bytes = self.0.end().map_err(UserAgentDecoderError::Decoder)?;
-        let user_agent = String::from_utf8(bytes).map_err(|_| UserAgentDecoderError::InvalidUtf8)?;
+        let user_agent =
+            String::from_utf8(bytes).map_err(|_| UserAgentDecoderError::InvalidUtf8)?;
         Ok(UserAgent { user_agent })
     }
 
@@ -153,9 +152,7 @@ impl encoding::Decoder for UserAgentDecoder {
 impl encoding::Decodable for UserAgent {
     type Decoder = UserAgentDecoder;
 
-    fn decoder() -> Self::Decoder {
-        UserAgentDecoder(UserAgentInnerDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { UserAgentDecoder(UserAgentInnerDecoder::new()) }
 }
 
 /// An error decoding a [`UserAgent`] message.
@@ -426,12 +423,10 @@ impl encoding::Encodable for Alert {
     type Encoder<'e> = AlertEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        AlertEncoder(
-            Encoder2::new(
-                CompactSizeEncoder::new(self.0.len()),
-                BytesEncoder::without_length_prefix(&self.0)
-            )
-        )
+        AlertEncoder(Encoder2::new(
+            CompactSizeEncoder::new(self.0.len()),
+            BytesEncoder::without_length_prefix(&self.0),
+        ))
     }
 }
 
@@ -461,9 +456,7 @@ impl encoding::Decoder for AlertDecoder {
 impl encoding::Decodable for Alert {
     type Decoder = AlertDecoder;
 
-    fn decoder() -> Self::Decoder {
-        AlertDecoder(AlertInnerDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { AlertDecoder(AlertInnerDecoder::new()) }
 }
 
 /// An error decoding a [`Alert`] message.
diff --git a/primitives/tests/api.rs b/primitives/tests/api.rs
index 2635cbcb..a3879e8a 100644
--- a/primitives/tests/api.rs
+++ b/primitives/tests/api.rs
@@ -212,8 +212,8 @@ fn api_can_use_units_modules_from_crate_root() {
 #[test]
 fn api_can_use_units_types_from_crate_root() {
     use bitcoin_primitives::{
-        Amount, BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval, BlockTime,
-        FeeRate, NumOpResult, Sequence, SignedAmount, Weight,
+        Amount, BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval, BlockTime, FeeRate,
+        NumOpResult, Sequence, SignedAmount, Weight,
     };
 }