tcharding · github-actions · Jun 8, 2025
diff --git a/bitcoin/examples/handshake.rs b/bitcoin/examples/handshake.rs
@@ -25,8 +25,7 @@ fn main() {
 
     let version_message = build_version_message(address);
 
-    let first_message =
-        message::RawNetworkMessage::new(Magic::BITCOIN, version_message);
+    let first_message = message::RawNetworkMessage::new(Magic::BITCOIN, version_message);
 
     if let Ok(mut stream) = TcpStream::connect(address) {
         // Send the message

diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
@@ -1099,12 +1099,7 @@ mod tests {
 
     #[test]
     fn parse_derivation_path_invalid_format() {
-        let invalid_paths = [
-            "n/0'/0",
-            "4/m/5",
-            "//3/0'",
-            "0h/0x",
-        ];
+        let invalid_paths = ["n/0'/0", "4/m/5", "//3/0'", "0h/0x"];
         for path in &invalid_paths {
             assert!(matches!(
                 path.parse::<DerivationPath>(),
@@ -1140,24 +1135,33 @@ mod tests {
         let valid_paths = [
             ("0'", vec![ChildNumber::ZERO_HARDENED]),
             ("0'/1", vec![ChildNumber::ZERO_HARDENED, ChildNumber::ONE_NORMAL]),
-            ("0h/1/2'", vec![
-                ChildNumber::ZERO_HARDENED,
-                ChildNumber::ONE_NORMAL,
-                ChildNumber::from_hardened_idx(2).unwrap(),
-            ]),
-            ("0'/1/2h/2", vec![
-                ChildNumber::ZERO_HARDENED,
-                ChildNumber::ONE_NORMAL,
-                ChildNumber::from_hardened_idx(2).unwrap(),
-                ChildNumber::from_normal_idx(2).unwrap(),
-            ]),
-            ("0'/1/2'/2/1000000000", vec![
-                ChildNumber::ZERO_HARDENED,
-                ChildNumber::ONE_NORMAL,
-                ChildNumber::from_hardened_idx(2).unwrap(),
-                ChildNumber::from_normal_idx(2).unwrap(),
-                ChildNumber::from_normal_idx(1000000000).unwrap(),
-            ]),
+            (
+                "0h/1/2'",
+                vec![
+                    ChildNumber::ZERO_HARDENED,
+                    ChildNumber::ONE_NORMAL,
+                    ChildNumber::from_hardened_idx(2).unwrap(),
+                ],
+            ),
+            (
+                "0'/1/2h/2",
+                vec![
+                    ChildNumber::ZERO_HARDENED,
+                    ChildNumber::ONE_NORMAL,
+                    ChildNumber::from_hardened_idx(2).unwrap(),
+                    ChildNumber::from_normal_idx(2).unwrap(),
+                ],
+            ),
+            (
+                "0'/1/2'/2/1000000000",
+                vec![
+                    ChildNumber::ZERO_HARDENED,
+                    ChildNumber::ONE_NORMAL,
+                    ChildNumber::from_hardened_idx(2).unwrap(),
+                    ChildNumber::from_normal_idx(2).unwrap(),
+                    ChildNumber::from_normal_idx(1000000000).unwrap(),
+                ],
+            ),
         ];
         for (path, expected) in valid_paths {
             // Access the inner private field so we don't have to clone expected.

diff --git a/bitcoin/src/p2p/address.rs b/bitcoin/src/p2p/address.rs
@@ -138,7 +138,6 @@ pub enum AddrV2 {
     Unknown(u8, Vec<u8>),
 }
 
-
 impl TryFrom<AddrV2> for IpAddr {
     type Error = AddrV2ToIpAddrError;
 
@@ -443,7 +442,8 @@ mod test {
     use hex_lit::hex;
 
     use super::*;
-    use crate::{consensus::encode::{deserialize, serialize}, p2p::message::AddrV2Payload};
+    use crate::consensus::encode::{deserialize, serialize};
+    use crate::p2p::message::AddrV2Payload;
 
     #[test]
     fn serialize_address() {

diff --git a/bitcoin/src/p2p/deser.rs b/bitcoin/src/p2p/deser.rs
@@ -27,7 +27,8 @@ macro_rules! impl_vec_wrapper {
                 // reallocate.
                 // Note: OOM protection relies on reader eventually running out of
                 // data to feed us.
-                let max_capacity = crate::consensus::encode::MAX_VEC_SIZE / 4 / core::mem::size_of::<$type>();
+                let max_capacity =
+                    crate::consensus::encode::MAX_VEC_SIZE / 4 / core::mem::size_of::<$type>();
                 let mut ret = Vec::with_capacity(core::cmp::min(len as usize, max_capacity));
                 for _ in 0..len {
                     ret.push(Decodable::consensus_decode_from_finite_reader(r)?);

diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs
@@ -14,12 +14,12 @@ use io::{BufRead, Write};
 use crate::consensus::encode::{self, CheckedData, Decodable, Encodable, ReadExt, WriteExt};
 use crate::merkle_tree::MerkleBlock;
 use crate::p2p::address::{AddrV2Message, Address};
+use crate::p2p::deser::impl_vec_wrapper;
 use crate::p2p::{
     message_blockdata, message_bloom, message_compact_blocks, message_filter, message_network,
     Magic,
 };
 use crate::prelude::{Box, Cow, String, ToOwned, Vec};
-use crate::p2p::deser::impl_vec_wrapper;
 use crate::{block, consensus, transaction};
 
 /// The maximum number of [super::message_blockdata::Inventory] items in an `inv` message.
@@ -755,12 +755,12 @@ mod test {
                 45,
                 Address::new(&([123, 255, 000, 100], 833).into(), ServiceFlags::NETWORK),
             )])),
-            NetworkMessage::Inv(InventoryPayload(vec![Inventory::Block(BlockHash::from_byte_array(
-                hash([8u8; 32]).to_byte_array(),
-            ))])),
-            NetworkMessage::GetData(InventoryPayload(vec![Inventory::Transaction(Txid::from_byte_array(
-                hash([45u8; 32]).to_byte_array(),
-            ))])),
+            NetworkMessage::Inv(InventoryPayload(vec![Inventory::Block(
+                BlockHash::from_byte_array(hash([8u8; 32]).to_byte_array()),
+            )])),
+            NetworkMessage::GetData(InventoryPayload(vec![Inventory::Transaction(
+                Txid::from_byte_array(hash([45u8; 32]).to_byte_array()),
+            )])),
             NetworkMessage::NotFound(InventoryPayload(vec![Inventory::Error([0u8; 32])])),
             NetworkMessage::GetBlocks(GetBlocksMessage::new(
                 vec![

diff --git a/bitcoin/src/p2p/mod.rs b/bitcoin/src/p2p/mod.rs
@@ -8,6 +8,8 @@
 #[cfg(feature = "std")]
 pub mod address;
 #[cfg(feature = "std")]
+mod deser;
+#[cfg(feature = "std")]
 pub mod message;
 #[cfg(feature = "std")]
 pub mod message_blockdata;
@@ -19,8 +21,6 @@ pub mod message_compact_blocks;
 pub mod message_filter;
 #[cfg(feature = "std")]
 pub mod message_network;
-#[cfg(feature = "std")]
-mod deser;
 
 use core::str::FromStr;
 use core::{fmt, ops};
@@ -409,7 +409,10 @@ mod tests {
         let magic: Magic = Network::Regtest.into();
         assert_eq!(serialize(&magic), &[0xfa, 0xbf, 0xb5, 0xda]);
 
-        assert_eq!(deserialize::<Magic>(&[0xf9, 0xbe, 0xb4, 0xd9]).ok(), Some(Network::Bitcoin.into()));
+        assert_eq!(
+            deserialize::<Magic>(&[0xf9, 0xbe, 0xb4, 0xd9]).ok(),
+            Some(Network::Bitcoin.into())
+        );
         assert_eq!(
             deserialize::<Magic>(&[0x0b, 0x11, 0x09, 0x07]).ok(),
             Some(Network::Testnet(TestnetVersion::V3).into())
@@ -418,11 +421,16 @@ mod tests {
             deserialize::<Magic>(&[0x1c, 0x16, 0x3f, 0x28]).ok(),
             Some(Network::Testnet(TestnetVersion::V4).into())
         );
-        assert_eq!(deserialize::<Magic>(&[0x0a, 0x03, 0xcf, 0x40]).ok(), Some(Network::Signet.into()));
-        assert_eq!(deserialize::<Magic>(&[0xfa, 0xbf, 0xb5, 0xda]).ok(), Some(Network::Regtest.into()));
+        assert_eq!(
+            deserialize::<Magic>(&[0x0a, 0x03, 0xcf, 0x40]).ok(),
+            Some(Network::Signet.into())
+        );
+        assert_eq!(
+            deserialize::<Magic>(&[0xfa, 0xbf, 0xb5, 0xda]).ok(),
+            Some(Network::Regtest.into())
+        );
     }
 
-
     #[test]
     fn service_flags_test() {
         let all = [

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
@@ -898,11 +898,11 @@ impl GetKey for $map<PublicKey, PrivateKey> {
             KeyRequest::XOnlyPubkey(xonly) => {
                 let pubkey_even = xonly.public_key(secp256k1::Parity::Even);
                 let key = self.get(&pubkey_even).cloned();
-              
+
                 if key.is_some() {
                     return Ok(key);
                 }
-              
+
                 let pubkey_odd = xonly.public_key(secp256k1::Parity::Odd);
                 if let Some(priv_key) = self.get(&pubkey_odd).copied() {
                     let negated_priv_key  = priv_key.negate();
@@ -935,18 +935,18 @@ impl GetKey for $map<XOnlyPublicKey, PrivateKey> {
             KeyRequest::XOnlyPubkey(xonly) => Ok(self.get(xonly).cloned()),
             KeyRequest::Pubkey(pk) => {
                 let (xonly, parity) = pk.inner.x_only_public_key();
-              
+
                 if let Some(mut priv_key) = self.get(&XOnlyPublicKey::from(xonly)).cloned() {
                     let computed_pk = priv_key.public_key(&secp);
                     let (_, computed_parity) = computed_pk.inner.x_only_public_key();
-                  
+
                     if computed_parity != parity {
                         priv_key = priv_key.negate();
                     }
-                  
+
                     return Ok(Some(priv_key));
                 }
-              
+
                 Ok(None)
             },
             KeyRequest::Bip32(_) => Err(GetKeyError::NotSupported),
@@ -1329,6 +1329,8 @@ pub use self::display_from_str::PsbtParseError;
 
 #[cfg(test)]
 mod tests {
+    use std::str::FromStr;
+
     use hashes::{hash160, ripemd160, sha256};
     use hex::FromHex;
     use hex_lit::hex;
@@ -1342,8 +1344,6 @@ mod tests {
         secp256k1::{All, SecretKey},
     };
 
-    use std::str::FromStr;
-
     use super::*;
     use crate::address::script_pubkey::ScriptExt as _;
     use crate::bip32::ChildNumber;
@@ -2249,17 +2249,35 @@ mod tests {
     fn serialize_and_deserialize_musig2_participants() {
         // XXX: Does not cover PSBT_IN_MUSIG2_PUB_NONCE, PSBT_IN_MUSIG2_PARTIAL_SIG (yet)
 
-        let expected_in_agg_pk  = secp256k1::PublicKey::from_str("021401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e00").unwrap();
+        let expected_in_agg_pk = secp256k1::PublicKey::from_str(
+            "021401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e00",
+        )
+        .unwrap();
         let expected_in_pubkeys = vec![
-            secp256k1::PublicKey::from_str("02bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a").unwrap(),
-            secp256k1::PublicKey::from_str("0355212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e2").unwrap(),
+            secp256k1::PublicKey::from_str(
+                "02bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a",
+            )
+            .unwrap(),
+            secp256k1::PublicKey::from_str(
+                "0355212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e2",
+            )
+            .unwrap(),
         ];
 
-        let expected_out_agg_pk = secp256k1::PublicKey::from_str("0364934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba5").unwrap();
+        let expected_out_agg_pk = secp256k1::PublicKey::from_str(
+            "0364934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba5",
+        )
+        .unwrap();
 
         let expected_out_pubkeys = vec![
-            secp256k1::PublicKey::from_str("02841d69a8b80ae23a8090e6f3765540ea5efd8c287b1307c983a6e2a3a171b525").unwrap(),
-            secp256k1::PublicKey::from_str("02bad833849a98cdfb0a0749609ddccab16ad54485ecc67f828df4bdc4f2b90d4c").unwrap(),
+            secp256k1::PublicKey::from_str(
+                "02841d69a8b80ae23a8090e6f3765540ea5efd8c287b1307c983a6e2a3a171b525",
+            )
+            .unwrap(),
+            secp256k1::PublicKey::from_str(
+                "02bad833849a98cdfb0a0749609ddccab16ad54485ecc67f828df4bdc4f2b90d4c",
+            )
+            .unwrap(),
         ];
 
         const PSBT_HEX: &str = "70736274ff01005e02000000017b42be5ea467afe0d0571dc4a91bef97ff9605a590c0b8d5892323946414d1810000000000ffffffff01f0b9f50500000000225120bc7e18f55e2c7a28d78cadac1bc72c248372375d269bafe6b315bc40505d07e5000000000001012b00e1f50500000000225120de564ebf8ff7bd9bb41bd88264c04b1713ebb9dc8df36319091d2eabb16cda6221161401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e000500eb4cbe62211655212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e20500755abbf92116bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a05002a33dfd90117201401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e00221a021401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e004202bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a0355212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e20001052064934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba5210764934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba50500fa4c6afa22080364934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba54202841d69a8b80ae23a8090e6f3765540ea5efd8c287b1307c983a6e2a3a171b52502bad833849a98cdfb0a0749609ddccab16ad54485ecc67f828df4bdc4f2b90d4c00";

diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
@@ -174,7 +174,8 @@ impl Deserialize for secp256k1::PublicKey {
 
 impl Serialize for Vec<secp256k1::PublicKey> {
     fn serialize(&self) -> Vec<u8> {
-        let mut result: Vec<u8> = Vec::with_capacity(secp256k1::constants::PUBLIC_KEY_SIZE * self.len());
+        let mut result: Vec<u8> =
+            Vec::with_capacity(secp256k1::constants::PUBLIC_KEY_SIZE * self.len());
 
         for pubkey in self.iter() {
             result.extend(Serialize::serialize(pubkey));
@@ -186,7 +187,8 @@ impl Serialize for Vec<secp256k1::PublicKey> {
 
 impl Deserialize for Vec<secp256k1::PublicKey> {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        bytes.chunks(secp256k1::constants::PUBLIC_KEY_SIZE)
+        bytes
+            .chunks(secp256k1::constants::PUBLIC_KEY_SIZE)
             .map(secp256k1::PublicKey::deserialize)
             .collect()
     }

diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
@@ -321,10 +321,8 @@ impl fmt::Display for LockTimeUnit {
         use LockTimeUnit as L;
 
         match *self {
-            L::Blocks =>
-                write!(f, "expected lock-by-height (must be < {})", LOCK_TIME_THRESHOLD),
-            L::Seconds =>
-                write!(f, "expected lock-by-time (must be >= {})", LOCK_TIME_THRESHOLD),
+            L::Blocks => write!(f, "expected lock-by-height (must be < {})", LOCK_TIME_THRESHOLD),
+            L::Seconds => write!(f, "expected lock-by-time (must be >= {})", LOCK_TIME_THRESHOLD),
         }
     }
 }

diff --git a/units/tests/serde.rs b/units/tests/serde.rs
@@ -6,7 +6,9 @@
 #![cfg(feature = "serde")]
 
 use bincode::serialize;
-use bitcoin_units::{amount, fee_rate, Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight};
+use bitcoin_units::{
+    amount, fee_rate, Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight,
+};
 use serde::{Deserialize, Serialize};
 
 /// A struct that includes all the types that implement or support `serde` traits.