2026-02-01 automated rustfmt nightly

diff --git a/bitcoin/examples/sign-tx-taproot.rs b/bitcoin/examples/sign-tx-taproot.rs
index a88cba5f..5eb28b7e 100644
--- a/bitcoin/examples/sign-tx-taproot.rs
+++ b/bitcoin/examples/sign-tx-taproot.rs
@@ -67,7 +67,8 @@ fn main() {
 
     // Sign the sighash using the secp256k1 library (exported by rust-bitcoin).
     let tweaked: TweakedKeypair = keypair.tap_tweak(None);
-    let signature = secp256k1::schnorr::sign(&sighash.to_byte_array(), &tweaked.as_keypair().to_inner());
+    let signature =
+        secp256k1::schnorr::sign(&sighash.to_byte_array(), &tweaked.as_keypair().to_inner());
 
     // Update the witness stack.
     let signature = bitcoin::taproot::Signature { signature, sighash_type };
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index b66d0b14..75ac22ea 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -742,9 +742,7 @@ impl Xpriv {
 
     /// Constructs a new BIP-0340 keypair for Schnorr signatures and Taproot use matching the internal
     /// secret key representation.
-    pub fn to_keypair(self) -> Keypair {
-        Keypair::from_secret_key(&self.private_key)
-    }
+    pub fn to_keypair(self) -> Keypair { Keypair::from_secret_key(&self.private_key) }
 
     /// Derives an extended private key from a path.
     ///
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index f40f1236..ba751ae7 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -35,7 +35,9 @@ use crate::{internal_macros, Amount, FeeRate, Sequence, SignedAmount};
 #[doc(no_inline)]
 pub use primitives::transaction::{ParseTransactionError, ParseOutPointError};
 #[doc(inline)]
-pub use primitives::transaction::{OutPoint, Transaction, Ntxid, Txid, Wtxid, Version, TxIn, TxOut};
+pub use primitives::transaction::{
+    Ntxid, OutPoint, Transaction, TxIn, TxOut, Txid, Version, Wtxid,
+};
 
 impl Encodable for Txid {
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 6e428b71..9bdd3f1e 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -176,11 +176,15 @@ impl Keypair {
     ///
     /// This is equivalent to using [`secp256k1::SecretKey::from_keypair`] on the inner value.
     #[inline]
-    pub fn to_secret_key(self) -> secp256k1::SecretKey { secp256k1::SecretKey::from_keypair(&self.to_inner()) }
+    pub fn to_secret_key(self) -> secp256k1::SecretKey {
+        secp256k1::SecretKey::from_keypair(&self.to_inner())
+    }
 
     /// Returns the secret bytes for this [`Keypair`].
     #[inline]
-    pub fn to_secret_bytes(self) -> [u8; constants::SECRET_KEY_SIZE] { self.to_inner().to_secret_bytes() }
+    pub fn to_secret_bytes(self) -> [u8; constants::SECRET_KEY_SIZE] {
+        self.to_inner().to_secret_bytes()
+    }
 
     /// Returns the [`PublicKey`] for this [`Keypair`].
     ///
@@ -200,9 +204,7 @@ impl Keypair {
 impl FromStr for Keypair {
     type Err = ParseKeypairError;
     fn from_str(s: &str) -> Result<Self, ParseKeypairError> {
-        secp256k1::Keypair::from_str(s)
-            .map(Self::from)
-            .map_err(ParseKeypairError)
+        secp256k1::Keypair::from_str(s).map(Self::from).map_err(ParseKeypairError)
     }
 }
 
@@ -1925,7 +1927,10 @@ mod tests {
         let keypair = Keypair::generate(&mut rand::rng());
         #[cfg(not(all(feature = "rand", feature = "std")))]
         let keypair = {
-            let bytes = <[u8; 32]>::from_hex("1ede31b0e7e47c2afc65ffd158b1b1b9d3b752bba8fd117dc8b9e944a390e8d9").unwrap();
+            let bytes = <[u8; 32]>::from_hex(
+                "1ede31b0e7e47c2afc65ffd158b1b1b9d3b752bba8fd117dc8b9e944a390e8d9",
+            )
+            .unwrap();
             let sk = PrivateKey::from_byte_array(bytes, NetworkKind::Test).unwrap();
             Keypair::from_secret_key(&sk.inner)
         };
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 2e03d04e..da583184 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -2023,7 +2023,8 @@ mod tests {
             assert_eq!(expected_hash_ty, hash_ty);
             assert_eq!(expected_key_spend_sig, key_spend_sig);
 
-            let tweaked_priv_key = SecretKey::from_keypair(&tweaked_keypair.to_keypair().to_inner());
+            let tweaked_priv_key =
+                SecretKey::from_keypair(&tweaked_keypair.to_keypair().to_inner());
             assert_eq!(expected.tweaked_privkey, tweaked_priv_key);
         }
     }
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 9de51a7e..71f01844 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -24,7 +24,7 @@ use secp256k1::Message;
 use crate::bip32::{self, KeySource, Xpriv, Xpub};
 use crate::crypto::key::{PrivateKey, PublicKey};
 use crate::crypto::{ecdsa, taproot};
-use crate::key::{TapTweak, XOnlyPublicKey, Keypair};
+use crate::key::{Keypair, TapTweak, XOnlyPublicKey};
 use crate::prelude::{btree_map, BTreeMap, BTreeSet, Borrow, Box, Vec};
 use crate::script::{ScriptExt as _, ScriptPubKeyExt as _};
 use crate::sighash::{self, EcdsaSighashType, Prevouts, SighashCache};
@@ -432,10 +432,13 @@ impl Psbt {
                         .to_keypair();
 
                     #[cfg(all(feature = "rand", feature = "std"))]
-                    let signature = secp256k1::schnorr::sign(&sighash.to_byte_array(), &key_pair.to_inner());
-                    #[cfg(not(all(feature = "rand", feature = "std")))]
                     let signature =
-                        secp256k1::schnorr::sign_no_aux_rand(&sighash.to_byte_array(), &key_pair.to_inner());
+                        secp256k1::schnorr::sign(&sighash.to_byte_array(), &key_pair.to_inner());
+                    #[cfg(not(all(feature = "rand", feature = "std")))]
+                    let signature = secp256k1::schnorr::sign_no_aux_rand(
+                        &sighash.to_byte_array(),
+                        &key_pair.to_inner(),
+                    );
 
                     let signature = taproot::Signature { signature, sighash_type };
                     input.tap_key_sig = Some(signature);
@@ -460,8 +463,10 @@ impl Psbt {
                             self.sighash_taproot(input_index, cache, Some(lh))?;
 
                         #[cfg(all(feature = "rand", feature = "std"))]
-                        let signature =
-                            secp256k1::schnorr::sign(&sighash.to_byte_array(), &key_pair.to_inner());
+                        let signature = secp256k1::schnorr::sign(
+                            &sighash.to_byte_array(),
+                            &key_pair.to_inner(),
+                        );
                         #[cfg(not(all(feature = "rand", feature = "std")))]
                         let signature = secp256k1::schnorr::sign_no_aux_rand(
                             &sighash.to_byte_array(),
diff --git a/bitcoin/tests/psbt-sign-taproot.rs b/bitcoin/tests/psbt-sign-taproot.rs
index 3a96f7c3..b0aec650 100644
--- a/bitcoin/tests/psbt-sign-taproot.rs
+++ b/bitcoin/tests/psbt-sign-taproot.rs
@@ -12,8 +12,8 @@ use bitcoin::script::{ScriptExt, TapScriptExt as _};
 use bitcoin::taproot::{LeafVersion, TaprootBuilder, TaprootSpendInfo};
 use bitcoin::transaction::Version;
 use bitcoin::{
-    absolute, script, Address, Amount, Keypair, Network, OutPoint, PrivateKey, Psbt,
-    ScriptSigBuf, Sequence, TapScriptBuf, Transaction, TxIn, TxOut, Witness, XOnlyPublicKey,
+    absolute, script, Address, Amount, Keypair, Network, OutPoint, PrivateKey, Psbt, ScriptSigBuf,
+    Sequence, TapScriptBuf, Transaction, TxIn, TxOut, Witness, XOnlyPublicKey,
 };
 
 #[test]
diff --git a/consensus_encoding/src/lib.rs b/consensus_encoding/src/lib.rs
index ad6dc567..78189a58 100644
--- a/consensus_encoding/src/lib.rs
+++ b/consensus_encoding/src/lib.rs
@@ -33,12 +33,12 @@ pub use self::decode::{
     decode_from_read, decode_from_read_unbuffered, decode_from_read_unbuffered_with, ReadError,
 };
 pub use self::decode::{decode_from_slice, Decodable, Decoder};
-#[cfg(feature = "alloc")]
-pub use self::encode::{encode_to_vec, flush_to_vec};
-#[cfg(feature = "std")]
-pub use self::encode::{encode_to_writer, flush_to_writer};
 pub use self::encode::encoders::{
     ArrayEncoder, BytesEncoder, CompactSizeEncoder, Encoder2, Encoder3, Encoder4, Encoder6,
     SliceEncoder,
 };
+#[cfg(feature = "alloc")]
+pub use self::encode::{encode_to_vec, flush_to_vec};
+#[cfg(feature = "std")]
+pub use self::encode::{encode_to_writer, flush_to_writer};
 pub use self::encode::{Encodable, EncodableByteIter, Encoder, ExactSizeEncoder};
diff --git a/hashes/src/sha256/crypto.rs b/hashes/src/sha256/crypto.rs
index 49fde45b..f2b3881b 100644
--- a/hashes/src/sha256/crypto.rs
+++ b/hashes/src/sha256/crypto.rs
@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: CC0-1.0
 
+#[cfg(all(feature = "std", target_arch = "aarch64"))]
+use core::arch::aarch64::*;
 #[cfg(all(feature = "std", target_arch = "x86"))]
 use core::arch::x86::*;
 #[cfg(all(feature = "std", target_arch = "x86_64"))]
 use core::arch::x86_64::*;
-#[cfg(all(feature = "std", target_arch = "aarch64"))]
-use core::arch::aarch64::*;
 
 use internals::slice::SliceExt;
 
diff --git a/p2p/src/bip152.rs b/p2p/src/bip152.rs
index 0cf462a1..b5e94348 100644
--- a/p2p/src/bip152.rs
+++ b/p2p/src/bip152.rs
@@ -14,7 +14,9 @@ use std::error;
 use arbitrary::{Arbitrary, Unstructured};
 use bitcoin::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
 use bitcoin::{block, Block, BlockChecked, BlockHash, Transaction};
-use encoding::{CompactSizeDecoder, CompactSizeEncoder, Decoder2, Encoder2, SliceEncoder, VecDecoder};
+use encoding::{
+    CompactSizeDecoder, CompactSizeEncoder, Decoder2, Encoder2, SliceEncoder, VecDecoder,
+};
 use hashes::{sha256, siphash24};
 use internals::array::ArrayExt as _;
 use internals::write_err;
@@ -322,9 +324,7 @@ struct Offset(usize);
 impl encoding::Encodable for Offset {
     type Encoder<'e> = CompactSizeEncoder;
 
-    fn encoder(&self) -> Self::Encoder<'_> {
-        CompactSizeEncoder::new(self.0)
-    }
+    fn encoder(&self) -> Self::Encoder<'_> { CompactSizeEncoder::new(self.0) }
 }
 
 struct OffsetDecoder(CompactSizeDecoder);
@@ -339,9 +339,7 @@ impl encoding::Decoder for OffsetDecoder {
     }
 
     #[inline]
-    fn end(self) -> Result<Self::Output, Self::Error> {
-        Ok(Offset(self.0.end()?))
-    }
+    fn end(self) -> Result<Self::Output, Self::Error> { Ok(Offset(self.0.end()?)) }
 
     #[inline]
     fn read_limit(&self) -> usize { self.0.read_limit() }
@@ -350,9 +348,7 @@ impl encoding::Decoder for OffsetDecoder {
 impl encoding::Decodable for Offset {
     type Decoder = OffsetDecoder;
 
-    fn decoder() -> Self::Decoder {
-        OffsetDecoder(CompactSizeDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { OffsetDecoder(CompactSizeDecoder::new()) }
 }
 
 /// A [`BlockTransactionsRequest`] structure is used to list transaction indexes
@@ -406,10 +402,8 @@ impl BlockTransactionsRequest {
                 Some(next) => {
                     indexes.push(next);
                     next
-                },
-                None => {
-                    return Err(TxIndexOutOfRangeError(last_cs as u64))
                 }
+                None => return Err(TxIndexOutOfRangeError(last_cs as u64)),
             };
             last_cs = last_cs.checked_add(1).ok_or(TxIndexOutOfRangeError(last_cs as u64))?;
         }
@@ -431,15 +425,13 @@ impl encoding::Encodable for BlockTransactionsRequest {
     type Encoder<'e> = BlockTransactionsRequestEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        BlockTransactionsRequestEncoder(
+        BlockTransactionsRequestEncoder(Encoder2::new(
+            self.block_hash.encoder(),
             Encoder2::new(
-                self.block_hash.encoder(),
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.offsets.len()),
-                    SliceEncoder::without_length_prefix(&self.offsets)
-                )
-            )
-        )
+                CompactSizeEncoder::new(self.offsets.len()),
+                SliceEncoder::without_length_prefix(&self.offsets),
+            ),
+        ))
     }
 }
 
@@ -477,7 +469,9 @@ impl encoding::Decodable for BlockTransactionsRequest {
 
 /// An error decoding a [`BlockTransactionsRequest`] message.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BlockTransactionsRequestDecoderError(<BlockTransactionsRequestInnerDecoder as encoding::Decoder>::Error);
+pub struct BlockTransactionsRequestDecoderError(
+    <BlockTransactionsRequestInnerDecoder as encoding::Decoder>::Error,
+);
 
 impl From<Infallible> for BlockTransactionsRequestDecoderError {
     fn from(never: Infallible) -> Self { match never {} }
@@ -632,9 +626,7 @@ impl<'a> Arbitrary<'a> for BlockTransactions {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Offset {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(Self(u.arbitrary()?))
-    }
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Self(u.arbitrary()?)) }
 }
 
 #[cfg(feature = "arbitrary")]
@@ -746,7 +738,10 @@ mod test {
             }
             {
                 // test serialization
-                let raw: Vec<u8> = serialize(&&BlockTransactionsRequest::from_indices_unchecked(BlockHash::from_byte_array([0; 32]), testcase.1));
+                let raw: Vec<u8> = serialize(&&BlockTransactionsRequest::from_indices_unchecked(
+                    BlockHash::from_byte_array([0; 32]),
+                    testcase.1,
+                ));
                 let mut expected_raw: Vec<u8> = [0u8; 32].to_vec();
                 expected_raw.extend(testcase.0);
                 assert_eq!(expected_raw, raw);
diff --git a/p2p/src/message.rs b/p2p/src/message.rs
index 3009bc64..39c81ba7 100644
--- a/p2p/src/message.rs
+++ b/p2p/src/message.rs
@@ -1855,12 +1855,10 @@ mod test {
             }])),
             NetworkMessage::SendAddrV2,
             NetworkMessage::CmpctBlock(cmptblock),
-            NetworkMessage::GetBlockTxn(
-                BlockTransactionsRequest::from_indices_unchecked(
-                    BlockHash::from_byte_array(hash([11u8; 32]).to_byte_array()),
-                    vec![0, 1, 2, 3, 10, 3002]
-                ),
-            ),
+            NetworkMessage::GetBlockTxn(BlockTransactionsRequest::from_indices_unchecked(
+                BlockHash::from_byte_array(hash([11u8; 32]).to_byte_array()),
+                vec![0, 1, 2, 3, 10, 3002],
+            )),
             NetworkMessage::BlockTxn(blocktxn),
             NetworkMessage::SendCmpct(SendCmpct { send_compact: true, version: 8333 }),
         ];
diff --git a/p2p/src/message_blockdata.rs b/p2p/src/message_blockdata.rs
index 5da9bd30..bfe5e498 100644
--- a/p2p/src/message_blockdata.rs
+++ b/p2p/src/message_blockdata.rs
@@ -12,7 +12,10 @@ use core::fmt;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use bitcoin::consensus::encode::{self, Decodable, Encodable};
-use encoding::{ArrayDecoder, ArrayEncoder, CompactSizeEncoder, Decoder2, Decoder3, Encoder2, Encoder3, SliceEncoder, VecDecoder};
+use encoding::{
+    ArrayDecoder, ArrayEncoder, CompactSizeEncoder, Decoder2, Decoder3, Encoder2, Encoder3,
+    SliceEncoder, VecDecoder,
+};
 use internals::write_err;
 use io::{BufRead, Write};
 use primitives::block::{BlockHashDecoder, BlockHashEncoder};
@@ -219,7 +222,11 @@ pub struct GetHeadersMessage {
     pub stop_hash: BlockHash,
 }
 
-type GetBlocksOrHeadersInnerEncoder<'e> = Encoder3<ProtocolVersionEncoder, Encoder2<CompactSizeEncoder, SliceEncoder<'e, BlockHash>>, BlockHashEncoder>;
+type GetBlocksOrHeadersInnerEncoder<'e> = Encoder3<
+    ProtocolVersionEncoder,
+    Encoder2<CompactSizeEncoder, SliceEncoder<'e, BlockHash>>,
+    BlockHashEncoder,
+>;
 
 encoding::encoder_newtype! {
     /// The encoder for [`GetBlocksMessage`].
@@ -232,44 +239,43 @@ encoding::encoder_newtype! {
 }
 
 impl encoding::Encodable for GetHeadersMessage {
-    type Encoder<'e> = GetHeadersEncoder<'e>
+    type Encoder<'e>
+        = GetHeadersEncoder<'e>
     where
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        GetHeadersEncoder(
-            Encoder3::new(
-                self.version.encoder(),
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.locator_hashes.len()),
-                    SliceEncoder::without_length_prefix(&self.locator_hashes),
-                ),
-                self.stop_hash.encoder(),
+        GetHeadersEncoder(Encoder3::new(
+            self.version.encoder(),
+            Encoder2::new(
+                CompactSizeEncoder::new(self.locator_hashes.len()),
+                SliceEncoder::without_length_prefix(&self.locator_hashes),
             ),
-        )
+            self.stop_hash.encoder(),
+        ))
     }
 }
 
 impl encoding::Encodable for GetBlocksMessage {
-    type Encoder<'e> = GetBlocksEncoder<'e>
+    type Encoder<'e>
+        = GetBlocksEncoder<'e>
     where
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        GetBlocksEncoder(
-            Encoder3::new(
-                self.version.encoder(),
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.locator_hashes.len()),
-                    SliceEncoder::without_length_prefix(&self.locator_hashes),
-                ),
-                self.stop_hash.encoder(),
+        GetBlocksEncoder(Encoder3::new(
+            self.version.encoder(),
+            Encoder2::new(
+                CompactSizeEncoder::new(self.locator_hashes.len()),
+                SliceEncoder::without_length_prefix(&self.locator_hashes),
             ),
-        )
+            self.stop_hash.encoder(),
+        ))
     }
 }
 
