milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Merge rust-bitcoin/rust-bitcoin#4600: Automated nightly rustfmt (2025-06-08) 

4b5c6dd547 2025-06-08 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:
  apoelstra:
    ACK 4b5c6dd54748eca214a0e2fce33d9f4a354b394a; successfully ran local tests

Tree-SHA512: 2459cab9fcc329136846dff463c3405b6b55e64e20294c860df6d6d7e81ef8292dacf70a54cad2b7ceb127b486406cf4164687a0294290e2a83581d06524ded0
This commit is contained in:
merge-script 2025-06-08 16:12:38 +00:00
parent a1be2fdf73 4b5c6dd547
commit 68981c6ab5
No known key found for this signature in database
GPG Key ID: C588D63CE41B97C1
10 changed files with 95 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bitcoin/examples/handshake.rs
View File

@ -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

28
bitcoin/src/bip32.rs
View File

@ -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![
(
"0h/1/2'",
vec![
ChildNumber::ZERO_HARDENED,
ChildNumber::ONE_NORMAL,
ChildNumber::from_hardened_idx(2).unwrap(),
]),
("0'/1/2h/2", vec![
],
),
(
"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![
],
),
(
"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.

4
bitcoin/src/p2p/address.rs
View File

@ -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() {

3
bitcoin/src/p2p/deser.rs
View File

@ -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)?);

14
bitcoin/src/p2p/message.rs
View File

@ -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![

20
bitcoin/src/p2p/mod.rs
View File

@ -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 = [

34
bitcoin/src/psbt/mod.rs
View File

@ -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";

6
bitcoin/src/psbt/serialize.rs
View File

@ -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()
}

6
units/src/locktime/absolute.rs
View File

@ -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),
}
}
}

4
units/tests/serde.rs
View File

@ -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.