Merge rust-bitcoin#4242: Automated nightly rustfmt (2025-03-16)

apoelstra · apoelstra · commit cfccd389a9bc · 2025-03-18T12:27:46.000Z
a74e08a 2025-03-16 automated rustfmt nightly (Fmt Bot) Pull request description: Automated nightly `rustfmt` changes by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action ACKs for top commit: tcharding: ACK a74e08a apoelstra: ACK a74e08a; successfully ran local tests Tree-SHA512: ca233e517c6734181e86940ba92bde1c2b138b66ff27e80a10f98d5ae1aac5ac73ec46633bba2a94ba143d01602764bfe6ffad2378cdf8bbfe4210be620113ea
diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
@@ -413,7 +413,7 @@ mod test {
     use crate::merkle_tree::TxMerkleNode;
     use crate::transaction::OutPointExt;
     use crate::{
-        transaction, Amount, BlockChecked, CompactTarget, OutPoint, ScriptBuf, Sequence, BlockTime,
+        transaction, Amount, BlockChecked, BlockTime, CompactTarget, OutPoint, ScriptBuf, Sequence,
         TxIn, TxOut, Txid, Witness,
     };
 
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
@@ -16,7 +16,7 @@ use crate::opcodes::all::*;
 use crate::pow::CompactTarget;
 use crate::transaction::{self, OutPoint, Transaction, TxIn, TxOut};
 use crate::witness::Witness;
-use crate::{script, Amount, BlockHash, Sequence, TestnetVersion, BlockTime};
+use crate::{script, Amount, BlockHash, BlockTime, Sequence, TestnetVersion};
 
 /// How many seconds between blocks we expect on average.
 pub const TARGET_BLOCK_SPACING: u32 = 600;
diff --git a/bitcoin/src/blockdata/mod.rs b/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.
diff --git a/bitcoin/src/blockdata/script/tests.rs b/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]
diff --git a/bitcoin/src/crypto/key.rs b/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))
     }
diff --git a/bitcoin/src/lib.rs b/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]
diff --git a/bitcoin/src/psbt/mod.rs b/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,
diff --git a/bitcoin/src/psbt/serialize.rs b/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)
     }
 }
 
diff --git a/bitcoin/src/taproot/merkle_branch.rs b/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))
         }
diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
@@ -109,8 +109,7 @@ fn serde_regression_txin() {
 
 #[test]
 fn serde_regression_txout() {
-    let txout =
-        TxOut { value: Amount::MAX, script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]) };
+    let txout = TxOut { value: Amount::MAX, script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]) };
     let got = serialize(&txout).unwrap();
     let want = include_bytes!("data/serde/txout_bincode") as &[_];
     assert_eq!(got, want)
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs b/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
@@ -1,6 +1,5 @@
-use honggfuzz::fuzz;
-
 use bitcoin_fuzz::fuzz_utils::consume_random_bytes;
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
     let mut new_data = data;
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -2,9 +2,8 @@ use bitcoin::address::Address;
 use bitcoin::consensus::encode;
 use bitcoin::script::{self, ScriptExt as _};
 use bitcoin::{FeeRate, Network};
-use honggfuzz::fuzz;
-
 use bitcoin_fuzz::fuzz_utils::{consume_random_bytes, consume_u64};
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
     let mut new_data = data;
diff --git a/hashes/src/ripemd160/crypto.rs b/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")]
diff --git a/hashes/src/sha1/crypto.rs b/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 {
diff --git a/hashes/src/sha256/crypto.rs b/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)]
diff --git a/hashes/src/sha256/mod.rs b/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);
         }
 
diff --git a/hashes/src/sha512/crypto.rs b/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)]
diff --git a/internals/src/slice.rs b/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)]
diff --git a/primitives/src/opcodes.rs b/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;
 
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
@@ -670,7 +670,10 @@ mod tests {
             witness: Witness::new(),
         };
 