-type GetBlocksOrHeadersInnerDecoder = Decoder3<ProtocolVersionDecoder, VecDecoder<BlockHash>, BlockHashDecoder>;
+type GetBlocksOrHeadersInnerDecoder =
+    Decoder3<ProtocolVersionDecoder, VecDecoder<BlockHash>, BlockHashDecoder>;
 
 /// Decoder type for [`GetBlocksMessage`].
 pub struct GetBlocksMessageDecoder(GetBlocksOrHeadersInnerDecoder);
@@ -288,7 +294,8 @@ impl encoding::Decoder for GetHeadersMessageDecoder {
 
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
-        let (version, locator_hashes, stop_hash) = self.0.end().map_err(GetHeadersMessageDecoderError)?;
+        let (version, locator_hashes, stop_hash) =
+            self.0.end().map_err(GetHeadersMessageDecoderError)?;
         Ok(GetHeadersMessage { version, locator_hashes, stop_hash })
     }
 
@@ -307,7 +314,8 @@ impl encoding::Decoder for GetBlocksMessageDecoder {
 
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
-        let (version, locator_hashes, stop_hash) = self.0.end().map_err(GetBlocksMessageDecoderError)?;
+        let (version, locator_hashes, stop_hash) =
+            self.0.end().map_err(GetBlocksMessageDecoderError)?;
         Ok(GetBlocksMessage { version, locator_hashes, stop_hash })
     }
 
