2025-03-09 automated rustfmt nightly

Author: Fmt Bot

bitcoin/src/blockdata/mod.rs

@@ -21,10 +21,10 @@ pub use self::{
 
 /// Implements `FeeRate` and assoctiated features.
 pub mod fee_rate {
-    /// Re-export everything from the [`units::fee_rate`] module.
-    pub use units::fee_rate::FeeRate;
     #[cfg(feature = "serde")]
     pub use units::fee_rate::serde;
+    /// Re-export everything from the [`units::fee_rate`] module.
+    pub use units::fee_rate::FeeRate;
 }
 
 /// Provides absolute and relative locktimes.

bitcoin/src/blockdata/script/tests.rs

@@ -8,7 +8,7 @@ use crate::address::script_pubkey::{
 };
 use crate::consensus::encode::{deserialize, serialize};
 use crate::crypto::key::{PublicKey, XOnlyPublicKey};
-use crate::{Amount, FeeRate, opcodes};
+use crate::{opcodes, Amount, FeeRate};
 
 #[test]
 #[rustfmt::skip]

bitcoin/src/crypto/key.rs

@@ -462,7 +462,7 @@ impl PrivateKey {
     /// Deserializes a private key from a byte array.
     pub fn from_byte_array(
         data: [u8; 32],
-        network: impl Into<NetworkKind>
+        network: impl Into<NetworkKind>,
     ) -> Result<PrivateKey, secp256k1::Error> {
         Ok(PrivateKey::new(secp256k1::SecretKey::from_byte_array(&data)?, network))
     }

bitcoin/src/lib.rs

@@ -164,9 +164,7 @@ pub use crate::{
     blockdata::script::witness_program::{self, WitnessProgram},
     blockdata::script::witness_version::{self, WitnessVersion},
     // These modules also re-export all the respective `primitives` types.
-    blockdata::{
-        block, constants, fee_rate, locktime, script, transaction, weight, witness,
-    },
+    blockdata::{block, constants, fee_rate, locktime, script, transaction, weight, witness},
 };
 
 #[rustfmt::skip]

bitcoin/src/psbt/mod.rs

@@ -135,7 +135,7 @@ impl Psbt {
     /// An alias for [`extract_tx_fee_rate_limit`].
     ///
     /// [`extract_tx_fee_rate_limit`]: Psbt::extract_tx_fee_rate_limit
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx(self) -> Result<Transaction, ExtractTxError> {
         self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
     }
@@ -147,7 +147,7 @@ impl Psbt {
     /// [`ExtractTxError`] variants will contain either the [`Psbt`] itself or the [`Transaction`]
     /// that was extracted. These can be extracted from the Errors in order to recover.
     /// See the error documentation for info on the variants. In general, it covers large fees.
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx_fee_rate_limit(self) -> Result<Transaction, ExtractTxError> {
         self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
     }
@@ -159,7 +159,7 @@ impl Psbt {
     /// See [`extract_tx`].
     ///
     /// [`extract_tx`]: Psbt::extract_tx
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx_with_fee_rate_limit(
         self,
         max_fee_rate: FeeRate,
@@ -187,7 +187,7 @@ impl Psbt {
     }
 
     #[inline]
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     fn internal_extract_tx_with_fee_rate_limit(
         self,
         max_fee_rate: FeeRate,

bitcoin/src/psbt/serialize.rs

@@ -260,10 +260,8 @@ impl Serialize for XOnlyPublicKey {
 
 impl Deserialize for XOnlyPublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        XOnlyPublicKey::from_byte_array(
-            bytes.try_into().map_err(|_| Error::InvalidXOnlyPublicKey)?,
-        )
-        .map_err(|_| Error::InvalidXOnlyPublicKey)
+        XOnlyPublicKey::from_byte_array(bytes.try_into().map_err(|_| Error::InvalidXOnlyPublicKey)?)
+            .map_err(|_| Error::InvalidXOnlyPublicKey)
     }
 }
 

bitcoin/src/taproot/merkle_branch.rs

@@ -52,11 +52,7 @@ impl TaprootMerkleBranch {
         } else if node_hashes.len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(InvalidMerkleTreeDepthError(sl.len() / TAPROOT_CONTROL_NODE_SIZE).into())
         } else {
-            let inner = node_hashes
-                .iter()
-                .copied()
-                .map(TapNodeHash::from_byte_array)
-                .collect();
+            let inner = node_hashes.iter().copied().map(TapNodeHash::from_byte_array).collect();
 
             Ok(TaprootMerkleBranch(inner))
         }

hashes/src/ripemd160/crypto.rs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, BLOCK_SIZE};
 
 #[cfg(feature = "small-hash")]

hashes/src/sha1/crypto.rs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, BLOCK_SIZE};
 
 impl HashEngine {

hashes/src/sha256/crypto.rs

@@ -6,6 +6,7 @@ use core::arch::x86::*;
 use core::arch::x86_64::*;
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, Midstate, BLOCK_SIZE};
 
 #[allow(non_snake_case)]

hashes/src/sha256/mod.rs

@@ -9,6 +9,7 @@ mod crypto;
 mod tests;
 
 use core::{cmp, convert, fmt};
+
 use internals::slice::SliceExt;
 
 use crate::{incomplete_block_len, sha256d, HashEngine as _};
@@ -80,7 +81,8 @@ impl HashEngine {
     /// Please see docs on [`Midstate`] before using this function.
     pub fn from_midstate(midstate: Midstate) -> HashEngine {
         let mut ret = [0; 8];
-        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate.as_ref().bitcoin_as_chunks().0) {
+        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate.as_ref().bitcoin_as_chunks().0)
+        {
             *ret_val = u32::from_be_bytes(*midstate_bytes);
         }
 

hashes/src/sha512/crypto.rs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, BLOCK_SIZE};
 
 #[allow(non_snake_case)]

internals/src/slice.rs

@@ -23,7 +23,9 @@ pub trait SliceExt {
     /// let mut slice = [1, 2, 3];
     /// let fail = slice.as_chunks_mut::<0>();
     /// ```
-    fn bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item]);
+    fn bitcoin_as_chunks_mut<const N: usize>(
+        &mut self,
+    ) -> (&mut [[Self::Item; N]], &mut [Self::Item]);
 }
 
 impl<T> SliceExt for [T] {
@@ -40,11 +42,15 @@ impl<T> SliceExt for [T] {
         // we're merely casting, so no aliasing issues here
         // arrays of T have same alignment as T
         // the resulting slice points within the obtained slice as was computed above
-        let left = unsafe { core::slice::from_raw_parts(left.as_ptr().cast::<[Self::Item; N]>(), chunks_count) };
+        let left = unsafe {
+            core::slice::from_raw_parts(left.as_ptr().cast::<[Self::Item; N]>(), chunks_count)
+        };
         (left, right)
     }
 
-    fn bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item]) {
+    fn bitcoin_as_chunks_mut<const N: usize>(
+        &mut self,
+    ) -> (&mut [[Self::Item; N]], &mut [Self::Item]) {
         #[allow(clippy::let_unit_value)]
         let _ = Hack::<N>::IS_NONZERO;
 
@@ -55,15 +61,22 @@ impl<T> SliceExt for [T] {
         // we're merely casting, so no aliasing issues here
         // arrays of T have same alignment as T
         // the resulting slice points within the obtained slice as was computed above
-        let left = unsafe { core::slice::from_raw_parts_mut(left.as_mut_ptr().cast::<[Self::Item; N]>(), chunks_count) };
+        let left = unsafe {
+            core::slice::from_raw_parts_mut(
+                left.as_mut_ptr().cast::<[Self::Item; N]>(),
+                chunks_count,
+            )
+        };
         (left, right)
     }
 }
 
 struct Hack<const N: usize>;
 
 impl<const N: usize> Hack<N> {
-    const IS_NONZERO: () = { assert!(N != 0); };
+    const IS_NONZERO: () = {
+        assert!(N != 0);
+    };
 }
 
 #[cfg(test)]

primitives/src/opcodes.rs

@@ -6,7 +6,7 @@
 //! all of the opcodes for that language.
 
 #![allow(non_camel_case_types)]
-#![allow(dead_code)]            // This module is private and is duplicated in `bitcoin`.
+#![allow(dead_code)] // This module is private and is duplicated in `bitcoin`.
 
 use core::fmt;
 

units/src/amount/mod.rs

@@ -113,7 +113,7 @@ impl Denomination {
             Denomination::MicroBitcoin => -2,
             Denomination::Bit => -2,
             Denomination::Satoshi => 0,
-            Denomination::_DoNotUse(infallible) => match infallible {}
+            Denomination::_DoNotUse(infallible) => match infallible {},
         }
     }
 
