2026-01-04 automated rustfmt nightly

Author: Fmt Bot

bitcoin/src/consensus/encode.rs

@@ -351,7 +351,10 @@ impl_int_encodable!(i32, read_i32, emit_i32);
 impl_int_encodable!(i64, read_i64, emit_i64);
 
 /// Returns 1 for 0..=0xFC, 3 for 0xFD..=(2^16-1), 5 for 0x10000..=(2^32-1), and 9 otherwise.
-#[deprecated(since = "0.33.0", note = "use `consensus_encoding::CompactSizeEncoder::encoded_size` instead")]
+#[deprecated(
+    since = "0.33.0",
+    note = "use `consensus_encoding::CompactSizeEncoder::encoded_size` instead"
+)]
 #[inline]
 pub const fn varint_size_u64(v: u64) -> usize {
     const LIMIT: u64 = if core::mem::size_of::<usize>() <= 8 {
@@ -360,15 +363,19 @@ pub const fn varint_size_u64(v: u64) -> usize {
         u64::MAX
     };
 
-    #[allow(unreachable_patterns)] // Disable lint because this match is reachable on < 64 bit platforms
+    #[allow(unreachable_patterns)]
+    // Disable lint because this match is reachable on < 64 bit platforms
     match v {
         0..=LIMIT => encoding::CompactSizeEncoder::encoded_size(v as usize), // cast is ok because we just checked bounds
         _ => encoding::CompactSizeEncoder::encoded_size(usize::MAX),
     }
 }
 
 /// Returns 1 for 0..=0xFC, 3 for 0xFD..=(2^16-1), 5 for 0x10000..=(2^32-1), and 9 otherwise.
-#[deprecated(since = "0.33.0", note = "use `consensus_encoding::CompactSizeEncoder::encoded_size` instead")]
+#[deprecated(
+    since = "0.33.0",
+    note = "use `consensus_encoding::CompactSizeEncoder::encoded_size` instead"
+)]
 #[inline]
 pub fn varint_size(v: impl ToU64) -> usize {
     encoding::CompactSizeEncoder::encoded_size(v.to_u64().try_into().unwrap_or(usize::MAX))

consensus_encoding/src/decode/decoders.rs

@@ -107,10 +107,10 @@ impl Decoder for ByteVecDecoder {
 
     fn end(self) -> Result<Self::Output, Self::Error> {
         use {ByteVecDecoderError as E, ByteVecDecoderErrorInner as Inner};
-        
-        if let Some(ref prefix_decoder) = self.prefix_decoder {  
+
+        if let Some(ref prefix_decoder) = self.prefix_decoder {
             return Err(E(Inner::UnexpectedEof(UnexpectedEofError {
-                missing: prefix_decoder.read_limit(), 
+                missing: prefix_decoder.read_limit(),
             })));
         }
 
@@ -1221,7 +1221,7 @@ mod tests {
         let data = [];
         let _ = decoder.push_bytes(&mut data.as_slice());
         let err = decoder.end().unwrap_err();
-        
+
         if let ByteVecDecoderErrorInner::UnexpectedEof(e) = err.0 {
             assert_eq!(e.missing, 1);
         } else {
@@ -1251,7 +1251,7 @@ mod tests {
         let data = [0xFE];
         let _ = decoder.push_bytes(&mut data.as_slice());
         let err = decoder.end().unwrap_err();
-        
+
         if let ByteVecDecoderErrorInner::UnexpectedEof(e) = err.0 {
             assert_eq!(e.missing, 4);
         } else {
@@ -1266,7 +1266,7 @@ mod tests {
         let data = [0xFF];
         let _ = decoder.push_bytes(&mut data.as_slice());
         let err = decoder.end().unwrap_err();
-        
+
         if let ByteVecDecoderErrorInner::UnexpectedEof(e) = err.0 {
             assert_eq!(e.missing, 8);
         } else {

consensus_encoding/src/encode/encoders.rs

@@ -11,10 +11,10 @@
 //! For implementing these newtypes, we provide the [`encoder_newtype`] macro.
 //!
 
-use super::{Encodable, Encoder};
-
 use internals::array_vec::ArrayVec;
 
+use super::{Encodable, Encoder};
+
 /// The maximum length of a compact size encoding.
 const SIZE: usize = 9;
 
@@ -231,9 +231,7 @@ impl CompactSizeEncoder {
     /// values. In such cases we will ignore the passed value and encode [`u64::MAX`].
     /// But even on such exotic systems, we expect users to pass the length of an
     /// in-memory object, meaning that such large values are impossible to obtain.
-    pub fn new(value: usize) -> Self {
-        Self { buf: Some(Self::encode(value)) }
-    }
+    pub fn new(value: usize) -> Self { Self { buf: Some(Self::encode(value)) } }
 
     /// Returns the number of bytes used to encode this `CompactSize` value.
     ///

primitives/src/block.rs

@@ -1187,20 +1187,18 @@ mod tests {
         };
 
         let block: u32 = 741_521;
-        let transactions = vec![
-            Transaction {
-                version: crate::transaction::Version::ONE,
-                lock_time: units::absolute::LockTime::from_height(block).unwrap(),
-                inputs: vec![crate::transaction::TxIn {
-                    previous_output: crate::transaction::OutPoint::COINBASE_PREVOUT,
-                    // Coinbase scriptSig must be 2-100 bytes
-                    script_sig: crate::script::ScriptSigBuf::from_bytes(vec![0x51, 0x51]),
-                    sequence: crate::sequence::Sequence::MAX,
-                    witness: crate::witness::Witness::new(),
-                }],
-                outputs: Vec::new(),
-            },
-        ];
+        let transactions = vec![Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: units::absolute::LockTime::from_height(block).unwrap(),
+            inputs: vec![crate::transaction::TxIn {
+                previous_output: crate::transaction::OutPoint::COINBASE_PREVOUT,
+                // Coinbase scriptSig must be 2-100 bytes
+                script_sig: crate::script::ScriptSigBuf::from_bytes(vec![0x51, 0x51]),
+                sequence: crate::sequence::Sequence::MAX,
+                witness: crate::witness::Witness::new(),
+            }],
+            outputs: Vec::new(),
+        }];
         let original_block = Block::new_unchecked(header, transactions);
 
         // Encode + decode the block

primitives/src/transaction.rs

@@ -716,9 +716,12 @@ impl fmt::Display for TransactionDecoderError {
             E::NoWitnesses => write!(f, "non-empty Segwit transaction with no witnesses"),
             E::LockTime(ref e) => write_err!(f, "transaction decoder error"; e),
             E::EarlyEnd(s) => write!(f, "early end of transaction (still decoding {})", s),
-            E::NullPrevoutInNonCoinbase(index) => write!(f, "null prevout in non-coinbase transaction at input {}", index),
-            E::CoinbaseScriptSigTooSmall(len) => write!(f, "coinbase scriptSig too small: {} bytes (min 2)", len),
-            E::CoinbaseScriptSigTooLarge(len) => write!(f, "coinbase scriptSig too large: {} bytes (max 100)", len),
+            E::NullPrevoutInNonCoinbase(index) =>
+                write!(f, "null prevout in non-coinbase transaction at input {}", index),
+            E::CoinbaseScriptSigTooSmall(len) =>
+                write!(f, "coinbase scriptSig too small: {} bytes (min 2)", len),
+            E::CoinbaseScriptSigTooLarge(len) =>
+                write!(f, "coinbase scriptSig too large: {} bytes (max 100)", len),
         }
     }
 }
@@ -2240,7 +2243,10 @@ mod tests {
         decoder.push_bytes(&mut slice).unwrap();
         let err = decoder.end().expect_err("null prevout in non-coinbase tx should be rejected");
 
-        assert_eq!(err, TransactionDecoderError(TransactionDecoderErrorInner::NullPrevoutInNonCoinbase(0)));
+        assert_eq!(
+            err,
+            TransactionDecoderError(TransactionDecoderErrorInner::NullPrevoutInNonCoinbase(0))
+        );
     }
 
     #[test]
@@ -2256,7 +2262,10 @@ mod tests {
         decoder.push_bytes(&mut slice).unwrap();
         let err = decoder.end().expect_err("coinbase with 1-byte scriptSig should be rejected");
 
-        assert_eq!(err, TransactionDecoderError(TransactionDecoderErrorInner::CoinbaseScriptSigTooSmall(1)));
+        assert_eq!(
+            err,
+            TransactionDecoderError(TransactionDecoderErrorInner::CoinbaseScriptSigTooSmall(1))
+        );
     }
 
     #[test]
@@ -2272,7 +2281,10 @@ mod tests {
         decoder.push_bytes(&mut slice).unwrap();
         let err = decoder.end().expect_err("coinbase with 101-byte scriptSig should be rejected");
 
-        assert_eq!(err, TransactionDecoderError(TransactionDecoderErrorInner::CoinbaseScriptSigTooLarge(101)));
+        assert_eq!(
+            err,
+            TransactionDecoderError(TransactionDecoderErrorInner::CoinbaseScriptSigTooLarge(101))
+        );
     }
 
     #[test]

primitives/src/witness.rs

@@ -1093,15 +1093,15 @@ mod test {
     #[test]
     fn witness_size() {
         let mut witness = Witness::new();
-        let want = 1;           // Number of elements compact size encoded.
+        let want = 1; // Number of elements compact size encoded.
         assert_eq!(witness.size(), want);
 
         witness.push([1, 2, 3]);
-        let want = 5;           // 1 + 1 + 3
+        let want = 5; // 1 + 1 + 3
         assert_eq!(witness.size(), want);
 
         witness.push([4, 5]);
-        let want = 8;           // 5 + 1 + 2
+        let want = 8; // 5 + 1 + 2
         assert_eq!(witness.size(), want);
     }
 

units/src/block.rs

@@ -597,11 +597,10 @@ impl<'a> core::iter::Sum<&'a Self> for BlockMtpInterval {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-
     #[cfg(feature = "encoding")]
     use encoding::{Decodable as _, Decoder as _, UnexpectedEofError};
 
+    use super::*;
     use crate::relative::{NumberOf512Seconds, TimeOverflowError};
 
     #[test]
@@ -756,7 +755,6 @@ mod tests {
         );
     }
 
-
     #[test]
     fn block_mtp_interval_to_relative_mtp_ceil() {
         let time = NumberOf512Seconds::from_512_second_intervals(0);

units/src/sequence.rs

@@ -392,12 +392,12 @@ mod tests {
     #[cfg(feature = "alloc")]
     use alloc::format;
 
-    use super::*;
-
-    #[cfg(feature = "encoding")]
-    use encoding::{Decodable as _, Decoder as _};
     #[cfg(all(feature = "encoding", feature = "alloc"))]
     use encoding::UnexpectedEofError;
+    #[cfg(feature = "encoding")]
+    use encoding::{Decodable as _, Decoder as _};
+
+    use super::*;
 
     const MAXIMUM_ENCODABLE_SECONDS: u32 = u16::MAX as u32 * 512;