diff --git a/rustfmt.toml b/rustfmt.toml index 389446dbfe..12e2f2d0ac 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -1,6 +1,5 @@ # Eventually this shoud be: ignore = [] ignore = [ - "src", "src/blockdata", "src/consensus", "src/network", diff --git a/src/hash_types.rs b/src/hash_types.rs index 4e1188d696..9a3818a3c3 100644 --- a/src/hash_types.rs +++ b/src/hash_types.rs @@ -23,18 +23,25 @@ macro_rules! impl_hashencode { ($hashtype:ident) => { impl $crate::consensus::Encodable for $hashtype { - fn consensus_encode(&self, s: S) -> Result { + fn consensus_encode( + &self, + s: S, + ) -> Result { self.0.consensus_encode(s) } } impl $crate::consensus::Decodable for $hashtype { - fn consensus_decode(d: D) -> Result { + fn consensus_decode( + d: D, + ) -> Result { use $crate::hashes::Hash; - Ok(Self::from_inner(<<$hashtype as $crate::hashes::Hash>::Inner>::consensus_decode(d)?)) + Ok(Self::from_inner( + <<$hashtype as $crate::hashes::Hash>::Inner>::consensus_decode(d)?, + )) } } - } + }; } // newtypes module is solely here so we can rustfmt::skip. diff --git a/src/internal_macros.rs b/src/internal_macros.rs index c0581130ee..8ae28f18a1 100644 --- a/src/internal_macros.rs +++ b/src/internal_macros.rs @@ -110,11 +110,9 @@ macro_rules! impl_array_newtype { type Output = <[$ty] as core::ops::Index>::Output; #[inline] - fn index(&self, index: I) -> &Self::Output { - &self.0[index] - } + fn index(&self, index: I) -> &Self::Output { &self.0[index] } } - } + }; } macro_rules! display_from_debug { @@ -124,7 +122,7 @@ macro_rules! display_from_debug { ::core::fmt::Debug::fmt(self, f) } } - } + }; } #[cfg(test)] @@ -362,8 +360,7 @@ macro_rules! serde_struct_human_string_impl { /// - core::str::FromStr /// - hashes::hex::FromHex macro_rules! impl_bytes_newtype { - ($t:ident, $len:expr) => ( - + ($t:ident, $len:expr) => { impl ::core::fmt::LowerHex for $t { fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { for &ch in self.0.iter() { @@ -388,9 +385,9 @@ macro_rules! impl_bytes_newtype { impl $crate::hashes::hex::FromHex for $t { fn from_byte_iter(iter: I) -> Result where - I: ::core::iter::Iterator> - + ::core::iter::ExactSizeIterator - + ::core::iter::DoubleEndedIterator, + I: ::core::iter::Iterator> + + ::core::iter::ExactSizeIterator + + ::core::iter::DoubleEndedIterator, { if iter.len() == $len { let mut ret = [0; $len]; @@ -433,7 +430,10 @@ macro_rules! impl_bytes_newtype { impl<'de> $crate::serde::de::Visitor<'de> for HexVisitor { type Value = $t; - fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + fn expecting( + &self, + formatter: &mut ::core::fmt::Formatter, + ) -> ::core::fmt::Result { formatter.write_str("an ASCII hex string") } @@ -444,7 +444,10 @@ macro_rules! impl_bytes_newtype { if let Ok(hex) = ::core::str::from_utf8(v) { $crate::hashes::hex::FromHex::from_hex(hex).map_err(E::custom) } else { - return Err(E::invalid_value($crate::serde::de::Unexpected::Bytes(v), &self)); + return Err(E::invalid_value( + $crate::serde::de::Unexpected::Bytes(v), + &self, + )); } } @@ -463,7 +466,10 @@ macro_rules! impl_bytes_newtype { impl<'de> $crate::serde::de::Visitor<'de> for BytesVisitor { type Value = $t; - fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + fn expecting( + &self, + formatter: &mut ::core::fmt::Formatter, + ) -> ::core::fmt::Result { formatter.write_str("a bytestring") } @@ -485,7 +491,7 @@ macro_rules! impl_bytes_newtype { } } } - ) + }; } macro_rules! user_enum { diff --git a/src/lib.rs b/src/lib.rs index 061a8ed977..02394c502d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -41,12 +41,9 @@ //! #![cfg_attr(all(not(feature = "std"), not(test)), no_std)] - // Experimental features we need #![cfg_attr(all(test, feature = "unstable"), feature(test))] - #![cfg_attr(docsrs, feature(doc_cfg))] - // Coding conventions #![forbid(unsafe_code)] #![deny(non_upper_case_globals)] @@ -79,9 +76,10 @@ extern crate core2; extern crate core; // for Rust 1.29 and no-std tests // Re-exported dependencies. -#[macro_use] pub extern crate bitcoin_hashes as hashes; -pub extern crate secp256k1; +#[macro_use] +pub extern crate bitcoin_hashes as hashes; pub extern crate bech32; +pub extern crate secp256k1; #[cfg(feature = "no-std")] extern crate hashbrown; @@ -90,12 +88,19 @@ extern crate hashbrown; #[cfg_attr(docsrs, doc(cfg(feature = "base64")))] pub extern crate base64; -#[cfg(feature="bitcoinconsensus")] extern crate bitcoinconsensus; -#[cfg(feature = "serde")] #[macro_use] extern crate actual_serde as serde; -#[cfg(all(test, feature = "serde"))] extern crate serde_json; -#[cfg(all(test, feature = "serde"))] extern crate serde_test; -#[cfg(all(test, feature = "serde"))] extern crate bincode; -#[cfg(all(test, feature = "unstable"))] extern crate test; +#[cfg(feature = "bitcoinconsensus")] +extern crate bitcoinconsensus; +#[cfg(feature = "serde")] +#[macro_use] +extern crate actual_serde as serde; +#[cfg(all(test, feature = "serde"))] +extern crate bincode; +#[cfg(all(test, feature = "serde"))] +extern crate serde_json; +#[cfg(all(test, feature = "serde"))] +extern crate serde_test; +#[cfg(all(test, feature = "unstable"))] +extern crate test; #[cfg(test)] #[macro_use] @@ -108,43 +113,34 @@ mod serde_utils; #[macro_use] pub mod network; pub mod blockdata; -pub mod util; pub mod consensus; pub mod hash_types; pub mod policy; +pub mod util; -pub use crate::hash_types::*; -pub use crate::blockdata::block::Block; -pub use crate::blockdata::block::BlockHeader; +#[cfg(feature = "std")] +use std::io; + +#[cfg(not(feature = "std"))] +use core2::io; + +pub use crate::blockdata::block::{Block, BlockHeader}; pub use crate::blockdata::script::Script; -pub use crate::blockdata::transaction::Transaction; -pub use crate::blockdata::transaction::TxIn; -pub use crate::blockdata::transaction::TxOut; -pub use crate::blockdata::transaction::OutPoint; -pub use crate::blockdata::transaction::EcdsaSighashType; +#[allow(deprecated)] +pub use crate::blockdata::transaction::SigHashType; +pub use crate::blockdata::transaction::{EcdsaSighashType, OutPoint, Transaction, TxIn, TxOut}; pub use crate::blockdata::witness::Witness; pub use crate::consensus::encode::VarInt; +pub use crate::hash_types::*; pub use crate::network::constants::Network; -pub use crate::util::Error; -pub use crate::util::address::Address; -pub use crate::util::address::AddressType; -pub use crate::util::amount::Amount; -pub use crate::util::amount::Denomination; -pub use crate::util::amount::SignedAmount; -pub use crate::util::merkleblock::MerkleBlock; -pub use crate::util::sighash::SchnorrSighashType; - +pub use crate::util::address::{Address, AddressType}; +pub use crate::util::amount::{Amount, Denomination, SignedAmount}; pub use crate::util::ecdsa::{self, EcdsaSig, EcdsaSigError}; +pub use crate::util::key::{KeyPair, PrivateKey, PublicKey, XOnlyPublicKey}; +pub use crate::util::merkleblock::MerkleBlock; pub use crate::util::schnorr::{self, SchnorrSig, SchnorrSigError}; -pub use crate::util::key::{PrivateKey, PublicKey, XOnlyPublicKey, KeyPair}; -pub use crate::util::psbt; -#[allow(deprecated)] -pub use crate::blockdata::transaction::SigHashType; - -#[cfg(feature = "std")] -use std::io; -#[cfg(not(feature = "std"))] -use core2::io; +pub use crate::util::sighash::SchnorrSighashType; +pub use crate::util::{psbt, Error}; #[cfg(not(feature = "std"))] mod io_extras { @@ -154,20 +150,14 @@ mod io_extras { } /// Creates an instance of a writer which will successfully consume all data. - pub const fn sink() -> Sink { - Sink { _priv: () } - } + pub const fn sink() -> Sink { Sink { _priv: () } } impl core2::io::Write for Sink { #[inline] - fn write(&mut self, buf: &[u8]) -> core2::io::Result { - Ok(buf.len()) - } + fn write(&mut self, buf: &[u8]) -> core2::io::Result { Ok(buf.len()) } #[inline] - fn flush(&mut self) -> core2::io::Result<()> { - Ok(()) - } + fn flush(&mut self) -> core2::io::Result<()> { Ok(()) } } } @@ -198,32 +188,26 @@ mod prelude { pub use std::collections::HashSet; } -#[cfg(all(test, feature = "unstable"))] use tests::EmptyWrite; +#[cfg(all(test, feature = "unstable"))] +use tests::EmptyWrite; #[cfg(all(test, feature = "unstable"))] mod tests { use core::fmt::Arguments; + use crate::io::{IoSlice, Result, Write}; #[derive(Default, Clone, Debug, PartialEq, Eq)] pub struct EmptyWrite; impl Write for EmptyWrite { - fn write(&mut self, buf: &[u8]) -> Result { - Ok(buf.len()) - } + fn write(&mut self, buf: &[u8]) -> Result { Ok(buf.len()) } fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result { Ok(bufs.iter().map(|s| s.len()).sum()) } - fn flush(&mut self) -> Result<()> { - Ok(()) - } + fn flush(&mut self) -> Result<()> { Ok(()) } - fn write_all(&mut self, _: &[u8]) -> Result<()> { - Ok(()) - } - fn write_fmt(&mut self, _: Arguments) -> Result<()> { - Ok(()) - } + fn write_all(&mut self, _: &[u8]) -> Result<()> { Ok(()) } + fn write_fmt(&mut self, _: Arguments) -> Result<()> { Ok(()) } } } diff --git a/src/policy.rs b/src/policy.rs index 0a86565385..00edd7f94c 100644 --- a/src/policy.rs +++ b/src/policy.rs @@ -24,9 +24,10 @@ //! These values were taken from bitcoind v0.21.1 (194b9b8792d9b0798fdb570b79fa51f1d1f5ebaf). //! -use super::blockdata::constants::{MAX_BLOCK_SIGOPS_COST, WITNESS_SCALE_FACTOR}; use core::cmp; +use super::blockdata::constants::{MAX_BLOCK_SIGOPS_COST, WITNESS_SCALE_FACTOR}; + /// Maximum weight of a transaction for it to be relayed by most nodes on the network pub const MAX_STANDARD_TX_WEIGHT: u32 = 400_000; diff --git a/src/serde_utils.rs b/src/serde_utils.rs index 5c8c7fbed0..d49c48fac6 100644 --- a/src/serde_utils.rs +++ b/src/serde_utils.rs @@ -9,10 +9,11 @@ pub mod btreemap_byte_values { // NOTE: This module can be exactly copied to use with HashMap. - use crate::prelude::*; - use crate::hashes::hex::{FromHex, ToHex}; use serde; + use crate::hashes::hex::{FromHex, ToHex}; + use crate::prelude::*; + pub fn serialize(v: &BTreeMap>, s: S) -> Result where S: serde::Serializer, @@ -50,9 +51,10 @@ pub mod btreemap_byte_values { write!(f, "a map with hexadecimal values") } - fn visit_map>(self, mut a: A) - -> Result - { + fn visit_map>( + self, + mut a: A, + ) -> Result { let mut ret = BTreeMap::new(); while let Some((key, value)) = a.next_entry()? { ret.insert(key, FromHex::from_hex(value).map_err(serde::de::Error::custom)?); @@ -77,9 +79,10 @@ pub mod btreemap_as_seq { // NOTE: This module can be exactly copied to use with HashMap. - use crate::prelude::*; use serde; + use crate::prelude::*; + pub fn serialize(v: &BTreeMap, s: S) -> Result where S: serde::Serializer, @@ -120,9 +123,10 @@ pub mod btreemap_as_seq { write!(f, "a sequence of pairs") } - fn visit_seq>(self, mut a: A) - -> Result - { + fn visit_seq>( + self, + mut a: A, + ) -> Result { let mut ret = BTreeMap::new(); while let Some((key, value)) = a.next_element()? { ret.insert(key, value); @@ -147,16 +151,16 @@ pub mod btreemap_as_seq_byte_values { // NOTE: This module can be exactly copied to use with HashMap. - use crate::prelude::*; use serde; + use crate::prelude::*; + /// A custom key-value pair type that serialized the bytes as hex. #[derive(Debug, Deserialize)] #[serde(crate = "actual_serde")] struct OwnedPair( T, - #[serde(deserialize_with = "crate::serde_utils::hex_bytes::deserialize")] - Vec, + #[serde(deserialize_with = "crate::serde_utils::hex_bytes::deserialize")] Vec, ); /// A custom key-value pair type that serialized the bytes as hex. @@ -164,8 +168,7 @@ pub mod btreemap_as_seq_byte_values { #[serde(crate = "actual_serde")] struct BorrowedPair<'a, T: 'static>( &'a T, - #[serde(serialize_with = "crate::serde_utils::hex_bytes::serialize")] - &'a [u8], + #[serde(serialize_with = "crate::serde_utils::hex_bytes::serialize")] &'a [u8], ); pub fn serialize(v: &BTreeMap>, s: S) -> Result @@ -205,9 +208,10 @@ pub mod btreemap_as_seq_byte_values { write!(f, "a sequence of pairs") } - fn visit_seq>(self, mut a: A) - -> Result - { + fn visit_seq>( + self, + mut a: A, + ) -> Result { let mut ret = BTreeMap::new(); while let Option::Some(OwnedPair(key, value)) = a.next_element()? { ret.insert(key, value); @@ -234,7 +238,8 @@ pub mod hex_bytes { pub fn serialize(bytes: &T, s: S) -> Result where - T: serde::Serialize + AsRef<[u8]>, S: serde::Serializer + T: serde::Serialize + AsRef<[u8]>, + S: serde::Serializer, { // Don't do anything special when not human readable. if !s.is_human_readable() { @@ -246,7 +251,8 @@ pub mod hex_bytes { pub fn deserialize<'de, D, B>(d: D) -> Result where - D: serde::Deserializer<'de>, B: serde::Deserialize<'de> + FromHex, + D: serde::Deserializer<'de>, + B: serde::Deserialize<'de> + FromHex, { struct Visitor(core::marker::PhantomData);