@@ -126,7 +126,7 @@ impl Denomination {
             Denomination::MicroBitcoin => "uBTC",
             Denomination::Bit => "bits",
             Denomination::Satoshi => "satoshi",
-            Denomination::_DoNotUse(infallible) => match infallible {}
+            Denomination::_DoNotUse(infallible) => match infallible {},
         }
     }
 

units/src/amount/tests.rs

@@ -1015,11 +1015,19 @@ fn sum_amounts() {
     assert_eq!([].iter().sum::<NumOpResult<Amount>>(), Amount::ZERO.into());
     assert_eq!([].iter().sum::<NumOpResult<SignedAmount>>(), SignedAmount::ZERO.into());
 
-    let results = [NumOpResult::Valid(sat(42)), NumOpResult::Valid(sat(1337)), NumOpResult::Valid(sat(21))];
+    let results =
+        [NumOpResult::Valid(sat(42)), NumOpResult::Valid(sat(1337)), NumOpResult::Valid(sat(21))];
     assert_eq!(results.iter().sum::<NumOpResult<Amount>>(), NumOpResult::Valid(sat(1400)));
 
-    let signed_results = [NumOpResult::Valid(ssat(42)), NumOpResult::Valid(ssat(1337)), NumOpResult::Valid(ssat(21))];
-    assert_eq!(signed_results.iter().sum::<NumOpResult<SignedAmount>>(), NumOpResult::Valid(ssat(1400)));
+    let signed_results = [
+        NumOpResult::Valid(ssat(42)),
+        NumOpResult::Valid(ssat(1337)),
+        NumOpResult::Valid(ssat(21)),
+    ];
+    assert_eq!(
+        signed_results.iter().sum::<NumOpResult<SignedAmount>>(),
+        NumOpResult::Valid(ssat(1400))
+    );
 
     let amounts = [sat(42), sat(1337), sat(21)];
     assert_eq!(
@@ -1303,9 +1311,7 @@ fn unsigned_amount_div_by_amount() {
 
 #[test]
 #[should_panic(expected = "attempt to divide by zero")]
-fn unsigned_amount_div_by_amount_zero() {
-    let _ = Amount::from_sat(1897) / Amount::ZERO;
-}
+fn unsigned_amount_div_by_amount_zero() { let _ = Amount::from_sat(1897) / Amount::ZERO; }
 
 #[test]
 fn signed_amount_div_by_amount() {
@@ -1321,9 +1327,7 @@ fn signed_amount_div_by_amount() {
 
 #[test]
 #[should_panic(expected = "attempt to divide by zero")]
-fn signed_amount_div_by_amount_zero() {
-    let _ = SignedAmount::from_sat(1897) / SignedAmount::ZERO;
-}
+fn signed_amount_div_by_amount_zero() { let _ = SignedAmount::from_sat(1897) / SignedAmount::ZERO; }
 
 #[test]
 fn check_const() {