@@ -319,11 +327,10 @@ impl encoding::Decodable for GetBlocksMessage {
     type Decoder = GetBlocksMessageDecoder;
     fn decoder() -> Self::Decoder {
         GetBlocksMessageDecoder(Decoder3::new(
-                ProtocolVersionDecoder::new(),
-                VecDecoder::<BlockHash>::new(),
-                BlockHashDecoder::new(),
-            )
-        )
+            ProtocolVersionDecoder::new(),
+            VecDecoder::<BlockHash>::new(),
+            BlockHashDecoder::new(),
+        ))
     }
 }
 
@@ -331,17 +338,18 @@ impl encoding::Decodable for GetHeadersMessage {
     type Decoder = GetHeadersMessageDecoder;
     fn decoder() -> Self::Decoder {
         GetHeadersMessageDecoder(Decoder3::new(
-                ProtocolVersionDecoder::new(),
-                VecDecoder::<BlockHash>::new(),
-                BlockHashDecoder::new(),
-            )
-        )
+            ProtocolVersionDecoder::new(),
+            VecDecoder::<BlockHash>::new(),
+            BlockHashDecoder::new(),
+        ))
     }
 }
 
 /// An error consensus decoding a [`GetBlocksMessage`].
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GetBlocksMessageDecoderError(<GetBlocksOrHeadersInnerDecoder as encoding::Decoder>::Error);
+pub struct GetBlocksMessageDecoderError(
+    <GetBlocksOrHeadersInnerDecoder as encoding::Decoder>::Error,
+);
 
 impl From<Infallible> for GetBlocksMessageDecoderError {
     fn from(never: Infallible) -> Self { match never {} }
@@ -360,7 +368,9 @@ impl std::error::Error for GetBlocksMessageDecoderError {
 
 /// An error consensus decoding a [`GetHeadersMessage`].
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GetHeadersMessageDecoderError(<GetBlocksOrHeadersInnerDecoder as encoding::Decoder>::Error);
+pub struct GetHeadersMessageDecoderError(
+    <GetBlocksOrHeadersInnerDecoder as encoding::Decoder>::Error,
+);
 
 impl From<Infallible> for GetHeadersMessageDecoderError {
     fn from(never: Infallible) -> Self { match never {} }
diff --git a/p2p/src/message_bloom.rs b/p2p/src/message_bloom.rs
index 6f3d399b..597212d9 100644
--- a/p2p/src/message_bloom.rs
+++ b/p2p/src/message_bloom.rs
@@ -11,7 +11,10 @@ use core::fmt;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use bitcoin::consensus::{encode, Decodable, Encodable, ReadExt};
-use encoding::{ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder4, Encoder2, Encoder3};
+use encoding::{
+    ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder4,
+    Encoder2, Encoder3,
+};
 use internals::write_err;
 use io::{BufRead, Write};
 
@@ -51,7 +54,7 @@ impl encoding::Encodable for FilterLoad {
         FilterLoadEncoder(Encoder2::new(
             Encoder2::new(
                 CompactSizeEncoder::new(self.filter.len()),
-                BytesEncoder::without_length_prefix(&self.filter)
+                BytesEncoder::without_length_prefix(&self.filter),
             ),
             Encoder3::new(
                 ArrayEncoder::without_length_prefix(self.hash_funcs.to_le_bytes()),
@@ -62,7 +65,8 @@ impl encoding::Encodable for FilterLoad {
     }
 }
 
-type FilterLoadInnerDecoder = Decoder4<ByteVecDecoder, ArrayDecoder<4>, ArrayDecoder<4>, BloomFlagsDecoder>;
+type FilterLoadInnerDecoder =
+    Decoder4<ByteVecDecoder, ArrayDecoder<4>, ArrayDecoder<4>, BloomFlagsDecoder>;
 
 /// The decoder for the [`FilterLoad`] message.
 pub struct FilterLoadDecoder(FilterLoadInnerDecoder);
@@ -83,7 +87,7 @@ impl encoding::Decoder for FilterLoadDecoder {
             filter,
             hash_funcs: u32::from_le_bytes(hash_funcs),
             tweak: u32::from_le_bytes(tweak),
-            flags
+            flags,
         })
     }
 
@@ -95,14 +99,12 @@ impl encoding::Decodable for FilterLoad {
     type Decoder = FilterLoadDecoder;
 
     fn decoder() -> Self::Decoder {
-        FilterLoadDecoder(
-            Decoder4::new(
-                ByteVecDecoder::new(),
-                ArrayDecoder::new(),
-                ArrayDecoder::new(),
-                BloomFlags::decoder(),
-            )
-        )
+        FilterLoadDecoder(Decoder4::new(
+            ByteVecDecoder::new(),
+            ArrayDecoder::new(),
+            ArrayDecoder::new(),
+            BloomFlags::decoder(),
+        ))
     }
 }
 
@@ -147,13 +149,11 @@ impl encoding::Encodable for BloomFlags {
     type Encoder<'e> = BloomFlagsEncoder;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        BloomFlagsEncoder(ArrayEncoder::without_length_prefix(
-         [match self {
-                Self::None => 0,
-                Self::All => 1,
-                Self::PubkeyOnly => 2,
-            }]
-        ))
+        BloomFlagsEncoder(ArrayEncoder::without_length_prefix([match self {
+            Self::None => 0,
+            Self::All => 1,
+            Self::PubkeyOnly => 2,
+        }]))
     }
 }
 
@@ -163,7 +163,9 @@ type BloomFlagsInnerDecoder = ArrayDecoder<1>;
 pub struct BloomFlagsDecoder(BloomFlagsInnerDecoder);
 
 impl BloomFlagsDecoder {
-    fn err_from_inner(inner: <ArrayDecoder<1> as encoding::Decoder>::Error) -> BloomFlagsDecoderError {
+    fn err_from_inner(
+        inner: <ArrayDecoder<1> as encoding::Decoder>::Error,
+    ) -> BloomFlagsDecoderError {
         BloomFlagsDecoderError::Decoder(inner)
     }
 }
@@ -196,9 +198,7 @@ impl encoding::Decoder for BloomFlagsDecoder {
 impl encoding::Decodable for BloomFlags {
     type Decoder = BloomFlagsDecoder;
 
-    fn decoder() -> Self::Decoder {
-        BloomFlagsDecoder(ArrayDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { BloomFlagsDecoder(ArrayDecoder::new()) }
 }
 
 /// An error occurring when decoding a [`BloomFlags`].
diff --git a/p2p/src/message_network.rs b/p2p/src/message_network.rs
index 4a5407d2..b241b2db 100644
--- a/p2p/src/message_network.rs
+++ b/p2p/src/message_network.rs
@@ -15,7 +15,10 @@ use core::fmt;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use bitcoin::consensus::{encode, Decodable, Encodable, ReadExt, WriteExt};
-use encoding::{ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder4, Encoder2, Encoder4};
+use encoding::{
+    ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder4,
+    Encoder2, Encoder4,
+};
 use hashes::sha256d;
 use internals::write_err;
 use io::{BufRead, Write};
@@ -402,9 +405,7 @@ impl encoding::Decoder for RejectReasonDecoder {
 impl encoding::Decodable for RejectReason {
     type Decoder = RejectReasonDecoder;
 
-    fn decoder() -> Self::Decoder {
-        RejectReasonDecoder(ArrayDecoder::new())
-    }
+    fn decoder() -> Self::Decoder { RejectReasonDecoder(ArrayDecoder::new()) }
 }
 
 /// Errors occuring when decoding a [`RejectReason`].
@@ -491,24 +492,23 @@ impl encoding::Encodable for Reject {
     type Encoder<'e> = RejectEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        RejectEncoder(
-            Encoder4::new(
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.message.len()),
-                    BytesEncoder::without_length_prefix(self.message.as_bytes())
-                ),
-                self.ccode.encoder(),
-                Encoder2::new(
-                    CompactSizeEncoder::new(self.reason.len()),
-                    BytesEncoder::without_length_prefix(self.reason.as_bytes())
-                ),
-                ArrayEncoder::without_length_prefix(self.hash.to_byte_array()),
-            )
-        )
+        RejectEncoder(Encoder4::new(
+            Encoder2::new(
+                CompactSizeEncoder::new(self.message.len()),
+                BytesEncoder::without_length_prefix(self.message.as_bytes()),
+            ),
+            self.ccode.encoder(),
+            Encoder2::new(
+                CompactSizeEncoder::new(self.reason.len()),
+                BytesEncoder::without_length_prefix(self.reason.as_bytes()),
+            ),
+            ArrayEncoder::without_length_prefix(self.hash.to_byte_array()),
+        ))
     }
 }
 
-type RejectInnerDecoder = Decoder4<ByteVecDecoder, RejectReasonDecoder, ByteVecDecoder, ArrayDecoder<32>>;
+type RejectInnerDecoder =
+    Decoder4<ByteVecDecoder, RejectReasonDecoder, ByteVecDecoder, ArrayDecoder<32>>;
 
 /// The decoder type for a [`Reject`] message.
 pub struct RejectDecoder(RejectInnerDecoder);
@@ -532,12 +532,7 @@ impl encoding::Decoder for RejectDecoder {
             .map_err(|_| RejectDecoderError::InvalidUtf8)
             .map(Cow::Owned)?;
         let hash = sha256d::Hash::from_byte_array(hash);
-        Ok(Reject {
-            message,
-            ccode,
-            reason,
-            hash,
-        })
+        Ok(Reject { message, ccode, reason, hash })
     }
 
     #[inline]
@@ -548,14 +543,12 @@ impl encoding::Decodable for Reject {
     type Decoder = RejectDecoder;
 
     fn decoder() -> Self::Decoder {
-        RejectDecoder(
-            Decoder4::new(
-                ByteVecDecoder::new(),
-                RejectReason::decoder(),
-                ByteVecDecoder::new(),
-                ArrayDecoder::new()
-            )
-        )
+        RejectDecoder(Decoder4::new(
+            ByteVecDecoder::new(),
+            RejectReason::decoder(),
+            ByteVecDecoder::new(),
+            ArrayDecoder::new(),
+        ))
     }
 }
 
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index 5642a28c..1af098ff 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -441,7 +441,8 @@ impl Decoder for WitnessDecoder {
 
                 // Re-encode the length back into the buffer.
                 let encoded_size = CompactSizeEncoder::encoded_size(element_length);
-                let required_len = self.cursor.saturating_add(encoded_size).saturating_add(element_length);
+                let required_len =
+                    self.cursor.saturating_add(encoded_size).saturating_add(element_length);
                 self.reserve_batch(required_len);
                 let encoded_compact_size = crate::compact_size_encode(element_length);
                 self.content[self.cursor..self.cursor + encoded_size]
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 51f20841..64022b90 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1394,12 +1394,7 @@ fn to_btc() {
     assert_eq!(SignedAmount::ONE_SAT.to_btc(), 0.000_000_01);
     assert_eq!(SignedAmount::ZERO.to_btc(), 0.0);
 
-    let amt_pairs = [
-        (200_000_000, 2.0),
-        (50_000_000, 0.5),
-        (100_000, 0.001),
-        (1, 0.000_000_01),
-    ];
+    let amt_pairs = [(200_000_000, 2.0), (50_000_000, 0.5), (100_000, 0.001), (1, 0.000_000_01)];
     for (sats, btc) in amt_pairs {
         assert_eq!(ssat(sats).to_btc(), btc);
         assert_eq!(ssat(-sats).to_btc(), -btc);
@@ -1435,11 +1430,7 @@ fn display_dynamic() {
     for (value, render_str) in format_pairs {
         assert_eq!(sat(value).display_dynamic().to_string(), render_str);
         assert_eq!(ssat(value as i64).display_dynamic().to_string(), render_str);
-        assert_eq!(
-            ssat(-(value as i64)).display_dynamic().to_string(),
-            format!("-{}", render_str),
-        );
-
+        assert_eq!(ssat(-(value as i64)).display_dynamic().to_string(), format!("-{}", render_str),);
     }
 }
 
@@ -1496,11 +1487,7 @@ fn checked_rem_none() {
 #[test]
 fn checked_rem() {
     // Valid remainders return Some
-    let rem_pairs = [
-        (100, 1),
-        (99, 0),
-        (7, 1)
-    ];
+    let rem_pairs = [(100, 1), (99, 0), (7, 1)];
     for (amt, rem) in rem_pairs {
         // SignedAmount +-
         assert_eq!(ssat(amt).checked_rem(3), Some(ssat(rem)));
diff --git a/units/src/locktime/absolute/mod.rs b/units/src/locktime/absolute/mod.rs
index 3a364bea..93c6e8c1 100644
--- a/units/src/locktime/absolute/mod.rs
+++ b/units/src/locktime/absolute/mod.rs
@@ -978,7 +978,8 @@ mod tests {
         let want = Height::from_u32(10).unwrap();
         assert_eq!("10".parse::<Height>().unwrap(), want);
         assert_eq!(Height::try_from("10").unwrap(), want);
-        #[cfg(feature = "alloc")] {
+        #[cfg(feature = "alloc")]
+        {
             assert_eq!(Height::try_from(String::from("10")).unwrap(), want);
             assert_eq!(Height::try_from(Box::<str>::from("10")).unwrap(), want);
         }
@@ -989,7 +990,8 @@ mod tests {
         // Only base-10 values should parse
         assert!("0xab".parse::<Height>().is_err());
         assert!(Height::try_from("0xab").is_err());
-        #[cfg(feature = "alloc")] {
+        #[cfg(feature = "alloc")]
+        {
             assert!(Height::try_from(String::from("0xab")).is_err());
             assert!(Height::try_from(Box::<str>::from("0xab")).is_err());
         }
@@ -1000,7 +1002,8 @@ mod tests {
         // Only integers should parse
         assert!("10.123".parse::<Height>().is_err());
         assert!(Height::try_from("10.123").is_err());
-        #[cfg(feature = "alloc")] {
+        #[cfg(feature = "alloc")]
+        {
             assert!(Height::try_from(String::from("10.123")).is_err());
             assert!(Height::try_from(Box::<str>::from("10.123")).is_err());
         }
diff --git a/units/src/result.rs b/units/src/result.rs
index c3ecec22..d8019760 100644
--- a/units/src/result.rs
+++ b/units/src/result.rs
@@ -502,7 +502,8 @@ mod tests {
     #[test]
     #[should_panic(expected = "test error message")]
     fn mathop_expect_panics_on_error() {
-        NumOpResult::<Amount>::Error(NumOpError::while_doing(MathOp::Add)).expect("test error message");
+        NumOpResult::<Amount>::Error(NumOpError::while_doing(MathOp::Add))
+            .expect("test error message");
     }
 
     #[test]
@@ -515,11 +516,7 @@ mod tests {
         for amount in amounts {
             assert_eq!(NumOpResult::Valid(amount).unwrap(), amount);
         }
-        let weights = [
-            Weight::from_wu(0),
-            Weight::from_wu(16_384_000),
-            Weight::from_wu(u64::MAX),
-        ];
+        let weights = [Weight::from_wu(0), Weight::from_wu(16_384_000), Weight::from_wu(u64::MAX)];
         for weight in weights {
             assert_eq!(NumOpResult::Valid(weight).unwrap(), weight);
         }