-        let txout = TxOut { value: Amount::from_sat(123_456_789).unwrap(), script_pubkey: ScriptBuf::new() };
+        let txout = TxOut {
+            value: Amount::from_sat(123_456_789).unwrap(),
+            script_pubkey: ScriptBuf::new(),
+        };
 
         let tx_orig = Transaction {
             version: Version::ONE,
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
@@ -355,8 +355,7 @@ impl<'de> serde::Deserialize<'de> for Witness {
                 self,
                 mut a: A,
             ) -> Result<Self::Value, A::Error> {
-                use hex::FromHex;
-                use hex::HexToBytesError as E;
+                use hex::{FromHex, HexToBytesError as E};
                 use serde::de::{self, Unexpected};
 
                 let mut ret = match a.size_hint() {
@@ -366,16 +365,17 @@ impl<'de> serde::Deserialize<'de> for Witness {
 
                 while let Some(elem) = a.next_element::<String>()? {
                     let vec = Vec::<u8>::from_hex(&elem).map_err(|e| match e {
-                        E::InvalidChar(ref e) => match core::char::from_u32(e.invalid_char().into()) {
-                            Some(c) => de::Error::invalid_value(
-                                Unexpected::Char(c),
-                                &"a valid hex character",
-                            ),
-                            None => de::Error::invalid_value(
-                                Unexpected::Unsigned(e.invalid_char().into()),
-                                &"a valid hex character",
-                            ),
-                        },
+                        E::InvalidChar(ref e) =>
+                            match core::char::from_u32(e.invalid_char().into()) {
+                                Some(c) => de::Error::invalid_value(
+                                    Unexpected::Char(c),
+                                    &"a valid hex character",
+                                ),
+                                None => de::Error::invalid_value(
+                                    Unexpected::Unsigned(e.invalid_char().into()),
+                                    &"a valid hex character",
+                                ),
+                            },
                         E::OddLengthString(ref e) =>
                             de::Error::invalid_length(e.length(), &"an even length string"),
                     })?;
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
@@ -115,7 +115,7 @@ impl Denomination {
             Denomination::MicroBitcoin => -2,
             Denomination::Bit => -2,
             Denomination::Satoshi => 0,
-            Denomination::_DoNotUse(infallible) => match infallible {}
+            Denomination::_DoNotUse(infallible) => match infallible {},
         }
     }
 
@@ -128,7 +128,7 @@ impl Denomination {
             Denomination::MicroBitcoin => "uBTC",
             Denomination::Bit => "bits",
             Denomination::Satoshi => "satoshi",
-            Denomination::_DoNotUse(infallible) => match infallible {}
+            Denomination::_DoNotUse(infallible) => match infallible {},
         }
     }
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
diff --git a/units/tests/api.rs b/units/tests/api.rs

Original file line number	Diff line number	Diff line change
`@@ -462,7 +462,7 @@ impl PrivateKey {`
`462`	`462`	`/// Deserializes a private key from a byte array.`
`463`	`463`	`pub fn from_byte_array(`
`464`	`464`	`data: [u8; 32],`
`465`		`- network: impl Into<NetworkKind>`
	`465`	`+ network: impl Into<NetworkKind>,`
`466`	`466`	`) -> Result<PrivateKey, secp256k1::Error> {`
`467`	`467`	`Ok(PrivateKey::new(secp256k1::SecretKey::from_byte_array(&data)?, network))`
`468`	`468`	`}`
Original file line number	Diff line number	Diff line change
`@@ -260,10 +260,8 @@ impl Serialize for XOnlyPublicKey {`
`260`	`260`
`261`	`261`	`impl Deserialize for XOnlyPublicKey {`
`262`	`262`	`fn deserialize(bytes: &[u8]) -> Result<Self, Error> {`
`263`		`- XOnlyPublicKey::from_byte_array(`
`264`		`- bytes.try_into().map_err(\|_\| Error::InvalidXOnlyPublicKey)?,`
`265`		`- )`
`266`		`- .map_err(\|_\| Error::InvalidXOnlyPublicKey)`
	`263`	`+ XOnlyPublicKey::from_byte_array(bytes.try_into().map_err(\|_\| Error::InvalidXOnlyPublicKey)?)`
	`264`	`+ .map_err(\|_\| Error::InvalidXOnlyPublicKey)`
`267`	`265`	`}`
`268`	`266`	`}`
`269`	`267`